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