Method ThreadedRequestData

Imaging/General/vtkImageSlab.cxx:412–493

------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void vtkImageSlab::ThreadedRequestData(vtkInformation*, vtkInformationVector** inVector,
  vtkInformationVector*, vtkImageData*** inData, vtkImageData** outData, int outExt[6], int id)
{
  void* inPtr;
  void* outPtr;
  int inExt[6];
  int extent[6];
  int dimIndex;
  int range[2];

  vtkDebugMacro("Execute: inData = " << inData << ", outData = " << outData);

  // get the direction along which to sum slices
  dimIndex = this->GetOrientation();

  // clamp the range to the whole extent
  vtkInformation* inInfo = inVector[0]->GetInformationObject(0);
  inInfo->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT(), extent);
  this->GetSliceRange(range);
  range[0] = std::max(range[0], extent[2 * dimIndex]);
  range[1] = std::min(range[1], extent[2 * dimIndex + 1]);

  // initialize input extent to output extent
  inExt[0] = outExt[0];
  inExt[1] = outExt[1];
  inExt[2] = outExt[2];
  inExt[3] = outExt[3];
  inExt[4] = outExt[4];
  inExt[5] = outExt[5];

  // the adjust for the slice range
  inExt[2 * dimIndex] += range[0];
  inExt[2 * dimIndex + 1] += range[1];

  // now get the pointers for the extents
  inPtr = inData[0][0]->GetScalarPointerForExtent(inExt);
  outPtr = outData[0]->GetScalarPointerForExtent(outExt);

  // get the scalar type
  int outScalarType = outData[0]->GetScalarType();
  int inScalarType = inData[0][0]->GetScalarType();

  // and call the execute method
  if (outScalarType == inScalarType)
  {
    switch (inScalarType)
    {
      vtkTemplateAliasMacro(vtkImageSlabExecute(this, inData[0][0], static_cast<VTK_TT*>(inPtr),
        outData[0], static_cast<VTK_TT*>(outPtr), outExt, id));
      default:
        vtkErrorMacro("Execute: Unknown ScalarType");
        return;
    }
  }
  else if (outScalarType == VTK_FLOAT)
  {
    switch (inScalarType)
    {