vtkFastSplatter.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkFastSplatter.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.
 
=========================================================================*/
/*----------------------------------------------------------------------------
 Copyright (c) Sandia Corporation
 See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
----------------------------------------------------------------------------*/
#ifndef vtkFastSplatter_h
#define vtkFastSplatter_h
 
#include "vtkImagingHybridModule.h" // For export macro
#include "vtkImageAlgorithm.h"
 
class VTKIMAGINGHYBRID_EXPORT vtkFastSplatter : public vtkImageAlgorithm
{
public:
  vtkTypeMacro(vtkFastSplatter, vtkImageAlgorithm);
  static vtkFastSplatter *New();
  virtual void PrintSelf(ostream &os, vtkIndent indent);
 
 
  vtkSetVector6Macro(ModelBounds,double);
  vtkGetVectorMacro(ModelBounds,double,6);
 
 
  vtkSetVector3Macro( OutputDimensions, int );
  vtkGetVector3Macro( OutputDimensions, int );
 
//BTX
  enum { NoneLimit, ClampLimit, ScaleLimit, FreezeScaleLimit };
//ETX
 
 
  vtkSetMacro(LimitMode, int);
  vtkGetMacro(LimitMode, int);
  void SetLimitModeToNone() { this->SetLimitMode(NoneLimit); }
  void SetLimitModeToClamp() { this->SetLimitMode(ClampLimit); }
  void SetLimitModeToScale() { this->SetLimitMode(ScaleLimit); }
  void SetLimitModeToFreezeScale() { this->SetLimitMode(FreezeScaleLimit); }
 
 
  vtkSetMacro(MinValue, double);
  vtkGetMacro(MinValue, double);
  vtkSetMacro(MaxValue, double);
  vtkGetMacro(MaxValue, double);
 
 
  vtkGetMacro(NumberOfPointsSplatted, int);
 
  void SetSplatConnection(vtkAlgorithmOutput*);
 
protected:
  vtkFastSplatter();
  virtual ~vtkFastSplatter();
 
  double ModelBounds[6];
  int OutputDimensions[3];
 
  int LimitMode;
  double MinValue;
  double MaxValue;
  double FrozenScale;
 
  vtkImageData *Buckets;
 
  virtual int FillInputPortInformation(int port, vtkInformation *info);
  virtual int RequestInformation(vtkInformation *,
                                 vtkInformationVector **,
                                 vtkInformationVector *);
  virtual int RequestUpdateExtent(vtkInformation*,
                                  vtkInformationVector**,
                                  vtkInformationVector*);
  virtual int RequestData(vtkInformation *,
                          vtkInformationVector **,
                          vtkInformationVector *);
 
  // Used internally for converting points in world space to indices in
  // the output image.
  double Origin[3];
  double Spacing[3];
 
  // This is updated every time the filter executes
  int NumberOfPointsSplatted;
 
  // Used internally to track the data range.  When the limit mode is
  // set to FreezeScale, the data will be scaled as if this were the
  // range regardless of what it actually is.
  double LastDataMinValue;
  double LastDataMaxValue;
 
private:
  vtkFastSplatter(const vtkFastSplatter &); // Not implemented
  void operator=(const vtkFastSplatter &); // Not implemented
};
 
//BTX
 
//-----------------------------------------------------------------------------
 
template<class T>
void vtkFastSplatterClamp(T *array, vtkIdType arraySize,
                          T minValue, T maxValue)
{
  for (vtkIdType i = 0; i < arraySize; i++)
    {
    if (array[i] < minValue) array[i] = minValue;
    if (array[i] > maxValue) array[i] = maxValue;
    }
}
 
//-----------------------------------------------------------------------------
 
template<class T>
void vtkFastSplatterScale(T *array, int numComponents, vtkIdType numTuples,
                          T minValue, T maxValue,
                          double *dataMinValue, double *dataMaxValue)
{
  T *a;
  T min, max;
  *dataMinValue = 0;
  *dataMaxValue = 0;
  vtkIdType t;
  for (int c = 0; c < numComponents; c++)
    {
    // Find the min and max values in the array.
    a = array+c;
    min = max = *a;
    a += numComponents;
    for (t = 1; t < numTuples; t++, a += numComponents)
      {
      if (min > *a) min = *a;
      if (max < *a) max = *a;
      }
 
    // Bias everything so that 0 is really the minimum.
    if (min != 0)
      {
      for (t = 0, a = array+c; t < numTuples; t++, a += numComponents)
        {
        *a -= min;
        }
      }
 
    // Scale the values.
    if (max != min)
      {
      for (t = 0, a = array+c; t < numTuples; t++, a += numComponents)
        {
        *a = ((maxValue-minValue)*(*a))/(max-min);
        }
      }
 
    // Bias everything again so that it lies in the correct range.
    if (minValue != 0)
      {
      for (t = 0, a = array+c; t < numTuples; t++, a += numComponents)
        {
        *a += minValue;
        }
      }
    if (c == 0)
      {
      *dataMinValue = min;
      *dataMaxValue = max;
      }
    }
}
 
 
//-----------------------------------------------------------------------------
 
template<class T>
void vtkFastSplatterFrozenScale(T *array,
                                int numComponents, vtkIdType numTuples,
                                T minValue, T maxValue,
                                double min, double max)
{
  T *a;
 
  vtkIdType t;
  for (int c = 0; c < numComponents; c++)
    {
    // Bias everything so that 0 is really the minimum.
    if (min != 0)
      {
      for (t = 0, a = array+c; t < numTuples; t++, a += numComponents)
        {
        *a -= static_cast<T>(min);
        }
      }
 
    // Scale the values.
    if (max != min)
      {
      for (t = 0, a = array+c; t < numTuples; t++, a += numComponents)
        {
        *a = static_cast<T>(((maxValue-minValue)*(*a))/(max-min));
        }
      }
 
    // Bias everything again so that it lies in the correct range.
    if (minValue != 0)
      {
      for (t = 0, a = array+c; t < numTuples; t++, a += numComponents)
        {
        *a += minValue;
        }
      }
    }
}
 
//ETX
 
#endif //vtkFastSplatter_h