vtkImprintFilter.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkImprintFilter.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 vtkImprintFilter_h
#define vtkImprintFilter_h
 
#include "vtkFiltersModelingModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
 
class vtkStaticCellLocator;
 
class VTKFILTERSMODELING_EXPORT vtkImprintFilter : public vtkPolyDataAlgorithm
{
public:
 
  static vtkImprintFilter* New();
  vtkTypeMacro(vtkImprintFilter, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void SetTargetConnection(vtkAlgorithmOutput* algOutput);
  vtkAlgorithmOutput* GetTargetConnection();
 
 
  void SetTargetData(vtkDataObject* target);
  vtkDataObject* GetTarget();
 
  void SetImprintConnection(vtkAlgorithmOutput* algOutput);
  vtkAlgorithmOutput* GetImprintConnection();
 
 
  void SetImprintData(vtkDataObject* imprint);
  vtkDataObject* GetImprint();
 
 
  vtkSetClampMacro(Tolerance, double, 0.0, VTK_FLOAT_MAX);
  vtkGetMacro(Tolerance, double);
 
  // Used to control how the merge tolerance is interpreted.
  // ABSOLUTE is a tolerance expressed in world coordinates;
  // RELATIVE_TO_TOLERANCE is a tolerance relative to the projection
  // tolerance; and RELATIVE_TO_MIN_EDGE_LENGTH is a tolerance relative
  // to the minimum edge length of the tool/imprint mesh.
  enum MergeTolType
  {
    ABSOLUTE = 0,
    RELATIVE_TO_PROJECTION_TOLERANCE = 1,
    RELATIVE_TO_MIN_EDGE_LENGTH = 2
  };
 
 
  vtkSetClampMacro(MergeToleranceType, int, ABSOLUTE, RELATIVE_TO_MIN_EDGE_LENGTH);
  vtkGetMacro(MergeToleranceType, int);
  void SetMergeToleranceTypeToAbsolute() { this->SetMergeToleranceType(ABSOLUTE); }
  void SetMergeToleranceTypeToRelativeToProjection()
  {
    this->SetMergeToleranceType(RELATIVE_TO_PROJECTION_TOLERANCE);
  }
  void SetMergeToleranceTypeToMinEdge()
  {
    this->SetMergeToleranceType(RELATIVE_TO_MIN_EDGE_LENGTH);
  }
  vtkSetClampMacro(MergeTolerance, double, 0.0, VTK_FLOAT_MAX);
  vtkGetMacro(MergeTolerance, double);
 
  enum SpecifiedOutput
  {
    TARGET_CELLS = 0,
    IMPRINTED_CELLS = 1,
    PROJECTED_IMPRINT = 2,
    IMPRINTED_REGION = 3,
    MERGED_IMPRINT = 5
  };
 
 
  vtkSetClampMacro(OutputType, int, TARGET_CELLS, MERGED_IMPRINT);
  vtkGetMacro(OutputType, int);
  void SetOutputTypeToTargetCells() { this->SetOutputType(TARGET_CELLS); }
  void SetOutputTypeToImprintedCells() { this->SetOutputType(IMPRINTED_CELLS); }
  void SetOutputTypeToProjectedImprint() { this->SetOutputType(PROJECTED_IMPRINT); }
  void SetOutputTypeToImprintedRegion() { this->SetOutputType(IMPRINTED_REGION); }
  void SetOutputTypeToMergedImprint() { this->SetOutputType(MERGED_IMPRINT); }
 
 
  vtkSetMacro(BoundaryEdgeInsertion, bool);
  vtkGetMacro(BoundaryEdgeInsertion, bool);
  vtkBooleanMacro(BoundaryEdgeInsertion, bool);
 
  enum DebugOutput
  {
    NO_DEBUG_OUTPUT = 0,
    TRIANGULATION_INPUT = 1,
    TRIANGULATION_OUTPUT = 2
  };
 
 
  vtkSetMacro(TriangulateOutput, bool);
  vtkGetMacro(TriangulateOutput, bool);
  vtkBooleanMacro(TriangulateOutput, bool);
 
 
  vtkSetClampMacro(DebugOutputType, int, NO_DEBUG_OUTPUT, TRIANGULATION_OUTPUT);
  vtkGetMacro(DebugOutputType, int);
  void SetDebugOutputTypeToNoDebugOutput() { this->SetDebugOutputType(NO_DEBUG_OUTPUT); }
  void SetDebugOutputTypeToTriangulationInput() { this->SetDebugOutputType(TRIANGULATION_INPUT); }
  void SetDebugOutputTypeToTriangulationOutput() { this->SetDebugOutputType(TRIANGULATION_OUTPUT); }
  vtkSetMacro(DebugCellId, vtkIdType);
  vtkGetMacro(DebugCellId, vtkIdType);
 
 
  vtkPolyData* GetDebugOutput();
 
protected:
  vtkImprintFilter();
  ~vtkImprintFilter() override;
 
  double Tolerance;
  double MergeTolerance;
  int MergeToleranceType;
  double ComputeMergeTolerance(vtkPolyData* pdata);
 
  int OutputType;
  bool BoundaryEdgeInsertion;
  bool TriangulateOutput;
 
  int DebugOutputType;
  vtkIdType DebugCellId;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestUpdateExtent(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
private:
  vtkImprintFilter(const vtkImprintFilter&) = delete;
  void operator=(const vtkImprintFilter&) = delete;
};
 
#endif