0026377: Passing Handle objects as arguments to functions as non-const reference...
[occt.git] / src / IGESToBRep / IGESToBRep_BasicSurface.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 //modified: 
16 //:k0 abv 16.12.98: eliminating existing code
17 // 21.12.98 rln, gka S4054
18 //:k5 abv 25 Dec 98: PRO8803 1901: extending method of fixing Multi > Degree
19 // 28.12.98 dce S3767 New messaging system
20 //#61 rln 05.01.99
21 //:l1 abv 06.01.99: USA60022.igs 243: fixing missing seam on closed surface 
22 //:p6 abv 26.02.99: improve messages after call to ConvertToPeriodic
23 //#75 rln 11.03.99: using message mechanism for periodic B-Spline
24 //S4181 pdn 15.04.99 implementing of reading IGES elementary surfaces.
25 //sln 29.12.2001 OCC90 : Method checkBSplineSurfaceStatus and varification of creation of bspline surfaces were added
26 //=======================================================================
27
28 #include <Geom_BSplineSurface.hxx>
29 #include <Geom_ConicalSurface.hxx>
30 #include <Geom_CylindricalSurface.hxx>
31 #include <Geom_Plane.hxx>
32 #include <Geom_SphericalSurface.hxx>
33 #include <Geom_Surface.hxx>
34 #include <Geom_ToroidalSurface.hxx>
35 #include <gp_Ax3.hxx>
36 #include <gp_Cylinder.hxx>
37 #include <gp_GTrsf.hxx>
38 #include <gp_Pln.hxx>
39 #include <gp_Trsf.hxx>
40 #include <IGESConvGeom.hxx>
41 #include <IGESData_IGESEntity.hxx>
42 #include <IGESData_IGESModel.hxx>
43 #include <IGESData_ToolLocation.hxx>
44 #include <IGESGeom_BSplineSurface.hxx>
45 #include <IGESGeom_Direction.hxx>
46 #include <IGESGeom_Point.hxx>
47 #include <IGESGeom_SplineSurface.hxx>
48 #include <IGESSolid_ConicalSurface.hxx>
49 #include <IGESSolid_CylindricalSurface.hxx>
50 #include <IGESSolid_PlaneSurface.hxx>
51 #include <IGESSolid_SphericalSurface.hxx>
52 #include <IGESSolid_ToroidalSurface.hxx>
53 #include <IGESToBRep.hxx>
54 #include <IGESToBRep_BasicSurface.hxx>
55 #include <IGESToBRep_CurveAndSurface.hxx>
56 #include <Interface_Macros.hxx>
57 #include <Message_Msg.hxx>
58 #include <Precision.hxx>
59 #include <ShapeAlgo.hxx>
60 #include <ShapeAlgo_AlgoContainer.hxx>
61 #include <ShapeConstruct_Curve.hxx>
62 #include <Standard_ErrorHandler.hxx>
63 #include <Standard_Failure.hxx>
64 #include <TColgp_Array2OfPnt.hxx>
65 #include <TColgp_HArray2OfPnt.hxx>
66 #include <TColStd_Array1OfInteger.hxx>
67 #include <TColStd_Array1OfReal.hxx>
68 #include <TColStd_Array2OfReal.hxx>
69 #include <TColStd_HArray1OfReal.hxx>
70 #include <TColStd_SequenceOfInteger.hxx>
71
72 //:36
73 //S3767
74 //S4181
75 //=======================================================================
76 //function : CheckBSplineSurface
77 //purpose  : Check coincidede knots. Check whether knots are in ascending 
78 //           order and difference between vaues of weights more than 1000. 
79 //           Send corresponding messages. The function returns Standard_False 
80 //           if surface can not be created, Standard_True otherwise.
81 //=======================================================================
82 static Standard_Boolean checkBSplineSurface(IGESToBRep_BasicSurface*             theSurface,
83                                           const Handle(IGESGeom_BSplineSurface)& theBSplineSurface,
84                                           TColStd_Array1OfReal&                  SUKnots,
85                                           TColStd_Array1OfReal&                  SVKnots,
86                                           const TColStd_Array2OfReal&            SWeights)
87 {
88   // check whether difference between vaues of weights more than 1000.
89   if(!theBSplineSurface->IsPolynomial()) {
90     Standard_Real aMinValue = SWeights.Value(SWeights.LowerRow(), SWeights.LowerCol());
91     Standard_Real aMaxValue = SWeights.Value(SWeights.LowerRow(), SWeights.LowerCol());
92     for(Standard_Integer i = SWeights.LowerRow(); i<= SWeights.UpperRow(); i++)
93     for(Standard_Integer j = SWeights.LowerCol(); j<= SWeights.UpperCol(); j++) {
94       if(SWeights.Value(i,j) < aMinValue) aMinValue = SWeights.Value(i,j);
95       if(SWeights.Value(i,j) > aMaxValue) aMaxValue = SWeights.Value(i,j);    
96
97       if(aMaxValue - aMinValue > 1000) {
98         Message_Msg msg1374("IGES_1374"); // WARNING - Difference between weights is too big.
99         theSurface->SendWarning(theBSplineSurface, msg1374);
100       }
101     }
102   }
103  
104   Standard_Boolean aResult = Standard_True;
105   
106   //check whether knots are in ascending order.
107   Standard_Boolean aWrongOrder = Standard_False;
108   Standard_Integer i;
109   for (i = SUKnots.Lower(); (i < SUKnots.Upper()) && (!aWrongOrder); i++) 
110     if(SUKnots.Value (i+1) < SUKnots.Value (i)) aWrongOrder = Standard_True;
111   for (i = SVKnots.Lower(); (i < SVKnots.Upper()) && (!aWrongOrder); i++) 
112     if(SVKnots.Value (i+1) < SVKnots.Value (i)) aWrongOrder = Standard_True;
113   
114   if(aWrongOrder) { 
115     Message_Msg msg1373("IGES_1373"); // FAIL - Knots are not in ascending order 
116     theSurface->SendFail(theBSplineSurface, msg1373);
117     aResult = Standard_False;
118   }
119
120   //Fix coincided knots
121   if(aResult) {
122     ShapeConstruct_Curve::FixKnots(SUKnots);
123     ShapeConstruct_Curve::FixKnots(SVKnots);
124   }
125   
126   return aResult;
127
128 }
129
130
131 //=======================================================================
132 //function : IGESToBRep_BasicSurface
133 //purpose  : 
134 //=======================================================================
135
136 IGESToBRep_BasicSurface::IGESToBRep_BasicSurface()
137      :IGESToBRep_CurveAndSurface()
138 {  
139   SetModeTransfer(Standard_False);
140 }
141
142 //=======================================================================
143 //function : IGESToBRep_BasicSurface
144 //purpose  : 
145 //=======================================================================
146
147 IGESToBRep_BasicSurface::IGESToBRep_BasicSurface
148   (const IGESToBRep_CurveAndSurface& CS)
149      :IGESToBRep_CurveAndSurface(CS)
150 {  
151 }
152
153 //=======================================================================
154 //function : IGESToBRep_BasicSurface
155 //purpose  : 
156 //=======================================================================
157
158 IGESToBRep_BasicSurface::IGESToBRep_BasicSurface
159   (const Standard_Real    eps,
160    const Standard_Real    epsCoeff,
161    const Standard_Real    epsGeom,
162    const Standard_Boolean mode,
163    const Standard_Boolean modeapprox,
164    const Standard_Boolean optimized)
165      :IGESToBRep_CurveAndSurface(eps, epsCoeff, epsGeom, mode, modeapprox,
166                                  optimized)
167 {  
168 }
169
170
171 //=============================================
172 //Function : TransferBasicSurface
173 //Purpose : Choice of the right transfer method
174 //=============================================
175
176 Handle(Geom_Surface) IGESToBRep_BasicSurface::TransferBasicSurface
177        (const Handle(IGESData_IGESEntity)& start)
178
179   Handle(Geom_Surface) resurf;
180   if (start.IsNull()) {
181     Message_Msg msg1005("IGES_1005");
182     SendFail(start, msg1005);
183     return resurf;
184   }
185
186   try { //:36 by abv 11.12.97: Geom_BSplineSurface raiss if some weights <0
187     OCC_CATCH_SIGNALS
188     
189     //S4054
190     if (start->IsKind(STANDARD_TYPE(IGESGeom_BSplineSurface))) {
191       DeclareAndCast(IGESGeom_BSplineSurface, st128, start);
192       resurf = TransferBSplineSurface(st128);
193     }
194     else if (start->IsKind(STANDARD_TYPE(IGESGeom_SplineSurface))) {
195       DeclareAndCast(IGESGeom_SplineSurface, st114, start);
196       resurf = TransferSplineSurface(st114);
197     } //S4181 pdn 15.04.99  implementing of reading IGES elementary surfaces.
198     else if (start->IsKind(STANDARD_TYPE(IGESSolid_PlaneSurface))) {
199       DeclareAndCast(IGESSolid_PlaneSurface, st190, start);
200       resurf = TransferPlaneSurface(st190);
201     }
202     else if (start->IsKind(STANDARD_TYPE(IGESSolid_CylindricalSurface))) {
203       DeclareAndCast(IGESSolid_CylindricalSurface, st192, start);
204       resurf = TransferRigthCylindricalSurface(st192);
205     }
206     else if (start->IsKind(STANDARD_TYPE(IGESSolid_ConicalSurface))) {
207       DeclareAndCast(IGESSolid_ConicalSurface, st194, start);
208       resurf = TransferRigthConicalSurface(st194);
209     }
210     else if (start->IsKind(STANDARD_TYPE(IGESSolid_SphericalSurface))) {
211       DeclareAndCast(IGESSolid_SphericalSurface, st196, start);
212       resurf = TransferSphericalSurface(st196);
213     }
214     else if (start->IsKind(STANDARD_TYPE(IGESSolid_ToroidalSurface))) {
215       DeclareAndCast(IGESSolid_ToroidalSurface, st198, start);
216       resurf = TransferToroidalSurface(st198);
217     }
218     else {
219      // AddFail(start, "Spline or BSpline surface expected for TransferBasicSurface");
220       return resurf;
221     }
222
223   } //:36
224   catch(Standard_Failure) {
225 #ifdef OCCT_DEBUG
226     cout << "\n** Exception in IGESToBRep_BasicSurface::TransferBasicSurface : "; 
227     Standard_Failure::Caught()->Print(cout);
228 #endif
229   }
230
231   if (resurf.IsNull()) {
232     // AddFail(start,"The IGESEntity cannot be transfered");
233   }
234   else
235     resurf->Scale(gp_Pnt(0,0,0),GetUnitFactor());
236
237   return resurf;
238 }
239
240
241 //=======================================================================
242 //function : TransferPlaneSurface
243 //purpose  : 
244 //=======================================================================
245
246 Handle(Geom_Plane) IGESToBRep_BasicSurface::TransferPlaneSurface(const Handle(IGESSolid_PlaneSurface)& start)
247 {
248   Handle(Geom_Plane) res;
249   if (start.IsNull()) {
250     Message_Msg msg1005("IGES_1005");
251     SendFail(start, msg1005);
252     return res;
253   }
254   
255   gp_Pln pln;
256   Standard_Boolean Param = start->IsParametrised();
257   Handle(IGESGeom_Point) Point = start->LocationPoint();
258   Handle(IGESGeom_Direction) Dir = start->Normal();
259
260   if (Point.IsNull()) {
261     Message_Msg msg174("XSTEP_174");   
262     SendFail(start, msg174);
263     // Point Reading Error : Null IGESEntity
264     return res;
265   }
266   if (Dir.IsNull()) {
267     Message_Msg msg1280("IGES_1280");
268     SendFail(start, msg1280);
269     // Direction Reading Error : Null IGESEntity
270     return res;
271   } 
272
273   gp_Pnt Pt = Point->Value();
274   gp_Dir Normale = gp_Dir(Dir->Value());
275   if (!Param) {
276     pln = gp_Pln(Pt,Normale);
277   }
278   else {
279     Handle(IGESGeom_Direction) refdir = start->ReferenceDir();
280     gp_Dir Dirgp = gp_Dir(refdir->Value());
281     pln = gp_Pln( gp_Ax3(Pt, Normale, Dirgp));  
282   }
283   
284   return new Geom_Plane(pln); 
285 }
286
287 //=======================================================================
288 //function : TransferRigthCylindricalSurface
289 //purpose  : 
290 //=======================================================================
291
292 Handle(Geom_CylindricalSurface) IGESToBRep_BasicSurface::TransferRigthCylindricalSurface
293        (const Handle(IGESSolid_CylindricalSurface)& start)
294 {
295   Handle(Geom_CylindricalSurface) res;
296   if (start.IsNull()) {
297     Message_Msg msg1005("IGES_1005");
298     SendFail(start, msg1005);
299     return res;
300   }
301   
302   Standard_Boolean Param = start->IsParametrised();
303   Handle(IGESGeom_Point) Point = start->LocationPoint();
304   Handle(IGESGeom_Direction) Axis = start->Axis();
305   Standard_Real radius = start->Radius();
306   
307   if (Point.IsNull()) {
308     Message_Msg msg174("XSTEP_174");   
309     SendFail(start, msg174);
310     // Point Reading Error : Null IGESEntity
311     return res;
312   }
313   if (Axis.IsNull()) {
314     Message_Msg msg1280("IGES_1280");
315     SendFail(start, msg1280);
316     // Direction Reading Error : Null IGESEntity
317     return res;
318   }
319   if (radius < Precision::Confusion()) {
320     return res;
321   }
322     
323   gp_Pnt Pt = Point->Value();
324   gp_Dir ax = gp_Dir(Axis->Value());
325   gp_Ax3 ax3;
326   if (!Param) 
327     ax3 = gp_Ax3(Pt,ax);
328   else {
329     Handle(IGESGeom_Direction) refdir = start->ReferenceDir();
330     gp_Dir Dir = gp_Dir(refdir->Value());
331     gp_Dir vc = Dir^ax;
332     if(vc.XYZ().Modulus() < Precision::Confusion()) {
333       
334       return res;
335     }
336     ax3 = gp_Ax3(Pt,ax,Dir);
337   }
338   gp_Cylinder cyl(ax3,radius);
339   return new Geom_CylindricalSurface(cyl);
340 }
341
342 //=======================================================================
343 //function : TransferRigthConicalSurface
344 //purpose  : 
345 //=======================================================================
346
347 Handle(Geom_ConicalSurface) IGESToBRep_BasicSurface::TransferRigthConicalSurface
348        (const Handle(IGESSolid_ConicalSurface)& start)
349 {
350   Handle(Geom_ConicalSurface) res;
351   if (start.IsNull()) {
352     Message_Msg msg1005("IGES_1005");
353     SendFail(start, msg1005);
354     return res;
355   } 
356   
357   Standard_Boolean Param = start->IsParametrised();
358   Handle(IGESGeom_Point) Point = start->LocationPoint();
359   Handle(IGESGeom_Direction) Axis = start->Axis();
360   Standard_Real radius = start->Radius();
361   Standard_Real angle  = start->SemiAngle()/180.*M_PI;
362   
363   if (Point.IsNull()) {
364     Message_Msg msg174("XSTEP_174");   
365     SendFail(start, msg174);
366     // Point Reading Error : Null IGESEntity
367     return res;
368   }
369   if (Axis.IsNull()) {
370     Message_Msg msg1280("IGES_1280");
371     SendFail(start, msg1280);
372     // Direction Reading Error : Null IGESEntity
373     return res;
374   }
375   if (angle < Precision::Confusion()||angle > M_PI/2.) {
376     return res;
377   }
378   if (radius < 0) {
379     return res;
380   }
381   if (radius < Precision::Confusion())
382     radius = 0.;
383   
384   gp_Pnt Pt = Point->Value();
385   gp_Dir ax = gp_Dir(Axis->Value());
386   gp_Ax3 ax3;
387   if (!Param) 
388     ax3 = gp_Ax3(Pt,ax);
389   else {
390     Handle(IGESGeom_Direction) refdir = start->ReferenceDir();
391     gp_Dir Dir = gp_Dir(refdir->Value());
392     gp_Dir vc = Dir^ax;
393     if(vc.XYZ().Modulus() < Precision::Confusion()) {
394       
395       return res;
396     }
397     ax3 = gp_Ax3(Pt,ax,Dir);
398   }
399   return new Geom_ConicalSurface(ax3,angle,radius);
400 }
401
402 //=======================================================================
403 //function : TransferSphericalSurface
404 //purpose  : 
405 //=======================================================================
406
407 Handle(Geom_SphericalSurface) IGESToBRep_BasicSurface::TransferSphericalSurface
408        (const Handle(IGESSolid_SphericalSurface)& start)
409 {
410   Handle(Geom_SphericalSurface) res;
411   if (start.IsNull()) {
412     Message_Msg msg1005("IGES_1005");
413     SendFail(start, msg1005);
414     return res;
415   } 
416   
417   Standard_Boolean Param = start->IsParametrised();
418   Handle(IGESGeom_Point) Point = start->Center();
419   Handle(IGESGeom_Direction) Axis = start->Axis();
420   Standard_Real radius = start->Radius();
421   
422   if (Point.IsNull()) {
423     Message_Msg msg174("XSTEP_174");   
424     SendFail(start, msg174);
425     // Point Reading Error : Null IGESEntity
426     return res;
427   }
428   if (Axis.IsNull()) {
429     Message_Msg msg1280("IGES_1280");
430     SendFail(start, msg1280);
431     // Direction Reading Error : Null IGESEntity
432     return res;
433   }
434   if (radius < Precision::Confusion()){
435    
436     return res;
437   }
438
439   gp_Pnt Pt = Point->Value();
440   gp_Dir ax = gp_Dir(Axis->Value());
441   gp_Ax3 ax3;
442   if (!Param) 
443     ax3 = gp_Ax3(Pt,ax);
444   else {
445     Handle(IGESGeom_Direction) refdir = start->ReferenceDir();
446     gp_Dir Dir = gp_Dir(refdir->Value());
447     gp_Dir vc = Dir^ax;
448     if(vc.XYZ().Modulus() < Precision::Confusion()) {
449       
450       return res;
451     }
452     ax3 = gp_Ax3(Pt,ax,Dir);
453   }
454   return new Geom_SphericalSurface(ax3,radius); 
455 }
456
457 //=======================================================================
458 //function : TransferToroidalSurface
459 //purpose  : 
460 //=======================================================================
461
462 Handle(Geom_ToroidalSurface) IGESToBRep_BasicSurface::TransferToroidalSurface
463        (const Handle(IGESSolid_ToroidalSurface)& start)
464 {
465   Handle(Geom_ToroidalSurface) res;
466   if (start.IsNull()) {
467     Message_Msg msg1005("IGES_1005");
468     SendFail(start, msg1005);
469     return res;
470   } 
471   
472   Standard_Boolean Param = start->IsParametrised();
473   Handle(IGESGeom_Point) Point = start->Center();
474   Handle(IGESGeom_Direction) Axis = start->Axis();
475   Standard_Real major = start->MajorRadius();
476   Standard_Real minor = start->MinorRadius();
477   
478   if (Point.IsNull()) {
479     Message_Msg msg174("XSTEP_174");   
480     SendFail(start, msg174);
481     // Point Reading Error : Null IGESEntity
482     return res;
483   }
484   if (Axis.IsNull()) {
485     Message_Msg msg1280("IGES_1280");
486     SendFail(start, msg1280);
487     // Direction Reading Error : Null IGESEntity
488     return res;
489   }
490   if (major < Precision::Confusion()||minor < Precision::Confusion()){
491    
492     return res;
493   }
494
495   gp_Pnt Pt = Point->Value();
496   gp_Dir ax = gp_Dir(Axis->Value());
497   gp_Ax3 ax3;
498   if (!Param) 
499     ax3 = gp_Ax3(Pt,ax);
500   else {
501     Handle(IGESGeom_Direction) refdir = start->ReferenceDir();
502     gp_Dir Dir = gp_Dir(refdir->Value());
503     gp_Dir vc = Dir^ax;
504     if(vc.XYZ().Modulus() < Precision::Confusion()) {
505       
506       return res;
507     }
508     ax3 = gp_Ax3(Pt,ax,Dir);
509   }
510   return new Geom_ToroidalSurface(ax3,major,minor);
511 }
512 //==================================
513 //Function : TransferSplineSurface :
514 //Purpose :
515 //==================================
516
517 Handle(Geom_BSplineSurface) IGESToBRep_BasicSurface::TransferSplineSurface
518        (const Handle(IGESGeom_SplineSurface)& start)
519
520   Handle(Geom_BSplineSurface) resconv;
521   if (start.IsNull()) {
522     Message_Msg msg1005("IGES_1005");
523     SendFail(start, msg1005);
524     return resconv;
525   }
526
527   Standard_Real epscoef = GetEpsCoeff();
528   Standard_Real epsgeom = GetEpsGeom();
529
530   Standard_Integer result = IGESConvGeom::SplineSurfaceFromIGES
531     (start, epscoef, epsgeom, resconv);
532
533   switch (result) {
534   case 5 : {
535     Message_Msg msg1305("IGES_1305");
536     SendFail (start, msg1305); // less than on segment in U or V (no result produced)
537     return resconv;
538   }
539   case 4 : {
540     Message_Msg msg1190("IGES_1190");
541     SendFail (start, msg1190);
542     return resconv;
543   }
544     // case 3 :
545     // AddWarning ( start, "Degree is not compatible with code boundary type , C0 is not guaranteed)");
546     //case 2 :
547     // AddWarning ( start, "Degree is not compatible with code boundary type , C0 is guaranted)");
548   default :
549       break;
550   }
551   
552   
553   //  Checking C2 and C1 continuity :  case 1 :
554   //  AddWarning ( start, "The result is not guaranteed to be C0");
555   //  ===============================
556
557   IGESConvGeom::IncreaseSurfaceContinuity (resconv, epsgeom, GetContinuity());
558   return resconv;
559 }
560
561 //===================================
562 //Function : TransferBSplineSurface :
563 //Purpose : 
564 //===================================
565
566 Handle(Geom_BSplineSurface)  IGESToBRep_BasicSurface::TransferBSplineSurface
567        (const Handle(IGESGeom_BSplineSurface)& start)
568
569   Handle(Geom_BSplineSurface)  res;
570   if (start.IsNull()) {
571     Message_Msg msg1005("IGES_1005");
572     SendFail(start, msg1005);
573     return res;
574   }
575
576   Standard_Integer  DegreeU = start->DegreeU();
577   Standard_Integer  DegreeV = start->DegreeV();
578   if ((DegreeU <= 0)  ||  (DegreeU > Geom_BSplineSurface::MaxDegree()) ||
579       (DegreeV <= 0)  ||  (DegreeV > Geom_BSplineSurface::MaxDegree())) {
580     Message_Msg msg1310("IGES_1310");
581     SendFail ( start, msg1310);
582     // Improper Input BSpline Degree
583     return res;
584   }
585   
586   //  Filling poles array :
587   //  =====================
588   
589   Standard_Integer  NbPolesU = start->NbPolesU();
590   Standard_Integer  newNbPolesU = NbPolesU;
591   if (NbPolesU<2) {
592     Message_Msg msg1195("IGES_1195");
593     SendFail(start, msg1195);
594     // Number of poles lower than 2 following U
595     return res;
596   }
597   
598   Standard_Integer  NbPolesV = start->NbPolesV();
599   Standard_Integer  newNbPolesV = NbPolesV;
600   if (NbPolesV<2) {
601     Message_Msg msg1195("IGES_1195");
602     SendFail(start, msg1195);
603     return res;
604   }
605   
606   TColgp_Array2OfPnt  Pole(1, NbPolesU, 1, NbPolesV);
607   Standard_Integer             UIndex = Pole.LowerRow();
608   Standard_Integer             VIndex = Pole.LowerCol();
609   Standard_Integer             i, j; //szv#4:S4163:12Mar99 k unused
610   
611   if (!GetModeTransfer() && start->HasTransf()) 
612     for (i=0; i <= start->UpperIndexU(); i++) {
613       for (j=0; j <= start->UpperIndexV(); j++) 
614         Pole.SetValue(UIndex, VIndex++, start->TransformedPole(i,j));
615       UIndex++;
616       VIndex = Pole.LowerCol();
617     }
618   else
619     for (i=0; i <= start->UpperIndexU(); i++) {
620       for (j=0; j <= start->UpperIndexV(); j++) 
621         Pole.SetValue(UIndex, VIndex++, start->Pole(i,j));
622       UIndex++;
623       VIndex = Pole.LowerCol();
624     }
625   
626   
627   //  KNOTS & MULTIPLICITIES for U :
628   //  ==============================
629   
630   Standard_Integer           NbUKnots = start->NbKnotsU();
631   TColStd_Array1OfReal       TempUKnot(1, NbUKnots);
632   TColStd_Array1OfInteger    TempUMult(1, NbUKnots);
633   TempUMult.Init(1);
634
635   UIndex = TempUKnot.Lower();
636   
637   
638   //  If several identical IGES knots are encountered, corresponding 
639   //  multiplicity is increased
640   //  ==============================================================
641   
642   TempUKnot.SetValue(UIndex, start->KnotU(-DegreeU));
643   
644   for (i = 1-DegreeU; i < NbUKnots-DegreeU; i++) {
645
646     Standard_Real  UKnot1 = start->KnotU(i);
647     Standard_Real  UKnot2 = start->KnotU(i-1);
648
649     if (Abs(UKnot1 - UKnot2) <= Epsilon(UKnot2))
650       TempUMult.SetValue(UIndex, TempUMult.Value(UIndex) + 1);
651     else 
652       TempUKnot.SetValue(++UIndex, UKnot1);
653   }
654   
655   //  Final knots & multiplicities arraies are dimensionned so as to be fully 
656   //  filled :
657   //  =======================================================================
658   
659   TColStd_Array1OfReal     UKnot(1,UIndex);
660   TColStd_Array1OfInteger  UMult(1,UIndex);
661   
662   Standard_Integer SumOfUMult = 0;
663
664   TColStd_SequenceOfInteger SeqIndexU;
665   Standard_Integer DelIndexU;
666   Standard_Integer OldSumOfUMult = 0;
667   for (i=1 ; i <= UIndex; i++) { //:k5 abv 25 Dec 98: cycle modified
668     Standard_Integer aMult = TempUMult.Value(i);
669     Standard_Integer maxMult = ( i==1 || i == UIndex ? DegreeU + 1 : DegreeU );
670     if (aMult > maxMult) {
671       Message_Msg msg1200("IGES_1200");
672       msg1200.Arg("U");
673       msg1200.Arg("U");
674       msg1200.Arg("U");//#61 rln 05.01.99
675       SendWarning(start, msg1200); //U Multiplicity > DegreeU (or Degree+1 at end); corrected
676       for ( DelIndexU = OldSumOfUMult + 1; aMult > maxMult; DelIndexU++, aMult-- ) {
677         newNbPolesU--;
678         SeqIndexU.Append(DelIndexU);
679       }
680     }
681     OldSumOfUMult += TempUMult.Value(i); 
682     UKnot.SetValue(i, TempUKnot.Value(i));
683     UMult.SetValue(i, aMult);
684     SumOfUMult += aMult;
685   }
686
687   if (SumOfUMult != newNbPolesU + DegreeU + 1) {
688     Message_Msg msg1210("IGES_1210");
689     msg1210.Arg("U");
690     msg1210.Arg("U");
691     SendWarning(start, msg1210);
692     // Sum of multiplicities following U is not equal to the sum : Count of poles + DegreeU + 1
693   }
694   
695   //  KNOTS & MULTIPLICITIES for V :
696   //  ==============================
697   
698   Standard_Integer         NbVKnots = start->NbKnotsV();
699   TColStd_Array1OfReal     TempVKnot(1, NbVKnots);
700   TColStd_Array1OfInteger  TempVMult(1, NbVKnots);
701   TempVMult.Init(1);
702   
703   VIndex = TempVKnot.Lower();
704   
705
706   //  If several identical IGES knots are encountered, corresponding 
707   //  multiplicity is increased
708   //  ==============================================================  
709   
710   TempVKnot.SetValue(VIndex, start->KnotV(-DegreeV));
711   
712   for (i = 1-DegreeV; i < NbVKnots-DegreeV; i++) {
713
714     Standard_Real  VKnot1 = start->KnotV(i);
715     Standard_Real  VKnot2 = start->KnotV(i-1);
716
717     if (Abs(VKnot1 - VKnot2) <= Epsilon(VKnot2))
718       TempVMult.SetValue(VIndex, TempVMult.Value(VIndex) + 1);
719     else 
720       TempVKnot.SetValue(++VIndex, VKnot1);
721   }
722   
723   //  Final knots & multiplicities arraies are dimensionned so as to be fully 
724   //  filled :
725   //  =======================================================================
726   
727   TColStd_Array1OfReal     VKnot(1,VIndex);
728   TColStd_Array1OfInteger  VMult(1,VIndex);
729   
730   Standard_Integer SumOfVMult = 0;
731    
732   TColStd_SequenceOfInteger SeqIndexV;
733   Standard_Integer DelIndexV;
734   Standard_Integer OldSumOfVMult = 0;
735   for (i=1; i <= VIndex; i++) { //:k5 abv 25 Dec 98: cycle modified
736     Standard_Integer aMult = TempVMult.Value(i);
737     Standard_Integer maxMult = ( i==1 || i == VIndex ? DegreeV + 1 : DegreeV );
738     if (aMult > maxMult) {
739       Message_Msg msg1200("IGES_1200");//#61 rln 05.01.99
740       msg1200.Arg("V");
741       msg1200.Arg("V");
742       msg1200.Arg("V");
743       SendWarning(start, msg1200);
744       //V Multiplicity > DegreeV (or Degree+1 at end); corrected
745       for ( DelIndexV = OldSumOfVMult + 1; aMult > maxMult; DelIndexV++, aMult-- ) {
746         newNbPolesV--;
747         SeqIndexV.Append(DelIndexV);
748       }
749     }
750     OldSumOfVMult += TempVMult.Value(i); 
751     VKnot.SetValue(i, TempVKnot.Value(i));
752     VMult.SetValue(i, aMult);
753     SumOfVMult += aMult;
754   }  
755
756   if (SumOfVMult != newNbPolesV + DegreeV + 1)  {
757     Message_Msg msg1210("IGES_1210");
758     msg1210.Arg("V");
759     msg1210.Arg("V");
760     SendWarning(start, msg1210); 
761     // Sum of multiplicities following V is not equal to the sum : Count of poles + Degree V + 1
762   }
763   
764   // Mise a jour du tableau des poles
765   TColgp_Array2OfPnt  Poles(1, newNbPolesU, 1, newNbPolesV);
766   TColStd_SequenceOfInteger PoleUInd;
767   TColStd_SequenceOfInteger PoleVInd;
768   for (i=1; i<=NbPolesU; i++) PoleUInd.Append(i);
769   for (i=1; i<=NbPolesV; i++) PoleVInd.Append(i);
770   UIndex = Poles.LowerRow();
771   VIndex = Poles.LowerCol();
772
773   if (( newNbPolesU < NbPolesU) || (newNbPolesV < NbPolesV)) {
774     if ( newNbPolesU < NbPolesU) {
775       Standard_Integer Offset = 0;
776       for (Standard_Integer itab = 1; itab <= SeqIndexU.Length(); itab++) {
777         DelIndexU = SeqIndexU.Value(itab) - Offset;
778         PoleUInd.Remove(DelIndexU);
779         Offset++;
780       }
781     }
782     if ( newNbPolesV < NbPolesV) {
783       Standard_Integer Offset = 0;
784       for (Standard_Integer itab = 1; itab <= SeqIndexV.Length(); itab++) {
785         DelIndexV = SeqIndexV.Value(itab) - Offset;
786         PoleVInd.Remove(DelIndexV);
787         Offset++;
788       }
789     }
790     Standard_Integer nbUseq = PoleUInd.Length();
791     Standard_Integer nbVseq = PoleVInd.Length();
792     if (( nbUseq == newNbPolesU)&&(nbVseq == newNbPolesV)) {
793       for ( i=1; i<= newNbPolesU; i++) {
794         for (j=1; j<= newNbPolesV; j++) 
795           Poles.SetValue(UIndex,VIndex++ , Pole.Value(PoleUInd.Value(i),
796                                                       PoleVInd.Value(j)));
797         UIndex++;
798         VIndex = Poles.LowerCol();
799       }
800     }
801     else {
802        Message_Msg msg1175("IGES_1175");
803        SendWarning(start, msg1175);
804     }
805   }
806
807   else {
808     for ( i=1; i<= newNbPolesU; i++) {
809       for (j=1; j<= newNbPolesV; j++) 
810         Poles.SetValue (UIndex, VIndex++,Pole.Value(i,j));
811       UIndex++;
812       VIndex = Poles.LowerCol();
813     }
814   }
815     
816
817   //  Building result taking into account transformation if any :
818   //  ===========================================================
819
820   if (!GetModeTransfer() && start->HasTransf()) {
821     gp_GTrsf GBSplTrsf(start->CompoundLocation());
822     gp_Trsf  BSplTrsf;
823     if (IGESData_ToolLocation::ConvertLocation(GetEpsilon(),GBSplTrsf,BSplTrsf)) 
824       for (i=Poles.LowerRow(); i<=Poles.UpperRow(); i++) 
825         for (j=Poles.LowerCol(); j<=Poles.UpperCol(); j++) 
826           Poles.SetValue(i, j, Poles.Value(i,j).Transformed(BSplTrsf));
827     else {   
828       Message_Msg msg1035("IGES_1035");
829       SendWarning(start, msg1035);
830     }
831   }
832   
833   
834   //  CREATION with the ARRAY of POLES WEIGHTS if any :
835   //  =================================================
836   
837     if (start->IsPolynomial()) 
838     {
839       //sln 29.12.2001 OCC90 : If surface can not be created do nothing
840       TColStd_Array2OfReal  Weight(1, 1, 1, 1);
841       if(!checkBSplineSurface(this, start, UKnot, VKnot, Weight)) return res;
842       res = new Geom_BSplineSurface(Poles, UKnot, VKnot, UMult, VMult, 
843                                     DegreeU, DegreeV);
844     }
845
846     else {
847       TColStd_Array2OfReal  PoleWeight(1, NbPolesU, 1, NbPolesV);
848       Standard_Boolean      polynomial          =  Standard_True;
849       Standard_Real         WeightReference     =  start->Weight(0,0);
850       Standard_Integer      WeightRow           =  PoleWeight.LowerRow();
851       Standard_Integer      WeightCol           =  PoleWeight.LowerCol();
852       
853       for (i=0; i <= start->UpperIndexU(); i++) {
854         for (j=0; j <= start->UpperIndexV(); j++) {
855           polynomial = (Abs(start->Weight(i,j) - WeightReference) 
856                         <= Epsilon(WeightReference)) && polynomial;
857           //:39 by abv 15.12.97
858           Standard_Real weight = start->Weight(i,j);
859           if ( weight < Precision::PConfusion() ) {
860             Message_Msg msg1215("IGES_1215");
861             SendFail (start, msg1215); // Some weights are not positive.
862             return res;
863           }
864           PoleWeight.SetValue(WeightRow, WeightCol++, weight);
865 //:39     PoleWeight.SetValue(WeightRow, WeightCol++, start->Weight(i,j));
866         }
867         WeightRow++;
868         WeightCol = PoleWeight.LowerCol();
869       }
870       if (polynomial) {
871         Message_Msg msg1220("IGES_1220");
872         const Standard_CString surface ("surface");      
873         msg1220.Arg(surface);
874         SendWarning(start, msg1220);
875      }
876       // Mise a jour du tableau des Weight lors de la correction de la multiplicite
877       TColStd_Array2OfReal Weight(1, newNbPolesU, 1, newNbPolesV);
878       UIndex = Weight.LowerRow();
879       VIndex = Weight.LowerCol();
880       if (( newNbPolesU < NbPolesU) || (newNbPolesV < NbPolesV)) {
881         //Standard_Integer indj = 1; //szv#4:S4163:12Mar99 unused
882         for ( i=1; i<= newNbPolesU; i++) {
883           for (j=1; j<= newNbPolesV; j++) 
884             Weight.SetValue(UIndex, VIndex++ , 
885                             PoleWeight.Value(PoleUInd.Value(i),PoleVInd.Value(j)));
886           UIndex++;
887           VIndex = Poles.LowerCol();
888         }
889       }
890       else {
891         for ( i=1; i<= newNbPolesU; i++) {
892           for (j=1; j<= newNbPolesV; j++) 
893             Weight.SetValue(UIndex, VIndex++ ,PoleWeight.Value(i,j));
894           UIndex++;
895           VIndex = Poles.LowerCol();
896         }
897       }
898
899       //sln 29.12.2001 OCC90 : If surface can not be created do nothing
900       if(!checkBSplineSurface(this, start, UKnot, VKnot, Weight)) return res;
901       res = new Geom_BSplineSurface
902         (Poles, Weight, UKnot, VKnot, UMult, VMult, DegreeU, DegreeV);
903     }
904   
905
906   //  Checking C2 and C1 continuity :
907   //  ===============================
908   
909   Standard_Integer icont = GetContinuity();
910   //Standard_Boolean isC1 = Standard_True, isC2 = Standard_True; //szv#4:S4163:12Mar99 not needed
911
912   i = res->LastUKnotIndex();
913   Standard_Integer FirstIndex = res->FirstUKnotIndex();
914   while (--i >= FirstIndex+1) {
915     if (icont >=2) {
916       if(!res->RemoveUKnot(i, DegreeU-2, GetEpsGeom())) {
917         //isC2 = Standard_False; //szv#4:S4163:12Mar99 not needed
918         res->RemoveUKnot(i, DegreeU-1, GetEpsGeom()); //szv#4:S4163:12Mar99 `isC1=` not needed
919       }
920       else
921         res->RemoveUKnot(i, DegreeU-1, GetEpsGeom()); //szv#4:S4163:12Mar99 `isC1=` not needed
922     }
923   }
924
925   i = res->LastVKnotIndex();
926   FirstIndex = res->FirstVKnotIndex();
927   while (--i >= FirstIndex+1) {
928     if (icont >=2) {
929       if(!res->RemoveVKnot(i, DegreeV-2, GetEpsGeom())) {
930         //isC2 = Standard_False; //szv#4:S4163:12Mar99 not needed
931         res->RemoveVKnot(i, DegreeV-1, GetEpsGeom()); //szv#4:S4163:12Mar99 `isC1=` not needed
932       }
933       else
934         res->RemoveVKnot(i, DegreeV-1, GetEpsGeom()); //szv#4:S4163:12Mar99 `isC1=` not needed
935     }
936   }
937
938   //:h7 abv 14 Jul 98: ims010.igs 2519: closed periodic surface should be forced
939   // else some wires which can lie over the seam will be incorrect
940   //:l1 abv 6 Jan 99: USA60022 243: force periodicity on any closed surface
941   Standard_Boolean isUPeriodic = ( start->IsClosedU() && ( start->IsPeriodicU() ||
942                                                            res->IsUClosed() ) );
943   Standard_Boolean isVPeriodic = ( start->IsClosedV() && ( start->IsPeriodicV() ||
944                                                            res->IsVClosed() ) );
945   //:k0 abv 16 Dec 98: use ShapeCustom 
946   if ( isUPeriodic || isVPeriodic ) {
947     Handle(Geom_BSplineSurface) periodicSurf =
948       Handle(Geom_BSplineSurface)::DownCast ( ShapeAlgo::AlgoContainer()->ConvertToPeriodic (res) );
949     if ( ! periodicSurf.IsNull() ) { //:p6 abv 26 Feb 99: && periodicSurf != res ) {
950       //#75 rln 11.03.99: using message mechanism
951       Message_Msg msg1221("IGES_1221");
952       SendWarning(start, msg1221);//SendWarning(start,"Surface forced to be periodic");
953       res = periodicSurf;
954     }
955   }
956   return res;
957 }
958
959
960
961
962 //=======================================================================
963 //function : DeletePoleRow
964 //purpose  : 
965 //=======================================================================
966 //szv#4:S4163:12Mar99 function never referenced
967 /*
968 static void DeletePoleRow
969   (const TColgp_Array2OfPnt& Poles,
970    const Standard_Integer    Index,
971          TColgp_Array2OfPnt& NewPoles)
972 {
973   Standard_Integer Offset = 0;
974   Standard_Integer ColIndex;
975   Standard_Integer RowIndex = NewPoles.LowerRow();
976   while (RowIndex <= NewPoles.UpperRow()) {
977     ColIndex = NewPoles.LowerCol();
978     if (RowIndex == Index)  Offset = 1;
979     while (ColIndex <= NewPoles.UpperCol()){
980       NewPoles (RowIndex, ColIndex) = Poles (RowIndex + Offset, ColIndex);
981       ColIndex++;
982     }
983     RowIndex++;
984   }
985 }
986 */
987
988 //=======================================================================
989 //function : DeletePoleCol
990 //purpose  : 
991 //=======================================================================
992 //szv#4:S4163:12Mar99 function never referenced
993 /*
994 static void DeletePoleCol
995   (const TColgp_Array2OfPnt& Poles,
996    const Standard_Integer    Index,
997          TColgp_Array2OfPnt& NewPoles)
998 {
999   Standard_Integer Offset = 0;
1000   Standard_Integer RowIndex;
1001   Standard_Integer ColIndex = NewPoles.LowerCol();
1002   while (ColIndex <= NewPoles.UpperCol()) {
1003     RowIndex = NewPoles.LowerRow();
1004     if (ColIndex == Index)  Offset = 1;
1005     while (RowIndex <= NewPoles.UpperRow()){
1006       NewPoles (RowIndex, ColIndex) = Poles (RowIndex, ColIndex + Offset);
1007       RowIndex++;
1008     }
1009     ColIndex++;
1010   }
1011 }
1012 */
1013