vtkAbstractImageInterpolator.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkAbstractImageInterpolator_h
#define vtkAbstractImageInterpolator_h

#include "vtkImagingCoreModule.h" // For export macro
#include "vtkObject.h"
#include "vtkWrappingHints.h"

enum vtkImageBorderMode : int
{
  VTK_IMAGE_BORDER_CLAMP = 0,
  VTK_IMAGE_BORDER_REPEAT = 1,
  VTK_IMAGE_BORDER_MIRROR = 2,
};

VTK_ABI_NAMESPACE_BEGIN
class vtkDataObject;
class vtkImageData;
class vtkDataArray;
struct vtkInterpolationInfo;
struct vtkInterpolationWeights;

class VTKIMAGINGCORE_EXPORT VTK_MARSHALAUTO vtkAbstractImageInterpolator : public vtkObject
{
public:
  vtkTypeMacro(vtkAbstractImageInterpolator, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  virtual void Initialize(vtkDataObject* data);

  virtual void ReleaseData();

  void DeepCopy(vtkAbstractImageInterpolator* obj);

  virtual void Update();

  double Interpolate(double x, double y, double z, int component);

  bool Interpolate(const double point[3], double* value);

  void SetOutValue(double outValue);
  double GetOutValue() { return this->OutValue; }

  void SetTolerance(double tol);
  double GetTolerance() { return this->Tolerance; }

  void SetComponentOffset(int offset);
  int GetComponentOffset() { return this->ComponentOffset; }

  void SetComponentCount(int count);
  int GetComponentCount() { return this->ComponentCount; }

  int ComputeNumberOfComponents(int inputComponents);

  int GetNumberOfComponents();


  void InterpolateIJK(const double point[3], double* value);
  void InterpolateIJK(const float point[3], float* value);


  bool CheckBoundsIJK(const double x[3]);
  bool CheckBoundsIJK(const float x[3]);


  void SetBorderMode(vtkImageBorderMode mode);
  void SetBorderModeToClamp() { this->SetBorderMode(VTK_IMAGE_BORDER_CLAMP); }
  void SetBorderModeToRepeat() { this->SetBorderMode(VTK_IMAGE_BORDER_REPEAT); }
  void SetBorderModeToMirror() { this->SetBorderMode(VTK_IMAGE_BORDER_MIRROR); }
  vtkImageBorderMode GetBorderMode() { return this->BorderMode; }
  const char* GetBorderModeAsString();

  void SetSlidingWindow(bool x);
  void SlidingWindowOn() { this->SetSlidingWindow(true); }
  void SlidingWindowOff() { this->SetSlidingWindow(false); }
  bool GetSlidingWindow() { return this->SlidingWindow; }

  virtual void ComputeSupportSize(const double matrix[16], int support[3]) = 0;

  virtual bool IsSeparable() = 0;


  virtual void PrecomputeWeightsForExtent(const double matrix[16], const int extent[6],
    int checkExtent[6], vtkInterpolationWeights*& weights);
  virtual void PrecomputeWeightsForExtent(const float matrix[16], const int extent[6],
    int checkExtent[6], vtkInterpolationWeights*& weights);

  virtual void FreePrecomputedWeights(vtkInterpolationWeights*& weights);


  void InterpolateRow(
    vtkInterpolationWeights*& weights, int xIdx, int yIdx, int zIdx, double* value, int n);
  void InterpolateRow(
    vtkInterpolationWeights*& weights, int xIdx, int yIdx, int zIdx, float* value, int n);


  vtkGetVector3Macro(Spacing, double);


  vtkGetVectorMacro(Direction, double, 9);


  vtkGetVector3Macro(Origin, double);


  vtkGetVector6Macro(Extent, int);

protected:
  vtkAbstractImageInterpolator();
  ~vtkAbstractImageInterpolator() override;

  virtual void InternalUpdate() = 0;

  virtual void InternalDeepCopy(vtkAbstractImageInterpolator* obj) = 0;

  void CoordinateToIJK(const double point[3], double ijk[3]);


  virtual void GetInterpolationFunc(
    void (**doublefunc)(VTK_FUTURE_CONST vtkInterpolationInfo*, const double[3], double*));
  virtual void GetInterpolationFunc(
    void (**floatfunc)(VTK_FUTURE_CONST vtkInterpolationInfo*, const float[3], float*));


  virtual void GetRowInterpolationFunc(
    void (**doublefunc)(vtkInterpolationWeights*, int, int, int, double*, int));
  virtual void GetRowInterpolationFunc(
    void (**floatfunc)(vtkInterpolationWeights*, int, int, int, float*, int));


  virtual void GetSlidingWindowFunc(
    void (**doublefunc)(vtkInterpolationWeights*, int, int, int, double*, int));
  virtual void GetSlidingWindowFunc(
    void (**floatfunc)(vtkInterpolationWeights*, int, int, int, float*, int));

  vtkDataArray* Scalars;
  double StructuredBoundsDouble[6];
  float StructuredBoundsFloat[6];
  int Extent[6];
  double Spacing[3];
  double Direction[9];
  double InverseDirection[9];
  double Origin[3];
  double OutValue;
  double Tolerance;
  vtkImageBorderMode BorderMode;
  int ComponentOffset;
  int ComponentCount;
  bool UseDirection;
  bool SlidingWindow;

  // information needed by the interpolator funcs
  vtkInterpolationInfo* InterpolationInfo;

  void (*InterpolationFuncDouble)(
    VTK_FUTURE_CONST vtkInterpolationInfo* info, const double point[3], double* outPtr);
  void (*InterpolationFuncFloat)(
    VTK_FUTURE_CONST vtkInterpolationInfo* info, const float point[3], float* outPtr);

  void (*RowInterpolationFuncDouble)(
    vtkInterpolationWeights* weights, int idX, int idY, int idZ, double* outPtr, int n);
  void (*RowInterpolationFuncFloat)(
    vtkInterpolationWeights* weights, int idX, int idY, int idZ, float* outPtr, int n);

private:
  vtkAbstractImageInterpolator(const vtkAbstractImageInterpolator&) = delete;
  void operator=(const vtkAbstractImageInterpolator&) = delete;
};

inline void vtkAbstractImageInterpolator::InterpolateIJK(const double point[3], double* value)
{
  this->InterpolationFuncDouble(this->InterpolationInfo, point, value);
}

inline void vtkAbstractImageInterpolator::InterpolateIJK(const float point[3], float* value)
{
  this->InterpolationFuncFloat(this->InterpolationInfo, point, value);
}

inline bool vtkAbstractImageInterpolator::CheckBoundsIJK(const double x[3])
{
  const double* bounds = this->StructuredBoundsDouble;
  return !((x[0] < bounds[0]) || (x[0] > bounds[1]) || (x[1] < bounds[2]) || (x[1] > bounds[3]) ||
    (x[2] < bounds[4]) || (x[2] > bounds[5]));
}

inline bool vtkAbstractImageInterpolator::CheckBoundsIJK(const float x[3])
{
  const float* bounds = this->StructuredBoundsFloat;
  return !((x[0] < bounds[0]) || (x[0] > bounds[1]) || (x[1] < bounds[2]) || (x[1] > bounds[3]) ||
    (x[2] < bounds[4]) || (x[2] > bounds[5]));
}

inline void vtkAbstractImageInterpolator::InterpolateRow(
  vtkInterpolationWeights*& weights, int xIdx, int yIdx, int zIdx, double* value, int n)
{
  this->RowInterpolationFuncDouble(weights, xIdx, yIdx, zIdx, value, n);
}

inline void vtkAbstractImageInterpolator::InterpolateRow(
  vtkInterpolationWeights*& weights, int xIdx, int yIdx, int zIdx, float* value, int n)
{
  this->RowInterpolationFuncFloat(weights, xIdx, yIdx, zIdx, value, n);
}

// The interpolator info struct
struct vtkInterpolationInfo
{
  const void* Pointer;
  int Extent[6];
  vtkIdType Increments[3];
  int ScalarType;
  int NumberOfComponents;
  vtkImageBorderMode BorderMode;
  int InterpolationMode;
  void* ExtraInfo;

  vtkDataArray* Array;
  vtkIdType Index;
};

// The interpolation weights struct
struct vtkInterpolationWeights : public vtkInterpolationInfo
{
  vtkIdType* Positions[3];
  void* Weights[3];
  int WeightExtent[6];
  int KernelSize[3];
  int WeightType; // VTK_FLOAT or VTK_DOUBLE
  void* Workspace;
  int LastY;
  int LastZ;

  // partial copy constructor from superclass
  vtkInterpolationWeights(const vtkInterpolationInfo& info)
    : vtkInterpolationInfo(info)
    , Workspace(nullptr)
  {
  }
};

VTK_ABI_NAMESPACE_END
#endif