0028427: Data Exchange - Update Reference Manual for STEP format
authorika <ika@opencascade.com>
Tue, 17 Jan 2017 09:18:42 +0000 (12:18 +0300)
committerbugmaster <bugmaster@opencascade.com>
Thu, 23 Mar 2017 12:57:20 +0000 (15:57 +0300)
- Update STEP manual
- Fix code style in several files

13 files changed:
dox/user_guides/step/step.md
src/STEPControl/STEPControl_ActorRead.cxx
src/StepToTopoDS/StepToTopoDS.cxx
src/StepToTopoDS/StepToTopoDS_Builder.cxx
src/StepToTopoDS/StepToTopoDS_GeometricTool.cxx
src/StepToTopoDS/StepToTopoDS_MakeTransformed.cxx
src/StepToTopoDS/StepToTopoDS_TranslateCompositeCurve.cxx
src/StepToTopoDS/StepToTopoDS_TranslateCurveBoundedSurface.cxx
src/StepToTopoDS/StepToTopoDS_TranslateEdge.cxx
src/StepToTopoDS/StepToTopoDS_TranslateEdgeLoop.cxx
src/StepToTopoDS/StepToTopoDS_TranslateFace.cxx
src/StepToTopoDS/StepToTopoDS_TranslatePolyLoop.cxx
src/StepToTopoDS/StepToTopoDS_TranslateShell.cxx

index d31ed41..0703a99 100644 (file)
@@ -48,7 +48,7 @@ This provides a natural way to deal with non-supported protocols when they share
 
 @subsection occt_step_1_2 STEP Interface
 
-The STEP interface reads STEP files produced in accordance with STEP Application Protocol 214 (Conformance Class 2 both CD and DIS versions of schema) and translates them to Open CASCADE Technology models. STEP Application Protocol 203 is also supported.
+The STEP interface reads STEP files produced in accordance with STEP Application Protocol 214 (Conformance Class 2 both CD and DIS versions of schema) and translates them to Open CASCADE Technology models. STEP Application Protocol 203 and some parts of AP242 are also supported.
 
 The STEP interface also translates OCCT models to STEP files. STEP files that are produced by this interface conform to STEP AP 203 or AP 214 (Conformance Class 2, either CD or DIS version of the schema) depending on the user's option.
 
@@ -56,7 +56,7 @@ Basic interface reads and writes geometrical, topological STEP data and assembly
 
 The interface is able to translate one entity, a group of entities or a whole file.
 
-Other kinds of data such as colors, validation properties, layers, names and the structure of assemblies can be read or written with the help of XDE tools: <i> STEPCAFControl_Reader</i> and <i> STEPCAFControl_Writer</i>. 
+Other kinds of data such as colors, validation properties, layers, GD&T, names and the structure of assemblies can be read or written with the help of XDE tools: <i> STEPCAFControl_Reader</i> and <i> STEPCAFControl_Writer</i>. 
 
 To choose a translation mode when exporting to a STEP format, use <i> STEPControl_STEPModelType</i>.
 
@@ -309,12 +309,12 @@ Note that the following parameters have effect only if *read.step.product.mode*
 
 <h4>read.step.product.context:</h4>
 
-When reading AP 209 STEP files, allows selecting either only ‘design’ or ‘analysis’, or both types of products for translation 
+When reading AP 209 STEP files, allows selecting either only `design' or `analysis', or both types of products for translation 
 * 1 (all) --  translates all products;
-* 2 (design) -- translates only products that have *PRODUCT_DEFINITION_CONTEXT* with field *life_cycle_stage* set to ‘design’; 
-* 3 (analysis) --   translates only products associated with *PRODUCT_DEFINITION_CONTEXT* entity whose field *life_cycle_stage* set to ‘analysis’. 
+* 2 (design) -- translates only products that have *PRODUCT_DEFINITION_CONTEXT* with field *life_cycle_stage* set to `design'; 
+* 3 (analysis) --   translates only products associated with *PRODUCT_DEFINITION_CONTEXT* entity whose field *life_cycle_stage* set to `analysis'. 
 
-Note that in AP 203 and AP214 files all products should be marked as ‘design’, so if this mode is set to ‘analysis’, nothing will be read. 
+Note that in AP 203 and AP214 files all products should be marked as `design', so if this mode is set to `analysis', nothing will be read. 
 
 Read this parameter with: 
 ~~~~~
@@ -522,12 +522,12 @@ There is a number of predefined operators that can be used. They are:
 Cumulative lists can be used as well.
  
 <h5>Single entities</h5>
-You can select an entity either by its rank or by its handle (an entity’s handle can be obtained by invoking the *StepData_StepModel::Entity* function). 
+You can select an entity either by its rank or by its handle (an entity's handle can be obtained by invoking the *StepData_StepModel::Entity* function). 
 
 <h5>Selection by rank</h5>
 Use method *StepData_StepModel::NextNumberForLabel* to find its rank with the following: 
 ~~~~~
-Standard_CString label = ‘#...’; 
+Standard_CString label = `#...'; 
 StepData_StepModel model = reader.StepModel(); 
 rank = model->NextNumberForLabe(label, 0, Standard_False); 
 ~~~~~
@@ -546,7 +546,7 @@ Standard_Boolean ok = reader.TransferEntity (ent);
 Tables given in this paragraph show the mapping of STEP entities to OCCT objects. Only topological and geometrical STEP entities and entities defining assembly structures are described in this paragraph. For a full list of STEP entities please refer to Appendix A. 
 
 @subsubsection occt_step_2_4_1 Assembly structure representation entities
-Not all entities defining the assembly structure in the STEP file are translated to OCCT shapes, but they are used to identify the relationships between assemblies and their components. Since the graph of ‘natural’ dependencies of entities based on direct references between them does not include the references from assemblies to their components, these dependencies are introduced in addition to the former ones. This is made basing on the analysis of the following entities describing the structure of the assembly. 
+Not all entities defining the assembly structure in the STEP file are translated to OCCT shapes, but they are used to identify the relationships between assemblies and their components. Since the graph of `natural' dependencies of entities based on direct references between them does not include the references from assemblies to their components, these dependencies are introduced in addition to the former ones. This is made basing on the analysis of the following entities describing the structure of the assembly. 
 
 | STEP entity type | CASCADE shape | Comments |
 | :--------------- | :-------------- | :------ |
@@ -861,10 +861,11 @@ Default value is 0.
 
 <h4>write.step.schema</h4>
 defines the version of schema used for the output STEP file:  
-    * 1 or ;AP214CD; (default): AP214, CD version (dated 26 November 1996), 
-    *  2 or ;AP214DIS;: AP214, DIS version (dated 15 September 1998). 
-    *  3 or ;AP203;: AP203, possibly with modular extensions (depending on data written to a file). 
-    *  4 or *AP214IS*: AP214, IS version (dated 2002) 
+    * 1 or *AP214CD* (default): AP214, CD version (dated 26 November 1996), 
+    * 2 or *AP214DIS*: AP214, DIS version (dated 15 September 1998). 
+    * 3 or *AP203*: AP203, possibly with modular extensions (depending on data written to a file). 
+    * 4 or *AP214IS*: AP214, IS version (dated 2002) 
+    * 5 or *AP242DIS*: AP242, DIS version. 
 
 Read this parameter with: 
 ~~~~~
@@ -879,7 +880,7 @@ Default value is 1 (;CD;).
 For the parameter *write.step.schema* to take effect, method *STEPControl_Writer::Model(Standard_True)* should be called after changing this parameter (corresponding command in DRAW is *newmodel*).
  
 <h4>write.step.product.name</h4>
-Defines the text string that will be used for field ‘name’ of PRODUCT entities written to the STEP file. 
+Defines the text string that will be used for field `name' of PRODUCT entities written to the STEP file. 
 
 Default value: OCCT STEP translator (current OCCT version number). 
 
@@ -1148,6 +1149,8 @@ The following steps should be taken:
      * Repr 
      * AP214 
      * AP203 
+     * AP242
+     
 Each field of a STEP entity should be represented by a corresponding field of this class. The class should have methods for initializing, setting and obtaining fields and it should also have the default constructor. 
 * Create the *RWStepxxx_RWNewEntity* class with a default constructor and methods *ReadStep()*, *WriteStep()* and if the entity references other entities, then method *Share()*. 
 * Update file *StepAP214_Protocol.cxx*. In the constructor *StepAP214_Protocol::StepAP214_Protocol()* add the new type to the map of registered types and associate the unique integer identifier with this type. 
@@ -1387,14 +1390,15 @@ It is necessary to call command *newmodel* to perform a new translation of the n
 
 @section occt_step_7 Reading from and writing to STEP
 
-The *STEPCAFControl* package (TKXDESTEP toolkit) provides tools to read and write STEP files (see XDE User’s Guide). 
+The *STEPCAFControl* package (TKXDESTEP toolkit) provides tools to read and write STEP files (see XDE User's Guide). 
 
 In addition to the translation of shapes implemented in basic translator, it provides the following: 
   * STEP assemblies, read as OCCT compounds by basic translator, are translated to XDE assemblies;
   * Names of products are translated and assigned to assembly components and instances in XDE;
   * STEP external references are recognized and translated (if external documents are STEP files);
   * Colors, layers, materials and validation properties assigned to parts or subparts are translated;
-  * STEP dimensional tolerances are translated.
+  * STEP Geometric Dimensions and Tolerances are translated;
+  * STEP Saved Views are translated.
   
 @subsection occt_step_7_1 Reading from STEP
 
@@ -1433,7 +1437,115 @@ Standard_Boolean ok = reader.Transfer(doc);
 ~~~~~
 where *doc* is a variable which contains a handle to the output document and should have a type *Handle(TDocStd_Document)*. 
 
-@subsection occt_step_7_2 Writing to STEP
+
+@subsection occt_step_7_2 Attributes read from STEP 
+
+### Colors
+Colors are implemented in accordance with <a href="http://www.cax-if.org/documents/rec_prac_styling_org_v15.pdf">Recommended practices for model styling and organization</a> sections 4 and 5.
+
+The following attributes are imported from STEP file:
+* colors linked to assemblies, solids, shells, faces/surfaces, wireframes, edges/curves and vertices/points;
+* information about invisibility.
+
+The following attributes are mentioned in the Recommended Practices, but not handled by OCCT:
+* styling different sides of surfaces with different colors;
+* transparency and reflectance for surfaces;
+* curve styles;
+* point markers.
+
+### Layers
+Layers are implemented in accordance with <a href="http://www.cax-if.org/documents/rec_prac_styling_org_v15.pdf">Recommended practices  for model styling and organization</a> section 6.
+All layers are imported, but invisibility styles are skipped.
+
+### Materials
+Materials are implemented in accordance with <a href="http://www.cax-if.org/documents/RecPrac_MaterialDensity_v21.pdf">Recommended practices for material identification and density</a> section 4.
+OCCT translator processes materials attached to solids in shape representations. The name, description and density (name and value) are imported for each material. 
+
+### Validation properties
+Validation properties are implemented in accordance with <a href="http://www.cax-if.org/documents/rec_prac_gvp_v44.pdf">Recommended practices for geometric and assembly validation properties</a> section 4 for AP214.
+OCCT processes several types of geometric validation properties for solids, shells and geometric sets:
+* area;
+* volume;
+* centroid.
+
+### Geometric dimensions and tolerances
+General types of STEP entities imported by OCCT are listed in the table below:
+|STEP entity|OCCT attribute|
+| :------------ | :----- |
+|Dimensional_Size|XCAFDoc_Dimension|
+|Dimensional_Location|XCAFDoc_Dimension|
+|Dimensional_Size_With_Path|XCAFDoc_Dimension|
+|Dimensional_Location_With_Path|XCAFDoc_Dimension|
+|Angular_Size|XCAFDoc_Dimension|
+|Angular_Location|XCAFDoc_Dimension|
+|Geometric_Tolerance and subtypes|XCAFDoc_GeometricTolerance|
+|Datum|XCAFDoc_Datum|
+|Datum_Feature|XCAFDoc_Datum|
+|Datum_Target|XCAFDoc_Datum|
+
+Processing of GD&T is realized in accordance with <a href="http://www.cax-if.org/documents/rec_pracs_pmi_v40.pdf">Recommended practices for the Representation and Presentation of Product Manufacturing</a> for AP242.
+The general restriction is that OCCT STEP Reader imports GD&T assigned only to shapes (faces, edges, vertices, etc) or to shape groups from general shape model i.e. any constructive geometries are not translated as referenced shapes.
+
+#### Dimensions
+Dimensions are implemented according to section 5 of the latter document.
+Additionally to the reference shapes, the Reader imports from STEP file some auxiliary geometry for dimensional line building: connection points and line orientation, if exist.
+
+The following values and modifiers described in sections 5.2 and 5.3 can be imported from STEP file:
+- qualifiers (minimum, maximum and average);
+- plus/minus bounds;
+- value range;
+- class of tolerance;
+- text notes, attached to dimension value;
+- dimension modifiers type 2 (Table 8);
+- number of decimal places.
+
+#### Datums
+Datums are implemented in accordance with sections 6.5 and 6.6.1-6.6.2.
+Each datum can have one or several datum features (shapes from the model, to which the datum is linked) and datum targets (auxiliary geometry: point, line, rectangle, circle or area).
+
+#### Tolerances
+Tolerances are implemented in accordance with sections 6.7-6.9 with several restrictions.
+
+Types of imported tolerances:
+- simple tolerances (see Table 10);
+- tolerance with modifiers (section 6.9.3);
+- tolerance with maximum value (section 6.9.5);
+- tolerance with datums (section 6.9.7 (simple datums and datum with modifiers) and 6.9.8 (common datums));
+- superposition of the mentioned types.
+
+Not all tolerance zones can be imported by OCCT STEP Reader, only the Tolerance Zones with associated symbols from *Table 11, Projected tolerance zone* (section 6.9.2.2) and *Runout zone* definition.
+
+#### Presentations
+Each semantic representation of GD&T (Dimension, Tolerance, Datum Feature or Datum Target) can have a presentation; its processing by OCCT is implemented in accordance with sections 7.3, 8 and 9.1-9.2.
+Presentations have several types:
+- *Graphic Presentation* (polylines or tessellated wireframes) - partially implemented in OCCT;
+- *Minimal Presentation* (position and orientation) - implemented in OCCT as a part of Graphic presentation;
+- *Character-based Presentation* (3D Text with information about fonts, curve styles etc.) - not handled by OCCT.
+
+Note, that separate Minimal presentation and Character-based Presentation are not described in any Recommended Practices, so there is no agreement about how such information should be saved in STEP file.
+
+OCCT STEP Reader imports only Annotation Planes, outline/stroked Polylines and Tessellated wireframes, i.e. all styling information (color, curve style, etc.) and filled characters are missed. 
+
+OCCT STEP Reader also handles Annotations, linked directly to shapes (section 9.3.1), processing of these presentations is subject to the same restrictions as the processing of presentations, linked to GD&T semantic.
+
+#### Geometric dimensions and tolerances AP214
+Simple types of GD&T (Dimensions, Tolerances and Datums without presentations or any types of modifiers) are also handled in AP214. However, according to the Recommended Practices for the Representation and Presentation of Product Manufacturing, this implementation is obsolete.
+
+### Saved views
+Saved views are implemented in accordance with <a href="http://www.cax-if.org/documents/rec_pracs_pmi_v40.pdf">Recommended practices for the Representation and Presentation of Product Manufacturing</a> section 9.4.1-9.4.4.
+For each Saved View OCCT STEP Reader will retrieve the following attributes:
+- set of displayed shape representations;
+- set of displayed PMI presentations;
+- projection point;
+- view direction;
+- up direction of view window;
+- horizontal size of view window;
+- vertical size of view window;
+- zoom factor;
+- clipping planes (single plane of combination of planes);
+- front and back plane clipping.
+
+@subsection occt_step_7_3 Writing to STEP
 
 The translation from XDE to STEP can be initialized as follows: 
 ~~~~~
@@ -1474,5 +1586,40 @@ IFSelect_ReturnStatus statw = writer.WriteFile (S);
 ~~~~~
 where *S* is *OStream*. 
 
+@subsection occt_step_7_4 Attributes written to STEP 
+
+### Colors
+The following attributes are exported to STEP file:
+* colors linked to assemblies, solids, shells, faces/surfaces, wireframes, edges/curves;
+* information about visibility.
+
+Restrictions:
+* colors and visibility information for points is not exported by default, it is necessary to use *write.step.vertex.mode* parameter;
+* all colors are always applied to both sides of surfaces;
+* all curves are exported with 'continuous' curve style.
+
+### Layers
+All layers are exported, but invisibility styles can be connected only to shapes.
+
+### Materials
+For solids with materials, the material is exported to STEP file (name, description and density (name and value)).
+
+### Validation properties
+Geometric validation properties, such as volume, area and centroid, which are attached to shape, are exported to STEP file.
+
+### Geometric dimensions and tolerances
+All entities, which can be imported from STEP, can be exported too.
+Please see the same item in section @ref occt_step_7_1 "Reading from STEP" to find more information.
+
+Note: OCCT use AP214 by default, so for GD&T exporting AP242 should be set manually:
+~~~~~
+Interface_Static::SetCVal("write.step.schema", "AP242DIS"));  
+~~~~~
+or
+~~~~~
+Interface_Static::SetIVal("write.step.schema", 5));  
+~~~~~
+### Saved views
+Saved Views are not exported by OCCT.
 
 
index 42b2ca0..fd392c9 100644 (file)
@@ -253,8 +253,6 @@ Standard_Boolean  STEPControl_ActorRead::Recognize
   }
 
   if (start->IsKind(STANDARD_TYPE(StepShape_ContextDependentShapeRepresentation))) {
-//    DeclareAndCast(StepShape_ContextDependentShapeRepresentation,CDSR,start);
-//    return Recognize (CDSR->RepresentationRelation());
     return Standard_True;
     //  on fait le pari que, si ce n est pas transferable tel quel,
     //  des CDSR implicitement references le sont ...
@@ -670,7 +668,6 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Han
     Handle(StepRepr_ProductDefinitionShape) PDS = 
       Handle(StepRepr_ProductDefinitionShape)::DownCast(subs1.Value());
     if(PDS.IsNull()) continue;
-    //IsPDS=Standard_True;
     Interface_EntityIterator subs2 = graph.Sharings(PDS);
     for (subs2.Start(); subs2.More(); subs2.Next()) {
       Handle(StepShape_ContextDependentShapeRepresentation) CDSR = 
@@ -689,7 +686,6 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Han
           DeclareAndCast(StepShape_ShapeDefinitionRepresentation,SDR,subs3.Value());
           Handle(StepRepr_ProductDefinitionShape) PDS1 = 
             Handle(StepRepr_ProductDefinitionShape)::DownCast(SDR->Definition().PropertyDefinition());
-          //Handle(StepRepr_PropertyDefinition) PD = SDR->Definition().PropertyDefinition();
           if(PDS1.IsNull()) continue;
           Interface_EntityIterator subs4 = graph.Shareds(PDS1);
           for (subs4.Start(); subs4.More(); subs4.Next()) {
@@ -871,10 +867,7 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Han
         if ( !myNMTool.IsPureNMShell(aCurrentShell) && !shellClosingsMap.Contains(aCurrentShell) )
           brepBuilder.Add(compWithClosings, aCurrentShell);
       }
-  
-
-      comp = compWithClosings;
+      comp = compWithClosings; 
     }
     // [END] Try to close OPEN Shells in I-DEAS case (ssv; 17.11.2010)
 
@@ -925,7 +918,6 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Han
   Handle(TransferBRep_ShapeBinder) shbinder;
   //:j2: treat SRRs here in order to compare them with NAUO
   Handle(StepRepr_ShapeRepresentationRelationship) SRR = CDSR->RepresentationRelation();
-  //DeclareAndCast(StepRepr_RepresentationRelationship,SRR,CDSR->RepresentationRelation());
   if ( SRR.IsNull() ) return shbinder;
   
   Standard_Boolean SRRReversed = STEPConstruct_Assembly::CheckSRRReversesNAUO ( TP->Graph(), CDSR );
@@ -939,34 +931,12 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Han
   
   gp_Trsf Trsf;
   Standard_Boolean iatrsf = ComputeSRRWT ( SRR, TP, Trsf );
-  /* Delete this part does not work gka
-  // use SDR for reading rep in order to handle subassemblies
-  Interface_EntityIterator subs = TP->Graph().Sharings(rep);
-  Standard_Integer nbitem=0;
-  for (subs.Start(); subs.More(); subs.Next()) nbitem++;
-  Message_ProgressSentry PS ( TP->GetProgress(), "Shape", 0, nbitem, 1 );
 
-  for (subs.Start(); subs.More() && PS.More() ; subs.Next(),PS.Next()) {
-    if ( subs.Value()->IsKind(STANDARD_TYPE(StepShape_ShapeDefinitionRepresentation))) {
-      DeclareAndCast(StepShape_ShapeDefinitionRepresentation,SDR,subs.Value());
-#ifdef TRANSLOG
-      if (TP->TraceLevel() > 1) 
-        sout<<" -- Actor : Ent.n0 "<<TP->Model()->Number(CDSR)<<" -> Sharing Ent.no"<<TP->Model()->Number(SDR)<<endl;
-#endif
-      
-      binder = TP->Find ( SDR );
-      if ( binder.IsNull() ) binder = TransferEntity(SDR,TP);
-      theResult = TransferBRep::ShapeResult (binder);
-      break;
-    }
-  }*/
-  //if ( theResult.IsNull() && ! subs.More() ) {
   Handle(Transfer_Binder) binder;
   Standard_Boolean isBound = Standard_False;
     if (!TP->IsBound(rep)) binder = TransferEntity(rep,TP,isBound);
     else binder = TP->Find(rep);
     theResult = TransferBRep::ShapeResult (binder);
-  //}
       
   if ( ! theResult.IsNull() ) {
     if ( iatrsf ) {
@@ -1017,7 +987,7 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Han
     Handle(StepShape_ShapeRepresentation) anitem = Handle(StepShape_ShapeRepresentation)::DownCast(anitemt);
     Handle(Transfer_Binder) binder;
     Standard_Boolean isBound = Standard_False;
-    if (!TP->IsBound(anitem)) binder = TransferEntity(anitem,TP,isBound);//TP->Transferring(anitem);
+    if (!TP->IsBound(anitem)) binder = TransferEntity(anitem,TP,isBound);
     else                       binder = TP->Find(anitem);
     TopoDS_Shape theResult = TransferBRep::ShapeResult (binder);
     if (!theResult.IsNull()) {
@@ -1044,10 +1014,6 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Han
 }
 
 //=======================================================================
-//function : OldWay
-//purpose  : 
-//=======================================================================
-//=======================================================================
 //function : IsNeedRepresentation
 //purpose  : 
 //=======================================================================
@@ -1308,7 +1274,6 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Han
   //  La Shape, et la mise en position
   Handle(StepShape_ShapeRepresentation) maprep =  Handle(StepShape_ShapeRepresentation)::
     DownCast(mapit->MappingSource()->MappedRepresentation());
-  //Handle(StepRepr_Representation) maprep = mapit->MappingSource()->MappedRepresentation();
   Standard_Boolean isBound = Standard_False; 
   Handle(Transfer_Binder) binder = TP->Find(maprep);
   if (binder.IsNull())    binder = TransferEntity(maprep,TP,isBound);
@@ -1367,51 +1332,51 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Han
   try {
     OCC_CATCH_SIGNALS
 
-  StepToTopoDS_Tool         myTool;
-  StepToTopoDS_DataMapOfTRI aMap;
-  
-  myTool.Init(aMap, TP);
-  StepToTopoDS_TranslateFace myTF;
-  myTF.SetPrecision(myPrecision);
-  myTF.SetMaxTol(myMaxTol);
-  
-  // Non-manifold topology is not processed here (ssv; 15.11.2010)
-  StepToTopoDS_NMTool dummyNMTool;
-  myTF.Init (fs, myTool, dummyNMTool);
-  Handle(StepRepr_Representation) oldSRContext = mySRContext;
-  if ( mySRContext.IsNull() ) { // if no context, try to find it (ex: r0701_ug.stp #4790)
-    Handle(StepRepr_Representation) context = FindContext ( fs, TP );
-    if ( context.IsNull() ) {
-      TP->AddWarning ( fs, "Entity with no unit context; default units taken" );
-      ResetUnits();
+    StepToTopoDS_Tool         myTool;
+    StepToTopoDS_DataMapOfTRI aMap;
+
+    myTool.Init(aMap, TP);
+    StepToTopoDS_TranslateFace myTF;
+    myTF.SetPrecision(myPrecision);
+    myTF.SetMaxTol(myMaxTol);
+
+    // Non-manifold topology is not processed here (ssv; 15.11.2010)
+    StepToTopoDS_NMTool dummyNMTool;
+    myTF.Init(fs, myTool, dummyNMTool);
+    Handle(StepRepr_Representation) oldSRContext = mySRContext;
+    if (mySRContext.IsNull()) { // if no context, try to find it (ex: r0701_ug.stp #4790)
+      Handle(StepRepr_Representation) context = FindContext(fs, TP);
+      if (context.IsNull()) {
+        TP->AddWarning(fs, "Entity with no unit context; default units taken");
+        ResetUnits();
+      }
+      else PrepareUnits(context, TP);
     }
-    else PrepareUnits ( context, TP );
-  }
-  
-  // Apply ShapeFix
-  Handle(Transfer_Binder) binder = TP->Find (fs);
-  sb = Handle(TransferBRep_ShapeBinder)::DownCast ( binder );
-  if ( ! sb.IsNull() && ! sb->Result().IsNull() ) {
-    TopoDS_Shape S = sb->Result();
-    
-    Handle(Standard_Transient) info;
-    TopoDS_Shape shape = XSAlgo::AlgoContainer()->ProcessShape( S, myPrecision, myMaxTol,
-                                                                "read.step.resource.name", 
-                                                                "read.step.sequence", info,
-                                                                TP->GetProgress() );
-    //      TopoDS_Shape shape = XSAlgo::AlgoContainer()->PerformFixShape( S, TP, myPrecision, myMaxTol );
-    if ( shape != S ) 
-      sb->SetResult ( shape );
-    
-    XSAlgo::AlgoContainer()->MergeTransferInfo(TP, info, nbTPitems);
-  }
 
-  
-  if ( oldSRContext.IsNull() && ! mySRContext.IsNull() ) //:S4136
-    PrepareUnits ( oldSRContext, TP ); 
-  TP->Bind(fs, sb);
-  return sb; // TP->Find (start);
-}
+    // Apply ShapeFix
+    Handle(Transfer_Binder) binder = TP->Find(fs);
+    sb = Handle(TransferBRep_ShapeBinder)::DownCast(binder);
+    if (!sb.IsNull() && !sb->Result().IsNull()) {
+      TopoDS_Shape S = sb->Result();
+
+      Handle(Standard_Transient) info;
+      TopoDS_Shape shape = XSAlgo::AlgoContainer()->ProcessShape(S, myPrecision, myMaxTol,
+        "read.step.resource.name",
+        "read.step.sequence", info,
+        TP->GetProgress());
+      //      TopoDS_Shape shape = XSAlgo::AlgoContainer()->PerformFixShape( S, TP, myPrecision, myMaxTol );
+      if (shape != S)
+        sb->SetResult(shape);
+
+      XSAlgo::AlgoContainer()->MergeTransferInfo(TP, info, nbTPitems);
+    }
+
+
+    if (oldSRContext.IsNull() && !mySRContext.IsNull()) //:S4136
+      PrepareUnits(oldSRContext, TP);
+    TP->Bind(fs, sb);
+    return sb; // TP->Find (start);
+  }
   catch(Standard_Failure)
   {
     TP->AddFail(fs,"Exeption is raised. Entity was not translated.");
@@ -1432,12 +1397,9 @@ Handle(Transfer_Binder) STEPControl_ActorRead::TransferShape(const Handle(Standa
   if (start.IsNull()) return NullResult();
   XSAlgo::AlgoContainer()->PrepareForTransfer();
 
-//  myContext.SetModel ( Handle(StepData_StepModel)::DownCast ( TP->Model() ) ); // for asking IsAP203?
-  
   Handle(Message_Messenger) sout = TP->Messenger();
 #ifdef TRANSLOG
 //  POUR MISE AU POINT, a supprimer ensuite
-//  sout<<"STEP->Shape, ent n0 "<<TP->Model()->Number(start)<<" Level="<<TP->NestingLevel()<<endl;
   if (TP->TraceLevel() > 1) 
     sout<<" -- Actor : Transfer Ent.n0 "<<TP->Model()->Number(start)<<"  Type "<<start->DynamicType()->Name()<<endl;
 #endif
@@ -1454,17 +1416,17 @@ Handle(Transfer_Binder) STEPControl_ActorRead::TransferShape(const Handle(Standa
     shbinder = OldWay(start,TP);
   //skl
   
-  else if(start->IsKind(STANDARD_TYPE(StepBasic_ProductDefinition))) {
-    Handle(StepBasic_ProductDefinition) PD = 
+  else if (start->IsKind(STANDARD_TYPE(StepBasic_ProductDefinition))) {
+    Handle(StepBasic_ProductDefinition) PD =
       Handle(StepBasic_ProductDefinition)::DownCast(start);
-     shbinder = TransferEntity(PD,TP);
+    shbinder = TransferEntity(PD, TP);
   }
   
   // NextAssemblyUsageOccurrence
   else if (start->IsKind(STANDARD_TYPE(StepRepr_NextAssemblyUsageOccurrence))) {
-    Handle(StepRepr_NextAssemblyUsageOccurrence) NAUO = 
+    Handle(StepRepr_NextAssemblyUsageOccurrence) NAUO =
       Handle(StepRepr_NextAssemblyUsageOccurrence)::DownCast(start);
-     shbinder = TransferEntity(NAUO,TP);
+    shbinder = TransferEntity(NAUO, TP);
   }
   //end skl
     
@@ -1522,9 +1484,7 @@ void STEPControl_ActorRead::PrepareUnits(const Handle(StepRepr_Representation)&
   mySRContext = rep;
   
   Standard_Integer stat1, stat2 = 0;  // sera alimente par STEPControl_Unit
-//  DeclareAndCast(StepShape_ShapeRepresentation,sr,start);
   if (rep.IsNull()) {
-//    TP->AddWarning(sr,"Not a ShapeRepresentation, default unit taken");
     ResetUnits();
     return;
   }
@@ -1549,7 +1509,6 @@ void STEPControl_ActorRead::PrepareUnits(const Handle(StepRepr_Representation)&
   if (theRepCont->IsKind(STANDARD_TYPE(StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext))) {
     DeclareAndCast(StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext, theGRCAGAUC,theRepCont);
     theGUAC = theGRCAGAUC->GlobalUnitAssignedContext();
-//    TP->AddWarning(theRepCont,"No Length Uncertainty, last defined one is taken");
   }
 
   // ----------------------------------------------------
@@ -1597,7 +1556,6 @@ void STEPControl_ActorRead::PrepareUnits(const Handle(StepRepr_Representation)&
   }
   myMaxTol = Max ( myPrecision, Interface_Static::RVal("read.maxprecision.val") );
   // Assign uncertainty
-//  Interface_Static::SetRVal("lastpreci",UpdatedValue);
 #ifdef TRANSLOG
   if (TP->TraceLevel() > 1) 
     TP->Messenger() <<"  Cc1ToTopoDS : Length Unit = "<<myUnit.LengthFactor()<<"  Tolerance CASCADE = "<<myPrecision<<endl;
@@ -1809,5 +1767,4 @@ void STEPControl_ActorRead::computeIDEASClosings(const TopoDS_Compound& comp,
     if ( !closingShells.IsEmpty() )
       shellClosingsMap.Add(shellA, closingShells);
   }
-
 }
index c553775..8fbee14 100644 (file)
 Handle(TCollection_HAsciiString) StepToTopoDS::DecodeBuilderError(const StepToTopoDS_BuilderError Error)
 {
   Handle(TCollection_HAsciiString) mess;
-  switch(Error)
-    {
+  switch (Error)
+  {
     case StepToTopoDS_BuilderDone:
-      {
-       mess = new TCollection_HAsciiString("Builder Done");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Builder Done");
+      break;
+    }
     case StepToTopoDS_BuilderOther:
-      {
-       mess = new TCollection_HAsciiString("Builder Other");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Builder Other");
+      break;
     }
+  }
   return mess;
 }
 
 Handle(TCollection_HAsciiString) StepToTopoDS::DecodeShellError(const StepToTopoDS_TranslateShellError Error)
 {
   Handle(TCollection_HAsciiString) mess;
-  switch(Error)
-    {
+  switch (Error)
+  {
     case StepToTopoDS_TranslateShellDone:
-      {
-       mess = new TCollection_HAsciiString("Translate Shell Done");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Translate Shell Done");
+      break;
+    }
     case StepToTopoDS_TranslateShellOther:
-      {
-       mess = new TCollection_HAsciiString("Translate Shell Other");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Translate Shell Other");
+      break;
     }
+  }
   return mess;
 }
 
 Handle(TCollection_HAsciiString) StepToTopoDS::DecodeFaceError(const StepToTopoDS_TranslateFaceError Error)
 {
   Handle(TCollection_HAsciiString) mess;
-  switch(Error)
-    {
+  switch (Error)
+  {
     case StepToTopoDS_TranslateFaceDone:
-      {
-       mess = new TCollection_HAsciiString("Translate Face Done");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Translate Face Done");
+      break;
+    }
     case StepToTopoDS_TranslateFaceOther:
-      {
-       mess = new TCollection_HAsciiString("Translate Face Other");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Translate Face Other");
+      break;
     }
+  }
   return mess;
 }
 
 Handle(TCollection_HAsciiString) StepToTopoDS::DecodeEdgeError(const StepToTopoDS_TranslateEdgeError Error)
 {
   Handle(TCollection_HAsciiString) mess;
-  switch(Error)
-    {
+  switch (Error)
+  {
     case StepToTopoDS_TranslateEdgeDone:
-      {
-       mess = new TCollection_HAsciiString("Translate Edge Done");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Translate Edge Done");
+      break;
+    }
     case StepToTopoDS_TranslateEdgeOther:
-      {
-       mess = new TCollection_HAsciiString("Translate Edge Other");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Translate Edge Other");
+      break;
     }
+  }
   return mess;
 }
 
 Handle(TCollection_HAsciiString) StepToTopoDS::DecodeVertexError(const StepToTopoDS_TranslateVertexError Error)
 {
   Handle(TCollection_HAsciiString) mess;
-  switch(Error)
-    {
+  switch (Error)
+  {
     case StepToTopoDS_TranslateVertexDone:
-      {
-       mess = new TCollection_HAsciiString("Translate Vertex Done");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Translate Vertex Done");
+      break;
+    }
     case StepToTopoDS_TranslateVertexOther:
-      {
-       mess = new TCollection_HAsciiString("Translate Vertex Other");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Translate Vertex Other");
+      break;
     }
+  }
   return mess;
 }
 
 Handle(TCollection_HAsciiString) StepToTopoDS::DecodeVertexLoopError(const StepToTopoDS_TranslateVertexLoopError Error)
 {
   Handle(TCollection_HAsciiString) mess;
-  switch(Error)
-    {
+  switch (Error)
+  {
     case StepToTopoDS_TranslateVertexLoopDone:
-      {
-       mess = new TCollection_HAsciiString("Translate VertexLoop Done");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Translate VertexLoop Done");
+      break;
+    }
     case StepToTopoDS_TranslateVertexLoopOther:
-      {
-       mess = new TCollection_HAsciiString("Translate VertexLoop Other");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Translate VertexLoop Other");
+      break;
     }
+  }
   return mess;
 }
 
 Handle(TCollection_HAsciiString) StepToTopoDS::DecodePolyLoopError(const StepToTopoDS_TranslatePolyLoopError Error)
 {
   Handle(TCollection_HAsciiString) mess;
-  switch(Error)
-    {
+  switch (Error)
+  {
     case StepToTopoDS_TranslatePolyLoopDone:
-      {
-       mess = new TCollection_HAsciiString("Translate PolyLoop Done");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Translate PolyLoop Done");
+      break;
+    }
     case StepToTopoDS_TranslatePolyLoopOther:
-      {
-       mess = new TCollection_HAsciiString("Translate PolyLoop Other");
-       break;
-      }
+    {
+      mess = new TCollection_HAsciiString("Translate PolyLoop Other");
+      break;
     }
+  }
   return mess;
 }
 
@@ -155,39 +155,39 @@ Handle(TCollection_HAsciiString) StepToTopoDS::DecodePolyLoopError(const StepToT
 Standard_CString StepToTopoDS::DecodeGeometricToolError(const StepToTopoDS_GeometricToolError Error)
 {
   Standard_CString  mess="";
-  switch(Error)
-    {
+  switch (Error)
+  {
     case StepToTopoDS_GeometricToolDone:
-      {
-       mess = Standard_CString(" Geometric Tool is done");
-       break;
-      }
+    {
+      mess = Standard_CString(" Geometric Tool is done");
+      break;
+    }
     case StepToTopoDS_GeometricToolIsDegenerated:
-      {
-       mess = Standard_CString(" an Edge is degenerated");
-       break;
-      }
+    {
+      mess = Standard_CString(" an Edge is degenerated");
+      break;
+    }
     case StepToTopoDS_GeometricToolHasNoPCurve:
-      {
-       mess = Standard_CString(" SurfaceCurve does not contain a PCurve lying on the BasisSurface");
-       break;
-      }
+    {
+      mess = Standard_CString(" SurfaceCurve does not contain a PCurve lying on the BasisSurface");
+      break;
+    }
     case StepToTopoDS_GeometricToolWrong3dParameters:
-      {
-       mess = Standard_CString(" the update of 3D-Parameters failed");
-       break;
-      }
+    {
+      mess = Standard_CString(" the update of 3D-Parameters failed");
+      break;
+    }
     case StepToTopoDS_GeometricToolNoProjectiOnCurve:
-      {
-       mess = Standard_CString(" the projection of a VertexPoint on the curve3d failed");
-       break;
-      }
+    {
+      mess = Standard_CString(" the projection of a VertexPoint on the curve3d failed");
+      break;
+    }
     case StepToTopoDS_GeometricToolOther:
-      {
-       mess = Standard_CString(" GeometricTool failed");
-       break;
-      }
+    {
+      mess = Standard_CString(" GeometricTool failed");
+      break;
     }
+  }
   return mess;
 }
 
index cb79d04..f7093f1 100644 (file)
@@ -89,8 +89,6 @@
 #include <TransferBRep.hxx>
 
 #include <stdio.h>
-//#include <StepShape_VertexShell.hxx>
-//:e0
 static void ResetPreci (const TopoDS_Shape& S, Standard_Real maxtol)
 {
   //:S4136
@@ -99,12 +97,6 @@ static void ResetPreci (const TopoDS_Shape& S, Standard_Real maxtol)
     ShapeFix_ShapeTolerance STU;
     STU.LimitTolerance (S,Precision::Confusion(),maxtol);
   }
-//  Standard_Real ratio = Interface_Static::RVal("XSTEP.readprecision.ratio");
-//  if (ratio >= 1) {
-//    Standard_Real lastpre = Interface_Static::RVal("lastpreci");
-//    ShapeFix_ShapeTolerance STU;
-//    STU.LimitTolerance (S,lastpre/ratio,lastpre*ratio);
-//  }
 }
 
 // ============================================================================
@@ -440,10 +432,10 @@ void StepToTopoDS_Builder::Init
       aCShell = aFBABWV->VoidsValue(i);
       myTranShell.Init(aCShell, myTool, dummyNMTool);
       if (myTranShell.IsDone()) {
-       Sh = myTranShell.Value();
-       Sh.Closed(Standard_True);
-       //BRepLib::SameParameter(Sh);
-       B.Add(S,Sh);
+        Sh = myTranShell.Value();
+        Sh.Closed(Standard_True);
+        //BRepLib::SameParameter(Sh);
+        B.Add(S, Sh);
       }
       else {
        TP->AddWarning
@@ -498,48 +490,32 @@ void StepToTopoDS_Builder::Init
   myTranShell.SetMaxTol(MaxTol());
 
   Message_ProgressSentry PS ( TP->GetProgress(), "Shell", 0, Nb, 1 );
-  for (Standard_Integer i=1; i<=Nb && PS.More(); i++, PS.Next()) {
-  //for (Standard_Integer i=1; i<=Nb; i++) {
+  for (Standard_Integer i = 1; i <= Nb && PS.More(); i++, PS.Next()) {
     aShell = aSBSM->SbsmBoundaryValue(i);
-    //aVertexShell = aShell.VertexShell();
-    aOpenShell   = aShell.OpenShell();
+    aOpenShell = aShell.OpenShell();
     aClosedShell = aShell.ClosedShell();
-    //if (!aVertexShell.IsNull()) {
-    //TP->AddWarning
-    //(aVertexShell,
-    //" VertexShell from ShellBasedSurfaceModel not mapped to TopoDS");
-    //}
-    //else 
     if (!aOpenShell.IsNull()) {
       myTranShell.Init(aOpenShell, myTool, NMTool);
       if (myTranShell.IsDone()) {
-       //Sh = myTranShell.Value();
-       //Sh.Closed(Standard_False);
-       //BRepLib::SameParameter(Sh);
-       //B.Add(S,Sh);
-       Shl = TopoDS::Shell(myTranShell.Value());
-       Shl.Closed(Standard_False);
-       B.Add(S,Shl);
+        Shl = TopoDS::Shell(myTranShell.Value());
+        Shl.Closed(Standard_False);
+        B.Add(S, Shl);
       }
-      else { 
-       TP->AddWarning
-         (aOpenShell," OpenShell from ShellBasedSurfaceModel not mapped to TopoDS");
+      else {
+        TP->AddWarning
+          (aOpenShell, " OpenShell from ShellBasedSurfaceModel not mapped to TopoDS");
       }
     }
     else if (!aClosedShell.IsNull()) {
       myTranShell.Init(aClosedShell, myTool, NMTool);
       if (myTranShell.IsDone()) {
-       //Sh = myTranShell.Value();
-       //Sh.Closed(Standard_True);
-       //BRepLib::SameParameter(Sh);
-       //B.Add(S,Sh);
-       Shl = TopoDS::Shell(myTranShell.Value());
-       Shl.Closed(Standard_True);
-       B.Add(S,Shl);
+        Shl = TopoDS::Shell(myTranShell.Value());
+        Shl.Closed(Standard_True);
+        B.Add(S, Shl);
       }
-      else { 
-       TP->AddWarning
-         (aClosedShell," ClosedShell from ShellBasedSurfaceModel not mapped to TopoDS");
+      else {
+        TP->AddWarning
+          (aClosedShell, " ClosedShell from ShellBasedSurfaceModel not mapped to TopoDS");
       }
     }
   }
@@ -735,13 +711,6 @@ void StepToTopoDS_Builder::Init
  const Handle(Transfer_ActorOfTransientProcess)& RA,
  const Standard_Boolean isManifold)
 {
-  // Initialisation of the Tool
-
-//  StepToTopoDS_Tool         myTool;
-//  StepToTopoDS_DataMapOfTRI aMap;
-
-//  myTool.Init(aMap, TP);
-
   // Start Mapping
   TopoDS_Compound S;
   BRep_Builder B;
@@ -773,42 +742,42 @@ void StepToTopoDS_Builder::Init
 
       // try composite_curve
       Handle(StepGeom_CompositeCurve) CC = Handle(StepGeom_CompositeCurve)::DownCast(aCrv);
-      if ( ! CC.IsNull() ) {
-       StepToTopoDS_TranslateCompositeCurve TrCC;
-       TrCC.SetPrecision(preci);
-       TrCC.SetMaxTol(maxtol);
-       TrCC.Init( CC, TP );
-       if ( TrCC.IsDone() ) 
-       {
-         if (TrCC.IsInfiniteSegment())
-         {
-           BRep_Builder aB;
-           TopoDS_Compound aComp;
-           aB.MakeCompound(aComp);
-           TopExp_Explorer anExp;
-           for (anExp.Init (TrCC.Value(), TopAbs_EDGE); anExp.More(); anExp.Next())
-             aB.Add (aComp, anExp.Current());
-           res = aComp;
-         }
-         else
-           res = TrCC.Value();
-       }
+      if (!CC.IsNull()) {
+        StepToTopoDS_TranslateCompositeCurve TrCC;
+        TrCC.SetPrecision(preci);
+        TrCC.SetMaxTol(maxtol);
+        TrCC.Init(CC, TP);
+        if (TrCC.IsDone())
+        {
+          if (TrCC.IsInfiniteSegment())
+          {
+            BRep_Builder aB;
+            TopoDS_Compound aComp;
+            aB.MakeCompound(aComp);
+            TopExp_Explorer anExp;
+            for (anExp.Init(TrCC.Value(), TopAbs_EDGE); anExp.More(); anExp.Next())
+              aB.Add(aComp, anExp.Current());
+            res = aComp;
+          }
+          else
+            res = TrCC.Value();
+        }
       }
       else { // try other curves
-       Handle(Geom_Curve) aGeomCrv;
-       try {
-         OCC_CATCH_SIGNALS
-          aGeomCrv = StepToGeom::MakeCurve (aCrv);
-       }
-       catch(Standard_Failure const& anException) {
-         Handle(Message_Messenger) sout = TP->Messenger();
-         sout<<"StepToTopoDS, GeometricSet, elem "<<i<<" of "<<nbElem<<": exception ";
-         sout<<anException.GetMessageString() << endl;
-       }
-       if ( ! aGeomCrv.IsNull() ) {
-         BRepBuilderAPI_MakeEdge anEdge(aGeomCrv, aGeomCrv->FirstParameter(), aGeomCrv->LastParameter());
-         if ( anEdge.IsDone() ) res = anEdge.Edge();
-       }
+        Handle(Geom_Curve) aGeomCrv;
+        try {
+          OCC_CATCH_SIGNALS
+            aGeomCrv = StepToGeom::MakeCurve(aCrv);
+        }
+        catch (Standard_Failure const& anException) {
+          Handle(Message_Messenger) sout = TP->Messenger();
+          sout << "StepToTopoDS, GeometricSet, elem " << i << " of " << nbElem << ": exception ";
+          sout << anException.GetMessageString() << endl;
+        }
+        if (!aGeomCrv.IsNull()) {
+          BRepBuilderAPI_MakeEdge anEdge(aGeomCrv, aGeomCrv->FirstParameter(), aGeomCrv->LastParameter());
+          if (anEdge.IsDone()) res = anEdge.Edge();
+        }
       }
     }
     // try point
@@ -821,39 +790,39 @@ void StepToTopoDS_Builder::Init
       }
     }
     // Element should finally be a Surface
-    else if ( ent->IsKind(STANDARD_TYPE(StepGeom_Surface)) ) {
-      Handle(StepGeom_Surface) aSurf = 
-       Handle(StepGeom_Surface)::DownCast(ent);
-       
+    else if (ent->IsKind(STANDARD_TYPE(StepGeom_Surface))) {
+      Handle(StepGeom_Surface) aSurf =
+        Handle(StepGeom_Surface)::DownCast(ent);
+
       // try curve_bounded_surf
-      if ( ent->IsKind(STANDARD_TYPE(StepGeom_CurveBoundedSurface)) ) {
-       Handle(StepGeom_CurveBoundedSurface) CBS = 
-         Handle(StepGeom_CurveBoundedSurface)::DownCast(aSurf);
-       StepToTopoDS_TranslateCurveBoundedSurface TrCBS;
-       TrCBS.SetPrecision(preci);
-       TrCBS.SetMaxTol(maxtol);
-       
-       TrCBS.Init( CBS, TP );
-       if ( TrCBS.IsDone() ) res = TrCBS.Value();
+      if (ent->IsKind(STANDARD_TYPE(StepGeom_CurveBoundedSurface))) {
+        Handle(StepGeom_CurveBoundedSurface) CBS =
+          Handle(StepGeom_CurveBoundedSurface)::DownCast(aSurf);
+        StepToTopoDS_TranslateCurveBoundedSurface TrCBS;
+        TrCBS.SetPrecision(preci);
+        TrCBS.SetMaxTol(maxtol);
+
+        TrCBS.Init(CBS, TP);
+        if (TrCBS.IsDone()) res = TrCBS.Value();
       }
       // try RectangularCompositeSurface
-      else if ( ent->IsKind(STANDARD_TYPE(StepGeom_RectangularCompositeSurface)) ) {
-       Handle(StepGeom_RectangularCompositeSurface) RCS = 
-         Handle(StepGeom_RectangularCompositeSurface)::DownCast(aSurf);
-       Standard_Integer nbi = RCS->NbSegmentsI();
-       Standard_Integer nbj = RCS->NbSegmentsJ();
-       TopoDS_Compound C;
-       B.MakeCompound ( C );
-       for ( Standard_Integer ii=1; ii <= nbi; ii++ ) 
-         for ( Standard_Integer j=1; j <= nbj; j++ ) {
-           Handle(StepGeom_SurfacePatch) patch = RCS->SegmentsValue ( ii, j );
-           TopoDS_Face f = TranslateBoundedSurf (patch->ParentSurface(), preci);
-           if ( ! f.IsNull() ) B.Add ( C, f );
-         }
-       res = C;
+      else if (ent->IsKind(STANDARD_TYPE(StepGeom_RectangularCompositeSurface))) {
+        Handle(StepGeom_RectangularCompositeSurface) RCS =
+          Handle(StepGeom_RectangularCompositeSurface)::DownCast(aSurf);
+        Standard_Integer nbi = RCS->NbSegmentsI();
+        Standard_Integer nbj = RCS->NbSegmentsJ();
+        TopoDS_Compound C;
+        B.MakeCompound(C);
+        for (Standard_Integer ii = 1; ii <= nbi; ii++)
+          for (Standard_Integer j = 1; j <= nbj; j++) {
+            Handle(StepGeom_SurfacePatch) patch = RCS->SegmentsValue(ii, j);
+            TopoDS_Face f = TranslateBoundedSurf(patch->ParentSurface(), preci);
+            if (!f.IsNull()) B.Add(C, f);
+          }
+        res = C;
       }
       // try other surfs
-      else res = TranslateBoundedSurf (aSurf, preci);
+      else res = TranslateBoundedSurf(aSurf, preci);
     }
     else if ( ent->IsKind(STANDARD_TYPE(StepGeom_GeometricRepresentationItem)) )
     {
index 3563ed7..a0351ee 100644 (file)
@@ -67,8 +67,6 @@
 #include <TopoDS.hxx>
 #include <Transfer_TransientProcess.hxx>
 
-//#include <StepToTopoDS_ExtPCOnS.hxx>
-//#include <BRepAPI.hxx>
 // ----------------------------------------------------------------------------
 // Method  : HasPCurve
 // Purpose : returns true if the surface curve has at least one pcurve lying
@@ -171,45 +169,45 @@ Standard_Boolean  StepToTopoDS_GeometricTool::IsLikeSeam
       if (StepEdge == OrEdge->EdgeElement()) nbOE ++;
     }
     // the two oriented edges are not in the same wire
-    if (nbOE == 1) { 
+    if (nbOE == 1) {
       // check is the two pcurve are not indentical ?
       Handle(StepGeom_Line) line1 = Handle(StepGeom_Line)::DownCast
-       (StepPCurve1->ReferenceToCurve()->ItemsValue(1));
+        (StepPCurve1->ReferenceToCurve()->ItemsValue(1));
       Handle(StepGeom_Line) line2 = Handle(StepGeom_Line)::DownCast
-       (StepPCurve2->ReferenceToCurve()->ItemsValue(1));
+        (StepPCurve2->ReferenceToCurve()->ItemsValue(1));
       if (!line1.IsNull() && !line2.IsNull()) {
-       // Same Origin in X OR Y && Same Vector ??
-       // WITHIN A given tolerance !!!
-       Standard_Real DeltaX = Abs(line1->Pnt()->CoordinatesValue(1) -
-                                  line2->Pnt()->CoordinatesValue(1));
-       Standard_Real DeltaY = Abs(line1->Pnt()->CoordinatesValue(2) -
-                                  line2->Pnt()->CoordinatesValue(2));
+        // Same Origin in X OR Y && Same Vector ??
+        // WITHIN A given tolerance !!!
+        Standard_Real DeltaX = Abs(line1->Pnt()->CoordinatesValue(1) -
+          line2->Pnt()->CoordinatesValue(1));
+        Standard_Real DeltaY = Abs(line1->Pnt()->CoordinatesValue(2) -
+          line2->Pnt()->CoordinatesValue(2));
 
-       Standard_Real DeltaDirX = 
-         Abs(line1->Dir()->Orientation()->DirectionRatiosValue(1) -
-             line2->Dir()->Orientation()->DirectionRatiosValue(1));
-       Standard_Real DeltaDirY = 
-         Abs(line1->Dir()->Orientation()->DirectionRatiosValue(2) -
-             line2->Dir()->Orientation()->DirectionRatiosValue(2));
+        Standard_Real DeltaDirX =
+          Abs(line1->Dir()->Orientation()->DirectionRatiosValue(1) -
+          line2->Dir()->Orientation()->DirectionRatiosValue(1));
+        Standard_Real DeltaDirY =
+          Abs(line1->Dir()->Orientation()->DirectionRatiosValue(2) -
+          line2->Dir()->Orientation()->DirectionRatiosValue(2));
 
-       Standard_Real preci2d = Precision::PConfusion(); //:S4136: Parametric(BRepAPI::Precision(),10);
-       
-       if ((DeltaX < preci2d) || (DeltaY < preci2d))
-         return ((DeltaDirX < preci2d) && (DeltaDirY < preci2d));
-       else return Standard_False;
+        Standard_Real preci2d = Precision::PConfusion(); //:S4136: Parametric(BRepAPI::Precision(),10);
 
-       // Warning : la manipulation de tolerances dans ce contexte est un
-       //           peu trop dangeureux.
-       //           il serait preferable de plus de ne pas restreindre au
-       //           cas de deux lignes.
-       //           un mode plus convenable de detection serait de se servir
-       //           des isos (ou bords naturels) de la surface de base
-       //           et de detecter que les deux courbes se trouvent sur le
-       //           bord de fermeture.
-       //           il faut toutefois prevoir le cas ou les deux courbes
-       //           sont confondues (ex : CATIA, "couture" de separation
-       //           en deux faces d un support periodique.
-       //  Ce travail reste evidement A FAIRE !!! ...
+        if ((DeltaX < preci2d) || (DeltaY < preci2d))
+          return ((DeltaDirX < preci2d) && (DeltaDirY < preci2d));
+        else return Standard_False;
+
+        // Warning : la manipulation de tolerances dans ce contexte est un
+        //           peu trop dangeureux.
+        //           il serait preferable de plus de ne pas restreindre au
+        //           cas de deux lignes.
+        //           un mode plus convenable de detection serait de se servir
+        //           des isos (ou bords naturels) de la surface de base
+        //           et de detecter que les deux courbes se trouvent sur le
+        //           bord de fermeture.
+        //           il faut toutefois prevoir le cas ou les deux courbes
+        //           sont confondues (ex : CATIA, "couture" de separation
+        //           en deux faces d un support periodique.
+        //  Ce travail reste evidement A FAIRE !!! ...
       }
       else return Standard_False;
     }
@@ -233,7 +231,6 @@ Standard_Boolean  StepToTopoDS_GeometricTool::UpdateParam3d
   
   Standard_Real cf = theCurve->FirstParameter();
   Standard_Real cl = theCurve->LastParameter();
-//  Standard_Real preci = BRepAPI::Precision();
 
   if (theCurve->IsKind(STANDARD_TYPE(Geom_BoundedCurve)) && !theCurve->IsClosed()) {
     if (w1 < cf) {
@@ -270,9 +267,9 @@ Standard_Boolean  StepToTopoDS_GeometricTool::UpdateParam3d
     // l'un des points projecte se trouve sur l'origine du parametrage
     // de la courbe 3D. L algo a donne cl +- preci au lieu de cf ou vice-versa
     // DANGER precision 3d applique a une espace 1d
-    
+
     // w2 = cf au lieu de w2 = cl
-    if      (Abs(w2 - cf) < Precision::PConfusion() /*preci*/)  w2 = cl ;
+    if (Abs(w2 - cf) < Precision::PConfusion() /*preci*/)  w2 = cl;
     // w1 = cl au lieu de w1 = cf
     else if (Abs(w1 - cl) < Precision::PConfusion() /*preci*/)  w1 = cf;
 
@@ -281,15 +278,15 @@ Standard_Boolean  StepToTopoDS_GeometricTool::UpdateParam3d
     // on inverse quand meme les parametres !!!!!!
     else {
       //:S4136 abv 20 Apr 99: r0701_ug.stp #6230: add check in 3d
-      if ( theCurve->Value(w1).Distance(theCurve->Value(cf)) < preci ) w1 = cf;
-      if ( theCurve->Value(w2).Distance(theCurve->Value(cl)) < preci ) w2 = cl;
-      if ( w1 > w2 ) {
+      if (theCurve->Value(w1).Distance(theCurve->Value(cf)) < preci) w1 = cf;
+      if (theCurve->Value(w2).Distance(theCurve->Value(cl)) < preci) w2 = cl;
+      if (w1 > w2) {
 #ifdef OCCT_DEBUG
-       cout << "Warning : parameter range of edge crossing non periodic curve origin" << endl;
+        cout << "Warning : parameter range of edge crossing non periodic curve origin" << endl;
 #endif
-       Standard_Real tmp = w1;
-       w1 = w2;
-       w2 = tmp;
+        Standard_Real tmp = w1;
+        w1 = w2;
+        w2 = tmp;
       }
     }
   }
@@ -304,9 +301,9 @@ Standard_Boolean  StepToTopoDS_GeometricTool::UpdateParam3d
       // DANGER precision 3d applique a une espace 1d
       
       // w2 = cf au lieu de w2 = cl
-      if      (Abs(w2 - cf) < Precision::PConfusion() /*preci*/) w2 = cl ;
+      if      (Abs(w2 - cf) < Precision::PConfusion()) w2 = cl ;
       // w1 = cl au lieu de w1 = cf
-      else if (Abs(w1 - cl) < Precision::PConfusion() /*preci*/) w1 =  cf;
+      else if (Abs(w1 - cl) < Precision::PConfusion()) w1 =  cf;
 
       // on se trouve dans un cas ou l origine est traversee
       // illegal sur une courbe fermee non periodique
index 5ff6938..d976e69 100644 (file)
 #include <TransferBRep_ShapeBinder.hxx>
 
 //  + pour CartesianOperator3d
+//=======================================================================
+//function : StepToTopoDS_MakeTransformed
+//purpose  : 
+//=======================================================================
+
 StepToTopoDS_MakeTransformed::StepToTopoDS_MakeTransformed ()
 {
 }
 
+//=======================================================================
+//function : Compute
+//purpose  : 
+//=======================================================================
+
 Standard_Boolean  StepToTopoDS_MakeTransformed::Compute
   (const Handle(StepGeom_Axis2Placement3d)& Origin,
    const Handle(StepGeom_Axis2Placement3d)& Target)
@@ -64,27 +74,46 @@ Standard_Boolean  StepToTopoDS_MakeTransformed::Compute
   return Standard_True;
 }
 
+//=======================================================================
+//function : Compute
+//purpose  : 
+//=======================================================================
+
 Standard_Boolean  StepToTopoDS_MakeTransformed::Compute
   (const Handle(StepGeom_CartesianTransformationOperator3d)& Operator)
 {
   return StepToGeom::MakeTransformation3d (Operator, theTrsf);
 }
 
+//=======================================================================
+//function : Transformation
+//purpose  : 
+//=======================================================================
+
 const gp_Trsf&  StepToTopoDS_MakeTransformed::Transformation () const
 {
   return theTrsf;
 }
 
+//=======================================================================
+//function : Transform
+//purpose  : 
+//=======================================================================
+
 Standard_Boolean  StepToTopoDS_MakeTransformed::Transform
   (TopoDS_Shape& shape) const
 {
   if (theTrsf.Form() == gp_Identity) return Standard_False;
   TopLoc_Location theLoc(theTrsf);
   shape.Move (theLoc);
-//  shape.Location(theLoc);
   return Standard_True;
 }
 
+//=======================================================================
+//function : TranslateMappedItem
+//purpose  : 
+//=======================================================================
+
 TopoDS_Shape  StepToTopoDS_MakeTransformed::TranslateMappedItem
 (const Handle(StepRepr_MappedItem)& mapit,
  const Handle(Transfer_TransientProcess)& TP)
@@ -103,8 +132,6 @@ TopoDS_Shape  StepToTopoDS_MakeTransformed::TranslateMappedItem
 
   Handle(StepGeom_CartesianTransformationOperator3d) CartOp =
     Handle(StepGeom_CartesianTransformationOperator3d)::DownCast(mapit->MappingTarget());
-//  Handle(StepRepr_ItemDefinedTransformation) ItemDef =
-//    Handle(StepRepr_ItemDefinedTransformation)::DownCast(mapit->MappingTarget());
 
   Standard_Boolean ok = Standard_False;
   if (!Origin.IsNull() && !Target.IsNull()) ok = Compute (Origin,Target);
index 448c092..6d57831 100644 (file)
@@ -127,20 +127,21 @@ Standard_Boolean StepToTopoDS_TranslateCompositeCurve::Init (const Handle(StepGe
 
     // if segment is itself a composite_curve, translate recursively
     if ( crv->IsKind(STANDARD_TYPE(StepGeom_CompositeCurve)) ) { 
-      if ( crv == CC ) { // cyclic reference protection
-       TP->AddFail (ccs, "Cyclic reference; segment dropped" );
-       continue;
+      if (crv == CC) { // cyclic reference protection
+        TP->AddFail(ccs, "Cyclic reference; segment dropped");
+        continue;
       }
       Handle(StepGeom_CompositeCurve) cc = Handle(StepGeom_CompositeCurve)::DownCast ( crv );
-      if ( ! Init ( cc, TP, S, Surf ) || myWire.IsNull() ) continue;
+      if ( ! Init ( cc, TP, S, Surf ) || myWire.IsNull() )
+        continue;
       Standard_Integer nb = sbwd->NbEdges() + 1;
-      for ( TopoDS_Iterator it ( myWire ); it.More(); it.Next() ) {
-       TopoDS_Edge edge = TopoDS::Edge ( it.Value() );
-       if ( ccs->SameSense() ) sbwd->Add ( edge );
-       else {
-         edge.Reverse();
-         sbwd->Add ( edge, nb > sbwd->NbEdges() ? 0 : nb );
-       }
+      for (TopoDS_Iterator it(myWire); it.More(); it.Next()) {
+        TopoDS_Edge edge = TopoDS::Edge(it.Value());
+        if (ccs->SameSense()) sbwd->Add(edge);
+        else {
+          edge.Reverse();
+          sbwd->Add(edge, nb > sbwd->NbEdges() ? 0 : nb);
+        }
       }
       myWire.Nullify();
       continue;
@@ -150,19 +151,21 @@ Standard_Boolean StepToTopoDS_TranslateCompositeCurve::Init (const Handle(StepGe
     
     // detect pcurve and 3d curve
     Handle(StepGeom_Pcurve) pcurve = Handle(StepGeom_Pcurve)::DownCast ( crv );
-    if ( pcurve.IsNull() ) {
-      Handle(StepGeom_SurfaceCurve) sc = Handle(StepGeom_SurfaceCurve)::DownCast ( crv );
-      if ( ! sc.IsNull() ) {
-       crv = sc->Curve3d();
-       if ( SurfMode ) { // find proper pcurve
-         for ( Standard_Integer j=1; j <= sc->NbAssociatedGeometry(); j++ ) {
-           StepGeom_PcurveOrSurface PCorS = sc->AssociatedGeometryValue ( j );
-           Handle(StepGeom_Pcurve) pc = PCorS.Pcurve();
-           if ( pc.IsNull() || pc->BasisSurface() != S ) continue;
-           pcurve = pc;
-           if ( ccs->SameSense() ) break;
-         }
-       }
+    if (pcurve.IsNull()) {
+      Handle(StepGeom_SurfaceCurve) sc = Handle(StepGeom_SurfaceCurve)::DownCast(crv);
+      if (!sc.IsNull()) {
+        crv = sc->Curve3d();
+        if (SurfMode) { // find proper pcurve
+          for (Standard_Integer j = 1; j <= sc->NbAssociatedGeometry(); j++) {
+            StepGeom_PcurveOrSurface PCorS = sc->AssociatedGeometryValue(j);
+            Handle(StepGeom_Pcurve) pc = PCorS.Pcurve();
+            if (pc.IsNull() || pc->BasisSurface() != S)
+              continue;
+            pcurve = pc;
+            if (ccs->SameSense())
+              break;
+          }
+        }
       }
     }
     else {
@@ -204,30 +207,30 @@ Standard_Boolean StepToTopoDS_TranslateCompositeCurve::Init (const Handle(StepGe
     if ( ! pcurve.IsNull() ) {
       try {
         OCC_CATCH_SIGNALS
-       StepToTopoDS_TranslateEdge TrE;
-       Handle(Geom2d_Curve) c2d = TrE.MakePCurve ( pcurve, Surf );
-       if ( ! c2d.IsNull() ) {
-         if ( edge.IsNull() ) {
-           BRepBuilderAPI_MakeEdge MkEdge ( c2d, Surf, c2d->FirstParameter(), c2d->LastParameter() );
-           if (MkEdge.IsDone())
-           {
-             if (Precision::IsNegativeInfinite (c2d->FirstParameter()) || Precision::IsPositiveInfinite (c2d->LastParameter()))
-             {
-               myInfiniteSegment = Standard_True;
-               TP->AddWarning (CC, "Segment with infinite parameters");
-             }
-             edge = MkEdge.Edge();
-           }
-         }
-         else {
-           BRep_Builder B;
-           TopLoc_Location L;
-           B.UpdateEdge ( edge, c2d, Surf, L, 0. );
-           B.Range ( edge, Surf, L, c2d->FirstParameter(), c2d->LastParameter() );
-           B.SameRange ( edge, Standard_False );
-           B.SameParameter ( edge, Standard_False );
-         }
-       }
+        StepToTopoDS_TranslateEdge TrE;
+        Handle(Geom2d_Curve) c2d = TrE.MakePCurve(pcurve, Surf);
+        if (!c2d.IsNull()) {
+          if (edge.IsNull()) {
+            BRepBuilderAPI_MakeEdge MkEdge(c2d, Surf, c2d->FirstParameter(), c2d->LastParameter());
+            if (MkEdge.IsDone())
+            {
+              if (Precision::IsNegativeInfinite(c2d->FirstParameter()) || Precision::IsPositiveInfinite(c2d->LastParameter()))
+              {
+                myInfiniteSegment = Standard_True;
+                TP->AddWarning(CC, "Segment with infinite parameters");
+              }
+              edge = MkEdge.Edge();
+            }
+          }
+          else {
+            BRep_Builder B;
+            TopLoc_Location L;
+            B.UpdateEdge(edge, c2d, Surf, L, 0.);
+            B.Range(edge, Surf, L, c2d->FirstParameter(), c2d->LastParameter());
+            B.SameRange(edge, Standard_False);
+            B.SameParameter(edge, Standard_False);
+          }
+        }
       }
       catch(Standard_Failure const& anException) {
 #ifdef OCCT_DEBUG
index c058f0b..4dcfc11 100644 (file)
@@ -56,6 +56,11 @@ StepToTopoDS_TranslateCurveBoundedSurface::StepToTopoDS_TranslateCurveBoundedSur
   Init ( CBS, TP );
 }
 
+//=======================================================================
+//function : Init
+//purpose  : 
+//=======================================================================
+
 Standard_Boolean StepToTopoDS_TranslateCurveBoundedSurface::Init (
                 const Handle(StepGeom_CurveBoundedSurface) &CBS, 
                 const Handle(Transfer_TransientProcess) &TP)
@@ -76,22 +81,10 @@ Standard_Boolean StepToTopoDS_TranslateCurveBoundedSurface::Init (
   // pdn to force bsplsurf to be periodic
   Handle(StepGeom_BSplineSurface) sgbss = Handle(StepGeom_BSplineSurface)::DownCast(S);
   if (!sgbss.IsNull()) {
-/*
-    StepGeom_BSplineSurfaceForm form = sgbss->SurfaceForm();
-    if ((form == StepGeom_bssfCylindricalSurf)||
-       (form == StepGeom_bssfConicalSurf)||
-       (form == StepGeom_bssfSphericalSurf)||
-       (form == StepGeom_bssfToroidalSurf)||
-       (form == StepGeom_bssfSurfOfRevolution)||
-       (form == StepGeom_bssfGeneralisedCone)||
-        (form == StepGeom_bssfUnspecified)) 
-*/
-    {
-      Handle(Geom_Surface) periodicSurf = ShapeAlgo::AlgoContainer()->ConvertToPeriodic (Surf);
-      if(!periodicSurf.IsNull()) {
-       TP->AddWarning(S,"Surface forced to be periodic");
-       Surf = periodicSurf;
-      }
+    Handle(Geom_Surface) periodicSurf = ShapeAlgo::AlgoContainer()->ConvertToPeriodic(Surf);
+    if (!periodicSurf.IsNull()) {
+      TP->AddWarning(S, "Surface forced to be periodic");
+      Surf = periodicSurf;
     }
   }
     
index fe3814e..83034c2 100644 (file)
@@ -85,11 +85,7 @@ static void DecodeMakeEdgeError(const BRepLib_MakeEdge&   ME,
   (void)U1, (void)U2; // avoid compiler warning
 
   Handle(Transfer_TransientProcess) TP = aTool.TransientProcess();
-//  if (!myCurve.IsNull() && !tobind.IsNull()) {
-//    TransferBRep::SetShapeResult
-//      (TP,tobind, MakeEdge(myCurve,V1,V2,U1,U2,BRepAPI::Precision()) );
-//    aTool.Bind (tobind,E);  SURTOUT PAS : noter pour debug/erreur
-//  }
+
 #ifdef OCCT_DEBUG
   cout << "------------------------------------" << endl;
   cout << "MakeEdge Error  : " << ME.Error()<<" - ";
@@ -158,18 +154,22 @@ static Handle(Geom_Curve) MakeCurve
 static TopoDS_Edge  MakeEdge
   (const Handle(Geom_Curve)& C3D,
    const TopoDS_Vertex& V1, const TopoDS_Vertex& V2,
-   const Standard_Real U1, const Standard_Real U2) //, const Standard_Real preci)
+   const Standard_Real U1, const Standard_Real U2)
 {
-//  fait son edge quoi qu il arrive
   BRep_Builder B;
   TopoDS_Edge E;
-  B.MakeEdge (E,C3D,Precision::Confusion());//preci);
+  B.MakeEdge (E,C3D,Precision::Confusion());
   B.Add (E,V1);  B.Add (E,V2);
-  B.UpdateVertex(V1, U1, E, 0.);//preci);
-  B.UpdateVertex(V2, U2, E, 0.);//preci);
+  B.UpdateVertex(V1, U1, E, 0.);
+  B.UpdateVertex(V2, U2, E, 0.);
   return E;
 }
 
+// ============================================================================
+// Method  : StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge()
+// Purpose : 
+// ============================================================================
+
 StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge()
 {
   done = Standard_False;
@@ -214,7 +214,6 @@ void StepToTopoDS_TranslateEdge::Init(const Handle(StepShape_Edge)& aEdge,
     else {
       myError  = StepToTopoDS_TranslateEdgeDone;
       done     = Standard_True;
-//      BRep_Builder B;
 //:S4136      B.SameRange(TopoDS::Edge(myResult), Standard_False);    //:a5 abv 11 Feb 98
 //:S4136      B.SameParameter(TopoDS::Edge(myResult), Standard_False);//:a5
       return;
@@ -253,10 +252,6 @@ void StepToTopoDS_TranslateEdge::Init(const Handle(StepShape_Edge)& aEdge,
 
   BRep_Builder B;
 
-//  Standard_Real preci = BRepAPI::Precision();
-
-//  Standard_Real precision = BRepAPI::Precision();
-
   Handle(StepGeom_Curve) C = EC->EdgeGeometry();
   if( C.IsNull())
   {
@@ -273,8 +268,7 @@ void StepToTopoDS_TranslateEdge::Init(const Handle(StepShape_Edge)& aEdge,
   // (following the geometrical sense)
   // -----------------------------------------------------------
 
-//  Standard_Boolean OrientedEdgeOrientation = OE->Orientation();
-  Standard_Boolean EdgeCurveSameSense      = EC->SameSense();
+  Standard_Boolean EdgeCurveSameSense = EC->SameSense();
   
   if (EdgeCurveSameSense) {
     Vstart = EC->EdgeStart();
@@ -315,37 +309,23 @@ void StepToTopoDS_TranslateEdge::Init(const Handle(StepShape_Edge)& aEdge,
   if ( C->IsKind(STANDARD_TYPE(StepGeom_Pcurve))) {
     B.MakeEdge(E);
 //:S4136    B.UpdateEdge (E,preci);
-    B.Add(E, V1);    // ?? en fin de TranslateEdgeLoop
+    B.Add(E, V1);
     B.Add(E, V2);
   }
   else if (C->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve)) ) {
-    // qui reprend les types SeamCurve et IntersectionCurve
+    // For SeamCurve and IntersectionCurve types
     // --- The Edge Geometry is a Surface Curve ---
     // ---     (3d + 2 Pcurve Or Surface)       ---
     Handle(StepGeom_SurfaceCurve) Sc =
       Handle(StepGeom_SurfaceCurve)::DownCast(C);
     Handle(StepGeom_Curve) C1 = Sc->Curve3d();
-//    if (C1->IsKind(STANDARD_TYPE(StepGeom_Polyline))) {
-//    B.MakeEdge(E);
-//      B.UpdateEdge (E,preci);
-//      B.Add(E, V1);    // ?? en fin de TranslateEdgeLoop
-//      B.Add(E, V2);
-//    }
-//    else {
       MakeFromCurve3D (C1,EC,Vend,Precision(), E,V1,V2 , aTool);
-//    }
   }
-//  else if (C->IsKind(STANDARD_TYPE(StepGeom_Polyline))) {
-//    B.MakeEdge(E);
-//    B.UpdateEdge (E,preci);
-//    B.Add(E, V1);    // ?? en fin de TranslateEdgeLoop
-//    B.Add(E, V2);
-//  }
   else {
     // --- The Edge Geometry is a Single 3d Curve ---
     MakeFromCurve3D (C,EC,Vend,Precision(), E,V1,V2 , aTool);
   }
-  // On force les flags SameRange et SameParameter a Standard_False
+  // Force set flags SameRange and SameParameter to Standard_False
   if (done) {
 //:S4136    B.SameRange(E, Standard_False);
 //:S4136    B.SameParameter(E, Standard_False);
@@ -384,6 +364,11 @@ static void GetCartesianPoints ( const Handle(StepShape_EdgeCurve)& EC,
   }
 }
 
+// ============================================================================
+// Method  : StepToTopoDS_TranslateEdge::MakeFromCurve3D()
+// Purpose : 
+// ============================================================================
+
 void  StepToTopoDS_TranslateEdge::MakeFromCurve3D
   (const Handle(StepGeom_Curve)& C3D, const Handle(StepShape_EdgeCurve)& EC,
    const Handle(StepShape_Vertex)&  Vend,
@@ -435,11 +420,9 @@ void  StepToTopoDS_TranslateEdge::MakeFromCurve3D
   }
   else {
     if (ME.Error() == BRepLib_DifferentPointsOnClosedCurve) {
-      // The Edge could be closed and trimmed by 2 Differents
-      // Vertices
+      // The Edge could be closed and trimmed by 2 Different vertices
       if (C1->IsClosed()) {
-       // Attention : il faudra mettre a jour la topologie des
-       // vertex pour avoir des edges cul a cul ...... Good Luck!
+       // Attention : topology updating
        aTool.Bind (Vend,V1);
        TopoDS_Shape aLocalShape = V1.Reversed();
        V2 = TopoDS::Vertex(aLocalShape);
@@ -450,8 +433,8 @@ void  StepToTopoDS_TranslateEdge::MakeFromCurve3D
        }
        else {
          DecodeMakeEdgeError(ME, C3D, C1, V1, V2, U1, U2, aTool, EC);
-         E = MakeEdge (C1,V1,V2,U1,U2);//preci
-         myError = StepToTopoDS_TranslateEdgeDone; // ????
+         E = MakeEdge (C1,V1,V2,U1,U2);
+         myError = StepToTopoDS_TranslateEdgeDone;
          done = Standard_True;
          //            return;               
         }
@@ -459,8 +442,7 @@ void  StepToTopoDS_TranslateEdge::MakeFromCurve3D
       else {
        // Then, this is should be coded as degenerated
        // To be performed later !!!
-//        DecodeMakeEdgeError(ME, C3D, C1, V1, V2, U1, U2, aTool, EC);
-       myError = StepToTopoDS_TranslateEdgeDone; // ????
+       myError = StepToTopoDS_TranslateEdgeDone;
        //  Bon, on la fait cette petite edge, mais faudra repasser
        //  pour l enlever ET FUSIONNER LES VERTEX, pour tout le shell !
        //  courbe trop petite pour etre mise -> fait planter
@@ -483,8 +465,8 @@ void  StepToTopoDS_TranslateEdge::MakeFromCurve3D
     }
     else {
       DecodeMakeEdgeError(ME, C3D, C1, V1, V2, U1, U2, aTool, EC);
-      E = MakeEdge (C1,V1,V2,U1,U2);//,preci
-      myError = StepToTopoDS_TranslateEdgeDone; // ????
+      E = MakeEdge (C1,V1,V2,U1,U2);
+      myError = StepToTopoDS_TranslateEdgeDone;
       done = Standard_True;
     }
   }
index 8b2d1aa..ab911b4 100644 (file)
@@ -127,8 +127,6 @@ static void CheckPCurves (TopoDS_Wire& aWire, const TopoDS_Face& aFace,
   Handle(ShapeExtend_WireData) sbwd = new ShapeExtend_WireData ( aWire );
   for (Standard_Integer i = 1; i <= sbwd->NbEdges(); i++) {
     const TopoDS_Edge& myEdge = sbwd->Edge(i);
-//    B.SameRange( myEdge, Standard_True );
-//    B.SameParameter ( myEdge, Standard_True ); 
     
     // First Check : 2D Parameters on Edge :
     // Case 1 : w1 == w2 illegal => Drop the PCurve
@@ -234,19 +232,14 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
   TopoDS_Edge   E;
   TopoDS_Vertex V;
 
-//  Standard_Real U1,U2, U1a, U1b, U2a, U2b;
-  
   Standard_Boolean isSeam, isLikeSeam;
   
   Handle(StepShape_Edge)         StepEdge, StepEdge1;
   Handle(StepShape_OrientedEdge) OrEdge1, OrEdge2;
   Handle(StepGeom_Curve) StepCurve, StepCurve1, StepCurve2;
-//  Handle(StepGeom_Pcurve) StepPCurve, StepPCurve1, StepPCurve2;
   Handle(StepRepr_DefinitionalRepresentation) DRI, Dri1, Dri2;
   
   Handle(Geom2d_Curve) C2d, C2d1, C2d2, WhichC2d1, WhichC2d2;
-// unused  gp_Pnt Pdeb, Pmil, Pfin, pV1, pV2;
-  
   TopoDS_Edge   suspectE; //:f1, degEdge; 
   
   Standard_Integer j, NbEdge = EL->NbEdgeList();
@@ -275,8 +268,6 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
 
   B.MakeWire(W);
 
-//  Standard_Integer lastpcurve = 0;
-
   // -----------------------------------------------
   // Preparation : Make Vertices + Curves3d
   //  Hence, a closed curve limited by distinct vertices
@@ -298,20 +289,8 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
       if (C->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve))) {
         Handle(StepGeom_SurfaceCurve) Sc = Handle(StepGeom_SurfaceCurve)::DownCast(C);
         C = Sc->Curve3d();
-//      if (modepcurve != 3) {
-//     lastpcurve = StepToTopoDS_GeometricTool::PCurve (Sc,StepSurf,StepPCurve1);
-//     if (StepPCurve1 == StepPCurve) modepcurve = -1;
-//     StepPCurve = StepPCurve1;
-//      }
       }
     }
-////    else if (C->IsKind(STANDARD_TYPE(StepGeom_Polyline))) {  }
-//    else if (C->IsKind(STANDARD_TYPE(StepGeom_Pcurve))) {
-//      if (modepcurve != 3) {
-//     if (C == StepPCurve) modepcurve = -1;
-//     StepPCurve = Handle(StepGeom_Pcurve)::DownCast(C);
-//      }
-//    }
     Handle(Geom_Curve) C1;
     if (!C.IsNull()) {
       try
@@ -355,10 +334,6 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
     if (myTranVertex1.IsDone()) {
       V1 = TopoDS::Vertex(myTranVertex1.Value());
     }
-//    if (Vend == Vstart) {  cas normal deja assure par aTool
-//      aTool.Bind (Vend,V1);
-//    }
-//    else
     if (myTranVertex2.IsDone()) {
       V2 = TopoDS::Vertex(myTranVertex2.Value());
       gp_Pnt p1 = BRep_Tool::Pnt(V1);
@@ -368,24 +343,12 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
        if(!iseV) aTool.Bind(Vend,V1); //gka 21.08.1998 bug PRO7656 
        else if(!istV)  aTool.Bind (Vstart,V2);
        else aTool.Bind (Vend,V1);
-        //Fixed = Standard_False;
-       //aTool.Bind (Vend,V1);
        if (!C1.IsNull() && !C1->IsClosed() && Fixed)
          TP->AddWarning(EL->EdgeListValue(j),
                         "Vertex of same coordinates, set confused");
       }
     }
   }
-//  if (NbEdge!=1 && theSame == NbEdge) {
-//    TP->AddWarning(EL,"Wire was ignored. All edges are the same.");
-//    done = Standard_False;
-//    return;
-//  }
-//  Fixed=Standard_True;
-//  if (modepcurve == -1) {
-//    modepcurve = 3;
-//    TP->AddWarning(EL,"Shared Pcurve not allowed, Pcurves are recomputed");
-//  }
 
   //:f6 abv 29 Apr 98: BUC50070 #3815: make sure that each two edges are
   // connected by the same vertex; else check that vertices confuse
@@ -408,7 +371,6 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
     Vs22 = ( OrEdge2->Orientation() ?  EC2->EdgeEnd() : EC2->EdgeStart() );
 
     if((Vs1 == Vs2) || (Vs1 == Vs22) || (Vs2 == Vs11) || (Vs22 == Vs11)) continue;
-    //??    if ( Vs1.IsSame(Vs2) ) continue; // OK
 
     StepToTopoDS_TranslateVertex myTranVertex1 (Vs1, aTool, NMTool);
     StepToTopoDS_TranslateVertex myTranVertex2 (Vs2, aTool, NMTool);
@@ -484,14 +446,14 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
       // --------------------------------------------
       if (C.IsNull())
       {
-       aTool.ComputePCurve(Standard_True);
-       hasPcurve = Standard_False;
+        aTool.ComputePCurve(Standard_True);
+        hasPcurve = Standard_False;
       }
       else if (C->IsKind(STANDARD_TYPE(StepGeom_Pcurve))) {
-       Handle(StepGeom_Pcurve) StepPCurve = Handle(StepGeom_Pcurve)::DownCast(C);
-       C2d = myTranEdge.MakePCurve (StepPCurve,ConvSurf);
-       // -- Statistics --
-       aTool.AddContinuity (C2d);
+        Handle(StepGeom_Pcurve) StepPCurve = Handle(StepGeom_Pcurve)::DownCast(C);
+        C2d = myTranEdge.MakePCurve(StepPCurve, ConvSurf);
+        // -- Statistics --
+        aTool.AddContinuity(C2d);
       }
 
       // -----------------------------------------
@@ -502,69 +464,69 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
       // -----------------------------------------
 
       else if (modepcurve == 3) {
-       aTool.ComputePCurve(Standard_True);
-       hasPcurve = Standard_False;
+        aTool.ComputePCurve(Standard_True);
+        hasPcurve = Standard_False;
       }
-      else if (C->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve)) ) {
-       // recouvre les cas SeamCurve et IntersectionCurve
-       
-       Handle(StepGeom_SurfaceCurve) SurfCurve =
-         Handle(StepGeom_SurfaceCurve)::DownCast(C);
-
-       Handle(StepGeom_Pcurve) StepPCurve, StepPCurve1, StepPCurve2;
-       Standard_Integer lastpcurve = StepToTopoDS_GeometricTool::PCurve(SurfCurve,StepSurf,StepPCurve,0);
-       hasPcurve = !StepPCurve.IsNull();
-
-       // De toute facon, on recalcule
-
-       if (isPlane) hasPcurve = Standard_False;
-
-       // -------------------------------------------
-       // ---        Special Mapping Cases :      ---
-       // ---   the SurfaceCurve is a SeamCurve   ---
-       // ---        or is like a seam curve      ---
-       // ---         (see CATIA cylinder)        ---
-       // -------------------------------------------
-       isLikeSeam = StepToTopoDS_GeometricTool::IsLikeSeam(SurfCurve,StepSurf,StepEdge,EL);
-
-       isSeam = StepToTopoDS_GeometricTool::IsSeamCurve(SurfCurve, StepSurf,StepEdge, EL);
-       
-       if (isSeam || isLikeSeam) {
-         // isLikeSeam = Two faces on the same Surface
-         StepPCurve1 = SurfCurve->AssociatedGeometryValue(1).Pcurve();
-         StepPCurve2 = SurfCurve->AssociatedGeometryValue(2).Pcurve();
-         if (StepPCurve1.IsNull() || StepPCurve2.IsNull()) hasPcurve = Standard_False; //smh : BUC60810
-         else {
-           C2d1 = myTranEdge.MakePCurve (StepPCurve1,ConvSurf);
-           C2d2 = myTranEdge.MakePCurve (StepPCurve2,ConvSurf);
-           hasPcurve = (!C2d1.IsNull() && !C2d2.IsNull());
-         }
-
-         if (isLikeSeam) {
-           suspectE = E;
-           ThereIsLikeSeam = Standard_True;
-           hasPcurve = Standard_True;
-         }
-       }
-       else if (hasPcurve) {
-//  GeometricTool : Pcurve a retourne StepPCurve
-         while (lastpcurve > 0) {
-           C2d1 = myTranEdge.MakePCurve (StepPCurve,ConvSurf);
-           if (C2d1.IsNull()) {
-         TP->AddWarning(EC,"Incorrect pcurve is not translated. Pcurve definition is not correct");
-             hasPcurve = Standard_False;
-             break;
-           }
-           else C2d = C2d1;
-           lastpcurve = StepToTopoDS_GeometricTool::PCurve(SurfCurve,StepSurf,StepPCurve,lastpcurve);
-           // -- Statistics --
-           aTool.AddContinuity (C2d);
-         }
-       }
-       if (!hasPcurve) {
-         // The edge geometry has no 2D representation
-         aTool.ComputePCurve(Standard_True);
-       }
+      else if (C->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve))) {
+        // recouvre les cas SeamCurve et IntersectionCurve
+
+        Handle(StepGeom_SurfaceCurve) SurfCurve =
+          Handle(StepGeom_SurfaceCurve)::DownCast(C);
+
+        Handle(StepGeom_Pcurve) StepPCurve, StepPCurve1, StepPCurve2;
+        Standard_Integer lastpcurve = StepToTopoDS_GeometricTool::PCurve(SurfCurve, StepSurf, StepPCurve, 0);
+        hasPcurve = !StepPCurve.IsNull();
+
+        // De toute facon, on recalcule
+
+        if (isPlane) hasPcurve = Standard_False;
+
+        // -------------------------------------------
+        // ---        Special Mapping Cases :      ---
+        // ---   the SurfaceCurve is a SeamCurve   ---
+        // ---        or is like a seam curve      ---
+        // ---         (see CATIA cylinder)        ---
+        // -------------------------------------------
+        isLikeSeam = StepToTopoDS_GeometricTool::IsLikeSeam(SurfCurve, StepSurf, StepEdge, EL);
+
+        isSeam = StepToTopoDS_GeometricTool::IsSeamCurve(SurfCurve, StepSurf, StepEdge, EL);
+
+        if (isSeam || isLikeSeam) {
+          // isLikeSeam = Two faces on the same Surface
+          StepPCurve1 = SurfCurve->AssociatedGeometryValue(1).Pcurve();
+          StepPCurve2 = SurfCurve->AssociatedGeometryValue(2).Pcurve();
+          if (StepPCurve1.IsNull() || StepPCurve2.IsNull()) hasPcurve = Standard_False; //smh : BUC60810
+          else {
+            C2d1 = myTranEdge.MakePCurve(StepPCurve1, ConvSurf);
+            C2d2 = myTranEdge.MakePCurve(StepPCurve2, ConvSurf);
+            hasPcurve = (!C2d1.IsNull() && !C2d2.IsNull());
+          }
+
+          if (isLikeSeam) {
+            suspectE = E;
+            ThereIsLikeSeam = Standard_True;
+            hasPcurve = Standard_True;
+          }
+        }
+        else if (hasPcurve) {
+          //  GeometricTool : Pcurve a retourne StepPCurve
+          while (lastpcurve > 0) {
+            C2d1 = myTranEdge.MakePCurve(StepPCurve, ConvSurf);
+            if (C2d1.IsNull()) {
+              TP->AddWarning(EC, "Incorrect pcurve is not translated. Pcurve definition is not correct");
+              hasPcurve = Standard_False;
+              break;
+            }
+            else C2d = C2d1;
+            lastpcurve = StepToTopoDS_GeometricTool::PCurve(SurfCurve, StepSurf, StepPCurve, lastpcurve);
+            // -- Statistics --
+            aTool.AddContinuity(C2d);
+          }
+        }
+        if (!hasPcurve) {
+          // The edge geometry has no 2D representation
+          aTool.ComputePCurve(Standard_True);
+        }
       }
       
       // ----------------------------------------------------------
@@ -573,8 +535,8 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
       // ----------------------------------------------------------
 
       else {
-       aTool.ComputePCurve(Standard_True);
-       hasPcurve = Standard_False;
+        aTool.ComputePCurve(Standard_True);
+        hasPcurve = Standard_False;
       }
       
       // ----------------------------------
@@ -583,101 +545,94 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
 
       if (hasPcurve && (isSeam || ThereIsLikeSeam)) {
 
-      // -----------------------------------------------------------
-      // The Edge is a Seam Edge : The pcurve wich is FORWARD has to
-      //                           be identified
-      // -----------------------------------------------------------
-      
-       if ((!C2d1.IsNull()) && (!C2d2.IsNull())) {
-         TopAbs_Orientation CumulO, EdgeO, WireO, FaceO;
-         EdgeO = E.Orientation();
-         if (ForwardWire)  WireO = TopAbs_FORWARD;
-         else              WireO = TopAbs_REVERSED;
-         if (sameSense) FaceO = TopAbs_FORWARD;
-         else           FaceO = TopAbs_REVERSED;
-
-         CumulO = TopAbs::Compose(EdgeO, WireO);
-         CumulO = TopAbs::Compose(CumulO, FaceO);
-
-         Standard_Boolean ForwardEdge = (CumulO == TopAbs_FORWARD);
-
-         // if(!ThereIsLikeSeam) ForwardEdge = Standard_True;
-         Standard_Integer forwardPC =
-           ShapeAnalysis_Curve().SelectForwardSeam (C2d1,C2d2);
-         if (forwardPC == 0) {
-           TP->AddFail(StepEdge," Seam curve not mapped");
-           done = Standard_False;
-           myError = StepToTopoDS_TranslateEdgeLoopOther;
-           continue;
-         }
-         else if (!ForwardEdge) forwardPC = 3 - forwardPC;  // inverser 1-2
-
-         if (forwardPC == 1) {
-           if(isSeam) {
-             // When the edge is a Seam, it is better to find the topological
-             // trimming right now. 
-             // Remarque : pour bien faire, il faudrait, si necessaire, recalculer
-             //            les trois courbes de maniere a ce qu`elles soient
-             //            immediatement Same Range et Same Parameter.
-             B.UpdateEdge(E, C2d1, C2d2, Face, 0.);
-//:S4136             FindParameter(C2d1, C2d2, E, Face, preci);
-           }
-           else
-             B.UpdateEdge(E, C2d1, Face, 0.); //preci
-         }
-         else {
-           if(isSeam) {
-             // When the edge is a Seam, it is better to find the topological
-             // trimming right now. 
-             B.UpdateEdge(E, C2d2, C2d1, Face, 0.);
-//:S4136             FindParameter(C2d1, C2d2, E, Face, preci);
-           }
-           else
-             B.UpdateEdge(E, C2d2, Face, 0.);
-         }
-       }
-       else {
-         TP->AddFail(StepEdge," Seam curve not mapped");
-         done = Standard_False;
-         myError = StepToTopoDS_TranslateEdgeLoopOther;
-         continue;
-       }
+        // -----------------------------------------------------------
+        // The Edge is a Seam Edge : The pcurve wich is FORWARD has to
+        //                           be identified
+        // -----------------------------------------------------------
+
+        if ((!C2d1.IsNull()) && (!C2d2.IsNull())) {
+          TopAbs_Orientation CumulO, EdgeO, WireO, FaceO;
+          EdgeO = E.Orientation();
+          if (ForwardWire)  WireO = TopAbs_FORWARD;
+          else             WireO = TopAbs_REVERSED;
+          if (sameSense) FaceO = TopAbs_FORWARD;
+          else           FaceO = TopAbs_REVERSED;
+
+          CumulO = TopAbs::Compose(EdgeO, WireO);
+          CumulO = TopAbs::Compose(CumulO, FaceO);
+
+          Standard_Boolean ForwardEdge = (CumulO == TopAbs_FORWARD);
+
+          Standard_Integer forwardPC =
+            ShapeAnalysis_Curve().SelectForwardSeam(C2d1, C2d2);
+          if (forwardPC == 0) {
+            TP->AddFail(StepEdge, " Seam curve not mapped");
+            done = Standard_False;
+            myError = StepToTopoDS_TranslateEdgeLoopOther;
+            continue;
+          }
+          else if (!ForwardEdge) forwardPC = 3 - forwardPC;  // inverser 1-2
+
+          if (forwardPC == 1) {
+            if (isSeam) {
+              // When the edge is a Seam, it is better to find the topological
+              // trimming right now. 
+              // Remarque : pour bien faire, il faudrait, si necessaire, recalculer
+              //            les trois courbes de maniere a ce qu`elles soient
+              //            immediatement Same Range et Same Parameter.
+              B.UpdateEdge(E, C2d1, C2d2, Face, 0.);
+              //:S4136       FindParameter(C2d1, C2d2, E, Face, preci);
+            }
+            else
+              B.UpdateEdge(E, C2d1, Face, 0.); //preci
+          }
+          else {
+            if (isSeam) {
+              // When the edge is a Seam, it is better to find the topological
+              // trimming right now. 
+              B.UpdateEdge(E, C2d2, C2d1, Face, 0.);
+              //:S4136       FindParameter(C2d1, C2d2, E, Face, preci);
+            }
+            else
+              B.UpdateEdge(E, C2d2, Face, 0.);
+          }
+        }
+        else {
+          TP->AddFail(StepEdge, " Seam curve not mapped");
+          done = Standard_False;
+          myError = StepToTopoDS_TranslateEdgeLoopOther;
+          continue;
+        }
       }
       else {
-       
-       // ---------------------------
-       // The Edge is a "normal" edge
-       // ---------------------------
-       
-       if (hasPcurve) {
-         if ( !C2d.IsNull() && !isLikeSeam ) {
-           B.UpdateEdge(E, C2d, Face, 0.);
-         }
-         else {
-           TP->AddFail(StepEdge," Edge: Trimming of 2D curve failed");
-           //    cout << "2D curve type : " << C2d->DynamicType() << endl;
-           done = Standard_False;
-           myError = StepToTopoDS_TranslateEdgeLoopOther;
-           continue;
-         }
-       }
-      }
 
-      if (!E.IsNull()) {
-//     B.Add(W,E);   -- DABORD regarder degeneree manquante !!!
+        // ---------------------------
+        // The Edge is a "normal" edge
+        // ---------------------------
+
+        if (hasPcurve) {
+          if (!C2d.IsNull() && !isLikeSeam) {
+            B.UpdateEdge(E, C2d, Face, 0.);
+          }
+          else {
+            TP->AddFail(StepEdge, " Edge: Trimming of 2D curve failed");
+            done = Standard_False;
+            myError = StepToTopoDS_TranslateEdgeLoopOther;
+            continue;
+          }
+        }
       }
-      else {
-       TP->AddFail(StepEdge," an Edge not mapped");
-       done = Standard_False;
-       myError = StepToTopoDS_TranslateEdgeLoopOther;
-//     continue;
+
+      if (E.IsNull()) {
+        TP->AddFail(StepEdge, " an Edge not mapped");
+        done = Standard_False;
+        myError = StepToTopoDS_TranslateEdgeLoopOther;
       }
     }
     else { // The Edge is Not mapped => switch to next wire ?
       TP->AddFail(StepEdge," an Edge not mapped");
       done = Standard_False;
       myError = StepToTopoDS_TranslateEdgeLoopOther;
-//      continue;
     }
 
     if (done) B.Add (W,E);  // on le fait ici. Sauf si erreur rencontree ... !
@@ -704,7 +659,7 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
   // ----------------------------------------------
   // Computes the 2D parameter of Vertices on Edges
   // ----------------------------------------------
-  //pdn compute parameter of Vertices using progecting
+  //pdn compute parameter of Vertices using projecting
   if (!aTool.ComputePCurve()) 
     for (TopoDS_Iterator EdgeIt(W);EdgeIt.More();EdgeIt.Next()){
       TopoDS_Edge edge = TopoDS::Edge(EdgeIt.Value());
@@ -728,19 +683,8 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
   myError  = StepToTopoDS_TranslateEdgeLoopDone;
   done     = Standard_True;
   //  Check des PCurves SYSTEMATIQUE, s il n y en a que quelques unes
-//  if (isPlane) RemovePCurves (W, Face);
-// else         CheckPCurves  (W, Face);
   CheckPCurves  (W, Face,isPlane,preci);
 
-  // --------------------------------------------      
-  // Control the UVLoop (Closed and Head To Tail)
-  // --------------------------------------------
-  
-//  StepToTopoDS_GeometricToolError tError = 
-//    StepToTopoDS_GeometricTool::CloseUV(W, Face, aTool);
-//  if(tError != StepToTopoDS_GeometricToolDone) {
-//    TP->AddWarning(StepEdge,StepToTopoDS::DecodeGeometricToolError(tError));
-//  }
   return;
 }
 
index cd673ae..e710c76 100644 (file)
@@ -127,6 +127,11 @@ static inline Standard_Boolean isReversed(const Handle(StepGeom_Surface)& theSte
   return (!aStepTorSur.IsNull() && aStepTorSur->MajorRadius() < 0 ? Standard_True : Standard_False);
 }
 
+// ============================================================================
+// Method  : Init
+// Purpose : Init with a FaceSurface and a Tool
+// ============================================================================
+
 void StepToTopoDS_TranslateFace::Init
 (const Handle(StepShape_FaceSurface)& FS, StepToTopoDS_Tool& aTool, StepToTopoDS_NMTool& NMTool)
 {
@@ -179,22 +184,10 @@ void StepToTopoDS_TranslateFace::Init
   // pdn to force bsplsurf to be periodic
   Handle(StepGeom_BSplineSurface) sgbss = Handle(StepGeom_BSplineSurface)::DownCast(StepSurf);
   if (!sgbss.IsNull()) {
-/*
-    StepGeom_BSplineSurfaceForm form = sgbss->SurfaceForm();
-    if ((form == StepGeom_bssfCylindricalSurf)||
-       (form == StepGeom_bssfConicalSurf)||
-       (form == StepGeom_bssfSphericalSurf)||
-       (form == StepGeom_bssfToroidalSurf)||
-       (form == StepGeom_bssfSurfOfRevolution)||
-       (form == StepGeom_bssfGeneralisedCone)||
-        (form == StepGeom_bssfUnspecified))
-*/
-    {
-      Handle(Geom_Surface) periodicSurf = ShapeAlgo::AlgoContainer()->ConvertToPeriodic (GeomSurf);
-      if(!periodicSurf.IsNull()) {
-       TP->AddWarning(StepSurf,"Surface forced to be periodic");
-       GeomSurf = periodicSurf;
-      }
+    Handle(Geom_Surface) periodicSurf = ShapeAlgo::AlgoContainer()->ConvertToPeriodic(GeomSurf);
+    if (!periodicSurf.IsNull()) {
+      TP->AddWarning(StepSurf, "Surface forced to be periodic");
+      GeomSurf = periodicSurf;
     }
   }
     
@@ -232,11 +225,6 @@ void StepToTopoDS_TranslateFace::Init
   // Alors on peut dire : face a deux bords dont la couture manque
   // La couture est entre les deux vertex
 
-//  TopoDS_Wire W1,W2;
-//  Standard_Boolean fautcoudre =
-//    ( (NbBnd == 2) && (GeomSurf->IsUClosed() || GeomSurf->IsVClosed()) );
-
-  
   for (Standard_Integer i = 1; i <= NbBnd; i ++) {
 
 #ifdef OCCT_DEBUG
@@ -264,29 +252,25 @@ void StepToTopoDS_TranslateFace::Init
           BRepBuilderAPI_MakeFace mf (GeomSurf, Precision());
           for (TopoDS_Iterator it(mf); it.More(); it.Next()) 
             B.Add (F, it.Value());
-        
-
-        continue;
+          continue;
         }
       }
       
-      if (//GeomSurf->IsKind(STANDARD_TYPE(Geom_SphericalSurface)) ||
-         GeomSurf->IsKind(STANDARD_TYPE(Geom_ToroidalSurface)) ) {
-//     TP->AddWarning(VL," VertexLoop on Cone or Torus NOT YET IMPLEMENTED");
-       continue;
+      if (GeomSurf->IsKind(STANDARD_TYPE(Geom_ToroidalSurface))) {
+        continue;
       }
-      if (GeomSurf->IsKind(STANDARD_TYPE(Geom_Plane)) ) {
-       TP->AddWarning(VL,"VertexLoop on plane is ignored");
-       continue; //smh : BUC60809
+      if (GeomSurf->IsKind(STANDARD_TYPE(Geom_Plane))) {
+        TP->AddWarning(VL, "VertexLoop on plane is ignored");
+        continue; //smh : BUC60809
       }
       myTranVL.SetPrecision(Precision());//gka
       myTranVL.SetMaxTol(MaxTol());
       myTranVL.Init(VL, aTool, NMTool);
       if (myTranVL.IsDone()) {
-       B.Add ( F, myTranVL.Value() );
+        B.Add(F, myTranVL.Value());
       }
       else {
-       TP->AddWarning(VL," a VertexLoop not mapped to TopoDS");
+        TP->AddWarning(VL, " a VertexLoop not mapped to TopoDS");
       }
     }
     
@@ -302,12 +286,12 @@ void StepToTopoDS_TranslateFace::Init
       myTranPL.SetMaxTol(MaxTol());
       myTranPL.Init(PL, aTool, GeomSurf, F);
       if (myTranPL.IsDone()) {
-       TopoDS_Wire W = TopoDS::Wire(myTranPL.Value());
-       W.Orientation ( FaceBound->Orientation()  ? TopAbs_FORWARD : TopAbs_REVERSED);
-       B.Add ( F, W );
+        TopoDS_Wire W = TopoDS::Wire(myTranPL.Value());
+        W.Orientation(FaceBound->Orientation() ? TopAbs_FORWARD : TopAbs_REVERSED);
+        B.Add(F, W);
       }
-      else { 
-       TP->AddWarning(PL," a PolyLoop not mapped to TopoDS");
+      else {
+        TP->AddWarning(PL, " a PolyLoop not mapped to TopoDS");
       }
     }
     
@@ -316,11 +300,11 @@ void StepToTopoDS_TranslateFace::Init
     // -----------------------
     
     else if (Loop->IsKind(STANDARD_TYPE(StepShape_EdgeLoop))) {
-//:S4136      if (STF.Closed()) {
-//:S4136       Handle(StepShape_EdgeLoop) EL = 
-//:S4136         Handle(StepShape_EdgeLoop)::DownCast(FaceBound->Bound());
-//:S4136       if (EL->NbEdgeList() != 1) STF.Closed() = Standard_False;
-//:S4136      }
+      //:S4136      if (STF.Closed()) {
+      //:S4136 Handle(StepShape_EdgeLoop) EL = 
+      //:S4136   Handle(StepShape_EdgeLoop)::DownCast(FaceBound->Bound());
+      //:S4136 if (EL->NbEdgeList() != 1) STF.Closed() = Standard_False;
+      //:S4136      }
 
       TopoDS_Wire   W;
       myTranEdgeLoop.SetPrecision(Precision());  //gka
@@ -328,62 +312,42 @@ void StepToTopoDS_TranslateFace::Init
       myTranEdgeLoop.Init(FaceBound, F, GeomSurf, StepSurf, sameSense, aTool, NMTool);
 
       if (myTranEdgeLoop.IsDone()) {
+        W = TopoDS::Wire(myTranEdgeLoop.Value());
 
-       W = TopoDS::Wire(myTranEdgeLoop.Value());
+        // STEP Face_Surface orientation :
+        // if the topological orientation is opposite to the geometric
+        // orientation of the surface => the underlying topological 
+        // orientation are not implicitly reversed
+        // this is the case in CAS.CADE => If the face_surface is reversed,
+        // the wire orientation has to be explictly reversed
+        if (FaceBound->Orientation()) {
+          // *DTH*       if (sameSense || GeomSurf->IsKind(STANDARD_TYPE(Geom_Plane)))
+          W.Orientation(sameSense ? TopAbs_FORWARD : TopAbs_REVERSED);
+        }
+        else {
+          // *DTH*       if (sameSense || GeomSurf->IsKind(STANDARD_TYPE(Geom_Plane)))
+          W.Orientation(sameSense ? TopAbs_REVERSED : TopAbs_FORWARD);
+        }
+        // -----------------------------
+        // The Wire is added to the Face      
+        // -----------------------------
 
-       // STEP Face_Surface orientation :
-       // if the topological orientation is opposite to the geometric
-       // orientation of the surface => the underlying topological 
-       // orientation are not implicitly reversed
-       // this is the case in CAS.CADE => If the face_surface is reversed,
-       // the wire orientation has to be explictly reversed
-       if (FaceBound->Orientation()) {
-// *DTH*         if (sameSense || GeomSurf->IsKind(STANDARD_TYPE(Geom_Plane)))
-         W.Orientation (sameSense ? TopAbs_FORWARD : TopAbs_REVERSED);
-       }
-       else {
-// *DTH*         if (sameSense || GeomSurf->IsKind(STANDARD_TYPE(Geom_Plane)))
-         W.Orientation (sameSense ? TopAbs_REVERSED : TopAbs_FORWARD);
-       }
-       // -----------------------------
-       // The Wire is added to the Face      
-       // -----------------------------
-       
-       B.Add ( F, W );
+        B.Add(F, W);
       }
       else {
-       // Il y a eu un probleme dans le mapping : On perd la Face
-       // (facon de parler ...) Pas de moyen aujourd hui de recuperer
-       // au moins toutes les geometries (Points, Courbes 3D, Surface)
-       TP->AddFail(Loop," EdgeLoop not mapped to TopoDS");
-       //if(GeomSurf->IsKind(STANDARD_TYPE(Geom_BoundedSurface))) {
-       //Standard_Real su1, sv1, su2, sv2;
-       //GeomSurf->Bounds(su1, su2, sv1, sv2);
-       //if(sv1 == -Precision::Infinite()) sv1 = 0.;
-       //if(sv2 ==  Precision::Infinite()) sv2 = 1.;
-       //BRepBuilderAPI_MakeFace mkf(GeomSurf,su1,su2,sv1,sv2);
-       //if (mkf.IsDone()) {
-       // done shall be standard false but no recipient to
-       // to store uncompletally mapped topology
-       // see Improvment Resquest DPA/126/95
-       //myResult = mkf.Face();
-       //done = Standard_True;
-       //}
-       //}
+        // Il y a eu un probleme dans le mapping : On perd la Face
+        // (facon de parler ...) Pas de moyen aujourd hui de recuperer
+        // au moins toutes les geometries (Points, Courbes 3D, Surface)
+        TP->AddFail(Loop, " EdgeLoop not mapped to TopoDS");
 
-       // CKY JAN-97 : un Wire manque, eh bien on continue quand meme !!
-       //  sauf si OuterBound : la c est quand meme pas bien normal ...
-       if (FaceBound->IsKind(STANDARD_TYPE(StepShape_FaceOuterBound))) {
-         TP->AddWarning(FS,"No Outer Bound : Face not done");
-//     return;
-       }
-       continue;
-//     myError = StepToTopoDS_TranslateFaceOther;
-//     done = Standard_False;
-//     return;
+        // CKY JAN-97 : un Wire manque, eh bien on continue quand meme !!
+        //  sauf si OuterBound : la c est quand meme pas bien normal ...
+        if (FaceBound->IsKind(STANDARD_TYPE(StepShape_FaceOuterBound))) {
+          TP->AddWarning(FS, "No Outer Bound : Face not done");
+        }
+        continue;
       }
-    }
-    
+    }    
     else { 
       // Type not yet implemented or non sens
       TP->AddFail(Loop," Type of loop not yet implemented");
@@ -391,9 +355,6 @@ void StepToTopoDS_TranslateFace::Init
       cout << Loop->DynamicType() << endl;
 #endif
       continue;
-//      done    = Standard_False;
-//      myError = StepToTopoDS_TranslateFaceOther;
-//      return;
     }
   }
 
index f414444..bdf0083 100644 (file)
@@ -113,55 +113,50 @@ void StepToTopoDS_TranslatePolyLoop::Init(const Handle(StepShape_PolyLoop)& PL,
       GP2 = StepToGeom::MakeCartesianPoint (P2);
       TopoDS_Shape aBoundEdge;
       Standard_Boolean isbound = aTool.IsEdgeBound(PP);
-      if ( !isbound) {
-       if (aTool.IsVertexBound(P2)) {
-         V2 = aTool.FindVertex(P2);
-       }
-       else {
-         B.MakeVertex(V2, GP2->Pnt(), Precision::Confusion()); //:S4136: preci
-         aTool.BindVertex(P2,V2);
-       }
-       V = gp_Vec( GP1->Pnt(), GP2->Pnt());
-       L = new Geom_Line( GP1->Pnt() , gp_Dir(V) );
-       B.MakeEdge(E, L, Precision::Confusion()); //:S4136: preci
-       V1.Orientation(TopAbs_FORWARD);
-       V2.Orientation(TopAbs_REVERSED);
-       B.Add(E, V1);
-       B.Add(E, V2);
-       Magn = V.Magnitude();
-       B.UpdateVertex(V1, 0., E, 0. ); //:S4136: preci
-       B.UpdateVertex(V2, Magn, E, 0. ); //:S4136: preci
-      } 
+      if (!isbound) {
+        if (aTool.IsVertexBound(P2)) {
+          V2 = aTool.FindVertex(P2);
+        }
+        else {
+          B.MakeVertex(V2, GP2->Pnt(), Precision::Confusion()); //:S4136: preci
+          aTool.BindVertex(P2, V2);
+        }
+        V = gp_Vec(GP1->Pnt(), GP2->Pnt());
+        L = new Geom_Line(GP1->Pnt(), gp_Dir(V));
+        B.MakeEdge(E, L, Precision::Confusion()); //:S4136: preci
+        V1.Orientation(TopAbs_FORWARD);
+        V2.Orientation(TopAbs_REVERSED);
+        B.Add(E, V1);
+        B.Add(E, V2);
+        Magn = V.Magnitude();
+        B.UpdateVertex(V1, 0., E, 0.); //:S4136: preci
+        B.UpdateVertex(V2, Magn, E, 0.); //:S4136: preci
+      }
       else {
-       aBoundEdge = aTool.FindEdge(PP);
-       E = TopoDS::Edge(aBoundEdge);
-//  Il faut qu en finale l edge soit vue
-//  - via sa premiere face, orientation combinee = celle de cette premiere face
-//  - via sa deuxieme face, orientation combinee INVERSE de la precedente
-       if (TopoFace.Orientation() == TopAbs_FORWARD) E.Reverse();
-       V2 = aTool.FindVertex(P2); 
-//     Standard_Real u1,v1,u2,v2;
-//     ElSLib::Parameters(SP->Pln(), GP1->Pnt(), u1, v1);
-//     ElSLib::Parameters(SP->Pln(), GP2->Pnt(), u2, v2);
-//     V2d = gp_Vec2d( gp_Pnt2d(u1,v1), gp_Pnt2d(u2,v2) );
-//     L2d = new Geom2d_Line( gp_Pnt2d(u1,v1), gp_Dir2d(V2d) );
+        aBoundEdge = aTool.FindEdge(PP);
+        E = TopoDS::Edge(aBoundEdge);
+        //  Il faut qu en finale l edge soit vue
+        //  - via sa premiere face, orientation combinee = celle de cette premiere face
+        //  - via sa deuxieme face, orientation combinee INVERSE de la precedente
+        if (TopoFace.Orientation() == TopAbs_FORWARD) E.Reverse();
+        V2 = aTool.FindVertex(P2);
       }
       gp_Pnt2d V2p1 = STSU->ValueOfUV (GP1->Pnt(), Precision());
       gp_Pnt2d V2p2 = STSU->ValueOfUV (GP2->Pnt(), Precision());
       if (E.Orientation() == TopAbs_FORWARD) {
-       V2d = gp_Vec2d( V2p1, V2p2 );
-       L2d = new Geom2d_Line( V2p1, gp_Dir2d(V2d) );
-      } else {
-       V2d = gp_Vec2d( V2p2, V2p1 );
-       L2d = new Geom2d_Line( V2p2, gp_Dir2d(V2d) );
+        V2d = gp_Vec2d(V2p1, V2p2);
+        L2d = new Geom2d_Line(V2p1, gp_Dir2d(V2d));
+      }
+      else {
+        V2d = gp_Vec2d(V2p2, V2p1);
+        L2d = new Geom2d_Line(V2p2, gp_Dir2d(V2d));
       }
       B.UpdateEdge(E, L2d, TopoFace, 0.);
-//      E.Orientation(TopAbs_FORWARD);
       TopoDS_Edge EB = E;  // pour le binding : cumul des orientations !
       EB.Orientation (TopoFace.Orientation());
       if (!isbound) aTool.BindEdge(PP, EB);
-      if (!E.IsNull()) { 
-       B.Add(W,E);
+      if (!E.IsNull()) {
+        B.Add(W, E);
       }
       P1  = P2;
       GP1 = GP2;
index b3df196..b9eab17 100644 (file)
@@ -81,26 +81,26 @@ void StepToTopoDS_TranslateShell::Init
     myTranFace.SetMaxTol(MaxTol());
 
     Message_ProgressSentry PS ( TP->GetProgress(), "Face", 0, NbFc, 1 );
-    for (Standard_Integer i=1; i<=NbFc && PS.More(); i++, PS.Next()) {
+    for (Standard_Integer i = 1; i <= NbFc && PS.More(); i++, PS.Next()) {
 #ifdef OCCT_DEBUG
       cout << "Processing Face : " << i << endl;
 #endif
       StepFace = CFS->CfsFacesValue(i);
-      Handle(StepShape_FaceSurface) theFS = 
-       Handle(StepShape_FaceSurface)::DownCast(StepFace);
+      Handle(StepShape_FaceSurface) theFS =
+        Handle(StepShape_FaceSurface)::DownCast(StepFace);
       if (!theFS.IsNull()) {
-       myTranFace.Init(theFS, aTool, NMTool);
-       if (myTranFace.IsDone()) {
-         S = myTranFace.Value();
-         F = TopoDS::Face(S);
-         B.Add(Sh, F);
-       }
-       else { // Warning only + add FaceSurface file Identifier
-         TP->AddWarning(theFS," a Face from Shell not mapped to TopoDS");
-       }
+        myTranFace.Init(theFS, aTool, NMTool);
+        if (myTranFace.IsDone()) {
+          S = myTranFace.Value();
+          F = TopoDS::Face(S);
+          B.Add(Sh, F);
+        }
+        else { // Warning only + add FaceSurface file Identifier
+          TP->AddWarning(theFS, " a Face from Shell not mapped to TopoDS");
+        }
       }
-      else { // Warning : ajouter identifier
-       TP->AddWarning(StepFace," Face is not of FaceSurface Type; not mapped to TopoDS");
+      else { // Warning : add identifier
+        TP->AddWarning(StepFace, " Face is not of FaceSurface Type; not mapped to TopoDS");
       }
     }
     Sh.Closed (BRep_Tool::IsClosed (Sh));