vtkImageMarchingCubes.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkImageMarchingCubes.h,v $

  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.


     THIS CLASS IS PATENTED UNDER UNITED STATES PATENT NUMBER 4,710,876
     "System and Method for the Display of Surface Structures Contained
     Within The Interior Region of a Solid body".
     Application of this software for commercial purposes requires 
     a license grant from GE. Contact:

         Carl B. Horton
         Sr. Counsel, Intellectual Property
         3000 N. Grandview Blvd., W-710
         Waukesha, WI  53188
         Phone:  (262) 513-4022
         E-Mail: [email protected]

     for more information.

=========================================================================*/
#ifndef __vtkImageMarchingCubes_h
#define __vtkImageMarchingCubes_h

#include "vtkPolyDataSource.h"

#include "vtkContourValues.h" // Needed for direct access to ContourValues

class vtkCellArray;
class vtkFloatArray;
class vtkImageData;
class vtkPoints;

class VTK_PATENTED_EXPORT vtkImageMarchingCubes : public vtkPolyDataSource
{
public:
  static vtkImageMarchingCubes *New();
  vtkTypeRevisionMacro(vtkImageMarchingCubes,vtkPolyDataSource);
  void PrintSelf(ostream& os, vtkIndent indent);
  

  void SetInput(vtkImageData *input);
  vtkImageData *GetInput();
  
  // Methods to set contour values
  void SetValue(int i, double value);
  double GetValue(int i);
  double *GetValues();
  void GetValues(double *contourValues);
  void SetNumberOfContours(int number);
  int GetNumberOfContours();
  void GenerateValues(int numContours, double range[2]);
  void GenerateValues(int numContours, double rangeStart, double rangeEnd);

  // Because we delegate to vtkContourValues & refer to vtkImplicitFunction
  unsigned long int GetMTime();


  vtkSetMacro(ComputeScalars, int);
  vtkGetMacro(ComputeScalars, int);
  vtkBooleanMacro(ComputeScalars, int);
  

  vtkSetMacro(ComputeNormals, int);
  vtkGetMacro(ComputeNormals, int);
  vtkBooleanMacro(ComputeNormals, int);
  

  vtkSetMacro(ComputeGradients, int);
  vtkGetMacro(ComputeGradients, int);
  vtkBooleanMacro(ComputeGradients, int);
  
  // Should be protected, but the templated functions need these
  int ComputeScalars;
  int ComputeNormals;
  int ComputeGradients;
  int NeedGradients;

  vtkCellArray *Triangles;
  vtkFloatArray *Scalars;
  vtkPoints *Points;
  vtkFloatArray *Normals;
  vtkFloatArray *Gradients;
  
  int GetLocatorPoint(int cellX, int cellY, int edge);
  void AddLocatorPoint(int cellX, int cellY, int edge, int ptId);
  void IncrementLocatorZ();

  void Update();
  

  vtkSetMacro(InputMemoryLimit, int);
  vtkGetMacro(InputMemoryLimit, int);

protected:
  vtkImageMarchingCubes();
  ~vtkImageMarchingCubes();

  int NumberOfSlicesPerChunk;
  int InputMemoryLimit;

  vtkContourValues *ContourValues;
   
  int *LocatorPointIds;
  int LocatorDimX;
  int LocatorDimY;
  int LocatorMinX;
  int LocatorMinY;
  
  void Execute();

  void March(vtkImageData *inData, int chunkMin, int chunkMax,
             int numContours, double *values);
  void InitializeLocator(int min0, int max0, int min1, int max1);
  void DeleteLocator();
  int *GetLocatorPointer(int cellX, int cellY, int edge);

  virtual int FillInputPortInformation(int, vtkInformation*);
private:
  vtkImageMarchingCubes(const vtkImageMarchingCubes&);  // Not implemented.
  void operator=(const vtkImageMarchingCubes&);  // Not implemented.
};

inline void vtkImageMarchingCubes::SetValue(int i, double value)
{this->ContourValues->SetValue(i,value);}


inline double vtkImageMarchingCubes::GetValue(int i)
{return this->ContourValues->GetValue(i);}


inline double *vtkImageMarchingCubes::GetValues()
{return this->ContourValues->GetValues();}

inline void vtkImageMarchingCubes::GetValues(double *contourValues)
{this->ContourValues->GetValues(contourValues);}

inline void vtkImageMarchingCubes::SetNumberOfContours(int number)
{this->ContourValues->SetNumberOfContours(number);}


inline int vtkImageMarchingCubes::GetNumberOfContours()
{return this->ContourValues->GetNumberOfContours();}


inline void vtkImageMarchingCubes::GenerateValues(int numContours, double range[2])
{this->ContourValues->GenerateValues(numContours, range);}


inline void vtkImageMarchingCubes::GenerateValues(int numContours, double
                                                 rangeStart, double rangeEnd)
{this->ContourValues->GenerateValues(numContours, rangeStart, rangeEnd);}

#endif

Generated on Tue Oct 5 08:39:15 2004 for VTK by Doxygen 1.3.8-20040913