vtkImageToPolyDataFilter.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkImageToPolyDataFilter.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 vtkImageToPolyDataFilter_h
#define vtkImageToPolyDataFilter_h
 
#include "vtkFiltersHybridModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
 
#define VTK_STYLE_PIXELIZE 0
#define VTK_STYLE_POLYGONALIZE 1
#define VTK_STYLE_RUN_LENGTH 2
 
#define VTK_COLOR_MODE_LUT 0
#define VTK_COLOR_MODE_LINEAR_256 1
 
class vtkDataArray;
class vtkEdgeTable;
class vtkIdTypeArray;
class vtkIntArray;
class vtkScalarsToColors;
class vtkStructuredPoints;
class vtkTimeStamp;
class vtkUnsignedCharArray;
 
class VTKFILTERSHYBRID_EXPORT vtkImageToPolyDataFilter : public vtkPolyDataAlgorithm
{
public:
  vtkTypeMacro(vtkImageToPolyDataFilter, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkImageToPolyDataFilter* New();
 
 
  vtkSetClampMacro(OutputStyle, int, VTK_STYLE_PIXELIZE, VTK_STYLE_RUN_LENGTH);
  vtkGetMacro(OutputStyle, int);
  void SetOutputStyleToPixelize() { this->SetOutputStyle(VTK_STYLE_PIXELIZE); }
  void SetOutputStyleToPolygonalize() { this->SetOutputStyle(VTK_STYLE_POLYGONALIZE); }
  void SetOutputStyleToRunLength() { this->SetOutputStyle(VTK_STYLE_RUN_LENGTH); }
 
 
  vtkSetClampMacro(ColorMode, int, VTK_COLOR_MODE_LUT, VTK_COLOR_MODE_LINEAR_256);
  vtkGetMacro(ColorMode, int);
  void SetColorModeToLUT() { this->SetColorMode(VTK_COLOR_MODE_LUT); }
  void SetColorModeToLinear256() { this->SetColorMode(VTK_COLOR_MODE_LINEAR_256); }
 
 
  virtual void SetLookupTable(vtkScalarsToColors*);
  vtkGetObjectMacro(LookupTable, vtkScalarsToColors);
 
 
  vtkSetMacro(Smoothing, vtkTypeBool);
  vtkGetMacro(Smoothing, vtkTypeBool);
  vtkBooleanMacro(Smoothing, vtkTypeBool);
 
 
  vtkSetClampMacro(NumberOfSmoothingIterations, int, 0, VTK_INT_MAX);
  vtkGetMacro(NumberOfSmoothingIterations, int);
 
 
  vtkSetMacro(Decimation, vtkTypeBool);
  vtkGetMacro(Decimation, vtkTypeBool);
  vtkBooleanMacro(Decimation, vtkTypeBool);
 
 
  vtkSetClampMacro(DecimationError, double, 0.0, VTK_DOUBLE_MAX);
  vtkGetMacro(DecimationError, double);
 
 
  vtkSetClampMacro(Error, int, 0, VTK_INT_MAX);
  vtkGetMacro(Error, int);
 
 
  vtkSetClampMacro(SubImageSize, int, 10, VTK_INT_MAX);
  vtkGetMacro(SubImageSize, int);
 
protected:
  vtkImageToPolyDataFilter();
  ~vtkImageToPolyDataFilter() override;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
  int OutputStyle;
  int ColorMode;
  vtkTypeBool Smoothing;
  int NumberOfSmoothingIterations;
  vtkTypeBool Decimation;
  double DecimationError;
  int Error;
  int SubImageSize;
  vtkScalarsToColors* LookupTable;
 
  virtual void PixelizeImage(vtkUnsignedCharArray* pixels, int dims[3], double origin[3],
    double spacing[3], vtkPolyData* output);
  virtual void PolygonalizeImage(vtkUnsignedCharArray* pixels, int dims[3], double origin[3],
    double spacing[3], vtkPolyData* output);
  virtual void RunLengthImage(vtkUnsignedCharArray* pixels, int dims[3], double origin[3],
    double spacing[3], vtkPolyData* output);
 
private:
  vtkUnsignedCharArray* Table; // color table used to quantize points
  vtkTimeStamp TableMTime;
  int* Visited;                     // traverse & mark connected regions
  vtkUnsignedCharArray* PolyColors; // the colors of each region -> polygon
  vtkEdgeTable* EdgeTable;          // keep track of intersection points
  vtkEdgeTable* EdgeUseTable;       // keep track of polygons use of edges
  vtkIntArray* EdgeUses;            // the two polygons that use an edge
                                    // and point id associated with edge (if any)
 
  void BuildTable(unsigned char* inPixels);
  vtkUnsignedCharArray* QuantizeImage(
    vtkDataArray* inScalars, int numComp, int type, int dims[3], int ext[4]);
  int ProcessImage(vtkUnsignedCharArray* pixels, int dims[2]);
  int BuildEdges(vtkUnsignedCharArray* pixels, int dims[3], double origin[3], double spacing[3],
    vtkUnsignedCharArray* pointDescr, vtkPolyData* edges);
  void BuildPolygons(vtkUnsignedCharArray* pointDescr, vtkPolyData* edges, int numPolys,
    vtkUnsignedCharArray* polyColors);
  void SmoothEdges(vtkUnsignedCharArray* pointDescr, vtkPolyData* edges);
  void DecimateEdges(vtkPolyData* edges, vtkUnsignedCharArray* pointDescr, double tol2);
  void GeneratePolygons(vtkPolyData* edges, int numPolys, vtkPolyData* output,
    vtkUnsignedCharArray* polyColors, vtkUnsignedCharArray* pointDescr);
 
  int GetNeighbors(
    unsigned char* ptr, int& i, int& j, int dims[3], unsigned char* neighbors[4], int mode);
 
  void GetIJ(int id, int& i, int& j, int dims[2]);
  unsigned char* GetColor(unsigned char* rgb);
  int IsSameColor(unsigned char* p1, unsigned char* p2);
 
private:
  vtkImageToPolyDataFilter(const vtkImageToPolyDataFilter&) = delete;
  void operator=(const vtkImageToPolyDataFilter&) = delete;
};
 
#endif