EIC code displayed by LXR master/​include/​opencascade/​BOPTools_AlgoTools3D.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-29 09:18:11

 // Created by: Peter KURNEV
 // 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.
 
 #ifndef _BOPTools_AlgoTools3D_HeaderFile
 #define _BOPTools_AlgoTools3D_HeaderFile
 
 #include <Standard.hxx>
 #include <Standard_DefineAlloc.hxx>
 #include <Standard_Handle.hxx>
 
 #include <Standard_Integer.hxx>
 class TopoDS_Edge;
 class TopoDS_Face;
 class gp_Dir;
 class Geom_Surface;
 class Geom2d_Curve;
 class gp_Pnt;
 class IntTools_Context;
 class gp_Pnt2d;
 class TopoDS_Shape;
 
 //! The class contains handy static functions
 //! dealing with the topology
 //! This is the copy of BOPTools_AlgoTools3D.cdl file
 class BOPTools_AlgoTools3D
 {
 public:
   DEFINE_STANDARD_ALLOC
 
   //! Makes the edge <theESplit> seam edge for the face <theFace> basing on the surface properties
   //! (U and V periods)
   Standard_EXPORT static bool DoSplitSEAMOnFace(const TopoDS_Edge& theESplit,
                                                 const TopoDS_Face& theFace);
 
   //! Makes the split edge <theESplit> seam edge for the face <theFace> basing on the positions
   //! of 2d curves of the original edge <theEOrigin>.
   Standard_EXPORT static bool DoSplitSEAMOnFace(const TopoDS_Edge& theEOrigin,
                                                 const TopoDS_Edge& theESplit,
                                                 const TopoDS_Face& theFace);
 
   //! Computes normal to the face <aF> for the point on the edge <aE>
   //! at parameter <aT>.
   //! <theContext> - storage for caching the geometrical tools
   Standard_EXPORT static void GetNormalToFaceOnEdge(
     const TopoDS_Edge&                   aE,
     const TopoDS_Face&                   aF,
     const double                         aT,
     gp_Dir&                              aD,
     const occ::handle<IntTools_Context>& theContext = occ::handle<IntTools_Context>());
 
   //! Computes normal to the face <aF> for the point on the edge <aE>
   //! at arbitrary intermediate parameter.
   //! <theContext> - storage for caching the geometrical tools
   Standard_EXPORT static void GetNormalToFaceOnEdge(
     const TopoDS_Edge&                   aE,
     const TopoDS_Face&                   aF,
     gp_Dir&                              aD,
     const occ::handle<IntTools_Context>& theContext = occ::handle<IntTools_Context>());
 
   //! Returns 1  if scalar product aNF1* aNF2>0.
   //! Returns 0  if directions aNF1 aNF2 coincide
   //! Returns -1 if scalar product aNF1* aNF2<0.
   Standard_EXPORT static int SenseFlag(const gp_Dir& aNF1, const gp_Dir& aNF2);
 
   //! Compute normal <aD> to surface <aS> in point (U,V)
   //! Returns TRUE if directions aD1U, aD1V coincide
   Standard_EXPORT static bool GetNormalToSurface(const occ::handle<Geom_Surface>& aS,
                                                  const double                     U,
                                                  const double                     V,
                                                  gp_Dir&                          aD);
 
   //! Computes normal to the face <aF> for the 3D-point that
   //! belongs to the edge <aE> at parameter <aT>.
   //! Output:
   //! aPx  -  the 3D-point where the normal computed
   //! aD   -  the normal;
   //! Warning:
   //! The normal is computed not exactly in the point on the
   //! edge, but in point that is near to the edge towards to
   //! the face material (so, we'll have approx. normal);
   //! The point is computed using PointNearEdge function,
   //! with the shifting value BOPTools_AlgoTools3D::MinStepIn2d(),
   //! from the edge, but if this value is too big,
   //! the point will be computed using Hatcher (PointInFace function).
   //! Returns TRUE in case of success.
   Standard_EXPORT static bool GetApproxNormalToFaceOnEdge(
     const TopoDS_Edge&                   aE,
     const TopoDS_Face&                   aF,
     const double                         aT,
     gp_Pnt&                              aPx,
     gp_Dir&                              aD,
     const occ::handle<IntTools_Context>& theContext);
 
   //! Computes normal to the face <aF> for the 3D-point that
   //! belongs to the edge <aE> at parameter <aT>.
   //! Output:
   //! aPx  -  the 3D-point where the normal computed
   //! aD   -  the normal;
   //! Warning:
   //! The normal is computed not exactly in the point on the
   //! edge, but in point that is near to the edge towards to
   //! the face material (so, we'll have approx. normal);
   //! The point is computed using PointNearEdge function
   //! with the shifting value <aDt2D> from the edge;
   //! No checks on this value will be done.
   //! Returns TRUE in case of success.
   Standard_EXPORT static bool GetApproxNormalToFaceOnEdge(const TopoDS_Edge& theE,
                                                           const TopoDS_Face& theF,
                                                           const double       aT,
                                                           gp_Pnt&            aP,
                                                           gp_Dir&            aDNF,
                                                           const double       aDt2D);
 
   //! Computes normal to the face <aF> for the 3D-point that
   //! belongs to the edge <aE> at parameter <aT>.
   //! Output:
   //! aPx  -  the 3D-point where the normal computed
   //! aD   -  the normal;
   //! Warning:
   //! The normal is computed not exactly in the point on the
   //! edge, but in point that is near to the edge towards to
   //! the face material (so, we'll have approx. normal);
   //! The point is computed using PointNearEdge function
   //! with the shifting value <aDt2D> from the edge,
   //! but if this value is too big the point will be
   //! computed using Hatcher (PointInFace function).
   //! Returns TRUE in case of success.
   Standard_EXPORT static bool GetApproxNormalToFaceOnEdge(
     const TopoDS_Edge&                   theE,
     const TopoDS_Face&                   theF,
     const double                         aT,
     const double                         aDt2D,
     gp_Pnt&                              aP,
     gp_Dir&                              aDNF,
     const occ::handle<IntTools_Context>& theContext);
 
   //! Compute the point <aPx>, (<aP2D>) that is near to
   //! the edge <aE> at parameter <aT> towards to the
   //! material of the face <aF>. The value of shifting in
   //! 2D is <aDt2D>
   //! If the value of shifting is too big the point
   //! will be computed using Hatcher (PointInFace function).
   //! Returns error status:
   //! 0 - in case of success;
   //! 1 - <aE> does not have 2d curve on the face <aF>;
   //! 2 - the computed point is out of the face.
   Standard_EXPORT static int PointNearEdge(const TopoDS_Edge&                   aE,
                                            const TopoDS_Face&                   aF,
                                            const double                         aT,
                                            const double                         aDt2D,
                                            gp_Pnt2d&                            aP2D,
                                            gp_Pnt&                              aPx,
                                            const occ::handle<IntTools_Context>& theContext);
 
   //! Compute the point <aPx>, (<aP2D>) that is near to
   //! the edge <aE> at parameter <aT> towards to the
   //! material of the face <aF>. The value of shifting in
   //! 2D is <aDt2D>. No checks on this value will be done.
   //! Returns error status:
   //! 0 - in case of success;
   //! 1 - <aE> does not have 2d curve on the face <aF>.
   Standard_EXPORT static int PointNearEdge(const TopoDS_Edge& aE,
                                            const TopoDS_Face& aF,
                                            const double       aT,
                                            const double       aDt2D,
                                            gp_Pnt2d&          aP2D,
                                            gp_Pnt&            aPx);
 
   //! Computes the point <aPx>, (<aP2D>) that is near to
   //! the edge <aE> at parameter <aT> towards to the
   //! material of the face <aF>. The value of shifting in
   //! 2D is dt2D=BOPTools_AlgoTools3D::MinStepIn2d()
   //! If the value of shifting is too big the point will be computed
   //! using Hatcher (PointInFace function).
   //! Returns error status:
   //! 0 - in case of success;
   //! 1 - <aE> does not have 2d curve on the face <aF>;
   //! 2 - the computed point is out of the face.
   Standard_EXPORT static int PointNearEdge(const TopoDS_Edge&                   aE,
                                            const TopoDS_Face&                   aF,
                                            const double                         aT,
                                            gp_Pnt2d&                            aP2D,
                                            gp_Pnt&                              aPx,
                                            const occ::handle<IntTools_Context>& theContext);
 
   //! Compute the point <aPx>, (<aP2D>) that is near to
   //! the edge <aE> at arbitrary parameter towards to the
   //! material of the face <aF>. The value of shifting in
   //! 2D is dt2D=BOPTools_AlgoTools3D::MinStepIn2d().
   //! If the value of shifting is too big the point will be computed
   //! using Hatcher (PointInFace function).
   //! Returns error status:
   //! 0 - in case of success;
   //! 1 - <aE> does not have 2d curve on the face <aF>;
   //! 2 - the computed point is out of the face.
   Standard_EXPORT static int PointNearEdge(const TopoDS_Edge&                   aE,
                                            const TopoDS_Face&                   aF,
                                            gp_Pnt2d&                            aP2D,
                                            gp_Pnt&                              aPx,
                                            const occ::handle<IntTools_Context>& theContext);
 
   //! Returns simple step value that is used in 2D-computations
   //! = 1.e-5
   Standard_EXPORT static double MinStepIn2d();
 
   //! Returns TRUE if the shape <aS> does not contain
   //! geometry information (e.g. empty compound)
   Standard_EXPORT static bool IsEmptyShape(const TopoDS_Shape& aS);
 
   //! Get the edge <aER> from the face <aF> that is the same as
   //! the edge <aE>
   Standard_EXPORT static void OrientEdgeOnFace(const TopoDS_Edge& aE,
                                                const TopoDS_Face& aF,
                                                TopoDS_Edge&       aER);
 
   //! Computes arbitrary point <theP> inside the face <theF>.
   //! <theP2D> - 2D representation of <theP>
   //! on the surface of <theF>
   //! Returns 0 in case of success.
   Standard_EXPORT static int PointInFace(const TopoDS_Face&                   theF,
                                          gp_Pnt&                              theP,
                                          gp_Pnt2d&                            theP2D,
                                          const occ::handle<IntTools_Context>& theContext);
 
   //! Computes a point <theP> inside the face <theF>
   //! using starting point taken by the parameter <theT>
   //! from the 2d curve of the edge <theE> on the face <theF>
   //! in the direction perpendicular to the tangent vector
   //! of the 2d curve of the edge.
   //! The point will be distanced on <theDt2D> from the 2d curve.
   //! <theP2D> - 2D representation of <theP>
   //! on the surface of <theF>
   //! Returns 0 in case of success.
   Standard_EXPORT static int PointInFace(const TopoDS_Face&                   theF,
                                          const TopoDS_Edge&                   theE,
                                          const double                         theT,
                                          const double                         theDt2D,
                                          gp_Pnt&                              theP,
                                          gp_Pnt2d&                            theP2D,
                                          const occ::handle<IntTools_Context>& theContext);
 
   //! Computes a point <theP> inside the face <theF>
   //! using the line <theL> so that 2D point
   //! <theP2D>, 2D representation of <theP>
   //! on the surface of <theF>, lies on that line.
   //! Returns 0 in case of success.
   Standard_EXPORT static int PointInFace(const TopoDS_Face&                   theF,
                                          const occ::handle<Geom2d_Curve>&     theL,
                                          gp_Pnt&                              theP,
                                          gp_Pnt2d&                            theP2D,
                                          const occ::handle<IntTools_Context>& theContext,
                                          const double                         theDt2D = 0.0);
 };
 
 #endif // _BOPTools_AlgoTools3D_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team