vtkTrimmedExtrusionFilter.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkTrimmedExtrusionFilter_h
#define vtkTrimmedExtrusionFilter_h
 
#include "vtkFiltersModelingModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractCellLocator;
 
class VTKFILTERSMODELING_EXPORT vtkTrimmedExtrusionFilter : public vtkPolyDataAlgorithm
{
public:
  vtkTypeMacro(vtkTrimmedExtrusionFilter, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkTrimmedExtrusionFilter* New();
 
 
  vtkSetVector3Macro(ExtrusionDirection, double);
  vtkGetVectorMacro(ExtrusionDirection, double, 3);
 
 
  void SetTrimSurfaceData(vtkPolyData* pd);
  void SetTrimSurfaceConnection(vtkAlgorithmOutput* algOutput);
 
 
  vtkPolyData* GetTrimSurface();
  vtkPolyData* GetTrimSurface(vtkInformationVector* sourceInfo);
 
 
  vtkSetMacro(Capping, int);
  vtkGetMacro(Capping, int);
  vtkBooleanMacro(Capping, int);
 
  // How to extrude data. Either determine boundary edges and sweep them; or
  // sweep all edges.
  enum ExtrusionStrategy
  {
    BOUNDARY_EDGES = 0,
    ALL_EDGES = 1
  };
 
 
  vtkSetMacro(ExtrusionStrategy, int);
  vtkGetMacro(ExtrusionStrategy, int);
  void SetExtrusionStrategyToBoundaryEdges() { this->SetExtrusionStrategy(BOUNDARY_EDGES); }
  void SetExtrusionStrategyToAllEdges() { this->SetExtrusionStrategy(ALL_EDGES); }
 
  // How to cap data.
  enum CappingStrategy
  {
    INTERSECTION = 0,
    MINIMUM_DISTANCE = 1,
    MAXIMUM_DISTANCE = 2,
    AVERAGE_DISTANCE = 3,
  };
 
 
  vtkSetMacro(CappingStrategy, int);
  vtkGetMacro(CappingStrategy, int);
  void SetCappingStrategyToIntersection() { this->SetCappingStrategy(INTERSECTION); }
  void SetCappingStrategyToMinimumDistance() { this->SetCappingStrategy(MINIMUM_DISTANCE); }
  void SetCappingStrategyToMaximumDistance() { this->SetCappingStrategy(MAXIMUM_DISTANCE); }
  void SetCappingStrategyToAverageDistance() { this->SetCappingStrategy(AVERAGE_DISTANCE); }
 
 
  void SetLocator(vtkAbstractCellLocator* locator);
  vtkGetObjectMacro(Locator, vtkAbstractCellLocator);
 
protected:
  vtkTrimmedExtrusionFilter();
  ~vtkTrimmedExtrusionFilter() override;
 
  int Capping;
  double ExtrusionDirection[3];
  int ExtrusionStrategy;
  int CappingStrategy;
  vtkAbstractCellLocator* Locator;
 
  void AdjustPoints(vtkPolyData* mesh, vtkIdType numPts, vtkIdType numCells, unsigned char* hots,
    vtkPoints* newPts);
 
  void ExtrudeEdges(vtkPolyData* input, vtkPolyData* output, vtkIdType numPts, vtkIdType numCells);
 
  vtkIdType GetNeighborCount(
    vtkPolyData* mesh, vtkIdType inCellId, vtkIdType p1, vtkIdType p2, vtkIdList* cellIds);
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int FillInputPortInformation(int, vtkInformation*) override;
 
private:
  vtkTrimmedExtrusionFilter(const vtkTrimmedExtrusionFilter&) = delete;
  void operator=(const vtkTrimmedExtrusionFilter&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif