0025814: Visualization, Prs3d_WFShape::AddPolygon() - always use polygonal representa...
[occt.git] / src / Prs3d / Prs3d_WFShape.cxx
1 // Copyright (c) 2013-2014 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14 #include <Prs3d_WFShape.hxx>
15
16 #include <Bnd_Box.hxx>
17 #include <BRepAdaptor_HSurface.hxx>
18 #include <BRepAdaptor_Curve.hxx>
19 #include <BRepBndLib.hxx>
20 #include <BRep_Tool.hxx>
21 #include <Graphic3d_Group.hxx>
22 #include <Graphic3d_AspectLine3d.hxx>
23 #include <Graphic3d_ArrayOfPolylines.hxx>
24 #include <Graphic3d_ArrayOfPoints.hxx>
25 #include <gp_Pnt.hxx>
26 #include <Poly_Connect.hxx>
27 #include <Poly_Triangulation.hxx>
28 #include <Poly_Array1OfTriangle.hxx>
29 #include <Poly_Polygon3D.hxx>
30 #include <Poly_PolygonOnTriangulation.hxx>
31 #include <Prs3d.hxx>
32 #include <Prs3d_Drawer.hxx>
33 #include <Prs3d_IsoAspect.hxx>
34 #include <Prs3d_PointAspect.hxx>
35 #include <Prs3d_NListIteratorOfListOfSequenceOfPnt.hxx>
36 #include <Prs3d_ShapeTool.hxx>
37 #include <Standard_ErrorHandler.hxx>
38 #include <TColgp_Array1OfPnt.hxx>
39 #include <TColgp_SequenceOfPnt.hxx>
40 #include <TopoDS_Edge.hxx>
41 #include <TopoDS.hxx>
42 #include <TopTools_HSequenceOfShape.hxx>
43 #include <TopTools_ListOfShape.hxx>
44 #include <TopTools_ListIteratorOfListOfShape.hxx>
45
46 namespace
47 {
48
49   //! Compare two aspects
50   inline Standard_Boolean IsSame (const Handle(Graphic3d_AspectLine3d)& theUAspect,
51                                   const Handle(Graphic3d_AspectLine3d)& theVAspect)
52   {
53     Quantity_Color aCU, aCV;
54     Aspect_TypeOfLine aTlU, aTlV;
55     Standard_Real aWU, aWV;
56     theUAspect->Values (aCU, aTlU, aWU);
57     theVAspect->Values (aCV, aTlV, aWV);
58     return aCU  == aCV 
59         && aTlU == aTlV
60         && aWU  == aWV;
61   }
62
63 };
64
65 // =========================================================================
66 // function: AddPolygon
67 // purpose :
68 // =========================================================================
69 Standard_Boolean Prs3d_WFShape::AddPolygon (const TopoDS_Edge&    theEdge,
70                                             TColgp_SequenceOfPnt& thePoints)
71 {
72   TopLoc_Location aLocation;
73   Handle(Poly_Polygon3D) aPolygon = BRep_Tool::Polygon3D (theEdge, aLocation);
74   if (!aPolygon.IsNull())
75   {
76     const TColgp_Array1OfPnt& aPoints = aPolygon->Nodes();
77     Standard_Integer anIndex = aPoints.Lower();
78     if (aLocation.IsIdentity())
79     {
80       for (; anIndex <= aPoints.Upper(); ++anIndex)
81       {
82         thePoints.Append (aPoints.Value (anIndex));
83       }
84     }
85     else
86     {
87       for (; anIndex <= aPoints.Upper(); ++anIndex)
88       {
89         thePoints.Append (aPoints.Value (anIndex).Transformed (aLocation));
90       }
91     }
92     return Standard_True;
93   }
94
95   Handle(Poly_Triangulation)          aTriangulation;
96   Handle(Poly_PolygonOnTriangulation) aHIndices;
97   BRep_Tool::PolygonOnTriangulation (theEdge, aHIndices, aTriangulation, aLocation);
98   if (!aHIndices.IsNull())
99   {
100     const TColStd_Array1OfInteger& anIndices = aHIndices->Nodes();
101     const TColgp_Array1OfPnt&      aNodes    = aTriangulation->Nodes();
102
103     Standard_Integer anIndex = anIndices.Lower();
104     if (aLocation.IsIdentity())
105     {
106       for (; anIndex <= anIndices.Upper(); ++anIndex)
107       {
108         thePoints.Append (aNodes (anIndices (anIndex)));
109       }
110     }
111     else
112     {
113       for (; anIndex <= anIndices.Upper(); ++anIndex)
114       {
115         thePoints.Append (aNodes (anIndices (anIndex)).Transformed (aLocation));
116       }
117     }
118     return Standard_True;
119   }
120   return Standard_False;
121 }
122
123 // =========================================================================
124 // function: Add
125 // purpose :
126 // =========================================================================
127 void Prs3d_WFShape::Add (const Handle (Prs3d_Presentation)& thePresentation,
128                          const TopoDS_Shape&                theShape,
129                          const Handle (Prs3d_Drawer)&       theDrawer)
130 {
131   if (theShape.IsNull())
132   {
133     return;
134   }
135
136   Prs3d_ShapeTool aTool (theShape, theDrawer->VertexDrawMode() == Prs3d_VDM_All);
137   TopTools_ListOfShape aLFree, aLUnFree, aLWire;
138   for (aTool.InitCurve(); aTool.MoreCurve(); aTool.NextCurve())
139   {
140     const TopoDS_Edge& anEdge = aTool.GetCurve();
141     switch (aTool.Neighbours())
142     {
143       case 0:  aLWire.Append (anEdge);   break;
144       case 1:  aLFree.Append (anEdge);   break;
145       default: aLUnFree.Append (anEdge); break;
146     }
147   }
148
149   Standard_Real aDeflection = Prs3d::GetDeflection(theShape, theDrawer);
150
151   Prs3d_NListOfSequenceOfPnt anUIsoCurves;
152   Prs3d_NListOfSequenceOfPnt aVIsoCurves;
153   Prs3d_NListOfSequenceOfPnt aWireCurves;
154   Prs3d_NListOfSequenceOfPnt aFreeCurves;
155   Prs3d_NListOfSequenceOfPnt anUnFreeCurves;
156
157   const Standard_Integer anIsoU = theDrawer->UIsoAspect()->Number();
158   const Standard_Integer anIsoV = theDrawer->VIsoAspect()->Number();
159
160   Standard_Boolean hasIsoU = anIsoU > 0;
161   Standard_Boolean hasIsoV = anIsoV > 0;
162
163   if (IsSame (theDrawer->UIsoAspect()->Aspect(),
164               theDrawer->VIsoAspect()->Aspect()))
165   {
166     if (hasIsoU || hasIsoV)
167     {
168       BRepAdaptor_Surface aSurface;
169       for (aTool.InitFace(); aTool.MoreFace(); aTool.NextFace())
170       {
171         if (aTool.HasSurface())
172         {
173           if (!aTool.IsPlanarFace() || theDrawer->IsoOnPlane())
174           {
175             aSurface.Initialize (aTool.GetFace());
176             Handle(BRepAdaptor_HSurface) aHSurface = new BRepAdaptor_HSurface (aSurface);
177             try
178             {
179               OCC_CATCH_SIGNALS
180               Prs3d_NListOfSequenceOfPnt aCurUIsoCurves;
181               myFaceAlgo.Add (thePresentation, aHSurface,
182                               hasIsoU, hasIsoV,
183                               aDeflection,
184                               anIsoU, anIsoV,
185                               theDrawer,
186                               aCurUIsoCurves);
187               Prs3d_NListIteratorOfListOfSequenceOfPnt anIt;
188               for (anIt.Init (aCurUIsoCurves); anIt.More(); anIt.Next())
189               {
190                 anUIsoCurves.Append (anIt.Value());
191               }
192             }
193             catch (Standard_Failure)
194             {
195             }
196           }
197         }
198       }
199     }
200   }
201   else
202   {
203     if (hasIsoU)
204     {
205       BRepAdaptor_Surface aSurface;
206       for (aTool.InitFace(); aTool.MoreFace(); aTool.NextFace())
207       {
208         if (aTool.HasSurface())
209         {
210           if (!aTool.IsPlanarFace() || theDrawer->IsoOnPlane())
211           {
212             aSurface.Initialize (aTool.GetFace());
213             Handle(BRepAdaptor_HSurface) aHSurface = new BRepAdaptor_HSurface (aSurface);
214             try
215             {
216               OCC_CATCH_SIGNALS
217               Prs3d_NListOfSequenceOfPnt aCurUIsoCurves;
218               myFaceAlgo.Add (thePresentation, aHSurface,
219                               hasIsoU, Standard_False,
220                               aDeflection,
221                               anIsoU, 0,
222                               theDrawer,
223                               aCurUIsoCurves);
224             }
225             catch (Standard_Failure)
226             {
227             #ifdef OCCT_DEBUG
228               const TopoDS_Face& aFace = aSurface.Face();
229               std::cout << "Problem with the face " << (void* ) &(*(aFace).TShape()) << std::endl;
230             #endif
231             }
232           }
233         }
234       }
235     }
236     if (hasIsoV)
237     {
238       BRepAdaptor_Surface aSurface;
239       for (aTool.InitFace(); aTool.MoreFace(); aTool.NextFace())
240       {
241         if (aTool.HasSurface())
242         {
243           if (!aTool.IsPlanarFace() || theDrawer->IsoOnPlane())
244           {
245             aSurface.Initialize (aTool.GetFace());
246             Handle(BRepAdaptor_HSurface) aHSurface = new BRepAdaptor_HSurface (aSurface);
247             try
248             {
249               OCC_CATCH_SIGNALS
250               Prs3d_NListOfSequenceOfPnt aCurUIsoCurves;
251               myFaceAlgo.Add (thePresentation, aHSurface,
252                               Standard_False, hasIsoV,
253                               aDeflection,
254                               0, anIsoV,
255                               theDrawer,
256                               aCurUIsoCurves);
257             }
258             catch (Standard_Failure)
259             {
260             #ifdef OCCT_DEBUG
261               const TopoDS_Face& aFace = aSurface.Face();
262               std::cout << "Problem with the face " << (void* ) &(*(aFace).TShape()) << std::endl;
263             #endif
264             }
265           }
266         }
267       }
268     }
269   }
270
271   Standard_Integer aNbVertices = 0, aNbBounds = 0;
272   if (anUIsoCurves.Size() > 0)
273   {
274     aNbBounds = anUIsoCurves.Size();
275     Prs3d_NListIteratorOfListOfSequenceOfPnt anIt;
276     for (anIt.Init (anUIsoCurves); anIt.More(); anIt.Next())
277     {
278       aNbVertices += anIt.Value()->Length();
279     }
280     Handle(Graphic3d_ArrayOfPolylines) anUIsoArray = new Graphic3d_ArrayOfPolylines (aNbVertices, aNbBounds);
281     for (anIt.Init (anUIsoCurves); anIt.More(); anIt.Next())
282     {
283       const Handle(TColgp_HSequenceOfPnt)& aPoints = anIt.Value();
284       anUIsoArray->AddBound (aPoints->Length());
285       for (Standard_Integer anI = 1; anI <= aPoints->Length(); ++anI)
286       {
287         anUIsoArray->AddVertex (aPoints->Value (anI));
288       }
289     }
290     Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePresentation);
291     aGroup->SetPrimitivesAspect (theDrawer->UIsoAspect()->Aspect());
292     aGroup->AddPrimitiveArray (anUIsoArray);
293   }
294
295   // NOTE: THIS BLOCK WILL NEVER EXECUTE AS aVIsoCurves IS NOT FILLED!!
296   if (aVIsoCurves.Size() > 0)
297   {
298     aNbBounds = aVIsoCurves.Size();
299     Prs3d_NListIteratorOfListOfSequenceOfPnt anIt;
300     for (anIt.Init (aVIsoCurves); anIt.More(); anIt.Next())
301     {
302       aNbVertices += anIt.Value()->Length();
303     }
304     Handle(Graphic3d_ArrayOfPolylines) VIsoArray = new Graphic3d_ArrayOfPolylines (aNbVertices, aNbBounds);
305     for (anIt.Init (aVIsoCurves); anIt.More(); anIt.Next())
306     {
307       const Handle(TColgp_HSequenceOfPnt)& aPoints = anIt.Value();
308       VIsoArray->AddBound (aPoints->Length());
309       for (int anI = 1; anI <= aPoints->Length(); anI++)
310       {
311         VIsoArray->AddVertex (aPoints->Value (anI));
312       }
313     }
314     Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePresentation);
315     aGroup->SetPrimitivesAspect (theDrawer->VIsoAspect()->Aspect());
316     aGroup->AddPrimitiveArray (VIsoArray);
317   }
318
319   TopLoc_Location aLocation;
320   Standard_Integer anI, aJ, aN[3];
321
322   TColgp_SequenceOfPnt aSurfPoints;
323   for (aTool.InitFace(); aTool.MoreFace(); aTool.NextFace())
324   {
325     if (!aTool.HasSurface())
326     {
327       Handle(Poly_Triangulation) T = aTool.CurrentTriangulation (aLocation);
328       if (!T.IsNull())
329       {
330         const TColgp_Array1OfPnt& aNodes = T->Nodes();
331         // Build the connect tool
332         Poly_Connect aPolyConnect (T);
333
334         Standard_Integer aNbTriangles = T->NbTriangles();
335         Standard_Integer aT[3];
336
337         // Count the free edges
338         Standard_Integer aNbFree = 0;
339         for (anI = 1; anI <= aNbTriangles; ++anI)
340         {
341           aPolyConnect.Triangles (anI, aT[0], aT[1], aT[2]);
342           for (aJ = 0; aJ < 3; ++aJ)
343           {
344             if (aT[aJ] == 0)
345             {
346               ++aNbFree;
347             }
348           }
349         }
350
351         // Allocate the arrays
352         TColStd_Array1OfInteger aFree (1, 2 * aNbFree);
353         Standard_Integer aNbInternal = (3 * aNbTriangles - aNbFree) / 2;
354         TColStd_Array1OfInteger anInternal (0, 2 * aNbInternal);
355
356         Standard_Integer aFreeIndex = 1, anIntIndex = 1;
357         const Poly_Array1OfTriangle& aTriangles = T->Triangles();
358         for (anI = 1; anI <= aNbTriangles; ++anI)
359         {
360           aPolyConnect.Triangles (anI, aT[0], aT[1], aT[2]);
361           aTriangles (anI).Get (aN[0], aN[1], aN[2]);
362           for (aJ = 0; aJ < 3; aJ++)
363           {
364             Standard_Integer k = (aJ + 1) % 3;
365             if (aT[aJ] == 0)
366             {
367               aFree (aFreeIndex)     = aN[aJ];
368               aFree (aFreeIndex + 1) = aN[k];
369               aFreeIndex += 2;
370             }
371             // internal edge if this triangle has a lower index than the adjacent
372             else if (anI < aT[aJ])
373             {
374               anInternal (anIntIndex)     = aN[aJ];
375               anInternal (anIntIndex + 1) = aN[k];
376               anIntIndex += 2;
377             }
378           }
379         }
380
381         if (!aTool.HasSurface())
382         {
383           // free edges
384           Standard_Integer aFreeHalfNb = aFree.Length() / 2;
385           for (anI = 1; anI <= aFreeHalfNb; ++anI)
386           {
387             gp_Pnt aPoint1 = aNodes (aFree (2 * anI - 1)).Transformed (aLocation);
388             gp_Pnt aPoint2 = aNodes (aFree (2 * anI    )).Transformed (aLocation);
389             aSurfPoints.Append (aPoint1);
390             aSurfPoints.Append (aPoint2);
391           }
392         }
393       }
394     }
395   }
396   if (aSurfPoints.Length() > 0)
397   {
398     aNbVertices = aSurfPoints.Length();
399     aNbBounds   = (Standard_Integer)aNbVertices / 2;
400     Handle(Graphic3d_ArrayOfPolylines) aSurfArray = new Graphic3d_ArrayOfPolylines (aNbVertices, aNbBounds);
401     for (anI = 1; anI <= aNbVertices; anI += 2)
402     {
403       aSurfArray->AddBound (2);
404       aSurfArray->AddVertex (aSurfPoints.Value (anI));
405       aSurfArray->AddVertex (aSurfPoints.Value (anI + 1));
406     }
407     Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePresentation);
408     aGroup->SetPrimitivesAspect (theDrawer->FreeBoundaryAspect()->Aspect());
409     aGroup->AddPrimitiveArray (aSurfArray);
410   }
411
412   TopTools_ListIteratorOfListOfShape anIt;
413   if (theDrawer->WireDraw())
414   {
415     // Wire (without any neighbour)
416     for (anIt.Initialize(aLWire); anIt.More(); anIt.Next())
417     {
418       const TopoDS_Edge& anEdge = TopoDS::Edge (anIt.Value());
419       try
420       {
421         OCC_CATCH_SIGNALS
422         const Handle(TColgp_HSequenceOfPnt)& aPoints = new TColgp_HSequenceOfPnt;
423         if (!AddPolygon (anEdge, aPoints->ChangeSequence()))
424         {
425           if (BRep_Tool::IsGeometric (anEdge))
426           {
427             BRepAdaptor_Curve aCurve (anEdge);
428             myCurveAlgo.Add (thePresentation, aCurve, aDeflection, theDrawer,
429                              aPoints->ChangeSequence(), Standard_False);
430             aWireCurves.Append (aPoints);
431           }
432         }
433         else
434         {
435           aWireCurves.Append (aPoints);
436         }
437       }
438       catch (Standard_Failure)
439       {
440       #ifdef OCCT_DEBUG
441         std::cout << "probleme sur aLocation'edge " << (void* ) &(*(anEdge).TShape()) << std::endl;
442       #endif
443       }
444     }
445   }
446
447   if (theDrawer->FreeBoundaryDraw())
448   {
449     // aFree boundaries;
450     for (anIt.Initialize (aLFree); anIt.More(); anIt.Next())
451     {
452       const TopoDS_Edge& anEdge = TopoDS::Edge (anIt.Value());
453       if (!BRep_Tool::Degenerated (anEdge))
454       {
455         try
456         {
457           OCC_CATCH_SIGNALS
458           const Handle(TColgp_HSequenceOfPnt)& aPoints = new TColgp_HSequenceOfPnt;
459           if (!AddPolygon (anEdge, aPoints->ChangeSequence()))
460           {
461             if (BRep_Tool::IsGeometric (anEdge))
462             {
463               BRepAdaptor_Curve aCurve (anEdge);
464               myCurveAlgo.Add (thePresentation, aCurve, aDeflection, theDrawer,
465                                aPoints->ChangeSequence(), Standard_False);
466               aFreeCurves.Append (aPoints);
467             }
468           }
469           else
470           {
471             aFreeCurves.Append (aPoints);
472           }
473         }
474         catch (Standard_Failure)
475         {
476         #ifdef OCCT_DEBUG
477           std::cout << "probleme sur aLocation'edge " << (void* ) &(*(anEdge).TShape()) << std::endl;
478         #endif
479         }
480       }
481     }
482   }
483
484   if (theDrawer->UnFreeBoundaryDraw())
485   {
486     // Unfree boundaries;
487     for (anIt.Initialize (aLUnFree); anIt.More(); anIt.Next())
488     {
489       const TopoDS_Edge& anEdge = TopoDS::Edge (anIt.Value());
490       try
491       {
492         OCC_CATCH_SIGNALS
493         const Handle(TColgp_HSequenceOfPnt)& aPoints = new TColgp_HSequenceOfPnt;
494         if (!AddPolygon (anEdge, aPoints->ChangeSequence()))
495         {
496           if (BRep_Tool::IsGeometric (anEdge))
497           {
498             BRepAdaptor_Curve aCurve (anEdge);
499             myCurveAlgo.Add (thePresentation, aCurve, aDeflection, theDrawer, aPoints->ChangeSequence(), Standard_False);
500             anUnFreeCurves.Append (aPoints);
501           }
502         }
503         else
504         {
505           anUnFreeCurves.Append (aPoints);
506         }
507       }
508       catch (Standard_Failure)
509       {
510       #ifdef OCCT_DEBUG
511         std::cout << "probleme sur aLocation'edge " << (void* ) &(*(anEdge).TShape()) << std::endl;
512       #endif
513       }
514     }
515   }
516
517   if (aWireCurves.Size() > 0)
518   {
519     aNbBounds = aWireCurves.Size();
520     Prs3d_NListIteratorOfListOfSequenceOfPnt anIt;
521     for (anIt.Init (aWireCurves); anIt.More(); anIt.Next())
522     {
523       aNbVertices += anIt.Value()->Length();
524     }
525     Handle(Graphic3d_ArrayOfPolylines) WireArray = new Graphic3d_ArrayOfPolylines (aNbVertices, aNbBounds);
526     for (anIt.Init (aWireCurves); anIt.More(); anIt.Next())
527     {
528       const Handle(TColgp_HSequenceOfPnt)& aPoints = anIt.Value();
529       WireArray->AddBound (aPoints->Length());
530       for (anI = 1; anI <= aPoints->Length(); ++anI)
531       {
532         WireArray->AddVertex (aPoints->Value (anI));
533       }
534     }
535     Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePresentation);
536     aGroup->SetPrimitivesAspect (theDrawer->WireAspect()->Aspect());
537     aGroup->AddPrimitiveArray (WireArray);
538   }
539
540   if (aFreeCurves.Size() > 0)
541   {
542     aNbBounds = aFreeCurves.Size();
543     Prs3d_NListIteratorOfListOfSequenceOfPnt anIt;
544     for (anIt.Init (aFreeCurves); anIt.More(); anIt.Next())
545     {
546       aNbVertices += anIt.Value()->Length();
547     }
548     Handle(Graphic3d_ArrayOfPolylines) aFreeArray = new Graphic3d_ArrayOfPolylines (aNbVertices, aNbBounds);
549     for (anIt.Init(aFreeCurves); anIt.More(); anIt.Next())
550     {
551       const Handle(TColgp_HSequenceOfPnt)& aPoints = anIt.Value();
552       aFreeArray->AddBound (aPoints->Length());
553       for (anI = 1; anI <= aPoints->Length(); ++anI)
554       {
555         aFreeArray->AddVertex (aPoints->Value (anI));
556       }
557     }  
558     Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePresentation);
559     aGroup->SetPrimitivesAspect (theDrawer->FreeBoundaryAspect()->Aspect());
560     aGroup->AddPrimitiveArray (aFreeArray);
561   }
562
563   if (anUnFreeCurves.Size() > 0)
564   {
565     aNbBounds = anUnFreeCurves.Size();
566     Prs3d_NListIteratorOfListOfSequenceOfPnt anIt;
567     for (anIt.Init (anUnFreeCurves); anIt.More(); anIt.Next())
568     {
569       aNbVertices += anIt.Value()->Length();
570     }
571     Handle(Graphic3d_ArrayOfPolylines) anUnFreeArray = new Graphic3d_ArrayOfPolylines (aNbVertices, aNbBounds);
572     for (anIt.Init (anUnFreeCurves); anIt.More(); anIt.Next())
573     {
574       const Handle(TColgp_HSequenceOfPnt)& aPoints = anIt.Value();
575       anUnFreeArray->AddBound (aPoints->Length());
576       for (anI = 1; anI <= aPoints->Length(); ++anI)
577       {
578         anUnFreeArray->AddVertex (aPoints->Value (anI));
579       }
580     }
581     Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePresentation);
582     aGroup->SetPrimitivesAspect (theDrawer->UnFreeBoundaryAspect()->Aspect());
583     aGroup->AddPrimitiveArray (anUnFreeArray);
584   }
585
586   // Points
587   TColgp_SequenceOfPnt aShapePoints;
588   for (aTool.InitVertex(); aTool.MoreVertex(); aTool.NextVertex())
589   {
590     aShapePoints.Append (BRep_Tool::Pnt (aTool.GetVertex()));
591   }
592
593   aNbVertices = aShapePoints.Length();
594   if (aNbVertices > 0)
595   {
596     Handle(Graphic3d_ArrayOfPoints) aPointArray = new Graphic3d_ArrayOfPoints (aNbVertices);
597     for (anI = 1; anI <= aNbVertices; ++anI)
598     {
599       aPointArray->AddVertex (aShapePoints.Value (anI));
600     }
601
602     Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePresentation);
603     aGroup->SetPrimitivesAspect (theDrawer->PointAspect()->Aspect());
604     aGroup->AddPrimitiveArray (aPointArray);
605   }
606 }
607
608 // =========================================================================
609 // function: PickCurve
610 // purpose :
611 // =========================================================================
612 Handle(TopTools_HSequenceOfShape) Prs3d_WFShape::PickCurve
613       (const Quantity_Length        theX,
614        const Quantity_Length        theY,
615        const Quantity_Length        theZ,
616        const Quantity_Length        theDistance,
617        const TopoDS_Shape&          theShape,
618        const Handle (Prs3d_Drawer)& theDrawer)
619 {
620   Handle(TopTools_HSequenceOfShape) aSeq = new TopTools_HSequenceOfShape();
621   Prs3d_ShapeTool aTool (theShape);
622   for (aTool.InitCurve(); aTool.MoreCurve(); aTool.NextCurve())
623   {
624     Bnd_Box aBndBox = aTool.CurveBound();
625     aBndBox.Enlarge (theDistance);
626     if (!aBndBox.IsOut (gp_Pnt (theX, theY, theZ)))
627     {
628       if (myCurveAlgo.Match (theX, theY, theZ, theDistance,
629                              BRepAdaptor_Curve (aTool.GetCurve()), theDrawer))
630       {
631         Standard_Boolean isContain = Standard_False;
632         for (Standard_Integer anI = 1; anI <= aSeq->Length(); ++anI)
633         {
634           if (aSeq->Value (anI) == (aTool.GetCurve()))
635           {
636             isContain = Standard_True;
637             break;
638           }
639         }
640         if (!isContain)
641         {
642           aSeq->Append (aTool.GetCurve());
643         }
644       }
645     }
646   }
647   return aSeq;
648 }
649
650 // =========================================================================
651 // function: PickPatch
652 // purpose :
653 // =========================================================================
654 Handle(TopTools_HSequenceOfShape) Prs3d_WFShape::PickPatch
655       (const Quantity_Length       theX,
656        const Quantity_Length       theY,
657        const Quantity_Length       theZ,
658        const Quantity_Length       theDistance,
659        const TopoDS_Shape&         theShape,
660        const Handle(Prs3d_Drawer)& theDrawer)
661 {
662    Handle(TopTools_HSequenceOfShape) aSeq = new TopTools_HSequenceOfShape();
663    Prs3d_ShapeTool aTool (theShape);
664
665    Standard_Boolean aRba1 = theDrawer->UIsoAspect()->Number() != 0;
666    Standard_Boolean aRba2 = theDrawer->VIsoAspect()->Number() != 0;
667    Standard_Boolean isContain;
668
669    if (aRba1 || aRba2)
670    {
671      BRepAdaptor_Surface aSurface;
672      for (aTool.InitFace(); aTool.MoreFace(); aTool.NextFace())
673      {
674        Bnd_Box aBndBox = aTool.FaceBound();
675        aBndBox.Enlarge (theDistance);
676        if (!aBndBox.IsOut (gp_Pnt (theX, theY, theZ)))
677        {
678          aSurface.Initialize (aTool.GetFace());
679          Handle(BRepAdaptor_HSurface) aHSurface = new BRepAdaptor_HSurface (aSurface);
680          if (myFaceAlgo.Match (theX, theY, theZ, theDistance, aHSurface, theDrawer))
681          {
682            isContain = Standard_False;
683            for (Standard_Integer anI = 1; anI <= aSeq->Length(); ++anI)
684            {
685              if (aSeq->Value (anI) == (aTool.GetFace()))
686              {
687                isContain = Standard_True;
688                break;
689              }
690            }
691            if (!isContain)
692            {
693              aSeq->Append (aTool.GetFace());
694            }
695          }
696        }
697      }
698    }
699
700    for (aTool.InitCurve(); aTool.MoreCurve(); aTool.NextCurve())
701    {
702      Bnd_Box aBndBox = aTool.CurveBound();
703      aBndBox.Enlarge (theDistance);
704      if (!aBndBox.IsOut (gp_Pnt (theX, theY, theZ)))
705      {
706        if (myCurveAlgo.Match (theX, theY, theZ, theDistance,
707                               BRepAdaptor_Curve(aTool.GetCurve()), theDrawer))
708        {
709          Handle(TopTools_HSequenceOfShape) aSurface = aTool.FacesOfEdge();
710          for (Standard_Integer anI = 1; anI <= aSurface->Length(); ++anI)
711          {
712            isContain = Standard_False;
713            for (Standard_Integer aJ = 1; aJ <= aSeq->Length(); ++aJ)
714            {
715              if (aSeq->Value (aJ) == (aSurface->Value (anI)))
716              {
717                isContain = Standard_True;
718                break;
719              }
720            }
721            if (!isContain)
722            {
723              aSeq->Append (aSurface->Value (anI));
724            }
725          }
726        }
727      }
728    }
729    return aSeq;
730 }