0026173: Wrong result of ChFi3d_ChBuilder algorithm: incorrect processing of G1 junct...
[occt.git] / src / ChFi3d / ChFi3d_Builder_CnCrn.cxx
1 // Created on: 1997-03-01
2 // Created by: MPS  
3 // Copyright (c) 1997-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 // Modified by  MPS (14-04-97)  traitement des cas  ou il n'y a pas
18 //                              d'intersection entre les stripes 
19 //  Modified by  MPS (16-06-97) : on tient compte du fait que GeomPlate
20 //                                rend les courbes 2d dans meme ordre que les
21 //                                courbes frontieres passees en entree   
22 //  Modified by JLR (20-08-97) mise en place des nouveaux constructeurs de GeomPlate
23 //  Modified by MPS (03-11-97) on ne cree pas un  batten lorsque le rapport
24 //  entre les deux resolutions sur la surface est trop grand (PRO10649)  
25 //  Modified by MPS (05-12-97) on ne tient pas compte des aretes degenerees
26 //                             lors du calcul du nombre d'aretes.
27 //  Modified by JCT (08-12-97) traitement des aretes vives consecutives ou non
28 //                             (grille EDC412 sauf D2, L1, L2, L3)
29 //  Modified by JCT (11-12-97) pb osf avec indpoint + orientation de plate
30 //                             ( --> D2, L1, L2, L3 valides mais laids)
31 //  Modified by MPS (24-02-98)  traitement des aretes de regularite 
32 //  Modified by MPS (01-06-98)  traitement des aretes de couture 
33 //  Modified by MPS (01-12-98)  traitement des bords libres 
34 //  Modified by MPS (01-02-99)  traitement des aretes de regularite 
35 //                              consecutives   
36 // Traitement des coins                  
37
38 #include <Adaptor2d_HCurve2d.hxx>
39 #include <Adaptor3d_CurveOnSurface.hxx>
40 #include <Adaptor3d_HCurveOnSurface.hxx>
41 #include <Adaptor3d_HSurface.hxx>
42 #include <Adaptor3d_TopolTool.hxx>
43 #include <AppBlend_Approx.hxx>
44 #include <Blend_CurvPointFuncInv.hxx>
45 #include <Blend_FuncInv.hxx>
46 #include <Blend_Function.hxx>
47 #include <Blend_RstRstFunction.hxx>
48 #include <Blend_SurfCurvFuncInv.hxx>
49 #include <Blend_SurfPointFuncInv.hxx>
50 #include <Blend_SurfRstFunction.hxx>
51 #include <Bnd_Box2d.hxx>
52 #include <BndLib_Add2dCurve.hxx>
53 #include <BRep_Tool.hxx>
54 #include <BRepAdaptor_HCurve2d.hxx>
55 #include <BRepAdaptor_HSurface.hxx>
56 #include <BRepAlgo_NormalProjection.hxx>
57 #include <BRepBlend_Line.hxx>
58 #include <BRepLib_MakeEdge.hxx>
59 #include <BRepLib_MakeFace.hxx>
60 #include <BRepTools.hxx>
61 #include <BRepTopAdaptor_TopolTool.hxx>
62 #include <ChFi3d_Builder.hxx>
63 #include <ChFi3d_Builder_0.hxx>
64 #include <ChFiDS_CommonPoint.hxx>
65 #include <ChFiDS_FaceInterference.hxx>
66 #include <ChFiDS_HData.hxx>
67 #include <ChFiDS_HElSpine.hxx>
68 #include <ChFiDS_ListIteratorOfListOfStripe.hxx>
69 #include <ChFiDS_Regul.hxx>
70 #include <ChFiDS_SequenceOfSurfData.hxx>
71 #include <ChFiDS_Spine.hxx>
72 #include <ChFiDS_Stripe.hxx>
73 #include <ChFiDS_StripeArray1.hxx>
74 #include <ChFiDS_SurfData.hxx>
75 #include <Extrema_ExtCC.hxx>
76 #include <Extrema_ExtPC.hxx>
77 #include <Extrema_POnCurv.hxx>
78 #include <FairCurve_Batten.hxx>
79 #include <Geom2d_BSplineCurve.hxx>
80 #include <Geom2d_Curve.hxx>
81 #include <Geom2d_Line.hxx>
82 #include <Geom2d_TrimmedCurve.hxx>
83 #include <Geom2dAdaptor_HCurve.hxx>
84 #include <Geom2dLProp_CLProps2d.hxx>
85 #include <Geom_BezierCurve.hxx>
86 #include <Geom_BSplineSurface.hxx>
87 #include <Geom_Curve.hxx>
88 #include <Geom_Line.hxx>
89 #include <Geom_Surface.hxx>
90 #include <GeomAdaptor.hxx>
91 #include <GeomAdaptor_HSurface.hxx>
92 #include <GeomInt_IntSS.hxx>
93 #include <GeomLib.hxx>
94 #include <GeomPlate_BuildPlateSurface.hxx>
95 #include <GeomPlate_CurveConstraint.hxx>
96 #include <GeomPlate_HArray1OfHCurveOnSurface.hxx>
97 #include <GeomPlate_MakeApprox.hxx>
98 #include <GeomPlate_PlateG0Criterion.hxx>
99 #include <GeomPlate_Surface.hxx>
100 #include <gp_Dir2d.hxx>
101 #include <gp_Pnt.hxx>
102 #include <gp_Pnt2d.hxx>
103 #include <math_Matrix.hxx>
104 #include <PLib.hxx>
105 #include <Precision.hxx>
106 #include <Standard_ConstructionError.hxx>
107 #include <Standard_NoSuchObject.hxx>
108 #include <Standard_OutOfRange.hxx>
109 #include <TColGeom2d_Array1OfCurve.hxx>
110 #include <TColGeom2d_HArray1OfCurve.hxx>
111 #include <TColGeom2d_SequenceOfCurve.hxx>
112 #include <TColGeom_Array1OfCurve.hxx>
113 #include <TColGeom_SequenceOfCurve.hxx>
114 #include <TColgp_Array1OfPnt.hxx>
115 #include <TColgp_Array1OfPnt2d.hxx>
116 #include <TColgp_Array1OfXYZ.hxx>
117 #include <TColgp_SequenceOfXY.hxx>
118 #include <TColgp_SequenceOfXYZ.hxx>
119 #include <TColStd_Array1OfBoolean.hxx>
120 #include <TColStd_Array1OfInteger.hxx>
121 #include <TColStd_Array1OfReal.hxx>
122 #include <TColStd_Array2OfInteger.hxx>
123 #include <TColStd_Array2OfReal.hxx>
124 #include <TColStd_HArray1OfInteger.hxx>
125 #include <TColStd_ListOfInteger.hxx>
126 #include <TopAbs_Orientation.hxx>
127 #include <TopExp.hxx>
128 #include <TopExp_Explorer.hxx>
129 #include <TopoDS_Edge.hxx>
130 #include <TopoDS_Face.hxx>
131 #include <TopoDS_Shape.hxx>
132 #include <TopoDS_Vertex.hxx>
133 #include <TopOpeBRepBuild_HBuilder.hxx>
134 #include <TopOpeBRepDS_Curve.hxx>
135 #include <TopOpeBRepDS_CurvePointInterference.hxx>
136 #include <TopOpeBRepDS_DataStructure.hxx>
137 #include <TopOpeBRepDS_HDataStructure.hxx>
138 #include <TopOpeBRepDS_Kind.hxx>
139 #include <TopOpeBRepDS_ListOfInterference.hxx>
140 #include <TopOpeBRepDS_Point.hxx>
141 #include <TopOpeBRepDS_SolidSurfaceInterference.hxx>
142 #include <TopOpeBRepDS_Surface.hxx>
143 #include <TopOpeBRepDS_SurfaceCurveInterference.hxx>
144 #include <TopOpeBRepDS_Transition.hxx>
145 #include <TopTools_Array2OfShape.hxx>
146 #include <TopTools_IndexedMapOfShape.hxx>
147
148 // performances 
149 #ifdef OCCT_DEBUG
150 #include <OSD_Chronometer.hxx>
151 extern Standard_Real  t_plate ,t_approxplate,t_batten; 
152 extern void ChFi3d_InitChron(OSD_Chronometer& ch);
153 extern void ChFi3d_ResultChron(OSD_Chronometer & ch,Standard_Real& time);
154 #endif
155
156
157 //=======================================================================
158 //function : Indices
159 //purpose  : 
160 //=======================================================================
161
162 static void Indices (     const  Standard_Integer n,
163                    const Standard_Integer ic,
164                    Standard_Integer & icplus,
165                    Standard_Integer & icmoins)
166 {
167   if (ic== (n-1)) icplus=0;
168     else icplus=ic+1;  
169     if (ic==0) icmoins=n-1;
170     else icmoins=ic-1;
171 }
172
173 //=======================================================================
174 //function : Calcul_Param
175 //purpose  : 
176 //=======================================================================
177
178 static void Calcul_Param (const Handle(ChFiDS_Stripe)& stripe,
179                           const Standard_Integer jfposit,
180                           const Standard_Integer indice,
181                           const Standard_Boolean isfirst,
182                           Standard_Real & param)
183 {
184   if (jfposit==2 ) 
185     param=stripe->SetOfSurfData()->Value(indice)->InterferenceOnS2().Parameter(isfirst);   
186   else 
187     param=stripe->SetOfSurfData()->Value(indice)->InterferenceOnS1().Parameter(isfirst);
188 }
189
190 //=======================================================================
191 //function : Calcul_P2dOnSurf
192 //purpose  : 
193 //=======================================================================
194
195 static void Calcul_P2dOnSurf(const Handle(ChFiDS_Stripe)& stripe,
196                              const Standard_Integer jfposit,
197                              const Standard_Integer indice,
198                              const Standard_Real param,
199                              gp_Pnt2d & p2)
200
201 {
202   if (jfposit==1) 
203     stripe->SetOfSurfData()->Value(indice)
204       ->InterferenceOnS1().PCurveOnSurf()->D0(param,p2);   
205   else
206     stripe->SetOfSurfData()->Value(indice)
207       ->InterferenceOnS2().PCurveOnSurf()->D0(param,p2);        
208 }
209
210 //=======================================================================
211 //function : Calcul_C2dOnFace
212 //purpose  : 
213 //=======================================================================
214
215 static void Calcul_C2dOnFace (const Handle(ChFiDS_Stripe)& stripe,
216                               const Standard_Integer jfposit,
217                               const Standard_Integer indice,
218                               Handle(Geom2d_Curve) & c2d)
219
220 {
221   if (jfposit==1) 
222     c2d = stripe->SetOfSurfData()->Value(indice)
223       ->InterferenceOnS1().PCurveOnFace();   
224   else
225     c2d = stripe->SetOfSurfData()->Value(indice)
226       ->InterferenceOnS2().PCurveOnFace();        
227 }
228
229 //=======================================================================
230 //function : Calcul_Orientation
231 //purpose  : 
232 //=======================================================================
233
234 static void Calcul_Orientation(const Handle(ChFiDS_Stripe)& stripe,
235                                const Standard_Integer jfposit,
236                                const Standard_Integer indice,
237                                TopAbs_Orientation & orient)
238 {
239   if (jfposit==1)
240     orient = stripe->SetOfSurfData()->Value(indice)
241       ->InterferenceOnS1().Transition();       
242   else
243     orient = stripe->SetOfSurfData()->Value(indice)
244       ->InterferenceOnS2().Transition();
245 }
246
247 //=======================================================================
248 //function : RemoveSD
249 //purpose  : 
250 //=======================================================================
251
252 static void RemoveSD(Handle(ChFiDS_Stripe)& Stripe,
253                      const Standard_Integer num1,
254                      const Standard_Integer num2     )
255 {
256   ChFiDS_SequenceOfSurfData& Seq = 
257     Stripe->ChangeSetOfSurfData()->ChangeSequence();
258   if(Seq.IsEmpty()) return;
259   if (num1==num2) 
260     Seq.Remove(num1);
261   else
262     Seq.Remove(num1,num2);
263 }
264
265 //=======================================================================
266 //function : cherche_edge1
267 //purpose  : find common edge of faces F1 and F2 
268 //=======================================================================
269
270 static void cherche_edge1 (const TopoDS_Face & F1,
271                            const TopoDS_Face & F2,
272                            TopoDS_Edge & Edge)
273 { Standard_Integer i,j; 
274   TopoDS_Edge Ecur1,Ecur2;
275   Standard_Boolean trouve=Standard_False;
276   TopTools_IndexedMapOfShape  MapE1,MapE2;
277   TopExp::MapShapes( F1,TopAbs_EDGE,MapE1);
278   TopExp::MapShapes( F2,TopAbs_EDGE,MapE2);
279   for ( i=1; i<= MapE1.Extent()&&!trouve; i++)
280   { 
281     TopoDS_Shape aLocalShape = TopoDS_Shape (MapE1(i));
282     Ecur1=TopoDS::Edge(aLocalShape);
283     //  Ecur1=TopoDS::Edge(TopoDS_Shape (MapE1(i)));
284     for ( j=1; j<= MapE2.Extent()&&!trouve; j++)
285     { 
286       aLocalShape = TopoDS_Shape (MapE2(j));
287       Ecur2=TopoDS::Edge(aLocalShape);
288       //              Ecur2=TopoDS::Edge(TopoDS_Shape (MapE2(j)));
289       if (Ecur2.IsSame(Ecur1))
290       {Edge=Ecur1;trouve=Standard_True;}
291     }
292   }
293 }
294
295 //=======================================================================
296 //function : CurveHermite
297 //purpose  : calculate a  curve 3d using polynoms of Hermite.
298 //           the edge is a regular edge. Curve 3D is constructed  
299 //           between edges icmoins and icplus. 
300 //=======================================================================
301
302 static void CurveHermite (const TopOpeBRepDS_DataStructure& DStr,
303                           const Handle(ChFiDS_Stripe)&   CDicmoins,
304                           const Standard_Integer jficmoins,
305                           const Standard_Integer icmoins,
306                           const Standard_Real    picmoins,
307                           const Standard_Integer sensicmoins,
308                           const Standard_Boolean sharpicmoins,
309                           const TopoDS_Edge & Eviveicmoins,
310                           const Handle(ChFiDS_Stripe)&   CDicplus,
311                           const Standard_Integer jficplus,
312                           const Standard_Integer icplus,
313                           const Standard_Real    picplus,
314                           const Standard_Integer sensicplus,
315                           const Standard_Boolean sharpicplus,
316                           const TopoDS_Edge & Eviveicplus,
317                           const Standard_Integer nbface,
318                           TopTools_SequenceOfShape & Ecom,
319                           const TopTools_SequenceOfShape & Face,
320                           TColGeom2d_SequenceOfCurve & proj2d,
321                           TColGeom_SequenceOfCurve & cproj,  
322                           TopTools_SequenceOfShape & Eproj,     
323                           TColStd_SequenceOfReal & param,
324                           Standard_Real & error)
325 {  
326   gp_Pnt p01,p02;
327   gp_Vec d11,d12;
328   Standard_Integer ii,jj;
329   Standard_Real up1,up2;
330   Standard_Integer ilin,jfp;
331   Handle (Geom_Curve) c1,c2;
332   if (sharpicmoins) {
333     c1=BRep_Tool::Curve(Eviveicmoins,up1,up2);
334   }
335   else {
336     if (jficmoins==1) 
337       ilin= CDicmoins->SetOfSurfData()->Value( icmoins)->InterferenceOnS1().LineIndex();
338     else ilin= CDicmoins->SetOfSurfData()->Value(icmoins)->InterferenceOnS2().LineIndex();
339     c1=DStr.Curve(ilin).Curve();
340   }
341   if (sharpicplus){
342     c2=BRep_Tool::Curve(Eviveicplus,up1,up2);
343   }
344   else {
345     jfp=3-jficplus;   
346     if (jfp==1) 
347       ilin= CDicplus->SetOfSurfData()->Value( icplus)->InterferenceOnS1().LineIndex();
348     else  ilin=CDicplus->SetOfSurfData()->Value(icplus)->InterferenceOnS2().LineIndex();
349     c2=DStr.Curve(ilin ).Curve();
350   }
351   c1->D1(picmoins,p01,d11);
352   c2->D1(picplus,p02,d12);
353   Standard_Integer size = 4;
354   math_Matrix  MatCoefs(1,size, 1,size);
355   TColgp_Array1OfXYZ Cont(1,size);
356   PLib::HermiteCoefficients(0, 1,1,1,MatCoefs);
357   Standard_Real L1=p01.Distance(p02);
358   Standard_Real lambda= ((Standard_Real)1) / Max (d11.Magnitude() / L1, 1.e-6);
359   Cont(1) = p01.XYZ();
360   if (sensicmoins==1) Cont(2) = d11.XYZ()*(-lambda) ;
361   else Cont(2) = d11.XYZ()*(lambda) ;
362   lambda= ((Standard_Real)1) / Max (d12.Magnitude() / L1, 1.e-6);
363   Cont(3) = p02.XYZ();
364   if (sensicplus==1) Cont(4) =  d12.XYZ()*(lambda);
365   else Cont(4) =  d12.XYZ()*(-lambda);
366   TColgp_Array1OfPnt ExtrapPoles(1, size);
367   TColgp_Array1OfPnt ExtraCoeffs(1, size);
368   gp_Pnt p0(0,0,0);
369   ExtraCoeffs.Init(p0);
370   for (ii=1; ii<=size; ii++) {
371     for (jj=1; jj<=size; jj++) {
372       ExtraCoeffs(jj).ChangeCoord() += MatCoefs(ii,jj)*Cont(ii);
373     }
374   }
375   PLib::CoefficientsPoles(ExtraCoeffs,  PLib::NoWeights(),
376                           ExtrapPoles,  PLib::NoWeights());
377   Handle(Geom_BezierCurve) Bezier = new (Geom_BezierCurve) (ExtrapPoles);
378   BRepLib_MakeEdge Bedge (Bezier);
379   TopoDS_Edge edg =Bedge. Edge();
380   TopoDS_Face F;
381   error=1.e-30;
382   Standard_Integer nb;
383   for(nb=1;nb<=nbface;nb++){
384     F=TopoDS::Face(Face.Value(nb));
385     TopTools_IndexedMapOfShape MapE1;
386     TopoDS_Edge E1;
387     Handle(Geom2d_Curve) proj1;
388     Handle(Geom_Curve) proj1c,proj2c;
389     BRepAlgo_NormalProjection OrtProj;
390     OrtProj.Init(F);
391     OrtProj.Add(edg);
392     OrtProj.SetParams(1.e-4, 1.e-4, GeomAbs_C1, 14, 16);
393     OrtProj.Build();
394     if ( OrtProj.IsDone()){
395       TopExp::MapShapes(OrtProj.Projection() , TopAbs_EDGE, MapE1);
396         if (MapE1.Extent()!=0){
397           if (MapE1.Extent()!=1) {
398             BRepLib_MakeFace Bface (BRep_Tool::Surface(F), Precision::Confusion());
399             F=Bface.Face();
400             OrtProj.Init(F);
401             OrtProj.Build();
402             MapE1.Clear();
403             if ( OrtProj.IsDone()) 
404               TopExp::MapShapes(OrtProj.Projection() ,TopAbs_EDGE, MapE1);
405           }
406           if (MapE1.Extent()!=0) { 
407             Standard_Boolean trouve=Standard_False;
408             for (Standard_Integer ind=1;ind<=MapE1.Extent()&&!trouve;ind++){
409               TopoDS_Shape aLocalShape = TopoDS_Shape( MapE1(ind));  
410               E1=TopoDS::Edge( aLocalShape );
411               //           E1=TopoDS::Edge( TopoDS_Shape (MapE1(ind)));
412               if (!BRep_Tool::Degenerated(E1)) trouve=Standard_True;
413             }
414             Eproj.Append(E1);
415             proj1=BRep_Tool::CurveOnSurface(E1,F,up1,up2);
416             proj2d.Append(new Geom2d_TrimmedCurve(proj1,up1,up2));
417             proj1c=BRep_Tool::Curve(E1,up1,up2);
418             cproj.Append(new Geom_TrimmedCurve(proj1c,up1,up2));
419             if (error>BRep_Tool::Tolerance(E1)) error=BRep_Tool::Tolerance(E1);
420           }
421           else {
422             Eproj.Append(E1);
423             proj2d.Append(proj1);
424             cproj.Append(proj1c);
425           } 
426         }
427         else {
428           Eproj.Append(E1);
429           proj2d.Append(proj1);
430           cproj.Append(proj1c);
431         }
432       }
433   }
434   for (nb=1;nb<=nbface-1;nb++) {
435     BRepAdaptor_Curve C(TopoDS::Edge(Ecom.Value(nb)));
436     C.D0(param.Value(nb),p02);
437     GeomAdaptor_Curve L (Bezier);
438     Extrema_ExtCC ext (C,L);
439     if (ext.IsDone()){ 
440       if (ext.NbExt()!=0){ 
441         Extrema_POnCurv POnC, POnL;
442         ext.Points(1, POnC, POnL);
443         if (POnC.Value().Distance(POnL.Value()) < Precision::Confusion())
444           param.ChangeValue(nb) =POnC.Parameter();
445         else
446         {
447           if (!cproj.Value(nb).IsNull()) {
448             cproj.Value(nb)->D0(cproj.Value(nb)->LastParameter(),p01);
449           }
450           else if (!cproj.Value(nb+1).IsNull()) {
451             cproj.Value(nb+1)->D0(cproj.Value(nb+1)->FirstParameter(),p01);
452           }
453         }
454       }
455     }
456     if (!ext.IsDone()||ext.NbExt()==0) {
457       if (!cproj.Value(nb).IsNull()) {
458         cproj.Value(nb)->D0(cproj.Value(nb)->LastParameter(),p01); 
459       }
460       else if (!cproj.Value(nb+1).IsNull()) {
461         cproj.Value(nb+1)->D0(cproj.Value(nb+1)->FirstParameter(),p01);  
462       } 
463       if (p01.Distance(p02)>1.e-4 ){
464         Extrema_ExtPC ext1 (p01,C);
465         if (ext1.IsDone()){ 
466           if (ext1.NbExt()!=0){  
467             Extrema_POnCurv POnC(ext1.Point(1));
468             param.ChangeValue(nb) =POnC.Parameter();
469           }
470         }
471       }
472     }       
473   }
474 }
475
476 //=======================================================================
477 //function : CalculDroite
478 //purpose  : calculate a 2D straight line passing through point p2d1 and direction xdir ydir 
479 //=======================================================================
480
481 static void CalculDroite(const gp_Pnt2d & p2d1,
482                          const Standard_Real  xdir,
483                          const Standard_Real  ydir,
484                          Handle (Geom2d_Curve) & pcurve) 
485 { gp_Dir2d dir1 (xdir, ydir);
486   Handle(Geom2d_Line) l= new Geom2d_Line (p2d1,dir1);
487   Standard_Real l0 = sqrt(xdir*xdir+ ydir*ydir );
488   pcurve = new Geom2d_TrimmedCurve(l,0,l0);
489 }
490
491 //=======================================================================
492 //function : CalculBatten
493 //purpose  : calcule a batten between curves 2d  curv2d1 and curv2d2 at points p2d1 and p2d2  
494 //=======================================================================
495
496 static void CalculBatten (const Handle (GeomAdaptor_HSurface) ASurf, 
497                           const TopoDS_Face Face ,
498                           const Standard_Real xdir,
499                           const Standard_Real  ydir,
500                           const gp_Pnt2d & p2d1,
501                           const gp_Pnt2d & p2d2,
502                           const Standard_Boolean contraint1,
503                           const Standard_Boolean contraint2,
504                           Handle (Geom2d_Curve) & curv2d1,
505                           Handle (Geom2d_Curve) & curv2d2,
506                           const Standard_Real  picicplus,
507                           const Standard_Real   picplusic,
508                           const Standard_Boolean inverseic,
509                           const Standard_Boolean inverseicplus,
510                           Handle (Geom2d_Curve)& pcurve)
511 {  
512   Standard_Boolean isplane;
513   Standard_Boolean anglebig = Standard_False;
514   isplane=ASurf->GetType()==GeomAbs_Plane;
515   gp_Dir2d dir1 (xdir, ydir);
516   Geom2dLProp_CLProps2d CL1(curv2d1, picicplus, 1, 1.e-4);
517   Geom2dLProp_CLProps2d CL2( curv2d2, picplusic, 1, 1.e-4);
518   gp_Dir2d dir3,dir4 ;
519   CL1.Tangent(dir3);
520   CL2.Tangent(dir4);
521   if (inverseic)  dir3.Reverse();
522   if (inverseicplus)  dir4.Reverse();
523   Standard_Real h =  p2d2.Distance(p2d1)/20;
524   FairCurve_Batten Bat(p2d1,p2d2,h);
525   Bat.SetFreeSliding (Standard_True);
526   Standard_Real ang1,ang2;
527   ang1=dir1.Angle(dir3);
528   if (dir1.Angle(dir4) >0 ) ang2=M_PI-dir1.Angle(dir4);
529   else ang2=-M_PI-dir1.Angle(dir4);
530   if (contraint1&&contraint2) 
531   anglebig=(Abs(ang1)>1.2)|| (Abs(ang2)>1.2 );
532   else if (contraint1) 
533   anglebig=Abs(ang1)>1.2;
534   else if (contraint2)
535   anglebig=Abs(ang2)>1.2; 
536   if (isplane && (Abs(ang1)>M_PI/2 || Abs(ang2)>M_PI/2))
537   isplane=Standard_False;
538   if (anglebig && !isplane) {
539     CalculDroite(p2d1,xdir,ydir,pcurve);
540   }
541   else {
542     if (contraint1) Bat.SetAngle1(ang1);
543     else  Bat.SetConstraintOrder1(0);
544     if (contraint2) Bat.SetAngle2(ang2);
545     else Bat.SetConstraintOrder2(0);
546     FairCurve_AnalysisCode Iana; 
547     Standard_Boolean Ok;
548     Ok = Bat.Compute(Iana,25,1.e-2);
549 #ifdef OCCT_DEBUG
550     if (!Ok) { 
551       cout<<"no batten :";
552       Bat.Dump(cout);
553     }    
554 #endif  
555     if (Ok) {
556        pcurve = Bat.Curve();
557        Standard_Real umin,vmin,umax,vmax;
558        BRepTools::UVBounds(Face,umin,umax,vmin,vmax);
559        Bnd_Box2d bf,bc;
560        Geom2dAdaptor_Curve acur(pcurve);
561        BndLib_Add2dCurve::Add(acur,0,bc);
562        bf.Update(umin,vmin,umax,vmax);
563        Standard_Real uminc,vminc,umaxc,vmaxc;
564        bc.Get(uminc,vminc,umaxc,vmaxc);
565        if (uminc<umin-1.e-7) Ok=Standard_False;
566        if (umaxc>umax+1.e-7) Ok=Standard_False;
567        if (vminc<vmin-1.e-7) Ok=Standard_False;
568        if (vmaxc>vmax+1.e-7) Ok=Standard_False;       
569     } 
570     if (!Ok) CalculDroite(p2d1, xdir,ydir, pcurve);    
571   }
572 }
573
574 //=======================================================================
575 //function : OrientationIcNonVive
576 //purpose  : calculate the orientation of the curve between ic and icplus knowing that ic 
577 //           is not a living edge.
578 //=======================================================================
579
580 static void OrientationIcNonVive (const Handle(ChFiDS_Stripe) & CDic,
581                                   const Standard_Integer jfic,
582                                   const Standard_Integer icicplus,
583                                   const Standard_Integer  sensic,
584                                   TopAbs_Orientation  & orien )
585 {
586   TopAbs_Orientation orinterf; 
587   Calcul_Orientation(CDic,jfic,icicplus,orinterf);
588   if (sensic!=1){
589     if (orinterf==TopAbs_FORWARD) orien=TopAbs_FORWARD;
590     else orien=TopAbs_REVERSED;                 
591   }
592   else {
593     if (orinterf==TopAbs_FORWARD) orien=TopAbs_REVERSED;
594     else orien=TopAbs_FORWARD;
595   }             
596 }
597
598 //=======================================================================
599 //function : OrientationIcplusNonVive
600 //purpose  : calculate the orientation of the curve between ic and icplus knowing that icplus
601 //           is not a living edge;
602 //=======================================================================
603
604 static void OrientationIcplusNonVive (const Handle(ChFiDS_Stripe) & CDicplus,
605                                       const Standard_Integer jficplus,
606                                       const Standard_Integer icplusic,
607                                       const Standard_Integer sensicplus,
608                                       TopAbs_Orientation & orien )
609 {
610   TopAbs_Orientation orinterf; 
611   Standard_Integer  jfp = 3 -jficplus;
612   Calcul_Orientation(CDicplus,jfp,icplusic,orinterf);
613   if (sensicplus==1){
614     if (orinterf==TopAbs_FORWARD) orien=TopAbs_FORWARD;
615     else orien=TopAbs_REVERSED;                 
616   }
617   else {
618     if (orinterf==TopAbs_FORWARD) orien=TopAbs_REVERSED;
619     else orien=TopAbs_FORWARD;
620   }             
621 }
622
623 //=======================================================================
624 //function : OrientationAreteViveConsecutive
625 //purpose  : calculate the orientation of the curve between edges ic and icplus 
626 //           where ic and icplus are consecutively living 
627 //=======================================================================
628
629 static void OrientationAreteViveConsecutive (const TopoDS_Shape & Fviveicicplus,
630                                              const TopoDS_Shape & Eviveic,
631                                              const TopoDS_Vertex & V1,
632                                              TopAbs_Orientation & orien)
633
634 { // orinterf is orientation of edge ic corresponding to face Fviveicicplus taken FORWARD
635   TopAbs_Orientation orinterf = TopAbs_FORWARD;
636   TopoDS_Face F=TopoDS::Face( Fviveicicplus);
637   TopoDS_Edge E=TopoDS::Edge( Eviveic);  
638   TopExp_Explorer ex;
639   for(ex.Init(F.Oriented(TopAbs_FORWARD),TopAbs_EDGE);ex.More(); ex.Next()){
640     if(E.IsSame(ex.Current())) {
641       orinterf = ex.Current().Orientation();
642       break;
643     }
644   }
645   // if V1 is vertex REVERSED of edge ic the curve  
646   // has the same orientation as ic 
647   TopoDS_Vertex vl;
648   vl=TopExp::LastVertex(E);
649   if (vl.IsSame(V1)){ 
650     if (orinterf==TopAbs_FORWARD) orien=TopAbs_FORWARD;
651     else orien=TopAbs_REVERSED;
652   }
653   else {
654     if (orinterf==TopAbs_FORWARD) orien=TopAbs_REVERSED;
655     else orien=TopAbs_FORWARD;
656   }
657 }
658
659 //=======================================================================
660 //function : PerformTwoCornerSameExt
661 //purpose  : calculate intersection between two stripes stripe1 and stripe2 
662 //=======================================================================
663
664 static void PerformTwoCornerSameExt(TopOpeBRepDS_DataStructure& DStr,
665                                     const Handle(ChFiDS_Stripe)& stripe1,
666                                     const Standard_Integer index1,
667                                     const Standard_Integer sens1,
668                                     const Handle(ChFiDS_Stripe) &stripe2,
669                                     const Standard_Integer index2,
670                                     const Standard_Integer sens2,
671                                     Standard_Boolean & trouve)
672                      
673 { Handle (TopOpeBRepDS_CurvePointInterference) Interfp1, Interfp2;
674   Handle (TopOpeBRepDS_SurfaceCurveInterference) Interfc;
675   TopAbs_Orientation orpcurve,trafil1,orsurf1,orsurf2;
676   Standard_Boolean isfirst;
677   Standard_Integer indic1,indic2, indpoint1,indpoint2,ind,indcurve;
678   Standard_Real tol;
679   gp_Pnt P1,P2,P3,P4;
680   gp_Pnt2d p2d;
681   Handle(Geom_Curve)cint;
682   Handle(Geom2d_Curve) C2dint1,C2dint2;
683   isfirst=sens1==1;
684   ChFiDS_CommonPoint& Com11= stripe1->SetOfSurfData()->Value(index1)->ChangeVertex (isfirst,1);
685   ChFiDS_CommonPoint& Com12= stripe1->SetOfSurfData()->Value(index1)->ChangeVertex (isfirst,2);
686   isfirst=sens2==1;
687   ChFiDS_CommonPoint& Com21= stripe2->SetOfSurfData()->Value(index2)->ChangeVertex (isfirst,1);
688 #ifdef OCCT_DEBUG
689 //  ChFiDS_CommonPoint& Com22= 
690 //    stripe2->SetOfSurfData()->Value(index2)->ChangeVertex (isfirst,2);
691 #endif
692   indic1=stripe1->SetOfSurfData()->Value(index1)->Surf();
693   indic2=stripe2->SetOfSurfData()->Value(index2)->Surf();
694   const Handle(ChFiDS_SurfData) Fd1=stripe1->SetOfSurfData()->Value(index1);
695   const Handle(ChFiDS_SurfData) Fd2=stripe2->SetOfSurfData()->Value(index2);
696
697   TColStd_Array1OfReal Pardeb(1,4),Parfin(1,4);
698   const ChFiDS_FaceInterference& Fi11 = Fd1->InterferenceOnS1();
699   const ChFiDS_FaceInterference& Fi12 = Fd1->InterferenceOnS2();
700   const ChFiDS_FaceInterference& Fi21 = Fd2->InterferenceOnS1();
701   const ChFiDS_FaceInterference& Fi22 = Fd2->InterferenceOnS2();
702   gp_Pnt2d pfi11,pfi12,pfi21,pfi22;
703   isfirst=sens1==1;
704   pfi11 = Fi11.PCurveOnSurf()->Value(Fi11.Parameter(isfirst));
705   pfi12 = Fi12.PCurveOnSurf()->Value(Fi12.Parameter(isfirst));
706   isfirst=sens2==1;
707   if (Com11.Point().Distance(Com21.Point()) <1.e-4) { 
708     pfi21 = Fi21.PCurveOnSurf()->Value(Fi21.Parameter(isfirst)); 
709     pfi22 = Fi22.PCurveOnSurf()->Value(Fi22.Parameter(isfirst));
710   }
711   else {
712     pfi22 = Fi21.PCurveOnSurf()->Value(Fi21.Parameter(isfirst));        
713     pfi21 = Fi22.PCurveOnSurf()->Value(Fi22.Parameter(isfirst));
714   }
715   
716   Pardeb(1)= pfi11.X();Pardeb(2) = pfi11.Y();
717   Pardeb(3)= pfi21.X();Pardeb(4) = pfi21.Y();
718   Parfin(1)= pfi12.X();Parfin(2) = pfi12.Y();
719   Parfin(3)= pfi22.X();Parfin(4) = pfi22.Y();
720
721   Handle(GeomAdaptor_HSurface) HS1= ChFi3d_BoundSurf(DStr,Fd1,1,2);
722   Handle(GeomAdaptor_HSurface) HS2= ChFi3d_BoundSurf(DStr,Fd2,1,2);
723   trouve=Standard_False;
724   if (ChFi3d_ComputeCurves(HS1,HS2,Pardeb,Parfin,cint,
725                            C2dint1,C2dint2,1.e-4,1.e-5,tol)){
726     cint->D0(cint->FirstParameter(),P1);
727     cint->D0(cint->LastParameter(),P2);
728     trouve=((Com11.Point().Distance(P1) <1.e-4 || Com11.Point().Distance(P2)<1.e-4)&&
729             (Com12.Point().Distance(P1) <1.e-4 || Com12.Point().Distance(P2)<1.e-4));
730   }
731
732   if (trouve) {
733     isfirst=sens1==1;
734     stripe1->InDS(isfirst);
735     indpoint1=ChFi3d_IndexPointInDS(Com11,DStr);
736     indpoint2=ChFi3d_IndexPointInDS(Com12,DStr);
737     stripe1->SetIndexPoint(indpoint1,isfirst,1);
738     stripe1->SetIndexPoint(indpoint2,isfirst,2);
739     isfirst=sens2==1;
740     stripe2->InDS(isfirst); 
741     if (Com11.Point().Distance(Com21.Point()) <1.e-4) {
742       stripe2->SetIndexPoint(indpoint1,isfirst,1);
743       stripe2->SetIndexPoint(indpoint2,isfirst,2);
744     }
745     else {
746       stripe2->SetIndexPoint(indpoint2,isfirst,1);
747       stripe2->SetIndexPoint(indpoint1,isfirst,2);
748     }
749     
750     orsurf1=Fd1->Orientation();
751     trafil1 = DStr.Shape(Fd1->IndexOfS1()).Orientation();
752     trafil1 = TopAbs::Compose(trafil1,Fd1->Orientation());
753     trafil1 = TopAbs::Compose(TopAbs::Reverse(Fi11.Transition()),trafil1);
754     orsurf2=Fd2->Orientation();
755     TopOpeBRepDS_Curve tcurv3d(cint,tol);
756     indcurve= DStr.AddCurve(tcurv3d);
757     cint->D0(cint->FirstParameter(),P1);
758     cint->D0(cint->LastParameter(),P2);
759     Fi11.PCurveOnFace()->D0(Fi11.LastParameter(),p2d);
760     const Handle(Geom_Surface) Stemp = 
761       BRep_Tool::Surface(TopoDS::Face(DStr.Shape(Fd1->IndexOfS1())));
762     Stemp ->D0(p2d.X(),p2d.Y(),P4);
763     Fi11.PCurveOnFace()->D0(Fi11.FirstParameter(),p2d);
764     Stemp ->D0(p2d.X(),p2d.Y(),P3);
765     if (P1.Distance(P4)<1.e-4  || P2.Distance(P3)<1.e-4)
766       orpcurve=trafil1;
767     else  orpcurve=TopAbs::Reverse(trafil1);
768     if (Com11.Point().Distance(P1) >1.e-4) {
769       ind=indpoint1;
770       indpoint1=indpoint2;
771       indpoint2=ind;
772     }    
773     Interfp1=ChFi3d_FilPointInDS(TopAbs_FORWARD,indcurve, indpoint1, cint->FirstParameter());
774     Interfp2=ChFi3d_FilPointInDS(TopAbs_REVERSED,indcurve,indpoint2, cint->LastParameter());
775     DStr.ChangeCurveInterferences(indcurve).Append(Interfp1);
776     DStr.ChangeCurveInterferences(indcurve).Append(Interfp2);
777     Interfc=ChFi3d_FilCurveInDS(indcurve,indic1,C2dint1,orpcurve);
778     DStr.ChangeSurfaceInterferences(indic1).Append(Interfc);
779     if (orsurf1==orsurf2) orpcurve=TopAbs::Reverse(orpcurve);
780     Interfc=ChFi3d_FilCurveInDS(indcurve,indic2,C2dint2,orpcurve);
781     DStr.ChangeSurfaceInterferences(indic2).Append(Interfc);
782   }   
783 }
784
785 //=======================================================================
786 //function : CpOnEdge
787 //purpose  : determine if surfdata num has a common point on Eadj1 or Eadj2
788 //=======================================================================
789
790 static void  CpOnEdge (const  Handle(ChFiDS_Stripe) & stripe,
791                        Standard_Integer num,
792                        Standard_Boolean isfirst,
793                        const TopoDS_Edge & Eadj1,
794                        const TopoDS_Edge & Eadj2,
795                        Standard_Boolean & compoint)
796
797 { ChFiDS_CommonPoint cp1,cp2;
798   compoint=Standard_False;  
799   cp1 = stripe->SetOfSurfData()->Value(num)->ChangeVertex (isfirst,1);
800   cp2 = stripe->SetOfSurfData()->Value(num)->ChangeVertex (isfirst,2);
801   if(cp1.IsOnArc()){
802     if (cp1.Arc().IsSame(Eadj1)||cp1.Arc().IsSame(Eadj2))
803       compoint=Standard_True;
804   } 
805   if(cp2.IsOnArc()){
806     if (cp2.Arc().IsSame(Eadj1)||cp2.Arc().IsSame(Eadj2))
807       compoint=Standard_True; 
808   } 
809 }
810
811 //=======================================================================
812 //function : RemoveSurfData
813 //purpose  : for each stripe removal of unused surfdatas 
814 //=======================================================================
815
816 static void RemoveSurfData (const ChFiDS_StripeMap & myVDataMap,
817                             const ChFiDS_Map & myEFMap,
818                             const TopoDS_Edge &edgecouture,
819                             const TopoDS_Face & facecouture,
820                             const TopoDS_Vertex &V1)
821 { ChFiDS_ListIteratorOfListOfStripe It;
822   Standard_Boolean isfirst;
823   TopoDS_Edge Ecur,Eadj1,Eadj2;
824   TopoDS_Face Fg,Fd,F1,F2;
825   TopoDS_Vertex Vbid;
826   Standard_Integer nbsurf,nbedge,sense,num;
827   for (It.Initialize(myVDataMap(V1));It.More();It.Next()) {
828     nbsurf= It.Value()->SetOfSurfData()->Length();
829     nbedge = It.Value()->Spine()->NbEdges();
830     if  (nbsurf!=1){
831       num=ChFi3d_IndexOfSurfData(V1,It.Value(),sense);
832       if (sense==1) 
833         Ecur = It.Value()->Spine()->Edges(1);
834       else  
835         Ecur = It.Value()->Spine()->Edges(nbedge);
836       ChFi3d_edge_common_faces(myEFMap(Ecur),F1,F2);
837       if (F1.IsSame(facecouture)) Eadj1=edgecouture; 
838       else ChFi3d_cherche_element(V1,Ecur,F1,Eadj1,Vbid);
839       ChFi3d_edge_common_faces(myEFMap(Eadj1),Fg,Fd);
840       if (F2.IsSame(facecouture)) Eadj2=edgecouture;
841       else ChFi3d_cherche_element(V1,Ecur,F2,Eadj2,Vbid);
842       ChFi3d_edge_common_faces(myEFMap(Eadj2),Fg,Fd); 
843       Standard_Boolean compoint=Standard_False;
844       isfirst=(sense==1); 
845       Standard_Integer ind;
846       if (sense==1) {
847         ind=0;
848         // among surfdatas find the greatest indice ind so that 
849         // surfdata could have one of commonpoint on Eadj1 and Eadj2
850         // remove surfdata from 1 to ind-1   
851         for (Standard_Integer i=1;i<=nbsurf;i++) {
852           CpOnEdge (It.Value(),i,isfirst,Eadj1,Eadj2,compoint);
853           if (compoint) ind=i;
854         }
855         if (ind>=2) RemoveSD(It.Value(),1,ind-1);
856       }
857       else {
858         ind=num;
859         // among surfdatas find the smallest indice ind so that 
860         // surfdata could have one of commonpoint on Eadj1 and Eadj2
861         // remove surfdata from ind+1 to num   
862         for (Standard_Integer i=num;i>=1;i--) {
863           CpOnEdge (It.Value(),i,isfirst,Eadj1,Eadj2,compoint);
864           if (compoint) ind=i;
865         }
866         if (ind<num) RemoveSD(It.Value(),ind+1,num);
867       }
868     }
869   }
870 }
871
872 //=======================================================================
873 //function : ParametrePlate
874 //purpose  : 
875 //=======================================================================
876
877 static void ParametrePlate(const Standard_Integer n3d,
878                            const GeomPlate_BuildPlateSurface & PSurf,
879                            const Handle(Geom_Surface) & Surf,
880                            const gp_Pnt & point,
881                            const Standard_Real apperror,
882                            gp_Pnt2d & uv)
883 {  Standard_Integer ip;
884    gp_Pnt P1;
885    Standard_Real par;
886    Standard_Boolean trouve=Standard_False;
887    for (ip=1;ip<=n3d && !trouve;ip++){
888      par=PSurf.Curves2d()->Value(ip)->FirstParameter();
889      PSurf.Curves2d()->Value(ip)->D0(par,uv);
890      Surf->D0(uv.X(),uv.Y(),P1);       
891      trouve=P1.IsEqual(point,apperror);
892      if (!trouve) {
893         par=PSurf.Curves2d()->Value(ip)->LastParameter();
894         PSurf.Curves2d()->Value(ip)->D0(par,uv);
895         Surf->D0(uv.X(),uv.Y(),P1);       
896         trouve=P1.IsEqual(point,apperror); 
897      } 
898   }
899 }
900
901 //=======================================================================
902 //function : SummarizeNormal
903 //purpose  : 
904 //=======================================================================
905
906 static void SummarizeNormal(const TopoDS_Vertex& V1,
907                             const TopoDS_Face& Fcur,
908                             const TopoDS_Edge& Ecur,
909                             gp_Vec& SumFaceNormalAtV1)
910 {
911   gp_Pnt2d uv1, uv2;
912   BRep_Tool::UVPoints(Ecur,Fcur,uv1,uv2);
913   if ( ! V1.IsSame(TopExp::FirstVertex(Ecur))) uv1 = uv2;
914   
915   gp_Pnt P;
916   gp_Vec d1U, d1V;
917   BRep_Tool::Surface(Fcur)->D1( uv1.X(), uv1.Y(), P, d1U, d1V);
918   gp_Vec N = d1U.Crossed(d1V);
919   if (Fcur.Orientation() == TopAbs_REVERSED) N.Reverse();
920   
921   if (N.SquareMagnitude() <= Precision::PConfusion()) return;
922   
923   SumFaceNormalAtV1 += N.Normalized();
924   SumFaceNormalAtV1.Normalize();
925 }
926
927 enum ChFi3d_SurfType { ChFiSURFACE, FACE1, FACE2 }; // for call SurfIndex(...)
928
929 //=======================================================================
930 //function : SurfIndex
931 //purpose  : 
932 //=======================================================================
933
934 static Standard_Integer SurfIndex(const ChFiDS_StripeArray1& StripeArray1,
935                                   const Standard_Integer     StripeIndex,
936                                   const Standard_Integer     SurfDataIndex,
937                                   const ChFi3d_SurfType      SurfType)
938 {
939   const Handle(ChFiDS_SurfData)& aSurfData =
940     StripeArray1(StripeIndex)->SetOfSurfData()->Value(SurfDataIndex);
941   switch (SurfType) {
942   case ChFiSURFACE: return aSurfData->Surf();
943   case FACE1:       return aSurfData->IndexOfS1();
944   case FACE2:       return aSurfData->IndexOfS2();
945   default:          return -1;
946   }
947 }
948
949 //=======================================================================
950 //function : PlateOrientation
951 //purpose  : Define Plate orientation compared to <theRefDir> previewing
952 //           that Plate surface can have a sharp angle with adjacent 
953 //           filet (bug occ266: 2 chamfs, OnSame and OnDiff) and
954 //           can be even twisted (grid tests cfi900 B1)
955 //=======================================================================
956
957 static TopAbs_Orientation PlateOrientation(const Handle(Geom_Surface)& thePlateSurf,
958                                            const Handle(TColGeom2d_HArray1OfCurve)& thePCArr,
959                                            const gp_Vec& theRefDir)
960 {
961   gp_Vec du,dv;
962   gp_Pnt pp1,pp2,pp3;
963   gp_Pnt2d uv;
964   Standard_Real fpar, lpar;
965   Standard_Real SumScal1 = 0, SumScal2 = 0;
966   
967   Standard_Integer i, nb = thePCArr->Upper();
968   Handle(Geom2d_Curve) aPC = thePCArr->Value(nb);
969   fpar = aPC->FirstParameter();
970   lpar = aPC->LastParameter();
971   aPC->D0( (fpar + lpar) / 2., uv);
972   thePlateSurf-> D0(uv.X(),uv.Y(),pp1);
973   aPC->D0( lpar ,uv);
974   thePlateSurf-> D0(uv.X(),uv.Y(),pp2);
975   
976   for (i=1; i<=nb; i++) {
977     aPC = thePCArr->Value(i);
978     fpar = aPC->FirstParameter();
979     lpar = aPC->LastParameter();
980     aPC->D0( fpar ,uv);
981     thePlateSurf -> D1(uv.X(),uv.Y(),pp2,du,dv);
982     gp_Vec n1 = du^dv;
983     n1.Normalize();
984     
985     aPC->D0( (fpar + lpar) / 2., uv);
986     thePlateSurf-> D0(uv.X(),uv.Y(),pp3);
987     
988     gp_Vec vv1(pp2,pp1), vv2(pp2,pp3);
989     gp_Vec n2 = vv2^vv1;
990     n2.Normalize();
991     
992     SumScal1 += n1*n2;
993     SumScal2 += n2*theRefDir;
994
995     pp1 = pp3;
996   }
997   if (SumScal2*SumScal1>0) return TopAbs_FORWARD;
998   else                     return TopAbs_REVERSED;
999 }
1000                                           
1001 //=======================================================================
1002 //function : PerformMoreThreeCorner
1003 //purpose  : Process case of a top with n edges.      
1004 //=======================================================================
1005
1006 void  ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
1007                                              const Standard_Integer nconges)
1008
1009 //    ========================================
1010 //             Initialisations
1011 //     ========================================
1012 #ifdef OCCT_DEBUG
1013   OSD_Chronometer ch;
1014 #endif 
1015   TopOpeBRepDS_DataStructure& DStr=myDS->ChangeDS();  
1016   const TopoDS_Vertex& V1 = myVDataMap.FindKey(Jndex);
1017   Standard_Integer nedge;
1018   Standard_Boolean bordlibre;
1019   TopoDS_Edge edgelibre1,edgelibre2;
1020 //  TopTools_ListIteratorOfListOfShape ItE;
1021   nedge=ChFi3d_NbNotDegeneratedEdges(V1,myVEMap);
1022   ChFi3d_ChercheBordsLibres(myVEMap,V1,bordlibre,edgelibre1,edgelibre2);
1023   Standard_Boolean droit=Standard_False;
1024   if (bordlibre) {nedge=(nedge-2)/2 +2;
1025      Standard_Real angedg=Abs(ChFi3d_AngleEdge(V1,edgelibre1,edgelibre2));
1026      droit=Abs(angedg-M_PI)<0.01;   
1027   }
1028   else  nedge=nedge/2;
1029   Standard_Integer size=nedge*2;
1030   ChFiDS_StripeArray1 CD(0,size);
1031   TColStd_Array1OfInteger jf(0,size);
1032   TColStd_Array1OfInteger Index(0,size);
1033   TColStd_Array1OfInteger Indice(0,size);
1034   TColStd_Array1OfInteger sens(0,size);
1035   TColStd_Array1OfInteger indcurve3d(0,size);
1036   TColStd_Array2OfInteger numfa( 0,size,0,size);
1037   TColStd_Array1OfInteger Order( 0,size);
1038   TColStd_Array2OfInteger i(0,size,0,size);
1039   TColStd_Array2OfInteger indpoint(0,size,0,1);
1040   TColStd_Array1OfBoolean  oksea(0,size);
1041   TColStd_Array1OfBoolean  sharp(0,size);
1042   TColStd_Array1OfBoolean regul(0,size);
1043   TColStd_Array2OfReal p (0,size,0,size);
1044   TColStd_Array1OfReal errapp (0,size);
1045   TopTools_Array1OfShape Evive(0,size);
1046   TopTools_Array2OfShape Fvive(0,size,0,size);
1047   TColStd_Array1OfBoolean ponctuel (0,size);
1048   TColStd_Array1OfBoolean samedge (0,size);
1049   TColStd_Array1OfBoolean moresurf (0,size);
1050   TColStd_Array1OfBoolean libre(0,size);
1051   TColStd_Array1OfBoolean tangentregul (0,size);
1052   TColStd_Array1OfBoolean isG1(0,size);
1053 //  for(Standard_Integer ind=0;ind<=size;ind++){
1054   Standard_Integer ind;
1055   for(ind=0;ind<=size;ind++){
1056    indpoint.SetValue(ind,0,0);
1057     indpoint.SetValue(ind,1,0);
1058     Indice.SetValue(ind,0);
1059     oksea.SetValue(ind,Standard_False);
1060     sharp.SetValue(ind,Standard_False);
1061     regul.SetValue(ind,Standard_False);
1062     ponctuel.SetValue(ind,Standard_False);
1063     samedge.SetValue(ind,Standard_False);
1064     moresurf.SetValue(ind,Standard_False);
1065     libre.SetValue(ind,Standard_False);
1066     tangentregul.SetValue(ind,Standard_False);
1067     isG1.SetValue(ind,Standard_False);
1068   }
1069   ChFiDS_ListIteratorOfListOfStripe It;
1070   Handle(ChFiDS_Stripe) cd2,cdbid,cnext;
1071   TopoDS_Face face;
1072   Standard_Integer jfp = 0,ii;
1073   Standard_Integer ic,icplus,icmoins,icplus2,
1074                    sense,index = 0,indice,isurf1,isurf2;
1075   Standard_Integer cbplus=0, n3d=0,IVtx = 0,nb;
1076   Standard_Boolean sameside,trouve,isfirst;
1077   Standard_Real pardeb ,parfin,xdir,ydir;
1078   Standard_Real tolapp=1.e-4,maxapp = 0.,maxapp1 = 0.,avedev;
1079   Handle (TopOpeBRepDS_CurvePointInterference) Interfp1, Interfp2;
1080   Handle (TopOpeBRepDS_SurfaceCurveInterference) Interfc;
1081   Handle(Geom_Curve) Curv3d;
1082   ChFiDS_Regul regular;
1083   TopTools_SequenceOfShape Fproj;
1084   Standard_Integer num;
1085   TopoDS_Edge Ecur; 
1086   TopTools_ListIteratorOfListOfShape ItF;
1087 #ifdef OCCT_DEBUG
1088 //  Standard_Integer nface=ChFi3d_nbface(myVFMap(V1));
1089 #endif
1090   TopoDS_Face F1,F2;
1091   gp_Vec SumFaceNormalAtV1(0,0,0); // is used to define Plate orientation 
1092
1093   // it is determined if there is a sewing edge
1094   Standard_Boolean couture=Standard_False;
1095   TopoDS_Face facecouture;
1096   TopoDS_Edge edgecouture;
1097   for(ItF.Initialize(myVFMap(V1));ItF.More()&&!couture;ItF.Next()) {
1098     TopoDS_Face fcur = TopoDS::Face(ItF.Value());
1099     ChFi3d_CoutureOnVertex(fcur,V1,couture,edgecouture);
1100     if (couture)
1101       facecouture=fcur;
1102   }
1103
1104 // unused surfdata are removed 
1105   RemoveSurfData (myVDataMap, myEFMap,edgecouture,facecouture,V1);
1106
1107  // parse edges and faces
1108   trouve=Standard_False;
1109   TopoDS_Edge Enext;
1110   TopoDS_Vertex VV;
1111   TopoDS_Face Fcur,Fnext;
1112   for (It.Initialize(myVDataMap(Jndex));It.More()&&!trouve;It.Next()) {
1113     cnext=It.Value();
1114     CD.SetValue(0,cnext);
1115     Index.SetValue(0,ChFi3d_IndexOfSurfData(V1,cnext,sense));
1116     sens.SetValue(0,sense);
1117     numfa.SetValue(0 ,1,SurfIndex(CD, 0, Index.Value(0), FACE2));
1118     numfa.SetValue(1 ,0, numfa.Value(0 ,1));
1119     Fcur=TopoDS::Face(DStr.Shape(numfa.Value(0,1)));
1120     Fvive.SetValue(0,1,Fcur);
1121     Fvive.SetValue(1,0,Fcur);
1122     jf.SetValue(0,2);
1123     if (sens.Value(0)==1) 
1124       Ecur = CD.Value(0)->Spine()->Edges(1);
1125     else  
1126       Ecur = CD.Value(0)->Spine()->Edges(CD.Value(0)->Spine()->NbEdges());
1127     Evive.SetValue(0,Ecur);
1128     ChFi3d_cherche_edge(V1,Evive,Fcur,Enext,VV);
1129     trouve= !Enext.IsNull();
1130   }
1131   // find sum of all face normals at V1
1132   SummarizeNormal(V1, Fcur, Ecur, SumFaceNormalAtV1);
1133   
1134   Standard_Integer nbcouture=0;
1135   for ( ii=1; ii<nedge; ii++) {
1136     if (Fcur.IsSame(facecouture)&& nbcouture==0) {
1137       Enext=edgecouture;
1138       nbcouture++;
1139     }
1140     else ChFi3d_cherche_edge(V1,Evive,Fcur,Enext,VV);
1141     if (Enext.IsNull())Standard_Failure::Raise
1142     ("PerformMoreThreeCorner: pb in the parsing of edges and faces"); 
1143     if (Enext.IsSame(edgelibre1)|| Enext.IsSame(edgelibre2)) {
1144       CD.SetValue(ii, cdbid);
1145       Index.SetValue(ii, 0);
1146       sens.SetValue(ii, -1);
1147       TopoDS_Vertex Vref;
1148       Vref = TopExp::FirstVertex(Enext);
1149       if (Vref.IsSame(V1)) sens.SetValue(ii, 1);   
1150       sharp.SetValue(ii, Standard_True);
1151       Evive.SetValue(ii, Enext);
1152       jf.SetValue(ii, 0);
1153       Indices(nedge,ii,icplus,icmoins);
1154       Fvive.SetValue(ii,icplus, Fcur);
1155       Fvive.SetValue(icplus,ii, Fcur);
1156       numfa.SetValue(ii,icplus, DStr.AddShape(Fcur));
1157       numfa.SetValue(icplus,ii,numfa.Value(ii,icplus));
1158       ii++;
1159       if (Enext.IsSame (edgelibre1)) Ecur=edgelibre2;
1160       else Ecur=edgelibre1;
1161       ChFi3d_edge_common_faces(myEFMap(Ecur),Fcur,Fcur);
1162       Indices(nedge,ii,icplus,icmoins);
1163       Fvive.SetValue(ii,icplus, Fcur);
1164       Fvive.SetValue(icplus,ii, Fcur);
1165       numfa.SetValue(ii,icplus, DStr.AddShape(Fcur));
1166       numfa.SetValue(icplus,ii,numfa.Value(ii,icplus));
1167       CD.SetValue(ii, cdbid);
1168       Index.SetValue(ii, 0);
1169       sens.SetValue(ii, -1);
1170       Vref = TopExp::FirstVertex(Ecur);
1171       if (Vref.IsSame(V1)) sens.SetValue(ii, 1);   
1172       sharp.SetValue(ii, Standard_True);
1173       Evive.SetValue(ii, Ecur);
1174       jf.SetValue(ii, 0); 
1175     }
1176     else {
1177 // it is found if Enext is in the map of stripes 
1178       TopoDS_Edge EE;
1179       /*Standard_Boolean */trouve = Standard_False;
1180       for (It.Initialize(myVDataMap(Jndex));It.More()&&!trouve;It.Next()) {
1181         index = ChFi3d_IndexOfSurfData(V1,It.Value(),sense);
1182         if (sense==1) 
1183           EE = It.Value()->Spine()->Edges(1);
1184         else  
1185           EE = It.Value()->Spine()->Edges(It.Value()->Spine()->NbEdges());
1186         if (Enext.IsSame(EE)) {
1187           cnext=It.Value();
1188           trouve=Standard_True;
1189         }
1190       }
1191       if (trouve) {
1192         CD.SetValue(ii, cnext);
1193         Index.SetValue(ii, index);
1194         sens.SetValue(ii, sense);
1195         sharp.SetValue(ii, Standard_False);
1196         Evive.SetValue(ii, Enext);
1197       }
1198       else {
1199         //      edge ii is alive
1200         CD.SetValue(ii, cdbid);
1201         Index.SetValue(ii, 0);
1202         sens.SetValue(ii, -1);
1203         TopoDS_Vertex Vref;
1204         Vref = TopExp::FirstVertex(Enext);
1205         if (Vref.IsSame(V1)) sens.SetValue(ii, 1);   
1206         sharp.SetValue(ii, Standard_True);
1207         Evive.SetValue(ii, Enext);
1208         jf.SetValue(ii, 0);
1209       }
1210       // Face Fnext!=Fcur containing Enext 
1211       Fnext=Fcur;
1212       ChFi3d_cherche_face1(myEFMap(Enext),Fcur,Fnext);
1213       Indices(nedge,ii,icplus,icmoins);
1214       Fvive.SetValue(ii,icplus, Fnext);
1215       Fvive.SetValue(icplus,ii, Fnext);
1216       numfa.SetValue(ii,icplus, DStr.AddShape(Fnext));
1217       numfa.SetValue(icplus,ii,numfa.Value(ii,icplus));
1218       Standard_Integer numface1,numface2;
1219       if (trouve) {
1220         // it is checked if numfa corresponds to IndexOfS1 or IndexOfS2 
1221         // jf is updated is consequently updated
1222         // if it is not the case among the previous faces are found 
1223         // those which correspond to  IndexOfs1 IndexOfS2  and  
1224         // numfa and Fvive are reupdated (cts16288)  
1225         numface2 = SurfIndex(CD, ii, Index.Value(ii), FACE2);
1226         if (numface2==numfa.Value(ii,icplus))
1227           jf.SetValue(ii, 2);
1228         else {
1229           numface1 = SurfIndex(CD, ii, Index.Value(ii), FACE1);
1230           if (numface1==numfa.Value(ii,icplus))
1231             jf.SetValue(ii, 1);
1232           else {
1233             if (numface1==numfa.Value(icmoins,ii))  {
1234               jf.SetValue(ii, 2);
1235               Fvive.SetValue(ii,icplus,TopoDS::Face(DStr.Shape(numface2)));
1236               Fvive.SetValue(icplus,ii,TopoDS::Face(DStr.Shape(numface2)));
1237               numfa.SetValue(ii,icplus, DStr.AddShape(TopoDS::Face(DStr.Shape(numface2))));
1238               numfa.SetValue(icplus,ii, numfa.Value (ii,icplus));
1239             }
1240             if (numface2==numfa.Value(icmoins,ii)) {
1241               jf.SetValue(ii, 1);
1242               Fvive.SetValue(ii,icplus,TopoDS::Face(DStr.Shape(numface1)));
1243               Fvive.SetValue(icplus,ii,TopoDS::Face(DStr.Shape(numface1)));
1244               numfa.SetValue(ii,icplus, DStr.AddShape(TopoDS::Face(DStr.Shape(numface1))));
1245               numfa.SetValue(icplus,ii, numfa.Value (ii,icplus));
1246             }
1247           }
1248         }
1249       }
1250       Ecur = Enext;
1251       Fcur = Fnext;
1252       // find sum of all face normales at V1
1253       SummarizeNormal(V1, Fcur, Ecur, SumFaceNormalAtV1);
1254     }
1255   }
1256   // mise a jour du tableau regul 
1257   for (ic=0;ic<nedge;ic++) {
1258     if (sharp.Value(ic)) {
1259       Ecur=TopoDS::Edge(Evive.Value(ic));
1260       if (!Ecur.IsSame(edgecouture)) {
1261         ChFi3d_edge_common_faces(myEFMap(Ecur),F1,F2);   
1262 //  Modified by Sergey KHROMOV - Fri Dec 21 18:11:02 2001 Begin
1263 //      regul.SetValue(ic,BRep_Tool::Continuity(TopoDS::Edge(Evive.Value(ic)),F1,F2)
1264 //                   !=GeomAbs_C0); 
1265         regul.SetValue(ic, ChFi3d_isTangentFaces(TopoDS::Edge(Evive.Value(ic)),F1,F2)); 
1266 //  Modified by Sergey KHROMOV - Fri Dec 21 18:11:07 2001 End
1267       }
1268     }
1269   }
1270   // it is checked if a regular edge is not tangent to another edge
1271   // in case if it is not considered regular (cts60072)
1272   for (ic=0;ic<nedge;ic++) {
1273     if (regul.Value(ic) ) {
1274       trouve=Standard_False;
1275       TopoDS_Edge ereg=TopoDS::Edge(Evive.Value(ic));
1276       for( ind=0;ind<nedge &&!trouve;ind++) {
1277         if (ind!=ic) {
1278           TopoDS_Edge ecur=TopoDS::Edge(Evive.Value(ind));
1279           Standard_Real ang=Abs(ChFi3d_AngleEdge(V1,ecur,ereg)); 
1280           if (ang<0.01 || Abs(ang-M_PI) <0.01) {
1281             regul.SetValue(ic,Standard_False);
1282             tangentregul.SetValue(ic,Standard_True);
1283             trouve=Standard_True;
1284           }  
1285         }
1286       }   
1287     }
1288   }
1289
1290   // variable deuxconges allows detecting cases when there is a top with 
1291   // n edges and two fillets on two tangent edges that are not free borders
1292   // the connecting curves start from the fillet and end on top 
1293   
1294   Standard_Boolean deuxconges,deuxcgnontg;
1295   deuxconges=Standard_False;
1296   trouve=Standard_False;
1297   if (nconges==2) {
1298     TopoDS_Edge E1,E2; 
1299     for (ic=0;ic<nedge&&!trouve;ic++) {
1300       Indices(nedge,ic,icplus,icmoins);
1301       if (!sharp.Value(ic) && !sharp.Value(icplus)){
1302         E1=TopoDS::Edge(Evive.Value(ic));
1303         E2=TopoDS::Edge(Evive.Value(icplus));                                   
1304         deuxconges=(Abs(ChFi3d_AngleEdge(V1 ,E1,E2)   )<0.01) ;
1305         trouve=deuxconges;
1306       }
1307     }
1308   }
1309
1310   // variable deuxconges is used in the special case when there are 
1311   // two fillets and if two other living edges are tangent (cts60072) 
1312   if (nconges==2 && nedge==4) {
1313     TopoDS_Edge E1,E2; 
1314      for (ic=0;ic<nedge&&!deuxconges;ic++) {
1315        Indices(nedge,ic,icplus,icmoins);
1316        if (sharp.Value(ic) && sharp.Value(icplus)){
1317          E1=TopoDS::Edge(Evive.Value(ic));
1318          E2=TopoDS::Edge(Evive.Value(icplus));
1319          if ( !E1.IsSame(edgelibre1) && !E1.IsSame(edgelibre2) &&
1320               !E2.IsSame(edgelibre1) && !E2.IsSame(edgelibre2)){ 
1321            Standard_Real ang=Abs(ChFi3d_AngleEdge(V1 ,E1,E2));
1322            deuxconges=(ang<0.01 || Abs(ang-M_PI)<0.01);
1323          }
1324        }
1325      }
1326   }
1327   
1328   deuxcgnontg=nconges==2&& nedge==3 && !deuxconges; // pro12305 
1329
1330   if (deuxconges )
1331   for  (ic=0;ic<nedge;ic++){
1332    regul.SetValue(ic,Standard_False);
1333   }
1334
1335   // Detect case of 3 edges & 2 conges: OnSame + OnDiff
1336   // (eap, Arp 9 2002, occ266)
1337   Standard_Boolean isOnSameDiff = Standard_False;
1338   if (deuxcgnontg) {
1339     Standard_Boolean isOnSame = Standard_False, isOnDiff = Standard_False;
1340     for (ic=0; ic<nedge; ic++) {
1341       if (sharp.Value(ic)) continue;
1342       ChFiDS_State stat;
1343       if ( sens(ic) == 1 )
1344         stat = CD.Value(ic)->Spine()->FirstStatus();
1345       else
1346         stat = CD.Value(ic)->Spine()->LastStatus();
1347       
1348       if      (stat == ChFiDS_OnSame) isOnSame = Standard_True;
1349       else if (stat == ChFiDS_OnDiff) isOnDiff = Standard_True;
1350     }
1351     isOnSameDiff = isOnSame && isOnDiff;
1352   }
1353   if ( isOnSameDiff ) {
1354 #ifdef OCCT_DEBUG
1355     cout << "OnSame + OnDiff, PerformMoreThreeCorner() calls PerformOneCorner()" << endl;
1356 #endif
1357     PerformOneCorner (Jndex, Standard_True);
1358   }
1359
1360 // if the commonpoint is on an edge that does not have a 
1361 // vertex at the extremity, Evive is found anew    
1362 // Fvive is found anew if it does not correspond 
1363 // to two faces adjacent to Evive (cts16288)
1364
1365   if (!deuxconges && !isOnSameDiff) 
1366     for (ic=0;ic<nedge;ic++) { 
1367       if (sharp.Value(ic)) {
1368         Indices(nedge,ic,icplus,icmoins);
1369         TopoDS_Edge Arc=TopoDS::Edge(Evive.Value(ic));
1370         ChFiDS_CommonPoint cp1, cp2;
1371         Standard_Real angedg=M_PI;
1372         TopoDS_Vertex Vcom;
1373         if (!sharp.Value(icplus)) {
1374           isfirst=(sens.Value(icplus)==1);
1375           jfp = 3 - jf.Value(icplus);
1376           cp1 = CD.Value(icplus)->SetOfSurfData()->Value(Index.Value(icplus))->
1377             ChangeVertex (isfirst,jfp);
1378           if (cp1.IsOnArc()){
1379             ChFi3d_cherche_vertex(Arc,cp1.Arc(),Vcom,trouve);
1380             if (trouve) angedg=Abs(ChFi3d_AngleEdge(Vcom,Arc,cp1.Arc()));
1381             if (!cp1.Arc().IsSame(Arc) && Abs(angedg-M_PI)<0.01){
1382               Evive.SetValue(ic,cp1.Arc());
1383               ChFi3d_edge_common_faces(myEFMap(cp1.Arc()),F1,F2);
1384               if (!Fvive.Value(ic,icplus).IsSame(F1) && !Fvive.Value(ic,icplus).IsSame(F2)) {
1385                 if (Fvive.Value(ic,icmoins).IsSame(F2))  {
1386                   Fvive.SetValue(ic,icplus,F1);
1387                   Fvive.SetValue(icplus,ic,F1);
1388                   numfa.SetValue(ic,icplus,DStr.AddShape(F1)); 
1389                   numfa.SetValue(icplus,ic,DStr.AddShape(F1)); 
1390                 }
1391                 else  {
1392                   Fvive.SetValue(ic,icplus,F2);
1393                   Fvive.SetValue(icplus,ic,F2);
1394                   numfa.SetValue(ic,icplus,DStr.AddShape(F2)); 
1395                   numfa.SetValue(icplus,ic,DStr.AddShape(F2)); 
1396                 }
1397               }
1398               samedge.SetValue(ic,Standard_True);
1399               p.SetValue(ic,icplus,cp1.ParameterOnArc());
1400               p.SetValue(ic,icmoins,cp1.ParameterOnArc());  
1401               i.SetValue(ic,icplus,1);        
1402             }
1403           }
1404         }
1405         if (!sharp.Value(icmoins)) {
1406           isfirst=(sens.Value(icmoins)==1);
1407           cp2 = CD.Value(icmoins)->SetOfSurfData()->Value(Index.Value(icmoins))->
1408             ChangeVertex (isfirst,jf.Value(icmoins));
1409           if (cp2.IsOnArc()) {
1410             angedg=M_PI;
1411             ChFi3d_cherche_vertex(Arc,cp2.Arc(),Vcom,trouve);
1412             if (trouve) angedg=Abs(ChFi3d_AngleEdge(Vcom,Arc,cp2.Arc()));
1413             if (!cp2.Arc().IsSame(Arc)&&Abs(angedg-M_PI)<0.01) {
1414               Evive.SetValue(ic,cp2.Arc());
1415               ChFi3d_edge_common_faces(myEFMap(cp2.Arc()),F1,F2);
1416               if (!Fvive.Value(ic,icmoins).IsSame(F1) && !Fvive.Value(ic,icmoins).IsSame(F2)) {
1417                 if (Fvive.Value(ic,icplus).IsSame(F2))  {
1418                   Fvive.SetValue(ic,icmoins,F1);
1419                   numfa.SetValue(ic,icmoins,DStr.AddShape(F1));
1420                   Fvive.SetValue(icmoins,ic,F1);
1421                   numfa.SetValue(icmoins,ic,DStr.AddShape(F1)); 
1422                 }
1423                 else  {
1424                   Fvive.SetValue(ic,icmoins,F2);
1425                   numfa.SetValue(ic,icmoins,DStr.AddShape(F2));
1426                   Fvive.SetValue(icmoins,ic,F2);
1427                   numfa.SetValue(icmoins,ic,DStr.AddShape(F2)); 
1428                 }
1429               }
1430               samedge.SetValue(ic,Standard_True);
1431               p.SetValue(ic,icmoins,cp2.ParameterOnArc());
1432               p.SetValue(ic,icplus,cp2.ParameterOnArc());
1433               i.SetValue(ic,icmoins,1);   
1434             }
1435           }
1436         }     
1437       }
1438     } 
1439
1440 // the first free edge is restored if it exists
1441   trouve=Standard_False;
1442   for (ic=0; ic<nedge&&!trouve;ic++) {  
1443     TopoDS_Edge ecom;
1444     ecom=TopoDS::Edge(Evive.Value(ic));
1445     if (ecom.IsSame(edgelibre1)||ecom.IsSame(edgelibre2)){ 
1446       libre.SetValue(ic,Standard_True);
1447       trouve=Standard_True;
1448     }
1449   }  
1450
1451 // determine the minimum recoil distance that can't be exceeded 
1452   Standard_Boolean distmini=Standard_False;
1453   gp_Pnt som=BRep_Tool::Pnt(V1),pic;  
1454   gp_Pnt2d p2;
1455   TopoDS_Edge edgemin;
1456   TopoDS_Vertex V,V2;
1457   Standard_Real dst,distmin;
1458   distmin=1.e30;
1459   for (ic=0;ic<nedge;ic++) {
1460     if (sharp.Value(ic))
1461       edgemin=TopoDS::Edge(Evive.Value(ic));
1462     else {
1463       if (sens.Value(ic)==1) 
1464         edgemin= CD.Value(ic)->Spine()->Edges(1);
1465       else  
1466         edgemin = CD.Value(ic)->Spine()->Edges(CD.Value(ic)->Spine()->NbEdges());
1467     }
1468     V=TopExp::FirstVertex(edgemin);
1469     V2=TopExp::LastVertex(edgemin);
1470     dst=(BRep_Tool::Pnt(V)).Distance(BRep_Tool::Pnt(V2))/1.5;
1471     if (dst<distmin) distmin=dst;
1472   }
1473
1474 //  calculate intersections between stripes and determine the parameters on each pcurve  
1475   Standard_Boolean inters=Standard_True;
1476   for (ic=0;ic<nedge;ic++) {
1477     Indices(nedge,ic,icplus,icmoins);
1478     if (sharp.Value(ic)||sharp.Value(icplus)) {
1479       oksea.SetValue(ic, Standard_False);
1480     }
1481     else {
1482       Standard_Integer jf1 = 0;
1483       Standard_Integer i1 = 0,i2 = 0;
1484       Standard_Real pa1 = 0.,pa2;
1485       Standard_Boolean ok;
1486       Handle(ChFiDS_Stripe) strip;
1487       Standard_Real angedg;
1488       Standard_Integer iface;
1489       // if two edges are tangent the intersection is not attempted (cts60046)
1490       angedg=Abs(ChFi3d_AngleEdge(V1,TopoDS::Edge(Evive.Value(ic)),TopoDS::Edge(Evive.Value(icplus))));
1491       if (Abs(angedg-M_PI)>0.01)
1492         ok = ChFi3d_SearchFD(DStr,CD.Value(ic),CD.Value(icplus),sens.Value(ic),sens.Value(icplus),
1493                                   i1,i2,pa1,pa2,
1494                                   Index.Value(ic),Index.Value(icplus),
1495                                   face,sameside,jf1,jfp);
1496       else ok=Standard_False;
1497      // if there is an intersection it is checked if surfdata with the intersection
1498      // corresponds to the first or the last 
1499      // if this is not the case, the surfdata are removed from SD 
1500       
1501       if (ok) {
1502         if (i1!=Index.Value(ic) ){
1503           Standard_Integer ideb,ifin;
1504           strip=CD.Value(ic);
1505           if (sens.Value(ic)==1) {
1506             ideb=Index.Value(ic);
1507             ifin=i1-1;
1508           }
1509           else {
1510             ifin=Index.Value(ic);
1511             ideb=i1+1;
1512           }
1513           if (i1<Index.Value(ic)) {
1514             for (nb=Index.Value(ic);nb>=i1;nb--) {
1515               if ((3-jf1)==1) 
1516                 iface=SurfIndex(CD, ic, nb , FACE1);
1517               else    iface=SurfIndex(CD, ic, nb , FACE2);
1518               Fproj.Append(TopoDS::Face(myDS->Shape(iface)));  
1519             }
1520           }
1521           if (i1>Index.Value(ic)) {
1522             for (nb=Index.Value(ic);nb<=i1;nb++) {
1523               if ((3-jf1)==1) 
1524                 iface=SurfIndex(CD, ic, nb , FACE1);
1525               else    iface=SurfIndex(CD, ic, nb , FACE2);
1526                Fproj.Append(TopoDS::Face(myDS->Shape(iface)));  
1527             }
1528           }    
1529           strip=CD.Value(ic);
1530           RemoveSD(strip,ideb,ifin);
1531           num=ChFi3d_IndexOfSurfData(V1,CD.Value(ic),sense);
1532           Index.SetValue(ic,num);
1533           i1=num; 
1534         }
1535         if (i2!=Index.Value(icplus) ){
1536           Standard_Integer ideb,ifin;
1537           strip=CD.Value(icplus);
1538           if (sens.Value(icplus)==1) {
1539             ideb=Index.Value(icplus);
1540             ifin=i2-1;
1541           }
1542           else {
1543             ifin=Index.Value(icplus);
1544             ideb=i2+1;
1545           }
1546           
1547           if (i2<Index.Value(icplus)) {
1548             for (nb=i2;nb<=Index.Value(icplus);nb++) {
1549               if ((3-jfp)==1) 
1550                 iface=SurfIndex(CD, icplus, nb , FACE1);
1551               else    iface=SurfIndex(CD, icplus, nb , FACE2);
1552               Fproj.Append(TopoDS::Face(myDS->Shape(iface)));  
1553             }
1554           }
1555           if (i2>Index.Value(icplus)) {
1556             for (nb=i2;nb>=Index.Value(icplus);nb--) {
1557               if ((3-jfp)==1) 
1558                 iface=SurfIndex(CD, icplus, nb , FACE1);
1559               else    iface=SurfIndex(CD, icplus, nb , FACE2);
1560               Fproj.Append(TopoDS::Face(myDS->Shape(iface)));  
1561             }
1562           }    
1563           RemoveSD(strip,ideb,ifin);
1564           num=ChFi3d_IndexOfSurfData(V1,CD.Value(icplus),sense);
1565           Index.SetValue(icplus,num);
1566           i2=num; 
1567       }
1568         Calcul_P2dOnSurf(CD.Value(ic),jf1,i1,pa1,p2);
1569         indice=SurfIndex(CD, ic, i1, ChFiSURFACE);
1570         DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),pic);
1571         if (pic.Distance(som)>distmin) distmini =Standard_True;
1572         jf.SetValue(ic,jf1);
1573         i.SetValue(ic,icplus,i1);
1574         i.SetValue(icplus,ic,i2);
1575         p.SetValue(ic,icplus,pa1);
1576         p.SetValue(icplus,ic,pa2);
1577       }
1578       oksea.SetValue(ic, ok);
1579     }
1580     if (!oksea.Value(ic) ) inters=Standard_False; 
1581   }
1582
1583   // case if there are only intersections 
1584   // the parametres on Pcurves are the extremities of the stripe
1585   Standard_Real para;
1586   if (!inters) {
1587     for (ic=0;ic<nedge;ic++) {
1588       Indices(nedge,ic,icplus,icmoins);
1589       Indices(nedge,icplus,icplus2,ic);
1590       if (!oksea.Value(ic)) {
1591         cbplus++;
1592         if (sharp.Value(ic)) {
1593           if (!samedge.Value(ic)){
1594             para=BRep_Tool::Parameter(V1,TopoDS::Edge(Evive.Value(ic)));
1595             p.SetValue(ic,icplus,para);
1596             i.SetValue(ic,icplus,1);
1597           }
1598         }
1599         else {
1600           isfirst= (sens.Value(ic)==1);
1601           i.SetValue(ic,icplus,ChFi3d_IndexOfSurfData(V1,CD.Value(ic),sense));
1602           if (oksea.Value(icmoins)) {
1603            para=p.Value(ic,icmoins);
1604            p.SetValue(ic,icplus,para);
1605           }
1606           else {
1607             Calcul_Param(CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),isfirst,para);
1608             p.SetValue(ic,icplus,para);
1609           }
1610         }
1611         if (sharp.Value(icplus)) {
1612           if (!samedge.Value(icplus)) {
1613             para=BRep_Tool::Parameter(V1,TopoDS::Edge(Evive.Value(icplus)));
1614             p.SetValue(icplus,ic, para);
1615             i.SetValue(icplus,ic,1);
1616           }
1617         }
1618         else {
1619           isfirst= (sens.Value(icplus)==1);
1620           i.SetValue(icplus,ic,ChFi3d_IndexOfSurfData(V1,CD.Value(icplus),sense));
1621           if (oksea.Value(icplus)){
1622           para=p.Value(icplus,icplus2);
1623           p.SetValue(icplus,ic,para);
1624           }
1625           else {
1626             jfp = 3 - jf.Value(icplus);
1627             Calcul_Param(CD.Value(icplus),jfp,i.Value(icplus,ic),isfirst,para);
1628             p.SetValue(icplus,ic,para);
1629           }
1630         }
1631       }
1632     }
1633       
1634 //  calculate max distance to the top at each point  
1635     TColStd_Array1OfReal dist1(0,size);
1636     TColStd_Array1OfReal dist2(0,size);
1637     Standard_Real distance=0.;
1638     gp_Pnt sommet=BRep_Tool::Pnt(V1);
1639     if (!deuxconges)
1640     for (ic=0;ic<nedge;ic++) {
1641       Indices(nedge,ic,icplus,icmoins);
1642       if (sharp.Value(ic)) {
1643         dist1.SetValue(ic, 0);
1644         dist2.SetValue(ic, 0);
1645       }
1646       else {        
1647         jfp = 3 - jf.Value(ic);       
1648         Calcul_P2dOnSurf(CD.Value(ic),jfp,i.Value(ic,icmoins),p.Value(ic,icmoins),p2);
1649         indice=SurfIndex(CD, ic, i.Value(ic,icmoins), ChFiSURFACE);
1650         DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),pic);
1651         dist1.SetValue(ic, sommet.Distance(pic));
1652         if (dist1.Value(ic) > distance ) distance= dist1.Value(ic);
1653
1654         Calcul_P2dOnSurf(CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),p.Value(ic,icplus),p2);
1655         indice=SurfIndex(CD, ic, i.Value(ic,icplus), ChFiSURFACE);
1656         DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),pic);
1657         dist2.SetValue(ic, sommet.Distance(pic));
1658         if( dist2.Value(ic) > distance  )  
1659           distance= dist2.Value(ic);
1660       }
1661     }
1662
1663 //  offset of parameters and removal of intersection points 
1664 //  too close to the top 
1665
1666     Standard_Real ec, dist; 
1667     if (!deuxconges && !deuxcgnontg)
1668     for (ic=0;ic<nedge;ic++) {
1669       Indices(nedge,ic,icplus,icmoins);
1670       if (sharp.Value(ic) ) {
1671         BRepAdaptor_Curve C(TopoDS::Edge(Evive.Value(ic)));
1672         // to pass from 3D distance to a parametric distance
1673         if (!tangentregul(ic))
1674           ec = distance*100*C.Resolution(0.01);
1675         else ec=0.0;
1676         if (TopExp::FirstVertex(TopoDS::Edge(Evive.Value(ic))).IsSame(V1)) {
1677           para=p.Value(ic,icmoins) + ec;
1678           p.SetValue(ic,icmoins, para);
1679         }
1680         else {
1681           para=p.Value(ic,icmoins) - ec;
1682           p.SetValue(ic,icmoins,para);
1683         }
1684 // it is necessary to be on to remain on the edge
1685         p.SetValue(ic,icplus, p.Value(ic,icmoins));
1686       }
1687       else if (!distmini) {
1688         dist = dist1.Value(ic);
1689         if ((!oksea.Value(icmoins))||(oksea.Value(icmoins)&&(distance>1.3*dist))) {
1690           ec= distance-dist;
1691           if (oksea.Value(icmoins)) {
1692             oksea.SetValue(icmoins,Standard_False);
1693             inters=Standard_False;
1694             cbplus++;
1695           }
1696           if (sens.Value(ic)==1) {
1697             para=p.Value(ic,icmoins) + ec;
1698             p.SetValue(ic,icmoins, para);
1699           }
1700           else{
1701              para=p.Value(ic,icmoins) - ec;
1702              p.SetValue(ic,icmoins,para);
1703           }
1704         }
1705         dist = dist2.Value(ic);
1706         if ((!oksea.Value(ic))||(oksea.Value(ic)&&(distance>1.3*dist))) {
1707           if(oksea.Value(ic)) { 
1708             oksea.SetValue(ic,Standard_False);
1709             inters=Standard_False;
1710             cbplus++;
1711           }
1712           if (nconges!=1) {
1713             Standard_Real parold,parnew;
1714             parold=p.Value(ic,icplus);
1715             parnew=p.Value(ic,icmoins);
1716             if (sens.Value(ic)==1) {
1717               if (parnew> parold) p.SetValue(ic,icplus, p.Value(ic,icmoins));
1718             }
1719             else {
1720               if (parnew<parold) p.SetValue(ic,icplus, p.Value(ic,icmoins));
1721             }
1722           }  
1723         }
1724       }
1725     }
1726   }
1727
1728 // it is attempted to limit the edge by a commonpoint
1729 //
1730  
1731   Standard_Real tolcp=0;
1732   gp_Pnt PE, sommet=BRep_Tool::Pnt(V1);
1733   if (!deuxconges)  
1734   for (ic=0;ic<nedge;ic++) {
1735     if (sharp.Value(ic)) {
1736       Indices(nedge,ic,icplus,icmoins);
1737       BRepAdaptor_Curve C(TopoDS::Edge(Evive.Value(ic)));
1738       PE = C.Value(p.Value(ic,icplus));
1739       Standard_Real d1=0., d2=0., dS = PE.Distance(sommet);
1740       ChFiDS_CommonPoint cp1, cp2;
1741       if (!sharp.Value(icplus)) {
1742         isfirst=(sens.Value(icplus)==1);
1743         jfp = 3 - jf.Value(icplus);
1744         cp1 = CD.Value(icplus)->SetOfSurfData()->Value(i.Value(icplus,ic))->
1745           ChangeVertex (isfirst,jfp);
1746         d1 = cp1.Point().Distance(sommet);
1747       }
1748       if (!sharp.Value(icmoins)) {
1749         isfirst=(sens.Value(icmoins)==1);
1750         cp2 = CD.Value(icmoins)->SetOfSurfData()->Value(i.Value(icmoins,ic))->
1751           ChangeVertex (isfirst,jf.Value(icmoins));
1752         d2 = cp2.Point().Distance(sommet);
1753       }
1754       Standard_Boolean samecompoint=Standard_False;
1755       if (!sharp.Value(icmoins) &&  !sharp.Value(icplus))
1756         samecompoint=cp1.Point().Distance(cp2.Point())<tolapp;
1757       if ((dS<d1 || dS<d2)&& !samecompoint) {
1758 // step back till Common Points
1759 // without leaving the Edge ??
1760         if (d2<d1 &&cp1.IsOnArc() ) {
1761 // cp1 is chosen
1762           p.SetValue(ic,icmoins, cp1.ParameterOnArc());
1763           p.SetValue(ic,icplus, p.Value(ic,icmoins));
1764           isfirst=(sens.Value(icplus)==1);
1765           jfp = 3 - jf.Value(icplus);
1766           Calcul_Param(CD.Value(icplus),jfp,i.Value(icplus,ic),isfirst,para);
1767           p.SetValue(icplus,ic,para);
1768           if (cp1.Tolerance()>tolcp &&cp1.Tolerance()<1 ) tolcp=cp1.Tolerance();
1769         }
1770         else if( cp2.IsOnArc()){
1771 // cp2 is chosen
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();
1778         }
1779       }
1780       else {
1781 // step back till Common Point only if it is very close
1782         if (!sharp.Value(icplus)) {
1783           if ((cp1.Point().Distance(PE)<cp1.Tolerance() || 
1784                samecompoint || nconges==1) && cp1.IsOnArc()) {
1785 // it is very close to cp1
1786             p.SetValue(ic,icmoins, cp1.ParameterOnArc());
1787             ponctuel.SetValue(ic,Standard_True);
1788             p.SetValue(ic,icplus, p.Value(ic,icmoins));
1789             isfirst=(sens.Value(icplus)==1);
1790             jfp = 3 - jf.Value(icplus);
1791             Calcul_Param(CD.Value(icplus),jfp,i.Value(icplus,ic),isfirst,para);
1792             p.SetValue(icplus,ic,para);
1793             if (cp1.Tolerance()>tolcp &&cp1.Tolerance()<1) tolcp=cp1.Tolerance();
1794           }
1795         }
1796          if (!sharp.Value(icmoins)){
1797           if ((cp2.Point().Distance(PE)<cp2.Tolerance() || 
1798                samecompoint || nconges==1) && cp2.IsOnArc()) {
1799 // it is very close to cp2
1800             ponctuel.SetValue(icmoins,Standard_True);
1801             p.SetValue(ic,icmoins, cp2.ParameterOnArc());
1802             p.SetValue(ic,icplus,p.Value(ic,icmoins));
1803             isfirst=(sens.Value(icmoins)==1);
1804             Calcul_Param(CD.Value(icmoins),jf.Value(icmoins),i.Value(icmoins,ic),isfirst,para);
1805             p.SetValue(icmoins,ic,para);
1806             if (cp2.Tolerance()>tolcp&&cp2.Tolerance()<1 ) tolcp=cp2.Tolerance();
1807           }
1808         }
1809       }
1810     }
1811   }
1812
1813 // in case of a free border the parameter corresponding 
1814 // to the common point on the free edge is chosen. 
1815
1816   for (ic=0;ic<nedge;ic++) {
1817     if (TopoDS::Edge(Evive.Value(ic)).IsSame(edgelibre1) || 
1818         TopoDS::Edge(Evive.Value(ic)).IsSame(edgelibre2)) {
1819       Standard_Integer indic;
1820       ChFiDS_CommonPoint CP1;
1821       Indices(nedge,ic,icplus,icmoins);
1822       if (libre.Value(ic))indic=icmoins;
1823       else indic=icplus;
1824       if (!sharp(indic)) {
1825         isfirst=sens.Value(indic)==1;         
1826         CP1 = CD.Value(indic)->SetOfSurfData()->Value(Index.Value(indic))->ChangeVertex(isfirst,1);
1827         /*Standard_Boolean*/ trouve=Standard_False;
1828         if (CP1.IsOnArc()) {
1829           if(CP1.Arc().IsSame(TopoDS::Edge(Evive.Value(ic)))) {
1830             p.SetValue(ic,icmoins,CP1.ParameterOnArc());
1831             p.SetValue(ic,icplus,CP1.ParameterOnArc());
1832             trouve=Standard_True;
1833           }  
1834         }
1835         if (!trouve) {
1836           CP1 = CD.Value(indic)->SetOfSurfData()->Value(Index.Value(indic))->ChangeVertex(isfirst,2);
1837           if (CP1.IsOnArc()) {
1838             if(CP1.Arc().IsSame(TopoDS::Edge(Evive.Value(ic)))) {
1839               p.SetValue(ic,icmoins,CP1.ParameterOnArc());
1840               p.SetValue(ic,icplus,CP1.ParameterOnArc());
1841             }  
1842           }
1843         }
1844       }
1845     }   
1846   }
1847
1848 // if ic is a regular edge, one finds edge indfin which is not 
1849 // a regular edge, and construtc a curve 3d 
1850 // between edges (or stripes ) icmoins and indfin. 
1851 // Then this courbe3d is projected on all faces (nbface) that
1852 // separate icmoins and indfin
1853   Standard_Integer nbface = 0;
1854   Standard_Real  error = 0.;
1855   TColGeom2d_Array1OfCurve proj2d1(0,size);
1856   TColGeom2d_Array1OfCurve proj2d2(0,size);
1857   TColGeom_Array1OfCurve cproj1(0,size);
1858   TColGeom_Array1OfCurve cproj2(0,size);
1859   if (!deuxconges) 
1860   for (ic=0;ic<nedge;ic++) {
1861     Standard_Integer ilin;
1862     TColGeom_SequenceOfCurve cr;
1863     TColGeom2d_SequenceOfCurve pr;
1864     TopTools_SequenceOfShape Lface;
1865     TopTools_SequenceOfShape Ledge;
1866     Lface.Clear();
1867     if (regul.Value(ic)){
1868       Indices(nedge,ic,icplus,icmoins);
1869       Indices(nedge,icplus,icplus2,ic);
1870       Standard_Integer indfin,indfinmoins,indfinplus;
1871       indfin=icplus;
1872       trouve=Standard_False;
1873       ii=icplus;
1874       while (!trouve) { 
1875         if (!regul.Value(ii)) { 
1876           indfin=ii;
1877           trouve=Standard_True;
1878         }
1879         if (ii==nedge-1) ii=0;
1880         else ii++;
1881       } 
1882       Indices(nedge,indfin,indfinplus,indfinmoins);
1883       if (!sharp.Value(icmoins)){
1884         if( jf.Value(icmoins)==1)
1885           ilin= SurfIndex(CD, icmoins, i.Value(icmoins,ic), FACE1);
1886         else 
1887           ilin= SurfIndex(CD, icmoins, i.Value(icmoins,ic), FACE2);
1888         Lface.Append(TopoDS::Face(DStr.Shape(ilin)));
1889       }
1890       else Lface.Append( Fvive(ic,icmoins));
1891       if (indfin>icmoins) 
1892         nbface=indfin-icmoins;
1893       else nbface =nedge-(icmoins-indfin);
1894       TopTools_SequenceOfShape Epj;
1895       TColStd_SequenceOfReal  seqpr;
1896       ii=ic;
1897       for (Standard_Integer nf=1;nf<=nbface-1;nf++) { 
1898         Standard_Integer iimoins,iiplus;
1899         Indices(nedge,ii,iiplus,iimoins); 
1900         Ledge.Append(TopoDS::Edge(Evive.Value(ii)));
1901         seqpr.Append(p.Value(ii,iiplus));
1902         if (nf!=nbface-1) Lface.Append( Fvive(ii,iiplus));
1903         if (ii==nedge-1) ii=0;
1904         else ii++;
1905       }
1906       if (!sharp.Value(indfin) ){
1907         jfp=3-jf.Value(indfin);   
1908         if (jfp==1) 
1909           ilin= SurfIndex(CD, indfin, i.Value(indfin,indfinmoins), FACE1);
1910         else  ilin=SurfIndex(CD, indfin, i.Value(indfin,indfinmoins), FACE2);
1911         Lface.Append(TopoDS::Face(DStr.Shape(ilin)));
1912       }
1913       else  Lface.Append(Fvive(indfin,indfinmoins));
1914       CurveHermite(DStr,CD.Value(icmoins),jf.Value(icmoins),i.Value(icmoins,ic),
1915                    p.Value(icmoins,ic),sens.Value(icmoins),sharp.Value(icmoins),
1916                    TopoDS::Edge(Evive.Value(icmoins)),CD.Value(indfin),jf.Value(indfin),
1917                    i.Value(indfin,indfinmoins),p.Value(indfin,indfinmoins),sens.Value(indfin),
1918                    sharp.Value(indfin),TopoDS::Edge(Evive.Value(indfin)),nbface,Ledge,
1919                    Lface,pr,cr,Epj,seqpr,error);
1920       ii=ic;
1921       for (ind=1;ind<=nbface-1;ind++) {
1922         Standard_Integer iimoins,iiplus;
1923         Indices(nedge,ii,iiplus,iimoins);
1924         p.SetValue(ii,iiplus,seqpr.Value(ind));
1925         p.SetValue(ii,iimoins,seqpr.Value(ind));
1926         proj2d1.SetValue(ii,pr.Value(ind));
1927         proj2d2.SetValue(ii,pr.Value(ind+1));
1928         cproj1.SetValue(ii,cr.Value(ind));
1929         cproj2.SetValue(ii,cr.Value(ind+1));
1930         if (ii==nedge-1) ii=0;
1931         else ii++;
1932       }
1933       if (!sharp.Value(icmoins)&&!sharp.Value(indfin)) {   
1934         ii=icmoins;
1935         while (ii!=indfin) {
1936          isG1.SetValue(ii,Standard_True);
1937          if (ii==nedge-1) ii=0;
1938          else ii++;
1939         }
1940       }
1941       ic=ic+nbface-1;
1942     }       
1943   }
1944
1945  // case when the conncting curve between ic and icplus crosses many faces
1946   
1947   TopTools_SequenceOfShape Ecom;
1948   TopTools_SequenceOfShape Eproj;
1949   TColStd_SequenceOfReal parcom; 
1950   if (!deuxconges) 
1951   for (ic=0;ic<nedge;ic++) {
1952     Standard_Integer iface1,iface2;
1953     TopoDS_Face face1,face2;
1954     TopoDS_Edge edge;
1955     TColGeom_SequenceOfCurve cr;
1956     TColGeom2d_SequenceOfCurve pr;
1957     Indices(nedge,ic,icplus,icmoins);
1958     if (!oksea.Value(ic)){
1959       iface1=numfa.Value(ic,icplus);
1960       iface2=numfa.Value(icplus,ic);
1961        if (!sharp.Value(ic)) {
1962         if (jf.Value(ic)==1)
1963           iface1 =SurfIndex(CD, ic, i.Value(ic,icplus), FACE1);
1964         else   iface1=SurfIndex(CD, ic, i.Value(ic,icplus), FACE2);
1965       }
1966       face1=TopoDS::Face(myDS->Shape(iface1));
1967       
1968       if (!sharp.Value(icplus)) {
1969         if (jf.Value(icplus)==1)
1970           iface2 =SurfIndex(CD, icplus, i.Value(icplus,ic), FACE2);
1971         else   iface2=SurfIndex(CD, icplus, i.Value(icplus,ic), FACE1);
1972       }
1973       face2=TopoDS::Face(myDS->Shape(iface2));
1974       if (!face1.IsSame(face2)) {
1975         if (Fproj.Length()==0) {
1976           Fproj.Append(face1);
1977           Fproj.Append(face2); 
1978         }
1979         moresurf.SetValue(ic,Standard_True);    
1980         nbface=Fproj.Length();
1981         if (!TopoDS::Face(Fproj.Value(nbface)).IsSame(face2)) {
1982           Fproj.Remove(nbface); 
1983           Fproj.Append(face2);   
1984         }
1985         if (!TopoDS::Face(Fproj.Value(1)).IsSame(face1)) {
1986           Fproj.Remove(1); 
1987           Fproj.Prepend(face1);   
1988         }
1989         for (nb=1;nb<=nbface-1; nb++) {
1990           cherche_edge1 ( TopoDS::Face(Fproj.Value(nb)), TopoDS::Face(Fproj.Value(nb+1)),edge);
1991           Ecom.Append(edge); 
1992           para=BRep_Tool::Parameter(TopExp::FirstVertex(edge),edge);
1993           parcom.Append(para);   
1994         }      
1995         CurveHermite (DStr,CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),
1996                     p.Value(ic,icplus),sens.Value(ic),sharp.Value(ic),
1997                     TopoDS::Edge(Evive.Value(ic)),
1998                     CD.Value(icplus),jf.Value(icplus),i.Value(icplus,ic),
1999                     p.Value(icplus,ic),sens.Value(icplus),sharp.Value(icplus),
2000                     TopoDS::Edge(Evive.Value(icplus)),nbface,Ecom,Fproj, pr,cr,Eproj,parcom,error);
2001         Ecom.Append(Ecom.Value(nbface-1)); 
2002         parcom.Append(parcom.Value(nbface-1));
2003       }
2004     }
2005   } 
2006
2007 // case when two fillets have the same commonpoints 
2008 // one continues then by intersection 
2009 // it is checked if the extremities of the intersection coincide with commonpoints
2010
2011   Standard_Boolean intersection=Standard_False, introuve;
2012   if (nconges==2 && !deuxconges) { 
2013     gp_Pnt P1,P2,P3,P4;
2014     Standard_Integer ic1 = 0,ic2 = 0;
2015     trouve=Standard_False;
2016     for (ic=0;ic<nedge&&!trouve;ic++) {
2017       if (!sharp.Value(ic)){ 
2018         ic1=ic;
2019         trouve=Standard_True;
2020       }
2021     }
2022     for (ic=0;ic<nedge;ic++) {
2023       if (!sharp.Value(ic)&& ic!=ic1) ic2=ic;   
2024     }
2025     jfp = 3 - jf.Value(ic1);
2026     Indices(nedge,ic1,icplus,icmoins);   
2027     Calcul_P2dOnSurf(CD.Value(ic1),jfp,i.Value(ic1,icmoins),p.Value(ic1,icmoins),p2);
2028     indice=SurfIndex(CD, ic1, i.Value(ic1,icmoins), ChFiSURFACE);
2029     DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),P1);
2030     
2031     Calcul_P2dOnSurf(CD.Value(ic1),jf.Value(ic1),i.Value(ic1,icplus),p.Value(ic1,icplus),p2);
2032     indice=SurfIndex(CD, ic1, i.Value(ic1,icplus), ChFiSURFACE);
2033     DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),P2);
2034     
2035     jfp = 3 - jf.Value(ic2);    
2036     Indices(nedge,ic2,icplus,icmoins);   
2037     Calcul_P2dOnSurf(CD.Value(ic2),jfp,i.Value(ic2,icmoins),p.Value(ic2,icmoins),p2);
2038     indice=SurfIndex(CD, ic2, i.Value(ic2,icmoins), ChFiSURFACE);
2039     DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),P3);
2040     
2041     Calcul_P2dOnSurf(CD.Value(ic2),jf.Value(ic2),i.Value(ic2,icplus),p.Value(ic2,icplus),p2);
2042     indice=SurfIndex(CD, ic2, i.Value(ic2,icplus), ChFiSURFACE);
2043     DStr.Surface(indice).Surface()->D0(p2.X(),p2.Y(),P4);
2044     intersection=(P1.Distance(P4)<=1.e-7 ||  P1.Distance(P3)<=1.e-7) &&
2045       (P2.Distance(P4)<=1.e-7 ||  P2.Distance(P3)<=1.e-7);
2046     if (intersection) { 
2047       PerformTwoCornerSameExt(DStr,CD.Value(ic1),Index.Value(ic1),sens.Value(ic1),
2048                               CD.Value(ic2),Index.Value(ic2),sens.Value(ic2),introuve);      
2049       if (introuve) return;
2050     }
2051   } 
2052
2053 // declaration for plate 
2054   GeomPlate_BuildPlateSurface PSurf(3,10,3,tol2d,tolesp,angular);
2055
2056 // calculation of curves on surface for each stripe 
2057   for (ic=0;ic<nedge;ic++) {
2058     gp_Pnt2d p2d1, p2d2;
2059     if (!sharp.Value(ic)) {
2060       n3d++;
2061       Indices(nedge,ic,icplus,icmoins);
2062       jfp = 3 - jf.Value(ic);
2063       Calcul_P2dOnSurf(CD.Value(ic),jfp,i.Value(ic,icmoins),p.Value(ic,icmoins),p2d1);
2064       Calcul_P2dOnSurf(CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),p.Value(ic,icplus),p2d2);
2065 //      if (i[ic][icplus]!=  i[ic][icmoins]) cout<<"probleme surface"<<endl;
2066       indice= SurfIndex(CD, ic, i.Value(ic,icplus), ChFiSURFACE);
2067       Handle (GeomAdaptor_HSurface) Asurf =
2068         new GeomAdaptor_HSurface(DStr.Surface(indice).Surface());
2069       // calculation of curve 2d  
2070       xdir= p2d2.X()-p2d1.X();  
2071       ydir= p2d2.Y()-p2d1.Y();
2072       Standard_Real l0 = sqrt(xdir*xdir+ ydir*ydir );
2073       gp_Dir2d dir (xdir, ydir);
2074       Handle(Geom2d_Line) l= new Geom2d_Line (p2d1 ,dir);
2075       Handle (Geom2d_Curve) pcurve = new  Geom2d_TrimmedCurve(l,0,l0); 
2076       Handle (Geom2dAdaptor_HCurve) Acurv = new Geom2dAdaptor_HCurve(pcurve);
2077       Adaptor3d_CurveOnSurface  CurvOnS (Acurv,Asurf);
2078       Handle(Adaptor3d_HCurveOnSurface) HCons =
2079         new Adaptor3d_HCurveOnSurface(CurvOnS);
2080       Order.SetValue(ic,1);
2081       Handle(GeomPlate_CurveConstraint) Cont = 
2082         new GeomPlate_CurveConstraint(HCons,Order.Value(ic),10,tolesp,angular,0.1);
2083       PSurf.Add(Cont);
2084       
2085       // calculate indexes of points and of the curve for the DS         
2086       isfirst=(sens.Value(ic)==1);
2087       GeomLib::BuildCurve3d(tolapp,CurvOnS,CurvOnS.FirstParameter(),
2088                             CurvOnS.LastParameter(),Curv3d,maxapp,avedev);
2089       TopOpeBRepDS_Curve tcurv3d( Curv3d,maxapp);
2090       indcurve3d.SetValue(n3d,DStr.AddCurve(tcurv3d));
2091       gp_Pnt point1,point2; 
2092       point1=  CurvOnS.Value(CurvOnS.FirstParameter());
2093       point2 =CurvOnS.Value(CurvOnS.LastParameter());
2094       
2095       TopOpeBRepDS_Point tpoint1 (point1,maxapp);
2096       TopOpeBRepDS_Point tpoint2 (point2,maxapp);
2097       errapp.SetValue(ic,maxapp);
2098       if (ic==0) {
2099 // it is necessary to create two points
2100         indpoint.SetValue(ic,0,DStr.AddPoint(tpoint1));
2101         indpoint.SetValue(ic,1,DStr.AddPoint(tpoint2));
2102       }
2103       else {
2104 // probably the points are already on the fillet 
2105 // (previous intersection...)
2106         trouve = Standard_False;
2107         for (ii=0;ii<ic&&(!trouve);ii++) {
2108           if (!sharp.Value(ii)) {
2109             TopOpeBRepDS_Point & tpt= DStr.ChangePoint(indpoint.Value(ii,1));
2110             if (point1.Distance(tpt.Point())<1.e-4)
2111               trouve = Standard_True;
2112           }
2113         }
2114         if (trouve)
2115           indpoint.SetValue(ic,0,indpoint.Value(ii-1,1));
2116         else
2117           indpoint.SetValue(ic,0,DStr.AddPoint(tpoint1));
2118
2119         trouve = Standard_False;
2120         for (ii=0;ii<ic&&(!trouve);ii++) {
2121           if (!sharp.Value(ii)) {
2122             TopOpeBRepDS_Point & tpt= DStr.ChangePoint(indpoint.Value(ii,0));
2123             if (point2.Distance(tpt.Point())<1.e-4)
2124               trouve = Standard_True;
2125           }
2126         }
2127         if (trouve)
2128           indpoint.SetValue(ic,1,indpoint.Value(ii-1,0));
2129         else
2130           indpoint.SetValue(ic,1,DStr.AddPoint(tpoint2));
2131       }
2132       
2133       //   update of the stripe 
2134       isurf1=3-jf.Value(ic); isurf2=jf.Value(ic);
2135       if (isurf1==2)  CD.Value(ic)->SetOrientation(TopAbs_REVERSED,isfirst);
2136       CD.Value(ic)->SetCurve(indcurve3d.Value(n3d),isfirst);
2137       CD.Value(ic)->SetIndexPoint(indpoint.Value(ic,0),isfirst,isurf1); 
2138       CD.Value(ic)->SetIndexPoint(indpoint.Value(ic,1),isfirst,isurf2);
2139       CD.Value(ic)->SetParameters(isfirst,pcurve->FirstParameter(),pcurve->LastParameter());     
2140       ChFiDS_CommonPoint cp1;
2141       ChFiDS_CommonPoint cp2;
2142       cp1.SetPoint (point1);
2143       cp2.SetPoint( point2);
2144       CD.Value(ic)->SetOfSurfData()->Value(i.Value(ic,icmoins))->
2145         ChangeVertex (isfirst,isurf1)=cp1;
2146       CD.Value(ic)->SetOfSurfData()->Value(i.Value(ic,icmoins))->
2147         ChangeVertex (isfirst,isurf2)=cp2; 
2148       CD.Value(ic)->SetOfSurfData()->Value(i.Value(ic,icmoins))->
2149         ChangeInterference(isurf1).SetParameter(p.Value(ic,icmoins),isfirst);
2150       CD.Value(ic)->SetOfSurfData()->Value(i.Value(ic,icmoins))->
2151         ChangeInterference(isurf2).SetParameter(p.Value(ic,icplus),isfirst);
2152       CD.Value(ic)-> ChangePCurve(isfirst)= pcurve;
2153     }
2154   }
2155       
2156 // calculate the indices of points for living edges    
2157   for (ic=0;ic<nedge;ic++) {
2158     if (sharp.Value(ic)) {
2159       Indices(nedge,ic,icplus,icmoins);
2160       BRepAdaptor_Curve C(TopoDS::Edge(Evive.Value(ic)));
2161       /*gp_Pnt*/ PE = C.Value(p.Value(ic,icplus));
2162       TopOpeBRepDS_Point TPE(PE,BRep_Tool::Tolerance(TopoDS::Edge(Evive.Value(ic))));
2163       ChFiDS_CommonPoint cp;
2164       if (deuxconges ) {
2165         IVtx = DStr.AddShape(V1);
2166         indpoint.SetValue(ic,0, IVtx );
2167         indpoint.SetValue(ic,1, IVtx );
2168       }
2169       if (!sharp.Value(icplus)) {
2170         isfirst=(sens.Value(icplus)==1);
2171         jfp = 3 - jf.Value(icplus);
2172         cp = CD.Value(icplus)->SetOfSurfData()->Value(i.Value(icplus,ic))->
2173           ChangeVertex (isfirst,jfp);
2174         if ( cp.Point().Distance(PE) <= Max(1.e-4,tolcp)) {
2175 // edge was limited by the 1st CommonPoint of CD[icplus]
2176           indpoint.SetValue(ic,0,indpoint.Value(icplus,0));
2177           indpoint.SetValue(ic,1,indpoint.Value(icplus,0));
2178         }
2179       }
2180       if (!sharp.Value(icmoins)) {
2181         isfirst=(sens.Value(icmoins)==1);
2182         cp = CD.Value(icmoins)->SetOfSurfData()->Value(i.Value(icmoins,ic))->
2183           ChangeVertex (isfirst,jf.Value(icmoins));
2184         if ( cp.Point().Distance(PE) <= Max(1.e-4,tolcp)) {
2185 // edge was limited by the 2nd CommonPoint of CD[icmoins]
2186          if (indpoint.Value(ic,0)==0) { 
2187           indpoint.SetValue(ic,0, indpoint.Value(icmoins,1));
2188           indpoint.SetValue(ic,1, indpoint.Value(icmoins,1));
2189          }
2190         }
2191       }
2192       if (indpoint.Value(ic,0)==0) { 
2193          indpoint.SetValue(ic,0,DStr.AddPoint(TPE));
2194          indpoint.SetValue(ic,1, indpoint.Value(ic,0));
2195       }
2196     }
2197   }
2198
2199 // calculation of intermediary curves connecting two stripes in case if  
2200 // there is no intersection. The curve is a straight line, projection or batten 
2201   
2202   Standard_Boolean raccordbatten;
2203   if (!inters) {
2204
2205     for (ic=0;ic<nedge;ic++) {
2206        
2207       if (!oksea.Value(ic)&& !moresurf.Value(ic) && !libre.Value(ic) ) {
2208         Indices(nedge,ic,icplus,icmoins);
2209         raccordbatten=Standard_False;
2210         if (!regul.Value(ic)) {
2211           raccordbatten=Standard_True;
2212           if (regul.Value(icplus))
2213           raccordbatten=Standard_False;
2214         }
2215         n3d++;
2216         gp_Pnt2d p2d1, p2d2;
2217         Handle(Geom2d_Curve) curv2d1,curv2d2;
2218         Handle (Geom2d_Curve) pcurve;
2219         Handle (Geom_Curve) curveint;
2220         Handle (GeomAdaptor_HSurface) Asurf;
2221         Standard_Real u1bid,u2bid;
2222         
2223         // return the 1st curve 2d 
2224         // and the 1st connection point 
2225         if (sharp.Value(ic))
2226           curv2d1 = BRep_Tool::CurveOnSurface(TopoDS::Edge(Evive.Value(ic)),TopoDS::Face(Fvive.Value(ic,icplus)),
2227                                               u1bid,u2bid);
2228         else
2229           Calcul_C2dOnFace(CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),curv2d1);
2230         p2d1 = curv2d1 ->Value(p.Value(ic,icplus));
2231         
2232         // recuperation de la deuxieme courbe 2d
2233         // et du deuxieme point de raccordement
2234         if (sharp.Value(icplus))
2235           curv2d2 = BRep_Tool::CurveOnSurface(TopoDS::Edge(Evive.Value(icplus)),
2236                                               TopoDS::Face(Fvive.Value(ic,icplus)),u1bid,u2bid);
2237         else {
2238           jfp = 3 - jf.Value(icplus);
2239           Calcul_C2dOnFace(CD.Value(icplus),jfp,i.Value(icplus,ic),curv2d2);
2240         }
2241         p2d2 = curv2d2 ->Value(p.Value(icplus,ic));
2242
2243         Asurf = new GeomAdaptor_HSurface(BRep_Tool::Surface(TopoDS::Face(Fvive.Value(ic,icplus))));
2244         Standard_Real tolu,tolv,ratio; 
2245         tolu=Asurf->Surface().UResolution(1.e-3);
2246         tolv=Asurf->Surface().VResolution(1.e-3);
2247         if (tolu>tolv) ratio=tolu/tolv;
2248         else ratio=tolv/tolu;
2249         
2250         // in case of a sewing edge the parameters are reframed 
2251         if (couture) {
2252           Standard_Boolean PI1=Standard_False, PI2=Standard_False;
2253           Standard_Real xx;
2254           PI1=0<=p2d1.X() && p2d1.X() <=M_PI;
2255           PI2=0<=p2d2.X() && p2d2.X() <=M_PI;
2256           
2257           if (Evive.Value(ic).IsSame(edgecouture)){
2258             xx=p2d1.X();
2259             if (PI2&&!PI1) xx=xx-2*M_PI;
2260             if (!PI2&&PI1) xx=xx+2*M_PI;
2261             p2d1.SetX(xx);
2262               
2263           }
2264           if (Evive.Value(icplus).IsSame(edgecouture)){
2265             xx=p2d2.X();
2266             if (PI2&&!PI1) xx=xx+2*M_PI;
2267             if (!PI2&&PI1) xx=xx-2*M_PI;
2268             p2d2.SetX(xx); 
2269           }
2270         }
2271         xdir= p2d2.X()-p2d1.X();
2272         ydir= p2d2.Y()-p2d1.Y();
2273
2274         Standard_Real l0 = sqrt(xdir*xdir+ ydir*ydir );
2275         if (l0<1.e-7|| ponctuel.Value(ic)) {
2276 // unused connection
2277           n3d--;
2278           ponctuel.SetValue(ic,Standard_True);
2279           if (!deuxconges) {
2280             if ( sharp.Value(icplus) && indpoint.Value(icplus,0) == 0 ) {
2281               indpoint.SetValue(icplus,0, indpoint.Value(ic,1));
2282               indpoint.SetValue(icplus,1, indpoint.Value(ic,1));
2283             }
2284             if ( sharp.Value(ic) && indpoint.Value(ic,0) == 0 ) {
2285               indpoint.SetValue(ic,0,indpoint.Value(icmoins,1));
2286               indpoint.SetValue(ic,1,indpoint.Value(icmoins,1));
2287            }
2288           }
2289         }
2290         else {  // the connection is a straight line, projection or batten 
2291          if (ratio>10 && nconges==1) raccordbatten=Standard_True; 
2292          if (ratio>10 && raccordbatten) {
2293             CalculDroite(p2d1,xdir,ydir,pcurve);
2294             raccordbatten=Standard_False;
2295           }
2296           else  if (!raccordbatten){  // the projected curves are returned 
2297             if (regul.Value(ic)) {
2298                if (cproj2.Value(ic).IsNull()){ 
2299                    raccordbatten=Standard_True;
2300                }
2301                else {
2302                 pcurve=proj2d2.Value(ic);
2303                 curveint=cproj2.Value(ic);
2304                 maxapp1=1.e-6;
2305                }
2306                
2307             }
2308             else  {
2309               if (cproj1.Value(ic+1).IsNull()) {
2310                   raccordbatten=Standard_True; 
2311               }
2312               else {
2313                 pcurve=proj2d1.Value(ic+1);
2314                 curveint=cproj1.Value(ic+1); 
2315                 maxapp1=1.e-6;
2316               }
2317             }
2318           }
2319           Standard_Boolean contraint1=Standard_True,
2320                             contraint2=Standard_True;
2321           if (raccordbatten) {
2322 #ifdef OCCT_DEBUG
2323             ChFi3d_InitChron(ch);// initial performances for  battens  
2324 #endif  
2325             Standard_Boolean inverseic,inverseicplus;
2326             if (sharp.Value(ic)) {
2327                  inverseic=TopExp::FirstVertex(TopoDS::Edge(Evive.Value(ic))).
2328                          IsSame(V1);   
2329             }
2330             else {
2331               inverseic=sens.Value(ic)==1;
2332             }
2333             if (sharp.Value(icplus)){
2334               inverseicplus=TopExp::FirstVertex(TopoDS::Edge(Evive.Value(icplus))).
2335                          IsSame(V1);
2336             }
2337             else {
2338               inverseicplus=sens.Value(icplus)==1;
2339             } 
2340             if (TopoDS::Edge(Evive.Value(ic)).IsSame(edgelibre1) ||
2341                 TopoDS::Edge(Evive.Value(ic)).IsSame(edgelibre2)) 
2342                 contraint1=Standard_False;
2343             if (TopoDS::Edge(Evive.Value(icplus)).IsSame(edgelibre1) ||
2344                 TopoDS::Edge(Evive.Value(icplus)).IsSame(edgelibre2))
2345             contraint2=Standard_False;
2346             CalculBatten(Asurf,TopoDS::Face(Fvive(ic,icplus)),xdir,ydir,p2d1,p2d2,contraint1,contraint2,curv2d1,curv2d2,p.Value(ic,icplus),
2347                          p.Value(icplus,ic),inverseic,inverseicplus,pcurve);
2348 #ifdef OCCT_DEBUG
2349             ChFi3d_ResultChron( ch,t_batten);  // resulting performances for battens 
2350 #endif 
2351           }
2352
2353          // construction of borders for Plate 
2354          Handle (Geom2dAdaptor_HCurve)  Acurv=new Geom2dAdaptor_HCurve(pcurve);
2355          Adaptor3d_CurveOnSurface  CurvOnS (Acurv,Asurf);
2356          Handle(Adaptor3d_HCurveOnSurface) HCons =
2357            new Adaptor3d_HCurveOnSurface(CurvOnS);
2358
2359          // constraints G1 are set if edges ic and icplus are not both alive 
2360
2361
2362          Order.SetValue(n3d,0);
2363          if (!sharp.Value(ic)&& !sharp.Value(icplus))
2364            Order.SetValue(n3d,1);
2365          if (!contraint1 && !sharp.Value(icplus))
2366            Order.SetValue(n3d,1);
2367          if (!contraint2 && !sharp.Value(ic))
2368            Order.SetValue(n3d,1);
2369          if (tangentregul(ic) || tangentregul(icplus) )
2370            Order.SetValue(n3d,1);
2371          if (isG1.Value(ic)) 
2372            Order.SetValue(n3d,1);
2373          Handle(GeomPlate_CurveConstraint) Cont =
2374            new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolesp,angular,0.1);
2375          PSurf.Add(Cont);
2376
2377          //calculation of curve 3d if it is not a projection 
2378          if (curveint.IsNull()) {
2379            GeomLib::BuildCurve3d(tolapp,CurvOnS,CurvOnS.FirstParameter(),
2380                                  CurvOnS.LastParameter(),Curv3d,maxapp1,avedev);
2381            pardeb=CurvOnS.FirstParameter();
2382            parfin= CurvOnS.LastParameter();
2383            curveint= new Geom_TrimmedCurve(Curv3d,pardeb,parfin);
2384          }
2385
2386          //storage in the DS  
2387          TopOpeBRepDS_Curve tcurv3d( curveint,maxapp1);
2388          indcurve3d.SetValue(n3d, DStr.AddCurve(tcurv3d));
2389          pardeb=curveint->FirstParameter();
2390          parfin=curveint->LastParameter();
2391          if ( sharp.Value(icplus) && indpoint.Value(icplus,0) == 0) {
2392            // it is necessary to initialize indpoint[icplus][0] and indpoint[icplus][1]
2393            gp_Pnt point2; 
2394            point2 =curveint->Value(parfin);
2395            TopOpeBRepDS_Point tpoint2 (point2,maxapp); 
2396            indpoint.SetValue(icplus,0,DStr.AddPoint(tpoint2));
2397            indpoint.SetValue(icplus,1,indpoint.Value(icplus,0));
2398          }
2399          Standard_Boolean IsVt1=Standard_False;
2400          Standard_Boolean IsVt2=Standard_False;
2401          if(deuxconges) {
2402            IsVt1=sharp.Value(ic);
2403            IsVt2=sharp.Value(icplus);
2404           }
2405           Interfp1=ChFi3d_FilPointInDS(TopAbs_FORWARD,indcurve3d.Value(n3d),
2406                                        indpoint.Value(ic,1),pardeb,IsVt1);
2407           Interfp2=ChFi3d_FilPointInDS(TopAbs_REVERSED,indcurve3d.Value(n3d),
2408                                        indpoint(icplus,0),parfin,IsVt2);
2409           DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append(Interfp1);
2410           DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append(Interfp2);
2411           if (!IsVt1) {
2412             TopOpeBRepDS_Point & tpt1= DStr.ChangePoint(indpoint(ic,1));
2413             tpt1.Tolerance (tpt1.Tolerance()+maxapp1);
2414           }       
2415           if (!IsVt2) {
2416             TopOpeBRepDS_Point &tpt2= DStr.ChangePoint(indpoint(icplus,0));
2417             tpt2.Tolerance (tpt2.Tolerance()+maxapp1);     
2418           }
2419
2420         // calculate orientation of the curve  
2421           TopAbs_Orientation orinterf; 
2422           if (!sharp.Value(ic)) {
2423               OrientationIcNonVive(CD.Value(ic),jf.Value(ic),i.Value(ic,icplus),sens.Value(ic),orinterf);
2424           }
2425           else if (!sharp.Value(icplus)) {
2426               OrientationIcplusNonVive(CD.Value(icplus),jf.Value(icplus),i.Value(icplus,ic),sens.Value(icplus),orinterf);
2427             }
2428           else {
2429                 OrientationAreteViveConsecutive (Fvive.Value(ic,icplus) ,Evive.Value(ic),V1,orinterf);                                      
2430           } 
2431           Interfc=ChFi3d_FilCurveInDS(indcurve3d.Value(n3d),numfa.Value(ic,icplus),pcurve,orinterf);      
2432           DStr.ChangeShapeInterferences(numfa.Value(ic,icplus)).Append(Interfc);
2433         }
2434        } // end of processing by edge 
2435     } // end of the loop on edges 
2436   }  // end of processing for intermediary curves 
2437         
2438 //  storage in the DS of curves projected on several faces 
2439   for (ic=0;ic<nedge;ic++) {
2440     if (moresurf.Value(ic) ){
2441       TopoDS_Vertex Vf,Vl;
2442       gp_Pnt Pf,Pl,P1,P2,Pcom;
2443       ind = 0; //must be initialized because of possible use, see L2249
2444       Standard_Real up1,up2;
2445       TopAbs_Orientation orvt;
2446       TopAbs_Orientation oredge = TopAbs_FORWARD;
2447       Standard_Integer indpoint1,indpoint2;
2448       Indices(nedge,ic,icplus,icmoins);
2449       Handle(Geom2d_Curve) proj,proj2d;
2450       Handle(Geom_Curve) projc,cproj;
2451       TopOpeBRepDS_Point& tpt1= DStr.ChangePoint(indpoint(ic,1));
2452       TopOpeBRepDS_Point& tpt2= DStr.ChangePoint(indpoint(icplus,0));
2453       tpt1.Tolerance (tpt1.Tolerance()+error);
2454       tpt2.Tolerance (tpt1.Tolerance()+error);
2455       for(nb=1;nb<=nbface;nb++) {
2456         orvt=TopAbs_REVERSED;
2457         Vf=TopExp::FirstVertex(TopoDS::Edge(Ecom.Value(nb)));
2458         Vl=TopExp::LastVertex (TopoDS::Edge(Ecom.Value(nb)));
2459         Pf=BRep_Tool::Pnt(Vf);
2460         Pl=BRep_Tool::Pnt(Vl);
2461         para=parcom.Value(nb);
2462         Pcom=BRep_Tool::Curve(TopoDS::Edge(Ecom.Value(nb)),up1,up2)->Value(para);
2463         if (Pf.Distance(BRep_Tool::Pnt(V1))< Pl.Distance(BRep_Tool::Pnt(V1)))
2464           orvt=TopAbs_FORWARD;
2465         if (!Eproj.Value(nb).IsNull())  {
2466           n3d++;
2467           proj=BRep_Tool::CurveOnSurface(TopoDS::Edge(Eproj.Value(nb)),
2468                                          TopoDS::Face(Fproj.Value(nb)),up1,up2);
2469           proj2d=new Geom2d_TrimmedCurve(proj,up1,up2);
2470           projc=BRep_Tool::Curve(TopoDS::Edge(Eproj.Value(nb)),up1,up2);
2471           cproj=new Geom_TrimmedCurve(projc,up1,up2);
2472           pardeb=cproj->FirstParameter();
2473           parfin=cproj->LastParameter();
2474           P1=cproj->Value(pardeb);
2475           P2=cproj->Value(parfin);
2476           if (P1.Distance(tpt1.Point())<1.e-3) 
2477             indpoint1=indpoint(ic,1); 
2478           else  indpoint1=ind;
2479           if (P2.Distance(tpt2.Point())<1.e-3) 
2480             indpoint2=indpoint(icplus,0); 
2481           else  {
2482             TopOpeBRepDS_Point tpoint2 (P2,error);
2483             indpoint2= DStr.AddPoint(tpoint2);
2484             ind=indpoint2;    
2485           }
2486           Handle (GeomAdaptor_HSurface) Asurf;
2487           Asurf = new GeomAdaptor_HSurface(BRep_Tool::Surface
2488                                            (TopoDS::Face(Fproj.Value(nb))));
2489           Handle (Geom2dAdaptor_HCurve)  Acurv=new Geom2dAdaptor_HCurve(proj2d);
2490           Adaptor3d_CurveOnSurface  CurvOnS (Acurv,Asurf);
2491           Handle(Adaptor3d_HCurveOnSurface) HCons =new Adaptor3d_HCurveOnSurface(CurvOnS);
2492           Order.SetValue(n3d,1);
2493           Handle(GeomPlate_CurveConstraint) Cont =
2494             new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolesp,angular,0.1);
2495           PSurf.Add(Cont);
2496           TopOpeBRepDS_Curve tcurv3d( cproj,error);
2497           indcurve3d.SetValue(n3d, DStr.AddCurve(tcurv3d));
2498           Interfp1=ChFi3d_FilPointInDS(TopAbs_FORWARD,indcurve3d.Value(n3d),
2499                                        indpoint1,pardeb);
2500           Interfp2=ChFi3d_FilPointInDS(TopAbs_REVERSED,indcurve3d.Value(n3d),
2501                                        indpoint2,parfin);
2502           DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append(Interfp1);
2503           DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append(Interfp2);
2504           num=DStr.AddShape(Fproj.Value(nb));
2505           TopExp_Explorer ex;
2506           for(ex.Init(Fproj.Value(nb).Oriented(TopAbs_FORWARD),TopAbs_EDGE); 
2507               ex.More(); ex.Next()){
2508             if(Ecom.Value(nb).IsSame(ex.Current())) {
2509               oredge = ex.Current().Orientation();
2510               break;
2511             }
2512           }
2513
2514           //calculation of the orientation        
2515           TopAbs_Orientation orinterf;
2516           if (P1.Distance(Pcom)>1.e-4) {
2517             if (orvt==TopAbs_FORWARD) {
2518               orinterf=oredge;
2519             }
2520             else {
2521               orinterf=TopAbs::Reverse(oredge);
2522             }
2523           }
2524           else {
2525             if (orvt==TopAbs_FORWARD) {
2526               orinterf=TopAbs::Reverse(oredge); 
2527             }
2528             else {
2529               orinterf=oredge;
2530             }
2531           }
2532           Interfc=ChFi3d_FilCurveInDS(indcurve3d.Value(n3d),num,proj2d,orinterf);         
2533           DStr.ChangeShapeInterferences(num).Append(Interfc);
2534         }
2535         indice=ind;
2536         if (nb!=nbface) {    
2537           if (Eproj.Value(nb).IsNull())  indice=indpoint(ic,1);
2538           if (Eproj.Value(nb+1).IsNull()) indice=indpoint(icplus,0); 
2539           Indice.SetValue(n3d,indice);
2540           Standard_Integer Iarc1=DStr.AddShape(TopoDS::Edge(Ecom.Value(nb)));
2541           Interfp1=ChFi3d_FilPointInDS(orvt,Iarc1,indice,parcom.Value(nb));
2542           DStr.ChangeShapeInterferences(Iarc1).Append(Interfp1);
2543         }
2544       }
2545     }                     
2546   }
2547             
2548 // case when two free borders are tangent
2549   if (droit)      
2550     for (ic=0;ic<nedge;ic++) {
2551       Handle(Geom_Curve) curve,ctrim,rcurve;
2552       Handle(Geom2d_Curve) curve2d,ctrim2d,rcurve2d;
2553       Standard_Real ufirst,ulast;  
2554       Indices(nedge,ic,icplus,icmoins);
2555       Standard_Integer indpoint1,indpoint2;
2556       Standard_Boolean isvt1=Standard_False,isvt2=Standard_False;
2557       TopoDS_Edge ecur =TopoDS::Edge(Evive.Value(ic));
2558       if (ecur.IsSame(edgelibre1)|| ecur.IsSame(edgelibre2)) {
2559         n3d++;
2560         curve2d=BRep_Tool::CurveOnSurface(TopoDS::Edge(Evive.Value(ic)),
2561                                           TopoDS::Face(Fvive.Value(ic,icplus)),ufirst,ulast);
2562         curve=BRep_Tool::Curve(TopoDS::Edge(Evive.Value(ic)),ufirst,ulast);
2563         if (TopExp::FirstVertex((TopoDS::Edge(Evive.Value(ic)))).IsSame (V1)) { 
2564           ctrim=new Geom_TrimmedCurve(curve,ufirst,p.Value(ic,icmoins));
2565           ctrim2d=new Geom2d_TrimmedCurve(curve2d,ufirst,p.Value(ic,icmoins)); 
2566           indpoint1=DStr.AddShape(V1);
2567           isvt1=1;
2568           indpoint2=indpoint(ic,1);
2569         }
2570         else { 
2571           ctrim=new Geom_TrimmedCurve(curve, p.Value(ic,icmoins),ulast);
2572           ctrim2d=new Geom2d_TrimmedCurve(curve2d,p.Value(ic,icmoins),ulast);
2573           indpoint2=DStr.AddShape(V1);
2574           isvt2=1;
2575           indpoint1=indpoint(ic,1);
2576         }
2577         if (libre.Value(ic)){
2578           if (TopExp::FirstVertex((TopoDS::Edge(Evive.Value(ic)))).IsSame(V1)) { 
2579             ctrim->Reverse();
2580             ctrim2d->Reverse();
2581             indpoint2=DStr.AddShape(V1);
2582             isvt2=1;
2583             isvt1=0;
2584             indpoint1=indpoint(ic,1);
2585           }
2586         }
2587         else {
2588           if (TopExp::LastVertex((TopoDS::Edge(Evive.Value(ic)))).IsSame(V1)) {
2589             ctrim->Reverse();
2590             ctrim2d->Reverse();
2591             indpoint1=DStr.AddShape(V1);
2592             isvt1=1;
2593             isvt2=0;
2594             indpoint2=indpoint(ic,1);  
2595           } 
2596         }       
2597         ufirst=ctrim->FirstParameter();
2598         ulast=ctrim->LastParameter();
2599         Handle (GeomAdaptor_HSurface) Asurf;
2600         Asurf = new GeomAdaptor_HSurface(BRep_Tool::Surface
2601                                          (TopoDS::Face(Fvive.Value(ic,icplus))));
2602         Handle (Geom2dAdaptor_HCurve)  Acurv=new Geom2dAdaptor_HCurve(ctrim2d);
2603         Adaptor3d_CurveOnSurface  CurvOnS (Acurv,Asurf);
2604         Handle(Adaptor3d_HCurveOnSurface) HCons =new Adaptor3d_HCurveOnSurface(CurvOnS);
2605         Order.SetValue(n3d,0);
2606         Handle(GeomPlate_CurveConstraint) Cont =
2607           new GeomPlate_CurveConstraint(HCons,Order.Value(n3d),10,tolesp,angular,0.1);
2608         PSurf.Add(Cont);
2609         TopOpeBRepDS_Curve tcurv3d( ctrim,1.e-4);
2610         indcurve3d.SetValue(n3d, DStr.AddCurve(tcurv3d));
2611         Interfp1=ChFi3d_FilPointInDS(TopAbs_FORWARD,indcurve3d.Value(n3d),
2612                                      indpoint1,ufirst,isvt1);
2613         Interfp2=ChFi3d_FilPointInDS(TopAbs_REVERSED,indcurve3d.Value(n3d),
2614                                      indpoint2,ulast,isvt2);
2615         DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append(Interfp1);
2616         DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append(Interfp2);
2617       }
2618   } 
2619  
2620 #ifdef OCCT_DEBUG
2621   ChFi3d_InitChron(ch); // init performances for plate 
2622 #endif
2623
2624   PSurf.Perform();
2625
2626 #ifdef OCCT_DEBUG
2627   ChFi3d_ResultChron(ch, t_plate); //result performances for plate 
2628 #endif 
2629
2630   // call of approx  
2631  
2632 #ifdef OCCT_DEBUG
2633   ChFi3d_InitChron(ch);  // init performances for approxplate
2634 #endif
2635   if (PSurf.IsDone()) {
2636     Standard_Integer nbcarreau=9;
2637     Standard_Integer degmax=8;
2638     Standard_Real seuil;
2639     Handle(GeomPlate_Surface) gpPlate = PSurf.Surface();
2640
2641     TColgp_SequenceOfXY S2d;
2642     TColgp_SequenceOfXYZ S3d;
2643     S2d.Clear();
2644     S3d.Clear();
2645     PSurf.Disc2dContour(4,S2d);
2646     PSurf.Disc3dContour(4,0,S3d);
2647     seuil = Max(tolapp,10*PSurf.G0Error());
2648     GeomPlate_PlateG0Criterion critere (S2d,S3d,seuil);
2649     GeomPlate_MakeApprox Mapp(gpPlate,critere,tolapp,nbcarreau,degmax);
2650     Handle (Geom_Surface) Surf (Mapp.Surface());
2651     Standard_Real coef = 1.1 ,apperror;
2652     apperror=Mapp.CriterionError()*coef;
2653
2654 #ifdef OCCT_DEBUG
2655   ChFi3d_ResultChron(ch, t_approxplate); // result performances for approxplate
2656 #endif
2657   
2658 //  Storage of the surface plate and corresponding curves in the DS 
2659
2660     TopAbs_Orientation orplate,orsurfdata,orpcurve,orien;
2661 #ifdef OCCT_DEBUG
2662 //    Standard_Real ang1=PSurf.G1Error();
2663 #endif
2664 //     gp_Vec n1,n2,du,dv,du1,dv1;
2665 //     gp_Pnt pp,pp1;
2666 //     Standard_Real tpar;
2667 //     gp_Pnt2d uv; 
2668 //     Standard_Real scal;
2669     
2670     TopOpeBRepDS_Surface Tsurf(Surf,Mapp.ApproxError());
2671     Standard_Integer Isurf=DStr.AddSurface(Tsurf);
2672     //lbo : historique QDF.
2673     if(!myEVIMap.IsBound(V1)){
2674       TColStd_ListOfInteger li;
2675       myEVIMap.Bind(V1,li);
2676     }
2677     myEVIMap.ChangeFind(V1).Append(Isurf);
2678   
2679     Standard_Integer SolInd = CD.Value(0)->SolidIndex();
2680     TopOpeBRepDS_ListOfInterference& SolidInterfs = 
2681       DStr.ChangeShapeInterferences(SolInd);
2682  
2683 // in case when one rereads at top, it is necessary that 
2684 // alive edges that arrive at the top should be removed from the DS. 
2685 // For this they are stored in the DS with their inverted orientation 
2686     Standard_Integer nbedge;
2687     TopExp_Explorer ex;
2688     if (deuxconges)
2689       for (ic=0;ic<nedge;ic++) {
2690         if (!sharp.Value(ic)){
2691           nbedge = CD.Value(ic)->Spine()->NbEdges();
2692           TopoDS_Edge Arcspine; 
2693           if (sens.Value(ic) ==1) 
2694             Arcspine=CD.Value(ic) ->Spine()->Edges(1);
2695           else  
2696             Arcspine= CD.Value(ic)->Spine()->Edges(nbedge);
2697           Standard_Integer IArcspine = DStr.AddShape(Arcspine);
2698           TopAbs_Orientation OVtx = TopAbs_FORWARD;
2699           for(ex.Init(Arcspine.Oriented(TopAbs_FORWARD),TopAbs_VERTEX); 
2700               ex.More(); ex.Next()){
2701             if(V1.IsSame(ex.Current())) {
2702               OVtx = ex.Current().Orientation();
2703               break;
2704             }
2705           }
2706           OVtx = TopAbs::Reverse(OVtx);
2707           Standard_Real parVtx = BRep_Tool::Parameter(V1,Arcspine);
2708           Handle(TopOpeBRepDS_CurvePointInterference) 
2709             interfv = ChFi3d_FilVertexInDS(OVtx,IArcspine,IVtx,parVtx);
2710           DStr.ChangeShapeInterferences(IArcspine).Append(interfv);
2711         }
2712       }
2713     
2714     // calculate orientation of Plate orplate corresponding to surfdata 
2715     // calculation corresponding to the first stripe 
2716     Indices(nedge,0,icplus,icmoins);
2717     isfirst=(sens.Value(0)==1);
2718     const Handle(ChFiDS_SurfData)& Fd = 
2719       CD.Value(0)->SetOfSurfData()->Value(i.Value(0,icmoins));
2720     indice= Fd->Surf();
2721 //    Handle (Geom_Surface) surfdata  = DStr.Surface(indice).Surface();
2722 //     tpar= (CD.Value(0)->PCurve(isfirst)->FirstParameter()+
2723 //       CD.Value(0)->PCurve(isfirst)->LastParameter())/2 ;
2724 //     CD.Value(0)->PCurve(isfirst)->D0(tpar,uv);
2725 //     surfdata->D1(uv.X(),uv.Y(),pp,du,dv);
2726 //     tpar=(PSurf.Curves2d()->Value(1)->FirstParameter()+
2727 //        PSurf.Curves2d()->Value(1)->LastParameter())/2;
2728 //     (PSurf.Curves2d())->Value(1)->D0(tpar,uv);
2729 //     Surf-> D1(uv.X(),uv.Y(),pp1,du1,dv1);
2730 //     n1=du.Crossed(dv);
2731 //     n2=du1.Crossed(dv1);  
2732 //     scal= n1.Dot(n2);
2733     orsurfdata=Fd->Orientation();
2734 //     if (scal>0) orplate=orsurfdata;
2735 //     else  orplate=TopAbs::Reverse(orsurfdata);  
2736     orplate = PlateOrientation(Surf,PSurf.Curves2d(),SumFaceNormalAtV1);
2737     
2738     //  creation of solidinterderence for Plate 
2739     Handle(TopOpeBRepDS_SolidSurfaceInterference) SSI = 
2740       new TopOpeBRepDS_SolidSurfaceInterference(TopOpeBRepDS_Transition(orplate),
2741                                               TopOpeBRepDS_SOLID,
2742                                               SolInd,
2743                                               TopOpeBRepDS_SURFACE,
2744                                               Isurf);
2745     SolidInterfs.Append(SSI);
2746   
2747   // calculate orientation orien of pcurves of Plate
2748   // the curves from ic to icplus the pcurves of Plate 
2749   // all have the same orientation  
2750     Standard_Integer Ishape1,Ishape2; 
2751     TopAbs_Orientation trafil1 = TopAbs_FORWARD, trafil2 = TopAbs_FORWARD;
2752     Ishape1 = Fd->IndexOfS1();
2753     Ishape2 = Fd->IndexOfS2();
2754     const ChFiDS_FaceInterference& Fi1 = Fd->InterferenceOnS1();
2755     const ChFiDS_FaceInterference& Fi2 = Fd->InterferenceOnS2();     
2756     if (Ishape1 != 0) {
2757       if (Ishape1 > 0) {
2758         trafil1 = DStr.Shape(Ishape1).Orientation();
2759       }
2760       trafil1 = TopAbs::Compose(trafil1,Fd->Orientation());
2761       trafil1 = TopAbs::Compose(TopAbs::Reverse(Fi1.Transition()),trafil1);
2762       trafil2 = TopAbs::Reverse(trafil1);
2763     }
2764     else {
2765       if (Ishape2 > 0) {
2766         trafil2 = DStr.Shape(Ishape2).Orientation();
2767       }
2768       trafil2 = TopAbs::Compose(trafil2,Fd->Orientation());
2769       trafil2 = TopAbs::Compose(TopAbs::Reverse(Fi2.Transition()),trafil2);
2770       trafil1 = TopAbs::Reverse(trafil2);
2771     }
2772     if (isfirst) {
2773       orpcurve=TopAbs::Reverse(trafil1);
2774       orpcurve= TopAbs::Compose(orpcurve,CD.Value(0)->FirstPCurveOrientation ()); }
2775     else {
2776       orpcurve=trafil1;
2777       orpcurve= TopAbs::Compose(orpcurve,CD.Value(0)->LastPCurveOrientation ());
2778     }
2779     if (orsurfdata==orplate) 
2780       orien =TopAbs::Reverse(orpcurve);
2781     else  orien=orpcurve; 
2782     
2783     
2784     if (!droit)
2785       for (ic=0;ic<=nedge;ic++) {
2786         if (libre.Value(ic)) {
2787           Standard_Integer icplus21;
2788           Indices(nedge,ic,icplus,icmoins);
2789           Indices(nedge,icplus,icplus21,ic);
2790           gp_Pnt2d UV1,UV2;
2791           Handle (Geom_Curve) C3d;
2792           Handle (Geom2d_Curve) C2d,curv2d;
2793           gp_Pnt ptic,pticplus;
2794           BRepAdaptor_Curve BCurv1(TopoDS::Edge(Evive.Value(ic)));
2795           BRepAdaptor_Curve BCurv2(TopoDS::Edge(Evive.Value(icplus)));
2796           Standard_Real par1=p.Value(ic,icplus);
2797           Standard_Real par2=p.Value(icplus,ic);
2798           BCurv1.D0(par1,ptic);
2799           BCurv2.D0(par2,pticplus);
2800           ParametrePlate(n3d,PSurf,Surf,ptic,apperror,UV1);
2801           ParametrePlate(n3d,PSurf,Surf,pticplus,apperror,UV2);
2802           Standard_Real to3d=1.e-3,to2d=1.e-6,tolreached;
2803           ChFiDS_CommonPoint CP1,CP2;
2804           CP1.SetArc(1.e-3, TopoDS::Edge(Evive.Value(ic)),par1,TopAbs_FORWARD);
2805           CP1.SetPoint(ptic);
2806           CP2.SetArc(1.e-3, TopoDS::Edge(Evive.Value(icplus)),par2,TopAbs_FORWARD);
2807           CP2.SetPoint(pticplus);
2808           Standard_Real param1,param2;
2809           ChFi3d_ComputeArete( CP1,UV1,CP2,UV2,Surf,C3d,C2d,param1,param2, 
2810                               to3d,to2d,tolreached,0);
2811           TopOpeBRepDS_Curve tcurv3d( C3d,tolreached);
2812           Standard_Integer ind1,ind2;
2813           ind1=indpoint(ic,0);
2814           ind2=indpoint(icplus,0);
2815           Standard_Integer indcurv=DStr.AddCurve(tcurv3d);
2816           Interfp1=ChFi3d_FilPointInDS(TopAbs_FORWARD,indcurv,ind1,param1);
2817           Interfp2=ChFi3d_FilPointInDS(TopAbs_REVERSED,indcurv,ind2,param2);
2818           DStr.ChangeCurveInterferences(indcurv).Append(Interfp1);
2819           DStr.ChangeCurveInterferences(indcurv).Append(Interfp2);
2820           Interfc=ChFi3d_FilCurveInDS(indcurv,Isurf,C2d,orien);
2821           DStr.ChangeSurfaceInterferences(Isurf).Append(Interfc);
2822         }
2823   }
2824     
2825     //  stockage des courbes relatives aux stripes  
2826     n3d = 0;
2827     for (ic=0; ic<nedge ;ic++) {
2828       if (!sharp.Value(ic)) {
2829         n3d++;
2830         Indices(nedge,ic,icplus,icmoins);
2831         
2832         isfirst=(sens.Value(ic)==1);
2833       //   calculate curves interference relative to stripes
2834       
2835         apperror=Mapp.CriterionError()*coef;
2836         pardeb=CD.Value(ic)->PCurve(isfirst)->FirstParameter();
2837         parfin=CD.Value(ic)->PCurve(isfirst)->LastParameter();
2838       
2839         Interfp1=ChFi3d_FilPointInDS(TopAbs_FORWARD,indcurve3d.Value(n3d),
2840                                      indpoint.Value(ic,0),pardeb);
2841         Interfp2=ChFi3d_FilPointInDS(TopAbs_REVERSED,indcurve3d.Value(n3d),
2842                                      indpoint.Value(ic,1),parfin);
2843         DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append( Interfp1);
2844         DStr.ChangeCurveInterferences(indcurve3d.Value(n3d)).Append( Interfp2);
2845         TopOpeBRepDS_Curve& tcourb = DStr.ChangeCurve(indcurve3d.Value(n3d));
2846         
2847         tcourb.Tolerance(errapp.Value(ic)+apperror);
2848         TopOpeBRepDS_Point& tpt1= DStr.ChangePoint(indpoint(ic,0));
2849         TopOpeBRepDS_Point& tpt2= DStr.ChangePoint(indpoint(ic,1));
2850         tpt1.Tolerance (tpt1.Tolerance()+apperror);
2851         tpt2.Tolerance (tpt2.Tolerance()+apperror ); 
2852         
2853       // calculate surfaceinterference
2854         Interfc=ChFi3d_FilCurveInDS(indcurve3d.Value(n3d),Isurf,
2855                                   PSurf.Curves2d()->Value(n3d),orien);     
2856         DStr.ChangeSurfaceInterferences(Isurf).Append(Interfc);
2857         regular.SetCurve(indcurve3d.Value(n3d));
2858         regular.SetS1(Isurf,Standard_False);
2859         indice=CD.Value(ic)->SetOfSurfData()->Value( i.Value(ic,icmoins))->Surf();
2860         regular.SetS2(indice,Standard_False);
2861         myRegul.Append(regular);
2862       }
2863     }
2864
2865   // storage of connection curves 
2866
2867     for (ic=0; ic<nedge;ic++) {
2868       Indices(nedge,ic,icplus,icmoins);
2869       if (!oksea.Value(ic)) {
2870         if (sharp.Value(ic) &&!deuxconges) {
2871           // limitation of the alive edge 
2872           TopAbs_Orientation ori;
2873           gp_Pnt Pf,Pl,sommet1;
2874           TopoDS_Vertex Vd = TopExp::FirstVertex(TopoDS::Edge(Evive.Value(ic)));
2875           TopoDS_Vertex Vf = TopExp::LastVertex(TopoDS::Edge(Evive.Value(ic)));
2876           Pf=BRep_Tool::Pnt(Vd);
2877           Pl=BRep_Tool::Pnt(Vf);
2878           sommet1=BRep_Tool::Pnt(V1);
2879           if (Pf.Distance(sommet1)<Pl.Distance(sommet1))
2880             ori = TopAbs_FORWARD;
2881           else
2882             ori = TopAbs_REVERSED;
2883           Standard_Integer Iarc1=DStr.AddShape(TopoDS::Edge(Evive.Value(ic)));
2884           Interfp1=ChFi3d_FilPointInDS(ori,Iarc1,indpoint(ic,1),p.Value(ic,icplus));
2885           DStr.ChangeShapeInterferences(TopoDS::Edge(Evive.Value(ic))).Append(Interfp1);
2886         }
2887         
2888         if (!ponctuel.Value(ic) && !libre.Value(ic)) {
2889           // actual connection
2890           if (!moresurf.Value(ic)){
2891             n3d++;
2892             TopOpeBRepDS_Curve& tcourb1 = DStr.ChangeCurve(indcurve3d.Value(n3d));
2893             tcourb1.Tolerance(tcourb1.Tolerance()+apperror);
2894             if (!deuxconges) {
2895               TopOpeBRepDS_Point& tpt11= DStr.ChangePoint(indpoint(ic,1));
2896               TopOpeBRepDS_Point& tpt21= DStr.ChangePoint(indpoint(icplus,0));
2897               tpt11.Tolerance (tpt11.Tolerance()+apperror);
2898               tpt21.Tolerance (tpt21.Tolerance()+apperror ); 
2899             }
2900             Interfc=ChFi3d_FilCurveInDS(indcurve3d.Value(n3d),Isurf,
2901                                         PSurf.Curves2d()->Value(n3d),orien);
2902             DStr.ChangeSurfaceInterferences(Isurf).Append(Interfc);
2903             if( Order.Value(n3d)==1) {
2904               regular.SetCurve(indcurve3d.Value(n3d));
2905               regular.SetS1(Isurf,Standard_False);
2906               regular.SetS2(numfa.Value(ic,icplus));
2907               myRegul.Append(regular);
2908             }
2909           }
2910         }
2911       }
2912     }
2913
2914   //storage of curves projected on several faces 
2915     for (ic=0; ic<nedge;ic++) {
2916       Indices(nedge,ic,icplus,icmoins);
2917       if (moresurf(ic))
2918         for (nb=1;nb<=nbface;nb++){ 
2919           if (!Eproj.Value(nb).IsNull()) {
2920             n3d++;
2921             TopOpeBRepDS_Curve& tcourb1 = DStr.ChangeCurve(indcurve3d.Value(n3d));
2922             tcourb1.Tolerance(tcourb1.Tolerance()+apperror);
2923             if(Indice.Value(n3d)!=0) {
2924               TopOpeBRepDS_Point& tpt11= DStr.ChangePoint(Indice.Value(n3d));
2925               tpt11.Tolerance (tpt11.Tolerance()+apperror);
2926             }
2927             Interfc=ChFi3d_FilCurveInDS(indcurve3d.Value(n3d),Isurf,
2928                                         PSurf.Curves2d()->Value(n3d),orien);
2929             DStr.ChangeSurfaceInterferences(Isurf).Append(Interfc);
2930             if( Order.Value(n3d)==1) {
2931               regular.SetCurve(indcurve3d.Value(n3d));
2932               regular.SetS1(Isurf,Standard_False);
2933               regular.SetS2(DStr.AddShape(TopoDS::Face(Fproj.Value(nb))));
2934               myRegul.Append(regular);
2935             }  
2936           }
2937         } 
2938     }
2939
2940   // storage of curves in case of tangent free borders 
2941     if (droit)
2942       for (ic=0; ic<nedge;ic++) {
2943         Indices(nedge,ic,icplus,icmoins);  
2944         TopoDS_Edge ecom;
2945         ecom=TopoDS::Edge(Evive.Value(ic));
2946         if (ecom.IsSame(edgelibre1)||ecom.IsSame(edgelibre2)) {
2947           n3d++;
2948           TopOpeBRepDS_Curve& tcourb1 = DStr.ChangeCurve(indcurve3d.Value(n3d));
2949           tcourb1.Tolerance(tcourb1.Tolerance()+apperror);
2950           Interfc=ChFi3d_FilCurveInDS(indcurve3d.Value(n3d),Isurf,
2951                                     PSurf.Curves2d()->Value(n3d),orien);
2952           DStr.ChangeSurfaceInterferences(Isurf).Append(Interfc);
2953         }         
2954       } 
2955   }
2956   else { // there is only one partial result 
2957     done=Standard_False;
2958     hasresult=Standard_True;
2959     for (ic=0; ic<nedge;ic++) {
2960       Indices(nedge,ic,icplus,icmoins);
2961       if (!oksea.Value(ic)) {
2962         if (sharp.Value(ic) &&!deuxconges) {
2963           // limitation of the alive edge
2964           TopAbs_Orientation ori;
2965           gp_Pnt Pf,Pl,sommet1;
2966           TopoDS_Vertex Vd = TopExp::FirstVertex(TopoDS::Edge(Evive.Value(ic)));
2967           TopoDS_Vertex Vf = TopExp::LastVertex(TopoDS::Edge(Evive.Value(ic)));
2968           Pf=BRep_Tool::Pnt(Vd);
2969           Pl=BRep_Tool::Pnt(Vf);
2970           sommet1=BRep_Tool::Pnt(V1);
2971           if (Pf.Distance(sommet1)<Pl.Distance(sommet1))
2972             ori = TopAbs_FORWARD;
2973           else
2974             ori = TopAbs_REVERSED;
2975           Standard_Integer Iarc1=DStr.AddShape(TopoDS::Edge(Evive.Value(ic)));
2976           Interfp1=ChFi3d_FilPointInDS(ori,Iarc1,indpoint(ic,1),p.Value(ic,icplus));
2977           DStr.ChangeShapeInterferences(TopoDS::Edge(Evive.Value(ic))).Append(Interfp1);
2978         }
2979       }
2980     }
2981   }
2982 }