vtkAbstractImageInterpolator.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkAbstractImageInterpolator.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkAbstractImageInterpolator_h
#define vtkAbstractImageInterpolator_h

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

#define VTK_IMAGE_BORDER_CLAMP 0
#define VTK_IMAGE_BORDER_REPEAT 1
#define VTK_IMAGE_BORDER_MIRROR 2

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

class VTKIMAGINGCORE_EXPORT 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);

  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(int 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); }
  int 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);


  vtkGetVector3Macro(Origin, double);


  vtkGetVector6Macro(Extent, int);


  VTK_LEGACY(int *GetWholeExtent());
  VTK_LEGACY(void GetWholeExtent(int extent[6]));

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

  virtual void InternalUpdate() = 0;

  virtual void InternalDeepCopy(vtkAbstractImageInterpolator *obj) = 0;


  virtual void GetInterpolationFunc(
    void (**doublefunc)(
      vtkInterpolationInfo *, const double [3], double *));
  virtual void GetInterpolationFunc(
    void (**floatfunc)(
      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 Origin[3];
  double OutValue;
  double Tolerance;
  int BorderMode;
  int ComponentOffset;
  int ComponentCount;
  bool SlidingWindow;

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

  void (*InterpolationFuncDouble)(
    vtkInterpolationInfo *info, const double point[3], double *outPtr);
  void (*InterpolationFuncFloat)(
    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);
}

#endif