vtkIntersectionPolyDataFilter.h 6.55 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkIntersectionPolyDataFilter.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.

=========================================================================*/
// .NAME vtkIntersectionPolyDataFilter
// .SECTION Description
//
// vtkIntersectionPolyDataFilter computes the intersection between two
// vtkPolyData objects. The first output is a set of lines that marks
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// the intersection of the input vtkPolyData objects. This contains five
// different attached data arrays:
//
// SurfaceID: Point data array that contatins information about the orgin
// surface of each point
//
// Input0CellID: Cell data array that says the contains the original
// cell id number on the first input mesh
//
// Input1CellID: Cell data array that says the contains the original
// cell id number on the second input mesh
//
// NewCell0ID: Cell data array that contains information about which cells
// of the remeshed first input surface it touches (If split)
//
// NewCell1ID: Cell data array that contains information about which cells
// on the remeshed second input surface it touches (If split)
//
// The second and third outputs are the first and second input vtkPolyData,
39
// respectively. Optionally, the two output vtkPolyData can be split
40
41
42
43
44
45
46
// along the intersection lines by remeshing. Optionally, the surface
// can be cleaned and checked at the end of the remeshing.
// If the meshes are split, The output vtkPolyDatas contain three possible
// data arrays:
//
// BoundaryPoints: This is a boolean indicating whether or not the point is
// on the boundary of the two input objects
47
//
48
49
50
51
52
53
54
55
56
57
58
59
// BadTri: If the surface is cleaned and checked, this is a cell data array
// indicating whether or not the cell has edges with multiple neighbors
// A manifold surface will have 0 everywhere for this array!
//
// FreeEdge: If the surface is cleaned and checked, this is a cell data array
// indicating if the cell has any free edges. A watertight surface will have
// 0 everywhere for this array!
/** @file vtkIntersectionPolyDataFilter.cxx
 *  @brief This is a filter that performs the intersection of surfaces
 *  @author Adam Updegrove
 *  @author updega2@gmail.com
 */
60

61
62
#ifndef vtkIntersectionPolyDataFilter_h
#define vtkIntersectionPolyDataFilter_h
63

64
#include "vtkFiltersGeneralModule.h" // For export macro
65
66
#include "vtkPolyDataAlgorithm.h"

67
68
class VTKFILTERSGENERAL_EXPORT vtkIntersectionPolyDataFilter :
        public vtkPolyDataAlgorithm
69
70
71
72
73
74
{
public:
  static vtkIntersectionPolyDataFilter *New();
  vtkTypeMacro(vtkIntersectionPolyDataFilter, vtkPolyDataAlgorithm);
  virtual void PrintSelf(ostream &os, vtkIndent indent);

75
76
77
78
79
  // Description:
  // Integer describing the number of intersection points and lines
  vtkGetMacro(NumberOfIntersectionPoints, int);
  vtkGetMacro(NumberOfIntersectionLines, int);

80
81
82
83
84
85
86
87
88
89
90
91
92
93
  // Description:
  // If on, the second output will be the first input mesh split by the
  // intersection with the second input mesh. Defaults to on.
  vtkGetMacro(SplitFirstOutput, int);
  vtkSetMacro(SplitFirstOutput, int);
  vtkBooleanMacro(SplitFirstOutput, int);

  // Description:
  // If on, the third output will be the second input mesh split by the
  // intersection with the first input mesh. Defaults to on.
  vtkGetMacro(SplitSecondOutput, int);
  vtkSetMacro(SplitSecondOutput, int);
  vtkBooleanMacro(SplitSecondOutput, int);

94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
  // Description:
  // If on, the output split surfaces will contain information about which
  // points are on the boundary of the two inputs. Default: ON
  vtkGetMacro(ApplyBoundaryPointArray, int);
  vtkSetMacro(ApplyBoundaryPointArray, int);
  vtkBooleanMacro(ApplyBoundaryPointArray, int);

  // Description:
  // If on, the normals of the input will be checked. Default: OFF
  vtkGetMacro(CheckInput, int);
  vtkSetMacro(CheckInput, int);
  vtkBooleanMacro(CheckInput, int);

  // Description:
  // If on, the output remeshed surfaces will be checked for bad cells and
  // free edges. Default: ON
  vtkGetMacro(CheckMesh, int);
  vtkSetMacro(CheckMesh, int);
  vtkBooleanMacro(CheckMesh, int);

  // Description:
  // Check the status of the filter after update. If the status is zero,
  // there was an error in the operation. If status is one, everything
  // went smoothly
  vtkGetMacro(Status, int);

  // Description:
  // The tolerance for geometric tests in the filter
  vtkGetMacro(Tolerance, double);
  vtkSetMacro(Tolerance, double);

125
126
127
128
129
130
  // Description:
  // Given two triangles defined by points (p1, q1, r1) and (p2, q2,
  // r2), returns whether the two triangles intersect. If they do,
  // the endpoints of the line forming the intersection are returned
  // in pt1 and pt2. The parameter coplanar is set to 1 if the
  // triangles are coplanar and 0 otherwise.
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
  static int TriangleTriangleIntersection(double p1[3], double q1[3],
                                          double r1[3], double p2[3],
                                          double q2[3], double r2[3],
                                          int &coplanar, double pt1[3],
                                          double pt2[3], double surfaceid[2],
                                          double tolerance);

  // Description:
  // Function to clean and check the output surfaces for bad triangles and
  // free edges
  static void CleanAndCheckSurface(vtkPolyData *pd, double stats[2],
                  double tolerance);

  // Description:
  // Function to clean and check the inputs
  static void CleanAndCheckInput(vtkPolyData *pd, double tolerance);

148
149

protected:
150
151
  vtkIntersectionPolyDataFilter();  //Constructor
  ~vtkIntersectionPolyDataFilter();  //Destructor
152

153
154
155
  int RequestData(vtkInformation*, vtkInformationVector**,
                  vtkInformationVector*);  //Update
  int FillInputPortInformation(int, vtkInformation*); //Input,Output
156
157

private:
158
159
  vtkIntersectionPolyDataFilter(const vtkIntersectionPolyDataFilter&);  // Not implemented
  void operator=(const vtkIntersectionPolyDataFilter&);  // Not implemented
160

161
162
  int NumberOfIntersectionPoints;
  int NumberOfIntersectionLines;
163
164
  int SplitFirstOutput;
  int SplitSecondOutput;
165
166
167
168
169
  int ApplyBoundaryPointArray;
  int CheckMesh;
  int CheckInput;
  int Status;
  double Tolerance;
170

171
  class Impl;  //Implementation class
172
173
174
};


175
#endif // vtkIntersectionPolyDataFilter_h