13153ab5ff38e114ee203fb62ac44aed513998f3
[occt.git] / src / ShapeUpgrade / ShapeUpgrade_SplitSurface.cxx
1 // Created on: 1998-03-16
2 // Created by: Pierre BARRAS
3 // Copyright (c) 1998-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 //    gka 30.04.99 S4137: extended for all types of surfaces
18
19 #include <Geom_BezierSurface.hxx>
20 #include <Geom_BSplineSurface.hxx>
21 #include <Geom_OffsetSurface.hxx>
22 #include <Geom_RectangularTrimmedSurface.hxx>
23 #include <Geom_Surface.hxx>
24 #include <Geom_SurfaceOfLinearExtrusion.hxx>
25 #include <Geom_SurfaceOfRevolution.hxx>
26 #include <gp_Ax1.hxx>
27 #include <Precision.hxx>
28 #include <ShapeExtend.hxx>
29 #include <ShapeExtend_CompositeSurface.hxx>
30 #include <ShapeUpgrade.hxx>
31 #include <ShapeUpgrade_SplitCurve3d.hxx>
32 #include <ShapeUpgrade_SplitSurface.hxx>
33 #include <Standard_ErrorHandler.hxx>
34 #include <Standard_Failure.hxx>
35 #include <Standard_Type.hxx>
36 #include <TColGeom_HArray1OfCurve.hxx>
37 #include <TColGeom_HArray2OfSurface.hxx>
38 #include <TColStd_Array1OfReal.hxx>
39 #include <TColStd_HSequenceOfReal.hxx>
40
41 IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_SplitSurface,Standard_Transient)
42
43 //=======================================================================
44 //function : ShapeUpgrade_SplitSurface
45 //purpose  : 
46 //=======================================================================
47 ShapeUpgrade_SplitSurface::ShapeUpgrade_SplitSurface()
48 : myNbResultingRow(0),
49   myNbResultingCol(0),
50   myStatus(0)
51 {
52 }
53
54 //=======================================================================
55 //function : Init
56 //purpose  : 
57 //=======================================================================
58
59 void ShapeUpgrade_SplitSurface::Init(const Handle(Geom_Surface)& S)
60 {
61   myStatus = ShapeExtend::EncodeStatus (ShapeExtend_OK);
62
63   myUSplitValues = new TColStd_HSequenceOfReal();
64   myVSplitValues = new TColStd_HSequenceOfReal();
65   mySurface = S;
66   myResSurfaces = new ShapeExtend_CompositeSurface();
67   myNbResultingRow =1;
68   myNbResultingCol =1;
69   Standard_Real U1,U2,V1,V2;
70   mySurface->Bounds(U1,U2,V1,V2);
71
72   myUSplitValues->Append(U1);
73   myUSplitValues->Append(U2);
74
75   myVSplitValues->Append(V1);
76   myVSplitValues->Append(V2);
77 }
78
79 //=======================================================================
80 //function : Init
81 //purpose  : 
82 //=======================================================================
83
84 void ShapeUpgrade_SplitSurface::Init(const Handle(Geom_Surface)& S, const Standard_Real UFirst,const Standard_Real ULast,
85                                      const Standard_Real VFirst, const Standard_Real VLast)
86 {
87   myStatus = ShapeExtend::EncodeStatus (ShapeExtend_OK);
88   
89   mySurface = S;
90   myResSurfaces  = new ShapeExtend_CompositeSurface();
91   myUSplitValues = new TColStd_HSequenceOfReal();
92   myVSplitValues = new TColStd_HSequenceOfReal();
93   
94   myNbResultingRow =1;
95   myNbResultingCol =1;
96
97   Standard_Real U1,U2,V1,V2;
98   mySurface->Bounds(U1,U2,V1,V2);
99   Standard_Real precision = Precision::PConfusion();
100   if ( mySurface->IsUPeriodic() && 
101        ULast - UFirst <= U2 - U1 + precision ) { U1 = UFirst; U2 = U1 + mySurface->UPeriod(); }
102   if ( mySurface->IsVPeriodic() && 
103        VLast - VFirst <= V2 - V1 + precision ) { V1 = VFirst; V2 = V1 + mySurface->VPeriod(); }
104   Standard_Real UF,UL,VF,VL;
105   if( UFirst > U2-precision || 
106       ULast  < U1-precision ) {
107     UF =U1; UL = U2;
108   }
109   else {
110     UF = Max(U1,UFirst);
111     UL = Min(U2,ULast);
112   }
113   if( VFirst > V2-precision || 
114      VLast  < V1-precision ) {
115     VF =V1; VL = V2;
116   }
117   else {
118     VF = Max(V1,VFirst);
119     VL = Min(V2,VLast);
120   }
121   
122   if(UL-UF < precision) {
123     Standard_Real p2 = precision/2.;
124     UF-= p2;
125     UL+= p2;
126   }
127   if(VL-VF < precision) {
128     Standard_Real p2 = precision/2.;
129     VF-= p2;
130     VL+= p2;
131   }
132   
133   myUSplitValues->Append(UF);
134   myUSplitValues->Append(UL);
135   myVSplitValues->Append(VF);
136   myVSplitValues->Append(VL);
137 }
138
139 //=======================================================================
140 //function : SetSplitValues
141 //purpose  : 
142 //=======================================================================
143
144 void ShapeUpgrade_SplitSurface::SetUSplitValues(const Handle(TColStd_HSequenceOfReal)& UValues)
145 {
146   if(UValues.IsNull()) return;
147   Standard_Real precision = Precision::PConfusion();
148   Standard_Real UFirst = myUSplitValues->Value(1),
149   ULast = myUSplitValues->Value(myUSplitValues->Length()); 
150   Standard_Integer i =1;
151   Standard_Integer len = UValues->Length(); 
152   
153   for(Standard_Integer ku =2; ku <= myUSplitValues->Length();ku++) {
154     ULast = myUSplitValues->Value(ku);
155     for(; i <= len; i++) {
156       if( (UFirst + precision) >= UValues->Value(i)) continue;
157       if((ULast - precision) <= UValues->Value(i)) break;
158       myUSplitValues->InsertBefore(ku++,UValues->Value(i));
159     }
160     UFirst = ULast;
161   }
162 }
163
164 //=======================================================================
165 //function : SetSplitVValues
166 //purpose  : 
167 //=======================================================================
168
169 void ShapeUpgrade_SplitSurface::SetVSplitValues(const Handle(TColStd_HSequenceOfReal)& VValues) 
170 {
171   if(VValues.IsNull()) return;
172   Standard_Real precision = Precision::PConfusion();
173   Standard_Real VFirst = myVSplitValues->Value(1), 
174   VLast = myVSplitValues->Value(myVSplitValues->Length()); 
175   Standard_Integer i =1;
176   Standard_Integer len = VValues->Length();
177   for(Standard_Integer kv =2; kv <= myVSplitValues->Length();kv++) {
178     VLast = myVSplitValues->Value(kv);
179     for(; i <= len;  i++) {
180       if( (VFirst + precision) >= VValues->Value(i)) continue;
181       if((VLast - precision) <= VValues->Value(i)) break;
182       myVSplitValues->InsertBefore(kv++,VValues->Value(i));
183     }
184     VFirst = VLast;
185   }
186 }
187
188 //=======================================================================
189 //function : Build
190 //purpose  : 
191 //=======================================================================
192
193 void ShapeUpgrade_SplitSurface::Build(const Standard_Boolean Segment) 
194 {
195   
196   Standard_Real UFirst = myUSplitValues->Value(1);
197   Standard_Real ULast = myUSplitValues->Value(myUSplitValues->Length());
198   Standard_Real VFirst =  myVSplitValues->Value(1);
199   Standard_Real VLast =   myVSplitValues->Value(myVSplitValues->Length());
200   
201   if(myUSplitValues->Length() > 2 || myVSplitValues->Length() > 2)
202     myStatus = ShapeExtend::EncodeStatus (ShapeExtend_DONE1);
203   
204   Standard_Real U1,U2,V1,V2;
205   mySurface->Bounds(U1, U2, V1, V2);
206   if (mySurface->IsKind(STANDARD_TYPE(Geom_SurfaceOfRevolution))) {      
207     Handle(Geom_SurfaceOfRevolution) Surface = Handle(Geom_SurfaceOfRevolution)::DownCast(mySurface);
208     Handle(Geom_Curve) BasCurve = Surface->BasisCurve();
209     ShapeUpgrade_SplitCurve3d spc;
210     spc.Init(BasCurve,VFirst,VLast);
211     spc.SetSplitValues(myVSplitValues);
212     spc.Build(Segment);
213     Handle(TColGeom_HArray2OfSurface) Surfaces;
214     myNbResultingCol = spc.GetCurves()->Length();
215     if(myUSplitValues->Length()> 2) {
216       myNbResultingRow =  myUSplitValues->Length() -1;
217       Surfaces = new TColGeom_HArray2OfSurface(1, myNbResultingRow,1,myNbResultingCol);
218       for(Standard_Integer nc =1; nc <= myNbResultingCol; nc++) {
219         Handle(Geom_SurfaceOfRevolution) NewSurfaceRev = 
220           new Geom_SurfaceOfRevolution(spc.GetCurves()->Value(nc),Surface->Axis()); 
221         Standard_Real U1p,U2p,V1p,V2p;
222         NewSurfaceRev->Bounds(U1p,U2p,V1p,V2p);
223         for(Standard_Integer nc1 =1; nc1 <= myNbResultingRow; nc1++) { 
224           Handle(Geom_RectangularTrimmedSurface) NewSurf = 
225             new Geom_RectangularTrimmedSurface ( NewSurfaceRev, myUSplitValues->Value(nc1),
226                                                  myUSplitValues->Value(nc1+1), V1p, V2p );
227           Surfaces->SetValue(nc1,nc,NewSurf);
228         }
229       }
230     }
231     else {
232       Surfaces = new TColGeom_HArray2OfSurface(1,1,1,myNbResultingCol);
233       
234       for(Standard_Integer nc =1; nc <= spc.GetCurves()->Length(); nc++) {
235         Handle(Geom_SurfaceOfRevolution) NewSurfaceRev = 
236           new Geom_SurfaceOfRevolution ( spc.GetCurves()->Value(nc), Surface->Axis() ); 
237         NewSurfaceRev->Bounds(U1, U2, V1, V2);
238         if( UFirst == U1 && ULast == U2)
239           Surfaces ->SetValue(1,nc,NewSurfaceRev);
240         else {
241           Handle(Geom_RectangularTrimmedSurface) NewSurf = new Geom_RectangularTrimmedSurface
242             (NewSurfaceRev,UFirst,ULast,V1,V2); //pdn correction for main seq
243           Surfaces ->SetValue(1,nc,NewSurf);
244         }
245       }
246     }
247     myResSurfaces->Init(Surfaces);
248     myResSurfaces->SetUFirstValue ( myUSplitValues->Sequence().First() );
249     myResSurfaces->SetVFirstValue ( myVSplitValues->Sequence().First() );
250     if ( spc.Status ( ShapeExtend_DONE1 ) )
251       myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_DONE1 );
252     if ( spc.Status ( ShapeExtend_DONE2 ) )
253       myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_DONE2 );
254     if ( spc.Status ( ShapeExtend_DONE3 ) )
255       myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_DONE3 );
256     return;
257   }
258   
259   if (mySurface->IsKind(STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion))) {
260     Handle(Geom_SurfaceOfLinearExtrusion) Surface = Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(mySurface);
261     Handle(Geom_Curve) BasCurve = Surface->BasisCurve(); 
262     ShapeUpgrade_SplitCurve3d spc;
263     spc.Init(BasCurve,UFirst,ULast);
264     spc.SetSplitValues(myUSplitValues);
265     spc.Build(Segment); 
266     myNbResultingRow = spc.GetCurves()->Length();
267     Handle(TColGeom_HArray2OfSurface) Surfaces;
268     if(myVSplitValues->Length() > 2) {
269       myNbResultingCol = myVSplitValues->Length() - 1;
270       Surfaces = new TColGeom_HArray2OfSurface(1,myNbResultingRow,1,myNbResultingCol);
271       for(Standard_Integer nc1 =1; nc1 <= myNbResultingRow; nc1++) {
272         Handle(Geom_SurfaceOfLinearExtrusion) NewSurfaceEx = new Geom_SurfaceOfLinearExtrusion(spc.GetCurves()->Value(nc1),
273                                                                                                Surface->Direction()); 
274         Standard_Real U1p,U2p,V1p,V2p;
275         NewSurfaceEx->Bounds(U1p,U2p,V1p,V2p);
276         for(Standard_Integer nc2 =1; nc2 <= myNbResultingCol; nc2++) {
277           Handle(Geom_RectangularTrimmedSurface) NewSurf = new Geom_RectangularTrimmedSurface
278             (NewSurfaceEx,U1p,U2p,myVSplitValues->Value(nc2),myVSplitValues->Value(nc2+1));
279           Surfaces ->SetValue(nc1,nc2,NewSurf);
280         } 
281       }
282     }
283     else {
284       Surfaces = new TColGeom_HArray2OfSurface(1,myNbResultingRow,1,1);
285       
286       for(Standard_Integer nc1 =1; nc1 <= myNbResultingRow; nc1++) {
287         Handle(Geom_SurfaceOfLinearExtrusion) NewSurfaceEx = new Geom_SurfaceOfLinearExtrusion(spc.GetCurves()->Value(nc1),Surface->Direction()); 
288         NewSurfaceEx->Bounds(U1,U2,V1,V2);
289         if(VFirst == V1 && VLast == V2)
290           Surfaces -> SetValue(nc1,1,NewSurfaceEx);
291         else {
292           Handle(Geom_RectangularTrimmedSurface) NewSurf = new Geom_RectangularTrimmedSurface
293             (NewSurfaceEx,Max(U1,UFirst),Min(ULast,U2),Max(VFirst,V1),Min(VLast,V2));
294           Surfaces ->SetValue(nc1,1,NewSurf);
295         }
296       } 
297     }
298     myResSurfaces->Init(Surfaces);
299     myResSurfaces->SetUFirstValue ( myUSplitValues->Sequence().First() );
300     myResSurfaces->SetVFirstValue ( myVSplitValues->Sequence().First() );
301     if ( spc.Status ( ShapeExtend_DONE1 ) )
302       myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_DONE1 );
303     if ( spc.Status ( ShapeExtend_DONE2 ) )
304       myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_DONE2 );
305     if ( spc.Status ( ShapeExtend_DONE3 ) )
306       myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_DONE3 );
307     return;
308   }
309   
310   if (mySurface->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
311     Handle(Geom_RectangularTrimmedSurface) tmp = Handle(Geom_RectangularTrimmedSurface)::DownCast (mySurface);
312     Handle(Geom_Surface) theSurf = tmp->BasisSurface();
313     ShapeUpgrade_SplitSurface sps;
314     sps.Init(theSurf,UFirst,ULast,VFirst,VLast);
315     sps.SetUSplitValues(myUSplitValues);
316     sps.SetVSplitValues(myVSplitValues);
317     sps.myStatus = myStatus;
318     sps.Build(Segment);
319     myStatus |= sps.myStatus;
320     myResSurfaces = sps.myResSurfaces;
321     return;
322   }
323   else if (mySurface->IsKind(STANDARD_TYPE(Geom_OffsetSurface))) {
324     Handle(Geom_OffsetSurface) tmp = Handle(Geom_OffsetSurface)::DownCast (mySurface);
325     Handle(Geom_Surface) theSurf = tmp->BasisSurface();
326     ShapeUpgrade_SplitSurface sps;
327     sps.Init(theSurf,UFirst,ULast,VFirst,VLast);
328     sps.SetUSplitValues(myUSplitValues);
329     sps.SetVSplitValues(myVSplitValues);
330     sps.myStatus = myStatus;
331     sps.Build(Segment);
332     Handle(TColGeom_HArray2OfSurface) Patches = new TColGeom_HArray2OfSurface
333       (1,sps.ResSurfaces()->NbUPatches(),1,sps.ResSurfaces()->NbVPatches());
334     for(Standard_Integer i1 = 1; i1 <= sps.ResSurfaces()->NbUPatches(); i1++) {
335       for(Standard_Integer j1 = 1 ; j1 <= sps.ResSurfaces()->NbVPatches(); j1++) {
336         Handle(Geom_OffsetSurface) NewOffSur = new Geom_OffsetSurface(sps.ResSurfaces()->Patch(i1,j1),tmp->Offset());
337         Patches->SetValue(i1,j1,NewOffSur);
338       }
339     }
340     myResSurfaces->Init(Patches);
341     myResSurfaces->SetUFirstValue ( myUSplitValues->Sequence().First() );
342     myResSurfaces->SetVFirstValue ( myVSplitValues->Sequence().First() );
343     myStatus |= sps.myStatus;
344     return;
345   }
346   
347   // splitting the surfaces:
348   myNbResultingRow = myUSplitValues->Length() -1;
349   myNbResultingCol = myVSplitValues->Length() -1;
350   Handle(TColGeom_HArray2OfSurface) Surfaces =new TColGeom_HArray2OfSurface(1,myNbResultingRow,1,myNbResultingCol);
351   Standard_Boolean isBSpline = mySurface->IsKind(STANDARD_TYPE(Geom_BSplineSurface));
352   Standard_Boolean isBezier  = mySurface->IsKind(STANDARD_TYPE(Geom_BezierSurface));
353   
354  // Standard_Real U1,U2,V1,V2;
355  // U1=UFirst;
356  // U2 = ULast;
357  // V1 = VFirst;
358  // V2 = VLast;
359
360   if(myNbResultingRow == 1 && myNbResultingCol == 1) {
361     mySurface->Bounds(U1, U2, V1, V2);
362     Standard_Boolean filled = Standard_True;
363     if ( Abs ( U1 - UFirst ) < Precision::PConfusion() && 
364          Abs ( U2 - ULast  ) < Precision::PConfusion() &&
365          Abs ( V1 - VFirst ) < Precision::PConfusion() && 
366          Abs ( V2 - VLast  ) < Precision::PConfusion() )
367       Surfaces->SetValue(1,1,mySurface);
368     else if ( ! Segment || ! mySurface->IsKind (STANDARD_TYPE (Geom_BSplineSurface) ) ||
369               ! Status ( ShapeExtend_DONE2 ) ) {
370       //pdn copying of surface
371       Handle(Geom_Surface) tmp = Handle(Geom_Surface)::DownCast(mySurface->Copy());
372       Handle(Geom_RectangularTrimmedSurface) Surf= 
373         new Geom_RectangularTrimmedSurface(tmp,UFirst,ULast,VFirst,VLast);
374       Surfaces->SetValue(1,1,Surf);  
375     }
376     else filled = Standard_False;
377     if ( filled ) {
378       myResSurfaces->Init(Surfaces);
379       myResSurfaces->SetUFirstValue ( myUSplitValues->Sequence().First() );
380       myResSurfaces->SetVFirstValue ( myVSplitValues->Sequence().First() );
381       return;
382     }
383   }
384   if (mySurface->IsKind (STANDARD_TYPE (Geom_BSplineSurface))) {
385     Handle(Geom_BSplineSurface) BsSurface = Handle(Geom_BSplineSurface)::DownCast(mySurface->Copy());
386     Standard_Integer FirstInd =BsSurface->FirstUKnotIndex(), 
387     LastInd = BsSurface->LastUKnotIndex();
388     Standard_Integer j =  FirstInd;
389     for(Standard_Integer ii =1 ; ii <= myUSplitValues->Length(); ii++) {
390       Standard_Real spval = myUSplitValues->Value(ii);
391       for(; j <=LastInd;j++) {
392         if( spval > BsSurface->UKnot(j) + Precision::PConfusion()) continue;
393         if( spval < BsSurface->UKnot(j) - Precision::PConfusion()) break;
394          myUSplitValues->ChangeValue(ii) = BsSurface->UKnot(j);
395        }
396        if(j == LastInd) break;
397      }
398      FirstInd =BsSurface->FirstVKnotIndex(), 
399      LastInd = BsSurface->LastVKnotIndex(); 
400      j = FirstInd;
401      for(Standard_Integer ii1 =1 ; ii1 <= myVSplitValues->Length(); ii1++) {
402        Standard_Real spval = myVSplitValues->Value(ii1);
403        for(; j <=LastInd;j++) {
404          if( spval > BsSurface->VKnot(j) + Precision::PConfusion()) continue;
405         if( spval < BsSurface->VKnot(j) - Precision::PConfusion()) break;
406         myVSplitValues->ChangeValue(ii1) =BsSurface->VKnot(j);
407       }
408       if(j == LastInd) break;
409     }
410   }
411   U1 = myUSplitValues->Value(1);
412   V1 = myVSplitValues->Value(1);
413   for(Standard_Integer  irow = 2; irow <= myUSplitValues->Length(); irow++) {
414     U2 = myUSplitValues->Value(irow);
415     for(Standard_Integer  icol = 2; icol <= myVSplitValues->Length(); icol++) {
416       V2 = myVSplitValues->Value(icol);
417 //      if (ShapeUpgrade::Debug())  {
418 //      std::cout<<".. bounds    ="<<U1    <<","<<U2   <<","<<V1    <<","<<V2   <<std::endl;
419 //      std::cout<<".. -> pos ="<<irow  <<","<<icol<<std::endl;
420 //      }
421       // creates a copy of theSurf before to segment:
422       Handle(Geom_Surface) theNew = Handle(Geom_Surface)::DownCast ( mySurface->Copy() );
423       if ( isBSpline || isBezier ) {
424         try {
425           OCC_CATCH_SIGNALS
426           if ( isBSpline ) 
427             Handle(Geom_BSplineSurface)::DownCast(theNew)->Segment(U1,U2,V1,V2);
428           else if ( isBezier ) {
429             //pdn K4L+ (work around)
430             // Standard_Real u1 = 2*U1 - 1;
431             // Standard_Real u2 = 2*U2 - 1;
432             // Standard_Real v1 = 2*V1 - 1;
433             // Standard_Real v2 = 2*V2 - 1; 
434             //rln C30 (direct use)
435             Standard_Real u1 = U1;
436             Standard_Real u2 = U2;
437             Standard_Real v1 = V1;
438             Standard_Real v2 = V2;
439             Handle(Geom_BezierSurface)::DownCast(theNew)->Segment(u1,u2,v1,v2);
440           }
441           myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_DONE3 );
442         }
443         catch (Standard_Failure const& anException) {
444 #ifdef OCCT_DEBUG
445           std::cout << "Warning: ShapeUpgrade_SplitSurface::Build(): Exception in Segment      :";
446           anException.Print(std::cout); std::cout << std::endl;
447 #endif
448           (void)anException;
449           Handle(Geom_Surface) theNewSurf = theNew;
450           theNew = new Geom_RectangularTrimmedSurface(theNewSurf,U1,U2,V1,V2);
451         }
452         Surfaces->SetValue((irow-1),(icol-1),theNew);
453       }
454       else {
455         // not a BSpline: trimming instead of segmentation
456         Handle(Geom_RectangularTrimmedSurface) SplittedSurf= 
457           new Geom_RectangularTrimmedSurface(theNew,U1,U2,V1,V2);
458         Surfaces->SetValue((irow-1),(icol-1),SplittedSurf);
459       }
460       
461       V1=V2;
462     }
463     U1=U2; 
464     V1 = myVSplitValues->Value(1);
465   }
466   Standard_Integer nbU =  myUSplitValues->Length();
467   TColStd_Array1OfReal UJoints(1,nbU);
468   Standard_Integer i;//svv Jan 10 2000 : porting on DEC
469   for(i = 1; i <= nbU; i++)
470     UJoints(i) = myUSplitValues->Value(i);
471   
472   Standard_Integer nbV=  myVSplitValues->Length();
473   TColStd_Array1OfReal VJoints(1,nbV);
474   for(i = 1; i <= nbV; i++)
475     VJoints(i) = myVSplitValues->Value(i);
476   myResSurfaces->Init(Surfaces,UJoints,VJoints);
477 //  if (ShapeUpgrade::Debug()) std::cout<<"SplitSurface::Build - end"<<std::endl;
478 }
479
480
481 //=======================================================================
482 //function : GlobalUKnots
483 //purpose  : 
484 //=======================================================================
485
486 const Handle(TColStd_HSequenceOfReal)& ShapeUpgrade_SplitSurface::USplitValues() const
487 {
488   return myUSplitValues;
489 }
490 //=======================================================================
491 //function : GlobalVKnots
492 //purpose  : 
493 //=======================================================================
494
495 const Handle(TColStd_HSequenceOfReal)& ShapeUpgrade_SplitSurface::VSplitValues() const
496 {
497   return myVSplitValues;
498 }
499 //=======================================================================
500 //function : Perform
501 //purpose  : 
502 //=======================================================================
503
504 void ShapeUpgrade_SplitSurface::Perform(const Standard_Boolean Segment) 
505 {
506   Compute(Segment);
507 //  SetUSplitValues(myUSplitValues);
508 //  SetVSplitValues(myVSplitValues);
509   Build (Segment);
510   
511 }
512 //=======================================================================
513 //function : Compute
514 //purpose  : 
515 //=======================================================================
516  
517 void ShapeUpgrade_SplitSurface::Compute(const Standard_Boolean /*Segment*/)
518 {
519   myStatus = ShapeExtend::EncodeStatus (ShapeExtend_OK); 
520 }
521 //=======================================================================
522 //function : Status
523 //purpose  : 
524 //=======================================================================
525
526 Standard_Boolean ShapeUpgrade_SplitSurface::Status(const ShapeExtend_Status status) const
527 {
528   return ShapeExtend::DecodeStatus (myStatus, status);
529 }
530
531 const Handle(ShapeExtend_CompositeSurface)& ShapeUpgrade_SplitSurface::ResSurfaces() const
532 {
533   return myResSurfaces;
534 }