projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0031642: Visualization - crash in Graphic3d_Structure::SetVisual() on redisplaying...
[occt.git] / src / AdvApp2Var / AdvApp2Var_Patch.cxx
CommitLineData
b311480e 1// Created on: 1996-07-02
2// Created by: Joelle CHAUVET
3// Copyright (c) 1996-1999 Matra Datavision
973c2be1 4// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 5//
973c2be1 6// This file is part of Open CASCADE Technology software library.
b311480e 7//
d5f74e42 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
973c2be1 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.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
b311480e 16
7fd59977 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
42cf5bc1 25#include <AdvApp2Var_ApproxF2var.hxx>
26#include <AdvApp2Var_Context.hxx>
27#include <AdvApp2Var_Criterion.hxx>
28#include <AdvApp2Var_Framework.hxx>
7fd59977 29#include <AdvApp2Var_Iso.hxx>
42cf5bc1 30#include <AdvApp2Var_MathBase.hxx>
31#include <AdvApp2Var_Node.hxx>
32#include <AdvApp2Var_Patch.hxx>
33#include <Convert_GridPolynomialToPoles.hxx>
7fd59977 34#include <gp_Pnt.hxx>
42cf5bc1 35#include <Standard_ConstructionError.hxx>
7fd59977 36#include <TColgp_Array2OfPnt.hxx>
42cf5bc1 37#include <TColgp_HArray2OfPnt.hxx>
38#include <TColStd_Array2OfReal.hxx>
7fd59977 39#include <TColStd_HArray1OfInteger.hxx>
40#include <TColStd_HArray1OfReal.hxx>
41#include <TColStd_HArray2OfReal.hxx>
7fd59977 42
158f2931 43IMPLEMENT_STANDARD_RTTIEXT(AdvApp2Var_Patch, Standard_Transient)
44
7fd59977 45//============================================================================
46//function : AdvApp2Var_Patch
47//purpose :
48//============================================================================
7fd59977 49AdvApp2Var_Patch::AdvApp2Var_Patch() :
50myU0(0.),
51myU1(1.),
52myV0(0.),
53myV1(1.),
54myOrdInU(0),
55myOrdInV(0),
7c97b4a3
KS		 56myNbCoeffInU(0),
57myNbCoeffInV(0),
7fd59977 58myApprIsDone(Standard_False),
59myHasResult(Standard_False),
60myCutSense(0),
61myDiscIsDone(Standard_False),
62myCritValue(0.)
63{
64}
65
66//============================================================================
67//function : AdvApp2Var_Patch
68//purpose :
69//============================================================================
70
71AdvApp2Var_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) :
77myU0(U0),
78myU1(U1),
79myV0(V0),
80myV1(V1),
81myOrdInU(iu),
82myOrdInV(iv),
7c97b4a3
KS		 83myNbCoeffInU(0),
84myNbCoeffInV(0),
7fd59977 85myApprIsDone(Standard_False),
86myHasResult(Standard_False),
87myCutSense(0),
88myDiscIsDone(Standard_False),
89myCritValue(0.)
90{
91}
92
93//============================================================================
94//function : IsDiscretised
95//purpose :
96//============================================================================
97
98Standard_Boolean AdvApp2Var_Patch::IsDiscretised() const
99{
100 return myDiscIsDone;
101}
102
103//============================================================================
104//function : Discretise
105//purpose :
106//============================================================================
107
108void AdvApp2Var_Patch::Discretise(const AdvApp2Var_Context& Conditions,
109 const AdvApp2Var_Framework& Constraints,
110 const AdvApp2Var_EvaluatorFunc2Var& Func)
111{
112
0d969553 113// data stored in the Context
96a95605 114 Standard_Integer NDIMEN, ISOFAV;
7fd59977 115 NDIMEN = Conditions.TotalDimension();
0d969553 116// Attention : works only for 3D
7fd59977 117 ISOFAV = Conditions.FavorIso();
118
0d969553 119// data related to the patch to be discretized
7fd59977 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
0d969553
Y		 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)
7fd59977 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++) {
0d969553 145// factor of normalization
7fd59977 146 rho = pow(du,iu)*pow(dv,iv);
147
0d969553 148// F(U0,V0) and its derivatives normalized on (-1,1)
158f2931 149 valnorm = rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).X();
7fd59977 150 HCOINS->SetValue( 1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv , valnorm );
158f2931 151 valnorm = rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Y();
7fd59977 152 HCOINS->SetValue( 2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
158f2931 153 valnorm = rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Z();
7fd59977 154 HCOINS->SetValue( 3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
155
0d969553 156// F(U1,V0) and its derivatives normalized on (-1,1)
158f2931 157 valnorm = rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).X();
7fd59977 158 HCOINS->SetValue( SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
158f2931 159 valnorm = rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Y();
7fd59977 160 HCOINS->SetValue( SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
158f2931 161 valnorm = rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Z();
7fd59977 162 HCOINS->SetValue( SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
163
0d969553 164// F(U0,V1) and its derivatives normalized on (-1,1)
158f2931 165 valnorm = rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).X();
7fd59977 166 HCOINS->SetValue( 2*SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
158f2931 167 valnorm = rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Y();
7fd59977 168 HCOINS->SetValue( 2*SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
158f2931 169 valnorm = rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Z();
7fd59977 170 HCOINS->SetValue( 2*SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
171
0d969553 172// F(U1,V1) and its derivatives normalized on (-1,1)
158f2931 173 valnorm = rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).X();
7fd59977 174 HCOINS->SetValue( 3*SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
158f2931 175 valnorm = rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Y();
7fd59977 176 HCOINS->SetValue( 3*SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
158f2931 177 valnorm = rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Z();
7fd59977 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
0d969553
Y		 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
7fd59977 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
0d969553 213// normalization
7fd59977 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
0d969553
Y		 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
7fd59977 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
0d969553 288// SOSOTB and DIDITB are dimensioned in FORTRAN at
7fd59977 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
0d969553 304// SODITB and DISOTB are dimensioned in FORTRAN at
7fd59977 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
0d969553 322// discretization of polynoms of interpolation
7fd59977 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
0d969553 327// discretization of the square
7fd59977 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
0d969553 365// the results are stored
7fd59977 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
383Standard_Boolean AdvApp2Var_Patch::HasResult() const
384{
385 return myHasResult;
386}
387
388//============================================================================
389//function : IsApproximated
390//purpose :
391//============================================================================
392
393Standard_Boolean AdvApp2Var_Patch::IsApproximated() const
394{
395 return myApprIsDone;
396}
397
398//============================================================================
399//function : AddConstraints
400//purpose :
401//============================================================================
402
403void AdvApp2Var_Patch::AddConstraints(const AdvApp2Var_Context& Conditions,
404 const AdvApp2Var_Framework& Constraints)
405{
0d969553 406// data stored in the Context
96a95605 407 Standard_Integer NDIMEN;
7fd59977 408 Standard_Integer IERCOD, NCFLMU, NCFLMV, NDegU, NDegV;
409 NDIMEN = Conditions.TotalDimension();
0d969553 410// Attention : works only for 3D
7fd59977 411 NCFLMU = Conditions.ULimit();
412 NCFLMV = Conditions.VLimit();
413 NDegU = NCFLMU - 1;
414 NDegV = NCFLMV - 1;
415
0d969553 416// data relative to the patch
7fd59977 417 Standard_Integer IORDRU = myOrdInU, IORDRV = myOrdInV;
418 Standard_Real *PATCAN =
419 (Standard_Real *) &myEquation ->ChangeArray1()(myEquation ->Lower());
420
0d969553 421// curves of approximation of Isos U
7fd59977 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
0d969553 447// normalization of Isos U
7fd59977 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
0d969553 462// curves of approximation of Isos V
7fd59977 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
0d969553 488// normalization of Isos V
7fd59977 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
0d969553 499// add constraints to constant V
7fd59977 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) {
9775fa61 507 throw Standard_ConstructionError("AdvApp2Var_Patch::AddConstraints : Error in FORTRAN");
7fd59977 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
0d969553 522// add constraints to constant U
7fd59977 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) {
9775fa61 530 throw Standard_ConstructionError("AdvApp2Var_Patch::AddConstraints : Error in FORTRAN");
7fd59977 531 }
532 AdvApp2Var_ApproxF2var::mma2ac3_(&NDIMEN,&NDegU,&NDegV,&IORDRU,&NCFLMV,
533 NCFU0,IsoU0,NCFU1,IsoU1,HermU,PATCAN);
534 }
535
0d969553 536// add constraints at the corners
7fd59977 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
0d969553 546// -F(U0,V0) and its derivatives normalized on (-1,1)
7fd59977 547 ideb = HCOINS->Lower() + NDIMEN*iu+NDIMEN*(IORDRU+2)*iv - 1;
158f2931 548 valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).X();
7fd59977 549 HCOINS->SetValue( 1+ideb , valnorm );
158f2931 550 valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Y();
7fd59977 551 HCOINS->SetValue( 2+ideb , valnorm );
158f2931 552 valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Z();
7fd59977 553 HCOINS->SetValue( 3+ideb , valnorm );
554
0d969553 555// -F(U1,V0) and its derivatives normalized on (-1,1)
7fd59977 556 ideb += SIZE;
158f2931 557 valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).X();
7fd59977 558 HCOINS->SetValue( 1+ideb , valnorm );
158f2931 559 valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Y();
7fd59977 560 HCOINS->SetValue( 2+ideb , valnorm );
158f2931 561 valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Z();
7fd59977 562 HCOINS->SetValue( 3+ideb , valnorm );
563
0d969553 564// -F(U0,V1) and its derivatives normalized on (-1,1)
7fd59977 565 ideb += SIZE;
158f2931 566 valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).X();
7fd59977 567 HCOINS->SetValue( 1+ideb , valnorm );
158f2931 568 valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Y();
7fd59977 569 HCOINS->SetValue( 2+ideb , valnorm );
158f2931 570 valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Z();
7fd59977 571 HCOINS->SetValue( 3+ideb , valnorm );
572
0d969553 573// -F(U1,V1) and its derivatives normalized on (-1,1)
7fd59977 574 ideb += SIZE;
158f2931 575 valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).X();
7fd59977 576 HCOINS->SetValue( 1+ideb , valnorm );
158f2931 577 valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Y();
7fd59977 578 HCOINS->SetValue( 2+ideb , valnorm );
158f2931 579 valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Z();
7fd59977 580 HCOINS->SetValue( 3+ideb , valnorm );
581 }
582 }
583
0d969553 584// tables required for FORTRAN
7fd59977 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
0d969553 598// add extremities of isos U
7fd59977 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
0d969553 620// add extremities of isos V
7fd59977 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
0d969553 642// add all to PATCAN
7fd59977 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
659void 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++) {
0d969553 671 // error max in sub-space iesp
7fd59977 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
0d969553 689 // average error in sub-space iesp
7fd59977 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
0d969553 710 // max errors at iso-borders
7fd59977 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
0d969553 722// calculate max errors at the corners
7fd59977 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++) {
158f2931 726 error = (Constraints.Node(myU0,myV0))->Error(iu,iv);
7fd59977 727 emax1 = Max(emax1,error);
158f2931 728 error = (Constraints.Node(myU1,myV0))->Error(iu,iv);
7fd59977 729 emax2 = Max(emax2,error);
158f2931 730 error = (Constraints.Node(myU0,myV1))->Error(iu,iv);
7fd59977 731 emax3 = Max(emax3,error);
158f2931 732 error = (Constraints.Node(myU1,myV1))->Error(iu,iv);
7fd59977 733 emax4 = Max(emax4,error);
734 }
735 }
736
0d969553 737// calculate max errors on borders
7fd59977 738 err1 = Max(emax1,emax2);
739 err2 = Max(emax3,emax4);
740 err3 = Max(emax1,emax3);
741 err4 = Max(emax2,emax4);
742
0d969553 743// calculate final errors on internal isos
7fd59977 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
765void AdvApp2Var_Patch::MakeApprox(const AdvApp2Var_Context& Conditions,
766 const AdvApp2Var_Framework& Constraints,
767 const Standard_Integer NumDec)
768{
769
0d969553 770// data stored in the Context
7fd59977 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
0d969553 790// data relative to the processed patch
7fd59977 791 Standard_Integer IORDRU = myOrdInU, IORDRV = myOrdInV,
792 NDMINU = 1, NDMINV = 1, NCOEFU, NCOEFV;
0d969553
Y		 793// NDMINU and NDMINV depend on the nb of coeff of neighboring isos
794// and of the required order of continuity
7fd59977 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
0d969553 807// tables of approximations
7fd59977 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
0d969553 853// tables of discretization of the square
7fd59977 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
0d969553 895// results
7fd59977 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
0d969553 905// Passage to canonic on [-1,1]
7fd59977 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) {
9775fa61 913 throw Standard_ConstructionError("AdvApp2Var_Patch::MakeApprox : Error in FORTRAN");
7fd59977 914 }
915 myEquation = HPCAN;
916
0d969553 917// Add constraints and errors
7fd59977 918 AddConstraints(Conditions,Constraints);
919 AddErrors(Constraints);
920
0d969553 921// Reduction of degrees if possible
7fd59977 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
966void 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
0d969553 979//purpose : allows removing a result when it is necessary to cut
7fd59977 980//============================================================================
981
982void AdvApp2Var_Patch::ResetApprox()
983{
984 myApprIsDone = Standard_False;
985 myHasResult = Standard_False;
986}
987
988//============================================================================
989//function : OverwriteApprox
0d969553 990//purpose : allows preserving a result even if the precision is not satisfactory
7fd59977 991//============================================================================
992
993void AdvApp2Var_Patch::OverwriteApprox()
994{
995 if (myHasResult) myApprIsDone = Standard_True;
996}
997
998//============================================================================
999//function : U0
1000//purpose :
1001//============================================================================
1002
1003Standard_Real AdvApp2Var_Patch::U0() const
1004{
1005 return myU0;
1006}
1007
1008//============================================================================
1009//function : U1
1010//purpose :
1011//============================================================================
1012
1013Standard_Real AdvApp2Var_Patch::U1() const
1014{
1015 return myU1;
1016}
1017
1018//============================================================================
1019//function : V0
1020//purpose :
1021//============================================================================
1022
1023Standard_Real AdvApp2Var_Patch::V0() const
1024{
1025 return myV0;
1026}
1027
1028//============================================================================
1029//function : V1
1030//purpose :
1031//============================================================================
1032
1033Standard_Real AdvApp2Var_Patch::V1() const
1034{
1035 return myV1;
1036}
1037
1038//============================================================================
1039//function : UOrder
1040//purpose :
1041//============================================================================
1042
1043Standard_Integer AdvApp2Var_Patch::UOrder() const
1044{
1045 return myOrdInU;
1046}
1047
1048
1049//============================================================================
1050//function : VOrder
1051//purpose :
1052//============================================================================
1053
1054Standard_Integer AdvApp2Var_Patch::VOrder() const
1055{
1056 return myOrdInV;
1057}
1058
1059
1060//============================================================================
0d969553
Y		 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
7fd59977 1064//============================================================================
1065
1066Standard_Integer AdvApp2Var_Patch::CutSense() const
1067{
1068 return myCutSense;
1069}
1070
1071
1072//============================================================================
0d969553
Y		 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
7fd59977 1076//============================================================================
1077
1078Standard_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
1101Standard_Integer AdvApp2Var_Patch::NbCoeffInU() const
1102{
1103 return myNbCoeffInU;
1104}
1105
1106//============================================================================
1107//function : NbCoeffInV
1108//purpose :
1109//============================================================================
1110
1111Standard_Integer AdvApp2Var_Patch::NbCoeffInV() const
1112{
1113 return myNbCoeffInV;
1114}
1115
1116//============================================================================
1117//function : ChangeNbCoeff
0d969553 1118//purpose : allows increasing the nb of coeff (cf Network)
7fd59977 1119//============================================================================
1120
1121void 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
0d969553 1130//purpose : returns max errors of polynomial approximation
7fd59977 1131//============================================================================
1132
1133Handle(TColStd_HArray1OfReal)
1134AdvApp2Var_Patch::MaxErrors() const
1135{
1136 return myMaxErrors;
1137}
1138
1139//============================================================================
1140//function : AverageErrors
0d969553 1141//purpose : returns average errors of polynomial approximation
7fd59977 1142//============================================================================
1143
1144Handle(TColStd_HArray1OfReal)
1145AdvApp2Var_Patch::AverageErrors() const
1146{
1147 return myMoyErrors;
1148}
1149
1150//============================================================================
1151//function : IsoErrors
0d969553 1152//purpose : returns max errors on borders of polynomial approximation
7fd59977 1153//============================================================================
1154
1155Handle(TColStd_HArray2OfReal)
1156AdvApp2Var_Patch::IsoErrors() const
1157{
1158 return myIsoErrors;
1159}
1160
1161//============================================================================
1162//function : Poles
0d969553 1163//purpose : returns poles of the polynomial approximation
7fd59977 1164//============================================================================
1165
1166Handle(TColgp_HArray2OfPnt)
1167AdvApp2Var_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 {
9775fa61 1175 throw Standard_ConstructionError("AdvApp2Var_Patch::Poles : SSPIndex out of range");
7fd59977 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
0d969553 1203//purpose : returns coeff. of the equation of polynomial approximation
7fd59977 1204//============================================================================
1205
1206Handle(TColStd_HArray1OfReal)
1207AdvApp2Var_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 {
9775fa61 1215 throw Standard_ConstructionError("AdvApp2Var_Patch::Poles : SSPIndex out of range");
7fd59977 1216 }
1217 return SousEquation;
1218}
1219
1220
1221//============================================================================
1222//function : CritValue
1223//purpose :
1224//============================================================================
1225
1226Standard_Real AdvApp2Var_Patch::CritValue() const
1227{
1228 return myCritValue;
1229}
1230
1231
1232//============================================================================
1233//function : SetCritValue
1234//purpose :
1235//============================================================================
1236
1237void AdvApp2Var_Patch::SetCritValue(const Standard_Real dist)
1238{
1239 myCritValue = dist;
1240}
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
Open CASCADE Technology repository