0031458: Visualization - refine classes across Prs3d and StdPrs packages
[occt.git] / src / StdPrs / StdPrs_WFShape.cxx
1 // Created on: 2014-10-14
2 // Created by: Anton POLETAEV
3 // Copyright (c) 2013-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <StdPrs_WFShape.hxx>
17
18 #include <BRep_Tool.hxx>
19 #include <BRepAdaptor_Curve.hxx>
20 #include <BRepAdaptor_Surface.hxx>
21 #include <BRepAdaptor_HSurface.hxx>
22 #include <OSD_Parallel.hxx>
23 #include <StdPrs_DeflectionCurve.hxx>
24 #include <StdPrs_Isolines.hxx>
25 #include <StdPrs_ShapeTool.hxx>
26 #include <StdPrs_ToolTriangulatedShape.hxx>
27 #include <Standard_ErrorHandler.hxx>
28 #include <Prs3d_IsoAspect.hxx>
29 #include <Prs3d.hxx>
30 #include <Poly_PolygonOnTriangulation.hxx>
31 #include <Poly_Polygon3D.hxx>
32 #include <Poly_Triangulation.hxx>
33 #include <Graphic3d_AspectLine3d.hxx>
34 #include <Graphic3d_ArrayOfSegments.hxx>
35 #include <Graphic3d_ArrayOfPoints.hxx>
36 #include <gp_Pnt.hxx>
37 #include <TColgp_HSequenceOfPnt.hxx>
38 #include <TColStd_Array1OfInteger.hxx>
39 #include <TopoDS_Edge.hxx>
40 #include <TopoDS_Face.hxx>
41 #include <TopoDS.hxx>
42 #include <TopExp.hxx>
43 #include <TopTools_ListIteratorOfListOfShape.hxx>
44 #include <Standard_Mutex.hxx>
45
46 //! Functor for executing StdPrs_Isolines in parallel threads.
47 class StdPrs_WFShape_IsoFunctor
48 {
49 public:
50   StdPrs_WFShape_IsoFunctor (Prs3d_NListOfSequenceOfPnt& thePolylinesU,
51                              Prs3d_NListOfSequenceOfPnt& thePolylinesV,
52                              const std::vector<TopoDS_Face>& theFaces,
53                              const Handle(Prs3d_Drawer)& theDrawer,
54                              Standard_Real theShapeDeflection)
55   : myPolylinesU (thePolylinesU),
56     myPolylinesV (thePolylinesV),
57     myFaces (theFaces),
58     myDrawer (theDrawer),
59     myShapeDeflection (theShapeDeflection)
60   {
61     //
62   }
63
64   void operator()(const Standard_Integer& theIndex) const
65   {
66     Prs3d_NListOfSequenceOfPnt aPolylinesU, aPolylinesV;
67     const TopoDS_Face& aFace = myFaces[theIndex];
68     StdPrs_Isolines::Add (aFace, myDrawer, myShapeDeflection, aPolylinesU, aPolylinesV);
69     {
70       Standard_Mutex::Sentry aLock (myMutex);
71       myPolylinesU.Append (aPolylinesU);
72       myPolylinesV.Append (aPolylinesV);
73     }
74   }
75
76 private:
77   StdPrs_WFShape_IsoFunctor operator= (StdPrs_WFShape_IsoFunctor& );
78 private:
79   Prs3d_NListOfSequenceOfPnt&     myPolylinesU;
80   Prs3d_NListOfSequenceOfPnt&     myPolylinesV;
81   const std::vector<TopoDS_Face>& myFaces;
82   const Handle(Prs3d_Drawer)&     myDrawer;
83   mutable Standard_Mutex          myMutex;
84   const Standard_Real             myShapeDeflection;
85 };
86
87
88 // =========================================================================
89 // function : Add
90 // purpose  :
91 // =========================================================================
92 void StdPrs_WFShape::Add (const Handle(Prs3d_Presentation)& thePresentation,
93                           const TopoDS_Shape& theShape,
94                           const Handle(Prs3d_Drawer)& theDrawer,
95                           Standard_Boolean theIsParallel)
96 {
97   if (theShape.IsNull())
98   {
99     return;
100   }
101
102   if (theDrawer->IsAutoTriangulation())
103   {
104     StdPrs_ToolTriangulatedShape::Tessellate (theShape, theDrawer);
105   }
106
107   // draw triangulation-only edges
108   if (Handle(Graphic3d_ArrayOfPrimitives) aTriFreeEdges = AddEdgesOnTriangulation (theShape, Standard_True))
109   {
110     Handle(Graphic3d_Group) aGroup = thePresentation->NewGroup();
111     aGroup->SetPrimitivesAspect (theDrawer->FreeBoundaryAspect()->Aspect());
112     aGroup->AddPrimitiveArray (aTriFreeEdges);
113   }
114
115   Prs3d_NListOfSequenceOfPnt aCommonPolylines;
116   const Handle(Prs3d_LineAspect)& aWireAspect = theDrawer->WireAspect();
117   const Standard_Real aShapeDeflection = StdPrs_ToolTriangulatedShape::GetDeflection (theShape, theDrawer);
118
119   // Draw isolines
120   {
121     Prs3d_NListOfSequenceOfPnt  aUPolylines, aVPolylines;
122     Prs3d_NListOfSequenceOfPnt* aUPolylinesPtr = &aUPolylines;
123     Prs3d_NListOfSequenceOfPnt* aVPolylinesPtr = &aVPolylines;
124
125     const Handle(Prs3d_LineAspect)& anIsoAspectU = theDrawer->UIsoAspect();
126     const Handle(Prs3d_LineAspect)& anIsoAspectV = theDrawer->VIsoAspect();
127     if (anIsoAspectV->Aspect()->IsEqual (*anIsoAspectU->Aspect()))
128     {
129       aVPolylinesPtr = aUPolylinesPtr;  // put both U and V isolines into single group
130     }
131     if (anIsoAspectU->Aspect()->IsEqual (*aWireAspect->Aspect()))
132     {
133       aUPolylinesPtr = &aCommonPolylines; // put U isolines into single group with common edges
134     }
135     if (anIsoAspectV->Aspect()->IsEqual (*aWireAspect->Aspect()))
136     {
137       aVPolylinesPtr = &aCommonPolylines; // put V isolines into single group with common edges
138     }
139
140     bool isParallelIso = false;
141     if (theIsParallel)
142     {
143       Standard_Integer aNbFaces = 0;
144       for (TopExp_Explorer aFaceExplorer (theShape, TopAbs_FACE); aFaceExplorer.More(); aFaceExplorer.Next())
145       {
146         ++aNbFaces;
147       }
148       if (aNbFaces > 1)
149       {
150         isParallelIso = true;
151         std::vector<TopoDS_Face> aFaces (aNbFaces);
152         aNbFaces = 0;
153         for (TopExp_Explorer aFaceExplorer (theShape, TopAbs_FACE); aFaceExplorer.More(); aFaceExplorer.Next())
154         {
155           const TopoDS_Face& aFace = TopoDS::Face (aFaceExplorer.Current());
156           if (theDrawer->IsoOnPlane() || !StdPrs_ShapeTool::IsPlanarFace (aFace))
157           {
158             aFaces[aNbFaces++] = aFace;
159           }
160         }
161
162         StdPrs_WFShape_IsoFunctor anIsoFunctor (*aUPolylinesPtr, *aVPolylinesPtr, aFaces, theDrawer, aShapeDeflection);
163         OSD_Parallel::For (0, aNbFaces, anIsoFunctor, aNbFaces < 2);
164       }
165     }
166
167     if (!isParallelIso)
168     {
169       for (TopExp_Explorer aFaceExplorer (theShape, TopAbs_FACE); aFaceExplorer.More(); aFaceExplorer.Next())
170       {
171         const TopoDS_Face& aFace = TopoDS::Face (aFaceExplorer.Current());
172         if (theDrawer->IsoOnPlane() || !StdPrs_ShapeTool::IsPlanarFace (aFace))
173         {
174           StdPrs_Isolines::Add (aFace, theDrawer, aShapeDeflection, *aUPolylinesPtr, *aVPolylinesPtr);
175         }
176       }
177     }
178
179     Prs3d::AddPrimitivesGroup (thePresentation, anIsoAspectU, aUPolylines);
180     Prs3d::AddPrimitivesGroup (thePresentation, anIsoAspectV, aVPolylines);
181   }
182
183   {
184     Prs3d_NListOfSequenceOfPnt anUnfree, aFree;
185     Prs3d_NListOfSequenceOfPnt* anUnfreePtr = &anUnfree;
186     Prs3d_NListOfSequenceOfPnt* aFreePtr = &aFree;
187     if (!theDrawer->UnFreeBoundaryDraw())
188     {
189       anUnfreePtr = NULL;
190     }
191     else if (theDrawer->UnFreeBoundaryAspect()->Aspect()->IsEqual (*aWireAspect->Aspect()))
192     {
193       anUnfreePtr = &aCommonPolylines; // put unfree edges into single group with common edges
194     }
195
196     if (!theDrawer->FreeBoundaryDraw())
197     {
198       aFreePtr = NULL;
199     }
200     else if (theDrawer->FreeBoundaryAspect()->Aspect()->IsEqual (*aWireAspect->Aspect()))
201     {
202       aFreePtr = &aCommonPolylines; // put free edges into single group with common edges
203     }
204
205     addEdges (theShape,
206               theDrawer,
207               aShapeDeflection,
208               theDrawer->WireDraw() ? &aCommonPolylines : NULL,
209               aFreePtr,
210               anUnfreePtr);
211     Prs3d::AddPrimitivesGroup (thePresentation, theDrawer->UnFreeBoundaryAspect(), anUnfree);
212     Prs3d::AddPrimitivesGroup (thePresentation, theDrawer->FreeBoundaryAspect(), aFree);
213   }
214
215   Prs3d::AddPrimitivesGroup (thePresentation, theDrawer->WireAspect(), aCommonPolylines);
216
217   if (Handle(Graphic3d_ArrayOfPoints) aVertexArray = AddVertexes (theShape, theDrawer->VertexDrawMode()))
218   {
219     Handle(Graphic3d_Group) aGroup = thePresentation->NewGroup();
220     aGroup->SetPrimitivesAspect (theDrawer->PointAspect()->Aspect());
221     aGroup->AddPrimitiveArray (aVertexArray);
222   }
223 }
224
225 // =========================================================================
226 // function : AddAllEdges
227 // purpose  :
228 // =========================================================================
229 Handle(Graphic3d_ArrayOfPrimitives) StdPrs_WFShape::AddAllEdges (const TopoDS_Shape& theShape,
230                                                                  const Handle(Prs3d_Drawer)& theDrawer)
231 {
232   const Standard_Real aShapeDeflection = StdPrs_ToolTriangulatedShape::GetDeflection (theShape, theDrawer);
233   Prs3d_NListOfSequenceOfPnt aPolylines;
234   addEdges (theShape, theDrawer, aShapeDeflection,
235             &aPolylines, &aPolylines, &aPolylines);
236   return Prs3d::PrimitivesFromPolylines (aPolylines);
237 }
238
239 // =========================================================================
240 // function : addEdges
241 // purpose  :
242 // =========================================================================
243 void StdPrs_WFShape::addEdges (const TopoDS_Shape& theShape,
244                                const Handle(Prs3d_Drawer)& theDrawer,
245                                Standard_Real theShapeDeflection,
246                                Prs3d_NListOfSequenceOfPnt* theWire,
247                                Prs3d_NListOfSequenceOfPnt* theFree,
248                                Prs3d_NListOfSequenceOfPnt* theUnFree)
249 {
250   if (theShape.IsNull())
251   {
252     return;
253   }
254
255   TopTools_ListOfShape aLWire, aLFree, aLUnFree;
256   TopTools_IndexedDataMapOfShapeListOfShape anEdgeMap;
257   TopExp::MapShapesAndAncestors (theShape, TopAbs_EDGE, TopAbs_FACE, anEdgeMap);
258   for (TopTools_IndexedDataMapOfShapeListOfShape::Iterator anEdgeIter (anEdgeMap); anEdgeIter.More(); anEdgeIter.Next())
259   {
260     const TopoDS_Edge& anEdge = TopoDS::Edge (anEdgeIter.Key());
261     const Standard_Integer aNbNeighbours = anEdgeIter.Value().Extent();
262     switch (aNbNeighbours)
263     {
264       case 0:
265       {
266         if (theWire != NULL)
267         {
268           aLWire.Append (anEdge);
269         }
270         break;
271       }
272       case 1:
273       {
274         if (theFree != NULL)
275         {
276           aLFree.Append (anEdge);
277         }
278         break;
279       }
280       default:
281       {
282         if (theUnFree)
283         {
284           aLUnFree.Append (anEdge);
285         }
286         break;
287       }
288     }
289   }
290
291   if (!aLWire.IsEmpty())
292   {
293     addEdges (aLWire, theDrawer, theShapeDeflection, *theWire);
294   }
295   if (!aLFree.IsEmpty())
296   {
297     addEdges (aLFree, theDrawer, theShapeDeflection, *theFree);
298   }
299   if (!aLUnFree.IsEmpty())
300   {
301     addEdges (aLUnFree, theDrawer, theShapeDeflection, *theUnFree);
302   }
303 }
304
305 // =========================================================================
306 // function : AddEdges
307 // purpose  :
308 // =========================================================================
309 void StdPrs_WFShape::addEdges (const TopTools_ListOfShape&  theEdges,
310                                const Handle (Prs3d_Drawer)& theDrawer,
311                                const Standard_Real          theShapeDeflection,
312                                Prs3d_NListOfSequenceOfPnt&  thePolylines)
313 {
314   TopTools_ListIteratorOfListOfShape anEdgesIter;
315   for (anEdgesIter.Initialize (theEdges); anEdgesIter.More(); anEdgesIter.Next())
316   {
317     const TopoDS_Edge& anEdge = TopoDS::Edge (anEdgesIter.Value());
318     if (BRep_Tool::Degenerated (anEdge))
319     {
320       continue;
321     }
322
323     Handle(TColgp_HSequenceOfPnt) aPoints = new TColgp_HSequenceOfPnt;
324
325     TopLoc_Location aLocation;
326     Handle(Poly_Triangulation)          aTriangulation;
327     Handle(Poly_PolygonOnTriangulation) anEdgeIndicies;
328     BRep_Tool::PolygonOnTriangulation (anEdge, anEdgeIndicies, aTriangulation, aLocation);
329     Handle(Poly_Polygon3D) aPolygon;
330
331     if (!anEdgeIndicies.IsNull())
332     {
333       // Presentation based on triangulation of a face.
334       const TColStd_Array1OfInteger& anIndices = anEdgeIndicies->Nodes();
335       const TColgp_Array1OfPnt&      aNodes    = aTriangulation->Nodes();
336
337       Standard_Integer anIndex = anIndices.Lower();
338       if (aLocation.IsIdentity())
339       {
340         for (; anIndex <= anIndices.Upper(); ++anIndex)
341         {
342           aPoints->Append (aNodes (anIndices (anIndex)));
343         }
344       }
345       else
346       {
347         for (; anIndex <= anIndices.Upper(); ++anIndex)
348         {
349           aPoints->Append (aNodes (anIndices (anIndex)).Transformed (aLocation));
350         }
351       }
352     }
353     else if (!(aPolygon = BRep_Tool::Polygon3D (anEdge, aLocation)).IsNull())
354     {
355       // Presentation based on triangulation of the free edge on a surface.
356       const TColgp_Array1OfPnt& aNodes = aPolygon->Nodes();
357       Standard_Integer anIndex = aNodes.Lower();
358       if (aLocation.IsIdentity())
359       {
360         for (; anIndex <= aNodes.Upper(); ++anIndex)
361         {
362           aPoints->Append (aNodes.Value (anIndex));
363         }
364       }
365       else
366       {
367         for (; anIndex <= aNodes.Upper(); ++anIndex)
368         {
369           aPoints->Append (aNodes.Value (anIndex).Transformed (aLocation));
370         }
371       }
372     }
373     else if (BRep_Tool::IsGeometric (anEdge))
374     {
375       // Default presentation for edges without triangulation.
376       BRepAdaptor_Curve aCurve (anEdge);
377       StdPrs_DeflectionCurve::Add (Handle(Prs3d_Presentation)(),
378                                    aCurve,
379                                    theShapeDeflection,
380                                    theDrawer,
381                                    aPoints->ChangeSequence(),
382                                    Standard_False);
383     }
384
385     if (!aPoints->IsEmpty())
386     {
387       thePolylines.Append (aPoints);
388     }
389   }
390 }
391
392 // =========================================================================
393 // function : AddEdgesOnTriangulation
394 // purpose  :
395 // =========================================================================
396 Handle(Graphic3d_ArrayOfPrimitives) StdPrs_WFShape::AddEdgesOnTriangulation (const TopoDS_Shape& theShape,
397                                                                              const Standard_Boolean theToExcludeGeometric)
398 {
399   TColgp_SequenceOfPnt aSeqPnts;
400   AddEdgesOnTriangulation (aSeqPnts, theShape, theToExcludeGeometric);
401   if (aSeqPnts.Size() < 2)
402   {
403     return Handle(Graphic3d_ArrayOfSegments)();
404   }
405
406   Standard_Integer aNbVertices = aSeqPnts.Size();
407   Handle(Graphic3d_ArrayOfSegments) aSurfArray = new Graphic3d_ArrayOfSegments (aNbVertices);
408   for (Standard_Integer anI = 1; anI <= aNbVertices; anI += 2)
409   {
410     aSurfArray->AddVertex (aSeqPnts.Value (anI));
411     aSurfArray->AddVertex (aSeqPnts.Value (anI + 1));
412   }
413   return aSurfArray;
414 }
415
416 // =========================================================================
417 // function : AddEdgesOnTriangulation
418 // purpose  :
419 // =========================================================================
420 void StdPrs_WFShape::AddEdgesOnTriangulation (TColgp_SequenceOfPnt& theSegments,
421                                               const TopoDS_Shape& theShape,
422                                               const Standard_Boolean theToExcludeGeometric)
423 {
424   TopLoc_Location aLocation, aDummyLoc;
425   for (TopExp_Explorer aFaceIter (theShape, TopAbs_FACE); aFaceIter.More(); aFaceIter.Next())
426   {
427     const TopoDS_Face& aFace = TopoDS::Face (aFaceIter.Current());
428     if (theToExcludeGeometric)
429     {
430       const Handle(Geom_Surface)& aSurf = BRep_Tool::Surface (aFace, aDummyLoc);
431       if (!aSurf.IsNull())
432       {
433         continue;
434       }
435     }
436     if (const Handle(Poly_Triangulation)& aPolyTri = BRep_Tool::Triangulation (aFace, aLocation))
437     {
438       Prs3d::AddFreeEdges (theSegments, aPolyTri, aLocation);
439     }
440   }
441 }
442
443 // =========================================================================
444 // function : AddVertexes
445 // purpose  :
446 // =========================================================================
447 Handle(Graphic3d_ArrayOfPoints) StdPrs_WFShape::AddVertexes (const TopoDS_Shape& theShape,
448                                                              Prs3d_VertexDrawMode theVertexMode)
449 {
450   TColgp_SequenceOfPnt aShapeVertices;
451   if (theVertexMode == Prs3d_VDM_All)
452   {
453     for (TopExp_Explorer aVertIter (theShape, TopAbs_VERTEX); aVertIter.More(); aVertIter.Next())
454     {
455       const TopoDS_Vertex& aVert = TopoDS::Vertex (aVertIter.Current());
456       aShapeVertices.Append (BRep_Tool::Pnt (aVert));
457     }
458   }
459   else
460   {
461     // isolated vertices
462     for (TopExp_Explorer aVertIter (theShape, TopAbs_VERTEX, TopAbs_EDGE); aVertIter.More(); aVertIter.Next())
463     {
464       const TopoDS_Vertex& aVert = TopoDS::Vertex (aVertIter.Current());
465       aShapeVertices.Append (BRep_Tool::Pnt (aVert));
466     }
467
468     // internal vertices
469     for (TopExp_Explorer anEdgeIter (theShape, TopAbs_EDGE); anEdgeIter.More(); anEdgeIter.Next())
470     {
471       for (TopoDS_Iterator aVertIter (anEdgeIter.Current(), Standard_False, Standard_True); aVertIter.More(); aVertIter.Next())
472       {
473         const TopoDS_Shape& aVertSh = aVertIter.Value();
474         if (aVertSh.Orientation() == TopAbs_INTERNAL
475             && aVertSh.ShapeType() == TopAbs_VERTEX)
476         {
477           const TopoDS_Vertex& aVert = TopoDS::Vertex (aVertSh);
478           aShapeVertices.Append (BRep_Tool::Pnt (aVert));
479         }
480       }
481     }
482   }
483
484   if (aShapeVertices.IsEmpty())
485   {
486     return Handle(Graphic3d_ArrayOfPoints)();
487   }
488
489   const Standard_Integer aNbVertices = aShapeVertices.Length();
490   Handle(Graphic3d_ArrayOfPoints) aVertexArray = new Graphic3d_ArrayOfPoints (aNbVertices);
491   for (Standard_Integer aVertIter = 1; aVertIter <= aNbVertices; ++aVertIter)
492   {
493     aVertexArray->AddVertex (aShapeVertices.Value (aVertIter));
494   }
495   return aVertexArray;
496 }