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

File indexing completed on 2026-09-21 09:17:40

 // Created on: 1999-03-03
 // Created by: Fabrice SERVANT
 // Copyright (c) 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.
 
 #ifndef _IntPolyh_MaillageAffinage_HeaderFile
 #define _IntPolyh_MaillageAffinage_HeaderFile
 
 #include <Adaptor3d_Surface.hxx>
 #include <Bnd_Box.hxx>
 #include <IntPolyh_ArrayOfPoints.hxx>
 #include <IntPolyh_ArrayOfEdges.hxx>
 #include <IntPolyh_ArrayOfTriangles.hxx>
 #include <NCollection_List.hxx>
 #include <IntPolyh_Couple.hxx>
 #include <NCollection_Array1.hxx>
 #include <IntPolyh_ArrayOfPointNormal.hxx>
 #include <IntPolyh_ArrayOfSectionLines.hxx>
 #include <IntPolyh_ArrayOfTangentZones.hxx>
 
 class IntPolyh_StartPoint;
 
 //! Low-level algorithm to compute intersection of the surfaces
 //! by computing the intersection of their triangulations.
 class IntPolyh_MaillageAffinage
 {
 public:
   DEFINE_STANDARD_ALLOC
 
   Standard_EXPORT IntPolyh_MaillageAffinage(const occ::handle<Adaptor3d_Surface>& S1,
                                             const int                             NbSU1,
                                             const int                             NbSV1,
                                             const occ::handle<Adaptor3d_Surface>& S2,
                                             const int                             NbSU2,
                                             const int                             NbSV2,
                                             const int                             PRINT);
 
   Standard_EXPORT IntPolyh_MaillageAffinage(const occ::handle<Adaptor3d_Surface>& S1,
                                             const occ::handle<Adaptor3d_Surface>& S2,
                                             const int                             PRINT);
 
   //! Makes the sampling of the surface -
   //! Fills the arrays with the parametric values of the sampling points (triangulation nodes).
   Standard_EXPORT void MakeSampling(const int                   SurfID,
                                     NCollection_Array1<double>& theUPars,
                                     NCollection_Array1<double>& theVPars);
 
   //! Computes points on one surface and fills an array of points;
   //! standard (default) method
   Standard_EXPORT void FillArrayOfPnt(const int SurfID);
 
   //! isShiftFwd flag is added. The purpose is to define shift
   //! of points along normal to the surface in this point. The
   //! shift length represents maximal deflection of triangulation.
   //! The direction (forward or reversed regarding to normal
   //! direction) is defined by isShiftFwd flag.
   //! Compute points on one surface and fill an array of points;
   //! advanced method
   Standard_EXPORT void FillArrayOfPnt(const int SurfID, const bool isShiftFwd);
 
   //! Compute points on one surface and fill an array of points;
   //! If given, <theDeflTol> is the deflection tolerance of the given sampling.
   //! standard (default) method
   Standard_EXPORT void FillArrayOfPnt(const int                         SurfID,
                                       const NCollection_Array1<double>& Upars,
                                       const NCollection_Array1<double>& Vpars,
                                       const double*                     theDeflTol = nullptr);
 
   //! isShiftFwd flag is added. The purpose is to define shift
   //! of points along normal to the surface in this point. The
   //! shift length represents maximal deflection of triangulation.
   //! The direction (forward or reversed regarding to normal
   //! direction) is defined by isShiftFwd flag.
   //! Compute points on one surface and fill an array of points;
   //! If given, <theDeflTol> is the deflection tolerance of the given sampling.
   //! advanced method
   Standard_EXPORT void FillArrayOfPnt(const int                         SurfID,
                                       const bool                        isShiftFwd,
                                       const NCollection_Array1<double>& Upars,
                                       const NCollection_Array1<double>& Vpars,
                                       const double*                     theDeflTol = nullptr);
 
   //! Fills the array of points for the surface taking into account the shift
   Standard_EXPORT void FillArrayOfPnt(const int                          SurfID,
                                       const bool                         isShiftFwd,
                                       const IntPolyh_ArrayOfPointNormal& thePoints,
                                       const NCollection_Array1<double>&  theUPars,
                                       const NCollection_Array1<double>&  theVPars,
                                       const double                       theDeflTol);
 
   //! Looks for the common box of the surfaces and marks the points
   //! of the surfaces inside that common box for possible intersection
   Standard_EXPORT void CommonBox();
 
   //! Compute the common box which is the intersection
   //! of the two bounding boxes, and mark the points of
   //! the two surfaces that are inside.
   Standard_EXPORT void CommonBox(const Bnd_Box& B1,
                                  const Bnd_Box& B2,
                                  double&        xMin,
                                  double&        yMin,
                                  double&        zMin,
                                  double&        xMax,
                                  double&        yMax,
                                  double&        zMax);
 
   //! Compute edges from the array of points
   Standard_EXPORT void FillArrayOfEdges(const int SurfID);
 
   //! Compute triangles from the array of points, and
   //! mark the triangles that use marked points by the
   //! CommonBox function.
   Standard_EXPORT void FillArrayOfTriangles(const int SurfID);
 
   //! Refine systematicaly all marked triangles of both surfaces
   Standard_EXPORT void CommonPartRefinement();
 
   //! Refine systematicaly all marked triangles of ONE surface
   Standard_EXPORT void LocalSurfaceRefinement(const int SurfId);
 
   //! Compute deflection for all triangles of one
   //! surface,and sort min and max of deflections
   Standard_EXPORT void ComputeDeflections(const int SurfID);
 
   //! Refine both surfaces using BoundSortBox as
   //! rejection. The criterions used to refine a
   //! triangle are: The deflection The size of the
   //! bounding boxes (one surface may be very small
   //! compared to the other)
   Standard_EXPORT void TrianglesDeflectionsRefinementBSB();
 
   //! This function checks if two triangles are in contact or not,
   //! return 1 if yes, return 0 if not.
   Standard_EXPORT int TriContact(const IntPolyh_Point& P1,
                                  const IntPolyh_Point& P2,
                                  const IntPolyh_Point& P3,
                                  const IntPolyh_Point& Q1,
                                  const IntPolyh_Point& Q2,
                                  const IntPolyh_Point& Q3,
                                  double&               Angle) const;
 
   Standard_EXPORT int TriangleEdgeContact(const int                TriSurfID,
                                           const int                EdgeIndice,
                                           const IntPolyh_Triangle& Tri1,
                                           const IntPolyh_Triangle& Tri2,
                                           const IntPolyh_Point&    P1,
                                           const IntPolyh_Point&    P2,
                                           const IntPolyh_Point&    P3,
                                           const IntPolyh_Point&    C1,
                                           const IntPolyh_Point&    C2,
                                           const IntPolyh_Point&    C3,
                                           const IntPolyh_Point&    Pe1,
                                           const IntPolyh_Point&    Pe2,
                                           const IntPolyh_Point&    E,
                                           const IntPolyh_Point&    N,
                                           IntPolyh_StartPoint&     SP1,
                                           IntPolyh_StartPoint&     SP2) const;
 
   //! From two triangles compute intersection points.
   //! If we found more than two intersection points
   //! that means that those triangles are coplanar
   Standard_EXPORT int StartingPointsResearch(const int            T1,
                                              const int            T2,
                                              IntPolyh_StartPoint& SP1,
                                              IntPolyh_StartPoint& SP2) const;
 
   //! from two triangles and an intersection point I
   //! search the other point (if it exists).
   //! This function is used by StartPointChain
   Standard_EXPORT int NextStartingPointsResearch(const int                  T1,
                                                  const int                  T2,
                                                  const IntPolyh_StartPoint& SPInit,
                                                  IntPolyh_StartPoint&       SPNext) const;
 
   //! Analyse each couple of triangles from the two -- array of triangles,
   //! to see if they are in contact, and compute the incidence.
   //! Then put couples in contact in the array of couples
   Standard_EXPORT int TriangleCompare();
 
   //! Loop on the array of couples. Compute StartPoints.
   //! Try to chain the StartPoints into SectionLines or
   //! put the point in the ArrayOfTangentZones if
   //! chaining it, is not possible.
   Standard_EXPORT int StartPointsChain(IntPolyh_ArrayOfSectionLines& TSectionLines,
                                        IntPolyh_ArrayOfTangentZones& TTangentZones);
 
   //! Mainly used by StartPointsChain(), this function
   //! try to compute the next StartPoint.
   Standard_EXPORT int GetNextChainStartPoint(const IntPolyh_StartPoint&    SPInit,
                                              IntPolyh_StartPoint&          SPNext,
                                              IntPolyh_SectionLine&         MySectionLine,
                                              IntPolyh_ArrayOfTangentZones& TTangentZones,
                                              const bool                    Prepend = false);
 
   Standard_EXPORT const IntPolyh_ArrayOfPoints& GetArrayOfPoints(const int SurfID) const;
 
   Standard_EXPORT const IntPolyh_ArrayOfEdges& GetArrayOfEdges(const int SurfID) const;
 
   Standard_EXPORT const IntPolyh_ArrayOfTriangles& GetArrayOfTriangles(const int SurfID) const;
 
   Standard_EXPORT int GetFinTE(const int SurfID) const;
 
   Standard_EXPORT int GetFinTT(const int SurfID) const;
 
   Standard_EXPORT Bnd_Box GetBox(const int SurfID) const;
 
   //! This method returns list of couples of contact triangles.
   Standard_EXPORT NCollection_List<IntPolyh_Couple>& GetCouples();
 
   Standard_EXPORT void SetEnlargeZone(const bool EnlargeZone);
 
   Standard_EXPORT bool GetEnlargeZone() const;
 
   //! returns FlecheMin
   Standard_EXPORT double GetMinDeflection(const int SurfID) const;
 
   //! returns FlecheMax
   Standard_EXPORT double GetMaxDeflection(const int SurfID) const;
 
 private:
   occ::handle<Adaptor3d_Surface> MaSurface1;
   occ::handle<Adaptor3d_Surface> MaSurface2;
   Bnd_Box                        MyBox1;
   Bnd_Box                        MyBox2;
   int                            NbSamplesU1;
   int                            NbSamplesU2;
   int                            NbSamplesV1;
   int                            NbSamplesV2;
   double                         FlecheMax1;
   double                         FlecheMax2;
   double                         FlecheMin1;
   double                         FlecheMin2;
   // For the arrays of Points, Edges and Triangles we need instant access to the items.
   // Moreover, we might add new items during refinement process in case the deflection
   // is too big, thus the vectors should be used.
   IntPolyh_ArrayOfPoints    TPoints1;
   IntPolyh_ArrayOfPoints    TPoints2;
   IntPolyh_ArrayOfEdges     TEdges1;
   IntPolyh_ArrayOfEdges     TEdges2;
   IntPolyh_ArrayOfTriangles TTriangles1;
   IntPolyh_ArrayOfTriangles TTriangles2;
   // The intersecting triangles are just filled and then
   // sequentially analyzed, thus we might use the list.
   NCollection_List<IntPolyh_Couple> TTrianglesContacts;
 
   bool myEnlargeZone;
 };
 
 #endif // _IntPolyh_MaillageAffinage_HeaderFile

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