src/StepToTopoDS/StepToTopoDS_TranslateEdgeLoop.cxx

   1 // Created on: 1995-03-29
   2 // Created by: Frederic MAUPAS
   3 // Copyright (c) 1995-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17 // gka 21.08.98 PRO7656
  18 // gka 15.12.98 UKI60591 #1274560
  19 //pdn 18.12.98 to keep pcurves
  20 //:o0 abv 16.02.99: POLYLINE allowed as 3d curve of edge
  21 //:   abv 07.04.99: S4136: improve tolerance management and dealing with pcurves
  22 //    rln 02.06.99 removing #include <StepToTopoDS_DegeneratedTool.hxx>
  23 //    smh 31.01.01 BUC60810 : IsNull protection
  24
  25 #include <BRep_Builder.hxx>
  26 #include <BRep_CurveRepresentation.hxx>
  27 #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
  28 #include <BRep_ListOfCurveRepresentation.hxx>
  29 #include <BRep_TEdge.hxx>
  30 #include <BRep_Tool.hxx>
  31 #include <ElCLib.hxx>
  32 #include <Geom2d_BoundedCurve.hxx>
  33 #include <Geom2d_Curve.hxx>
  34 #include <Geom2d_Line.hxx>
  35 #include <Geom_Curve.hxx>
  36 #include <Geom_Plane.hxx>
  37 #include <Geom_RectangularTrimmedSurface.hxx>
  38 #include <Geom_Surface.hxx>
  39 #include <gp_Pnt.hxx>
  40 #include <gp_Pnt2d.hxx>
  41 #include <Interface_Static.hxx>
  42 #include <Precision.hxx>
  43 #include <ShapeAlgo.hxx>
  44 #include <ShapeAlgo_AlgoContainer.hxx>
  45 #include <ShapeAlgo_ToolContainer.hxx>
  46 #include <ShapeAnalysis_Curve.hxx>
  47 #include <ShapeAnalysis_Edge.hxx>
  48 #include <ShapeBuild_Edge.hxx>
  49 #include <ShapeExtend_WireData.hxx>
  50 #include <ShapeFix_EdgeProjAux.hxx>
  51 #include <Standard_ErrorHandler.hxx>
  52 #include <StdFail_NotDone.hxx>
  53 #include <StepGeom_Curve.hxx>
  54 #include <StepGeom_Pcurve.hxx>
  55 #include <StepGeom_PcurveOrSurface.hxx>
  56 #include <StepGeom_Polyline.hxx>
  57 #include <StepGeom_Surface.hxx>
  58 #include <StepGeom_SurfaceCurve.hxx>
  59 #include <StepRepr_DefinitionalRepresentation.hxx>
  60 #include <StepShape_Edge.hxx>
  61 #include <StepShape_EdgeCurve.hxx>
  62 #include <StepShape_EdgeLoop.hxx>
  63 #include <StepShape_FaceBound.hxx>
  64 #include <StepShape_OrientedEdge.hxx>
  65 #include <StepShape_Vertex.hxx>
  66 #include <StepToGeom.hxx>
  67 #include <StepToTopoDS.hxx>
  68 #include <StepToTopoDS_GeometricTool.hxx>
  69 #include <StepToTopoDS_NMTool.hxx>
  70 #include <StepToTopoDS_Tool.hxx>
  71 #include <StepToTopoDS_TranslateEdge.hxx>
  72 #include <StepToTopoDS_TranslateEdgeLoop.hxx>
  73 #include <StepToTopoDS_TranslateVertex.hxx>
  74 #include <TopAbs.hxx>
  75 #include <TopExp.hxx>
  76 #include <TopExp_Explorer.hxx>
  77 #include <TopLoc_Location.hxx>
  78 #include <TopoDS.hxx>
  79 #include <TopoDS_Edge.hxx>
  80 #include <TopoDS_Face.hxx>
  81 #include <TopoDS_Iterator.hxx>
  82 #include <TopoDS_Shape.hxx>
  83 #include <TopoDS_Vertex.hxx>
  84 #include <TopoDS_Wire.hxx>
  85 #include <Transfer_TransientProcess.hxx>
  86 #include <XSAlgo.hxx>
  87 #include <XSAlgo_AlgoContainer.hxx>
  88
  89 // ============================================================================
  90 // Method  : RemoveSinglePCurve
  91 // Purpose :
  92 // ============================================================================
  93 static void RemoveSinglePCurve (const TopoDS_Edge& aEdge, const TopoDS_Face& aFace)
  94 {
  95   ShapeBuild_Edge().RemovePCurve (aEdge, aFace);
  96 }
  97
  98 // ============================================================================
  99 // Method  : RemovePCurves
 100 // Purpose :
 101 // ============================================================================
 102
 103 static void RemovePCurves(const TopoDS_Wire& aWire, const TopoDS_Face& aFace)
 104 {
 105   TopExp_Explorer EdgeExp(aWire, TopAbs_EDGE);
 106   while (EdgeExp.More()) {
 107     const TopoDS_Edge& myEdge = TopoDS::Edge(EdgeExp.Current());
 108     RemoveSinglePCurve(myEdge, aFace);
 109     EdgeExp.Next();
 110   }
 111 }
 112
 113 // ============================================================================
 114 // Method  : CheckPCurves
 115 // Purpose : Checks the pcurves topological trimming parameter consistency
 116 //           and deviation between 2D ans 3D
 117 // ============================================================================
 118
 119 static void CheckPCurves (TopoDS_Wire& aWire, const TopoDS_Face& aFace,
 120   const Standard_Boolean isPlane, const Standard_Real preci)
 121 {
 122   if (isPlane) { RemovePCurves (aWire, aFace);return; }
 123   BRep_Builder B;
 124   Standard_Real w1, w2, cf, cl;
 125   Handle(Geom_Surface) mySurf = BRep_Tool::Surface(aFace);
 126
 127   Handle(ShapeExtend_WireData) sbwd = new ShapeExtend_WireData (aWire);
 128   for (Standard_Integer i = 1; i <= sbwd->NbEdges(); i++) {
 129     const TopoDS_Edge& myEdge = sbwd->Edge(i);
 130
 131     // First Check : 2D Parameters on Edge :
 132     // Case 1 : w1 == w2 illegal => Drop the PCurve
 133     // Case 2 : on bounded curve w1 < FirstParameter => w1 = FirstParameter
 134     //                           w2 > LastParameter  => w2 = LastParameter
 135
 136     Handle(Geom2d_Curve) thePC;
 137     ShapeAnalysis_Edge sae;
 138     if (!sae.PCurve (myEdge, aFace, thePC, w1, w2, Standard_False)) {
 139       continue;
 140     }
 141     cf = thePC->FirstParameter();
 142     cl = thePC->LastParameter();
 143
 144     if (w1 == w2) {
 145       RemoveSinglePCurve(myEdge, aFace);
 146 #ifdef OCCT_DEBUG
 147       std::cout<<"Removing pcuve w1=w2"<<std::endl;
 148 #endif
 149       continue;
 150     }
 151
 152     //check parameters of range only for not periodic curves
 153     if (!thePC->IsPeriodic())
 154     {
 155       if (w1 < cf) {
 156         B.Range(myEdge, aFace, cf, w2);
 157         w1 = cf;
 158       }
 159       if (w2 > cl) {
 160         B.Range(myEdge, aFace, w1, cl);
 161         w2 = cl;
 162       }
 163     }
 164
 165     if (w1 > w2 && mySurf->IsUPeriodic())
 166     {
 167       Standard_Real u1, u2, v1, v2;
 168       mySurf->Bounds(u1, u2, v1, v2);
 169       ElCLib::AdjustPeriodic(u1, u2,
 170         Min(Abs(w2-w1)/2, Precision::PConfusion()),
 171         w1, w2);
 172       B.Range(myEdge, aFace, w1, w2);
 173     }
 174
 175
 176     // advanced check
 177     XSAlgo::AlgoContainer()->CheckPCurve (myEdge, aFace, preci, sbwd->IsSeam(i));
 178   }
 179 }
 180
 181 // ============================================================================
 182 // Method  : StepToTopoDS_TranslateEdgeLoop::StepToTopoDS_TranslateEdgeLoop
 183 // Purpose : Empty Constructor
 184 // ============================================================================
 185
 186 StepToTopoDS_TranslateEdgeLoop::StepToTopoDS_TranslateEdgeLoop()
 187 : myError(StepToTopoDS_TranslateEdgeLoopOther)
 188 {
 189   done = Standard_False;
 190 }
 191
 192 // ============================================================================
 193 // Method  : StepToTopoDS_TranslateEdgeLoop::StepToTopoDS_TranslateEdgeLoop
 194 // Purpose : Constructor with a FaceSurface and a Tool
 195 // ============================================================================
 196
 197 StepToTopoDS_TranslateEdgeLoop::StepToTopoDS_TranslateEdgeLoop(const Handle(StepShape_FaceBound)& FB,
 198   const TopoDS_Face& Face,
 199   const Handle(Geom_Surface)& GeomSurf,
 200   const Handle(StepGeom_Surface)& StepSurf,
 201   const Standard_Boolean sameSense,
 202   StepToTopoDS_Tool& T,
 203   StepToTopoDS_NMTool& NMTool) {
 204   Init(FB, Face, GeomSurf, StepSurf, sameSense, T, NMTool);
 205 }
 206
 207 // ============================================================================
 208 // Method  : Init
 209 // Purpose : Init with a EdgeLoop and a Tool
 210 // ============================================================================
 211
 212 void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& FaceBound,
 213   const TopoDS_Face& Face,
 214   const Handle(Geom_Surface)& GeomSurf,
 215   const Handle(StepGeom_Surface)& StepSurf,
 216   const Standard_Boolean sameSense,
 217   StepToTopoDS_Tool& aTool,
 218   StepToTopoDS_NMTool& NMTool) {
 219   done = Standard_True;
 220   Handle(StepShape_EdgeLoop) EL =
 221     Handle(StepShape_EdgeLoop)::DownCast(FaceBound->Bound());
 222
 223   if (aTool.IsBound(EL)) {
 224     myResult = TopoDS::Wire(aTool.Find(EL));
 225     myError  = StepToTopoDS_TranslateEdgeLoopDone;
 226     done     = Standard_True;
 227     return;
 228   }
 229   Standard_Integer modepcurve = Interface_Static::IVal("read.surfacecurve.mode");
 230   //  0,1 : suivre le code,  2 : ne prendre que pcurve,  3 : ne prendre que C3D
 231
 232   BRep_Builder B;
 233   Handle(Transfer_TransientProcess) TP = aTool.TransientProcess();
 234
 235   Standard_Real preci = Precision();
 236   TopoDS_Wire   W;
 237   TopoDS_Edge   E;
 238   TopoDS_Vertex V;
 239
 240   Standard_Boolean isSeam, isLikeSeam;
 241
 242   Handle(StepShape_OrientedEdge) OrEdge1, OrEdge2;
 243   Handle(StepGeom_Curve) StepCurve, StepCurve1, StepCurve2;
 244   Handle(StepRepr_DefinitionalRepresentation) DRI, Dri1, Dri2;
 245
 246   Handle(Geom2d_Curve) C2d, C2d1, C2d2, WhichC2d1, WhichC2d2;
 247   TopoDS_Edge   suspectE; //:f1, degEdge;
 248
 249   Standard_Integer j, NbEdge = EL->NbEdgeList();
 250   if (NbEdge == 0) {
 251     TP->AddWarning(EL, "Wire not done. EdgeLoop does not contain edges.");
 252     done = Standard_False;
 253     return;
 254   }
 255   // PTV 16.09.2000
 256   // default value set as Standard_True (if not correct see logic of algorithm).
 257   Standard_Boolean hasPcurve = Standard_True;
 258   Standard_Boolean isPlane = GeomSurf->IsKind(STANDARD_TYPE(Geom_Plane));
 259   Handle(Geom_Surface) ConvSurf = GeomSurf;
 260   if (GeomSurf->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
 261     Handle(Geom_RectangularTrimmedSurface) theRTS =
 262       Handle(Geom_RectangularTrimmedSurface)::DownCast(GeomSurf);
 263     ConvSurf = theRTS->BasisSurface();
 264   }
 265
 266   aTool.ComputePCurve(Standard_False);
 267
 268   // What is the Wire Orientation
 269   Standard_Boolean ForwardWire = FaceBound->Orientation();
 270
 271   // --- Initialize target Wire ---
 272
 273   B.MakeWire(W);
 274
 275   // -----------------------------------------------
 276   // Preparation : Make Vertices + Curves3d
 277   //  Hence, a closed curve limited by distinct vertices
 278   //  will give a unique vertex (if same coords)
 279   //
 280   // In addition : detect shared PCurve (cf SYRKO)
 281   //  This case may not be processed, PCurves has to be recomputed from scratch
 282   // -----------------------------------------------
 283 //  Standard_Integer theSame = 1; //gka 15.12.98
 284
 285   for (j=1; j<=NbEdge; j++) {
 286     OrEdge1  = EL->EdgeListValue(j);
 287
 288     // see bug #29979: oriented edge contains another oriented edge
 289     if (OrEdge1->EdgeElement()->IsKind (STANDARD_TYPE(StepShape_OrientedEdge)))
 290       OrEdge1 = Handle(StepShape_OrientedEdge)::DownCast (OrEdge1->EdgeElement());
 291
 292     Handle(StepShape_EdgeCurve) EC = Handle(StepShape_EdgeCurve)::DownCast(OrEdge1->EdgeElement());
 293     if (EC.IsNull())
 294     {
 295       TP->AddWarning (OrEdge1, "Edge does not contain EDGE_CURVE, skipped");
 296       continue;
 297     }
 298
 299     Handle(StepGeom_Curve) C = EC->EdgeGeometry();
 300     if (!C.IsNull()) {
 301       if (C->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve))) {
 302         Handle(StepGeom_SurfaceCurve) Sc = Handle(StepGeom_SurfaceCurve)::DownCast(C);
 303         C = Sc->Curve3d();
 304       }
 305     }
 306     Handle(Geom_Curve) C1;
 307     if (!C.IsNull()) {
 308       try
 309       {
 310         OCC_CATCH_SIGNALS
 311           C1 = Handle(Geom_Curve)::DownCast (TP->FindTransient(C));
 312         if (C1.IsNull()) {
 313           C1 = StepToGeom::MakeCurve (C);
 314           if (! C1.IsNull())
 315             TP->BindTransient (C, C1);
 316           else
 317             TP->AddWarning(C, "Could not convert a curve. Curve definition is incorrect");
 318         }
 319       }
 320       catch (Standard_Failure const& anException) {
 321 #ifdef OCCT_DEBUG
 322         std::cout << "Warning: StepToTopoDS_TranslateEdgeLoop: Exception: ";
 323         anException.Print(std::cout); std::cout << std::endl;
 324 #endif
 325         (void)anException;
 326         TP->AddFail(C, "Exeption was raised. Curve geometry definition is incorrect");
 327       }
 328     }
 329
 330     Handle(StepShape_Vertex) Vstart, Vend;
 331     if (EC->SameSense()) {
 332       Vstart = EC->EdgeStart();
 333       Vend   = EC->EdgeEnd();
 334     }
 335     else {
 336       Vend   = EC->EdgeStart();
 337       Vstart = EC->EdgeEnd();
 338     }
 339
 340     Standard_Boolean istV = aTool.IsBound(Vstart);
 341     Standard_Boolean iseV = aTool.IsBound(Vend);
 342     TopoDS_Vertex V1, V2;
 343     StepToTopoDS_TranslateVertex myTranVertex1(Vstart, aTool, NMTool);
 344     StepToTopoDS_TranslateVertex myTranVertex2(Vend, aTool, NMTool);
 345
 346     if (myTranVertex1.IsDone()) {
 347       V1 = TopoDS::Vertex(myTranVertex1.Value());
 348     }
 349     if (myTranVertex2.IsDone()) {
 350       V2 = TopoDS::Vertex(myTranVertex2.Value());
 351       gp_Pnt p1 = BRep_Tool::Pnt(V1);
 352       gp_Pnt p2 = BRep_Tool::Pnt(V2);
 353       if (p1.Distance(p2) <= Precision::Confusion()) { //:S4136: preci) {
 354         Standard_Boolean Fixed = Standard_True;
 355         if (!iseV) aTool.Bind(Vend, V1); //gka 21.08.1998 bug PRO7656
 356         else if (!istV)  aTool.Bind (Vstart, V2);
 357         else aTool.Bind (Vend, V1);
 358         if (!C1.IsNull() && !C1->IsClosed() && Fixed)
 359           TP->AddWarning(EL->EdgeListValue(j),
 360             "Vertex of same coordinates, set confused");
 361       }
 362     }
 363   }
 364
 365   //:f6 abv 29 Apr 98: BUC50070 #3815: make sure that each two edges are
 366   // connected by the same vertex; else check that vertices confuse
 367   // and make it be one vertex
 368   // NOTE: this is done only for the case if at least one of edges
 369   // was not yet translated; else nothing will help
 370   for (j=1; j<=NbEdge; j++) {
 371     OrEdge1  = EL->EdgeListValue (j);
 372     OrEdge2  = EL->EdgeListValue (j < NbEdge ? j + 1 : 1);
 373     Handle(StepShape_EdgeCurve) EC1 =
 374       Handle(StepShape_EdgeCurve)::DownCast (OrEdge1->EdgeElement());
 375     Handle(StepShape_EdgeCurve) EC2 =
 376       Handle(StepShape_EdgeCurve)::DownCast (OrEdge2->EdgeElement());
 377     if (EC1.IsNull() || EC2.IsNull()) // see #29979
 378     {
 379       continue;
 380     }
 381
 382     Handle(StepShape_Vertex) Vs1, Vs2, Vs11, Vs22;
 383     Vs1 = (OrEdge1->Orientation() ? EC1->EdgeEnd() : EC1->EdgeStart());
 384     Vs2 = (OrEdge2->Orientation() ? EC2->EdgeStart() : EC2->EdgeEnd());
 385
 386     Vs11 = (OrEdge1->Orientation() ?  EC1->EdgeStart() : EC1->EdgeEnd());
 387     Vs22 = (OrEdge2->Orientation() ?  EC2->EdgeEnd() : EC2->EdgeStart());
 388
 389     if ((Vs1 == Vs2) || (Vs1 == Vs22) || (Vs2 == Vs11) || (Vs22 == Vs11)) continue;
 390
 391     StepToTopoDS_TranslateVertex myTranVertex1 (Vs1, aTool, NMTool);
 392     StepToTopoDS_TranslateVertex myTranVertex2 (Vs2, aTool, NMTool);
 393
 394     TopoDS_Vertex V1, V2;
 395     if (myTranVertex1.IsDone())
 396       V1 = TopoDS::Vertex (myTranVertex1.Value());
 397     if (myTranVertex2.IsDone())
 398       V2 = TopoDS::Vertex (myTranVertex2.Value());
 399     if (V1.IsNull() || V2.IsNull()) continue; // not treated
 400     if (V1.IsSame(V2)) continue; // OK
 401
 402     gp_Pnt p1 = BRep_Tool::Pnt(V1);
 403     gp_Pnt p2 = BRep_Tool::Pnt(V2);
 404     Standard_Boolean locFixed = Standard_True;
 405     if (p1.Distance(p2) <= preci) {
 406       if (! aTool.IsBound (EC1)) aTool.Bind (Vs1, V2);
 407       else if (! aTool.IsBound (EC2)) aTool.Bind (Vs2, V1);
 408       else locFixed = Standard_False;
 409     }
 410     else locFixed = Standard_False;
 411     if (locFixed) TP->AddWarning(EL, "Adjacent edges do not have common vertex; set confused");
 412     else TP->AddWarning(EL, "Adjacent edges are not connected");
 413   }
 414
 415   // -----------------------------------------------
 416   // Iteration on each Oriented Edge of the EdgeLoop
 417   // -----------------------------------------------
 418
 419   for (j=1; j<=NbEdge; j++) {
 420
 421     Standard_Boolean ThereIsLikeSeam = Standard_False;
 422
 423 #ifdef OCCT_DEBUG
 424     std::cout << "      Processing Edge :" << j << std::endl;
 425 #endif
 426
 427     OrEdge1  = EL->EdgeListValue(j);
 428
 429     // see bug #29979: oriented edge contains another oriented edge
 430     if (OrEdge1->EdgeElement()->IsKind (STANDARD_TYPE(StepShape_OrientedEdge)))
 431       OrEdge1 = Handle(StepShape_OrientedEdge)::DownCast (OrEdge1->EdgeElement());
 432
 433     Handle(StepShape_EdgeCurve) EC = Handle(StepShape_EdgeCurve)::DownCast(OrEdge1->EdgeElement());
 434     if (EC.IsNull())
 435     {
 436       continue;
 437     }
 438
 439     // ----------------
 440     // Map the StepEdge
 441     // ----------------
 442
 443     StepToTopoDS_TranslateEdge myTranEdge;
 444
 445     myTranEdge.SetPrecision(preci);
 446     myTranEdge.SetMaxTol(MaxTol());
 447     myTranEdge.Init(OrEdge1, aTool, NMTool);
 448
 449     if (myTranEdge.IsDone()) {
 450
 451       E = TopoDS::Edge(myTranEdge.Value());
 452       if (E.IsNull()) continue;  // NULL, on saute
 453
 454       Handle(StepGeom_Curve) C = EC->EdgeGeometry();
 455
 456       if (OrEdge1->Orientation() && EC->SameSense())
 457         E.Orientation(TopAbs_FORWARD);
 458       else if (!OrEdge1->Orientation() && !EC->SameSense())
 459         E.Orientation(TopAbs_FORWARD);
 460       else E.Orientation(TopAbs_REVERSED);
 461
 462       isSeam = isLikeSeam = Standard_False;
 463
 464       // ------------------------------------------
 465       // Map the StepEdge parametric representation
 466       // ------------------------------------------
 467
 468       // --------------------------------------------
 469       // CASE 1 : The Edge Geometry is of Pcurve Type
 470       // --------------------------------------------
 471       if (C.IsNull())
 472       {
 473         aTool.ComputePCurve(Standard_True);
 474         hasPcurve = Standard_False;
 475       }
 476       else if (C->IsKind(STANDARD_TYPE(StepGeom_Pcurve))) {
 477         Handle(StepGeom_Pcurve) StepPCurve = Handle(StepGeom_Pcurve)::DownCast(C);
 478         C2d = myTranEdge.MakePCurve(StepPCurve, ConvSurf);
 479         // -- Statistics --
 480         aTool.AddContinuity(C2d);
 481       }
 482
 483       // -----------------------------------------
 484       // CASE 2 : The curve is a SurfaceCurve i.e.
 485       //           - a 3D Curve (mandatory)
 486       //           - 2 PCurveOrSurface
 487       //   If modepcurve = 3, PCurve are ignored here
 488       // -----------------------------------------
 489
 490       else if (modepcurve == 3) {
 491         aTool.ComputePCurve(Standard_True);
 492         hasPcurve = Standard_False;
 493       }
 494       else if (C->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve))) {
 495         // recouvre les cas SeamCurve et IntersectionCurve
 496
 497         Handle(StepGeom_SurfaceCurve) SurfCurve =
 498           Handle(StepGeom_SurfaceCurve)::DownCast(C);
 499
 500         Handle(StepGeom_Pcurve) StepPCurve, StepPCurve1, StepPCurve2;
 501         Standard_Integer lastpcurve = StepToTopoDS_GeometricTool::PCurve(SurfCurve, StepSurf, StepPCurve, 0);
 502         hasPcurve = !StepPCurve.IsNull();
 503
 504         // De toute facon, on recalcule
 505
 506         if (isPlane) hasPcurve = Standard_False;
 507
 508         // -------------------------------------------
 509         // ---        Special Mapping Cases :      ---
 510         // ---   the SurfaceCurve is a SeamCurve   ---
 511         // ---        or is like a seam curve      ---
 512         // ---         (see CATIA cylinder)        ---
 513         // -------------------------------------------
 514         isLikeSeam = StepToTopoDS_GeometricTool::IsLikeSeam(SurfCurve, StepSurf, EC, EL);
 515
 516         isSeam = StepToTopoDS_GeometricTool::IsSeamCurve(SurfCurve, StepSurf, EC, EL);
 517
 518         if (isSeam || isLikeSeam) {
 519           // isLikeSeam = Two faces on the same Surface
 520           StepPCurve1 = SurfCurve->AssociatedGeometryValue(1).Pcurve();
 521           StepPCurve2 = SurfCurve->AssociatedGeometryValue(2).Pcurve();
 522           if (StepPCurve1.IsNull() || StepPCurve2.IsNull()) hasPcurve = Standard_False; //smh : BUC60810
 523           else {
 524             C2d1 = myTranEdge.MakePCurve(StepPCurve1, ConvSurf);
 525             C2d2 = myTranEdge.MakePCurve(StepPCurve2, ConvSurf);
 526             hasPcurve = (!C2d1.IsNull() && !C2d2.IsNull());
 527           }
 528
 529           if (isLikeSeam) {
 530             suspectE = E;
 531             ThereIsLikeSeam = Standard_True;
 532             hasPcurve = Standard_True;
 533           }
 534         }
 535         else if (hasPcurve) {
 536           //  GeometricTool : Pcurve a retourne StepPCurve
 537           while (lastpcurve > 0) {
 538             C2d1 = myTranEdge.MakePCurve(StepPCurve, ConvSurf);
 539             if (C2d1.IsNull()) {
 540               TP->AddWarning(EC, "Incorrect pcurve is not translated. Pcurve definition is not correct");
 541               hasPcurve = Standard_False;
 542               break;
 543             }
 544             else C2d = C2d1;
 545             lastpcurve = StepToTopoDS_GeometricTool::PCurve(SurfCurve, StepSurf, StepPCurve, lastpcurve);
 546             // -- Statistics --
 547             aTool.AddContinuity(C2d);
 548           }
 549         }
 550         if (!hasPcurve) {
 551           // The edge geometry has no 2D representation
 552           aTool.ComputePCurve(Standard_True);
 553         }
 554       }
 555
 556       // ----------------------------------------------------------
 557       // CASE 3 : The EdgeCurve Geometry is not a Pcurve
 558       //          nor a SurfaceCurve (i.e. it is a single 3D curve)
 559       // ----------------------------------------------------------
 560
 561       else {
 562         aTool.ComputePCurve(Standard_True);
 563         hasPcurve = Standard_False;
 564       }
 565
 566       // ----------------------------------
 567       // update the edge with the pcurve(s)
 568       // ----------------------------------
 569
 570       if (hasPcurve && (isSeam || ThereIsLikeSeam)) {
 571
 572         // -----------------------------------------------------------
 573         // The Edge is a Seam Edge : The pcurve wich is FORWARD has to
 574         //                           be identified
 575         // -----------------------------------------------------------
 576
 577         if ((!C2d1.IsNull()) && (!C2d2.IsNull())) {
 578           TopAbs_Orientation CumulO, EdgeO, WireO, FaceO;
 579           EdgeO = E.Orientation();
 580           if (ForwardWire)  WireO = TopAbs_FORWARD;
 581           else              WireO = TopAbs_REVERSED;
 582           if (sameSense) FaceO = TopAbs_FORWARD;
 583           else           FaceO = TopAbs_REVERSED;
 584
 585           CumulO = TopAbs::Compose(EdgeO, WireO);
 586           CumulO = TopAbs::Compose(CumulO, FaceO);
 587
 588           Standard_Boolean ForwardEdge = (CumulO == TopAbs_FORWARD);
 589
 590           Standard_Integer forwardPC =
 591             ShapeAnalysis_Curve().SelectForwardSeam(C2d1, C2d2);
 592           if (forwardPC == 0) {
 593             TP->AddFail(EC, " Seam curve not mapped");
 594             done = Standard_False;
 595             myError = StepToTopoDS_TranslateEdgeLoopOther;
 596             continue;
 597           }
 598           else if (!ForwardEdge) forwardPC = 3 - forwardPC;  // inverser 1-2
 599
 600           if (forwardPC == 1) {
 601             if (isSeam) {
 602               // When the edge is a Seam, it is better to find the topological
 603               // trimming right now.
 604               // Remarque : pour bien faire, il faudrait, si necessaire, recalculer
 605               //            les trois courbes de maniere a ce qu`elles soient
 606               //            immediatement Same Range et Same Parameter.
 607               B.UpdateEdge(E, C2d1, C2d2, Face, 0.);
 608               //:S4136        FindParameter(C2d1, C2d2, E, Face, preci);
 609             }
 610             else
 611               B.UpdateEdge(E, C2d1, Face, 0.); //preci
 612           }
 613           else {
 614             if (isSeam) {
 615               // When the edge is a Seam, it is better to find the topological
 616               // trimming right now.
 617               B.UpdateEdge(E, C2d2, C2d1, Face, 0.);
 618               //:S4136        FindParameter(C2d1, C2d2, E, Face, preci);
 619             }
 620             else
 621               B.UpdateEdge(E, C2d2, Face, 0.);
 622           }
 623         }
 624         else {
 625           TP->AddFail(EC, " Seam curve not mapped");
 626           done = Standard_False;
 627           myError = StepToTopoDS_TranslateEdgeLoopOther;
 628           continue;
 629         }
 630       }
 631       else {
 632
 633         // ---------------------------
 634         // The Edge is a "normal" edge
 635         // ---------------------------
 636
 637         if (hasPcurve) {
 638           if (!C2d.IsNull() && !isLikeSeam) {
 639             B.UpdateEdge(E, C2d, Face, 0.);
 640           }
 641           else {
 642             TP->AddFail(EC, " Edge: Trimming of 2D curve failed");
 643             done = Standard_False;
 644             myError = StepToTopoDS_TranslateEdgeLoopOther;
 645             continue;
 646           }
 647         }
 648       }
 649
 650       if (E.IsNull()) {
 651         TP->AddFail(EC, " an Edge not mapped");
 652         done = Standard_False;
 653         myError = StepToTopoDS_TranslateEdgeLoopOther;
 654       }
 655     }
 656     else { // The Edge is Not mapped => switch to next wire ?
 657       TP->AddFail(EC," an Edge not mapped");
 658       done = Standard_False;
 659       myError = StepToTopoDS_TranslateEdgeLoopOther;
 660     }
 661
 662     if (done) B.Add (W, E);  // on le fait ici. Sauf si erreur rencontree ... !
 663     else {
 664       Handle(StepShape_Vertex) Vs1, Vs2;
 665       Vs1 = EC->EdgeStart();
 666       Vs2 = EC->EdgeEnd();
 667       if (!Vs1.IsNull() && !Vs2.IsNull() && Vs1==Vs2) {
 668         done = Standard_True;
 669         TP->AddFail(EL, " Edge with equal vertices failed, scipped");
 670       }
 671     }
 672   }
 673
 674   // The EdgeLoop is binded in the Wire
 675
 676   if (!done) {
 677     TP->AddFail(EL, "At least one edge failed : wire not done");
 678     return;
 679   }
 680   W.Closed (BRep_Tool::IsClosed (W));
 681   aTool.Bind(EL, W);
 682
 683   // ----------------------------------------------
 684   // Computes the 2D parameter of Vertices on Edges
 685   // ----------------------------------------------
 686   //pdn compute parameter of Vertices using projecting
 687   if (!aTool.ComputePCurve())
 688     for (TopoDS_Iterator EdgeIt(W);EdgeIt.More();EdgeIt.Next()) {
 689       TopoDS_Edge edge = TopoDS::Edge(EdgeIt.Value());
 690       Handle(ShapeFix_EdgeProjAux) myEdgePro = ShapeAlgo::AlgoContainer()->ToolContainer()->EdgeProjAux();
 691       myEdgePro->Init (Face, edge);
 692       myEdgePro->Compute(preci);
 693       if (myEdgePro->IsFirstDone() && myEdgePro->IsLastDone()) {
 694         if (Abs (myEdgePro->FirstParam() - myEdgePro->LastParam()) < Precision::PConfusion())
 695           continue;
 696         B.Range(edge, Face, myEdgePro->FirstParam(), myEdgePro->LastParam());
 697       }
 698       else {
 699         RemoveSinglePCurve(edge, Face);
 700 #ifdef OCCT_DEBUG
 701         std::cout <<"Removing after prj"<<std::endl;
 702 #endif
 703       }
 704     }
 705
 706   myResult = W;
 707   myError  = StepToTopoDS_TranslateEdgeLoopDone;
 708   done     = Standard_True;
 709   //  Check des PCurves SYSTEMATIQUE, s il n y en a que quelques unes
 710   CheckPCurves  (W, Face, isPlane, preci);
 711
 712   return;
 713 }
 714
 715
 716 // ============================================================================
 717 // Method  : Value
 718 // Purpose : Return the mapped Shape
 719 // ============================================================================
 720
 721 const TopoDS_Shape& StepToTopoDS_TranslateEdgeLoop::Value() const
 722 {
 723   StdFail_NotDone_Raise_if (!done, "StepToTopoDS_TranslateEdgeLoop::Value() - no result");
 724   return myResult;
 725 }
 726
 727 // ============================================================================
 728 // Method  : Error
 729 // Purpose : Return the TranslateEdgeLoop error
 730 // ============================================================================
 731
 732 StepToTopoDS_TranslateEdgeLoopError StepToTopoDS_TranslateEdgeLoop::Error() const
 733 {
 734   return myError;
 735 }
 736