1 // Created on: 1995-07-04
2 // Created by: Stagiaire Flore Lantheaume
3 // Copyright (c) 1995-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
6 // This file is part of Open CASCADE Technology software library.
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
17 #include <StdFail_NotDone.hxx>
18 #include <Standard_ConstructionError.hxx>
19 #include <Standard_NotImplemented.hxx>
21 #include <TColStd_ListOfInteger.hxx>
22 #include <ChFi3d_ChBuilder.jxx>
23 #include <ChFi3d_Builder_0.hxx>
25 #include <ChFiKPart_ComputeData_Fcts.hxx>
27 #include <ChFiDS_HData.hxx>
28 #include <ChFiDS_ListIteratorOfListOfStripe.hxx>
29 #include <ChFiDS_Stripe.hxx>
30 #include <ChFiDS_Spine.hxx>
31 #include <ChFiDS_ChamfSpine.hxx>
32 #include <ChFiDS_SurfData.hxx>
33 #include <ChFiDS_Regul.hxx>
37 #include <gp_Pnt2d.hxx>
40 #include <gp_Vec2d.hxx>
41 #include <gp_Dir2d.hxx>
42 #include <gp_Lin2d.hxx>
44 #include <GeomAbs_SurfaceType.hxx>
45 #include <Geom_Curve.hxx>
46 #include <Geom2d_Curve.hxx>
47 #include <Geom_Surface.hxx>
48 #include <Geom_Plane.hxx>
49 #include <Geom2d_Line.hxx>
50 #include <Geom_Line.hxx>
51 #include <GeomAdaptor_HSurface.hxx>
53 #include <BRepAdaptor_Surface.hxx>
54 #include <Geom2dAdaptor_Curve.hxx>
55 #include <Geom2dAdaptor_HCurve.hxx>
56 #include <IntRes2d_IntersectionPoint.hxx>
57 #include <Geom2dInt_GInter.hxx>
59 #include <GeomInt_IntSS.hxx>
60 #include <GeomAdaptor_HCurve.hxx>
61 #include <Geom_TrimmedCurve.hxx>
62 #include <GeomAPI_ProjectPointOnSurf.hxx>
63 #include <GeomAPI_ProjectPointOnCurve.hxx>
65 #include <TopOpeBRepDS_HDataStructure.hxx>
67 #include <TopOpeBRepDS_DataStructure.hxx>
68 #include <BRepAdaptor_HSurface.hxx>
69 #include <BRep_Tool.hxx>
70 #include <BRepLib_MakeEdge.hxx>
72 #include <ProjLib_ProjectedCurve.hxx>
76 #include <IntCurveSurface_HInter.hxx>
77 #include <IntCurveSurface_IntersectionPoint.hxx>
80 #include <Precision.hxx>
85 //=======================================================================
87 //purpose : Sert a savoir si 4 points sont coplanaires, pour cela on calcul
88 // la distance de PntD par rapport au plan passant par les trois
89 // points PntA, PntB, PntC
90 //=======================================================================
92 static int CoPlanar(const gp_Pnt PntA,
97 Standard_Boolean IsCoplanar;
99 gp_Vec vecAB(PntA, PntB);
100 gp_Vec vecAC(PntA, PntC);
101 gp_Vec vecAD(PntA, PntD);
103 Standard_Real nor2AB = vecAB.SquareMagnitude();
104 Standard_Real nor2AC = vecAC.SquareMagnitude();
105 Standard_Real ProABAC = vecAB.Dot(vecAC);
108 Standard_Real Alpha = nor2AB * nor2AC - ProABAC * ProABAC;
110 if (Alpha < Precision::Confusion()) {
111 IsCoplanar = Standard_True;
114 Standard_Real ProABAD = vecAB.Dot(vecAD);
115 Standard_Real ProACAD = vecAC.Dot(vecAD);
116 Standard_Real Alpha1 = ProABAD * nor2AC - ProABAC * ProACAD;
117 Standard_Real Alpha2 = ProACAD * nor2AB - ProABAC * ProABAD;
118 gp_Vec vecDABC = Alpha1 * vecAB + Alpha2 * vecAC - Alpha * vecAD;
120 IsCoplanar = (vecDABC.Magnitude() / Alpha < Precision::Confusion() );
130 //=======================================================================
131 //function : BoundSurf
132 //purpose : computes a GeomAdaptor_Surface from the surface and trims
133 // it to allow the intersection computation
134 //=======================================================================
136 static Handle(GeomAdaptor_HSurface) BoundSurf(const Handle(Geom_Surface)& S,
137 const gp_Pnt2d& Pdeb,
138 const gp_Pnt2d& Pfin)
140 Handle(GeomAdaptor_HSurface) HS = new GeomAdaptor_HSurface();
141 GeomAdaptor_Surface& GAS = HS->ChangeSurface();
144 Standard_Real uu1,uu2,vv1,vv2;
145 Standard_Real uuu1,uuu2,vvv1,vvv2;
146 S->Bounds(uuu1,uuu2,vvv1,vvv2);
147 ChFi3d_Boite(Pdeb,Pfin,uu1,uu2,vv1,vv2);
148 Standard_Real Step = Max((uu2-uu1),(vv2-vv1));
150 uuu1 = Max((uu1-Step),uuu1); uuu2 = Min((uu2+Step),uuu2);
151 vvv1 = Max((vv1-Step),vvv1); vvv2 = Min((vv2+Step),vvv2);
152 GAS.Load(S,uuu1,uuu2,vvv1,vvv2);
156 //=======================================================================
157 //function : ComputeIntersection
158 //purpose : compute the 3d curve <gc> and the pcurves <pc1> and <pc2>
159 // of the intersection between one of the 3 SurfData <SD> and
160 // the SurfData of the corner <SDCoin>. Here we know the
161 // extremities of the intersection <pdeb> and <pfin>, and
162 // their parameters <p2dfin>, <p2ddeb> on <SD>.
163 // <ptcoindeb> cointains the intersection 2d point on the corner
164 // which corresponds to the point <pdeb>
165 // <derudeb> and <dervdeb> are the derivative vectors on the
166 // SurfData <SD> at the point <ptdeb>
167 //=======================================================================
169 static Standard_Boolean ComputeIntersection(TopOpeBRepDS_DataStructure& DStr,
170 const Handle(ChFiDS_SurfData)& SD,
171 const Handle(ChFiDS_SurfData)& SDCoin,
173 const gp_Pnt2d& p2ddeb,
175 const gp_Pnt2d& p2dfin,
176 Handle(Geom_Curve)& gc,
177 Handle(Geom2d_Curve)& pc1,
178 Handle(Geom2d_Curve)& pc2,
182 const Standard_Real tol3d,
183 const Standard_Real tol2d,
184 Standard_Real& tolreached)
186 // gp_Pnt2d UVf1,UVf2,UVl1,UVl2;
188 // take the surface of the pivot SurfData and trim it to allow
189 // the intersection computation if it's an analytic surface
190 Handle(GeomAdaptor_HSurface) HS1;
191 HS1 = ChFi3d_BoundSurf(DStr,SD,1,2);
193 const Handle(Geom_Surface)& gpl = DStr.Surface(SDCoin->Surf()).Surface();
194 const Handle(Geom_Surface)& gSD = DStr.Surface(SD->Surf()).Surface();
197 TColStd_Array1OfReal Pardeb(1,4),Parfin(1,4);
202 gSD->D1(u,v,Pbidon,derudeb,dervdeb);
205 // gp_Pnt2d pd2(u,v);
207 ChFi3d_Parameters(gpl,pdeb,u,v);
210 ptcoindeb.SetCoord(u,v);
217 // gp_Pnt2d pf2(u,v);
219 ChFi3d_Parameters(gpl,pfin,u,v);
224 // Trims the chamfer surface to allow the intersection computation
225 // and computes a GeomAdaptor_Surface for using the ComputeCurves
227 Handle(GeomAdaptor_HSurface) HS2;
228 HS2 = BoundSurf(gpl,ptcoindeb,cpf2);
230 // compute the intersection curves and pcurves
231 return ChFi3d_ComputeCurves(HS1,HS2,Pardeb,Parfin,gc,
232 pc1,pc2,tol3d,tol2d,tolreached);
235 //======================================================================
236 // function : PerformThreeCorner
237 // purpose : compute the intersection of three chamfers on a same
238 // vertex of index <Jndex> in myVDataMap
239 //======================================================================
241 void ChFi3d_ChBuilder::PerformThreeCorner(const Standard_Integer Jndex)
244 //modifier pour le passer en option dans le cdl!!!!!!!!!!!!
245 Standard_Boolean issmooth = Standard_False;
247 TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
248 const TopoDS_Vertex& Vtx = myVDataMap.FindKey(Jndex);
249 ChFiDS_ListIteratorOfListOfStripe It;
250 // Standard_Integer Index[3],pivot,deb,fin,ii,jj,kk;
251 Standard_Integer Index[3],pivot=0,deb=0,fin=0,ii;
252 Handle(ChFiDS_Stripe) CD[3];
254 Standard_Integer jf[3][3];
255 Standard_Boolean sameside[3], oksea[3];
256 for(Standard_Integer g = 0; g <= 2; g++){oksea[g] = Standard_False;}
257 Standard_Integer i[3][3];
258 Standard_Integer sens[3];
259 Standard_Real p[3][3];
261 Standard_Boolean c1triangle = Standard_False;
263 for (It.Initialize(myVDataMap(Jndex)),ii=0;It.More() && ii<3;It.Next(),ii++){
264 Index[ii] = ChFi3d_IndexOfSurfData(Vtx,It.Value(),sens[ii]);
267 // On verifie que l une des CD ne figure pas deux fois, au quel cas
268 // il faut modifier le retour de IndexOfSurfData qui prend la
269 // premiere des solutions.
271 Index[1] = CD[1]->SetOfSurfData()->Length();
274 else if(CD[1] == CD[2]){
275 Index[2] = CD[2]->SetOfSurfData()->Length();
278 else if(CD[0] == CD[2]){
279 Index[2] = CD[2]->SetOfSurfData()->Length();
282 oksea[2] = ChFi3d_SearchFD(DStr,CD[0],CD[1],sens[0],sens[1],i[0][1],i[1][0],
283 p[0][1],p[1][0],Index[0],Index[1],face[2],sameside[2],
285 oksea[1] = ChFi3d_SearchFD(DStr,CD[0],CD[2],sens[0],sens[2],i[0][2],i[2][0],
286 p[0][2],p[2][0],Index[0],Index[2],face[1],sameside[1],
288 oksea[0] = ChFi3d_SearchFD(DStr,CD[1],CD[2],sens[1],sens[2],i[1][2],i[2][1],
289 p[1][2],p[2][1],Index[1],Index[2],face[0],sameside[0],
292 // Analyse des concavites des 3 chanfreins :
293 // - 2 concavites identiques et 1 inverse.
294 // - 3 concavites identiques
296 Standard_Boolean CornerAllSame = Standard_False;
297 Standard_Boolean okinter = Standard_True;
298 Standard_Boolean visavis;
300 if(oksea[2] && oksea[1] && !sameside[2] && !sameside[1]) {
301 pivot = 0; deb = 1; fin = 2;
302 //on calcule l'intersection des pcurves sans les restreindre a leur common point
304 okinter = ChFi3d_IsInFront(DStr,CD[1],CD[2],i[1][2],i[2][1],sens[1],sens[2],
305 p[1][2],p[2][1],face[0],sameside[0],
306 jf[1][2],jf[2][1],visavis,Vtx,Standard_False,1);
308 else if(oksea[2] && oksea[0] && !sameside[2] && !sameside[0]) {
309 pivot = 1; deb = 2; fin = 0;
311 okinter = ChFi3d_IsInFront(DStr,CD[0],CD[2],i[0][2],i[2][0],sens[0],sens[2],
312 p[0][2],p[2][0],face[1],sameside[1],
313 jf[0][2],jf[2][0],visavis,Vtx,Standard_False,1);
315 else if(oksea[1] && oksea[0] && !sameside[1] && !sameside[0]) {
316 pivot = 2; deb = 0; fin = 1;
318 okinter = ChFi3d_IsInFront(DStr,CD[0],CD[1],i[0][1],i[1][0],sens[0],sens[1],
319 p[0][1],p[1][0],face[2],sameside[2],
320 jf[0][1],jf[1][0],visavis,Vtx,Standard_False,1);
322 else if(oksea[0] && oksea[1] && oksea[2]){
323 // 3 concavites identiques.
324 pivot = ChFi3d_SearchPivot(sens,p,tol2d);
326 // on prend un pivot au hasard!!!!!!!!!!!!!!!
328 deb = (pivot+1)%3 ; fin = (pivot+2)%3;
329 CornerAllSame = Standard_True;
331 else Standard_Failure::Raise("FD en vis a vis non trouvees");
333 Standard_Failure::Raise("Echec intersection PCurves OnCommonFace");
335 // on a le pivot, le CD deb et le CD fin (enfin on espere !?!) :
336 // -------------------------------------------------------------
338 /* Remarque Importante : dans le cas ou les indices des Surf data
339 du pivot sur lesquelles ont ete trouvees les intersections de pcurves
340 ne sont pas egaux, il va y avoir changement de Surf data lors du
341 cheminement et creations de Surf data mutantes a 3 ou 5 cotes!!!
342 NON TRAITE !!!!!! (pour l instant)*/
343 if(i[pivot][deb] != i[pivot][fin]){
344 Standard_NotImplemented::Raise("coin mutant non programme");
346 /* Autre Remarque : dans le cas ou les indices des Surf data
347 du deb (de la fin) sur lesquelles ont ete trouvees les intersections
348 de pcurves ne sont pas egaux, il va y avoir changement de face lors du
349 cheminement NON GERE !!!!!! (pour l instant). Prevoir un
350 PerformSetOfSurf adapte.*/
352 (i[deb][pivot] != i[deb][fin] || i[fin][pivot] != i[fin][deb])){
353 Standard_NotImplemented::Raise("coin sur plusieurs faces non programme");
356 Handle(ChFiDS_SurfData)&
357 fddeb = CD[deb]->ChangeSetOfSurfData()->ChangeValue(i[deb][pivot]);
358 Handle(ChFiDS_SurfData)&
359 fdfin = CD[fin]->ChangeSetOfSurfData()->ChangeValue(i[fin][pivot]);
360 Handle(ChFiDS_SurfData)&
361 fdpiv = CD[pivot]->ChangeSetOfSurfData()->ChangeValue(i[pivot][deb]);
364 // On construit les HSurfaces et autres outils qui vont bien.
365 // ----------------------------------------------------------
367 Handle(BRepAdaptor_HSurface) Fac = new BRepAdaptor_HSurface(face[pivot]);
368 Handle(GeomAdaptor_HSurface)
369 bidsurf = new GeomAdaptor_HSurface(Fac->ChangeSurface().Surface());
370 Handle(Adaptor3d_TopolTool) IFac = new Adaptor3d_TopolTool(bidsurf);
372 Handle(GeomAdaptor_HSurface) Surf = ChFi3d_BoundSurf (DStr,fdpiv,jf[pivot][deb],jf[pivot][fin]);
373 Handle(Adaptor3d_TopolTool) ISurf = new Adaptor3d_TopolTool(Surf);
375 // Creation of a new Stripe for the corner
376 Handle(ChFiDS_Stripe) corner = new ChFiDS_Stripe();
377 Handle(ChFiDS_HData)& cornerset = corner->ChangeSetOfSurfData();
378 cornerset = new ChFiDS_HData();
379 Handle(ChFiDS_SurfData) coin = new ChFiDS_SurfData();
380 cornerset->Append(coin);
382 // Pour plus de surete, on verifie les intersections des pcurves des chanfreins sur leur
384 Handle(GeomAdaptor_HSurface) HSdeb
385 = new GeomAdaptor_HSurface( GeomAdaptor_Surface(DStr.Surface(fddeb->Surf()).Surface()) );
386 Handle(GeomAdaptor_HSurface) HSfin
387 = new GeomAdaptor_HSurface( GeomAdaptor_Surface(DStr.Surface(fdfin->Surf()).Surface()) );
388 Handle(GeomAdaptor_HSurface) HSpiv
389 = new GeomAdaptor_HSurface( GeomAdaptor_Surface(DStr.Surface(fdpiv->Surf()).Surface()) );
394 ChFi3d_ComputesIntPC (fdpiv->Interference(jf[pivot][deb]),fddeb->Interference(jf[deb][pivot]),
395 HSpiv,HSdeb,p[pivot][deb],p[deb][pivot], p3d[fin]);
396 ChFi3d_ComputesIntPC (fdpiv->Interference(jf[pivot][fin]),fdfin->Interference(jf[fin][pivot]),
397 HSpiv,HSfin,p[pivot][fin],p[fin][pivot], p3d[deb]);
398 ChFi3d_ComputesIntPC (fddeb->Interference(jf[deb][fin]),fdfin->Interference(jf[fin][deb]),
399 HSdeb,HSfin,p[deb][fin],p[fin][deb], PSom);
403 // On determine les extremites du coin
404 //------------------------------------
405 // c1triangle : on n'a besoin que des 3 points intersection des 3 chanfreins
406 // sinon : on a les 2 points intersection de fdpiv avec fddeb et fdfin, et on
407 // cree 2 autres points sur la face commune a l'aide des deux premiers
409 // p2d[deb] et p2d[fin] sur la surface du chanfrein fdpiv.
410 // p2d[piv], p2d[3] (confondus si c1triangle) sur la face en bout du chanfrein de fdpiv
411 // p2d[piv](resp.vp2d[3]) est sur la Uiso de fddeb(resp. fdfin) passant par p2d[deb]
414 // if (CornerAllSame)
415 // c1triangle = (Abs(p[deb][pivot]-p[deb][fin])<tolesp &&
416 // Abs(p[fin][pivot]-p[fin][deb])<tolesp);
421 // p2d[pivot] = fddeb->Interference(jf[deb][fin]).PCurveOnFace()->Value(p[deb][pivot]);
424 fddeb->Interference(jf[deb][fin]).PCurveOnFace()->D1(p[deb][pivot],p2d[pivot],Tgpiv);
425 fdfin->Interference(jf[fin][deb]).PCurveOnFace()->D1(p[fin][pivot],p2d[3],Tg3);
428 p2d[pivot] = fddeb->Interference(jf[deb][fin]).PCurveOnFace()->Value(p[deb][pivot]);
429 p2d[3] = fdfin->Interference(jf[fin][deb]).PCurveOnFace()->Value(p[fin][pivot]);
432 p2d[fin] = fdpiv->Interference(jf[pivot][deb]).PCurveOnSurf()->Value(p[pivot][deb]);
433 p2d[deb] = fdpiv->Interference(jf[pivot][fin]).PCurveOnSurf()->Value(p[pivot][fin]);
438 // p3d[fin] = HSpiv->Value(p2d[fin].X(),p2d[fin].Y());
439 // p3d[deb] = HSpiv->Value(p2d[deb].X(),p2d[deb].Y());
440 Fac->D1(p2d[pivot].X(),p2d[pivot].Y(),p3d[pivot],deru,derv);
441 gp_Vec norpl = deru.Crossed(derv);
443 p3d[3] = Fac->Value(p2d[3].X(),p2d[3].Y());
445 Standard_Real DistMin = (p3d[3]).Distance(p3d[fin]);
446 Standard_Real DistTmp = (p3d[pivot]).Distance(p3d[deb]);
447 Standard_Real DistDebFin = (p3d[pivot]).Distance(p3d[3]);
449 if (DistTmp > DistMin) DistMin = DistTmp;
451 // on elargi la notion de triangle pour eviter de creer
452 // des surfaces ecraser avec deux coins proches
453 // attention ceci entraine un effet de seuil
455 c1triangle = (DistDebFin < 0.3 * DistMin);
461 // on calcule la surface portant le coin
462 //--------------------------------------
463 // Si c1triangle ou les 4 points p3d sont coplanaires, alors
464 // le chanfrein est porte par le plan passant par les 3 premiers p3d.
465 // Sinon, on construit le chanfrein par la methode GeomFill_ConstrainedFilling
466 Standard_Boolean c1plan = c1triangle;
467 gp_Vec v1(p3d[pivot],p3d[deb]);
468 gp_Vec v2(p3d[pivot],p3d[fin]);
469 gp_Vec nor = v1.Crossed(v2);
471 done = Standard_False;
473 Standard_Integer Icf=0,Icl=0;
474 Handle(Geom2d_Curve) debpc1,finpc1;
477 c1plan = CoPlanar(p3d[0], p3d[1], p3d[2], p3d[3]);
484 // on construit le plan
486 // gp_Dir xdir(gp_Vec(p3d[fin],p3d[deb]));
487 gp_Dir xdir = gp_Dir(gp_Vec(p3d[fin],p3d[deb]));
488 gp_Ax3 planAx3(p3d[pivot],ndir,xdir);
489 if (planAx3.YDirection().Dot(v1)<=0.)
491 Handle(Geom_Plane) gpl= new Geom_Plane(planAx3);
492 coin->ChangeSurf(ChFiKPart_IndexSurfaceInDS(gpl,DStr));
495 gp_Vec norface = norpl;
496 if (face[pivot].Orientation() == TopAbs_REVERSED )
498 gp_Vec norcoin = gpl->Pln().Position().XDirection().
499 Crossed (gpl->Pln().Position().YDirection());
500 if ( norcoin.Dot(norface) <= 0. )
501 coin->ChangeOrientation() = TopAbs_REVERSED;
503 coin->ChangeOrientation() = TopAbs_FORWARD;
505 // on calcule les intersections
506 Handle(Geom_Curve) gcpiv,gcdeb,gcfin;
507 Handle(Geom_TrimmedCurve) gcface;
508 Handle(Geom2d_Curve) pivpc1,pivpc2,debpc2,finpc2,facepc1,facepc2;
511 //intersection coin-pivot
512 Standard_Real tolrcoinpiv;
513 if (!ComputeIntersection(DStr,fdpiv,coin,
514 p3d[fin],p2d[fin],p3d[deb],p2d[deb],
515 gcpiv,pivpc1,pivpc2,deru,derv,ptbid,
516 tolesp,tol2d,tolrcoinpiv))
517 StdFail_NotDone::Raise("echec calcul intersection coin-pivot");
518 gp_Vec norpiv = deru.Crossed(derv);
520 //intersection coin-deb
521 Standard_Real tolrcoindeb;
524 p2d1 = fddeb->Interference(jf[deb][fin]).PCurveOnSurf()->Value(p[deb][fin]);
526 p2d1 = fddeb->Interference(jf[deb][fin]).PCurveOnSurf()->Value(p[deb][pivot]);
528 p2d2 = fddeb->Interference(jf[deb][pivot]).PCurveOnSurf()->Value(p[deb][pivot]);
530 if (!ComputeIntersection(DStr,fddeb,coin,
531 p3d[pivot],p2d1,p3d[fin],p2d2,
532 gcdeb,debpc1,debpc2,deru,derv,ptbid,
533 tolesp,tol2d,tolrcoindeb))
534 StdFail_NotDone::Raise("echec calcul intersection coin-deb");
535 Icf = DStr.AddCurve(TopOpeBRepDS_Curve(gcdeb,tolrcoindeb));
537 //intersection coin-fin
538 Standard_Real tolrcoinfin;
541 p3dface = p3d[pivot];
542 p2d1 = fdfin->Interference(jf[fin][deb]).PCurveOnSurf()->Value(p[fin][deb]);
546 p2d1 = fdfin->Interference(jf[fin][deb]).PCurveOnSurf()->Value(p[fin][pivot]);
548 p2d2 = fdfin->Interference(jf[fin][pivot]).PCurveOnSurf()->Value(p[fin][pivot]);
549 if (!ComputeIntersection(DStr,fdfin,coin,
550 p3dface,p2d1,p3d[deb],p2d2,
551 gcfin,finpc1,finpc2,deru,derv,ptbid,
552 tolesp,tol2d,tolrcoinfin))
553 StdFail_NotDone::Raise("echec calcul intersection coin-face");
554 Icl = DStr.AddCurve(TopOpeBRepDS_Curve(gcfin,tolrcoinfin));
556 //!c1triangle: intersection coin-face[pivot]
559 BRepAdaptor_Surface facebid(face[pivot]);
561 surfbid = Handle(Geom_Surface)::DownCast(facebid.Surface().Surface()->Transformed(facebid.Trsf()));
562 inter.Perform(gpl,surfbid,Precision::Intersection());
563 if (inter.IsDone()) {
564 Standard_Integer nbl = inter.NbLines();
567 cout<<"trop d'intersection entre les surfaces"<<endl;
571 ChFi3d_TrimCurve(inter.Line(1),p3d[pivot],p3dface,gcface);
573 Handle(GeomAdaptor_HCurve) gac = new GeomAdaptor_HCurve();
574 gac->ChangeCurve().Load(gcface);
575 Handle(GeomAdaptor_HSurface) gas = new GeomAdaptor_HSurface;
576 gas->ChangeSurface().Load(gpl);
577 Handle(BRepAdaptor_HSurface) gaf = new BRepAdaptor_HSurface;
578 gaf->ChangeSurface().Initialize(face[pivot]);
581 ChFi3d_ProjectPCurv(gac,gaf,facepc1,tolesp,tolr);
582 ChFi3d_ProjectPCurv(gac,gas,facepc2,tolesp,tolr);
587 // on remplit les donnees du coin oriente face-pivot
588 TopAbs_Orientation trans;
590 //avec les CommonPoints
591 coin->ChangeVertexFirstOnS1().SetPoint(p3d[pivot]);
592 coin->ChangeVertexFirstOnS2().SetPoint(p3d[fin]);
594 coin->ChangeVertexLastOnS1().SetPoint(p3d[pivot]);
596 coin->ChangeVertexLastOnS1().SetPoint(p3d[3]);
597 coin->ChangeVertexLastOnS2().SetPoint(p3d[deb]);
599 //avec les FaceInterference
600 // Standard_Integer Igcpiv,Igcdeb,Igcfin,Igcface;
601 Standard_Integer Igcpiv,Igcface;
602 ChFiDS_FaceInterference& fi1 = coin->ChangeInterferenceOnS1();
603 ChFiDS_FaceInterference& fi2 = coin->ChangeInterferenceOnS2();
606 if (norcoin.Dot(norpl) <= 0.)
607 trans = TopAbs_FORWARD;
609 trans = TopAbs_REVERSED;
610 Handle(Geom2d_Curve) bidpc;
612 fi1.SetInterference(0,trans,bidpc,bidpc);
614 Igcface = ChFiKPart_IndexCurveInDS(gcface,DStr);
615 fi1.SetInterference(Igcface,trans,facepc1,facepc2);
616 fi1.SetFirstParameter(gcface->FirstParameter());
617 fi1.SetLastParameter(gcface->LastParameter());
620 if (norcoin.Dot(norpiv) <= 0.)
621 trans = TopAbs_REVERSED;
623 trans = TopAbs_FORWARD;
624 Igcpiv = ChFiKPart_IndexCurveInDS(gcpiv,DStr);
625 fi2.SetInterference(Igcpiv,trans,pivpc1,pivpc2);
626 fi2.SetFirstParameter(gcpiv->FirstParameter());
627 fi2.SetLastParameter(gcpiv->LastParameter());
629 done = Standard_True;
636 Handle(Geom_Surface) Surfcoin;
637 Handle(Geom2d_Curve) PCurveOnFace,PCurveOnPiv;
639 // le contour a remplir est constitue de courbes isos sur deb et fin
640 // de deux pcurves calculees sur piv et la face opposee.
641 Handle(GeomFill_Boundary) Bdeb,Bfin,Bpiv,Bfac;
642 Standard_Integer ind1 = fddeb->Interference(jf[deb][pivot]).LineIndex();
643 Standard_Integer ind2 = fdfin->Interference(jf[fin][pivot]).LineIndex();
647 DStr.Curve(ind1).Curve()->D1(p[deb][pivot],Pfin,vpfin);
648 DStr.Curve(ind2).Curve()->D1(p[fin][pivot],Pdeb,vpdeb);
651 // les bords de coin sont des lignes courbes qui suivent les
653 Bfac = ChFi3d_mkbound(Fac,PCurveOnFace,sens[deb],p2d[pivot],Tgpiv,
654 sens[fin],p2d[3],Tg3,tolesp,2.e-4);
655 Bpiv = ChFi3d_mkbound(Surf,PCurveOnPiv,sens[deb],p2d[fin],vpfin,
656 sens[fin],p2d[deb],vpdeb,tolesp,2.e-4);
659 // les bords de coin sont des segments
660 // Bfac = ChFi3d_mkbound(Fac,PCurveOnFace,p2d[pivot],
661 // p2d[3],tolesp,2.e-4);
662 Bfac = ChFi3d_mkbound(Fac,PCurveOnFace,p2d[pivot],
663 p2d[3],tolesp,2.e-4);
664 Bpiv = ChFi3d_mkbound(Surf,PCurveOnPiv,p2d[fin],
665 p2d[deb],tolesp,2.e-4);
668 gp_Pnt2d pdeb1 = fddeb->Interference(jf[deb][pivot]).PCurveOnSurf()->Value(p[deb][pivot]);
669 gp_Pnt2d pdeb2 = fddeb->Interference(jf[deb][fin]).PCurveOnSurf()->Value(p[deb][pivot]);
670 gp_Pnt2d pfin1 = fdfin->Interference(jf[fin][pivot]).PCurveOnSurf()->Value(p[fin][pivot]);
671 gp_Pnt2d pfin2 = fdfin->Interference(jf[fin][deb]).PCurveOnSurf()->Value(p[fin][pivot]);
674 // il faut homogeneiser, mettre les bords "BoundWithSurf"
675 Bdeb = ChFi3d_mkbound(DStr.Surface(fddeb->Surf()).Surface(),pdeb1,pdeb2,tolesp,2.e-4);
676 Bfin = ChFi3d_mkbound(DStr.Surface(fdfin->Surf()).Surface(),pfin1,pfin2,tolesp,2.e-4);
679 // ou les 4 bords de type "FreeBoundary"
680 Bdeb = ChFi3d_mkbound(DStr.Surface(fddeb->Surf()).Surface(),pdeb1,pdeb2,
681 tolesp,2.e-4,Standard_True);
682 Bfin = ChFi3d_mkbound(DStr.Surface(fdfin->Surf()).Surface(),pfin1,pfin2,
683 tolesp,2.e-4,Standard_True);
685 GeomFill_ConstrainedFilling fil(8,20);
686 fil.Init(Bpiv,Bfin,Bfac,Bdeb);
688 Surfcoin = fil.Surface();
689 // on se ramene au sens face surf: S1 = face, S2 = surf
690 Surfcoin->VReverse();
692 done = CompleteData(coin,Surfcoin,
694 Surf,PCurveOnPiv,fdpiv->Orientation(),0,
697 Standard_Real P1deb,P2deb,P1fin,P2fin;
700 Standard_Integer If1,If2,Il1,Il2;
702 // Mise a jour des 4 Stripes et de la DS
703 // -------------------------------------
705 const ChFiDS_CommonPoint& Pf1 = coin->VertexFirstOnS1();
706 const ChFiDS_CommonPoint& Pf2 = coin->VertexFirstOnS2();
707 ChFiDS_CommonPoint& Pl1 = coin->ChangeVertexLastOnS1();
709 Pl1 = coin->ChangeVertexFirstOnS1();
710 const ChFiDS_CommonPoint& Pl2 = coin->VertexLastOnS2();
712 // le coin pour commencer,
713 // -----------------------
714 ChFiDS_Regul regdeb, regfin;
715 If1 = ChFi3d_IndexPointInDS(Pf1,DStr);
716 If2 = ChFi3d_IndexPointInDS(Pf2,DStr);
720 Il1 = ChFi3d_IndexPointInDS(Pl1,DStr);
721 Il2 = ChFi3d_IndexPointInDS(Pl2,DStr);
723 coin->ChangeIndexOfS1(DStr.AddShape(face[pivot]));
724 coin->ChangeIndexOfS2(-fdpiv->Surf());
729 P1deb = DStr.Curve(Icf).Curve()->FirstParameter();
730 P2deb = DStr.Curve(Icf).Curve()->LastParameter();
733 pp1 = coin->InterferenceOnS1().PCurveOnSurf()->
734 Value(coin->InterferenceOnS1().FirstParameter());
735 pp2 = coin->InterferenceOnS2().PCurveOnSurf()->
736 Value( coin->InterferenceOnS2().FirstParameter());
737 Handle(Geom_Curve) C3d;
738 Standard_Real tolreached;
739 ChFi3d_ComputeArete(Pf1,pp1,Pf2,pp2,
740 DStr.Surface(coin->Surf()).Surface(),C3d,
741 corner->ChangeFirstPCurve(),P1deb,P2deb,
742 tolesp,tol2d,tolreached,0);
743 TopOpeBRepDS_Curve Tcurv(C3d,tolreached);
744 Icf = DStr.AddCurve(Tcurv);
747 regdeb.SetCurve(Icf);
748 regdeb.SetS1(coin->Surf(),0);
749 regdeb.SetS2(fddeb->Surf(),0);
750 myRegul.Append(regdeb);
751 corner->ChangeFirstCurve(Icf);
752 corner->ChangeFirstParameters(P1deb,P2deb);
753 corner->ChangeIndexFirstPointOnS1(If1);
754 corner->ChangeIndexFirstPointOnS2(If2);
758 P1fin = DStr.Curve(Icl).Curve()->FirstParameter();
759 P2fin = DStr.Curve(Icl).Curve()->LastParameter();
762 pp1 = coin->InterferenceOnS1().PCurveOnSurf()->
763 Value(coin->InterferenceOnS1().LastParameter());
764 pp2 = coin->InterferenceOnS2().PCurveOnSurf()->
765 Value(coin->InterferenceOnS2().LastParameter());
766 Handle(Geom_Curve) C3d;
767 Standard_Real tolreached;
768 ChFi3d_ComputeArete(Pl1,pp1,Pl2,pp2,
769 DStr.Surface(coin->Surf()).Surface(),C3d,
770 corner->ChangeLastPCurve(),P1fin,P2fin,
771 tolesp,tol2d,tolreached,0);
772 TopOpeBRepDS_Curve Tcurv(C3d,tolreached);
773 Icl = DStr.AddCurve(Tcurv);
775 regfin.SetCurve(Icl);
776 regfin.SetS1(coin->Surf(),0);
777 regfin.SetS2(fdfin->Surf(),0);
778 myRegul.Append(regfin);
779 corner->ChangeLastCurve(Icl);
780 corner->ChangeLastParameters(P1fin,P2fin);
781 corner->ChangeIndexLastPointOnS1(Il1);
782 corner->ChangeIndexLastPointOnS2(Il2);
784 // puis la CornerData du debut,
785 // ----------------------------
786 Standard_Boolean isfirst = (sens[deb] == 1), rev = (jf[deb][fin] == 2);
787 Standard_Integer isurf1 = 1, isurf2 = 2;
788 Standard_Real par = p[deb][pivot], par2 = p[deb][pivot];
789 if(c1triangle) par2 = p[deb][fin];
791 isurf1 = 2; isurf2 = 1;
792 CD[deb]->SetOrientation(TopAbs_REVERSED,isfirst);
794 CD[deb]->SetCurve(Icf,isfirst);
795 CD[deb]->SetIndexPoint(If1,isfirst,isurf1);
796 CD[deb]->SetIndexPoint(If2,isfirst,isurf2);
797 CD[deb]->SetParameters(isfirst,P1deb,P2deb);
798 fddeb->ChangeVertex(isfirst,isurf1) = Pf1;
799 fddeb->ChangeVertex(isfirst,isurf2) = Pf2;
800 fddeb->ChangeInterference(isurf1).SetParameter(par2,isfirst);
801 fddeb->ChangeInterference(isurf2).SetParameter(par,isfirst);
803 CD[deb]->ChangePCurve(isfirst) = debpc1;
805 pp1 = fddeb->InterferenceOnS1().PCurveOnSurf()->Value(par);
806 pp2 = fddeb->InterferenceOnS2().PCurveOnSurf()->Value(par);
807 ChFi3d_ComputePCurv(pp1,pp2,CD[deb]->ChangePCurve(isfirst),P1deb,P2deb,rev);
810 // puis la CornerData de la fin,
811 // -----------------------------
812 isfirst = (sens[fin] == 1); rev = (jf[fin][deb] == 2);
813 isurf1 = 1; isurf2 = 2;
814 par = p[fin][pivot]; par2 = p[fin][pivot];
815 if(c1triangle) par2 = p[fin][deb];
817 isurf1 = 2; isurf2 = 1;
818 CD[fin]->SetOrientation(TopAbs_REVERSED,isfirst);
820 CD[fin]->SetCurve(Icl,isfirst);
821 CD[fin]->SetIndexPoint(Il1,isfirst,isurf1);
822 CD[fin]->SetIndexPoint(Il2,isfirst,isurf2);
823 CD[fin]->SetParameters(isfirst,P1fin,P2fin);
824 fdfin->ChangeVertex(isfirst,isurf1) = Pl1;
825 fdfin->ChangeVertex(isfirst,isurf2) = Pl2;
826 fdfin->ChangeInterference(isurf1).SetParameter(par2,isfirst);
827 fdfin->ChangeInterference(isurf2).SetParameter(par,isfirst);
829 CD[fin]->ChangePCurve(isfirst) = finpc1;
831 pp1 = fdfin->InterferenceOnS1().PCurveOnSurf()->Value(par);
832 pp2 = fdfin->InterferenceOnS2().PCurveOnSurf()->Value(par);
833 ChFi3d_ComputePCurv(pp1,pp2,CD[fin]->ChangePCurve(isfirst),P1fin,P2fin,rev);
836 // et enfin le pivot.
837 // ------------------
838 ChFiDS_FaceInterference& fi = coin->ChangeInterferenceOnS2();
839 isfirst = (sens[pivot] == 1); rev = (jf[pivot][deb] == 2);
840 isurf1 = 1; isurf2 = 2;
842 isurf1 = 2; isurf2 = 1;
843 CD[pivot]->SetOrientation(TopAbs_REVERSED,isfirst);
845 CD[pivot]->SetCurve(fi.LineIndex(),isfirst);
846 CD[pivot]->ChangePCurve(isfirst) = fi.PCurveOnFace();
847 CD[pivot]->SetIndexPoint(If2,isfirst,isurf1);
848 CD[pivot]->SetIndexPoint(Il2,isfirst,isurf2);
849 CD[pivot]->SetParameters(isfirst,fi.FirstParameter(),fi.LastParameter());
850 fdpiv->ChangeVertex(isfirst,isurf1) = Pf2;
851 fdpiv->ChangeVertex(isfirst,isurf2) = Pl2;
852 fdpiv->ChangeInterference(isurf1).SetParameter(p[pivot][deb],isfirst);
853 fdpiv->ChangeInterference(isurf2).SetParameter(p[pivot][fin],isfirst);
854 CD[pivot]->InDS(isfirst); // filDS fait deja le boulot depuis le coin.
857 //On tronque les corners data et met a jour les index.
858 //----------------------------------------------------
860 if(i[deb][pivot] < Index[deb]){
861 CD[deb]->ChangeSetOfSurfData()->Remove(i[deb][pivot]+1,Index[deb]);
862 Index[deb] = i[deb][pivot];
864 else if(i[deb][pivot] > Index[deb]) {
865 CD[deb]->ChangeSetOfSurfData()->Remove(Index[deb],i[deb][pivot]-1);
866 i[deb][pivot] = Index[deb];
868 if(i[fin][pivot] < Index[fin]) {
869 CD[fin]->ChangeSetOfSurfData()->Remove(i[fin][pivot]+1,Index[fin]);
870 Index[fin] = i[fin][pivot];
872 else if(i[fin][pivot] > Index[fin]) {
873 CD[fin]->ChangeSetOfSurfData()->Remove(Index[fin],i[fin][pivot]-1);
874 i[fin][pivot] = Index[fin];
876 // il faudra ici tenir compte des coins mutants.
877 if(i[pivot][deb] < Index[pivot]) {
878 CD[pivot]->ChangeSetOfSurfData()->Remove(i[pivot][deb]+1,Index[pivot]);
879 Index[pivot] = i[pivot][deb];
881 else if(i[pivot][deb] > Index[pivot]) {
882 CD[pivot]->ChangeSetOfSurfData()->Remove(Index[pivot],i[pivot][deb]-1);
883 i[pivot][deb] = Index[pivot];
885 if(!myEVIMap.IsBound(Vtx)){
886 TColStd_ListOfInteger li;
887 myEVIMap.Bind(Vtx,li);
889 myEVIMap.ChangeFind(Vtx).Append(coin->Surf());
890 corner->SetSolidIndex(CD[pivot]->SolidIndex());
891 myListStripe.Append(corner);