1 // File: ChFi3d_Builder_CnCrn.cxx
4 // Modified by MPS (14-04-97) traitement des cas ou il n'y a pas
5 // d'intersection entre les stripes
6 // Modified by MPS (16-06-97) : on tient compte du fait que GeomPlate
7 // rend les courbes 2d dans meme ordre que les
8 // courbes frontieres passees en entree
9 // Modified by JLR (20-08-97) mise en place des nouveaux constructeurs de GeomPlate
11 // Modified by MPS (03-11-97) on ne cree pas un batten lorsque le rapport
12 // entre les deux resolutions sur la surface est trop grand (PRO10649)
14 // Modified by MPS (05-12-97) on ne tient pas compte des aretes degenerees
15 // lors du calcul du nombre d'aretes.
17 // Modified by JCT (08-12-97) traitement des aretes vives consecutives ou non
18 // (grille EDC412 sauf D2, L1, L2, L3)
20 // Modified by JCT (11-12-97) pb osf avec indpoint + orientation de plate
21 // ( --> D2, L1, L2, L3 valides mais laids)
23 // Modified by MPS (24-02-98) traitement des aretes de regularite
25 // Modified by MPS (01-06-98) traitement des aretes de couture
26 // Modified by MPS (01-12-98) traitement des bords libres
27 // Modified by MPS (01-02-99) traitement des aretes de regularite
29 // Traitement des coins
31 #include <Adaptor3d_HCurveOnSurface.hxx>
32 #include <Adaptor3d_CurveOnSurface.hxx>
33 #include <Bnd_Box2d.hxx>
34 #include <BndLib_Add2dCurve.hxx>
35 #include <BRep_Tool.hxx>
36 #include <BRepTools.hxx>
37 #include <BRepAlgo_NormalProjection.hxx>
38 #include <BRepLib_MakeEdge.hxx>
39 #include <ChFi3d_Builder.jxx>
40 #include <ChFi3d_Builder_0.hxx>
41 #include <ChFiDS_FaceInterference.hxx>
42 #include <ChFiDS_ListIteratorOfListOfStripe.hxx>
43 #include <ChFiDS_SurfData.hxx>
44 #include <ChFiDS_SequenceOfSurfData.hxx>
45 #include <ChFiDS_Stripe.hxx>
46 #include <ChFiDS_HData.hxx>
47 #include <ChFiDS_CommonPoint.hxx>
48 #include <ChFiDS_Regul.hxx>
49 #include <ChFiDS_StripeArray1.hxx>
50 #include <Extrema_ExtPC.hxx>
51 #include <Extrema_ExtCC.hxx>
52 #include <Extrema_POnCurv.hxx>
53 #include <GeomLib.hxx>
54 #include <Extrema_ExtPC.hxx>
55 #include <Geom2d_BSplineCurve.hxx>
56 #include <GeomAdaptor_HSurface.hxx>
57 #include <Geom2d_Line.hxx>
58 #include <Geom_Line.hxx>
59 #include <Geom_Curve.hxx>
60 #include <Geom2d_TrimmedCurve.hxx>
61 #include <GeomInt_IntSS.hxx>
62 #include <GeomLib.hxx>
63 #include <GeomAdaptor.hxx>
64 #include <Geom2dAdaptor_HCurve.hxx>
65 #include <GeomPlate_BuildPlateSurface.hxx>
66 #include <GeomPlate_Surface.hxx>
67 #include <GeomPlate_MakeApprox.hxx>
68 #include <GeomPlate_PlateG0Criterion.hxx>
69 #include <GeomPlate_HArray1OfHCurveOnSurface.hxx>
70 #include <Geom_Surface.hxx>
71 #include <Geom_BezierCurve.hxx>
72 #include <Geom2dLProp_CLProps2d.hxx>
73 #include <GeomPlate_CurveConstraint.hxx>
74 #include <FairCurve_Batten.hxx>
75 #include <Geom2d_BSplineCurve.hxx>
77 #include <gp_Pnt2d.hxx>
78 #include <gp_Dir2d.hxx>
79 #include <math_Matrix.hxx>
81 #include <TColStd_HArray1OfInteger.hxx>
82 #include <TColStd_ListOfInteger.hxx>
83 #include <TColgp_SequenceOfXY.hxx>
84 #include <TColgp_SequenceOfXYZ.hxx>
85 #include <TColgp_Array1OfXYZ.hxx>
86 #include <TColgp_Array1OfPnt.hxx>
87 #include <TColgp_Array1OfPnt2d.hxx>
88 #include <TopTools_IndexedMapOfShape.hxx>
89 #include <TColStd_Array1OfInteger.hxx>
90 #include <TColStd_Array1OfBoolean.hxx>
91 #include <TColStd_Array2OfInteger.hxx>
92 #include <TColStd_Array1OfReal.hxx>
93 #include <TColStd_Array2OfReal.hxx>
94 #include <TColGeom2d_Array1OfCurve.hxx>
95 #include <TColGeom2d_SequenceOfCurve.hxx>
96 #include <TColGeom_Array1OfCurve.hxx>
97 #include <TColGeom_SequenceOfCurve.hxx>
98 #include <TColGeom2d_HArray1OfCurve.hxx>
99 #include <TopAbs_Orientation.hxx>
100 #include <TopExp.hxx>
101 #include <TopExp_Explorer.hxx>
102 #include <TopOpeBRepDS_DataStructure.hxx>
103 #include <TopOpeBRepDS_Curve.hxx>
104 #include <TopOpeBRepDS_Point.hxx>
105 #include <TopOpeBRepDS_Surface.hxx>
106 #include <TopOpeBRepDS_ListOfInterference.hxx>
107 #include <TopOpeBRepDS_SolidSurfaceInterference.hxx>
108 #include <TopOpeBRepDS_Kind.hxx>
109 #include <TopOpeBRepDS_Transition.hxx>
110 #include <TopOpeBRepDS_CurvePointInterference.hxx>
111 #include <TopOpeBRepDS_SurfaceCurveInterference.hxx>
112 #include <TopTools_Array2OfShape.hxx>
113 #include <BRepLib_MakeFace.hxx>
114 #include <Precision.hxx>
117 #include <OSD_Chronometer.hxx>
118 extern Standard_Real t_plate ,t_approxplate,t_batten;
119 extern void ChFi3d_InitChron(OSD_Chronometer& ch);
120 extern void ChFi3d_ResultChron(OSD_Chronometer & ch,Standard_Real& time);
123 // Modified by Sergey KHROMOV - Fri Dec 21 17:08:19 2001 Begin
124 Standard_Boolean isTangentFaces(const TopoDS_Edge &theEdge,
125 const TopoDS_Face &theFace1,
126 const TopoDS_Face &theFace2);
127 // Modified by Sergey KHROMOV - Fri Dec 21 17:08:19 2001 End
129 //=======================================================================
132 //=======================================================================
134 static void Indices ( const Standard_Integer n,
135 const Standard_Integer ic,
136 Standard_Integer & icplus,
137 Standard_Integer & icmoins)
139 if (ic== (n-1)) icplus=0;
141 if (ic==0) icmoins=n-1;
145 //=======================================================================
146 //function : Calcul_Param
148 //=======================================================================
150 static void Calcul_Param (const Handle(ChFiDS_Stripe)& stripe,
151 const Standard_Integer jfposit,
152 const Standard_Integer indice,
153 const Standard_Boolean isfirst,
154 Standard_Real & param)
157 param=stripe->SetOfSurfData()->Value(indice)->InterferenceOnS2().Parameter(isfirst);
159 param=stripe->SetOfSurfData()->Value(indice)->InterferenceOnS1().Parameter(isfirst);
162 //=======================================================================
163 //function : Calcul_P2dOnSurf
165 //=======================================================================
167 static void Calcul_P2dOnSurf(const Handle(ChFiDS_Stripe)& stripe,
168 const Standard_Integer jfposit,
169 const Standard_Integer indice,
170 const Standard_Real param,
175 stripe->SetOfSurfData()->Value(indice)
176 ->InterferenceOnS1().PCurveOnSurf()->D0(param,p2);
178 stripe->SetOfSurfData()->Value(indice)
179 ->InterferenceOnS2().PCurveOnSurf()->D0(param,p2);
182 //=======================================================================
183 //function : Calcul_C2dOnFace
185 //=======================================================================
187 static void Calcul_C2dOnFace (const Handle(ChFiDS_Stripe)& stripe,
188 const Standard_Integer jfposit,
189 const Standard_Integer indice,
190 Handle(Geom2d_Curve) & c2d)
194 c2d = stripe->SetOfSurfData()->Value(indice)
195 ->InterferenceOnS1().PCurveOnFace();
197 c2d = stripe->SetOfSurfData()->Value(indice)
198 ->InterferenceOnS2().PCurveOnFace();
201 //=======================================================================
202 //function : Calcul_Orientation
204 //=======================================================================
206 static void Calcul_Orientation(const Handle(ChFiDS_Stripe)& stripe,
207 const Standard_Integer jfposit,
208 const Standard_Integer indice,
209 TopAbs_Orientation & orient)
212 orient = stripe->SetOfSurfData()->Value(indice)
213 ->InterferenceOnS1().Transition();
215 orient = stripe->SetOfSurfData()->Value(indice)
216 ->InterferenceOnS2().Transition();
219 //=======================================================================
220 //function : RemoveSD
222 //=======================================================================
224 static void RemoveSD(Handle(ChFiDS_Stripe)& Stripe,
225 const Standard_Integer num1,
226 const Standard_Integer num2 )
228 ChFiDS_SequenceOfSurfData& Seq =
229 Stripe->ChangeSetOfSurfData()->ChangeSequence();
230 if(Seq.IsEmpty()) return;
234 Seq.Remove(num1,num2);
237 //=======================================================================
238 //function : cherche_edge1
239 //purpose : find common edge of faces F1 and F2
240 //=======================================================================
242 static void cherche_edge1 (const TopoDS_Face & F1,
243 const TopoDS_Face & F2,
245 { Standard_Integer i,j;
246 TopoDS_Edge Ecur1,Ecur2;
247 Standard_Boolean trouve=Standard_False;
248 TopTools_IndexedMapOfShape MapE1,MapE2;
249 TopExp::MapShapes( F1,TopAbs_EDGE,MapE1);
250 TopExp::MapShapes( F2,TopAbs_EDGE,MapE2);
251 for ( i=1; i<= MapE1.Extent()&&!trouve; i++)
253 TopoDS_Shape aLocalShape = TopoDS_Shape (MapE1(i));
254 Ecur1=TopoDS::Edge(aLocalShape);
255 // Ecur1=TopoDS::Edge(TopoDS_Shape (MapE1(i)));
256 for ( j=1; j<= MapE2.Extent()&&!trouve; j++)
258 aLocalShape = TopoDS_Shape (MapE2(j));
259 Ecur2=TopoDS::Edge(aLocalShape);
260 // Ecur2=TopoDS::Edge(TopoDS_Shape (MapE2(j)));
261 if (Ecur2.IsSame(Ecur1))
262 {Edge=Ecur1;trouve=Standard_True;}
267 //=======================================================================
268 //function : CurveHermite
269 //purpose : calculate a curve 3d using polynoms of Hermite.
270 // the edge is a regular edge. Curve 3D is constructed
271 // between edges icmoins and icplus.
272 //=======================================================================
274 static void CurveHermite (const TopOpeBRepDS_DataStructure& DStr,
275 const Handle(ChFiDS_Stripe)& CDicmoins,
276 const Standard_Integer jficmoins,
277 const Standard_Integer icmoins,
278 const Standard_Real picmoins,
279 const Standard_Integer sensicmoins,
280 const Standard_Boolean sharpicmoins,
281 const TopoDS_Edge & Eviveicmoins,
282 const Handle(ChFiDS_Stripe)& CDicplus,
283 const Standard_Integer jficplus,
284 const Standard_Integer icplus,
285 const Standard_Real picplus,
286 const Standard_Integer sensicplus,
287 const Standard_Boolean sharpicplus,
288 const TopoDS_Edge & Eviveicplus,
289 const Standard_Integer nbface,
290 TopTools_SequenceOfShape & Ecom,
291 const TopTools_SequenceOfShape & Face,
292 TColGeom2d_SequenceOfCurve & proj2d,
293 TColGeom_SequenceOfCurve & cproj,
294 TopTools_SequenceOfShape & Eproj,
295 TColStd_SequenceOfReal & param,
296 Standard_Real & error)
300 Standard_Integer ii,jj;
301 Standard_Real up1,up2;
302 Standard_Integer ilin,jfp;
303 Handle (Geom_Curve) c1,c2;
305 c1=BRep_Tool::Curve(Eviveicmoins,up1,up2);
309 ilin= CDicmoins->SetOfSurfData()->Value( icmoins)->InterferenceOnS1().LineIndex();
310 else ilin= CDicmoins->SetOfSurfData()->Value(icmoins)->InterferenceOnS2().LineIndex();
311 c1=DStr.Curve(ilin).Curve();
314 c2=BRep_Tool::Curve(Eviveicplus,up1,up2);
319 ilin= CDicplus->SetOfSurfData()->Value( icplus)->InterferenceOnS1().LineIndex();
320 else ilin=CDicplus->SetOfSurfData()->Value(icplus)->InterferenceOnS2().LineIndex();
321 c2=DStr.Curve(ilin ).Curve();
323 c1->D1(picmoins,p01,d11);
324 c2->D1(picplus,p02,d12);
325 Standard_Integer size = 4;
326 math_Matrix MatCoefs(1,size, 1,size);
327 TColgp_Array1OfXYZ Cont(1,size);
328 PLib::HermiteCoefficients(0, 1,1,1,MatCoefs);
329 Standard_Real L1=p01.Distance(p02);
330 Standard_Real lambda= ((Standard_Real)1) / Max (d11.Magnitude() / L1, 1.e-6);
332 if (sensicmoins==1) Cont(2) = d11.XYZ()*(-lambda) ;
333 else Cont(2) = d11.XYZ()*(lambda) ;
334 lambda= ((Standard_Real)1) / Max (d12.Magnitude() / L1, 1.e-6);
336 if (sensicplus==1) Cont(4) = d12.XYZ()*(lambda);
337 else Cont(4) = d12.XYZ()*(-lambda);
338 TColgp_Array1OfPnt ExtrapPoles(1, size);
339 TColgp_Array1OfPnt ExtraCoeffs(1, size);
341 ExtraCoeffs.Init(p0);
342 for (ii=1; ii<=size; ii++) {
343 for (jj=1; jj<=size; jj++) {
344 ExtraCoeffs(jj).ChangeCoord() += MatCoefs(ii,jj)*Cont(ii);
347 PLib::CoefficientsPoles(ExtraCoeffs, PLib::NoWeights(),
348 ExtrapPoles, PLib::NoWeights());
349 Handle(Geom_BezierCurve) Bezier = new (Geom_BezierCurve) (ExtrapPoles);
350 BRepLib_MakeEdge Bedge (Bezier);
351 TopoDS_Edge edg =Bedge. Edge();
355 for(nb=1;nb<=nbface;nb++){
356 F=TopoDS::Face(Face.Value(nb));
357 TopTools_IndexedMapOfShape MapE1;
359 Handle(Geom2d_Curve) proj1;
360 Handle(Geom_Curve) proj1c,proj2c;
361 BRepAlgo_NormalProjection OrtProj;
364 OrtProj.SetParams(1.e-4, 1.e-4, GeomAbs_C1, 14, 16);
366 if ( OrtProj.IsDone()){
367 TopExp::MapShapes(OrtProj.Projection() , TopAbs_EDGE, MapE1);
368 if (MapE1.Extent()!=0){
369 if (MapE1.Extent()!=1) {
370 BRepLib_MakeFace Bface (BRep_Tool::Surface(F), Precision::Confusion());
375 if ( OrtProj.IsDone())
376 TopExp::MapShapes(OrtProj.Projection() ,TopAbs_EDGE, MapE1);
378 if (MapE1.Extent()!=0) {
379 Standard_Boolean trouve=Standard_False;
380 for (Standard_Integer ind=1;ind<=MapE1.Extent()&&!trouve;ind++){
381 TopoDS_Shape aLocalShape = TopoDS_Shape( MapE1(ind));
382 E1=TopoDS::Edge( aLocalShape );
383 // E1=TopoDS::Edge( TopoDS_Shape (MapE1(ind)));
384 if (!BRep_Tool::Degenerated(E1)) trouve=Standard_True;
387 proj1=BRep_Tool::CurveOnSurface(E1,F,up1,up2);
388 proj2d.Append(new Geom2d_TrimmedCurve(proj1,up1,up2));
389 proj1c=BRep_Tool::Curve(E1,up1,up2);
390 cproj.Append(new Geom_TrimmedCurve(proj1c,up1,up2));
391 if (error>BRep_Tool::Tolerance(E1)) error=BRep_Tool::Tolerance(E1);
395 proj2d.Append(proj1);
396 cproj.Append(proj1c);
401 proj2d.Append(proj1);
402 cproj.Append(proj1c);
406 for (nb=1;nb<=nbface-1;nb++) {
407 BRepAdaptor_Curve C(TopoDS::Edge(Ecom.Value(nb)));
408 C.D0(param.Value(nb),p02);
409 GeomAdaptor_Curve L (Bezier);
410 Extrema_ExtCC ext (C,L);
413 Extrema_POnCurv POnC, POnL;
414 ext.Points(1, POnC, POnL);
415 param.ChangeValue(nb) =POnC.Parameter();
418 if (!ext.IsDone()||ext.NbExt()==0) {
419 if (!cproj.Value(nb).IsNull()) {
420 cproj.Value(nb)->D0(cproj.Value(nb)->LastParameter(),p01);
422 else if (!cproj.Value(nb+1).IsNull()) {
423 cproj.Value(nb+1)->D0(cproj.Value(nb+1)->FirstParameter(),p01);
425 if (p01.Distance(p02)>1.e-4 ){
426 Extrema_ExtPC ext1 (p01,C);
428 if (ext1.NbExt()!=0){
429 Extrema_POnCurv POnC(ext1.Point(1));
430 param.ChangeValue(nb) =POnC.Parameter();
438 //=======================================================================
439 //function : CalculDroite
440 //purpose : calculate a 2D straight line passing through point p2d1 and direction xdir ydir
441 //=======================================================================
443 static void CalculDroite(const gp_Pnt2d & p2d1,
444 const Standard_Real xdir,
445 const Standard_Real ydir,
446 Handle (Geom2d_Curve) & pcurve)
447 { gp_Dir2d dir1 (xdir, ydir);
448 Handle(Geom2d_Line) l= new Geom2d_Line (p2d1,dir1);
449 Standard_Real l0 = sqrt(xdir*xdir+ ydir*ydir );
450 pcurve = new Geom2d_TrimmedCurve(l,0,l0);
453 //=======================================================================
454 //function : CalculBatten
455 //purpose : calcule a batten between curves 2d curv2d1 and curv2d2 at points p2d1 and p2d2
456 //=======================================================================
458 static void CalculBatten (const Handle (GeomAdaptor_HSurface) ASurf,
459 const TopoDS_Face Face ,
460 const Standard_Real xdir,
461 const Standard_Real ydir,
462 const gp_Pnt2d & p2d1,
463 const gp_Pnt2d & p2d2,
464 const Standard_Boolean contraint1,
465 const Standard_Boolean contraint2,
466 Handle (Geom2d_Curve) & curv2d1,
467 Handle (Geom2d_Curve) & curv2d2,
468 const Standard_Real picicplus,
469 const Standard_Real picplusic,
470 const Standard_Boolean inverseic,
471 const Standard_Boolean inverseicplus,
472 Handle (Geom2d_Curve)& pcurve)
474 Standard_Boolean isplane;
476 Standard_Boolean anglebig = Standard_False;
478 Standard_Boolean anglebig;
480 isplane=ASurf->GetType()==GeomAbs_Plane;
481 gp_Dir2d dir1 (xdir, ydir);
482 Geom2dLProp_CLProps2d CL1(curv2d1, picicplus, 1, 1.e-4);
483 Geom2dLProp_CLProps2d CL2( curv2d2, picplusic, 1, 1.e-4);
487 if (inverseic) dir3.Reverse();
488 if (inverseicplus) dir4.Reverse();
489 Standard_Real h = p2d2.Distance(p2d1)/20;
490 FairCurve_Batten Bat(p2d1,p2d2,h);
491 Bat.SetFreeSliding (Standard_True);
492 Standard_Real ang1,ang2;
493 ang1=dir1.Angle(dir3);
494 if (dir1.Angle(dir4) >0 ) ang2=PI-dir1.Angle(dir4);
495 else ang2=-PI-dir1.Angle(dir4);
496 if (contraint1&&contraint2)
497 anglebig=(Abs(ang1)>1.2)|| (Abs(ang2)>1.2 );
499 anglebig=Abs(ang1)>1.2;
501 anglebig=Abs(ang2)>1.2;
502 if (isplane && (Abs(ang1)>PI/2 || Abs(ang2)>PI/2))
503 isplane=Standard_False;
504 if (anglebig && !isplane) {
505 CalculDroite(p2d1,xdir,ydir,pcurve);
508 if (contraint1) Bat.SetAngle1(ang1);
509 else Bat.SetConstraintOrder1(0);
510 if (contraint2) Bat.SetAngle2(ang2);
511 else Bat.SetConstraintOrder2(0);
512 FairCurve_AnalysisCode Iana;
514 Ok = Bat.Compute(Iana,25,1.e-2);
522 pcurve = Bat.Curve();
523 Standard_Real umin,vmin,umax,vmax;
524 BRepTools::UVBounds(Face,umin,umax,vmin,vmax);
526 Geom2dAdaptor_Curve acur(pcurve);
527 BndLib_Add2dCurve::Add(acur,0,bc);
528 bf.Update(umin,vmin,umax,vmax);
529 Standard_Real uminc,vminc,umaxc,vmaxc;
530 bc.Get(uminc,vminc,umaxc,vmaxc);
531 if (uminc<umin-1.e-7) Ok=Standard_False;
532 if (umaxc>umax+1.e-7) Ok=Standard_False;
533 if (vminc<vmin-1.e-7) Ok=Standard_False;
534 if (vmaxc>vmax+1.e-7) Ok=Standard_False;
536 if (!Ok) CalculDroite(p2d1, xdir,ydir, pcurve);
540 //=======================================================================
541 //function : OrientationIcNonVive
542 //purpose : calculate the orientation of the curve between ic and icplus knowing that ic
543 // is not a living edge.
544 //=======================================================================
546 static void OrientationIcNonVive (const Handle(ChFiDS_Stripe) & CDic,
547 const Standard_Integer jfic,
548 const Standard_Integer icicplus,
549 const Standard_Integer sensic,
550 TopAbs_Orientation & orien )
552 TopAbs_Orientation orinterf;
553 Calcul_Orientation(CDic,jfic,icicplus,orinterf);
555 if (orinterf==TopAbs_FORWARD) orien=TopAbs_FORWARD;
556 else orien=TopAbs_REVERSED;
559 if (orinterf==TopAbs_FORWARD) orien=TopAbs_REVERSED;
560 else orien=TopAbs_FORWARD;
564 //=======================================================================
565 //function : OrientationIcplusNonVive
566 //purpose : calculate the orientation of the curve between ic and icplus knowing that icplus
567 // is not a living edge;
568 //=======================================================================
570 static void OrientationIcplusNonVive (const Handle(ChFiDS_Stripe) & CDicplus,
571 const Standard_Integer jficplus,
572 const Standard_Integer icplusic,
573 const Standard_Integer sensicplus,
574 TopAbs_Orientation & orien )
576 TopAbs_Orientation orinterf;
577 Standard_Integer jfp = 3 -jficplus;
578 Calcul_Orientation(CDicplus,jfp,icplusic,orinterf);
580 if (orinterf==TopAbs_FORWARD) orien=TopAbs_FORWARD;
581 else orien=TopAbs_REVERSED;
584 if (orinterf==TopAbs_FORWARD) orien=TopAbs_REVERSED;
585 else orien=TopAbs_FORWARD;
589 //=======================================================================
590 //function : OrientationAreteViveConsecutive
591 //purpose : calculate the orientation of the curve between edges ic and icplus
592 // where ic and icplus are consecutively living
593 //=======================================================================
595 static void OrientationAreteViveConsecutive (const TopoDS_Shape & Fviveicicplus,
596 const TopoDS_Shape & Eviveic,
597 const TopoDS_Vertex & V1,
598 TopAbs_Orientation & orien)
600 { // orinterf is orientation of edge ic corresponding to face Fviveicicplus taken FORWARD
602 TopAbs_Orientation orinterf = TopAbs_FORWARD;
604 TopAbs_Orientation orinterf;
606 TopoDS_Face F=TopoDS::Face( Fviveicicplus);
607 TopoDS_Edge E=TopoDS::Edge( Eviveic);
609 for(ex.Init(F.Oriented(TopAbs_FORWARD),TopAbs_EDGE);ex.More(); ex.Next()){
610 if(E.IsSame(ex.Current())) {
611 orinterf = ex.Current().Orientation();
615 // if V1 is vertex REVERSED of edge ic the curve
616 // has the same orientation as ic
618 vl=TopExp::LastVertex(E);
620 if (orinterf==TopAbs_FORWARD) orien=TopAbs_FORWARD;
621 else orien=TopAbs_REVERSED;
624 if (orinterf==TopAbs_FORWARD) orien=TopAbs_REVERSED;
625 else orien=TopAbs_FORWARD;
629 //=======================================================================
630 //function : PerformTwoCornerSameExt
631 //purpose : calculate intersection between two stripes stripe1 and stripe2
632 //=======================================================================
634 static void PerformTwoCornerSameExt(TopOpeBRepDS_DataStructure& DStr,
635 const Handle(ChFiDS_Stripe)& stripe1,
636 const Standard_Integer index1,
637 const Standard_Integer sens1,
638 const Handle(ChFiDS_Stripe) &stripe2,
639 const Standard_Integer index2,
640 const Standard_Integer sens2,
641 Standard_Boolean & trouve)
643 { Handle (TopOpeBRepDS_CurvePointInterference) Interfp1, Interfp2;
644 Handle (TopOpeBRepDS_SurfaceCurveInterference) Interfc;
645 TopAbs_Orientation orpcurve,trafil1,orsurf1,orsurf2;
646 Standard_Boolean isfirst;
647 Standard_Integer indic1,indic2, indpoint1,indpoint2,ind,indcurve;
651 Handle(Geom_Curve)cint;
652 Handle(Geom2d_Curve) C2dint1,C2dint2;
654 ChFiDS_CommonPoint& Com11= stripe1->SetOfSurfData()->Value(index1)->ChangeVertex (isfirst,1);
655 ChFiDS_CommonPoint& Com12= stripe1->SetOfSurfData()->Value(index1)->ChangeVertex (isfirst,2);
657 ChFiDS_CommonPoint& Com21= stripe2->SetOfSurfData()->Value(index2)->ChangeVertex (isfirst,1);
659 // ChFiDS_CommonPoint& Com22=
660 // stripe2->SetOfSurfData()->Value(index2)->ChangeVertex (isfirst,2);
662 indic1=stripe1->SetOfSurfData()->Value(index1)->Surf();
663 indic2=stripe2->SetOfSurfData()->Value(index2)->Surf();
664 const Handle(ChFiDS_SurfData) Fd1=stripe1->SetOfSurfData()->Value(index1);
665 const Handle(ChFiDS_SurfData) Fd2=stripe2->SetOfSurfData()->Value(index2);
667 TColStd_Array1OfReal Pardeb(1,4),Parfin(1,4);
668 const ChFiDS_FaceInterference& Fi11 = Fd1->InterferenceOnS1();
669 const ChFiDS_FaceInterference& Fi12 = Fd1->InterferenceOnS2();
670 const ChFiDS_FaceInterference& Fi21 = Fd2->InterferenceOnS1();
671 const ChFiDS_FaceInterference& Fi22 = Fd2->InterferenceOnS2();
672 gp_Pnt2d pfi11,pfi12,pfi21,pfi22;
674 pfi11 = Fi11.PCurveOnSurf()->Value(Fi11.Parameter(isfirst));
675 pfi12 = Fi12.PCurveOnSurf()->Value(Fi12.Parameter(isfirst));
677 if (Com11.Point().Distance(Com21.Point()) <1.e-4) {
678 pfi21 = Fi21.PCurveOnSurf()->Value(Fi21.Parameter(isfirst));
679 pfi22 = Fi22.PCurveOnSurf()->Value(Fi22.Parameter(isfirst));
682 pfi22 = Fi21.PCurveOnSurf()->Value(Fi21.Parameter(isfirst));
683 pfi21 = Fi22.PCurveOnSurf()->Value(Fi22.Parameter(isfirst));
686 Pardeb(1)= pfi11.X();Pardeb(2) = pfi11.Y();
687 Pardeb(3)= pfi21.X();Pardeb(4) = pfi21.Y();
688 Parfin(1)= pfi12.X();Parfin(2) = pfi12.Y();
689 Parfin(3)= pfi22.X();Parfin(4) = pfi22.Y();
691 Handle(GeomAdaptor_HSurface) HS1= ChFi3d_BoundSurf(DStr,Fd1,1,2);
692 Handle(GeomAdaptor_HSurface) HS2= ChFi3d_BoundSurf(DStr,Fd2,1,2);
693 trouve=Standard_False;
694 if (ChFi3d_ComputeCurves(HS1,HS2,Pardeb,Parfin,cint,
695 C2dint1,C2dint2,1.e-4,1.e-5,tol)){
696 cint->D0(cint->FirstParameter(),P1);
697 cint->D0(cint->LastParameter(),P2);
698 trouve=((Com11.Point().Distance(P1) <1.e-4 || Com11.Point().Distance(P2)<1.e-4)&&
699 (Com12.Point().Distance(P1) <1.e-4 || Com12.Point().Distance(P2)<1.e-4));
704 stripe1->InDS(isfirst);
705 indpoint1=ChFi3d_IndexPointInDS(Com11,DStr);
706 indpoint2=ChFi3d_IndexPointInDS(Com12,DStr);
707 stripe1->SetIndexPoint(indpoint1,isfirst,1);
708 stripe1->SetIndexPoint(indpoint2,isfirst,2);
710 stripe2->InDS(isfirst);
711 if (Com11.Point().Distance(Com21.Point()) <1.e-4) {
712 stripe2->SetIndexPoint(indpoint1,isfirst,1);
713 stripe2->SetIndexPoint(indpoint2,isfirst,2);
716 stripe2->SetIndexPoint(indpoint2,isfirst,1);
717 stripe2->SetIndexPoint(indpoint1,isfirst,2);
720 orsurf1=Fd1->Orientation();
721 trafil1 = DStr.Shape(Fd1->IndexOfS1()).Orientation();
722 trafil1 = TopAbs::Compose(trafil1,Fd1->Orientation());
723 trafil1 = TopAbs::Compose(TopAbs::Reverse(Fi11.Transition()),trafil1);
724 orsurf2=Fd2->Orientation();
725 TopOpeBRepDS_Curve tcurv3d(cint,tol);
726 indcurve= DStr.AddCurve(tcurv3d);
727 cint->D0(cint->FirstParameter(),P1);
728 cint->D0(cint->LastParameter(),P2);
729 Fi11.PCurveOnFace()->D0(Fi11.LastParameter(),p2d);
730 const Handle(Geom_Surface) Stemp =
731 BRep_Tool::Surface(TopoDS::Face(DStr.Shape(Fd1->IndexOfS1())));
732 Stemp ->D0(p2d.X(),p2d.Y(),P4);
733 Fi11.PCurveOnFace()->D0(Fi11.FirstParameter(),p2d);
734 Stemp ->D0(p2d.X(),p2d.Y(),P3);
735 if (P1.Distance(P4)<1.e-4 || P2.Distance(P3)<1.e-4)
737 else orpcurve=TopAbs::Reverse(trafil1);
738 if (Com11.Point().Distance(P1) >1.e-4) {
743 Interfp1=ChFi3d_FilPointInDS(TopAbs_FORWARD,indcurve, indpoint1, cint->FirstParameter());
744 Interfp2=ChFi3d_FilPointInDS(TopAbs_REVERSED,indcurve,indpoint2, cint->LastParameter());
745 DStr.ChangeCurveInterferences(indcurve).Append(Interfp1);
746 DStr.ChangeCurveInterferences(indcurve).Append(Interfp2);
747 Interfc=ChFi3d_FilCurveInDS(indcurve,indic1,C2dint1,orpcurve);
748 DStr.ChangeSurfaceInterferences(indic1).Append(Interfc);
749 if (orsurf1==orsurf2) orpcurve=TopAbs::Reverse(orpcurve);
750 Interfc=ChFi3d_FilCurveInDS(indcurve,indic2,C2dint2,orpcurve);
751 DStr.ChangeSurfaceInterferences(indic2).Append(Interfc);
755 //=======================================================================
756 //function : CpOnEdge
757 //purpose : determine if surfdata num has a common point on Eadj1 or Eadj2
758 //=======================================================================
760 static void CpOnEdge (const Handle(ChFiDS_Stripe) & stripe,
761 Standard_Integer num,
762 Standard_Boolean isfirst,
763 const TopoDS_Edge & Eadj1,
764 const TopoDS_Edge & Eadj2,
765 Standard_Boolean & compoint)
767 { ChFiDS_CommonPoint cp1,cp2;
768 compoint=Standard_False;
769 cp1 = stripe->SetOfSurfData()->Value(num)->ChangeVertex (isfirst,1);
770 cp2 = stripe->SetOfSurfData()->Value(num)->ChangeVertex (isfirst,2);
772 if (cp1.Arc().IsSame(Eadj1)||cp1.Arc().IsSame(Eadj2))
773 compoint=Standard_True;
776 if (cp2.Arc().IsSame(Eadj1)||cp2.Arc().IsSame(Eadj2))
777 compoint=Standard_True;
781 //=======================================================================
782 //function : RemoveSurfData
783 //purpose : for each stripe removal of unused surfdatas
784 //=======================================================================
786 static void RemoveSurfData (const ChFiDS_StripeMap & myVDataMap,
787 const ChFiDS_Map & myEFMap,
788 const TopoDS_Edge &edgecouture,
789 const TopoDS_Face & facecouture,
790 const TopoDS_Vertex &V1)
791 { ChFiDS_ListIteratorOfListOfStripe It;
792 Standard_Boolean isfirst;
793 TopoDS_Edge Ecur,Eadj1,Eadj2;
794 TopoDS_Face Fg,Fd,F1,F2;
796 Standard_Integer nbsurf,nbedge,sense,num;
797 for (It.Initialize(myVDataMap(V1));It.More();It.Next()) {
798 nbsurf= It.Value()->SetOfSurfData()->Length();
799 nbedge = It.Value()->Spine()->NbEdges();
801 num=ChFi3d_IndexOfSurfData(V1,It.Value(),sense);
803 Ecur = It.Value()->Spine()->Edges(1);
805 Ecur = It.Value()->Spine()->Edges(nbedge);
806 ChFi3d_edge_common_faces(myEFMap(Ecur),F1,F2);
807 if (F1.IsSame(facecouture)) Eadj1=edgecouture;
808 else ChFi3d_cherche_element(V1,Ecur,F1,Eadj1,Vbid);
809 ChFi3d_edge_common_faces(myEFMap(Eadj1),Fg,Fd);
810 if (F2.IsSame(facecouture)) Eadj2=edgecouture;
811 else ChFi3d_cherche_element(V1,Ecur,F2,Eadj2,Vbid);
812 ChFi3d_edge_common_faces(myEFMap(Eadj2),Fg,Fd);
813 Standard_Boolean compoint=Standard_False;
815 Standard_Integer ind;
818 // among surfdatas find the greatest indice ind so that
819 // surfdata could have one of commonpoint on Eadj1 and Eadj2
820 // remove surfdata from 1 to ind-1
821 for (Standard_Integer i=1;i<=nbsurf;i++) {
822 CpOnEdge (It.Value(),i,isfirst,Eadj1,Eadj2,compoint);
825 if (ind>=2) RemoveSD(It.Value(),1,ind-1);
829 // among surfdatas find the smallest indice ind so that
830 // surfdata could have one of commonpoint on Eadj1 and Eadj2
831 // remove surfdata from ind+1 to num
832 for (Standard_Integer i=num;i>=1;i--) {
833 CpOnEdge (It.Value(),i,isfirst,Eadj1,Eadj2,compoint);
836 if (ind<num) RemoveSD(It.Value(),ind+1,num);
842 //=======================================================================
843 //function : ParametrePlate
845 //=======================================================================
847 static void ParametrePlate(const Standard_Integer n3d,
848 const GeomPlate_BuildPlateSurface & PSurf,
849 const Handle(Geom_Surface) & Surf,
850 const gp_Pnt & point,
851 const Standard_Real apperror,
853 { Standard_Integer ip;
856 Standard_Boolean trouve=Standard_False;
857 for (ip=1;ip<=n3d && !trouve;ip++){
858 par=PSurf.Curves2d()->Value(ip)->FirstParameter();
859 PSurf.Curves2d()->Value(ip)->D0(par,uv);
860 Surf->D0(uv.X(),uv.Y(),P1);
861 trouve=P1.IsEqual(point,apperror);
863 par=PSurf.Curves2d()->Value(ip)->LastParameter();
864 PSurf.Curves2d()->Value(ip)->D0(par,uv);
865 Surf->D0(uv.X(),uv.Y(),P1);
866 trouve=P1.IsEqual(point,apperror);
871 //=======================================================================
872 //function : SummarizeNormal
874 //=======================================================================
876 static void SummarizeNormal(const TopoDS_Vertex& V1,
877 const TopoDS_Face& Fcur,
878 const TopoDS_Edge& Ecur,
879 gp_Vec& SumFaceNormalAtV1)
882 BRep_Tool::UVPoints(Ecur,Fcur,uv1,uv2);
883 if ( ! V1.IsSame(TopExp::FirstVertex(Ecur))) uv1 = uv2;
887 BRep_Tool::Surface(Fcur)->D1( uv1.X(), uv1.Y(), P, d1U, d1V);
888 gp_Vec N = d1U.Crossed(d1V);
889 if (Fcur.Orientation() == TopAbs_REVERSED) N.Reverse();
891 if (N.SquareMagnitude() <= Precision::PConfusion()) return;
893 SumFaceNormalAtV1 += N.Normalized();
894 SumFaceNormalAtV1.Normalize();
897 enum ChFi3d_SurfType { ChFiSURFACE, FACE1, FACE2 }; // for call SurfIndex(...)
899 //=======================================================================
900 //function : SurfIndex
902 //=======================================================================
904 static Standard_Integer SurfIndex(const ChFiDS_StripeArray1& StripeArray1,
905 const Standard_Integer StripeIndex,
906 const Standard_Integer SurfDataIndex,
907 const ChFi3d_SurfType SurfType)
909 const Handle(ChFiDS_SurfData)& aSurfData =
910 StripeArray1(StripeIndex)->SetOfSurfData()->Value(SurfDataIndex);
912 case ChFiSURFACE: return aSurfData->Surf();
913 case FACE1: return aSurfData->IndexOfS1();
914 case FACE2: return aSurfData->IndexOfS2();
920 //=======================================================================
921 //function : PlateOrientation
922 //purpose : Define Plate orientation compared to <theRefDir> previewing
923 // that Plate surface can have a sharp angle with adjacent
924 // filet (bug occ266: 2 chamfs, OnSame and OnDiff) and
925 // can be even twisted (grid tests cfi900 B1)
926 //=======================================================================
928 static TopAbs_Orientation PlateOrientation(const Handle(Geom_Surface)& thePlateSurf,
929 const Handle(TColGeom2d_HArray1OfCurve)& thePCArr,
930 const gp_Vec& theRefDir)
935 Standard_Real fpar, lpar;
936 Standard_Real SumScal1 = 0, SumScal2 = 0;
938 Standard_Integer i, nb = thePCArr->Upper();
939 Handle(Geom2d_Curve) aPC = thePCArr->Value(nb);
940 fpar = aPC->FirstParameter();
941 lpar = aPC->LastParameter();
942 aPC->D0( (fpar + lpar) / 2., uv);
943 thePlateSurf-> D0(uv.X(),uv.Y(),pp1);
945 thePlateSurf-> D0(uv.X(),uv.Y(),pp2);
947 for (i=1; i<=nb; i++) {
948 aPC = thePCArr->Value(i);
949 fpar = aPC->FirstParameter();
950 lpar = aPC->LastParameter();
952 thePlateSurf -> D1(uv.X(),uv.Y(),pp2,du,dv);
956 aPC->D0( (fpar + lpar) / 2., uv);
957 thePlateSurf-> D0(uv.X(),uv.Y(),pp3);
959 gp_Vec vv1(pp2,pp1), vv2(pp2,pp3);
964 SumScal2 += n2*theRefDir;
968 if (SumScal2*SumScal1>0) return TopAbs_FORWARD;
969 else return TopAbs_REVERSED;
972 //=======================================================================
973 //function : PerformMoreThreeCorner
974 //purpose : Process case of a top with n edges.
975 //=======================================================================
977 void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
978 const Standard_Integer nconges)
980 // ========================================
982 // ========================================
986 TopOpeBRepDS_DataStructure& DStr=myDS->ChangeDS();
987 const TopoDS_Vertex& V1 = myVDataMap.FindKey(Jndex);
988 Standard_Integer nedge;
989 Standard_Boolean bordlibre;
990 TopoDS_Edge edgelibre1,edgelibre2;
991 // TopTools_ListIteratorOfListOfShape ItE;
992 nedge=ChFi3d_NbNotDegeneratedEdges(V1,myVEMap);
993 ChFi3d_ChercheBordsLibres(myVEMap,V1,bordlibre,edgelibre1,edgelibre2);
994 Standard_Boolean droit=Standard_False;
995 if (bordlibre) {nedge=(nedge-2)/2 +2;
996 Standard_Real angedg=Abs(ChFi3d_AngleEdge(V1,edgelibre1,edgelibre2));
997 droit=Abs(angedg-PI)<0.01;
1000 Standard_Integer size=nedge*2;
1001 ChFiDS_StripeArray1 CD(0,size);
1002 TColStd_Array1OfInteger jf(0,size);
1003 TColStd_Array1OfInteger Index(0,size);
1004 TColStd_Array1OfInteger Indice(0,size);
1005 TColStd_Array1OfInteger sens(0,size);
1006 TColStd_Array1OfInteger indcurve3d(0,size);
1007 TColStd_Array2OfInteger numfa( 0,size,0,size);
1008 TColStd_Array1OfInteger Order( 0,size);
1009 TColStd_Array2OfInteger i(0,size,0,size);
1010 TColStd_Array2OfInteger indpoint(0,size,0,1);
1011 TColStd_Array1OfBoolean oksea(0,size);
1012 TColStd_Array1OfBoolean sharp(0,size);
1013 TColStd_Array1OfBoolean regul(0,size);
1014 TColStd_Array2OfReal p (0,size,0,size);
1015 TColStd_Array1OfReal errapp (0,size);
1016 TopTools_Array1OfShape Evive(0,size);
1017 TopTools_Array2OfShape Fvive(0,size,0,size);
1018 TColStd_Array1OfBoolean ponctuel (0,size);
1019 TColStd_Array1OfBoolean samedge (0,size);
1020 TColStd_Array1OfBoolean moresurf (0,size);
1021 TColStd_Array1OfBoolean libre(0,size);
1022 TColStd_Array1OfBoolean tangentregul (0,size);
1023 TColStd_Array1OfBoolean isG1(0,size);
1024 // for(Standard_Integer ind=0;ind<=size;ind++){
1025 Standard_Integer ind;
1026 for(ind=0;ind<=size;ind++){
1027 indpoint.SetValue(ind,0,0);
1028 indpoint.SetValue(ind,1,0);
1029 Indice.SetValue(ind,0);
1030 oksea.SetValue(ind,Standard_False);
1031 sharp.SetValue(ind,Standard_False);
1032 regul.SetValue(ind,Standard_False);
1033 ponctuel.SetValue(ind,Standard_False);
1034 samedge.SetValue(ind,Standard_False);
1035 moresurf.SetValue(ind,Standard_False);
1036 libre.SetValue(ind,Standard_False);
1037 tangentregul.SetValue(ind,Standard_False);
1038 isG1.SetValue(ind,Standard_False);
1040 ChFiDS_ListIteratorOfListOfStripe It;
1041 Handle(ChFiDS_Stripe) cd2,cdbid,cnext;
1043 Standard_Integer jfp,ii;
1044 Standard_Integer ic,icplus,icmoins,icplus2,
1045 sense,index,indice,isurf1,isurf2;
1046 Standard_Integer cbplus=0, n3d=0,IVtx,nb;
1047 Standard_Boolean sameside,trouve,isfirst;
1048 Standard_Real pardeb ,parfin,xdir,ydir;
1049 Standard_Real tolapp=1.e-4,maxapp,maxapp1,avedev;
1050 Handle (TopOpeBRepDS_CurvePointInterference) Interfp1, Interfp2;
1051 Handle (TopOpeBRepDS_SurfaceCurveInterference) Interfc;
1052 Handle(Geom_Curve) Curv3d;
1053 ChFiDS_Regul regular;
1054 TopTools_SequenceOfShape Fproj;
1055 Standard_Integer num;
1057 TopTools_ListIteratorOfListOfShape ItF;
1059 // Standard_Integer nface=ChFi3d_nbface(myVFMap(V1));
1062 gp_Vec SumFaceNormalAtV1(0,0,0); // is used to define Plate orientation
1064 // it is determined if there is a sewing edge
1065 Standard_Boolean couture=Standard_False;
1066 TopoDS_Face facecouture;
1067 TopoDS_Edge edgecouture;
1068 for(ItF.Initialize(myVFMap(V1));ItF.More()&&!couture;ItF.Next()) {
1069 TopoDS_Face fcur = TopoDS::Face(ItF.Value());
1070 ChFi3d_CoutureOnVertex(fcur,V1,couture,edgecouture);
1075 // unused surfdata are removed
1076 RemoveSurfData (myVDataMap, myEFMap,edgecouture,facecouture,V1);
1078 // parse edges and faces
1079 trouve=Standard_False;
1082 TopoDS_Face Fcur,Fnext;
1083 for (It.Initialize(myVDataMap(Jndex));It.More()&&!trouve;It.Next()) {
1085 CD.SetValue(0,cnext);
1086 Index.SetValue(0,ChFi3d_IndexOfSurfData(V1,cnext,sense));
1087 sens.SetValue(0,sense);
1088 numfa.SetValue(0 ,1,SurfIndex(CD, 0, Index.Value(0), FACE2));
1089 numfa.SetValue(1 ,0, numfa.Value(0 ,1));
1090 Fcur=TopoDS::Face(DStr.Shape(numfa.Value(0,1)));
1091 Fvive.SetValue(0,1,Fcur);
1092 Fvive.SetValue(1,0,Fcur);
1094 if (sens.Value(0)==1)
1095 Ecur = CD.Value(0)->Spine()->Edges(1);
1097 Ecur = CD.Value(0)->Spine()->Edges(CD.Value(0)->Spine()->NbEdges());
1098 Evive.SetValue(0,Ecur);
1099 ChFi3d_cherche_edge(V1,Evive,Fcur,Enext,VV);
1100 trouve= !Enext.IsNull();
1102 // find sum of all face normals at V1
1103 SummarizeNormal(V1, Fcur, Ecur, SumFaceNormalAtV1);
1105 Standard_Integer nbcouture=0;
1106 for ( ii=1; ii<nedge; ii++) {
1107 if (Fcur.IsSame(facecouture)&& nbcouture==0) {
1111 else ChFi3d_cherche_edge(V1,Evive,Fcur,Enext,VV);
1112 if (Enext.IsNull())Standard_Failure::Raise
1113 ("PerformMoreThreeCorner: pb in the parsing of edges and faces");
1114 if (Enext.IsSame(edgelibre1)|| Enext.IsSame(edgelibre2)) {
1115 CD.SetValue(ii, cdbid);
1116 Index.SetValue(ii, 0);
1117 sens.SetValue(ii, -1);
1119 Vref = TopExp::FirstVertex(Enext);
1120 if (Vref.IsSame(V1)) sens.SetValue(ii, 1);
1121 sharp.SetValue(ii, Standard_True);
1122 Evive.SetValue(ii, Enext);
1124 Indices(nedge,ii,icplus,icmoins);
1125 Fvive.SetValue(ii,icplus, Fcur);
1126 Fvive.SetValue(icplus,ii, Fcur);
1127 numfa.SetValue(ii,icplus, DStr.AddShape(Fcur));
1128 numfa.SetValue(icplus,ii,numfa.Value(ii,icplus));
1130 if (Enext.IsSame (edgelibre1)) Ecur=edgelibre2;
1131 else Ecur=edgelibre1;
1132 ChFi3d_edge_common_faces(myEFMap(Ecur),Fcur,Fcur);
1133 Indices(nedge,ii,icplus,icmoins);
1134 Fvive.SetValue(ii,icplus, Fcur);
1135 Fvive.SetValue(icplus,ii, Fcur);
1136 numfa.SetValue(ii,icplus, DStr.AddShape(Fcur));
1137 numfa.SetValue(icplus,ii,numfa.Value(ii,icplus));
1138 CD.SetValue(ii, cdbid);
1139 Index.SetValue(ii, 0);
1140 sens.SetValue(ii, -1);
1141 Vref = TopExp::FirstVertex(Ecur);
1142 if (Vref.IsSame(V1)) sens.SetValue(ii, 1);
1143 sharp.SetValue(ii, Standard_True);
1144 Evive.SetValue(ii, Ecur);
1148 // it is found if Enext is in the map of stripes
1150 /*Standard_Boolean */trouve = Standard_False;
1151 for (It.Initialize(myVDataMap(Jndex));It.More()&&!trouve;It.Next()) {
1152 index = ChFi3d_IndexOfSurfData(V1,It.Value(),sense);
1154 EE = It.Value()->Spine()->Edges(1);
1156 EE = It.Value()->Spine()->Edges(It.Value()->Spine()->NbEdges());
1157 if (Enext.IsSame(EE)) {
1159 trouve=Standard_True;
1163 CD.SetValue(ii, cnext);
1164 Index.SetValue(ii, index);
1165 sens.SetValue(ii, sense);
1166 sharp.SetValue(ii, Standard_False);
1167 Evive.SetValue(ii, Enext);
1171 CD.SetValue(ii, cdbid);
1172 Index.SetValue(ii, 0);
1173 sens.SetValue(ii, -1);
1175 Vref = TopExp::FirstVertex(Enext);
1176 if (Vref.IsSame(V1)) sens.SetValue(ii, 1);
1177 sharp.SetValue(ii, Standard_True);
1178 Evive.SetValue(ii, Enext);
1181 // Face Fnext!=Fcur containing Enext
1183 ChFi3d_cherche_face1(myEFMap(Enext),Fcur,Fnext);
1184 Indices(nedge,ii,icplus,icmoins);
1185 Fvive.SetValue(ii,icplus, Fnext);
1186 Fvive.SetValue(icplus,ii, Fnext);
1187 numfa.SetValue(ii,icplus, DStr.AddShape(Fnext));
1188 numfa.SetValue(icplus,ii,numfa.Value(ii,icplus));
1189 Standard_Integer numface1,numface2;
1191 // it is checked if numfa corresponds to IndexOfS1 or IndexOfS2
1192 // jf is updated is consequently updated
1193 // if it is not the case among the previous faces are found
1194 // those which correspond to IndexOfs1 IndexOfS2 and
1195 // numfa and Fvive are reupdated (cts16288)
1196 numface2 = SurfIndex(CD, ii, Index.Value(ii), FACE2);
1197 if (numface2==numfa.Value(ii,icplus))
1200 numface1 = SurfIndex(CD, ii, Index.Value(ii), FACE1);
1201 if (numface1==numfa.Value(ii,icplus))
1204 if (numface1==numfa.Value(icmoins,ii)) {
1206 Fvive.SetValue(ii,icplus,TopoDS::Face(DStr.Shape(numface2)));
1207 Fvive.SetValue(icplus,ii,TopoDS::Face(DStr.Shape(numface2)));
1208 numfa.SetValue(ii,icplus, DStr.AddShape(TopoDS::Face(DStr.Shape(numface2))));
1209 numfa.SetValue(icplus,ii, numfa.Value (ii,icplus));
1211 if (numface2==numfa.Value(icmoins,ii)) {
1213 Fvive.SetValue(ii,icplus,TopoDS::Face(DStr.Shape(numface1)));
1214 Fvive.SetValue(icplus,ii,TopoDS::Face(DStr.Shape(numface1)));
1215 numfa.SetValue(ii,icplus, DStr.AddShape(TopoDS::Face(DStr.Shape(numface1))));
1216 numfa.SetValue(icplus,ii, numfa.Value (ii,icplus));
1223 // find sum of all face normales at V1
1224 SummarizeNormal(V1, Fcur, Ecur, SumFaceNormalAtV1);
1227 // mise a jour du tableau regul
1228 for (ic=0;ic<nedge;ic++) {
1229 if (sharp.Value(ic)) {
1230 Ecur=TopoDS::Edge(Evive.Value(ic));
1231 if (!Ecur.IsSame(edgecouture)) {
1232 ChFi3d_edge_common_faces(myEFMap(Ecur),F1,F2);
1233 // Modified by Sergey KHROMOV - Fri Dec 21 18:11:02 2001 Begin
1234 // regul.SetValue(ic,BRep_Tool::Continuity(TopoDS::Edge(Evive.Value(ic)),F1,F2)
1236 regul.SetValue(ic,isTangentFaces(TopoDS::Edge(Evive.Value(ic)),F1,F2));
1237 // Modified by Sergey KHROMOV - Fri Dec 21 18:11:07 2001 End
1241 // it is checked if a regular edge is not tangent to another edge
1242 // in case if it is not considered regular (cts60072)
1243 for (ic=0;ic<nedge;ic++) {
1244 if (regul.Value(ic) ) {
1245 trouve=Standard_False;
1246 TopoDS_Edge ereg=TopoDS::Edge(Evive.Value(ic));
1247 for( ind=0;ind<nedge &&!trouve;ind++) {
1249 TopoDS_Edge ecur=TopoDS::Edge(Evive.Value(ind));
1250 Standard_Real ang=Abs(ChFi3d_AngleEdge(V1,ecur,ereg));
1251 if (ang<0.01 || Abs(ang-PI) <0.01) {
1252 regul.SetValue(ic,Standard_False);
1253 tangentregul.SetValue(ic,Standard_True);
1254 trouve=Standard_True;
1261 // variable deuxconges allows detecting cases when there is a top with
1262 // n edges and two fillets on two tangent edges that are not free borders
1263 // the connecting curves start from the fillet and end on top
1265 Standard_Boolean deuxconges,deuxcgnontg;
1266 deuxconges=Standard_False;
1267 trouve=Standard_False;
1270 for (ic=0;ic<nedge&&!trouve;ic++) {
1271 Indices(nedge,ic,icplus,icmoins);
1272 if (!sharp.Value(ic) && !sharp.Value(icplus)){
1273 E1=TopoDS::Edge(Evive.Value(ic));
1274 E2=TopoDS::Edge(Evive.Value(icplus));
1275 deuxconges=(Abs(ChFi3d_AngleEdge(V1 ,E1,E2) )<0.01) ;
1281 // variable deuxconges is used in the special case when there are
1282 // two fillets and if two other living edges are tangent (cts60072)
1283 if (nconges==2 && nedge==4) {
1285 for (ic=0;ic<nedge&&!deuxconges;ic++) {
1286 Indices(nedge,ic,icplus,icmoins);
1287 if (sharp.Value(ic) && sharp.Value(icplus)){
1288 E1=TopoDS::Edge(Evive.Value(ic));
1289 E2=TopoDS::Edge(Evive.Value(icplus));
1290 if ( !E1.IsSame(edgelibre1) && !E1.IsSame(edgelibre2) &&
1291 !E2.IsSame(edgelibre1) && !E2.IsSame(edgelibre2)){
1292 Standard_Real ang=Abs(ChFi3d_AngleEdge(V1 ,E1,E2));
1293 deuxconges=(ang<0.01 || Abs(ang-PI)<0.01);
1299 deuxcgnontg=nconges==2&& nedge==3 && !deuxconges; // pro12305
1302 for (ic=0;ic<nedge;ic++){
1303 regul.SetValue(ic,Standard_False);
1306 // Detect case of 3 edges & 2 conges: OnSame + OnDiff
1307 // (eap, Arp 9 2002, occ266)
1308 Standard_Boolean isOnSameDiff = Standard_False;
1310 Standard_Boolean isOnSame = Standard_False, isOnDiff = Standard_False;
1311 for (ic=0; ic<nedge; ic++) {
1312 if (sharp.Value(ic)) continue;
1314 if ( sens(ic) == 1 )
1315 stat = CD.Value(ic)->Spine()->FirstStatus();
1317 stat = CD.Value(ic)->Spine()->LastStatus();
1319 if (stat == ChFiDS_OnSame) isOnSame = Standard_True;
1320 else if (stat == ChFiDS_OnDiff) isOnDiff = Standard_True;
1322 isOnSameDiff = isOnSame && isOnDiff;
1324 if ( isOnSameDiff ) {
1326 cout << "OnSame + OnDiff, PerformMoreThreeCorner() calls PerformOneCorner()" << endl;
1328 PerformOneCorner (Jndex, Standard_True);
1331 // if the commonpoint is on an edge that does not have a
1332 // vertex at the extremity, Evive is found anew
1333 // Fvive is found anew if it does not correspond
1334 // to two faces adjacent to Evive (cts16288)
1336 if (!deuxconges && !isOnSameDiff)
1337 for (ic=0;ic<nedge;ic++) {
1338 if (sharp.Value(ic)) {
1339 Indices(nedge,ic,icplus,icmoins);
1340 TopoDS_Edge Arc=TopoDS::Edge(Evive.Value(ic));
1341 ChFiDS_CommonPoint cp1, cp2;
1342 Standard_Real angedg=PI;
1344 if (!sharp.Value(icplus)) {
1345 isfirst=(sens.Value(icplus)==1);
1346 jfp = 3 - jf.Value(icplus);
1347 cp1 = CD.Value(icplus)->SetOfSurfData()->Value(Index.Value(icplus))->
1348 ChangeVertex (isfirst,jfp);
1350 ChFi3d_cherche_vertex(Arc,cp1.Arc(),Vcom,trouve);
1351 if (trouve) angedg=Abs(ChFi3d_AngleEdge(Vcom,Arc,cp1.Arc()));
1352 if (!cp1.Arc().IsSame(Arc) && Abs(angedg-PI)<0.01){
1353 Evive.SetValue(ic,cp1.Arc());
1354 ChFi3d_edge_common_faces(myEFMap(cp1.Arc()),F1,F2);
1355 if (!Fvive.Value(ic,icplus).IsSame(F1) && !Fvive.Value(ic,icplus).IsSame(F2)) {
1356 if (Fvive.Value(ic,icmoins).IsSame(F2)) {
1357 Fvive.SetValue(ic,icplus,F1);
1358 Fvive.SetValue(icplus,ic,F1);
1359 numfa.SetValue(ic,icplus,DStr.AddShape(F1));
1360 numfa.SetValue(icplus,ic,DStr.AddShape(F1));
1363 Fvive.SetValue(ic,icplus,F2);
1364 Fvive.SetValue(icplus,ic,F2);
1365 numfa.SetValue(ic,icplus,DStr.AddShape(F2));
1366 numfa.SetValue(icplus,ic,DStr.AddShape(F2));
1369 samedge.SetValue(ic,Standard_True);
1370 p.SetValue(ic,icplus,cp1.ParameterOnArc());
1371 p.SetValue(ic,icmoins,cp1.ParameterOnArc());
1372 i.SetValue(ic,icplus,1);
1376 if (!sharp.Value(icmoins)) {
1377 isfirst=(sens.Value(icmoins)==1);
1378 cp2 = CD.Value(icmoins)->SetOfSurfData()->Value(Index.Value(icmoins))->
1379 ChangeVertex (isfirst,jf.Value(icmoins));
1380 if (cp2.IsOnArc()) {
1382 ChFi3d_cherche_vertex(Arc,cp2.Arc(),Vcom,trouve);
1383 if (trouve) angedg=Abs(ChFi3d_AngleEdge(Vcom,Arc,cp2.Arc()));
1384 if (!cp2.Arc().IsSame(Arc)&&Abs(angedg-PI)<0.01) {
1385 Evive.SetValue(ic,cp2.Arc());
1386 ChFi3d_edge_common_faces(myEFMap(cp2.Arc()),F1,F2);
1387 if (!Fvive.Value(ic,icmoins).IsSame(F1) && !Fvive.Value(ic,icmoins).IsSame(F2)) {
1388 if (Fvive.Value(ic,icplus).IsSame(F2)) {
1389 Fvive.SetValue(ic,icmoins,F1);
1390 numfa.SetValue(ic,icmoins,DStr.AddShape(F1));
1391 Fvive.SetValue(icmoins,ic,F1);
1392 numfa.SetValue(icmoins,ic,DStr.AddShape(F1));
1395 Fvive.SetValue(ic,icmoins,F2);
1396 numfa.SetValue(ic,icmoins,DStr.AddShape(F2));
1397 Fvive.SetValue(icmoins,ic,F2);
1398 numfa.SetValue(icmoins,ic,DStr.AddShape(F2));
1401 samedge.SetValue(ic,Standard_True);
1402 p.SetValue(ic,icmoins,cp2.ParameterOnArc());
1403 p.SetValue(ic,icplus,cp2.ParameterOnArc());
1404 i.SetValue(ic,icmoins,1);
1411 // the first free edge is restored if it exists
1412 trouve=Standard_False;
1413 for (ic=0; ic<nedge&&!trouve;ic++) {
1415 ecom=TopoDS::Edge(Evive.Value(ic));
1416 if (ecom.IsSame(edgelibre1)||ecom.IsSame(edgelibre2)){
1417 libre.SetValue(ic,Standard_True);
1418 trouve=Standard_True;
1422 // determine the minimum recoil distance that can't be exceeded
1423 Standard_Boolean distmini=Standard_False;
1424 gp_Pnt som=BRep_Tool::Pnt(V1),pic;
1426 TopoDS_Edge edgemin;
1428 Standard_Real dst,distmin;
1430 for (ic=0;ic<nedge;ic++) {
1431 if (sharp.Value(ic))
1432 edgemin=TopoDS::Edge(Evive.Value(ic));
1434 if (sens.Value(ic)==1)
1435 edgemin= CD.Value(ic)->Spine()->Edges(1);
1437 edgemin = CD.Value(ic)->Spine()->Edges(CD.Value(ic)->Spine()->NbEdges());
1439 V=TopExp::FirstVertex(edgemin);
1440 V2=TopExp::LastVertex(edgemin);
1441 dst=(BRep_Tool::Pnt(V)).Distance(BRep_Tool::Pnt(V2))/1.5;
1442 if (dst<distmin) distmin=dst;
1445 // calculate intersections between stripes and determine the parameters on each pcurve
1446 Standard_Boolean inters=Standard_True;
1447 for (ic=0;ic<nedge;ic++) {
1448 Indices(nedge,ic,icplus,icmoins);
1449 if (sharp.Value(ic)||sharp.Value(icplus)) {
1450 oksea.SetValue(ic, Standard_False);
1453 Standard_Integer jf1;
1454 Standard_Integer i1,i2;
1455 Standard_Real pa1,pa2;
1456 Standard_Boolean ok;
1457 Handle(ChFiDS_Stripe) strip;
1458 Standard_Real angedg;
1459 Standard_Integer iface;
1460 // if two edges are tangent the intersection is not attempted (cts60046)
1461 angedg=Abs(ChFi3d_AngleEdge(V1,TopoDS::Edge(Evive.Value(ic)),TopoDS::Edge(Evive.Value(icplus))));
1462 if (Abs(angedg-PI)>0.01)
1463 ok = ChFi3d_SearchFD(DStr,CD.Value(ic),CD.Value(icplus),sens.Value(ic),sens.Value(icplus),
1465 Index.Value(ic),Index.Value(icplus),
1466 face,sameside,jf1,jfp);
1467 else ok=Standard_False;
1468 // if there is an intersection it is checked if surfdata with the intersection
1469 // corresponds to the first or the last
1470 // if this is not the case, the surfdata are removed from SD
1473 if (i1!=Index.Value(ic) ){
1474 Standard_Integer ideb,ifin;
1476 if (sens.Value(ic)==1) {
1477 ideb=Index.Value(ic);
1481 ifin=Index.Value(ic);
1484 if (i1<Index.Value(ic)) {
1485 for (nb=Index.Value(ic);nb>=i1;nb--) {
1487 iface=SurfIndex(CD, ic, nb , FACE1);
1488 else iface=SurfIndex(CD, ic, nb , FACE2);
1489 Fproj.Append(TopoDS::Face(myDS->Shape(iface)));
1492 if (i1>Index.Value(ic)) {
1493 for (nb=Index.Value(ic);nb<=i1;nb++) {
1495 iface=SurfIndex(CD, ic, nb , FACE1);
1496 else iface=SurfIndex(CD, ic, nb , FACE2);
1497 Fproj.Append(TopoDS::Face(myDS->Shape(iface)));
1501 RemoveSD(strip,ideb,ifin);
1502 num=ChFi3d_IndexOfSurfData(V1,CD.Value(ic),sense);
1503 Index.SetValue(ic,num);
1506 if (i2!=Index.Value(icplus) ){
1507 Standard_Integer ideb,ifin;
1508 strip=CD.Value(icplus);
1509 if (sens.Value(icplus)==1) {
1510 ideb=Index.Value(icplus);
1514 ifin=Index.Value(icplus);
1518 if (i2<Index.Value(icplus)) {
1519 for (nb=i2;nb<=Index.Value(icplus);nb++) {
1521 iface=SurfIndex(CD, icplus, nb , FACE1);
1522 else iface=SurfIndex(CD, icplus, nb , FACE2);
1523 Fproj.Append(TopoDS::Face(myDS->Shape(iface)));
1526 if (i2>Index.Value(icplus)) {
1527 for (nb=i2;nb>=Index.Value(icplus);nb--) {
1529 iface=SurfIndex(CD, icplus, nb , FACE1);
1530 else iface=SurfIndex(CD, icplus, nb , FACE2);
1531 Fproj.Append(TopoDS::Face(myDS->Shape(iface)));
1534 RemoveSD(strip,ideb,ifin);
1535 num=ChFi3d_IndexOfSurfData(V1,CD.Value(icplus),sense);
1536 Index.SetValue(icplus,num);
1539 Calcul_P2dOnSurf(CD.Value(ic),jf1,i1,pa1,p2);
1540 indice=SurfIndex(CD, ic, i1, ChFiSURFACE);
1541 DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),pic);
1542 if (pic.Distance(som)>distmin) distmini =Standard_True;
1543 jf.SetValue(ic,jf1);
1544 i.SetValue(ic,icplus,i1);
1545 i.SetValue(icplus,ic,i2);
1546 p.SetValue(ic,icplus,pa1);
1547 p.SetValue(icplus,ic,pa2);
1549 oksea.SetValue(ic, ok);
1551 if (!oksea.Value(ic) ) inters=Standard_False;
1554 // case if there are only intersections
1555 // the parametres on Pcurves are the extremities of the stripe
1558 for (ic=0;ic<nedge;ic++) {
1559 Indices(nedge,ic,icplus,icmoins);
1560 Indices(nedge,icplus,icplus2,ic);
1561 if (!oksea.Value(ic)) {
1563 if (sharp.Value(ic)) {
1564 if (!samedge.Value(ic)){
1565 para=BRep_Tool::Parameter(V1,TopoDS::Edge(Evive.Value(ic)));
1566 p.SetValue(ic,icplus,para);
1567 i.SetValue(ic,icplus,1);
1571 isfirst= (sens.Value(ic)==1);
1572 i.SetValue(ic,icplus,ChFi3d_IndexOfSurfData(V1,CD.Value(ic),sense));
1573 if (oksea.Value(icmoins)) {
1574 para=p.Value(ic,icmoins);
1575 p.SetValue(ic,icplus,para);
1578 Calcul_Param(CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),isfirst,para);
1579 p.SetValue(ic,icplus,para);
1582 if (sharp.Value(icplus)) {
1583 if (!samedge.Value(icplus)) {
1584 para=BRep_Tool::Parameter(V1,TopoDS::Edge(Evive.Value(icplus)));
1585 p.SetValue(icplus,ic, para);
1586 i.SetValue(icplus,ic,1);
1590 isfirst= (sens.Value(icplus)==1);
1591 i.SetValue(icplus,ic,ChFi3d_IndexOfSurfData(V1,CD.Value(icplus),sense));
1592 if (oksea.Value(icplus)){
1593 para=p.Value(icplus,icplus2);
1594 p.SetValue(icplus,ic,para);
1597 jfp = 3 - jf.Value(icplus);
1598 Calcul_Param(CD.Value(icplus),jfp,i.Value(icplus,ic),isfirst,para);
1599 p.SetValue(icplus,ic,para);
1605 // calculate max distance to the top at each point
1606 TColStd_Array1OfReal dist1(0,size);
1607 TColStd_Array1OfReal dist2(0,size);
1608 Standard_Real distance=0.;
1609 gp_Pnt sommet=BRep_Tool::Pnt(V1);
1611 for (ic=0;ic<nedge;ic++) {
1612 Indices(nedge,ic,icplus,icmoins);
1613 if (sharp.Value(ic)) {
1614 dist1.SetValue(ic, 0);
1615 dist2.SetValue(ic, 0);
1618 jfp = 3 - jf.Value(ic);
1619 Calcul_P2dOnSurf(CD.Value(ic),jfp,i.Value(ic,icmoins),p.Value(ic,icmoins),p2);
1620 indice=SurfIndex(CD, ic, i.Value(ic,icmoins), ChFiSURFACE);
1621 DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),pic);
1622 dist1.SetValue(ic, sommet.Distance(pic));
1623 if (dist1.Value(ic) > distance ) distance= dist1.Value(ic);
1625 Calcul_P2dOnSurf(CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),p.Value(ic,icplus),p2);
1626 indice=SurfIndex(CD, ic, i.Value(ic,icplus), ChFiSURFACE);
1627 DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),pic);
1628 dist2.SetValue(ic, sommet.Distance(pic));
1629 if( dist2.Value(ic) > distance )
1630 distance= dist2.Value(ic);
1634 // offset of parameters and removal of intersection points
1635 // too close to the top
1637 Standard_Real ec, dist;
1638 if (!deuxconges && !deuxcgnontg)
1639 for (ic=0;ic<nedge;ic++) {
1640 Indices(nedge,ic,icplus,icmoins);
1641 if (sharp.Value(ic) ) {
1642 BRepAdaptor_Curve C(TopoDS::Edge(Evive.Value(ic)));
1643 // to pass from 3D distance to a parametric distance
1644 if (!tangentregul(ic))
1645 ec = distance*100*C.Resolution(0.01);
1647 if (TopExp::FirstVertex(TopoDS::Edge(Evive.Value(ic))).IsSame(V1)) {
1648 para=p.Value(ic,icmoins) + ec;
1649 p.SetValue(ic,icmoins, para);
1652 para=p.Value(ic,icmoins) - ec;
1653 p.SetValue(ic,icmoins,para);
1655 // it is necessary to be on to remain on the edge
1656 p.SetValue(ic,icplus, p.Value(ic,icmoins));
1658 else if (!distmini) {
1659 dist = dist1.Value(ic);
1660 if ((!oksea.Value(icmoins))||(oksea.Value(icmoins)&&(distance>1.3*dist))) {
1662 if (oksea.Value(icmoins)) {
1663 oksea.SetValue(icmoins,Standard_False);
1664 inters=Standard_False;
1667 if (sens.Value(ic)==1) {
1668 para=p.Value(ic,icmoins) + ec;
1669 p.SetValue(ic,icmoins, para);
1672 para=p.Value(ic,icmoins) - ec;
1673 p.SetValue(ic,icmoins,para);
1676 dist = dist2.Value(ic);
1677 if ((!oksea.Value(ic))||(oksea.Value(ic)&&(distance>1.3*dist))) {
1678 if(oksea.Value(ic)) {
1679 oksea.SetValue(ic,Standard_False);
1680 inters=Standard_False;
1684 Standard_Real parold,parnew;
1685 parold=p.Value(ic,icplus);
1686 parnew=p.Value(ic,icmoins);
1687 if (sens.Value(ic)==1) {
1688 if (parnew> parold) p.SetValue(ic,icplus, p.Value(ic,icmoins));
1691 if (parnew<parold) p.SetValue(ic,icplus, p.Value(ic,icmoins));
1699 // it is attempted to limit the edge by a commonpoint
1702 Standard_Real tolcp=0;
1703 gp_Pnt PE, sommet=BRep_Tool::Pnt(V1);
1705 for (ic=0;ic<nedge;ic++) {
1706 if (sharp.Value(ic)) {
1707 Indices(nedge,ic,icplus,icmoins);
1708 BRepAdaptor_Curve C(TopoDS::Edge(Evive.Value(ic)));
1709 PE = C.Value(p.Value(ic,icplus));
1710 Standard_Real d1=0., d2=0., dS = PE.Distance(sommet);
1711 ChFiDS_CommonPoint cp1, cp2;
1712 if (!sharp.Value(icplus)) {
1713 isfirst=(sens.Value(icplus)==1);
1714 jfp = 3 - jf.Value(icplus);
1715 cp1 = CD.Value(icplus)->SetOfSurfData()->Value(i.Value(icplus,ic))->
1716 ChangeVertex (isfirst,jfp);
1717 d1 = cp1.Point().Distance(sommet);
1719 if (!sharp.Value(icmoins)) {
1720 isfirst=(sens.Value(icmoins)==1);
1721 cp2 = CD.Value(icmoins)->SetOfSurfData()->Value(i.Value(icmoins,ic))->
1722 ChangeVertex (isfirst,jf.Value(icmoins));
1723 d2 = cp2.Point().Distance(sommet);
1725 Standard_Boolean samecompoint=Standard_False;
1726 if (!sharp.Value(icmoins) && !sharp.Value(icplus))
1727 samecompoint=cp1.Point().Distance(cp2.Point())<tolapp;
1728 if ((dS<d1 || dS<d2)&& !samecompoint) {
1729 // step back till Common Points
1730 // without leaving the Edge ??
1731 if (d2<d1 &&cp1.IsOnArc() ) {
1733 p.SetValue(ic,icmoins, cp1.ParameterOnArc());
1734 p.SetValue(ic,icplus, p.Value(ic,icmoins));
1735 isfirst=(sens.Value(icplus)==1);
1736 jfp = 3 - jf.Value(icplus);
1737 Calcul_Param(CD.Value(icplus),jfp,i.Value(icplus,ic),isfirst,para);
1738 p.SetValue(icplus,ic,para);
1739 if (cp1.Tolerance()>tolcp &&cp1.Tolerance()<1 ) tolcp=cp1.Tolerance();
1741 else if( cp2.IsOnArc()){
1743 p.SetValue(ic,icmoins, cp2.ParameterOnArc());
1744 p.SetValue(ic,icplus, p.Value(ic,icmoins));
1745 isfirst=(sens.Value(icmoins)==1);
1746 Calcul_Param(CD.Value(icmoins),jf.Value(icmoins),i.Value(icmoins,ic),isfirst, para);
1747 p.SetValue(icmoins,ic,para);
1748 if (cp2.Tolerance()>tolcp&&cp2.Tolerance()<1) tolcp=cp2.Tolerance();
1752 // step back till Common Point only if it is very close
1753 if (!sharp.Value(icplus)) {
1754 if ((cp1.Point().Distance(PE)<cp1.Tolerance() ||
1755 samecompoint || nconges==1) && cp1.IsOnArc()) {
1756 // it is very close to cp1
1757 p.SetValue(ic,icmoins, cp1.ParameterOnArc());
1758 ponctuel.SetValue(ic,Standard_True);
1759 p.SetValue(ic,icplus, p.Value(ic,icmoins));
1760 isfirst=(sens.Value(icplus)==1);
1761 jfp = 3 - jf.Value(icplus);
1762 Calcul_Param(CD.Value(icplus),jfp,i.Value(icplus,ic),isfirst,para);
1763 p.SetValue(icplus,ic,para);
1764 if (cp1.Tolerance()>tolcp &&cp1.Tolerance()<1) tolcp=cp1.Tolerance();
1767 if (!sharp.Value(icmoins)){
1768 if ((cp2.Point().Distance(PE)<cp2.Tolerance() ||
1769 samecompoint || nconges==1) && cp2.IsOnArc()) {
1770 // it is very close to cp2
1771 ponctuel.SetValue(icmoins,Standard_True);
1772 p.SetValue(ic,icmoins, cp2.ParameterOnArc());
1773 p.SetValue(ic,icplus,p.Value(ic,icmoins));
1774 isfirst=(sens.Value(icmoins)==1);
1775 Calcul_Param(CD.Value(icmoins),jf.Value(icmoins),i.Value(icmoins,ic),isfirst,para);
1776 p.SetValue(icmoins,ic,para);
1777 if (cp2.Tolerance()>tolcp&&cp2.Tolerance()<1 ) tolcp=cp2.Tolerance();
1784 // in case of a free border the parameter corresponding
1785 // to the common point on the free edge is chosen.
1787 for (ic=0;ic<nedge;ic++) {
1788 if (TopoDS::Edge(Evive.Value(ic)).IsSame(edgelibre1) ||
1789 TopoDS::Edge(Evive.Value(ic)).IsSame(edgelibre2)) {
1790 Standard_Integer indic;
1791 ChFiDS_CommonPoint CP1;
1792 Indices(nedge,ic,icplus,icmoins);
1793 if (libre.Value(ic))indic=icmoins;
1795 if (!sharp(indic)) {
1796 isfirst=sens.Value(indic)==1;
1797 CP1 = CD.Value(indic)->SetOfSurfData()->Value(Index.Value(indic))->ChangeVertex(isfirst,1);
1798 /*Standard_Boolean*/ trouve=Standard_False;
1799 if (CP1.IsOnArc()) {
1800 if(CP1.Arc().IsSame(TopoDS::Edge(Evive.Value(ic)))) {
1801 p.SetValue(ic,icmoins,CP1.ParameterOnArc());
1802 p.SetValue(ic,icplus,CP1.ParameterOnArc());
1803 trouve=Standard_True;
1807 CP1 = CD.Value(indic)->SetOfSurfData()->Value(Index.Value(indic))->ChangeVertex(isfirst,2);
1808 if (CP1.IsOnArc()) {
1809 if(CP1.Arc().IsSame(TopoDS::Edge(Evive.Value(ic)))) {
1810 p.SetValue(ic,icmoins,CP1.ParameterOnArc());
1811 p.SetValue(ic,icplus,CP1.ParameterOnArc());
1819 // if ic is a regular edge, one finds edge indfin which is not
1820 // a regular edge, and construtc a curve 3d
1821 // between edges (or stripes ) icmoins and indfin.
1822 // Then this courbe3d is projected on all faces (nbface) that
1823 // separate icmoins and indfin
1825 Standard_Integer nbface = 0;
1827 Standard_Integer nbface;
1829 Standard_Real error;
1830 TColGeom2d_Array1OfCurve proj2d1(0,size);
1831 TColGeom2d_Array1OfCurve proj2d2(0,size);
1832 TColGeom_Array1OfCurve cproj1(0,size);
1833 TColGeom_Array1OfCurve cproj2(0,size);
1835 for (ic=0;ic<nedge;ic++) {
1836 Standard_Integer ilin;
1837 TColGeom_SequenceOfCurve cr;
1838 TColGeom2d_SequenceOfCurve pr;
1839 TopTools_SequenceOfShape Lface;
1840 TopTools_SequenceOfShape Ledge;
1842 if (regul.Value(ic)){
1843 Indices(nedge,ic,icplus,icmoins);
1844 Indices(nedge,icplus,icplus2,ic);
1845 Standard_Integer indfin,indfinmoins,indfinplus;
1847 trouve=Standard_False;
1850 if (!regul.Value(ii)) {
1852 trouve=Standard_True;
1854 if (ii==nedge-1) ii=0;
1857 Indices(nedge,indfin,indfinplus,indfinmoins);
1858 if (!sharp.Value(icmoins)){
1859 if( jf.Value(icmoins)==1)
1860 ilin= SurfIndex(CD, icmoins, i.Value(icmoins,ic), FACE1);
1862 ilin= SurfIndex(CD, icmoins, i.Value(icmoins,ic), FACE2);
1863 Lface.Append(TopoDS::Face(DStr.Shape(ilin)));
1865 else Lface.Append( Fvive(ic,icmoins));
1867 nbface=indfin-icmoins;
1868 else nbface =nedge-(icmoins-indfin);
1869 TopTools_SequenceOfShape Epj;
1870 TColStd_SequenceOfReal seqpr;
1872 for (Standard_Integer nf=1;nf<=nbface-1;nf++) {
1873 Standard_Integer iimoins,iiplus;
1874 Indices(nedge,ii,iiplus,iimoins);
1875 Ledge.Append(TopoDS::Edge(Evive.Value(ii)));
1876 seqpr.Append(p.Value(ii,iiplus));
1877 if (nf!=nbface-1) Lface.Append( Fvive(ii,iiplus));
1878 if (ii==nedge-1) ii=0;
1881 if (!sharp.Value(indfin) ){
1882 jfp=3-jf.Value(indfin);
1884 ilin= SurfIndex(CD, indfin, i.Value(indfin,indfinmoins), FACE1);
1885 else ilin=SurfIndex(CD, indfin, i.Value(indfin,indfinmoins), FACE2);
1886 Lface.Append(TopoDS::Face(DStr.Shape(ilin)));
1888 else Lface.Append(Fvive(indfin,indfinmoins));
1889 CurveHermite(DStr,CD.Value(icmoins),jf.Value(icmoins),i.Value(icmoins,ic),
1890 p.Value(icmoins,ic),sens.Value(icmoins),sharp.Value(icmoins),
1891 TopoDS::Edge(Evive.Value(icmoins)),CD.Value(indfin),jf.Value(indfin),
1892 i.Value(indfin,indfinmoins),p.Value(indfin,indfinmoins),sens.Value(indfin),
1893 sharp.Value(indfin),TopoDS::Edge(Evive.Value(indfin)),nbface,Ledge,
1894 Lface,pr,cr,Epj,seqpr,error);
1896 for (ind=1;ind<=nbface-1;ind++) {
1897 Standard_Integer iimoins,iiplus;
1898 Indices(nedge,ii,iiplus,iimoins);
1899 p.SetValue(ii,iiplus,seqpr.Value(ind));
1900 p.SetValue(ii,iimoins,seqpr.Value(ind));
1901 proj2d1.SetValue(ii,pr.Value(ind));
1902 proj2d2.SetValue(ii,pr.Value(ind+1));
1903 cproj1.SetValue(ii,cr.Value(ind));
1904 cproj2.SetValue(ii,cr.Value(ind+1));
1905 if (ii==nedge-1) ii=0;
1908 if (!sharp.Value(icmoins)&&!sharp.Value(indfin)) {
1910 while (ii!=indfin) {
1911 isG1.SetValue(ii,Standard_True);
1912 if (ii==nedge-1) ii=0;
1920 // case when the conncting curve between ic and icplus crosses many faces
1922 TopTools_SequenceOfShape Ecom;
1923 TopTools_SequenceOfShape Eproj;
1924 TColStd_SequenceOfReal parcom;
1926 for (ic=0;ic<nedge;ic++) {
1927 Standard_Integer iface1,iface2;
1928 TopoDS_Face face1,face2;
1930 TColGeom_SequenceOfCurve cr;
1931 TColGeom2d_SequenceOfCurve pr;
1932 Indices(nedge,ic,icplus,icmoins);
1933 if (!oksea.Value(ic)){
1934 iface1=numfa.Value(ic,icplus);
1935 iface2=numfa.Value(icplus,ic);
1936 if (!sharp.Value(ic)) {
1937 if (jf.Value(ic)==1)
1938 iface1 =SurfIndex(CD, ic, i.Value(ic,icplus), FACE1);
1939 else iface1=SurfIndex(CD, ic, i.Value(ic,icplus), FACE2);
1941 face1=TopoDS::Face(myDS->Shape(iface1));
1943 if (!sharp.Value(icplus)) {
1944 if (jf.Value(icplus)==1)
1945 iface2 =SurfIndex(CD, icplus, i.Value(icplus,ic), FACE2);
1946 else iface2=SurfIndex(CD, icplus, i.Value(icplus,ic), FACE1);
1948 face2=TopoDS::Face(myDS->Shape(iface2));
1949 if (!face1.IsSame(face2)) {
1950 if (Fproj.Length()==0) {
1951 Fproj.Append(face1);
1952 Fproj.Append(face2);
1954 moresurf.SetValue(ic,Standard_True);
1955 nbface=Fproj.Length();
1956 if (!TopoDS::Face(Fproj.Value(nbface)).IsSame(face2)) {
1957 Fproj.Remove(nbface);
1958 Fproj.Append(face2);
1960 if (!TopoDS::Face(Fproj.Value(1)).IsSame(face1)) {
1962 Fproj.Prepend(face1);
1964 for (nb=1;nb<=nbface-1; nb++) {
1965 cherche_edge1 ( TopoDS::Face(Fproj.Value(nb)), TopoDS::Face(Fproj.Value(nb+1)),edge);
1967 para=BRep_Tool::Parameter(TopExp::FirstVertex(edge),edge);
1968 parcom.Append(para);
1970 CurveHermite (DStr,CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),
1971 p.Value(ic,icplus),sens.Value(ic),sharp.Value(ic),
1972 TopoDS::Edge(Evive.Value(ic)),
1973 CD.Value(icplus),jf.Value(icplus),i.Value(icplus,ic),
1974 p.Value(icplus,ic),sens.Value(icplus),sharp.Value(icplus),
1975 TopoDS::Edge(Evive.Value(icplus)),nbface,Ecom,Fproj, pr,cr,Eproj,parcom,error);
1976 Ecom.Append(Ecom.Value(nbface-1));
1977 parcom.Append(parcom.Value(nbface-1));
1982 // case when two fillets have the same commonpoints
1983 // one continues then by intersection
1984 // it is checked if the extremities of the intersection coincide with commonpoints
1986 Standard_Boolean intersection=Standard_False, introuve;
1987 if (nconges==2 && !deuxconges) {
1990 Standard_Integer ic1 = 0,ic2 = 0;
1992 Standard_Integer ic1,ic2;
1994 trouve=Standard_False;
1995 for (ic=0;ic<nedge&&!trouve;ic++) {
1996 if (!sharp.Value(ic)){
1998 trouve=Standard_True;
2001 for (ic=0;ic<nedge;ic++) {
2002 if (!sharp.Value(ic)&& ic!=ic1) ic2=ic;
2004 jfp = 3 - jf.Value(ic1);
2005 Indices(nedge,ic1,icplus,icmoins);
2006 Calcul_P2dOnSurf(CD.Value(ic1),jfp,i.Value(ic1,icmoins),p.Value(ic1,icmoins),p2);
2007 indice=SurfIndex(CD, ic1, i.Value(ic1,icmoins), ChFiSURFACE);
2008 DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),P1);
2010 Calcul_P2dOnSurf(CD.Value(ic1),jf.Value(ic1),i.Value(ic1,icplus),p.Value(ic1,icplus),p2);
2011 indice=SurfIndex(CD, ic1, i.Value(ic1,icplus), ChFiSURFACE);
2012 DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),P2);
2014 jfp = 3 - jf.Value(ic2);
2015 Indices(nedge,ic2,icplus,icmoins);
2016 Calcul_P2dOnSurf(CD.Value(ic2),jfp,i.Value(ic2,icmoins),p.Value(ic2,icmoins),p2);
2017 indice=SurfIndex(CD, ic2, i.Value(ic2,icmoins), ChFiSURFACE);
2018 DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),P3);
2020 Calcul_P2dOnSurf(CD.Value(ic2),jf.Value(ic2),i.Value(ic2,icplus),p.Value(ic2,icplus),p2);
2021 indice=SurfIndex(CD, ic2, i.Value(ic2,icplus), ChFiSURFACE);
2022 DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),P4);
2023 intersection=(P1.Distance(P4)<=1.e-7 || P1.Distance(P3)<=1.e-7) &&
2024 (P2.Distance(P4)<=1.e-7 || P2.Distance(P3)<=1.e-7);
2026 PerformTwoCornerSameExt(DStr,CD.Value(ic1),Index.Value(ic1),sens.Value(ic1),
2027 CD.Value(ic2),Index.Value(ic2),sens.Value(ic2),introuve);
2028 if (introuve) return;
2032 // declaration for plate
2033 GeomPlate_BuildPlateSurface PSurf(3,10,3,tol2d,tolesp,angular);
2035 // calculation of curves on surface for each stripe
2036 for (ic=0;ic<nedge;ic++) {
2037 gp_Pnt2d p2d1, p2d2;
2038 if (!sharp.Value(ic)) {
2040 Indices(nedge,ic,icplus,icmoins);
2041 jfp = 3 - jf.Value(ic);
2042 Calcul_P2dOnSurf(CD.Value(ic),jfp,i.Value(ic,icmoins),p.Value(ic,icmoins),p2d1);
2043 Calcul_P2dOnSurf(CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),p.Value(ic,icplus),p2d2);
2044 // if (i[ic][icplus]!= i[ic][icmoins]) cout<<"probleme surface"<<endl;
2045 indice= SurfIndex(CD, ic, i.Value(ic,icplus), ChFiSURFACE);
2046 Handle (GeomAdaptor_HSurface) Asurf =
2047 new GeomAdaptor_HSurface(DStr.Surface(indice).Surface());
2048 // calculation of curve 2d
2049 xdir= p2d2.X()-p2d1.X();
2050 ydir= p2d2.Y()-p2d1.Y();
2051 Standard_Real l0 = sqrt(xdir*xdir+ ydir*ydir );
2052 gp_Dir2d dir (xdir, ydir);
2053 Handle(Geom2d_Line) l= new Geom2d_Line (p2d1 ,dir);
2054 Handle (Geom2d_Curve) pcurve = new Geom2d_TrimmedCurve(l,0,l0);
2055 Handle (Geom2dAdaptor_HCurve) Acurv = new Geom2dAdaptor_HCurve(pcurve);
2056 Adaptor3d_CurveOnSurface CurvOnS (Acurv,Asurf);
2057 Handle(Adaptor3d_HCurveOnSurface) HCons =
2058 new Adaptor3d_HCurveOnSurface(CurvOnS);
2059 Order.SetValue(ic,1);
2060 Handle(GeomPlate_CurveConstraint) Cont =
2061 new GeomPlate_CurveConstraint(HCons,Order.Value(ic),10,tolesp,angular,0.1);
2064 // calculate indexes of points and of the curve for the DS
2065 isfirst=(sens.Value(ic)==1);
2066 GeomLib::BuildCurve3d(tolapp,CurvOnS,CurvOnS.FirstParameter(),
2067 CurvOnS.LastParameter(),Curv3d,maxapp,avedev);
2068 TopOpeBRepDS_Curve tcurv3d( Curv3d,maxapp);
2069 indcurve3d.SetValue(n3d,DStr.AddCurve(tcurv3d));
2070 gp_Pnt point1,point2;
2071 point1= CurvOnS.Value(CurvOnS.FirstParameter());
2072 point2 =CurvOnS.Value(CurvOnS.LastParameter());
2074 TopOpeBRepDS_Point tpoint1 (point1,maxapp);
2075 TopOpeBRepDS_Point tpoint2 (point2,maxapp);
2076 errapp.SetValue(ic,maxapp);
2078 // it is necessary to create two points
2079 indpoint.SetValue(ic,0,DStr.AddPoint(tpoint1));
2080 indpoint.SetValue(ic,1,DStr.AddPoint(tpoint2));
2083 // probably the points are already on the fillet
2084 // (previous intersection...)
2085 trouve = Standard_False;
2086 for (ii=0;ii<ic&&(!trouve);ii++) {
2087 if (!sharp.Value(ii)) {
2088 TopOpeBRepDS_Point & tpt= DStr.ChangePoint(indpoint.Value(ii,1));
2089 if (point1.Distance(tpt.Point())<1.e-4)
2090 trouve = Standard_True;
2094 indpoint.SetValue(ic,0,indpoint.Value(ii-1,1));
2096 indpoint.SetValue(ic,0,DStr.AddPoint(tpoint1));
2098 trouve = Standard_False;
2099 for (ii=0;ii<ic&&(!trouve);ii++) {
2100 if (!sharp.Value(ii)) {
2101 TopOpeBRepDS_Point & tpt= DStr.ChangePoint(indpoint.Value(ii,0));
2102 if (point2.Distance(tpt.Point())<1.e-4)
2103 trouve = Standard_True;
2107 indpoint.SetValue(ic,1,indpoint.Value(ii-1,0));
2109 indpoint.SetValue(ic,1,DStr.AddPoint(tpoint2));
2112 // update of the stripe
2113 isurf1=3-jf.Value(ic); isurf2=jf.Value(ic);
2114 if (isurf1==2) CD.Value(ic)->SetOrientation(TopAbs_REVERSED,isfirst);
2115 CD.Value(ic)->SetCurve(indcurve3d.Value(n3d),isfirst);
2116 CD.Value(ic)->SetIndexPoint(indpoint.Value(ic,0),isfirst,isurf1);
2117 CD.Value(ic)->SetIndexPoint(indpoint.Value(ic,1),isfirst,isurf2);
2118 CD.Value(ic)->SetParameters(isfirst,pcurve->FirstParameter(),pcurve->LastParameter());
2119 ChFiDS_CommonPoint cp1;
2120 ChFiDS_CommonPoint cp2;
2121 cp1.SetPoint (point1);
2122 cp2.SetPoint( point2);
2123 CD.Value(ic)->SetOfSurfData()->Value(i.Value(ic,icmoins))->
2124 ChangeVertex (isfirst,isurf1)=cp1;
2125 CD.Value(ic)->SetOfSurfData()->Value(i.Value(ic,icmoins))->
2126 ChangeVertex (isfirst,isurf2)=cp2;
2127 CD.Value(ic)->SetOfSurfData()->Value(i.Value(ic,icmoins))->
2128 ChangeInterference(isurf1).SetParameter(p.Value(ic,icmoins),isfirst);
2129 CD.Value(ic)->SetOfSurfData()->Value(i.Value(ic,icmoins))->
2130 ChangeInterference(isurf2).SetParameter(p.Value(ic,icplus),isfirst);
2131 CD.Value(ic)-> ChangePCurve(isfirst)= pcurve;
2135 // calculate the indices of points for living edges
2136 for (ic=0;ic<nedge;ic++) {
2137 if (sharp.Value(ic)) {
2138 Indices(nedge,ic,icplus,icmoins);
2139 BRepAdaptor_Curve C(TopoDS::Edge(Evive.Value(ic)));
2140 /*gp_Pnt*/ PE = C.Value(p.Value(ic,icplus));
2141 TopOpeBRepDS_Point TPE(PE,BRep_Tool::Tolerance(TopoDS::Edge(Evive.Value(ic))));
2142 ChFiDS_CommonPoint cp;
2144 IVtx = DStr.AddShape(V1);
2145 indpoint.SetValue(ic,0, IVtx );
2146 indpoint.SetValue(ic,1, IVtx );
2148 if (!sharp.Value(icplus)) {
2149 isfirst=(sens.Value(icplus)==1);
2150 jfp = 3 - jf.Value(icplus);
2151 cp = CD.Value(icplus)->SetOfSurfData()->Value(i.Value(icplus,ic))->
2152 ChangeVertex (isfirst,jfp);
2153 if ( cp.Point().Distance(PE) <= Max(1.e-4,tolcp)) {
2154 // edge was limited by the 1st CommonPoint of CD[icplus]
2155 indpoint.SetValue(ic,0,indpoint.Value(icplus,0));
2156 indpoint.SetValue(ic,1,indpoint.Value(icplus,0));
2159 if (!sharp.Value(icmoins)) {
2160 isfirst=(sens.Value(icmoins)==1);
2161 cp = CD.Value(icmoins)->SetOfSurfData()->Value(i.Value(icmoins,ic))->
2162 ChangeVertex (isfirst,jf.Value(icmoins));
2163 if ( cp.Point().Distance(PE) <= Max(1.e-4,tolcp)) {
2164 // edge was limited by the 2nd CommonPoint of CD[icmoins]
2165 if (indpoint.Value(ic,0)==0) {
2166 indpoint.SetValue(ic,0, indpoint.Value(icmoins,1));
2167 indpoint.SetValue(ic,1, indpoint.Value(icmoins,1));
2171 if (indpoint.Value(ic,0)==0) {
2172 indpoint.SetValue(ic,0,DStr.AddPoint(TPE));
2173 indpoint.SetValue(ic,1, indpoint.Value(ic,0));
2178 // calculation of intermediary curves connecting two stripes in case if
2179 // there is no intersection. The curve is a straight line, projection or batten
2181 Standard_Boolean raccordbatten;
2184 for (ic=0;ic<nedge;ic++) {
2186 if (!oksea.Value(ic)&& !moresurf.Value(ic) && !libre.Value(ic) ) {
2187 Indices(nedge,ic,icplus,icmoins);
2188 raccordbatten=Standard_False;
2189 if (!regul.Value(ic)) {
2190 raccordbatten=Standard_True;
2191 if (regul.Value(icplus))
2192 raccordbatten=Standard_False;
2195 gp_Pnt2d p2d1, p2d2;
2196 Handle(Geom2d_Curve) curv2d1,curv2d2;
2197 Handle (Geom2d_Curve) pcurve;
2198 Handle (Geom_Curve) curveint;
2199 Handle (GeomAdaptor_HSurface) Asurf;
2200 Standard_Real u1bid,u2bid;
2202 // return the 1st curve 2d
2203 // and the 1st connection point
2204 if (sharp.Value(ic))
2205 curv2d1 = BRep_Tool::CurveOnSurface(TopoDS::Edge(Evive.Value(ic)),TopoDS::Face(Fvive.Value(ic,icplus)),
2208 Calcul_C2dOnFace(CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),curv2d1);
2209 p2d1 = curv2d1 ->Value(p.Value(ic,icplus));
2211 // recuperation de la deuxieme courbe 2d
2212 // et du deuxieme point de raccordement
2213 if (sharp.Value(icplus))
2214 curv2d2 = BRep_Tool::CurveOnSurface(TopoDS::Edge(Evive.Value(icplus)),
2215 TopoDS::Face(Fvive.Value(ic,icplus)),u1bid,u2bid);
2217 jfp = 3 - jf.Value(icplus);
2218 Calcul_C2dOnFace(CD.Value(icplus),jfp,i.Value(icplus,ic),curv2d2);
2220 p2d2 = curv2d2 ->Value(p.Value(icplus,ic));
2222 Asurf = new GeomAdaptor_HSurface(BRep_Tool::Surface(TopoDS::Face(Fvive.Value(ic,icplus))));
2223 Standard_Real tolu,tolv,ratio;
2224 tolu=Asurf->Surface().UResolution(1.e-3);
2225 tolv=Asurf->Surface().VResolution(1.e-3);
2226 if (tolu>tolv) ratio=tolu/tolv;
2227 else ratio=tolv/tolu;
2229 // in case of a sewing edge the parameters are reframed
2231 Standard_Boolean PI1=Standard_False, PI2=Standard_False;
2233 PI1=0<=p2d1.X() && p2d1.X() <=PI;
2234 PI2=0<=p2d2.X() && p2d2.X() <=PI;
2236 if (Evive.Value(ic).IsSame(edgecouture)){
2238 if (PI2&&!PI1) xx=xx-2*PI;
2239 if (!PI2&&PI1) xx=xx+2*PI;
2243 if (Evive.Value(icplus).IsSame(edgecouture)){
2245 if (PI2&&!PI1) xx=xx+2*PI;
2246 if (!PI2&&PI1) xx=xx-2*PI;
2250 xdir= p2d2.X()-p2d1.X();
2251 ydir= p2d2.Y()-p2d1.Y();
2253 Standard_Real l0 = sqrt(xdir*xdir+ ydir*ydir );
2254 if (l0<1.e-7|| ponctuel.Value(ic)) {
2255 // unused connection
2257 ponctuel.SetValue(ic,Standard_True);
2259 if ( sharp.Value(icplus) && indpoint.Value(icplus,0) == 0 ) {
2260 indpoint.SetValue(icplus,0, indpoint.Value(ic,1));
2261 indpoint.SetValue(icplus,1, indpoint.Value(ic,1));
2263 if ( sharp.Value(ic) && indpoint.Value(ic,0) == 0 ) {
2264 indpoint.SetValue(ic,0,indpoint.Value(icmoins,1));
2265 indpoint.SetValue(ic,1,indpoint.Value(icmoins,1));
2269 else { // the connection is a straight line, projection or batten
2270 if (ratio>10 && nconges==1) raccordbatten=Standard_True;
2271 if (ratio>10 && raccordbatten) {
2272 CalculDroite(p2d1,xdir,ydir,pcurve);
2273 raccordbatten=Standard_False;
2275 else if (!raccordbatten){ // the projected curves are returned
2276 if (regul.Value(ic)) {
2277 if (cproj2.Value(ic).IsNull()){
2278 raccordbatten=Standard_True;
2281 pcurve=proj2d2.Value(ic);
2282 curveint=cproj2.Value(ic);
2288 if (cproj1.Value(ic+1).IsNull()) {
2289 raccordbatten=Standard_True;
2292 pcurve=proj2d1.Value(ic+1);
2293 curveint=cproj1.Value(ic+1);
2298 Standard_Boolean contraint1=Standard_True,
2299 contraint2=Standard_True;
2300 if (raccordbatten) {
2302 ChFi3d_InitChron(ch);// initial performances for battens
2304 Standard_Boolean inverseic,inverseicplus;
2305 if (sharp.Value(ic)) {
2306 inverseic=TopExp::FirstVertex(TopoDS::Edge(Evive.Value(ic))).
2310 inverseic=sens.Value(ic)==1;
2312 if (sharp.Value(icplus)){
2313 inverseicplus=TopExp::FirstVertex(TopoDS::Edge(Evive.Value(icplus))).
2317 inverseicplus=sens.Value(icplus)==1;
2319 if (TopoDS::Edge(Evive.Value(ic)).IsSame(edgelibre1) ||
2320 TopoDS::Edge(Evive.Value(ic)).IsSame(edgelibre2))
2321 contraint1=Standard_False;
2322 if (TopoDS::Edge(Evive.Value(icplus)).IsSame(edgelibre1) ||
2323 TopoDS::Edge(Evive.Value(icplus)).IsSame(edgelibre2))
2324 contraint2=Standard_False;
2325 CalculBatten(Asurf,TopoDS::Face(Fvive(ic,icplus)),xdir,ydir,p2d1,p2d2,contraint1,contraint2,curv2d1,curv2d2,p.Value(ic,icplus),
2326 p.Value(icplus,ic),inverseic,inverseicplus,pcurve);
2328 ChFi3d_ResultChron( ch,t_batten); // resulting performances for battens
2332 // construction of borders for Plate
2333 Handle (Geom2dAdaptor_HCurve) Acurv=new Geom2dAdaptor_HCurve(pcurve);
2334 Adaptor3d_CurveOnSurface CurvOnS (Acurv,Asurf);
2335 Handle(Adaptor3d_HCurveOnSurface) HCons =
2336 new Adaptor3d_HCurveOnSurface(CurvOnS);
2338 // constraints G1 are set if edges ic and icplus are not both alive
2341 Order.SetValue(n3d,0);
2342 if (!sharp.Value(ic)&& !sharp.Value(icplus))
2343 Order.SetValue(n3d,1);
2344 if (!contraint1 && !sharp.Value(icplus))
2345 Order.SetValue(n3d,1);
2346 if (!contraint2 && !sharp.Value(ic))
2347 Order.SetValue(n3d,1);
2348 if (tangentregul(ic) || tangentregul(icplus) )
2349 Order.SetValue(n3d,1);
2351 Order.SetValue(n3d,1);
2352 Handle(GeomPlate_CurveConstraint) Cont =
2353 new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolesp,angular,0.1);
2356 //calculation of curve 3d if it is not a projection
2357 if (curveint.IsNull()) {
2358 GeomLib::BuildCurve3d(tolapp,CurvOnS,CurvOnS.FirstParameter(),
2359 CurvOnS.LastParameter(),Curv3d,maxapp1,avedev);
2360 pardeb=CurvOnS.FirstParameter();
2361 parfin= CurvOnS.LastParameter();
2362 curveint= new Geom_TrimmedCurve(Curv3d,pardeb,parfin);
2366 TopOpeBRepDS_Curve tcurv3d( curveint,maxapp1);
2367 indcurve3d.SetValue(n3d, DStr.AddCurve(tcurv3d));
2368 pardeb=curveint->FirstParameter();
2369 parfin=curveint->LastParameter();
2370 if ( sharp.Value(icplus) && indpoint.Value(icplus,0) == 0) {
2371 // it is necessary to initialize indpoint[icplus][0] and indpoint[icplus][1]
2373 point2 =curveint->Value(parfin);
2374 TopOpeBRepDS_Point tpoint2 (point2,maxapp);
2375 indpoint.SetValue(icplus,0,DStr.AddPoint(tpoint2));
2376 indpoint.SetValue(icplus,1,indpoint.Value(icplus,0));
2378 Standard_Boolean IsVt1=Standard_False;
2379 Standard_Boolean IsVt2=Standard_False;
2381 IsVt1=sharp.Value(ic);
2382 IsVt2=sharp.Value(icplus);
2384 Interfp1=ChFi3d_FilPointInDS(TopAbs_FORWARD,indcurve3d.Value(n3d),
2385 indpoint.Value(ic,1),pardeb,IsVt1);
2386 Interfp2=ChFi3d_FilPointInDS(TopAbs_REVERSED,indcurve3d.Value(n3d),
2387 indpoint(icplus,0),parfin,IsVt2);
2388 DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append(Interfp1);
2389 DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append(Interfp2);
2391 TopOpeBRepDS_Point & tpt1= DStr.ChangePoint(indpoint(ic,1));
2392 tpt1.Tolerance (tpt1.Tolerance()+maxapp1);
2395 TopOpeBRepDS_Point &tpt2= DStr.ChangePoint(indpoint(icplus,0));
2396 tpt2.Tolerance (tpt2.Tolerance()+maxapp1);
2399 // calculate orientation of the curve
2400 TopAbs_Orientation orinterf;
2401 if (!sharp.Value(ic)) {
2402 OrientationIcNonVive(CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),sens.Value(ic),orinterf);
2404 else if (!sharp.Value(icplus)) {
2405 OrientationIcplusNonVive(CD.Value(icplus),jf.Value(icplus),i.Value(icplus,ic),sens.Value(icplus),orinterf);
2408 OrientationAreteViveConsecutive (Fvive.Value(ic,icplus) ,Evive.Value(ic),V1,orinterf);
2410 Interfc=ChFi3d_FilCurveInDS(indcurve3d.Value(n3d),numfa.Value(ic,icplus),pcurve,orinterf);
2411 DStr.ChangeShapeInterferences(numfa.Value(ic,icplus)).Append(Interfc);
2413 } // end of processing by edge
2414 } // end of the loop on edges
2415 } // end of processing for intermediary curves
2417 // storage in the DS of curves projected on several faces
2418 for (ic=0;ic<nedge;ic++) {
2419 if (moresurf.Value(ic) ){
2420 TopoDS_Vertex Vf,Vl;
2421 gp_Pnt Pf,Pl,P1,P2,Pcom;
2422 ind = 0; //must be initialized because of possible use, see L2249
2423 Standard_Real up1,up2;
2424 TopAbs_Orientation orvt;
2425 TopAbs_Orientation oredge = TopAbs_FORWARD;
2426 Standard_Integer indpoint1,indpoint2;
2427 Indices(nedge,ic,icplus,icmoins);
2428 Handle(Geom2d_Curve) proj,proj2d;
2429 Handle(Geom_Curve) projc,cproj;
2430 TopOpeBRepDS_Point& tpt1= DStr.ChangePoint(indpoint(ic,1));
2431 TopOpeBRepDS_Point& tpt2= DStr.ChangePoint(indpoint(icplus,0));
2432 tpt1.Tolerance (tpt1.Tolerance()+error);
2433 tpt2.Tolerance (tpt1.Tolerance()+error);
2434 for(nb=1;nb<=nbface;nb++) {
2435 orvt=TopAbs_REVERSED;
2436 Vf=TopExp::FirstVertex(TopoDS::Edge(Ecom.Value(nb)));
2437 Vl=TopExp::LastVertex (TopoDS::Edge(Ecom.Value(nb)));
2438 Pf=BRep_Tool::Pnt(Vf);
2439 Pl=BRep_Tool::Pnt(Vl);
2440 para=parcom.Value(nb);
2441 Pcom=BRep_Tool::Curve(TopoDS::Edge(Ecom.Value(nb)),up1,up2)->Value(para);
2442 if (Pf.Distance(BRep_Tool::Pnt(V1))< Pl.Distance(BRep_Tool::Pnt(V1)))
2443 orvt=TopAbs_FORWARD;
2444 if (!Eproj.Value(nb).IsNull()) {
2446 proj=BRep_Tool::CurveOnSurface(TopoDS::Edge(Eproj.Value(nb)),
2447 TopoDS::Face(Fproj.Value(nb)),up1,up2);
2448 proj2d=new Geom2d_TrimmedCurve(proj,up1,up2);
2449 projc=BRep_Tool::Curve(TopoDS::Edge(Eproj.Value(nb)),up1,up2);
2450 cproj=new Geom_TrimmedCurve(projc,up1,up2);
2451 pardeb=cproj->FirstParameter();
2452 parfin=cproj->LastParameter();
2453 P1=cproj->Value(pardeb);
2454 P2=cproj->Value(parfin);
2455 if (P1.Distance(tpt1.Point())<1.e-3)
2456 indpoint1=indpoint(ic,1);
2458 if (P2.Distance(tpt2.Point())<1.e-3)
2459 indpoint2=indpoint(icplus,0);
2461 TopOpeBRepDS_Point tpoint2 (P2,error);
2462 indpoint2= DStr.AddPoint(tpoint2);
2465 Handle (GeomAdaptor_HSurface) Asurf;
2466 Asurf = new GeomAdaptor_HSurface(BRep_Tool::Surface
2467 (TopoDS::Face(Fproj.Value(nb))));
2468 Handle (Geom2dAdaptor_HCurve) Acurv=new Geom2dAdaptor_HCurve(proj2d);
2469 Adaptor3d_CurveOnSurface CurvOnS (Acurv,Asurf);
2470 Handle(Adaptor3d_HCurveOnSurface) HCons =new Adaptor3d_HCurveOnSurface(CurvOnS);
2471 Order.SetValue(n3d,1);
2472 Handle(GeomPlate_CurveConstraint) Cont =
2473 new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolesp,angular,0.1);
2475 TopOpeBRepDS_Curve tcurv3d( cproj,error);
2476 indcurve3d.SetValue(n3d, DStr.AddCurve(tcurv3d));
2477 Interfp1=ChFi3d_FilPointInDS(TopAbs_FORWARD,indcurve3d.Value(n3d),
2479 Interfp2=ChFi3d_FilPointInDS(TopAbs_REVERSED,indcurve3d.Value(n3d),
2481 DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append(Interfp1);
2482 DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append(Interfp2);
2483 num=DStr.AddShape(Fproj.Value(nb));
2485 for(ex.Init(Fproj.Value(nb).Oriented(TopAbs_FORWARD),TopAbs_EDGE);
2486 ex.More(); ex.Next()){
2487 if(Ecom.Value(nb).IsSame(ex.Current())) {
2488 oredge = ex.Current().Orientation();
2493 //calculation of the orientation
2494 TopAbs_Orientation orinterf;
2495 if (P1.Distance(Pcom)>1.e-4) {
2496 if (orvt==TopAbs_FORWARD) {
2500 orinterf=TopAbs::Reverse(oredge);
2504 if (orvt==TopAbs_FORWARD) {
2505 orinterf=TopAbs::Reverse(oredge);
2511 Interfc=ChFi3d_FilCurveInDS(indcurve3d.Value(n3d),num,proj2d,orinterf);
2512 DStr.ChangeShapeInterferences(num).Append(Interfc);
2516 if (Eproj.Value(nb).IsNull()) indice=indpoint(ic,1);
2517 if (Eproj.Value(nb+1).IsNull()) indice=indpoint(icplus,0);
2518 Indice.SetValue(n3d,indice);
2519 Standard_Integer Iarc1=DStr.AddShape(TopoDS::Edge(Ecom.Value(nb)));
2520 Interfp1=ChFi3d_FilPointInDS(orvt,Iarc1,indice,parcom.Value(nb));
2521 DStr.ChangeShapeInterferences(Iarc1).Append(Interfp1);
2527 // case when two free borders are tangent
2529 for (ic=0;ic<nedge;ic++) {
2530 Handle(Geom_Curve) curve,ctrim,rcurve;
2531 Handle(Geom2d_Curve) curve2d,ctrim2d,rcurve2d;
2532 Standard_Real ufirst,ulast;
2533 Indices(nedge,ic,icplus,icmoins);
2534 Standard_Integer indpoint1,indpoint2;
2535 Standard_Boolean isvt1=Standard_False,isvt2=Standard_False;
2536 TopoDS_Edge ecur =TopoDS::Edge(Evive.Value(ic));
2537 if (ecur.IsSame(edgelibre1)|| ecur.IsSame(edgelibre2)) {
2539 curve2d=BRep_Tool::CurveOnSurface(TopoDS::Edge(Evive.Value(ic)),
2540 TopoDS::Face(Fvive.Value(ic,icplus)),ufirst,ulast);
2541 curve=BRep_Tool::Curve(TopoDS::Edge(Evive.Value(ic)),ufirst,ulast);
2542 if (TopExp::FirstVertex((TopoDS::Edge(Evive.Value(ic)))).IsSame (V1)) {
2543 ctrim=new Geom_TrimmedCurve(curve,ufirst,p.Value(ic,icmoins));
2544 ctrim2d=new Geom2d_TrimmedCurve(curve2d,ufirst,p.Value(ic,icmoins));
2545 indpoint1=DStr.AddShape(V1);
2547 indpoint2=indpoint(ic,1);
2550 ctrim=new Geom_TrimmedCurve(curve, p.Value(ic,icmoins),ulast);
2551 ctrim2d=new Geom2d_TrimmedCurve(curve2d,p.Value(ic,icmoins),ulast);
2552 indpoint2=DStr.AddShape(V1);
2554 indpoint1=indpoint(ic,1);
2556 if (libre.Value(ic)){
2557 if (TopExp::FirstVertex((TopoDS::Edge(Evive.Value(ic)))).IsSame(V1)) {
2560 indpoint2=DStr.AddShape(V1);
2563 indpoint1=indpoint(ic,1);
2567 if (TopExp::LastVertex((TopoDS::Edge(Evive.Value(ic)))).IsSame(V1)) {
2570 indpoint1=DStr.AddShape(V1);
2573 indpoint2=indpoint(ic,1);
2576 ufirst=ctrim->FirstParameter();
2577 ulast=ctrim->LastParameter();
2578 Handle (GeomAdaptor_HSurface) Asurf;
2579 Asurf = new GeomAdaptor_HSurface(BRep_Tool::Surface
2580 (TopoDS::Face(Fvive.Value(ic,icplus))));
2581 Handle (Geom2dAdaptor_HCurve) Acurv=new Geom2dAdaptor_HCurve(ctrim2d);
2582 Adaptor3d_CurveOnSurface CurvOnS (Acurv,Asurf);
2583 Handle(Adaptor3d_HCurveOnSurface) HCons =new Adaptor3d_HCurveOnSurface(CurvOnS);
2584 Order.SetValue(n3d,0);
2585 Handle(GeomPlate_CurveConstraint) Cont =
2586 new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolesp,angular,0.1);
2588 TopOpeBRepDS_Curve tcurv3d( ctrim,1.e-4);
2589 indcurve3d.SetValue(n3d, DStr.AddCurve(tcurv3d));
2590 Interfp1=ChFi3d_FilPointInDS(TopAbs_FORWARD,indcurve3d.Value(n3d),
2591 indpoint1,ufirst,isvt1);
2592 Interfp2=ChFi3d_FilPointInDS(TopAbs_REVERSED,indcurve3d.Value(n3d),
2593 indpoint2,ulast,isvt2);
2594 DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append(Interfp1);
2595 DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append(Interfp2);
2600 ChFi3d_InitChron(ch); // init performances for plate
2606 ChFi3d_ResultChron(ch, t_plate); //result performances for plate
2612 ChFi3d_InitChron(ch); // init performances for approxplate
2614 if (PSurf.IsDone()) {
2615 Standard_Integer nbcarreau=9;
2616 Standard_Integer degmax=8;
2617 Standard_Real seuil;
2618 Handle(GeomPlate_Surface) gpPlate = PSurf.Surface();
2620 TColgp_SequenceOfXY S2d;
2621 TColgp_SequenceOfXYZ S3d;
2624 PSurf.Disc2dContour(4,S2d);
2625 PSurf.Disc3dContour(4,0,S3d);
2626 seuil = Max(tolapp,10*PSurf.G0Error());
2627 GeomPlate_PlateG0Criterion critere (S2d,S3d,seuil);
2628 GeomPlate_MakeApprox Mapp(gpPlate,critere,tolapp,nbcarreau,degmax);
2629 Handle (Geom_Surface) Surf (Mapp.Surface());
2630 Standard_Real coef = 1.1 ,apperror;
2631 apperror=Mapp.CriterionError()*coef;
2634 ChFi3d_ResultChron(ch, t_approxplate); // result performances for approxplate
2637 // Storage of the surface plate and corresponding curves in the DS
2639 TopAbs_Orientation orplate,orsurfdata,orpcurve,orien;
2641 // Standard_Real ang1=PSurf.G1Error();
2643 // gp_Vec n1,n2,du,dv,du1,dv1;
2645 // Standard_Real tpar;
2647 // Standard_Real scal;
2649 TopOpeBRepDS_Surface Tsurf(Surf,Mapp.ApproxError());
2650 Standard_Integer Isurf=DStr.AddSurface(Tsurf);
2651 //lbo : historique QDF.
2652 if(!myEVIMap.IsBound(V1)){
2653 TColStd_ListOfInteger li;
2654 myEVIMap.Bind(V1,li);
2656 myEVIMap.ChangeFind(V1).Append(Isurf);
2658 Standard_Integer SolInd = CD.Value(0)->SolidIndex();
2659 TopOpeBRepDS_ListOfInterference& SolidInterfs =
2660 DStr.ChangeShapeInterferences(SolInd);
2662 // in case when one rereads at top, it is necessary that
2663 // alive edges that arrive at the top should be removed from the DS.
2664 // For this they are stored in the DS with their inverted orientation
2665 Standard_Integer nbedge;
2668 for (ic=0;ic<nedge;ic++) {
2669 if (!sharp.Value(ic)){
2670 nbedge = CD.Value(ic)->Spine()->NbEdges();
2671 TopoDS_Edge Arcspine;
2672 if (sens.Value(ic) ==1)
2673 Arcspine=CD.Value(ic) ->Spine()->Edges(1);
2675 Arcspine= CD.Value(ic)->Spine()->Edges(nbedge);
2676 Standard_Integer IArcspine = DStr.AddShape(Arcspine);
2678 TopAbs_Orientation OVtx = TopAbs_FORWARD;
2680 TopAbs_Orientation OVtx;
2682 for(ex.Init(Arcspine.Oriented(TopAbs_FORWARD),TopAbs_VERTEX);
2683 ex.More(); ex.Next()){
2684 if(V1.IsSame(ex.Current())) {
2685 OVtx = ex.Current().Orientation();
2689 OVtx = TopAbs::Reverse(OVtx);
2690 Standard_Real parVtx = BRep_Tool::Parameter(V1,Arcspine);
2691 Handle(TopOpeBRepDS_CurvePointInterference)
2692 interfv = ChFi3d_FilVertexInDS(OVtx,IArcspine,IVtx,parVtx);
2693 DStr.ChangeShapeInterferences(IArcspine).Append(interfv);
2697 // calculate orientation of Plate orplate corresponding to surfdata
2698 // calculation corresponding to the first stripe
2699 Indices(nedge,0,icplus,icmoins);
2700 isfirst=(sens.Value(0)==1);
2701 const Handle(ChFiDS_SurfData)& Fd =
2702 CD.Value(0)->SetOfSurfData()->Value(i.Value(0,icmoins));
2704 // Handle (Geom_Surface) surfdata = DStr.Surface(indice).Surface();
2705 // tpar= (CD.Value(0)->PCurve(isfirst)->FirstParameter()+
2706 // CD.Value(0)->PCurve(isfirst)->LastParameter())/2 ;
2707 // CD.Value(0)->PCurve(isfirst)->D0(tpar,uv);
2708 // surfdata->D1(uv.X(),uv.Y(),pp,du,dv);
2709 // tpar=(PSurf.Curves2d()->Value(1)->FirstParameter()+
2710 // PSurf.Curves2d()->Value(1)->LastParameter())/2;
2711 // (PSurf.Curves2d())->Value(1)->D0(tpar,uv);
2712 // Surf-> D1(uv.X(),uv.Y(),pp1,du1,dv1);
2713 // n1=du.Crossed(dv);
2714 // n2=du1.Crossed(dv1);
2715 // scal= n1.Dot(n2);
2716 orsurfdata=Fd->Orientation();
2717 // if (scal>0) orplate=orsurfdata;
2718 // else orplate=TopAbs::Reverse(orsurfdata);
2719 orplate = PlateOrientation(Surf,PSurf.Curves2d(),SumFaceNormalAtV1);
2721 // creation of solidinterderence for Plate
2722 Handle(TopOpeBRepDS_SolidSurfaceInterference) SSI =
2723 new TopOpeBRepDS_SolidSurfaceInterference(TopOpeBRepDS_Transition(orplate),
2726 TopOpeBRepDS_SURFACE,
2728 SolidInterfs.Append(SSI);
2730 // calculate orientation orien of pcurves of Plate
2731 // the curves from ic to icplus the pcurves of Plate
2732 // all have the same orientation
2733 Standard_Integer Ishape1,Ishape2;
2735 TopAbs_Orientation trafil1 = TopAbs_FORWARD, trafil2 = TopAbs_FORWARD;
2737 TopAbs_Orientation trafil1,trafil2;
2739 Ishape1 = Fd->IndexOfS1();
2740 Ishape2 = Fd->IndexOfS2();
2741 const ChFiDS_FaceInterference& Fi1 = Fd->InterferenceOnS1();
2742 const ChFiDS_FaceInterference& Fi2 = Fd->InterferenceOnS2();
2745 trafil1 = DStr.Shape(Ishape1).Orientation();
2747 trafil1 = TopAbs::Compose(trafil1,Fd->Orientation());
2748 trafil1 = TopAbs::Compose(TopAbs::Reverse(Fi1.Transition()),trafil1);
2749 trafil2 = TopAbs::Reverse(trafil1);
2753 trafil2 = DStr.Shape(Ishape2).Orientation();
2755 trafil2 = TopAbs::Compose(trafil2,Fd->Orientation());
2756 trafil2 = TopAbs::Compose(TopAbs::Reverse(Fi2.Transition()),trafil2);
2757 trafil1 = TopAbs::Reverse(trafil2);
2760 orpcurve=TopAbs::Reverse(trafil1);
2761 orpcurve= TopAbs::Compose(orpcurve,CD.Value(0)->FirstPCurveOrientation ()); }
2764 orpcurve= TopAbs::Compose(orpcurve,CD.Value(0)->LastPCurveOrientation ());
2766 if (orsurfdata==orplate)
2767 orien =TopAbs::Reverse(orpcurve);
2768 else orien=orpcurve;
2772 for (ic=0;ic<=nedge;ic++) {
2773 if (libre.Value(ic)) {
2774 Standard_Integer icplus21;
2775 Indices(nedge,ic,icplus,icmoins);
2776 Indices(nedge,icplus,icplus21,ic);
2778 Handle (Geom_Curve) C3d;
2779 Handle (Geom2d_Curve) C2d,curv2d;
2780 gp_Pnt ptic,pticplus;
2781 BRepAdaptor_Curve BCurv1(TopoDS::Edge(Evive.Value(ic)));
2782 BRepAdaptor_Curve BCurv2(TopoDS::Edge(Evive.Value(icplus)));
2783 Standard_Real par1=p.Value(ic,icplus);
2784 Standard_Real par2=p.Value(icplus,ic);
2785 BCurv1.D0(par1,ptic);
2786 BCurv2.D0(par2,pticplus);
2787 ParametrePlate(n3d,PSurf,Surf,ptic,apperror,UV1);
2788 ParametrePlate(n3d,PSurf,Surf,pticplus,apperror,UV2);
2789 Standard_Real to3d=1.e-3,to2d=1.e-6,tolreached;
2790 ChFiDS_CommonPoint CP1,CP2;
2791 CP1.SetArc(1.e-3, TopoDS::Edge(Evive.Value(ic)),par1,TopAbs_FORWARD);
2793 CP2.SetArc(1.e-3, TopoDS::Edge(Evive.Value(icplus)),par2,TopAbs_FORWARD);
2794 CP2.SetPoint(pticplus);
2795 Standard_Real param1,param2;
2796 ChFi3d_ComputeArete( CP1,UV1,CP2,UV2,Surf,C3d,C2d,param1,param2,
2797 to3d,to2d,tolreached,0);
2798 TopOpeBRepDS_Curve tcurv3d( C3d,tolreached);
2799 Standard_Integer ind1,ind2;
2800 ind1=indpoint(ic,0);
2801 ind2=indpoint(icplus,0);
2802 Standard_Integer indcurv=DStr.AddCurve(tcurv3d);
2803 Interfp1=ChFi3d_FilPointInDS(TopAbs_FORWARD,indcurv,ind1,param1);
2804 Interfp2=ChFi3d_FilPointInDS(TopAbs_REVERSED,indcurv,ind2,param2);
2805 DStr.ChangeCurveInterferences(indcurv).Append(Interfp1);
2806 DStr.ChangeCurveInterferences(indcurv).Append(Interfp2);
2807 Interfc=ChFi3d_FilCurveInDS(indcurv,Isurf,C2d,orien);
2808 DStr.ChangeSurfaceInterferences(Isurf).Append(Interfc);
2812 // stockage des courbes relatives aux stripes
2814 for (ic=0; ic<nedge ;ic++) {
2815 if (!sharp.Value(ic)) {
2817 Indices(nedge,ic,icplus,icmoins);
2819 isfirst=(sens.Value(ic)==1);
2820 // calculate curves interference relative to stripes
2822 apperror=Mapp.CriterionError()*coef;
2823 pardeb=CD.Value(ic)->PCurve(isfirst)->FirstParameter();
2824 parfin=CD.Value(ic)->PCurve(isfirst)->LastParameter();
2826 Interfp1=ChFi3d_FilPointInDS(TopAbs_FORWARD,indcurve3d.Value(n3d),
2827 indpoint.Value(ic,0),pardeb);
2828 Interfp2=ChFi3d_FilPointInDS(TopAbs_REVERSED,indcurve3d.Value(n3d),
2829 indpoint.Value(ic,1),parfin);
2830 DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append( Interfp1);
2831 DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append( Interfp2);
2832 TopOpeBRepDS_Curve& tcourb = DStr.ChangeCurve(indcurve3d.Value(n3d));
2834 tcourb.Tolerance(errapp.Value(ic)+apperror);
2835 TopOpeBRepDS_Point& tpt1= DStr.ChangePoint(indpoint(ic,0));
2836 TopOpeBRepDS_Point& tpt2= DStr.ChangePoint(indpoint(ic,1));
2837 tpt1.Tolerance (tpt1.Tolerance()+apperror);
2838 tpt2.Tolerance (tpt2.Tolerance()+apperror );
2840 // calculate surfaceinterference
2841 Interfc=ChFi3d_FilCurveInDS(indcurve3d.Value(n3d),Isurf,
2842 PSurf.Curves2d()->Value(n3d),orien);
2843 DStr.ChangeSurfaceInterferences(Isurf).Append(Interfc);
2844 regular.SetCurve(indcurve3d.Value(n3d));
2845 regular.SetS1(Isurf,Standard_False);
2846 indice=CD.Value(ic)->SetOfSurfData()->Value( i.Value(ic,icmoins))->Surf();
2847 regular.SetS2(indice,Standard_False);
2848 myRegul.Append(regular);
2852 // storage of connection curves
2854 for (ic=0; ic<nedge;ic++) {
2855 Indices(nedge,ic,icplus,icmoins);
2856 if (!oksea.Value(ic)) {
2857 if (sharp.Value(ic) &&!deuxconges) {
2858 // limitation of the alive edge
2859 TopAbs_Orientation ori;
2860 gp_Pnt Pf,Pl,sommet1;
2861 TopoDS_Vertex Vd = TopExp::FirstVertex(TopoDS::Edge(Evive.Value(ic)));
2862 TopoDS_Vertex Vf = TopExp::LastVertex(TopoDS::Edge(Evive.Value(ic)));
2863 Pf=BRep_Tool::Pnt(Vd);
2864 Pl=BRep_Tool::Pnt(Vf);
2865 sommet1=BRep_Tool::Pnt(V1);
2866 if (Pf.Distance(sommet1)<Pl.Distance(sommet1))
2867 ori = TopAbs_FORWARD;
2869 ori = TopAbs_REVERSED;
2870 Standard_Integer Iarc1=DStr.AddShape(TopoDS::Edge(Evive.Value(ic)));
2871 Interfp1=ChFi3d_FilPointInDS(ori,Iarc1,indpoint(ic,1),p.Value(ic,icplus));
2872 DStr.ChangeShapeInterferences(TopoDS::Edge(Evive.Value(ic))).Append(Interfp1);
2875 if (!ponctuel.Value(ic) && !libre.Value(ic)) {
2876 // actual connection
2877 if (!moresurf.Value(ic)){
2879 TopOpeBRepDS_Curve& tcourb1 = DStr.ChangeCurve(indcurve3d.Value(n3d));
2880 tcourb1.Tolerance(tcourb1.Tolerance()+apperror);
2882 TopOpeBRepDS_Point& tpt11= DStr.ChangePoint(indpoint(ic,1));
2883 TopOpeBRepDS_Point& tpt21= DStr.ChangePoint(indpoint(icplus,0));
2884 tpt11.Tolerance (tpt11.Tolerance()+apperror);
2885 tpt21.Tolerance (tpt21.Tolerance()+apperror );
2887 Interfc=ChFi3d_FilCurveInDS(indcurve3d.Value(n3d),Isurf,
2888 PSurf.Curves2d()->Value(n3d),orien);
2889 DStr.ChangeSurfaceInterferences(Isurf).Append(Interfc);
2890 if( Order.Value(n3d)==1) {
2891 regular.SetCurve(indcurve3d.Value(n3d));
2892 regular.SetS1(Isurf,Standard_False);
2893 regular.SetS2(numfa.Value(ic,icplus));
2894 myRegul.Append(regular);
2901 //storage of curves projected on several faces
2902 for (ic=0; ic<nedge;ic++) {
2903 Indices(nedge,ic,icplus,icmoins);
2905 for (nb=1;nb<=nbface;nb++){
2906 if (!Eproj.Value(nb).IsNull()) {
2908 TopOpeBRepDS_Curve& tcourb1 = DStr.ChangeCurve(indcurve3d.Value(n3d));
2909 tcourb1.Tolerance(tcourb1.Tolerance()+apperror);
2910 if(Indice.Value(n3d)!=0) {
2911 TopOpeBRepDS_Point& tpt11= DStr.ChangePoint(Indice.Value(n3d));
2912 tpt11.Tolerance (tpt11.Tolerance()+apperror);
2914 Interfc=ChFi3d_FilCurveInDS(indcurve3d.Value(n3d),Isurf,
2915 PSurf.Curves2d()->Value(n3d),orien);
2916 DStr.ChangeSurfaceInterferences(Isurf).Append(Interfc);
2917 if( Order.Value(n3d)==1) {
2918 regular.SetCurve(indcurve3d.Value(n3d));
2919 regular.SetS1(Isurf,Standard_False);
2920 regular.SetS2(DStr.AddShape(TopoDS::Face(Fproj.Value(nb))));
2921 myRegul.Append(regular);
2927 // storage of curves in case of tangent free borders
2929 for (ic=0; ic<nedge;ic++) {
2930 Indices(nedge,ic,icplus,icmoins);
2932 ecom=TopoDS::Edge(Evive.Value(ic));
2933 if (ecom.IsSame(edgelibre1)||ecom.IsSame(edgelibre2)) {
2935 TopOpeBRepDS_Curve& tcourb1 = DStr.ChangeCurve(indcurve3d.Value(n3d));
2936 tcourb1.Tolerance(tcourb1.Tolerance()+apperror);
2937 Interfc=ChFi3d_FilCurveInDS(indcurve3d.Value(n3d),Isurf,
2938 PSurf.Curves2d()->Value(n3d),orien);
2939 DStr.ChangeSurfaceInterferences(Isurf).Append(Interfc);
2943 else { // there is only one partial result
2944 done=Standard_False;
2945 hasresult=Standard_True;
2946 for (ic=0; ic<nedge;ic++) {
2947 Indices(nedge,ic,icplus,icmoins);
2948 if (!oksea.Value(ic)) {
2949 if (sharp.Value(ic) &&!deuxconges) {
2950 // limitation of the alive edge
2951 TopAbs_Orientation ori;
2952 gp_Pnt Pf,Pl,sommet1;
2953 TopoDS_Vertex Vd = TopExp::FirstVertex(TopoDS::Edge(Evive.Value(ic)));
2954 TopoDS_Vertex Vf = TopExp::LastVertex(TopoDS::Edge(Evive.Value(ic)));
2955 Pf=BRep_Tool::Pnt(Vd);
2956 Pl=BRep_Tool::Pnt(Vf);
2957 sommet1=BRep_Tool::Pnt(V1);
2958 if (Pf.Distance(sommet1)<Pl.Distance(sommet1))
2959 ori = TopAbs_FORWARD;
2961 ori = TopAbs_REVERSED;
2962 Standard_Integer Iarc1=DStr.AddShape(TopoDS::Edge(Evive.Value(ic)));
2963 Interfp1=ChFi3d_FilPointInDS(ori,Iarc1,indpoint(ic,1),p.Value(ic,icplus));
2964 DStr.ChangeShapeInterferences(TopoDS::Edge(Evive.Value(ic))).Append(Interfp1);