const Standard_Integer theIndex2) {
myIndex1=theIndex1;
myIndex2=theIndex2;
- };
+ }
//
/**
* Returns the indices of interferred shapes
Standard_Integer& theIndex2) const {
theIndex1=myIndex1;
theIndex2=myIndex2;
- };
+ }
//
/**
* Sets the index of the first interferred shape
*/
void SetIndex1(const Standard_Integer theIndex) {
myIndex1=theIndex;
- };
+ }
//
/**
* Sets the index of the second interferred shape
*/
void SetIndex2(const Standard_Integer theIndex) {
myIndex2=theIndex;
- };
+ }
//
/**
* Returns the index of the first interferred shape
*/
Standard_Integer Index1() const {
return myIndex1;
- };
+ }
//
/**
* Returns the index of the second interferred shape
*/
Standard_Integer Index2() const {
return myIndex2;
- };
+ }
//
/**
* Returns the index of that are opposite to the given index
else {
return -1;
}
- };
+ }
//
/**
* Returns true if the interference contains given index
*/
void SetIndexNew(const Standard_Integer theIndex) {
myIndexNew=theIndex;
- };
+ }
//
//
/**
*/
Standard_Integer IndexNew() const {
return myIndexNew;
- };
+ }
//
/**
* Returns true if the interference has index of new shape
Standard_Boolean HasIndexNew(Standard_Integer& theIndex) const {
theIndex=myIndexNew;
return (myIndexNew>=0);
- };
+ }
//
/**
* Returns true if the interference has index of new shape
*/
Standard_Boolean HasIndexNew() const {
return (myIndexNew>=0);
- };
+ }
//
protected:
BOPDS_Interf() :
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;
* Constructor
*/
BOPDS_InterfVV() : BOPDS_Interf() {
- };
+ }
//
/**
* Constructor
*/
BOPDS_InterfVV(const Handle(NCollection_BaseAllocator)& theAllocator)
: BOPDS_Interf(theAllocator) {
- };
+ }
//
/**
* Destructor
*/
virtual ~BOPDS_InterfVV() {
- };
+ }
//
};
/**
:
BOPDS_Interf(),
myParameter(0.) {
- };
+ }
//
/**
* Constructor
:
BOPDS_Interf(theAllocator),
myParameter(0.) {
- };
+ }
//
/**
* Destructor
*/
virtual ~BOPDS_InterfVE() {
- };
+ }
//
/**
* Modifier
*/
void SetParameter(const Standard_Real theT) {
myParameter=theT;
- };
+ }
//
/**
* Selector
*/
Standard_Real Parameter() const {
return myParameter;
- };
+ }
protected:
Standard_Real myParameter;
: BOPDS_Interf(),
myU(0.),
myV(0.) {
- };
+ }
//
/**
* Constructor
: BOPDS_Interf(theAllocator),
myU(0.),
myV(0.) {
- };
+ }
//
/**
* Destructor
*/
virtual ~BOPDS_InterfVF() {
- };
+ }
//
/**
* Modifier
const Standard_Real theV) {
myU=theU;
myV=theV;
- };
+ }
//
/**
* Selector
void UV(Standard_Real& theU,Standard_Real& theV) const {
theU=myU;
theV=myV;
- };
+ }
protected:
Standard_Real myU;
* Constructor
*/
BOPDS_InterfEE() : BOPDS_Interf() {
- };
+ }
//
/**
* Constructor
*/
BOPDS_InterfEE(const Handle(NCollection_BaseAllocator)& theAllocator)
: BOPDS_Interf(theAllocator) {
- };
+ }
//
/**
* Destructor
*/
virtual ~BOPDS_InterfEE() {
- };
+ }
//
/**
* Modifier
*/
void SetCommonPart(const IntTools_CommonPrt& theCP) {
myCommonPart=theCP;
- };
+ }
//
/**
* Selector
*/
const IntTools_CommonPrt& CommonPart() const {
return myCommonPart;
- };
+ }
protected:
IntTools_CommonPrt myCommonPart;
* Constructor
*/
BOPDS_InterfEF(): BOPDS_Interf() {
- };
+ }
//
/**
* Constructor
*/
BOPDS_InterfEF(const Handle(NCollection_BaseAllocator)& theAllocator)
: BOPDS_Interf(theAllocator) {
- };
+ }
//
/**
* Destructor
*/
virtual ~BOPDS_InterfEF() {
- };
+ }
//
/**
* Modifier
*/
void SetCommonPart(const IntTools_CommonPrt& theCP){
myCommonPart=theCP;
- };
+ }
//
/**
* Selector
*/
const IntTools_CommonPrt& CommonPart() const {
return myCommonPart;
- };
+ }
//
protected:
IntTools_CommonPrt myCommonPart;
myTolR2D(1.e-7),
myCurves(myAllocator),
myPoints(myAllocator) {
- };
+ }
//
/**
* Constructor
myTolR2D(1.e-7),
myCurves(myAllocator),
myPoints(myAllocator) {
- };
+ }
*/
//
/**
* Destructor
*/
virtual ~BOPDS_InterfFF() {
- };
+ }
//
/**
* Initializer
*/
const BOPDS_VectorOfCurve& Curves()const{
return myCurves;
- };
+ }
//
/**
* Selector/Modifier
*/
BOPDS_VectorOfCurve& ChangeCurves(){
return myCurves;
- };
+ }
//
/**
* Selector
*/
const BOPDS_VectorOfPoint& Points()const{
return myPoints;
- };
+ }
//
/**
* Selector/Modifier
*/
BOPDS_VectorOfPoint& ChangePoints(){
return myPoints;
- };
+ }
//
protected:
Standard_Boolean myTangentFaces;
BOPDS_VectorOfPoint myPoints;
};
+/**
+ * The class BOPDS_InterfVZ is is to store 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 is is to store 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 is is to store 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 is is to store 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