Integration of OCCT 6.5.0 from SVN
[occt.git] / src / Adaptor3d / Adaptor3d_TopolTool.cxx
1
2 #include <Standard_NotImplemented.hxx>
3 #include <Adaptor3d_TopolTool.ixx>
4 #include <Precision.hxx>
5
6 #include <gp_Cone.hxx>
7 #include <gp_Pnt.hxx>
8 #include <gp_Trsf.hxx>
9
10 #define myInfinite 1.e15
11
12 static void GetConeApexParam(const gp_Cone& C, Standard_Real& U, Standard_Real& V)
13 {
14   const gp_Ax3& Pos = C.Position();
15   Standard_Real Radius = C.RefRadius();
16   Standard_Real SAngle = C.SemiAngle();
17   const gp_Pnt& P = C.Apex();
18  
19   gp_Trsf T;
20   T.SetTransformation (Pos);
21   gp_Pnt Ploc = P.Transformed (T);
22
23   if(Ploc.X() ==0.0  &&  Ploc.Y()==0.0 ) {
24     U = 0.0;
25   }
26   else if ( -Radius > Ploc.Z()* Tan(SAngle) ) {
27     // le point est du `mauvais` cote de l`apex
28     U = atan2(-Ploc.Y(), -Ploc.X());
29   }
30   else {
31     U = atan2(Ploc.Y(),Ploc.X());
32   }
33   if      (U < -1.e-16)  U += (PI+PI);
34   else if (U < 0)        U = 0;
35
36   V =  sin(SAngle) * ( Ploc.X() * cos(U) + Ploc.Y() * sin(U) - Radius)
37     + cos(SAngle) * Ploc.Z();
38 }
39
40
41 Adaptor3d_TopolTool::Adaptor3d_TopolTool () : nbRestr(0),idRestr(0),myNbSamplesU(-1)
42                                               
43 {
44 }
45
46 Adaptor3d_TopolTool::Adaptor3d_TopolTool (const Handle(Adaptor3d_HSurface)& S)
47 {
48   Initialize(S);
49 }
50
51
52 void Adaptor3d_TopolTool::Initialize ()
53 {
54  Standard_NotImplemented::Raise("Adaptor3d_TopolTool::Initialize ()");
55 }
56
57 void Adaptor3d_TopolTool::Initialize (const Handle(Adaptor3d_HSurface)& S)
58 {
59   Standard_Real pinf,psup,deltap;
60   //Adaptor2d_Line2d  * Line2dPtr ;
61
62   myNbSamplesU=-1;
63   Uinf = S->FirstUParameter(); // ou UIntervalFirst ??
64   Vinf = S->FirstVParameter();
65   Usup = S->LastUParameter();
66   Vsup = S->LastVParameter();
67   nbRestr = 0;
68   idRestr = 0;
69
70   Standard_Boolean Uinfinfinite = Precision::IsNegativeInfinite(Uinf);
71   Standard_Boolean Usupinfinite = Precision::IsPositiveInfinite(Usup);
72   Standard_Boolean Vinfinfinite = Precision::IsNegativeInfinite(Vinf);
73   Standard_Boolean Vsupinfinite = Precision::IsPositiveInfinite(Vsup);
74
75   if (! Vinfinfinite) {
76     deltap = Min(Usup-Uinf,2.*myInfinite);
77     if (Uinf >= -myInfinite){
78       pinf = Uinf;
79       psup = pinf + deltap;
80     }
81     else if (Usup <= myInfinite) {
82       psup = Usup;
83       pinf = psup - deltap;
84     }
85     else {
86       pinf = -myInfinite;
87       psup = myInfinite;
88     }
89
90     // Line2dPtr = new Adaptor2d_Line2d(gp_Pnt2d(0.,Vinf),gp_Dir2d(1.,0.),pinf,psup);
91     //myRestr[nbRestr] = new Adaptor2d_HLine2d(*Line2dPtr);
92     myRestr[nbRestr] = new Adaptor2d_HLine2d(Adaptor2d_Line2d(gp_Pnt2d(0.,Vinf),gp_Dir2d(1.,0.),pinf,psup));
93     nbRestr++;
94   }
95
96   if (!Usupinfinite) {
97     deltap = Min(Vsup-Vinf,2.*myInfinite);
98     if (Vinf >= -myInfinite){
99       pinf = Vinf;
100       psup = pinf + deltap;
101     }
102     else if (Vsup <= myInfinite) {
103       psup = Vsup;
104       pinf = psup - deltap;
105     }
106     else {
107       pinf = -myInfinite;
108       psup = myInfinite;
109     }
110
111
112     
113     //Line2dPtr = new Adaptor2d_Line2d(gp_Pnt2d(Usup,0.),gp_Dir2d(0.,1.),pinf,psup);
114     //myRestr[nbRestr] = new Adaptor2d_HLine2d(*Line2dPtr);
115     myRestr[nbRestr] = new Adaptor2d_HLine2d(Adaptor2d_Line2d(gp_Pnt2d(Usup,0.),gp_Dir2d(0.,1.),pinf,psup));
116     nbRestr++;
117   }
118
119   if (!Vsupinfinite) {
120     deltap = Min(Usup-Uinf,2.*myInfinite);
121     if (-Usup >= -myInfinite){
122       pinf = -Usup;
123       psup = pinf + deltap;
124     }
125     else if (-Uinf <= myInfinite) {
126       psup = -Uinf;
127       pinf = psup - deltap;
128     }
129     else {
130       pinf = -myInfinite;
131       psup = myInfinite;
132     }
133
134     
135     //Line2dPtr = new Adaptor2d_Line2d(gp_Pnt2d(0.,Vsup),gp_Dir2d(-1.,0.),pinf,psup);
136     //myRestr[nbRestr] = new Adaptor2d_HLine2d(*Line2dPtr);
137     myRestr[nbRestr] = new Adaptor2d_HLine2d(Adaptor2d_Line2d(gp_Pnt2d(0.,Vsup),gp_Dir2d(-1.,0.),pinf,psup));
138     nbRestr++;
139   }
140
141   if (!Uinfinfinite) {
142     deltap = Min(Vsup-Vinf,2.*myInfinite);
143     if (-Vsup >= -myInfinite){
144       pinf = -Vsup;
145       psup = pinf + deltap;
146     }
147     else if (-Vinf <= myInfinite) {
148       psup = -Vinf;
149       pinf = psup - deltap;
150     }
151     else {
152       pinf = -myInfinite;
153       psup = myInfinite;
154     }
155
156     //Line2dPtr = new Adaptor2d_Line2d(gp_Pnt2d(Uinf,0.),gp_Dir2d(0.,-1),pinf,psup);
157     //myRestr[nbRestr] = new Adaptor2d_HLine2d(*Line2dPtr);
158     myRestr[nbRestr] = new Adaptor2d_HLine2d(Adaptor2d_Line2d(gp_Pnt2d(Uinf,0.),gp_Dir2d(0.,-1),pinf,psup));
159     nbRestr++;
160   }
161
162   myS = S;
163
164   if(nbRestr == 2 && S->GetType() == GeomAbs_Cone ) {
165     Standard_Real U = 0., V = 0.;
166     GetConeApexParam(S->Cone(),U,V);
167
168     deltap = Min(Usup-Uinf,2.*myInfinite);
169     if (Uinf >= -myInfinite){
170       pinf = Uinf;
171       psup = pinf + deltap;
172     }
173     else if (Usup <= myInfinite) {
174       psup = Usup;
175       pinf = psup - deltap;
176     }
177     else {
178       pinf = -myInfinite;
179       psup = myInfinite;
180     }
181
182     //Line2dPtr = new Adaptor2d_Line2d(gp_Pnt2d(U,V),gp_Dir2d(1.,0.),pinf,psup);
183     //myRestr[nbRestr] = new Adaptor2d_HLine2d(*Line2dPtr);
184     myRestr[nbRestr] = new Adaptor2d_HLine2d(Adaptor2d_Line2d(gp_Pnt2d(U,V),gp_Dir2d(1.,0.),pinf,psup));
185     nbRestr++;
186   }
187 }
188
189
190 void Adaptor3d_TopolTool::Init ()
191 {
192   idRestr = 0;
193 }
194
195
196 Standard_Boolean Adaptor3d_TopolTool::More ()
197 {
198   return (idRestr < nbRestr);
199 }
200
201 Handle(Adaptor2d_HCurve2d) Adaptor3d_TopolTool::Value ()
202 {
203   if (idRestr >= nbRestr) {Standard_DomainError::Raise();}
204   return myRestr[idRestr];
205 }
206
207 void Adaptor3d_TopolTool::Next ()
208 {
209   idRestr++;
210 }
211
212
213 void Adaptor3d_TopolTool::Initialize(const Handle(Adaptor2d_HCurve2d)& C)
214 {
215   nbVtx = 0;
216   idVtx = 0;
217   Standard_Real theUinf,theUsup;
218   theUinf = C->FirstParameter();
219   theUsup = C->LastParameter();
220 //  if (!Precision::IsNegativeInfinite(theUinf)) {
221   if (theUinf > -myInfinite) {
222     myVtx[nbVtx] = new Adaptor3d_HVertex(C->Value(theUinf),TopAbs_FORWARD,1.e-8);
223     nbVtx++;
224   }
225 //  if (!Precision::IsPositiveInfinite(theUsup)) {
226   if (theUsup < myInfinite) {
227     myVtx[nbVtx] = new Adaptor3d_HVertex(C->Value(theUsup),TopAbs_REVERSED,1.e-8);
228     nbVtx++;
229   }
230 }
231
232
233 void Adaptor3d_TopolTool::InitVertexIterator ()
234 {
235   idVtx =  0;
236 }
237
238
239 Standard_Boolean Adaptor3d_TopolTool::MoreVertex ()
240 {
241   return (idVtx < nbVtx);
242 }
243
244
245 Handle(Adaptor3d_HVertex) Adaptor3d_TopolTool::Vertex ()
246 {
247   if (idVtx >= nbVtx) {Standard_DomainError::Raise();}
248   return myVtx[idVtx];
249 }
250
251 void Adaptor3d_TopolTool::NextVertex ()
252 {
253   idVtx++;
254 }
255
256
257 TopAbs_State Adaptor3d_TopolTool::Classify(const gp_Pnt2d& P,
258                                          const Standard_Real Tol,
259                                          const Standard_Boolean )
260 //                                       const Standard_Boolean RecadreOnPeriodic)
261 {
262
263   Standard_Real U = P.X();
264   Standard_Real V = P.Y();
265
266   if (nbRestr == 4) {
267     if ((U < Uinf - Tol) || (U > Usup + Tol) ||
268         (V < Vinf - Tol) || (V > Vsup + Tol)) {
269       return TopAbs_OUT;
270     }
271     if ((Abs(U - Uinf) <= Tol) || (Abs(U - Usup) <= Tol) ||
272         (Abs(V - Vinf) <= Tol) || (Abs(V - Vsup) <= Tol)) {
273       return TopAbs_ON;
274     }
275     return TopAbs_IN;
276   }
277   else if (nbRestr == 0) {
278     return TopAbs_IN;
279   }
280   else {
281     Standard_Boolean dansu,dansv,surumin,surumax,survmin,survmax;
282     if (Precision::IsNegativeInfinite(Uinf) && 
283         Precision::IsPositiveInfinite(Usup)) {
284       dansu = Standard_True;
285       surumin = surumax = Standard_False;
286     }
287     else if (Precision::IsNegativeInfinite(Uinf)) {
288       surumin = Standard_False;
289       if (U >= Usup+Tol) {
290         dansu = Standard_False;
291         surumax = Standard_False;
292       }
293       else {
294         dansu = Standard_True;
295         surumax = Standard_False;
296         if (Abs(U-Usup)<=Tol) {
297           surumax = Standard_True;
298         }
299       }
300     }
301     else if (Precision::IsPositiveInfinite(Usup)) {
302       surumax = Standard_False;
303       if (U < Uinf-Tol) {
304         dansu = Standard_False;
305         surumin = Standard_False;
306       }
307       else {
308         dansu = Standard_True;
309         surumin = Standard_False;
310         if (Abs(U-Uinf)<=Tol) {
311           surumin = Standard_True;
312         }
313       }
314     }
315     else {
316       if ((U < Uinf - Tol) || (U > Usup + Tol)) {
317         surumin = surumax = dansu = Standard_False;
318       }
319       else {
320         dansu = Standard_True;
321         surumin = surumax = Standard_False;
322         if (Abs(U-Uinf)<=Tol) {
323           surumin = Standard_True;
324         }
325         else if (Abs(U-Usup)<=Tol) {
326           surumax = Standard_True;
327         }
328       }
329     }
330
331     if (Precision::IsNegativeInfinite(Vinf) &&
332         Precision::IsPositiveInfinite(Vsup)) {
333       dansv = Standard_True;
334       survmin = survmax = Standard_False;
335     }
336     else if (Precision::IsNegativeInfinite(Vinf)) {
337       survmin = Standard_False;
338       if (V > Vsup+Tol) {
339         dansv = Standard_False;
340         survmax = Standard_False;
341       }
342       else {
343         dansv = Standard_True;
344         survmax = Standard_False;
345         if (Abs(V-Vsup)<=Tol) {
346           survmax = Standard_True;
347         }
348       }
349     }
350     else if (Precision::IsPositiveInfinite(Vsup)) {
351       survmax = Standard_False;
352       if (V < Vinf-Tol) {
353         dansv = Standard_False;
354         survmin = Standard_False;
355       }
356       else {
357         dansv = Standard_True;
358         survmin = Standard_False;
359         if (Abs(V-Vinf)<=Tol) {
360           survmin = Standard_True;
361         }
362       }
363     }
364     else {
365       if ((V < Vinf - Tol) || (V > Vsup + Tol)) {
366         survmin = survmax = dansv = Standard_False;
367       }
368       else {
369         dansv = Standard_True;
370         survmin = survmax = Standard_False;
371         if (Abs(V-Vinf)<=Tol) {
372           survmin = Standard_True;
373         }
374         else if (Abs(V-Vsup)<=Tol) {
375           survmax = Standard_True;
376         }
377       }
378     }
379
380     if (!dansu || !dansv) {
381       return TopAbs_OUT;
382     }
383     if (surumin || survmin || surumax || survmax) {
384       return TopAbs_ON;
385     }
386     return TopAbs_IN;
387   }
388 }
389
390
391
392 Standard_Boolean  Adaptor3d_TopolTool::IsThePointOn(const gp_Pnt2d& P,
393                                              const Standard_Real Tol,
394                                              const Standard_Boolean )
395 //                                           const Standard_Boolean RecadreOnPeriodic)
396 {
397
398   Standard_Real U = P.X();
399   Standard_Real V = P.Y();
400
401   if (nbRestr == 4) {
402     if ((U < Uinf - Tol) || (U > Usup + Tol) ||
403         (V < Vinf - Tol) || (V > Vsup + Tol)) {
404       return(Standard_False);
405     }
406     if ((Abs(U - Uinf) <= Tol) || (Abs(U - Usup) <= Tol) ||
407         (Abs(V - Vinf) <= Tol) || (Abs(V - Vsup) <= Tol)) {
408       return(Standard_True);
409     }
410     return(Standard_False);
411   }
412   else if (nbRestr == 0) {
413     return(Standard_False);
414   }
415   else {
416     Standard_Boolean dansu,dansv,surumin,surumax,survmin,survmax;
417     if (Precision::IsNegativeInfinite(Uinf) && 
418         Precision::IsPositiveInfinite(Usup)) {
419       dansu = Standard_True;
420       surumin = surumax = Standard_False;
421     }
422     else if (Precision::IsNegativeInfinite(Uinf)) {
423       surumin = Standard_False;
424       if (U >= Usup+Tol) {
425         dansu = Standard_False;
426         surumax = Standard_False;
427       }
428       else {
429         dansu = Standard_True;
430         surumax = Standard_False;
431         if (Abs(U-Usup)<=Tol) {
432           surumax = Standard_True;
433         }
434       }
435     }
436     else if (Precision::IsPositiveInfinite(Usup)) {
437       surumax = Standard_False;
438       if (U < Uinf-Tol) {
439         dansu = Standard_False;
440         surumin = Standard_False;
441       }
442       else {
443         dansu = Standard_True;
444         surumin = Standard_False;
445         if (Abs(U-Uinf)<=Tol) {
446           surumin = Standard_True;
447         }
448       }
449     }
450     else {
451       if ((U < Uinf - Tol) || (U > Usup + Tol)) {
452         surumin = surumax = dansu = Standard_False;
453       }
454       else {
455         dansu = Standard_True;
456         surumin = surumax = Standard_False;
457         if (Abs(U-Uinf)<=Tol) {
458           surumin = Standard_True;
459         }
460         else if (Abs(U-Usup)<=Tol) {
461           surumax = Standard_True;
462         }
463       }
464     }
465
466     if (Precision::IsNegativeInfinite(Vinf) &&
467         Precision::IsPositiveInfinite(Vsup)) {
468       dansv = Standard_True;
469       survmin = survmax = Standard_False;
470     }
471     else if (Precision::IsNegativeInfinite(Vinf)) {
472       survmin = Standard_False;
473       if (V > Vsup+Tol) {
474         dansv = Standard_False;
475         survmax = Standard_False;
476       }
477       else {
478         dansv = Standard_True;
479         survmax = Standard_False;
480         if (Abs(V-Vsup)<=Tol) {
481           survmax = Standard_True;
482         }
483       }
484     }
485     else if (Precision::IsPositiveInfinite(Vsup)) {
486       survmax = Standard_False;
487       if (V < Vinf-Tol) {
488         dansv = Standard_False;
489         survmin = Standard_False;
490       }
491       else {
492         dansv = Standard_True;
493         survmin = Standard_False;
494         if (Abs(V-Vinf)<=Tol) {
495           survmin = Standard_True;
496         }
497       }
498     }
499     else {
500       if ((V < Vinf - Tol) || (V > Vsup + Tol)) {
501         survmin = survmax = dansv = Standard_False;
502       }
503       else {
504         dansv = Standard_True;
505         survmin = survmax = Standard_False;
506         if (Abs(V-Vinf)<=Tol) {
507           survmin = Standard_True;
508         }
509         else if (Abs(V-Vsup)<=Tol) {
510           survmax = Standard_True;
511         }
512       }
513     }
514
515     if (!dansu || !dansv) {
516       return(Standard_False);
517     }
518     if (surumin || survmin || surumax || survmax) {
519       return(Standard_True);
520     }
521     return(Standard_False);;
522   }
523 }
524
525
526 TopAbs_Orientation Adaptor3d_TopolTool::Orientation
527   (const Handle(Adaptor2d_HCurve2d)&)
528 {
529   return TopAbs_FORWARD;
530 }
531
532 TopAbs_Orientation Adaptor3d_TopolTool::Orientation
533   (const Handle(Adaptor3d_HVertex)& V)
534 {
535   return V->Orientation();
536 }
537
538 Standard_Boolean Adaptor3d_TopolTool::Identical
539   (const Handle(Adaptor3d_HVertex)& V1,
540    const Handle(Adaptor3d_HVertex)& V2)
541 {
542   return V1->IsSame(V2);
543 }
544
545
546 //-- ============================================================
547 //-- m e t h o d e s   u t i l i s e e s   p o u r   l e s  
548 //--  s a m p l e s
549 //-- ============================================================ 
550 #include <TColgp_Array2OfPnt.hxx>
551 #include <Geom_BezierSurface.hxx>
552 #include <Geom_BSplineSurface.hxx>
553 #include <TColStd_Array1OfReal.hxx>
554 #include <TColStd_Array1OfBoolean.hxx>
555 //#include <gce_MakeLin.hxx>
556 #include <gp_Lin.hxx>
557 #include <gp_Dir.hxx>
558 #include <gp_Vec.hxx>
559
560 #define myMinPnts 4 //Absolut possible minimum of sample points
561                     //Restriction of IntPolyh
562
563
564 static void Analyse(const TColgp_Array2OfPnt& array2,
565                     const Standard_Integer nbup,
566                     const Standard_Integer nbvp,
567                     Standard_Integer& myNbSamplesU,
568                     Standard_Integer& myNbSamplesV) { 
569   gp_Vec Vi,Vip1;
570   Standard_Integer sh,nbch,i,j;
571   
572   sh = 1;
573   nbch = 0;
574   if(nbvp>2) { 
575     for(i=2;i<nbup;i++) { 
576       const gp_Pnt& A=array2.Value(i,1);
577       const gp_Pnt& B=array2.Value(i,2);
578       const gp_Pnt& C=array2.Value(i,3);
579       Vi.SetCoord(C.X()-B.X()-B.X()+A.X(),
580                   C.Y()-B.Y()-B.Y()+A.Y(),
581                   C.Z()-B.Z()-B.Z()+A.Z());
582       Standard_Integer locnbch=0;
583       for(j=3; j<nbvp;j++) {  //-- essai
584         const gp_Pnt& A1=array2.Value(i,j-1);
585         const gp_Pnt& B1=array2.Value(i,j);
586         const gp_Pnt& C1=array2.Value(i,j+1);
587         Vip1.SetCoord(C1.X()-B1.X()-B1.X()+A1.X(),
588                       C1.Y()-B1.Y()-B1.Y()+A1.Y(),
589                       C1.Z()-B1.Z()-B1.Z()+A1.Z());
590         Standard_Real pd = Vi.Dot(Vip1);
591         Vi=Vip1;
592         if(pd>1.0e-7 || pd<-1.0e-7) { 
593           if(pd>0) {  if(sh==-1) {   sh=1; locnbch++;   }  }
594           else {        if(sh==1) {  sh=-1; locnbch++;  }  }
595         }
596       }
597       if(locnbch>nbch) { 
598         nbch=locnbch; 
599       }
600     }
601   }
602   myNbSamplesV = nbch+5;
603   
604   nbch=0;
605   if(nbup>2) { 
606     for(j=2;j<nbvp;j++) { 
607       const gp_Pnt& A=array2.Value(1,j);
608       const gp_Pnt& B=array2.Value(2,j);
609       const gp_Pnt& C=array2.Value(3,j);
610       Vi.SetCoord(C.X()-B.X()-B.X()+A.X(),
611                   C.Y()-B.Y()-B.Y()+A.Y(),
612                   C.Z()-B.Z()-B.Z()+A.Z());
613       Standard_Integer locnbch=0;
614       for(i=3; i<nbup;i++) {  //-- essai
615         const gp_Pnt& A1=array2.Value(i-1,j);
616         const gp_Pnt& B1=array2.Value(i,j);
617         const gp_Pnt& C1=array2.Value(i+1,j);
618         Vip1.SetCoord(C1.X()-B1.X()-B1.X()+A1.X(),
619                       C1.Y()-B1.Y()-B1.Y()+A1.Y(),
620                       C1.Z()-B1.Z()-B1.Z()+A1.Z());
621         Standard_Real pd = Vi.Dot(Vip1);
622         Vi=Vip1;
623         if(pd>1.0e-7 || pd<-1.0e-7) { 
624           if(pd>0) {  if(sh==-1) {   sh=1; locnbch++;   }  }
625           else {        if(sh==1) {  sh=-1; locnbch++;  }  }
626         }
627       }
628       if(locnbch>nbch) nbch=locnbch;
629     }  
630   }
631   myNbSamplesU = nbch+5;
632 }  
633
634
635 void Adaptor3d_TopolTool::ComputeSamplePoints() { 
636   Standard_Real uinf,usup,vinf,vsup;
637   uinf = myS->FirstUParameter();  usup = myS->LastUParameter();
638   vinf = myS->FirstVParameter();  vsup = myS->LastVParameter();
639   if (usup < uinf) { Standard_Real temp=uinf; uinf=usup; usup=temp; }
640   if (vsup < vinf) { Standard_Real temp=vinf; vinf=vsup; vsup=temp; }
641   if (uinf == RealFirst() && usup == RealLast()) { uinf=-1.e5; usup=1.e5; }
642   else if (uinf == RealFirst()) { uinf=usup-2.e5; }
643   else if (usup == RealLast()) {  usup=uinf+2.e5; }
644   
645   if (vinf == RealFirst() && vsup == RealLast()) { vinf=-1.e5; vsup=1.e5; }
646   else if (vinf == RealFirst()) { vinf=vsup-2.e5;  }
647   else if (vsup == RealLast()) {  vsup=vinf+2.e5;  }
648   
649   Standard_Integer nbsu,nbsv;
650   GeomAbs_SurfaceType typS = myS->GetType();
651   switch(typS) { 
652   case GeomAbs_Plane:          { nbsv=2; nbsu=2; } break;
653   case GeomAbs_BezierSurface:  { nbsv=3+myS->NbVPoles(); nbsu=3+myS->NbUPoles();  } break;
654   case GeomAbs_BSplineSurface: {
655     nbsv = myS->NbVKnots();     nbsv*= myS->VDegree();     if(nbsv < 4) nbsv=4;    
656     nbsu = myS->NbUKnots();     nbsu*= myS->UDegree();     if(nbsu < 4) nbsu=4;
657   }
658     break;
659   case GeomAbs_Cylinder:
660   case GeomAbs_Cone:
661   case GeomAbs_Sphere:
662   case GeomAbs_Torus:
663   case GeomAbs_SurfaceOfRevolution:
664   case GeomAbs_SurfaceOfExtrusion:    { nbsv = 15; nbsu=15; }     break;
665   default:                            { nbsu = 10; nbsv=10; }    break;
666   }
667   
668   //-- Si le nb de points est trop grand   on analyse 
669   //-- 
670   //-- 
671   
672   if(nbsu<6) nbsu=6;
673   if(nbsv<6) nbsv=6;
674   
675   myNbSamplesU = nbsu;
676   myNbSamplesV = nbsv;
677
678   if(nbsu>8 || nbsv>8) {
679     if(typS == GeomAbs_BSplineSurface) { 
680       const Handle(Geom_BSplineSurface)& Bspl = myS->BSpline();
681       Standard_Integer nbup = Bspl->NbUPoles();
682       Standard_Integer nbvp = Bspl->NbVPoles();
683       TColgp_Array2OfPnt array2(1,nbup,1,nbvp);
684       Bspl->Poles(array2);
685       Analyse(array2,nbup,nbvp,myNbSamplesU,myNbSamplesV);
686     }
687     else if(typS == GeomAbs_BezierSurface) { 
688       const Handle(Geom_BezierSurface)& Bez = myS->Bezier();
689       Standard_Integer nbup = Bez->NbUPoles();
690       Standard_Integer nbvp = Bez->NbVPoles();
691       TColgp_Array2OfPnt array2(1,nbup,1,nbvp);
692       Bez->Poles(array2);
693       Analyse(array2,nbup,nbvp,myNbSamplesU,myNbSamplesV);
694     }
695   }
696 }
697
698 Standard_Integer Adaptor3d_TopolTool::NbSamplesU()
699
700   if(myNbSamplesU <0) {
701     ComputeSamplePoints();
702   }
703   return(myNbSamplesU);
704 }
705
706 Standard_Integer Adaptor3d_TopolTool::NbSamplesV()
707
708   if(myNbSamplesU <0) { 
709     ComputeSamplePoints();    
710   }
711   return(myNbSamplesV);
712 }
713
714 Standard_Integer Adaptor3d_TopolTool::NbSamples()
715
716   if(myNbSamplesU <0) { 
717     ComputeSamplePoints();    
718   }
719   return(myNbSamplesU*myNbSamplesV);
720 }
721
722 void Adaptor3d_TopolTool::UParameters(TColStd_Array1OfReal& theArray) const
723 {
724   theArray = myUPars->Array1();
725 }
726
727 void Adaptor3d_TopolTool::VParameters(TColStd_Array1OfReal& theArray) const
728 {
729   theArray = myVPars->Array1();
730 }
731
732 void Adaptor3d_TopolTool::SamplePoint(const Standard_Integer i,
733                                       gp_Pnt2d& P2d,
734                                       gp_Pnt& P3d)
735 {
736   Standard_Integer iu, iv;
737   Standard_Real u, v;
738   if (myUPars.IsNull())
739     {
740       Standard_Real myDU=(Usup-Uinf)/(myNbSamplesU+1);
741       Standard_Real myDV=(Vsup-Vinf)/(myNbSamplesV+1);
742       iv = 1 + i/myNbSamplesU;
743       iu = 1+ i-(iv-1)*myNbSamplesU;
744       u=Uinf+iu*myDU;
745       v=Vinf+iv*myDV;
746     }
747   else
748     {
749       iv = (i-1)/myNbSamplesU + 1;
750       iu = (i-1)%myNbSamplesU + 1;
751       u = myUPars->Value(iu);
752       v = myVPars->Value(iv);
753     }
754
755   P2d.SetCoord(u,v);
756   P3d = myS->Value(u,v);
757 }
758
759
760
761 Standard_Boolean Adaptor3d_TopolTool::DomainIsInfinite() { 
762   if(Precision::IsNegativeInfinite(Uinf)) return(Standard_True);
763   if(Precision::IsPositiveInfinite(Usup)) return(Standard_True);
764   if(Precision::IsNegativeInfinite(Vinf)) return(Standard_True);
765   if(Precision::IsPositiveInfinite(Vsup)) return(Standard_True);
766   return(Standard_False);
767 }
768 //modified by NIZNHY-PKV Mon Apr 23 16:00:31 2001 f
769 //=======================================================================
770 //function : Edge
771 //purpose  : 
772 //=======================================================================
773   Standard_Address Adaptor3d_TopolTool::Edge() const 
774 {
775   return NULL;
776
777 //modified by NIZNHY-PKV Mon Apr 23 16:00:35 2001 t
778
779 //=======================================================================
780 //function : Has3d
781 //purpose  : 
782 //=======================================================================
783
784 Standard_Boolean Adaptor3d_TopolTool::Has3d() const
785 {
786   return Standard_False;
787 }
788
789 //=======================================================================
790 //function : Tol3d
791 //purpose  : 
792 //=======================================================================
793
794 Standard_Real Adaptor3d_TopolTool::Tol3d(const Handle(Adaptor2d_HCurve2d)&) const
795 {
796   Standard_DomainError::Raise("Adaptor3d_TopolTool: has no 3d representation");
797   return 0.;
798 }
799
800 //=======================================================================
801 //function : Tol3d
802 //purpose  : 
803 //=======================================================================
804
805 Standard_Real Adaptor3d_TopolTool::Tol3d(const Handle(Adaptor3d_HVertex)&) const
806 {
807   Standard_DomainError::Raise("Adaptor3d_TopolTool: has no 3d representation");
808   return 0.;
809 }
810
811 //=======================================================================
812 //function : Pnt
813 //purpose  : 
814 //=======================================================================
815
816 gp_Pnt Adaptor3d_TopolTool::Pnt(const Handle(Adaptor3d_HVertex)&) const
817 {
818   Standard_DomainError::Raise("Adaptor3d_TopolTool: has no 3d representation");
819   return gp::Origin();
820 }
821
822
823 //=======================================================================
824 //function : SamplePnts
825 //purpose  : 
826 //=======================================================================
827
828 void Adaptor3d_TopolTool::SamplePnts(const Standard_Real theDefl, 
829                                      const Standard_Integer theNUmin,
830                                      const Standard_Integer theNVmin)
831
832   Standard_Real uinf,usup,vinf,vsup;
833   uinf = myS->FirstUParameter();  usup = myS->LastUParameter();
834   vinf = myS->FirstVParameter();  vsup = myS->LastVParameter();
835   if (usup < uinf) { Standard_Real temp=uinf; uinf=usup; usup=temp; }
836   if (vsup < vinf) { Standard_Real temp=vinf; vinf=vsup; vsup=temp; }
837   if (uinf == RealFirst() && usup == RealLast()) { uinf=-1.e5; usup=1.e5; }
838   else if (uinf == RealFirst()) { uinf=usup-2.e5; }
839   else if (usup == RealLast()) {  usup=uinf+2.e5; }
840   
841   if (vinf == RealFirst() && vsup == RealLast()) { vinf=-1.e5; vsup=1.e5; }
842   else if (vinf == RealFirst()) { vinf=vsup-2.e5;  }
843   else if (vsup == RealLast()) {  vsup=vinf+2.e5;  }
844   
845 //   Standard_Integer nbsu,nbsv;
846   GeomAbs_SurfaceType typS = myS->GetType();
847 //   switch(typS) { 
848 //   case GeomAbs_Plane:          { nbsv=2; nbsu=2; } break;
849 //   case GeomAbs_BezierSurface:  { 
850 //     nbsv=myS->NbVPoles(); 
851 //     nbsu=myS->NbUPoles();
852 //     nbsu = Max(nbsu, theNUmin);
853 //     nbsv = Max(nbsv, theNVmin);
854 //     if(nbsu>8 || nbsv>8) {
855 //       const Handle(Geom_BezierSurface)& Bez = myS->Bezier();
856 //       Standard_Integer nbup = Bez->NbUPoles();
857 //       Standard_Integer nbvp = Bez->NbVPoles();
858 //       TColgp_Array2OfPnt array2(1,nbup,1,nbvp);
859 //       Bez->Poles(array2);
860 //       Analyse(array2,nbup,nbvp,myNbSamplesU,myNbSamplesV);
861 //     }  
862 //   } 
863 //     break;
864 //   case GeomAbs_BSplineSurface: {
865   if(typS == GeomAbs_BSplineSurface) {
866     // Treatment BSpline surface 
867     BSplSamplePnts(theDefl, theNUmin, theNVmin);
868     return;
869   }
870   else {
871     ComputeSamplePoints();
872   }
873 //   case GeomAbs_Cylinder:
874 //   case GeomAbs_Cone:
875 //   case GeomAbs_Sphere:
876 //   case GeomAbs_Torus:
877 //   case GeomAbs_SurfaceOfRevolution:
878 //   case GeomAbs_SurfaceOfExtrusion:    { nbsv = Max(15,theNVmin); nbsu=Max(15,theNUmin); } break;
879 //   default:                            { nbsu = Max(10,theNUmin); nbsv=Max(10,theNVmin); } break;
880 //   }
881   
882   
883 //   if(nbsu<6) nbsu=6;
884 //   if(nbsv<6) nbsv=6;
885   
886 //   myNbSamplesU = nbsu;
887 //   myNbSamplesV = nbsv;
888
889
890   myUPars = new TColStd_HArray1OfReal(1, myNbSamplesU);
891   myVPars = new TColStd_HArray1OfReal(1, myNbSamplesV);
892   Standard_Integer i;
893   Standard_Real t, dt = (usup - uinf)/(myNbSamplesU - 1);
894   myUPars->SetValue(1, uinf);
895   myUPars->SetValue(myNbSamplesU, usup);
896   for(i = 2, t = uinf+dt; i < myNbSamplesU; ++i, t += dt) {
897     myUPars->SetValue(i, t);
898   }
899
900   dt = (vsup - vinf)/(myNbSamplesV - 1);
901   myVPars->SetValue(1, vinf);
902   myVPars->SetValue(myNbSamplesV, vsup);
903   for(i = 2, t = vinf+dt; i < myNbSamplesV; ++i, t += dt) {
904     myVPars->SetValue(i, t);
905   }
906
907   return;
908
909 }
910
911 //=======================================================================
912 //function : BSplSamplePnts
913 //purpose  : 
914 //=======================================================================
915
916 void Adaptor3d_TopolTool::BSplSamplePnts(const Standard_Real theDefl, 
917                                          const Standard_Integer theNUmin,
918                                          const Standard_Integer theNVmin)
919
920   const Handle(Geom_BSplineSurface)& aBS = myS->BSpline();
921   Standard_Real uinf,usup,vinf,vsup;
922   uinf = myS->FirstUParameter();  usup = myS->LastUParameter();
923   vinf = myS->FirstVParameter();  vsup = myS->LastVParameter();
924
925   Standard_Integer i, j, k, nbi;
926   Standard_Real t1, t2, dt;
927   Standard_Integer ui1 = aBS->FirstUKnotIndex();
928   Standard_Integer ui2 = aBS->LastUKnotIndex();
929   Standard_Integer vi1 = aBS->FirstVKnotIndex();
930   Standard_Integer vi2 = aBS->LastVKnotIndex();
931
932   for(i = ui1; i < ui2; ++i) {
933     if(uinf >= aBS->UKnot(i) && uinf < aBS->UKnot(i+1)) {
934       ui1 = i;
935       break;
936     }
937   }
938
939   for(i = ui2; i > ui1; --i) {
940     if(usup <= aBS->UKnot(i) && usup > aBS->UKnot(i-1)) {
941       ui2 = i;
942       break;
943     }
944   }
945
946   for(i = vi1; i < vi2; ++i) {
947     if(vinf >= aBS->VKnot(i) && vinf < aBS->VKnot(i+1)) {
948       vi1 = i;
949       break;
950     }
951   }
952
953   for(i = vi2; i > vi1; --i) {
954     if(vsup <= aBS->VKnot(i) && vsup > aBS->VKnot(i-1)) {
955       vi2 = i;
956       break;
957     }
958   }
959
960   Standard_Integer nbsu = ui2-ui1+1; nbsu += (nbsu - 1) * (aBS->UDegree()-1);
961   Standard_Integer nbsv = vi2-vi1+1; nbsv += (nbsv - 1) * (aBS->VDegree()-1);
962   Standard_Boolean bUuniform = Standard_False;
963   Standard_Boolean bVuniform = Standard_False;
964
965   if(nbsu < theNUmin) {
966     nbsu = theNUmin;
967     bUuniform = Standard_True;
968   }
969
970   if(nbsv < theNVmin) {
971     nbsv = theNVmin;
972     bVuniform = Standard_True;
973   }
974
975   TColStd_Array1OfReal anUPars(1, nbsu);
976   TColStd_Array1OfBoolean anUFlg(1, nbsu);
977   TColStd_Array1OfReal aVPars(1, nbsv);
978   TColStd_Array1OfBoolean aVFlg(1, nbsv);
979
980   //Filling of sample parameters
981   if(bUuniform) {
982     t1 = uinf;
983     t2 = usup;
984     dt = (t2 - t1)/(nbsu - 1);
985     anUPars(1) = t1;
986     anUFlg(1) = Standard_False;
987     anUPars(nbsu) = t2;
988     anUFlg(nbsu) = Standard_False;
989     for(i = 2, t1 += dt; i < nbsu; ++i, t1 += dt) {
990       anUPars(i) = t1;
991       anUFlg(i) = Standard_False;
992     }
993   }
994   else {  
995     nbi = aBS->UDegree();
996     k = 0;
997     t1 = uinf;
998     for(i = ui1+1; i <= ui2; ++i) {
999       if(i == ui2) t2 = usup;
1000       else t2 = aBS->UKnot(i);
1001       dt = (t2 - t1)/nbi;
1002       j = 1;
1003       do { 
1004         ++k;
1005         anUPars(k) = t1;
1006         anUFlg(k) = Standard_False;
1007         t1 += dt;       
1008       }
1009       while (++j <= nbi);
1010       t1 = t2;
1011     }
1012     ++k;
1013     anUPars(k) = t1;
1014   }
1015
1016   if(bVuniform) {
1017     t1 = vinf;
1018     t2 = vsup;
1019     dt = (t2 - t1)/(nbsv - 1);
1020     aVPars(1) = t1;
1021     aVFlg(1) = Standard_False;
1022     aVPars(nbsv) = t2;
1023     aVFlg(nbsv) = Standard_False;
1024     for(i = 2, t1 += dt; i < nbsv; ++i, t1 += dt) {
1025       aVPars(i) = t1;
1026       aVFlg(i) = Standard_False;
1027     }
1028   }
1029   else {  
1030     nbi = aBS->VDegree();
1031     k = 0;
1032     t1 = vinf;
1033     for(i = vi1+1; i <= vi2; ++i) {
1034       if(i == vi2) t2 = vsup;
1035       else t2 = aBS->VKnot(i);
1036       dt = (t2 - t1)/nbi;
1037       j = 1;
1038       do { 
1039         ++k;
1040         aVPars(k) = t1;
1041         aVFlg(k) = Standard_False;
1042         t1 += dt;       
1043       }
1044       while (++j <= nbi);
1045       t1 = t2;
1046     }
1047     ++k;
1048     aVPars(k) = t1;
1049   }
1050  
1051   //Analysis of deflection
1052
1053   Standard_Real aDefl2 = Max(theDefl*theDefl, 1.e-9);
1054   Standard_Real tol = Max(0.01*aDefl2, 1.e-9);
1055   Standard_Integer l;
1056
1057   anUFlg(1) = Standard_True;
1058   anUFlg(nbsu) = Standard_True;
1059   myNbSamplesU = 2; 
1060   for(i = 1; i <= nbsv; ++i) {
1061     t1 = aVPars(i);
1062     j = 1;
1063     Standard_Boolean bCont = Standard_True;
1064     while (j < nbsu-1 && bCont) {
1065
1066       if(anUFlg(j+1)) {
1067         ++j;
1068         continue;
1069       }
1070
1071       t2 = anUPars(j);
1072       gp_Pnt p1 = aBS->Value(t2, t1);
1073       for(k = j+2; k <= nbsu; ++k) {
1074         t2 = anUPars(k);
1075         gp_Pnt p2 = aBS->Value(t2, t1);
1076         //gce_MakeLin MkLin(p1, p2);
1077         //const gp_Lin& lin = MkLin.Value();
1078
1079         if(p1.SquareDistance(p2) <= tol) continue;
1080
1081         gp_Lin lin(p1, gp_Dir(gp_Vec(p1, p2)));
1082         Standard_Boolean ok = Standard_True;
1083         for(l = j+1; l < k; ++l) {
1084
1085           if(anUFlg(l)) {
1086             ok = Standard_False;
1087             break;
1088           }
1089
1090           gp_Pnt pp =  aBS->Value(anUPars(l), t1);
1091           Standard_Real d = lin.SquareDistance(pp);
1092           
1093           if(d <= aDefl2) continue;
1094
1095           ok = Standard_False;
1096           break;
1097         }
1098
1099         if(!ok) {
1100           j = k - 1;
1101           anUFlg(j) = Standard_True;
1102           ++myNbSamplesU;
1103           break;
1104         }
1105         
1106         if(anUFlg(k)) {
1107           j = k;
1108           break;
1109         }
1110         
1111
1112       }
1113
1114       if(k >= nbsu) bCont = Standard_False;
1115
1116     }
1117   }
1118   if(myNbSamplesU < myMinPnts) {
1119     if(myNbSamplesU == 2) {
1120       //"uniform" distribution;
1121       Standard_Integer nn = nbsu/myMinPnts;
1122       anUFlg(1+nn) = Standard_True;
1123       anUFlg(nbsu-nn) = Standard_True;
1124     }
1125     else { //myNbSamplesU == 3
1126       //insert in bigger segment
1127       i = 2;
1128       while(!anUFlg(i++));
1129       if(i < nbsu/2) j = Min(i+(nbsu-i)/2, nbsu-1);
1130       else j = Max(i/2, 2);
1131     }
1132     anUFlg(j) = Standard_True;
1133     myNbSamplesU = myMinPnts;
1134   }
1135       
1136   aVFlg(1) = Standard_True;
1137   aVFlg(nbsv) = Standard_True;
1138   myNbSamplesV = 2;
1139   for(i = 1; i <= nbsu; ++i) {
1140     t1 = anUPars(i);
1141     j = 1;
1142     Standard_Boolean bCont = Standard_True;
1143     while (j < nbsv-1 && bCont) {
1144
1145       if(aVFlg(j+1)) {
1146         ++j;
1147         continue;
1148       }
1149
1150       t2 = aVPars(j);
1151       gp_Pnt p1 = aBS->Value(t1, t2);
1152       for(k = j+2; k <= nbsv; ++k) {
1153         t2 = aVPars(k);
1154         gp_Pnt p2 = aBS->Value(t1, t2);
1155
1156         if(p1.SquareDistance(p2) <= tol) continue;
1157         //gce_MakeLin MkLin(p1, p2);
1158         //const gp_Lin& lin = MkLin.Value();
1159         gp_Lin lin(p1, gp_Dir(gp_Vec(p1, p2)));
1160         Standard_Boolean ok = Standard_True;
1161         for(l = j+1; l < k; ++l) {
1162
1163           if(aVFlg(l)) {
1164             ok = Standard_False;
1165             break;
1166           }
1167
1168           gp_Pnt pp =  aBS->Value(t1, aVPars(l));
1169           Standard_Real d = lin.SquareDistance(pp);
1170           
1171           if(d <= aDefl2) continue;
1172
1173           ok = Standard_False;
1174           break;
1175         }
1176
1177         if(!ok) {
1178           j = k - 1;
1179           aVFlg(j) = Standard_True;
1180           ++myNbSamplesV;
1181           break;
1182         }
1183         
1184         if(aVFlg(k)) {
1185           j = k;
1186           break;
1187         }
1188         
1189
1190       }
1191
1192       if(k >= nbsv) bCont = Standard_False;
1193
1194     }
1195   }
1196   if(myNbSamplesV < myMinPnts) {
1197     if(myNbSamplesV == 2) {
1198       //"uniform" distribution;
1199       Standard_Integer nn = nbsv/myMinPnts;
1200       aVFlg(1+nn) = Standard_True;
1201       aVFlg(nbsv-nn) = Standard_True;
1202       myNbSamplesV = myMinPnts;
1203     }
1204     else { //myNbSamplesU == 3
1205       //insert in bigger segment
1206       i = 2;
1207       while(!aVFlg(i++));
1208       if(i < nbsv/2) j = Min(i+(nbsv-i)/2, nbsv-1);
1209       else j = Max(i/2, 2);
1210     }
1211     myNbSamplesV = myMinPnts;
1212     aVFlg(j) = Standard_True;
1213   }
1214
1215  
1216   myUPars = new TColStd_HArray1OfReal(1, myNbSamplesU);
1217   myVPars = new TColStd_HArray1OfReal(1, myNbSamplesV);
1218
1219   j = 0;
1220   for(i = 1; i <= nbsu; ++i) {
1221     if(anUFlg(i)) {
1222       ++j;
1223       myUPars->SetValue(j,anUPars(i));
1224     }
1225   }
1226
1227   j = 0;
1228   for(i = 1; i <= nbsv; ++i) {
1229     if(aVFlg(i)) {
1230       ++j;
1231       myVPars->SetValue(j,aVPars(i));
1232     }
1233   }
1234  
1235
1236 }
1237
1238 Standard_Boolean Adaptor3d_TopolTool::IsUniformSampling() const
1239 {
1240   GeomAbs_SurfaceType typS = myS->GetType();
1241
1242   if(typS == GeomAbs_BSplineSurface)
1243     return Standard_False;
1244   return Standard_True;
1245 }