Branch data Line data Source code
1 : : //-Class: TDSplitSurface.hpp
2 : :
3 : : #ifndef TD_SPLIT_SURFACE_HPP
4 : : #define TD_SPLIT_SURFACE_HPP
5 : :
6 : : #include "ToolData.hpp"
7 : : #include "CastTo.hpp"
8 : : #include "DLIList.hpp"
9 : : #include "CubitVector.hpp"
10 : : #include "Cubit2DPoint.hpp"
11 : : #include "CGMGeomConfigure.h"
12 : :
13 : : class RefFace;
14 : : class RefEdge;
15 : : class RefVertex;
16 : : class CoEdge;
17 : :
18 : : //================================================================================
19 : : // Description: A trivial class to hold two parameter values so that they
20 : : // can be stored in a DLIList. They are the min and max parameter
21 : : // space along the composite curve. (Split Surface Param)
22 : : // Author : Steve Storm
23 : : // Date : 2/3/2004
24 : : //================================================================================
25 : : class CUBIT_GEOM_EXPORT SSParam
26 : : {
27 : : public:
28 : :
29 : : SSParam( double min, double max );
30 : : ~SSParam();
31 : :
32 : : double umin();
33 : : double umax();
34 : :
35 : : private:
36 : :
37 : : double uMin;
38 : : double uMax;
39 : : };
40 : :
41 : 0 : inline double SSParam::umin()
42 : 0 : { return uMin; }
43 : :
44 : 0 : inline double SSParam::umax()
45 : 0 : { return uMax; }
46 : :
47 : : //================================================================================
48 : : // Description: This class (Split Surface Side) holds a chain of curves on one
49 : : // side of the surface. It is needed to handle queries using a
50 : : // composite curve concept.
51 : : // Author : Steve Storm
52 : : // Date : 2/3/2004
53 : : //================================================================================
54 : : class CUBIT_GEOM_EXPORT SSSide
55 : : {
56 : : public:
57 : :
58 : : SSSide( RefFace *ref_face_ptr, DLIList<CoEdge*> &co_edges,
59 : : const CubitVector *collapsed_loc_ptr = NULL );
60 : : ~SSSide();
61 : :
62 : : CubitStatus position_from_u( double u_value,
63 : : CubitVector& output_position );
64 : :
65 : : CubitStatus u_from_position ( const CubitVector& input_position,
66 : : double &u );
67 : : CubitStatus u_from_position ( const CubitVector& input_position,
68 : : CoEdge *co_edge_ptr, SSParam *param,
69 : : double &u );
70 : :
71 : : CubitBoolean is_vertex_on( RefVertex *ref_vertex_ptr );
72 : : //- Determines if the given vertex lies on this side spatially.
73 : :
74 : : double length();
75 : : //- Return curve length of this side
76 : :
77 : : CubitStatus build_param_list_from_facets( double tolerance = 0.1 );
78 : : //- This function builds paramList using the graphics facets. The
79 : : //- coordList will be filled during syncronization - syncronize_lists.
80 : : //- The tolerance is used by the geometry engine as the allowable deviation
81 : : //- of the facets from the actual curve.
82 : :
83 : : CubitStatus build_param_list( double fraction, double distance, int num_segs,
84 : : DLIList<RefVertex*> &through_vertex_list );
85 : : //- This function fills the paramList and coordList with the
86 : : //- appropriate number of points for the A and C sides of the surface.
87 : : //- This is typically one point at the 50% location; however it could
88 : : //- be at a specified fraction value, at a vertex location or multiple
89 : : //- points evenly spaced.
90 : :
91 : : CubitStatus syncronize_lists( SSSide *other_side,
92 : : double param_tol=.1 );
93 : : //- Update lists in "this" and other_side. Parameter values from
94 : : //- both lists will be merged so that paramList will be identical
95 : : //- on both SSSides. This also populates coordList. Use this
96 : : //- function to syncronize the B-D sides.
97 : :
98 : : DLIList<CoEdge*> *co_edges();
99 : : //- Returns a pointer to this side's CoEdge list
100 : :
101 : : int coord_list_size();
102 : : //- Return size of coordList
103 : : void coord_list_reset();
104 : : //- Set coordList to start of list
105 : : void coord_list_last();
106 : : //- Set coordList to end of list
107 : : CubitVector *coord_list_get();
108 : : //- Return value of current item in coordList
109 : : CubitVector *coord_list_get_and_step();
110 : : //- Get and step on the coordList
111 : : CubitVector *coord_list_get_and_back();
112 : : //- Get and back on the coordList
113 : :
114 : : int param_list_size();
115 : : //- Return size of paramList
116 : : void param_list_reset();
117 : : //- Set paramList to start of list
118 : : void param_list_last();
119 : : //- Set paramList to end of list
120 : : double param_list_get();
121 : : //- Return value of current item in paramList
122 : : double param_list_get_and_step();
123 : : //- Get and step on the paramList
124 : : double param_list_get_and_back();
125 : : //- Get and back on the paramList
126 : :
127 : : CubitBoolean is_collapsed();
128 : : //- Return whether this side is collapsed or not
129 : :
130 : : private:
131 : :
132 : : RefFace *refFacePtr;
133 : : DLIList<CoEdge*> coEdgeChain;
134 : : double paramHigh; // Parameter space of chain goes from 0.0 to curve length
135 : : DLIList<SSParam*> coEdgeParamList; // Holds low and high parameter on each CoEdge
136 : :
137 : : DLIList<CubitVector*> coordList; // Coordinates for determining split locations
138 : : DLIList<double> paramList; // Parameters for determining split locations
139 : : // Note: sideA and sideC just contain the interior locs, while sideB and sideD
140 : : // contain interior plus end locs built from curve facetting
141 : :
142 : : CubitBoolean isCollapsed; // CUBIT_TRUE if edge is collapsed (just a point)
143 : : };
144 : :
145 : 0 : inline double SSSide::length()
146 : 0 : { return paramHigh; }
147 : :
148 : 0 : inline DLIList<CoEdge*> *SSSide::co_edges()
149 : 0 : { return &coEdgeChain; }
150 : :
151 : 0 : inline int SSSide::coord_list_size()
152 : 0 : { return coordList.size(); }
153 : 0 : inline void SSSide::coord_list_reset()
154 : 0 : { coordList.reset(); }
155 : 0 : inline void SSSide::coord_list_last()
156 : 0 : { coordList.last(); }
157 : : inline CubitVector *SSSide::coord_list_get()
158 : : { return coordList.get(); }
159 : 0 : inline CubitVector *SSSide::coord_list_get_and_step()
160 : 0 : { return coordList.get_and_step(); }
161 : 0 : inline CubitVector *SSSide::coord_list_get_and_back()
162 : 0 : { return coordList.get_and_back(); }
163 : :
164 : : inline int SSSide::param_list_size()
165 : : { return paramList.size(); }
166 : 0 : inline void SSSide::param_list_reset()
167 : 0 : { paramList.reset(); }
168 : 0 : inline void SSSide::param_list_last()
169 : 0 : { paramList.last(); }
170 : : inline double SSSide::param_list_get()
171 : : { return paramList.get(); }
172 : 0 : inline double SSSide::param_list_get_and_step()
173 : 0 : { return paramList.get_and_step(); }
174 : 0 : inline double SSSide::param_list_get_and_back()
175 : 0 : { return paramList.get_and_back(); }
176 : :
177 : 0 : inline CubitBoolean SSSide::is_collapsed()
178 : 0 : { return isCollapsed;}
179 : :
180 : : //================================================================================
181 : : // Description: This class holds data on the surface defining the sides of
182 : : // the surface to be split.
183 : : // Author : Steve Storm
184 : : // Date : 2/3/2004
185 : : //================================================================================
186 : : class CUBIT_GEOM_EXPORT TDSplitSurface : public ToolData
187 : : {
188 : : public:
189 : :
190 : : TDSplitSurface( int vertex_type );
191 : : //- Constructor if placed on a CoEdge
192 : :
193 : : TDSplitSurface( RefFace *ref_face_ptr );
194 : : //- Constructor if placed on a RefFace
195 : :
196 : : ~TDSplitSurface();
197 : : //- Destructor
198 : :
199 : : RefFace *ref_face_ptr();
200 : : //- Return this TDSplitSurface's RefFace ptr
201 : :
202 : : void add_type( int type );
203 : : int get_type();
204 : : //- For CoEdges
205 : :
206 : : CubitStatus add_coedges( DLIList<CoEdge*> &co_edge_list,
207 : : int side_interval[] );
208 : : CubitStatus add_a_coedges( DLIList<CoEdge*> &a_coedges,
209 : : RefVertex *start_vertex_ptr = NULL );
210 : : CubitStatus add_b_coedges( DLIList<CoEdge*> &b_coedges,
211 : : RefVertex *start_vertex_ptr = NULL );
212 : : CubitStatus add_c_coedges( DLIList<CoEdge*> &c_coedges,
213 : : RefVertex *start_vertex_ptr = NULL );
214 : : CubitStatus add_d_coedges( DLIList<CoEdge*> &d_coedges,
215 : : RefVertex *start_vertex_ptr = NULL );
216 : : //- Add the curves into SSSide. Note any side could be collapsed because of
217 : : //- a triangle, if that is true a vertex needs to be provided to give the
218 : : //- coordinate of the side.
219 : :
220 : : CubitStatus tessellate_sides( double tol, double fraction, double distance,
221 : : int num_segs,
222 : : DLIList<RefVertex*> &through_vertex_list );
223 : : //- Tessellates curves on the sides to find boundary coordinates in preparation
224 : : //- for the mapping algirithm. To give a smooth mapping, the tessellations
225 : : //- are matched across the sides (ie., all locations on either side are at the
226 : : //- same parameter value along the side). The through_vertex_list if optional -
227 : : //- if specified, the split will pass through vertices in the through_vertex_list
228 : : //- that are on sides A or C spatially.
229 : :
230 : : RefVertex *start_vertex( CoEdge *co_edge_ptr );
231 : : //- Get the starting vertex of the given CoEdge.
232 : :
233 : : DLIList<CoEdge*> *get_a_coedges();
234 : : DLIList<CoEdge*> *get_b_coedges();
235 : : DLIList<CoEdge*> *get_c_coedges();
236 : : DLIList<CoEdge*> *get_d_coedges();
237 : : //- Just return a pointer to the curves
238 : :
239 : : double length_a();
240 : : double length_b();
241 : : double length_c();
242 : : double length_d();
243 : : //- Return the length of the given side
244 : :
245 : : int coord_list_size_a();
246 : : void coord_list_reset_a();
247 : : void coord_list_last_a();
248 : : CubitVector *coord_list_get_a();
249 : : CubitVector *coord_list_get_and_step_a();
250 : : CubitVector *coord_list_get_and_back_a();
251 : : //- Used to traverse the coordinates on side A
252 : :
253 : : int coord_list_size_b();
254 : : void coord_list_reset_b();
255 : : void coord_list_last_b();
256 : : CubitVector *coord_list_get_b();
257 : : CubitVector *coord_list_get_and_step_b();
258 : : CubitVector *coord_list_get_and_back_b();
259 : : //- Used to traverse the coordinates on side B
260 : :
261 : : int coord_list_size_c();
262 : : void coord_list_reset_c();
263 : : void coord_list_last_c();
264 : : CubitVector *coord_list_get_c();
265 : : CubitVector *coord_list_get_and_step_c();
266 : : CubitVector *coord_list_get_and_back_c();
267 : : //- Used to traverse the coordinates on side C
268 : :
269 : : int coord_list_size_d();
270 : : void coord_list_reset_d();
271 : : void coord_list_last_d();
272 : : CubitVector *coord_list_get_d();
273 : : CubitVector *coord_list_get_and_step_d();
274 : : CubitVector *coord_list_get_and_back_d();
275 : : //- Used to traverse the coordinates on side D
276 : :
277 : : int param_list_size_a();
278 : : void param_list_reset_a();
279 : : void param_list_last_a();
280 : : double param_list_get_a();
281 : : double param_list_get_and_step_a();
282 : : double param_list_get_and_back_a();
283 : : //- Used to traverse the parameters on side A
284 : :
285 : : int param_list_size_b();
286 : : void param_list_reset_b();
287 : : void param_list_last_b();
288 : : double param_list_get_b();
289 : : double param_list_get_and_step_b();
290 : : double param_list_get_and_back_b();
291 : : //- Used to traverse the parameters on side B
292 : :
293 : : int param_list_size_c();
294 : : void param_list_reset_c();
295 : : void param_list_last_c();
296 : : double param_list_get_c();
297 : : double param_list_get_and_step_c();
298 : : double param_list_get_and_back_c();
299 : : //- Used to traverse the parameters on side C
300 : :
301 : : int param_list_size_d();
302 : : void param_list_reset_d();
303 : : void param_list_last_d();
304 : : double param_list_get_d();
305 : : double param_list_get_and_step_d();
306 : : double param_list_get_and_back_d();
307 : : //- Used to traverse the parameters on side D
308 : :
309 : : CubitBoolean is_a_collapsed();
310 : : CubitBoolean is_b_collapsed();
311 : : CubitBoolean is_c_collapsed();
312 : : CubitBoolean is_d_collapsed();
313 : : //- Return whether sides are collapsed or not
314 : :
315 : 0 : static int is_split_surface(const ToolData* td)
316 [ # # ][ # # ]: 0 : {return (CAST_TO(td, const TDSplitSurface) != NULL);}
317 : :
318 : : private:
319 : :
320 : : RefFace *refFacePtr;
321 : :
322 : : SSSide *sideA;
323 : : SSSide *sideB;
324 : : SSSide *sideC;
325 : : SSSide *sideD;
326 : :
327 : : // For vertices
328 : : int vertexType;
329 : : };
330 : :
331 : 0 : inline RefFace *TDSplitSurface::ref_face_ptr()
332 : 0 : { return refFacePtr; }
333 : :
334 : 0 : inline int TDSplitSurface::get_type()
335 : 0 : { return vertexType; }
336 : :
337 : 0 : inline double TDSplitSurface::length_a()
338 : 0 : { return sideA->length(); }
339 : 0 : inline double TDSplitSurface::length_b()
340 : 0 : { return sideB->length(); }
341 : 0 : inline double TDSplitSurface::length_c()
342 : 0 : { return sideC->length(); }
343 : 0 : inline double TDSplitSurface::length_d()
344 : 0 : { return sideD->length(); }
345 : :
346 : 0 : inline int TDSplitSurface::coord_list_size_a()
347 : 0 : { return sideA->coord_list_size(); }
348 : 0 : inline void TDSplitSurface::coord_list_reset_a()
349 : 0 : { sideA->coord_list_reset(); }
350 : 0 : inline CubitVector *TDSplitSurface::coord_list_get_and_step_a()
351 : 0 : { return sideA->coord_list_get_and_step(); }
352 : :
353 : 0 : inline int TDSplitSurface::coord_list_size_b()
354 : 0 : { return sideB->coord_list_size(); }
355 : 0 : inline void TDSplitSurface::coord_list_reset_b()
356 : 0 : { sideB->coord_list_reset(); }
357 : 0 : inline CubitVector *TDSplitSurface::coord_list_get_and_step_b()
358 : 0 : { return sideB->coord_list_get_and_step(); }
359 : :
360 : 0 : inline int TDSplitSurface::coord_list_size_c()
361 : 0 : { return sideC->coord_list_size(); }
362 : 0 : inline void TDSplitSurface::coord_list_reset_c()
363 : 0 : { sideC->coord_list_reset(); }
364 : 0 : inline void TDSplitSurface::coord_list_last_c()
365 : 0 : { sideC->coord_list_last(); }
366 : 0 : inline CubitVector *TDSplitSurface::coord_list_get_and_step_c()
367 : 0 : { return sideC->coord_list_get_and_step(); }
368 : 0 : inline CubitVector *TDSplitSurface::coord_list_get_and_back_c()
369 : 0 : { return sideC->coord_list_get_and_back(); }
370 : :
371 : 0 : inline int TDSplitSurface::coord_list_size_d()
372 : 0 : { return sideD->coord_list_size(); }
373 : 0 : inline void TDSplitSurface::coord_list_reset_d()
374 : 0 : { sideD->coord_list_reset(); }
375 : 0 : inline void TDSplitSurface::coord_list_last_d()
376 : 0 : { sideD->coord_list_last(); }
377 : 0 : inline CubitVector *TDSplitSurface::coord_list_get_and_step_d()
378 : 0 : { return sideD->coord_list_get_and_step(); }
379 : 0 : inline CubitVector *TDSplitSurface::coord_list_get_and_back_d()
380 : 0 : { return sideD->coord_list_get_and_back(); }
381 : :
382 : 0 : inline void TDSplitSurface::param_list_reset_a()
383 : 0 : { sideA->param_list_reset(); }
384 : : inline void TDSplitSurface::param_list_last_a()
385 : : { sideA->param_list_last(); }
386 : 0 : inline double TDSplitSurface::param_list_get_and_step_a()
387 : 0 : { return sideA->param_list_get_and_step(); }
388 : :
389 : 0 : inline void TDSplitSurface::param_list_reset_b()
390 : 0 : { sideB->param_list_reset(); }
391 : 0 : inline double TDSplitSurface::param_list_get_and_step_b()
392 : 0 : { return sideB->param_list_get_and_step(); }
393 : :
394 : 0 : inline void TDSplitSurface::param_list_last_c()
395 : 0 : { sideC->param_list_last(); }
396 : 0 : inline double TDSplitSurface::param_list_get_and_back_c()
397 : 0 : { return sideC->param_list_get_and_back(); }
398 : :
399 : 0 : inline void TDSplitSurface::param_list_last_d()
400 : 0 : { sideD->param_list_last(); }
401 : 0 : inline double TDSplitSurface::param_list_get_and_back_d()
402 : 0 : { return sideD->param_list_get_and_back(); }
403 : :
404 : 0 : inline CubitBoolean TDSplitSurface::is_a_collapsed()
405 : 0 : { return sideA->is_collapsed(); }
406 : :
407 : 0 : inline CubitBoolean TDSplitSurface::is_b_collapsed()
408 : 0 : { return sideB->is_collapsed(); }
409 : :
410 : 0 : inline CubitBoolean TDSplitSurface::is_c_collapsed()
411 : 0 : { return sideC->is_collapsed(); }
412 : :
413 : 0 : inline CubitBoolean TDSplitSurface::is_d_collapsed()
414 : 0 : { return sideD->is_collapsed(); }
415 : :
416 : :
417 : : //================================================================================
418 : : // Description: This class holds data on vertices for split across extend
419 : : // Author : Steve Storm
420 : : // Date : 10/7/2007
421 : : //================================================================================
422 : : class CUBIT_GEOM_EXPORT TDSplitSurfaceExtend : public ToolData
423 : : {
424 : : public:
425 : :
426 : : TDSplitSurfaceExtend();
427 : : //- Constructor
428 : :
429 : : ~TDSplitSurfaceExtend();
430 : : //- Destructor
431 : :
432 : : void set_success();
433 : : //- This indicates we successfully extended from this vertex
434 : :
435 : : CubitBoolean is_success();
436 : : //- Did we successfully extend from this vertex?
437 : :
438 : 0 : static int is_split_surface_extend(const ToolData* td)
439 [ # # ][ # # ]: 0 : {return (CAST_TO(td, const TDSplitSurfaceExtend) != NULL);}
440 : :
441 : : private:
442 : :
443 : : CubitBoolean successFlg;
444 : : };
445 : :
446 : : inline void
447 : 0 : TDSplitSurfaceExtend::set_success()
448 : 0 : { successFlg = CUBIT_TRUE; }
449 : :
450 : : inline CubitBoolean
451 : 0 : TDSplitSurfaceExtend::is_success()
452 : 0 : { return successFlg; }
453 : : #endif // TD_SPLIT_SURFACE_HPP
|
