Method ThreadedRequestData

Imaging/General/vtkImageAnisotropicDiffusion3D.cxx:110–164

------------------------------------------------------------------------------ This method contains a switch statement that calls the correct templated function for the input region type. The input and output regions must have the same data type.

// templated function for the input region type.  The input and output regions
// must have the same data type.
void vtkImageAnisotropicDiffusion3D::ThreadedRequestData(vtkInformation* vtkNotUsed(request),
  vtkInformationVector** inputVector, vtkInformationVector* vtkNotUsed(outputVector),
  vtkImageData*** inData, vtkImageData** outData, int outExt[6], int id)
{
  int inExt[6], wholeExt[6];
  double* ar;
  int idx;
  vtkImageData* temp;

  vtkInformation* inInfo = inputVector[0]->GetInformationObject(0);
  inInfo->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT(), wholeExt);
  this->InternalRequestUpdateExtent(inExt, outExt, wholeExt);

  // this filter expects that input is the same type as output.
  if (inData[0][0]->GetScalarType() != outData[0]->GetScalarType())
  {
    vtkErrorMacro("Execute: input ScalarType, " << inData[0][0]->GetScalarType()
                                                << ", must match out ScalarType "
                                                << outData[0]->GetScalarType());
    return;
  }

  ar = inData[0][0]->GetSpacing();

  // make the temporary regions to iterate over.
  vtkImageData* in = vtkImageData::New();
  in->SetExtent(inExt);
  in->AllocateScalars(VTK_DOUBLE, inData[0][0]->GetNumberOfScalarComponents());
  in->CopyAndCastFrom(inData[0][0], inExt);

  vtkImageData* out = vtkImageData::New();
  out->SetExtent(inExt);
  out->AllocateScalars(VTK_DOUBLE, inData[0][0]->GetNumberOfScalarComponents());

  // Loop performing the diffusion
  // Note: region extent could get smaller as the diffusion progresses
  // (but never get smaller than output region).
  for (idx = this->NumberOfIterations - 1; !this->AbortExecute && idx >= 0; --idx)
  {
    if (!id)
    {
      this->UpdateProgress(
        static_cast<double>(this->NumberOfIterations - idx) / this->NumberOfIterations);
    }
    this->Iterate(in, out, ar[0], ar[1], ar[2], outExt, idx);
    temp = in;
    in = out;
    out = temp;
  }

  // copy results into output.
  outData[0]->CopyAndCastFrom(in, outExt);
  in->Delete();
  out->Delete();
}

//------------------------------------------------------------------------------
// This method performs one pass of the diffusion filter.