0027870: Modeling - refactoring of HLR algorithms
[occt.git] / src / HLRBRep / HLRBRep_Intersector.cxx
1 // Created on: 1992-10-22
2 // Created by: Christophe MARION
3 // Copyright (c) 1992-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 #ifndef No_Exception
18 #define No_Exception
19 #endif
20
21
22 #include <Bnd_Box.hxx>
23 #include <ElCLib.hxx>
24 #include <gp.hxx>
25 #include <gp_Lin.hxx>
26 #include <HLRBRep_Curve.hxx>
27 #include <HLRBRep_CurveTool.hxx>
28 #include <HLRBRep_EdgeData.hxx>
29 #include <HLRBRep_Intersector.hxx>
30 #include <HLRBRep_SurfaceTool.hxx>
31 #include <HLRBRep_ThePolygonOfInterCSurf.hxx>
32 #include <HLRBRep_ThePolyhedronOfInterCSurf.hxx>
33 #include <IntCurveSurface_IntersectionPoint.hxx>
34 #include <IntCurveSurface_IntersectionSegment.hxx>
35 #include <IntImpParGen.hxx>
36 #include <IntRes2d_IntersectionPoint.hxx>
37 #include <IntRes2d_IntersectionSegment.hxx>
38 #include <IntRes2d_Position.hxx>
39 #include <IntRes2d_Transition.hxx>
40 #include <StdFail_UndefinedDerivative.hxx>
41
42 #include <stdio.h>
43 //#define PERF
44
45 #ifdef PERF
46 static Standard_Integer NbIntersCS=0;
47 static Standard_Integer NbIntersCSVides=0;
48 static Standard_Integer NbIntersAuto=0;
49 static Standard_Integer NbIntersSimulate=0;
50  static Standard_Integer NbInters=0;
51  static Standard_Integer NbIntersVides=0;
52  static Standard_Integer NbInters1Segment=0;
53  static Standard_Integer NbInters1Point=0;
54  static Standard_Integer NbIntersNPoints=0;
55  static Standard_Integer NbIntersNSegments=0;
56  static Standard_Integer NbIntersPointEtSegment=0;
57 #endif
58
59 //=======================================================================
60 //function : HLRBRep_Intersector
61 //purpose  : 
62 //=======================================================================
63
64 HLRBRep_Intersector::HLRBRep_Intersector () :
65 myPolyhedron(NULL)
66 {
67 #ifdef PERF
68   if(NbInters) { 
69     printf("\n--------------------------------------");
70     printf("\nNbIntersSimulate  : %6d",NbIntersSimulate);
71     printf("\nNbIntersCrvSurf   : %6d",NbIntersCS);
72     printf("\n      -> vide     : %6d",NbIntersCSVides);
73     printf("\nNbAutoInters      : %6d\n",NbIntersAuto);
74     printf("\nNbInters          : %6d",NbInters);
75     printf("\n        Vides     : %6d",NbIntersVides);
76     printf("\n        1 Segment : %6d",NbInters1Segment);
77     printf("\n        1 Point   : %6d",NbInters1Point);
78     printf("\n       >1 Point   : %6d",NbIntersNPoints);
79     printf("\n       >1 Segment : %6d",NbIntersNSegments);
80     printf("\n     >1 Pt et Seg : %6d",NbIntersPointEtSegment);
81     printf("\n--------------------------------------\n");
82   }
83   NbIntersSimulate=NbIntersAuto=NbIntersCS
84   =NbInters=NbIntersVides=NbInters1Segment=NbInters1Point=NbIntersNPoints
85   = NbIntersNSegments=NbIntersPointEtSegment=NbIntersCSVides=0;
86 #endif
87
88   // Set minimal number of samples in case of HLR polygonal intersector.
89   const Standard_Integer aMinNbHLRSamples = 4;
90   myIntersector.SetMinNbSamples(aMinNbHLRSamples);
91 }
92
93 //=======================================================================
94 //function : Perform
95 //purpose  : 
96 //=======================================================================
97
98 void  HLRBRep_Intersector::Perform (const Standard_Address A1,
99                                     const Standard_Real da1,
100                                     const Standard_Real db1)
101 {
102 #ifdef PERF
103   NbIntersAuto++;
104 #endif
105
106
107   Standard_Address myC1 = ((HLRBRep_EdgeData*) A1)->Curve();
108
109   myTypePerform = 1;
110
111   gp_Pnt2d pa,pb;//,pa1,pb1;
112   Standard_Real a,b,d,tol;
113   Standard_ShortReal ta,tb;
114   
115   ((HLRBRep_EdgeData*) A1)->Status().Bounds(a,ta,b,tb);
116   d = b - a;
117   if (da1 != 0) a = a + d * da1;
118   if (db1 != 0) b = b - d * db1;
119   ((HLRBRep_Curve*)myC1)->D0(a,pa);
120   ((HLRBRep_Curve*)myC1)->D0(b,pb);
121   a = ((HLRBRep_Curve*)myC1)->Parameter2d(a);
122   b = ((HLRBRep_Curve*)myC1)->Parameter2d(b);
123   IntRes2d_Domain D1(pa,a,(Standard_Real)ta,pb,b,(Standard_Real)tb);
124
125   //modified by jgv, 18.04.2016 for OCC27341
126   //tol = (Standard_Real)(((HLRBRep_EdgeData*) A1)->Tolerance());
127   tol = Precision::Confusion();
128   //////////////////////////////////////////
129
130   myIntersector.Perform(myC1,D1,tol,tol);
131 }
132
133 //=======================================================================
134 //function : Perform
135 //purpose  : 
136 //=======================================================================
137
138 void  HLRBRep_Intersector::Perform (const Standard_Integer /*nA*/,
139                                     const Standard_Address A1,
140                                     const Standard_Real da1,
141                                     const Standard_Real db1,
142                                     const Standard_Integer /*nB*/,
143                                     const Standard_Address A2,
144                                     const Standard_Real da2,
145                                     const Standard_Real db2,
146                                     const Standard_Boolean EnBout)
147 {
148
149
150 //  if(EnBout) { 
151 //    myTypePerform=43; 
152 //    return;
153 //  }
154
155   Standard_Address myC1 = ((HLRBRep_EdgeData*) A1)->Curve();
156   Standard_Address myC2 = ((HLRBRep_EdgeData*) A2)->Curve();
157
158   myTypePerform = 1;
159
160   gp_Pnt2d pa1,pb1,pa2,pb2;
161   gp_Vec2d va1,vb1,va2,vb2;
162   Standard_Real a1,b1,a2,b2,d,dd,tol,tol1,tol2;
163   Standard_ShortReal ta,tb;
164
165   //modified by jgv, 18.04.2016 for OCC27341
166   //tol1 = (Standard_Real)(((HLRBRep_EdgeData*) A1)->Tolerance());
167   //tol2 = (Standard_Real)(((HLRBRep_EdgeData*) A2)->Tolerance());
168   tol1 = Precision::Confusion();
169   tol2 = Precision::Confusion();
170   //////////////////////////////////////////
171   if (tol1 > tol2) tol = tol1;
172   else             tol = tol2;
173
174
175   Standard_Boolean PasBon;
176   Standard_Real    decalagea1=100.0;
177   Standard_Real    decalagea2=100.0;
178   Standard_Real    decalageb1=100.0;
179   Standard_Real    decalageb2=100.0;
180   do { 
181     PasBon=Standard_False;
182     ((HLRBRep_EdgeData*) A1)->Status().Bounds(a1,ta,b1,tb); //--   -> Parametres 3d 
183     Standard_Real mtol = tol;
184     if(mtol<ta) mtol=ta;
185     if(mtol<tb) mtol=tb;
186     d = b1 - a1;
187
188     Standard_Real    pdist = tol;
189     if(pdist<0.0000001) pdist = 0.0000001;
190     
191
192     if (da1 != 0)  { 
193       //-- a = a + d * da1;
194       ((HLRBRep_Curve*)myC1)->D1(a1,pa1,va1);
195       Standard_Real qwe=va1.Magnitude();
196       if(qwe>1e-12) { 
197         dd=pdist*decalagea1/qwe;
198         if(dd<d*0.4) { 
199           a1+=dd;
200         }
201         else { 
202           a1+= d * da1; decalagea1=-1;
203         }
204       }
205       else { 
206         a1+=d * da1;  decalagea1=-1;
207       }
208     }
209     
210     if (db1 != 0) { 
211       //-- b = b - d * db1;
212       ((HLRBRep_Curve*)myC1)->D1(b1,pb1,vb1);
213       Standard_Real qwe=vb1.Magnitude();
214       if(qwe>1e-12) { 
215         dd=pdist*decalageb1/qwe;
216         if(dd<d*0.4) { 
217           b1-=dd;
218         }
219         else { 
220           b1-= d * db1; decalageb1=-1;
221         }
222       }
223       else { 
224         b1-=d * db1; decalageb1=-1;
225       }
226     }
227
228
229 //    if(EnBout) {  //-- ************************************************************
230 //      Standard_Real d=b1-a1;
231 //      a1+=d*0.45;
232 //      b1-=d*0.45;
233 //    }
234
235
236     
237     ((HLRBRep_Curve*)myC1)->D0(a1,pa1);
238     ((HLRBRep_Curve*)myC1)->D0(b1,pb1);
239     
240     a1 = ((HLRBRep_Curve*)myC1)->Parameter2d(a1);
241     b1 = ((HLRBRep_Curve*)myC1)->Parameter2d(b1);
242     
243     if(EnBout) { 
244       ta=tb=-1.;
245     }
246     
247     if(ta>tol) ta=(Standard_ShortReal) tol;
248     if(tb>tol) tb=(Standard_ShortReal) tol;
249     
250     IntRes2d_Domain D1(pa1,a1,(Standard_Real)ta,pb1,b1,(Standard_Real)tb);  
251     
252     ((HLRBRep_EdgeData*) A2)->Status().Bounds(a2,ta,b2,tb);
253     mtol = tol;
254     if(mtol<ta) mtol=ta;
255     if(mtol<tb) mtol=tb;
256     
257     d = b2-a2;
258     
259     if (da2 != 0)  { 
260       //-- a = a + d * da2;
261       ((HLRBRep_Curve*)myC2)->D1(a2,pa2,va2);
262       Standard_Real qwe=va2.Magnitude();
263       if(qwe>1e-12) { 
264         dd=pdist*decalagea2/qwe;
265         if(dd<d*0.4) { 
266           a2+=dd;
267         }
268         else { 
269           a2+= d * da2;   decalagea2=-1;
270         }
271       }
272       else { 
273         a2+=d * da2;      decalagea2=-1;
274       }
275     }
276     
277     if (db2 != 0) { 
278       //-- b = b - d * db2;
279       ((HLRBRep_Curve*)myC2)->D1(b2,pb2,vb2);
280       Standard_Real qwe=vb2.Magnitude();
281       if(qwe>1e-12) { 
282         dd=pdist*decalageb2/qwe;
283         if(dd<d*0.4) { 
284           b2-=dd;
285         }
286         else { 
287           b2-= d * db2;           decalageb2=-1;
288         }
289       }
290       else { 
291         b2-=d * db2;      decalageb2=-1;
292       }
293     }
294
295
296
297 //    if(EnBout) { //-- ************************************************************
298 //      Standard_Real d=b2-a2;
299 //      a2+=d*0.45;
300 //      b2-=d*0.45;
301 //    }
302
303
304
305
306
307     
308     ((HLRBRep_Curve*)myC2)->D0(a2,pa2);
309     ((HLRBRep_Curve*)myC2)->D0(b2,pb2);
310     
311     a2 = ((HLRBRep_Curve*)myC2)->Parameter2d(a2);
312     b2 = ((HLRBRep_Curve*)myC2)->Parameter2d(b2);
313     
314     if(EnBout) { 
315       ta=tb=-1.;
316     }
317     
318     if(ta>tol) ta=(Standard_ShortReal) tol;
319     if(tb>tol) tb=(Standard_ShortReal) tol;
320     
321     IntRes2d_Domain D2(pa2,a2,(Standard_Real)ta,pb2,b2,(Standard_Real)tb);
322     
323     
324     if(EnBout) { 
325       Standard_Real a1a2 = (da1 || da2)? pa1.Distance(pa2) : RealLast();
326       Standard_Real a1b2 = (da1 || db2)? pa1.Distance(pb2) : RealLast();
327       Standard_Real b1a2 = (db1 || da2)? pb1.Distance(pa2) : RealLast();
328       Standard_Real b1b2 = (db1 || db2)? pb1.Distance(pb2) : RealLast();
329       
330       Standard_Integer cote=1;
331       Standard_Real mindist = a1a2;      //-- cas 1 
332       if(mindist>a1b2) { mindist = a1b2; cote=2; } 
333       if(mindist>b1a2) { mindist = b1a2; cote=3; } 
334       if(mindist>b1b2) { mindist = b1b2; cote=4; } 
335
336       
337
338       //--printf("\n----- Edge %3d  %3d   [%7.5g  %7.5g] [%7.5g  %7.5g] Mindist:%8.5g   1000*Tol:%8.5g\n",
339       //--     nA,nB,decalagea1,decalageb1,decalagea2,decalageb2,mindist,1000.0*tol);
340       
341       
342       if(mindist < tol*1000) { 
343         PasBon=Standard_True;
344         switch (cote) { 
345         case 1:  { decalagea1*=2; decalagea2*=2; break; } 
346         case 2:  { decalagea1*=2; decalageb2*=2; break; } 
347         case 3:  { decalageb1*=2; decalagea2*=2; break; } 
348         default: { decalageb1*=2; decalageb2*=2; break; } 
349         }
350         if(decalagea1<0.0 || decalagea2<0.0 || decalageb1<0.0 || decalageb2<=0.0) { 
351           PasBon=Standard_False; 
352         }
353       }
354     }
355     if(PasBon==Standard_False) { 
356       myIntersector.Perform(myC1,D1,myC2,D2,tol,tol);
357     }
358   }
359   while(PasBon);
360   
361
362   
363   
364 #ifdef PERF
365   NbInters++;
366   if(myIntersector.NbPoints()==1) { 
367     if(myIntersector.NbSegments()==0) { 
368       NbInters1Point++;
369     }
370     else { 
371       NbIntersPointEtSegment++;
372     }
373   }
374   else if(myIntersector.NbPoints()==0) { 
375     if(myIntersector.NbSegments()==0) {
376       NbIntersVides++;
377     }
378     else if(myIntersector.NbSegments()==1) {
379       NbInters1Segment++;
380     }
381     else { 
382       NbIntersNSegments++;
383     }
384   }
385   else {
386     if(myIntersector.NbSegments()==0) { 
387       NbIntersNPoints++;
388     }
389     else { 
390       NbIntersPointEtSegment++;
391     }
392   } 
393 #endif
394 }
395
396 //=======================================================================
397 //function : SimulateOnePoint
398 //purpose  : 
399 //=======================================================================
400
401 void  HLRBRep_Intersector::SimulateOnePoint(const Standard_Address A1,
402                                             const Standard_Real    u,
403                                             const Standard_Address A2,
404                                             const Standard_Real    v) { 
405 #ifdef PERF
406   NbIntersSimulate++;
407 #endif
408   Standard_Address myC1 = ((HLRBRep_EdgeData*) A1)->Curve();
409   Standard_Address myC2 = ((HLRBRep_EdgeData*) A2)->Curve();
410
411   Standard_Real u3= ((HLRBRep_Curve*)myC1)->Parameter3d(u);
412   Standard_Real v3= ((HLRBRep_Curve*)myC2)->Parameter3d(v);
413   gp_Pnt2d P13,P23;   
414   gp_Vec2d T13,T23;
415   ((HLRBRep_Curve*)myC1)->D1(u3,P13,T13);
416   ((HLRBRep_Curve*)myC2)->D1(v3,P23,T23);
417   
418   IntRes2d_Transition Tr1,Tr2;
419   IntRes2d_Position Pos1,Pos2;
420   Pos1=Pos2=IntRes2d_Middle;
421   
422   IntImpParGen::DetermineTransition(Pos1,T13,Tr1,Pos2,T23,Tr2,0.0);
423   myTypePerform = 0;
424   mySinglePoint.SetValues(P13,u,v,Tr1,Tr2,Standard_False);
425 }
426
427
428
429 //=======================================================================
430 //function : Load
431 //purpose  : 
432 //=======================================================================
433
434 void  HLRBRep_Intersector::Load (Standard_Address& A)
435 {
436   mySurface = A;
437   if (myPolyhedron != NULL) { 
438     delete myPolyhedron;
439     myPolyhedron = NULL;
440   }
441 }
442
443 //=======================================================================
444 //function : Perform
445 //purpose  : 
446 //=======================================================================
447
448 void  HLRBRep_Intersector::Perform (const gp_Lin& L,
449                                     const Standard_Real P)
450 {
451   myTypePerform = 2;
452   GeomAbs_SurfaceType typ = HLRBRep_SurfaceTool::GetType(mySurface);
453   switch (typ) {
454   case GeomAbs_Plane :
455   case GeomAbs_Cylinder :
456   case GeomAbs_Cone :
457   case GeomAbs_Sphere :
458   case GeomAbs_Torus :
459     myCSIntersector.Perform(L,mySurface);
460     break;
461     default :
462     {
463       if (myPolyhedron == NULL) {
464         Standard_Integer nbsu,nbsv;
465         Standard_Real u1,v1,u2,v2;
466         u1   = HLRBRep_SurfaceTool::FirstUParameter(mySurface);
467         v1   = HLRBRep_SurfaceTool::FirstVParameter(mySurface);
468         u2   = HLRBRep_SurfaceTool::LastUParameter(mySurface);
469         v2   = HLRBRep_SurfaceTool::LastVParameter(mySurface);   
470         nbsu = HLRBRep_SurfaceTool::NbSamplesU(mySurface,u1,u2);
471         nbsv = HLRBRep_SurfaceTool::NbSamplesV(mySurface,v1,v2);
472         myPolyhedron =
473     new HLRBRep_ThePolyhedronOfInterCSurf(mySurface,nbsu,nbsv,u1,v1,u2,v2);
474       }
475       Standard_Real x0,y0,z0,x1,y1,z1,pmin,pmax;//,pp;
476       myPolyhedron->Bounding().Get(x0,y0,z0,x1,y1,z1);
477 #if 0
478       pmax = pmin = ElCLib::Parameter(L, gp_Pnt((x1+x0)*0.5,
479                                                 (y1+y0)*0.5,
480                                                 (z1+z0)*0.5));
481       Standard_Real d = (x1-x0) + (y1-y0) + (z1-z0);
482       pmin -= d;
483       pmax += d;
484       if (pmin > P) pmin = P - d;
485       if (pmax > P) pmax = P;
486       HLRBRep_ThePolygonOfInterCSurf Polygon(L,pmin,pmax,3);
487       myCSIntersector.Perform(L,Polygon,mySurface,
488                               *((HLRBRep_ThePolyhedronOfInterCSurf*)
489                                 myPolyhedron));
490       break;
491 #else 
492       //-- On va rejeter tous les points de parametres > P
493       Standard_Real p;
494       p = ElCLib::Parameter(L, gp_Pnt(x0,y0,z0));  pmin=pmax=p;
495       p = ElCLib::Parameter(L, gp_Pnt(x0,y0,z1));  if(pmin>p) pmin=p; if(pmax<p) pmax=p;
496
497       p = ElCLib::Parameter(L, gp_Pnt(x1,y0,z0));  if(pmin>p) pmin=p; if(pmax<p) pmax=p;
498       p = ElCLib::Parameter(L, gp_Pnt(x1,y0,z1));  if(pmin>p) pmin=p; if(pmax<p) pmax=p;
499
500       p = ElCLib::Parameter(L, gp_Pnt(x0,y1,z0));  if(pmin>p) pmin=p; if(pmax<p) pmax=p;
501       p = ElCLib::Parameter(L, gp_Pnt(x0,y1,z1));  if(pmin>p) pmin=p; if(pmax<p) pmax=p;
502
503       p = ElCLib::Parameter(L, gp_Pnt(x1,y1,z0));  if(pmin>p) pmin=p; if(pmax<p) pmax=p;
504       p = ElCLib::Parameter(L, gp_Pnt(x1,y1,z1));  if(pmin>p) pmin=p; if(pmax<p) pmax=p;
505       pmin-=0.000001; pmax+=0.000001;
506
507       if(pmin>P) { pmin=pmax+1; pmax=pmax+2; } //-- on va rejeter avec les boites
508       else { 
509         if(pmax>P) pmax=P+0.0000001;
510       }
511       HLRBRep_ThePolygonOfInterCSurf Polygon(L,pmin,pmax,3);
512       myCSIntersector.Perform(L,Polygon,mySurface,
513                               *((HLRBRep_ThePolyhedronOfInterCSurf*)
514                                 myPolyhedron));
515       
516       break;
517 #endif
518
519     }
520   }
521 #ifdef PERF
522   NbIntersCS++;
523   if(myCSIntersector.NbPoints()==0) { 
524     NbIntersCSVides++;
525   }
526 #endif
527  
528 }
529
530 //=======================================================================
531 //function : IsDone
532 //purpose  : 
533 //=======================================================================
534
535 Standard_Boolean HLRBRep_Intersector::IsDone () const
536
537   if(myTypePerform == 1) 
538     return myIntersector  .IsDone();
539   else if(myTypePerform ==2) 
540     return myCSIntersector.IsDone();
541   else 
542     return(Standard_True);
543 }
544
545 //=======================================================================
546 //function : NbPoints
547 //purpose  : 
548 //=======================================================================
549
550 Standard_Integer HLRBRep_Intersector::NbPoints() const
551 {
552   if(myTypePerform==43) return(0);
553
554   if (myTypePerform == 1) 
555     return myIntersector  .NbPoints();
556   else if(myTypePerform == 2) 
557     return myCSIntersector.NbPoints();
558   else 
559     return(1);
560 }
561
562 //=======================================================================
563 //function : Point
564 //purpose  : 
565 //=======================================================================
566
567 const IntRes2d_IntersectionPoint &
568 HLRBRep_Intersector::Point (const Standard_Integer N) const
569 {
570   if(myTypePerform==0) 
571     return(mySinglePoint);
572   else 
573     return myIntersector.Point(N);
574 }
575
576 //=======================================================================
577 //function : CSPoint
578 //purpose  : 
579 //=======================================================================
580
581 const IntCurveSurface_IntersectionPoint &
582  HLRBRep_Intersector::CSPoint (const Standard_Integer N) const
583 {
584   return myCSIntersector.Point(N);
585 }
586
587 //=======================================================================
588 //function : NbSegments
589 //purpose  : 
590 //=======================================================================
591
592 Standard_Integer HLRBRep_Intersector::NbSegments () const
593 {
594   if(myTypePerform == 1) 
595     return myIntersector  .NbSegments();
596   else if(myTypePerform==2) 
597     return myCSIntersector.NbSegments();
598   else 
599     return(0);
600 }
601
602 //=======================================================================
603 //function : Segment
604 //purpose  : 
605 //=======================================================================
606
607 const IntRes2d_IntersectionSegment &
608 HLRBRep_Intersector::Segment (const Standard_Integer N) const
609 {
610   return myIntersector .Segment(N);
611 }
612
613 //=======================================================================
614 //function : CSSegment
615 //purpose  : 
616 //=======================================================================
617
618 const IntCurveSurface_IntersectionSegment & 
619 HLRBRep_Intersector::CSSegment (const Standard_Integer N) const
620 {
621   return myCSIntersector.Segment(N);
622 }
623
624 //=======================================================================
625 //function : Destroy
626 //purpose  : 
627 //=======================================================================
628
629 void HLRBRep_Intersector::Destroy ()
630 {
631   if (myPolyhedron != NULL)
632     delete myPolyhedron;
633 }
634
635
636
637
638
639
640
641
642
643
644 /* ********************************************************************************
645    
646    sauvegarde de l etat du 23 janvier 98 
647    
648    
649 void  HLRBRep_Intersector::Perform (const Standard_Integer nA,
650                                     const Standard_Address A1,
651                                     const Standard_Real da1,
652                                     const Standard_Real db1,
653                                     const Standard_Integer nB,
654                                     const Standard_Address A2,
655                                     const Standard_Real da2,
656                                     const Standard_Real db2,
657                                     const Standard_Boolean EnBout)
658 {
659   Standard_Address myC1 = ((HLRBRep_EdgeData*) A1)->Curve();
660   Standard_Address myC2 = ((HLRBRep_EdgeData*) A2)->Curve();
661
662   myTypePerform = 1;
663
664   gp_Pnt2d pa,pb;
665   Standard_Real a,b,d,tol,tol1,tol2;
666   Standard_ShortReal ta,tb;
667
668   tol1 = (Standard_Real)(((HLRBRep_EdgeData*) A1)->Tolerance());
669   tol2 = (Standard_Real)(((HLRBRep_EdgeData*) A2)->Tolerance());
670   if (tol1 > tol2) tol = tol1;
671   else             tol = tol2;
672
673   ((HLRBRep_EdgeData*) A1)->Status().Bounds(a,ta,b,tb); //--   -> Parametres 3d 
674   Standard_Real mtol = tol;
675   if(mtol<ta) mtol=ta;
676   if(mtol<tb) mtol=tb;
677   d = b - a;
678   if (da1 != 0) a = a + d * da1;
679   if (db1 != 0) b = b - d * db1;
680   ((HLRBRep_Curve*)myC1)->D0(a,pa);
681   ((HLRBRep_Curve*)myC1)->D0(b,pb);
682
683   a = ((HLRBRep_Curve*)myC1)->Parameter2d(a);
684   b = ((HLRBRep_Curve*)myC1)->Parameter2d(b);
685
686   if(EnBout) { 
687     ta=tb=0;
688   }
689   
690   if(ta>tol) ta=tol;
691   if(tb>tol) tb=tol;
692
693
694   IntRes2d_Domain D1(pa,a,(Standard_Real)ta,pb,b,(Standard_Real)tb);  
695
696   ((HLRBRep_EdgeData*) A2)->Status().Bounds(a,ta,b,tb);
697   mtol = tol;
698   if(mtol<ta) mtol=ta;
699   if(mtol<tb) mtol=tb;
700
701   d = b - a;
702   if (da2 != 0) a = a + d * da2;
703   if (db2 != 0) b = b - d * db2;
704   ((HLRBRep_Curve*)myC2)->D0(a,pa);
705   ((HLRBRep_Curve*)myC2)->D0(b,pb);
706
707   a = ((HLRBRep_Curve*)myC2)->Parameter2d(a);
708   b = ((HLRBRep_Curve*)myC2)->Parameter2d(b);
709  
710   if(EnBout) { 
711     ta=tb=0;
712   }
713
714   if(ta>tol) ta=tol;
715   if(tb>tol) tb=tol;
716
717
718  IntRes2d_Domain D2(pa,a,(Standard_Real)ta,pb,b,(Standard_Real)tb);
719
720   myIntersector.Perform(myC1,D1,myC2,D2,tol,tol);
721   
722   
723   
724   
725   
726 #ifdef PERF
727   NbInters++;
728   if(myIntersector.NbPoints()==1) { 
729     if(myIntersector.NbSegments()==0) { 
730       NbInters1Point++;
731     }
732     else { 
733       NbIntersPointEtSegment++;
734     }
735   }
736   else if(myIntersector.NbPoints()==0) { 
737     if(myIntersector.NbSegments()==0) {
738       NbIntersVides++;
739     }
740     else if(myIntersector.NbSegments()==1) {
741       NbInters1Segment++;
742     }
743     else { 
744       NbIntersNSegments++;
745     }
746   }
747   else {
748     if(myIntersector.NbSegments()==0) { 
749       NbIntersNPoints++;
750     }
751     else { 
752       NbIntersPointEtSegment++;
753     }
754   } 
755 #endif
756 }
757 ******************************************************************************** */