1 // Created on: 1995-05-05
2 // Created by: Christophe MARION
3 // Copyright (c) 1995-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
6 // This file is part of Open CASCADE Technology software library.
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
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.
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
17 // Modified by cma, Tue Apr 1 11:39:48 1997
18 // Modified by cma, Tue Apr 1 11:40:30 1997
20 #include <BRep_Builder.hxx>
21 #include <BRep_Tool.hxx>
22 #include <BRepLib_MakeEdge.hxx>
24 #include <CSLib_DerivativeStatus.hxx>
25 #include <CSLib_NormalStatus.hxx>
26 #include <Geom_RectangularTrimmedSurface.hxx>
27 #include <Geom_Surface.hxx>
29 #include <HLRAlgo_BiPoint.hxx>
30 #include <HLRAlgo_EdgeStatus.hxx>
31 #include <HLRAlgo_ListIteratorOfListOfBPoint.hxx>
32 #include <HLRAlgo_PolyAlgo.hxx>
33 #include <HLRAlgo_PolyData.hxx>
34 #include <HLRAlgo_PolyInternalData.hxx>
35 #include <HLRAlgo_PolyMask.hxx>
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>
50 #include <TopExp_Explorer.hxx>
52 #include <TopoDS_Edge.hxx>
53 #include <TopoDS_Shape.hxx>
54 #include <TopTools_Array1OfShape.hxx>
55 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
56 #include <TopTools_ListIteratorOfListOfShape.hxx>
58 IMPLEMENT_STANDARD_RTTIEXT(HLRBRep_PolyAlgo,MMgt_TShared)
71 static Standard_Integer DoTrace = Standard_False;
72 static Standard_Integer DoError = Standard_False;
74 //=======================================================================
75 //function : HLRBRep_PolyAlgo
77 //=======================================================================
79 HLRBRep_PolyAlgo::HLRBRep_PolyAlgo () :
80 myDebug (Standard_False),
81 myAngle (5 * M_PI / 180.),
86 myAlgo = new HLRAlgo_PolyAlgo();
89 //=======================================================================
90 //function : HLRBRep_PolyAlgo
92 //=======================================================================
94 HLRBRep_PolyAlgo::HLRBRep_PolyAlgo (const Handle(HLRBRep_PolyAlgo)& A)
98 myTolAngular = A->TolAngular();
99 myTolSta = A->TolCoef();
100 myTolEnd = 1 - myTolSta;
102 myProj = A->Projector();
104 Standard_Integer n = A->NbShapes();
106 for (Standard_Integer i = 1; i <= n; i++)
110 //=======================================================================
111 //function : HLRBRep_PolyAlgo
113 //=======================================================================
115 HLRBRep_PolyAlgo::HLRBRep_PolyAlgo (const TopoDS_Shape& S) :
116 myDebug (Standard_False),
117 myAngle (5 * M_PI / 180.),
123 myAlgo = new HLRAlgo_PolyAlgo();
126 //=======================================================================
129 //=======================================================================
131 TopoDS_Shape & HLRBRep_PolyAlgo::Shape (const Standard_Integer I)
133 Standard_OutOfRange_Raise_if (I == 0 || I > myShapes.Length(),
134 "HLRBRep_PolyAlgo::Shape : unknown Shape");
138 //=======================================================================
141 //=======================================================================
143 void HLRBRep_PolyAlgo::Remove (const Standard_Integer I)
145 Standard_OutOfRange_Raise_if (I == 0 || I > myShapes.Length(),
146 "HLRBRep_PolyAlgo::Remove : unknown Shape");
153 //=======================================================================
156 //=======================================================================
158 Standard_Integer HLRBRep_PolyAlgo::Index (const TopoDS_Shape& S) const
160 Standard_Integer n = myShapes.Length();
162 for (Standard_Integer i = 1; i <= n; i++)
163 if (myShapes(i) == S) return i;
168 //=======================================================================
171 //=======================================================================
173 Handle(HLRAlgo_PolyAlgo) HLRBRep_PolyAlgo::Algo () const
178 //=======================================================================
181 //=======================================================================
183 void HLRBRep_PolyAlgo::Update ()
188 TopoDS_Shape Shape = MakeShape();
190 if (!Shape.IsNull()) {
191 TopExp_Explorer exshell;
192 Standard_Boolean IsoledF,IsoledE;//,closed;
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);
204 TColStd_Array1OfTransient& Shell = myAlgo->PolyShell();
205 Standard_Integer iShell = 0;
207 for (exshell.Init(Shape, TopAbs_SHELL);
210 StoreShell(exshell.Current(),iShell,Shell,
211 Standard_False,Standard_False,
212 ES,PD,PID,ShapeMap1,ShapeMap2);
214 StoreShell(Shape,iShell,Shell,IsoledF,Standard_False,
215 ES,PD,PID,ShapeMap1,ShapeMap2);
217 StoreShell(Shape,iShell,Shell,Standard_False,IsoledE,
218 ES,PD,PID,ShapeMap1,ShapeMap2);
224 //=======================================================================
225 //function : MakeShape
227 //=======================================================================
229 TopoDS_Shape HLRBRep_PolyAlgo::MakeShape () const
231 Standard_Integer n = myShapes.Length();
232 Standard_Boolean FirstTime = Standard_True;
236 for (Standard_Integer i = 1; i <= n; i++) {
238 FirstTime = Standard_False;
239 B.MakeCompound(TopoDS::Compound(Shape));
241 B.Add(Shape,myShapes(i));
246 //=======================================================================
247 //function : InitShape
249 //=======================================================================
252 HLRBRep_PolyAlgo::InitShape (const TopoDS_Shape& Shape,
253 Standard_Boolean& IsoledF,
254 Standard_Boolean& IsoledE)
256 TopTools_MapOfShape ShapeMap0;
257 Standard_Integer nbShell = 0;
258 IsoledF = Standard_False;
259 IsoledE = Standard_False;
260 TopExp_Explorer exshell,exface,exedge;
263 for (exshell.Init(Shape, TopAbs_SHELL);
266 Standard_Boolean withTrian = Standard_False;
268 for (exface.Init(exshell.Current(), TopAbs_FACE);
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;
277 if (withTrian) nbShell++;
280 for (exface.Init(Shape, TopAbs_FACE, TopAbs_SHELL);
281 exface.More() && !IsoledF;
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;
289 if (IsoledF) nbShell++;
291 for (exedge.Init(Shape, TopAbs_EDGE, TopAbs_FACE);
292 exedge.More() && !IsoledE;
294 IsoledE = Standard_True;
295 if (IsoledE) nbShell++;
297 myAlgo->Init(new TColStd_HArray1OfTransient(1,nbShell));
301 //=======================================================================
302 //function : StoreShell
304 //=======================================================================
306 void 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)
318 TopExp_Explorer exface,exedge;
319 Standard_Integer f = 0,i,j;
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();
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();
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);
355 closed = Shape.Closed();
357 TopTools_IndexedMapOfShape EM;
358 TopExp::MapShapes(Shape,TopAbs_EDGE,EM);
360 Standard_Integer nbEdge = EM.Extent ();
361 Standard_Integer *flag = new Standard_Integer[nbEdge + 1];
363 for (ie = 1; ie <= nbEdge; ie++)
366 for (exedge.Init(Shape, TopAbs_EDGE);
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;
377 closed = Standard_True;
379 for (ie = 1; ie <= nbEdge && closed; ie++)
380 closed = (flag[ie] == 0);
385 exface.Init(Shape, TopAbs_FACE);
388 exface.Init(Shape, TopAbs_FACE, TopAbs_SHELL);
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))
398 if (nbFaceShell > 0 || IsoledE) {
400 Shell(iShell) = new HLRAlgo_PolyShellData(nbFaceShell);
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;
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);
414 if (ShapeMap2.Add(F)) {
416 f = myFMap.FindIndex(F);
417 reversed = F.Orientation() == TopAbs_REVERSED;
418 gp_Trsf TT = L.Transformation();
420 const gp_XYZ& ttlo = TT.TranslationPart();
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);
448 HLRAlgo_Array1OfTData* TData = &pid->TData();
449 HLRAlgo_Array1OfPISeg* PISeg = &pid->PISeg();
450 HLRAlgo_Array1OfPINod* PINod = &pid->PINod();
451 Poly_Triangle * OT = &(Tri.ChangeValue(1));
452 HLRAlgo_TriangleData* NT = &TData->ChangeValue(1);
454 for (i = 1; i <= nbT; i++) {
455 OT->Get(NT->Node1, NT->Node2, NT->Node3);
459 NT->Node1 = NT->Node3;
466 gp_Pnt * ON = &(Nod.ChangeValue(1));
467 Handle(HLRAlgo_PolyInternalNode)* NN = &PINod->ChangeValue(1);
469 for (i = 1; i <= nbN; i++) {
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);
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)->
487 for (i = 1; i <= nbN; i++) {
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,
492 TData,PISeg,PINod,Standard_False))
493 aNodIndices.Flag |= NMsk_Norm;
495 aNodIndices.Flag &= ~NMsk_Norm;
496 Nod1RValues.Scal = 0;
504 cout << " HLRBRep_PolyAlgo::StoreShell : Face ";
505 cout << f << " non triangulated" << endl;
508 NT = &(((HLRAlgo_Array1OfTData*)TData)->ChangeValue(1));
510 for (i = 1; i <= nbT; i++) {
511 const Handle(HLRAlgo_PolyInternalNode)* PN1 =
512 &PINod->ChangeValue(NT->Node1);
513 const Handle(HLRAlgo_PolyInternalNode)* PN2 =
514 &PINod->ChangeValue(NT->Node2);
515 const Handle(HLRAlgo_PolyInternalNode)* PN3 =
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);
530 cout << "HLRBRep_PolyAlgo::StoreShell : Face ";
531 cout << f << " deja stockee" << endl;
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));
542 for (f = 1; f <= nbFace; f++) {
543 if (!(*pid).IsNull()) {
545 for (exedge.Init(myFMap(f),TopAbs_EDGE);
548 TopoDS_Edge E = TopoDS::Edge(exedge.Current());
549 if (ShapeMap1.Add(E)) {
550 Standard_Integer e = myEMap.FindIndex(E);
552 Standard_Integer anIndexE = EF.FindIndex(E);
554 TopTools_ListOfShape& LS = EF(anIndexE);
555 InitBiPointsWithConnexity(e,E,List,PID,LS,Standard_True);
558 TopTools_ListOfShape LS;
559 InitBiPointsWithConnexity(e,E,List,PID,LS,Standard_False);
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));
573 for (f = 1; f <= nbFace; f++) {
579 const Handle(HLRAlgo_PolyShellData)& psd =
580 *(Handle(HLRAlgo_PolyShellData)*)&(Shell(iShell));
581 HLRAlgo_ListOfBPoint& List = psd->Edges();
583 for (exedge.Init(Shape, TopAbs_EDGE, TopAbs_FACE);
586 TopoDS_Edge E = TopoDS::Edge(exedge.Current());
587 if (ShapeMap1.Add(E)) {
588 Standard_Integer e = myEMap.FindIndex(E);
590 TopTools_ListOfShape LS;
591 InitBiPointsWithConnexity(e,E,List,PID,LS,Standard_False);
597 //=======================================================================
600 //=======================================================================
602 Standard_Boolean HLRBRep_PolyAlgo::
603 Normal (const Standard_Integer iNode,
604 HLRAlgo_PolyInternalNode::NodeIndices& theNodIndices,
605 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
606 HLRAlgo_Array1OfTData*& TData,
607 HLRAlgo_Array1OfPISeg*& PISeg,
608 HLRAlgo_Array1OfPINod*& PINod,
609 const Standard_Boolean orient) const
611 gp_Vec D1U,D1V,D2U,D2V,D2UV;
615 CSLib_DerivativeStatus Status;
616 CSLib_NormalStatus NStat;
617 myBSurf.D1(Nod1RValues.UV.X(), Nod1RValues.UV.Y(), P, D1U, D1V);
618 CSLib::Normal(D1U,D1V,Standard_Real(Precision::Angular()),
620 if (Status != CSLib_Done) {
621 myBSurf.D2(Nod1RValues.UV.X(), Nod1RValues.UV.Y(), P, D1U, D1V, D2U, D2V, D2UV);
622 CSLib::Normal(D1U,D1V,D2U,D2V,D2UV,
623 Precision::Angular(),OK,NStat,Norma);
625 return Standard_False;
627 Standard_Real EyeX = 0;
628 Standard_Real EyeY = 0;
629 Standard_Real EyeZ = -1;
630 if (myProj.Perspective()) {
631 EyeX = Nod1RValues.Point.X();
632 EyeY = Nod1RValues.Point.Y();
633 EyeZ = Nod1RValues.Point.Z() - myProj.Focus();
634 Standard_Real d = sqrt(EyeX * EyeX + EyeY * EyeY + EyeZ * EyeZ);
641 Nod1RValues.Normal = Norma.XYZ();
642 // TMultiply(Nod1NrmX,Nod1NrmY,Nod1NrmZ);
643 TMultiply(Nod1RValues.Normal,myProj.Perspective()); //OCC349
646 if (AverageNormal(iNode,theNodIndices,TData,PISeg,PINod,Norm))
648 if (Nod1RValues.Normal * Norm < 0)
650 Nod1RValues.Normal.Reverse();
652 Nod1RValues.Scal = (Nod1RValues.Normal * gp_XYZ(EyeX, EyeY, EyeZ));
655 Nod1RValues.Scal = 0;
656 Nod1RValues.Normal = gp_XYZ(1., 0., 0.);
659 cout << "HLRBRep_PolyAlgo::Normal : AverageNormal error";
664 if (Nod1RValues.Scal > 0) {
665 if ( Nod1RValues.Scal < myTolAngular) {
666 Nod1RValues.Scal = 0;
667 theNodIndices.Flag |= NMsk_OutL;
671 if (-Nod1RValues.Scal < myTolAngular) {
672 Nod1RValues.Scal = 0;
673 theNodIndices.Flag |= NMsk_OutL;
676 if (orient) UpdateAroundNode(iNode,theNodIndices,
678 return Standard_True;
681 //=======================================================================
682 //function : AverageNormal
684 //=======================================================================
687 HLRBRep_PolyAlgo::AverageNormal(const Standard_Integer iNode,
688 HLRAlgo_PolyInternalNode::NodeIndices& theNodeIndices,
689 HLRAlgo_Array1OfTData*& TData,
690 HLRAlgo_Array1OfPISeg*& PISeg,
691 HLRAlgo_Array1OfPINod*& PINod,
694 Standard_Real& Z) const
696 Standard_Boolean OK = Standard_False;
697 Standard_Integer jNode = 0,kNode,iiii,iTri1,iTri2;
701 iiii = theNodeIndices.NdSg;
703 while (iiii != 0 && !OK) {
704 HLRAlgo_PolyInternalSegment& aSegIndices =
705 ((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii);
706 iTri1 = aSegIndices.Conex1;
707 iTri2 = aSegIndices.Conex2;
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);
712 if (aSegIndices.LstSg1 == iNode) iiii = aSegIndices.NxtSg1;
713 else iiii = aSegIndices.NxtSg2;
717 iiii = theNodeIndices.NdSg;
719 while (iiii != 0 && !OK) {
720 HLRAlgo_PolyInternalSegment& aSegIndices = PISeg->ChangeValue(iiii);
721 iTri1 = aSegIndices.Conex1;
722 iTri2 = aSegIndices.Conex2;
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);
727 if (aSegIndices.LstSg1 == jNode) iiii = aSegIndices.NxtSg1;
728 else iiii = aSegIndices.NxtSg2;
731 Standard_Real d = sqrt (X * X + Y * Y + Z * Z);
732 if (OK && d < 1.e-10) {
736 cout << "HLRAlgo_PolyInternalData:: inverted normals on ";
737 cout << "node " << iNode << endl;
744 //=======================================================================
745 //function : AddNormalOnTriangle
747 //=======================================================================
751 AddNormalOnTriangle(const Standard_Integer iTri,
752 const Standard_Integer iNode,
753 Standard_Integer& jNode,
754 HLRAlgo_Array1OfTData*& TData,
755 HLRAlgo_Array1OfPINod*& PINod,
759 Standard_Boolean& OK) const
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;
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;
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;
789 const gp_XYZ aDN = (1 / (aD1Norm * aD2Norm)) * (aD1 ^ aD2);
790 const Standard_Real aDNNorm = aDN.Modulus();
791 if (aDNNorm > 1.e-10) {
802 //=======================================================================
803 //function : InitBiPointsWithConnexity
805 //=======================================================================
807 void HLRBRep_PolyAlgo::
808 InitBiPointsWithConnexity (const Standard_Integer e,
810 HLRAlgo_ListOfBPoint& List,
811 TColStd_Array1OfTransient& PID,
812 TopTools_ListOfShape& LS,
813 const Standard_Boolean connex)
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;
818 Standard_Real U1,U2 = 0.;
819 Handle(Poly_PolygonOnTriangulation) HPol[2];
821 myBCurv.Initialize(E);
823 Standard_Integer nbConnex = LS.Extent();
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();
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;
842 const Handle(HLRAlgo_PolyInternalNode)* pi1p1 =
843 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(Pol1(1 )));
844 aNode11Indices = &(*pi1p1)->Indices();
845 HLRAlgo_PolyInternalNode::NodeData* Nod11RValues = &(*pi1p1)->Data();
846 const Handle(HLRAlgo_PolyInternalNode)* pi1p2 =
847 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(Pol1(nbPol)));
848 aNode12Indices = &(*pi1p2)->Indices();
849 HLRAlgo_PolyInternalNode::NodeData* Nod12RValues = &(*pi1p2)->Data();
850 aNode11Indices->Flag |= NMsk_Vert;
851 aNode12Indices->Flag |= NMsk_Vert;
853 for (iPol = 1; iPol <= nbPol; iPol++) {
854 const Handle(HLRAlgo_PolyInternalNode)* pi1pA =
855 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(Pol1(iPol)));
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);
863 aNodeIndices1A.Edg2 = e;
864 Nod1ARValues.PCu2 = par->Value(iPol);
869 aNode12Indices = aNode11Indices;
870 Nod12RValues = Nod11RValues;
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;
878 cout << " HLRBRep_PolyAlgo::InitBiPointsWithConnexity : ";
879 cout << "Parameter error on Node " << i1p2 << endl;
882 aNode12Indices->Flag |= NMsk_Edge;
883 TIMultiply(XTI2,YTI2,ZTI2);
884 if (Pol1(1) == Pol1(nbPol) && myPC.IsPeriodic())
885 U2 = U2 - myPC.Period();
887 if (nbPol == 2 && BRep_Tool::Degenerated(E)) {
888 CheckDegeneratedSegment(*aNode11Indices,*Nod11RValues,
889 *aNode12Indices,*Nod12RValues);
890 UpdateAroundNode(Pol1(1 ),*aNode11Indices,TData1,PISeg1,PINod1);
891 UpdateAroundNode(Pol1(nbPol),*aNode12Indices,TData1,PISeg1,PINod1);
895 for (iPol = 2; iPol <= nbPol; iPol++) {
897 aNode11Indices = aNode12Indices;
898 Nod11RValues = Nod12RValues;
900 const Handle(HLRAlgo_PolyInternalNode)* pi1p2iPol =
901 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(Pol1(iPol)));
902 aNode12Indices = &(*pi1p2iPol)->Indices();
903 Nod12RValues = &(*pi1p2iPol)->Data();
906 if (Nod11RValues->Normal.X()*Nod12RValues->Normal.X() +
907 Nod11RValues->Normal.Y()*Nod12RValues->Normal.Y() +
908 Nod11RValues->Normal.Z()*Nod12RValues->Normal.Z() < 0) {
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;
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;
930 cout << " HLRBRep_PolyAlgo::InitBiPointsWithConnexity : ";
931 cout << "Parameter error on Node " << i1p2 << endl;
934 aNode12Indices->Flag |= NMsk_Edge;
935 TIMultiply(XTI2,YTI2,ZTI2);
937 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
938 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
940 *aNode11Indices,*Nod11RValues,
941 *aNode12Indices,*Nod12RValues,
942 i1p1,i1p2,i1,pid1,TData1,PISeg1,PINod1);
948 cout << "HLRBRep_PolyAlgo::InitBiPointsWithConnexity : Edge ";
949 cout << e << " connex 1 sans PolygonOnTriangulation" << endl;
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);
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();
975 Standard_Integer nbPol1 = Pol1.Upper();
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();
982 const Handle(HLRAlgo_PolyInternalNode)* pi1p1 =
983 &PINod1->ChangeValue(Pol1(1));
984 HLRAlgo_PolyInternalNode::NodeIndices* aNode11Indices = &(*pi1p1)->Indices();
985 HLRAlgo_PolyInternalNode::NodeData* Nod11RValues = &(*pi1p1)->Data();
986 const Handle(HLRAlgo_PolyInternalNode)* pi1p2nbPol1 =
987 &PINod1->ChangeValue(Pol1(nbPol1));
988 HLRAlgo_PolyInternalNode::NodeIndices* aNode12Indices = &(*pi1p2nbPol1)->Indices();
989 HLRAlgo_PolyInternalNode::NodeData* Nod12RValues = &(*pi1p2nbPol1)->Data();
990 const Handle(HLRAlgo_PolyInternalNode)* pi2p1 =
991 &PINod2->ChangeValue(Pol2(1));
992 HLRAlgo_PolyInternalNode::NodeIndices* Nod21Indices = &(*pi2p1)->Indices();
993 HLRAlgo_PolyInternalNode::NodeData* Nod21RValues = &(*pi2p1)->Data();
994 const Handle(HLRAlgo_PolyInternalNode)* pi2p2 =
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;
1003 for (iPol = 1; iPol <= nbPol1; iPol++) {
1004 const Handle(HLRAlgo_PolyInternalNode)* pi1pA =
1005 &PINod1->ChangeValue(Pol1(iPol));
1006 HLRAlgo_PolyInternalNode::NodeIndices* Nod1AIndices = &(*pi1pA)->Indices();
1007 HLRAlgo_PolyInternalNode::NodeData* Nod1ARValues = &(*pi1pA)->Data();
1008 const Handle(HLRAlgo_PolyInternalNode)* pi2pA =
1009 &PINod2->ChangeValue(Pol2(iPol));
1010 HLRAlgo_PolyInternalNode::NodeIndices* Nod2AIndices = &(*pi2pA)->Indices();
1011 HLRAlgo_PolyInternalNode::NodeData* Nod2ARValues = &(*pi2pA)->Data();
1012 Standard_Real PCu = par->Value(iPol);
1013 if (Nod1AIndices->Edg1 == 0 || Nod1AIndices->Edg1 == e) {
1014 Nod1AIndices->Edg1 = e;
1015 Nod1ARValues->PCu1 = PCu;
1018 Nod1AIndices->Edg2 = e;
1019 Nod1ARValues->PCu2 = PCu;
1021 if (Nod2AIndices->Edg1 == 0 || Nod2AIndices->Edg1 == e) {
1022 Nod2AIndices->Edg1 = e;
1023 Nod2ARValues->PCu1 = PCu;
1026 Nod2AIndices->Edg2 = e;
1027 Nod2ARValues->PCu2 = PCu;
1032 aNode12Indices = aNode11Indices;
1033 Nod12RValues = Nod11RValues;
1035 Nod22Indices = Nod21Indices;
1036 Nod22RValues = Nod21RValues;
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;
1044 cout << " HLRBRep_PolyAlgo::InitBiPointsWithConnexity : ";
1045 cout << "Parameter error on Node " << i1p2 << endl;
1048 aNode12Indices->Flag |= NMsk_Edge;
1049 Nod22Indices->Flag |= NMsk_Edge;
1050 TIMultiply(XTI2,YTI2,ZTI2);
1051 if (Pol1(1) == Pol1(nbPol1) && myPC.IsPeriodic())
1052 U2 = U2 - myPC.Period();
1054 if (nbPol1 == 2 && BRep_Tool::Degenerated(E)) {
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);
1066 for (iPol = 2; iPol <= nbPol1; iPol++) {
1068 aNode11Indices = aNode12Indices;
1069 Nod11RValues = Nod12RValues;
1071 Nod21Indices = Nod22Indices;
1072 Nod21RValues = Nod22RValues;
1074 const Handle(HLRAlgo_PolyInternalNode)* pi1p2iPol =
1075 &PINod1->ChangeValue(Pol1(iPol));
1076 aNode12Indices = &(*pi1p2iPol)->Indices();
1077 Nod12RValues = &(*pi1p2iPol)->Data();
1079 const Handle(HLRAlgo_PolyInternalNode)* pi2p2iPol =
1080 &PINod2->ChangeValue(Pol2(iPol));
1081 Nod22Indices = &(*pi2p2iPol)->Indices();
1082 Nod22RValues = &(*pi2p2iPol)->Data();
1085 if (Nod11RValues->Normal.X()*Nod12RValues->Normal.X() +
1086 Nod11RValues->Normal.Y()*Nod12RValues->Normal.Y() +
1087 Nod11RValues->Normal.Z()*Nod12RValues->Normal.Z() < 0) {
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;
1093 if (Nod21RValues->Normal.X()*Nod22RValues->Normal.X() +
1094 Nod21RValues->Normal.Y()*Nod22RValues->Normal.Y() +
1095 Nod21RValues->Normal.Z()*Nod22RValues->Normal.Z() < 0) {
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;
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;
1117 cout << " HLRBRep_PolyAlgo::InitBiPointsWithConnexity : ";
1118 cout << "Parameter error on Node " << i1p2 << endl;
1121 aNode12Indices->Flag |= NMsk_Edge;
1122 aNode12Indices->Flag |= NMsk_Edge;
1123 TIMultiply(XTI2,YTI2,ZTI2);
1125 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
1126 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
1128 *aNode11Indices,*Nod11RValues,
1129 *aNode12Indices,*Nod12RValues,
1130 i1p1,i1p2,i1,pid1,TData1,PISeg1,PINod1,
1131 *Nod21Indices,*Nod21RValues,
1132 *Nod22Indices,*Nod22RValues,
1133 i2p1,i2p2,i2,pid2,TData2,PISeg2,PINod2);
1139 cout << "HLRBRep_PolyAlgo::InitBiPointsWithConnexity : Edge ";
1140 cout << e << " connect 2 without PolygonOnTriangulation" << endl;
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();
1152 const gp_XYZ& ttlo = TT.TranslationPart();
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);
1166 Standard_Integer nbPol1 = Pol.Upper();
1167 const gp_XYZ& P1 = Pol(1).XYZ();
1171 TTMultiply(X2,Y2,Z2);
1175 TIMultiply(XTI2,YTI2,ZTI2);
1177 for (Standard_Integer jPol = 2; jPol <= nbPol1; jPol++) {
1184 const gp_XYZ& P2 = Pol(jPol).XYZ();
1188 TTMultiply(X2,Y2,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,
1201 cout << "HLRBRep_PolyAlgo::InitBiPointsWithConnexity : Edge ";
1202 cout << e << " Isolated, without Polygone 3D" << endl;
1208 //=======================================================================
1209 //function : Interpolation
1211 //=======================================================================
1215 Interpolation (HLRAlgo_ListOfBPoint& List,
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,
1231 HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices,
1232 HLRAlgo_PolyInternalNode::NodeData& Nod11RValues,
1233 HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices,
1234 HLRAlgo_PolyInternalNode::NodeData& Nod12RValues,
1235 const Standard_Integer i1p1,
1236 const Standard_Integer i1p2,
1237 const Standard_Integer i1,
1238 const Handle(HLRAlgo_PolyInternalData)& pid1,
1239 HLRAlgo_Array1OfTData*& TData1,
1240 HLRAlgo_Array1OfPISeg*& PISeg1,
1241 HLRAlgo_Array1OfPINod*& PINod1) const
1243 Standard_Boolean insP3,mP3P1;
1244 Standard_Real X3,Y3,Z3,XTI3,YTI3,ZTI3,coef3,U3;
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,
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);
1258 //=======================================================================
1259 //function : Interpolation
1261 //=======================================================================
1265 Interpolation (HLRAlgo_ListOfBPoint& List,
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,
1281 const GeomAbs_Shape rg,
1282 HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices,
1283 HLRAlgo_PolyInternalNode::NodeData& Nod11RValues,
1284 HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices,
1285 HLRAlgo_PolyInternalNode::NodeData& Nod12RValues,
1286 const Standard_Integer i1p1,
1287 const Standard_Integer i1p2,
1288 const Standard_Integer i1,
1289 const Handle(HLRAlgo_PolyInternalData)& pid1,
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,
1297 const Standard_Integer i2p1,
1298 const Standard_Integer i2p2,
1299 const Standard_Integer i2,
1300 const Handle(HLRAlgo_PolyInternalData)& pid2,
1301 HLRAlgo_Array1OfTData*& TData2,
1302 HLRAlgo_Array1OfPISeg*& PISeg2,
1303 HLRAlgo_Array1OfPINod*& PINod2) const
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;
1309 Standard_Integer flag = 0;
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;
1318 if (!insP4) // p1 i1p3 p2
1319 MoveOrInsertPoint(List,
1320 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
1321 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
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,
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,
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,
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,
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);
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));
1388 //=======================================================================
1389 //function : Interpolation
1391 //=======================================================================
1395 Interpolation (const Standard_Real U1,
1396 const Standard_Real U2,
1397 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
1398 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues,
1402 Standard_Real& XTI3,
1403 Standard_Real& YTI3,
1404 Standard_Real& ZTI3,
1405 Standard_Real& coef3,
1407 Standard_Boolean& mP3P1) const
1409 if (NewNode(Nod1RValues,Nod2RValues,coef3,mP3P1)) {
1410 U3 = U1 + (U2 - U1) * coef3;
1411 const gp_Pnt& P3 = myBCurv.Value(U3);
1415 TMultiply(X3,Y3,Z3);
1416 return Standard_True;
1418 X3 = Y3 = Z3 = XTI3 = YTI3 = ZTI3 = coef3 = U3 = 0.;
1419 return Standard_False;
1422 //=======================================================================
1423 //function : MoveOrInsertPoint
1425 //=======================================================================
1429 MoveOrInsertPoint (HLRAlgo_ListOfBPoint& List,
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,
1445 HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices,
1446 HLRAlgo_PolyInternalNode::NodeData& Nod11RValues,
1447 HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices,
1448 HLRAlgo_PolyInternalNode::NodeData& Nod12RValues,
1449 const Standard_Integer i1p1,
1450 const Standard_Integer i1p2,
1451 const Standard_Integer i1,
1452 const Handle(HLRAlgo_PolyInternalData)& pid1,
1453 HLRAlgo_Array1OfTData*& TData1,
1454 HLRAlgo_Array1OfPISeg*& PISeg1,
1455 HLRAlgo_Array1OfPINod*& PINod1,
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,
1466 const Standard_Integer flag) const
1468 HLRAlgo_Array1OfTData* TData2 = 0;
1469 HLRAlgo_Array1OfPISeg* PISeg2 = 0;
1470 HLRAlgo_Array1OfPINod* PINod2 = 0;
1471 Standard_Boolean ins3 = insP3;
1472 if (ins3 && mP3P1) { // P1 ---> P3
1473 if (!(Nod11Indices.Flag & NMsk_Vert) && coef3 < myTolSta) {
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);
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;
1492 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1493 cout << "Parameter error on Node " << i1p1 << endl;
1496 Nod11RValues.Scal = 0;
1497 Nod11Indices.Flag |= NMsk_OutL;
1498 UpdateAroundNode(i1p1,Nod11Indices,TData1,PISeg1,PINod1);
1499 HLRAlgo_BiPoint::PointsT& aPoints = List.First().Points();
1500 aPoints.PntP2 = gp_XYZ(X3, Y3, Z3);
1501 aPoints.Pnt2 = gp_XYZ(XTI3, YTI3, ZTI3);
1504 if (ins3 && !mP3P1) { // P2 ---> P3
1505 if (!(Nod12Indices.Flag & NMsk_Vert) && coef3 > myTolEnd) {
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);
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;
1524 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1525 cout << "Parameter error on Node " << i1p2 << endl;
1528 Nod12RValues.Scal = 0;
1529 Nod12Indices.Flag |= NMsk_OutL;
1530 UpdateAroundNode(i1p2,Nod12Indices,TData1,PISeg1,PINod1);
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));
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;
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));
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));
1564 //=======================================================================
1565 //function : MoveOrInsertPoint
1567 //=======================================================================
1571 MoveOrInsertPoint (HLRAlgo_ListOfBPoint& List,
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,
1587 HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices,
1588 HLRAlgo_PolyInternalNode::NodeData& Nod11RValues,
1589 HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices,
1590 HLRAlgo_PolyInternalNode::NodeData& Nod12RValues,
1591 const Standard_Integer i1p1,
1592 const Standard_Integer i1p2,
1593 const Standard_Integer i1,
1594 const Handle(HLRAlgo_PolyInternalData)& pid1,
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,
1602 const Standard_Integer i2p1,
1603 const Standard_Integer i2p2,
1604 const Standard_Integer i2,
1605 const Handle(HLRAlgo_PolyInternalData)& pid2,
1606 HLRAlgo_Array1OfTData*& TData2,
1607 HLRAlgo_Array1OfPISeg*& PISeg2,
1608 HLRAlgo_Array1OfPINod*& PINod2,
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,
1619 const Standard_Integer flag) const
1621 Standard_Boolean ins3 = insP3;
1622 if (ins3 && mP3P1) { // P1 ---> P3
1623 if (!(Nod11Indices.Flag & NMsk_Vert) && coef3 < myTolSta) {
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);
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;
1647 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1648 cout << "Parameter error on Node " << i1p1 << endl;
1651 Nod11RValues.Scal = 0;
1652 Nod11Indices.Flag |= NMsk_OutL;
1653 UpdateAroundNode(i1p1,Nod11Indices,TData1,PISeg1,PINod1);
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;
1659 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1660 cout << "Parameter error on Node " << i2p1 << endl;
1663 Nod21RValues.Scal = 0;
1664 Nod21Indices.Flag |= NMsk_OutL;
1665 UpdateAroundNode(i2p1,Nod21Indices,TData2,PISeg2,PINod2);
1666 HLRAlgo_BiPoint::PointsT& aPoints = List.First().Points();
1667 aPoints.PntP2 = gp_XYZ(X3, Y3, Z3);
1668 aPoints.Pnt2 = gp_XYZ(XTI3, YTI3, ZTI3);
1671 if (ins3 && !mP3P1) { // P2 ---> P3
1672 if (!(Nod12Indices.Flag & NMsk_Vert) && coef3 > myTolEnd) {
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);
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;
1696 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1697 cout << "Parameter error on Node " << i1p2 << endl;
1700 Nod12RValues.Scal = 0;
1701 Nod12Indices.Flag |= NMsk_OutL;
1702 UpdateAroundNode(i1p2,Nod12Indices,TData1,PISeg1,PINod1);
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;
1708 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1709 cout << "Parameter error on Node " << i2p2 << endl;
1712 Nod22RValues.Scal = 0;
1713 Nod22Indices.Flag |= NMsk_OutL;
1714 UpdateAroundNode(i2p2,Nod22Indices,TData2,PISeg2,PINod2);
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));
1724 HLRAlgo_PolyInternalNode::NodeIndices& Nod13Indices = (*pi1p3)->Indices();
1725 HLRAlgo_PolyInternalNode::NodeData& Nod13RValues = (*pi1p3)->Data();
1726 const Handle(HLRAlgo_PolyInternalNode)* pi2p3 =
1727 &(((HLRAlgo_Array1OfPINod*)PINod2)->ChangeValue(i2p3));
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;
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));
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));
1762 //=======================================================================
1763 //function : MoveOrInsertPoint
1765 //=======================================================================
1769 MoveOrInsertPoint (HLRAlgo_ListOfBPoint& List,
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,
1785 HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices,
1786 HLRAlgo_PolyInternalNode::NodeData& Nod11RValues,
1787 HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices,
1788 HLRAlgo_PolyInternalNode::NodeData& Nod12RValues,
1789 const Standard_Integer i1p1,
1790 const Standard_Integer i1p2,
1791 const Standard_Integer i1,
1792 const Handle(HLRAlgo_PolyInternalData)& pid1,
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,
1800 const Standard_Integer i2p1,
1801 const Standard_Integer i2p2,
1802 const Standard_Integer i2,
1803 const Handle(HLRAlgo_PolyInternalData)& pid2,
1804 HLRAlgo_Array1OfTData*& TData2,
1805 HLRAlgo_Array1OfPISeg*& PISeg2,
1806 HLRAlgo_Array1OfPINod*& PINod2,
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,
1827 const Standard_Integer flag) const
1829 Standard_Boolean ins3 = insP3;
1830 Standard_Boolean ins4 = insP4;
1831 if (ins3 && mP3P1) { // P1 ---> P3
1832 if (!(Nod11Indices.Flag & NMsk_Vert) && coef3 < myTolSta) {
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);
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;
1856 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1857 cout << "Parameter error on Node " << i1p1 << endl;
1860 Nod11RValues.Scal = 0;
1861 Nod11Indices.Flag |= NMsk_OutL;
1862 UpdateAroundNode(i1p1,Nod11Indices,TData1,PISeg1,PINod1);
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;
1868 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1869 cout << "Parameter error on Node " << i2p1 << endl;
1872 Nod21RValues.Scal = 0;
1873 Nod21Indices.Flag |= NMsk_OutL;
1874 UpdateAroundNode(i2p1,Nod21Indices,TData2,PISeg2,PINod2);
1875 HLRAlgo_BiPoint::PointsT& aPoints = List.First().Points();
1876 aPoints.PntP2 = gp_XYZ(X3, Y3, Z3);
1877 aPoints.Pnt2 = gp_XYZ(XTI3, YTI3, ZTI3);
1880 if (ins4 && !mP4P1) { // P2 ---> P4
1881 if (!(Nod12Indices.Flag & NMsk_Vert) && coef4 > myTolEnd) {
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);
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;
1905 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1906 cout << "Parameter error on Node " << i1p2 << endl;
1909 Nod12RValues.Scal = 0;
1910 Nod12Indices.Flag |= NMsk_OutL;
1911 UpdateAroundNode(i1p2,Nod12Indices,TData1,PISeg1,PINod1);
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;
1917 cout << " HLRBRep_PolyAlgo::MoveOrInsertPoint : ";
1918 cout << "Parameter error on Node " << i2p2 << endl;
1921 Nod22RValues.Scal = 0;
1922 Nod22Indices.Flag |= NMsk_OutL;
1923 UpdateAroundNode(i2p2,Nod22Indices,TData2,PISeg2,PINod2);
1927 if (!ins4) // p1 i1p3 p2
1928 MoveOrInsertPoint(List,
1929 X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ,
1930 XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2,
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,
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));
1962 HLRAlgo_PolyInternalNode::NodeIndices& Nod13Indices = (*pi1p3)->Indices();
1963 HLRAlgo_PolyInternalNode::NodeData& Nod13RValues = (*pi1p3)->Data();
1964 const Handle(HLRAlgo_PolyInternalNode)* pi1p4 =
1965 &(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(i1p4));
1966 HLRAlgo_PolyInternalNode::NodeIndices& Nod14Indices = (*pi1p4)->Indices();
1967 HLRAlgo_PolyInternalNode::NodeData& Nod14RValues = (*pi1p4)->Data();
1968 const Handle(HLRAlgo_PolyInternalNode)* pi2p3 =
1969 &(((HLRAlgo_Array1OfPINod*)PINod2)->ChangeValue(i2p3));
1970 HLRAlgo_PolyInternalNode::NodeIndices& Nod23Indices = (*pi2p3)->Indices();
1971 HLRAlgo_PolyInternalNode::NodeData& Nod23RValues = (*pi2p3)->Data();
1972 const Handle(HLRAlgo_PolyInternalNode)* pi2p4 =
1973 &(((HLRAlgo_Array1OfPINod*)PINod2)->ChangeValue(i2p4));
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;
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));
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));
2029 //=======================================================================
2030 //function : InsertOnOutLine
2032 //=======================================================================
2035 HLRBRep_PolyAlgo::InsertOnOutLine (TColStd_Array1OfTransient& PID)
2037 HLRAlgo_Array1OfTData* TData2 = 0;
2038 HLRAlgo_Array1OfPISeg* PISeg2 = 0;
2039 HLRAlgo_Array1OfPINod* PINod2 = 0;
2040 Handle(HLRAlgo_PolyInternalData)* pid =
2041 (Handle(HLRAlgo_PolyInternalData)*) (&(PID.ChangeValue(1)));
2044 Standard_Boolean insP3,mP3P1,IntOutL;
2045 Standard_Integer f,ip1,ip2,ip3;//, i;
2046 Standard_Real U3,V3,coef3,X3 = 0.,Y3 = 0.,Z3 = 0.;
2048 const gp_Trsf& T = myProj.Transformation();
2050 Standard_Integer nbFace = myFMap.Extent();
2051 for (f = 1; f <= nbFace; f++) {
2053 if (!((*pid).IsNull())) {
2054 IntOutL = Standard_False;
2055 HLRAlgo_Array1OfTData* TData1= &((*pid)->TData());
2056 HLRAlgo_Array1OfPISeg* PISeg1= &(*pid)->PISeg();
2057 HLRAlgo_Array1OfPINod* PINod1= &((*pid)->PINod());
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();
2064 const gp_XYZ& ttlo = TT.TranslationPart();
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);
2081 cout << " InsertOnOutLine : NbTData " << (*pid)->NbTData() << endl;
2082 cout << " InsertOnOutLine : NbPISeg " << (*pid)->NbPISeg() << endl;
2083 cout << " InsertOnOutLine : NbPINod " << (*pid)->NbPINod() << endl;
2087 Standard_Integer iseg,nbS;
2088 nbS = (*pid)->NbPISeg();
2089 for (iseg = 1; iseg <= nbS; iseg++) {
2090 HLRAlgo_PolyInternalSegment& aSegIndices = PISeg1->ChangeValue(iseg);
2091 // Standard_Boolean Cutted = Standard_False;
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)
2102 IntOutL = Standard_True;
2103 else if ((Nod1RValues.Scal >= myTolAngular &&
2104 Nod2RValues.Scal <= -myTolAngular) ||
2105 (Nod2RValues.Scal >= myTolAngular &&
2106 Nod1RValues.Scal <= -myTolAngular)) {
2107 IntOutL = Standard_True;
2108 insP3 = NewNode(Nod1RValues,Nod2RValues,coef3,mP3P1);
2110 UVNode(Nod1RValues,Nod2RValues,coef3,U3,V3);
2111 const gp_Pnt& PT3 = myGSurf->Value(U3,V3);
2115 TTMultiply(X3,Y3,Z3);
2118 if (insP3 && mP3P1) { // P1 ---> P3
2119 if ((Nod1Indices.Flag & NMsk_Edge) == 0 && coef3 < myTolSta) {
2120 insP3 = Standard_False;
2122 Nod1Indices,Nod1RValues,
2123 Nod2Indices,Nod2RValues,
2124 coef3,X3,Y3,Z3,Standard_True,
2125 TData1,PISeg1,PINod1);
2126 Nod1RValues.Scal = 0;
2127 Nod1Indices.Flag |= NMsk_OutL;
2130 if (insP3 && !mP3P1) { // P2 ---> P3
2131 if ((Nod2Indices.Flag & NMsk_Edge) == 0 && coef3 > myTolEnd) {
2132 insP3 = Standard_False;
2134 Nod1Indices,Nod1RValues,
2135 Nod2Indices,Nod2RValues,
2136 coef3,X3,Y3,Z3,Standard_False,
2137 TData1,PISeg1,PINod1);
2138 Nod2RValues.Scal = 0;
2139 Nod2Indices.Flag |= NMsk_OutL;
2142 if (insP3) { // p1 ip3 p2
2143 ip3 = (*pid)->AddNode(Nod1RValues,Nod2RValues,PINod1,PINod2,
2145 const Handle(HLRAlgo_PolyInternalNode)* pip3 =
2146 (&((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(ip3));
2147 HLRAlgo_PolyInternalNode::NodeIndices& Nod3Indices = (*pip3)->Indices();
2148 HLRAlgo_PolyInternalNode::NodeData& Nod3RValues = (*pip3)->Data();
2149 (*pid)->UpdateLinks(ip1,ip2,ip3,
2150 TData1,TData2,PISeg1,PISeg2,PINod1,PINod2);
2151 UpdateAroundNode(ip3,Nod3Indices,TData1,PISeg1,PINod1);
2152 Nod3RValues.Scal = 0;
2153 Nod3Indices.Flag |= NMsk_OutL;
2159 (*pid)->IntOutL(Standard_True);
2161 nbS = (*pid)->NbPISeg();
2165 cout << " InsertOnOutLine : NbTData " << (*pid)->NbTData() << endl;
2166 cout << " InsertOnOutLine : NbPISeg " << (*pid)->NbPISeg() << endl;
2167 cout << " InsertOnOutLine : NbPINod " << (*pid)->NbPINod() << endl;
2175 //=======================================================================
2176 //function : CheckFrBackTriangles
2178 //=======================================================================
2181 HLRBRep_PolyAlgo::CheckFrBackTriangles (HLRAlgo_ListOfBPoint& List,
2182 TColStd_Array1OfTransient& PID)
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;
2189 HLRAlgo_Array1OfTData* TData;
2190 HLRAlgo_Array1OfPISeg* PISeg;
2191 HLRAlgo_Array1OfPINod* PINod;
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();
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();
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;
2219 Handle(HLRAlgo_PolyInternalData)* pid;
2221 nbFace = myFMap.Extent();
2222 Standard_Boolean Modif = Standard_True;
2223 Standard_Integer iLoop = 0;
2225 while (Modif && iLoop < 4) {
2227 Modif = Standard_False;
2228 FrBackInList = Standard_False;
2229 pid = (Handle(HLRAlgo_PolyInternalData)*)&(PID.ChangeValue(1));
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();
2237 HLRAlgo_TriangleData* tdata = &TData->ChangeValue(1);
2239 for (i = 1; i <= nbT; i++) {
2240 if ((tdata->Flags & HLRAlgo_PolyMask_FMskSide) == 0 &&
2241 (tdata->Flags & HLRAlgo_PolyMask_FMskFrBack)) {
2244 cout << " face : " << f << " , triangle " << i << endl;
2246 Modif = Standard_True;
2247 const Handle(HLRAlgo_PolyInternalNode)* pi1p1 =
2248 &PINod->ChangeValue(tdata->Node1);
2249 Nod11Indices = &(*pi1p1)->Indices();
2250 Nod11RValues = &(*pi1p1)->Data();
2251 const Handle(HLRAlgo_PolyInternalNode)* pi1p2 =
2252 &PINod->ChangeValue(tdata->Node2);
2253 Nod12Indices = &(*pi1p2)->Indices();
2254 Nod12RValues = &(*pi1p2)->Data();
2255 const Handle(HLRAlgo_PolyInternalNode)* pi1p3 =
2256 &PINod->ChangeValue(tdata->Node3);
2257 Nod13Indices = &(*pi1p3)->Indices();
2258 Nod13RValues = &(*pi1p3)->Data();
2259 D1 = 0.; D2 = 0.; D3 = 0.;
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();
2265 D1 = dX * dX + dY * dY;
2267 nX = - dY / D1; nY = dX / D1;
2268 dX = Nod11RValues->Point.X() - Nod12RValues->Point.X();
2269 dY = Nod11RValues->Point.Y() - Nod12RValues->Point.Y();
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;
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();
2280 D2 = dX * dX + dY * dY;
2282 nX = - dY / D2; nY = dX / D2;
2283 dX = Nod12RValues->Point.X() - Nod13RValues->Point.X();
2284 dY = Nod12RValues->Point.Y() - Nod13RValues->Point.Y();
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;
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();
2295 D3 = dX * dX + dY * dY;
2297 nX = - dY / D3; nY = dX / D3;
2298 dX = Nod13RValues->Point.X() - Nod11RValues->Point.X();
2299 dY = Nod13RValues->Point.Y() - Nod11RValues->Point.Y();
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;
2305 if (D1 > D2 && D1 > D3) {
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);
2310 FrBackInList = Standard_True;
2313 cout << tdata->Node1 << " modifies : DX,DY ";
2314 cout << X1 << " , " << Y1 << endl;
2318 else if (D2 > D3 && D2 > D1) {
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);
2323 FrBackInList = Standard_True;
2326 cout << tdata->Node2 << " modifies : DX,DY ";
2327 cout << X2 << " , " << Y2 << endl;
2331 else if (D3 > D1 && D3 > D2) {
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);
2336 FrBackInList = Standard_True;
2339 cout << tdata->Node3 << " modifies : DX,DY ";
2340 cout << X3 << " , " << Y3 << endl;
2346 cout << "modification error" << endl;
2355 HLRAlgo_ListIteratorOfListOfBPoint it;
2357 for (it.Initialize(List); it.More(); it.Next()) {
2358 HLRAlgo_BiPoint& BP = it.Value();
2359 HLRAlgo_BiPoint::IndicesT& theIndices = BP.Indices();
2360 if (theIndices.FaceConex1 != 0) {
2361 const Handle(HLRAlgo_PolyInternalData)& pid1 =
2362 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(theIndices.FaceConex1));
2363 TData1 = &pid1->TData();
2364 PISeg1 = &pid1->PISeg();
2365 PINod1 = &pid1->PINod();
2367 if (theIndices.FaceConex2 != 0) {
2368 if (theIndices.FaceConex1 == theIndices.FaceConex2) {
2374 const Handle(HLRAlgo_PolyInternalData)& pid2 =
2375 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(theIndices.FaceConex2));
2376 TData2 = &pid2->TData();
2377 PISeg2 = &pid2->PISeg();
2378 PINod2 = &pid2->PINod();
2381 if (theIndices.FaceConex1 != 0) {
2382 Nod11Indices = &PINod1->ChangeValue(theIndices.Face1Pt1)->Indices();
2383 if (Nod11Indices->Flag & NMsk_Move) {
2386 cout << theIndices.Face1Pt1 << " modifies 11" << endl;
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,
2398 TData2,PISeg2,PINod2);
2401 Nod11Indices = &PINod1->ChangeValue(theIndices.Face1Pt2)->Indices();
2402 if (Nod11Indices->Flag & NMsk_Move) {
2405 cout << theIndices.Face1Pt2 << " modifies 12" << endl;
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,
2417 TData2,PISeg2,PINod2);
2421 if (theIndices.FaceConex2 != 0) {
2422 const Handle(HLRAlgo_PolyInternalData)& pid2 =
2423 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(theIndices.FaceConex2));
2424 PINod2 = &pid2->PINod();
2425 Nod11Indices = &PINod2->ChangeValue(theIndices.Face2Pt1)->Indices();
2426 if (Nod11Indices->Flag & NMsk_Move) {
2429 cout << theIndices.Face2Pt1 << " modifies 21" << endl;
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,
2441 TData1,PISeg1,PINod1);
2444 Nod11Indices = &PINod2->ChangeValue(theIndices.Face2Pt2)->Indices();
2445 if (Nod11Indices->Flag & NMsk_Move) {
2448 cout << theIndices.Face2Pt2 << " modifies 22" << endl;
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,
2460 TData1,PISeg1,PINod1);
2465 pid = (Handle(HLRAlgo_PolyInternalData)*)&(PID.ChangeValue(1));
2467 for (f = 1; f <= nbFace; f++) {
2468 if (!(*pid).IsNull()) {
2469 nbN = (*pid)->NbPINod();
2470 PINod = &(*pid)->PINod();
2472 for (i = 1; i <= nbN; i++)
2474 Nod11Indices = &PINod->ChangeValue(i)->Indices();
2475 Nod11Indices->Flag &= ~NMsk_Move;
2484 //=======================================================================
2485 //function : FindEdgeOnTriangle
2487 //=======================================================================
2491 FindEdgeOnTriangle (const HLRAlgo_TriangleData& theTriangle,
2492 const Standard_Integer ip1,
2493 const Standard_Integer ip2,
2494 Standard_Integer& jtrouv,
2495 Standard_Boolean& isDirect) const
2497 Standard_Integer n1 = theTriangle.Node1;
2498 Standard_Integer n2 = theTriangle.Node2;
2499 Standard_Integer n3 = theTriangle.Node3;
2500 if (ip1 == n1 && ip2 == n2) {
2502 isDirect = Standard_True;
2505 else if (ip2 == n1 && ip1 == n2) {
2507 isDirect = Standard_False;
2510 else if (ip1 == n2 && ip2 == n3) {
2512 isDirect = Standard_True;
2515 else if (ip2 == n2 && ip1 == n3) {
2517 isDirect = Standard_False;
2520 else if (ip1 == n3 && ip2 == n1) {
2522 isDirect = Standard_True;
2525 else if (ip2 == n3 && ip1 == n1) {
2527 isDirect = Standard_False;
2532 //=======================================================================
2533 //function : ChangeNode
2535 //=======================================================================
2537 void HLRBRep_PolyAlgo::ChangeNode (const Standard_Integer ip1,
2538 const Standard_Integer ip2,
2539 HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices,
2540 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
2541 HLRAlgo_PolyInternalNode::NodeIndices& Nod2Indices,
2542 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues,
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,
2548 HLRAlgo_Array1OfTData*& TData,
2549 HLRAlgo_Array1OfPISeg*& PISeg,
2550 HLRAlgo_Array1OfPINod*& PINod) const
2552 Standard_Real coef2 = 1 - coef1;
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();
2560 Nod1RValues.Normal = (1 / aNorm) * aXYZ;
2563 Nod1RValues.Normal = gp_XYZ(1., 0., 0.);
2566 cout << "HLRBRep_PolyAlgo::ChangeNode between " << ip1;
2567 cout << " and " << ip2 << endl;
2571 UpdateAroundNode(ip1,Nod1Indices,TData,PISeg,PINod);
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();
2580 Nod2RValues.Normal = (1 / aNorm) * aXYZ;
2583 Nod2RValues.Normal = gp_XYZ(1., 0., 0.);
2586 cout << "HLRBRep_PolyAlgo::ChangeNode between " << ip2;
2587 cout << " and " << ip1 << endl;
2591 UpdateAroundNode(ip2,Nod2Indices,TData,PISeg,PINod);
2595 //=======================================================================
2596 //function : UpdateAroundNode
2598 //=======================================================================
2600 void HLRBRep_PolyAlgo::
2601 UpdateAroundNode (const Standard_Integer iNode,
2602 HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices,
2603 HLRAlgo_Array1OfTData* TData,
2604 HLRAlgo_Array1OfPISeg* PISeg,
2605 HLRAlgo_Array1OfPINod* PINod) const
2607 Standard_Integer iiii,iTri1,iTri2;
2608 iiii = Nod1Indices.NdSg;
2611 HLRAlgo_PolyInternalSegment& aSegIndices = PISeg->ChangeValue(iiii);
2612 iTri1 = aSegIndices.Conex1;
2613 iTri2 = aSegIndices.Conex2;
2615 HLRAlgo_TriangleData& aTriangle = TData->ChangeValue(iTri1);
2616 const Handle(HLRAlgo_PolyInternalNode)* PN1 =
2617 &PINod->ChangeValue(aTriangle.Node1);
2618 const Handle(HLRAlgo_PolyInternalNode)* PN2 =
2619 &PINod->ChangeValue(aTriangle.Node2);
2620 const Handle(HLRAlgo_PolyInternalNode)* PN3 =
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,
2629 aNod1Indices,aNod1RValues,
2630 aNod2Indices,aNod2RValues,
2631 aNod3Indices,aNod3RValues);
2634 HLRAlgo_TriangleData& aTriangle2 = TData->ChangeValue(iTri2);
2635 const Handle(HLRAlgo_PolyInternalNode)* PN1 =
2636 &PINod->ChangeValue(aTriangle2.Node1);
2637 const Handle(HLRAlgo_PolyInternalNode)* PN2 =
2638 &PINod->ChangeValue(aTriangle2.Node2);
2639 const Handle(HLRAlgo_PolyInternalNode)* PN3 =
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,
2648 aNod1Indices,aNod1RValues,
2649 aNod2Indices,aNod2RValues,
2650 aNod3Indices,aNod3RValues);
2652 if (aSegIndices.LstSg1 == iNode) iiii = aSegIndices.NxtSg1;
2653 else iiii = aSegIndices.NxtSg2;
2657 //=======================================================================
2658 //function : OrientTriangle
2660 //=======================================================================
2664 HLRBRep_PolyAlgo::OrientTriangle(const Standard_Integer iTri,
2666 HLRBRep_PolyAlgo::OrientTriangle(const Standard_Integer,
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
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;
2681 if (o1 && o2 && o3) {
2682 theTriangle.Flags |= HLRAlgo_PolyMask_FMskSide;
2683 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
2684 theTriangle.Flags |= HLRAlgo_PolyMask_FMskOnOutL;
2687 cout << "HLRBRep_PolyAlgo::OrientTriangle : OnOutL";
2688 cout << " triangle " << iTri << endl;
2693 Standard_Real s1 = Nod1RValues.Scal;
2694 Standard_Real s2 = Nod2RValues.Scal;
2695 Standard_Real s3 = Nod3RValues.Scal;
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;}
2708 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskSide;
2709 theTriangle.Flags |= HLRAlgo_PolyMask_FMskBack;
2712 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskSide;
2713 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
2715 gp_XYZ aD12 = Nod2RValues.Point - Nod1RValues.Point;
2716 const Standard_Real aD12Norm = aD12.Modulus();
2717 if (aD12Norm <= 1.e-10) {
2720 cout << "HLRBRep_PolyAlgo::OrientTriangle : Flat";
2721 cout << " triangle " << iTri << endl;
2724 theTriangle.Flags |= HLRAlgo_PolyMask_FMskFlat;
2725 theTriangle.Flags |= HLRAlgo_PolyMask_FMskSide;
2726 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
2729 gp_XYZ aD23 = Nod3RValues.Point - Nod2RValues.Point;
2730 const Standard_Real aD23Norm = aD23.Modulus();
2731 if (aD23Norm < 1.e-10) {
2734 cout << "HLRBRep_PolyAlgo::OrientTriangle : Flat";
2735 cout << " triangle " << iTri << endl;
2738 theTriangle.Flags |= HLRAlgo_PolyMask_FMskFlat;
2739 theTriangle.Flags |= HLRAlgo_PolyMask_FMskSide;
2740 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
2743 const gp_XYZ aD31 = Nod1RValues.Point - Nod3RValues.Point;
2744 const Standard_Real aD31Norm = aD31.Modulus();
2745 if (aD31Norm < 1.e-10) {
2748 cout << "HLRBRep_PolyAlgo::OrientTriangle : Flat";
2749 cout << " triangle " << iTri << endl;
2752 theTriangle.Flags |= HLRAlgo_PolyMask_FMskFlat;
2753 theTriangle.Flags |= HLRAlgo_PolyMask_FMskSide;
2754 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
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) {
2764 cout << "HLRBRep_PolyAlgo::OrientTriangle : Flat";
2765 cout << " triangle " << iTri << endl;
2768 theTriangle.Flags |= HLRAlgo_PolyMask_FMskFlat;
2769 theTriangle.Flags |= HLRAlgo_PolyMask_FMskSide;
2770 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
2774 if (myProj.Perspective()) {
2776 o = aD.Z() * myProj.Focus() - aD * Nod1RValues.Point;
2779 o = aD.Z() / aDNorm;
2781 theTriangle.Flags |= HLRAlgo_PolyMask_FMskOrBack;
2785 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskOrBack;
2787 theTriangle.Flags |= HLRAlgo_PolyMask_FMskSide;
2788 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskBack;
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;
2799 theTriangle.Flags &= ~HLRAlgo_PolyMask_FMskFrBack;
2802 //=======================================================================
2803 //function : Triangles
2805 //=======================================================================
2808 HLRBRep_PolyAlgo::Triangles(const Standard_Integer ip1,
2809 const Standard_Integer ip2,
2810 HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices,
2811 HLRAlgo_Array1OfPISeg*& PISeg,
2812 Standard_Integer& iTri1,
2813 Standard_Integer& iTri2) const
2815 Standard_Integer iiii = Nod1Indices.NdSg;
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;
2824 return Standard_True;
2826 else iiii = aSegIndices.NxtSg1;
2829 if (aSegIndices.LstSg1 == ip2) {
2830 iTri1 = aSegIndices.Conex1;
2831 iTri2 = aSegIndices.Conex2;
2832 return Standard_True;
2834 else iiii = aSegIndices.NxtSg2;
2841 cout << "HLRBRep_PolyAlgo::Triangles : error";
2842 cout << " between " << ip1 << " and " << ip2 << endl;
2845 return Standard_False;
2848 //=======================================================================
2849 //function : NewNode
2851 //=======================================================================
2856 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
2857 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues,
2858 Standard_Real& coef1,
2859 Standard_Boolean& moveP1) const
2861 Standard_Real TolAng = myTolAngular * 0.5;
2862 if ((Nod1RValues.Scal >= TolAng && Nod2RValues.Scal <= -TolAng) ||
2863 (Nod2RValues.Scal >= TolAng && Nod1RValues.Scal <= -TolAng)) {
2864 coef1 = Nod1RValues.Scal / ( Nod2RValues.Scal - Nod1RValues.Scal );
2865 if (coef1 < 0) coef1 = - coef1;
2866 moveP1 = coef1 < 0.5;
2867 return Standard_True;
2869 return Standard_False;
2872 //=======================================================================
2875 //=======================================================================
2878 HLRBRep_PolyAlgo::UVNode (
2879 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
2880 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues,
2881 const Standard_Real coef1,
2883 Standard_Real& V3) const
2885 Standard_Real coef2 = 1 - coef1;
2886 const gp_XY aUV3 = coef2 * Nod1RValues.UV + coef1 * Nod2RValues.UV;
2891 //=======================================================================
2892 //function : CheckDegeneratedSegment
2894 //=======================================================================
2898 CheckDegeneratedSegment(
2899 HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices,
2900 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
2901 HLRAlgo_PolyInternalNode::NodeIndices& Nod2Indices,
2902 HLRAlgo_PolyInternalNode::NodeData& Nod2RValues) const
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;
2915 //=======================================================================
2916 //function : UpdateOutLines
2918 //=======================================================================
2921 HLRBRep_PolyAlgo::UpdateOutLines (HLRAlgo_ListOfBPoint& List,
2922 TColStd_Array1OfTransient& PID)
2925 Standard_Integer nbFace = myFMap.Extent();
2926 Standard_Real X1 ,Y1 ,Z1 ,X2 ,Y2 ,Z2 ;
2927 Standard_Real XTI1,YTI1,ZTI1,XTI2,YTI2,ZTI2;
2929 Handle(HLRAlgo_PolyInternalData)* pid =
2930 (Handle(HLRAlgo_PolyInternalData)*)&(PID.ChangeValue(1));
2932 for (f = 1; f <= nbFace; f++) {
2933 if (!(*pid).IsNull()) {
2934 if ((*pid)->IntOutL()) {
2935 HLRAlgo_Array1OfTData* TData = &(*pid)->TData();
2936 HLRAlgo_Array1OfPISeg* PISeg = &(*pid)->PISeg();
2937 HLRAlgo_Array1OfPINod* PINod = &(*pid)->PINod();
2938 Standard_Integer i,j,it1,it2,tn1,tn2,tn3,pd,pf;
2939 Standard_Boolean outl;
2940 Standard_Integer nbS = (*pid)->NbPISeg();
2942 for (i = 1; i <= nbS; i++)
2944 HLRAlgo_PolyInternalSegment* psg = &PISeg->ChangeValue(i);
2947 if (it1 != 0 && it2 != 0 && it1 != it2) { // debile but sure !
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))
2953 outl = Standard_False;
2954 else if ( aTriangle.Flags & HLRAlgo_PolyMask_FMskSide)
2955 outl = !(aTriangle.Flags & HLRAlgo_PolyMask_FMskFlat) && !(aTriangle2.Flags & HLRAlgo_PolyMask_FMskBack);
2957 outl = !(aTriangle2.Flags & HLRAlgo_PolyMask_FMskFlat) && !(aTriangle.Flags & HLRAlgo_PolyMask_FMskBack);
2962 tn1 = aTriangle.Node1;
2963 tn2 = aTriangle.Node2;
2964 tn3 = aTriangle.Node3;
2965 if (!(aTriangle.Flags & HLRAlgo_PolyMask_FMskSide) && (aTriangle.Flags & HLRAlgo_PolyMask_FMskOrBack)) {
2970 if ((tn1 == pd && tn2 == pf) || (tn1 == pf && tn2 == pd))
2971 aTriangle.Flags |= HLRAlgo_PolyMask_EMskOutLin1;
2972 else if ((tn2 == pd && tn3 == pf) || (tn2 == pf && tn3 == pd))
2973 aTriangle.Flags |= HLRAlgo_PolyMask_EMskOutLin2;
2974 else if ((tn3 == pd && tn1 == pf) || (tn3 == pf && tn1 == pd))
2975 aTriangle.Flags |= HLRAlgo_PolyMask_EMskOutLin3;
2978 cout << "HLRAlgo_PolyInternalData::UpdateOutLines";
2979 cout << " : segment not found" << endl;
2982 tn1 = aTriangle2.Node1;
2983 tn2 = aTriangle2.Node2;
2984 tn3 = aTriangle2.Node3;
2985 if (!(aTriangle2.Flags & HLRAlgo_PolyMask_FMskSide) && (aTriangle2.Flags & HLRAlgo_PolyMask_FMskOrBack)) {
2990 if ((tn1 == pd && tn2 == pf) || (tn1 == pf && tn2 == pd))
2991 aTriangle2.Flags |= HLRAlgo_PolyMask_EMskOutLin1;
2992 else if ((tn2 == pd && tn3 == pf) || (tn2 == pf && tn3 == pd))
2993 aTriangle2.Flags |= HLRAlgo_PolyMask_EMskOutLin2;
2994 else if ((tn3 == pd && tn1 == pf) || (tn3 == pf && tn1 == pd))
2995 aTriangle2.Flags |= HLRAlgo_PolyMask_EMskOutLin3;
2998 cout << "HLRAlgo_PolyInternalData::UpdateOutLines";
2999 cout << " : segment not found" << endl;
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();
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));
3026 //=======================================================================
3027 //function : UpdateEdgesBiPoints
3029 //=======================================================================
3031 void HLRBRep_PolyAlgo::
3032 UpdateEdgesBiPoints (HLRAlgo_ListOfBPoint& List,
3033 const TColStd_Array1OfTransient& PID,
3034 const Standard_Boolean closed)
3036 Standard_Integer itri1,itri2,tbid;
3037 HLRAlgo_ListIteratorOfListOfBPoint it;
3039 for (it.Initialize(List); it.More(); it.Next()) {
3040 HLRAlgo_BiPoint& BP = it.Value();
3041 // Standard_Integer i[5];
3042 HLRAlgo_BiPoint::IndicesT& aIndices = BP.Indices();
3043 if (aIndices.FaceConex1 != 0 && aIndices.FaceConex2 != 0) {
3044 const Handle(HLRAlgo_PolyInternalData)& pid1 =
3045 *(Handle(HLRAlgo_PolyInternalData)*)&(PID(aIndices.FaceConex1));
3046 const Handle(HLRAlgo_PolyInternalData)& pid2 =
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);
3057 if (itri1 != 0 && itri2 != 0) {
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);
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)))
3068 BP.Hidden(Standard_True);
3070 Standard_Boolean outl;
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))
3074 outl = Standard_False;
3075 else if ( (aTriangle.Flags & HLRAlgo_PolyMask_FMskSide))
3076 outl = !(aTriangle.Flags & HLRAlgo_PolyMask_FMskFlat) && !(aTriangle2.Flags & HLRAlgo_PolyMask_FMskBack);
3078 outl = !(aTriangle2.Flags & HLRAlgo_PolyMask_FMskFlat) && !(aTriangle.Flags & HLRAlgo_PolyMask_FMskBack);
3084 cout << "HLRBRep_PolyAlgo::UpdateEdgesBiPoints : error ";
3085 cout << " between " << aIndices.FaceConex1 << setw(6);
3086 cout << " and " << aIndices.FaceConex2 << endl;
3093 //=======================================================================
3094 //function : UpdatePolyData
3096 //=======================================================================
3099 HLRBRep_PolyAlgo::UpdatePolyData (TColStd_Array1OfTransient& PD,
3100 TColStd_Array1OfTransient& PID,
3101 const Standard_Boolean closed)
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));
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();
3121 HLRAlgo_Array1OfTData* TData = &(*pid)->TData();
3122 HLRAlgo_Array1OfPINod* PINod = &(*pid)->PINod();
3123 Standard_Integer nbHide = 0;
3125 for (i = 1; i <= nbN; i++) {
3126 HLRAlgo_PolyInternalNode::NodeData& Nod1RValues = PINod->ChangeValue(i)->Data();
3127 Nodes.ChangeValue(i) = Nod1RValues.Point;
3130 for (i = 1; i <= nbT; i++) {
3131 HLRAlgo_TriangleData* OT = &TData->ChangeValue(i);
3132 HLRAlgo_TriangleData* NT = &(Trian.ChangeValue(i));
3133 if (!(OT->Flags & HLRAlgo_PolyMask_FMskSide)) {
3135 if ((OT->Flags & HLRAlgo_PolyMask_FMskFrBack) && DoTrace) {
3136 cout << "HLRBRep_PolyAlgo::ReverseBackTriangle :";
3137 cout << " face " << f << setw(6);
3138 cout << " triangle " << i << endl;
3141 if (OT->Flags & HLRAlgo_PolyMask_FMskOrBack) {
3142 Standard_Integer j = OT->Node1;
3143 OT->Node1 = OT->Node3;
3145 OT->Flags |= HLRAlgo_PolyMask_FMskBack;
3148 OT->Flags &= ~HLRAlgo_PolyMask_FMskBack;
3149 //Tri1Flags |= HLRAlgo_PolyMask_FMskBack;//OCC349
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;
3161 NT->Flags &= ~HLRAlgo_PolyMask_FMskHiding;
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);
3175 //=======================================================================
3176 //function : TMultiply
3178 //=======================================================================
3181 HLRBRep_PolyAlgo::TMultiply (Standard_Real& X,
3184 const Standard_Boolean VPO) const
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
3193 //=======================================================================
3194 //function : TTMultiply
3196 //=======================================================================
3199 HLRBRep_PolyAlgo::TTMultiply (Standard_Real& X,
3202 const Standard_Boolean VPO) const
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
3211 //=======================================================================
3212 //function : TIMultiply
3214 //=======================================================================
3217 HLRBRep_PolyAlgo::TIMultiply (Standard_Real& X,
3220 const Standard_Boolean VPO) const
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
3229 //=======================================================================
3232 //=======================================================================
3234 HLRAlgo_BiPoint::PointsT& HLRBRep_PolyAlgo::Hide (
3235 HLRAlgo_EdgeStatus& status,
3237 Standard_Boolean& reg1,
3238 Standard_Boolean& regn,
3239 Standard_Boolean& outl,
3240 Standard_Boolean& intl)
3242 Standard_Integer index;
3243 HLRAlgo_BiPoint::PointsT& aPoints = myAlgo->Hide(status,index,reg1,regn,outl,intl);
3244 if (intl) S = myFMap(index);
3245 else S = myEMap(index);
3249 //=======================================================================
3252 //=======================================================================
3254 HLRAlgo_BiPoint::PointsT& HLRBRep_PolyAlgo::Show (
3256 Standard_Boolean& reg1,
3257 Standard_Boolean& regn,
3258 Standard_Boolean& outl,
3259 Standard_Boolean& intl)
3261 Standard_Integer index;
3262 HLRAlgo_BiPoint::PointsT& aPoints = myAlgo->Show(index,reg1,regn,outl,intl);
3263 if (intl) S = myFMap(index);
3264 else S = myEMap(index);
3268 //=======================================================================
3269 //function : OutLinedShape
3271 //=======================================================================
3274 HLRBRep_PolyAlgo::OutLinedShape (const TopoDS_Shape& S) const
3276 TopoDS_Shape Result;
3280 B.MakeCompound(TopoDS::Compound(Result));
3283 TopTools_MapOfShape Map;
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());
3290 Standard_Integer nbFace = myFMap.Extent();
3292 TopTools_Array1OfShape NewF(1,nbFace);
3293 TColStd_Array1OfTransient& Shell = myAlgo->PolyShell();
3294 Standard_Integer nbShell = Shell.Upper();
3295 HLRAlgo_ListIteratorOfListOfBPoint it;
3297 for (Standard_Integer iShell = 1; iShell <= nbShell; iShell++) {
3298 HLRAlgo_ListOfBPoint& List =
3299 (*(Handle(HLRAlgo_PolyShellData)*)&(Shell(iShell)))->Edges();
3301 for (it.Initialize(List); it.More(); it.Next()) {
3302 HLRAlgo_BiPoint& BP = it.Value();
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));