projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0028832: MMgt_TShared can be replaced by Standard_Transient
[occt.git] / src / HLRBRep / HLRBRep_PolyAlgo.cxx
CommitLineData
b311480e 1// Created on: 1995-05-05
2// Created by: Christophe MARION
3// Copyright (c) 1995-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.
733a0e55 16
7fd59977 17// Modified by cma, Tue Apr 1 11:39:48 1997
18// Modified by cma, Tue Apr 1 11:40:30 1997
19
42cf5bc1 20#include <BRep_Builder.hxx>
21#include <BRep_Tool.hxx>
22#include <BRepLib_MakeEdge.hxx>
7fd59977 23#include <CSLib.hxx>
24#include <CSLib_DerivativeStatus.hxx>
25#include <CSLib_NormalStatus.hxx>
7fd59977 26#include <Geom_RectangularTrimmedSurface.hxx>
42cf5bc1 27#include <Geom_Surface.hxx>
28#include <gp.hxx>
29#include <HLRAlgo_BiPoint.hxx>
30#include <HLRAlgo_EdgeStatus.hxx>
7fd59977 31#include <HLRAlgo_ListIteratorOfListOfBPoint.hxx>
42cf5bc1 32#include <HLRAlgo_PolyAlgo.hxx>
7fd59977 33#include <HLRAlgo_PolyData.hxx>
42cf5bc1 34#include <HLRAlgo_PolyInternalData.hxx>
681f3919 35#include <HLRAlgo_PolyMask.hxx>
42cf5bc1 36#include <HLRAlgo_PolyShellData.hxx>
37#include <HLRAlgo_Projector.hxx>
38#include <HLRBRep_PolyAlgo.hxx>
39#include <Poly_Polygon3D.hxx>
40#include <Poly_PolygonOnTriangulation.hxx>
41#include <Poly_Triangulation.hxx>
42#include <Precision.hxx>
43#include <Standard_ErrorHandler.hxx>
44#include <Standard_OutOfRange.hxx>
45#include <Standard_Stream.hxx>
46#include <Standard_Type.hxx>
47#include <TColStd_HArray1OfInteger.hxx>
48#include <TColStd_HArray1OfTransient.hxx>
7fd59977 49#include <TopExp.hxx>
50#include <TopExp_Explorer.hxx>
42cf5bc1 51#include <TopoDS.hxx>
52#include <TopoDS_Edge.hxx>
53#include <TopoDS_Shape.hxx>
7fd59977 54#include <TopTools_Array1OfShape.hxx>
7fd59977 55#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
42cf5bc1 56#include <TopTools_ListIteratorOfListOfShape.hxx>
7fd59977 57
25e59720 58IMPLEMENT_STANDARD_RTTIEXT(HLRBRep_PolyAlgo,Standard_Transient)
92efcf78 59
681f3919 60enum
61{
62 NMsk_Vert = 1,
63 NMsk_OutL = 2,
64 NMsk_Norm = 4,
65 NMsk_Fuck = 8,
66 NMsk_Edge = 16,
67 NMsk_Move = 32
68};
69
0797d9d3 70#ifdef OCCT_DEBUG
7fd59977 71static Standard_Integer DoTrace = Standard_False;
72static Standard_Integer DoError = Standard_False;
7fd59977 73#endif
74//=======================================================================
75//function : HLRBRep_PolyAlgo
76//purpose :
77//=======================================================================
78
79HLRBRep_PolyAlgo::HLRBRep_PolyAlgo () :
80myDebug (Standard_False),
c6541a0c 81myAngle (5 * M_PI / 180.),
7fd59977 82myTolSta (0.1),
83myTolEnd (0.9),
84myTolAngular(0.001)
85{
86 myAlgo = new HLRAlgo_PolyAlgo();
87}
88
89//=======================================================================
90//function : HLRBRep_PolyAlgo
91//purpose :
92//=======================================================================
93
94HLRBRep_PolyAlgo::HLRBRep_PolyAlgo (const Handle(HLRBRep_PolyAlgo)& A)
95{
96 myDebug = A->Debug();
97 myAngle = A->Angle();
98 myTolAngular = A->TolAngular();
99 myTolSta = A->TolCoef();
100 myTolEnd = 1 - myTolSta;
101 myAlgo = A->Algo();
102 myProj = A->Projector();
103
104 Standard_Integer n = A->NbShapes();
105
106 for (Standard_Integer i = 1; i <= n; i++)
107 Load(A->Shape(i));
108}
109
110//=======================================================================
111//function : HLRBRep_PolyAlgo
112//purpose :
113//=======================================================================
114
115HLRBRep_PolyAlgo::HLRBRep_PolyAlgo (const TopoDS_Shape& S) :
116myDebug (Standard_False),
c6541a0c 117myAngle (5 * M_PI / 180.),
7fd59977 118myTolSta (0.1),
119myTolEnd (0.9),
120myTolAngular(0.001)
121{
122 myShapes.Append(S);
123 myAlgo = new HLRAlgo_PolyAlgo();
124}
125
126//=======================================================================
127//function : Shape
128//purpose :
129//=======================================================================
130
131TopoDS_Shape & HLRBRep_PolyAlgo::Shape (const Standard_Integer I)
132{
133 Standard_OutOfRange_Raise_if (I == 0 || I > myShapes.Length(),
134 "HLRBRep_PolyAlgo::Shape : unknown Shape");
135 return myShapes(I);
136}
137
138//=======================================================================
139//function : Remove
140//purpose :
141//=======================================================================
142
143void HLRBRep_PolyAlgo::Remove (const Standard_Integer I)
144{
145 Standard_OutOfRange_Raise_if (I == 0 || I > myShapes.Length(),
146 "HLRBRep_PolyAlgo::Remove : unknown Shape");
147 myShapes.Remove(I);
148 myAlgo->Clear();
149 myEMap.Clear();
150 myFMap.Clear();
151}
152
153//=======================================================================
154//function : Index
155//purpose :
156//=======================================================================
157
158Standard_Integer HLRBRep_PolyAlgo::Index (const TopoDS_Shape& S) const
159{
160 Standard_Integer n = myShapes.Length();
161
162 for (Standard_Integer i = 1; i <= n; i++)
163 if (myShapes(i) == S) return i;
164
165 return 0;
166}
167
168//=======================================================================
169//function : Algo
170//purpose :
171//=======================================================================
172
173Handle(HLRAlgo_PolyAlgo) HLRBRep_PolyAlgo::Algo () const
174{
175 return myAlgo;
176}
177
178//=======================================================================
179//function : Update
180//purpose :
181//=======================================================================
182
183void HLRBRep_PolyAlgo::Update ()
184{
185 myAlgo->Clear();
186 myEMap.Clear();
187 myFMap.Clear();
188 TopoDS_Shape Shape = MakeShape();
189
190 if (!Shape.IsNull()) {
191 TopExp_Explorer exshell;
192 Standard_Boolean IsoledF,IsoledE;//,closed;
193 TopLoc_Location L;
194 TopTools_MapOfShape ShapeMap1,ShapeMap2;
195 TopExp::MapShapes(Shape,TopAbs_EDGE,myEMap);
196 TopExp::MapShapes(Shape,TopAbs_FACE,myFMap);
197 Standard_Integer nbEdge = myEMap.Extent();
198 Standard_Integer nbFace = myFMap.Extent();
199 TColStd_Array1OfInteger ES (0,nbEdge); // index of the Shell
200 TColStd_Array1OfTransient PD (0,nbFace); // HLRAlgo_PolyData
201 TColStd_Array1OfTransient PID(0,nbFace); // PolyInternalData
202 Standard_Integer nbShell = InitShape(Shape,IsoledF,IsoledE);
203 if (nbShell > 0) {
204 TColStd_Array1OfTransient& Shell = myAlgo->PolyShell();
205 Standard_Integer iShell = 0;
206
207 for (exshell.Init(Shape, TopAbs_SHELL);
208 exshell.More();
209 exshell.Next())
210 StoreShell(exshell.Current(),iShell,Shell,
211 Standard_False,Standard_False,
212 ES,PD,PID,ShapeMap1,ShapeMap2);
213 if (IsoledF)
214 StoreShell(Shape,iShell,Shell,IsoledF,Standard_False,
215 ES,PD,PID,ShapeMap1,ShapeMap2);
216 if (IsoledE)
217 StoreShell(Shape,iShell,Shell,Standard_False,IsoledE,
218 ES,PD,PID,ShapeMap1,ShapeMap2);
219 myAlgo->Update();
220 }
221 }
222}
223
224//=======================================================================
225//function : MakeShape
226//purpose :
227//=======================================================================
228
229TopoDS_Shape HLRBRep_PolyAlgo::MakeShape () const
230{
231 Standard_Integer n = myShapes.Length();
232 Standard_Boolean FirstTime = Standard_True;
233 BRep_Builder B;
234 TopoDS_Shape Shape;
235
236 for (Standard_Integer i = 1; i <= n; i++) {
237 if (FirstTime) {
238 FirstTime = Standard_False;
239 B.MakeCompound(TopoDS::Compound(Shape));
240 }
241 B.Add(Shape,myShapes(i));
242 }
243 return Shape;
244}
245
246//=======================================================================
247//function : InitShape
248//purpose :
249//=======================================================================
250
251Standard_Integer
252HLRBRep_PolyAlgo::InitShape (const TopoDS_Shape& Shape,
253 Standard_Boolean& IsoledF,
254 Standard_Boolean& IsoledE)
255{
256 TopTools_MapOfShape ShapeMap0;
257 Standard_Integer nbShell = 0;
258 IsoledF = Standard_False;
259 IsoledE = Standard_False;
260 TopExp_Explorer exshell,exface,exedge;
261 TopLoc_Location L;
262
263 for (exshell.Init(Shape, TopAbs_SHELL);
264 exshell.More();
265 exshell.Next()) {
266 Standard_Boolean withTrian = Standard_False;
267
268 for (exface.Init(exshell.Current(), TopAbs_FACE);
269 exface.More();
270 exface.Next()) {
271 const TopoDS_Face& F = TopoDS::Face(exface.Current());
272 if (!BRep_Tool::Triangulation(F,L).IsNull()) {
273 if (ShapeMap0.Add(F))
274 withTrian = Standard_True;
275 }
276 }
277 if (withTrian) nbShell++;
278 }
279
280 for (exface.Init(Shape, TopAbs_FACE, TopAbs_SHELL);
281 exface.More() && !IsoledF;
282 exface.Next()) {
283 const TopoDS_Face& F = TopoDS::Face(exface.Current());
284 if (!BRep_Tool::Triangulation(F,L).IsNull()) {
285 if (ShapeMap0.Add(F))
286 IsoledF = Standard_True;
287 }
288 }
289 if (IsoledF) nbShell++;
290
291 for (exedge.Init(Shape, TopAbs_EDGE, TopAbs_FACE);
292 exedge.More() && !IsoledE;
293 exedge.Next())
294 IsoledE = Standard_True;
295 if (IsoledE) nbShell++;
296 if (nbShell > 0)
297 myAlgo->Init(new TColStd_HArray1OfTransient(1,nbShell));
298 return nbShell;
299}
300
301//=======================================================================
302//function : StoreShell
303//purpose :
304//=======================================================================
305
306void HLRBRep_PolyAlgo::StoreShell (const TopoDS_Shape& Shape,
307 Standard_Integer& iShell,
308 TColStd_Array1OfTransient& Shell,
309 const Standard_Boolean IsoledF,
310 const Standard_Boolean IsoledE,
311 TColStd_Array1OfInteger& ES,
312 TColStd_Array1OfTransient& PD,
313 TColStd_Array1OfTransient& PID,
314 TopTools_MapOfShape& ShapeMap1,
315 TopTools_MapOfShape& ShapeMap2)
316{
317 TopLoc_Location L;
318 TopExp_Explorer exface,exedge;
1d47d8d0 319 Standard_Integer f = 0,i,j;
7fd59977 320 Standard_Integer nbFaceShell = 0;
321 Standard_Boolean reversed;
322 Standard_Boolean closed = Standard_False;
323 const gp_Trsf& T = myProj.Transformation();
324 const gp_Trsf& TI = myProj.InvertedTransformation();
325 const gp_XYZ& tloc = T.TranslationPart();
326 TLoc[0] = tloc.X();
327 TLoc[1] = tloc.Y();
328 TLoc[2] = tloc.Z();
329 const gp_Mat& tmat = T.VectorialPart();
330 TMat[0][0] = tmat.Value(1,1);
331 TMat[0][1] = tmat.Value(1,2);
332 TMat[0][2] = tmat.Value(1,3);
333 TMat[1][0] = tmat.Value(2,1);
334 TMat[1][1] = tmat.Value(2,2);
335 TMat[1][2] = tmat.Value(2,3);
336 TMat[2][0] = tmat.Value(3,1);
337 TMat[2][1] = tmat.Value(3,2);
338 TMat[2][2] = tmat.Value(3,3);
339 const gp_XYZ& tilo = TI.TranslationPart();
340 TILo[0] = tilo.X();
341 TILo[1] = tilo.Y();
342 TILo[2] = tilo.Z();
343 const gp_Mat& tima = TI.VectorialPart();
344 TIMa[0][0] = tima.Value(1,1);
345 TIMa[0][1] = tima.Value(1,2);
346 TIMa[0][2] = tima.Value(1,3);
347 TIMa[1][0] = tima.Value(2,1);
348 TIMa[1][1] = tima.Value(2,2);
349 TIMa[1][2] = tima.Value(2,3);
350 TIMa[2][0] = tima.Value(3,1);
351 TIMa[2][1] = tima.Value(3,2);
352 TIMa[2][2] = tima.Value(3,3);
353 if (!IsoledE) {
354 if (!IsoledF) {
355 closed = Shape.Closed();
356 if (!closed) {
357 TopTools_IndexedMapOfShape EM;
358 TopExp::MapShapes(Shape,TopAbs_EDGE,EM);
359 Standard_Integer ie;
360 Standard_Integer nbEdge = EM.Extent ();
361 Standard_Integer *flag = new Standard_Integer[nbEdge + 1];
362
363 for (ie = 1; ie <= nbEdge; ie++)
364 flag[ie] = 0;
365
366 for (exedge.Init(Shape, TopAbs_EDGE);
367 exedge.More();
368 exedge.Next()) {
369 const TopoDS_Edge& E = TopoDS::Edge(exedge.Current());
370 ie = EM.FindIndex(E);
371 TopAbs_Orientation orient = E.Orientation();
372 if (!BRep_Tool::Degenerated(E)) {
373 if (orient == TopAbs_FORWARD ) flag[ie] += 1;
374 else if (orient == TopAbs_REVERSED) flag[ie] -= 1;
375 }
376 }
377 closed = Standard_True;
378
379 for (ie = 1; ie <= nbEdge && closed; ie++)
380 closed = (flag[ie] == 0);
381 delete [] flag;
382 flag = NULL;
383 }
384
385 exface.Init(Shape, TopAbs_FACE);
386 }
387 else
388 exface.Init(Shape, TopAbs_FACE, TopAbs_SHELL);
389
390 for (; exface.More(); exface.Next()) {
391 const TopoDS_Face& F = TopoDS::Face(exface.Current());
392 if (!BRep_Tool::Triangulation(F,L).IsNull()) {
393 if (ShapeMap1.Add(F))
394 nbFaceShell++;
395 }
396 }
397 }
398 if (nbFaceShell > 0 || IsoledE) {
399 iShell++;
400 Shell(iShell) = new HLRAlgo_PolyShellData(nbFaceShell);
401 }
402 if (nbFaceShell > 0) {
403 const Handle(HLRAlgo_PolyShellData)& psd =
404 *(Handle(HLRAlgo_PolyShellData)*)&(Shell(iShell));
405 Standard_Integer iFace = 0;
406 if (!IsoledF) exface.Init(Shape, TopAbs_FACE);
407 else exface.Init(Shape, TopAbs_FACE, TopAbs_SHELL);
408 TopTools_MapOfShape ShapeMapBis;
409
410 for (; exface.More(); exface.Next()) {
411 const TopoDS_Face& F = TopoDS::Face(exface.Current());
412 const Handle(Poly_Triangulation)& Tr = BRep_Tool::Triangulation(F,L);
413 if (!Tr.IsNull()) {
414 if (ShapeMap2.Add(F)) {
415 iFace++;
416 f = myFMap.FindIndex(F);
417 reversed = F.Orientation() == TopAbs_REVERSED;
418 gp_Trsf TT = L.Transformation();
419 TT.PreMultiply(T);
420 const gp_XYZ& ttlo = TT.TranslationPart();
421 TTLo[0] = ttlo.X();
422 TTLo[1] = ttlo.Y();
423 TTLo[2] = ttlo.Z();
424 const gp_Mat& ttma = TT.VectorialPart();
425 TTMa[0][0] = ttma.Value(1,1);
426 TTMa[0][1] = ttma.Value(1,2);
427 TTMa[0][2] = ttma.Value(1,3);
428 TTMa[1][0] = ttma.Value(2,1);
429 TTMa[1][1] = ttma.Value(2,2);
430 TTMa[1][2] = ttma.Value(2,3);
431 TTMa[2][0] = ttma.Value(3,1);
432 TTMa[2][1] = ttma.Value(3,2);
433 TTMa[2][2] = ttma.Value(3,3);
434 Poly_Array1OfTriangle & Tri = Tr->ChangeTriangles();
435 TColgp_Array1OfPnt & Nod = Tr->ChangeNodes();
436 Standard_Integer nbN = Nod.Upper();
437 Standard_Integer nbT = Tri.Upper();
438 PD (f) = new HLRAlgo_PolyData();
439 psd->PolyData().ChangeValue(iFace) = PD(f);
440 PID(f) = new HLRAlgo_PolyInternalData(nbN,nbT);
441 Handle(HLRAlgo_PolyInternalData)& pid =
442 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(f));
443 Handle(Geom_Surface) S = BRep_Tool::Surface(F);
444 if (S->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface))
445 S = Handle(Geom_RectangularTrimmedSurface)::DownCast(S)->BasisSurface();
446 GeomAdaptor_Surface AS(S);
447 pid->Planar(AS.GetType() == GeomAbs_Plane);
681f3919 448 HLRAlgo_Array1OfTData* TData = &pid->TData();
449 HLRAlgo_Array1OfPISeg* PISeg = &pid->PISeg();
450 HLRAlgo_Array1OfPINod* PINod = &pid->PINod();
7fd59977 451 Poly_Triangle * OT = &(Tri.ChangeValue(1));
681f3919 452 HLRAlgo_TriangleData* NT = &TData->ChangeValue(1);
7fd59977 453
454 for (i = 1; i <= nbT; i++) {
681f3919 455 OT->Get(NT->Node1, NT->Node2, NT->Node3);
456 NT->Flags = 0;
7fd59977 457 if (reversed) {
681f3919 458 j = NT->Node1;
459 NT->Node1 = NT->Node3;
460 NT->Node3 = j;
7fd59977 461 }
462 OT++;
463 NT++;
464 }
465
466 gp_Pnt * ON = &(Nod.ChangeValue(1));
681f3919 467 Handle(HLRAlgo_PolyInternalNode)* NN = &PINod->ChangeValue(1);
7fd59977 468
469 for (i = 1; i <= nbN; i++) {
681f3919 470 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues = (*NN)->Data();
471 HLRAlgo_PolyInternalNode::NodeIndices& aNodIndices = (*NN)->Indices();
472 aNodIndices.NdSg = 0;
473 aNodIndices.Flag = 0;
474 Nod1RValues.Point = ON->Coord();
475 TTMultiply(Nod1RValues.Point);
7fd59977 476 ON++;
477 NN++;
478 }
479 pid->UpdateLinks(TData,PISeg,PINod);
480 if (Tr->HasUVNodes()) {
481 myBSurf.Initialize(F,Standard_False);
482 TColgp_Array1OfPnt2d & UVN = Tr->ChangeUVNodes();
483 gp_Pnt2d* OUVN = &(UVN.ChangeValue(1));
484 NN = &(((HLRAlgo_Array1OfPINod*)PINod)->
485 ChangeValue(1));
486
487 for (i = 1; i <= nbN; i++) {
681f3919 488 HLRAlgo_PolyInternalNode::NodeIndices& aNodIndices = (*NN)->Indices();
489 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues = (*NN)->Data();
490 Nod1RValues.UV = OUVN->Coord();
491 if (Normal(i,aNodIndices,Nod1RValues,
7fd59977 492 TData,PISeg,PINod,Standard_False))
681f3919 493 aNodIndices.Flag |= NMsk_Norm;
7fd59977 494 else {
681f3919 495 aNodIndices.Flag &= ~NMsk_Norm;
496 Nod1RValues.Scal = 0;
7fd59977 497 }
498 OUVN++;
499 NN++;
500 }
501 }
0797d9d3 502#ifdef OCCT_DEBUG
7fd59977 503 else if (DoError) {
504 cout << " HLRBRep_PolyAlgo::StoreShell : Face ";
505 cout << f << " non triangulated" << endl;
506 }
507#endif
508 NT = &(((HLRAlgo_Array1OfTData*)TData)->ChangeValue(1));
509
510 for (i = 1; i <= nbT; i++) {
7fd59977 511 const Handle(HLRAlgo_PolyInternalNode)* PN1 =
681f3919 512 &PINod->ChangeValue(NT->Node1);
7fd59977 513 const Handle(HLRAlgo_PolyInternalNode)* PN2 =
681f3919 514 &PINod->ChangeValue(NT->Node2);
7fd59977 515 const Handle(HLRAlgo_PolyInternalNode)* PN3 =
681f3919 516 &PINod->ChangeValue(NT->Node3);
517 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues = (*PN1)->Data();
518 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues = (*PN2)->Data();
519 HLRAlgo_PolyInternalNode::NodeData& Nod3RValues = (*PN3)->Data();
520 OrientTriangle(i,*NT,
521 (*PN1)->Indices(),Nod1RValues,
522 (*PN2)->Indices(),Nod2RValues,
523 (*PN3)->Indices(),Nod3RValues);
7fd59977 524 NT++;
525 }
526 }
527 }
0797d9d3 528#ifdef OCCT_DEBUG
7fd59977 529 else if (DoError) {
530 cout << "HLRBRep_PolyAlgo::StoreShell : Face ";
531 cout << f << " deja stockee" << endl;
532 }
533#endif
534 }
535 Standard_Integer nbFace = myFMap.Extent();
536 HLRAlgo_ListOfBPoint& List = psd->Edges();
537 TopTools_IndexedDataMapOfShapeListOfShape EF;
538 TopExp::MapShapesAndAncestors(Shape,TopAbs_EDGE,TopAbs_FACE,EF);
539 Handle(HLRAlgo_PolyInternalData)* pid =
540 (Handle(HLRAlgo_PolyInternalData)*)&(PID.ChangeValue(1));
541
542 for (f = 1; f <= nbFace; f++) {
543 if (!(*pid).IsNull()) {
544
545 for (exedge.Init(myFMap(f),TopAbs_EDGE);
546 exedge.More();
547 exedge.Next()) {
548 TopoDS_Edge E = TopoDS::Edge(exedge.Current());
549 if (ShapeMap1.Add(E)) {
550 Standard_Integer e = myEMap.FindIndex(E);
551 ES(e) = iShell;
51740958 552 Standard_Integer anIndexE = EF.FindIndex(E);
553 if (anIndexE > 0) {
554 TopTools_ListOfShape& LS = EF(anIndexE);
7fd59977 555 InitBiPointsWithConnexity(e,E,List,PID,LS,Standard_True);
556 }
557 else {
558 TopTools_ListOfShape LS;
559 InitBiPointsWithConnexity(e,E,List,PID,LS,Standard_False);
560 }
561 }
562 }
563 }
564 pid++;
565 }
566 InsertOnOutLine(PID);
567 CheckFrBackTriangles(List,PID);
568 UpdateOutLines(List,PID);
569 UpdateEdgesBiPoints(List,PID,closed);
570 UpdatePolyData(PD,PID,closed);
571 pid = (Handle(HLRAlgo_PolyInternalData)*)&(PID.ChangeValue(1));
572
573 for (f = 1; f <= nbFace; f++) {
574 (*pid).Nullify();
575 pid++;
576 }
577 }
578 else if (IsoledE) {
579 const Handle(HLRAlgo_PolyShellData)& psd =
580 *(Handle(HLRAlgo_PolyShellData)*)&(Shell(iShell));
581 HLRAlgo_ListOfBPoint& List = psd->Edges();
582
583 for (exedge.Init(Shape, TopAbs_EDGE, TopAbs_FACE);
584 exedge.More();
585 exedge.Next()) {
586 TopoDS_Edge E = TopoDS::Edge(exedge.Current());
587 if (ShapeMap1.Add(E)) {
588 Standard_Integer e = myEMap.FindIndex(E);
589 ES(e) = iShell;
590 TopTools_ListOfShape LS;
591 InitBiPointsWithConnexity(e,E,List,PID,LS,Standard_False);
592 }
593 }
594 }
595}
596
597//=======================================================================
598//function : Normal
599//purpose :
600//=======================================================================
601
602Standard_Boolean HLRBRep_PolyAlgo::
603Normal (const Standard_Integer iNode,
681f3919 604 HLRAlgo_PolyInternalNode::NodeIndices& theNodIndices,
605 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
606 HLRAlgo_Array1OfTData*& TData,
607 HLRAlgo_Array1OfPISeg*& PISeg,
608 HLRAlgo_Array1OfPINod*& PINod,
7fd59977 609 const Standard_Boolean orient) const
610{
611 gp_Vec D1U,D1V,D2U,D2V,D2UV;
612 gp_Pnt P;
613 gp_Dir Norma;
614 Standard_Boolean OK;
9fd2d2c3 615 CSLib_DerivativeStatus aStatus;
7fd59977 616 CSLib_NormalStatus NStat;
681f3919 617 myBSurf.D1(Nod1RValues.UV.X(), Nod1RValues.UV.Y(), P, D1U, D1V);
7fd59977 618 CSLib::Normal(D1U,D1V,Standard_Real(Precision::Angular()),
9fd2d2c3 619 aStatus,Norma);
620 if (aStatus != CSLib_Done) {
681f3919 621 myBSurf.D2(Nod1RValues.UV.X(), Nod1RValues.UV.Y(), P, D1U, D1V, D2U, D2V, D2UV);
7fd59977 622 CSLib::Normal(D1U,D1V,D2U,D2V,D2UV,
623 Precision::Angular(),OK,NStat,Norma);
624 if (!OK)
625 return Standard_False;
626 }
627 Standard_Real EyeX = 0;
628 Standard_Real EyeY = 0;
629 Standard_Real EyeZ = -1;
630 if (myProj.Perspective()) {
681f3919 631 EyeX = Nod1RValues.Point.X();
632 EyeY = Nod1RValues.Point.Y();
633 EyeZ = Nod1RValues.Point.Z() - myProj.Focus();
7fd59977 634 Standard_Real d = sqrt(EyeX * EyeX + EyeY * EyeY + EyeZ * EyeZ);
635 if (d > 0) {
636 EyeX /= d;
637 EyeY /= d;
638 EyeZ /= d;
639 }
640 }
681f3919 641 Nod1RValues.Normal = Norma.XYZ();
7fd59977 642// TMultiply(Nod1NrmX,Nod1NrmY,Nod1NrmZ);
681f3919 643 TMultiply(Nod1RValues.Normal,myProj.Perspective()); //OCC349
644 gp_XYZ Norm;
7fd59977 645
681f3919 646 if (AverageNormal(iNode,theNodIndices,TData,PISeg,PINod,Norm))
647 {
648 if (Nod1RValues.Normal * Norm < 0)
649 {
650 Nod1RValues.Normal.Reverse();
7fd59977 651 }
681f3919 652 Nod1RValues.Scal = (Nod1RValues.Normal * gp_XYZ(EyeX, EyeY, EyeZ));
7fd59977 653 }
654 else {
681f3919 655 Nod1RValues.Scal = 0;
656 Nod1RValues.Normal = gp_XYZ(1., 0., 0.);
0797d9d3 657#ifdef OCCT_DEBUG
7fd59977 658 if (DoError) {
659 cout << "HLRBRep_PolyAlgo::Normal : AverageNormal error";
660 cout << endl;
661 }
662#endif
663 }
681f3919 664 if (Nod1RValues.Scal > 0) {
665 if ( Nod1RValues.Scal < myTolAngular) {
666 Nod1RValues.Scal = 0;
667 theNodIndices.Flag |= NMsk_OutL;
7fd59977 668 }
669 }
670 else {
681f3919 671 if (-Nod1RValues.Scal < myTolAngular) {
672 Nod1RValues.Scal = 0;
673 theNodIndices.Flag |= NMsk_OutL;
7fd59977 674 }
675 }
681f3919 676 if (orient) UpdateAroundNode(iNode,theNodIndices,
7fd59977 677 TData,PISeg,PINod);
678 return Standard_True;
679}
680
681//=======================================================================
682//function : AverageNormal
683//purpose :
684//=======================================================================
685
686Standard_Boolean
687HLRBRep_PolyAlgo::AverageNormal(const Standard_Integer iNode,
681f3919 688 HLRAlgo_PolyInternalNode::NodeIndices& theNodeIndices,
689 HLRAlgo_Array1OfTData*& TData,
690 HLRAlgo_Array1OfPISeg*& PISeg,
691 HLRAlgo_Array1OfPINod*& PINod,
7fd59977 692 Standard_Real& X,
693 Standard_Real& Y,
694 Standard_Real& Z) const
695{
696 Standard_Boolean OK = Standard_False;
697 Standard_Integer jNode = 0,kNode,iiii,iTri1,iTri2;
698 X = 0;
699 Y = 0;
700 Z = 0;
681f3919 701 iiii = theNodeIndices.NdSg;
7fd59977 702
703 while (iiii != 0 && !OK) {
681f3919 704 HLRAlgo_PolyInternalSegment& aSegIndices =
705 ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii);
706 iTri1 = aSegIndices.Conex1;
707 iTri2 = aSegIndices.Conex2;
7fd59977 708 if ( iTri1 != 0) AddNormalOnTriangle
709 (iTri1,iNode,jNode,TData,PINod,X,Y,Z,OK);
710 if ( iTri2 != 0) AddNormalOnTriangle
711 (iTri2,iNode,jNode,TData,PINod,X,Y,Z,OK);
681f3919 712 if (aSegIndices.LstSg1 == iNode) iiii = aSegIndices.NxtSg1;
713 else iiii = aSegIndices.NxtSg2;
7fd59977 714 }
715
716 if (jNode != 0) {
681f3919 717 iiii = theNodeIndices.NdSg;
7fd59977 718
719 while (iiii != 0 && !OK) {
681f3919 720 HLRAlgo_PolyInternalSegment& aSegIndices = PISeg->ChangeValue(iiii);
721 iTri1 = aSegIndices.Conex1;
722 iTri2 = aSegIndices.Conex2;
7fd59977 723 if ( iTri1 != 0) AddNormalOnTriangle
724 (iTri1,jNode,kNode,TData,PINod,X,Y,Z,OK);
725 if ( iTri2 != 0) AddNormalOnTriangle
726 (iTri2,jNode,kNode,TData,PINod,X,Y,Z,OK);
681f3919 727 if (aSegIndices.LstSg1 == jNode) iiii = aSegIndices.NxtSg1;
728 else iiii = aSegIndices.NxtSg2;
7fd59977 729 }
730 }
731 Standard_Real d = sqrt (X * X + Y * Y + Z * Z);
732 if (OK && d < 1.e-10) {
733 OK = Standard_False;
0797d9d3 734#ifdef OCCT_DEBUG
7fd59977 735 if (DoError) {
736 cout << "HLRAlgo_PolyInternalData:: inverted normals on ";
737 cout << "node " << iNode << endl;
738 }
739#endif
740 }
741 return OK;
742}
743
744//=======================================================================
745//function : AddNormalOnTriangle
746//purpose :
747//=======================================================================
748
749void
750HLRBRep_PolyAlgo::
751AddNormalOnTriangle(const Standard_Integer iTri,
752 const Standard_Integer iNode,
753 Standard_Integer& jNode,
681f3919 754 HLRAlgo_Array1OfTData*& TData,
755 HLRAlgo_Array1OfPINod*& PINod,
7fd59977 756 Standard_Real& X,
757 Standard_Real& Y,
758 Standard_Real& Z,
759 Standard_Boolean& OK) const
760{
681f3919 761 HLRAlgo_TriangleData& aTriangle = TData->ChangeValue(iTri);
762 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues =
763 PINod->ChangeValue(aTriangle.Node1)->Data();
764 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues =
765 PINod->ChangeValue(aTriangle.Node2)->Data();
766 HLRAlgo_PolyInternalNode::NodeData& Nod3RValues =
767 PINod->ChangeValue(aTriangle.Node3)->Data();
768 const gp_XYZ aD1 = Nod2RValues.Point - Nod1RValues.Point;
769 const Standard_Real aD1Norm = aD1.Modulus();
770 if (aD1Norm < 1.e-10) {
771 if (aTriangle.Node1 == iNode) jNode = aTriangle.Node2;
772 else if (aTriangle.Node2 == iNode) jNode = aTriangle.Node1;
7fd59977 773 }
774 else {
681f3919 775 const gp_XYZ aD2 = Nod3RValues.Point - Nod2RValues.Point;
776 const Standard_Real aD2Norm = aD2.Modulus();
777 if (aD2Norm < 1.e-10) {
778 if (aTriangle.Node2 == iNode) jNode = aTriangle.Node3;
779 else if (aTriangle.Node3 == iNode) jNode = aTriangle.Node2;
7fd59977 780 }
781 else {
681f3919 782 const gp_XYZ aD3 = Nod1RValues.Point - Nod3RValues.Point;
783 const Standard_Real aD3Norm = aD3.Modulus();
784 if (aD3Norm < 1.e-10) {
785 if (aTriangle.Node3 == iNode) jNode = aTriangle.Node1;
786 else if (aTriangle.Node1 == iNode) jNode = aTriangle.Node3;
7fd59977 787 }
788 else {
681f3919 789 const gp_XYZ aDN = (1 / (aD1Norm * aD2Norm)) * (aD1 ^ aD2);
790 const Standard_Real aDNNorm = aDN.Modulus();
791 if (aDNNorm > 1.e-10) {
7fd59977 792 OK = Standard_True;
681f3919 793 X += aDN.X();
794 Y += aDN.Y();
795 Z += aDN.Z();
7fd59977 796 }
797 }
798 }
799 }
800}
801
802//=======================================================================
803//function : InitBiPointsWithConnexity
804//purpose :
805//=======================================================================
806
807void HLRBRep_PolyAlgo::
808InitBiPointsWithConnexity (const Standard_Integer e,
809 TopoDS_Edge& E,
810 HLRAlgo_ListOfBPoint& List,
811 TColStd_Array1OfTransient& PID,
812 TopTools_ListOfShape& LS,
813 const Standard_Boolean connex)
814{
815 Standard_Integer iPol,nbPol,i1,i1p1,i1p2,i2,i2p1,i2p2;
816 Standard_Real X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ;
817 Standard_Real XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2;
1d47d8d0 818 Standard_Real U1,U2 = 0.;
7fd59977 819 Handle(Poly_PolygonOnTriangulation) HPol[2];
820 TopLoc_Location L;
821 myBCurv.Initialize(E);
822 if (connex) {
823 Standard_Integer nbConnex = LS.Extent();
824 if (nbConnex == 1) {
825 TopTools_ListIteratorOfListOfShape itn(LS);
826 const TopoDS_Face& F1 = TopoDS::Face(itn.Value());
827 i1 = myFMap.FindIndex(F1);
828 const Handle(Poly_Triangulation)& Tr1 = BRep_Tool::Triangulation(F1,L);
829 HPol[0] = BRep_Tool::PolygonOnTriangulation(E,Tr1,L);
830 const Handle(HLRAlgo_PolyInternalData)& pid1 =
831 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(i1));
832 if (!HPol[0].IsNull()) {
833 myPC.Initialize(E,F1);
834 const Handle(TColStd_HArray1OfReal)& par = HPol[0]->Parameters();
835 const TColStd_Array1OfInteger& Pol1 = HPol[0]->Nodes();
836 nbPol = Pol1.Upper();
681f3919 837 HLRAlgo_Array1OfTData* TData1 = &pid1->TData();
838 HLRAlgo_Array1OfPISeg* PISeg1 = &pid1->PISeg();
839 HLRAlgo_Array1OfPINod* PINod1 = &pid1->PINod();
840 HLRAlgo_PolyInternalNode::NodeIndices* aNode11Indices;
841 HLRAlgo_PolyInternalNode::NodeIndices* aNode12Indices;
7fd59977 842 const Handle(HLRAlgo_PolyInternalNode)* pi1p1 =
843 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(Pol1(1 )));
681f3919 844 aNode11Indices = &(*pi1p1)->Indices();
845 HLRAlgo_PolyInternalNode::NodeData* Nod11RValues = &(*pi1p1)->Data();
7fd59977 846 const Handle(HLRAlgo_PolyInternalNode)* pi1p2 =
847 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(Pol1(nbPol)));
681f3919 848 aNode12Indices = &(*pi1p2)->Indices();
849 HLRAlgo_PolyInternalNode::NodeData* Nod12RValues = &(*pi1p2)->Data();
850 aNode11Indices->Flag |= NMsk_Vert;
851 aNode12Indices->Flag |= NMsk_Vert;
7fd59977 852
853 for (iPol = 1; iPol <= nbPol; iPol++) {
854 const Handle(HLRAlgo_PolyInternalNode)* pi1pA =
855 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(Pol1(iPol)));
681f3919 856 HLRAlgo_PolyInternalNode::NodeIndices& aNodeIndices1A = (*pi1pA)->Indices();
857 HLRAlgo_PolyInternalNode::NodeData& Nod1ARValues = (*pi1pA)->Data();
858 if (aNodeIndices1A.Edg1 == 0 || aNodeIndices1A.Edg1 == e) {
859 aNodeIndices1A.Edg1 = e;
860 Nod1ARValues.PCu1 = par->Value(iPol);
7fd59977 861 }
862 else {
681f3919 863 aNodeIndices1A.Edg2 = e;
864 Nod1ARValues.PCu2 = par->Value(iPol);
7fd59977 865 }
866 }
867
868 i1p2 = Pol1(1);
681f3919 869 aNode12Indices = aNode11Indices;
7fd59977 870 Nod12RValues = Nod11RValues;
681f3919 871 XTI2 = X2 = Nod12RValues->Point.X();
872 YTI2 = Y2 = Nod12RValues->Point.Y();
873 ZTI2 = Z2 = Nod12RValues->Point.Z();
874 if (aNode12Indices->Edg1 == e) U2 = Nod12RValues->PCu1;
875 else if (aNode12Indices->Edg2 == e) U2 = Nod12RValues->PCu2;
0797d9d3 876#ifdef OCCT_DEBUG
7fd59977 877 else {
878 cout << " HLRBRep_PolyAlgo::InitBiPointsWithConnexity : ";
879 cout << "Parameter error on Node " << i1p2 << endl;
880 }
881#endif
681f3919 882 aNode12Indices->Flag |= NMsk_Edge;
7fd59977 883 TIMultiply(XTI2,YTI2,ZTI2);
884 if (Pol1(1) == Pol1(nbPol) && myPC.IsPeriodic())
885 U2 = U2 - myPC.Period();
886
887 if (nbPol == 2 && BRep_Tool::Degenerated(E)) {
681f3919 888 CheckDegeneratedSegment(*aNode11Indices,*Nod11RValues,
889 *aNode12Indices,*Nod12RValues);
890 UpdateAroundNode(Pol1(1 ),*aNode11Indices,TData1,PISeg1,PINod1);
891 UpdateAroundNode(Pol1(nbPol),*aNode12Indices,TData1,PISeg1,PINod1);
7fd59977 892 }
893 else {
894
895 for (iPol = 2; iPol <= nbPol; iPol++) {
896 i1p1 = i1p2;
681f3919 897 aNode11Indices = aNode12Indices;
7fd59977 898 Nod11RValues = Nod12RValues;
899 i1p2 = Pol1(iPol);
51740958 900 const Handle(HLRAlgo_PolyInternalNode)* pi1p2iPol =
7fd59977 901 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(Pol1(iPol)));
681f3919 902 aNode12Indices = &(*pi1p2iPol)->Indices();
903 Nod12RValues = &(*pi1p2iPol)->Data();
0797d9d3 904#ifdef OCCT_DEBUG
7fd59977 905 if (DoError) {
681f3919 906 if (Nod11RValues->Normal.X()*Nod12RValues->Normal.X() +
907 Nod11RValues->Normal.Y()*Nod12RValues->Normal.Y() +
908 Nod11RValues->Normal.Z()*Nod12RValues->Normal.Z() < 0) {
7fd59977 909 cout << " HLRBRep_PolyAlgo::InitBiPointsWithConnexity : ";
910 cout << "Too big angle between " << i1p1 << setw(6);
911 cout << " and " << i1p2 << setw(6);
912 cout << " in face " << i1 << endl;
913 }
914 }
915#endif
916 X1 = X2;
917 Y1 = Y2;
918 Z1 = Z2;
919 XTI1 = XTI2;
920 YTI1 = YTI2;
921 ZTI1 = ZTI2;
922 U1 = U2;
681f3919 923 XTI2 = X2 = Nod12RValues->Point.X();
924 YTI2 = Y2 = Nod12RValues->Point.Y();
925 ZTI2 = Z2 = Nod12RValues->Point.Z();
926 if (aNode12Indices->Edg1 == e) U2 = Nod12RValues->PCu1;
927 else if (aNode12Indices->Edg2 == e) U2 = Nod12RValues->PCu2;
0797d9d3 928#ifdef OCCT_DEBUG
7fd59977 929 else {
930 cout << " HLRBRep_PolyAlgo::InitBiPointsWithConnexity : ";
931 cout << "Parameter error on Node " << i1p2 << endl;
932 }
933#endif
681f3919 934 aNode12Indices->Flag |= NMsk_Edge;
7fd59977 935 TIMultiply(XTI2,YTI2,ZTI2);
936 Interpolation(List,
937 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
938 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
939 e,U1,U2,
681f3919 940 *aNode11Indices,*Nod11RValues,
941 *aNode12Indices,*Nod12RValues,
7fd59977 942 i1p1,i1p2,i1,pid1,TData1,PISeg1,PINod1);
943 }
944 }
945 }
0797d9d3 946#ifdef OCCT_DEBUG
7fd59977 947 else if (DoError) {
948 cout << "HLRBRep_PolyAlgo::InitBiPointsWithConnexity : Edge ";
949 cout << e << " connex 1 sans PolygonOnTriangulation" << endl;
950 }
951#endif
952 }
953 else if (nbConnex == 2) {
954 TopTools_ListIteratorOfListOfShape itn(LS);
955 const TopoDS_Face& F1 = TopoDS::Face(itn.Value());
956 i1 = myFMap.FindIndex(F1);
957 const Handle(Poly_Triangulation)& Tr1 = BRep_Tool::Triangulation(F1,L);
958 HPol[0] = BRep_Tool::PolygonOnTriangulation(E,Tr1,L);
959 itn.Next();
960 const TopoDS_Face& F2 = TopoDS::Face(itn.Value());
961 i2 = myFMap.FindIndex(F2);
962 if (i1 == i2) E.Reverse();
963 const Handle(Poly_Triangulation)& Tr2 = BRep_Tool::Triangulation(F2,L);
964 HPol[1] = BRep_Tool::PolygonOnTriangulation(E,Tr2,L);
965 GeomAbs_Shape rg = BRep_Tool::Continuity(E,F1,F2);
966 const Handle(HLRAlgo_PolyInternalData)& pid1 =
967 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(i1));
968 const Handle(HLRAlgo_PolyInternalData)& pid2 =
969 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(i2));
970 if (!HPol[0].IsNull() && !HPol[1].IsNull()) {
971 myPC.Initialize(E,F1);
972 const TColStd_Array1OfInteger& Pol1 = HPol[0]->Nodes();
973 const TColStd_Array1OfInteger& Pol2 = HPol[1]->Nodes();
974 const Handle(TColStd_HArray1OfReal)& par = HPol[0]->Parameters();
51740958 975 Standard_Integer nbPol1 = Pol1.Upper();
681f3919 976 HLRAlgo_Array1OfTData* TData1 = &pid1->TData();
977 HLRAlgo_Array1OfPISeg* PISeg1 = &pid1->PISeg();
978 HLRAlgo_Array1OfPINod* PINod1 = &pid1->PINod();
979 HLRAlgo_Array1OfTData* TData2 = &pid2->TData();
980 HLRAlgo_Array1OfPISeg* PISeg2 = &pid2->PISeg();
981 HLRAlgo_Array1OfPINod* PINod2 = &pid2->PINod();
7fd59977 982 const Handle(HLRAlgo_PolyInternalNode)* pi1p1 =
681f3919 983 &PINod1->ChangeValue(Pol1(1));
984 HLRAlgo_PolyInternalNode::NodeIndices* aNode11Indices = &(*pi1p1)->Indices();
985 HLRAlgo_PolyInternalNode::NodeData* Nod11RValues = &(*pi1p1)->Data();
51740958 986 const Handle(HLRAlgo_PolyInternalNode)* pi1p2nbPol1 =
681f3919 987 &PINod1->ChangeValue(Pol1(nbPol1));
988 HLRAlgo_PolyInternalNode::NodeIndices* aNode12Indices = &(*pi1p2nbPol1)->Indices();
989 HLRAlgo_PolyInternalNode::NodeData* Nod12RValues = &(*pi1p2nbPol1)->Data();
7fd59977 990 const Handle(HLRAlgo_PolyInternalNode)* pi2p1 =
681f3919 991 &PINod2->ChangeValue(Pol2(1));
992 HLRAlgo_PolyInternalNode::NodeIndices* Nod21Indices = &(*pi2p1)->Indices();
993 HLRAlgo_PolyInternalNode::NodeData* Nod21RValues = &(*pi2p1)->Data();
7fd59977 994 const Handle(HLRAlgo_PolyInternalNode)* pi2p2 =
681f3919 995 &PINod2->ChangeValue(Pol2(nbPol1));
996 HLRAlgo_PolyInternalNode::NodeIndices* Nod22Indices = &(*pi2p2)->Indices();
997 HLRAlgo_PolyInternalNode::NodeData* Nod22RValues = &(*pi2p2)->Data();
998 aNode11Indices->Flag |= NMsk_Vert;
999 aNode12Indices->Flag |= NMsk_Vert;
1000 Nod21Indices->Flag |= NMsk_Vert;
1001 Nod22Indices->Flag |= NMsk_Vert;
7fd59977 1002
51740958 1003 for (iPol = 1; iPol <= nbPol1; iPol++) {
7fd59977 1004 const Handle(HLRAlgo_PolyInternalNode)* pi1pA =
681f3919 1005 &PINod1->ChangeValue(Pol1(iPol));
1006 HLRAlgo_PolyInternalNode::NodeIndices* Nod1AIndices = &(*pi1pA)->Indices();
1007 HLRAlgo_PolyInternalNode::NodeData* Nod1ARValues = &(*pi1pA)->Data();
7fd59977 1008 const Handle(HLRAlgo_PolyInternalNode)* pi2pA =
681f3919 1009 &PINod2->ChangeValue(Pol2(iPol));
1010 HLRAlgo_PolyInternalNode::NodeIndices* Nod2AIndices = &(*pi2pA)->Indices();
1011 HLRAlgo_PolyInternalNode::NodeData* Nod2ARValues = &(*pi2pA)->Data();
7fd59977 1012 Standard_Real PCu = par->Value(iPol);
681f3919 1013 if (Nod1AIndices->Edg1 == 0 || Nod1AIndices->Edg1 == e) {
1014 Nod1AIndices->Edg1 = e;
1015 Nod1ARValues->PCu1 = PCu;
7fd59977 1016 }
1017 else {
681f3919 1018 Nod1AIndices->Edg2 = e;
1019 Nod1ARValues->PCu2 = PCu;
7fd59977 1020 }
681f3919 1021 if (Nod2AIndices->Edg1 == 0 || Nod2AIndices->Edg1 == e) {
1022 Nod2AIndices->Edg1 = e;
1023 Nod2ARValues->PCu1 = PCu;
7fd59977 1024 }
1025 else {
681f3919 1026 Nod2AIndices->Edg2 = e;
1027 Nod2ARValues->PCu2 = PCu;
7fd59977 1028 }
1029 }
1030
1031 i1p2 = Pol1(1);
681f3919 1032 aNode12Indices = aNode11Indices;
7fd59977 1033 Nod12RValues = Nod11RValues;
1034 i2p2 = Pol2(1);
1035 Nod22Indices = Nod21Indices;
1036 Nod22RValues = Nod21RValues;
681f3919 1037 XTI2 = X2 = Nod12RValues->Point.X();
1038 YTI2 = Y2 = Nod12RValues->Point.Y();
1039 ZTI2 = Z2 = Nod12RValues->Point.Z();
1040 if (aNode12Indices->Edg1 == e) U2 = Nod12RValues->PCu1;
1041 else if (aNode12Indices->Edg2 == e) U2 = Nod12RValues->PCu2;
0797d9d3 1042#ifdef OCCT_DEBUG
7fd59977 1043 else {
1044 cout << " HLRBRep_PolyAlgo::InitBiPointsWithConnexity : ";
1045 cout << "Parameter error on Node " << i1p2 << endl;
1046 }
1047#endif
681f3919 1048 aNode12Indices->Flag |= NMsk_Edge;
1049 Nod22Indices->Flag |= NMsk_Edge;
7fd59977 1050 TIMultiply(XTI2,YTI2,ZTI2);
51740958 1051 if (Pol1(1) == Pol1(nbPol1) && myPC.IsPeriodic())
7fd59977 1052 U2 = U2 - myPC.Period();
1053
51740958 1054 if (nbPol1 == 2 && BRep_Tool::Degenerated(E)) {
681f3919 1055 CheckDegeneratedSegment(*aNode11Indices,*Nod11RValues,
1056 *aNode12Indices,*Nod12RValues);
1057 CheckDegeneratedSegment(*Nod21Indices,*Nod21RValues,
1058 *Nod22Indices,*Nod22RValues);
1059 UpdateAroundNode(Pol1(1 ),*aNode11Indices,TData1,PISeg1,PINod1);
1060 UpdateAroundNode(Pol1(nbPol1),*aNode12Indices,TData1,PISeg1,PINod1);
1061 UpdateAroundNode(Pol2(1 ),*Nod21Indices,TData2,PISeg2,PINod2);
1062 UpdateAroundNode(Pol2(nbPol1),*Nod22Indices,TData2,PISeg2,PINod2);
7fd59977 1063 }
1064 else {
1065
51740958 1066 for (iPol = 2; iPol <= nbPol1; iPol++) {
7fd59977 1067 i1p1 = i1p2;
681f3919 1068 aNode11Indices = aNode12Indices;
7fd59977 1069 Nod11RValues = Nod12RValues;
1070 i2p1 = i2p2;
1071 Nod21Indices = Nod22Indices;
1072 Nod21RValues = Nod22RValues;
1073 i1p2 = Pol1(iPol);
51740958 1074 const Handle(HLRAlgo_PolyInternalNode)* pi1p2iPol =
681f3919 1075 &PINod1->ChangeValue(Pol1(iPol));
1076 aNode12Indices = &(*pi1p2iPol)->Indices();
1077 Nod12RValues = &(*pi1p2iPol)->Data();
7fd59977 1078 i2p2 = Pol2(iPol);
51740958 1079 const Handle(HLRAlgo_PolyInternalNode)* pi2p2iPol =
681f3919 1080 &PINod2->ChangeValue(Pol2(iPol));
1081 Nod22Indices = &(*pi2p2iPol)->Indices();
1082 Nod22RValues = &(*pi2p2iPol)->Data();
0797d9d3 1083#ifdef OCCT_DEBUG
7fd59977 1084 if (DoError) {
681f3919 1085 if (Nod11RValues->Normal.X()*Nod12RValues->Normal.X() +
1086 Nod11RValues->Normal.Y()*Nod12RValues->Normal.Y() +
1087 Nod11RValues->Normal.Z()*Nod12RValues->Normal.Z() < 0) {
7fd59977 1088 cout << " HLRBRep_PolyAlgo::InitBiPointsWithConnexity : ";
1089 cout << "To big angle between " << i1p1 << setw(6);
1090 cout << " and " << i1p2 << setw(6);
1091 cout << " in face " << i1 << endl;
1092 }
681f3919 1093 if (Nod21RValues->Normal.X()*Nod22RValues->Normal.X() +
1094 Nod21RValues->Normal.Y()*Nod22RValues->Normal.Y() +
1095 Nod21RValues->Normal.Z()*Nod22RValues->Normal.Z() < 0) {
7fd59977 1096 cout << " HLRBRep_PolyAlgo::InitBiPointsWithConnexity : ";
1097 cout << "To big angle between " << i2p1 << setw(6);
1098 cout << " and " << i2p2 << setw(6);
1099 cout<< " in face " << i2 << endl;
1100 }
1101 }
1102#endif
1103 X1 = X2;
1104 Y1 = Y2;
1105 Z1 = Z2;
1106 XTI1 = XTI2;
1107 YTI1 = YTI2;
1108 ZTI1 = ZTI2;
1109 U1 = U2;
681f3919 1110 XTI2 = X2 = Nod12RValues->Point.X();
1111 YTI2 = Y2 = Nod12RValues->Point.Y();
1112 ZTI2 = Z2 = Nod12RValues->Point.Z();
1113 if (aNode12Indices->Edg1 == e) U2 = Nod12RValues->PCu1;
1114 else if (aNode12Indices->Edg2 == e) U2 = Nod12RValues->PCu2;
0797d9d3 1115#ifdef OCCT_DEBUG
7fd59977 1116 else {
1117 cout << " HLRBRep_PolyAlgo::InitBiPointsWithConnexity : ";
1118 cout << "Parameter error on Node " << i1p2 << endl;
1119 }
1120#endif
681f3919 1121 aNode12Indices->Flag |= NMsk_Edge;
1122 aNode12Indices->Flag |= NMsk_Edge;
7fd59977 1123 TIMultiply(XTI2,YTI2,ZTI2);
1124 Interpolation(List,
1125 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
1126 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1127 e,U1,U2,rg,
681f3919 1128 *aNode11Indices,*Nod11RValues,
1129 *aNode12Indices,*Nod12RValues,
7fd59977 1130 i1p1,i1p2,i1,pid1,TData1,PISeg1,PINod1,
681f3919 1131 *Nod21Indices,*Nod21RValues,
1132 *Nod22Indices,*Nod22RValues,
7fd59977 1133 i2p1,i2p2,i2,pid2,TData2,PISeg2,PINod2);
1134 }
1135 }
1136 }
0797d9d3 1137#ifdef OCCT_DEBUG
7fd59977 1138 else if (DoError) {
1139 cout << "HLRBRep_PolyAlgo::InitBiPointsWithConnexity : Edge ";
1140 cout << e << " connect 2 without PolygonOnTriangulation" << endl;
1141 }
1142#endif
1143 }
1144 }
1145 else { // no connexity
1146 const Handle(Poly_Polygon3D)& Polyg = BRep_Tool::Polygon3D(E,L);
1147 if (!Polyg.IsNull()) {
1148 const TColgp_Array1OfPnt& Pol = Polyg->Nodes();
1149 gp_Trsf TT = L.Transformation();
1150 const gp_Trsf& T = myProj.Transformation();
1151 TT.PreMultiply(T);
1152 const gp_XYZ& ttlo = TT.TranslationPart();
1153 TTLo[0] = ttlo.X();
1154 TTLo[1] = ttlo.Y();
1155 TTLo[2] = ttlo.Z();
1156 const gp_Mat& ttma = TT.VectorialPart();
1157 TTMa[0][0] = ttma.Value(1,1);
1158 TTMa[0][1] = ttma.Value(1,2);
1159 TTMa[0][2] = ttma.Value(1,3);
1160 TTMa[1][0] = ttma.Value(2,1);
1161 TTMa[1][1] = ttma.Value(2,2);
1162 TTMa[1][2] = ttma.Value(2,3);
1163 TTMa[2][0] = ttma.Value(3,1);
1164 TTMa[2][1] = ttma.Value(3,2);
1165 TTMa[2][2] = ttma.Value(3,3);
51740958 1166 Standard_Integer nbPol1 = Pol.Upper();
7fd59977 1167 const gp_XYZ& P1 = Pol(1).XYZ();
1168 X2 = P1.X();
1169 Y2 = P1.Y();
1170 Z2 = P1.Z();
1171 TTMultiply(X2,Y2,Z2);
1172 XTI2 = X2;
1173 YTI2 = Y2;
1174 ZTI2 = Z2;
1175 TIMultiply(XTI2,YTI2,ZTI2);
1176
51740958 1177 for (Standard_Integer jPol = 2; jPol <= nbPol1; jPol++) {
7fd59977 1178 X1 = X2;
1179 Y1 = Y2;
1180 Z1 = Z2;
1181 XTI1 = XTI2;
1182 YTI1 = YTI2;
1183 ZTI1 = ZTI2;
51740958 1184 const gp_XYZ& P2 = Pol(jPol).XYZ();
7fd59977 1185 X2 = P2.X();
1186 Y2 = P2.Y();
1187 Z2 = P2.Z();
1188 TTMultiply(X2,Y2,Z2);
1189 XTI2 = X2;
1190 YTI2 = Y2;
1191 ZTI2 = Z2;
1192 TIMultiply(XTI2,YTI2,ZTI2);
1193 List.Prepend(HLRAlgo_BiPoint
1194 (XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1195 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 , e,
1196 0));
1197 }
1198 }
0797d9d3 1199#ifdef OCCT_DEBUG
7fd59977 1200 else if (DoError) {
1201 cout << "HLRBRep_PolyAlgo::InitBiPointsWithConnexity : Edge ";
1202 cout << e << " Isolated, without Polygone 3D" << endl;
1203 }
1204#endif
1205 }
1206}
1207
1208//=======================================================================
1209//function : Interpolation
1210//purpose :
1211//=======================================================================
1212
1213void
1214HLRBRep_PolyAlgo::
1215Interpolation (HLRAlgo_ListOfBPoint& List,
1216 Standard_Real& X1,
1217 Standard_Real& Y1,
1218 Standard_Real& Z1,
1219 Standard_Real& X2,
1220 Standard_Real& Y2,
1221 Standard_Real& Z2,
1222 Standard_Real& XTI1,
1223 Standard_Real& YTI1,
1224 Standard_Real& ZTI1,
1225 Standard_Real& XTI2,
1226 Standard_Real& YTI2,
1227 Standard_Real& ZTI2,
1228 const Standard_Integer e,
1229 Standard_Real& U1,
1230 Standard_Real& U2,
681f3919 1231 HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices,
1232 HLRAlgo_PolyInternalNode::NodeData& Nod11RValues,
1233 HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices,
1234 HLRAlgo_PolyInternalNode::NodeData& Nod12RValues,
7fd59977 1235 const Standard_Integer i1p1,
1236 const Standard_Integer i1p2,
1237 const Standard_Integer i1,
1238 const Handle(HLRAlgo_PolyInternalData)& pid1,
681f3919 1239 HLRAlgo_Array1OfTData*& TData1,
1240 HLRAlgo_Array1OfPISeg*& PISeg1,
1241 HLRAlgo_Array1OfPINod*& PINod1) const
7fd59977 1242{
1243 Standard_Boolean insP3,mP3P1;
1244 Standard_Real X3,Y3,Z3,XTI3,YTI3,ZTI3,coef3,U3;
1245// gp_Pnt P3,PT3;
1246 insP3 = Interpolation(U1,U2,Nod11RValues,Nod12RValues,
1247 X3,Y3,Z3,XTI3,YTI3,ZTI3,coef3,U3,mP3P1);
1248 MoveOrInsertPoint(List,
1249 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
1250 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1251 e,U1,U2,
1252 Nod11Indices,Nod11RValues,
1253 Nod12Indices,Nod12RValues,
1254 i1p1,i1p2,i1,pid1,TData1,PISeg1,PINod1,
1255 X3,Y3,Z3,XTI3,YTI3,ZTI3,coef3,U3,insP3,mP3P1,0);
1256}
1257
1258//=======================================================================
1259//function : Interpolation
1260//purpose :
1261//=======================================================================
1262
1263void
1264HLRBRep_PolyAlgo::
1265Interpolation (HLRAlgo_ListOfBPoint& List,
1266 Standard_Real& X1,
1267 Standard_Real& Y1,
1268 Standard_Real& Z1,
1269 Standard_Real& X2,
1270 Standard_Real& Y2,
1271 Standard_Real& Z2,
1272 Standard_Real& XTI1,
1273 Standard_Real& YTI1,
1274 Standard_Real& ZTI1,
1275 Standard_Real& XTI2,
1276 Standard_Real& YTI2,
1277 Standard_Real& ZTI2,
1278 const Standard_Integer e,
1279 Standard_Real& U1,
1280 Standard_Real& U2,
1281 const GeomAbs_Shape rg,
681f3919 1282 HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices,
1283 HLRAlgo_PolyInternalNode::NodeData& Nod11RValues,
1284 HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices,
1285 HLRAlgo_PolyInternalNode::NodeData& Nod12RValues,
7fd59977 1286 const Standard_Integer i1p1,
1287 const Standard_Integer i1p2,
1288 const Standard_Integer i1,
1289 const Handle(HLRAlgo_PolyInternalData)& pid1,
681f3919 1290 HLRAlgo_Array1OfTData*& TData1,
1291 HLRAlgo_Array1OfPISeg*& PISeg1,
1292 HLRAlgo_Array1OfPINod*& PINod1,
1293 HLRAlgo_PolyInternalNode::NodeIndices& Nod21Indices,
1294 HLRAlgo_PolyInternalNode::NodeData& Nod21RValues,
1295 HLRAlgo_PolyInternalNode::NodeIndices& Nod22Indices,
1296 HLRAlgo_PolyInternalNode::NodeData& Nod22RValues,
7fd59977 1297 const Standard_Integer i2p1,
1298 const Standard_Integer i2p2,
1299 const Standard_Integer i2,
1300 const Handle(HLRAlgo_PolyInternalData)& pid2,
681f3919 1301 HLRAlgo_Array1OfTData*& TData2,
1302 HLRAlgo_Array1OfPISeg*& PISeg2,
1303 HLRAlgo_Array1OfPINod*& PINod2) const
7fd59977 1304{
1305 Standard_Boolean insP3,mP3P1,insP4,mP4P1;
1306 Standard_Real X3,Y3,Z3,XTI3,YTI3,ZTI3,coef3,U3;
1307 Standard_Real X4,Y4,Z4,XTI4,YTI4,ZTI4,coef4,U4;
1308// gp_Pnt P3,PT3,P4,PT4;
dde68833 1309 Standard_Integer flag = 0;
7fd59977 1310 if (rg >= GeomAbs_G1) flag += 1;
1311 if (rg >= GeomAbs_G2) flag += 2;
1312 insP3 = Interpolation(U1,U2,Nod11RValues,Nod12RValues,
1313 X3,Y3,Z3,XTI3,YTI3,ZTI3,coef3,U3,mP3P1);
1314 insP4 = Interpolation(U1,U2,Nod21RValues,Nod22RValues,
1315 X4,Y4,Z4,XTI4,YTI4,ZTI4,coef4,U4,mP4P1);
1316 Standard_Boolean OK = insP3 || insP4;
1317 if (OK) {
1318 if (!insP4) // p1 i1p3 p2
1319 MoveOrInsertPoint(List,
1320 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
1321 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1322 e,U1,U2,
1323 Nod11Indices,Nod11RValues,
1324 Nod12Indices,Nod12RValues,
1325 i1p1,i1p2,i1,pid1,TData1,PISeg1,PINod1,
1326 Nod21Indices,Nod21RValues,
1327 Nod22Indices,Nod22RValues,
1328 i2p1,i2p2,i2,pid2,TData2,PISeg2,PINod2,
1329 X3,Y3,Z3,XTI3,YTI3,ZTI3,coef3,U3,insP3,mP3P1,flag);
1330 else if (!insP3) // p1 i2p4 p2
1331 MoveOrInsertPoint(List,
1332 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
1333 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1334 e,U1,U2,
1335 Nod21Indices,Nod21RValues,
1336 Nod22Indices,Nod22RValues,
1337 i2p1,i2p2,i2,pid2,TData2,PISeg2,PINod2,
1338 Nod11Indices,Nod11RValues,
1339 Nod12Indices,Nod12RValues,
1340 i1p1,i1p2,i1,pid1,TData1,PISeg1,PINod1,
1341 X4,Y4,Z4,XTI4,YTI4,ZTI4,coef4,U4,insP4,mP4P1,flag);
1342 else if (Abs(coef4 - coef3) < myTolSta) // p1 i1p3-i2p4 p2
1343 MoveOrInsertPoint(List,
1344 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
1345 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1346 e,U1,U2,
1347 Nod21Indices,Nod21RValues,
1348 Nod22Indices,Nod22RValues,
1349 i2p1,i2p2,i2,pid2,TData2,PISeg2,PINod2,
1350 Nod11Indices,Nod11RValues,
1351 Nod12Indices,Nod12RValues,
1352 i1p1,i1p2,i1,pid1,TData1,PISeg1,PINod1,
1353 X4,Y4,Z4,XTI4,YTI4,ZTI4,coef4,U4,insP4,mP4P1,flag);
1354 else if (coef4 < coef3) // p1 i2p4 i1p3 p2
1355 MoveOrInsertPoint(List,
1356 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
1357 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1358 e,U1,U2,
1359 Nod21Indices,Nod21RValues,
1360 Nod22Indices,Nod22RValues,
1361 i2p1,i2p2,i2,pid2,TData2,PISeg2,PINod2,
1362 Nod11Indices,Nod11RValues,
1363 Nod12Indices,Nod12RValues,
1364 i1p1,i1p2,i1,pid1,TData1,PISeg1,PINod1,
1365 X4,Y4,Z4,XTI4,YTI4,ZTI4,coef4,U4,insP4,mP4P1,
1366 X3,Y3,Z3,XTI3,YTI3,ZTI3,coef3,U3,insP3,mP3P1,flag);
1367 else // p1 i1p3 i2p4 p2
1368 MoveOrInsertPoint(List,
1369 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
1370 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1371 e,U1,U2,
1372 Nod11Indices,Nod11RValues,
1373 Nod12Indices,Nod12RValues,
1374 i1p1,i1p2,i1,pid1,TData1,PISeg1,PINod1,
1375 Nod21Indices,Nod21RValues,
1376 Nod22Indices,Nod22RValues,
1377 i2p1,i2p2,i2,pid2,TData2,PISeg2,PINod2,
1378 X3,Y3,Z3,XTI3,YTI3,ZTI3,coef3,U3,insP3,mP3P1,
1379 X4,Y4,Z4,XTI4,YTI4,ZTI4,coef4,U4,insP4,mP4P1,flag);
1380 }
1381 else // p1 p2
1382 List.Prepend(HLRAlgo_BiPoint
1383 (XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1384 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 , e,
1385 i1 ,i1p1,i1p2,i2 ,i2p1,i2p2,flag));
1386}
1387
1388//=======================================================================
1389//function : Interpolation
1390//purpose :
1391//=======================================================================
1392
1393Standard_Boolean
1394HLRBRep_PolyAlgo::
1395Interpolation (const Standard_Real U1,
1396 const Standard_Real U2,
681f3919 1397 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
1398 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues,
7fd59977 1399 Standard_Real& X3,
1400 Standard_Real& Y3,
1401 Standard_Real& Z3,
1402 Standard_Real& XTI3,
1403 Standard_Real& YTI3,
1404 Standard_Real& ZTI3,
1405 Standard_Real& coef3,
1406 Standard_Real& U3,
1407 Standard_Boolean& mP3P1) const
1408{
1409 if (NewNode(Nod1RValues,Nod2RValues,coef3,mP3P1)) {
1410 U3 = U1 + (U2 - U1) * coef3;
1411 const gp_Pnt& P3 = myBCurv.Value(U3);
1412 XTI3 = X3 = P3.X();
1413 YTI3 = Y3 = P3.Y();
1414 ZTI3 = Z3 = P3.Z();
1415 TMultiply(X3,Y3,Z3);
1416 return Standard_True;
1417 }
7c65581d 1418 X3 = Y3 = Z3 = XTI3 = YTI3 = ZTI3 = coef3 = U3 = 0.;
7fd59977 1419 return Standard_False;
1420}
1421
1422//=======================================================================
1423//function : MoveOrInsertPoint
1424//purpose :
1425//=======================================================================
1426
1427void
1428HLRBRep_PolyAlgo::
1429MoveOrInsertPoint (HLRAlgo_ListOfBPoint& List,
1430 Standard_Real& X1,
1431 Standard_Real& Y1,
1432 Standard_Real& Z1,
1433 Standard_Real& X2,
1434 Standard_Real& Y2,
1435 Standard_Real& Z2,
1436 Standard_Real& XTI1,
1437 Standard_Real& YTI1,
1438 Standard_Real& ZTI1,
1439 Standard_Real& XTI2,
1440 Standard_Real& YTI2,
1441 Standard_Real& ZTI2,
1442 const Standard_Integer e,
1443 Standard_Real& U1,
1444 Standard_Real& U2,
681f3919 1445 HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices,
1446 HLRAlgo_PolyInternalNode::NodeData& Nod11RValues,
1447 HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices,
1448 HLRAlgo_PolyInternalNode::NodeData& Nod12RValues,
7fd59977 1449 const Standard_Integer i1p1,
1450 const Standard_Integer i1p2,
1451 const Standard_Integer i1,
1452 const Handle(HLRAlgo_PolyInternalData)& pid1,
681f3919 1453 HLRAlgo_Array1OfTData*& TData1,
1454 HLRAlgo_Array1OfPISeg*& PISeg1,
1455 HLRAlgo_Array1OfPINod*& PINod1,
7fd59977 1456 const Standard_Real X3,
1457 const Standard_Real Y3,
1458 const Standard_Real Z3,
1459 const Standard_Real XTI3,
1460 const Standard_Real YTI3,
1461 const Standard_Real ZTI3,
1462 const Standard_Real coef3,
1463 const Standard_Real U3,
1464 const Standard_Boolean insP3,
1465 const Standard_Boolean mP3P1,
dde68833 1466 const Standard_Integer flag) const
7fd59977 1467{
681f3919 1468 HLRAlgo_Array1OfTData* TData2 = 0;
1469 HLRAlgo_Array1OfPISeg* PISeg2 = 0;
1470 HLRAlgo_Array1OfPINod* PINod2 = 0;
7fd59977 1471 Standard_Boolean ins3 = insP3;
1472 if (ins3 && mP3P1) { // P1 ---> P3
681f3919 1473 if (!(Nod11Indices.Flag & NMsk_Vert) && coef3 < myTolSta) {
7fd59977 1474 ins3 = Standard_False;
1475 ChangeNode(i1p1,i1p2,
1476 Nod11Indices,Nod11RValues,
1477 Nod12Indices,Nod12RValues,
1478 coef3,X3,Y3,Z3,Standard_True,
1479 TData1,PISeg1,PINod1);
1480 X1 = X3;
1481 Y1 = Y3;
1482 Z1 = Z3;
1483 XTI1 = XTI3;
1484 YTI1 = YTI3;
1485 ZTI1 = ZTI3;
1486 U1 = U3;
681f3919 1487 Nod11RValues.Point = gp_XYZ(X3, Y3, Z3);
1488 if (Nod11Indices.Edg1 == e) Nod11RValues.PCu1 = U3;
1489 else if (Nod11Indices.Edg2 == e) Nod11RValues.PCu2 = U3;
0797d9d3 1490#ifdef OCCT_DEBUG
7fd59977 1491 else {
1492 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1493 cout << "Parameter error on Node " << i1p1 << endl;
1494 }
1495#endif
681f3919 1496 Nod11RValues.Scal = 0;
1497 Nod11Indices.Flag |= NMsk_OutL;
7fd59977 1498 UpdateAroundNode(i1p1,Nod11Indices,TData1,PISeg1,PINod1);
681f3919 1499 HLRAlgo_BiPoint::PointsT& aPoints = List.First().Points();
1500 aPoints.PntP2 = gp_XYZ(X3, Y3, Z3);
1501 aPoints.Pnt2 = gp_XYZ(XTI3, YTI3, ZTI3);
7fd59977 1502 }
1503 }
1504 if (ins3 && !mP3P1) { // P2 ---> P3
681f3919 1505 if (!(Nod12Indices.Flag & NMsk_Vert) && coef3 > myTolEnd) {
7fd59977 1506 ins3 = Standard_False;
1507 ChangeNode(i1p1,i1p2,
1508 Nod11Indices,Nod11RValues,
1509 Nod12Indices,Nod12RValues,
1510 coef3,X3,Y3,Z3,Standard_False,
1511 TData1,PISeg1,PINod1);
1512 X2 = X3;
1513 Y2 = Y3;
1514 Z2 = Z3;
1515 XTI2 = XTI3;
1516 YTI2 = YTI3;
1517 ZTI2 = ZTI3;
1518 U2 = U3;
681f3919 1519 Nod12RValues.Point = gp_XYZ(X3, Y3, Z3);
1520 if (Nod12Indices.Edg1 == e) Nod12RValues.PCu1 = U3;
1521 else if (Nod12Indices.Edg2 == e) Nod12RValues.PCu2 = U3;
0797d9d3 1522#ifdef OCCT_DEBUG
7fd59977 1523 else {
1524 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1525 cout << "Parameter error on Node " << i1p2 << endl;
1526 }
1527#endif
681f3919 1528 Nod12RValues.Scal = 0;
1529 Nod12Indices.Flag |= NMsk_OutL;
7fd59977 1530 UpdateAroundNode(i1p2,Nod12Indices,TData1,PISeg1,PINod1);
1531 }
1532 }
1533 if (ins3) { // p1 i1p3 p2
1534 Standard_Integer i1p3 = pid1->AddNode
1535 (Nod11RValues,Nod12RValues,PINod1,PINod2,coef3,X3,Y3,Z3);
1536 const Handle(HLRAlgo_PolyInternalNode)* pi1p3 =
1537 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(i1p3));
681f3919 1538 HLRAlgo_PolyInternalNode::NodeIndices& Nod13Indices = (*pi1p3)->Indices();
1539 HLRAlgo_PolyInternalNode::NodeData& Nod13RValues = (*pi1p3)->Data();
1540 Nod13Indices.Edg1 = e;
1541 Nod13RValues.PCu1 = U3;
1542 Nod13RValues.Scal = 0;
1543 Nod13Indices.Flag |= NMsk_OutL;
1544 Nod13Indices.Flag |= NMsk_Edge;
7fd59977 1545 pid1->UpdateLinks(i1p1,i1p2,i1p3,
1546 TData1,TData2,PISeg1,PISeg2,PINod1,PINod2);
1547 UpdateAroundNode(i1p3,Nod13Indices,TData1,PISeg1,PINod1);
1548 List.Prepend(HLRAlgo_BiPoint
1549 (XTI1,YTI1,ZTI1,XTI3,YTI3,ZTI3,
1550 X1 ,Y1 ,Z1 ,X3 ,Y3 ,Z3 , e,
1551 i1 ,i1p1,i1p3,flag));
1552 List.Prepend(HLRAlgo_BiPoint
1553 (XTI3,YTI3,ZTI3,XTI2,YTI2,ZTI2,
1554 X3 ,Y3 ,Z3 ,X2 ,Y2 ,Z2 , e,
1555 i1 ,i1p3,i1p2,flag));
1556 }
1557 else // p1 p2
1558 List.Prepend(HLRAlgo_BiPoint
1559 (XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1560 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 , e,
1561 i1 ,i1p1,i1p2,flag));
1562}
1563
1564//=======================================================================
1565//function : MoveOrInsertPoint
1566//purpose :
1567//=======================================================================
1568
1569void
1570HLRBRep_PolyAlgo::
1571MoveOrInsertPoint (HLRAlgo_ListOfBPoint& List,
1572 Standard_Real& X1,
1573 Standard_Real& Y1,
1574 Standard_Real& Z1,
1575 Standard_Real& X2,
1576 Standard_Real& Y2,
1577 Standard_Real& Z2,
1578 Standard_Real& XTI1,
1579 Standard_Real& YTI1,
1580 Standard_Real& ZTI1,
1581 Standard_Real& XTI2,
1582 Standard_Real& YTI2,
1583 Standard_Real& ZTI2,
1584 const Standard_Integer e,
1585 Standard_Real& U1,
1586 Standard_Real& U2,
681f3919 1587 HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices,
1588 HLRAlgo_PolyInternalNode::NodeData& Nod11RValues,
1589 HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices,
1590 HLRAlgo_PolyInternalNode::NodeData& Nod12RValues,
7fd59977 1591 const Standard_Integer i1p1,
1592 const Standard_Integer i1p2,
1593 const Standard_Integer i1,
1594 const Handle(HLRAlgo_PolyInternalData)& pid1,
681f3919 1595 HLRAlgo_Array1OfTData*& TData1,
1596 HLRAlgo_Array1OfPISeg*& PISeg1,
1597 HLRAlgo_Array1OfPINod*& PINod1,
1598 HLRAlgo_PolyInternalNode::NodeIndices& Nod21Indices,
1599 HLRAlgo_PolyInternalNode::NodeData& Nod21RValues,
1600 HLRAlgo_PolyInternalNode::NodeIndices& Nod22Indices,
1601 HLRAlgo_PolyInternalNode::NodeData& Nod22RValues,
7fd59977 1602 const Standard_Integer i2p1,
1603 const Standard_Integer i2p2,
1604 const Standard_Integer i2,
1605 const Handle(HLRAlgo_PolyInternalData)& pid2,
681f3919 1606 HLRAlgo_Array1OfTData*& TData2,
1607 HLRAlgo_Array1OfPISeg*& PISeg2,
1608 HLRAlgo_Array1OfPINod*& PINod2,
7fd59977 1609 const Standard_Real X3,
1610 const Standard_Real Y3,
1611 const Standard_Real Z3,
1612 const Standard_Real XTI3,
1613 const Standard_Real YTI3,
1614 const Standard_Real ZTI3,
1615 const Standard_Real coef3,
1616 const Standard_Real U3,
1617 const Standard_Boolean insP3,
1618 const Standard_Boolean mP3P1,
dde68833 1619 const Standard_Integer flag) const
7fd59977 1620{
1621 Standard_Boolean ins3 = insP3;
1622 if (ins3 && mP3P1) { // P1 ---> P3
681f3919 1623 if (!(Nod11Indices.Flag & NMsk_Vert) && coef3 < myTolSta) {
7fd59977 1624 ins3 = Standard_False;
1625 ChangeNode(i1p1,i1p2,
1626 Nod11Indices,Nod11RValues,
1627 Nod12Indices,Nod12RValues,
1628 coef3,X3,Y3,Z3,Standard_True,
1629 TData1,PISeg1,PINod1);
1630 ChangeNode(i2p1,i2p2,
1631 Nod21Indices,Nod21RValues,
1632 Nod22Indices,Nod22RValues,
1633 coef3,X3,Y3,Z3,Standard_True,
1634 TData2,PISeg2,PINod2);
1635 X1 = X3;
1636 Y1 = Y3;
1637 Z1 = Z3;
1638 XTI1 = XTI3;
1639 YTI1 = YTI3;
1640 ZTI1 = ZTI3;
1641 U1 = U3;
681f3919 1642 Nod11RValues.Point = gp_XYZ(X3, Y3, Z3);
1643 if (Nod11Indices.Edg1 == e) Nod11RValues.PCu1 = U3;
1644 else if (Nod11Indices.Edg2 == e) Nod11RValues.PCu2 = U3;
0797d9d3 1645#ifdef OCCT_DEBUG
7fd59977 1646 else {
1647 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1648 cout << "Parameter error on Node " << i1p1 << endl;
1649 }
1650#endif
681f3919 1651 Nod11RValues.Scal = 0;
1652 Nod11Indices.Flag |= NMsk_OutL;
7fd59977 1653 UpdateAroundNode(i1p1,Nod11Indices,TData1,PISeg1,PINod1);
681f3919 1654 Nod21RValues.Point = gp_XYZ(X3, Y3, Z3);
1655 if (Nod21Indices.Edg1 == e) Nod21RValues.PCu1 = U3;
1656 else if (Nod21Indices.Edg2 == e) Nod21RValues.PCu2 = U3;
0797d9d3 1657#ifdef OCCT_DEBUG
7fd59977 1658 else {
1659 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1660 cout << "Parameter error on Node " << i2p1 << endl;
1661 }
1662#endif
681f3919 1663 Nod21RValues.Scal = 0;
1664 Nod21Indices.Flag |= NMsk_OutL;
7fd59977 1665 UpdateAroundNode(i2p1,Nod21Indices,TData2,PISeg2,PINod2);
681f3919 1666 HLRAlgo_BiPoint::PointsT& aPoints = List.First().Points();
1667 aPoints.PntP2 = gp_XYZ(X3, Y3, Z3);
1668 aPoints.Pnt2 = gp_XYZ(XTI3, YTI3, ZTI3);
7fd59977 1669 }
1670 }
1671 if (ins3 && !mP3P1) { // P2 ---> P3
681f3919 1672 if (!(Nod12Indices.Flag & NMsk_Vert) && coef3 > myTolEnd) {
7fd59977 1673 ins3 = Standard_False;
1674 ChangeNode(i1p1,i1p2,
1675 Nod11Indices,Nod11RValues,
1676 Nod12Indices,Nod12RValues,
1677 coef3,X3,Y3,Z3,Standard_False,
1678 TData1,PISeg1,PINod1);
1679 ChangeNode(i2p1,i2p2,
1680 Nod21Indices,Nod21RValues,
1681 Nod22Indices,Nod22RValues,
1682 coef3,X3,Y3,Z3,Standard_False,
1683 TData2,PISeg2,PINod2);
1684 X2 = X3;
1685 Y2 = Y3;
1686 Z2 = Z3;
1687 XTI2 = XTI3;
1688 YTI2 = YTI3;
1689 ZTI2 = ZTI3;
1690 U2 = U3;
681f3919 1691 Nod12RValues.Point = gp_XYZ(X3, Y3, Z3);
1692 if (Nod12Indices.Edg1 == e) Nod12RValues.PCu1 = U3;
1693 else if (Nod12Indices.Edg2 == e) Nod12RValues.PCu2 = U3;
0797d9d3 1694#ifdef OCCT_DEBUG
7fd59977 1695 else {
1696 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1697 cout << "Parameter error on Node " << i1p2 << endl;
1698 }
1699#endif
681f3919 1700 Nod12RValues.Scal = 0;
1701 Nod12Indices.Flag |= NMsk_OutL;
7fd59977 1702 UpdateAroundNode(i1p2,Nod12Indices,TData1,PISeg1,PINod1);
681f3919 1703 Nod22RValues.Point = gp_XYZ(X3, Y3, Z3);
1704 if (Nod22Indices.Edg1 == e) Nod22RValues.PCu1 = U3;
1705 else if (Nod22Indices.Edg2 == e) Nod22RValues.PCu2 = U3;
0797d9d3 1706#ifdef OCCT_DEBUG
7fd59977 1707 else {
1708 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1709 cout << "Parameter error on Node " << i2p2 << endl;
1710 }
1711#endif
681f3919 1712 Nod22RValues.Scal = 0;
1713 Nod22Indices.Flag |= NMsk_OutL;
7fd59977 1714 UpdateAroundNode(i2p2,Nod22Indices,TData2,PISeg2,PINod2);
1715 }
1716 }
1717 if (ins3) { // p1 i1p3 p2
1718 Standard_Integer i1p3 = pid1->AddNode
1719 (Nod11RValues,Nod12RValues,PINod1,PINod2,coef3,X3,Y3,Z3);
1720 Standard_Integer i2p3 = pid2->AddNode
1721 (Nod21RValues,Nod22RValues,PINod2,PINod1,coef3,X3,Y3,Z3);
1722 const Handle(HLRAlgo_PolyInternalNode)* pi1p3 =
1723 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(i1p3));
681f3919 1724 HLRAlgo_PolyInternalNode::NodeIndices& Nod13Indices = (*pi1p3)->Indices();
1725 HLRAlgo_PolyInternalNode::NodeData& Nod13RValues = (*pi1p3)->Data();
7fd59977 1726 const Handle(HLRAlgo_PolyInternalNode)* pi2p3 =
1727 &(((HLRAlgo_Array1OfPINod*)PINod2)->ChangeValue(i2p3));
681f3919 1728 HLRAlgo_PolyInternalNode::NodeIndices& Nod23Indices = (*pi2p3)->Indices();
1729 HLRAlgo_PolyInternalNode::NodeData& Nod23RValues = (*pi2p3)->Data();
1730 Nod13Indices.Edg1 = e;
1731 Nod13RValues.PCu1 = U3;
1732 Nod13RValues.Scal = 0;
1733 Nod13Indices.Flag |= NMsk_OutL;
1734 Nod13Indices.Flag |= NMsk_Edge;
1735 Nod23Indices.Edg1 = e;
1736 Nod23RValues.PCu1 = U3;
1737 Nod23RValues.Scal = 0;
1738 Nod23Indices.Flag |= NMsk_OutL;
1739 Nod23Indices.Flag |= NMsk_Edge;
7fd59977 1740 pid1->UpdateLinks(i1p1,i1p2,i1p3,
1741 TData1,TData2,PISeg1,PISeg2,PINod1,PINod2);
1742 pid2->UpdateLinks(i2p1,i2p2,i2p3,
1743 TData2,TData1,PISeg2,PISeg1,PINod2,PINod1);
1744 UpdateAroundNode(i1p3,Nod13Indices,TData1,PISeg1,PINod1);
1745 UpdateAroundNode(i2p3,Nod23Indices,TData2,PISeg2,PINod2);
1746 List.Prepend(HLRAlgo_BiPoint
1747 (XTI1,YTI1,ZTI1,XTI3,YTI3,ZTI3,
1748 X1 ,Y1 ,Z1 ,X3 ,Y3 ,Z3 , e,
1749 i1 ,i1p1,i1p3,i2 ,i2p1,i2p3,flag));
1750 List.Prepend(HLRAlgo_BiPoint
1751 (XTI3,YTI3,ZTI3,XTI2,YTI2,ZTI2,
1752 X3 ,Y3 ,Z3 ,X2 ,Y2 ,Z2 , e,
1753 i1 ,i1p3,i1p2,i2 ,i2p3,i2p2,flag));
1754 }
1755 else // p1 p2
1756 List.Prepend(HLRAlgo_BiPoint
1757 (XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1758 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 , e,
1759 i1 ,i1p1,i1p2,i2 ,i2p1,i2p2,flag));
1760}
1761
1762//=======================================================================
1763//function : MoveOrInsertPoint
1764//purpose :
1765//=======================================================================
1766
1767void
1768HLRBRep_PolyAlgo::
1769MoveOrInsertPoint (HLRAlgo_ListOfBPoint& List,
1770 Standard_Real& X1,
1771 Standard_Real& Y1,
1772 Standard_Real& Z1,
1773 Standard_Real& X2,
1774 Standard_Real& Y2,
1775 Standard_Real& Z2,
1776 Standard_Real& XTI1,
1777 Standard_Real& YTI1,
1778 Standard_Real& ZTI1,
1779 Standard_Real& XTI2,
1780 Standard_Real& YTI2,
1781 Standard_Real& ZTI2,
1782 const Standard_Integer e,
1783 Standard_Real& U1,
1784 Standard_Real& U2,
681f3919 1785 HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices,
1786 HLRAlgo_PolyInternalNode::NodeData& Nod11RValues,
1787 HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices,
1788 HLRAlgo_PolyInternalNode::NodeData& Nod12RValues,
7fd59977 1789 const Standard_Integer i1p1,
1790 const Standard_Integer i1p2,
1791 const Standard_Integer i1,
1792 const Handle(HLRAlgo_PolyInternalData)& pid1,
681f3919 1793 HLRAlgo_Array1OfTData*& TData1,
1794 HLRAlgo_Array1OfPISeg*& PISeg1,
1795 HLRAlgo_Array1OfPINod*& PINod1,
1796 HLRAlgo_PolyInternalNode::NodeIndices& Nod21Indices,
1797 HLRAlgo_PolyInternalNode::NodeData& Nod21RValues,
1798 HLRAlgo_PolyInternalNode::NodeIndices& Nod22Indices,
1799 HLRAlgo_PolyInternalNode::NodeData& Nod22RValues,
7fd59977 1800 const Standard_Integer i2p1,
1801 const Standard_Integer i2p2,
1802 const Standard_Integer i2,
1803 const Handle(HLRAlgo_PolyInternalData)& pid2,
681f3919 1804 HLRAlgo_Array1OfTData*& TData2,
1805 HLRAlgo_Array1OfPISeg*& PISeg2,
1806 HLRAlgo_Array1OfPINod*& PINod2,
7fd59977 1807 const Standard_Real X3,
1808 const Standard_Real Y3,
1809 const Standard_Real Z3,
1810 const Standard_Real XTI3,
1811 const Standard_Real YTI3,
1812 const Standard_Real ZTI3,
1813 const Standard_Real coef3,
1814 const Standard_Real U3,
1815 const Standard_Boolean insP3,
1816 const Standard_Boolean mP3P1,
1817 const Standard_Real X4,
1818 const Standard_Real Y4,
1819 const Standard_Real Z4,
1820 const Standard_Real XTI4,
1821 const Standard_Real YTI4,
1822 const Standard_Real ZTI4,
1823 const Standard_Real coef4,
1824 const Standard_Real U4,
1825 const Standard_Boolean insP4,
1826 const Standard_Boolean mP4P1,
dde68833 1827 const Standard_Integer flag) const
7fd59977 1828{
1829 Standard_Boolean ins3 = insP3;
1830 Standard_Boolean ins4 = insP4;
1831 if (ins3 && mP3P1) { // P1 ---> P3
681f3919 1832 if (!(Nod11Indices.Flag & NMsk_Vert) && coef3 < myTolSta) {
7fd59977 1833 ins3 = Standard_False;
1834 ChangeNode(i1p1,i1p2,
1835 Nod11Indices,Nod11RValues,
1836 Nod12Indices,Nod12RValues,
1837 coef3,X3,Y3,Z3,Standard_True,
1838 TData1,PISeg1,PINod1);
1839 ChangeNode(i2p1,i2p2,
1840 Nod21Indices,Nod21RValues,
1841 Nod22Indices,Nod22RValues,
1842 coef3,X3,Y3,Z3,Standard_True,
1843 TData2,PISeg2,PINod2);
1844 X1 = X3;
1845 Y1 = Y3;
1846 Z1 = Z3;
1847 XTI1 = XTI3;
1848 YTI1 = YTI3;
1849 ZTI1 = ZTI3;
1850 U1 = U3;
681f3919 1851 Nod11RValues.Point = gp_XYZ(X3, Y3, Z3);
1852 if (Nod11Indices.Edg1 == e) Nod11RValues.PCu1 = U3;
1853 else if (Nod11Indices.Edg2 == e) Nod11RValues.PCu2 = U3;
0797d9d3 1854#ifdef OCCT_DEBUG
7fd59977 1855 else {
1856 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1857 cout << "Parameter error on Node " << i1p1 << endl;
1858 }
1859#endif
681f3919 1860 Nod11RValues.Scal = 0;
1861 Nod11Indices.Flag |= NMsk_OutL;
7fd59977 1862 UpdateAroundNode(i1p1,Nod11Indices,TData1,PISeg1,PINod1);
681f3919 1863 Nod21RValues.Point = gp_XYZ(X3, Y3, Z3);
1864 if (Nod21Indices.Edg1 == e) Nod21RValues.PCu1 = U3;
1865 else if (Nod21Indices.Edg2 == e) Nod21RValues.PCu2 = U3;
0797d9d3 1866#ifdef OCCT_DEBUG
7fd59977 1867 else {
1868 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1869 cout << "Parameter error on Node " << i2p1 << endl;
1870 }
1871#endif
681f3919 1872 Nod21RValues.Scal = 0;
1873 Nod21Indices.Flag |= NMsk_OutL;
7fd59977 1874 UpdateAroundNode(i2p1,Nod21Indices,TData2,PISeg2,PINod2);
681f3919 1875 HLRAlgo_BiPoint::PointsT& aPoints = List.First().Points();
1876 aPoints.PntP2 = gp_XYZ(X3, Y3, Z3);
1877 aPoints.Pnt2 = gp_XYZ(XTI3, YTI3, ZTI3);
7fd59977 1878 }
1879 }
1880 if (ins4 && !mP4P1) { // P2 ---> P4
681f3919 1881 if (!(Nod12Indices.Flag & NMsk_Vert) && coef4 > myTolEnd) {
7fd59977 1882 ins4 = Standard_False;
1883 ChangeNode(i2p1,i2p2,
1884 Nod21Indices,Nod21RValues,
1885 Nod22Indices,Nod22RValues,
1886 coef4,X4,Y4,Z4,Standard_False,
1887 TData2,PISeg2,PINod2);
1888 ChangeNode(i1p1,i1p2,
1889 Nod11Indices,Nod11RValues,
1890 Nod12Indices,Nod12RValues,
1891 coef4,X4,Y4,Z4,Standard_False,
1892 TData1,PISeg1,PINod1);
1893 X2 = X4;
1894 Y2 = Y4;
1895 Z2 = Z4;
1896 XTI2 = XTI4;
1897 YTI2 = YTI4;
1898 ZTI2 = ZTI4;
1899 U2 = U4;
681f3919 1900 Nod12RValues.Point = gp_XYZ(X4, Y4, Z4);
1901 if (Nod12Indices.Edg1 == e) Nod12RValues.PCu1 = U4;
1902 else if (Nod12Indices.Edg2 == e) Nod12RValues.PCu2 = U4;
0797d9d3 1903#ifdef OCCT_DEBUG
7fd59977 1904 else {
1905 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1906 cout << "Parameter error on Node " << i1p2 << endl;
1907 }
1908#endif
681f3919 1909 Nod12RValues.Scal = 0;
1910 Nod12Indices.Flag |= NMsk_OutL;
7fd59977 1911 UpdateAroundNode(i1p2,Nod12Indices,TData1,PISeg1,PINod1);
681f3919 1912 Nod22RValues.Point = gp_XYZ(X4, Y4, Z4);
1913 if (Nod22Indices.Edg1 == e) Nod22RValues.PCu1 = U4;
1914 else if (Nod22Indices.Edg2 == e) Nod22RValues.PCu2 = U4;
0797d9d3 1915#ifdef OCCT_DEBUG
7fd59977 1916 else {
1917 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1918 cout << "Parameter error on Node " << i2p2 << endl;
1919 }
1920#endif
681f3919 1921 Nod22RValues.Scal = 0;
1922 Nod22Indices.Flag |= NMsk_OutL;
7fd59977 1923 UpdateAroundNode(i2p2,Nod22Indices,TData2,PISeg2,PINod2);
1924 }
1925 }
1926 if (ins3 || ins4) {
1927 if (!ins4) // p1 i1p3 p2
1928 MoveOrInsertPoint(List,
1929 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
1930 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1931 e,U1,U2,
1932 Nod11Indices,Nod11RValues,
1933 Nod12Indices,Nod12RValues,
1934 i1p1,i1p2,i1,pid1,TData1,PISeg1,PINod1,
1935 Nod21Indices,Nod21RValues,
1936 Nod22Indices,Nod22RValues,
1937 i2p1,i2p2,i2,pid2,TData2,PISeg2,PINod2,
1938 X3,Y3,Z3,XTI3,YTI3,ZTI3,coef3,U3,insP3,mP3P1,flag);
1939 else if (!ins3) // p1 i2p4 p2
1940 MoveOrInsertPoint(List,
1941 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
1942 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1943 e,U1,U2,
1944 Nod21Indices,Nod21RValues,
1945 Nod22Indices,Nod22RValues,
1946 i2p1,i2p2,i2,pid2,TData2,PISeg2,PINod2,
1947 Nod11Indices,Nod11RValues,
1948 Nod12Indices,Nod12RValues,
1949 i1p1,i1p2,i1,pid1,TData1,PISeg1,PINod1,
1950 X4,Y4,Z4,XTI4,YTI4,ZTI4,coef4,U4,insP4,mP4P1,flag);
1951 else { // p1 i1p3 i2p4 p2
1952 Standard_Integer i1p3 = pid1->AddNode
1953 (Nod11RValues,Nod12RValues,PINod1,PINod2,coef3,X3,Y3,Z3);
1954 Standard_Integer i2p3 = pid2->AddNode
1955 (Nod21RValues,Nod22RValues,PINod2,PINod1,coef3,X3,Y3,Z3);
1956 Standard_Integer i1p4 = pid1->AddNode
1957 (Nod11RValues,Nod12RValues,PINod1,PINod2,coef4,X4,Y4,Z4);
1958 Standard_Integer i2p4 = pid2->AddNode
1959 (Nod21RValues,Nod22RValues,PINod2,PINod1,coef4,X4,Y4,Z4);
1960 const Handle(HLRAlgo_PolyInternalNode)* pi1p3 =
1961 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(i1p3));
681f3919 1962 HLRAlgo_PolyInternalNode::NodeIndices& Nod13Indices = (*pi1p3)->Indices();
1963 HLRAlgo_PolyInternalNode::NodeData& Nod13RValues = (*pi1p3)->Data();
7fd59977 1964 const Handle(HLRAlgo_PolyInternalNode)* pi1p4 =
1965 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(i1p4));
681f3919 1966 HLRAlgo_PolyInternalNode::NodeIndices& Nod14Indices = (*pi1p4)->Indices();
1967 HLRAlgo_PolyInternalNode::NodeData& Nod14RValues = (*pi1p4)->Data();
7fd59977 1968 const Handle(HLRAlgo_PolyInternalNode)* pi2p3 =
1969 &(((HLRAlgo_Array1OfPINod*)PINod2)->ChangeValue(i2p3));
681f3919 1970 HLRAlgo_PolyInternalNode::NodeIndices& Nod23Indices = (*pi2p3)->Indices();
1971 HLRAlgo_PolyInternalNode::NodeData& Nod23RValues = (*pi2p3)->Data();
7fd59977 1972 const Handle(HLRAlgo_PolyInternalNode)* pi2p4 =
1973 &(((HLRAlgo_Array1OfPINod*)PINod2)->ChangeValue(i2p4));
681f3919 1974 HLRAlgo_PolyInternalNode::NodeIndices& Nod24Indices = (*pi2p4)->Indices();
1975 HLRAlgo_PolyInternalNode::NodeData& Nod24RValues = (*pi2p4)->Data();
1976 Nod13Indices.Edg1 = e;
1977 Nod13RValues.PCu1 = U3;
1978 Nod13RValues.Scal = 0;
1979 Nod13Indices.Flag |= NMsk_OutL;
1980 Nod13Indices.Flag |= NMsk_Edge;
1981 Nod23Indices.Edg1 = e;
1982 Nod23RValues.PCu1 = U3;
1983 Nod23RValues.Scal = 0;
1984 Nod23Indices.Flag |= NMsk_OutL;
1985 Nod23Indices.Flag |= NMsk_Edge;
1986 Nod14Indices.Edg1 = e;
1987 Nod14RValues.PCu1 = U4;
1988 Nod14RValues.Scal = 0;
1989 Nod14Indices.Flag |= NMsk_OutL;
1990 Nod14Indices.Flag |= NMsk_Edge;
1991 Nod24Indices.Edg1 = e;
1992 Nod24RValues.PCu1 = U4;
1993 Nod24RValues.Scal = 0;
1994 Nod24Indices.Flag |= NMsk_OutL;
1995 Nod24Indices.Flag |= NMsk_Edge;
7fd59977 1996 pid1->UpdateLinks(i1p1,i1p2,i1p3,
1997 TData1,TData2,PISeg1,PISeg2,PINod1,PINod2);
1998 pid2->UpdateLinks(i2p1,i2p2,i2p3,
1999 TData2,TData1,PISeg2,PISeg1,PINod2,PINod1);
2000 pid2->UpdateLinks(i2p3,i2p2,i2p4,
2001 TData2,TData1,PISeg2,PISeg1,PINod2,PINod1);
2002 pid1->UpdateLinks(i1p3,i1p2,i1p4,
2003 TData1,TData2,PISeg1,PISeg2,PINod1,PINod2);
2004 UpdateAroundNode(i1p3,Nod13Indices,TData1,PISeg1,PINod1);
2005 UpdateAroundNode(i2p3,Nod23Indices,TData2,PISeg2,PINod2);
2006 UpdateAroundNode(i1p4,Nod14Indices,TData1,PISeg1,PINod1);
2007 UpdateAroundNode(i2p4,Nod24Indices,TData2,PISeg2,PINod2);
2008 List.Prepend(HLRAlgo_BiPoint
2009 (XTI1,YTI1,ZTI1,XTI3,YTI3,ZTI3,
2010 X1 ,Y1 ,Z1 ,X3 ,Y3 ,Z3 , e,
2011 i1 ,i1p1,i1p3,i2 ,i2p1,i2p3,flag));
2012 List.Prepend(HLRAlgo_BiPoint
2013 (XTI3,YTI3,ZTI3,XTI4,YTI4,ZTI4,
2014 X3 ,Y3 ,Z3 ,X4 ,Y4 ,Z4 , e,
2015 i1 ,i1p3,i1p4,i2 ,i2p3,i2p4,flag));
2016 List.Prepend(HLRAlgo_BiPoint
2017 (XTI4,YTI4,ZTI4,XTI2,YTI2,ZTI2,
2018 X4 ,Y4 ,Z4 ,X2 ,Y2 ,Z2 , e,
2019 i1 ,i1p4,i1p2,i2 ,i2p4,i2p2,flag));
2020 }
2021 }
2022 else // p1 p2
2023 List.Prepend(HLRAlgo_BiPoint
2024 (XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
2025 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 , e,
2026 i1 ,i1p1,i1p2,i2 ,i2p1,i2p2,flag));
2027}
2028
2029//=======================================================================
2030//function : InsertOnOutLine
2031//purpose :
2032//=======================================================================
2033
2034void
2035HLRBRep_PolyAlgo::InsertOnOutLine (TColStd_Array1OfTransient& PID)
2036{
681f3919 2037 HLRAlgo_Array1OfTData* TData2 = 0;
2038 HLRAlgo_Array1OfPISeg* PISeg2 = 0;
2039 HLRAlgo_Array1OfPINod* PINod2 = 0;
7fd59977 2040 Handle(HLRAlgo_PolyInternalData)* pid =
2041 (Handle(HLRAlgo_PolyInternalData)*) (&(PID.ChangeValue(1)));
2042
2043 TopLoc_Location L;
2044 Standard_Boolean insP3,mP3P1,IntOutL;
2045 Standard_Integer f,ip1,ip2,ip3;//, i;
1d47d8d0 2046 Standard_Real U3,V3,coef3,X3 = 0.,Y3 = 0.,Z3 = 0.;
7fd59977 2047
2048 const gp_Trsf& T = myProj.Transformation();
2049
2050 Standard_Integer nbFace = myFMap.Extent();
2051 for (f = 1; f <= nbFace; f++) {
2052
2053 if (!((*pid).IsNull())) {
2054 IntOutL = Standard_False;
681f3919 2055 HLRAlgo_Array1OfTData* TData1= &((*pid)->TData());
2056 HLRAlgo_Array1OfPISeg* PISeg1= &(*pid)->PISeg();
2057 HLRAlgo_Array1OfPINod* PINod1= &((*pid)->PINod());
7fd59977 2058 TopoDS_Shape LocalShape = myFMap(f);
2059 const TopoDS_Face& F = TopoDS::Face(LocalShape);
2060 myBSurf.Initialize(F,Standard_False);
2061 myGSurf = BRep_Tool::Surface(F,L);
2062 gp_Trsf TT = L.Transformation();
2063 TT.PreMultiply(T);
2064 const gp_XYZ& ttlo = TT.TranslationPart();
2065 TTLo[0] = ttlo.X();
2066 TTLo[1] = ttlo.Y();
2067 TTLo[2] = ttlo.Z();
2068 const gp_Mat& ttma = TT.VectorialPart();
2069 TTMa[0][0] = ttma.Value(1,1);
2070 TTMa[0][1] = ttma.Value(1,2);
2071 TTMa[0][2] = ttma.Value(1,3);
2072 TTMa[1][0] = ttma.Value(2,1);
2073 TTMa[1][1] = ttma.Value(2,2);
2074 TTMa[1][2] = ttma.Value(2,3);
2075 TTMa[2][0] = ttma.Value(3,1);
2076 TTMa[2][1] = ttma.Value(3,2);
2077 TTMa[2][2] = ttma.Value(3,3);
7fd59977 2078
0797d9d3 2079#ifdef OCCT_DEBUG
7fd59977 2080 if (DoTrace) {
96a95605
DB		 2081 cout << " InsertOnOutLine : NbTData " << (*pid)->NbTData() << endl;
2082 cout << " InsertOnOutLine : NbPISeg " << (*pid)->NbPISeg() << endl;
2083 cout << " InsertOnOutLine : NbPINod " << (*pid)->NbPINod() << endl;
7fd59977 2084 }
2085#endif
2086
96a95605
DB		 2087 Standard_Integer iseg,nbS;
2088 nbS = (*pid)->NbPISeg();
7fd59977 2089 for (iseg = 1; iseg <= nbS; iseg++) {
681f3919 2090 HLRAlgo_PolyInternalSegment& aSegIndices = PISeg1->ChangeValue(iseg);
7fd59977 2091// Standard_Boolean Cutted = Standard_False;
681f3919 2092 if (aSegIndices.Conex1 != 0 && aSegIndices.Conex2 != 0) {
2093 ip1 = aSegIndices.LstSg1;
2094 ip2 = aSegIndices.LstSg2;
2095 const Handle(HLRAlgo_PolyInternalNode)* pip1 = &PINod1->ChangeValue(ip1);
2096 HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices = (*pip1)->Indices();
2097 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues = (*pip1)->Data();
2098 const Handle(HLRAlgo_PolyInternalNode)* pip2 = &PINod1->ChangeValue(ip2);
2099 HLRAlgo_PolyInternalNode::NodeIndices& Nod2Indices = (*pip2)->Indices();
2100 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues = (*pip2)->Data();
2101 if (Nod1Indices.Flag & NMsk_OutL && Nod2Indices.Flag & NMsk_OutL)
7fd59977 2102 IntOutL = Standard_True;
681f3919 2103 else if ((Nod1RValues.Scal >= myTolAngular &&
2104 Nod2RValues.Scal <= -myTolAngular) ||
2105 (Nod2RValues.Scal >= myTolAngular &&
2106 Nod1RValues.Scal <= -myTolAngular)) {
7fd59977 2107 IntOutL = Standard_True;
2108 insP3 = NewNode(Nod1RValues,Nod2RValues,coef3,mP3P1);
2109 if (insP3) {
2110 UVNode(Nod1RValues,Nod2RValues,coef3,U3,V3);
2111 const gp_Pnt& PT3 = myGSurf->Value(U3,V3);
2112 X3 = PT3.X();
2113 Y3 = PT3.Y();
2114 Z3 = PT3.Z();
2115 TTMultiply(X3,Y3,Z3);
2116 }
2117
2118 if (insP3 && mP3P1) { // P1 ---> P3
681f3919 2119 if ((Nod1Indices.Flag & NMsk_Edge) == 0 && coef3 < myTolSta) {
7fd59977 2120 insP3 = Standard_False;
2121 ChangeNode(ip1,ip2,
2122 Nod1Indices,Nod1RValues,
2123 Nod2Indices,Nod2RValues,
2124 coef3,X3,Y3,Z3,Standard_True,
2125 TData1,PISeg1,PINod1);
681f3919 2126 Nod1RValues.Scal = 0;
2127 Nod1Indices.Flag |= NMsk_OutL;
7fd59977 2128 }
2129 }
2130 if (insP3 && !mP3P1) { // P2 ---> P3
681f3919 2131 if ((Nod2Indices.Flag & NMsk_Edge) == 0 && coef3 > myTolEnd) {
7fd59977 2132 insP3 = Standard_False;
2133 ChangeNode(ip1,ip2,
2134 Nod1Indices,Nod1RValues,
2135 Nod2Indices,Nod2RValues,
2136 coef3,X3,Y3,Z3,Standard_False,
2137 TData1,PISeg1,PINod1);
681f3919 2138 Nod2RValues.Scal = 0;
2139 Nod2Indices.Flag |= NMsk_OutL;
7fd59977 2140 }
2141 }
2142 if (insP3) { // p1 ip3 p2
2143 ip3 = (*pid)->AddNode(Nod1RValues,Nod2RValues,PINod1,PINod2,
2144 coef3,X3,Y3,Z3);
2145 const Handle(HLRAlgo_PolyInternalNode)* pip3 =
2146 (&((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(ip3));
681f3919 2147 HLRAlgo_PolyInternalNode::NodeIndices& Nod3Indices = (*pip3)->Indices();
2148 HLRAlgo_PolyInternalNode::NodeData& Nod3RValues = (*pip3)->Data();
7fd59977 2149 (*pid)->UpdateLinks(ip1,ip2,ip3,
2150 TData1,TData2,PISeg1,PISeg2,PINod1,PINod2);
2151 UpdateAroundNode(ip3,Nod3Indices,TData1,PISeg1,PINod1);
681f3919 2152 Nod3RValues.Scal = 0;
2153 Nod3Indices.Flag |= NMsk_OutL;
7fd59977 2154 }
2155 }
2156 }
2157 }
2158 if (IntOutL)
2159 (*pid)->IntOutL(Standard_True);
2160
7fd59977 2161 nbS = (*pid)->NbPISeg();
2162
0797d9d3 2163#ifdef OCCT_DEBUG
7fd59977 2164 if (DoTrace) {
96a95605
DB		 2165 cout << " InsertOnOutLine : NbTData " << (*pid)->NbTData() << endl;
2166 cout << " InsertOnOutLine : NbPISeg " << (*pid)->NbPISeg() << endl;
2167 cout << " InsertOnOutLine : NbPINod " << (*pid)->NbPINod() << endl;
7fd59977 2168 }
2169#endif
2170 }
2171 pid++;
2172 }
2173}
2174
2175//=======================================================================
2176//function : CheckFrBackTriangles
2177//purpose :
2178//=======================================================================
2179
2180void
2181HLRBRep_PolyAlgo::CheckFrBackTriangles (HLRAlgo_ListOfBPoint& List,
2182 TColStd_Array1OfTransient& PID)
2183{
2184 Standard_Integer f,i,nbN,nbT,nbFace;
2185 Standard_Real X1 =0.,Y1 =0.,X2 =0.,Y2 =0.,X3 =0.,Y3 =0.;
2186 Standard_Real D1,D2,D3;
2187 Standard_Real dd,dX,dY,nX,nY;
2188 Standard_Boolean FrBackInList;
681f3919 2189 HLRAlgo_Array1OfTData* TData;
2190 HLRAlgo_Array1OfPISeg* PISeg;
2191 HLRAlgo_Array1OfPINod* PINod;
2192
2193 //Standard_Address IndexPtr = NULL;
2194 //const Handle(HLRAlgo_PolyInternalData)& pid1 =
2195 // *(Handle(HLRAlgo_PolyInternalData)*)&(PID(F1Index));
2196 //Standard_Address TData1 = &pid1->TData(),
2197 //PISeg1 = &pid1->PISeg(),
2198 //PINod1 = &pid1->PINod();
2199
2200 //const Handle(HLRAlgo_PolyInternalData)& pid2 =
2201 // *(Handle(HLRAlgo_PolyInternalData)*)&(PID(F2Index));
2202 //Standard_Address TData2 = &pid2->TData(),
2203 //PISeg2 = &pid2->PISeg(),
2204 //PINod2 = &pid2->PISeg();
2205
2206 HLRAlgo_Array1OfTData* TData1 = NULL;
2207 HLRAlgo_Array1OfPISeg* PISeg1 = NULL;
2208 HLRAlgo_Array1OfPINod* PINod1 = NULL;
2209 HLRAlgo_Array1OfTData* TData2 = NULL;
2210 HLRAlgo_Array1OfPISeg* PISeg2 = NULL;
2211 HLRAlgo_Array1OfPINod* PINod2 = NULL;
2212 HLRAlgo_PolyInternalNode::NodeIndices* Nod11Indices;
2213 HLRAlgo_PolyInternalNode::NodeIndices* Nod12Indices;
2214 HLRAlgo_PolyInternalNode::NodeIndices* Nod13Indices;
2215 HLRAlgo_PolyInternalNode::NodeData* Nod11RValues;
2216 HLRAlgo_PolyInternalNode::NodeData* Nod12RValues;
2217 HLRAlgo_PolyInternalNode::NodeData* Nod13RValues;
7fd59977 2218
2219 Handle(HLRAlgo_PolyInternalData)* pid;
2220
2221 nbFace = myFMap.Extent();
2222 Standard_Boolean Modif = Standard_True;
2223 Standard_Integer iLoop = 0;
2224
2225 while (Modif && iLoop < 4) {
2226 iLoop++;
2227 Modif = Standard_False;
2228 FrBackInList = Standard_False;
2229 pid = (Handle(HLRAlgo_PolyInternalData)*)&(PID.ChangeValue(1));
2230
2231 for (f = 1; f <= nbFace; f++) {
2232 if (!(*pid).IsNull()) {
2233 nbT = (*pid)->NbTData();
2234 TData = &(*pid)->TData();
2235 PISeg = &(*pid)->PISeg();
2236 PINod = &(*pid)->PINod();
681f3919 2237 HLRAlgo_TriangleData* tdata = &TData->ChangeValue(1);
7fd59977 2238
2239 for (i = 1; i <= nbT; i++) {
681f3919 2240 if ((tdata->Flags & HLRAlgo_PolyMask_FMskSide) == 0 &&
2241 (tdata->Flags & HLRAlgo_PolyMask_FMskFrBack)) {
0797d9d3 2242#ifdef OCCT_DEBUG
7fd59977 2243 if (DoTrace)
2244 cout << " face : " << f << " , triangle " << i << endl;
2245#endif
2246 Modif = Standard_True;
2247 const Handle(HLRAlgo_PolyInternalNode)* pi1p1 =
681f3919 2248 &PINod->ChangeValue(tdata->Node1);
2249 Nod11Indices = &(*pi1p1)->Indices();
2250 Nod11RValues = &(*pi1p1)->Data();
7fd59977 2251 const Handle(HLRAlgo_PolyInternalNode)* pi1p2 =
681f3919 2252 &PINod->ChangeValue(tdata->Node2);
2253 Nod12Indices = &(*pi1p2)->Indices();
2254 Nod12RValues = &(*pi1p2)->Data();
7fd59977 2255 const Handle(HLRAlgo_PolyInternalNode)* pi1p3 =
681f3919 2256 &PINod->ChangeValue(tdata->Node3);
2257 Nod13Indices = &(*pi1p3)->Indices();
2258 Nod13RValues = &(*pi1p3)->Data();
7fd59977 2259 D1 = 0.; D2 = 0.; D3 = 0.;
681f3919 2260 if (((Nod11Indices->Flag & NMsk_Edge) == 0 || iLoop > 1) &&
2261 ((Nod11Indices->Flag & NMsk_OutL) == 0 || iLoop > 1) &&
2262 ((Nod11Indices->Flag & NMsk_Vert) == 0)) {
2263 dX = Nod13RValues->Point.X() - Nod12RValues->Point.X();
2264 dY = Nod13RValues->Point.Y() - Nod12RValues->Point.Y();
7fd59977 2265 D1 = dX * dX + dY * dY;
2266 D1 = sqrt(D1);
2267 nX = - dY / D1; nY = dX / D1;
681f3919 2268 dX = Nod11RValues->Point.X() - Nod12RValues->Point.X();
2269 dY = Nod11RValues->Point.Y() - Nod12RValues->Point.Y();
7fd59977 2270 dd = - (dX * nX + dY * nY);
2271 if (dd < 0) dd -= D1 * 0.01;
2272 else dd += D1 * 0.01;
2273 X1 = nX * dd; Y1 = nY * dd;
2274 }
681f3919 2275 if (((Nod12Indices->Flag & NMsk_Edge) == 0 || iLoop > 1) &&
2276 ((Nod12Indices->Flag & NMsk_OutL) == 0 || iLoop > 1) &&
2277 ((Nod12Indices->Flag & NMsk_Vert) == 0)) {
2278 dX = Nod11RValues->Point.X() - Nod13RValues->Point.X();
2279 dY = Nod11RValues->Point.Y() - Nod13RValues->Point.Y();
7fd59977 2280 D2 = dX * dX + dY * dY;
2281 D2 = sqrt(D2);
2282 nX = - dY / D2; nY = dX / D2;
681f3919 2283 dX = Nod12RValues->Point.X() - Nod13RValues->Point.X();
2284 dY = Nod12RValues->Point.Y() - Nod13RValues->Point.Y();
7fd59977 2285 dd = - (dX * nX + dY * nY);
2286 if (dd < 0) dd -= D2 * 0.01;
2287 else dd += D2 * 0.01;
2288 X2 = nX * dd; Y2 = nY * dd;
2289 }
681f3919 2290 if (((Nod13Indices->Flag & NMsk_Edge) == 0 || iLoop > 1) &&
2291 ((Nod13Indices->Flag & NMsk_OutL) == 0 || iLoop > 1) &&
2292 ((Nod13Indices->Flag & NMsk_Vert) == 0)) {
2293 dX = Nod12RValues->Point.X() - Nod11RValues->Point.X();
2294 dY = Nod12RValues->Point.Y() - Nod11RValues->Point.Y();
7fd59977 2295 D3 = dX * dX + dY * dY;
2296 D3 = sqrt(D3);
2297 nX = - dY / D3; nY = dX / D3;
681f3919 2298 dX = Nod13RValues->Point.X() - Nod11RValues->Point.X();
2299 dY = Nod13RValues->Point.Y() - Nod11RValues->Point.Y();
7fd59977 2300 dd = - (dX * nX + dY * nY);
2301 if (dd < 0) dd -= D3 * 0.01;
2302 else dd += D3 * 0.01;
2303 X3 = nX * dd; Y3 = nY * dd;
2304 }
2305 if (D1 > D2 && D1 > D3) {
681f3919 2306 Nod11RValues->Point.ChangeCoord(1) += X1;
2307 Nod11RValues->Point.ChangeCoord(2) += Y1;
2308 Nod11Indices->Flag |= NMsk_Move;
2309 UpdateAroundNode(tdata->Node1,*Nod11Indices,TData,PISeg,PINod);
7fd59977 2310 FrBackInList = Standard_True;
0797d9d3 2311#ifdef OCCT_DEBUG
7fd59977 2312 if (DoTrace) {
681f3919 2313 cout << tdata->Node1 << " modifies : DX,DY ";
7fd59977 2314 cout << X1 << " , " << Y1 << endl;
2315 }
2316#endif
2317 }
2318 else if (D2 > D3 && D2 > D1) {
681f3919 2319 Nod12RValues->Point.ChangeCoord(1) += X2;
2320 Nod12RValues->Point.ChangeCoord(2) += Y2;
2321 Nod12Indices->Flag |= NMsk_Move;
2322 UpdateAroundNode(tdata->Node2,*Nod12Indices,TData,PISeg,PINod);
7fd59977 2323 FrBackInList = Standard_True;
0797d9d3 2324#ifdef OCCT_DEBUG
7fd59977 2325 if (DoTrace) {
681f3919 2326 cout << tdata->Node2 << " modifies : DX,DY ";
7fd59977 2327 cout << X2 << " , " << Y2 << endl;
2328 }
2329#endif
2330 }
2331 else if (D3 > D1 && D3 > D2) {
681f3919 2332 Nod13RValues->Point.ChangeCoord(1) += X3;
2333 Nod13RValues->Point.ChangeCoord(2) += Y3;
2334 Nod13Indices->Flag |= NMsk_Move;
2335 UpdateAroundNode(tdata->Node3,*Nod13Indices,TData,PISeg,PINod);
7fd59977 2336 FrBackInList = Standard_True;
0797d9d3 2337#ifdef OCCT_DEBUG
7fd59977 2338 if (DoTrace) {
681f3919 2339 cout << tdata->Node3 << " modifies : DX,DY ";
7fd59977 2340 cout << X3 << " , " << Y3 << endl;
2341 }
2342#endif
2343 }
0797d9d3 2344#ifdef OCCT_DEBUG
7fd59977 2345 else if (DoTrace)
2346 cout << "modification error" << endl;
2347#endif
2348 }
2349 tdata++;
2350 }
2351 }
2352 pid++;
2353 }
2354 if (FrBackInList) {
7fd59977 2355 HLRAlgo_ListIteratorOfListOfBPoint it;
2356
2357 for (it.Initialize(List); it.More(); it.Next()) {
2358 HLRAlgo_BiPoint& BP = it.Value();
681f3919 2359 HLRAlgo_BiPoint::IndicesT& theIndices = BP.Indices();
2360 if (theIndices.FaceConex1 != 0) {
7fd59977 2361 const Handle(HLRAlgo_PolyInternalData)& pid1 =
681f3919 2362 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(theIndices.FaceConex1));
7fd59977 2363 TData1 = &pid1->TData();
2364 PISeg1 = &pid1->PISeg();
2365 PINod1 = &pid1->PINod();
2366 }
681f3919 2367 if (theIndices.FaceConex2 != 0) {
2368 if (theIndices.FaceConex1 == theIndices.FaceConex2) {
7fd59977 2369 TData2 = TData1;
2370 PISeg2 = PISeg1;
2371 PINod2 = PINod1;
2372 }
2373 else {
2374 const Handle(HLRAlgo_PolyInternalData)& pid2 =
681f3919 2375 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(theIndices.FaceConex2));
7fd59977 2376 TData2 = &pid2->TData();
2377 PISeg2 = &pid2->PISeg();
2378 PINod2 = &pid2->PINod();
2379 }
2380 }
681f3919 2381 if (theIndices.FaceConex1 != 0) {
2382 Nod11Indices = &PINod1->ChangeValue(theIndices.Face1Pt1)->Indices();
2383 if (Nod11Indices->Flag & NMsk_Move) {
0797d9d3 2384#ifdef OCCT_DEBUG
7fd59977 2385 if (DoTrace)
681f3919 2386 cout << theIndices.Face1Pt1 << " modifies 11" << endl;
7fd59977 2387#endif
681f3919 2388 Nod11RValues = &PINod1->ChangeValue(theIndices.Face1Pt1)->Data();
2389 HLRAlgo_BiPoint::PointsT& aPoints = BP.Points();
2390 aPoints.Pnt1 = aPoints.PntP1 = Nod11RValues->Point;
2391 TIMultiply(aPoints.Pnt1);
2392 if (theIndices.FaceConex2 != 0) {
2393 Nod12Indices = &PINod2->ChangeValue(theIndices.Face2Pt1)->Indices();
2394 Nod12RValues = &PINod2->ChangeValue(theIndices.Face2Pt1)->Data();
2395 Nod12RValues->Point.ChangeCoord(1) = Nod11RValues->Point.X();
2396 Nod12RValues->Point.ChangeCoord(2) = Nod11RValues->Point.Y();
2397 UpdateAroundNode(theIndices.Face2Pt1,*Nod12Indices,
7fd59977 2398 TData2,PISeg2,PINod2);
2399 }
2400 }
681f3919 2401 Nod11Indices = &PINod1->ChangeValue(theIndices.Face1Pt2)->Indices();
2402 if (Nod11Indices->Flag & NMsk_Move) {
0797d9d3 2403#ifdef OCCT_DEBUG
7fd59977 2404 if (DoTrace)
681f3919 2405 cout << theIndices.Face1Pt2 << " modifies 12" << endl;
7fd59977 2406#endif
681f3919 2407 Nod11RValues = &PINod1->ChangeValue(theIndices.Face1Pt2)->Data();
2408 HLRAlgo_BiPoint::PointsT& aPoints = BP.Points();
2409 aPoints.Pnt2 = aPoints.PntP2 = Nod11RValues->Point;
2410 TIMultiply(aPoints.Pnt2);
2411 if (theIndices.FaceConex2 != 0) {
2412 Nod12Indices = &PINod2->ChangeValue(theIndices.Face2Pt2)->Indices();
2413 Nod12RValues = &PINod2->ChangeValue(theIndices.Face2Pt2)->Data();
2414 Nod12RValues->Point.ChangeCoord(1) = Nod11RValues->Point.X();
2415 Nod12RValues->Point.ChangeCoord(2) = Nod11RValues->Point.Y();
2416 UpdateAroundNode(theIndices.Face2Pt2,*Nod12Indices,
7fd59977 2417 TData2,PISeg2,PINod2);
2418 }
2419 }
2420 }
681f3919 2421 if (theIndices.FaceConex2 != 0) {
7fd59977 2422 const Handle(HLRAlgo_PolyInternalData)& pid2 =
681f3919 2423 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(theIndices.FaceConex2));
7fd59977 2424 PINod2 = &pid2->PINod();
681f3919 2425 Nod11Indices = &PINod2->ChangeValue(theIndices.Face2Pt1)->Indices();
2426 if (Nod11Indices->Flag & NMsk_Move) {
0797d9d3 2427#ifdef OCCT_DEBUG
7fd59977 2428 if (DoTrace)
681f3919 2429 cout << theIndices.Face2Pt1 << " modifies 21" << endl;
7fd59977 2430#endif
681f3919 2431 Nod11RValues = &PINod2->ChangeValue(theIndices.Face2Pt1)->Data();
2432 HLRAlgo_BiPoint::PointsT& aPoints = BP.Points();
2433 aPoints.Pnt1 = aPoints.PntP1 = Nod11RValues->Point;
2434 TIMultiply(aPoints.Pnt1);
2435 if (theIndices.FaceConex1 != 0) {
2436 Nod12Indices = &PINod1->ChangeValue(theIndices.Face1Pt1)->Indices();
2437 Nod12RValues = &PINod1->ChangeValue(theIndices.Face1Pt1)->Data();
2438 Nod12RValues->Point.ChangeCoord(1) = Nod11RValues->Point.X();
2439 Nod12RValues->Point.ChangeCoord(2) = Nod11RValues->Point.Y();
2440 UpdateAroundNode(theIndices.Face1Pt1,*Nod12Indices,
7fd59977 2441 TData1,PISeg1,PINod1);
2442 }
2443 }
681f3919 2444 Nod11Indices = &PINod2->ChangeValue(theIndices.Face2Pt2)->Indices();
2445 if (Nod11Indices->Flag & NMsk_Move) {
0797d9d3 2446#ifdef OCCT_DEBUG
7fd59977 2447 if (DoTrace)
681f3919 2448 cout << theIndices.Face2Pt2 << " modifies 22" << endl;
7fd59977 2449#endif
681f3919 2450 Nod11RValues = &PINod2->ChangeValue(theIndices.Face2Pt2)->Data();
2451 HLRAlgo_BiPoint::PointsT& aPoints = BP.Points();
2452 aPoints.Pnt2 = aPoints.PntP2 = Nod11RValues->Point;
2453 TIMultiply(aPoints.Pnt2);
2454 if (theIndices.FaceConex1 != 0) {
2455 Nod12Indices = &PINod1->ChangeValue(theIndices.Face1Pt2)->Indices();
2456 Nod12RValues = &PINod1->ChangeValue(theIndices.Face1Pt2)->Data();
2457 Nod12RValues->Point.ChangeCoord(1) = Nod11RValues->Point.X();
2458 Nod12RValues->Point.ChangeCoord(2) = Nod11RValues->Point.Y();
2459 UpdateAroundNode(theIndices.Face1Pt2,*Nod12Indices,
7fd59977 2460 TData1,PISeg1,PINod1);
2461 }
2462 }
2463 }
2464 }
2465 pid = (Handle(HLRAlgo_PolyInternalData)*)&(PID.ChangeValue(1));
2466
2467 for (f = 1; f <= nbFace; f++) {
2468 if (!(*pid).IsNull()) {
2469 nbN = (*pid)->NbPINod();
2470 PINod = &(*pid)->PINod();
7fd59977 2471
681f3919 2472 for (i = 1; i <= nbN; i++)
2473 {
2474 Nod11Indices = &PINod->ChangeValue(i)->Indices();
2475 Nod11Indices->Flag &= ~NMsk_Move;
7fd59977 2476 }
2477 }
2478 pid++;
2479 }
2480 }
2481 }
2482}
2483
2484//=======================================================================
2485//function : FindEdgeOnTriangle
2486//purpose :
2487//=======================================================================
2488
2489void
2490HLRBRep_PolyAlgo::
681f3919 2491FindEdgeOnTriangle (const HLRAlgo_TriangleData& theTriangle,
7fd59977 2492 const Standard_Integer ip1,
2493 const Standard_Integer ip2,
2494 Standard_Integer& jtrouv,
2495 Standard_Boolean& isDirect) const
2496{
681f3919 2497 Standard_Integer n1 = theTriangle.Node1;
2498 Standard_Integer n2 = theTriangle.Node2;
2499 Standard_Integer n3 = theTriangle.Node3;
7fd59977 2500 if (ip1 == n1 && ip2 == n2) {
2501 jtrouv = 0;
2502 isDirect = Standard_True;
2503 return;
2504 }
2505 else if (ip2 == n1 && ip1 == n2) {
2506 jtrouv = 0;
2507 isDirect = Standard_False;
2508 return;
2509 }
2510 else if (ip1 == n2 && ip2 == n3) {
2511 jtrouv = 1;
2512 isDirect = Standard_True;
2513 return;
2514 }
2515 else if (ip2 == n2 && ip1 == n3) {
2516 jtrouv = 1;
2517 isDirect = Standard_False;
2518 return;
2519 }
2520 else if (ip1 == n3 && ip2 == n1) {
2521 jtrouv = 2;
2522 isDirect = Standard_True;
2523 return;
2524 }
2525 else if (ip2 == n3 && ip1 == n1) {
2526 jtrouv = 2;
2527 isDirect = Standard_False;
2528 return;
2529 }
2530}
2531
2532//=======================================================================
2533//function : ChangeNode
2534//purpose :
2535//=======================================================================
2536
2537void HLRBRep_PolyAlgo::ChangeNode (const Standard_Integer ip1,
2538 const Standard_Integer ip2,
681f3919 2539 HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices,
2540 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
2541 HLRAlgo_PolyInternalNode::NodeIndices& Nod2Indices,
2542 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues,
7fd59977 2543 const Standard_Real coef1,
2544 const Standard_Real X3,
2545 const Standard_Real Y3,
2546 const Standard_Real Z3,
2547 const Standard_Boolean first,
681f3919 2548 HLRAlgo_Array1OfTData*& TData,
2549 HLRAlgo_Array1OfPISeg*& PISeg,
2550 HLRAlgo_Array1OfPINod*& PINod) const
7fd59977 2551{
2552 Standard_Real coef2 = 1 - coef1;
2553 if (first) {
681f3919 2554 Nod1RValues.Point = gp_XYZ(X3, Y3, Z3);
2555 Nod1RValues.UV = coef2 * Nod1RValues.UV + coef1 * Nod2RValues.UV;
2556 Nod1RValues.Scal = Nod1RValues.Scal * coef2 + Nod2RValues.Scal * coef1;
2557 const gp_XYZ aXYZ = coef2 * Nod1RValues.Normal + coef1 * Nod2RValues.Normal;
2558 const Standard_Real aNorm = aXYZ.Modulus();
2559 if (aNorm > 0) {
2560 Nod1RValues.Normal = (1 / aNorm) * aXYZ;
7fd59977 2561 }
2562 else {
681f3919 2563 Nod1RValues.Normal = gp_XYZ(1., 0., 0.);
0797d9d3 2564#ifdef OCCT_DEBUG
7fd59977 2565 if (DoError) {
2566 cout << "HLRBRep_PolyAlgo::ChangeNode between " << ip1;
2567 cout << " and " << ip2 << endl;
2568 }
2569#endif
2570 }
2571 UpdateAroundNode(ip1,Nod1Indices,TData,PISeg,PINod);
2572 }
2573 else {
681f3919 2574 Nod2RValues.Point = gp_XYZ(X3, Y3, Z3);
2575 Nod2RValues.UV = coef2 * Nod1RValues.UV + coef1 * Nod2RValues.UV;
2576 Nod2RValues.Scal = Nod1RValues.Scal * coef2 + Nod2RValues.Scal * coef1;
2577 const gp_XYZ aXYZ = coef2 * Nod1RValues.Normal + coef1 * Nod2RValues.Normal;
2578 const Standard_Real aNorm = aXYZ.Modulus();
2579 if (aNorm > 0) {
2580 Nod2RValues.Normal = (1 / aNorm) * aXYZ;
7fd59977 2581 }
2582 else {
681f3919 2583 Nod2RValues.Normal = gp_XYZ(1., 0., 0.);
0797d9d3 2584#ifdef OCCT_DEBUG
7fd59977 2585 if (DoError) {
2586 cout << "HLRBRep_PolyAlgo::ChangeNode between " << ip2;
2587 cout << " and " << ip1 << endl;
2588 }
2589#endif
2590 }
2591 UpdateAroundNode(ip2,Nod2Indices,TData,PISeg,PINod);
2592 }
2593}
2594
2595//=======================================================================
2596//function : UpdateAroundNode
2597//purpose :
2598//=======================================================================
2599
2600void HLRBRep_PolyAlgo::
2601UpdateAroundNode (const Standard_Integer iNode,
681f3919 2602 HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices,
2603 HLRAlgo_Array1OfTData* TData,
2604 HLRAlgo_Array1OfPISeg* PISeg,
2605 HLRAlgo_Array1OfPINod* PINod) const
7fd59977 2606{
2607 Standard_Integer iiii,iTri1,iTri2;
681f3919 2608 iiii = Nod1Indices.NdSg;
7fd59977 2609
2610 while (iiii != 0) {
681f3919 2611 HLRAlgo_PolyInternalSegment& aSegIndices = PISeg->ChangeValue(iiii);
2612 iTri1 = aSegIndices.Conex1;
2613 iTri2 = aSegIndices.Conex2;
7fd59977 2614 if ( iTri1 != 0) {
681f3919 2615 HLRAlgo_TriangleData& aTriangle = TData->ChangeValue(iTri1);
7fd59977 2616 const Handle(HLRAlgo_PolyInternalNode)* PN1 =
681f3919 2617 &PINod->ChangeValue(aTriangle.Node1);
7fd59977 2618 const Handle(HLRAlgo_PolyInternalNode)* PN2 =
681f3919 2619 &PINod->ChangeValue(aTriangle.Node2);
7fd59977 2620 const Handle(HLRAlgo_PolyInternalNode)* PN3 =
681f3919 2621 &PINod->ChangeValue(aTriangle.Node3);
2622 HLRAlgo_PolyInternalNode::NodeIndices& aNod1Indices = (*PN1)->Indices();
2623 HLRAlgo_PolyInternalNode::NodeIndices& aNod2Indices = (*PN2)->Indices();
2624 HLRAlgo_PolyInternalNode::NodeIndices& aNod3Indices = (*PN3)->Indices();
2625 HLRAlgo_PolyInternalNode::NodeData& aNod1RValues = (*PN1)->Data();
2626 HLRAlgo_PolyInternalNode::NodeData& aNod2RValues = (*PN2)->Data();
2627 HLRAlgo_PolyInternalNode::NodeData& aNod3RValues = (*PN3)->Data();
2628 OrientTriangle(iTri1,aTriangle,
464cd2fb 2629 aNod1Indices,aNod1RValues,
2630 aNod2Indices,aNod2RValues,
2631 aNod3Indices,aNod3RValues);
7fd59977 2632 }
2633 if ( iTri2 != 0) {
681f3919 2634 HLRAlgo_TriangleData& aTriangle2 = TData->ChangeValue(iTri2);
7fd59977 2635 const Handle(HLRAlgo_PolyInternalNode)* PN1 =
681f3919 2636 &PINod->ChangeValue(aTriangle2.Node1);
7fd59977 2637 const Handle(HLRAlgo_PolyInternalNode)* PN2 =
681f3919 2638 &PINod->ChangeValue(aTriangle2.Node2);
7fd59977 2639 const Handle(HLRAlgo_PolyInternalNode)* PN3 =
681f3919 2640 &PINod->ChangeValue(aTriangle2.Node3);
2641 HLRAlgo_PolyInternalNode::NodeIndices& aNod1Indices = (*PN1)->Indices();
2642 HLRAlgo_PolyInternalNode::NodeIndices& aNod2Indices = (*PN2)->Indices();
2643 HLRAlgo_PolyInternalNode::NodeIndices& aNod3Indices = (*PN3)->Indices();
2644 HLRAlgo_PolyInternalNode::NodeData& aNod1RValues = (*PN1)->Data();
2645 HLRAlgo_PolyInternalNode::NodeData& aNod2RValues = (*PN2)->Data();
2646 HLRAlgo_PolyInternalNode::NodeData& aNod3RValues = (*PN3)->Data();
2647 OrientTriangle(iTri2,aTriangle2,
464cd2fb 2648 aNod1Indices,aNod1RValues,
2649 aNod2Indices,aNod2RValues,
2650 aNod3Indices,aNod3RValues);
7fd59977 2651 }
681f3919 2652 if (aSegIndices.LstSg1 == iNode) iiii = aSegIndices.NxtSg1;
2653 else iiii = aSegIndices.NxtSg2;
7fd59977 2654 }
2655}
2656
2657//=======================================================================
2658//function : OrientTriangle
2659//purpose :
2660//=======================================================================
2661
2662void
0797d9d3 2663#ifdef OCCT_DEBUG
7fd59977 2664HLRBRep_PolyAlgo::OrientTriangle(const Standard_Integer iTri,
498ce76b 2665#else
2666HLRBRep_PolyAlgo::OrientTriangle(const Standard_Integer,
2667#endif
681f3919 2668 HLRAlgo_TriangleData& theTriangle,
2669 HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices,
2670 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
2671 HLRAlgo_PolyInternalNode::NodeIndices& Nod2Indices,
2672 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues,
2673 HLRAlgo_PolyInternalNode::NodeIndices& Nod3Indices,
2674 HLRAlgo_PolyInternalNode::NodeData& Nod3RValues) const
7fd59977 2675{
681f3919 2676 Standard_Boolean o1 = (Nod1Indices.Flag & NMsk_OutL) != 0;
2677 Standard_Boolean o2 = (Nod2Indices.Flag & NMsk_OutL) != 0;
2678 Standard_Boolean o3 = (Nod3Indices.Flag & NMsk_OutL) != 0;
2679 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskFlat;
2680 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskOnOutL;
7fd59977 2681 if (o1 && o2 && o3) {
681f3919 2682 theTriangle.Flags |= HLRAlgo_PolyMask_FMskSide;
2683 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
2684 theTriangle.Flags |= HLRAlgo_PolyMask_FMskOnOutL;
0797d9d3 2685#ifdef OCCT_DEBUG
7fd59977 2686 if (DoTrace) {
2687 cout << "HLRBRep_PolyAlgo::OrientTriangle : OnOutL";
2688 cout << " triangle " << iTri << endl;
2689 }
2690#endif
2691 }
2692 else {
681f3919 2693 Standard_Real s1 = Nod1RValues.Scal;
2694 Standard_Real s2 = Nod2RValues.Scal;
2695 Standard_Real s3 = Nod3RValues.Scal;
7fd59977 2696 Standard_Real as1 = s1;
2697 Standard_Real as2 = s2;
2698 Standard_Real as3 = s3;
2699 if (s1 < 0) as1 = -s1;
2700 if (s2 < 0) as2 = -s2;
2701 if (s3 < 0) as3 = -s3;
2702 Standard_Real s = 0;
2703 Standard_Real as = 0;
2704 if (!o1 ) {s = s1; as = as1;}
2705 if (!o2 && as < as2) {s = s2; as = as2;}
2706 if (!o3 && as < as3) {s = s3; as = as3;}
2707 if (s > 0) {
681f3919 2708 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskSide;
2709 theTriangle.Flags |= HLRAlgo_PolyMask_FMskBack;
7fd59977 2710 }
2711 else {
681f3919 2712 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskSide;
2713 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
7fd59977 2714 }
681f3919 2715 gp_XYZ aD12 = Nod2RValues.Point - Nod1RValues.Point;
2716 const Standard_Real aD12Norm = aD12.Modulus();
2717 if (aD12Norm <= 1.e-10) {
0797d9d3 2718#ifdef OCCT_DEBUG
7fd59977 2719 if (DoTrace) {
2720 cout << "HLRBRep_PolyAlgo::OrientTriangle : Flat";
2721 cout << " triangle " << iTri << endl;
2722 }
2723#endif
681f3919 2724 theTriangle.Flags |= HLRAlgo_PolyMask_FMskFlat;
2725 theTriangle.Flags |= HLRAlgo_PolyMask_FMskSide;
2726 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
7fd59977 2727 }
2728 else {
681f3919 2729 gp_XYZ aD23 = Nod3RValues.Point - Nod2RValues.Point;
2730 const Standard_Real aD23Norm = aD23.Modulus();
2731 if (aD23Norm < 1.e-10) {
0797d9d3 2732#ifdef OCCT_DEBUG
7fd59977 2733 if (DoTrace) {
2734 cout << "HLRBRep_PolyAlgo::OrientTriangle : Flat";
2735 cout << " triangle " << iTri << endl;
2736 }
2737#endif
681f3919 2738 theTriangle.Flags |= HLRAlgo_PolyMask_FMskFlat;
2739 theTriangle.Flags |= HLRAlgo_PolyMask_FMskSide;
2740 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
7fd59977 2741 }
2742 else {
681f3919 2743 const gp_XYZ aD31 = Nod1RValues.Point - Nod3RValues.Point;
2744 const Standard_Real aD31Norm = aD31.Modulus();
2745 if (aD31Norm < 1.e-10) {
0797d9d3 2746#ifdef OCCT_DEBUG
7fd59977 2747 if (DoTrace) {
2748 cout << "HLRBRep_PolyAlgo::OrientTriangle : Flat";
2749 cout << " triangle " << iTri << endl;
2750 }
2751#endif
681f3919 2752 theTriangle.Flags |= HLRAlgo_PolyMask_FMskFlat;
2753 theTriangle.Flags |= HLRAlgo_PolyMask_FMskSide;
2754 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
7fd59977 2755 }
2756 else {
681f3919 2757 aD12 *= 1 / aD12Norm;
2758 aD23 *= 1 / aD23Norm;
2759 gp_XYZ aD = aD12 ^ aD23;
2760 const Standard_Real aDNorm = aD.Modulus();
2761 if (aDNorm < 1.e-5) {
0797d9d3 2762#ifdef OCCT_DEBUG
7fd59977 2763 if (DoTrace) {
2764 cout << "HLRBRep_PolyAlgo::OrientTriangle : Flat";
2765 cout << " triangle " << iTri << endl;
2766 }
2767#endif
681f3919 2768 theTriangle.Flags |= HLRAlgo_PolyMask_FMskFlat;
2769 theTriangle.Flags |= HLRAlgo_PolyMask_FMskSide;
2770 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
7fd59977 2771 }
2772 else {
2773 Standard_Real o;
2774 if (myProj.Perspective()) {
681f3919 2775 aD *= 1 / aDNorm;
2776 o = aD.Z() * myProj.Focus() - aD * Nod1RValues.Point;
7fd59977 2777 }
2778 else
681f3919 2779 o = aD.Z() / aDNorm;
7fd59977 2780 if (o < 0) {
681f3919 2781 theTriangle.Flags |= HLRAlgo_PolyMask_FMskOrBack;
7fd59977 2782 o = -o;
2783 }
2784 else
681f3919 2785 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskOrBack;
7fd59977 2786 if (o < 1.e-10) {
681f3919 2787 theTriangle.Flags |= HLRAlgo_PolyMask_FMskSide;
2788 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
7fd59977 2789 }
2790 }
2791 }
2792 }
2793 }
2794 }
681f3919 2795 if ((!(theTriangle.Flags & HLRAlgo_PolyMask_FMskBack) && (theTriangle.Flags & HLRAlgo_PolyMask_FMskOrBack)) ||
2796 ( (theTriangle.Flags & HLRAlgo_PolyMask_FMskBack) && !(theTriangle.Flags & HLRAlgo_PolyMask_FMskOrBack)))
2797 theTriangle.Flags |= HLRAlgo_PolyMask_FMskFrBack;
7fd59977 2798 else
681f3919 2799 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskFrBack;
7fd59977 2800}
2801
2802//=======================================================================
2803//function : Triangles
2804//purpose :
2805//=======================================================================
2806
2807Standard_Boolean
2808HLRBRep_PolyAlgo::Triangles(const Standard_Integer ip1,
2809 const Standard_Integer ip2,
681f3919 2810 HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices,
2811 HLRAlgo_Array1OfPISeg*& PISeg,
7fd59977 2812 Standard_Integer& iTri1,
2813 Standard_Integer& iTri2) const
2814{
681f3919 2815 Standard_Integer iiii = Nod1Indices.NdSg;
7fd59977 2816
2817 while (iiii != 0) {
681f3919 2818 HLRAlgo_PolyInternalSegment& aSegIndices =
2819 ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii);
2820 if (aSegIndices.LstSg1 == ip1) {
2821 if (aSegIndices.LstSg2 == ip2) {
2822 iTri1 = aSegIndices.Conex1;
2823 iTri2 = aSegIndices.Conex2;
7fd59977 2824 return Standard_True;
2825 }
681f3919 2826 else iiii = aSegIndices.NxtSg1;
7fd59977 2827 }
2828 else {
681f3919 2829 if (aSegIndices.LstSg1 == ip2) {
2830 iTri1 = aSegIndices.Conex1;
2831 iTri2 = aSegIndices.Conex2;
7fd59977 2832 return Standard_True;
2833 }
681f3919 2834 else iiii = aSegIndices.NxtSg2;
7fd59977 2835 }
2836 }
2837 iTri1 = 0;
2838 iTri2 = 0;
0797d9d3 2839#ifdef OCCT_DEBUG
7fd59977 2840 if (DoError) {
2841 cout << "HLRBRep_PolyAlgo::Triangles : error";
2842 cout << " between " << ip1 << " and " << ip2 << endl;
2843 }
2844#endif
2845 return Standard_False;
2846}
2847
2848//=======================================================================
2849//function : NewNode
2850//purpose :
2851//=======================================================================
2852
2853Standard_Boolean
2854HLRBRep_PolyAlgo::
681f3919 2855NewNode (
2856 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
2857 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues,
2858 Standard_Real& coef1,
2859 Standard_Boolean& moveP1) const
7fd59977 2860{
2861 Standard_Real TolAng = myTolAngular * 0.5;
681f3919 2862 if ((Nod1RValues.Scal >= TolAng && Nod2RValues.Scal <= -TolAng) ||
2863 (Nod2RValues.Scal >= TolAng && Nod1RValues.Scal <= -TolAng)) {
2864 coef1 = Nod1RValues.Scal / ( Nod2RValues.Scal - Nod1RValues.Scal );
7fd59977 2865 if (coef1 < 0) coef1 = - coef1;
2866 moveP1 = coef1 < 0.5;
2867 return Standard_True;
2868 }
2869 return Standard_False;
2870}
2871
2872//=======================================================================
2873//function : UVNode
2874//purpose :
2875//=======================================================================
2876
2877void
681f3919 2878HLRBRep_PolyAlgo::UVNode (
2879 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
2880 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues,
2881 const Standard_Real coef1,
2882 Standard_Real& U3,
2883 Standard_Real& V3) const
7fd59977 2884{
2885 Standard_Real coef2 = 1 - coef1;
681f3919 2886 const gp_XY aUV3 = coef2 * Nod1RValues.UV + coef1 * Nod2RValues.UV;
2887 U3 = aUV3.X();
2888 V3 = aUV3.Y();
7fd59977 2889}
2890
2891//=======================================================================
2892//function : CheckDegeneratedSegment
2893//purpose :
2894//=======================================================================
2895
2896void
2897HLRBRep_PolyAlgo::
681f3919 2898CheckDegeneratedSegment(
2899 HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices,
2900 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
2901 HLRAlgo_PolyInternalNode::NodeIndices& Nod2Indices,
2902 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues) const
7fd59977 2903{
681f3919 2904 Nod1Indices.Flag |= NMsk_Fuck;
2905 Nod2Indices.Flag |= NMsk_Fuck;
2906 if ((Nod1RValues.Scal >= myTolAngular && Nod2RValues.Scal <= -myTolAngular) ||
2907 (Nod2RValues.Scal >= myTolAngular && Nod1RValues.Scal <= -myTolAngular)) {
2908 Nod1RValues.Scal = 0.;
2909 Nod1Indices.Flag |= NMsk_OutL;
2910 Nod2RValues.Scal = 0.;
2911 Nod2Indices.Flag |= NMsk_OutL;
7fd59977 2912 }
2913}
2914
2915//=======================================================================
2916//function : UpdateOutLines
2917//purpose :
2918//=======================================================================
2919
2920void
2921HLRBRep_PolyAlgo::UpdateOutLines (HLRAlgo_ListOfBPoint& List,
2922 TColStd_Array1OfTransient& PID)
2923{
2924 Standard_Integer f;
2925 Standard_Integer nbFace = myFMap.Extent();
2926 Standard_Real X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ;
2927 Standard_Real XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2;
2928
2929 Handle(HLRAlgo_PolyInternalData)* pid =
2930 (Handle(HLRAlgo_PolyInternalData)*)&(PID.ChangeValue(1));
2931
2932 for (f = 1; f <= nbFace; f++) {
2933 if (!(*pid).IsNull()) {
2934 if ((*pid)->IntOutL()) {
681f3919 2935 HLRAlgo_Array1OfTData* TData = &(*pid)->TData();
2936 HLRAlgo_Array1OfPISeg* PISeg = &(*pid)->PISeg();
2937 HLRAlgo_Array1OfPINod* PINod = &(*pid)->PINod();
7fd59977 2938 Standard_Integer i,j,it1,it2,tn1,tn2,tn3,pd,pf;
7fd59977 2939 Standard_Boolean outl;
2940 Standard_Integer nbS = (*pid)->NbPISeg();
681f3919 2941
2942 for (i = 1; i <= nbS; i++)
2943 {
2944 HLRAlgo_PolyInternalSegment* psg = &PISeg->ChangeValue(i);
2945 it1 = psg->Conex1;
2946 it2 = psg->Conex2;
7fd59977 2947 if (it1 != 0 && it2 != 0 && it1 != it2) { // debile but sure !
681f3919 2948 HLRAlgo_TriangleData& aTriangle = TData->ChangeValue(it1);
2949 HLRAlgo_TriangleData& aTriangle2 = TData->ChangeValue(it2);
2950 if (!(aTriangle.Flags & HLRAlgo_PolyMask_FMskSide) && !(aTriangle2.Flags & HLRAlgo_PolyMask_FMskSide))
2951 outl = (aTriangle.Flags & HLRAlgo_PolyMask_FMskBack) != (aTriangle2.Flags & HLRAlgo_PolyMask_FMskBack);
2952 else if ( (aTriangle.Flags & HLRAlgo_PolyMask_FMskSide) && (aTriangle2.Flags & HLRAlgo_PolyMask_FMskSide))
7fd59977 2953 outl = Standard_False;
681f3919 2954 else if ( aTriangle.Flags & HLRAlgo_PolyMask_FMskSide)
2955 outl = !(aTriangle.Flags & HLRAlgo_PolyMask_FMskFlat) && !(aTriangle2.Flags & HLRAlgo_PolyMask_FMskBack);
7fd59977 2956 else
681f3919 2957 outl = !(aTriangle2.Flags & HLRAlgo_PolyMask_FMskFlat) && !(aTriangle.Flags & HLRAlgo_PolyMask_FMskBack);
7fd59977 2958
2959 if (outl) {
681f3919 2960 pd = psg->LstSg1;
2961 pf = psg->LstSg2;
2962 tn1 = aTriangle.Node1;
2963 tn2 = aTriangle.Node2;
2964 tn3 = aTriangle.Node3;
2965 if (!(aTriangle.Flags & HLRAlgo_PolyMask_FMskSide) && (aTriangle.Flags & HLRAlgo_PolyMask_FMskOrBack)) {
7fd59977 2966 j = tn1;
2967 tn1 = tn3;
2968 tn3 = j;
2969 }
2970 if ((tn1 == pd && tn2 == pf) || (tn1 == pf && tn2 == pd))
681f3919 2971 aTriangle.Flags |= HLRAlgo_PolyMask_EMskOutLin1;
7fd59977 2972 else if ((tn2 == pd && tn3 == pf) || (tn2 == pf && tn3 == pd))
681f3919 2973 aTriangle.Flags |= HLRAlgo_PolyMask_EMskOutLin2;
7fd59977 2974 else if ((tn3 == pd && tn1 == pf) || (tn3 == pf && tn1 == pd))
681f3919 2975 aTriangle.Flags |= HLRAlgo_PolyMask_EMskOutLin3;
0797d9d3 2976#ifdef OCCT_DEBUG
7fd59977 2977 else if (DoError) {
2978 cout << "HLRAlgo_PolyInternalData::UpdateOutLines";
2979 cout << " : segment not found" << endl;
2980 }
2981#endif
681f3919 2982 tn1 = aTriangle2.Node1;
2983 tn2 = aTriangle2.Node2;
2984 tn3 = aTriangle2.Node3;
2985 if (!(aTriangle2.Flags & HLRAlgo_PolyMask_FMskSide) && (aTriangle2.Flags & HLRAlgo_PolyMask_FMskOrBack)) {
7fd59977 2986 j = tn1;
2987 tn1 = tn3;
2988 tn3 = j;
2989 }
2990 if ((tn1 == pd && tn2 == pf) || (tn1 == pf && tn2 == pd))
681f3919 2991 aTriangle2.Flags |= HLRAlgo_PolyMask_EMskOutLin1;
7fd59977 2992 else if ((tn2 == pd && tn3 == pf) || (tn2 == pf && tn3 == pd))
681f3919 2993 aTriangle2.Flags |= HLRAlgo_PolyMask_EMskOutLin2;
7fd59977 2994 else if ((tn3 == pd && tn1 == pf) || (tn3 == pf && tn1 == pd))
681f3919 2995 aTriangle2.Flags |= HLRAlgo_PolyMask_EMskOutLin3;
0797d9d3 2996#ifdef OCCT_DEBUG
7fd59977 2997 else if (DoError) {
2998 cout << "HLRAlgo_PolyInternalData::UpdateOutLines";
2999 cout << " : segment not found" << endl;
3000 }
3001#endif
681f3919 3002 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues =
3003 PINod->ChangeValue(pd)->Data();
3004 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues =
3005 PINod->ChangeValue(pf)->Data();
3006 XTI1 = X1 = Nod1RValues.Point.X();
3007 YTI1 = Y1 = Nod1RValues.Point.Y();
3008 ZTI1 = Z1 = Nod1RValues.Point.Z();
3009 XTI2 = X2 = Nod2RValues.Point.X();
3010 YTI2 = Y2 = Nod2RValues.Point.Y();
3011 ZTI2 = Z2 = Nod2RValues.Point.Z();
7fd59977 3012 TIMultiply(XTI1,YTI1,ZTI1);
3013 TIMultiply(XTI2,YTI2,ZTI2);
3014 List.Append(HLRAlgo_BiPoint(XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
3015 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
3016 f,f,pd,pf,f,pd,pf,12));
3017 }
3018 }
7fd59977 3019 }
3020 }
3021 }
3022 pid++;
3023 }
3024}
3025
3026//=======================================================================
3027//function : UpdateEdgesBiPoints
3028//purpose :
3029//=======================================================================
3030
3031void HLRBRep_PolyAlgo::
3032UpdateEdgesBiPoints (HLRAlgo_ListOfBPoint& List,
3033 const TColStd_Array1OfTransient& PID,
3034 const Standard_Boolean closed)
3035{
3036 Standard_Integer itri1,itri2,tbid;
7fd59977 3037 HLRAlgo_ListIteratorOfListOfBPoint it;
3038
3039 for (it.Initialize(List); it.More(); it.Next()) {
3040 HLRAlgo_BiPoint& BP = it.Value();
3041// Standard_Integer i[5];
681f3919 3042 HLRAlgo_BiPoint::IndicesT& aIndices = BP.Indices();
3043 if (aIndices.FaceConex1 != 0 && aIndices.FaceConex2 != 0) {
7fd59977 3044 const Handle(HLRAlgo_PolyInternalData)& pid1 =
681f3919 3045 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(aIndices.FaceConex1));
7fd59977 3046 const Handle(HLRAlgo_PolyInternalData)& pid2 =
681f3919 3047 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(aIndices.FaceConex2));
3048 HLRAlgo_Array1OfPISeg* PISeg1 = &pid1->PISeg();
3049 HLRAlgo_Array1OfPISeg* PISeg2 = &pid2->PISeg();
3050 HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices =
3051 pid1->PINod().ChangeValue(aIndices.Face1Pt1)->Indices();
3052 HLRAlgo_PolyInternalNode::NodeIndices& Nod21Indices =
3053 pid2->PINod().ChangeValue(aIndices.Face2Pt1)->Indices();
3054 Triangles(aIndices.Face1Pt1,aIndices.Face1Pt2,Nod11Indices,PISeg1,itri1,tbid);
3055 Triangles(aIndices.Face2Pt1,aIndices.Face2Pt2,Nod21Indices,PISeg2,itri2,tbid);
7fd59977 3056
3057 if (itri1 != 0 && itri2 != 0) {
681f3919 3058 if (aIndices.FaceConex1 != aIndices.FaceConex2 || itri1 != itri2) {
3059 HLRAlgo_Array1OfTData* TData1 = &pid1->TData();
3060 HLRAlgo_Array1OfTData* TData2 = &pid2->TData();
3061 HLRAlgo_TriangleData& aTriangle = TData1->ChangeValue(itri1);
3062 HLRAlgo_TriangleData& aTriangle2 = TData2->ChangeValue(itri2);
7fd59977 3063 if (closed) {
681f3919 3064 if (((aTriangle.Flags & HLRAlgo_PolyMask_FMskBack) && (aTriangle2.Flags & HLRAlgo_PolyMask_FMskBack)) ||
3065 ((aTriangle.Flags & HLRAlgo_PolyMask_FMskSide) && (aTriangle2.Flags & HLRAlgo_PolyMask_FMskSide)) ||
3066 ((aTriangle.Flags & HLRAlgo_PolyMask_FMskBack) && (aTriangle2.Flags & HLRAlgo_PolyMask_FMskSide)) ||
3067 ((aTriangle.Flags & HLRAlgo_PolyMask_FMskSide) && (aTriangle2.Flags & HLRAlgo_PolyMask_FMskBack)))
7fd59977 3068 BP.Hidden(Standard_True);
3069 }
3070 Standard_Boolean outl;
681f3919 3071 if (!(aTriangle.Flags & HLRAlgo_PolyMask_FMskSide) && !(aTriangle2.Flags & HLRAlgo_PolyMask_FMskSide))
3072 outl = (aTriangle.Flags & HLRAlgo_PolyMask_FMskBack) != (aTriangle2.Flags & HLRAlgo_PolyMask_FMskBack);
3073 else if ( (aTriangle.Flags & HLRAlgo_PolyMask_FMskSide) && (aTriangle2.Flags & HLRAlgo_PolyMask_FMskSide))
7fd59977 3074 outl = Standard_False;
681f3919 3075 else if ( (aTriangle.Flags & HLRAlgo_PolyMask_FMskSide))
3076 outl = !(aTriangle.Flags & HLRAlgo_PolyMask_FMskFlat) && !(aTriangle2.Flags & HLRAlgo_PolyMask_FMskBack);
7fd59977 3077 else
681f3919 3078 outl = !(aTriangle2.Flags & HLRAlgo_PolyMask_FMskFlat) && !(aTriangle.Flags & HLRAlgo_PolyMask_FMskBack);
7fd59977 3079 BP.OutLine(outl);
3080 }
3081 }
0797d9d3 3082#ifdef OCCT_DEBUG
7fd59977 3083 else if (DoError) {
3084 cout << "HLRBRep_PolyAlgo::UpdateEdgesBiPoints : error ";
681f3919 3085 cout << " between " << aIndices.FaceConex1 << setw(6);
3086 cout << " and " << aIndices.FaceConex2 << endl;
7fd59977 3087 }
3088#endif
3089 }
3090 }
3091}
3092
3093//=======================================================================
3094//function : UpdatePolyData
3095//purpose :
3096//=======================================================================
3097
3098void
3099HLRBRep_PolyAlgo::UpdatePolyData (TColStd_Array1OfTransient& PD,
3100 TColStd_Array1OfTransient& PID,
3101 const Standard_Boolean closed)
3102{
3103 Standard_Integer f,i;//,n[3];
3104 Handle(TColgp_HArray1OfXYZ) HNodes;
3105 Handle(HLRAlgo_HArray1OfTData) HTData;
3106 Handle(HLRAlgo_HArray1OfPHDat) HPHDat;
3107 Standard_Integer nbFace = myFMap.Extent();
3108 Handle(HLRAlgo_PolyInternalData)* pid =
3109 (Handle(HLRAlgo_PolyInternalData)*)&(PID.ChangeValue(1));
3110 Handle(HLRAlgo_PolyData)* pd =
3111 (Handle(HLRAlgo_PolyData)*)&(PD.ChangeValue(1));
3112
3113 for (f = 1; f <= nbFace; f++) {
3114 if (!(*pid).IsNull()) {
3115 Standard_Integer nbN = (*pid)->NbPINod();
3116 Standard_Integer nbT = (*pid)->NbTData();
3117 HNodes = new TColgp_HArray1OfXYZ (1,nbN);
3118 HTData = new HLRAlgo_HArray1OfTData(1,nbT);
3119 TColgp_Array1OfXYZ& Nodes = HNodes->ChangeArray1();
3120 HLRAlgo_Array1OfTData& Trian = HTData->ChangeArray1();
681f3919 3121 HLRAlgo_Array1OfTData* TData = &(*pid)->TData();
3122 HLRAlgo_Array1OfPINod* PINod = &(*pid)->PINod();
7fd59977 3123 Standard_Integer nbHide = 0;
681f3919 3124
7fd59977 3125 for (i = 1; i <= nbN; i++) {
681f3919 3126 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues = PINod->ChangeValue(i)->Data();
3127 Nodes.ChangeValue(i) = Nod1RValues.Point;
7fd59977 3128 }
3129
7fd59977 3130 for (i = 1; i <= nbT; i++) {
681f3919 3131 HLRAlgo_TriangleData* OT = &TData->ChangeValue(i);
3132 HLRAlgo_TriangleData* NT = &(Trian.ChangeValue(i));
3133 if (!(OT->Flags & HLRAlgo_PolyMask_FMskSide)) {
0797d9d3 3134#ifdef OCCT_DEBUG
681f3919 3135 if ((OT->Flags & HLRAlgo_PolyMask_FMskFrBack) && DoTrace) {
7fd59977 3136 cout << "HLRBRep_PolyAlgo::ReverseBackTriangle :";
3137 cout << " face " << f << setw(6);
3138 cout << " triangle " << i << endl;
3139 }
3140#endif
681f3919 3141 if (OT->Flags & HLRAlgo_PolyMask_FMskOrBack) {
3142 Standard_Integer j = OT->Node1;
3143 OT->Node1 = OT->Node3;
3144 OT->Node3 = j;
3145 OT->Flags |= HLRAlgo_PolyMask_FMskBack;
7fd59977 3146 }
3147 else
681f3919 3148 OT->Flags &= ~HLRAlgo_PolyMask_FMskBack;
3149 //Tri1Flags |= HLRAlgo_PolyMask_FMskBack;//OCC349
7fd59977 3150 }
681f3919 3151 NT->Node1 = OT->Node1;
3152 NT->Node2 = OT->Node2;
3153 NT->Node3 = OT->Node3;
3154 NT->Flags = OT->Flags;
3155 if (!(NT->Flags & HLRAlgo_PolyMask_FMskSide) &&
3156 (!(NT->Flags & HLRAlgo_PolyMask_FMskBack) || !closed)) {
3157 NT->Flags |= HLRAlgo_PolyMask_FMskHiding;
7fd59977 3158 nbHide++;
3159 }
3160 else
681f3919 3161 NT->Flags &= ~HLRAlgo_PolyMask_FMskHiding;
7fd59977 3162 }
3163 if (nbHide > 0) HPHDat = new HLRAlgo_HArray1OfPHDat(1,nbHide);
3164 else HPHDat.Nullify();
3165 (*pd)->HNodes(HNodes);
3166 (*pd)->HTData(HTData);
3167 (*pd)->HPHDat(HPHDat);
3168 (*pd)->FaceIndex(f);
3169 }
3170 pid++;
3171 pd++;
3172 }
3173}
3174
3175//=======================================================================
3176//function : TMultiply
3177//purpose :
3178//=======================================================================
3179
3180void
3181HLRBRep_PolyAlgo::TMultiply (Standard_Real& X,
3182 Standard_Real& Y,
3183 Standard_Real& Z,
3184 const Standard_Boolean VPO) const
3185{
3186 Standard_Real Xt = TMat[0][0]*X + TMat[0][1]*Y + TMat[0][2]*Z + (VPO ? 0 : TLoc[0]);//OCC349
3187 Standard_Real Yt = TMat[1][0]*X + TMat[1][1]*Y + TMat[1][2]*Z + (VPO ? 0 : TLoc[1]);//OCC349
3188 Z = TMat[2][0]*X + TMat[2][1]*Y + TMat[2][2]*Z + (VPO ? 0 : TLoc[2]);//OCC349
3189 X = Xt;
3190 Y = Yt;
3191}
3192
3193//=======================================================================
3194//function : TTMultiply
3195//purpose :
3196//=======================================================================
3197
3198void
3199HLRBRep_PolyAlgo::TTMultiply (Standard_Real& X,
3200 Standard_Real& Y,
3201 Standard_Real& Z,
3202 const Standard_Boolean VPO) const
3203{
3204 Standard_Real Xt = TTMa[0][0]*X + TTMa[0][1]*Y + TTMa[0][2]*Z + (VPO ? 0 : TTLo[0]);//OCC349
3205 Standard_Real Yt = TTMa[1][0]*X + TTMa[1][1]*Y + TTMa[1][2]*Z + (VPO ? 0 : TTLo[1]);//OCC349
3206 Z = TTMa[2][0]*X + TTMa[2][1]*Y + TTMa[2][2]*Z + (VPO ? 0 : TTLo[2]);//OCC349
3207 X = Xt;
3208 Y = Yt;
3209}
3210
3211//=======================================================================
3212//function : TIMultiply
3213//purpose :
3214//=======================================================================
3215
3216void
3217HLRBRep_PolyAlgo::TIMultiply (Standard_Real& X,
3218 Standard_Real& Y,
3219 Standard_Real& Z,
3220 const Standard_Boolean VPO) const
3221{
3222 Standard_Real Xt = TIMa[0][0]*X + TIMa[0][1]*Y + TIMa[0][2]*Z + (VPO ? 0 : TILo[0]);//OCC349
3223 Standard_Real Yt = TIMa[1][0]*X + TIMa[1][1]*Y + TIMa[1][2]*Z + (VPO ? 0 : TILo[1]);//OCC349
3224 Z = TIMa[2][0]*X + TIMa[2][1]*Y + TIMa[2][2]*Z + (VPO ? 0 : TILo[2]);//OCC349
3225 X = Xt;
3226 Y = Yt;
3227}
3228
3229//=======================================================================
3230//function : Hide
3231//purpose :
3232//=======================================================================
3233
681f3919 3234HLRAlgo_BiPoint::PointsT& HLRBRep_PolyAlgo::Hide (
7fd59977 3235 HLRAlgo_EdgeStatus& status,
3236 TopoDS_Shape& S,
3237 Standard_Boolean& reg1,
3238 Standard_Boolean& regn,
3239 Standard_Boolean& outl,
3240 Standard_Boolean& intl)
3241{
3242 Standard_Integer index;
681f3919 3243 HLRAlgo_BiPoint::PointsT& aPoints = myAlgo->Hide(status,index,reg1,regn,outl,intl);
7fd59977 3244 if (intl) S = myFMap(index);
3245 else S = myEMap(index);
681f3919 3246 return aPoints;
7fd59977 3247}
3248
3249//=======================================================================
3250//function : Show
3251//purpose :
3252//=======================================================================
3253
681f3919 3254HLRAlgo_BiPoint::PointsT& HLRBRep_PolyAlgo::Show (
7fd59977 3255 TopoDS_Shape& S,
3256 Standard_Boolean& reg1,
3257 Standard_Boolean& regn,
3258 Standard_Boolean& outl,
3259 Standard_Boolean& intl)
3260{
3261 Standard_Integer index;
681f3919 3262 HLRAlgo_BiPoint::PointsT& aPoints = myAlgo->Show(index,reg1,regn,outl,intl);
7fd59977 3263 if (intl) S = myFMap(index);
3264 else S = myEMap(index);
681f3919 3265 return aPoints;
7fd59977 3266}
3267
3268//=======================================================================
3269//function : OutLinedShape
3270//purpose :
3271//=======================================================================
3272
3273TopoDS_Shape
3274HLRBRep_PolyAlgo::OutLinedShape (const TopoDS_Shape& S) const
3275{
3276 TopoDS_Shape Result;
3277
3278 if (!S.IsNull()) {
3279 BRep_Builder B;
3280 B.MakeCompound(TopoDS::Compound(Result));
3281 B.Add(Result,S);
3282
3283 TopTools_MapOfShape Map;
3284 TopExp_Explorer ex;
3285 for (ex.Init(S,TopAbs_EDGE); ex.More(); ex.Next())
3286 Map.Add(ex.Current());
3287 for (ex.Init(S,TopAbs_FACE); ex.More(); ex.Next())
3288 Map.Add(ex.Current());
3289
3290 Standard_Integer nbFace = myFMap.Extent();
3291 if (nbFace > 0) {
3292 TopTools_Array1OfShape NewF(1,nbFace);
3293 TColStd_Array1OfTransient& Shell = myAlgo->PolyShell();
3294 Standard_Integer nbShell = Shell.Upper();
3295 HLRAlgo_ListIteratorOfListOfBPoint it;
3296
3297 for (Standard_Integer iShell = 1; iShell <= nbShell; iShell++) {
3298 HLRAlgo_ListOfBPoint& List =
3299 (*(Handle(HLRAlgo_PolyShellData)*)&(Shell(iShell)))->Edges();
3300
3301 for (it.Initialize(List); it.More(); it.Next()) {
3302 HLRAlgo_BiPoint& BP = it.Value();
3303 if (BP.IntLine()) {
681f3919 3304 HLRAlgo_BiPoint::IndicesT& aIndices = BP.Indices();
3305 if (Map.Contains(myFMap(aIndices.ShapeIndex))) {
3306 HLRAlgo_BiPoint::PointsT& aPoints = BP.Points();
3307 B.Add(Result,BRepLib_MakeEdge(aPoints.Pnt1, aPoints.Pnt2));
7fd59977 3308 }
3309 }
3310 }
3311 }
3312 }
3313 }
3314 return Result;
3315}
3316
Open CASCADE Technology repository