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
IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_SplitSurface,Standard_Transient)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
Init(const Handle (Geom_Surface)& S)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
Init(const Handle (Geom_Surface)& S,const Standard_Real UFirst,const Standard_Real ULast,const Standard_Real VFirst,const Standard_Real VLast)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
SetUSplitValues(const Handle (TColStd_HSequenceOfReal)& UValues)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
SetVSplitValues(const Handle (TColStd_HSequenceOfReal)& VValues)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
Build(const Standard_Boolean Segment)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
Handle(TColStd_HSequenceOfReal)486 const Handle(TColStd_HSequenceOfReal)& ShapeUpgrade_SplitSurface::USplitValues() const
487 {
488 return myUSplitValues;
489 }
490 //=======================================================================
491 //function : GlobalVKnots
492 //purpose :
493 //=======================================================================
494
Handle(TColStd_HSequenceOfReal)495 const Handle(TColStd_HSequenceOfReal)& ShapeUpgrade_SplitSurface::VSplitValues() const
496 {
497 return myVSplitValues;
498 }
499 //=======================================================================
500 //function : Perform
501 //purpose :
502 //=======================================================================
503
Perform(const Standard_Boolean Segment)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
Compute(const Standard_Boolean)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
Status(const ShapeExtend_Status status) const526 Standard_Boolean ShapeUpgrade_SplitSurface::Status(const ShapeExtend_Status status) const
527 {
528 return ShapeExtend::DecodeStatus (myStatus, status);
529 }
530
Handle(ShapeExtend_CompositeSurface)531 const Handle(ShapeExtend_CompositeSurface)& ShapeUpgrade_SplitSurface::ResSurfaces() const
532 {
533 return myResSurfaces;
534 }
535