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