cgma
ImprintBoundaryTool.hpp
Go to the documentation of this file.
00001 //---------------------------------------------------------------------------
00002 //- Class:          ImprintBoundaryTool
00003 //- Description:    Given two surfaces, imprints the boundary loops on each
00004 //-                 other.  Returns the intersection graph.
00005 //-
00006 //- Owner:          David R. White
00007 //- Created:        4/15/2002
00008 //---------------------------------------------------------------------------
00009 #ifndef IMPRINT_BOUNDARY_TOOL_HPP
00010 #define IMPRINT_BOUNDARY_TOOL_HPP
00011 
00012 #include "GeometryDefines.h"
00013 #include "AbstractTree.hpp"
00014 #include "CubitDefines.h"
00015 #include "DLIList.hpp"
00016 class CubitVector;
00017 class RefEntity;
00018 class RefFace;
00019 class RefEdge;
00020 class RefVertex;
00021 class ImprintPointData;
00022 class ImprintLineSegment;
00023 class ImprintMatchData;
00024 template <class Y> class KDDTree;
00025 
00026 template <class X> class DLIList;
00027 typedef DLIList <ImprintPointData*> PointList;
00028 typedef DLIList <PointList*> PointLoopList;
00029 typedef DLIList <ImprintLineSegment*> SegList;
00030 typedef DLIList <SegList*> SegLoopList;
00031 
00032 enum IntersectResult { UNSET_INTERSECT = -1,
00033                        NO_INTERSECT = 0, 
00034                        CROSS_INTERSECT,//Segments intersect like a cross or plus sign, not near end points.
00035                        T_INTERSECT_0, //tells which node intersects of segments {0,1} and {2,3}
00036                        T_INTERSECT_1,
00037                        T_INTERSECT_2,
00038                        T_INTERSECT_3,
00039                        L_INTERSECT_0_2, // Segments intersect like an L or just at one end.
00040                        L_INTERSECT_0_3,// Numbers denote which points of segments intersect of segments {0,1} and {2,3}
00041                        L_INTERSECT_1_2,
00042                        L_INTERSECT_1_3,
00043                        OVERLAP_ALL_0_2_3_1, //One line fits entirely inside the other line.  The number denotes
00044                        OVERLAP_ALL_2_0_1_3, //which line is the super segment of segments {0,1} or {2,3}
00045                        OVERLAP_ALL_2_1_0_3, 
00046                        OVERLAP_ALL_0_3_2_1, 
00047                        OVERLAP_PART_0_3, //Lines overlap, number denote which points are exterior of overlap.
00048                        OVERLAP_PART_0_2,
00049                        OVERLAP_PART_1_2,
00050                        OVERLAP_PART_1_3,
00051                        OVERLAP_JOIN_02_1_3,//Lines overlap, but are joined at one end.
00052                        OVERLAP_JOIN_02_3_1,//First two digits denote nodes that are joined (or ontop of each other)
00053                        OVERLAP_JOIN_03_1_2,//Next digit denotes node on segment.
00054                        OVERLAP_JOIN_03_2_1,//Last digit denotes node at end that is not on anything.
00055                        OVERLAP_JOIN_13_0_2,
00056                        OVERLAP_JOIN_13_2_0,
00057                        OVERLAP_JOIN_12_0_3,
00058                        OVERLAP_JOIN_12_3_0,
00059                        SEGS_EQUAL_0_2, //Linesegments are equal and match according to number.
00060                        SEGS_EQUAL_0_3};
00061 
00062 //  MatchType enum nomen-clature. Match points on segments 1 and 2.
00063 //  But use the prev and next of each one also.  This is
00064 //  for resolve small segments relative to myTolerance.
00065 //     4---prev_seg_1--|0|------seg_1----|1|----next_seg_1---5
00066 //
00067 //     7---next_seg_2--|3|------seg_2----|2|----prev_seg_2---6 
00068 //
00069 // OR
00070 //
00071 //     4---prev_seg_1--|0|------seg_1----|1|----next_seg_1---5
00072 //
00073 //     6---prev_seg_2--|2|------seg_2----|3|----next_seg_2---7
00074 enum MatchType { NO_MATCH,
00075                   MATCH_0_2,
00076                   MATCH_0_3,
00077                   MATCH_0_6,
00078                   MATCH_0_7,
00079                   MATCH_1_2,
00080                   MATCH_1_3,
00081                   MATCH_1_6,
00082                   MATCH_1_7,
00083                   MATCH_2_4,
00084                   MATCH_2_5,
00085                   MATCH_3_4,
00086                   MATCH_3_5,
00087                   ON_SEG_1,
00088                   ON_SEG_2
00089 };
00090 // Enum for returning during a loop.  Continue on, return or get out sucessful or
00091 // report and error.
00092 enum LoopEnum {RETURN_FAILURE, RETURN_SUCCESS, CONTINUE
00093 };
00094 
00095 class ImprintBoundaryTool
00096 {
00097 private:
00098   double myTolerance;
00099   RefFace *refFacePtr1;
00100   RefFace *refFacePtr2;
00101   CubitBoolean modBound1;
00102   CubitBoolean modBound2;
00103   
00104     //- Tolerance used for imprinting and snapping imprints together.
00105   PointList *allocatedPointData;
00106   SegList *allocatedLineData;
00107   PointLoopList *allocatedPointLoops;
00108   SegLoopList *allocatedLineLoops;
00109   DLIList <ImprintMatchData*> *allocatedMatchData;
00110   DLIList <RefEdge*> *allocatedRefEdge;
00111   
00112 
00113   CubitStatus imprint_boundaries(PointLoopList &boundary_loops_1,
00114                                  PointLoopList &boundary_loops_2,
00115                                  RefFace *ref_face_1,
00116                                  RefFace *ref_face_2,
00117                                  DLIList <RefFace*> &results);
00118     //- Intersects the two boundary point loops.  May delete point data or add point data to
00119     //- the loops.
00120 
00121   CubitStatus get_boundary_points( RefFace *ref_face,
00122                                    PointLoopList &boundary_point_loops );
00123     //- Gets the boundary points for the given surface.
00124 
00125   CubitStatus get_curve_facets( RefEdge* curve, PointList& segments );
00126     //- Gets the points that facet this curve.
00127   CubitStatus convert_to_lines( PointLoopList &boundary_point_loops,
00128                                 SegLoopList &boundary_line_loops,
00129                                 RefFace *ref_face,
00130                                 const CubitBoolean boundary_1);
00131   CubitStatus imprint_segments( SegLoopList &boundary_line_loops_1,
00132                                 SegLoopList &boundary_line_loops_2,
00133                                 PointLoopList &boundary_loops_1,
00134                                 PointLoopList &boundary_loops_2);
00135     //- Does the imprinting of the segments through finding the closest
00136     //- segments and closest points to match.  Utilizes the AbstractTree for
00137     //- efficiency. 
00138 
00139   CubitStatus find_matching_points( SegLoopList &seg_loops,
00140                                     AbstractTree <ImprintLineSegment*>& atree );
00141     //- Finds the matching points for a segments with those segments stored
00142     //- in the AbstractTree.  The seg_loops contain the segments for one surface
00143     //- and the AbstractTree contains them for the other surface.
00144   
00145   void set_closest_point(ImprintPointData *imp_point_0);
00146     //- Given the point, and the match data that has been added to it, find
00147     //- the point that is closest, and set that for the point.  This is
00148     //- in preparation to actually setting the matching point...
00149 
00150   CubitStatus find_closest_points(ImprintLineSegment *curr_seg,
00151                                   ImprintLineSegment *test_seg );
00152     //- For the two segments.  Finds the closest points between the
00153     //- segments for curr_seg.  (Doesn't do anything for test_seg.)
00154 
00155   CubitStatus match_seg_points( ImprintLineSegment *seg_1,
00156                                 ImprintLineSegment *seg_2,
00157                                 ImprintMatchData *&point_0_match,
00158                                 ImprintMatchData *&point_1_match );
00159     //- Finds the match information between seg_1 and seg_2.  The
00160     //- ImprintMatchData returned stores how the points for seg_1
00161     //- line up with seg_2 (do they match with points on seg2, do
00162     //- they match along seg_2, do they not match at all...).
00163 
00164   CubitStatus final_match( ImprintLineSegment **surf_1_loop_heads,
00165                            int num_loops_1,
00166                            ImprintLineSegment **surf_2_loop_heads,
00167                            int num_loops_2,
00168                            AbstractTree <ImprintLineSegment*>& atree_1,
00169                            AbstractTree <ImprintLineSegment*>& atree_2);
00170     //- Finally sets the matching point information for both of the loops.
00171     //- Makes sure that if a point matches one boundary with a point
00172     //- on the other boundary, that that point also matches with it.
00173     //- Does this for both surfaces.
00174 
00175   CubitStatus final_match_loop(ImprintLineSegment **surf_1_loop_heads,
00176                                int num_loops_1,
00177                                ImprintLineSegment **surf_2_loop_heads,
00178                                int num_loops_2,
00179                                AbstractTree <ImprintLineSegment*>& atree_1,
00180                                AbstractTree <ImprintLineSegment*>& atree_2);
00181     //- Resolve the matching points for loop_1, with the points in surface 2.
00182     //- If the match is determined to be on a segment, update the AbstractTree by
00183     //- removing split segments and adding the new segments.
00184 
00185   CubitStatus match_on_point(ImprintPointData *start_point,
00186                              ImprintMatchData *start_match,
00187                              ImprintLineSegment **loop_heads,
00188                              int num_loops,
00189                              AbstractTree <ImprintLineSegment*>& atree_2);
00190     //- Match the start_point with the point stored in start match.  Set
00191     //- the matching point data.  This function may call match_on_segment if
00192     //- a point is matched up incorrectly.
00193 
00194   CubitStatus match_on_segment(ImprintPointData *start_point,
00195                                ImprintMatchData *start_match,
00196                                ImprintLineSegment **loop_heads,
00197                                int num_loops,
00198                                AbstractTree <ImprintLineSegment*>& atree_2);
00199     //- Match the start point with the segment stored in startmatch.  Split
00200     //- the segment and update the loops heads and AbstractTree accordingly.
00201 
00202   CubitStatus update_seg_matches(ImprintLineSegment *old_seg,
00203                                  ImprintLineSegment *new_seg_1,
00204                                  ImprintLineSegment *new_seg_2,
00205                                  ImprintMatchData *curr_match_data);
00206     //- As the segments get split, match data points to it.  Update
00207     //- the match data that may point to the old segment to point to
00208     //- the new_seg_1 or new_seg_2.  curr_match_data is not updated
00209     //- since it was already used (passed in to ignore).
00210 
00211   void update_linked_list(ImprintLineSegment *old_seg,
00212                           ImprintLineSegment *new_seg_1,
00213                           ImprintLineSegment *new_seg_2 );
00214     //- With new_seg_1 and new_seg_2 replacing old_seg, add them
00215     //- in the proper places to the segment linked list.
00216 
00217   void just_match_two_points(ImprintPointData *point_1,
00218                              ImprintPointData *point_2 );
00219     //- Does the low level data assignments for matching point_1 and point_2.
00220 
00221   CubitStatus find_crossings(ImprintLineSegment **surf_1_loop_heads,
00222                              int num_loops_1,
00223                              ImprintLineSegment **surf_2_loop_heads,
00224                              int num_loops_2,
00225                              AbstractTree <ImprintLineSegment*>& atree );
00226     //- Finds the crossings (segments that don't having any matching
00227     //- end points, but cross each other.).  Splits the segments that
00228     //- cross and updates the data lists etc.  Uses the atree of surface2.
00229 
00230   CubitStatus do_crossing(  ImprintPointData *imp_point_0,
00231                             ImprintPointData *imp_point_1,
00232                             ImprintPointData *imp_point_2,
00233                             ImprintPointData *imp_point_3,
00234                             ImprintLineSegment *&seg_1,
00235                             ImprintLineSegment *seg_2,
00236                             ImprintLineSegment **surf_1_loop_heads,
00237                             int num_loops_1,
00238                             ImprintLineSegment **surf_2_loop_heads,
00239                             int num_loops_2,
00240                             AbstractTree <ImprintLineSegment*>& atree,
00241                             CubitBoolean &modified);
00242 
00243     //- Computes the intersection of the two segments and does tha actual
00244     //- Crossing data updates.
00245 
00246   void update_boundary_loops( PointLoopList &boundary_loops,
00247                               ImprintLineSegment **surf_loop_heads);
00248     //- Updates the boundary_loops or rather replaces them with the
00249     //- data stored in the line segment linked lists.  Remember all
00250     //- the allocated memory is tracked by the class and deleted for
00251     //- the class so no memory is cleaned at this time.
00252   
00253     CubitStatus intersect_segments( ImprintLineSegment *seg_1,
00254                                   ImprintLineSegment *seg_2,
00255                                   IntersectResult &int_result,
00256                                   ImprintLineSegment **new_segments);
00257     //- Finds the intersection between seg_1 and seg_2.  The possible intersections
00258     //- are enumerated in the IntersectResult enum and the function assigns
00259     //- the appropriate result to int_result.  Also, if the intersection
00260     //- status requires it, the line segments are broken up into the new_segments
00261     //- array.  This array is assumed to be previously allocated and to
00262     //- be of size 4.  The first two positioins in the array are reserved for
00263     //- breaking up segment 1, the last two are for segment two.  They are
00264     //- assumed to be properly ordered (the first positions line segment should
00265     //- have the same start point as seg_1).  There is one exception to this.  In
00266     //- the case of OVERLAP_ALL_*, one line segment fits entirely inside another
00267     //- line segment.  The result is that one line segment gets split into *3* segments
00268     //- while the other is not split at all.  In that case, the new_segments array,
00269     //- will have three entries.  If the first segment is split into three, the new
00270     //- segments will occupy positions 0, 1, and 2. If it is the second, the new segments
00271     //- will occupy positions, 1, 2, and 3.  Again these are also properly ordered.
00272   
00273   void update_list(ImprintLineSegment **new_segments,
00274                    ImprintLineSegment *seg_1,
00275                    ImprintLineSegment *seg_2,
00276                    const CubitBoolean list_1 );
00277     //- utility function to update the linked list structure of the
00278     //- new segments.  List 1 flag tells which list to update.
00279 
00280   CubitStatus determine_on_boundary( ImprintLineSegment *seg_1,
00281                                      ImprintLineSegment *seg_2,
00282                                      MatchType &type_0, MatchType &type_1,
00283                                      MatchType &type_2, MatchType &type_3 );
00284     //- Checks the nodes to find if they are on seg_1 or 2.  They also
00285     //- determine based on the MatchType if the nodes should be matched
00286     //- with the segment or not.
00287   
00288   CubitStatus case_0_2_equal( ImprintLineSegment *seg_1,
00289                               ImprintLineSegment *seg_2,
00290                               ImprintPointData* imp_point_0,
00291                               ImprintPointData* imp_point_1,
00292                               ImprintPointData* imp_point_2,
00293                               ImprintPointData* imp_point_3,
00294                               MatchType type_1, MatchType type_3,
00295                               IntersectResult &int_result,
00296                               ImprintLineSegment **new_segments);
00297     //- This function resolves the intersections cases where points 0 and
00298     //- 2 are known to be equal and the other two nodes are not within tolerance.
00299     //- Basically two types of intersections can be occuring.  Either one of two
00300     //- OVERLAP_JOIN cases or an L_INTERSECT case.
00301   
00302   CubitStatus case_0_3_equal( ImprintLineSegment *seg_1,
00303                               ImprintLineSegment *seg_2,
00304                               ImprintPointData* imp_point_0,
00305                               ImprintPointData* imp_point_1,
00306                               ImprintPointData* imp_point_2,
00307                               ImprintPointData* imp_point_3,
00308                               MatchType type_1, MatchType type_2,
00309                               IntersectResult &int_result,
00310                               ImprintLineSegment **new_segments);
00311     //- This function resolves the intersections cases where points 0 and
00312     //- 2 are known to be equal and the other two nodes are not within tolerance.
00313     //- Basically two types of intersections can be occuring.  Either one of two
00314     //- OVERLAP_JOIN cases or an L_INTERSECT case.
00315   
00316   CubitStatus case_1_2_equal( ImprintLineSegment *seg_1,
00317                               ImprintLineSegment *seg_2,
00318                               ImprintPointData* imp_point_0,
00319                               ImprintPointData* imp_point_1,
00320                               ImprintPointData* imp_point_2,
00321                               ImprintPointData* imp_point_3,
00322                               MatchType type_0, MatchType type_3,
00323                               IntersectResult &int_result,
00324                               ImprintLineSegment **new_segments);
00325     //- This function resolves the intersections cases where points 0 and
00326     //- 2 are known to be equal and the other two nodes are not within tolerance.
00327     //- Basically two types of intersections can be occuring.  Either one of two
00328     //- OVERLAP_JOIN cases or an L_INTERSECT case.
00329 
00330   CubitStatus case_1_3_equal( ImprintLineSegment *seg_1,
00331                               ImprintLineSegment *seg_2,
00332                               ImprintPointData* imp_point_0,
00333                               ImprintPointData* imp_point_1,
00334                               ImprintPointData* imp_point_2,
00335                               ImprintPointData* imp_point_3,
00336                               MatchType type_0, MatchType type_2,
00337                               IntersectResult &int_result,
00338                               ImprintLineSegment **new_segments);
00339     //- This function resolves the intersections cases where points 0 and
00340     //- 2 are known to be equal and the other two nodes are not within tolerance.
00341     //- Basically two types of intersections can be occuring.  Either one of two
00342     //- OVERLAP_JOIN cases or an L_INTERSECT case.
00343 
00344   CubitStatus set_type_for_equal(ImprintPointData *pair_1_1,
00345                                  ImprintPointData *pair_1_2,
00346                                  ImprintPointData *pair_2_1,
00347                                  ImprintPointData *pair_2_2);
00348     //- Given the two pairs of points that are equal on the
00349     //- respective boundaries (_1_1 is pair 1, point on boundary 1,
00350     //- _1_2 is pair 1, point on boundary 2, _2_1 is pair 2, point
00351     //- on boundary 2, etc...), set up the correct PointTypes for
00352     //- the nodes for the EQUAL case.
00353 
00354   CubitStatus set_type_for_L(ImprintPointData *imp_point_1,
00355                              ImprintPointData *imp_point_2);
00356     //- Given point_1 on boundary 1 and point_2 on boundary 2, set
00357     //- the correct point type for each point given the two points
00358     //- meet at an L condition.
00359   
00360   CubitBoolean on_interior_segment(ImprintPointData *point,
00361                           ImprintLineSegment *line );
00362     //- Determines if the point is within myTolerance of the line segment.
00363 
00364   CubitStatus closest_point_seg( ImprintPointData *point,
00365                                  ImprintLineSegment *line,
00366                                  CubitVector &closest_point );
00367     //- Finds the closest point to the line segment.
00368 
00369   CubitStatus closest_point_seg( CubitVector &point_v,
00370                                  ImprintLineSegment *line,
00371                                  CubitVector &closest_point );
00372     //- Finds the closest point to the line segment.
00373   CubitBoolean closest_point_interior_seg( ImprintPointData *point,
00374                                            ImprintLineSegment *line,
00375                                            CubitVector &closest_point );
00376     //- Finds the closest point to the line segment.
00377 
00378   CubitStatus find_graph_for_surf(PointLoopList &boundary_loops_1,
00379                                   PointLoopList &boundary_loops_2,
00380                                   RefFace *ref_face,
00381                                   PointLoopList &part_segs,
00382                                   PointList &partition_points,
00383                                   CubitBoolean surf_1);
00384     //-Given the boundary_line_loops for a surface
00385     //-that have already been intersected against another
00386     //-surface, and the boundary_line_loops for that surface,
00387     //-determine the line segments that are needed
00388     //-to perform the actual imprint.  Also find points
00389     //-That are need to partition or imprint the existing boundaries.
00390     //-These points will also include the points of the segments
00391     //-that touch against the boundary, if necessary.  The
00392     //-RefFace is pretty important as it is used to determine
00393     //-if the points are inside or outside the surface.
00394   
00395   CubitStatus point_intersects_case( ImprintPointData *curr_point,
00396                                      ImprintPointData *next_point,
00397                                      RefFace *ref_face,
00398                                      PointLoopList &part_segs,
00399                                      PointList *&new_part_line,
00400                                      CubitBoolean &start_recording,
00401                                      CubitBoolean surf_1 );
00402     //-Given the fact that curr_point's PointType shows
00403     //-that it is a vertex on both boundaries or a new vertex,
00404     //-Resolve how the partition curves are extraced from the
00405     //-boundary loop 2 on surface 1.
00406 
00407   CubitBoolean on_surface( ImprintPointData *point,
00408                            RefFace *ref_face );
00409     //-Determines through the find_closest_point_trimmed
00410     //-function if a point is inside or outside a surface.
00411     //-This is not a very efficient method but since the
00412     //-surface can be non-planar, we can't do a simple test.
00413 
00414   CubitBoolean on_surface( CubitVector &vert_point,
00415                            RefFace *ref_face );
00416     //-Determines through the find_closest_point_trimmed
00417     //-function if a point is inside or outside a surface.
00418     //-This is not a very efficient method but since the
00419     //-surface can be non-planar, we can't do a simple test.
00420 
00421   CubitBoolean on_curve( ImprintPointData *point,
00422                          RefEdge *ref_edge );
00423 
00424     //- Determine if the point is within tolerance of the ref_edge.
00425   
00426   CubitBoolean are_connected( RefEntity *ent_1,
00427                               RefEntity *ent_2,
00428                               RefFace *ref_face );
00429     //-Determines through topology traversals
00430     //-if the two refentities are directly
00431     //-connected.  The function assumes
00432     //-that the RefEntities are either RefVerticies or
00433     //-RefEdges.  The entites must be connected within
00434     //-one entity for vertices or the same for
00435     //-curves...
00436 
00437   CubitStatus imprint_boundary_vertices( PointList &partition_points,
00438                                          CubitBoolean &modified_boundary );
00439     //-Given the data in the partition_points, partition the curves that the data points
00440     //-point to as their owner's.  Reasign owners as RefVertices.
00441   
00442   CubitStatus imprint_surface(RefFace *ref_face,
00443                               PointLoopList &part_segs,
00444                               DLIList <RefFace*> &results);
00445     //- Given the sorted partition segments, create refedges, then partition the
00446     //- surface.  Also merge appropriate vertices.  Relies on owner data, and matching
00447     //- data in the ImprintPointData class.
00448 
00449   CubitBoolean valid_partition(DLIList <RefEdge*> &ref_edges, RefFace *ref_face );
00450     //- Tests to see if the ref_edges are a valid parition, are there hard lines or unmerged
00451     //- lines in the lists of ref_edges.
00452 
00453   CubitStatus merge_vertices(DLIList <RefVertex*> &ref_verts);
00454     //- Do the normal merging but use myTolerance as the merge tolerance.
00455   
00456   CubitStatus merge_vertices(RefVertex *ref_vertex1,
00457                              RefVertex *ref_vertex2,
00458                              CubitBoolean &kept_1);
00459     //- Merge the two vertices.  Do a force for speed.
00460     //- Assigns kept_1 if ref_vertex1 is the vertex that survives the
00461     //- merge.
00462 
00463   CubitStatus resolve_on_boundaries( PointLoopList &boundary_loops_1,
00464                                      PointLoopList &boundary_loops_2);
00465   
00466   CubitBoolean resolve_match_conflict_this(ImprintPointData *this_point,
00467                                            ImprintPointData *other,
00468                                            CubitBoolean this_is_1 );
00469   CubitBoolean resolve_match_conflict_other(ImprintPointData *this_point,
00470                                            ImprintPointData *other,
00471                                            CubitBoolean this_is_1 );
00472   CubitStatus match_points( ImprintLineSegment *seg_1,
00473                             ImprintLineSegment *seg_2,
00474                             MatchType &type_0,
00475                             MatchType &type_1,
00476                             MatchType &type_2,
00477                             MatchType &type_3);
00478     //Computes how the end points between the segments match.  If
00479     //The segments are small, points may match with previous or next nodes
00480     //along the boundary and are indicated by the MatchType.
00481   
00482   void draw_seg(ImprintLineSegment *seg, int color = -1);
00483     //- draws the end node colored according to it's point type.
00484   void draw_point(ImprintPointData *imp_point, int color = -1);
00485     //- draws the end node colored according to it's point type.
00486   void draw_end(ImprintLineSegment *seg);
00487     //- draws the end node colored according to it's point type.
00488   void draw_loops(PointLoopList &boundary_loop);
00489     //- draws the loops of nodes.
00490 
00491   int num_coedges_on_face(RefEdge *edge_ptr,
00492                           RefFace *ref_face);
00493     //- Counts number of coedges this edge_ptr has that are also part of
00494     //- just this refface.
00495   
00496 
00497   CubitStatus ignore_match( ImprintPointData *start_point,
00498                             ImprintMatchData *start_match,
00499                             AbstractTree <ImprintLineSegment*>& atree_1,
00500                             CubitBoolean &ignore);
00505 
00506   RefEdge* create_virtual_edge(RefVertex *start,
00507                                RefVertex *end,
00508                                DLIList<CubitVector*> &interior_points);
00509   RefVertex* create_virtual_vertex(CubitVector &pos);
00510   
00511 
00512 
00513   
00514 public:
00515   ImprintBoundaryTool(RefFace *ref_face_1,
00516                       RefFace *ref_face_2,
00517                       double tol = GEOMETRY_RESABS);
00518   ~ImprintBoundaryTool();
00519   CubitBoolean modified_bound_1()
00520     {return modBound1;}
00521   CubitBoolean modified_bound_2()
00522     {return modBound2;}
00523       
00524   CubitStatus imprint(DLIList <RefFace*> &results,
00525                       CubitBoolean merge = CUBIT_FALSE);
00526     //- Main interface function for imprinting the boundary loops
00527     //- of two refFaces.  It is assumed that if the reffaces intersect
00528     //- at any where else other than the boundary loops, this will
00529     //- not be found.
00530   
00531   
00532 };
00533 
00534 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines