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

File indexing completed on 2026-06-13 08:29:46

 // 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 BOPDS_Interf_HeaderFile
 #define BOPDS_Interf_HeaderFile
 
 #include <IntTools_CommonPrt.hxx>
 #include <NCollection_BaseAllocator.hxx>
 #include <BOPDS_VectorOfCurve.hxx>
 #include <BOPDS_VectorOfPoint.hxx>
 
 /**
  * The class BOPDS_Interf stores the information about
  * the interference between two shapes.
  * The class BOPDS_Interf is root class
  *
  */
 //=======================================================================
 // function : BOPDS_Interf
 // purpose  :
 //=======================================================================
 class BOPDS_Interf
 {
 public:
   //
   /**
    * Sets the indices of interferred shapes
    * @param theIndex1
    *   index of the first shape
    * @param theIndex2
    *   index of the second shape
    */
   void SetIndices(const Standard_Integer theIndex1, const Standard_Integer theIndex2)
   {
     myIndex1 = theIndex1;
     myIndex2 = theIndex2;
   }
 
   //
   /**
    * Returns the indices of interferred shapes
    * @param theIndex1
    *   index of the first shape
    * @param theIndex2
    *   index of the second shape
    */
   void Indices(Standard_Integer& theIndex1, Standard_Integer& theIndex2) const
   {
     theIndex1 = myIndex1;
     theIndex2 = myIndex2;
   }
 
   //
   /**
    * Sets the index of the first interferred shape
    * @param theIndex
    *   index of the first shape
    */
   void SetIndex1(const Standard_Integer theIndex) { myIndex1 = theIndex; }
 
   //
   /**
    * Sets the index of the second interferred shape
    * @param theIndex
    *   index of the second shape
    */
   void SetIndex2(const Standard_Integer theIndex) { myIndex2 = theIndex; }
 
   //
   /**
    * Returns the index of the first interferred shape
    * @return
    *   index of the first shape
    */
   Standard_Integer Index1() const { return myIndex1; }
 
   //
   /**
    * Returns the index of the second interferred shape
    * @return
    *   index of the second shape
    */
   Standard_Integer Index2() const { return myIndex2; }
 
   //
   /**
    * Returns the index of that are opposite to the given index
    * @param theI
    *   the index
    * @return
    *   index of opposite shape
    */
   Standard_Integer OppositeIndex(const Standard_Integer theI) const
   {
     if (theI == myIndex1)
     {
       return myIndex2;
     }
     else if (theI == myIndex2)
     {
       return myIndex1;
     }
     else
     {
       return -1;
     }
   }
 
   //
   /**
    * Returns true if the interference contains given index
    * @param theIndex
    *   the index
    * @return
    *   true if the interference contains given index
    */
   Standard_Boolean Contains(const Standard_Integer theIndex) const
   {
     return (myIndex1 == theIndex || myIndex2 == theIndex);
   }
 
   //
   /**
    * Sets the index of new shape
    * @param theIndex
    *   the index
    */
   void SetIndexNew(const Standard_Integer theIndex) { myIndexNew = theIndex; }
 
   //
   //
   /**
    * Returns the index of new shape
    * @return theIndex
    *   the index of new shape
    */
   Standard_Integer IndexNew() const { return myIndexNew; }
 
   //
   /**
    * Returns true if the interference has index of new shape
    * that is equal to the given index
    * @param theIndex
    *   the index
    * @return true if the interference has index of new shape
    * that is equal to the given index
    */
   Standard_Boolean HasIndexNew(Standard_Integer& theIndex) const
   {
     theIndex = myIndexNew;
     return (myIndexNew >= 0);
   }
 
   //
   /**
    * Returns true if the interference has index of new shape
    *   the index
    * @return true if the interference has index of new shape
    */
   Standard_Boolean HasIndexNew() const { return (myIndexNew + 1) != 0; }
 
   //
 protected:
   BOPDS_Interf()
       : myIndex1(-1),
         myIndex2(-1),
         myIndexNew(-1),
         myAllocator(NCollection_BaseAllocator::CommonBaseAllocator())
   {
   }
 
   //
   BOPDS_Interf(const Handle(NCollection_BaseAllocator)& theAllocator)
       : myIndex1(-1),
         myIndex2(-1),
         myIndexNew(-1),
         myAllocator(theAllocator)
   {
   }
 
   //
   virtual ~BOPDS_Interf() {}
 
 protected:
   Standard_Integer                  myIndex1;
   Standard_Integer                  myIndex2;
   Standard_Integer                  myIndexNew;
   Handle(NCollection_BaseAllocator) myAllocator;
 };
 
 /**
  * The class BOPDS_InterfVV stores the information about
  * the interference of the type vertex/vertex.
  */
 //=======================================================================
 // function : BOPDS_InterfVV
 // purpose  :
 //=======================================================================
 class BOPDS_InterfVV : public BOPDS_Interf
 {
 public:
   //
   /**
    *  Constructor
    */
   BOPDS_InterfVV()
       : BOPDS_Interf()
   {
   }
 
   //
   /**
    *  Constructor
    * @param theAllocator
    *   allocator to manage the memory
    */
   BOPDS_InterfVV(const Handle(NCollection_BaseAllocator)& theAllocator)
       : BOPDS_Interf(theAllocator)
   {
   }
 
   //
   /**
    *  Destructor
    */
   virtual ~BOPDS_InterfVV() {}
 
   //
 };
 
 /**
  * The class BOPDS_InterfVE stores the information about
  * the interference of the type vertex/edge.
  */
 //=======================================================================
 // function : BOPDS_InterfVE
 // purpose  :
 //=======================================================================
 class BOPDS_InterfVE : public BOPDS_Interf
 {
 public:
   //
   /**
    *  Constructor
    */
   BOPDS_InterfVE()
       : BOPDS_Interf(),
         myParameter(0.)
   {
   }
 
   //
   /**
    *  Constructor
    * @param theAllocator
    *   allocator to manage the memory
    */
   BOPDS_InterfVE(const Handle(NCollection_BaseAllocator)& theAllocator)
       : BOPDS_Interf(theAllocator),
         myParameter(0.)
   {
   }
 
   //
   /**
    *  Destructor
    */
   virtual ~BOPDS_InterfVE() {}
 
   //
   /**
    *  Modifier
    * Sets the value of parameter
    * of the point of the vertex
    * on the curve of the edge
    * @param theT
    *   value of parameter
    */
   void SetParameter(const Standard_Real theT) { myParameter = theT; }
 
   //
   /**
    *  Selector
    * Returrns the value of parameter
    * of the point of the vertex
    * on the curve of the edge
    * @return
    *   value of parameter
    */
   Standard_Real Parameter() const { return myParameter; }
 
 protected:
   Standard_Real myParameter;
 };
 
 /**
  * The class BOPDS_InterfVF stores the information about
  * the interference of the type vertex/face
  */
 //=======================================================================
 // function : BOPDS_InterfVF
 // purpose  :
 //=======================================================================
 class BOPDS_InterfVF : public BOPDS_Interf
 {
 public:
   //
   /**
    *  Constructor
    */
   BOPDS_InterfVF()
       : BOPDS_Interf(),
         myU(0.),
         myV(0.)
   {
   }
 
   //
   /**
    *  Constructor
    * @param theAllocator
    *   allocator to manage the memory
    */
   BOPDS_InterfVF(const Handle(NCollection_BaseAllocator)& theAllocator)
       : BOPDS_Interf(theAllocator),
         myU(0.),
         myV(0.)
   {
   }
 
   //
   /**
    *  Destructor
    */
   virtual ~BOPDS_InterfVF() {}
 
   //
   /**
    * Modifier
    * Sets the value of parameters
    * of the point of the vertex
    * on the surface of of the face
    * @param theU
    *   value of U parameter
    * @param theV
    *   value of U parameter
    */
   void SetUV(const Standard_Real theU, const Standard_Real theV)
   {
     myU = theU;
     myV = theV;
   }
 
   //
   /**
    * Selector
    * Returns the value of parameters
    * of the point of the vertex
    * on the surface of of the face
    * @param theU
    *   value of U parameter
    * @param theV
    *   value of U parameter
    */
   void UV(Standard_Real& theU, Standard_Real& theV) const
   {
     theU = myU;
     theV = myV;
   }
 
 protected:
   Standard_Real myU;
   Standard_Real myV;
 };
 
 /**
  * The class BOPDS_InterfEE stores the information about
  * the interference of the type edge/edge.
  */
 //=======================================================================
 // function : BOPDS_InterfEE
 // purpose  :
 //=======================================================================
 class BOPDS_InterfEE : public BOPDS_Interf
 {
 public:
   //
   /**
    *  Constructor
    */
   BOPDS_InterfEE()
       : BOPDS_Interf()
   {
   }
 
   //
   /**
    *  Constructor
    * @param theAllocator
    *   allocator to manage the memory
    */
   BOPDS_InterfEE(const Handle(NCollection_BaseAllocator)& theAllocator)
       : BOPDS_Interf(theAllocator)
   {
   }
 
   //
   /**
    *  Destructor
    */
   virtual ~BOPDS_InterfEE() {}
 
   //
   /**
    *  Modifier
    * Sets the info of common part
    * @param theCP
    *   common part
    */
   void SetCommonPart(const IntTools_CommonPrt& theCP) { myCommonPart = theCP; }
 
   //
   /**
    *  Selector
    * Returns the info of common part
    * @return
    *   common part
    */
   const IntTools_CommonPrt& CommonPart() const { return myCommonPart; }
 
 protected:
   IntTools_CommonPrt myCommonPart;
 };
 
 /**
  * The class BOPDS_InterfEF stores the information about
  * the interference of the type edge/face.
  */
 //=======================================================================
 // function : BOPDS_InterfEF
 // purpose  :
 //=======================================================================
 class BOPDS_InterfEF : public BOPDS_Interf
 {
 public:
   //
   /**
    *  Constructor
    */
   BOPDS_InterfEF()
       : BOPDS_Interf()
   {
   }
 
   //
   /**
    *  Constructor
    * @param theAllocator
    *   allocator to manage the memory
    */
   /**
    *  Constructor
    * @param theAllocator
    *   allocator to manage the memory
    */
   BOPDS_InterfEF(const Handle(NCollection_BaseAllocator)& theAllocator)
       : BOPDS_Interf(theAllocator)
   {
   }
 
   //
   /**
    *  Destructor
    */
   virtual ~BOPDS_InterfEF() {}
 
   //
   /**
    * Modifier
    * Sets the info of common part
    * @param theCP
    *   common part
    */
   void SetCommonPart(const IntTools_CommonPrt& theCP) { myCommonPart = theCP; }
 
   //
   /**
    *  Selector
    * Returns the info of common part
    * @return
    *   common part
    */
   const IntTools_CommonPrt& CommonPart() const { return myCommonPart; }
 
   //
 protected:
   IntTools_CommonPrt myCommonPart;
 }
 /**
  * The class BOPDS_InterfFF stores the information about
  * the interference of the type face/face.
  */
 ;
 
 //=======================================================================
 // function : BOPDS_InterfFF
 // purpose  :
 //=======================================================================
 class BOPDS_InterfFF : public BOPDS_Interf
 {
 public:
   //
   /**
    *  Constructor
    */
   BOPDS_InterfFF()
       : BOPDS_Interf(),
         myTangentFaces(Standard_False),
         myCurves(0, myAllocator),
         myPoints(0, myAllocator)
   {
   }
 
   //
   /**
    *  Destructor
    */
   virtual ~BOPDS_InterfFF() {}
 
   //
   /**
    * Initializer
    * @param theNbCurves
    *   number of intersection curves
    * @param theNbPoints
    *   number of intersection points
    */
 
   void Init(const Standard_Integer theNbCurves, const Standard_Integer theNbPoints)
   {
     if (theNbCurves > 0)
     {
       myCurves.SetIncrement(theNbCurves);
     }
     if (theNbPoints > 0)
     {
       myPoints.SetIncrement(theNbPoints);
     }
   }
 
   /**
    * Modifier
    * Sets the flag of whether the faces are tangent
    * @param theFlag
    *   the flag
    */
   void SetTangentFaces(const Standard_Boolean theFlag) { myTangentFaces = theFlag; }
 
   /**
    * Selector
    * Returns the flag whether the faces are tangent
    * @return
    *   the flag
    */
   Standard_Boolean TangentFaces() const { return myTangentFaces; }
 
   //
   /**
    * Selector
    * Returns the intersection curves
    * @return
    *   intersection curves
    */
   const BOPDS_VectorOfCurve& Curves() const { return myCurves; }
 
   //
   /**
    * Selector/Modifier
    * Returns the intersection curves
    * @return
    *   intersection curves
    */
   BOPDS_VectorOfCurve& ChangeCurves() { return myCurves; }
 
   //
   /**
    * Selector
    * Returns the intersection points
    * @return
    *   intersection points
    */
   const BOPDS_VectorOfPoint& Points() const { return myPoints; }
 
   //
   /**
    * Selector/Modifier
    * Returns the intersection points
    * @return
    *   intersection points
    */
   BOPDS_VectorOfPoint& ChangePoints() { return myPoints; }
 
   //
 protected:
   Standard_Boolean    myTangentFaces;
   BOPDS_VectorOfCurve myCurves;
   BOPDS_VectorOfPoint myPoints;
 };
 
 /**
  * The class BOPDS_InterfVZ stores the information about
  * the interference of the type vertex/solid.
  */
 //=======================================================================
 // function : BOPDS_InterfVZ
 // purpose  :
 //=======================================================================
 class BOPDS_InterfVZ : public BOPDS_Interf
 {
 public:
   //
   /**
    *  Constructor
    */
   BOPDS_InterfVZ()
       : BOPDS_Interf() {};
   //
   /**
    *  Constructor
    * @param theAllocator
    *   allocator to manage the memory
    */
   BOPDS_InterfVZ(const Handle(NCollection_BaseAllocator)& theAllocator)
       : BOPDS_Interf(theAllocator) {};
   //
   /**
    *  Destructor
    */
   virtual ~BOPDS_InterfVZ() {};
   //
 };
 
 /**
  * The class BOPDS_InterfEZ stores the information about
  * the interference of the type edge/solid.
  */
 //=======================================================================
 // function : BOPDS_InterfEZ
 // purpose  :
 //=======================================================================
 class BOPDS_InterfEZ : public BOPDS_Interf
 {
 public:
   //
   /**
    *  Constructor
    */
   BOPDS_InterfEZ()
       : BOPDS_Interf() {};
   //
   /**
    *  Constructor
    * @param theAllocator
    *   allocator to manage the memory
    */
   BOPDS_InterfEZ(const Handle(NCollection_BaseAllocator)& theAllocator)
       : BOPDS_Interf(theAllocator) {};
   //
   /**
    *  Destructor
    */
   virtual ~BOPDS_InterfEZ() {};
   //
 };
 
 /**
  * The class BOPDS_InterfFZ stores the information about
  * the interference of the type face/solid.
  */
 //=======================================================================
 // function : BOPDS_InterfFZ
 // purpose  :
 //=======================================================================
 class BOPDS_InterfFZ : public BOPDS_Interf
 {
 public:
   //
   /**
    *  Constructor
    */
   BOPDS_InterfFZ()
       : BOPDS_Interf() {};
   //
   /**
    *  Constructor
    * @param theAllocator
    *   allocator to manage the memory
    */
   BOPDS_InterfFZ(const Handle(NCollection_BaseAllocator)& theAllocator)
       : BOPDS_Interf(theAllocator) {};
   //
   /**
    *  Destructor
    */
   virtual ~BOPDS_InterfFZ() {};
   //
 };
 
 /**
  * The class BOPDS_InterfZZ stores the information about
  * the interference of the type solid/solid.
  */
 //=======================================================================
 // function : BOPDS_InterfZZ
 // purpose  :
 //=======================================================================
 class BOPDS_InterfZZ : public BOPDS_Interf
 {
 public:
   //
   /**
    *  Constructor
    */
   BOPDS_InterfZZ()
       : BOPDS_Interf() {};
   //
   /**
    *  Constructor
    * @param theAllocator
    *   allocator to manage the memory
    */
   BOPDS_InterfZZ(const Handle(NCollection_BaseAllocator)& theAllocator)
       : BOPDS_Interf(theAllocator) {};
   //
   /**
    *  Destructor
    */
   virtual ~BOPDS_InterfZZ() {};
   //
 };
 
 #endif

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