0031004: Coding - eliminate warnings issued by gcc 9.1.0
[occt.git] / src / AdvApp2Var / AdvApp2Var_Patch.cxx
1 // Created on: 1996-07-02
2 // Created by: Joelle CHAUVET
3 // Copyright (c) 1996-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 // Modified:    Wed Jan 15 10:04:41 1997
18 //   by:        Joelle CHAUVET
19 //              G1135 : Methods CutSense with criterion, Coefficients,
20 //                              CritValue, SetCritValue
21 // Modified:    Tue May 19 10:22:44 1998
22 //   by:        Joelle CHAUVET / Jean-Marc LACHAUME
23 //              Initialisation de myCritValue pour OSF
24
25 #include <AdvApp2Var_ApproxF2var.hxx>
26 #include <AdvApp2Var_Context.hxx>
27 #include <AdvApp2Var_Criterion.hxx>
28 #include <AdvApp2Var_Framework.hxx>
29 #include <AdvApp2Var_Iso.hxx>
30 #include <AdvApp2Var_MathBase.hxx>
31 #include <AdvApp2Var_Node.hxx>
32 #include <AdvApp2Var_Patch.hxx>
33 #include <Convert_GridPolynomialToPoles.hxx>
34 #include <gp_Pnt.hxx>
35 #include <Standard_ConstructionError.hxx>
36 #include <TColgp_Array2OfPnt.hxx>
37 #include <TColgp_HArray2OfPnt.hxx>
38 #include <TColStd_Array2OfReal.hxx>
39 #include <TColStd_HArray1OfInteger.hxx>
40 #include <TColStd_HArray1OfReal.hxx>
41 #include <TColStd_HArray2OfReal.hxx>
42
43 IMPLEMENT_STANDARD_RTTIEXT(AdvApp2Var_Patch, Standard_Transient)
44
45 //============================================================================
46 //function : AdvApp2Var_Patch
47 //purpose  :
48 //============================================================================
49 AdvApp2Var_Patch::AdvApp2Var_Patch() :
50 myU0(0.),
51 myU1(1.),
52 myV0(0.),
53 myV1(1.),
54 myOrdInU(0),
55 myOrdInV(0),
56 myNbCoeffInU(0),
57 myNbCoeffInV(0),
58 myApprIsDone(Standard_False),
59 myHasResult(Standard_False),
60 myCutSense(0),
61 myDiscIsDone(Standard_False),
62 myCritValue(0.)
63 {
64 }
65
66 //============================================================================
67 //function : AdvApp2Var_Patch
68 //purpose  :
69 //============================================================================
70
71 AdvApp2Var_Patch::AdvApp2Var_Patch(const Standard_Real U0,
72                                    const Standard_Real U1,
73                                    const Standard_Real V0,
74                                    const Standard_Real V1,
75                                    const Standard_Integer iu,
76                                    const Standard_Integer iv) :
77 myU0(U0),
78 myU1(U1),
79 myV0(V0),
80 myV1(V1),
81 myOrdInU(iu),
82 myOrdInV(iv),
83 myNbCoeffInU(0),
84 myNbCoeffInV(0),
85 myApprIsDone(Standard_False),
86 myHasResult(Standard_False),
87 myCutSense(0),
88 myDiscIsDone(Standard_False),
89 myCritValue(0.)
90 {
91 }
92
93 //============================================================================
94 //function : IsDiscretised
95 //purpose  :
96 //============================================================================
97
98 Standard_Boolean AdvApp2Var_Patch::IsDiscretised() const 
99 {
100   return myDiscIsDone; 
101 }
102
103 //============================================================================
104 //function : Discretise
105 //purpose  : 
106 //============================================================================
107
108 void AdvApp2Var_Patch::Discretise(const AdvApp2Var_Context& Conditions,
109                                   const AdvApp2Var_Framework& Constraints,
110                                   const AdvApp2Var_EvaluatorFunc2Var& Func) 
111 {
112
113 // data stored in the Context
114   Standard_Integer NDIMEN, ISOFAV;
115   NDIMEN = Conditions.TotalDimension();
116 // Attention : works only for 3D
117   ISOFAV = Conditions.FavorIso();
118
119 // data related to the patch to be discretized
120   Standard_Integer NBPNTU, NBPNTV;
121   Standard_Integer IORDRU = myOrdInU, IORDRV = myOrdInV;
122   Handle (TColStd_HArray1OfReal) HUROOT  = Conditions.URoots();
123   Handle (TColStd_HArray1OfReal) HVROOT  = Conditions.VRoots();
124   Standard_Real * UROOT;
125     UROOT =  (Standard_Real *) &HUROOT ->ChangeArray1()(HUROOT ->Lower());
126   NBPNTU = (Conditions.URoots())->Length();
127   if (myOrdInU>-1) NBPNTU -= 2;
128   Standard_Real * VROOT;
129     VROOT =  (Standard_Real *) &HVROOT ->ChangeArray1()(HVROOT ->Lower());
130   NBPNTV = (Conditions.VRoots())->Length();
131   if (myOrdInV>-1) NBPNTV -= 2;
132
133 // data stored in the Framework Constraints cad Nodes and Isos 
134 // C1, C2, C3 and C4 are dimensionnes in FORTRAN with (NDIMEN,IORDRU+2,IORDRV+2)
135   Standard_Integer SIZE=NDIMEN*(IORDRU+2)*(IORDRV+2);
136   Handle (TColStd_HArray1OfReal) HCOINS  =
137     new TColStd_HArray1OfReal(1,SIZE*4);
138   HCOINS->Init(0.);
139
140   Standard_Integer iu,iv;
141   Standard_Real du=(myU1-myU0)/2,dv=(myV1-myV0)/2,rho,valnorm;
142
143   for (iu=0;iu<=myOrdInU;iu++) {
144     for (iv=0;iv<=myOrdInV;iv++) {
145 // factor of normalization
146       rho = pow(du,iu)*pow(dv,iv);
147
148 // F(U0,V0) and its derivatives normalized on (-1,1)
149       valnorm = rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).X();
150       HCOINS->SetValue( 1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv , valnorm );
151       valnorm = rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Y();
152       HCOINS->SetValue( 2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
153       valnorm = rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Z();
154       HCOINS->SetValue( 3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
155
156 // F(U1,V0) and its derivatives normalized on (-1,1)
157       valnorm = rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).X();
158       HCOINS->SetValue( SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
159       valnorm = rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Y();
160       HCOINS->SetValue( SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
161       valnorm = rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Z();
162       HCOINS->SetValue( SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
163
164 // F(U0,V1) and its derivatives normalized on (-1,1)
165       valnorm = rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).X();
166       HCOINS->SetValue( 2*SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
167       valnorm = rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Y();
168       HCOINS->SetValue( 2*SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
169       valnorm = rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Z();
170       HCOINS->SetValue( 2*SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
171
172 // F(U1,V1) and its derivatives normalized on (-1,1)
173       valnorm = rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).X();
174       HCOINS->SetValue( 3*SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
175       valnorm = rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Y();
176       HCOINS->SetValue( 3*SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
177       valnorm = rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Z();
178       HCOINS->SetValue( 3*SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
179     }
180   }
181   Standard_Real *C1 = 
182     (Standard_Real *) &HCOINS ->ChangeArray1()(HCOINS ->Lower());
183   Standard_Real *C2 = C1 + SIZE;
184   Standard_Real *C3 = C2 + SIZE;
185   Standard_Real *C4 = C3 + SIZE;
186
187 // tables SomTab and Diftab of discretization of isos U=U0 and U=U1
188 // SU0, SU1, DU0 and DU1 are dimensioned in FORTRAN to 
189 // (1+NBPNTV/2)*NDIMEN*(IORDRU+1)
190
191   SIZE = (1+NBPNTV/2)*NDIMEN;
192
193   Handle (TColStd_HArray1OfReal) HSU0
194     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
195   HSU0 ->ChangeArray1() =
196     ( (Constraints.IsoU(myU0,myV0,myV1)).SomTab() ) ->Array1();
197
198   Handle (TColStd_HArray1OfReal) HDU0
199     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
200   HDU0 ->ChangeArray1() =
201     ( (Constraints.IsoU(myU0,myV0,myV1)).DifTab() ) ->Array1();
202
203   Handle (TColStd_HArray1OfReal) HSU1
204     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
205   HSU1 ->ChangeArray1() =
206     ( (Constraints.IsoU(myU1,myV0,myV1)).SomTab() ) ->Array1();
207
208   Handle (TColStd_HArray1OfReal) HDU1
209     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
210   HDU1 ->ChangeArray1() =
211     ( (Constraints.IsoU(myU1,myV0,myV1)).DifTab() ) ->Array1();
212
213 // normalization
214   Standard_Integer ideb1,ideb2,ideb3,ideb4,jj;
215   for (iu=1;iu<=IORDRU;iu++) {
216     rho = pow(du,iu);
217     ideb1 = HSU0->Lower() + iu*SIZE -1;
218     ideb2 = HDU0->Lower() + iu*SIZE -1;
219     ideb3 = HSU1->Lower() + iu*SIZE -1;
220     ideb4 = HDU1->Lower() + iu*SIZE -1;
221     for (jj=1;jj<=SIZE;jj++) {
222       HSU0 ->SetValue(ideb1+jj,rho*HSU0->Value(ideb1+jj));
223       HDU0 ->SetValue(ideb2+jj,rho*HDU0->Value(ideb2+jj));
224       HSU1 ->SetValue(ideb3+jj,rho*HSU1->Value(ideb3+jj));
225       HDU1 ->SetValue(ideb4+jj,rho*HDU1->Value(ideb4+jj));
226     }
227   }
228
229   Standard_Real *SU0 = 
230     (Standard_Real *) &HSU0 ->ChangeArray1()(HSU0 ->Lower());
231   Standard_Real *DU0 = 
232     (Standard_Real *) &HDU0 ->ChangeArray1()(HDU0 ->Lower());
233   Standard_Real *SU1 = 
234     (Standard_Real *) &HSU1 ->ChangeArray1()(HSU1 ->Lower());
235   Standard_Real *DU1 = 
236     (Standard_Real *) &HDU1 ->ChangeArray1()(HDU1 ->Lower());
237
238 // tables SomTab and Diftab of discretization of isos V=V0 and V=V1
239 // SU0, SU1, DU0 and DU1 are dimensioned in FORTRAN at
240 // (1+NBPNTU/2)*NDIMEN*(IORDRV+1)
241
242   SIZE = (1+NBPNTU/2)*NDIMEN;
243
244   Handle (TColStd_HArray1OfReal) HSV0
245     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
246   HSV0 ->ChangeArray1() =
247     ( (Constraints.IsoV(myU0,myU1,myV0)).SomTab() ) ->Array1();
248
249   Handle (TColStd_HArray1OfReal) HDV0
250     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
251   HDV0 ->ChangeArray1() =
252     ( (Constraints.IsoV(myU0,myU1,myV0)).DifTab() ) ->Array1();
253
254   Handle (TColStd_HArray1OfReal) HSV1
255     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
256   HSV1 ->ChangeArray1() =
257     ( (Constraints.IsoV(myU0,myU1,myV1)).SomTab() ) ->Array1();
258
259   Handle (TColStd_HArray1OfReal) HDV1
260     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
261   HDV1 ->ChangeArray1() =
262     ( (Constraints.IsoV(myU0,myU1,myV1)).DifTab() ) ->Array1();
263
264 // normalisation
265   for (iv=1;iv<=IORDRV;iv++) {
266     rho = pow(dv,iv);
267     ideb1 = HSV0->Lower() + iv*SIZE -1;
268     ideb2 = HDV0->Lower() + iv*SIZE -1;
269     ideb3 = HSV1->Lower() + iv*SIZE -1;
270     ideb4 = HDV1->Lower() + iv*SIZE -1;
271     for (jj=1;jj<=SIZE;jj++) {
272       HSV0 ->SetValue(ideb1+jj,rho*HSV0->Value(ideb1+jj));
273       HDV0 ->SetValue(ideb2+jj,rho*HDV0->Value(ideb2+jj));
274       HSV1 ->SetValue(ideb3+jj,rho*HSV1->Value(ideb3+jj));
275       HDV1 ->SetValue(ideb4+jj,rho*HDV1->Value(ideb4+jj));
276     }
277   }
278
279   Standard_Real *SV0 = 
280     (Standard_Real *) &HSV0 ->ChangeArray1()(HSV0 ->Lower());
281   Standard_Real *DV0 = 
282     (Standard_Real *) &HDV0 ->ChangeArray1()(HDV0 ->Lower());
283   Standard_Real *SV1 = 
284     (Standard_Real *) &HSV1 ->ChangeArray1()(HSV1 ->Lower());
285   Standard_Real *DV1 = 
286     (Standard_Real *) &HDV1 ->ChangeArray1()(HDV1 ->Lower());
287
288 // SOSOTB and DIDITB are dimensioned in FORTRAN at 
289 // (0:NBPNTU/2,0:NBPNTV/2,NDIMEN)
290
291   SIZE=(1+NBPNTU/2)*(1+NBPNTV/2)*NDIMEN;
292
293   Handle (TColStd_HArray1OfReal) HSOSO  =
294     new TColStd_HArray1OfReal(1,SIZE);
295   Standard_Real *SOSOTB  =  
296     (Standard_Real *) &HSOSO ->ChangeArray1()(HSOSO ->Lower());
297   HSOSO->Init(0.);
298   Handle (TColStd_HArray1OfReal) HDIDI  =
299     new TColStd_HArray1OfReal(1,SIZE);
300   Standard_Real *DIDITB  =  
301     (Standard_Real *) &HDIDI ->ChangeArray1()(HDIDI ->Lower());
302   HDIDI->Init(0.);
303
304 // SODITB and DISOTB are dimensioned in FORTRAN at
305 // (1:NBPNTU/2,1:NBPNTV/2,NDIMEN)
306
307   SIZE=(NBPNTU/2)*(NBPNTV/2)*NDIMEN;
308
309   Handle (TColStd_HArray1OfReal) HSODI  =
310     new TColStd_HArray1OfReal(1,SIZE);
311   Standard_Real *SODITB  =  
312     (Standard_Real *) &HSODI ->ChangeArray1()(HSODI ->Lower());
313   HSODI->Init(0.);
314   Handle (TColStd_HArray1OfReal) HDISO  =
315     new TColStd_HArray1OfReal(1,SIZE);
316   Standard_Real *DISOTB  =  
317     (Standard_Real *) &HDISO ->ChangeArray1()(HDISO ->Lower());
318   HDISO->Init(0.);
319
320   Standard_Integer IERCOD=0;
321
322 //  discretization of polynoms of interpolation
323   AdvApp2Var_ApproxF2var::mma2cdi_(&NDIMEN,&NBPNTU,UROOT,&NBPNTV,VROOT,&IORDRU,&IORDRV,
324          C1,C2,C3,C4,SU0,SU1,DU0,DU1,SV0,SV1,DV0,DV1,
325          SOSOTB,SODITB,DISOTB,DIDITB,&IERCOD);
326
327 //  discretization of the square
328   Standard_Real UDBFN[2],VDBFN[2];
329   UDBFN[0] = myU0;
330   UDBFN[1] = myU1;
331   VDBFN[0] = myV0;
332   VDBFN[1] = myV1;
333
334   SIZE = Max(NBPNTU,NBPNTV);
335   Handle (TColStd_HArray1OfReal) HTABLE  =
336     new TColStd_HArray1OfReal(1,SIZE);
337   Standard_Real *TAB  =  
338     (Standard_Real *) &HTABLE ->ChangeArray1()(HTABLE ->Lower());
339
340   Handle (TColStd_HArray1OfReal) HPOINTS  =
341     new TColStd_HArray1OfReal(1,SIZE*NDIMEN);
342   Standard_Real *PTS  =  
343     (Standard_Real *) &HPOINTS ->ChangeArray1()(HPOINTS ->Lower());
344
345   // GCC 3.0 would not accept this line without the void
346   // pointer cast.  Perhaps the real problem is a definition
347   // somewhere that has a void * in it.
348   AdvApp2Var_ApproxF2var::mma2ds1_(&NDIMEN,
349                                    UDBFN,
350                                    VDBFN,
351                                    /*(void *)*/Func,
352                                    &NBPNTU,
353                                    &NBPNTV,
354                                    UROOT,
355                                    VROOT,
356                                    &ISOFAV,
357                                    SOSOTB,
358                                    DISOTB,
359                                    SODITB,
360                                    DIDITB,
361                                    PTS,
362                                    TAB,
363                                    &IERCOD);
364
365 // the results are stored
366   if (IERCOD == 0) {
367     myDiscIsDone = Standard_True;
368     mySosoTab = HSOSO;
369     myDisoTab = HDISO;
370     mySodiTab = HSODI;
371     myDidiTab = HDIDI;
372   }
373   else {
374     myDiscIsDone = Standard_False;
375   }
376 }
377
378 //============================================================================
379 //function : HasResult
380 //purpose  :
381 //============================================================================
382
383 Standard_Boolean AdvApp2Var_Patch::HasResult() const 
384 {
385   return myHasResult; 
386 }
387
388 //============================================================================
389 //function : IsApproximated
390 //purpose  :
391 //============================================================================
392
393 Standard_Boolean AdvApp2Var_Patch::IsApproximated() const 
394 {
395   return myApprIsDone;
396 }
397
398 //============================================================================
399 //function : AddConstraints
400 //purpose  :
401 //============================================================================
402
403 void AdvApp2Var_Patch::AddConstraints(const AdvApp2Var_Context& Conditions,
404                                       const AdvApp2Var_Framework& Constraints)
405 {
406 // data stored in the  Context
407   Standard_Integer NDIMEN;
408   Standard_Integer IERCOD, NCFLMU, NCFLMV, NDegU, NDegV;
409   NDIMEN = Conditions.TotalDimension();
410 // Attention : works only for 3D
411   NCFLMU = Conditions.ULimit();
412   NCFLMV = Conditions.VLimit();
413   NDegU = NCFLMU - 1;
414   NDegV = NCFLMV - 1;
415
416 // data relative to the patch 
417   Standard_Integer IORDRU = myOrdInU, IORDRV = myOrdInV;
418   Standard_Real *PATCAN  =  
419     (Standard_Real *) &myEquation ->ChangeArray1()(myEquation ->Lower());
420
421 // curves of approximation of Isos U
422   Standard_Integer SIZE = NCFLMV*NDIMEN;
423   Handle (TColStd_HArray1OfReal) HIsoU0
424     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
425   HIsoU0 -> ChangeArray1() =
426     (Constraints.IsoU(myU0,myV0,myV1)).Polynom() -> Array1();
427   Standard_Real *IsoU0 = 
428     (Standard_Real *) &HIsoU0 ->ChangeArray1()(HIsoU0 ->Lower());
429   Handle (TColStd_HArray1OfInteger) HCFU0
430     = new TColStd_HArray1OfInteger(1,IORDRU+1);
431   Standard_Integer *NCFU0 = 
432     (Standard_Integer *) &HCFU0 ->ChangeArray1()(HCFU0 ->Lower());
433   HCFU0->Init( (Constraints.IsoU(myU0,myV0,myV1)).NbCoeff() );
434
435   Handle (TColStd_HArray1OfReal) HIsoU1
436     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
437   HIsoU1 -> ChangeArray1() =
438     (Constraints.IsoU(myU1,myV0,myV1)).Polynom() -> Array1();
439   Standard_Real *IsoU1 = 
440     (Standard_Real *) &HIsoU1 ->ChangeArray1()(HIsoU1 ->Lower());
441   Handle (TColStd_HArray1OfInteger) HCFU1
442     = new TColStd_HArray1OfInteger(1,IORDRU+1);
443   Standard_Integer *NCFU1 = 
444     (Standard_Integer *) &HCFU1 ->ChangeArray1()(HCFU1 ->Lower());
445   HCFU1->Init( (Constraints.IsoU(myU1,myV0,myV1)).NbCoeff() );
446
447 // normalization of Isos U
448   Standard_Integer iu,iv;
449   Standard_Real du=(myU1-myU0)/2,dv=(myV1-myV0)/2,rho,valnorm;
450   Standard_Integer ideb0,ideb1,jj;
451
452   for (iu=1;iu<=IORDRU;iu++) {
453     rho = pow(du,iu);
454     ideb0 = HIsoU0->Lower() + iu*SIZE -1;
455     ideb1 = HIsoU1->Lower() + iu*SIZE -1;
456     for (jj=1;jj<=SIZE;jj++) {
457       HIsoU0->SetValue(ideb0+jj,rho*HIsoU0->Value(ideb0+jj));
458       HIsoU1->SetValue(ideb1+jj,rho*HIsoU1->Value(ideb1+jj));
459     }
460   }
461
462 // curves of approximation of Isos V
463   SIZE = NCFLMU*NDIMEN;
464   Handle (TColStd_HArray1OfReal) HIsoV0
465     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
466   HIsoV0 -> ChangeArray1() =
467     (Constraints.IsoV(myU0,myU1,myV0)).Polynom() -> Array1();
468   Standard_Real *IsoV0 = 
469     (Standard_Real *) &HIsoV0 ->ChangeArray1()(HIsoV0 ->Lower());
470   Handle (TColStd_HArray1OfInteger) HCFV0
471     = new TColStd_HArray1OfInteger(1,IORDRV+1);
472   Standard_Integer *NCFV0 = 
473     (Standard_Integer *) &HCFV0 ->ChangeArray1()(HCFV0 ->Lower());
474   HCFV0->Init( (Constraints.IsoV(myU0,myU1,myV0)).NbCoeff() );
475
476   Handle (TColStd_HArray1OfReal) HIsoV1
477     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
478   HIsoV1 -> ChangeArray1() =
479     (Constraints.IsoV(myU0,myU1,myV1)).Polynom() -> Array1();
480   Standard_Real *IsoV1 = 
481     (Standard_Real *) &HIsoV1 ->ChangeArray1()(HIsoV1 ->Lower());
482   Handle (TColStd_HArray1OfInteger) HCFV1
483     = new TColStd_HArray1OfInteger(1,IORDRV+1);
484   Standard_Integer *NCFV1 = 
485     (Standard_Integer *) &HCFV1 ->ChangeArray1()(HCFV1 ->Lower());
486   HCFV1->Init( (Constraints.IsoV(myU0,myU1,myV1)).NbCoeff() );
487
488 //  normalization of Isos V
489   for (iv=1;iv<=IORDRV;iv++) {
490     rho = pow(dv,iv);
491     ideb0 = HIsoV0->Lower() + iv*SIZE -1;
492     ideb1 = HIsoV1->Lower() + iv*SIZE -1;
493     for (jj=1;jj<=SIZE;jj++) {
494       HIsoV0 ->SetValue(ideb0+jj,rho*HIsoV0->Value(ideb0+jj));
495       HIsoV1->SetValue(ideb1+jj,rho*HIsoV1->Value(ideb1+jj));
496     }
497   }
498
499 // add constraints to constant V
500   Handle (TColStd_HArray1OfReal) HHERMV 
501     = new TColStd_HArray1OfReal(1,(2*IORDRV+2)*(2*IORDRV+2));
502   Standard_Real *HermV = 
503     (Standard_Real *) &HHERMV ->ChangeArray1()(HHERMV ->Lower());
504   if (IORDRV>=0) {
505     AdvApp2Var_ApproxF2var::mma1her_(&IORDRV,HermV,&IERCOD);
506     if (IERCOD!=0) {
507       throw Standard_ConstructionError("AdvApp2Var_Patch::AddConstraints : Error in FORTRAN");
508     }
509     AdvApp2Var_ApproxF2var::mma2ac2_(&NDIMEN,
510                                      &NDegU,
511                                      &NDegV,
512                                      &IORDRV,
513                                      &NCFLMU,
514                                      NCFV0,
515                                      IsoV0,
516                                      NCFV1,
517                                      IsoV1,
518                                      HermV,
519                                      PATCAN);
520   }
521
522 // add constraints to constant U
523   Handle (TColStd_HArray1OfReal) HHERMU 
524     = new TColStd_HArray1OfReal(1,(2*IORDRU+2)*(2*IORDRU+2));
525   Standard_Real *HermU = 
526     (Standard_Real *) &HHERMU ->ChangeArray1()(HHERMU ->Lower());
527   if (IORDRU>=0) {
528     AdvApp2Var_ApproxF2var::mma1her_(&IORDRU,HermU,&IERCOD);
529     if (IERCOD!=0) {
530       throw Standard_ConstructionError("AdvApp2Var_Patch::AddConstraints : Error in FORTRAN");
531     }
532     AdvApp2Var_ApproxF2var::mma2ac3_(&NDIMEN,&NDegU,&NDegV,&IORDRU,&NCFLMV,
533                                      NCFU0,IsoU0,NCFU1,IsoU1,HermU,PATCAN);
534   }
535
536 // add constraints at the corners
537   Standard_Integer ideb;
538   SIZE=NDIMEN*(IORDRU+2)*(IORDRV+2);
539   Handle (TColStd_HArray1OfReal) HCOINS  =
540     new TColStd_HArray1OfReal(1,SIZE*4);
541
542   for (iu=0;iu<=myOrdInU;iu++) {
543     for (iv=0;iv<=myOrdInV;iv++) {
544       rho = pow(du,iu)*pow(dv,iv);
545
546 // -F(U0,V0) and its derivatives normalized on (-1,1)
547       ideb = HCOINS->Lower() + NDIMEN*iu+NDIMEN*(IORDRU+2)*iv - 1;
548       valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).X();
549       HCOINS->SetValue( 1+ideb , valnorm );
550       valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Y();
551       HCOINS->SetValue( 2+ideb , valnorm );
552       valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Z();
553       HCOINS->SetValue( 3+ideb , valnorm );
554
555 // -F(U1,V0) and its derivatives normalized on (-1,1)
556       ideb += SIZE;
557       valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).X();
558       HCOINS->SetValue( 1+ideb , valnorm );
559       valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Y();
560       HCOINS->SetValue( 2+ideb , valnorm );
561       valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Z();
562       HCOINS->SetValue( 3+ideb , valnorm );
563
564 // -F(U0,V1) and its derivatives normalized on (-1,1)
565       ideb += SIZE;
566       valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).X();
567       HCOINS->SetValue( 1+ideb , valnorm );
568       valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Y();
569       HCOINS->SetValue( 2+ideb , valnorm );
570       valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Z();
571       HCOINS->SetValue( 3+ideb , valnorm );
572
573 // -F(U1,V1) and its derivatives normalized on (-1,1)
574       ideb += SIZE;
575       valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).X();
576       HCOINS->SetValue( 1+ideb , valnorm );
577       valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Y();
578       HCOINS->SetValue( 2+ideb , valnorm );
579       valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Z();
580       HCOINS->SetValue( 3+ideb , valnorm );
581     }
582   }
583
584 //  tables required for FORTRAN
585   Standard_Integer IORDMX = Max(IORDRU,IORDRV);
586   Handle (TColStd_HArray1OfReal) HEXTR =
587     new TColStd_HArray1OfReal(1,2*IORDMX+2);
588   Standard_Real *EXTR = 
589     (Standard_Real *) &HEXTR ->ChangeArray1()(HEXTR ->Lower());
590   Handle (TColStd_HArray1OfReal) HFACT =
591     new TColStd_HArray1OfReal(1,IORDMX+1);
592   Standard_Real *FACT = 
593     (Standard_Real *) &HFACT ->ChangeArray1()(HFACT ->Lower());
594
595   Standard_Integer idim,ncf0,ncf1,iun=1;
596   Standard_Real *Is;
597
598 // add extremities of isos U
599   for (iu=1;iu<=IORDRU+1;iu++) {
600     ncf0 = HCFU0->Value(HCFU0->Lower()+iu-1);
601     ncf1 = HCFU1->Value(HCFU1->Lower()+iu-1);
602     for (idim=1;idim<=NDIMEN;idim++) {
603       Is = IsoU0 + NCFLMV*(idim-1) + NCFLMV*NDIMEN*(iu-1);
604       AdvApp2Var_MathBase::mmdrc11_(&IORDRV,&iun,&ncf0,Is,EXTR,FACT);
605       for (iv=1;iv<=IORDRV+1;iv++) {
606         ideb = HCOINS->Lower() + NDIMEN*(iu-1)+NDIMEN*(IORDRU+2)*(iv-1) - 1;
607         HCOINS->ChangeValue(idim+ideb) += HEXTR->Value(1+2*(iv-1));
608         HCOINS->ChangeValue(2*SIZE+idim+ideb) += HEXTR->Value(2+2*(iv-1));
609       }
610       Is = IsoU1 + NCFLMV*(idim-1) + NCFLMV*NDIMEN*(iu-1);
611       AdvApp2Var_MathBase::mmdrc11_(&IORDRV,&iun,&ncf1,Is,EXTR,FACT);
612       for (iv=1;iv<=IORDRV+1;iv++) {
613         ideb = HCOINS->Lower() + NDIMEN*(iu-1)+NDIMEN*(IORDRU+2)*(iv-1) - 1;
614         HCOINS->ChangeValue(SIZE+idim+ideb) += HEXTR->Value(1+2*(iv-1));
615         HCOINS->ChangeValue(3*SIZE+idim+ideb) += HEXTR->Value(2+2*(iv-1));
616       }
617     }
618   }
619
620 // add extremities of isos V
621   for (iv=1;iv<=IORDRV+1;iv++) {
622     ncf0 = HCFV0->Value(HCFV0->Lower()+iv-1);
623     ncf1 = HCFV1->Value(HCFV1->Lower()+iv-1);
624     for (idim=1;idim<=NDIMEN;idim++) {
625       Is = IsoV0 + NCFLMU*(idim-1) + NCFLMU*NDIMEN*(iv-1);
626       AdvApp2Var_MathBase::mmdrc11_(&IORDRU,&iun,&ncf0,Is,EXTR,FACT);
627       for (iu=1;iu<=IORDRU+1;iu++) {
628         ideb = HCOINS->Lower() + NDIMEN*(iu-1)+NDIMEN*(IORDRU+2)*(iv-1) - 1;
629         HCOINS->ChangeValue(idim+ideb) += HEXTR->Value(1+2*(iu-1));
630         HCOINS->ChangeValue(SIZE+idim+ideb) += HEXTR->Value(2+2*(iu-1));
631       }
632       Is = IsoV1 + NCFLMU*(idim-1) + NCFLMU*NDIMEN*(iv-1);
633       AdvApp2Var_MathBase::mmdrc11_(&IORDRU,&iun,&ncf1,Is,EXTR,FACT);
634       for (iu=1;iu<=IORDRU+1;iu++) {
635         ideb = HCOINS->Lower() + NDIMEN*(iu-1)+NDIMEN*(IORDRU+2)*(iv-1) - 1;
636         HCOINS->ChangeValue(2*SIZE+idim+ideb) += HEXTR->Value(1+2*(iu-1));
637         HCOINS->ChangeValue(3*SIZE+idim+ideb) += HEXTR->Value(2+2*(iu-1));
638       }
639     }
640   }
641
642 // add all to PATCAN
643   Standard_Real *C1 = 
644     (Standard_Real *) &HCOINS ->ChangeArray1()(HCOINS ->Lower());
645   Standard_Real *C2 = C1 + SIZE;
646   Standard_Real *C3 = C2 + SIZE;
647   Standard_Real *C4 = C3 + SIZE;
648   if ( IORDRU>=0 && IORDRV>=0 ) {
649     AdvApp2Var_ApproxF2var::mma2ac1_(&NDIMEN,&NDegU,&NDegV,&IORDRU,&IORDRV,
650                                      C1,C2,C3,C4,HermU,HermV,PATCAN);
651   }
652 }
653
654 //============================================================================
655 //function : AddErrors
656 //purpose  :
657 //============================================================================
658
659 void AdvApp2Var_Patch::AddErrors(const AdvApp2Var_Framework& Constraints)
660 {
661   Standard_Integer NBSESP = 1, iesp;
662   Standard_Integer iu,iv;
663
664   Standard_Real errU,errV,error,hmax[4];
665   hmax[0] = 0;
666   hmax[1] = 1;
667   hmax[2] = 1.5;
668   hmax[3] = 1.75;
669
670   for (iesp=1;iesp<=NBSESP;iesp++) {
671     //  error max in sub-space iesp
672     errU=0.;
673     for (iv=1;iv<=myOrdInV+1;iv++) {
674       error = ((Constraints.IsoV(myU0,myU1,myV0)).MaxErrors())->Value(iesp,iv);
675       errU = Max(errU,error);
676       error = ((Constraints.IsoV(myU0,myU1,myV1)).MaxErrors())->Value(iesp,iv);
677       errU = Max(errU,error);
678     }
679     errV=0.;
680     for (iu=1;iu<=myOrdInU+1;iu++) {
681       error = ((Constraints.IsoU(myU0,myV0,myV1)).MaxErrors())->Value(iesp,iu);
682       errV = Max(errV,error);
683       error = ((Constraints.IsoU(myU1,myV0,myV1)).MaxErrors())->Value(iesp,iu);
684       errV = Max(errV,error);
685     }
686     myMaxErrors->ChangeValue(iesp) +=
687       errU * hmax[myOrdInV+1]  +  errV * hmax[myOrdInU+1];
688
689     // average error in sub-space iesp
690     errU=0.;
691     for (iv=1;iv<=myOrdInV+1;iv++) {
692       error = ((Constraints.IsoV(myU0,myU1,myV0)).MoyErrors())->Value(iesp,iv);
693       errU = Max(errU,error);
694       error = ((Constraints.IsoV(myU0,myU1,myV1)).MoyErrors())->Value(iesp,iv);
695       errU = Max(errU,error);
696     }
697     errV=0.;
698     for (iu=1;iu<=myOrdInU+1;iu++) {
699       error = ((Constraints.IsoU(myU0,myV0,myV1)).MoyErrors())->Value(iesp,iu);
700       errV = Max(errV,error);
701       error = ((Constraints.IsoU(myU1,myV0,myV1)).MoyErrors())->Value(iesp,iu);
702       errV = Max(errV,error);
703     }
704     error = myMoyErrors->Value(iesp);
705     error *= error;
706     error += errU*hmax[myOrdInV+1] * errU*hmax[myOrdInV+1]
707                    + errV*hmax[myOrdInU+1] * errV*hmax[myOrdInU+1];
708     myMoyErrors->SetValue(iesp,Sqrt(error));
709
710     // max errors at iso-borders
711     Handle (TColStd_HArray2OfReal) HERISO
712       = new TColStd_HArray2OfReal(1,NBSESP,1,4);
713     HERISO->SetValue(iesp,1,
714               ((Constraints.IsoV(myU0,myU1,myV0)).MaxErrors())->Value(iesp,1));
715     HERISO->SetValue(iesp,2,
716               ((Constraints.IsoV(myU0,myU1,myV1)).MaxErrors())->Value(iesp,1));
717     HERISO->SetValue(iesp,3,
718               ((Constraints.IsoU(myU0,myV0,myV1)).MaxErrors())->Value(iesp,1));
719     HERISO->SetValue(iesp,4,
720               ((Constraints.IsoU(myU1,myV0,myV1)).MaxErrors())->Value(iesp,1));
721
722 // calculate max errors at the corners
723     Standard_Real emax1=0.,emax2=0.,emax3=0.,emax4=0.,err1,err2,err3,err4;
724     for (iu=0;iu<=myOrdInU;iu++) {
725       for (iv=0;iv<=myOrdInV;iv++) {
726     error = (Constraints.Node(myU0,myV0))->Error(iu,iv);
727         emax1 = Max(emax1,error);
728     error = (Constraints.Node(myU1,myV0))->Error(iu,iv);
729         emax2 = Max(emax2,error);
730     error = (Constraints.Node(myU0,myV1))->Error(iu,iv);
731         emax3 = Max(emax3,error);
732     error = (Constraints.Node(myU1,myV1))->Error(iu,iv);
733         emax4 = Max(emax4,error);
734       }
735     }
736
737 // calculate max errors on borders
738     err1 = Max(emax1,emax2);
739     err2 = Max(emax3,emax4);
740     err3 = Max(emax1,emax3);
741     err4 = Max(emax2,emax4);
742
743 //   calculate final errors on internal isos
744     if ( (Constraints.IsoV(myU0,myU1,myV0)).Position() == 0 ) {
745       HERISO ->ChangeValue(iesp,1) += err1*hmax[myOrdInU+1];
746     }
747     if ( (Constraints.IsoV(myU0,myU1,myV1)).Position() == 0 ) {
748       HERISO ->ChangeValue(iesp,2) += err2*hmax[myOrdInU+1];
749     }
750     if ( (Constraints.IsoU(myU0,myV0,myV1)).Position() == 0 ) {
751       HERISO ->ChangeValue(iesp,3) += err3*hmax[myOrdInV+1];
752     }
753     if ( (Constraints.IsoU(myU1,myV0,myV1)).Position() == 0 ) {
754       HERISO ->ChangeValue(iesp,4) += err4*hmax[myOrdInV+1];
755     }
756     myIsoErrors = HERISO;
757   }
758 }
759
760 //============================================================================
761 //function : MakeApprox
762 //purpose  :
763 //============================================================================
764
765 void AdvApp2Var_Patch::MakeApprox(const AdvApp2Var_Context& Conditions,
766                                   const AdvApp2Var_Framework& Constraints,
767                                   const Standard_Integer NumDec)
768 {
769
770 // data stored in the Context
771   Standard_Integer NDIMEN, NBSESP, NDIMSE;
772   Standard_Integer NBPNTU, NBPNTV, NCFLMU, NCFLMV, NDJACU, NDJACV;
773   Standard_Integer NDegU, NDegV, NJacU, NJacV;
774   NDIMEN = Conditions.TotalDimension();
775   NBSESP = Conditions.TotalNumberSSP();
776   NDIMSE = 3;
777   NBPNTU = (Conditions.URoots())->Length();
778   if (myOrdInU>-1) NBPNTU -= 2;
779   NBPNTV = (Conditions.VRoots())->Length();
780   if (myOrdInV>-1) NBPNTV -= 2;
781   NCFLMU = Conditions.ULimit();
782   NCFLMV = Conditions.VLimit();
783   NDegU = NCFLMU - 1;
784   NDegV = NCFLMV - 1;
785   NDJACU = Conditions.UJacDeg();
786   NDJACV = Conditions.VJacDeg();
787   NJacU = NDJACU + 1;
788   NJacV = NDJACV + 1;
789
790 // data relative to the processed patch
791   Standard_Integer IORDRU = myOrdInU, IORDRV = myOrdInV,
792                    NDMINU = 1, NDMINV = 1, NCOEFU, NCOEFV;
793 // NDMINU and NDMINV depend on the nb of coeff of neighboring isos
794 // and of the required order of continuity
795   NDMINU = Max(1,2*IORDRU+1);
796   NCOEFU = (Constraints.IsoV(myU0,myU1,myV0)).NbCoeff()-1;
797   NDMINU = Max(NDMINU,NCOEFU);
798   NCOEFU = (Constraints.IsoV(myU0,myU1,myV1)).NbCoeff()-1;
799   NDMINU = Max(NDMINU,NCOEFU);
800
801   NDMINV = Max(1,2*IORDRV+1);
802   NCOEFV = (Constraints.IsoU(myU0,myV0,myV1)).NbCoeff()-1;
803   NDMINV = Max(NDMINV,NCOEFV);
804   NCOEFV = (Constraints.IsoU(myU1,myV0,myV1)).NbCoeff()-1;
805   NDMINV = Max(NDMINV,NCOEFV);
806
807 // tables of approximations
808   Handle (TColStd_HArray1OfReal) HEPSAPR =
809     new TColStd_HArray1OfReal(1,NBSESP);
810   Handle (TColStd_HArray1OfReal) HEPSFRO =
811     new TColStd_HArray1OfReal(1,NBSESP*8);
812   Standard_Integer iesp;
813   for (iesp=1;iesp<=NBSESP;iesp++) {
814     HEPSAPR->SetValue(iesp,(Conditions.IToler())->Value(iesp));
815     HEPSFRO->SetValue(iesp,(Conditions.FToler())->Value(iesp,1));
816     HEPSFRO->SetValue(iesp+NBSESP,(Conditions.FToler())->Value(iesp,2));
817     HEPSFRO->SetValue(iesp+2*NBSESP,(Conditions.FToler())->Value(iesp,3));
818     HEPSFRO->SetValue(iesp+3*NBSESP,(Conditions.FToler())->Value(iesp,4));
819     HEPSFRO->SetValue(iesp+4*NBSESP,(Conditions.CToler())->Value(iesp,1));
820     HEPSFRO->SetValue(iesp+5*NBSESP,(Conditions.CToler())->Value(iesp,2));
821     HEPSFRO->SetValue(iesp+6*NBSESP,(Conditions.CToler())->Value(iesp,3));
822     HEPSFRO->SetValue(iesp+7*NBSESP,(Conditions.CToler())->Value(iesp,4));
823   }
824   Standard_Real *EPSAPR  =
825     (Standard_Real *) &HEPSAPR ->ChangeArray1()(HEPSAPR ->Lower());
826   Standard_Real *EPSFRO  =
827     (Standard_Real *) &HEPSFRO ->ChangeArray1()(HEPSFRO ->Lower());
828
829   Standard_Integer SIZE=(1+NDJACU)*(1+NDJACV)*NDIMEN;
830   Handle (TColStd_HArray1OfReal) HPJAC  =
831     new TColStd_HArray1OfReal(1,SIZE);
832   Standard_Real *PATJAC  =  
833     (Standard_Real *) &HPJAC ->ChangeArray1()(HPJAC ->Lower());
834   SIZE=2*SIZE;
835   Handle (TColStd_HArray1OfReal) HPAUX  =
836     new TColStd_HArray1OfReal(1,SIZE);
837   Standard_Real *PATAUX  =  
838     (Standard_Real *) &HPAUX ->ChangeArray1()(HPAUX ->Lower());
839   SIZE=NCFLMU*NCFLMV*NDIMEN;
840   Handle (TColStd_HArray1OfReal) HPCAN  =
841     new TColStd_HArray1OfReal(1,SIZE);
842   Standard_Real *PATCAN  =  
843     (Standard_Real *) &HPCAN ->ChangeArray1()(HPCAN ->Lower());
844   Handle (TColStd_HArray1OfReal) HERRMAX  =  
845     new TColStd_HArray1OfReal(1,NBSESP);
846   Standard_Real *ERRMAX =
847     (Standard_Real *) &HERRMAX ->ChangeArray1()(HERRMAX ->Lower());
848   Handle (TColStd_HArray1OfReal) HERRMOY  =  
849     new TColStd_HArray1OfReal(1,NBSESP);
850   Standard_Real *ERRMOY =
851     (Standard_Real *) &HERRMOY ->ChangeArray1()(HERRMOY ->Lower());
852
853 // tables of discretization of the square
854   Standard_Real *SOSOTB  =  
855     (Standard_Real *) &mySosoTab ->ChangeArray1()(mySosoTab ->Lower());
856   Standard_Real *DISOTB  =  
857     (Standard_Real *) &myDisoTab ->ChangeArray1()(myDisoTab ->Lower());
858   Standard_Real *SODITB  =  
859     (Standard_Real *) &mySodiTab ->ChangeArray1()(mySodiTab ->Lower());
860   Standard_Real *DIDITB  =  
861     (Standard_Real *) &myDidiTab ->ChangeArray1()(myDidiTab ->Lower());
862
863 //  approximation
864   Standard_Integer ITYDEC=0, IERCOD=0;
865   Standard_Integer iun=1,itrois=3;
866   NCOEFU=0;
867   NCOEFV=0;
868   AdvApp2Var_ApproxF2var::mma2ce1_((integer *)&NumDec,
869                                    &NDIMEN,
870                                    &NBSESP,
871                                    &NDIMSE,
872                                    &NDMINU,
873                                    &NDMINV,
874                                    &NDegU,
875                                    &NDegV,
876                                    &NDJACU,
877                                    &NDJACV,
878                                    &IORDRU,
879                                    &IORDRV,
880                                    &NBPNTU,
881                                    &NBPNTV,
882                                    EPSAPR,
883                                    SOSOTB,
884                                    DISOTB,
885                                    SODITB,
886                                    DIDITB,
887                                    PATJAC,
888                                    ERRMAX,
889                                    ERRMOY,
890                                    &NCOEFU,
891                                    &NCOEFV,
892                                    &ITYDEC,
893                                    &IERCOD);
894
895 // results
896   myCutSense = ITYDEC;
897   if (ITYDEC == 0 && IERCOD<=0) {
898     myHasResult  = Standard_True;
899     myApprIsDone = (IERCOD==0);
900     myNbCoeffInU  = NCOEFU+1;
901     myNbCoeffInV  = NCOEFV+1;
902     myMaxErrors = HERRMAX;
903     myMoyErrors = HERRMOY;
904
905 // Passage to canonic on [-1,1]
906     AdvApp2Var_MathBase::mmfmca9_(&NJacU,&NJacV,&NDIMEN,&myNbCoeffInU,&myNbCoeffInV,
907                                   &NDIMEN,PATJAC,PATJAC);
908     AdvApp2Var_ApproxF2var::mma2can_(&NCFLMU,&NCFLMV,&NDIMEN,
909                                      &myOrdInU,&myOrdInV,&myNbCoeffInU,
910                                      &myNbCoeffInV,
911                                      PATJAC,PATAUX,PATCAN,&IERCOD);
912     if (IERCOD !=0) {
913       throw Standard_ConstructionError("AdvApp2Var_Patch::MakeApprox : Error in FORTRAN");
914     }
915     myEquation = HPCAN;
916
917 // Add constraints and errors
918     AddConstraints(Conditions,Constraints);
919     AddErrors(Constraints);
920
921 // Reduction of degrees if possible
922     PATCAN = (Standard_Real *) 
923       &myEquation->ChangeArray1()(myEquation ->Lower());
924
925     AdvApp2Var_ApproxF2var::mma2fx6_(&NCFLMU,
926                                      &NCFLMV,
927                                      &NDIMEN,
928                                      &NBSESP,
929                                      &itrois,
930                                      &iun,
931                                      &iun,
932                                      &IORDRU,
933                                      &IORDRV,
934                                      EPSAPR,
935                                      EPSFRO,
936                                      PATCAN,
937                                      ERRMAX,
938                                      &myNbCoeffInU,
939                                      &myNbCoeffInV);
940     
941 // transposition (NCFLMU,NCFLMV,NDIMEN)Fortran-C++
942     Standard_Integer aIU, aIN, dim, ii, jj;
943     for (dim=1; dim<=NDIMEN; dim++){
944        aIN = (dim-1)*NCFLMU*NCFLMV;
945        for (ii=1; ii<=NCFLMU; ii++) {
946          aIU = (ii-1)*NDIMEN*NCFLMV;
947          for (jj=1; jj<=NCFLMV; jj++) {
948            HPAUX->SetValue(dim+NDIMEN*(jj-1)+aIU ,
949                            myEquation->Value(ii+NCFLMU*(jj-1)+aIN) );
950          }
951        }
952      }
953     myEquation = HPAUX;
954   } 
955   else { 
956     myApprIsDone = Standard_False;
957     myHasResult  = Standard_False;
958   } 
959 }
960
961 //============================================================================
962 //function : ChangeDomain
963 //purpose  :
964 //============================================================================
965
966 void AdvApp2Var_Patch::ChangeDomain(const Standard_Real a,
967                                     const Standard_Real b,
968                                     const Standard_Real c,
969                                     const Standard_Real d)
970 {
971   myU0 = a;
972   myU1 = b;
973   myV0 = c;
974   myV1 = d;
975 }
976
977 //============================================================================
978 //function : ResetApprox
979 //purpose  : allows removing a result when it is necessary to cut
980 //============================================================================
981
982 void AdvApp2Var_Patch::ResetApprox()
983 {
984   myApprIsDone = Standard_False;
985   myHasResult = Standard_False;
986 }
987
988 //============================================================================
989 //function : OverwriteApprox
990 //purpose  : allows preserving a result even if the precision is not satisfactory
991 //============================================================================
992
993 void AdvApp2Var_Patch::OverwriteApprox()
994 {
995   if (myHasResult) myApprIsDone = Standard_True;
996 }
997
998 //============================================================================
999 //function : U0
1000 //purpose  :
1001 //============================================================================
1002
1003 Standard_Real AdvApp2Var_Patch::U0() const 
1004 {
1005   return myU0;
1006 }
1007
1008 //============================================================================
1009 //function : U1
1010 //purpose  :
1011 //============================================================================
1012
1013 Standard_Real AdvApp2Var_Patch::U1() const 
1014 {
1015   return myU1;
1016 }
1017
1018 //============================================================================
1019 //function : V0
1020 //purpose  :
1021 //============================================================================
1022
1023 Standard_Real AdvApp2Var_Patch::V0() const 
1024 {
1025   return myV0;
1026 }
1027
1028 //============================================================================
1029 //function : V1
1030 //purpose  :
1031 //============================================================================
1032
1033 Standard_Real AdvApp2Var_Patch::V1() const 
1034 {
1035   return myV1;
1036 }
1037
1038 //============================================================================
1039 //function : UOrder
1040 //purpose  : 
1041 //============================================================================
1042
1043 Standard_Integer AdvApp2Var_Patch::UOrder() const 
1044 {
1045   return myOrdInU;
1046 }
1047
1048
1049 //============================================================================
1050 //function : VOrder
1051 //purpose  : 
1052 //============================================================================
1053
1054 Standard_Integer AdvApp2Var_Patch::VOrder() const 
1055 {
1056   return myOrdInV;
1057 }
1058
1059
1060 //============================================================================
1061 //function : CutSense without Critere
1062 //purpose  : 0 : OK; 1 : required cut by U;
1063 //           2 : required cut by V; 3 : required cut by U and by V
1064 //============================================================================
1065
1066 Standard_Integer AdvApp2Var_Patch::CutSense() const 
1067 {
1068   return myCutSense;
1069 }
1070
1071
1072 //============================================================================
1073 //function : CutSense with critere
1074 //purpose  : 0 : OK; 1 : required cut by U;
1075 //           2 : required cut by V; 3 : required cut by U and by V
1076 //============================================================================
1077
1078 Standard_Integer AdvApp2Var_Patch::CutSense(const AdvApp2Var_Criterion& Crit,
1079                                             const Standard_Integer NumDec) const 
1080 {
1081   Standard_Boolean CritRel = (Crit.Type() == AdvApp2Var_Relative);
1082   if ( CritRel && !IsApproximated()) {
1083     return myCutSense;
1084   }
1085   else {
1086     if (Crit.IsSatisfied(*this)) {
1087       return 0;
1088     } 
1089     else {
1090       return NumDec;
1091     } 
1092   }
1093 }
1094
1095
1096 //============================================================================
1097 //function : NbCoeffInU
1098 //purpose  :
1099 //============================================================================
1100
1101 Standard_Integer AdvApp2Var_Patch::NbCoeffInU() const 
1102 {
1103   return myNbCoeffInU;
1104 }
1105
1106 //============================================================================
1107 //function : NbCoeffInV
1108 //purpose  :
1109 //============================================================================
1110
1111 Standard_Integer AdvApp2Var_Patch::NbCoeffInV() const 
1112 {
1113   return myNbCoeffInV;
1114 }
1115
1116 //============================================================================
1117 //function : ChangeNbCoeff
1118 //purpose  : allows increasing the nb of coeff (cf Network)
1119 //============================================================================
1120
1121 void AdvApp2Var_Patch::ChangeNbCoeff(const Standard_Integer NbCoeffU,
1122                                      const Standard_Integer NbCoeffV)
1123 {
1124   if (myNbCoeffInU<NbCoeffU) myNbCoeffInU = NbCoeffU;
1125   if (myNbCoeffInV<NbCoeffV) myNbCoeffInV = NbCoeffV;
1126 }
1127
1128 //============================================================================
1129 //function : MaxErrors
1130 //purpose  : returns max errors of polynomial approximation
1131 //============================================================================
1132
1133 Handle(TColStd_HArray1OfReal) 
1134 AdvApp2Var_Patch::MaxErrors() const 
1135 {
1136   return myMaxErrors;
1137 }
1138
1139 //============================================================================
1140 //function : AverageErrors
1141 //purpose  : returns average errors of polynomial approximation
1142 //============================================================================
1143
1144 Handle(TColStd_HArray1OfReal) 
1145 AdvApp2Var_Patch::AverageErrors() const 
1146 {
1147   return myMoyErrors;
1148 }
1149
1150 //============================================================================
1151 //function : IsoErrors
1152 //purpose  : returns max errors on borders of polynomial approximation
1153 //============================================================================
1154
1155 Handle(TColStd_HArray2OfReal) 
1156 AdvApp2Var_Patch::IsoErrors() const 
1157 {
1158   return myIsoErrors;
1159 }
1160
1161 //============================================================================
1162 //function : Poles
1163 //purpose  : returns poles of the polynomial approximation 
1164 //============================================================================
1165
1166 Handle(TColgp_HArray2OfPnt) 
1167 AdvApp2Var_Patch::Poles(const Standard_Integer SSPIndex,
1168                         const  AdvApp2Var_Context & Cond) const 
1169 {
1170   Handle(TColStd_HArray1OfReal) SousEquation;
1171   if ( Cond.TotalNumberSSP( ) == 1 && SSPIndex == 1 ) {
1172     SousEquation = myEquation;
1173   }
1174   else {
1175     throw Standard_ConstructionError("AdvApp2Var_Patch::Poles :  SSPIndex out of range");
1176   }
1177   Handle(TColStd_HArray1OfReal) Intervalle = 
1178     new (TColStd_HArray1OfReal) (1,2);
1179   Intervalle->SetValue(1, -1);
1180   Intervalle->SetValue(2, 1);
1181
1182
1183   Handle(TColStd_HArray1OfInteger) NbCoeff = 
1184     new (TColStd_HArray1OfInteger) (1,2);
1185   NbCoeff->SetValue(1, myNbCoeffInU);
1186   NbCoeff->SetValue(2, myNbCoeffInV);
1187
1188 // Conversion
1189   Convert_GridPolynomialToPoles 
1190      Conv (Cond.ULimit()-1,
1191            Cond.VLimit()-1,
1192            NbCoeff,
1193            SousEquation,
1194            Intervalle,
1195            Intervalle);
1196
1197   return Conv.Poles();  
1198 }
1199
1200
1201 //============================================================================
1202 //function : Coefficients
1203 //purpose  : returns coeff. of the equation of polynomial approximation
1204 //============================================================================
1205
1206 Handle(TColStd_HArray1OfReal) 
1207 AdvApp2Var_Patch::Coefficients(const Standard_Integer SSPIndex,
1208                                const  AdvApp2Var_Context & Cond) const 
1209 {
1210   Handle(TColStd_HArray1OfReal) SousEquation;
1211   if ( Cond.TotalNumberSSP( ) == 1 && SSPIndex == 1 ) {
1212     SousEquation = myEquation;
1213   }
1214   else {
1215     throw Standard_ConstructionError("AdvApp2Var_Patch::Poles :  SSPIndex out of range");
1216   }
1217   return SousEquation;
1218 }
1219
1220
1221 //============================================================================
1222 //function : CritValue
1223 //purpose  :
1224 //============================================================================
1225
1226 Standard_Real AdvApp2Var_Patch::CritValue() const 
1227 {
1228   return myCritValue;
1229 }
1230
1231
1232 //============================================================================
1233 //function : SetCritValue
1234 //purpose  :
1235 //============================================================================
1236
1237 void AdvApp2Var_Patch::SetCritValue(const Standard_Real dist) 
1238 {
1239   myCritValue = dist;
1240 }
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251