[occt.git] / src / StdPrs / StdPrs_ShadedShape.cxx

// Created on: 1993-09-23
// Created by: Jean-Louis FRENKEL
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <StdPrs_ShadedShape.hxx>

#include <Bnd_Box.hxx>
#include <BRepTools.hxx>
#include <BRepBndLib.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <Graphic3d_ArrayOfSegments.hxx>
#include <Graphic3d_ArrayOfTriangles.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
#include <Graphic3d_Group.hxx>
#include <gp_Dir.hxx>
#include <gp_Vec.hxx>
#include <gp_Pnt.hxx>
#include <NCollection_List.hxx>
#include <Precision.hxx>
#include <Prs3d_Drawer.hxx>
#include <Prs3d_IsoAspect.hxx>
#include <Prs3d_LineAspect.hxx>
#include <Prs3d_Presentation.hxx>
#include <Prs3d_ShadingAspect.hxx>
#include <Poly_Connect.hxx>
#include <Poly_PolygonOnTriangulation.hxx>
#include <Poly_Triangulation.hxx>
#include <StdPrs_ToolTriangulatedShape.hxx>
#include <StdPrs_WFShape.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shape.hxx>
#include <TColgp_Array1OfDir.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>

namespace
{

  //! Computes wireframe presentation for free wires and vertices
  void wireframeFromShape (const Handle (Prs3d_Presentation)& thePrs,
                           const TopoDS_Shape&                theShape,
                           const Handle (Prs3d_Drawer)&       theDrawer)
  {
    Standard_Boolean aDrawAllVerticesFlag = (theDrawer->VertexDrawMode() == Prs3d_VDM_All);

    if (!aDrawAllVerticesFlag && theShape.ShapeType() != TopAbs_COMPOUND)
    {
      return;
    }

    TopExp_Explorer aShapeIter (theShape, TopAbs_FACE);
    if (!aShapeIter.More())
    {
      // compound contains no shaded elements at all
      StdPrs_WFShape::Add (thePrs, theShape, theDrawer);
      return;
    }

    // We have to create a compound and collect all subshapes not drawn by the shading algo.
    // This includes:
    // - isolated edges
    // - isolated vertices, if aDrawAllVerticesFlag == Standard_False
    // - all shape's vertices, if aDrawAllVerticesFlag == Standard_True
    TopoDS_Compound aCompoundWF;
    BRep_Builder aBuilder;
    aBuilder.MakeCompound (aCompoundWF);
    Standard_Boolean hasElement = Standard_False;

    // isolated edges
    for (aShapeIter.Init (theShape, TopAbs_EDGE, TopAbs_FACE); aShapeIter.More(); aShapeIter.Next())
    {
      hasElement = Standard_True;
      aBuilder.Add (aCompoundWF, aShapeIter.Current());
    }
    // isolated or all vertices
    aShapeIter.Init (theShape, TopAbs_VERTEX, aDrawAllVerticesFlag ? TopAbs_SHAPE : TopAbs_EDGE);
    for (; aShapeIter.More(); aShapeIter.Next())
    {
      hasElement = Standard_True;
      aBuilder.Add (aCompoundWF, aShapeIter.Current());
    }
    if (hasElement)
    {
      StdPrs_WFShape::Add (thePrs, aCompoundWF, theDrawer);
    }
  }

  //! Computes special wireframe presentation for faces without triangulation.
  void wireframeNoTriangFacesFromShape (const Handle(Prs3d_Presentation)& thePrs,
                                        const TopoDS_Shape&               theShape,
                                        const Handle(Prs3d_Drawer)&       theDrawer)
  {
    TopoDS_Compound aCompoundWF;
    BRep_Builder aBuilder;
    aBuilder.MakeCompound (aCompoundWF);
    TopLoc_Location aLoc;
    Standard_Boolean hasElement = Standard_False;

    for (TopExp_Explorer aShapeIter(theShape, TopAbs_FACE); aShapeIter.More(); aShapeIter.Next())
    {
      const TopoDS_Face& aFace = TopoDS::Face (aShapeIter.Current());
      const Handle(Poly_Triangulation) aTriang = BRep_Tool::Triangulation (aFace, aLoc);
      if (aTriang.IsNull())
      {
        hasElement = Standard_True;
        aBuilder.Add (aCompoundWF, aFace);
      }
    }

    if (hasElement)
    {
      Standard_Integer aPrevUIsoNb = theDrawer->UIsoAspect()->Number();
      Standard_Integer aPrevVIsoNb = theDrawer->VIsoAspect()->Number();
      theDrawer->UIsoAspect()->SetNumber (5);
      theDrawer->VIsoAspect()->SetNumber (5);

      StdPrs_WFShape::Add (thePrs, aCompoundWF, theDrawer);

      theDrawer->UIsoAspect()->SetNumber (aPrevUIsoNb);
      theDrawer->VIsoAspect()->SetNumber (aPrevVIsoNb);
    }
  }

  //! Gets triangulation of every face of shape and fills output array of triangles
  static Handle(Graphic3d_ArrayOfTriangles) fillTriangles (const TopoDS_Shape&    theShape,
                                                           const Standard_Boolean theHasTexels,
                                                           const gp_Pnt2d&        theUVOrigin,
                                                           const gp_Pnt2d&        theUVRepeat,
                                                           const gp_Pnt2d&        theUVScale)
  {
    Handle(Poly_Triangulation) aT;
    TopLoc_Location aLoc;
    gp_Pnt aPoint;
    Standard_Integer aNbTriangles = 0;
    Standard_Integer aNbVertices  = 0;

    // Precision for compare square distances
    const Standard_Real aPreci = Precision::SquareConfusion();

    TopExp_Explorer aFaceIt(theShape, TopAbs_FACE);
    for (; aFaceIt.More(); aFaceIt.Next())
    {
      const TopoDS_Face& aFace = TopoDS::Face(aFaceIt.Current());
      aT = BRep_Tool::Triangulation (aFace, aLoc);
      if (!aT.IsNull())
      {
        aNbTriangles += aT->NbTriangles();
        aNbVertices  += aT->NbNodes();
      }
    }
    if (aNbVertices  <  3 || aNbTriangles <= 0)
    {
      return Handle(Graphic3d_ArrayOfTriangles)();
    }

    Handle(Graphic3d_ArrayOfTriangles) anArray = new Graphic3d_ArrayOfTriangles (aNbVertices, 3 * aNbTriangles,
                                                                                 Standard_True, Standard_False, theHasTexels);
    Standard_Real aUmin (0.0), aUmax (0.0), aVmin (0.0), aVmax (0.0), dUmax (0.0), dVmax (0.0);
    for (aFaceIt.Init (theShape, TopAbs_FACE); aFaceIt.More(); aFaceIt.Next())
    {
      const TopoDS_Face& aFace = TopoDS::Face(aFaceIt.Current());
      aT = BRep_Tool::Triangulation (aFace, aLoc);
      if (aT.IsNull())
      {
        continue;
      }
      const gp_Trsf& aTrsf = aLoc.Transformation();

      // Determinant of transform matrix less then 0 means that mirror transform applied.
      Standard_Boolean isMirrored = aTrsf.VectorialPart().Determinant() < 0;

      Poly_Connect aPolyConnect (aT);
      // Extracts vertices & normals from nodes
      const TColgp_Array1OfPnt&   aNodes   = aT->Nodes();
      const TColgp_Array1OfPnt2d& aUVNodes = aT->UVNodes();
      TColgp_Array1OfDir aNormals (aNodes.Lower(), aNodes.Upper());
      StdPrs_ToolTriangulatedShape::Normal (aFace, aPolyConnect, aNormals);

      if (theHasTexels)
      {
        BRepTools::UVBounds (aFace, aUmin, aUmax, aVmin, aVmax);
        dUmax = (aUmax - aUmin);
        dVmax = (aVmax - aVmin);
      }

      const Standard_Integer aDecal = anArray->VertexNumber();
      for (Standard_Integer aNodeIter = aNodes.Lower(); aNodeIter <= aNodes.Upper(); ++aNodeIter)
      {
        aPoint = aNodes (aNodeIter);
        if (!aLoc.IsIdentity())
        {
          aPoint.Transform (aTrsf);

          aNormals (aNodeIter) = aNormals (aNodeIter).Transformed (aTrsf);
        }

        if (theHasTexels && aUVNodes.Upper() == aNodes.Upper())
        {
          const gp_Pnt2d aTexel = gp_Pnt2d ((-theUVOrigin.X() + (theUVRepeat.X() * (aUVNodes (aNodeIter).X() - aUmin)) / dUmax) / theUVScale.X(),
                                            (-theUVOrigin.Y() + (theUVRepeat.Y() * (aUVNodes (aNodeIter).Y() - aVmin)) / dVmax) / theUVScale.Y());
          anArray->AddVertex (aPoint, aNormals (aNodeIter), aTexel);
        }
        else
        {
          anArray->AddVertex (aPoint, aNormals (aNodeIter));
        }
      }

      // Fill array with vertex and edge visibility info
      const Poly_Array1OfTriangle& aTriangles = aT->Triangles();
      Standard_Integer anIndex[3];
      for (Standard_Integer aTriIter = 1; aTriIter <= aT->NbTriangles(); ++aTriIter)
      {
        if ((aFace.Orientation() == TopAbs_REVERSED) ^ isMirrored)
        {
          aTriangles (aTriIter).Get (anIndex[0], anIndex[2], anIndex[1]);
        }
        else
        {
          aTriangles (aTriIter).Get (anIndex[0], anIndex[1], anIndex[2]);
        }

        gp_Pnt aP1 = aNodes (anIndex[0]);
        gp_Pnt aP2 = aNodes (anIndex[1]);
        gp_Pnt aP3 = aNodes (anIndex[2]);

        gp_Vec aV1 (aP1, aP2);
        if (aV1.SquareMagnitude() <= aPreci)
        {
          continue;
        }
        gp_Vec aV2 (aP2, aP3);
        if (aV2.SquareMagnitude() <= aPreci)
        {
          continue;
        }
        gp_Vec aV3 (aP3, aP1);
        if (aV3.SquareMagnitude() <= aPreci)
        {
          continue;
        }
        aV1.Normalize();
        aV2.Normalize();
        aV1.Cross (aV2);
        if (aV1.SquareMagnitude() > aPreci)
        {
          anArray->AddEdge (anIndex[0] + aDecal);
          anArray->AddEdge (anIndex[1] + aDecal);
          anArray->AddEdge (anIndex[2] + aDecal);
        }
      }
    }
    return anArray;
  }

  //! Prepare shaded presentation for specified shape
  static Standard_Boolean shadeFromShape (const TopoDS_Shape&               theShape,
                                          const Handle(Prs3d_Presentation)& thePrs,
                                          const Handle(Prs3d_Drawer)&       theDrawer,
                                          const Standard_Boolean            theHasTexels,
                                          const gp_Pnt2d&                   theUVOrigin,
                                          const gp_Pnt2d&                   theUVRepeat,
                                          const gp_Pnt2d&                   theUVScale,
                                          const bool                        theIsClosed)
  {
    Handle(Graphic3d_ArrayOfTriangles) aPArray = fillTriangles (theShape, theHasTexels, theUVOrigin, theUVRepeat, theUVScale);
    if (aPArray.IsNull())
    {
      return Standard_False;
    }

    Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePrs);
    aGroup->SetClosed (theIsClosed);
    aGroup->SetGroupPrimitivesAspect (theDrawer->ShadingAspect()->Aspect());
    aGroup->AddPrimitiveArray (aPArray);
    return Standard_True;
  }

  //! Compute boundary presentation for faces of the shape.
  static Handle(Graphic3d_ArrayOfSegments) fillFaceBoundaries (const TopoDS_Shape& theShape)
  {
    // collection of all triangulation nodes on edges
    // for computing boundaries presentation
    Standard_Integer aNodeNumber = 0;
    Standard_Integer aNbPolylines = 0;

    TopLoc_Location aTrsf;

    // explore all boundary edges
    TopTools_IndexedDataMapOfShapeListOfShape anEdgesMap;
    TopExp::MapShapesAndAncestors (theShape, TopAbs_EDGE, TopAbs_FACE, anEdgesMap);
    for (TopTools_IndexedDataMapOfShapeListOfShape::Iterator anEdgeIter (anEdgesMap); anEdgeIter.More(); anEdgeIter.Next())
    {
      // reject free edges
      if (anEdgeIter.Value().Extent() == 0)
      {
        continue;
      }

      // take one of the shared edges and get edge triangulation
      const TopoDS_Face& aFace = TopoDS::Face (anEdgeIter.Value().First());
      Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (aFace, aTrsf);
      if (aTriangulation.IsNull())
      {
        continue;
      }

      const TopoDS_Edge& anEdge = TopoDS::Edge (anEdgeIter.Key());
      Handle(Poly_PolygonOnTriangulation) anEdgePoly = BRep_Tool::PolygonOnTriangulation (anEdge, aTriangulation, aTrsf);
      if (!anEdgePoly.IsNull()
        && anEdgePoly->Nodes().Length() >= 2)
      {
        aNodeNumber += anEdgePoly->Nodes().Length();
        ++aNbPolylines;
      }
    }
    if (aNodeNumber == 0)
    {
      return Handle(Graphic3d_ArrayOfSegments)();
    }

    // create indexed segments array to pack polylines from different edges into single array
    const Standard_Integer aSegmentEdgeNb = (aNodeNumber - aNbPolylines) * 2;
    Handle(Graphic3d_ArrayOfSegments) aSegments = new Graphic3d_ArrayOfSegments (aNodeNumber, aSegmentEdgeNb);
    for (TopTools_IndexedDataMapOfShapeListOfShape::Iterator anEdgeIter (anEdgesMap); anEdgeIter.More(); anEdgeIter.Next())
    {
      if (anEdgeIter.Value().Extent() == 0)
      {
        continue;
      }

      const TopoDS_Face& aFace = TopoDS::Face (anEdgeIter.Value().First());
      Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (aFace, aTrsf);
      if (aTriangulation.IsNull())
      {
        continue;
      }

      const TopoDS_Edge& anEdge = TopoDS::Edge (anEdgeIter.Key());
      Handle(Poly_PolygonOnTriangulation) anEdgePoly = BRep_Tool::PolygonOnTriangulation (anEdge, aTriangulation, aTrsf);
      if (anEdgePoly.IsNull()
       || anEdgePoly->Nodes().Length () < 2)
      {
        continue;
      }

      // get edge nodes indexes from face triangulation
      const TColgp_Array1OfPnt&      aTriNodes   = aTriangulation->Nodes();
      const TColStd_Array1OfInteger& anEdgeNodes = anEdgePoly->Nodes();

      // collect the edge nodes
      Standard_Integer aSegmentEdge = aSegments->VertexNumber() + 1;
      for (Standard_Integer aNodeIdx = anEdgeNodes.Lower(); aNodeIdx <= anEdgeNodes.Upper(); ++aNodeIdx)
      {
        // node index in face triangulation
        // get node and apply location transformation to the node
        const Standard_Integer aTriIndex = anEdgeNodes.Value (aNodeIdx);
        gp_Pnt aTriNode = aTriNodes.Value (aTriIndex);
        if (!aTrsf.IsIdentity())
        {
          aTriNode.Transform (aTrsf);
        }

        aSegments->AddVertex (aTriNode);
        if (aNodeIdx != anEdgeNodes.Lower())
        {
          aSegments->AddEdge (  aSegmentEdge);
          aSegments->AddEdge (++aSegmentEdge);
        }
      }
    }
    return aSegments;
  }

} // anonymous namespace

// =======================================================================
// function : ExploreSolids
// purpose  :
// =======================================================================
void StdPrs_ShadedShape::ExploreSolids (const TopoDS_Shape&    theShape,
                                        const BRep_Builder&    theBuilder,
                                        TopoDS_Compound&       theClosed,
                                        TopoDS_Compound&       theOpened,
                                        const Standard_Boolean theIgnore1DSubShape)
{
  if (theShape.IsNull())
  {
    return;
  }

  switch (theShape.ShapeType())
  {
    case TopAbs_COMPOUND:
    case TopAbs_COMPSOLID:
    {
      for (TopoDS_Iterator anIter (theShape); anIter.More(); anIter.Next())
      {
        ExploreSolids (anIter.Value(), theBuilder, theClosed, theOpened, theIgnore1DSubShape);
      }
      return;
    }
    case TopAbs_SOLID:
    {
      for (TopoDS_Iterator anIter (theShape); anIter.More(); anIter.Next())
      {
        const TopoDS_Shape& aSubShape   = anIter.Value();
        const Standard_Boolean isClosed = aSubShape.ShapeType() == TopAbs_SHELL &&
                                          BRep_Tool::IsClosed (aSubShape)       &&
                                          StdPrs_ToolTriangulatedShape::IsTriangulated (aSubShape);
        theBuilder.Add (isClosed ? theClosed : theOpened, aSubShape);
      }
      return;
    }
    case TopAbs_SHELL:
    case TopAbs_FACE:
    {
      theBuilder.Add (theOpened, theShape);
      return;
    }
    case TopAbs_WIRE:
    case TopAbs_EDGE:
    case TopAbs_VERTEX:
    {
      if (!theIgnore1DSubShape)
      {
        theBuilder.Add (theOpened, theShape);
      }
      return;
    }
    case TopAbs_SHAPE:
    default:
      return;
  }
}

// =======================================================================
// function : Add
// purpose  :
// =======================================================================
void StdPrs_ShadedShape::Add (const Handle(Prs3d_Presentation)& thePrs,
                              const TopoDS_Shape&               theShape,
                              const Handle(Prs3d_Drawer)&       theDrawer,
                              const StdPrs_Volume               theVolume)
{
  gp_Pnt2d aDummy;
  StdPrs_ShadedShape::Add (thePrs, theShape, theDrawer,
                           Standard_False, aDummy, aDummy, aDummy, theVolume);
}

// =======================================================================
// function : Add
// purpose  :
// =======================================================================
void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs,
                              const TopoDS_Shape&                theShape,
                              const Handle (Prs3d_Drawer)&       theDrawer,
                              const Standard_Boolean             theHasTexels,
                              const gp_Pnt2d&                    theUVOrigin,
                              const gp_Pnt2d&                    theUVRepeat,
                              const gp_Pnt2d&                    theUVScale,
                              const StdPrs_Volume                theVolume)
{
  if (theShape.IsNull())
  {
    return;
  }

  // add wireframe presentation for isolated edges and vertices
  wireframeFromShape (thePrs, theShape, theDrawer);

  // Use automatic re-triangulation with deflection-check logic only if this feature is enable
  if (theDrawer->IsAutoTriangulation())
  {
    // Triangulation completeness is important for "open-closed" analysis - perform tessellation beforehand
    StdPrs_ToolTriangulatedShape::Tessellate (theShape, theDrawer);
  }

  // add special wireframe presentation for faces without triangulation
  wireframeNoTriangFacesFromShape (thePrs, theShape, theDrawer);

  // The shape types listed below need advanced analysis as potentially containing
  // both closed and open parts. Solids are also included, because they might
  // contain non-manifold parts inside (internal open shells)
  if ((theShape.ShapeType() == TopAbs_COMPOUND
    || theShape.ShapeType() == TopAbs_COMPSOLID
    || theShape.ShapeType() == TopAbs_SOLID)
   &&  theVolume == StdPrs_Volume_Autodetection)
  {
    // collect two compounds: for opened and closed (solid) sub-shapes
    TopoDS_Compound anOpened, aClosed;
    BRep_Builder aBuilder;
    aBuilder.MakeCompound (aClosed);
    aBuilder.MakeCompound (anOpened);
    ExploreSolids (theShape, aBuilder, aClosed, anOpened, Standard_True);

    TopoDS_Iterator aShapeIter (aClosed);
    if (aShapeIter.More())
    {
      shadeFromShape (aClosed, thePrs, theDrawer,
                      theHasTexels, theUVOrigin, theUVRepeat, theUVScale, true);
    }

    aShapeIter.Initialize (anOpened);
    if (aShapeIter.More())
    {
      shadeFromShape (anOpened, thePrs, theDrawer,
                      theHasTexels, theUVOrigin, theUVRepeat, theUVScale, false);
    }
  }
  else
  {
    // if the shape type is not compound, composolid or solid, use autodetection back-facing filled
    shadeFromShape (theShape, thePrs, theDrawer,
                    theHasTexels, theUVOrigin, theUVRepeat, theUVScale,
                    theVolume == StdPrs_Volume_Closed);
  }

  if (theDrawer->FaceBoundaryDraw())
  {
    Handle(Graphic3d_ArrayOfSegments) aBndSegments = fillFaceBoundaries (theShape);
    if (!aBndSegments.IsNull())
    {
      Handle(Graphic3d_AspectLine3d) aBoundaryAspect = theDrawer->FaceBoundaryAspect()->Aspect();
      Handle(Graphic3d_Group) aPrsGrp = Prs3d_Root::CurrentGroup (thePrs);
      aPrsGrp->SetGroupPrimitivesAspect (aBoundaryAspect);
      aPrsGrp->AddPrimitiveArray (aBndSegments);
    }
  }
}

// =======================================================================
// function : FillTriangles
// purpose  :
// =======================================================================
Handle(Graphic3d_ArrayOfTriangles) StdPrs_ShadedShape::FillTriangles (const TopoDS_Shape&    theShape,
                                                                      const Standard_Boolean theHasTexels,
                                                                      const gp_Pnt2d&        theUVOrigin,
                                                                      const gp_Pnt2d&        theUVRepeat,
                                                                      const gp_Pnt2d&        theUVScale)
{
  return fillTriangles (theShape, theHasTexels, theUVOrigin, theUVRepeat, theUVScale);
}

// =======================================================================
// function : FillFaceBoundaries
// purpose  :
// =======================================================================
Handle(Graphic3d_ArrayOfSegments) StdPrs_ShadedShape::FillFaceBoundaries (const TopoDS_Shape& theShape)
{
  return fillFaceBoundaries (theShape);
}

// =======================================================================
// function : AddWireframeForFreeElements
// purpose  :
// =======================================================================
void StdPrs_ShadedShape::AddWireframeForFreeElements (const Handle (Prs3d_Presentation)& thePrs,
                                                      const TopoDS_Shape&                theShape,
                                                      const Handle (Prs3d_Drawer)&       theDrawer)
{
  wireframeFromShape (thePrs, theShape, theDrawer);
}

// =======================================================================
// function : AddWireframeForFacesWithoutTriangles
// purpose  :
// =======================================================================
void StdPrs_ShadedShape::AddWireframeForFacesWithoutTriangles (const Handle(Prs3d_Presentation)& thePrs,
                                                               const TopoDS_Shape&               theShape,
                                                               const Handle(Prs3d_Drawer)&       theDrawer)
{
  wireframeNoTriangFacesFromShape (thePrs, theShape, theDrawer);
}
Commit	Line	Data
	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	aGroup->SetGroupPrimitivesAspect (theDrawer->ShadingAspect()->Aspect());
	294	aGroup->AddPrimitiveArray (aPArray);
	295	return Standard_True;
	296	}
	297
	298	//! Compute boundary presentation for faces of the shape.
	299	static Handle(Graphic3d_ArrayOfSegments) fillFaceBoundaries (const TopoDS_Shape& theShape)
	300	{
	301	// collection of all triangulation nodes on edges
	302	// for computing boundaries presentation
	303	Standard_Integer aNodeNumber = 0;
	304	Standard_Integer aNbPolylines = 0;
	305
	306	TopLoc_Location aTrsf;
	307
	308	// explore all boundary edges
	309	TopTools_IndexedDataMapOfShapeListOfShape anEdgesMap;
	310	TopExp::MapShapesAndAncestors (theShape, TopAbs_EDGE, TopAbs_FACE, anEdgesMap);
	311	for (TopTools_IndexedDataMapOfShapeListOfShape::Iterator anEdgeIter (anEdgesMap); anEdgeIter.More(); anEdgeIter.Next())
	312	{
	313	// reject free edges
	314	if (anEdgeIter.Value().Extent() == 0)
	315	{
	316	continue;
	317	}
	318
	319	// take one of the shared edges and get edge triangulation
	320	const TopoDS_Face& aFace = TopoDS::Face (anEdgeIter.Value().First());
	321	Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (aFace, aTrsf);
	322	if (aTriangulation.IsNull())
	323	{
	324	continue;
	325	}
	326
	327	const TopoDS_Edge& anEdge = TopoDS::Edge (anEdgeIter.Key());
	328	Handle(Poly_PolygonOnTriangulation) anEdgePoly = BRep_Tool::PolygonOnTriangulation (anEdge, aTriangulation, aTrsf);
	329	if (!anEdgePoly.IsNull()
	330	&& anEdgePoly->Nodes().Length() >= 2)
	331	{
	332	aNodeNumber += anEdgePoly->Nodes().Length();
	333	++aNbPolylines;
	334	}
	335	}
	336	if (aNodeNumber == 0)
	337	{
	338	return Handle(Graphic3d_ArrayOfSegments)();
	339	}
	340
	341	// create indexed segments array to pack polylines from different edges into single array
	342	const Standard_Integer aSegmentEdgeNb = (aNodeNumber - aNbPolylines) * 2;
	343	Handle(Graphic3d_ArrayOfSegments) aSegments = new Graphic3d_ArrayOfSegments (aNodeNumber, aSegmentEdgeNb);
	344	for (TopTools_IndexedDataMapOfShapeListOfShape::Iterator anEdgeIter (anEdgesMap); anEdgeIter.More(); anEdgeIter.Next())
	345	{
	346	if (anEdgeIter.Value().Extent() == 0)
	347	{
	348	continue;
	349	}
	350
	351	const TopoDS_Face& aFace = TopoDS::Face (anEdgeIter.Value().First());
	352	Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (aFace, aTrsf);
	353	if (aTriangulation.IsNull())
	354	{
	355	continue;
	356	}
	357
	358	const TopoDS_Edge& anEdge = TopoDS::Edge (anEdgeIter.Key());
	359	Handle(Poly_PolygonOnTriangulation) anEdgePoly = BRep_Tool::PolygonOnTriangulation (anEdge, aTriangulation, aTrsf);
	360	if (anEdgePoly.IsNull()
	361	\|\| anEdgePoly->Nodes().Length () < 2)
	362	{
	363	continue;
	364	}
	365
	366	// get edge nodes indexes from face triangulation
	367	const TColgp_Array1OfPnt& aTriNodes = aTriangulation->Nodes();
	368	const TColStd_Array1OfInteger& anEdgeNodes = anEdgePoly->Nodes();
	369
	370	// collect the edge nodes
	371	Standard_Integer aSegmentEdge = aSegments->VertexNumber() + 1;
	372	for (Standard_Integer aNodeIdx = anEdgeNodes.Lower(); aNodeIdx <= anEdgeNodes.Upper(); ++aNodeIdx)
	373	{
	374	// node index in face triangulation
	375	// get node and apply location transformation to the node
	376	const Standard_Integer aTriIndex = anEdgeNodes.Value (aNodeIdx);
	377	gp_Pnt aTriNode = aTriNodes.Value (aTriIndex);
	378	if (!aTrsf.IsIdentity())
	379	{
	380	aTriNode.Transform (aTrsf);
	381	}
	382
	383	aSegments->AddVertex (aTriNode);
	384	if (aNodeIdx != anEdgeNodes.Lower())
	385	{
	386	aSegments->AddEdge ( aSegmentEdge);
	387	aSegments->AddEdge (++aSegmentEdge);
	388	}
	389	}
	390	}
	391	return aSegments;
	392	}
	393
	394	} // anonymous namespace
	395
	396	// =======================================================================
	397	// function : ExploreSolids
	398	// purpose :
	399	// =======================================================================
	400	void StdPrs_ShadedShape::ExploreSolids (const TopoDS_Shape& theShape,
	401	const BRep_Builder& theBuilder,
	402	TopoDS_Compound& theClosed,
	403	TopoDS_Compound& theOpened,
	404	const Standard_Boolean theIgnore1DSubShape)
	405	{
	406	if (theShape.IsNull())
	407	{
	408	return;
	409	}
	410
	411	switch (theShape.ShapeType())
	412	{
	413	case TopAbs_COMPOUND:
	414	case TopAbs_COMPSOLID:
	415	{
	416	for (TopoDS_Iterator anIter (theShape); anIter.More(); anIter.Next())
	417	{
	418	ExploreSolids (anIter.Value(), theBuilder, theClosed, theOpened, theIgnore1DSubShape);
	419	}
	420	return;
	421	}
	422	case TopAbs_SOLID:
	423	{
	424	for (TopoDS_Iterator anIter (theShape); anIter.More(); anIter.Next())
	425	{
	426	const TopoDS_Shape& aSubShape = anIter.Value();
	427	const Standard_Boolean isClosed = aSubShape.ShapeType() == TopAbs_SHELL &&
	428	BRep_Tool::IsClosed (aSubShape) &&
	429	StdPrs_ToolTriangulatedShape::IsTriangulated (aSubShape);
	430	theBuilder.Add (isClosed ? theClosed : theOpened, aSubShape);
	431	}
	432	return;
	433	}
	434	case TopAbs_SHELL:
	435	case TopAbs_FACE:
	436	{
	437	theBuilder.Add (theOpened, theShape);
	438	return;
	439	}
	440	case TopAbs_WIRE:
	441	case TopAbs_EDGE:
	442	case TopAbs_VERTEX:
	443	{
	444	if (!theIgnore1DSubShape)
	445	{
	446	theBuilder.Add (theOpened, theShape);
	447	}
	448	return;
	449	}
	450	case TopAbs_SHAPE:
	451	default:
	452	return;
	453	}
	454	}
	455
	456	// =======================================================================
	457	// function : Add
	458	// purpose :
	459	// =======================================================================
	460	void StdPrs_ShadedShape::Add (const Handle(Prs3d_Presentation)& thePrs,
	461	const TopoDS_Shape& theShape,
	462	const Handle(Prs3d_Drawer)& theDrawer,
	463	const StdPrs_Volume theVolume)
	464	{
	465	gp_Pnt2d aDummy;
	466	StdPrs_ShadedShape::Add (thePrs, theShape, theDrawer,
	467	Standard_False, aDummy, aDummy, aDummy, theVolume);
	468	}
	469
	470	// =======================================================================
	471	// function : Add
	472	// purpose :
	473	// =======================================================================
	474	void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs,
	475	const TopoDS_Shape& theShape,
	476	const Handle (Prs3d_Drawer)& theDrawer,
	477	const Standard_Boolean theHasTexels,
	478	const gp_Pnt2d& theUVOrigin,
	479	const gp_Pnt2d& theUVRepeat,
	480	const gp_Pnt2d& theUVScale,
	481	const StdPrs_Volume theVolume)
	482	{
	483	if (theShape.IsNull())
	484	{
	485	return;
	486	}
	487
	488	// add wireframe presentation for isolated edges and vertices
	489	wireframeFromShape (thePrs, theShape, theDrawer);
	490
	491	// Use automatic re-triangulation with deflection-check logic only if this feature is enable
	492	if (theDrawer->IsAutoTriangulation())
	493	{
	494	// Triangulation completeness is important for "open-closed" analysis - perform tessellation beforehand
	495	StdPrs_ToolTriangulatedShape::Tessellate (theShape, theDrawer);
	496	}
	497
	498	// add special wireframe presentation for faces without triangulation
	499	wireframeNoTriangFacesFromShape (thePrs, theShape, theDrawer);
	500
	501	// The shape types listed below need advanced analysis as potentially containing
	502	// both closed and open parts. Solids are also included, because they might
	503	// contain non-manifold parts inside (internal open shells)
	504	if ((theShape.ShapeType() == TopAbs_COMPOUND
	505	\|\| theShape.ShapeType() == TopAbs_COMPSOLID
	506	\|\| theShape.ShapeType() == TopAbs_SOLID)
	507	&& theVolume == StdPrs_Volume_Autodetection)
	508	{
	509	// collect two compounds: for opened and closed (solid) sub-shapes
	510	TopoDS_Compound anOpened, aClosed;
	511	BRep_Builder aBuilder;
	512	aBuilder.MakeCompound (aClosed);
	513	aBuilder.MakeCompound (anOpened);
	514	ExploreSolids (theShape, aBuilder, aClosed, anOpened, Standard_True);
	515
	516	TopoDS_Iterator aShapeIter (aClosed);
	517	if (aShapeIter.More())
	518	{
	519	shadeFromShape (aClosed, thePrs, theDrawer,
	520	theHasTexels, theUVOrigin, theUVRepeat, theUVScale, true);
	521	}
	522
	523	aShapeIter.Initialize (anOpened);
	524	if (aShapeIter.More())
	525	{
	526	shadeFromShape (anOpened, thePrs, theDrawer,
	527	theHasTexels, theUVOrigin, theUVRepeat, theUVScale, false);
	528	}
	529	}
	530	else
	531	{
	532	// if the shape type is not compound, composolid or solid, use autodetection back-facing filled
	533	shadeFromShape (theShape, thePrs, theDrawer,
	534	theHasTexels, theUVOrigin, theUVRepeat, theUVScale,
	535	theVolume == StdPrs_Volume_Closed);
	536	}
	537
	538	if (theDrawer->FaceBoundaryDraw())
	539	{
	540	Handle(Graphic3d_ArrayOfSegments) aBndSegments = fillFaceBoundaries (theShape);
	541	if (!aBndSegments.IsNull())
	542	{
	543	Handle(Graphic3d_AspectLine3d) aBoundaryAspect = theDrawer->FaceBoundaryAspect()->Aspect();
	544	Handle(Graphic3d_Group) aPrsGrp = Prs3d_Root::CurrentGroup (thePrs);
	545	aPrsGrp->SetGroupPrimitivesAspect (aBoundaryAspect);
	546	aPrsGrp->AddPrimitiveArray (aBndSegments);
	547	}
	548	}
	549	}
	550
	551	// =======================================================================
	552	// function : FillTriangles
	553	// purpose :
	554	// =======================================================================
	555	Handle(Graphic3d_ArrayOfTriangles) StdPrs_ShadedShape::FillTriangles (const TopoDS_Shape& theShape,
	556	const Standard_Boolean theHasTexels,
	557	const gp_Pnt2d& theUVOrigin,
	558	const gp_Pnt2d& theUVRepeat,
	559	const gp_Pnt2d& theUVScale)
	560	{
	561	return fillTriangles (theShape, theHasTexels, theUVOrigin, theUVRepeat, theUVScale);
	562	}
	563
	564	// =======================================================================
	565	// function : FillFaceBoundaries
	566	// purpose :
	567	// =======================================================================
	568	Handle(Graphic3d_ArrayOfSegments) StdPrs_ShadedShape::FillFaceBoundaries (const TopoDS_Shape& theShape)
	569	{
	570	return fillFaceBoundaries (theShape);
	571	}
	572
	573	// =======================================================================
	574	// function : AddWireframeForFreeElements
	575	// purpose :
	576	// =======================================================================
	577	void StdPrs_ShadedShape::AddWireframeForFreeElements (const Handle (Prs3d_Presentation)& thePrs,
	578	const TopoDS_Shape& theShape,
	579	const Handle (Prs3d_Drawer)& theDrawer)
	580	{
	581	wireframeFromShape (thePrs, theShape, theDrawer);
	582	}
	583
	584	// =======================================================================
	585	// function : AddWireframeForFacesWithoutTriangles
	586	// purpose :
	587	// =======================================================================
	588	void StdPrs_ShadedShape::AddWireframeForFacesWithoutTriangles (const Handle(Prs3d_Presentation)& thePrs,
	589	const TopoDS_Shape& theShape,
	590	const Handle(Prs3d_Drawer)& theDrawer)
	591	{
	592	wireframeNoTriangFacesFromShape (thePrs, theShape, theDrawer);
	593	}