0027670: Visualization - avoid duplication of structures defining primitive array...
[occt.git] / src / StdPrs / StdPrs_ShadedShape.cxx
1 // Created on: 1993-09-23
2 // Created by: Jean-Louis FRENKEL
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
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.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <StdPrs_ShadedShape.hxx>
18
19 #include <Bnd_Box.hxx>
20 #include <BRepTools.hxx>
21 #include <BRepBndLib.hxx>
22 #include <BRep_Builder.hxx>
23 #include <BRep_Tool.hxx>
24 #include <Graphic3d_ArrayOfSegments.hxx>
25 #include <Graphic3d_ArrayOfTriangles.hxx>
26 #include <Graphic3d_AspectFillArea3d.hxx>
27 #include <Graphic3d_Group.hxx>
28 #include <gp_Dir.hxx>
29 #include <gp_Vec.hxx>
30 #include <gp_Pnt.hxx>
31 #include <NCollection_List.hxx>
32 #include <Precision.hxx>
33 #include <Prs3d_Drawer.hxx>
34 #include <Prs3d_IsoAspect.hxx>
35 #include <Prs3d_LineAspect.hxx>
36 #include <Prs3d_Presentation.hxx>
37 #include <Prs3d_ShadingAspect.hxx>
38 #include <Poly_Connect.hxx>
39 #include <Poly_PolygonOnTriangulation.hxx>
40 #include <Poly_Triangulation.hxx>
41 #include <StdPrs_ToolTriangulatedShape.hxx>
42 #include <StdPrs_WFShape.hxx>
43 #include <TopExp.hxx>
44 #include <TopExp_Explorer.hxx>
45 #include <TopoDS.hxx>
46 #include <TopoDS_Compound.hxx>
47 #include <TopoDS_Face.hxx>
48 #include <TopoDS_Shape.hxx>
49 #include <TColgp_Array1OfDir.hxx>
50 #include <TColgp_Array1OfPnt2d.hxx>
51 #include <TColgp_HArray1OfPnt.hxx>
52 #include <TopTools_ListOfShape.hxx>
53 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
54
55 namespace
56 {
57
58   //! Computes wireframe presentation for free wires and vertices
59   void wireframeFromShape (const Handle (Prs3d_Presentation)& thePrs,
60                            const TopoDS_Shape&                theShape,
61                            const Handle (Prs3d_Drawer)&       theDrawer)
62   {
63     Standard_Boolean aDrawAllVerticesFlag = (theDrawer->VertexDrawMode() == Prs3d_VDM_All);
64
65     if (!aDrawAllVerticesFlag && theShape.ShapeType() != TopAbs_COMPOUND)
66     {
67       return;
68     }
69
70     TopExp_Explorer aShapeIter (theShape, TopAbs_FACE);
71     if (!aShapeIter.More())
72     {
73       // compound contains no shaded elements at all
74       StdPrs_WFShape::Add (thePrs, theShape, theDrawer);
75       return;
76     }
77
78     // We have to create a compound and collect all subshapes not drawn by the shading algo.
79     // This includes:
80     // - isolated edges
81     // - isolated vertices, if aDrawAllVerticesFlag == Standard_False
82     // - all shape's vertices, if aDrawAllVerticesFlag == Standard_True
83     TopoDS_Compound aCompoundWF;
84     BRep_Builder aBuilder;
85     aBuilder.MakeCompound (aCompoundWF);
86     Standard_Boolean hasElement = Standard_False;
87
88     // isolated edges
89     for (aShapeIter.Init (theShape, TopAbs_EDGE, TopAbs_FACE); aShapeIter.More(); aShapeIter.Next())
90     {
91       hasElement = Standard_True;
92       aBuilder.Add (aCompoundWF, aShapeIter.Current());
93     }
94     // isolated or all vertices
95     aShapeIter.Init (theShape, TopAbs_VERTEX, aDrawAllVerticesFlag ? TopAbs_SHAPE : TopAbs_EDGE);
96     for (; aShapeIter.More(); aShapeIter.Next())
97     {
98       hasElement = Standard_True;
99       aBuilder.Add (aCompoundWF, aShapeIter.Current());
100     }
101     if (hasElement)
102     {
103       StdPrs_WFShape::Add (thePrs, aCompoundWF, theDrawer);
104     }
105   }
106
107   //! Computes special wireframe presentation for faces without triangulation.
108   void wireframeNoTriangFacesFromShape (const Handle(Prs3d_Presentation)& thePrs,
109                                         const TopoDS_Shape&               theShape,
110                                         const Handle(Prs3d_Drawer)&       theDrawer)
111   {
112     TopoDS_Compound aCompoundWF;
113     BRep_Builder aBuilder;
114     aBuilder.MakeCompound (aCompoundWF);
115     TopLoc_Location aLoc;
116     Standard_Boolean hasElement = Standard_False;
117
118     for (TopExp_Explorer aShapeIter(theShape, TopAbs_FACE); aShapeIter.More(); aShapeIter.Next())
119     {
120       const TopoDS_Face& aFace = TopoDS::Face (aShapeIter.Current());
121       const Handle(Poly_Triangulation) aTriang = BRep_Tool::Triangulation (aFace, aLoc);
122       if (aTriang.IsNull())
123       {
124         hasElement = Standard_True;
125         aBuilder.Add (aCompoundWF, aFace);
126       }
127     }
128
129     if (hasElement)
130     {
131       Standard_Integer aPrevUIsoNb = theDrawer->UIsoAspect()->Number();
132       Standard_Integer aPrevVIsoNb = theDrawer->VIsoAspect()->Number();
133       theDrawer->UIsoAspect()->SetNumber (5);
134       theDrawer->VIsoAspect()->SetNumber (5);
135
136       StdPrs_WFShape::Add (thePrs, aCompoundWF, theDrawer);
137
138       theDrawer->UIsoAspect()->SetNumber (aPrevUIsoNb);
139       theDrawer->VIsoAspect()->SetNumber (aPrevVIsoNb);
140     }
141   }
142
143   //! Gets triangulation of every face of shape and fills output array of triangles
144   static Handle(Graphic3d_ArrayOfTriangles) fillTriangles (const TopoDS_Shape&    theShape,
145                                                            const Standard_Boolean theHasTexels,
146                                                            const gp_Pnt2d&        theUVOrigin,
147                                                            const gp_Pnt2d&        theUVRepeat,
148                                                            const gp_Pnt2d&        theUVScale)
149   {
150     Handle(Poly_Triangulation) aT;
151     TopLoc_Location aLoc;
152     gp_Pnt aPoint;
153     Standard_Integer aNbTriangles = 0;
154     Standard_Integer aNbVertices  = 0;
155
156     // Precision for compare square distances
157     const Standard_Real aPreci = Precision::SquareConfusion();
158
159     TopExp_Explorer aFaceIt(theShape, TopAbs_FACE);
160     for (; aFaceIt.More(); aFaceIt.Next())
161     {
162       const TopoDS_Face& aFace = TopoDS::Face(aFaceIt.Current());
163       aT = BRep_Tool::Triangulation (aFace, aLoc);
164       if (!aT.IsNull())
165       {
166         aNbTriangles += aT->NbTriangles();
167         aNbVertices  += aT->NbNodes();
168       }
169     }
170     if (aNbVertices  <  3 || aNbTriangles <= 0)
171     {
172       return Handle(Graphic3d_ArrayOfTriangles)();
173     }
174
175     Handle(Graphic3d_ArrayOfTriangles) anArray = new Graphic3d_ArrayOfTriangles (aNbVertices, 3 * aNbTriangles,
176                                                                                  Standard_True, Standard_False, theHasTexels);
177     Standard_Real aUmin (0.0), aUmax (0.0), aVmin (0.0), aVmax (0.0), dUmax (0.0), dVmax (0.0);
178     for (aFaceIt.Init (theShape, TopAbs_FACE); aFaceIt.More(); aFaceIt.Next())
179     {
180       const TopoDS_Face& aFace = TopoDS::Face(aFaceIt.Current());
181       aT = BRep_Tool::Triangulation (aFace, aLoc);
182       if (aT.IsNull())
183       {
184         continue;
185       }
186       const gp_Trsf& aTrsf = aLoc.Transformation();
187
188       // Determinant of transform matrix less then 0 means that mirror transform applied.
189       Standard_Boolean isMirrored = aTrsf.VectorialPart().Determinant() < 0;
190
191       Poly_Connect aPolyConnect (aT);
192       // Extracts vertices & normals from nodes
193       const TColgp_Array1OfPnt&   aNodes   = aT->Nodes();
194       const TColgp_Array1OfPnt2d& aUVNodes = aT->UVNodes();
195       TColgp_Array1OfDir aNormals (aNodes.Lower(), aNodes.Upper());
196       StdPrs_ToolTriangulatedShape::Normal (aFace, aPolyConnect, aNormals);
197
198       if (theHasTexels)
199       {
200         BRepTools::UVBounds (aFace, aUmin, aUmax, aVmin, aVmax);
201         dUmax = (aUmax - aUmin);
202         dVmax = (aVmax - aVmin);
203       }
204
205       const Standard_Integer aDecal = anArray->VertexNumber();
206       for (Standard_Integer aNodeIter = aNodes.Lower(); aNodeIter <= aNodes.Upper(); ++aNodeIter)
207       {
208         aPoint = aNodes (aNodeIter);
209         if (!aLoc.IsIdentity())
210         {
211           aPoint.Transform (aTrsf);
212
213           aNormals (aNodeIter) = aNormals (aNodeIter).Transformed (aTrsf);
214         }
215
216         if (theHasTexels && aUVNodes.Upper() == aNodes.Upper())
217         {
218           const gp_Pnt2d aTexel = gp_Pnt2d ((-theUVOrigin.X() + (theUVRepeat.X() * (aUVNodes (aNodeIter).X() - aUmin)) / dUmax) / theUVScale.X(),
219                                             (-theUVOrigin.Y() + (theUVRepeat.Y() * (aUVNodes (aNodeIter).Y() - aVmin)) / dVmax) / theUVScale.Y());
220           anArray->AddVertex (aPoint, aNormals (aNodeIter), aTexel);
221         }
222         else
223         {
224           anArray->AddVertex (aPoint, aNormals (aNodeIter));
225         }
226       }
227
228       // Fill array with vertex and edge visibility info
229       const Poly_Array1OfTriangle& aTriangles = aT->Triangles();
230       Standard_Integer anIndex[3];
231       for (Standard_Integer aTriIter = 1; aTriIter <= aT->NbTriangles(); ++aTriIter)
232       {
233         if ((aFace.Orientation() == TopAbs_REVERSED) ^ isMirrored)
234         {
235           aTriangles (aTriIter).Get (anIndex[0], anIndex[2], anIndex[1]);
236         }
237         else
238         {
239           aTriangles (aTriIter).Get (anIndex[0], anIndex[1], anIndex[2]);
240         }
241
242         gp_Pnt aP1 = aNodes (anIndex[0]);
243         gp_Pnt aP2 = aNodes (anIndex[1]);
244         gp_Pnt aP3 = aNodes (anIndex[2]);
245
246         gp_Vec aV1 (aP1, aP2);
247         if (aV1.SquareMagnitude() <= aPreci)
248         {
249           continue;
250         }
251         gp_Vec aV2 (aP2, aP3);
252         if (aV2.SquareMagnitude() <= aPreci)
253         {
254           continue;
255         }
256         gp_Vec aV3 (aP3, aP1);
257         if (aV3.SquareMagnitude() <= aPreci)
258         {
259           continue;
260         }
261         aV1.Normalize();
262         aV2.Normalize();
263         aV1.Cross (aV2);
264         if (aV1.SquareMagnitude() > aPreci)
265         {
266           anArray->AddEdge (anIndex[0] + aDecal);
267           anArray->AddEdge (anIndex[1] + aDecal);
268           anArray->AddEdge (anIndex[2] + aDecal);
269         }
270       }
271     }
272     return anArray;
273   }
274
275   //! Prepare shaded presentation for specified shape
276   static Standard_Boolean shadeFromShape (const TopoDS_Shape&               theShape,
277                                           const Handle(Prs3d_Presentation)& thePrs,
278                                           const Handle(Prs3d_Drawer)&       theDrawer,
279                                           const Standard_Boolean            theHasTexels,
280                                           const gp_Pnt2d&                   theUVOrigin,
281                                           const gp_Pnt2d&                   theUVRepeat,
282                                           const gp_Pnt2d&                   theUVScale,
283                                           const bool                        theIsClosed)
284   {
285     Handle(Graphic3d_ArrayOfTriangles) aPArray = fillTriangles (theShape, theHasTexels, theUVOrigin, theUVRepeat, theUVScale);
286     if (aPArray.IsNull())
287     {
288       return Standard_False;
289     }
290
291     Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePrs);
292     aGroup->SetClosed (theIsClosed);
293     if (!theDrawer->ShadingAspectGlobal())
294     {
295       Handle(Graphic3d_AspectFillArea3d) anAsp = theDrawer->ShadingAspect()->Aspect();
296       aGroup->SetGroupPrimitivesAspect (anAsp);
297     }
298     aGroup->AddPrimitiveArray (aPArray);
299     return Standard_True;
300   }
301
302   //! Compute boundary presentation for faces of the shape.
303   static void computeFaceBoundaries (const TopoDS_Shape&               theShape,
304                                      const Handle(Prs3d_Presentation)& thePrs,
305                                      const Handle(Prs3d_Drawer)&       theDrawer)
306   {
307     // collection of all triangulation nodes on edges
308     // for computing boundaries presentation
309     NCollection_List<Handle(TColgp_HArray1OfPnt)> aNodeCollection;
310     Standard_Integer aNodeNumber = 0;
311     Standard_Integer aNbPolylines = 0;
312
313     TopLoc_Location aTrsf;
314
315     // explore all boundary edges
316     TopTools_IndexedDataMapOfShapeListOfShape anEdgesMap;
317     TopExp::MapShapesAndAncestors (theShape, TopAbs_EDGE, TopAbs_FACE, anEdgesMap);
318     for (TopTools_IndexedDataMapOfShapeListOfShape::Iterator anEdgeIter (anEdgesMap); anEdgeIter.More(); anEdgeIter.Next())
319     {
320       // reject free edges
321       if (anEdgeIter.Value().Extent() == 0)
322       {
323         continue;
324       }
325
326       // take one of the shared edges and get edge triangulation
327       const TopoDS_Face& aFace = TopoDS::Face (anEdgeIter.Value().First());
328       Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (aFace, aTrsf);
329       if (aTriangulation.IsNull())
330       {
331         continue;
332       }
333
334       const TopoDS_Edge& anEdge = TopoDS::Edge (anEdgeIter.Key());
335       Handle(Poly_PolygonOnTriangulation) anEdgePoly = BRep_Tool::PolygonOnTriangulation (anEdge, aTriangulation, aTrsf);
336       if (!anEdgePoly.IsNull()
337         && anEdgePoly->Nodes().Length() >= 2)
338       {
339         aNodeNumber += anEdgePoly->Nodes().Length();
340         ++aNbPolylines;
341       }
342     }
343     if (aNodeNumber == 0)
344     {
345       return;
346     }
347
348     // create indexed segments array to pack polylines from different edges into single array
349     const Standard_Integer aSegmentEdgeNb = (aNodeNumber - aNbPolylines) * 2;
350     Handle(Graphic3d_ArrayOfSegments) aSegments = new Graphic3d_ArrayOfSegments (aNodeNumber, aSegmentEdgeNb);
351     for (TopTools_IndexedDataMapOfShapeListOfShape::Iterator anEdgeIter (anEdgesMap); anEdgeIter.More(); anEdgeIter.Next())
352     {
353       if (anEdgeIter.Value().Extent() == 0)
354       {
355         continue;
356       }
357
358       const TopoDS_Face& aFace = TopoDS::Face (anEdgeIter.Value().First());
359       Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (aFace, aTrsf);
360       if (aTriangulation.IsNull())
361       {
362         continue;
363       }
364
365       const TopoDS_Edge& anEdge = TopoDS::Edge (anEdgeIter.Key());
366       Handle(Poly_PolygonOnTriangulation) anEdgePoly = BRep_Tool::PolygonOnTriangulation (anEdge, aTriangulation, aTrsf);
367       if (anEdgePoly.IsNull()
368        || anEdgePoly->Nodes().Length () < 2)
369       {
370         continue;
371       }
372
373       // get edge nodes indexes from face triangulation
374       const TColgp_Array1OfPnt&      aTriNodes   = aTriangulation->Nodes();
375       const TColStd_Array1OfInteger& anEdgeNodes = anEdgePoly->Nodes();
376
377       // collect the edge nodes
378       Standard_Integer aSegmentEdge = aSegments->VertexNumber() + 1;
379       for (Standard_Integer aNodeIdx = anEdgeNodes.Lower(); aNodeIdx <= anEdgeNodes.Upper(); ++aNodeIdx)
380       {
381         // node index in face triangulation
382         // get node and apply location transformation to the node
383         const Standard_Integer aTriIndex = anEdgeNodes.Value (aNodeIdx);
384         gp_Pnt aTriNode = aTriNodes.Value (aTriIndex);
385         if (!aTrsf.IsIdentity())
386         {
387           aTriNode.Transform (aTrsf);
388         }
389
390         aSegments->AddVertex (aTriNode);
391         if (aNodeIdx != anEdgeNodes.Lower())
392         {
393           aSegments->AddEdge (  aSegmentEdge);
394           aSegments->AddEdge (++aSegmentEdge);
395         }
396       }
397     }
398
399     // set up aspect and add polyline data
400     Handle(Graphic3d_AspectLine3d) aBoundaryAspect = theDrawer->FaceBoundaryAspect()->Aspect();
401
402     Handle(Graphic3d_Group) aPrsGrp = Prs3d_Root::CurrentGroup (thePrs);
403     aPrsGrp->SetGroupPrimitivesAspect (aBoundaryAspect);
404     aPrsGrp->AddPrimitiveArray (aSegments);
405   }
406
407 } // anonymous namespace
408
409 // =======================================================================
410 // function : ExploreSolids
411 // purpose  :
412 // =======================================================================
413 void StdPrs_ShadedShape::ExploreSolids (const TopoDS_Shape&    theShape,
414                                         const BRep_Builder&    theBuilder,
415                                         TopoDS_Compound&       theClosed,
416                                         TopoDS_Compound&       theOpened,
417                                         const Standard_Boolean theIgnore1DSubShape)
418 {
419   if (theShape.IsNull())
420   {
421     return;
422   }
423
424   switch (theShape.ShapeType())
425   {
426     case TopAbs_COMPOUND:
427     case TopAbs_COMPSOLID:
428     {
429       for (TopoDS_Iterator anIter (theShape); anIter.More(); anIter.Next())
430       {
431         ExploreSolids (anIter.Value(), theBuilder, theClosed, theOpened, theIgnore1DSubShape);
432       }
433       return;
434     }
435     case TopAbs_SOLID:
436     {
437       for (TopoDS_Iterator anIter (theShape); anIter.More(); anIter.Next())
438       {
439         const TopoDS_Shape& aSubShape   = anIter.Value();
440         const Standard_Boolean isClosed = aSubShape.ShapeType() == TopAbs_SHELL &&
441                                           BRep_Tool::IsClosed (aSubShape)       &&
442                                           StdPrs_ToolTriangulatedShape::IsTriangulated (aSubShape);
443         theBuilder.Add (isClosed ? theClosed : theOpened, aSubShape);
444       }
445       return;
446     }
447     case TopAbs_SHELL:
448     case TopAbs_FACE:
449     {
450       theBuilder.Add (theOpened, theShape);
451       return;
452     }
453     case TopAbs_WIRE:
454     case TopAbs_EDGE:
455     case TopAbs_VERTEX:
456     {
457       if (!theIgnore1DSubShape)
458       {
459         theBuilder.Add (theOpened, theShape);
460       }
461       return;
462     }
463     case TopAbs_SHAPE:
464     default:
465       return;
466   }
467 }
468
469 // =======================================================================
470 // function : Add
471 // purpose  :
472 // =======================================================================
473 void StdPrs_ShadedShape::Add (const Handle(Prs3d_Presentation)& thePrs,
474                               const TopoDS_Shape&               theShape,
475                               const Handle(Prs3d_Drawer)&       theDrawer,
476                               const StdPrs_Volume               theVolume)
477 {
478   gp_Pnt2d aDummy;
479   StdPrs_ShadedShape::Add (thePrs, theShape, theDrawer,
480                            Standard_False, aDummy, aDummy, aDummy, theVolume);
481 }
482
483 // =======================================================================
484 // function : Add
485 // purpose  :
486 // =======================================================================
487 void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs,
488                               const TopoDS_Shape&                theShape,
489                               const Handle (Prs3d_Drawer)&       theDrawer,
490                               const Standard_Boolean             theHasTexels,
491                               const gp_Pnt2d&                    theUVOrigin,
492                               const gp_Pnt2d&                    theUVRepeat,
493                               const gp_Pnt2d&                    theUVScale,
494                               const StdPrs_Volume                theVolume)
495 {
496   if (theShape.IsNull())
497   {
498     return;
499   }
500
501   // add wireframe presentation for isolated edges and vertices
502   wireframeFromShape (thePrs, theShape, theDrawer);
503
504   // Use automatic re-triangulation with deflection-check logic only if this feature is enable
505   if (theDrawer->IsAutoTriangulation())
506   {
507     // Triangulation completeness is important for "open-closed" analysis - perform tessellation beforehand
508     StdPrs_ToolTriangulatedShape::Tessellate (theShape, theDrawer);
509   }
510
511   // add special wireframe presentation for faces without triangulation
512   wireframeNoTriangFacesFromShape (thePrs, theShape, theDrawer);
513
514   // The shape types listed below need advanced analysis as potentially containing
515   // both closed and open parts. Solids are also included, because they might
516   // contain non-manifold parts inside (internal open shells)
517   if ((theShape.ShapeType() == TopAbs_COMPOUND
518     || theShape.ShapeType() == TopAbs_COMPSOLID
519     || theShape.ShapeType() == TopAbs_SOLID)
520    &&  theVolume == StdPrs_Volume_Autodetection)
521   {
522     // collect two compounds: for opened and closed (solid) sub-shapes
523     TopoDS_Compound anOpened, aClosed;
524     BRep_Builder aBuilder;
525     aBuilder.MakeCompound (aClosed);
526     aBuilder.MakeCompound (anOpened);
527     ExploreSolids (theShape, aBuilder, aClosed, anOpened, Standard_True);
528
529     TopoDS_Iterator aShapeIter (aClosed);
530     if (aShapeIter.More())
531     {
532       shadeFromShape (aClosed, thePrs, theDrawer,
533                       theHasTexels, theUVOrigin, theUVRepeat, theUVScale, true);
534     }
535
536     aShapeIter.Initialize (anOpened);
537     if (aShapeIter.More())
538     {
539       shadeFromShape (anOpened, thePrs, theDrawer,
540                       theHasTexels, theUVOrigin, theUVRepeat, theUVScale, false);
541     }
542   }
543   else
544   {
545     // if the shape type is not compound, composolid or solid, use autodetection back-facing filled
546     shadeFromShape (theShape, thePrs, theDrawer,
547                     theHasTexels, theUVOrigin, theUVRepeat, theUVScale,
548                     theVolume == StdPrs_Volume_Closed);
549   }
550
551   if (theDrawer->FaceBoundaryDraw())
552   {
553     computeFaceBoundaries (theShape, thePrs, theDrawer);
554   }
555 }