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