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