0024510: Remove unused local variables
[occt.git] / src / IntPatch / IntPatch_Polyhedron.cxx
CommitLineData
b311480e 1// Created on: 1993-02-03
2// Created by: Laurent BUCHARD
3// Copyright (c) 1993-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//
973c2be1 8// This library is free software; you can redistribute it and / or modify it
9// under the terms of the GNU Lesser General Public version 2.1 as published
10// by the Free Software Foundation, with special exception defined in the file
11// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12// distribution for complete text of the license and disclaimer of any warranty.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
7fd59977 16
17#include <IntPatch_Polyhedron.ixx>
18
19#include <IntPatch_HInterTool.hxx>
20
21#include <gp_Pnt.hxx>
22#include <gp_Vec.hxx>
23#include <TColgp_Array2OfPnt.hxx>
24#include <TColStd_Array2OfReal.hxx>
25#include <Bnd_Array1OfBox.hxx>
26#include <Standard_ConstructionError.hxx>
27#include <Precision.hxx>
28#include <stdio.h>
29
30#define MSG_DEBUG 0
31
32#define LONGUEUR_MINI_EDGE_TRIANGLE 1e-14
33#define DEFLECTION_COEFF 1.1
34#define NBMAXUV 30
35
36//================================================================================
37static Standard_Integer NbPOnU (const Handle(Adaptor3d_HSurface)& S)
38{
39 const Standard_Real u0 = S->FirstUParameter();
40 const Standard_Real u1 = S->LastUParameter();
41 const Standard_Integer nbpu = IntPatch_HInterTool::NbSamplesU(S,u0,u1);
42 return (nbpu>NBMAXUV? NBMAXUV : nbpu);
43}
44//================================================================================
45static Standard_Integer NbPOnV (const Handle(Adaptor3d_HSurface)& S)
46{
47 const Standard_Real v0 = S->FirstVParameter();
48 const Standard_Real v1 = S->LastVParameter();
49 const Standard_Integer nbpv = IntPatch_HInterTool::NbSamplesV(S,v0,v1);
50 return (nbpv>NBMAXUV? NBMAXUV : nbpv);
51}
52
53//=======================================================================
54//function : Destroy
55//purpose :
56//=======================================================================
57void IntPatch_Polyhedron::Destroy()
58{
59 gp_Pnt *CMyPnts = (gp_Pnt *)C_MyPnts; if(C_MyPnts) delete [] CMyPnts;
60 Standard_Real *CMyU = (Standard_Real *)C_MyU; if(C_MyU) delete [] CMyU;
61 Standard_Real *CMyV = (Standard_Real *)C_MyV; if(C_MyV) delete [] CMyV;
62 C_MyPnts=C_MyU=C_MyV=NULL;
63}
64
65//=======================================================================
66//function : IntPatch_Polyhedron
67//purpose :
68//=======================================================================
69IntPatch_Polyhedron::IntPatch_Polyhedron (const Handle(Adaptor3d_HSurface)& Surface)
70 : TheDeflection(Epsilon(100.)),
71 nbdeltaU(NbPOnU(Surface)),
72 nbdeltaV(NbPOnV(Surface)),
73 C_MyPnts(NULL),C_MyU(NULL),C_MyV(NULL),
74 UMinSingular(IntPatch_HInterTool::SingularOnVMin(Surface)),
75 UMaxSingular(IntPatch_HInterTool::SingularOnVMin(Surface)),
76 VMinSingular(IntPatch_HInterTool::SingularOnVMin(Surface)),
77 VMaxSingular(IntPatch_HInterTool::SingularOnVMin(Surface))
78{
79 const Standard_Integer t = (nbdeltaU+1)*(nbdeltaV+1)+1;
80 gp_Pnt *CMyPnts = new gp_Pnt[t];
81 Standard_Real *CMyU = new Standard_Real[t];
82 Standard_Real *CMyV = new Standard_Real[t];
83 C_MyPnts = CMyPnts;
84 C_MyU = CMyU;
85 C_MyV = CMyV;
86
87 const Standard_Real u0 = Surface->FirstUParameter();
88 const Standard_Real u1 = Surface->LastUParameter();
89 const Standard_Real v0 = Surface->FirstVParameter();
90 const Standard_Real v1 = Surface->LastVParameter();
91
92 const Standard_Real U1mU0sNbdeltaU = (u1-u0)/(Standard_Real)nbdeltaU;
93 const Standard_Real V1mV0sNbdeltaV = (v1-v0)/(Standard_Real)nbdeltaV;
94
95 gp_Pnt TP;
96 Standard_Real U,V;
97 Standard_Integer i1, i2, Index=1;
98 for (i1 = 0, U = u0; i1 <= nbdeltaU; i1++, U+= U1mU0sNbdeltaU) {
99 for (i2 = 0, V = v0; i2 <= nbdeltaV; i2++, V+= V1mV0sNbdeltaV ) {
100 Surface->D0(U,V,TP);
101 CMyPnts[Index] = TP;
102 CMyU[Index] = U;
103 CMyV[Index] = V;
104 TheBnd.Add(TP);
105 Index++;
106 }
107 }
108
109 Standard_Real tol=0.0;
110 const Standard_Integer nbtriangles = NbTriangles();
111 for (i1=1; i1<=nbtriangles; i1++) {
112 const Standard_Real tol1 = DeflectionOnTriangle(Surface,i1);
113 if(tol1>tol) tol=tol1;
114 }
115
116 tol*=DEFLECTION_COEFF;
117
118 DeflectionOverEstimation(tol);
119 FillBounding();
120}
121
122//=======================================================================
123//function : IntPatch_Polyhedron
124//purpose :
125//=======================================================================
126IntPatch_Polyhedron::IntPatch_Polyhedron (const Handle(Adaptor3d_HSurface)& Surface,
127 const Standard_Integer nbu,
128 const Standard_Integer nbv)
129: TheDeflection(Epsilon(100.)),
130 nbdeltaU(nbu),
131 nbdeltaV(nbv),
132 C_MyPnts(NULL),C_MyU(NULL),C_MyV(NULL),
133 UMinSingular(IntPatch_HInterTool::SingularOnVMin(Surface)),
134 UMaxSingular(IntPatch_HInterTool::SingularOnVMin(Surface)),
135 VMinSingular(IntPatch_HInterTool::SingularOnVMin(Surface)),
136 VMaxSingular(IntPatch_HInterTool::SingularOnVMin(Surface))
137{
138 const Standard_Integer t = (nbdeltaU+1)*(nbdeltaV+1)+1;
139 gp_Pnt *CMyPnts = new gp_Pnt[t];
140 Standard_Real *CMyU = new Standard_Real[t];
141 Standard_Real *CMyV = new Standard_Real[t];
142 C_MyPnts = CMyPnts;
143 C_MyU = CMyU;
144 C_MyV = CMyV;
145
146 const Standard_Real u0 = Surface->FirstUParameter();
147 const Standard_Real u1 = Surface->LastUParameter();
148 const Standard_Real v0 = Surface->FirstVParameter();
149 const Standard_Real v1 = Surface->LastVParameter();
150
151 const Standard_Real U1mU0sNbdeltaU = (u1-u0)/(Standard_Real)nbdeltaU;
152 const Standard_Real V1mV0sNbdeltaV = (v1-v0)/(Standard_Real)nbdeltaV;
153
154 gp_Pnt TP;
155 Standard_Real U,V;
156 Standard_Integer i1, i2, Index=1;
157 for (i1 = 0, U = u0; i1 <= nbdeltaU; i1++, U+= U1mU0sNbdeltaU) {
158 for (i2 = 0, V = v0; i2 <= nbdeltaV; i2++, V+= V1mV0sNbdeltaV ) {
159 Surface->D0(U,V,TP);
160 CMyPnts[Index] = TP;
161 CMyU[Index] = U;
162 CMyV[Index] = V;
163 TheBnd.Add(TP);
164 Index++;
165 }
166 }
167
168 Standard_Real tol=0.0;
169 const Standard_Integer nbtriangles = NbTriangles();
170 for (i1=1; i1<=nbtriangles; i1++) {
171 const Standard_Real tol1 = DeflectionOnTriangle(Surface,i1);
172 if(tol1>tol) tol=tol1;
173 }
174
175 tol*=DEFLECTION_COEFF;
176
177 DeflectionOverEstimation(tol);
178 FillBounding();
179}
180
181
182//=======================================================================
183//function : DeflectionOnTriangle
184//purpose :
185//=======================================================================
186
187Standard_Real IntPatch_Polyhedron::DeflectionOnTriangle
188 (const Handle(Adaptor3d_HSurface)& Surface,
189 const Standard_Integer Triang) const
190{
191 Standard_Integer i1,i2,i3;
192
193 Triangle(Triang,i1,i2,i3);
194 //-- Calcul de l eqution du plan
195 Standard_Real u1,v1,u2,v2,u3,v3;
196 gp_Pnt P1,P2,P3;
197 P1 = Point(i1,u1,v1);
198 P2 = Point(i2,u2,v2);
199 P3 = Point(i3,u3,v3);
200 if(P1.SquareDistance(P2)<=LONGUEUR_MINI_EDGE_TRIANGLE) return(0);
201 if(P1.SquareDistance(P3)<=LONGUEUR_MINI_EDGE_TRIANGLE) return(0);
202 if(P2.SquareDistance(P3)<=LONGUEUR_MINI_EDGE_TRIANGLE) return(0);
203 gp_XYZ XYZ1=P2.XYZ()-P1.XYZ();
204 gp_XYZ XYZ2=P3.XYZ()-P2.XYZ();
205 gp_XYZ XYZ3=P1.XYZ()-P3.XYZ();
206 gp_Vec NormalVector((XYZ1^XYZ2)+(XYZ2^XYZ3)+(XYZ3^XYZ1));
207 NormalVector.Normalize();
7fd59977 208 //-- Calcul du point u,v au centre du triangle
209 Standard_Real u = (u1+u2+u3)/3.0;
210 Standard_Real v = (v1+v2+v3)/3.0;
211 gp_Vec P1P(P1,Surface->Value(u,v));
212 return(Abs(P1P.Dot(NormalVector)));
213}
214
215//=======================================================================
216//function : Parameters
217//purpose :
218//=======================================================================
219void IntPatch_Polyhedron::Parameters( const Standard_Integer Index
220 ,Standard_Real &U
221 ,Standard_Real &V) const
222{
223 U = ((Standard_Real *)C_MyU)[Index];
224 V = ((Standard_Real *)C_MyV)[Index];
225}
226
227//=======================================================================
228//function : DeflectionOverEstimation
229//purpose :
230//=======================================================================
231void IntPatch_Polyhedron::DeflectionOverEstimation(const Standard_Real flec)
232{
233 if(flec<0.0001) {
234 TheDeflection=0.0001;
235 TheBnd.Enlarge(0.0001);
236 }
237 else {
238 TheDeflection=flec;
239 TheBnd.Enlarge(flec);
240 }
241}
242
243//=======================================================================
244//function : DeflectionOverEstimation
245//purpose :
246//=======================================================================
247Standard_Real IntPatch_Polyhedron::DeflectionOverEstimation() const
248{
249 return TheDeflection;
250}
251
252//=======================================================================
253//function : Bounding
254//purpose :
255//=======================================================================
256const Bnd_Box& IntPatch_Polyhedron::Bounding() const
257{
258 return TheBnd;
259}
260
261//=======================================================================
262//function : FillBounding
263//purpose :
264//=======================================================================
265void IntPatch_Polyhedron::FillBounding()
266{
267 TheComponentsBnd=new Bnd_HArray1OfBox(1, NbTriangles());
268 Bnd_Box Boite;
269 Standard_Integer p1, p2, p3;
270 Standard_Integer nbtriangles = NbTriangles();
271 for (Standard_Integer iTri=1; iTri<=nbtriangles; iTri++) {
272 Triangle(iTri, p1, p2, p3);
273 Boite.SetVoid();
274 const gp_Pnt& P1 = Point(p1);
275 const gp_Pnt& P2 = Point(p2);
276 const gp_Pnt& P3 = Point(p3);
277 if(P1.SquareDistance(P2)>LONGUEUR_MINI_EDGE_TRIANGLE) {
278 if(P1.SquareDistance(P3)>LONGUEUR_MINI_EDGE_TRIANGLE) {
279 if(P2.SquareDistance(P3)>LONGUEUR_MINI_EDGE_TRIANGLE) {
280 Boite.Add(P1);
281 Boite.Add(P2);
282 Boite.Add(P3);
283 }
284 }
285 }
286 Boite.Enlarge(TheDeflection);
287 TheComponentsBnd->SetValue(iTri,Boite);
288 }
289}
290
291//=======================================================================
292//function : ComponentsBounding
293//purpose :
294//=======================================================================
295const Handle(Bnd_HArray1OfBox)& IntPatch_Polyhedron::ComponentsBounding () const
296{
297 return TheComponentsBnd;
298}
299
300//=======================================================================
301//function : NbTriangles
302//purpose :
303//=======================================================================
304Standard_Integer IntPatch_Polyhedron::NbTriangles () const
305{
306 return nbdeltaU*nbdeltaV*2;
307}
308
309//=======================================================================
310//function : NbPoints
311//purpose :
312//=======================================================================
313Standard_Integer IntPatch_Polyhedron::NbPoints () const
314{
315 return (nbdeltaU+1)*(nbdeltaV+1);
316}
317
318//=======================================================================
319//function : TriConnex
320//purpose :
321//=======================================================================
322Standard_Integer IntPatch_Polyhedron::TriConnex (const Standard_Integer Triang,
323 const Standard_Integer Pivot,
324 const Standard_Integer Pedge,
325 Standard_Integer& TriCon,
326 Standard_Integer& OtherP) const {
327
7fd59977 328 Standard_Integer Pivotm1 = Pivot-1;
329 Standard_Integer nbdeltaVp1 = nbdeltaV+1;
330 Standard_Integer nbdeltaVm2 = nbdeltaV + nbdeltaV;
331
332// Pivot position in the MaTriangle :
333 Standard_Integer ligP = Pivotm1/nbdeltaVp1;
334 Standard_Integer colP = Pivotm1 - ligP * nbdeltaVp1;
335
336// Point sur Edge position in the MaTriangle and edge typ :
7fd59977 337 Standard_Integer ligE = 0, colE = 0, typE = 0;
7fd59977 338 if (Pedge!=0) {
339 ligE= (Pedge-1)/nbdeltaVp1;
340 colE= (Pedge-1) - (ligE * nbdeltaVp1);
341 // Horizontal
342 if (ligP==ligE) typE=1;
343 // Vertical
344 else if (colP==colE) typE=2;
345 // Oblique
346 else typE=3;
347 }
348 else {
349 typE=0;
350 }
351
352// Triangle position General case :
7fd59977 353 Standard_Integer linT = 0, colT = 0;
354 Standard_Integer linO = 0, colO = 0;
7fd59977 355 Standard_Integer t,tt;
356 if (Triang!=0) {
357 t = (Triang-1)/(nbdeltaVm2);
358 tt= (Triang-1)-t*nbdeltaVm2;
359 linT= 1+t;
360 colT= 1+tt;
361 if (typE==0) {
362 if (ligP==linT) {
363 ligE=ligP-1;
364 colE=colP-1;
365 typE=3;
366 }
367 else {
368 if (colT==ligP+ligP) {
369 ligE=ligP;
370 colE=colP-1;
371 typE=1;
372 }
373 else {
374 ligE=ligP+1;
375 colE=colP+1;
376 typE=3;
377 }
378 }
379 }
380 switch (typE) {
381 case 1: // Horizontal
382 if (linT==ligP) {
383 linT++;
384 linO=ligP+1;
385 colO=(colP>colE)? colP : colE; //--colO=Max(colP, colE);
386 }
387 else {
388 linT--;
389 linO=ligP-1;
390 colO=(colP<colE)? colP : colE; //--colO=Min(colP, colE);
391 }
392 break;
393 case 2: // Vertical
394 if (colT==(colP+colP)) {
395 colT++;
396 linO=(ligP>ligE)? ligP : ligE; //--linO=Max(ligP, ligE);
397 colO=colP+1;;
398 }
399 else {
400 colT--;
401 linO=(ligP<ligE)? ligP : ligE; //--linO=Min(ligP, ligE);
402 colO=colP-1;;
403 }
404 break;
405 case 3: // Oblique
406 if ((colT&1)==0) {
407 colT--;
408 linO=(ligP>ligE)? ligP : ligE; //--linO=Max(ligP, ligE);
409 colO=(colP<colE)? colP : colE; //--colO=Min(colP, colE);
410 }
411 else {
412 colT++;
413 linO=(ligP<ligE)? ligP : ligE; //--linO=Min(ligP, ligE);
414 colO=(colP>colE)? colP : colE; //--colO=Max(colP, colE);
415 }
416 break;
417 }
418 }
419 else {
420 // Unknown Triangle position :
421 if (Pedge==0) {
422 // Unknown edge :
423 linT=(1>ligP)? 1 : ligP; //--linT=Max(1, ligP);
424 colT=(1>(colP+colP))? 1 : (colP+colP); //--colT=Max(1, colP+colP);
425 if (ligP==0) linO=ligP+1;
426 else linO=ligP-1;
427 colO=colP;
428 }
429 else {
430 // Known edge We take the left or down connectivity :
431 switch (typE) {
432 case 1: // Horizontal
433 linT=ligP+1;
434 colT=(colP>colE)? colP : colE; //--colT=Max(colP,colE);
435 colT+=colT;
436 linO=ligP+1;
437 colO=(colP>colE)? colP : colE; //--colO=Max(colP,colE);
438 break;
439 case 2: // Vertical
440 linT=(ligP>ligE)? ligP : ligE; //--linT=Max(ligP, ligE);
441 colT=colP+colP;
442 linO=(ligP<ligE)? ligP : ligE; //--linO=Min(ligP, ligE);
443 colO=colP-1;
444 break;
445 case 3: // Oblique
446 linT=(ligP>ligE)? ligP : ligE; //--linT=Max(ligP, ligE);
447 colT=colP+colE;
448 linO=(ligP>ligE)? ligP : ligE; //--linO=Max(ligP, ligE);
449 colO=(colP<colE)? colP : colE; //--colO=Min(colP, colE);
450 break;
451 }
452 }
453 }
454
455 TriCon=(linT-1)*nbdeltaVm2 + colT;
456
457 if (linT<1) {
458 linO=0;
459 colO=colP+colP-colE;
460 if (colO<0) {colO=0;linO=1;}
461 else if (colO>nbdeltaV) {colO=nbdeltaV;linO=1;}
462 TriCon=0;
463 }
464 else if (linT>nbdeltaU) {
465 linO=nbdeltaU;
466 colO=colP+colP-colE;
467 if (colO<0) {colO=0;linO=nbdeltaU-1;}
468 else if (colO>nbdeltaV) {colO=nbdeltaV;linO=nbdeltaU-1;}
469 TriCon=0;
470 }
471
472 if (colT<1) {
473 colO=0;
474 linO=ligP+ligP-ligE;
475 if (linO<0) {linO=0;colO=1;}
476 else if (linO>nbdeltaU) {linO=nbdeltaU;colO=1;}
477 TriCon=0;
478 }
479 else if (colT>nbdeltaV) {
480 colO=nbdeltaV;
481 linO=ligP+ligP-ligE;
482 if (linO<0) {linO=0;colO=nbdeltaV-1;}
483 else if (linO>nbdeltaU) {linO=nbdeltaU;colO=nbdeltaV-1;}
484 TriCon=0;
485 }
486
487 OtherP=linO*nbdeltaVp1 + colO+1;
488
489
490 //----------------------------------------------------
491 //-- Detection des cas ou le triangle retourne est
492 //-- invalide. Dans ce cas, on retourne le triangle
493 //-- suivant par un nouvel appel a TriConnex.
494 //--
495 //-- Si En entree : Point(Pivot)==Point(Pedge)
496 //-- Alors on retourne OtherP a 0
497 //-- et Tricon = Triangle
498 //--
499 if(Point(Pivot).SquareDistance(Point(Pedge))<=LONGUEUR_MINI_EDGE_TRIANGLE) {
500 OtherP=0;
501 TriCon=Triang;
502#if MSG_DEBUG
503 cout<<" Probleme ds IntCurveSurface_Polyhedron : Pivot et PEdge Confondus "<<endl;
504#endif
505 return(TriCon);
506 }
507 if(Point(OtherP).SquareDistance(Point(Pedge))<=LONGUEUR_MINI_EDGE_TRIANGLE) {
508#if MSG_DEBUG
509 cout<<" Probleme ds IntCurveSurface_Polyhedron : OtherP et PEdge Confondus "<<endl;
510#endif
7fd59977 511 return(0); //-- BUG NON CORRIGE ( a revoir le role de nbdeltaU et nbdeltaV)
96a95605
DB
512// Standard_Integer TempTri,TempOtherP;
513// TempTri = TriCon;
514// TempOtherP = OtherP;
d3f26155 515// return(TriConnex(TempTri,Pivot,TempOtherP,TriCon,OtherP));
7fd59977 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//=======================================================================