0026936: Drawbacks of inlining in new type system in OCCT 7.0 -- automatic
[occt.git] / src / BRepTools / BRepTools_NurbsConvertModification.cxx
CommitLineData
b311480e 1// Created on: 1996-07-12
2// Created by: Stagiaire Mary FABIEN
3// Copyright (c) 1996-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.
7fd59977 16
7fd59977 17
42cf5bc1 18#include <Approx_SameParameter.hxx>
19#include <BRep_GCurve.hxx>
20#include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
21#include <BRep_TEdge.hxx>
22#include <BRep_Tool.hxx>
7fd59977 23#include <BRepTools.hxx>
42cf5bc1 24#include <BRepTools_NurbsConvertModification.hxx>
25#include <BSplCLib.hxx>
26#include <ElSLib.hxx>
27#include <Extrema_LocateExtPC.hxx>
28#include <Geom2d_BezierCurve.hxx>
7fd59977 29#include <Geom2d_BSplineCurve.hxx>
42cf5bc1 30#include <Geom2d_Curve.hxx>
31#include <Geom2d_TrimmedCurve.hxx>
32#include <Geom2dAdaptor_Curve.hxx>
33#include <Geom2dAdaptor_HCurve.hxx>
7fd59977 34#include <Geom2dConvert.hxx>
42cf5bc1 35#include <Geom_BezierCurve.hxx>
36#include <Geom_BezierSurface.hxx>
37#include <Geom_BSplineCurve.hxx>
38#include <Geom_BSplineSurface.hxx>
39#include <Geom_Circle.hxx>
40#include <Geom_Curve.hxx>
41#include <Geom_CylindricalSurface.hxx>
42#include <Geom_Ellipse.hxx>
7fd59977 43#include <Geom_Line.hxx>
42cf5bc1 44#include <Geom_Plane.hxx>
45#include <Geom_RectangularTrimmedSurface.hxx>
46#include <Geom_Surface.hxx>
47#include <Geom_TrimmedCurve.hxx>
7fd59977 48#include <GeomAdaptor_Curve.hxx>
7fd59977 49#include <GeomAdaptor_HCurve.hxx>
50#include <GeomAdaptor_HSurface.hxx>
42cf5bc1 51#include <GeomAdaptor_Surface.hxx>
52#include <GeomConvert.hxx>
7fd59977 53#include <gp_GTrsf2d.hxx>
42cf5bc1 54#include <gp_Pnt.hxx>
7fd59977 55#include <gp_TrsfForm.hxx>
42cf5bc1 56#include <OSD_Chronometer.hxx>
7fd59977 57#include <ProjLib_ComputeApprox.hxx>
58#include <ProjLib_ComputeApproxOnPolarSurface.hxx>
42cf5bc1 59#include <Standard_NoSuchObject.hxx>
60#include <Standard_Type.hxx>
7fd59977 61#include <TColStd_Array1OfReal.hxx>
42cf5bc1 62#include <TColStd_ListIteratorOfListOfTransient.hxx>
63#include <TopAbs.hxx>
64#include <TopLoc_Location.hxx>
65#include <TopoDS.hxx>
66#include <TopoDS_Edge.hxx>
67#include <TopoDS_Face.hxx>
68#include <TopoDS_Vertex.hxx>
69#include <TopTools_ListIteratorOfListOfShape.hxx>
2651bfde 70#include <BRep_Builder.hxx>
92efcf78 71IMPLEMENT_STANDARD_RTTIEXT(BRepTools_NurbsConvertModification,BRepTools_Modification)
72
2651bfde 73//
7fd59977 74static void GeomLib_ChangeUBounds(Handle(Geom_BSplineSurface)& aSurface,
35e08fe8 75 const Standard_Real newU1,
76 const Standard_Real newU2)
7fd59977 77{
78 TColStd_Array1OfReal knots(1,aSurface->NbUKnots()) ;
79 aSurface->UKnots(knots) ;
80 BSplCLib::Reparametrize(newU1,
35e08fe8 81 newU2,
82 knots) ;
7fd59977 83 aSurface->SetUKnots(knots) ;
84}
85static void GeomLib_ChangeVBounds(Handle(Geom_BSplineSurface)& aSurface,
35e08fe8 86 const Standard_Real newV1,
87 const Standard_Real newV2)
7fd59977 88{
89 TColStd_Array1OfReal knots(1,aSurface->NbVKnots()) ;
90 aSurface->VKnots(knots) ;
91 BSplCLib::Reparametrize(newV1,
35e08fe8 92 newV2,
93 knots) ;
7fd59977 94 aSurface->SetVKnots(knots) ;
95}
96
97//=======================================================================
98//function : BRepTools_NurbsConvertModification
99//purpose :
100//=======================================================================
101
102BRepTools_NurbsConvertModification::BRepTools_NurbsConvertModification()
103{
104}
105
106
107
108//=======================================================================
109//function : NewSurface
110//purpose :
111//=======================================================================
112
113Standard_Boolean BRepTools_NurbsConvertModification::NewSurface
114 (const TopoDS_Face& F,
115 Handle(Geom_Surface)& S,
116 TopLoc_Location& L,
117 Standard_Real& Tol,
118 Standard_Boolean& RevWires,
119 Standard_Boolean& RevFace)
120{
121 Standard_Real U1, U2, curvU1, curvU2, surfU1, surfU2, UTol;
122 Standard_Real V1, V2, curvV1, curvV2, surfV1, surfV2, VTol;
123 RevWires = Standard_False;
124 RevFace = Standard_False;
125 Handle(Geom_Surface) SS = BRep_Tool::Surface(F,L);
126 Handle(Standard_Type) TheTypeSS = SS->DynamicType();
127 if ((TheTypeSS == STANDARD_TYPE(Geom_BSplineSurface)) ||
128 (TheTypeSS == STANDARD_TYPE(Geom_BezierSurface))) {
129 return Standard_False;
130 }
131 S = SS;
132 BRepTools::UVBounds(F,curvU1,curvU2,curvV1,curvV2);
133 Tol = BRep_Tool::Tolerance(F);
134 Standard_Real TolPar = 0.1*Tol;
135 Standard_Boolean IsUp = S->IsUPeriodic(), IsVp = S->IsVPeriodic();
136 //OCC466(apo)->
137 U1 = curvU1; U2 = curvU2;
138 V1 = curvV1; V2 = curvV2;
86eff19e
J
139 SS->Bounds(surfU1,surfU2,surfV1,surfV2);
140
141 if (Abs(U1 - surfU1) <= TolPar)
142 U1 = surfU1;
143 if (Abs(U2 - surfU2) <= TolPar)
144 U2 = surfU2;
145 if (Abs(V1 - surfV1) <= TolPar)
146 V1 = surfV1;
147 if (Abs(V2 - surfV2) <= TolPar)
148 V2 = surfV2;
149
7fd59977 150 if(!IsUp){
151 U1 = Max(surfU1,curvU1);
152 U2 = Min(surfU2,curvU2);
153 }
154 if(!IsVp){
155 V1 = Max(surfV1,curvV1);
156 V2 = Min(surfV2,curvV2);
157 }
86eff19e
J
158 //<-OCC466(apo)
159
160 if (IsUp)
161 {
162 Standard_Real Up = S->UPeriod();
163 if (U2 - U1 > Up)
164 U2 = U1 + Up;
165 }
166 if (IsVp)
167 {
168 Standard_Real Vp = S->VPeriod();
169 if (V2 - V1 > Vp)
170 V2 = V1 + Vp;
171 }
172
173 /*
7fd59977 174 if(IsUp && IsVp) {
175 Standard_Real dU = Abs(U2 - U1), dV = Abs(V2 - V1);
176 Standard_Real Up = S->UPeriod(), Vp = S->VPeriod();
177 if(Abs(dU - Up) <= TolPar && U2 <= Up) {
178 if(Abs(dV - Vp) <= TolPar && V2 <= Vp) { }
179 else {
35e08fe8 180 SS = new Geom_RectangularTrimmedSurface(S, V1+1e-9, V2-1e-9, Standard_False);
7fd59977 181 }
182 }
183 else {
184 if(Abs(dV - Vp) <= TolPar && V2 <= Vp)
35e08fe8 185 SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, Standard_True);
7fd59977 186 else
35e08fe8 187 SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, V1+1e-9, V2-1e-9);
7fd59977 188 }
189 }
190
191 if(IsUp && !IsVp) {
192 Standard_Real dU = Abs(U2 - U1);
193 Standard_Real Up = S->UPeriod();
194 if(Abs(dU - Up) <= TolPar && U2 <= Up)
195 SS = new Geom_RectangularTrimmedSurface(S, V1+1e-9, V2-1e-9, Standard_False);
196 else
197 SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, V1+1e-9, V2-1e-9);
198 }
35e08fe8 199
7fd59977 200 if(!IsUp && IsVp) {
201 Standard_Real dV = Abs(V2 - V1);
202 Standard_Real Vp = S->VPeriod();
203 if(Abs(dV - Vp) <= TolPar && V2 <= Vp)
204 SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, Standard_True);
205 else
206 SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, V1+1e-9, V2-1e-9);
207 }
208
209 if(!IsUp && !IsVp) {
210 SS = new Geom_RectangularTrimmedSurface(S, U1+1e-9, U2-1e-9, V1+1e-9, V2-1e-9);
211 }
86eff19e 212 */
7fd59977 213
86eff19e
J
214 if (Abs(surfU1-U1) > Tol || Abs(surfU2-U2) > Tol ||
215 Abs(surfV1-V1) > Tol || Abs(surfV2-V2) > Tol)
216 SS = new Geom_RectangularTrimmedSurface(S, U1, U2, V1, V2);
217 SS->Bounds(surfU1,surfU2,surfV1,surfV2);
7fd59977 218
219 S = GeomConvert::SurfaceToBSplineSurface(SS);
220 Handle(Geom_BSplineSurface) BS = Handle(Geom_BSplineSurface)::DownCast(S) ;
221 BS->Resolution(Tol, UTol, VTol) ;
222
223 //
224 // on recadre les bornes de S sinon les anciennes PCurves sont aux fraises
225 //
226
227 if (Abs(curvU1-surfU1) > UTol && !BS->IsUPeriodic()) {
228 GeomLib_ChangeUBounds(BS, U1,U2) ;
229 }
230 if (Abs(curvV1-surfV1) > VTol && !BS->IsVPeriodic()) {
231 GeomLib_ChangeVBounds(BS, V1, V2) ;
232 }
233
234 return Standard_True;
235}
236
237static Standard_Boolean IsConvert(const TopoDS_Edge& E)
238{
239 Standard_Boolean isConvert = Standard_False;
240 Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&E.TShape());
241 // iterate on pcurves
242 BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
243 for ( ; itcr.More() && !isConvert; itcr.Next() ) {
244 Handle(BRep_GCurve) GC = Handle(BRep_GCurve)::DownCast(itcr.Value());
245 if ( GC.IsNull() || ! GC->IsCurveOnSurface() ) continue;
246 Handle(Geom_Surface) aSurface = GC->Surface();
247 Handle(Geom2d_Curve) aCurve2d = GC->PCurve();
248 isConvert =((!aSurface->IsKind(STANDARD_TYPE(Geom_BSplineSurface)) &&
249 !aSurface->IsKind(STANDARD_TYPE(Geom_BezierSurface))) ||
250 (!aCurve2d->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve)) &&
251 !aCurve2d->IsKind(STANDARD_TYPE(Geom2d_BezierCurve))));
252
253 }
254 return isConvert;
255
256}
257
258//=======================================================================
259//function : NewCurve
260//purpose :
261//=======================================================================
262
263Standard_Boolean BRepTools_NurbsConvertModification::NewCurve
264(const TopoDS_Edge& E,
265 Handle(Geom_Curve)& C,
266 TopLoc_Location& L,
267 Standard_Real& Tol)
268{
269
270 Tol = BRep_Tool::Tolerance(E);
271 if(BRep_Tool::Degenerated(E)) {
272 C.Nullify();
273 L.Identity();
274 return Standard_True;
275 }
276 Standard_Real f, l;
277
278 Handle(Geom_Curve) Caux = BRep_Tool::Curve(E, L, f, l);
279
280 if ( Caux.IsNull()) {
281 L.Identity();
282 return Standard_False;
283 }
284 Handle(Standard_Type) TheType = Caux->DynamicType();
285 if ((TheType == STANDARD_TYPE(Geom_BSplineCurve)) ||
286 (TheType == STANDARD_TYPE(Geom_BezierCurve))) {
287 if(IsConvert(E)) {
288 C = Handle(Geom_Curve)::DownCast(Caux->Copy());
289 return Standard_True;
290 }
291 return Standard_False;
292 }
293
294 C = Caux;
295
296 Standard_Real TolPar = Tol *.1;
297
298 if(C->IsPeriodic()) {
299 Standard_Real p = C->Period();
300 Standard_Real d = Abs(l - f);
301 if(Abs(d - p) <= TolPar && l <= p) {}
302 else
303 C = new Geom_TrimmedCurve(C, f, l);
304 }
305 else
306 C = new Geom_TrimmedCurve(C, f, l);
307
308//modif WOK++ portage hp (fbi du 14/03/97)
309// gp_Trsf trsf(L);
310// gp_Trsf trsf = L.Transformation();
311
312// C = GeomConvert::CurveToBSplineCurve(C,Convert_QuasiAngular);
313
314 C = GeomConvert::CurveToBSplineCurve(C);
315
316 Standard_Real fnew = C->FirstParameter(), lnew = C->LastParameter(), UTol;
317
318 Handle(Geom_BSplineCurve) BC = Handle(Geom_BSplineCurve)::DownCast(C) ;
319
320 if(!BC->IsPeriodic()) {
321 BC->Resolution(Tol, UTol) ;
322 if(Abs(f - fnew) > UTol || Abs(l - lnew) > UTol) {
323 TColStd_Array1OfReal knots(1,BC->NbKnots()) ;
324 BC->Knots(knots) ;
325 BSplCLib::Reparametrize(f, l, knots) ;
326 BC->SetKnots(knots) ;
327 }
328 }
329
330 if(!myMap.Contains(Caux)) {
331 myMap.Add(Caux,C);
332 }
333 return Standard_True ;
334}
335
336//=======================================================================
337//function : NewPoint
338//purpose :
339//=======================================================================
340
341Standard_Boolean BRepTools_NurbsConvertModification::NewPoint
35e08fe8 342 (const TopoDS_Vertex&, gp_Pnt&, Standard_Real& )
343{
7fd59977 344 return Standard_False;
345}
346
347
348//=======================================================================
349//function : NewCurve2d
350//purpose :
351//=======================================================================
352
353Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
35e08fe8 354 (const TopoDS_Edge& E,
355 const TopoDS_Face& F,
356 const TopoDS_Edge& newE,
357 const TopoDS_Face& newF,
358 Handle(Geom2d_Curve)& Curve2d,
359 Standard_Real& Tol)
7fd59977 360{
361
362 Tol = BRep_Tool::Tolerance(E);
363 Standard_Real f2d,l2d;
364 Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E,F,f2d,l2d);
365 Standard_Real f3d,l3d;
366 TopLoc_Location Loc;
367 Handle(Geom_Curve) C3d = BRep_Tool::Curve(E, Loc, f3d,l3d);
368 Standard_Boolean isConvert2d = ((!C3d.IsNull() && !C3d->IsKind(STANDARD_TYPE(Geom_BSplineCurve)) &&
369 !C3d->IsKind(STANDARD_TYPE(Geom_BezierCurve))) ||
370 IsConvert(E));
86eff19e 371
7fd59977 372 if(BRep_Tool::Degenerated(E)) {
373 //Curve2d = C2d;
374 if(!C2d->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve)))
375 {
376 Handle(Geom2d_TrimmedCurve) aTrimC = new Geom2d_TrimmedCurve(C2d,f2d,l2d);
377 C2d = aTrimC;
378 }
379 Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
380 return Standard_True;
381 }
382 if(!BRepTools::IsReallyClosed(E,F)) {
383 Handle(Standard_Type) TheTypeC2d = C2d->DynamicType();
384
385 if(TheTypeC2d == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
386 Handle(Geom2d_TrimmedCurve) TC = Handle(Geom2d_TrimmedCurve)::DownCast(C2d);
387 C2d = TC->BasisCurve();
388 }
389
390 Standard_Real fc = C2d->FirstParameter(), lc = C2d->LastParameter();
391
392 if(!C2d->IsPeriodic()) {
393 if(fc - f2d > Precision::PConfusion()) f2d = fc;
394 if(l2d - lc > Precision::PConfusion()) l2d = lc;
395 }
396
397 C2d = new Geom2d_TrimmedCurve(C2d, f2d, l2d);
398
399 Geom2dAdaptor_Curve G2dAC(C2d, f2d, l2d);
400 Handle(Geom2dAdaptor_HCurve) G2dAHC = new Geom2dAdaptor_HCurve(G2dAC);
401
7fd59977 402 if(!newE.IsNull()) {
403 C3d = BRep_Tool::Curve(newE, f3d, l3d);
404 }
405 else {
406 C3d = BRep_Tool::Curve(E,f3d,l3d);
407 }
408 GeomAdaptor_Curve G3dAC(C3d, f3d, l3d);
409 Handle(GeomAdaptor_HCurve) G3dAHC = new GeomAdaptor_HCurve(G3dAC);
410
411 Standard_Real Uinf, Usup, Vinf, Vsup, u = 0, v = 0;
412 Handle(Geom_Surface) S = BRep_Tool::Surface(F);
413 Handle(Standard_Type) myT = S->DynamicType();
414 if(myT != STANDARD_TYPE(Geom_Plane)) {
415 if(newF.IsNull()) {
d3f26155 416 Handle(Standard_Type) st = C2d->DynamicType();
417 if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) ||
418 (st == STANDARD_TYPE(Geom2d_BezierCurve))) {
419 if(isConvert2d) {
420 Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
2651bfde 421 Standard_Real newTol = BRepTools::EvalAndUpdateTol(newE, C3d, Curve2d, S, f3d, l3d);
422 if(newTol > Tol)
423 {
424 Tol = newTol;
425 myUpdatedEdges.Append(newE);
426 }
d3f26155 427 return Standard_True;
428 }
429 return Standard_False;
35e08fe8 430 }
431 }
432 else {
d3f26155 433 S = BRep_Tool::Surface(newF);
7fd59977 434 }
435 S->Bounds(Uinf, Usup, Vinf, Vsup);
86eff19e 436 //Uinf -= 1e-9; Usup += 1e-9; Vinf -= 1e-9; Vsup += 1e-9;
7fd59977 437 u = (Usup - Uinf)*0.1;
438 v = (Vsup - Vinf)*0.1;
439 if(S->IsUPeriodic()) {
d3f26155 440 Standard_Real uperiod = S->UPeriod();
441 if(uperiod < (Usup+2*u-Uinf)) {
442 if(uperiod <= (Usup-Uinf)) {
443 u = 0;
444 }
445 else {
446 u = (uperiod-(Usup-Uinf))*0.5;
447 }
448 }
7fd59977 449 }
450 if(S->IsVPeriodic()) {
d3f26155 451 Standard_Real vperiod = S->VPeriod();
452 if(vperiod < (Vsup+2*v-Vinf)) {
453 if(vperiod <= (Vsup-Vinf)) {
454 v = 0;
455 }
456 else {
457 v = (vperiod-(Vsup-Vinf))*0.5;
458 }
459 }
7fd59977 460 }
461 }
462 else {
463 S = BRep_Tool::Surface(F);// Si S est un plan, pas de changement de parametrisation
464 GeomAdaptor_Surface GAS(S);
465 Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);
466 ProjLib_ComputeApprox ProjOnCurve(G3dAHC,GAHS,Tol);
467 if(ProjOnCurve.BSpline().IsNull()) {
d3f26155 468 Curve2d = Geom2dConvert::CurveToBSplineCurve(ProjOnCurve.Bezier());
2651bfde 469 Standard_Real newTol = BRepTools::EvalAndUpdateTol(newE, C3d, Curve2d, S, f3d, l3d);
470 if(newTol > Tol)
471 {
472 Tol = newTol;
473 myUpdatedEdges.Append(newE);
474 }
d3f26155 475 return Standard_True;
7fd59977 476 }
477 Curve2d = ProjOnCurve.BSpline();
2651bfde 478 Standard_Real newTol = BRepTools::EvalAndUpdateTol(newE, C3d, Curve2d, S, f3d, l3d);
479 if(newTol > Tol)
480 {
481 Tol = newTol;
482 myUpdatedEdges.Append(newE);
483 }
7fd59977 484 return Standard_True;
485 }
486 GeomAdaptor_Surface GAS(S,Uinf-u,Usup+u,Vinf-v,Vsup+v);
487
488 Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);
489
490 ProjLib_ComputeApproxOnPolarSurface ProjOnCurve(G2dAHC,G3dAHC,GAHS,Tol);
491
492 if(ProjOnCurve.IsDone()) {
493 Curve2d = ProjOnCurve.BSpline();
2651bfde 494 Standard_Real newTol = BRepTools::EvalAndUpdateTol(newE, C3d, Curve2d, S, f3d, l3d);
495 if(newTol > Tol)
496 {
497 Tol = newTol;
498 myUpdatedEdges.Append(newE);
499 }
7fd59977 500 return Standard_True;
501 }
502 else {
503 Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
2651bfde 504 Standard_Real newTol = BRepTools::EvalAndUpdateTol(newE, C3d, Curve2d, S, f3d, l3d);
505 if(newTol > Tol)
506 {
507 Tol = newTol;
508 myUpdatedEdges.Append(newE);
509 }
7fd59977 510 return Standard_True;
511 }
512 }
513 else {
514 TopTools_ListIteratorOfListOfShape itled;
515 TColStd_ListIteratorOfListOfTransient itlcu;
516
517 for (itled.Initialize(myled), itlcu.Initialize(mylcu);
35e08fe8 518 itled.More(); // itlcu.More()
519 itled.Next(),itlcu.Next()) {
7fd59977 520 if (itled.Value().IsSame(E)) {
d3f26155 521 // deja traitee
522 break;
7fd59977 523 }
524 }
525 if (!itled.More()) { // on stocke l`edge et la curve2d
526 Handle(Geom2d_Curve) C2dBis;
51740958 527 Standard_Real f2dBis,l2dBis;
7fd59977 528 C2d = new Geom2d_TrimmedCurve(C2d, f2d, l2d);
529 Geom2dAdaptor_Curve G2dAC(C2d, f2d, l2d);
530 Handle(Geom2dAdaptor_HCurve) G2dAHC = new Geom2dAdaptor_HCurve(G2dAC);
531 TopoDS_Edge ERevers = E;
532 ERevers.Reverse();
35e08fe8 533 C2dBis = BRep_Tool::CurveOnSurface(ERevers,F,f2dBis,l2dBis);
7fd59977 534 Handle(Standard_Type) TheTypeC2dBis = C2dBis->DynamicType();
535 C2dBis = new Geom2d_TrimmedCurve(C2dBis,f2dBis, l2dBis);
536 Geom2dAdaptor_Curve G2dACBis(C2dBis, f2dBis, l2dBis);
537 Handle(Geom2dAdaptor_HCurve) G2dAHCBis = new Geom2dAdaptor_HCurve(G2dACBis);
538
7fd59977 539 if(C3d.IsNull()) {
540 if(isConvert2d) {
541 Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
2651bfde 542
543 Handle(Geom_Surface) S;
544 if(newF.IsNull())
545 S = BRep_Tool::Surface(F);
546 else
547 S = BRep_Tool::Surface(newF);
548 //
549 Standard_Real newTol = BRepTools::EvalAndUpdateTol(newE, C3d, Curve2d, S, f3d, l3d);
550 if(newTol > Tol)
551 {
552 Tol = newTol;
553 myUpdatedEdges.Append(newE);
554 }
7fd59977 555 return Standard_True;
556 }
d3f26155 557 return Standard_False;
7fd59977 558 }
559 if(!newE.IsNull()) {
d3f26155 560 C3d = BRep_Tool::Curve(newE, f3d,l3d);
7fd59977 561 }
562 GeomAdaptor_Curve G3dAC(C3d, f3d, l3d);
563 Handle(GeomAdaptor_HCurve) G3dAHC = new GeomAdaptor_HCurve(G3dAC);
564
565 Handle(Geom_Surface) S = BRep_Tool::Surface(F);
566 Handle(Standard_Type) myT = S->DynamicType();
567 if(newF.IsNull()) {
d3f26155 568 mylcu.Append(C2dBis);
569 Handle(Standard_Type) st = C2d->DynamicType();
570 if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) ||
571 (st == STANDARD_TYPE(Geom2d_BezierCurve))) {
572 if(isConvert2d) {
573 Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
2651bfde 574 Standard_Real newTol = BRepTools::EvalAndUpdateTol(newE, C3d, Curve2d, S, f3d, l3d);
575 if(newTol > Tol)
576 {
577 Tol = newTol;
578 myUpdatedEdges.Append(newE);
579 }
d3f26155 580 return Standard_True;
581 }
582 return Standard_False;
583 }
7fd59977 584 }
585 else {
d3f26155 586 S = BRep_Tool::Surface(newF);// S est une BSplineSurface : pas besoin de la trimmed
7fd59977 587 }
588 Standard_Real Uinf, Usup, Vinf, Vsup, u = 0, v = 0;
589 S->Bounds(Uinf, Usup, Vinf, Vsup);
86eff19e 590 //Uinf -= 1e-9; Usup += 1e-9; Vinf -= 1e-9; Vsup += 1e-9;
7fd59977 591 u = (Usup - Uinf)*0.1;
592 v = (Vsup - Vinf)*0.1;
593 if(S->IsUPeriodic()) {
d3f26155 594 Standard_Real uperiod = S->UPeriod();
eafb234b 595 if(uperiod < (Usup+2*u-Uinf)) {
d3f26155 596 if(uperiod <= (Usup-Uinf))
597 u = 0;
598 else
599 u = (uperiod-(Usup-Uinf))*0.5;
eafb234b 600 }
7fd59977 601 }
602 if(S->IsVPeriodic()) {
d3f26155 603 Standard_Real vperiod = S->VPeriod();
eafb234b 604 if(vperiod < (Vsup+2*v-Vinf)) {
d3f26155 605 if(vperiod <= (Vsup-Vinf))
606 v = 0;
607 else
608 v = (vperiod-(Vsup-Vinf))*0.5;
eafb234b 609 }
7fd59977 610 }
611 GeomAdaptor_Surface GAS(S, Uinf-u,Usup+u,Vinf-v,Vsup+v);
612 Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);
613 myled.Append(E);
614
615 ProjLib_ComputeApproxOnPolarSurface
d3f26155 616 ProjOnCurve(G2dAHC,G2dAHCBis,G3dAHC,GAHS,Tol);
7fd59977 617
618 if(ProjOnCurve.IsDone()) {
d3f26155 619 Curve2d = ProjOnCurve.BSpline();
620 mylcu.Append(ProjOnCurve.Curve2d());
2651bfde 621 Standard_Real newTol = BRepTools::EvalAndUpdateTol(newE, C3d, Curve2d, S, f3d, l3d);
622 if(newTol > Tol)
623 {
624 Tol = newTol;
625 myUpdatedEdges.Append(newE);
626 }
d3f26155 627 return Standard_True;
7fd59977 628 }
629 else {
d3f26155 630 Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
2651bfde 631 Standard_Real newTol = BRepTools::EvalAndUpdateTol(newE, C3d, Curve2d, S, f3d, l3d);
632 if(newTol > Tol)
633 {
634 Tol = newTol;
635 myUpdatedEdges.Append(newE);
636 }
d3f26155 637 mylcu.Append(C2dBis);
638 return Standard_True;
7fd59977 639 }
640 }
641 else { // on est au 2ieme tour
642 C2d = Handle(Geom2d_Curve)::DownCast(itlcu.Value());
643 Handle(Standard_Type) st = C2d->DynamicType();
644 if (!(st == STANDARD_TYPE(Geom2d_BSplineCurve)) &&
35e08fe8 645 !(st == STANDARD_TYPE(Geom2d_BezierCurve))) {
d3f26155 646 return Standard_False;
7fd59977 647 }
648 Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
649 return Standard_True;
650 }
651 }
7fd59977 652}
653
654//=======================================================================
655//function : NewParameter
656//purpose :
657//=======================================================================
658
659Standard_Boolean BRepTools_NurbsConvertModification::NewParameter
660 (const TopoDS_Vertex& V,
661 const TopoDS_Edge& E,
662 Standard_Real& P,
663 Standard_Real& Tol)
664{
665 if(BRep_Tool::Degenerated(E))
666 return Standard_False;
667 Standard_Real f, l, param = BRep_Tool::Parameter(V,E);
668 TopLoc_Location L;
669
670 Handle(Geom_Curve) gc = BRep_Tool::Curve(E, L, f, l);
671 if(!myMap.Contains(gc))
672 return Standard_False;
673
674 Handle(Geom_BSplineCurve) gcc =
675 Handle(Geom_BSplineCurve)::DownCast(myMap.FindFromKey(gc));
676
677 gcc = Handle(Geom_BSplineCurve)::DownCast(gcc->Transformed(L.Transformation()));
678
679 GeomAdaptor_Curve ac(gcc);
680 gp_Pnt pnt = BRep_Tool::Pnt(V);
681
682 Extrema_LocateExtPC proj(pnt, ac, param, f, l, Tol);
683 if(proj.IsDone()) {
684 Standard_Real Dist2Min = proj.SquareDistance();
685 if (Dist2Min < Tol*Tol) {
7fd59977 686 P = proj.Point().Parameter();
687 return Standard_True;
688 }
689 }
690 return Standard_False;
691}
692
693//=======================================================================
694//function : Continuity
695//purpose :
696//=======================================================================
697
698GeomAbs_Shape BRepTools_NurbsConvertModification::Continuity
699 (const TopoDS_Edge& E,
700 const TopoDS_Face& F1,
701 const TopoDS_Face& F2,
702 const TopoDS_Edge&,
703 const TopoDS_Face&,
704 const TopoDS_Face&)
705{
706 return BRep_Tool::Continuity(E,F1,F2);
707}
708
709
2651bfde 710//=======================================================================
711//function : GetUpdatedEdges
712//purpose :
713//=======================================================================
714const TopTools_ListOfShape&
715 BRepTools_NurbsConvertModification::GetUpdatedEdges() const
716{
717 return myUpdatedEdges;
718}