0028931: Eliminate dependency from TBB in OSD_Parallel header
[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_ToolTriangulatedShape.hxx>
25 #include <StdPrs_Isolines.hxx>
26 #include <Standard_ErrorHandler.hxx>
27 #include <Prs3d_ShapeTool.hxx>
28 #include <Prs3d_IsoAspect.hxx>
29 #include <Prs3d.hxx>
30 #include <Poly_Connect.hxx>
31 #include <Poly_PolygonOnTriangulation.hxx>
32 #include <Poly_Polygon3D.hxx>
33 #include <Poly_Triangulation.hxx>
34 #include <Graphic3d_AspectLine3d.hxx>
35 #include <Graphic3d_ArrayOfSegments.hxx>
36 #include <Graphic3d_ArrayOfPoints.hxx>
37 #include <gp_Pnt.hxx>
38 #include <TColgp_HSequenceOfPnt.hxx>
39 #include <TColStd_Array1OfInteger.hxx>
40 #include <TopoDS_Edge.hxx>
41 #include <TopoDS_Face.hxx>
42 #include <TopoDS.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   Prs3d_ShapeTool aTool (theShape, theDrawer->VertexDrawMode() == Prs3d_VDM_All);
103
104   // Explore shape elements.
105   TopTools_ListOfShape aLFree, aLUnFree, aLWire;
106   for (aTool.InitCurve(); aTool.MoreCurve(); aTool.NextCurve())
107   {
108     const TopoDS_Edge& anEdge = aTool.GetCurve();
109     switch (aTool.Neighbours())
110     {
111       case 0:  aLWire.Append (anEdge);   break;
112       case 1:  aLFree.Append (anEdge);   break;
113       default: aLUnFree.Append (anEdge); break;
114     }
115   }
116
117   Standard_Real aShapeDeflection = Prs3d::GetDeflection (theShape, theDrawer);
118
119   // Draw shape elements
120   {
121     Handle(Graphic3d_ArrayOfPrimitives) aTriFreeEdges = AddEdgesOnTriangulation (theShape, Standard_True);
122     if (!aTriFreeEdges.IsNull())
123     {
124       Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePresentation);
125       aGroup->SetPrimitivesAspect (theDrawer->FreeBoundaryAspect()->Aspect());
126       aGroup->AddPrimitiveArray (aTriFreeEdges);
127     }
128   }
129
130   Prs3d_NListOfSequenceOfPnt aCommonPolylines;
131   const Handle(Prs3d_LineAspect)& aWireAspect = theDrawer->WireAspect();
132
133   // Draw isolines
134   {
135     Prs3d_NListOfSequenceOfPnt  aUPolylines, aVPolylines;
136     Prs3d_NListOfSequenceOfPnt* aUPolylinesPtr = &aUPolylines;
137     Prs3d_NListOfSequenceOfPnt* aVPolylinesPtr = &aVPolylines;
138
139     const Handle(Prs3d_LineAspect)& anIsoAspectU = theDrawer->UIsoAspect();
140     const Handle(Prs3d_LineAspect)& anIsoAspectV = theDrawer->VIsoAspect();
141     if (anIsoAspectV->Aspect()->IsEqual (*anIsoAspectU->Aspect()))
142     {
143       aVPolylinesPtr = aUPolylinesPtr;
144     }
145     if (anIsoAspectU->Aspect()->IsEqual (*aWireAspect->Aspect()))
146     {
147       aUPolylinesPtr = &aCommonPolylines;
148     }
149     if (anIsoAspectV->Aspect()->IsEqual (*aWireAspect->Aspect()))
150     {
151       aVPolylinesPtr = &aCommonPolylines;
152     }
153
154     bool isParallelIso = false;
155     if (theIsParallel)
156     {
157       Standard_Integer aNbFaces = 0;
158       for (TopExp_Explorer aFaceExplorer (theShape, TopAbs_FACE); aFaceExplorer.More(); aFaceExplorer.Next())
159       {
160         ++aNbFaces;
161       }
162       if (aNbFaces > 1)
163       {
164         isParallelIso = true;
165         std::vector<TopoDS_Face> aFaces (aNbFaces);
166         aNbFaces = 0;
167         for (TopExp_Explorer aFaceExplorer (theShape, TopAbs_FACE); aFaceExplorer.More(); aFaceExplorer.Next())
168         {
169           const TopoDS_Face& aFace = TopoDS::Face (aFaceExplorer.Current());
170           if (theDrawer->IsoOnPlane() || !Prs3d_ShapeTool::IsPlanarFace (aFace))
171           {
172             aFaces[aNbFaces++] = aFace;
173           }
174         }
175
176         StdPrs_WFShape_IsoFunctor anIsoFunctor (*aUPolylinesPtr, *aVPolylinesPtr, aFaces, theDrawer, aShapeDeflection);
177         OSD_Parallel::For (0, aNbFaces, anIsoFunctor, aNbFaces < 2);
178       }
179     }
180
181     if (!isParallelIso)
182     {
183       for (TopExp_Explorer aFaceExplorer (theShape, TopAbs_FACE); aFaceExplorer.More(); aFaceExplorer.Next())
184       {
185         const TopoDS_Face& aFace = TopoDS::Face (aFaceExplorer.Current());
186         if (theDrawer->IsoOnPlane() || !Prs3d_ShapeTool::IsPlanarFace (aFace))
187         {
188           StdPrs_Isolines::Add (aFace, theDrawer, aShapeDeflection, *aUPolylinesPtr, *aVPolylinesPtr);
189         }
190       }
191     }
192
193     Prs3d::AddPrimitivesGroup (thePresentation, anIsoAspectU, aUPolylines);
194     Prs3d::AddPrimitivesGroup (thePresentation, anIsoAspectV, aVPolylines);
195   }
196
197   if (!aLWire.IsEmpty() && theDrawer->WireDraw())
198   {
199     addEdges (aLWire, theDrawer, aShapeDeflection, aCommonPolylines);
200   }
201
202   if (!aLUnFree.IsEmpty() && theDrawer->UnFreeBoundaryDraw())
203   {
204     const Handle(Prs3d_LineAspect)& aLineAspect = theDrawer->UnFreeBoundaryAspect();
205     if (!aLineAspect->Aspect()->IsEqual (*aWireAspect->Aspect()))
206     {
207       Prs3d_NListOfSequenceOfPnt aPolylines;
208       addEdges (aLUnFree, theDrawer, aShapeDeflection, aPolylines);
209       Prs3d::AddPrimitivesGroup (thePresentation, aLineAspect, aPolylines);
210     }
211     else
212     {
213       addEdges (aLUnFree, theDrawer, aShapeDeflection, aCommonPolylines);
214     }
215   }
216
217   if (!aLFree.IsEmpty() && theDrawer->FreeBoundaryDraw())
218   {
219     const Handle(Prs3d_LineAspect)& aLineAspect = theDrawer->FreeBoundaryAspect();
220     if (!aLineAspect->Aspect()->IsEqual (*aWireAspect->Aspect()))
221     {
222       Prs3d_NListOfSequenceOfPnt aPolylines;
223       addEdges (aLFree, theDrawer, aShapeDeflection, aPolylines);
224       Prs3d::AddPrimitivesGroup (thePresentation, aLineAspect, aPolylines);
225     }
226     else
227     {
228       addEdges (aLFree, theDrawer, aShapeDeflection, aCommonPolylines);
229     }
230   }
231
232   Prs3d::AddPrimitivesGroup (thePresentation, theDrawer->WireAspect(), aCommonPolylines);
233
234   {
235     TColgp_SequenceOfPnt aShapeVertices;
236     for (aTool.InitVertex(); aTool.MoreVertex(); aTool.NextVertex())
237     {
238       aShapeVertices.Append (BRep_Tool::Pnt (aTool.GetVertex()));
239     }
240     if (!aShapeVertices.IsEmpty())
241     {
242       addVertices (thePresentation, aShapeVertices, theDrawer->PointAspect());
243     }
244   }
245 }
246
247 // =========================================================================
248 // function : AddEdges
249 // purpose  :
250 // =========================================================================
251 void StdPrs_WFShape::addEdges (const TopTools_ListOfShape&  theEdges,
252                                const Handle (Prs3d_Drawer)& theDrawer,
253                                const Standard_Real          theShapeDeflection,
254                                Prs3d_NListOfSequenceOfPnt&  thePolylines)
255 {
256   TopTools_ListIteratorOfListOfShape anEdgesIter;
257   for (anEdgesIter.Initialize (theEdges); anEdgesIter.More(); anEdgesIter.Next())
258   {
259     const TopoDS_Edge& anEdge = TopoDS::Edge (anEdgesIter.Value());
260     if (BRep_Tool::Degenerated (anEdge))
261     {
262       continue;
263     }
264
265     Handle(TColgp_HSequenceOfPnt) aPoints = new TColgp_HSequenceOfPnt;
266
267     TopLoc_Location aLocation;
268     Handle(Poly_Triangulation)          aTriangulation;
269     Handle(Poly_PolygonOnTriangulation) anEdgeIndicies;
270     BRep_Tool::PolygonOnTriangulation (anEdge, anEdgeIndicies, aTriangulation, aLocation);
271     Handle(Poly_Polygon3D) aPolygon;
272
273     if (!anEdgeIndicies.IsNull())
274     {
275       // Presentation based on triangulation of a face.
276       const TColStd_Array1OfInteger& anIndices = anEdgeIndicies->Nodes();
277       const TColgp_Array1OfPnt&      aNodes    = aTriangulation->Nodes();
278
279       Standard_Integer anIndex = anIndices.Lower();
280       if (aLocation.IsIdentity())
281       {
282         for (; anIndex <= anIndices.Upper(); ++anIndex)
283         {
284           aPoints->Append (aNodes (anIndices (anIndex)));
285         }
286       }
287       else
288       {
289         for (; anIndex <= anIndices.Upper(); ++anIndex)
290         {
291           aPoints->Append (aNodes (anIndices (anIndex)).Transformed (aLocation));
292         }
293       }
294     }
295     else if (!(aPolygon = BRep_Tool::Polygon3D (anEdge, aLocation)).IsNull())
296     {
297       // Presentation based on triangulation of the free edge on a surface.
298       const TColgp_Array1OfPnt& aNodes = aPolygon->Nodes();
299       Standard_Integer anIndex = aNodes.Lower();
300       if (aLocation.IsIdentity())
301       {
302         for (; anIndex <= aNodes.Upper(); ++anIndex)
303         {
304           aPoints->Append (aNodes.Value (anIndex));
305         }
306       }
307       else
308       {
309         for (; anIndex <= aNodes.Upper(); ++anIndex)
310         {
311           aPoints->Append (aNodes.Value (anIndex).Transformed (aLocation));
312         }
313       }
314     }
315     else if (BRep_Tool::IsGeometric (anEdge))
316     {
317       // Default presentation for edges without triangulation.
318       BRepAdaptor_Curve aCurve (anEdge);
319       StdPrs_DeflectionCurve::Add (Handle(Prs3d_Presentation)(),
320                                    aCurve,
321                                    theShapeDeflection,
322                                    theDrawer,
323                                    aPoints->ChangeSequence(),
324                                    Standard_False);
325     }
326
327     if (!aPoints->IsEmpty())
328     {
329       thePolylines.Append (aPoints);
330     }
331   }
332 }
333
334 // =========================================================================
335 // function : AddEdgesOnTriangulation
336 // purpose  :
337 // =========================================================================
338 Handle(Graphic3d_ArrayOfPrimitives) StdPrs_WFShape::AddEdgesOnTriangulation (const TopoDS_Shape& theShape,
339                                                                              const Standard_Boolean theToExcludeGeometric)
340 {
341   TColgp_SequenceOfPnt aSeqPnts;
342   AddEdgesOnTriangulation (aSeqPnts, theShape, theToExcludeGeometric);
343   if (aSeqPnts.Size() < 2)
344   {
345     return Handle(Graphic3d_ArrayOfSegments)();
346   }
347
348   Standard_Integer aNbVertices = aSeqPnts.Size();
349   Handle(Graphic3d_ArrayOfSegments) aSurfArray = new Graphic3d_ArrayOfSegments (aNbVertices);
350   for (Standard_Integer anI = 1; anI <= aNbVertices; anI += 2)
351   {
352     aSurfArray->AddVertex (aSeqPnts.Value (anI));
353     aSurfArray->AddVertex (aSeqPnts.Value (anI + 1));
354   }
355   return aSurfArray;
356 }
357
358 // =========================================================================
359 // function : AddEdgesOnTriangulation
360 // purpose  :
361 // =========================================================================
362 void StdPrs_WFShape::AddEdgesOnTriangulation (TColgp_SequenceOfPnt& theSegments,
363                                               const TopoDS_Shape& theShape,
364                                               const Standard_Boolean theToExcludeGeometric)
365 {
366   TopLoc_Location aLocation, aDummyLoc;
367   for (TopExp_Explorer aFaceIter (theShape, TopAbs_FACE); aFaceIter.More(); aFaceIter.Next())
368   {
369     const TopoDS_Face& aFace = TopoDS::Face (aFaceIter.Current());
370     if (theToExcludeGeometric)
371     {
372       const Handle(Geom_Surface)& aSurf = BRep_Tool::Surface (aFace, aDummyLoc);
373       if (!aSurf.IsNull())
374       {
375         continue;
376       }
377     }
378     const Handle(Poly_Triangulation)& T = BRep_Tool::Triangulation (aFace, aLocation);
379     if (T.IsNull())
380     {
381       continue;
382     }
383
384     const TColgp_Array1OfPnt& aNodes = T->Nodes();
385
386     // Build the connect tool.
387     Poly_Connect aPolyConnect (T);
388
389     Standard_Integer aNbTriangles = T->NbTriangles();
390     Standard_Integer aT[3];
391     Standard_Integer aN[3];
392
393     // Count the free edges.
394     Standard_Integer aNbFree = 0;
395     for (Standard_Integer anI = 1; anI <= aNbTriangles; ++anI)
396     {
397       aPolyConnect.Triangles (anI, aT[0], aT[1], aT[2]);
398       for (Standard_Integer aJ = 0; aJ < 3; ++aJ)
399       {
400         if (aT[aJ] == 0)
401         {
402           ++aNbFree;
403         }
404       }
405     }
406
407     if (aNbFree == 0)
408     {
409       continue;
410     }
411
412     // Allocate the arrays.
413     TColStd_Array1OfInteger aFree (1, 2 * aNbFree);
414     Standard_Integer aNbInternal = (3 * aNbTriangles - aNbFree) / 2;
415     TColStd_Array1OfInteger anInternal (0, 2 * aNbInternal);
416
417     Standard_Integer aFreeIndex = 1, anIntIndex = 1;
418     const Poly_Array1OfTriangle& aTriangles = T->Triangles();
419     for (Standard_Integer anI = 1; anI <= aNbTriangles; ++anI)
420     {
421       aPolyConnect.Triangles (anI, aT[0], aT[1], aT[2]);
422       aTriangles (anI).Get (aN[0], aN[1], aN[2]);
423       for (Standard_Integer aJ = 0; aJ < 3; aJ++)
424       {
425         Standard_Integer k = (aJ + 1) % 3;
426         if (aT[aJ] == 0)
427         {
428           aFree (aFreeIndex)     = aN[aJ];
429           aFree (aFreeIndex + 1) = aN[k];
430           aFreeIndex += 2;
431         }
432         // internal edge if this triangle has a lower index than the adjacent.
433         else if (anI < aT[aJ])
434         {
435           anInternal (anIntIndex)     = aN[aJ];
436           anInternal (anIntIndex + 1) = aN[k];
437           anIntIndex += 2;
438         }
439       }
440     }
441
442     // free edges
443     Standard_Integer aFreeHalfNb = aFree.Length() / 2;
444     for (Standard_Integer anI = 1; anI <= aFreeHalfNb; ++anI)
445     {
446       gp_Pnt aPoint1 = aNodes (aFree (2 * anI - 1)).Transformed (aLocation);
447       gp_Pnt aPoint2 = aNodes (aFree (2 * anI    )).Transformed (aLocation);
448       theSegments.Append (aPoint1);
449       theSegments.Append (aPoint2);
450     }
451   }
452 }
453
454 // =========================================================================
455 // function : AddPoints
456 // purpose  :
457 // =========================================================================
458 void StdPrs_WFShape::addVertices (const Handle (Prs3d_Presentation)& thePresentation,
459                                   const TColgp_SequenceOfPnt&        theVertices,
460                                   const Handle (Prs3d_PointAspect)&  theAspect)
461 {
462   Standard_Integer aNbVertices = theVertices.Length();
463   if (aNbVertices < 1)
464   {
465     return;
466   }
467
468   Handle(Graphic3d_ArrayOfPoints) aVertexArray = new Graphic3d_ArrayOfPoints (aNbVertices);
469   for (Standard_Integer anI = 1; anI <= aNbVertices; ++anI)
470   {
471     aVertexArray->AddVertex (theVertices.Value (anI));
472   }
473
474   Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePresentation);
475   aGroup->SetPrimitivesAspect (theAspect->Aspect());
476   aGroup->AddPrimitiveArray (aVertexArray);
477 }