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 2025-01-18 10:03:04

 // 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