b4ea8d5e0c481601d95c5f335d83c2ed9508c22e
[occt.git] / dox / user_guides / shape_healing / shape_healing.md
1 Shape Healing  {#occt_user_guides__shape_healing}
2 ===================
3
4 @tableofcontents
5
6 @section occt_shg_1 Overview
7
8 @subsection occt_shg_1_1 Introduction
9
10 This manual explains how to use Shape Healing. It provides basic documentation on its operation. For advanced information on Shape Healing and its applications, see our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings. 
11
12 The **Shape Healing** toolkit provides a set of tools to work on the geometry and topology of Open CASCADE Technology (**OCCT**) shapes. Shape Healing adapts shapes so as to make them as appropriate for use by Open CASCADE Technology as possible. 
13
14 @subsection occt_shg_1_2 Examples of use
15
16 Here are a few examples of typical problems with illustrations of how Shape Healing deals with them:
17
18 #### Face with missing seam edge
19
20 The problem: Face on a periodical surface is limited by wires which make a full trip around the surface. These wires are closed in 3d but not closed in parametric space of the surface. This is not valid in Open CASCADE.
21 The solution: Shape Healing fixes this face by inserting seam edge which combines two open wires and thus closes the parametric space. Note that internal wires are processed correctly.
22
23 #### Wrong orientation of wires
24 The problem: Wires on face have incorrect orientation, so that interior and outer parts of the face are mixed.
25 The solution: Shape Healing recovers correct orientation of wires.
26
27 #### Self-intersecting wire
28 The problem: Face is invalid because its boundary wire has self-intersection (on two adjacent edges)
29 The solution: Shape Healing cuts intersecting edges at intersection points thus making boundary valid.
30
31 #### Lacking edge
32 The problem: There is a gap between two edges in the wire, so that wire is not closed
33 The solution: Shape Healing closes a gap by inserting lacking edge.
34
35 @subsection occt_shg_1_3 Toolkit Structure
36
37 **Shape Healing** currently includes several packages that are designed to help you to: 
38   *  analyze shape characteristics and, in particular, identify shapes that do not comply with Open CASCADE Technology validity rules 
39   *  fix some of the problems shapes may have 
40   *  upgrade shape characteristics for users needs, for example a C0 supporting surface can be upgraded so that it becomes C1 continuous. 
41   
42 The following diagram shows dependencies of API packages: 
43
44 @figure{/user_guides/shape_healing/images/shape_healing_image009.svg, "Shape Healing packages"}
45
46 Each sub-domain has its own scope of functionality: 
47 * analysis - exploring shape properties, computing shape features, detecting violation of OCCT requirements (shape itself is not modified);
48 * fixing - fixing shape to meet the OCCT requirements (the shape may change its original form: modifying, removing, constructing sub-shapes, etc.); 
49 * upgrade - shape improvement for better usability in Open CASCADE Technology or other algorithms (the shape is replaced with a new one, but geometrically they are the same); 
50 * customization - modifying shape representation to fit specific needs (shape is not modified, only the form of its representation is modified); 
51 * processing  - mechanism of managing shape modification via a user-editable resource file. 
52
53 Message management is used for creating messages, filling them with various parameters and storing them in the trace file. This tool provides functionality for attaching messages to the shapes for deferred analysis of various run-time events. In this document only general principles of using Shape Healing will be described. For more detailed information please see the corresponding CDL files. 
54
55 Tools responsible for analysis, fixing and upgrading of shapes can give the information about how these operations were performed. This information can be obtained by the user with the help of mechanism of status querying. 
56
57 @subsection occt_shg_1_4 Querying the statuses
58
59 Each fixing and upgrading tool has its own status, which is reset when their methods are called. The status can contain several flags, which give the information about how the method was performed. For exploring the statuses, a set of methods named *Status...()* is provided. These methods accept enumeration *ShapeExtend_Status* and return True if the status has the corresponding flag set. The meaning of flags for each method is described below. 
60
61 The status may contain a set of Boolean flags (internally represented by bits). Flags are coded by enumeration ShapeExtend_Status. This enumeration provides the following families of statuses: 
62 * *ShapeExtend_OK*  -  The situation is OK, no operation is necessary and has not been performed. 
63 * *ShapeExtend_DONE* - The operation has been successfully performed. 
64 * *ShapeExtend_FAIL* - An error has occurred during operation. 
65
66 It is possible to test the status for the presence of some flag(s), using Status...() method(s) provided by the class: 
67
68 ~~~~~
69 if ( object.Status.. ( ShapeExtend_DONE ) ) {// something was done 
70
71 ~~~~~
72
73 8 'DONE' and 8 'FAIL' flags, named ShapeExtend_DONE1 ... ShapeExtend_FAIL8, are defined for a detailed analysis of the encountered situation. Each method assigns its own meaning to each flag, documented in the CDL for that method. There are also three enumerative values used for testing several flags at a time: 
74 * *ShapeExtend_OK*   -     if no flags have been set; 
75 * *ShapeExtend_DONE* - if at least one ShapeExtend_DONEi has been set; 
76 * *ShapeExtend_FAIL* - if at least one ShapeExtend_FAILi has been set. 
77
78 @section occt_shg_2 Repair
79
80 Algorithms for fixing problematic (violating the OCCT requirements) shapes are placed in package *ShapeFix*. 
81
82 Each class of package *ShapeFix* deals with one certain type of shapes or with some family of problems. 
83
84 There is no necessity for you to detect problems before using *ShapeFix* because all components of package *ShapeFix* make an analysis of existing problems before fixing them by a corresponding tool from package of *ShapeAnalysis* and then fix the discovered problems. 
85
86 The *ShapeFix* package currently includes functions that: 
87   * add a 2D curve or a 3D curve where one is missing,
88   * correct a deviation of a 2D curve from a 3D curve when it exceeds a given tolerance value,
89   * limit the tolerance value of shapes within a given range,
90   * set a given tolerance value for shapes,
91   * repair the connections between adjacent edges of a wire,
92   * correct self–intersecting wires,
93   * add seam edges,
94   * correct gaps between 3D and 2D curves,
95   * merge and remove small edges,
96   * correct orientation of shells and solids.
97
98 @subsection occt_shg_2_1 Basic Shape Repair
99
100 The simplest way for fixing shapes is to use classes *ShapeFix_Shape* and *ShapeFix_Wireframe* on a whole shape with default parameters. A combination of these tools can fix most of the problems that shapes may have. 
101 The sequence of actions is as follows : 
102
103 1. Create tool *ShapeFix_Shape* and initialize it by shape: 
104    
105        Handle(ShapeFix_Shape) sfs = new ShapeFix_Shape; 
106        sfs->Init ( shape ); 
107
108 2. Set the basic precision, the maximum allowed tolerance, the minimal allowed tolerance:
109
110         sfs->SetPrecision ( Prec ); 
111         sfs->SetMaxTolerance ( maxTol ); 
112         sfs->SetMinTolerance ( mintol );
113
114    where *Prec* – basic precision,  *maxTol* – maximum allowed tolerance, *minTol* – minimal allowed tolerance.
115    * *maxTol* - All problems will be detected for cases when a dimension of invalidity is larger than the basic precision or a tolerance of sub-shape on that problem is detected.
116                 The maximum tolerance value limits the increasing tolerance for fixing a problem such as fix of not connenected and self-intersected wires. If a value larger than the maximum allowed tolerance is necessary for correcting a detected problem the problem can not be fixed.
117                 The maximal tolerance is not taking into account during computation of tolerance of edges in ShapeFix_SameParameter() method and  ShapeFix_Edge::FixVertexTolerance() method.
118                 See @ref occt_shg_2_3_8 for details.
119    * *minTol* - The minimal allowed tolerance defines minimal allowed length of edges. Detected edges having length less than specified minimal tolerance will be removed if ModifyTopologyMode in Repairing tool for wires is set to true.
120                 See @ref occt_shg_2_3_7 for details.
121
122 3. Launch fixing:
123
124         sfs->Perform(); 
125
126 4. Get the result:
127
128         TopoDS_Shape aResult = sfs->Shape(); 
129
130    In some cases using  only *ShapeFix_Shape* can be insufficient. It is possible to use tools for merging and removing small edges and fixing gaps between 2D and 3D curves.
131
132 5. Create *ShapeFix_Wireframe* tool and initialize it by shape:
133 ~~~~~
134 Handle(ShapeFix_Wirefarme) SFWF = new ShapeFix_Wirefarme(shape); 
135 Or 
136 Handle(ShapeFix_Wirefarme) SFWF = new ShapeFix_Wirefarme; 
137 SFWF->Load(shape); 
138 ~~~~~
139 6. Set the basic precision and the maximum allowed tolerance:
140 ~~~~~
141 sfs->SetPrecision ( Prec ); 
142 sfs->SetMaxTolerance ( maxTol ); 
143 ~~~~~
144 See the description for *Prec* and *maxTol* above. 
145 7. Merge and remove small edges:
146 ~~~~~
147 SFWF->DropSmallEdgesMode() = Standard_True; 
148 SFWF->FixSmallEdges(); 
149 ~~~~~
150 **Note:** Small edges are not removed with the default mode, but in many cases removing small edges is very useful for fixing a shape. 
151 8. Fix gaps for 2D and 3D curves
152 ~~~~~
153 SFWF->FixWireGaps(); 
154 ~~~~~
155 9. Get the result
156 ~~~~~
157 TopoDS_Shape Result = SFWF->Shape(); 
158 ~~~~~
159
160
161 @subsection occt_shg_2_2 Shape Correction.
162
163 If you do not want to make fixes on the whole shape or make a definite set of fixes you can set flags for separate fix cases (marking them ON or OFF) and you can also use classes for fixing specific types of sub-shapes such as solids, shells, faces, wires, etc.  
164
165 For each type of sub-shapes there are specific types of fixing tools such as *ShapeFix_Solid, ShapeFix_Shell, ShapeFix_Face, ShapeFix_Wire,* etc.
166
167 @subsubsection occt_shg_2_2_1 Fixing sub-shapes
168 If you want to make a fix on one subshape of a certain shape it is possible to take the following steps: 
169   * create a tool for a specified subshape type and initialize this tool by the subshape;
170   * create a tool for rebuilding the shape and initialize it by the whole shape (section 5.1);
171   * set a tool for rebuilding the shape in the tool for fixing the subshape;
172   * fix the subshape;
173   * get the resulting whole shape containing a new corrected subshape.
174
175 For example, in the following way it is possible to fix face *Face1* of shape *Shape1*: 
176
177 ~~~~~
178 //create tools for fixing a face 
179 Handle(ShapeFix_Face)  SFF= new ShapeFix_Face; 
180
181 // create tool for rebuilding a shape and initialize it by shape 
182 Handle(ShapeBuild_ReShape) Context = new ShapeBuild_ReShape;  
183 Context->Apply(Shape1); 
184
185 //set a tool for rebuilding a shape in the tool for fixing 
186 SFF->SetContext(Context); 
187         
188 //initialize the fixing tool by one face 
189 SFF->Init(Face1); 
190
191 //fix the set face 
192 SFF->Perform(); 
193         
194 //get the result 
195 TopoDS_Shape  NewShape = Context->Apply(Shape1); 
196 //Resulting shape contains the fixed face. 
197 ~~~~~
198
199 A set of required fixes and invalid sub-shapes can be obtained with the help of tools responsible for the analysis of shape validity (section 3.2). 
200
201 @subsection occt_shg_2_3 Repairing tools
202
203 Each class of package ShapeFix deals with one certain type of shapes or with a family of problems. Each repairing tool makes fixes for the specified shape and its sub-shapes with the help of method *Perform()* containing an optimal set of fixes. The execution of these fixes in the method Perform can be managed with  help of a set of control flags (fixes can be either forced or forbidden). 
204
205 @subsubsection occt_shg_2_3_1 General Workflow 
206
207 The following sequence of actions should be applied to perform fixes:
208 1. Create a tool. 
209 2. Set the following values: 
210         + the working precision by method  *SetPrecision()* (default 1.e-7) 
211         + set the maximum allowed tolerance by method *SetMaxTolerance()* (by default it is equal to the working precision). 
212         + set the minimum tolerance by method *SetMinTolerance()* (by default it is equal to the working precision). 
213         + set a tool for rebuilding shapes after the modification (tool *ShapeBuild_ReShape*) by method *SetContext()*. For separate faces, wires and edges this tool is set optionally. 
214         + to force or forbid some of fixes, set the corresponding flag to 0 or 1. 
215 3. Initialize the tool by the shape with the help of methods Init or Load
216 4. Use method *Perform()* or create a custom set of fixes. 
217 5. Check the statuses of fixes by the general method *Status* or specialized methods *Status_*(for example *StatusSelfIntersection* (*ShapeExtentd_DONE*)). See the description of statuses below. 
218 6. Get the result in two ways : 
219         - with help of a special method *Shape(),Face(),Wire().Edge()*. 
220         - from the rebuilding tool by method *Apply* (for access to rebuilding tool use method *Context()*): 
221 ~~~~~
222         TopoDS_Shape resultShape = fixtool->Context()->Apply(initialShape); 
223 ~~~~~
224 Modification fistory for the shape and its sub-shapes can be obtained from the tool for shape re-building (*ShapeBuild_ReShape*). 
225
226 ~~~~~
227 TopoDS_Shape modifsubshape = fixtool->Context() -> Apply(initsubshape); 
228 ~~~~~
229
230  
231 @subsubsection occt_shg_2_3_2 Flags Management
232  
233 The flags *Fix...Mode()* are used to control the execution of fixing procedures from the API fixing methods. By default, these flags have values equal to -1, this means that the corresponding procedure will either be called or not called, depending on the situation. If the flag is set to 1, the procedure is executed anyway; if the flag is 0, the procedure is not executed. The name of the flag corresponds to the fixing procedure that is controlled. For each fixing tool there exists its own set of flags. To set a flag to the desired value, get a tool containing this flag and set the flag to the required value. 
234
235 For example, it is possible to forbid performing fixes to remove small edges - *FixSmall* 
236
237 ~~~~~
238 Handle(ShapeFix_Shape) Sfs = new ShapeFix_Shape(shape); 
239 Sfs-> FixWireTool ()->FixSmallMode () =0; 
240 if(Sfs->Perform()) 
241         TopoDS_Shape resShape = Sfs->Shape(); 
242 ~~~~~
243
244
245 @subsubsection occt_shg_2_3_3 Repairing tool for shapes
246
247 Class *ShapeFix_Shape* allows using repairing tools for all sub-shapes of a shape. It provides access to all repairing tools for fixing sub-shapes of the specified shape and to all control flags from these tools.
248
249 For example, it is possible to force the removal of invalid 2D curves from a face. 
250
251 ~~~~~
252 TopoDS_Face face … // face with invalid 2D curves. 
253 //creation of tool and its initialization by shape. 
254 Handle(ShapeFix_Shape) sfs = new ShapeFix_Shape(face); 
255 //set work precision and max allowed tolerance. 
256 sfs->SetPrecision(prec); 
257 sfs->SetMaxTolerance(maxTol); 
258 //set the value of flag for forcing the removal of 2D curves 
259 sfs->FixWireTool()->FixRemovePCurveMode() =1; 
260 //reform fixes 
261 sfs->Perform(); 
262 //getting the result 
263 if(sfs->Status(ShapeExtend_DONE) ) { 
264  cout << "Shape was fixed" << endl; 
265  TopoDS_Shape resFace = sfs->Shape(); 
266
267 else if(sfs->Status(ShapeExtend_FAIL)) { 
268 cout<< "Shape could not be fixed" << endl; 
269
270 else if(sfs->Status(ShapeExtent_OK)) { 
271 cout<< "Initial face is valid with specified precision ="<< precendl; 
272
273 ~~~~~
274
275 @subsubsection occt_shg_2_3_4 Repairing tool for solids
276
277 Class *ShapeFix_Solid* allows fixing solids and building a solid from a shell to obtain a valid solid with a finite volume. The tool *ShapeFix_Shell* is used for correction of shells belonging to a solid. 
278
279 This tool has the following control flags:
280 * *FixShellMode* - Mode for applying fixes of ShapeFix_Shell, True by default. 
281 * *CreateOpenShellMode* - If it is equal to true solids are created from open shells, else solids are created from closed shells only, False by default. 
282
283 @subsubsection occt_shg_2_3_5 Repairing tool for shells 
284 Class *ShapeFix_Shell* allows fixing wrong orientation of faces in a shell. It changes the orientation of faces in the shell  so that all faces in the shell have coherent orientations. If it is impossible to orient all faces in the shell (like in case of Mebious tape), then a few manifold or non-manifold shells will be created depending on the specified Non-manifold mode. The *ShapeFix_Face* tool is used to correct faces in the shell. 
285 This tool has the following control flags:
286 * *FixFaceMode* - mode for applying the fixes of  *ShapeFix_Face*, *True* by default. 
287 * *FixOrientationMode*  - mode for applying a fix for the orientation of faces in the shell. 
288
289 @subsubsection occt_shg_2_3_6 Repairing tool for faces 
290
291 Class *ShapeFix_Face* allows fixing the problems connected with wires of a face. It allows controlling the creation of a face (adding wires), and fixing wires by means of tool *ShapeFix_Wire*. 
292 When a wire is added to a face, it can be reordered and degenerated edges can be fixed. This is performed or not depending on the user-defined flags (by default, False). 
293 The following fixes are available: 
294   * fixing of wires orientation on the face. If the face has no wire, the natural bounds are computed. If the face is on a spherical surface and has two or more wires on it describing holes, the natural bounds are added. In case of a single wire, it is made to be an outer one. If the face has several wires, they are oriented to lay one outside another (if possible). If the supporting surface is periodic, 2D curves of internal wires can be shifted on integer number of periods to put them inside the outer wire. 
295   * fixing the case when the face on the closed surface is defined by a set of closed wires, and the seam is missing (this is not valid in OCCT). In that case, these wires are connected by means of seam edges into the same wire.
296
297 This tool has the following control flags: 
298 * *FixWireMode*  - mode for applying fixes of a wire, True by default. 
299 * *FixOrientationMode*  - mode for orienting a wire to border a limited square, True by default. 
300 * *FixAddNaturalBoundMode* - mode for adding natural bounds to a face, False by default. 
301 * *FixMissingSeamMode* – mode to fix a missing seam, True by default. If True, tries to insert a seam. 
302 * *FixSmallAreaWireMode* - mode to fix a small-area wire, False by default. If True, drops wires bounding small areas. 
303
304 ~~~~~
305
306 TopoDS_Face face = ...; 
307 TopoDS_Wire wire = ...; 
308
309 //Creates a tool and adds a wire to the face 
310 ShapeFix_Face sff (face); 
311 sff.Add (wire); 
312
313 //use method Perform to fix the wire and the face 
314 sff.Perfom(); 
315
316 //or make a separate fix for the orientation of wire on the face 
317 sff.FixOrientation(); 
318
319 //Get the resulting face 
320 TopoDS_Face newface = sff.Face(); 
321 ~~~~~
322
323 @subsubsection occt_shg_2_3_7 Repairing tool for wires 
324
325 Class *ShapeFix_Wire* allows fixing a wire. Its method *Perform()* performs all the available fixes in addition to the geometrical filling of gaps. The geometrical filling of gaps can be made with the help of the tool for fixing the wireframe of shape *ShapeFix_Wireframe*.  
326
327 The fixing order and the default behavior of *Perform()* is as follows: 
328   * Edges in the wire are reordered by *FixReorder*. Most of fixing methods expect edges in a wire to be ordered, so it is necessary to make call to *FixReorder()* before making any other fixes. Even if it is forbidden, the analysis of whether the wire is ordered or not is performed anyway. 
329   * Small edges are removed by *FixSmall* . 
330   * Edges in the wire are connected (topologically) by *FixConnected* (if the wire is ordered). 
331   * Edges (3Dcurves and 2D curves)  are fixed by *FixEdgeCurves* (without *FixShifted* if the wire is not ordered). 
332   * Degenerated edges  are added by *FixDegenerated*(if the wire is ordered). 
333   * Self-intersection is fixed by *FixSelfIntersection* (if the wire is ordered and *ClosedMode* is True). 
334   * Lacking edges are fixed by *FixLacking* (if the wire is ordered). 
335   
336  The flag *ClosedWireMode* specifies whether the wire is (or should be) closed or not. If that flag is True (by default), fixes that require or force connection between edges are also executed for the last and the first edges. 
337   
338 The fixing methods can be turned on/off by using their corresponding control flags: 
339 * *FixReorderMode,* 
340 * *FixSmallMode,* 
341 * *FixConnectedMode,* 
342 * *FixEdgeCurvesMode,* 
343 * *FixDegeneratedMode,* 
344 * *FixSelfIntersectionMode* 
345
346 Some fixes can be made in three ways: 
347   * Increasing the tolerance of an edge or a vertex. 
348   * Changing topology (adding/removing/replacing an edge in the wire and/or replacing the vertex in the edge, copying the edge etc.). 
349   * Changing geometry (shifting a vertex or adjusting ends of an edge curve to vertices, or re-computing a 3D curve or 2D curves of the edge). 
350   
351 When it is possible to make a fix in more than one way (e.g., either by increasing the tolerance or shifting a vertex), it is chosen according to the user-defined flags: 
352 * *ModifyTopologyMode* -   allows modifying topology, False by default. 
353 * *ModifyGeometryMode* -  allows modifying geometry. Now this flag is used only in fixing self-intersecting edges (allows to modify 2D curves) and is True by default. 
354   
355 #### Fixing disordered edges
356
357 *FixReorder* is necessary for most other fixes (but is not necessary for Open CASCADE Technology). It checks whether edges in the wire go in a sequential order (the end of a preceding edge is the start of a following one). If it is not so, an attempt to reorder the edges is made. 
358
359 #### Fixing small edges
360
361 *FixSmall* method searches for the edges, which have a length less than the given value (degenerated edges are ignored). If such an edge is found, it is removed provided that one of the following conditions is satisfied: 
362   * both end vertices of that edge are one and the same vertex, 
363   * end vertices of the edge are different, but the flag *ModifyTopologyMode* is True. In the latter case, method *FixConnected* is applied to the preceding and the following edges to ensure their connection.
364  
365 #### Fixing disconnected edges
366
367 *FixConnected* method forces two adjacent edges to share the same common vertex (if they do not have a common one). It checks whether the end vertex of the preceding edge coincides with the start vertex of the following edge with the given precision, and then creates a new vertex and sets it as a common vertex for the fixed edges. At that point, edges are copied, hence the wire topology is changed (regardless of the *ModifyTopologyMode* flag). If the vertices do not coincide, this method fails. 
368
369 #### Fixing the consistency of edge curves
370
371 *FixEdgeCurves* method performs a set of fixes dealing with 3D curves and 2D curves of edges in a wire. 
372
373 These fixes will be activated with the help of a set of fixes from the repairing tool for edges called *ShapeFix_Edge*. Each of these fixes can be forced or forbidden by means of setting the corresponding flag to either True or False. 
374
375 The mentioned fixes and the conditions of their execution are: 
376   * fixing a disoriented 2D curve by call to *ShapeFix_Edge::FixReversed2d* - if not forbidden by flag *FixReversed2dMode*;
377   * removing a wrong 2D curve  by call to *ShapeFix_Edge::FixRemovePCurve* - only if forced by flag *FixRemovePCurveMode*;
378   * fixing a missing  2D curve by call to *ShapeFix_Edge::FixAddPCurve* - if not forbidden by flag *FixAddPCurveMode*; 
379   * removing a wrong 3D curve by call to *ShapeFix_Edge::FixRemoveCurve3d* - only if forced by flag *FixRemoveCurve3dMode*; 
380   * fixing a missing 3D curve by call to *ShapeFix_Edge::FixAddCurve3d* - if not forbidden by flag *FixAddCurve3dMode*;
381   * fixing 2D curves of seam edges - if not forbidden by flag *FixSeamMode*; 
382   * fixing 2D curves which can be shifted at an integer number of periods on the closed surface by call to *ShapeFix_Edge::FixShifted*  - if not forbidden by flag *FixShiftedMode*. 
383   
384 This fix is required if 2D curves of some edges in a wire lying on a closed surface were recomputed from 3D curves. In that case, the 2D curve for the edge, which goes along the seam of the surface, can be incorrectly shifted at an integer number of periods. The method *FixShifted* detects such cases and shifts wrong 2D curves back, ensuring that the 2D curves of the edges in the wire are connected.
385
386   * fixing the SameParameter problem by call to *ShapeFix_Edge::FixSameParameter* - if not forbidden by flag *FixSameParameterMode*.
387   
388   
389 #### Fixing degenerated edges
390
391 *FixDegenerated*  method checks whether an edge in a wire lies on a degenerated point of the supporting surface, or whether there is a degenerated point between the edges. If one of these cases is detected for any edge, a new degenerated edge is created and it replaces the current edge in the first case or is added to the wire in the second case. The newly created degenerated edge has a straight 2D curve, which goes from the end of the 2D curve of the preceding edge to the start of the following one. 
392
393 #### Fixing intersections of 2D curves of the edges
394
395 *FixSelfIntersection* method detects and fixes the following problems: 
396   * self-intersection of 2D curves of individual edges. If the flag *ModifyGeometryMode()* is False this fix will be performed by increasing the tolerance of one of end vertices to a value less then *MaxTolerance()*.
397   * intersection of 2D curves of each of the two adjacent edges (except the first and the last edges if the flag ClosedWireMode is False). If such intersection is found, the common vertex is modified in order to comprise the intersection point. If the flag *ModifyTopologyMode* is False this fix will be performed by increasing the tolerance of the vertex to a value less then *MaxTolerance()*.
398   * intersection of 2D curves of non-adjacent edges. If such intersection is found the tolerance of the nearest vertex is increased to comprise the intersection point. If such increase cannot be done with a tolerance less than *MaxTolerance* this fix will not be performed.
399
400 #### Fixing a lacking edge
401
402 *FixLacking* method checks whether a wire is not closed in the parametrical space of the surface (while it can be closed in 3D). This is done by checking whether the gap between 2D curves of each of the two adjacent edges in the wire is smaller than the tolerance of the corresponding vertex. The algorithm computes the gap between the edges, analyses positional relationship of the ends of these edges and (if possible) tries to insert a new edge into the gap or increases the tolerance. 
403
404 #### Fixing gaps in 2D and 3D wire by geometrical filling
405 The following methods check gaps between the ends of 2D or 3D curves of adjacent edges:
406 * Method *FixGap2d* moves the ends of 2D curves to the middle point. 
407 * Method *FixGaps3d* moves the ends of 3D curves to a common vertex. 
408
409 Boolean flag *FixGapsByRanges* is used to activate an additional mode applied before converting to B-Splines. When this mode is on, methods try to find the most precise intersection of curves, or the most precise projection of a target point, or an extremity point between two curves (to modify their parametric range accordingly). This mode is off by default. Independently of the additional mode described above, if gaps remain, these methods convert curves to B-Spline form and shift their ends if a gap is detected. 
410
411 #### Example: A custom set of fixes 
412
413
414 Let us create a custom set of fixes as an example. 
415 ~~~~~
416 TopoDS_Face face = ...; 
417 TopoDS_Wire wire = ...; 
418 Standard_Real precision = 1e-04; 
419 ShapeFix_Wire sfw (wire, face, precision); 
420 //Creates a tool and loads objects into it 
421 sfw.FixReorder(); 
422 //Orders edges in the wire so that each edge starts at the end of the one before it. 
423 sfw.FixConnected(); 
424 //Forces all adjacent edges to share 
425 //the same vertex 
426 Standard_Boolean LockVertex = Standard_True; 
427         if (sfw.FixSmall (LockVertex, precision)) { 
428         //Removes all edges which are shorter than the given precision and have the same vertex at both ends. 
429
430         if (sfw.FixSelfIntersection()) { 
431         //Fixes self-intersecting edges and intersecting adjacent edges. 
432         cout <<"Wire was slightly self-intersecting. Repaired"<<endl; 
433
434         if ( sfw.FixLacking ( Standard_False ) ) { 
435         //Inserts edges to connect adjacent non-continuous edges. 
436
437 TopoDS_Wire newwire = sfw.Wire(); 
438 //Returns the corrected wire 
439 ~~~~~
440
441 #### Example: Correction of a wire 
442
443 Let us correct the following wire:
444
445 @image html /user_guides/shape_healing/images/shape_healing_image013.png "Initial shape"
446 @image latex /user_guides/shape_healing/images/shape_healing_image013.png "Initial shape"
447
448 It is necessary to apply the <a href="#_3_1_2">Tools for the analysis of validity of wires</a> to check that:
449 * the edges are correctly oriented;
450 * there are no edges that are too short;
451 * there are no intersecting adjacent edges;
452 and then immediately apply fixing tools. 
453
454 ~~~~~
455 TopoDS_Face face = ...;
456 TopoDS_Wire wire = ...;
457 Standard_Real precision = 1e-04;
458 ShapeAnalysis_Wire saw (wire, face, precision);
459 ShapeFix_Wire sfw (wire, face, precision);
460 if (saw.CheckOrder()) {
461   cout<<“Some edges in the wire need to be reordered”<<endl;
462   // Two edges are incorrectly oriented
463   sfw.FixReorder();
464   cout<<“Reordering is done”<<endl;
465 }
466 // their orientation is corrected
467 if (saw.CheckSmall (precision)) {
468   cout<<“Wire contains edge(s) shorter than “<<precision<<endl;
469   // An edge that is shorter than the given tolerance is found.
470   Standard_Boolean LockVertex = Standard_True;
471   if (sfw.FixSmall (LockVertex, precision)) {
472     cout<<“Edges shorter than “<<precision<<“ have been removed”
473 <<endl;
474     //The edge is removed
475   }
476 }
477 if (saw.CheckSelfIntersection()) {
478   cout<<“Wire has self-intersecting or intersecting
479 adjacent edges”<<endl;
480   // Two intersecting adjacent edges are found.
481   if (sfw.FixSelfIntersection()) {
482     cout<<“Wire was slightly self-intersecting. Repaired”<<endl;
483     // The edges are cut at the intersection point so that they no longer intersect.
484   }
485 }
486 ~~~~~
487
488 As the result all failures have been fixed.
489
490 @image html /user_guides/shape_healing/images/shape_healing_image014.png "Resulting shape"
491 @image latex /user_guides/shape_healing/images/shape_healing_image014.png "Resulting shape"
492
493 @subsubsection occt_shg_2_3_8 Repairing tool for edges 
494
495 Class *ShapeFix_Edge*  provides tools for fixing invalid edges. The following geometrical and/or topological inconsistencies are detected and fixed: 
496   * missing 3D curve or 2D curve, 
497   * mismatching orientation of a 3D curve and a 2D curve, 
498   * incorrect SameParameter flag (curve deviation is greater than the edge tolerance). 
499 Each fixing method first checks whether the problem exists using methods of the *ShapeAnalysis_Edge* class. If the problem is not detected, nothing is done. 
500 This tool does not have the method *Perform()*. 
501
502 To see how this tool works, it is possible to take an edge, where the maximum deviation between the 3D curve and 2D curve P1 is greater than the edge tolerance.
503
504 @image html /user_guides/shape_healing/images/shape_healing_image011.png "Initial shape"
505 @image latex /user_guides/shape_healing/images/shape_healing_image011.png "Initial shape"
506
507 First it is necessary to apply the <a href="#_3_1_3">Tool for checking the validity of edges</a> to find that maximum deviation between pcurve and 3D curve is greater than tolerance. Then we can use the repairing tool to increase the tolerance and make the deviation acceptable.
508
509 ~~~~~   
510 ShapeAnalysis_Edge sae;
511 TopoDS_Face face = ...; 
512 TopoDS_Wire wire = ...; 
513 Standard_Real precision = 1e-04; 
514 ShapeFix_Edge sfe;
515 Standard_Real maxdev;
516 if (sae.CheckSameParameter (edge, maxdev)) {
517   cout<<“Incorrect SameParameter flag”<<endl;
518   cout<<“Maximum deviation “<<maxdev<< “, tolerance “
519 <<BRep_Tool::Tolerance(edge)<<endl;
520   sfe.FixSameParameter();
521   cout<<“New tolerance “<<BRep_Tool::Tolerance(edge)<<endl;
522 }
523 ~~~~~
524
525 @image html /user_guides/shape_healing/images/shape_healing_image012.png "Resulting shape"
526 @image latex /user_guides/shape_healing/images/shape_healing_image012.png "Resulting shape"
527
528 As the result, the  edge tolerance has been increased.
529
530
531 @subsubsection occt_shg_2_3_9 Repairing tool for the wireframe of a shape 
532
533 Class *ShapeFix_Wireframe* provides methods for geometrical fixing of gaps and merging small edges in a shape. This class performs the following operations: 
534   * fills gaps in the 2D and 3D wireframe of a shape. 
535   * merges and removes small edges.
536   
537 Fixing of small edges can be managed with the help of two flags: 
538   * *ModeDropSmallEdges()* – mode for removing small edges that can not be merged, by default it is equal to Standard_False. 
539   * *LimitAngle* – maximum possible angle for merging two adjacent edges, by default no limit angle is applied (-1).
540 To perform fixes it is necessary to: 
541   * create a tool and initialize it by shape,
542   * set the working precision problems will be detected with and the maximum allowed tolerance
543   * perform fixes
544   
545 ~~~~~
546 //creation of a tool 
547 Handle(ShapeFix_Wireframe) sfwf = new ShapeFix_Wireframe(shape); 
548 //sets the working precision problems will be detected with and the maximum allowed tolerance 
549 sfwf->SetPrecision(prec); 
550 sfwf->SetMaxTolerance(maxTol); 
551 //fixing of gaps 
552 sfwf->FixWireGaps(); 
553 //fixing of small edges 
554 //setting of the drop mode for the fixing of small edges and max possible angle between merged edges. 
555 sfwf->ModeDropSmallEdges = Standard_True; 
556 sfwf->SetLimliteAngle(angle); 
557 //performing the fix 
558 sfwf->FixSmallEdges(); 
559 //getting the result 
560 TopoDS_Shape resShape = sfwf->Shape(); 
561 ~~~~~
562
563 It is desirable that a shape is topologically correct before applying the methods of this class. 
564
565 @subsubsection occt_shg_2_3_10 Tool for removing small faces from a shape 
566
567 Class ShapeFix_FixSmallFaceThis tool is intended for dropping small faces from the shape. The following cases are processed: 
568 * Spot face: if the size of the face is less than the given precision;
569 * Strip face: if the size of the face in one dimension is less then the given precision. 
570
571 The sequence of actions for performing the fix is the same as for the fixes described above: 
572
573 ~~~~~
574 //creation of a tool 
575 Handle(ShapeFix_FixSmallFace) sff = new ShapeFix_FixSmallFace(shape); 
576 //setting of tolerances 
577 sff->SetPrecision(prec); 
578 sff->SetMaxTolerance(maxTol); 
579 //performing fixes 
580 sff.Perform(); 
581 //getting the result 
582 TopoDS_Shape resShape = sff.FixShape(); 
583 ~~~~~
584
585 @subsubsection occt_shg_2_3_11 Tool to modify  tolerances of shapes (Class ShapeFix_ShapeTolerance).
586
587 This tool provides a functionality to set tolerances of a shape and its sub-shapes. 
588 In Open CASCADE Technology only vertices, edges and faces have tolerances. 
589
590 This tool allows processing each concrete type of sub-shapes or all types at a time. 
591 You set the tolerance functionality as follows: 
592   * set a tolerance for sub-shapes, by method SetTolerance,
593   * limit tolerances with given ranges, by method LimitTolerance.
594   
595 ~~~~~
596 //creation of a tool 
597 ShapeFix_ShapeTolerance Sft; 
598 //setting a specified tolerance on shape and all of its sub-shapes. 
599 Sft.SetTolerance(shape,toler); 
600 //setting a specified tolerance for vertices only 
601 Sft.SetTolerance(shape,toler,TopAbs_VERTEX); 
602 //limiting the tolerance on the shape and its sub-shapes between minimum and maximum tolerances 
603 Sft.LimitTolerance(shape,tolermin,tolermax); 
604 ~~~~~
605
606
607 @section occt_shg_3 Analysis
608
609 @subsection occt_shg_3_1 Analysis of shape validity
610
611 The *ShapeAnalysis* package provides tools for the analysis of topological shapes. 
612 It is not necessary to check a shape by these tools before the execution of repairing tools because these tools are used for the analysis before performing fixes inside the repairing tools. 
613 However, if you want, these tools can be used for detecting some of shape problems independently from the repairing tools. 
614
615  It can be done in the following way: 
616   * create an analysis tool. 
617   * initialize it by shape and set a tolerance problems will be detected with if it is necessary.
618   * check the problem that interests you.
619   
620 ~~~~~
621 TopoDS_Face face = ...; 
622 ShapeAnalysis_Edge sae; 
623 //Creates a tool for analyzing an edge 
624 for(TopExp_Explorer Exp(face,TopAbs_EDGE);Exp.More();Exp.Next()) { 
625   TopoDS_Edge edge = TopoDS::Edge (Exp.Current()); 
626   if (!sae.HasCurve3d (edge)) { 
627     cout  <<"Edge has no 3D curve"<<  endl;  } 
628
629 ~~~~~
630
631 @subsubsection occt_shg_3_1_1 Analysis of orientation of wires on a face.
632
633 It is possible to check whether a face has an outer boundary with the help of method *ShapeAnalysis::IsOuterBound*. 
634
635 ~~~~~
636 TopoDS_Face face … //analyzed face 
637 if(!ShapeAnalysis::IsOuterBound(face)) { 
638 cout<<"Face has not outer boundary"<<endl; 
639
640 ~~~~~
641
642 @subsubsection occt_shg_3_1_2 Analysis of wire validity
643
644 Class *ShapeAnalysis_Wire* is intended to analyze a wire. It provides functionalities both to explore wire properties and to check its conformance to Open CASCADE Technology requirements. 
645 These functionalities include: 
646   * checking the order of edges in the wire, 
647   * checking for the presence of small edges (with a length less than the given value), 
648   * checking for the presence of disconnected edges (adjacent edges having different vertices), 
649   * checking the consistency of edge curves, 
650   * checking for the presence or missing of degenerated edges, 
651   * checking for the presence of self-intersecting edges and intersecting edges (edges intersection is understood as intersection of their 2D curves), 
652   * checking for lacking edges to fill gaps in the surface parametrical space, 
653   * analyzing the wire orientation (to define the outer or the inner bound on the face), 
654   * analyzing the orientation of the shape (edge or wire) being added to an already existing wire. 
655
656 **Note** that all checking operations except for the first one are based on the assumption that edges in the wire are ordered. Thus, if the wire is detected as non-ordered it is necessary to order it before calling other checking operations. This can be done, for example, with the help of the *ShapeFix_Wire::FixOrder()* method. 
657
658 This tool should be initialized with wire, face (or a surface with a location) or precision. 
659 Once the tool has been initialized, it is possible to perform the necessary checking operations. In order to obtain all information on a wire at a time the global method *Perform* is provided. It calls all other API checking operations to check each separate case. 
660
661 API methods check for corresponding cases only, the value and the status they return can be analyzed to understand whether the case was detected or not. 
662
663 Some methods in this class are: 
664   *  *CheckOrder* checks whether edges in the wire are in the right order 
665   *  *CheckConnected* checks whether edges are disconnected 
666   *  *CheckSmall* checks whether there are edges that are shorter than the given value 
667   *  *CheckSelfIntersection* checks, whether there are self-intersecting or adjacent intersecting edges. If the intersection takes place due to nonadjacent edges, it is not detected. 
668   
669 This class maintains status management. Each API method stores the status of its last execution which can be queried by the corresponding *Status..()* method. In addition, each API method returns a Boolean value, which is True when a case being analyzed is detected (with the set *ShapeExtend_DONE* status), otherwise it is False. 
670
671 ~~~~~
672 TopoDS_Face face = ...; 
673 TopoDS_Wire wire = ...; 
674 Standard_Real precision = 1e-04; 
675 ShapeAnalysis_Wire saw (wire, face, precision); 
676 //Creates a tool and loads objects into it 
677 if (saw.CheckOrder()) { 
678   cout<<"Some edges in the wire need to be reordered"<<endl; 
679   cout<<"Please ensure that all the edges are correctly ordered before further analysis"<<endl; 
680   return; 
681
682 if (saw.CheckSmall (precision)) { 
683   cout<<"Wire contains edge(s) shorter than "<<precisionendl; 
684
685 if (saw.CheckConnected()) { 
686   cout<<"Wire is disconnected"<<endl; 
687
688 if (saw.CheckSelfIntersection()) { 
689   cout<<"Wire has self-intersecting or intersecting adjacent edges"<<  endl; 
690
691 ~~~~~
692
693 @subsubsection occt_shg_3_1_3 Analysis of edge validity 
694
695 Class *ShapeAnalysis_Edge* is intended to analyze edges. It provides the following functionalities to work with an edge: 
696   * querying geometrical representations (3D curve and pcurve(s) on a given face or surface), 
697   * querying topological sub-shapes (bounding vertices), 
698   * checking overlapping edges,
699   * analyzing the curves consistency: 
700                 + mutual orientation of the 3D curve and 2D curve (co-directions or opposite directions), 
701                 + correspondence of 3D and 2D curves to vertices. 
702
703 This class supports status management described above. 
704
705 ~~~~~
706 TopoDS_Face face = ...; 
707 ShapeAnalysis_Edge sae; 
708 //Creates a tool for analyzing an edge 
709 for(TopExp_Explorer Exp(face,TopAbs_EDGE);Exp.More();Exp.Next()) { 
710   TopoDS_Edge edge = TopoDS::Edge (Exp.Current()); 
711   if (!sae.HasCurve3d (edge)) { 
712     cout << "Edge has no 3D curve" <<  endl; 
713   } 
714   Handle(Geom2d_Curve) pcurve; 
715   Standard_Real cf, cl; 
716   if (sae.PCurve (edge, face, pcurve, cf, cl, Standard_False)) { 
717     //Returns the pcurve and its range on the given face 
718     cout<<"Pcurve range ["<<cf<<", "<<cl<<"]"<< endl; 
719   } 
720   Standard_Real maxdev; 
721   if (sae.CheckSameParameter (edge, maxdev)) { 
722     //Checks the consistency of all the curves in the edge 
723     cout<<"Incorrect SameParameter flag"<<endl; 
724   } 
725   cout<<"Maximum deviation "<<maxdev<<", tolerance" 
726              <<BRep_Tool::Tolerance(edge)<<endl; 
727
728 //checks the overlapping of two edges 
729 if(sae.CheckOverlapping(edge1,edge2,prec,dist)) { 
730          cout<<"Edges are overlapped with tolerance = "<<prec<<endl; 
731          cout<<"Domain of overlapping ="<<dist<<endl; 
732
733 ~~~~~
734
735 @subsubsection occt_shg_3_1_4 Analysis of presence of small faces
736
737 Class *ShapeAnalysis_CheckSmallFace* class is intended for analyzing small faces from the shape using the following methods: 
738 * *CheckSpotFace()* checks if the size of the face is less than the given precision; 
739 * *CheckStripFace* checks if the size of the face in one dimension is less than the given precision.
740
741 ~~~~~
742 TopoDS_Shape shape … // checked shape 
743 //Creation of a tool 
744 ShapeAnalysis_CheckSmallFace saf; 
745 //exploring the shape on faces and checking each face 
746 Standard_Integer numSmallfaces =0; 
747 for(TopExp_Explorer aExp(shape,TopAbs_FACE); aExp.More(); aExp.Next()) { 
748  TopoDS_Face face = TopoDS::Face(aexp.Current()); 
749  TopoDS_Edge E1,E2; 
750 if(saf.CheckSpotFace(face,prec) || 
751 saf.CheckStripFace(face,E1,E2,prec)) 
752 NumSmallfaces++; 
753
754 if(numSmallfaces) 
755  cout<<"Number of small faces in the shape ="<< numSmallfaces <<endl; 
756 ~~~~~ 
757  
758 @subsubsection occt_shg_3_1_5 Analysis of shell validity and closure 
759
760 Class *ShapeAnalysis_Shell* allows checking the orientation of edges in a manifold shell. With the help of this tool, free edges (edges entered into one face) and bad edges (edges entered into the shell twice with the same orientation) can be found. By occurrence of bad and free edges a conclusion about the shell validity and the closure of the shell can be made. 
761
762 ~~~~~
763 TopoDS_Shell shell // checked shape 
764 ShapeAnalysis_Shell sas(shell); 
765 //analysis of the shell , second parameter is set to True for //getting free edges,(default False) 
766 sas.CheckOrientedShells(shell,Standard_True); 
767 //getting the result of analysis 
768 if(sas.HasBadEdges()) { 
769 cout<<"Shell is invalid"<<endl; 
770 TopoDS_Compound badEdges = sas.BadEdges(); 
771
772 if(sas.HasFreeEdges()) { 
773  cout<<"Shell is open"<<endl; 
774  TopoDS_Compound freeEdges = sas.FreeEdges(); 
775
776 ~~~~~
777
778 @subsection occt_shg_3_2 Analysis of shape properties.
779 @subsubsection occt_shg_3_2_1 Analysis of tolerance on shape 
780
781 Class *ShapeAnalysis_ShapeTolerance* allows computing tolerances of the shape and its sub-shapes. In Open CASCADE Technology only vertices, edges and faces have tolerances: 
782
783 This tool allows analyzing each concrete type of sub-shapes or all types at a time. 
784 The analysis of tolerance functionality is the following: 
785   * computing the minimum, maximum and average tolerances of sub-shapes, 
786   * finding sub-shapes with tolerances exceeding the given value, 
787   * finding sub-shapes with tolerances in the given range. 
788   
789 ~~~~~
790 TopoDS_Shape shape = ...; 
791 ShapeAnalysis_ShapeTolerance sast; 
792 Standard_Real AverageOnShape = sast.Tolerance (shape, 0); 
793 cout<<"Average tolerance of the shape is "<<AverageOnShape<<endl; 
794 Standard_Real MinOnEdge = sast.Tolerance (shape,-1,TopAbs_EDGE); 
795 cout<<"Minimum tolerance of the edges is "<<MinOnEdge<<endl; 
796 Standard_Real MaxOnVertex = sast.Tolerance (shape,1,TopAbs_VERTEX); 
797 cout<<"Maximum tolerance of the vertices is "<<MaxOnVertex<<endl; 
798 Standard_Real MaxAllowed = 0.1; 
799 if (MaxOnVertex > MaxAllowed) { 
800   cout<<"Maximum tolerance of the vertices exceeds maximum allowed"<<endl; 
801
802 ~~~~~
803
804 @subsubsection occt_shg_3_2_2 Analysis of free boundaries. 
805
806 Class ShapeAnalysis_FreeBounds is intended to analyze and output the free bounds of a shape. Free bounds are wires consisting of edges referenced only once by only one face in the shape. 
807 This class works on two distinct types of shapes when analyzing their free bounds: 
808 * Analysis of possible free bounds taking the specified tolerance into account. This analysis can be applied to a compound of faces. The analyzer of the sewing algorithm (*BRepAlgo_Sewing*) is used to forecast what free bounds would be obtained after the sewing of these faces is performed. The following method should be used for this analysis:
809 ~~~~~
810 ShapeAnalysis_FreeBounds safb(shape,toler); 
811 ~~~~~
812 * Analysis of already existing free bounds. Actual free bounds (edges shared by the only face in the shell) are output in this case. *ShapeAnalysis_Shell* is used for that. 
813 ~~~~~
814 ShapeAnalysis_FreeBounds safb(shape); 
815 ~~~~~
816
817 When connecting edges into wires this algorithm tries to build wires of maximum length. Two options are provided for the user to extract closed sub-contours out of closed and/or open contours. Free bounds are returned as two compounds, one for closed and one for open wires. To obtain a result it is necessary to use methods: 
818 ~~~~~
819 TopoDS_Compound ClosedWires  = safb.GetClosedWires(); 
820 TopoDS_Compound OpenWires = safb.GetOpenWires(); 
821 ~~~~~
822 This class also provides some static methods for advanced use: connecting edges/wires to wires, extracting closed sub-wires from wires, distributing wires into compounds for closed and open wires. 
823
824 ~~~~~
825 TopoDS_Shape shape = ...; 
826 Standard_Real SewTolerance = 1.e-03; 
827 //Tolerance for sewing 
828 Standard_Boolean SplitClosed = Standard_False; 
829 Standard_Boolean SplitOpen = Standard_True; 
830 //in case of analysis of possible free boundaries 
831 ShapeAnalysis_FreeBounds safb (shape, SewTolerance, 
832 SplitClosed, SplitOpen); 
833 //in case of analysis of existing free bounds 
834 ShapeAnalysis_FreeBounds safb (shape, SplitClosed, SplitOpen); 
835 //getting the results 
836 TopoDS_Compound ClosedWires = safb.GetClosedWires(); 
837 //Returns a compound of closed free bounds 
838 TopoDS_Compound OpenWires = safb.GetClosedWires(); 
839 //Returns a compound of open free bounds 
840 ~~~~~
841
842 @subsubsection occt_shg_3_2_3 Analysis of shape contents
843
844 Class *ShapeAnalysis_ShapeContents* provides tools counting the number of sub-shapes and selecting a sub-shape by the following criteria: 
845
846 Methods for getting the number of sub-shapes: 
847   * number of solids,
848   * number of shells,
849   * number of faces,
850   * number of edges,
851   * number of vertices.
852   
853 Methods for calculating the number of geometrical objects or sub-shapes with a specified type: 
854   * number of free faces,
855   * number of free wires,
856   * number of free edges,
857   * number of C0 surfaces,
858   * number of C0 curves,
859   * number of BSpline surfaces,… etc
860   
861 and selecting sub-shapes by various criteria. 
862
863 The corresponding flags should be set to True for storing a shape by a specified criteria: 
864   * faces based on indirect surfaces - *safc.MofifyIndirectMode() = Standard_True*; 
865   * faces based on offset surfaces - *safc.ModifyOffsetSurfaceMode() = Standard_True*; 
866   * edges if their 3D curves are trimmed - *safc.ModifyTrimmed3dMode() = Standard_True*; 
867   * edges if their 3D curves and 2D curves are offset curves - *safc.ModifyOffsetCurveMode() = Standard_True*; 
868   * edges if their 2D curves are trimmed - *safc.ModifyTrimmed2dMode() = Standard_True*; 
869
870 Let us, for example, select faces based on offset surfaces.
871
872 ~~~~~ 
873 ShapeAnalysis_ShapeContents safc; 
874 //set a corresponding flag for storing faces based on the offset surfaces 
875 safc.ModifyOffsetSurfaceMode() = Standard_True; 
876 safc.Perform(shape); 
877 //getting the number of offset surfaces in the shape 
878 Standard_Integer NbOffsetSurfaces = safc.NbOffsetSurf(); 
879 //getting the sequence of faces based on offset surfaces. 
880 Handle(TopTools_HSequenceOfShape) seqFaces = safc.OffsetSurfaceSec(); 
881 ~~~~~
882
883 @section occt_shg_4 Upgrading
884
885 Upgrading tools are intended for adaptation of shapes for better use by Open CASCADE Technology or for customization to particular needs, i.e. for export to another system. This means that not only it corrects and upgrades but also changes the definition of a shape with regard to its geometry, size and other aspects. Convenient API allows you to create your own tools to perform specific upgrading. Additional tools for particular cases provide an ability to divide shapes and surfaces according to certain criteria. 
886
887 @subsection occt_shg_4_1 Tools for splitting a shape according to a specified criterion
888
889 @subsubsection occt_shg_4_1_1 Overview
890
891 These tools provide such modifications when one topological object can be divided or converted to several ones according to specified criteria. Besides, there are high level API tools for particular cases which: 
892   * Convert the geometry of shapes up to a given continuity, 
893   * split revolutions by U to segments less than the given value, 
894   * convert to Bezier surfaces and Bezier curves, 
895   * split closed faces,
896   * convert C0 BSpline curve to a sequence of C1 BSpline curves. 
897   
898 All tools for particular cases are based on general tools for shape splitting but each of them has its own tools for splitting or converting geometry in accordance with the specified criteria. 
899
900 General tools for shape splitting are: 
901   * tool for splitting the whole shape,
902   * tool for splitting a face,
903   * tool for splitting wires.
904   
905 Tools for shape splitting use tools for geometry splitting: 
906   * tool for splitting surfaces,
907   * tool for splitting 3D curves,
908   * tool for splitting 2D curves.
909   
910 @subsubsection occt_shg_4_1_2 Using tools available for shape splitting.
911 If it is necessary to split a shape by a specified continuity, split closed faces in the shape, split surfaces of revolution in the shape by angle or to convert all surfaces, all 3D curves, all 2D curves in the shape to Bezier, it is possible to use the existing/available tools. 
912
913 The usual way to use these tools exception for the tool of converting a C0 BSpline curve is the following: 
914   * a tool is created and initialized by shape.
915   * work precision for splitting and the maximum allowed tolerance are set
916   * the value of splitting criterion Is set (if necessary)
917   * splitting is performed.
918   * splitting statuses are obtained.
919   * result is obtained
920   * the history of modification of the initial shape and its sub-shapes is output (this step is optional).
921
922 Let us, for example, split all surfaces and all 3D and 2D curves having a continuity of less the C2. 
923
924 ~~~~~
925 //create a tool and initializes it by shape. 
926 ShapeUpgrade_ShapeDivideContinuity ShapeDivedeCont(initShape); 
927
928 //set the working 3D and 2D precision and the maximum allowed //tolerance 
929 ShapeDivideCont.SetTolerance(prec); 
930 ShapeDivideCont.SetTolerance2D(prec2d); 
931 ShapeDivideCont.SetMaxTolerance(maxTol); 
932
933 //set the values of criteria for surfaces, 3D curves and 2D curves. 
934 ShapeDivideCont.SetBoundaryCriterion(GeomAbs_C2); 
935 ShapeDivideCont.SetPCurveCriterion(GeomAbs_C2); 
936 ShapeDivideCont.SetSurfaceCriterion(GeomAbs_C2); 
937
938 //perform the splitting. 
939 ShapeDivideCont.Perform(); 
940
941 //check the status and gets the result 
942 if(ShapeDivideCont.Status(ShapeExtend_DONE) 
943  TopoDS_Shape result = ShapeDivideCont.GetResult(); 
944 //get the history of modifications made to faces 
945 for(TopExp_Explorer aExp(initShape,TopAbs_FACE); aExp.More(0; aExp.Next()) { 
946   TopoDS_Shape modifShape = ShapeDivideCont.GetContext()-> Apply(aExp.Current()); 
947
948 ~~~~~
949
950 @subsubsection occt_shg_4_1_3 Creation of a new tool for splitting a shape.
951 To create a new splitting tool it is necessary to create tools for geometry splitting according to a desirable criterion. The new tools should be inherited from basic tools for geometry splitting. Then the new tools should be set into corresponding tools for shape splitting. 
952   * a new tool for surface splitting  should be set into the tool for face splitting
953   * new tools for splitting of 3D and 2D curves  should be set into the splitting tool for wires.
954   
955 To change the value of criterion of shape splitting it is necessary to create a new tool for shape splitting that should be inherited from the general splitting tool for shapes. 
956
957 Let us split a shape according to a specified criterion. 
958
959 ~~~~~
960 //creation of new tools for geometry splitting by a specified criterion. 
961 Handle(MyTools_SplitSurfaceTool) MySplitSurfaceTool = new MyTools_SplitSurfaceTool; 
962 Handle(MyTools_SplitCurve3DTool) MySplitCurve3Dtool = new MyTools_SplitCurve3DTool; 
963 Handle(MyTools_SplitCurve2DTool) MySplitCurve2Dtool = new MyTools_SplitCurve2DTool; 
964
965 //creation of a tool for splitting the shape and initialization of that tool by shape. 
966 TopoDS_Shape initShape 
967 MyTools_ShapeDivideTool ShapeDivide (initShape); 
968
969 //setting of work precision for splitting and maximum allowed tolerance. 
970 ShapeDivide.SetPrecision(prec); 
971 ShapeDivide.SetMaxTolerance(MaxTol); 
972
973 //setting of new splitting geometry tools in the shape splitting tools 
974 Handle(ShapeUpgrade_FaceDivide) FaceDivide = ShapeDivide->GetSplitFaceTool(); 
975 Handle(ShapeUpgrade_WireDivide) WireDivide = FaceDivide->GetWireDivideTool(); 
976 FaceDivide->SetSplitSurfaceTool(MySplitSurfaceTool); 
977 WireDivide->SetSplitCurve3dTool(MySplitCurve3DTool); 
978 WireDivide->SetSplitCurve2dTool(MySplitCurve2DTool); 
979
980 //setting of the value criterion. 
981  ShapeDivide.SetValCriterion(val); 
982             
983 //shape splitting 
984 ShapeDivide.Perform(); 
985
986 //getting the result 
987 TopoDS_Shape splitShape = ShapeDivide.GetResult(); 
988
989 //getting the history of modifications of faces 
990 for(TopExp_Explorer aExp(initShape,TopAbs_FACE); aExp.More(0; aExp.Next()) { 
991 TopoDS_Shape modifShape = ShapeDivide.GetContext()-> Apply(aExp.Current()); 
992
993 ~~~~~
994
995 @subsection occt_shg_4_2 General splitting tools.
996  
997 @subsubsection occt_shg_4_2_1 General tool for shape splitting 
998
999 Class *ShapeUpgrade_ShapeDivide* provides shape splitting and converting according to the given criteria. It performs these operations for each face with the given tool for face splitting (*ShapeUpgrade_FaceDivide* by default). 
1000
1001 This tool provides access to the tool for dividing faces with the help of the methods *SetSplitFaceTool* and *GetSpliFaceTool.* 
1002
1003 @subsubsection occt_shg_4_2_2 General tool for face splitting
1004
1005 Class *ShapeUpgrade_FaceDivide* divides a Face (edges in the wires, by splitting 3D and 2D curves, as well as the face itself, by splitting the supporting surface) according to the given criteria. 
1006
1007 The area of the face intended for division is defined by 2D curves of the wires on the Face. 
1008 All 2D curves are supposed to be defined (in the parametric space of the supporting surface). 
1009 The result is available after the call to the *Perform* method. It is a Shell containing all resulting Faces. All modifications made during the splitting operation are recorded in the external context (*ShapeBuild_ReShape*). 
1010
1011 This tool provides access to the tool for wire division and surface splitting by means of the following methods: 
1012 * *SetWireDivideTool,* 
1013 * *GetWireDivideTool,* 
1014 * *SetSurfaceSplitTool,* 
1015 * *GetSurfaceSplitTool*. 
1016
1017 @subsubsection occt_shg_4_2_3 General tool for wire splitting
1018 Class *ShapeUpgrade_WireDivide* divides edges in the wire lying on the face or free wires or free edges with a given criterion. It splits the 3D curve and 2D curve(s) of the edge on the face. Other 2D curves, which may be associated with the edge, are simply copied. If the 3D curve is split then the 2D curve on the face is split as well, and vice-versa. The original shape is not modified. Modifications made are recorded in the context (*ShapeBuild_ReShape*). 
1019
1020 This tool provides access to the tool for dividing and splitting 3D and 2D curves by means of the following methods: 
1021 * *SetEdgeDivdeTool,* 
1022 * *GetEdgeDivideTool,* 
1023 * *SetSplitCurve3dTool,* 
1024 * *GetSplitCurve3dTool,* 
1025 * *SetSplitCurve2dTool,* 
1026 * *GetSplitCurve2dTool* 
1027
1028 and it also provides access to the mode for splitting edges by methods *SetEdgeMode* and *GetEdgeMode*.
1029  
1030 This mode sets whether only free edges, only shared edges or all edges are split.
1031
1032 @subsubsection occt_shg_4_2_4 General tool for edge splitting
1033
1034 Class *ShapeUpgrade_EdgeDivide* divides edges and their geometry according to the specified criteria. It is used in the wire-dividing tool. 
1035
1036 This tool provides access to the tool for dividing and splitting 3D and 2D curves by the following methods: 
1037 * *SetSplitCurve3dTool,* 
1038 * *GetSplitCurve3dTool,* 
1039 * *SetSplitCurve2dTool,* 
1040 * *GetSplitCurve2dTool*. 
1041
1042 @subsubsection occt_shg_4_2_5 General tools for geometry splitting
1043
1044 There are three general tools for geometry splitting. 
1045   * General tool for surface splitting.(*ShapeUpgrade_SplitSurface*)
1046   * General tool for splitting 3D curves.(*ShapeUpgrade_SplitCurve3d*)
1047   * General tool for splitting 2D curves.(*ShapeUpgrade_SplitCurve2d*)
1048   
1049 All these tools are constructed the same way: 
1050 They have methods: 
1051   * for initializing by geometry (method *Init*) 
1052   * for splitting (method *Perform*)
1053   * for getting the status after splitting and the results:
1054         + *Status* – for getting the result status; 
1055         + *ResSurface* - for splitting surfaces; 
1056         + *GetCurves* - for splitting 3D and 2D curves. 
1057 During the process of splitting in the method *Perform* : 
1058   * splitting values in the parametric space are computed according to a specified criterion (method  *Compute*) 
1059   * splitting is made in accordance with the values computed for splitting (method *Build*).
1060
1061 To create new tools for geometry splitting it is enough to inherit a new tool from the general tool for splitting a corresponding type of geometry and to re-define the method for computation of splitting values according to the specified criterion in them. (method *Compute*). 
1062
1063 Header file for the tool for surface splitting by continuity: 
1064
1065 ~~~~~
1066 class ShapeUpgrade_SplitSurfaceContinuity : public ShapeUpgrade_SplitSurface { 
1067 Standard_EXPORT ShapeUpgrade_SplitSurfaceContinuity(); 
1068
1069 //methods to set the criterion and the tolerance into the splitting tool 
1070 Standard_EXPORT   void SetCriterion(const GeomAbs_Shape Criterion) ; 
1071 Standard_EXPORT   void SetTolerance(const Standard_Real Tol) ; 
1072
1073 //redefinition of method Compute 
1074 Standard_EXPORT virtual void Compute(const Standard_Boolean Segment) ; 
1075 Standard_EXPORT ~ShapeUpgrade_SplitSurfaceContinuity(); 
1076 private: 
1077 GeomAbs_Shape myCriterion; 
1078 Standard_Real myTolerance; 
1079 Standard_Integer myCont; 
1080 }; 
1081 ~~~~~
1082
1083 @subsection occt_shg_4_3 Specific splitting tools.
1084
1085 @subsubsection occt_shg_4_3_1 Conversion of shape geometry to the target continuity
1086 Class *ShapeUpgrade_ShapeDivideContinuity* allows converting geometry with continuity less than the specified continuity to geometry with target continuity. If converting is not possible than geometrical object is split into several ones, which satisfy the given criteria. A topological object based on this geometry is replaced by several objects based on the new geometry. 
1087
1088 ~~~~~
1089 ShapeUpgrade_ShapeDivideContinuity sdc (shape); 
1090 sdc.SetTolerance (tol3d); 
1091 sdc.SetTolerance3d (tol2d); // if known, else 1.e-09 is taken 
1092 sdc.SetBoundaryCriterion (GeomAbs_C2); // for Curves 3D 
1093 sdc.SetPCurveCriterion (GeomAbs_C2); // for Curves 2D 
1094 sdc.SetSurfaceCriterion (GeomAbs_C2); // for Surfaces 
1095 sdc.Perform (); 
1096 TopoDS_Shape bshape = sdc.Result(); 
1097 //.. to also get the correspondances before/after 
1098 Handle(ShapeBuild_ReShape) ctx = sdc.Context(); 
1099 //.. on a given shape 
1100 if (ctx.IsRecorded (sh)) { 
1101   TopoDS_Shape newsh = ctx->Value (sh); 
1102 // if there are several results, they are recorded inside a Compound.
1103 // .. process as needed 
1104
1105 ~~~~~
1106
1107 @subsubsection occt_shg_4_3_2 Splitting by angle
1108 Class *ShapeUpgrade_ShapeDivideAngle* allows  splitting all surfaces of revolution, cylindrical, toroidal, conical, spherical surfaces in the given shape so that each resulting segment covers not more than the defined angle (in radians). 
1109
1110 @subsubsection occt_shg_4_3_3 Conversion of 2D, 3D curves and surfaces to Bezier
1111
1112 Class *ShapeUpgrade_ShapeConvertToBezier* is an API tool for performing a conversion of 3D, 2D curves to Bezier curves and surfaces to Bezier based surfaces (Bezier surface, surface of revolution based on Bezier curve, offset surface based on any of previous types).
1113  
1114 This tool provides access to various flags for conversion of different types of curves and surfaces to Bezier by methods: 
1115 * For 3D curves: 
1116         * *Set3dConversion,* 
1117         * *Get3dConversion,* 
1118         * *Set3dLineConversion,* 
1119         * *Get3dLineConversion,* 
1120         * *Set3dCircleConversion,* 
1121         * *Get3dCircleConversion,* 
1122         * *Set3dConicConversion,* 
1123         * *Get3dConicConversion* 
1124 * For 2D curves: 
1125         * *Set2dConversion,* 
1126         * *Get2dConversion* 
1127 * For surfaces : 
1128         * *GetSurfaceConversion,* 
1129         * *SetPlaneMode,* 
1130         * *GetPlaneMode,* 
1131         * *SetRevolutionMode,* 
1132         * *GetRevolutionMode,* 
1133         * *SetExtrusionMode,* 
1134         * *GetExtrusionMode,* 
1135         * *SetBSplineMode,* 
1136         * *GetBSplineMode,* 
1137
1138 Let us attempt to produce a conversion of planes to Bezier surfaces. 
1139 ~~~~~
1140 //Creation and initialization of a tool. 
1141 ShapeUpgrade_ShapeConvertToBezier SCB (Shape); 
1142 //setting tolerances 
1143 ...
1144 //setting mode for conversion of planes 
1145 SCB.SetSurfaceConversion (Standard_True); 
1146 SCB.SetPlaneMode(Standard_True); 
1147 SCB.Perform(); 
1148 If(SCB.Status(ShapeExtend_DONE) 
1149     TopoDS_Shape result = SCB.GetResult(); 
1150 ~~~~~
1151
1152 @subsubsection occt_shg_4_3_4 Tool for splitting closed faces
1153
1154 Class *ShapeUpgrade_ShapeDivideClosed* provides splitting of closed faces in the shape to a defined number of components by the U and V parameters. It topologically and (partially) geometrically processes closed faces and performs splitting with the help of class *ShapeUpgrade_ClosedFaceDivide*. 
1155
1156 ~~~~~
1157 TopoDS_Shape aShape = …; 
1158 ShapeUpgrade_ShapeDivideClosed tool (aShape ); 
1159 Standard_Real closeTol = …; 
1160 tool.SetPrecision(closeTol); 
1161 Standard_Real maxTol = …; 
1162 tool.SetMaxTolerance(maxTol); 
1163 Standard_Integer NbSplitPoints = …; 
1164 tool.SetNbSplitPoints(num); 
1165 if ( ! tool.Perform() && tool.Status (ShapeExtend_FAIL) ) { 
1166   cout<<"Splitting of closed faces failed"<<endl; 
1167   . . . 
1168
1169 TopoDS_Shape aResult = tool.Result(); 
1170 ~~~~~
1171
1172 @subsubsection occt_shg_4_3_5 Tool for splitting a C0 BSpline 2D or 3D curve to a sequence C1 BSpline curves
1173
1174 The API methods for this tool is a package of methods *ShapeUpgrade::C0BSplineToSequenceOfC1BsplineCurve*, which converts a C0 B-Spline curve into a sequence of C1 B-Spline curves. This method splits a B-Spline at the knots with multiplicities equal to degree, it does not use any tolerance and therefore does not change the geometry of the B-Spline. The method returns True if C0 B-Spline was successfully split, otherwise returns False (if BS is C1 B-Spline). 
1175
1176 @subsubsection occt_shg_4_3_6 Tool for splitting faces
1177
1178 *ShapeUpgrade_ShapeDivideArea* can work with compounds, solids, shells and faces. 
1179 During the work this tool examines each face of a specified shape and if the face area exceeds the specified maximal area, this face is divided. Face splitting is performed in the parametric space of this face. The values of splitting in U and V directions are calculated with the account of translation of the bounding box form parametric space to 3D space. 
1180
1181 Such calculations are necessary to avoid creation of strip faces. In the process of splitting the holes on the initial face are taken into account. After the splitting all new faces are checked by area again and the splitting procedure is repeated for the faces whose area still exceeds the max allowed area. Sharing between faces in the shape is preserved and the resulting shape is of the same type as the source shape. 
1182
1183 An example of using this tool is presented in the figures below: 
1184
1185 @image html /user_guides/shape_healing/images/shape_healing_image003.png "Source Face"
1186 @image latex /user_guides/shape_healing/images/shape_healing_image003.png "Source Face"
1187
1188 @image html /user_guides/shape_healing/images/shape_healing_image004.png "Resulting shape"
1189 @image latex /user_guides/shape_healing/images/shape_healing_image004.png "Resulting shape"
1190
1191
1192 *ShapeUpgrade_ShapeDivideArea* is inherited from the base class *ShapeUpgrade_ShapeDivide* and should be used in the following way: 
1193 *       This class should be initialized on a shape with the help of the constructor or  method *Init()* from the base class. 
1194 *       The maximal allowed area should be specified by the method *MaxArea()*.
1195 *       To produce a splitting use  method Perform from the base class. 
1196 *       The result shape can be obtained with the help the method *Result()*.
1197
1198 ~~~~~
1199 ShapeUpgrade_ShapeDivideArea tool (inputShape); 
1200 tool.MaxArea() = aMaxArea; 
1201 tool.Perform(); 
1202 if(tool.Status(ShapeExtend_DONE)) { 
1203   TopoDS_Shape ResultShape = tool.Result(); 
1204   ShapeFix::SameParameter ( ResultShape, Standard_False ); 
1205
1206 ~~~~~
1207
1208 **Note** that the use of method *ShapeFix::SameParameter* is necessary, otherwise the parameter edges obtained as a result of splitting can be different. 
1209
1210 #### Additional methods
1211
1212 * Class *ShapeUpgrade_FaceDivideArea* inherited from *ShapeUpgrade_FaceDivide* is intended for splitting a face by the maximal area criterion. 
1213 * Class *ShapeUpgrade_SplitSurfaceArea* inherited from *ShapeUpgrade_SplitSurface* calculates the parameters of face splitting in the parametric space. 
1214
1215
1216 @subsection occt_shg_4_4 Customization of shapes
1217
1218 Customization tools are intended for adaptation of shape geometry in compliance with the customer needs. They modify a geometrical object to another one in the shape. 
1219
1220 To implement the necessary shape modification it is enough to initialize the appropriate tool by the shape and desirable parameters and to get the resulting shape. For example for conversion of indirect surfaces in the shape do the following:
1221
1222 ~~~~~
1223 TopoDS_Shape initialShape .. 
1224 TopoDS_Shape resultShape = ShapeCustom::DirectFaces(initialShape); 
1225 ~~~~~
1226
1227 @subsubsection occt_shg_4_4_1 Conversion of indirect surfaces.
1228
1229 ~~~~~
1230 ShapeCustom::DirectFaces 
1231         static TopoDS_Shape DirectFaces(const TopoDS_Shape& S); 
1232 ~~~~~ 
1233
1234 This method provides conversion of indirect elementary surfaces (elementary surfaces with left-handed coordinate systems) in the shape into direct ones. New 2d curves (recomputed for converted surfaces) are added to the same edges being shared by both the resulting shape and the original shape *S*. 
1235
1236 @subsubsection occt_shg_4_4_2 Shape Scaling 
1237
1238 ~~~~~
1239 ShapeCustom::ScaleShape 
1240         TopoDS_Shape ShapeCustom::ScaleShape(const TopoDS_Shape& S,
1241                 const Standard_Real scale); 
1242 ~~~~~
1243
1244 This method returns a new shape, which is a scaled original shape with a coefficient equal to the specified value of scale. It uses the tool *ShapeCustom_TrsfModification*. 
1245
1246 @subsubsection occt_shg_4_4_3 Conversion of curves and surfaces to BSpline
1247
1248 *ShapeCustom_BSplineRestriction* allows approximation of surfaces, curves and 2D curves with a specified degree, maximum number of segments, 2d tolerance and 3d tolerance. If the approximation result cannot be achieved with the specified continuity, the latter can be reduced. 
1249
1250 The method with all parameters looks as follows:
1251 ~~~~~
1252 ShapeCustom::BsplineRestriction 
1253         TopoDS_Shape ShapeCustom::BSplineRestriction (const TopoDS_Shape& S, 
1254                 const Standard_Real Tol3d, const Standard_Real Tol2d, 
1255                 const Standard_Integer MaxDegree, 
1256                 const Standard_Integer MaxNbSegment, 
1257                 const GeomAbs_Shape Continuity3d, 
1258                 const GeomAbs_Shape Continuity2d, 
1259                 const Standard_Boolean Degree, 
1260                 const Standard_Boolean Rational, 
1261                 const Handle(ShapeCustom_RestrictionParameters)& aParameters) 
1262 ~~~~~
1263                 
1264 It returns a new shape with all surfaces, curves and 2D curves of BSpline/Bezier type or based on them, converted with a degree less than *MaxDegree* or with a number of spans less then *NbMaxSegment* depending on the priority parameter *Degree*. If this parameter is equal to True then *Degree* will be increased to the value *GmaxDegree*, otherwise *NbMaxSegments* will be increased to the value *GmaxSegments*. *GmaxDegree* and *GMaxSegments* are the maximum possible degree and the number of spans correspondingly. These values will be used in cases when an approximation with specified parameters is impossible and either *GmaxDegree* or *GMaxSegments* is selected depending on the priority. 
1265
1266 Note that if approximation is impossible with *GMaxDegree*, even then the number of spans can exceed the specified *GMaxSegment*. *Rational* specifies whether Rational BSpline/Bezier should be converted into polynomial B-Spline. 
1267
1268 Also note that the continuity of surfaces in the resulting shape can be less than the given value. 
1269
1270 #### Flags
1271
1272 To convert other types of curves and surfaces to BSpline with required parameters it is necessary to use flags from class ShapeCustom_RestrictionParameters, which is just a container of flags. 
1273 The following flags define whether a specified-type geometry has been converted to BSpline with the required parameters: 
1274 * *ConvertPlane,* 
1275 * *ConvertBezierSurf,* 
1276 * *ConvertRevolutionSurf,* 
1277 * *ConvertExtrusionSurf,* 
1278 * *ConvertOffsetSurf,* 
1279 * *ConvertCurve3d,* - for conversion of all types of 3D curves. 
1280 * *ConvertOffsetCurv3d,* - for conversion of offset 3D curves. 
1281 * *ConvertCurve2d,* - for conversion of all types of 2D curves. 
1282 * *ConvertOffsetCurv2d,* - for conversion of offset 2D curves. 
1283 * *SegmentSurfaceMode* - defines whether the surface would be approximated within the boundaries of the face lying on this surface. 
1284
1285
1286
1287 @subsubsection occt_shg_4_4_4 Conversion of elementary surfaces into surfaces of revolution 
1288
1289 ~~~~~
1290 ShapeCustom::ConvertToRevolution()
1291         TopoDS_Shape ShapeCustom::ConvertToRevolution(const TopoDS_Shape& S) ; 
1292 ~~~~~
1293
1294 This method returns a new shape with all elementary periodic surfaces converted to *Geom_SurfaceOfRevolution*. It uses the tool *ShapeCustom_ConvertToRevolution*. 
1295
1296 @subsubsection occt_shg_4_4_5 Conversion of elementary surfaces into Bspline surfaces
1297
1298 ~~~~~
1299 ShapeCustom::ConvertToBSpline() 
1300         TopoDS_Shape ShapeCustom::ConvertToBSpline( const TopoDS_Shape& S, 
1301                 const Standard_Boolean extrMode, 
1302                 const Standard_Boolean revolMode, 
1303                 const Standard_Boolean offsetMode); 
1304 ~~~~~           
1305
1306 This method returns a new shape with all surfaces of linear extrusion, revolution and offset surfaces converted according to flags to *Geom_BSplineSurface* (with the same parameterization). It uses the tool *ShapeCustom_ConvertToBSpline*. 
1307
1308 @subsubsection occt_shg_4_4_6 Getting the history of modification of sub-shapes.
1309 If, in addition to the resulting shape, you want to get the history of modification of sub-shapes you should not use the package methods described above and should use your own code instead: 
1310 1. Create a tool that is responsible for the necessary modification. 
1311 2. Create the tool *BRepTools_Modifier* that performs a specified modification in the shape. 
1312 3. To get the history and to keep the assembly structure use the method *ShapeCustom::ApplyModifier*. 
1313
1314
1315 The general calling syntax for scaling is
1316 ~~~~~ 
1317 TopoDS_Shape scaled_shape = ShapeCustom::ScaleShape(shape, scale); 
1318 ~~~~~
1319
1320 Note that scale is a real value. You can refine your mapping process by using additional calls to follow shape mapping subshape by subshape. The following code along with pertinent includes can be used: 
1321
1322 ~~~~~
1323 p_Trsf T; 
1324 Standard_Real scale = 100; // for example! 
1325 T.SetScale (gp_Pnt (0, 0, 0), scale); 
1326 Handle(ShapeCustom_TrsfModification) TM = new 
1327 ShapeCustom_TrsfModification(T); 
1328 TopTools_DataMapOfShapeShape context; 
1329 BRepTools_Modifier MD; 
1330 TopoDS_Shape res = ShapeCustom::ApplyModifier ( 
1331 Shape, TM, context,MD ); 
1332 ~~~~~
1333
1334 The map, called context in our example, contains the history. 
1335 Substitutions are made one by one and all shapes are transformed. 
1336 To determine what happens to a particular subshape, it is possible to use: 
1337
1338 ~~~~~
1339 TopoDS_Shape oneres = context.Find (oneshape); 
1340 //In case there is a doubt, you can also add: 
1341 if (context.IsBound(oneshape)) oneres = context.Find(oneshape); 
1342 //You can also sweep the entire data map by using: 
1343 TopTools_DataMapIteratorOfDataMapOfShapeShape 
1344 //To do this, enter: 
1345 for(TopTools_DataMapIteratorOfDataMapOfShapeShape 
1346 iter(context);iter(more ();iter.next ()) { 
1347   TopoDs_Shape oneshape = iter.key (); 
1348   TopoDs_Shape oneres = iter.value (); 
1349
1350 ~~~~~
1351
1352
1353 @subsubsection occt_shg_4_4_7 Remove internal wires
1354
1355 *ShapeUpgrade_RemoveInternalWires* tool removes internal wires with contour area less than the specified minimal area. It can work with compounds, solids, shells and faces.
1356
1357 If the flag *RemoveFaceMode* is set to TRUE, separate faces or a group of faces with outer wires, which consist only of edges that belong to the removed internal wires, are removed (seam edges are not taken into account). Such faces can be removed only for a sewed shape.
1358
1359 Internal wires can be removed   by the methods *Perform*.  Both methods *Perform* can not be carried out if the class has not been initialized by the shape. In such case the status of *Perform* is set to FAIL . 
1360
1361 The method *Perform* without arguments removes from all faces in the specified shape internal wires whose area is less than the minimal area.
1362
1363 The other method *Perform* has a sequence of shapes as an argument. This sequence can contain faces or wires. 
1364 If the sequence of shapes contains wires, only the internal wires are removed.
1365
1366 If the sequence of shapes contains faces, only the internal wires from these faces are removed. 
1367
1368 *       The status of the performed operation can be obtained using  method *Status()*;
1369 *       The resulting shape can be obtained using  method *GetResult()*.
1370
1371 An example of using this tool is presented in the figures below: 
1372
1373 @image html /user_guides/shape_healing/images/shape_healing_image005.png "Source Face"
1374 @image latex /user_guides/shape_healing/images/shape_healing_image005.png "Source Face"
1375 @image html /user_guides/shape_healing/images/shape_healing_image006.png "Resulting shape"
1376 @image latex /user_guides/shape_healing/images/shape_healing_image006.png "Resulting shape"
1377
1378 After the processing three internal wires with contour area less than the specified minimal area have been removed. One internal face has been removed. The outer wire of this face consists of the edges belonging to the removed internal wires and a seam edge. 
1379 Two other internal faces have not been removed because their outer wires consist not only of edges belonging to the removed wires.
1380
1381 @image html /user_guides/shape_healing/images/shape_healing_image007.png "Source Face"
1382 @image latex /user_guides/shape_healing/images/shape_healing_image007.png "Source Face"
1383
1384 @image html /user_guides/shape_healing/images/shape_healing_image008.png "Resulting shape"
1385 @image latex /user_guides/shape_healing/images/shape_healing_image008.png "Resulting shape"
1386
1387 After the processing six internal wires with contour area less than the specified minimal area have been removed. Six internal faces have been removed. These faces can be united into groups of faces. Each group of faces has an outer wire consisting only of edges belonging to the removed internal wires. Such groups of faces are also removed. 
1388
1389 The example of method application is also given below:
1390
1391 ~~~~~
1392 //Initialization of the class by shape. 
1393 Handle(ShapeUpgrade_RemoveInternalWires) aTool = new ShapeUpgrade_RemoveInternalWires(inputShape); 
1394 //setting parameters 
1395 aTool->MinArea() = aMinArea; 
1396 aTool->RemoveFaceMode() = aModeRemoveFaces; 
1397  
1398 //when method Perform is carried out on separate shapes. 
1399 aTool->Perform(aSeqShapes); 
1400  
1401 //when method Perform is carried out on whole shape. 
1402 aTool->Perform(); 
1403 //check status set after method Perform 
1404 if(aTool->Status(ShapeExtend_FAIL) { 
1405   cout<<"Operation failed"<< <<"\n"; 
1406    return; 
1407
1408
1409 if(aTool->Status(ShapeExtend_DONE1)) { 
1410     const TopTools_SequenceOfShape& aRemovedWires =aTool->RemovedWires(); 
1411      cout<<aRemovedWires.Length()<<" internal wires were removed"<<"\n"; 
1412     
1413   } 
1414
1415   if(aTool->Status(ShapeExtend_DONE2)) { 
1416     const TopTools_SequenceOfShape& aRemovedFaces =aTool->RemovedFaces(); 
1417      cout<<aRemovedFaces.Length()<<" small faces were removed"<<"\n"; 
1418     
1419   }   
1420     //getting result shape 
1421   TopoDS_Shape res = aTool->GetResult(); 
1422 ~~~~~
1423
1424 @subsubsection occt_shg_4_4_8 Conversion of surfaces 
1425
1426 Class ShapeCustom_Surface allows:
1427   * converting BSpline and Bezier surfaces to the analytical form (using method *ConvertToAnalytical())*
1428   * converting closed B-Spline surfaces to periodic ones.(using method *ConvertToPeriodic*)
1429   
1430 To convert surfaces to analytical form this class analyzes the form and the closure of the source surface and defines whether it can be approximated by analytical surface of one of the following types: 
1431 *       *Geom_Plane,*
1432 *       *Geom_SphericalSurface,*
1433 *       *Geom_CylindricalSurface,* 
1434 *       *Geom_ConicalSurface,* 
1435 *       *Geom_ToroidalSurface*.
1436  
1437 The conversion is done only if the new (analytical) surface does not deviate from the source one more than by the given precision. 
1438
1439 ~~~~~
1440 Handle(Geom_Surface) initSurf; 
1441 ShapeCustom_Surface ConvSurf(initSurf); 
1442 //conversion to analytical form 
1443 Handle(Geom_Surface) newSurf  = ConvSurf.ConvertToAnalytical(allowedtol,Standard_False); 
1444 //or conversion to a periodic surface 
1445 Handle(Geom_Surface) newSurf  = ConvSurf.ConvertToPeriodic(Standard_False); 
1446 //getting the maximum deviation of the new surface from the initial surface 
1447 Standard_Real maxdist = ConvSurf.Gap(); 
1448 ~~~~~
1449
1450 @subsubsection occt_shg_4_4_9 Unify Same Domain
1451
1452 *ShapeUpgrade_UnifySameDomain* tool allows unifying all possible faces and edges of a shape, which lies on the same geometry. Faces/edges are considered as 'same-domain' if the neighboring faces/edges lie on coincident surfaces/curves.  Such faces/edges can be unified into one face/edge.
1453 This tool takes an input shape and returns a new one. All modifications of the initial shape are recorded during the operation.
1454  
1455 The following options are available:
1456
1457   * If the flag *UnifyFaces* is set to TRUE, *UnifySameDomain* tries to unify all possible faces;
1458   * If the flag *UnifyEdges* is set to TRUE, *UnifySameDomain* tries to unify all possible edges;
1459   * if the flag *ConcatBSplines* is set to TRUE, all neighboring edges, which lie on the BSpline or Bezier curves with C1 continuity on their common vertices will be merged into one common edge. 
1460
1461 By default, *UnifyFaces* and *UnifyEdges* are set to TRUE; *ConcatBSplines* is set to FALSE.
1462
1463 The common methods of this tool are as follows:
1464  
1465   * Method *Build()* is used to unify.
1466   * Method *Shape()* is used to get the resulting shape.
1467   * Method *Generated()* is used to get a new common shape from the old shape. If a group of edges has been unified into one common edge then method *Generated()* called on any edge from this group will return the common edge. The same goes for the faces.
1468
1469 The example of the usage is given below:
1470 ~~~~~
1471  // 'Sh' is the initial shape
1472  ShapeUpgrade_UnifySameDomain USD(Sh, true, true, true); // UnifyFaces mode on, UnifyEdges mode on, ConcatBSplines mode on.
1473  USD.Build();
1474  //get the result
1475  TopoDS_Shape Result = USD.Shape(); 
1476  //Let Sh1 as a part of Sh
1477  //get the new (probably unified) shape form the Sh1
1478  TopoDS_Shape ResSh1 = USD.Generated(Sh1);
1479 ~~~~~ 
1480
1481 @section occt_shg_5_ Auxiliary tools for repairing, analysis and upgrading
1482
1483 @subsection occt_shg_5_1 Tool for rebuilding shapes
1484
1485   Class *ShapeBuild_ReShape* rebuilds a shape by making predefined substitutions on some of its components. During the first phase, it records requests to replace or remove some individual shapes. For each shape, the last given request is recorded. Requests may be applied as *Oriented* (i.e. only to an item with the same orientation) or not (the orientation of the replacing shape corresponds to that of the original one). Then these requests may be applied to any shape, which may contain one or more of these individual shapes. 
1486
1487 This tool has a flag for taking the location of shapes into account (for keeping the structure of assemblies) (*ModeConsiderLocation*). If this mode is equal to Standard_True, the shared shapes with locations will be kept. If this mode is equal to Standard_False, some different shapes will be produced from one shape with different locations after rebuilding. By default, this mode is equal to Standard_False. 
1488
1489 To use this tool for the reconstruction of shapes it is necessary to take the following steps:
1490 1. Create this tool and use method *Apply()* for its initialization by the initial shape. Parameter *until* sets the level of shape type and requests are taken into account up to this level only. Sub-shapes of the type standing beyond the *line* set by parameter until will not be rebuilt and no further exploration will be done 
1491 2. Replace or remove sub-shapes of the initial shape. Each sub-shape can be replaced by a shape of the same type or by shape containing shapes of that type only (for example, *TopoDS_Edge* can be replaced by *TopoDS_Edge, TopoDS_Wire* or *TopoDS_Compound* containing *TopoDS_Edges*). If an incompatible shape type is encountered, it is ignored and flag FAIL1 is set in Status. 
1492 For a sub-shape it is recommended to use method *Apply* before methods *Replace* and *Remove*, because the sub-shape has already been changed for the moment by its previous modifications or modification of its sub-shape (for example *TopoDS_Edge* can be changed by a modification of its *TopoDS_Vertex*, etc.). 
1493 3. Use method *Apply* for the initial shape again to get the resulting shape after all modifications have been made.
1494 4. Use method *Apply* to obtain the history of sub-shape modification.
1495
1496 **Note** that in fact class *ShapeBuild_ReShape* is an alias for class *BRepTools_ReShape*. They differ only in queries of statuses in the *ShapeBuild_ReShape* class. 
1497
1498 Let us use the tool to get the result shape after modification of sub-shapes of the initial shape:
1499
1500 ~~~~~ 
1501 TopoDS_Shape initialShape… 
1502 //creation of a rebuilding tool 
1503 Handle(ShapeBuild_ReShape) Context = new ShapeBuild_ReShape. 
1504
1505 //next step is optional. It can be used for keeping the assembly structure. 
1506 Context-> ModeConsiderLocation = Standard_True; 
1507
1508 //initialization of this tool by the initial shape 
1509 Context->Apply(initialShape); 
1510 … 
1511 //getting the intermediate result for replacing subshape1 with the modified subshape1. 
1512 TopoDS_Shape tempshape1 = Context->Apply(subshape1); 
1513
1514 //replacing the intermediate shape obtained from subshape1 with the newsubshape1. 
1515 Context->Replace(tempsubshape1,newsubshape1); 
1516 … 
1517 //for removing the subshape 
1518 TopoDS_Shape tempshape2 = Context->Apply(subshape2); 
1519 Context->Remove(tempsubshape2); 
1520
1521 //getting the result and the history of modification 
1522 TopoDS_Shape resultShape = Context->Apply(initialShape); 
1523
1524 //getting the resulting subshape from the subshape1 of the initial shape. 
1525 TopoDS_Shape result_subshape1 = Context->Apply(subshape1); 
1526 ~~~~~
1527
1528 @subsection occt_shg_5_2 Status definition
1529
1530 *ShapExtend_Status* is used to report the status after executing some methods that can either fail, do something, or do nothing. The status is a set of flags *DONEi* and *FAILi*. Any combination of them can be set at the same time. For exploring the status, enumeration is used. 
1531
1532 The values have the following meaning: 
1533
1534 | Value | Meaning |
1535 | :----- | :----------------- |
1536 | *OK,*     |  Nothing is done, everything OK |
1537 | *DONE1,*  |  Something was done, case 1 |
1538 | *DONE8*,  |  Something was done, case 8 |
1539 | *DONE*,   |  Something was done (any of DONE#) |
1540 | *FAIL1*,  |  The method failed, case 1 |
1541 | *FAIL8*,  |  The method failed, case 8 |
1542 | *FAIL*    |  The method failed (any of FAIL# occurred) |
1543
1544
1545 @subsection occt_shg_5_3 Tool representing a wire 
1546 Class *ShapeExtend_WireData* provides a data structure necessary to work with the wire as with an ordered list of edges, and that is required for many algorithms. The advantage of this class is that it allows to work with incorrect wires. 
1547
1548 The object of the class *ShapeExtend_WireData* can be initialized by *TopoDS_Wire* and converted back to *TopoDS_Wire*. 
1549
1550 An edge in the wire is defined by its rank number. Operations of accessing, adding and removing an edge at/to the given rank number are provided. Operations of circular permutation and reversing (both orientations of all edges and the order of edges) are provided on the whole wire as well. 
1551
1552 This class also provides a method to check if the edge in the wire is a seam (if the wire lies on a face). 
1553
1554 Let us remove edges from the wire and define whether it is seam edge 
1555
1556 ~~~~~
1557 TopoDS_Wire ini = .. 
1558 Handle(ShapeExtend_Wire) asewd = new ShapeExtend_Wire(initwire); 
1559 //Removing edge Edge1 from the wire. 
1560
1561 Standard_Integer index_edge1 = asewd->Index(Edge1); 
1562 asewd.Remove(index_edge1); 
1563 //Definition of whether Edge2 is a seam edge 
1564 Standard_Integer index_edge2 = asewd->Index(Edge2); 
1565 asewd->IsSeam(index_edge2); 
1566 ~~~~~
1567
1568
1569 @subsection occt_shg_5_4 Tool for exploring shapes 
1570 Class *ShapeExtend_Explorer* is intended to explore shapes and convert different representations (list, sequence, compound) of complex shapes. It provides tools for: 
1571   * obtaining the type of the shapes in the context of *TopoDS_Compound*, 
1572   * exploring shapes in the context of *TopoDS_Compound*, 
1573   * converting different representations of shapes (list, sequence, compound). 
1574   
1575 @subsection occt_shg_5_5 Tool for attaching messages to objects 
1576 Class *ShapeExtend_MsgRegistrator* attaches messages to objects (generic Transient or shape). The objects of this class are transmitted to the Shape Healing algorithms so that they could collect messages occurred during shape processing. Messages are added to the Maps (stored as a field) that can be used, for instance, by Data Exchange processors to attach those messages to initial file entities. 
1577
1578 Let us send and get a message attached to object:
1579
1580 ~~~~~ 
1581 Handle(ShapeExtend_MsgRegistrator) MessageReg = new ShapeExtend_MsgRegistrator; 
1582 //attaches messages to an object (shape or entity) 
1583 Message_Msg msg.. 
1584 TopoDS_Shape Shape1… 
1585 MessageReg->Send(Shape1,msg,Message_WARNING); 
1586 Handle(Standard_Transient) ent .. 
1587 MessageReg->Send(ent,msg,Message_WARNING); 
1588 //gets messages attached to shape 
1589 const ShapeExtend_DataMapOfShapeListOfMsg& msgmap = MessageReg->MapShape(); 
1590 if (msgmap.IsBound (Shape1)) { 
1591  const Message_ListOfMsg &msglist = msgmap.Find (Shape1); 
1592  for (Message_ListIteratorOfListOfMsg iter (msglist); 
1593 iter.More(); iter.Next()) { 
1594        Message_Msg msg = iter.Value(); 
1595  } 
1596     } 
1597 ~~~~~
1598
1599 @subsection occt_shg_5_6 Tools for performance measurement
1600
1601 Classes *MoniTool_Timer* and *MoniTool_TimerSentry* are used for measuring the performance of a current operation or any part of code, and provide the necessary API. Timers are used for debugging and performance optimizing purposes. 
1602
1603 Let us try to use timers in *XSDRAWIGES.cxx* and *IGESBRep_Reader.cxx* to analyse the performance of command *igesbrep*:
1604
1605 ~~~~~
1606 XSDRAWIGES.cxx
1607   ...
1608   #include <MoniTool_Timer.hxx>
1609   #include <MoniTool_TimerSentry.hxx>
1610   ...
1611   MoniTool_Timer::ClearTimers();
1612   ...
1613   MoniTool_TimerSentry MTS("IGES_LoadFile");
1614   Standard_Integer status = Reader.LoadFile(fnom.ToCString());
1615   MTS.Stop();
1616   ...
1617   MoniTool_Timer::DumpTimers(cout);
1618   return;
1619                                                                                 
1620                         
1621 IGESBRep_Reader.cxx
1622   ...
1623   #include <MoniTool_TimerSentry.hxx>
1624   ...
1625   Standard_Integer nb = theModel->NbEntities();
1626   ...
1627   for (Standard_Integer i=1; i<=nb; i++) {
1628     MoniTool_TimerSentry MTS("IGESToBRep_Transfer");
1629     ...
1630     try {
1631       TP.Transfer(ent);
1632       shape = TransferBRep::ShapeResult (theProc,ent);
1633     }
1634     ...
1635   }
1636 ~~~~~
1637
1638 The result of *DumpTimer()* after file translation is as follows: 
1639
1640 | TIMER | Elapsed | CPU User | CPU Sys | Hits |
1641 | :--- | :---- | :----- | :---- | :---- |
1642 | *IGES_LoadFile* | 1.0 sec |  0.9 sec | 0.0 sec | 1 |  
1643 | *IGESToBRep_Transfer* | 14.5 sec | 4.4 sec | 0.1 sec | 1311 |
1644
1645
1646 @section occt_shg_6 Shape Processing
1647
1648 @subsection occt_shg_6_1 Usage Workflow
1649
1650 The Shape Processing module allows defining and applying the general Shape Processing as a customizable sequence of Shape Healing operators. The customization is implemented via the user-editable resource file, which defines the sequence of operators to be executed and their parameters. 
1651
1652 The Shape Processing functionality is implemented with the help of the *XSAlgo* interface. The main function *XSAlgo_AlgoContainer::ProcessShape()* does shape processing with specified tolerances and returns the resulting shape and associated information in the form of *Transient*. 
1653
1654 This function is used in the following way:
1655
1656 ~~~~~
1657 TopoDS_Shape aShape = …; 
1658 Standard_Real Prec = …, 
1659 Standard_Real MaxTol = …; 
1660 TopoDS_Shape aResult; 
1661 Handle(Standard_Transient) info; 
1662 TopoDS_Shape aResult = XSAlgo::AlgoContainer()->ProcessShape(aShape, Prec, MaxTol., "Name of ResourceFile", "NameSequence", info ); 
1663 ~~~~~
1664
1665 Let us create a custom sequence of operations: 
1666
1667 1. Create a resource file with the name *ResourceFile*, which includes the following string: 
1668 ~~~~~
1669 NameSequence.exec.op:    MyOper 
1670 ~~~~~
1671 where *MyOper* is the name of operation. 
1672 2. Input a custom parameter for this operation in the resource file, for example: 
1673 ~~~~~
1674 NameSequence.MyOper.Tolerance: 0.01 
1675 ~~~~~
1676 where *Tolerance* is the name of the parameter and 0.01 is its value. 
1677 3. Add the following string into *void ShapeProcess_OperLibrary::Init()*: 
1678 ~~~~~
1679 ShapeProcess::RegisterOperator(;MyOper;, 
1680 new ShapeProcess_UOperator(myfunction)); 
1681 ~~~~~
1682 where *myfunction* is a function which implements the operation. 
1683 4. Create this function in *ShapeProcess_OperLibrary* as follows:
1684 ~~~~~
1685 static Standard_Boolean myfunction (const 
1686                         Handle(ShapeProcess_Context)& context) 
1687
1688         Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast(context); 
1689   if(ctx.IsNull()) return Standard_False; 
1690   TopoDS_Shape aShape = ctx->Result(); 
1691   //receive our parameter: 
1692   Standard_Real toler; 
1693   ctx->GetReal(;Tolerance;, toler);
1694 ~~~~~
1695 5. Make the necessary operations with *aShape* using the received value of parameter *Tolerance* from the resource file. 
1696 ~~~~~
1697   return Standard_True; 
1698
1699 ~~~~~
1700 6. Define some operations (with their parameters) *MyOper1, MyOper2, MyOper3*, etc. and describe the corresponding functions in *ShapeProcess_OperLibrary*. 
1701 7. Perform the required sequence using the specified name of operations and values of parameters in the resource file. 
1702
1703 For example: input of the following string:
1704 ~~~~~
1705 NameSequence.exec.op:    MyOper1,MyOper3 
1706 ~~~~~
1707 means that the corresponding functions from *ShapeProcess_OperLibrary* will be performed with the original shape *aShape* using parameters defined for *MyOper1* and *MyOper3* in the resource file. 
1708
1709 It is necessary to note that these operations will be performed step by step and the result obtained after performing the first operation will be used as the initial shape for the second operation. 
1710
1711 @subsection occt_shg_6_2 Operators
1712
1713 ### DirectFaces 
1714 This operator sets all faces based on indirect surfaces, defined with left-handed coordinate systems as direct faces. This concerns surfaces defined by Axis Placement (Cylinders, etc). Such Axis Placement may be indirect, which is allowed in Cascade, but not allowed in some other systems. This operator reverses indirect placements and recomputes PCurves accordingly. 
1715
1716 ### SameParameter
1717 This operator is required after calling some other operators, according to the computations they do. Its call is explicit, so each call can be removed according to the operators, which are either called or not afterwards. This mainly concerns splitting operators that can split edges. 
1718
1719 The operator applies the computation *SameParameter* which ensures that various representations of each edge (its 3d curve, the pcurve on each of the faces on which it lies) give the same 3D point for the same parameter, within a given tolerance.  
1720 * For each edge coded as *same parameter*, deviation of curve representation is computed and if the edge tolerance is less than that deviation, the tolerance is increased so that it satisfies the deviation. No geometry modification, only an increase of tolerance is possible.  
1721 * For each edge coded as *not same parameter* the deviation is computed as in the first case. Then an attempt is made to achieve the edge equality to *same parameter* by means of modification of 2d curves. If the deviation of this modified edge is less than the original deviation then this edge is returned, otherwise the original edge (with non-modified 2d curves) is returned with an increased (if necessary) tolerance.  Computation is done by call to the standard algorithm *BRepLib::SameParameter*. 
1722
1723 This operator can be called with the following parameters: 
1724         * *Boolean : Force* (optional) - if True, encodes all edges as *not same parameter* then runs the computation. Else, the computation is done only for those edges already coded as *not same parameter*. 
1725         * *Real : Tolerance3d* (optional) - if not defined, the local tolerance of each edge is taken for its own computation. Else, this parameter gives the global tolerance for the whole shape.
1726         
1727 ### BSplineRestriction
1728
1729 This operator is used for conversion of surfaces, curves 2d curves to BSpline surfaces with a specified degree and a specified number of spans. It performs approximations on surfaces, curves and 2d curves with a specified degree, maximum number of segments, 2d tolerance, 3d tolerance. The specified continuity can be reduced if the approximation with a specified continuity was not done successfully. 
1730
1731 This operator can be called with the following parameters: 
1732 * *Boolean : SurfaceMode* allows considering the surfaces; 
1733 * *Boolean : Curve3dMode*  allows considering the 3d curves; 
1734 * *Boolean : Curve2dMode* allows considering the 2d curves; 
1735 * *Real : Tolerance3d* defines 3d tolerance to be used in computation; 
1736 * *Real : Tolerance2d* defines 2d tolerance to be used when computing 2d curves; 
1737 * *GeomAbs_Shape (C0 G1 C1 G2 C2 CN) : Continuity3d* is the continuity required in 2d; 
1738 * *GeomAbs_Shape (C0 G1 C1 G2 C2 CN) : Continuity2d* is the continuity required in 3d; 
1739 * *Integer : RequiredDegree* gives the required degree;
1740 * *Integer : RequiredNbSegments* gives the required number of segments;
1741 * *Boolean : PreferDegree* if true, *RequiredDegree* has a priority, else *RequiredNbSegments* has a priority;
1742 * *Boolean : RationalToPolynomial*  serves for conversion of BSplines to polynomial form; 
1743 * *Integer : MaxDegree* gives the maximum allowed Degree, if *RequiredDegree* cannot be reached; 
1744 * *Integer : MaxNbSegments* gives the maximum allowed NbSegments, if *RequiredNbSegments* cannot be reached.
1745  
1746 The following flags allow managing the conversion of special types of curves or surfaces, in addition to BSpline. They are controlled by *SurfaceMode, Curve3dMode* or *Curve2dMode* respectively; by default, only BSplines and Bezier Geometries are considered:
1747 * *Boolean : OffsetSurfaceMode*  
1748 * *Boolean : LinearExtrusionMode*  
1749 * *Boolean : RevolutionMode*  
1750 * *Boolean : OffsetCurve3dMode* 
1751 * *Boolean : OffsetCurve2dMode* 
1752 * *Boolean : PlaneMode* 
1753 * *Boolean : BezierMode* 
1754 * *Boolean : ConvCurve3dMode* 
1755 * *Boolean : ConvCurve2dMode* 
1756
1757 For each of the Mode parameters listed above, if it is True, the specified geometry is converted to BSpline, otherwise only its basic geometry is checked and converted (if necessary) keeping the original type of geometry (revolution, offset, etc). 
1758
1759 * *Boolean :SegmentSurfaceMode* has effect only for Bsplines and Bezier surfaces. When False a surface will be replaced by a Trimmed Surface, else new geometry will be created by splitting the original Bspline or Bezier surface. 
1760
1761 ### ElementaryToRevolution
1762
1763 This operator converts elementary periodic surfaces to SurfaceOfRevolution. 
1764
1765 ### SplitAngle
1766
1767 This operator splits surfaces of revolution, cylindrical, toroidal, conical, spherical surfaces in the given shape so that each resulting segment covers not more than the defined number of degrees. 
1768
1769 It can be called with the following parameters: 
1770 * *Real : Angle* - the maximum allowed angle for resulting faces; 
1771 *  *Real : MaxTolerance* - the maximum tolerance used in computations.
1772  
1773 ### SurfaceToBSpline
1774 This operator converts some specific types of Surfaces, to BSpline (according to parameters). 
1775 It can be called with the following parameters: 
1776 * *Boolean : LinearExtrusionMode* allows converting surfaces of Linear Extrusion; 
1777 * *Boolean : RevolutionMode* allows converting surfaces of Revolution; 
1778 * *Boolean : OffsetMode* allows converting Offset Surfaces 
1779
1780 ### ToBezier
1781
1782 This operator is used for data supported as Bezier only  and converts various types of geometries to Bezier. It can be called with the following parameters used in computation of conversion :  
1783 * *Boolean : SurfaceMode*  
1784 * *Boolean : Curve3dMode*  
1785 * *Boolean : Curve2dMode*  
1786 * *Real : MaxTolerance* 
1787 * *Boolean : SegmentSurfaceMode* (default is True) has effect only for Bsplines and Bezier surfaces. When False a surface will be replaced by a Trimmed Surface, else new geometry will be created by splitting the original Bspline or Bezier surface. 
1788
1789 The following parameters are controlled by *SurfaceMode, Curve3dMode* or *Curve2dMode* (according to the case): 
1790 * *Boolean : Line3dMode*  
1791 * *Boolean : Circle3dMode*  
1792 * *Boolean : Conic3dMode*  
1793 * *Boolean : PlaneMode*  
1794 * *Boolean : RevolutionMode*  
1795 * *Boolean : ExtrusionMode*  
1796 * *Boolean : BSplineMode* 
1797
1798 ### SplitContinuity
1799 This operator splits a shape in order to have each geometry (surface, curve 3d, curve 2d) correspond the given criterion of continuity. It can be called with the following parameters: 
1800 * *Real : Tolerance3d*  
1801 * *Integer (GeomAbs_Shape ) : CurveContinuity*  
1802 * *Integer (GeomAbs_Shape ) : SurfaceContinuity*  
1803 * *Real : MaxTolerance* 
1804
1805 Because of algorithmic limitations in the operator *BSplineRestriction* (in some particular cases, this operator can produce unexpected C0 geometry), if *SplitContinuity* is called, it is recommended to call it after *BSplineRestriction*. 
1806 Continuity Values will be set as *GeomAbs_Shape* (i.e. C0 G1 C1 G2 C2 CN) besides direct integer values (resp. 0 1 2 3 4 5). 
1807
1808 ### SplitClosedFaces
1809 This operator splits faces, which are closed even if they are not revolutionary or cylindrical, conical, spherical, toroidal. This corresponds to BSpline or Bezier surfaces which can be closed (whether periodic or not), hence they have a seam edge.  As a result, no more seam edges remain. The number of points allows to control the minimum count of faces to be produced per input closed face. 
1810
1811 This operator can be called with the following parameters: 
1812 * *Integer : NbSplitPoints* gives the number of points to use for splitting (the number of intervals produced is *NbSplitPoints+1*); 
1813 * *Real : CloseTolerance* tolerance used to determine if a face is closed;  
1814 * *Real : MaxTolerance* is used in the computation of splitting.
1815  
1816 ### FixGaps
1817
1818 This operator must be called when *FixFaceSize* and/or *DropSmallEdges* are called. Using Surface Healing may require an additional call to *BSplineRestriction* to ensure that modified geometries meet the requirements for BSpline. 
1819 This operators repairs geometries which contain gaps between edges in wires (always performed) or gaps on faces, controlled by parameter *SurfaceMode*, Gaps on Faces are fixed by using algorithms of Surface Healing 
1820 This operator can be called with the following parameters: 
1821 * *Real : Tolerance3d* sets the tolerance to reach in 3d. If a gap is less than this value, it is not fixed. 
1822 * *Boolean : SurfaceMode* sets the mode of fixing gaps between edges and faces (yes/no) ;
1823 * *Integer : SurfaceAddSpans* sets the number of spans to add to the surface in order to fix gaps ;
1824 * *GeomAbs_Shape (C0 G1 C1 G2 C2 CN) : SurfaceContinuity* sets the minimal continuity of a resulting surface ;
1825 * *Integer : NbIterations* sets the number of iterations 
1826 * *Real : Beta* sets the elasticity coefficient for modifying a surface [1-1000] ;
1827 * *Reals : Coeff1 to Coeff6* sets energy coefficients for modifying a surface [0-10000] ;
1828 * *Real : MaxDeflection*  sets maximal deflection of surface from an old position. 
1829
1830 This operator may change the original geometry. In addition, it is CPU consuming, and it may fail in some cases.  Also **FixGaps** can help only when there are gaps obtained as a result of removal of small edges that can be removed by **DropSmallEdges** or **FixFaceSize**. 
1831
1832 ### FixFaceSize
1833 This operator  removes faces, which are small in all directions (spot face) or small in one direction (strip face). It can be called with the parameter *Real : Tolerance*, which sets the minimal dimension, which is used to consider a face, is small enough to be removed. 
1834
1835 ### DropSmallEdges
1836 This operator drops edges in a wire, and merges them with adjacent edges, when they are smaller than the given value (*Tolerance3d*) and when the topology allows such merging (i.e. same adjacent faces for each of the merged edges). Free (non-shared by adjacent faces) small edges can be also removed in case if they share the same vertex Parameters. 
1837
1838 It can be called with the parameter *Real : Tolerance3d*, which sets the dimension used to determine if an edge is small. 
1839
1840 ### FixShape
1841
1842 This operator may be added for fixing invalid shapes. It performs various checks and fixes, according to the modes listed hereafter. Management of a set of fixes can be performed by flags as follows: 
1843 * if the flag for a fixing tool is set to 0 , it is not performed;
1844 * if set to 1 , it is performed in any case;
1845 * if not set, or set to -1 , for each shape to be applied on, a check is done to evaluate whether a fix is needed. The fix is performed if the check is positive.
1846  
1847 By default, the flags are not set, the checks are carried out each individual shape. 
1848
1849 This operator can be called with the following parameters: 
1850 * *Real : Tolerance3d* sets basic tolerance used for fixing; 
1851 * *Real : MaxTolerance3d* sets maximum allowed value for the resulting tolerance; 
1852 * *Real : MinTolerance3d* sets minimum allowed value for the resulting tolerance. 
1853 * *Boolean : FixFreeShellMode*
1854 * *Boolean : FixFreeFaceMode*  
1855 * *Boolean : FixFreeWireMode*  
1856 * *Boolean : FixSameParameterMode*
1857 * *Boolean : FixSolidMode*
1858 * *Boolean : FixShellMode*
1859 * *Boolean : FixFaceMode*
1860 * *Boolean : FixWireMode*
1861 * *Boolean : FixOrientationMode*
1862 * *Boolean : FixMissingSeamMode*
1863 * *Boolean : FixSmallAreaWireMode* 
1864 * *Boolean (not checked) : ModifyTopologyMode* specifies the mode for modifying topology. Should be False (default) for shapes with shells and can be True for free faces. 
1865 * *Boolean (not checked) : ModifyGeometryMode* specifies the mode for modifying geometry. Should be False if geometry is to be kept and True if it can be modified. 
1866 * *Boolean (not checked) : ClosedWireMode*  specifies the mode for wires. Should be True for wires on faces and False for free wires. 
1867 * *Boolean (not checked) : PreferencePCurveMode (not used)* specifies the preference of 3d or 2d representations for an edge 
1868 * *Boolean : FixReorderMode*  
1869 * *Boolean : FixSmallMode*  
1870 * *Boolean : FixConnectedMode*  
1871 * *Boolean : FixEdgeCurvesMode*  
1872 * *Boolean : FixDegeneratedMode*  
1873 * *Boolean : FixLackingMode*  
1874 * *Boolean : FixSelfIntersectionMode*  
1875 * *Boolean : FixGaps3dMode*  
1876 * *Boolean : FixGaps2dMode*  
1877 * *Boolean : FixReversed2dMode*  
1878 * *Boolean : FixRemovePCurveMode*  
1879 * *Boolean : FixRemoveCurve3dMode*  
1880 * *Boolean : FixAddPCurveMode*  
1881 * *Boolean : FixAddCurve3dMode*  
1882 * *Boolean : FixSeamMode* 
1883 * *Boolean : FixShiftedMode* 
1884 * *Boolean : FixEdgeSameParameterMode*
1885 * *Boolean : FixSelfIntersectingEdgeMode* 
1886 * *Boolean : FixIntersectingEdgesMode*  
1887 * *Boolean : FixNonAdjacentIntersectingEdgesMode* 
1888
1889 ### SplitClosedEdges
1890 This operator handles closed edges i.e. edges with one vertex. Such edges are not supported in some receiving systems. This operator  splits topologically closed edges (i.e. edges having one vertex) into two edges. Degenerated edges and edges with a size of less than Tolerance are not processed. 
1891
1892 @section occt_shg_7 Messaging mechanism
1893
1894 Various messages about modification, warnings and fails can be generated in the process of shape fixing or upgrade. The messaging mechanism allows generating messages, which will be sent to the chosen target medium  a file or the screen. The messages may report failures and/or warnings or provide information on events such as analysis, fixing or upgrade of shapes. 
1895
1896 @subsection occt_shg_7_1  Message Gravity
1897 Enumeration *Message_Gravity* is used for defining message gravity. 
1898 It provides the following message statuses: 
1899 * *Message_FAIL* - the message reports a fail;
1900 * *Message_WARNING*  - the message reports a warning;
1901 * *Message_INFO* - the message supplies information. 
1902
1903 @subsection occt_shg_7_2 Tool for loading a message file into memory
1904 Class *Message_MsgFile* allows defining messages by loading a custom message file into memory. It is necessary to create a custom message file before loading it into memory, as its path will be used as the argument to load it. Each message in the message file is identified by a key. The user can get the text content of the message by specifying the message key. 
1905
1906 ### Format of the message file
1907
1908 The message file is an ASCII file, which defines a set of messages. Each line of the file must have a length of less than 255 characters.  
1909 All lines in the file starting with the exclamation sign (perhaps preceded by spaces and/or tabs) are considered as comments and are ignored. 
1910 A message file may contain several messages. Each message is identified by its key (string). 
1911 Each line in the file starting with the *dot* character (perhaps preceded by spaces and/or tabs) defines the key. The key is a string starting with a symbol placed after the dot and ending with the symbol preceding the ending of the newline character <i>\\n.</i> 
1912 All lines in the file after the key and before the next keyword (and which are not comments) define the message for that key. If the message consists of several lines, the message string will contain newline symbols <i>\\n</i> between each line (but not at the end). 
1913
1914 The following example illustrates the structure of a message file: 
1915
1916 ~~~~~
1917 !This is a sample message file 
1918 !------------------------------ 
1919 !Messages for ShapeAnalysis package 
1920
1921 .SampleKeyword 
1922 Your message string goes here 
1923
1924 !... 
1925
1926 !End of the message file 
1927 ~~~~~
1928
1929 ### Loading the message file
1930
1931 A custom file can be loaded into memory using the method *Message_MsgFile::LoadFile*, taking as an argument the path to your file as in the example below: 
1932 ~~~~~
1933 Standard_CString MsgFilePath = ;(path)/sample.file;; 
1934 Message_MsgFile::LoadFile (MsgFilePath); 
1935 ~~~~~
1936
1937 @subsection occt_shg_7_3 Tool for managing filling messages 
1938
1939 The class *Message_Msg* allows using the message file loaded as a template. This class provides a tool for preparing the message, filling it with parameters, storing and outputting to the default trace file. 
1940 A message is created from a key: this key identifies the message to be created in the message file. The text of the message is taken from the loaded message file (class *Message_MsgFile* is used). 
1941 The text of the message can contain places for parameters, which are to be filled by the proper values when the message is prepared. These parameters can be of the following types: 
1942 * string - coded in the text as \%s, 
1943 * integer - coded in the text as \%d, 
1944 * real - coded in the text as \%f. 
1945 The parameter fields are filled by the message text by calling the corresponding methods *AddInteger, AddReal* and *AddString*. Both the original text of the message and the input text with substituted parameters are stored in the object. The prepared and filled message can be output to the default trace file. The text of the message (either original or filled) can be also obtained. 
1946 ~~~~~
1947 Message_Msg msg01 (;SampleKeyword;); 
1948 //Creates the message msg01, identified in the file by the keyword SampleKeyword 
1949 msg1.AddInteger (73); 
1950 msg1.AddString (;SampleFile;); 
1951 //fills out the code areas 
1952 ~~~~~
1953
1954 @subsection occt_shg_7_4 Tool for managing trace files
1955
1956 Class *Message_TraceFile* is intended to manage the trace file (or stream) for outputting messages and the current trace level. Trace level is an integer number, which is used when messages are sent. Generally, 0 means minimum, \> 0 various levels. If the current trace level is lower than the level of the message it is not output to the trace file. The trace level is to be managed and used by the users. 
1957 There are two ways of using trace files: 
1958 * define an object of *Message_TraceFile*, with its own definition (file name or cout, trace level), and use it where it is defined, 
1959 * use the default trace file (file name or cout, trace level), usable from anywhere. 
1960 Use the constructor method to define the target file and the level of the messages as in the example below: 
1961 ~~~~~
1962 Message_TraceFile myTF 
1963         (tracelevel, "tracefile.log", Standard_False); 
1964 ~~~~~
1965 The parameters are as follows:  
1966 * *tracelevel* is a Standard_Integer and modifies the level of messages. It has the following values and semantics: 
1967         + 0: gives general information such as the start and end of process;
1968         + 1: gives exceptions raised and fail messages;
1969         + 2: gives the same information as 1 plus warning messages.
1970 * *filename* is the string containing the path to the log file. 
1971 The Boolean set to False will rewrite the existing file. When set to True, new messages will be appended to the existing file. 
1972
1973 A new default log file can be added using  method *SetDefault* with the same arguments as in the constructor. 
1974 The default trace level can be changed by using method *SetDefLevel*. In this way, the information received in the log file is modified. 
1975 It is possible to close the log file and set the default trace output to the screen display instead of the log file using the method *SetDefault* without any arguments. 
1976