0022922: Clean up warnings on uninitialized / unused variables
[occt.git] / src / IntPatch / IntPatch_Polyhedron.cxx
CommitLineData
7fd59977 1// File: IntPatch_Polyhedron.cxx
2// Created: Wed Feb 3 11:33:09 1993
3// Author: Laurent BUCHARD
4// Copyright: OPEN CASCADE 1993
5
6#include <IntPatch_Polyhedron.ixx>
7
8#include <IntPatch_HInterTool.hxx>
9
10#include <gp_Pnt.hxx>
11#include <gp_Vec.hxx>
12#include <TColgp_Array2OfPnt.hxx>
13#include <TColStd_Array2OfReal.hxx>
14#include <Bnd_Array1OfBox.hxx>
15#include <Standard_ConstructionError.hxx>
16#include <Precision.hxx>
17#include <stdio.h>
18
19#define MSG_DEBUG 0
20
21#define LONGUEUR_MINI_EDGE_TRIANGLE 1e-14
22#define DEFLECTION_COEFF 1.1
23#define NBMAXUV 30
24
25//================================================================================
26static Standard_Integer NbPOnU (const Handle(Adaptor3d_HSurface)& S)
27{
28 const Standard_Real u0 = S->FirstUParameter();
29 const Standard_Real u1 = S->LastUParameter();
30 const Standard_Integer nbpu = IntPatch_HInterTool::NbSamplesU(S,u0,u1);
31 return (nbpu>NBMAXUV? NBMAXUV : nbpu);
32}
33//================================================================================
34static Standard_Integer NbPOnV (const Handle(Adaptor3d_HSurface)& S)
35{
36 const Standard_Real v0 = S->FirstVParameter();
37 const Standard_Real v1 = S->LastVParameter();
38 const Standard_Integer nbpv = IntPatch_HInterTool::NbSamplesV(S,v0,v1);
39 return (nbpv>NBMAXUV? NBMAXUV : nbpv);
40}
41
42//=======================================================================
43//function : Destroy
44//purpose :
45//=======================================================================
46void IntPatch_Polyhedron::Destroy()
47{
48 gp_Pnt *CMyPnts = (gp_Pnt *)C_MyPnts; if(C_MyPnts) delete [] CMyPnts;
49 Standard_Real *CMyU = (Standard_Real *)C_MyU; if(C_MyU) delete [] CMyU;
50 Standard_Real *CMyV = (Standard_Real *)C_MyV; if(C_MyV) delete [] CMyV;
51 C_MyPnts=C_MyU=C_MyV=NULL;
52}
53
54//=======================================================================
55//function : IntPatch_Polyhedron
56//purpose :
57//=======================================================================
58IntPatch_Polyhedron::IntPatch_Polyhedron (const Handle(Adaptor3d_HSurface)& Surface)
59 : TheDeflection(Epsilon(100.)),
60 nbdeltaU(NbPOnU(Surface)),
61 nbdeltaV(NbPOnV(Surface)),
62 C_MyPnts(NULL),C_MyU(NULL),C_MyV(NULL),
63 UMinSingular(IntPatch_HInterTool::SingularOnVMin(Surface)),
64 UMaxSingular(IntPatch_HInterTool::SingularOnVMin(Surface)),
65 VMinSingular(IntPatch_HInterTool::SingularOnVMin(Surface)),
66 VMaxSingular(IntPatch_HInterTool::SingularOnVMin(Surface))
67{
68 const Standard_Integer t = (nbdeltaU+1)*(nbdeltaV+1)+1;
69 gp_Pnt *CMyPnts = new gp_Pnt[t];
70 Standard_Real *CMyU = new Standard_Real[t];
71 Standard_Real *CMyV = new Standard_Real[t];
72 C_MyPnts = CMyPnts;
73 C_MyU = CMyU;
74 C_MyV = CMyV;
75
76 const Standard_Real u0 = Surface->FirstUParameter();
77 const Standard_Real u1 = Surface->LastUParameter();
78 const Standard_Real v0 = Surface->FirstVParameter();
79 const Standard_Real v1 = Surface->LastVParameter();
80
81 const Standard_Real U1mU0sNbdeltaU = (u1-u0)/(Standard_Real)nbdeltaU;
82 const Standard_Real V1mV0sNbdeltaV = (v1-v0)/(Standard_Real)nbdeltaV;
83
84 gp_Pnt TP;
85 Standard_Real U,V;
86 Standard_Integer i1, i2, Index=1;
87 for (i1 = 0, U = u0; i1 <= nbdeltaU; i1++, U+= U1mU0sNbdeltaU) {
88 for (i2 = 0, V = v0; i2 <= nbdeltaV; i2++, V+= V1mV0sNbdeltaV ) {
89 Surface->D0(U,V,TP);
90 CMyPnts[Index] = TP;
91 CMyU[Index] = U;
92 CMyV[Index] = V;
93 TheBnd.Add(TP);
94 Index++;
95 }
96 }
97
98 Standard_Real tol=0.0;
99 const Standard_Integer nbtriangles = NbTriangles();
100 for (i1=1; i1<=nbtriangles; i1++) {
101 const Standard_Real tol1 = DeflectionOnTriangle(Surface,i1);
102 if(tol1>tol) tol=tol1;
103 }
104
105 tol*=DEFLECTION_COEFF;
106
107 DeflectionOverEstimation(tol);
108 FillBounding();
109}
110
111//=======================================================================
112//function : IntPatch_Polyhedron
113//purpose :
114//=======================================================================
115IntPatch_Polyhedron::IntPatch_Polyhedron (const Handle(Adaptor3d_HSurface)& Surface,
116 const Standard_Integer nbu,
117 const Standard_Integer nbv)
118: TheDeflection(Epsilon(100.)),
119 nbdeltaU(nbu),
120 nbdeltaV(nbv),
121 C_MyPnts(NULL),C_MyU(NULL),C_MyV(NULL),
122 UMinSingular(IntPatch_HInterTool::SingularOnVMin(Surface)),
123 UMaxSingular(IntPatch_HInterTool::SingularOnVMin(Surface)),
124 VMinSingular(IntPatch_HInterTool::SingularOnVMin(Surface)),
125 VMaxSingular(IntPatch_HInterTool::SingularOnVMin(Surface))
126{
127 const Standard_Integer t = (nbdeltaU+1)*(nbdeltaV+1)+1;
128 gp_Pnt *CMyPnts = new gp_Pnt[t];
129 Standard_Real *CMyU = new Standard_Real[t];
130 Standard_Real *CMyV = new Standard_Real[t];
131 C_MyPnts = CMyPnts;
132 C_MyU = CMyU;
133 C_MyV = CMyV;
134
135 const Standard_Real u0 = Surface->FirstUParameter();
136 const Standard_Real u1 = Surface->LastUParameter();
137 const Standard_Real v0 = Surface->FirstVParameter();
138 const Standard_Real v1 = Surface->LastVParameter();
139
140 const Standard_Real U1mU0sNbdeltaU = (u1-u0)/(Standard_Real)nbdeltaU;
141 const Standard_Real V1mV0sNbdeltaV = (v1-v0)/(Standard_Real)nbdeltaV;
142
143 gp_Pnt TP;
144 Standard_Real U,V;
145 Standard_Integer i1, i2, Index=1;
146 for (i1 = 0, U = u0; i1 <= nbdeltaU; i1++, U+= U1mU0sNbdeltaU) {
147 for (i2 = 0, V = v0; i2 <= nbdeltaV; i2++, V+= V1mV0sNbdeltaV ) {
148 Surface->D0(U,V,TP);
149 CMyPnts[Index] = TP;
150 CMyU[Index] = U;
151 CMyV[Index] = V;
152 TheBnd.Add(TP);
153 Index++;
154 }
155 }
156
157 Standard_Real tol=0.0;
158 const Standard_Integer nbtriangles = NbTriangles();
159 for (i1=1; i1<=nbtriangles; i1++) {
160 const Standard_Real tol1 = DeflectionOnTriangle(Surface,i1);
161 if(tol1>tol) tol=tol1;
162 }
163
164 tol*=DEFLECTION_COEFF;
165
166 DeflectionOverEstimation(tol);
167 FillBounding();
168}
169
170
171//=======================================================================
172//function : DeflectionOnTriangle
173//purpose :
174//=======================================================================
175
176Standard_Real IntPatch_Polyhedron::DeflectionOnTriangle
177 (const Handle(Adaptor3d_HSurface)& Surface,
178 const Standard_Integer Triang) const
179{
180 Standard_Integer i1,i2,i3;
181
182 Triangle(Triang,i1,i2,i3);
183 //-- Calcul de l eqution du plan
184 Standard_Real u1,v1,u2,v2,u3,v3;
185 gp_Pnt P1,P2,P3;
186 P1 = Point(i1,u1,v1);
187 P2 = Point(i2,u2,v2);
188 P3 = Point(i3,u3,v3);
189 if(P1.SquareDistance(P2)<=LONGUEUR_MINI_EDGE_TRIANGLE) return(0);
190 if(P1.SquareDistance(P3)<=LONGUEUR_MINI_EDGE_TRIANGLE) return(0);
191 if(P2.SquareDistance(P3)<=LONGUEUR_MINI_EDGE_TRIANGLE) return(0);
192 gp_XYZ XYZ1=P2.XYZ()-P1.XYZ();
193 gp_XYZ XYZ2=P3.XYZ()-P2.XYZ();
194 gp_XYZ XYZ3=P1.XYZ()-P3.XYZ();
195 gp_Vec NormalVector((XYZ1^XYZ2)+(XYZ2^XYZ3)+(XYZ3^XYZ1));
196 NormalVector.Normalize();
7fd59977 197 //-- Calcul du point u,v au centre du triangle
198 Standard_Real u = (u1+u2+u3)/3.0;
199 Standard_Real v = (v1+v2+v3)/3.0;
200 gp_Vec P1P(P1,Surface->Value(u,v));
201 return(Abs(P1P.Dot(NormalVector)));
202}
203
204//=======================================================================
205//function : Parameters
206//purpose :
207//=======================================================================
208void IntPatch_Polyhedron::Parameters( const Standard_Integer Index
209 ,Standard_Real &U
210 ,Standard_Real &V) const
211{
212 U = ((Standard_Real *)C_MyU)[Index];
213 V = ((Standard_Real *)C_MyV)[Index];
214}
215
216//=======================================================================
217//function : DeflectionOverEstimation
218//purpose :
219//=======================================================================
220void IntPatch_Polyhedron::DeflectionOverEstimation(const Standard_Real flec)
221{
222 if(flec<0.0001) {
223 TheDeflection=0.0001;
224 TheBnd.Enlarge(0.0001);
225 }
226 else {
227 TheDeflection=flec;
228 TheBnd.Enlarge(flec);
229 }
230}
231
232//=======================================================================
233//function : DeflectionOverEstimation
234//purpose :
235//=======================================================================
236Standard_Real IntPatch_Polyhedron::DeflectionOverEstimation() const
237{
238 return TheDeflection;
239}
240
241//=======================================================================
242//function : Bounding
243//purpose :
244//=======================================================================
245const Bnd_Box& IntPatch_Polyhedron::Bounding() const
246{
247 return TheBnd;
248}
249
250//=======================================================================
251//function : FillBounding
252//purpose :
253//=======================================================================
254void IntPatch_Polyhedron::FillBounding()
255{
256 TheComponentsBnd=new Bnd_HArray1OfBox(1, NbTriangles());
257 Bnd_Box Boite;
258 Standard_Integer p1, p2, p3;
259 Standard_Integer nbtriangles = NbTriangles();
260 for (Standard_Integer iTri=1; iTri<=nbtriangles; iTri++) {
261 Triangle(iTri, p1, p2, p3);
262 Boite.SetVoid();
263 const gp_Pnt& P1 = Point(p1);
264 const gp_Pnt& P2 = Point(p2);
265 const gp_Pnt& P3 = Point(p3);
266 if(P1.SquareDistance(P2)>LONGUEUR_MINI_EDGE_TRIANGLE) {
267 if(P1.SquareDistance(P3)>LONGUEUR_MINI_EDGE_TRIANGLE) {
268 if(P2.SquareDistance(P3)>LONGUEUR_MINI_EDGE_TRIANGLE) {
269 Boite.Add(P1);
270 Boite.Add(P2);
271 Boite.Add(P3);
272 }
273 }
274 }
275 Boite.Enlarge(TheDeflection);
276 TheComponentsBnd->SetValue(iTri,Boite);
277 }
278}
279
280//=======================================================================
281//function : ComponentsBounding
282//purpose :
283//=======================================================================
284const Handle(Bnd_HArray1OfBox)& IntPatch_Polyhedron::ComponentsBounding () const
285{
286 return TheComponentsBnd;
287}
288
289//=======================================================================
290//function : NbTriangles
291//purpose :
292//=======================================================================
293Standard_Integer IntPatch_Polyhedron::NbTriangles () const
294{
295 return nbdeltaU*nbdeltaV*2;
296}
297
298//=======================================================================
299//function : NbPoints
300//purpose :
301//=======================================================================
302Standard_Integer IntPatch_Polyhedron::NbPoints () const
303{
304 return (nbdeltaU+1)*(nbdeltaV+1);
305}
306
307//=======================================================================
308//function : TriConnex
309//purpose :
310//=======================================================================
311Standard_Integer IntPatch_Polyhedron::TriConnex (const Standard_Integer Triang,
312 const Standard_Integer Pivot,
313 const Standard_Integer Pedge,
314 Standard_Integer& TriCon,
315 Standard_Integer& OtherP) const {
316
7fd59977 317 Standard_Integer Pivotm1 = Pivot-1;
318 Standard_Integer nbdeltaVp1 = nbdeltaV+1;
319 Standard_Integer nbdeltaVm2 = nbdeltaV + nbdeltaV;
320
321// Pivot position in the MaTriangle :
322 Standard_Integer ligP = Pivotm1/nbdeltaVp1;
323 Standard_Integer colP = Pivotm1 - ligP * nbdeltaVp1;
324
325// Point sur Edge position in the MaTriangle and edge typ :
326#ifndef DEB
327 Standard_Integer ligE = 0, colE = 0, typE = 0;
328#else
329 Standard_Integer ligE, colE, typE;
330#endif
331 if (Pedge!=0) {
332 ligE= (Pedge-1)/nbdeltaVp1;
333 colE= (Pedge-1) - (ligE * nbdeltaVp1);
334 // Horizontal
335 if (ligP==ligE) typE=1;
336 // Vertical
337 else if (colP==colE) typE=2;
338 // Oblique
339 else typE=3;
340 }
341 else {
342 typE=0;
343 }
344
345// Triangle position General case :
346#ifndef DEB
347 Standard_Integer linT = 0, colT = 0;
348 Standard_Integer linO = 0, colO = 0;
349#else
350 Standard_Integer linT, colT;
351 Standard_Integer linO, colO;
352#endif
353 Standard_Integer t,tt;
354 if (Triang!=0) {
355 t = (Triang-1)/(nbdeltaVm2);
356 tt= (Triang-1)-t*nbdeltaVm2;
357 linT= 1+t;
358 colT= 1+tt;
359 if (typE==0) {
360 if (ligP==linT) {
361 ligE=ligP-1;
362 colE=colP-1;
363 typE=3;
364 }
365 else {
366 if (colT==ligP+ligP) {
367 ligE=ligP;
368 colE=colP-1;
369 typE=1;
370 }
371 else {
372 ligE=ligP+1;
373 colE=colP+1;
374 typE=3;
375 }
376 }
377 }
378 switch (typE) {
379 case 1: // Horizontal
380 if (linT==ligP) {
381 linT++;
382 linO=ligP+1;
383 colO=(colP>colE)? colP : colE; //--colO=Max(colP, colE);
384 }
385 else {
386 linT--;
387 linO=ligP-1;
388 colO=(colP<colE)? colP : colE; //--colO=Min(colP, colE);
389 }
390 break;
391 case 2: // Vertical
392 if (colT==(colP+colP)) {
393 colT++;
394 linO=(ligP>ligE)? ligP : ligE; //--linO=Max(ligP, ligE);
395 colO=colP+1;;
396 }
397 else {
398 colT--;
399 linO=(ligP<ligE)? ligP : ligE; //--linO=Min(ligP, ligE);
400 colO=colP-1;;
401 }
402 break;
403 case 3: // Oblique
404 if ((colT&1)==0) {
405 colT--;
406 linO=(ligP>ligE)? ligP : ligE; //--linO=Max(ligP, ligE);
407 colO=(colP<colE)? colP : colE; //--colO=Min(colP, colE);
408 }
409 else {
410 colT++;
411 linO=(ligP<ligE)? ligP : ligE; //--linO=Min(ligP, ligE);
412 colO=(colP>colE)? colP : colE; //--colO=Max(colP, colE);
413 }
414 break;
415 }
416 }
417 else {
418 // Unknown Triangle position :
419 if (Pedge==0) {
420 // Unknown edge :
421 linT=(1>ligP)? 1 : ligP; //--linT=Max(1, ligP);
422 colT=(1>(colP+colP))? 1 : (colP+colP); //--colT=Max(1, colP+colP);
423 if (ligP==0) linO=ligP+1;
424 else linO=ligP-1;
425 colO=colP;
426 }
427 else {
428 // Known edge We take the left or down connectivity :
429 switch (typE) {
430 case 1: // Horizontal
431 linT=ligP+1;
432 colT=(colP>colE)? colP : colE; //--colT=Max(colP,colE);
433 colT+=colT;
434 linO=ligP+1;
435 colO=(colP>colE)? colP : colE; //--colO=Max(colP,colE);
436 break;
437 case 2: // Vertical
438 linT=(ligP>ligE)? ligP : ligE; //--linT=Max(ligP, ligE);
439 colT=colP+colP;
440 linO=(ligP<ligE)? ligP : ligE; //--linO=Min(ligP, ligE);
441 colO=colP-1;
442 break;
443 case 3: // Oblique
444 linT=(ligP>ligE)? ligP : ligE; //--linT=Max(ligP, ligE);
445 colT=colP+colE;
446 linO=(ligP>ligE)? ligP : ligE; //--linO=Max(ligP, ligE);
447 colO=(colP<colE)? colP : colE; //--colO=Min(colP, colE);
448 break;
449 }
450 }
451 }
452
453 TriCon=(linT-1)*nbdeltaVm2 + colT;
454
455 if (linT<1) {
456 linO=0;
457 colO=colP+colP-colE;
458 if (colO<0) {colO=0;linO=1;}
459 else if (colO>nbdeltaV) {colO=nbdeltaV;linO=1;}
460 TriCon=0;
461 }
462 else if (linT>nbdeltaU) {
463 linO=nbdeltaU;
464 colO=colP+colP-colE;
465 if (colO<0) {colO=0;linO=nbdeltaU-1;}
466 else if (colO>nbdeltaV) {colO=nbdeltaV;linO=nbdeltaU-1;}
467 TriCon=0;
468 }
469
470 if (colT<1) {
471 colO=0;
472 linO=ligP+ligP-ligE;
473 if (linO<0) {linO=0;colO=1;}
474 else if (linO>nbdeltaU) {linO=nbdeltaU;colO=1;}
475 TriCon=0;
476 }
477 else if (colT>nbdeltaV) {
478 colO=nbdeltaV;
479 linO=ligP+ligP-ligE;
480 if (linO<0) {linO=0;colO=nbdeltaV-1;}
481 else if (linO>nbdeltaU) {linO=nbdeltaU;colO=nbdeltaV-1;}
482 TriCon=0;
483 }
484
485 OtherP=linO*nbdeltaVp1 + colO+1;
486
487
488 //----------------------------------------------------
489 //-- Detection des cas ou le triangle retourne est
490 //-- invalide. Dans ce cas, on retourne le triangle
491 //-- suivant par un nouvel appel a TriConnex.
492 //--
493 //-- Si En entree : Point(Pivot)==Point(Pedge)
494 //-- Alors on retourne OtherP a 0
495 //-- et Tricon = Triangle
496 //--
497 if(Point(Pivot).SquareDistance(Point(Pedge))<=LONGUEUR_MINI_EDGE_TRIANGLE) {
498 OtherP=0;
499 TriCon=Triang;
500#if MSG_DEBUG
501 cout<<" Probleme ds IntCurveSurface_Polyhedron : Pivot et PEdge Confondus "<<endl;
502#endif
503 return(TriCon);
504 }
505 if(Point(OtherP).SquareDistance(Point(Pedge))<=LONGUEUR_MINI_EDGE_TRIANGLE) {
506#if MSG_DEBUG
507 cout<<" Probleme ds IntCurveSurface_Polyhedron : OtherP et PEdge Confondus "<<endl;
508#endif
509 Standard_Integer TempTri,TempOtherP;
510 TempTri = TriCon;
511 TempOtherP = OtherP;
512
513 return(0); //-- BUG NON CORRIGE ( a revoir le role de nbdeltaU et nbdeltaV)
514
515 return(TriConnex(TempTri,Pivot,TempOtherP,TriCon,OtherP));
516 }
517 return TriCon;
518}
519
520
521
522//=======================================================================
523//function : PlaneEquation
524//purpose :
525//=======================================================================
526
527void IntPatch_Polyhedron::PlaneEquation (const Standard_Integer Triang,
528 gp_XYZ& NormalVector,
529 Standard_Real& PolarDistance) const
530{
531 Standard_Integer i1,i2,i3;
532 Triangle(Triang,i1,i2,i3);
533
534 gp_XYZ Pointi1(Point(i1).XYZ());
535 gp_XYZ Pointi2(Point(i2).XYZ());
536 gp_XYZ Pointi3(Point(i3).XYZ());
537
538
539 gp_XYZ v1= Pointi2 - Pointi1;
540 gp_XYZ v2= Pointi3 - Pointi2;
541 gp_XYZ v3= Pointi1 - Pointi3;
542
543 if(v1.SquareModulus()<=LONGUEUR_MINI_EDGE_TRIANGLE) { NormalVector.SetCoord(1.0,0.0,0.0); return; }
544 if(v2.SquareModulus()<=LONGUEUR_MINI_EDGE_TRIANGLE) { NormalVector.SetCoord(1.0,0.0,0.0); return; }
545 if(v3.SquareModulus()<=LONGUEUR_MINI_EDGE_TRIANGLE) { NormalVector.SetCoord(1.0,0.0,0.0); return; }
546
547 NormalVector= (v1^v2)+(v2^v3)+(v3^v1);
548 NormalVector.Normalize();
549 PolarDistance = NormalVector * Point(i1).XYZ();
550}
551//=======================================================================
552//function : Contain
553//purpose :
554//=======================================================================
555Standard_Boolean IntPatch_Polyhedron::Contain (const Standard_Integer Triang,
556 const gp_Pnt& ThePnt) const
557{
558 Standard_Integer i1,i2,i3;
559 Triangle(Triang,i1,i2,i3);
560 gp_XYZ Pointi1(Point(i1).XYZ());
561 gp_XYZ Pointi2(Point(i2).XYZ());
562 gp_XYZ Pointi3(Point(i3).XYZ());
563
564 gp_XYZ v1=(Pointi2-Pointi1)^(ThePnt.XYZ()-Pointi1);
565 gp_XYZ v2=(Pointi3-Pointi2)^(ThePnt.XYZ()-Pointi2);
566 gp_XYZ v3=(Pointi1-Pointi3)^(ThePnt.XYZ()-Pointi3);
567 if (v1*v2 >= 0. && v2*v3 >= 0. && v3*v1>=0.)
568 return Standard_True;
569 else
570 return Standard_False;
571}
572//=======================================================================
573//function : Dump
574//purpose :
575//=======================================================================
576
577void IntPatch_Polyhedron::Dump()const
578{
579}
580//=======================================================================
581//function : Size
582//purpose :
583//=======================================================================
584void IntPatch_Polyhedron::Size(Standard_Integer& nbdu,
585 Standard_Integer& nbdv) const
586{
587 nbdu=nbdeltaU;
588 nbdv=nbdeltaV;
589}
590//=======================================================================
591//function : Triangle
592//purpose :
593//=======================================================================
594void IntPatch_Polyhedron::Triangle (const Standard_Integer Index,
595 Standard_Integer& P1,
596 Standard_Integer& P2,
597 Standard_Integer& P3) const
598{
599 Standard_Integer line=1+((Index-1)/(nbdeltaV*2));
600 Standard_Integer colon=1+((Index-1)%(nbdeltaV*2));
601 Standard_Integer colpnt=(colon+1)/2;
602
603// General formula = (line-1)*(nbdeltaV+1)+colpnt
604
605// Position of P1 = MesXYZ(line,colpnt);
606 P1= (line-1)*(nbdeltaV+1) + colpnt;
607
608// Position of P2= MesXYZ(line+1,colpnt+((colon-1)%2));
609 P2= line*(nbdeltaV+1) + colpnt+((colon-1)%2);
610
611// Position of P3= MesXYZ(line+(colon%2),colpnt+1);
612 P3= (line-1+(colon%2))*(nbdeltaV+1) + colpnt + 1;
613 //-- printf("\nTriangle %4d P1:%4d P2:%4d P3:%4d",Index,P1,P2,P3);
614}
615//=======================================================================
616//function : Point
617//=======================================================================
618const gp_Pnt& IntPatch_Polyhedron::Point( const Standard_Integer Index
619 ,Standard_Real& U
620 ,Standard_Real& V) const
621{
622 gp_Pnt *CMyPnts = (gp_Pnt *)C_MyPnts;
623 Standard_Real *CMyU = (Standard_Real *)C_MyU;
624 Standard_Real *CMyV = (Standard_Real *)C_MyV;
625 U=CMyU[Index];
626 V=CMyV[Index];
627 return CMyPnts[Index];
628}
629//=======================================================================
630//function : Point
631//=======================================================================
632const gp_Pnt& IntPatch_Polyhedron::Point(const Standard_Integer Index) const {
633 gp_Pnt *CMyPnts = (gp_Pnt *)C_MyPnts;
634 return CMyPnts[Index];
635}
636
637//=======================================================================
638//function : Point
639//=======================================================================
640void IntPatch_Polyhedron::Point (const gp_Pnt& /*p*/,
641 const Standard_Integer /*lig*/,
642 const Standard_Integer /*col*/,
643 const Standard_Real /*u*/,
644 const Standard_Real /*v*/)
645{
646 //printf("\n IntPatch_Polyhedron::Point : Ne dois pas etre appelle\n");
647}
648
649//=======================================================================
650//function : Point
651//=======================================================================
652void IntPatch_Polyhedron::Point (const Standard_Integer Index, gp_Pnt& P) const
653{
654 gp_Pnt *CMyPnts = (gp_Pnt *)C_MyPnts;
655 P = CMyPnts[Index];
656}
657//=======================================================================