Method RequestUpdateExtent

Imaging/Core/vtkImageResize.cxx:236–311

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

//------------------------------------------------------------------------------
int vtkImageResize::RequestUpdateExtent(
  vtkInformation*, vtkInformationVector** inputVector, vtkInformationVector* outputVector)
{
  vtkInformation* outInfo = outputVector->GetInformationObject(0);
  vtkInformation* inInfo = inputVector[0]->GetInformationObject(0);

  int wholeExt[6];
  int extent[6];

  outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT(), extent);
  inInfo->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT(), wholeExt);

  // get the interpolator
  vtkAbstractImageInterpolator* interpolator = this->GetInternalInterpolator();

  // set the extent according to the interpolation kernel size:
  // first create a matrix to map output to input indices
  double elements[16];
  for (int i = 0; i < 3; i++)
  {
    elements[4 * i + 0] = elements[4 * i + 1] = elements[4 * i + 2] = 0;
    elements[4 * i + i] = this->IndexStretch[i];
    elements[4 * i + 3] = this->IndexTranslate[i];
    elements[12 + i] = 0;
  }
  elements[15] = 1;
  // get the kernel size
  int supportSize[3];
  interpolator->ComputeSupportSize(elements, supportSize);

  for (int j = 0; j < 3; j++)
  {
    double range[2];
    range[0] = extent[2 * j] * this->IndexStretch[j] + this->IndexTranslate[j];
    range[1] = extent[2 * j + 1] * this->IndexStretch[j] + this->IndexTranslate[j];

    extent[2 * j] = VTK_INT_MAX;
    extent[2 * j + 1] = VTK_INT_MIN;

    for (int ii = 0; ii < 2; ii++)
    {
      int kernelSize = supportSize[j];
      int extra = (kernelSize + 1) / 2 - 1;

      // most kernels have even size
      if ((kernelSize & 1) == 0)
      {
        double f;
        int k = vtkInterpolationMath::Floor(range[ii], f);
        extent[2 * j] = std::min(k - extra, extent[2 * j]);
        k += (f != 0);
        extent[2 * j + 1] = std::max(k + extra, extent[2 * j + 1]);
      }
      // else is for kernels with odd size
      else
      {
        int k = vtkInterpolationMath::Round(range[ii]);
        if (k < extent[2 * j])