0032140: Modeling Algorithms - unify same domain calls crossed for opposite vectors
[occt.git] / src / ShapeUpgrade / ShapeUpgrade_UnifySameDomain.hxx
1 // Copyright: Open CASCADE 2014
2 // Created on: 2012-06-09
3 // Created by: jgv@ROLEX
4 // Copyright (c) 2012-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #ifndef _ShapeUpgrade_UnifySameDomain_HeaderFile
18 #define _ShapeUpgrade_UnifySameDomain_HeaderFile
19
20 #include <BRepTools_History.hxx>
21 #include <Standard.hxx>
22 #include <Standard_Type.hxx>
23
24 #include <TopoDS_Shape.hxx>
25 #include <Standard_Boolean.hxx>
26 #include <Standard_Transient.hxx>
27 #include <TopTools_DataMapOfShapeShape.hxx>
28 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
29 #include <TopTools_MapOfShape.hxx>
30 #include <TopTools_SequenceOfShape.hxx>
31 #include <Geom_Plane.hxx>
32 #include <Precision.hxx>
33 class ShapeBuild_ReShape;
34 class TopoDS_Shape;
35
36
37 class ShapeUpgrade_UnifySameDomain;
38 DEFINE_STANDARD_HANDLE(ShapeUpgrade_UnifySameDomain, Standard_Transient)
39
40 //! This tool tries to unify faces and edges of the shape which lie on the same geometry.
41 //! Faces/edges are considering as 'same-domain' if a group of neighbouring faces/edges
42 //! are lying on coincident surfaces/curves.
43 //! In this case these faces/edges can be unified into one face/edge.
44 //! ShapeUpgrade_UnifySameDomain is initialized by a shape and the next optional parameters:
45 //! UnifyFaces - tries to unify all possible faces
46 //! UnifyEdges - tries to unify all possible edges
47 //! ConcatBSplines - if this flag is set to true then all neighbouring edges, which lay
48 //! on BSpline or Bezier curves with C1 continuity on their common vertices,
49 //! will be merged into one common edge.
50 //!
51 //! The input shape can be of any type containing faces or edges - compsolid, solid, shell, 
52 //! wire, compound of any kind of shapes. The algorithm preserves the structure of compsolids,
53 //! solids, shells and wires. E.g., if two shells have a common edge and the faces sharing
54 //! this edge lie on the same surface the algorithm will not unify these faces, otherwise 
55 //! the structure of shells would be broken. However, if such faces belong to different
56 //! compounds of faces they will be unified.
57 //! 
58 //! The output result of the tool is the unified shape.
59 //!
60 //! All the modifications of initial shape are recorded during unifying.
61 //! Methods History are intended to: <br>
62 //! - set a place holder for the history of modifications of sub-shapes of
63 //!   the initial shape; <br>
64 //! - get the collected history. <br>
65 //! The algorithm provides a place holder for the history and collects the
66 //! history by default.
67 //! To avoid collecting of the history the place holder should be set to null handle.
68
69 struct SubSequenceOfEdges
70 {
71   TopTools_SequenceOfShape SeqsEdges;
72   TopoDS_Edge UnionEdges;
73 };
74
75 class ShapeUpgrade_UnifySameDomain : public Standard_Transient
76 {
77
78 public:
79
80   typedef NCollection_DataMap<TopoDS_Shape, Handle(Geom_Plane), TopTools_ShapeMapHasher> DataMapOfFacePlane;
81   
82   //! Empty constructor
83   Standard_EXPORT ShapeUpgrade_UnifySameDomain();
84   
85   //! Constructor defining input shape and necessary flags.
86   //! It does not perform unification.
87   Standard_EXPORT ShapeUpgrade_UnifySameDomain
88                    (const TopoDS_Shape& aShape, 
89                     const Standard_Boolean UnifyEdges = Standard_True,
90                     const Standard_Boolean UnifyFaces = Standard_True,
91                     const Standard_Boolean ConcatBSplines = Standard_False);
92   
93   //! Initializes with a shape and necessary flags.
94   //! It does not perform unification.
95   //! If you intend to nullify the History place holder do it after
96   //! initialization.
97   Standard_EXPORT void Initialize
98                    (const TopoDS_Shape& aShape,
99                     const Standard_Boolean UnifyEdges = Standard_True,
100                     const Standard_Boolean UnifyFaces = Standard_True,
101                     const Standard_Boolean ConcatBSplines = Standard_False);
102   
103   //! Sets the flag defining whether it is allowed to create
104   //! internal edges inside merged faces in the case of non-manifold
105   //! topology. Without this flag merging through multi connected edge
106   //! is forbidden. Default value is false.
107   Standard_EXPORT void AllowInternalEdges (const Standard_Boolean theValue);
108
109   //! Sets the shape for avoid merging of the faces/edges.
110   //! This shape can be vertex or edge.
111   //! If the shape is a vertex it forbids merging of connected edges.
112   //! If the shape is a edge it forbids merging of connected faces.
113   //! This method can be called several times to keep several shapes.
114   Standard_EXPORT void KeepShape(const TopoDS_Shape& theShape);
115
116   //! Sets the map of shapes for avoid merging of the faces/edges.
117   //! It allows passing a ready to use map instead of calling many times
118   //! the method KeepShape.
119   Standard_EXPORT void KeepShapes(const TopTools_MapOfShape& theShapes);
120
121   //! Sets the flag defining the behavior of the algorithm regarding 
122   //! modification of input shape.
123   //! If this flag is equal to True then the input (original) shape can't be
124   //! modified during modification process. Default value is true.
125   Standard_EXPORT void SetSafeInputMode(Standard_Boolean theValue);
126
127   //! Sets the linear tolerance. It plays the role of chord error when
128   //! taking decision about merging of shapes. Default value is Precision::Confusion().
129   void SetLinearTolerance(const Standard_Real theValue)
130   {
131     myLinTol = theValue;
132   }
133
134   //! Sets the angular tolerance. If two shapes form a connection angle greater than 
135   //! this value they will not be merged. Default value is Precision::Angular().
136   void SetAngularTolerance(const Standard_Real theValue)
137   {
138     myAngTol = (theValue < Precision::Angular() ? Precision::Angular() : theValue);
139   }
140
141   //! Performs unification and builds the resulting shape.
142   Standard_EXPORT void Build();
143   
144   //! Gives the resulting shape
145   const TopoDS_Shape& Shape() const
146   {
147     return myShape;
148   }
149
150   //! Returns the history of the processed shapes.
151   const Handle(BRepTools_History)& History() const
152   {
153     return myHistory;
154   }
155
156   //! Returns the history of the processed shapes.
157   Handle(BRepTools_History)& History()
158   {
159     return myHistory;
160   }
161
162   DEFINE_STANDARD_RTTIEXT(ShapeUpgrade_UnifySameDomain,Standard_Transient)
163
164 protected:
165
166   //! This method makes if possible a common face from each
167   //! group of faces lying on coincident surfaces
168   Standard_EXPORT void UnifyFaces();
169
170   //! This method makes if possible a common edge from each
171   //! group of smothly connected edges, which are common for the same couple of faces
172   Standard_EXPORT void UnifyEdges();
173
174   void IntUnifyFaces(const TopoDS_Shape& theInpShape,
175                      TopTools_IndexedDataMapOfShapeListOfShape& theGMapEdgeFaces);
176
177   //! Splits the sequence of edges into the sequence of chains
178   Standard_Boolean MergeEdges(TopTools_SequenceOfShape& SeqEdges,
179                               const TopTools_IndexedDataMapOfShapeListOfShape& theVFmap,
180                               NCollection_Sequence<SubSequenceOfEdges>& SeqOfSubSeqOfEdges,
181                               const TopTools_MapOfShape& NonMergVrt);
182
183   //! Tries to unify the sequence of edges with the set of
184   //! another edges which lies on the same geometry
185   Standard_Boolean MergeSeq(TopTools_SequenceOfShape& SeqEdges,
186                             const TopTools_IndexedDataMapOfShapeListOfShape& theVFmap,
187                             const TopTools_MapOfShape& nonMergVert);
188
189   //! Merges a sequence of edges into one edge if possible
190   Standard_Boolean MergeSubSeq(const TopTools_SequenceOfShape& theChain,
191                                const TopTools_IndexedDataMapOfShapeListOfShape& theVFmap,
192                                TopoDS_Edge& OutEdge);
193
194   //! Unifies the pcurve of the chain into one pcurve of the edge
195   void UnionPCurves(const TopTools_SequenceOfShape& theChain,
196                     TopoDS_Edge& theEdge);
197
198   //! Fills the history of the modifications during the operation.
199   Standard_EXPORT void FillHistory();
200
201 private:
202
203   TopoDS_Shape myInitShape;
204   Standard_Real myLinTol;
205   Standard_Real myAngTol;
206   Standard_Boolean myUnifyFaces;
207   Standard_Boolean myUnifyEdges;
208   Standard_Boolean myConcatBSplines;
209   Standard_Boolean myAllowInternal;
210   Standard_Boolean mySafeInputMode;
211   TopoDS_Shape myShape;
212   Handle(ShapeBuild_ReShape) myContext;
213   TopTools_MapOfShape myKeepShapes;
214   DataMapOfFacePlane myFacePlaneMap;
215   TopTools_IndexedDataMapOfShapeListOfShape myEFmap;
216   TopTools_DataMapOfShapeShape myFaceNewFace;
217
218   Handle(BRepTools_History) myHistory; //!< The history.
219 };
220
221 #endif // _ShapeUpgrade_UnifySameDomain_HeaderFile