Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : PartitionTool.hpp
3 : : //
4 : : // Purpose : Functions for splitting geometry
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Jason Kraftcheck
9 : : //
10 : : // Creation Date : 12/13/98
11 : : //-------------------------------------------------------------------------
12 : :
13 : : #ifndef PARTITION_TOOL_HPP
14 : : #define PARTITION_TOOL_HPP
15 : :
16 : : class SenseEntity;
17 : : class PartitionEntity;
18 : : class PartitionCurve;
19 : : class PartitionSurface;
20 : : class Loop;
21 : : class Shell;
22 : :
23 : : class RefEdge;
24 : : class RefVertex;
25 : : class Curve;
26 : : template <class X> class DLIList;
27 : : class PartitionCurve;
28 : :
29 : : class CubitFacet;
30 : :
31 : : #include "CubitDefines.h"
32 : : #include "RefEdge.hpp"
33 : :
34 : : class PartitionTool
35 : : {
36 : : public:
37 : :
38 : : static PartitionTool* instance();
39 : : /*
40 : : virtual CubitStatus partition( RefEdge* edge_ptr,
41 : : RefVertex* split_point,
42 : : RefEdge*& first_new_edge,
43 : : RefEdge*& second_new_edge,
44 : : CubitBoolean ignore_mesh = CUBIT_FALSE );
45 : : */
46 : : virtual RefVertex* partition( RefEdge* edge_ptr,
47 : : const CubitVector& split_point,
48 : : RefEdge*& first_new_edge,
49 : : RefEdge*& second_new_edge,
50 : : CubitBoolean ignore_mesh = CUBIT_FALSE );
51 : : virtual RefVertex* partition( RefEdge* edge_ptr,
52 : : const CubitVector& split_point,
53 : : DLIList<RefEdge*>& result_edges,
54 : : CubitBoolean ignore_mesh = CUBIT_FALSE );
55 : : //R CubitStatus
56 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
57 : : //I edge_ptr
58 : : //I- A pointer to the RefEdge to Partition.
59 : : //I split_point
60 : : //I- A pointer to the Vertex at the split location.
61 : : //O first_new_edge / second_new_edge
62 : : //O- Pointers to the new RefEdges created.
63 : : //- Partition a RefEdge.
64 : :
65 : : virtual RefFace* insert_edge( RefFace* face_ptr,
66 : : DLIList<CubitVector*>& segments,
67 : : CubitBoolean is_meshed,
68 : : DLIList<RefEdge*>& created_curves,
69 : : int level_of_recursion = 0,
70 : : const double *tolerance_length = NULL);
71 : :
72 : : virtual CubitStatus insert_edge( DLIList<RefFace*>& input_faces,
73 : : DLIList<CubitVector*>& segments,
74 : : DLIList<RefFace*>& result_faces,
75 : : DLIList<RefEdge*>& created_edges,
76 : : CubitBoolean do_split_curves = CUBIT_FALSE);
77 : :
78 : :
79 : : virtual CubitStatus partition( RefFace* face_ptr,
80 : : RefEdge* edge_ptr,
81 : : RefFace*& new_face1,
82 : : RefFace*& new_face2,
83 : : CubitBoolean );
84 : :
85 : : virtual CubitStatus partition( RefFace* face_ptr,
86 : : DLIList<RefEdge*>& split_edges,
87 : : RefFace*& first_new_face,
88 : : RefFace*& second_new_face,
89 : : CubitBoolean ignore_mesh = CUBIT_FALSE );
90 : : //R CubitStatus
91 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
92 : : //I face_ptr
93 : : //I- A pointer to the RefFace to split.
94 : : //I split_edges
95 : : //I- The list of edges defining split location.
96 : : //O first_new_face / second_new_face
97 : : //O- The new RefFaces created.
98 : : //- Partition a RefFace.
99 : :
100 : : virtual CubitStatus partition( RefVolume* vol_ptr,
101 : : DLIList<RefFace*>& split_faces,
102 : : RefVolume*& first_new_volume,
103 : : RefVolume*& second_new_volume,
104 : : CubitBoolean ignore_mesh = CUBIT_FALSE );
105 : : virtual CubitStatus partition( RefVolume* vol_ptr,
106 : : DLIList<CubitFacet*>& split_faces,
107 : : RefVolume*& first_new_volume,
108 : : RefVolume*& second_new_volume,
109 : : DLIList<RefFace*>& new_surfaces,
110 : : CubitBoolean ignore_mesh = CUBIT_FALSE );
111 : : //R CubitStatus
112 : : //I vol_ptr
113 : : //I- A pointer to the RefVolume to split.
114 : : //I split_faces
115 : : //I- The list of faces defining the split location
116 : : //O first_new_volume/second_new_volume
117 : : //O- The new RefVolumes created
118 : : //- Partition a RefVolume.
119 : :
120 : : CubitStatus destroy_volume_partition( RefVolume* partition );
121 : :
122 : : //CubitStatus partition( RefEdge* edge_ptr,
123 : : // DLIList<RefVertex*>& split_points,
124 : : // DLIList<RefEdge*>& new_edges,
125 : : // CubitBoolean ignore_mesh = CUBIT_FALSE );
126 : : CubitStatus partition( RefEdge* edge_ptr,
127 : : DLIList<CubitVector*>& split_points,
128 : : DLIList<RefEdge*>& new_edges,
129 : : CubitBoolean ignore_mesh = CUBIT_FALSE );
130 : : CubitStatus partition( RefEdge* edge_ptr,
131 : : DLIList<CubitVector*>& split_points,
132 : : DLIList<RefVertex*>& new_vertices,
133 : : DLIList<RefEdge*>& new_edges,
134 : : CubitBoolean ignore_mesh = CUBIT_FALSE );
135 : : //R CubitStatus
136 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
137 : : //I edge_ptr
138 : : //I- A pointer to the RefEdge to Partition.
139 : : //I split_points
140 : : //I- A list of Vertices at which to split the curve.
141 : : //O new_edges
142 : : //O- The new RefEdges created.
143 : : //- Partition a RefEdge.
144 : :
145 : : CubitStatus partition_face_by_curves( RefFace* face_ptr,
146 : : const DLIList<Curve*>& split_curves,
147 : : DLIList<RefFace*>& result_faces,
148 : : CubitBoolean do_split_curves = CUBIT_FALSE,
149 : : DLIList<RefEdge*>* new_edges = NULL,
150 : : CubitBoolean ignore_mesh = CUBIT_FALSE );
151 : : //- Similar to the next function but takes curves as input
152 : :
153 : : CubitStatus partition( RefFace* face_ptr,
154 : : const DLIList<RefEdge*>& split_edges,
155 : : DLIList<RefFace*>& result_faces,
156 : : CubitBoolean do_split_curves = CUBIT_FALSE,
157 : : DLIList<RefEdge*>* new_edges = NULL,
158 : : CubitBoolean ignore_mesh = CUBIT_FALSE );
159 : : //R CubitStatus
160 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
161 : : //I face_ptr
162 : : //I- A pointer to the RefFace to partition
163 : : //I split_edges
164 : : //I- A list of RefEdges with which to partition the RefFace
165 : : //O result_faces
166 : : //O- The RefFaces resulting from the splitting operation
167 : : //I split_curves
168 : : //I- If true, spatially compare all RefVertices in the split_edge
169 : : //I- list with edges in that list and on the RefFace, and partition
170 : : //I- RefEdges as necessary.
171 : : //O new_edges
172 : : //O- If split_curves in CUBIT_TRUE, and this is non-null, a list
173 : : //O- of new RefEdges created by partitioning will be passed back.
174 : : //I ignore_mesh
175 : : //I- If true, operator will not fail if the passed RefFace is meshed,
176 : : //I- or if split_curves in true and any of the RefEdges are meshed.
177 : : //I- NOTE: If this is passed as CUBIT_TRUE, it is the responsibility
178 : : //I- of the caller to remove the mesh from hidden entities.
179 : : //- Do multiple partitioning of a RefFace.
180 : :
181 : : RefEdge* unpartition( RefEdge* first_partition_edge,
182 : : RefEdge* second_partition_edge );
183 : : //R RefEdge*
184 : : //R- The RefEdge restored to the model.
185 : : //I first_partition_edge / second_partition_edge
186 : : //I- Pointers to RefEdges with PartitionCurve geometry.
187 : : //O free_vertex
188 : : //O- A pointer to the freed vertex.
189 : : //I keep_dead
190 : : //I- If true, the passed-in RefEdges are not destroyed, but the
191 : : //I- attached PartitionCurve is.
192 : : //- Undo a partitioning operation.
193 : :
194 : : RefFace* unpartition( RefFace* first_partition_face,
195 : : RefFace* second_partition_face );
196 : : //R RefFace*
197 : : //R- The RefFace restored to the model.
198 : : //I first_partition_face / second_partition_face
199 : : //I- Pointers to RefFaces with PartitionSurface geometry.
200 : : //O free_edges
201 : : //O- A list of edges freed by this operation.
202 : : //I keep_dead
203 : : //I- If true, the passed-in RefFaces are not destroyed, but the
204 : : //I- attached PartitionSurface is.
205 : : //- Undo a partitioning operation.
206 : :
207 : : RefVolume* unpartition( RefVolume* first_partition_volume,
208 : : RefVolume* second_partition_volume );
209 : : //R RefVolume*
210 : : //R- The RefVolume restored to the model.
211 : : //I first_partition_volume / second_partition_volume
212 : : //I- Pointers to RefVolumes with PartitionLump geometry.
213 : : //O free_faces
214 : : //O- A list of faces freed by this operation.
215 : : //- Undo a partitioning operation.
216 : :
217 : : RefVolume* unpartition( DLIList<RefVolume*>& partition_volumes );
218 : :
219 : :
220 : : virtual CubitStatus unpartitionAll( DLIList<RefEdge*>& partition_edges,
221 : : DLIList<RefEdge*>& restored_edges );
222 : : //R CubitStatus
223 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
224 : : //I partition_edges
225 : : //I- A list of RefEdges with PartitionCurve geometry.
226 : : //O restored_edges
227 : : //O- A list of RefEdges restored to the model.
228 : : //- Remove a bunch of partitions.
229 : : //-
230 : : //- Note: Any vertices freed by this operation will be deleted.
231 : :
232 : : virtual CubitStatus unpartitionAll( DLIList<RefFace*>& partition_faces,
233 : : DLIList<RefFace*>& restored_faces );
234 : : //R CubitStatus
235 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
236 : : //I partition_faces
237 : : //I- A list of RefFaces with PartitionSurfaces geometry.
238 : : //O restored_faces
239 : : //O- A list of RefFaces restored to the model.
240 : : //- Remove a bunch of partitions.
241 : : //-
242 : : //- Note: any RefEdges freed by this operation and thier child
243 : : //- RefVertices will be deleted.
244 : :
245 : :
246 : : virtual CubitStatus unpartitionAll( DLIList<RefVolume*>& partition_vols,
247 : : DLIList<RefVolume*>& restored_vols );
248 : :
249 : : RefVertex* make_point_curve( RefFace* ref_face,
250 : : const CubitVector& position );
251 : :
252 : : CubitStatus make_point_curves( RefFace* ref_face,
253 : : DLIList<CubitVector> &position,
254 : : DLIList<RefVertex*> &new_vertices);
255 : :
256 : : virtual ~PartitionTool();
257 : :
258 : : virtual CubitStatus can_remove( RefVertex* vertex );
259 : : virtual CubitStatus can_remove( RefEdge* edge );
260 : : virtual CubitStatus can_remove( RefFace* face );
261 : :
262 : 0 : int get_faceting_tolerance() {return facetingTolerance;}
263 : :
264 : : protected:
265 : :
266 : : static PartitionTool* instance_;
267 : :
268 : : PartitionTool();
269 : :
270 : : DLIList<Surface*>* group_merged_surfaces( DLIList<RefFace*>& face_list,
271 : : int& num_result_sets );
272 : :
273 : :
274 : : private:
275 : :
276 : : void notify_partition( DLIList<RefEntity*> &partitioning_entities,
277 : : BasicTopologyEntity *first_partitioned_entity,
278 : : BasicTopologyEntity *second_partitioned_entity,
279 : : BasicTopologyEntity *old_entity );
280 : : // notify observers that the old_entity was partitioned
281 : :
282 : :
283 : :
284 : : CubitStatus commonGroupingEntities( BasicTopologyEntity* first_bte_ptr,
285 : : BasicTopologyEntity* secnd_bte_ptr,
286 : : GroupingEntity*& first_gpe_ptr,
287 : : GroupingEntity*& second_gpe_ptr ) const;
288 : : //R CubitStatus
289 : : //R- CUBIT_SUCCESS/CUBIT_FAILURE
290 : : //I first_bte_ptr/second_bte_ptr
291 : : //I- Pointers to two BTEs of the same type.
292 : : //O first_gpe_ptr/second_gpe_ptr
293 : : //O- Child grouping entities of first_bte_ptr and second_bte_ptr,
294 : : //O- respectively.
295 : : //- This function searches for a grouping entity from each
296 : : //- of the BTEs for which those GroupingEntites have atleast one
297 : : //- common child.
298 : : //- If there is only one pair of grouping entities which meet this
299 : : //- criteria, they are passed back, and CUBIT_SUCCESS is returned.
300 : : //- If there is more than one pair, an arbitrary pair is passed
301 : : //- back, and CUBIT_FAILURE is returned.
302 : : //- If no common GpEs are found, both pointers are passed back as
303 : : //- NULL, and CUBIT_FAILURE is returned.
304 : :
305 : : int facetingTolerance;
306 : :
307 : : };
308 : :
309 : : //-------------------------------------------------------------------------
310 : : // Purpose : Singleton class
311 : : //
312 : : // Special Notes :
313 : : //
314 : : // Creator : Jason Kraftcheck
315 : : //
316 : : // Creation Date : 12/13/98
317 : : //-------------------------------------------------------------------------
318 : 0 : inline PartitionTool* PartitionTool::instance()
319 : : {
320 [ # # ][ # # ]: 0 : if( instance_ == NULL ) instance_ = new PartitionTool();
321 : 0 : return instance_;
322 : : }
323 : :
324 : : #endif
325 : :
|
