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

  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.

=========================================================================*/
// .NAME vtkAbstractImageInterpolator - interpolate data values from images
// .SECTION Description
// vtkAbstractImageInterpolator provides an abstract interface for
// interpolating image data.  You specify the data set you want to
// interpolate values from, then call Interpolate(x,y,z) to interpolate
// the data.
// .SECTION Thanks
// Thanks to David Gobbi at the Seaman Family MR Centre and Dept. of Clinical
// Neurosciences, Foothills Medical Centre, Calgary, for providing this class.
// .SECTION See also
// vtkImageReslice vtkImageInterpolator vtkImageSincInterpolator


#ifndef __vtkAbstractImageInterpolator_h
#define __vtkAbstractImageInterpolator_h

#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 VTK_FILTERING_EXPORT vtkAbstractImageInterpolator : public vtkObject
{
public:
  vtkTypeMacro(vtkAbstractImageInterpolator, vtkObject);
  virtual void PrintSelf(ostream& os, vtkIndent indent);

  // Description:
  // Initialize the interpolator with the data that you wish to interpolate.
  virtual void Initialize(vtkDataObject *data);

  // Description:
  // Release any data stored by the interpolator.
  virtual void ReleaseData();

  // Description:
  // Copy the interpolator.  It is possible to duplicate an interpolator
  // by calling NewInstance() followed by DeepCopy().
  void DeepCopy(vtkAbstractImageInterpolator *obj);

  // Description:
  // Update the interpolator.  If the interpolator has been modified by
  // a Set method since Initialize() was called, you must call this method
  // to update the interpolator before you can use it.
  void Update();

  // Description:
  // Get the result of interpolating the specified component of the input
  // data, which should be set to zero if there is only one component.
  // If the point is not within the bounds of the data set, then OutValue
  // will be returned.  This method is primarily meant for use by the
  // wrapper languages.
  double Interpolate(double x, double y, double z, int component);

  // Description:
  // Sample the input data. This is an inline method that calls the
  // function that performs the appropriate interpolation for the
  // data type.  If the point is not within the bounds of the data set,
  // then the return value is false, and each component will be set to
  // the OutValue.
  bool Interpolate(const double point[3], double *value);

  // Description:
  // The value to return when the point is out of bounds.
  void SetOutValue(double outValue);
  double GetOutValue() { return this->OutValue; }

  // Description:
  // The tolerance to apply when checking whether a point is out of bounds.
  // This is a fractional distance relative to the voxel size, so a tolerance
  // of 1 expands the bounds by one voxel.
  void SetTolerance(double tol);
  double GetTolerance() { return this->Tolerance; }

  // Description:
  // This method specifies which component of the input will be interpolated,
  // or if ComponentCount is also set, it specifies the first component.
  // When the interpolation is performed, it will be clamped to the number
  // of available components.
  void SetComponentOffset(int offset);
  int GetComponentOffset() { return this->ComponentOffset; }

  // Description:
  // This method specifies the number of components to extract.  The default
  // value is -1, which extracts all available components.  When the
  // interpolation is performed, this will be clamped to the number of
  // available components.
  void SetComponentCount(int count);
  int GetComponentCount() { return this->ComponentCount; }

  // Description:
  // Compute the number of output components based on the ComponentOffset,
  // ComponentCount, and the number of components in the input data.
  int ComputeNumberOfComponents(int inputComponents);

  // Description:
  // Get the number of components that will be returned when Interpolate()
  // is called.  This is only valid after initialization.  Before then, use
  // ComputeNumberOfComponents instead.
  int GetNumberOfComponents();

  // Description:
  // A version of Interpolate that takes structured coords instead of data
  // coords.  Structured coords are the data coords after subtracting the
  // Origin and dividing by the Spacing.
  void InterpolateIJK(const double point[3], double *value);
  void InterpolateIJK(const float point[3], float *value);

  // Description:
  // Check an x,y,z point to see if it is within the bounds for the
  // structured coords of the image.  This is meant to be called prior
  // to InterpolateIJK.  The bounds that are checked against are the input
  // image extent plus the tolerance.
  bool CheckBoundsIJK(const double x[3]);
  bool CheckBoundsIJK(const float x[3]);

  // Description:
  // The border mode (default: clamp).  This controls how out-of-bounds
  // lookups are handled, i.e. how data will be extrapolated beyond the
  // bounds of the image.  The default is to clamp the lookup point to the
  // bounds.  The other modes wrap around to the opposite boundary, or
  // mirror the image at the boundary.
  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();

  // Description:
  // Get the support size for use in computing update extents.  If the data
  // will be sampled on a regular grid, then pass a matrix describing the
  // structured coordinate transformation between the output and the input.
  // Otherwise, pass NULL as the matrix to retrieve the full kernel size.
  virtual void ComputeSupportSize(const double matrix[16], int support[3]) = 0;

  // Description:
  // True if the interpolation is separable, which means that the weights
  // can be precomputed in order to accelerate the interpolation.  Any
  // interpolator which is separable will implement the methods
  // PrecomputeWeightsForExtent and InterpolateRow
  virtual bool IsSeparable() = 0;

  // Description:
  // If the data is going to be sampled on a regular grid, then the
  // interpolation weights can be precomputed.  A matrix must be supplied
  // that provides a transformation between the provided extent and the
  // structured coordinates of the input.  This matrix must perform only
  // permutation, scale, and translation, i.e. each of the three columns
  // must have only one non-zero value.  A checkExtent is provided that can
  // be used to check which indices in the extent map to out-of-bounds
  // coordinates in the input data.
  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);

  // Description:
  // Free the weights that were provided by PrecomputeWeightsForExtent.
  virtual void FreePrecomputedWeights(vtkInterpolationWeights *&weights);

  // Description:
  // Get a row of samples, using the weights that were precomputed
  // by PrecomputeWeightsForExtent.  Note that each sample may have
  // multiple components.  It is possible to select which components
  // will be returned by setting the ComponentOffset and ComponentCount.
  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);

  // Description:
  // Get the spacing of the data being interpolated.
  vtkGetVector3Macro(Spacing, double);

  // Description:
  // Get the origin of the data being interpolated.
  vtkGetVector3Macro(Origin, double);

  // Description:
  // Get the extent of the data being interpolated.
  vtkGetVector6Macro(Extent, int);

  // Description:
  // Get the whole extent of the data being interpolated, including
  // parts of the data that are not currently in memory.
  vtkGetVector6Macro(WholeExtent, int);

protected:
  vtkAbstractImageInterpolator();
  ~vtkAbstractImageInterpolator();

  // Description:
  // Subclass-specific updates.
  virtual void InternalUpdate() = 0;

  // Description:
  // Subclass-specific copy.
  virtual void InternalDeepCopy(vtkAbstractImageInterpolator *obj) = 0;

  // Description:
  // Get the interpolation functions.
  virtual void GetInterpolationFunc(
    void (**doublefunc)(
      vtkInterpolationInfo *, const double [3], double *));
  virtual void GetInterpolationFunc(
    void (**floatfunc)(
      vtkInterpolationInfo *, const float [3], float *));

  // Description:
  // Get the row interpolation functions.
  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
