Paraview与VTK学习笔记（五）

上一节最后执行到：

this->GetRenderWindow()->Render();

也就是执行到了vtkRenderWindow::Render()了，我们可以看到这个函数是告诉这个RenderWindow下的每一个renderer去渲染他的图像，并且保持进程同步

// Ask each renderer owned by this RenderWindow to render its image and
// synchronize this process

void vtkRenderWindow::Render()
{
  int *size;
  int x,y;
  float *p1;
  // if we are in the middle of an abort check then return now
  if (this->InAbortCheck)
    {
    return;
    }

如果是在中止的中间过程，则check并且返回

// if we are in a render already from somewhere else abort now
  if (this->InRender)
    {
    return;
    }

如果从其他某个地方现在已经在渲染了，那么立即中止

 // if SetSize has not yet been called (from a script, possible off
  // screen use, other scenarios?) then call it here with reasonable
  // default values
  if (0 == this->Size[0] && 0 == this->Size[1])
    {
    this->SetSize(300, 300);
    }

如果SetSize还没有被使用（通过一个脚本，或者关闭屏幕，或者其他情况），那么在这里调用它，并赋值默认值

// reset the Abort flag
  this->AbortRender = 0;
  this->InRender = 1;

  vtkDebugMacro(<< "Starting Render Method.\n");
  this->InvokeEvent(vtkCommand::StartEvent,NULL);

  this->NeverRendered = 0;

  if ( this->Interactor && ! this->Interactor->GetInitialized() )
    {
    this->Interactor->Initialize();
    }

重置中止符号，开始渲染，设置InRender为1。调用开始事件。并且初始化关联器

 // CAUTION:
  // This method uses this->GetSize() and allocates buffers using that size.
  // Remember that GetSize() will returns a size scaled by the TileScale factor.
  // We should use GetActualSize() when we don't want the size to be scaled.

  // if there is a reason for an AccumulationBuffer
  if ( this->SubFrames || this->AAFrames || this->FDFrames)
    {
    // check the current size
    size = this->GetSize();
    unsigned int bufferSize = 3*size[0]*size[1];
    // If there is not a buffer or the size is too small
    // re-allocate it
    if( !this->AccumulationBuffer
        || bufferSize > this->AccumulationBufferSize)
      {
      // it is OK to delete null, no sense in two if's
      delete [] this->AccumulationBuffer;
      // Save the size of the buffer
      this->AccumulationBufferSize = 3*size[0]*size[1];
      this->AccumulationBuffer = new float [this->AccumulationBufferSize];<span style="font-family: Arial, Helvetica, sans-serif;">memset(this->AccumulationBuffer,0,this->AccumulationBufferSize*sizeof(float));}}</span>

这个方法使用this->GetSize()，并且分配buffers从而使用这个size。这个GetSize()函数会根据TileScale调整比例。如果我们不希望这个size被调整，那么调用GetActualSize()。

上面这段代码我们可以看出，主要是为了确保AccumulationBuffer的正确性，如果过不存在或者比bufferSize小。则给它删除原有的，重新赋值并且分配空间。

  // handle any sub frames
  if (this->SubFrames)
    {
    // get the size
    size = this->GetSize();

    // draw the images
    this->DoAARender();

    // now accumulate the images
    if ((!this->AAFrames) && (!this->FDFrames))
      {
      p1 = this->AccumulationBuffer;
      unsigned char *p2;
      unsigned char *p3;
      if (this->ResultFrame)
        {
        p2 = this->ResultFrame;
        }
      else
        {
        p2 = this->GetPixelData(0,0,size[0]-1,size[1]-1,!this->DoubleBuffer);
        }
      p3 = p2;
      for (y = 0; y < size[1]; y++)
        {
        for (x = 0; x < size[0]; x++)
          {
          *p1 += *p2; p1++; p2++;
          *p1 += *p2; p1++; p2++;
          *p1 += *p2; p1++; p2++;
          }
        }
      delete [] p3;
      }

控制子窗口，首先获得size，然后画出图形。把图像集成起来，如果当前window不是AAFrames且不是FDFrames。

    // if this is the last sub frame then convert back into unsigned char
    this->CurrentSubFrame++;
    if (this->CurrentSubFrame >= this->SubFrames)
      {
      double num;
      unsigned char *p2 = new unsigned char [3*size[0]*size[1]];

      num = this->SubFrames;
      if (this->AAFrames)
        {
        num *= this->AAFrames;
        }
      if (this->FDFrames)
        {
        num *= this->FDFrames;
        }

      this->ResultFrame = p2;
      p1 = this->AccumulationBuffer;
      for (y = 0; y < size[1]; y++)
        {
        for (x = 0; x < size[0]; x++)
          {
          *p2 = static_cast<unsigned char>(*p1/num);
          p1++;
          p2++;
          *p2 = static_cast<unsigned char>(*p1/num);
          p1++;
          p2++;
          *p2 = static_cast<unsigned char>(*p1/num);
          p1++;
          p2++;
          }
        }

      this->CurrentSubFrame = 0;
      this->CopyResultFrame();

如果这是最后的子帧，那么重新转换成unsigned char。

 // free any memory
      delete [] this->AccumulationBuffer;
      this->AccumulationBuffer = NULL;
      }
    }

释放内存

 else // no subframes
    {
    // get the size
    size = this->GetSize();

    this->DoAARender();
    // if we had some accumulation occur
    if (this->AccumulationBuffer)
      {
      double num;
      unsigned char *p2 = new unsigned char [3*size[0]*size[1]];

      if (this->AAFrames)
        {
        num = this->AAFrames;
        }
      else
        {
        num = 1;
        }
      if (this->FDFrames)
        {
        num *= this->FDFrames;
        }

      this->ResultFrame = p2;
      p1 = this->AccumulationBuffer;
      for (y = 0; y < size[1]; y++)
        {
        for (x = 0; x < size[0]; x++)
          {
          *p2 = static_cast<unsigned char>(*p1/num);
          p1++;
          p2++;
          *p2 = static_cast<unsigned char>(*p1/num);
          p1++;
          p2++;
          *p2 = static_cast<unsigned char>(*p1/num);
          p1++;
          p2++;
          }
        }

      delete [] this->AccumulationBuffer;
      this->AccumulationBuffer = NULL;
      }

    this->CopyResultFrame();
    }

如果没有子帧。则直接执行。

  delete [] this->ResultFrame;
  this->ResultFrame = NULL;

  this->InRender = 0;
  this->InvokeEvent(vtkCommand::EndEvent,NULL);
}

结束渲染事件。
我们可以看到上面真正渲染的代码是this->DoAARender()。那么我们继续分析这个函数

// Handle rendering any antialiased frames.
void vtkRenderWindow::DoAARender()
{
  int i;

  // handle any anti aliasing控制任何抗锯齿
  if (this->AAFrames)
    {
    int *size;
    int x,y;
    float *p1;
    vtkRenderer *aren;
    vtkCamera *acam;
    double *dpoint;
    double offsets[2];
    double origfocus[4];
    double worldOffset[3];

这个函数显然我们可以看到，它是用来控制渲染抗锯齿帧的。

   // get the size
    size = this->GetSize();

    origfocus[3] = 1.0;

    for (i = 0; i < this->AAFrames; i++)
      {
      // jitter the cameras
      offsets[0] = vtkMath::Random() - 0.5;
      offsets[1] = vtkMath::Random() - 0.5;

      vtkCollectionSimpleIterator rsit;
      for (this->Renderers->InitTraversal(rsit);
           (aren = this->Renderers->GetNextRenderer(rsit)); )
        {
        acam = aren->GetActiveCamera();

获得size，然后对于AA帧，抖动相机？

        // calculate the amount to jitter
        acam->GetFocalPoint(origfocus);
        aren->SetWorldPoint(origfocus);
        aren->WorldToDisplay();
        dpoint = aren->GetDisplayPoint();
        aren->SetDisplayPoint(dpoint[0] + offsets[0],
                              dpoint[1] + offsets[1],
                              dpoint[2]);
        aren->DisplayToWorld();
        dpoint = aren->GetWorldPoint();
        dpoint[0] /= dpoint[3];
        dpoint[1] /= dpoint[3];
        dpoint[2] /= dpoint[3];
        acam->SetFocalPoint(dpoint);

        worldOffset[0] = dpoint[0] - origfocus[0];
        worldOffset[1] = dpoint[1] - origfocus[1];
        worldOffset[2] = dpoint[2] - origfocus[2];

        acam->GetPosition(dpoint);
        acam->SetPosition(dpoint[0]+worldOffset[0],
                          dpoint[1]+worldOffset[1],
                          dpoint[2]+worldOffset[2]);
        }

      // draw the images
      this->DoFDRender();

计算抖动的值，然后继续渲染

     // restore the jitter to normal
      for (this->Renderers->InitTraversal(rsit);
           (aren = this->Renderers->GetNextRenderer(rsit)); )
        {
        acam = aren->GetActiveCamera();

        // calculate the amount to jitter
        acam->GetFocalPoint(origfocus);
        aren->SetWorldPoint(origfocus);
        aren->WorldToDisplay();
        dpoint = aren->GetDisplayPoint();
        aren->SetDisplayPoint(dpoint[0] - offsets[0],
                              dpoint[1] - offsets[1],
                              dpoint[2]);
        aren->DisplayToWorld();
        dpoint = aren->GetWorldPoint();
        dpoint[0] /= dpoint[3];
        dpoint[1] /= dpoint[3];
        dpoint[2] /= dpoint[3];
        acam->SetFocalPoint(dpoint);

        worldOffset[0] = dpoint[0] - origfocus[0];
        worldOffset[1] = dpoint[1] - origfocus[1];
        worldOffset[2] = dpoint[2] - origfocus[2];

        acam->GetPosition(dpoint);
        acam->SetPosition(dpoint[0]+worldOffset[0],
                          dpoint[1]+worldOffset[1],
                          dpoint[2]+worldOffset[2]);
        }

然后把抖动恢复成正常值

      // now accumulate the images
      p1 = this->AccumulationBuffer;
      if (!this->FDFrames)
        {
        unsigned char *p2;
        unsigned char *p3;
        if (this->ResultFrame)
          {
          p2 = this->ResultFrame;
          }
        else
          {
          p2 = this->GetPixelData(0,0,size[0]-1,size[1]-1,!this->DoubleBuffer);
          }
        p3 = p2;
        for (y = 0; y < size[1]; y++)
          {
          for (x = 0; x < size[0]; x++)
            {
            *p1 += static_cast<float>(*p2);
            p1++;
            p2++;
            *p1 += static_cast<float>(*p2);
            p1++;
            p2++;
            *p1 += static_cast<float>(*p2);
            p1++;
            p2++;
            }
          }
        delete [] p3;
        }
      }
    }

然后再组装图像。

  else
    {
    this->DoFDRender();
    }
}

如果没有AA帧，就直接执行下一级渲染。

// Handle rendering any focal depth frames.
void vtkRenderWindow::DoFDRender()
{
  int i;

  // handle any focal depth
  if (this->FDFrames)
    {...this->DoStereoRender()....<span style="font-family: Arial, Helvetica, sans-serif;">}</span>

  else
    {
    this->DoStereoRender();
    }

这个函数是用来控制渲染所有焦点深度的帧的。其基本过程和上面一样。就没什么细说的，只是算法不一样。再看下一级渲染：

void vtkRenderWindow::DoStereoRender()
{
  vtkCollectionSimpleIterator rsit;

  this->Start();//初始化渲染进程
  this->StereoUpdate();//更新整个系统，如果需要，还要控制立体渲染。对于一些立体方法，在这里子类需要选择硬件支持

  if (this->StereoType != VTK_STEREO_RIGHT)
    { // render the left eye
    vtkRenderer *aren;
    for (this->Renderers->InitTraversal(rsit);
         (aren = this->Renderers->GetNextRenderer(rsit)); )
      {

首先渲染左眼。一个安全的方式通过集合去进行迭代，没一次传递相同的cookie值。这里定义一个for循环，对于每一个Render循环。

      // Ugly piece of code - we need to know if the camera already
      // exists or not. If it does not yet exist, we must reset the
      // camera here - otherwise it will never be done (missing its
      // oppportunity to be reset in the Render method of the
      // vtkRenderer because it will already exist by that point...)
      if ( !aren->IsActiveCameraCreated() )
        {
        aren->ResetCamera();
        }
      aren->GetActiveCamera()->SetLeftEye(1);
      }
    this->Renderers->Render();
    }

我们需要知道相机是否已经存在。如果过不存在，我们需要reser它。否则我们把它设置为左眼使用。然后进行渲染。

  if (this->StereoRender)
    {
    this->StereoMidpoint();
    if (this->StereoType != VTK_STEREO_LEFT)
      { // render the right eye
      vtkRenderer *aren;
      for (this->Renderers->InitTraversal(rsit);
           (aren = this->Renderers->GetNextRenderer(rsit)); )
        {
        // Duplicate the ugly code here too. Of course, most
        // times the left eye will have been rendered before
        // the right eye, but it is possible that the user sets
        // everything up and renders just the right eye - so we
        // need this check here too.
        if ( !aren->IsActiveCameraCreated() )
          {
          aren->ResetCamera();
          }
        aren->GetActiveCamera()->SetLeftEye(0);
        }
      this->Renderers->Render();
      }
    this->StereoRenderComplete();
    }

}

这段代码与上面基本一样，其实就是再渲染右眼，但中间有一个this->Steromidpoint()，这个方法使用来渲染从左眼到右眼的对参数的一些改变操作。
接下来，不论左眼右眼，我们都可以看到，它调用了this->Renders->Render();

Renders是vtkRendererCollection类的一个对象。

void vtkRendererCollection::Render()
{
  vtkRenderer      *ren, *firstRen;
  vtkRenderWindow  *renWin;
  int               numLayers, i;

  vtkCollectionSimpleIterator rsit;
  this->InitTraversal(rsit);
  firstRen = this->GetNextRenderer(rsit);
  if (firstRen == NULL)
    {
    // We cannot determine the number of layers because there are no
    // renderers.  No problem, just return.
    return;
    }
  renWin = firstRen->GetRenderWindow();
  numLayers = renWin->GetNumberOfLayers();

初始化rsit，然后获取第一个renderer。然后再获取RenderWindow和Layer的数量。

 // Only have the renderers render from back to front.  This is necessary
  // because transparent renderers clear the z-buffer before each render and
  // then overlay their image.
  for (i = 0; i < numLayers; i++)
    {
    for (this->InitTraversal(rsit); (ren = this->GetNextRenderer(rsit)); )
      {
      if (ren->GetLayer() == i)
        {
        ren->Render();
        }
      }
    }

从后到前，对于每一层Layer，使每一个renderer渲染。

  // Let the user know if they have put a renderer at an unused layer.
  for (this->InitTraversal(rsit); (ren = this->GetNextRenderer(rsit)); )
    {
    if (ren->GetLayer() < 0 || ren->GetLayer() >= numLayers)
      {
      vtkErrorMacro(<< "Invalid layer for renderer: not rendered.");
      }
    }
}

报错，使用户知道他是否使一个renderer放到了不会用到的layer上。