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);
  virtual void PrintSelf(ostream& os, vtkIndent indent);
 
  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();
 
  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);
 
 
  vtkGetVector6Macro(WholeExtent, int);
 
protected:
  vtkAbstractImageInterpolator();
  ~vtkAbstractImageInterpolator();
 
  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));
 
  vtkDataArray *Scalars;
  double StructuredBoundsDouble[6];
  float StructuredBoundsFloat[6];
  int WholeExtent[6];
  int Extent[6];
  double Spacing[3];
  double Origin[3];
  double OutValue;
  double Tolerance;
  int BorderMode;
  int ComponentOffset;
  int ComponentCount;
 
  // 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&);  // Not implemented.
  void operator=(const vtkAbstractImageInterpolator&);  // Not implemented.
};
 
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])
{
  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])
{
  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