0024624: Lost word in license statement in source files
[occt.git] / src / BOPDS / BOPDS_Interf.hxx
1 // Created by: Peter KURNEV
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #ifndef BOPDS_Interf_HeaderFile
16 #define BOPDS_Interf_HeaderFile
17
18 #ifndef _Standard_HeaderFile
19 #include <Standard.hxx>
20 #endif
21 #ifndef _Standard_Macro_HeaderFile
22 #include <Standard_Macro.hxx>
23 #endif
24
25 #ifndef _Standard_Integer_HeaderFile
26 #include <Standard_Integer.hxx>
27 #endif
28
29 #ifndef _IntTools_CommonPrt_HeaderFile
30 #include <IntTools_CommonPrt.hxx>
31 #endif
32
33 #include <NCollection_BaseAllocator.hxx>
34 #include <BOPDS_VectorOfCurve.hxx>
35 #include <BOPDS_VectorOfPoint.hxx>
36 /**
37  * The class BOPDS_Interf is is to store the information about
38  * the interference between two shapes. 
39  * The class BOPDS_Interf is root class 
40  *
41 */
42 //=======================================================================
43 //function : BOPDS_Interf
44 //purpose  : 
45 //=======================================================================
46 class BOPDS_Interf  {
47  public:
48   //
49   /**
50    * Sets the indices of interferred shapes
51    * @param theIndex1
52    *   index of the first shape
53    * @param theIndex2
54    *   index of the second shape
55    */
56   void SetIndices(const Standard_Integer theIndex1,
57                   const Standard_Integer theIndex2) {
58     myIndex1=theIndex1; 
59     myIndex2=theIndex2; 
60   }
61   //
62   /**
63    * Returns the indices of interferred shapes
64    * @param theIndex1
65    *   index of the first shape
66    * @param theIndex2
67    *   index of the second shape
68    */
69   void Indices(Standard_Integer& theIndex1,
70                Standard_Integer& theIndex2) const {
71                  theIndex1=myIndex1; 
72                  theIndex2=myIndex2; 
73                }
74   //
75   /**
76    * Sets the index of the first interferred shape
77    * @param theIndex
78    *   index of the first shape 
79    */
80   void SetIndex1(const Standard_Integer theIndex) {
81     myIndex1=theIndex; 
82   }
83   //
84   /**
85    * Sets the index of the second interferred shape
86    * @param theIndex
87    *   index of the second shape 
88    */
89   void SetIndex2(const Standard_Integer theIndex) {
90     myIndex2=theIndex;
91   }
92   //
93   /**
94    * Returns the index of the first interferred shape
95    * @return
96    *   index of the first shape 
97    */
98   Standard_Integer Index1() const {
99     return myIndex1; 
100   }
101   //
102   /**
103    * Returns the index of the second interferred shape
104    * @return
105    *   index of the second shape 
106    */
107   Standard_Integer Index2() const {
108     return myIndex2; 
109   }
110   //
111   /**
112    * Returns the index of that are opposite to the given index
113    * @param theI
114    *   the index
115    * @return
116    *   index of opposite shape 
117    */
118   Standard_Integer OppositeIndex(const Standard_Integer theI) const {
119     if (theI==myIndex1) {
120       return myIndex2;
121     }
122     else if(theI==myIndex2) {
123       return myIndex1;
124     }
125     else {
126       return -1;
127     }
128   }
129   //
130   /**
131    * Returns true if the interference contains given index
132    * @param theIndex 
133    *   the index
134    * @return
135    *   true if the interference contains given index
136    */
137   Standard_Boolean Contains(const Standard_Integer theIndex)const {
138     return (myIndex1==theIndex || myIndex2==theIndex);
139   }
140   //
141   /**
142    * Sets the index of new shape 
143    * @param theIndex 
144    *   the index
145    */
146   void SetIndexNew(const Standard_Integer theIndex) {
147     myIndexNew=theIndex;
148   }
149   //
150   //
151   /**
152    * Returns the index of new shape 
153    * @return theIndex 
154    *   the index of new shape 
155    */
156   Standard_Integer IndexNew() const {
157     return myIndexNew; 
158   }
159   //
160   /**
161    * Returns true if the interference has index of new shape
162    * that is equal to the given index 
163    * @param theIndex 
164    *   the index
165    * @return true if the interference has index of new shape
166    * that is equal to the given index 
167    */
168   Standard_Boolean HasIndexNew(Standard_Integer& theIndex) const {
169     theIndex=myIndexNew;
170     return (myIndexNew>=0);
171   }
172   //
173   /**
174    * Returns true if the interference has index of new shape
175    *   the index
176    * @return true if the interference has index of new shape
177    */
178   Standard_Boolean HasIndexNew() const {
179     return (myIndexNew>=0);
180   }
181   //
182  protected:     
183   BOPDS_Interf() :
184     myIndex1(-1), 
185     myIndex2(-1),
186     myIndexNew(-1),
187     myAllocator(NCollection_BaseAllocator::CommonBaseAllocator()) {
188   }
189   //
190   BOPDS_Interf(const Handle(NCollection_BaseAllocator)& theAllocator) :
191     myIndex1(-1), 
192     myIndex2(-1),
193     myIndexNew(-1),
194     myAllocator(theAllocator) {
195   }
196   //
197   virtual ~BOPDS_Interf() {
198   }
199   
200  protected:     
201   Standard_Integer myIndex1;
202   Standard_Integer myIndex2;
203   Standard_Integer myIndexNew;
204   Handle(NCollection_BaseAllocator) myAllocator;
205 };
206 /**
207  * The class BOPDS_InterfVV is is to store the information about
208  * the interference of the type vertex/vertex. 
209 */
210 //=======================================================================
211 //function : BOPDS_InterfVV
212 //purpose  : 
213 //=======================================================================
214 class BOPDS_InterfVV  : public BOPDS_Interf {
215  public:
216   //
217   /**
218    *  Constructor
219    */
220   BOPDS_InterfVV() : BOPDS_Interf() {
221   }
222   //
223   /**
224    *  Constructor
225    * @param theAllocator
226    *   allocator to manage the memory
227    */
228   BOPDS_InterfVV(const Handle(NCollection_BaseAllocator)& theAllocator) 
229     : BOPDS_Interf(theAllocator) {
230   }
231   //
232   /**
233    *  Destructor
234    */
235   virtual ~BOPDS_InterfVV() {
236   }
237   //
238 };
239 /**
240  * The class BOPDS_InterfVE is is to store the information about
241  * the interference of the type vertex/edge. 
242 */
243 //=======================================================================
244 //function : BOPDS_InterfVE
245 //purpose  : 
246 //=======================================================================
247 class BOPDS_InterfVE  : public BOPDS_Interf {
248  public:
249   //
250   /**
251    *  Constructor
252    */
253   BOPDS_InterfVE() 
254     :
255       BOPDS_Interf(),
256       myParameter(0.) {
257   }
258   //
259   /**
260    *  Constructor
261    * @param theAllocator
262    *   allocator to manage the memory
263    */
264   BOPDS_InterfVE(const Handle(NCollection_BaseAllocator)& theAllocator) 
265     :
266       BOPDS_Interf(theAllocator),
267       myParameter(0.) {
268   }
269   //
270   /**
271    *  Destructor
272    */
273   virtual ~BOPDS_InterfVE() {
274   }
275   //
276   /**
277    *  Modifier
278    * Sets the value of parameter 
279    * of the point of the vertex 
280    * on the curve of the edge
281    * @param theT
282    *   value of parameter 
283    */
284   void SetParameter(const Standard_Real theT) {
285     myParameter=theT;
286   }
287   //
288   /**
289    *  Selector
290    * Returrns the value of parameter 
291    * of the point of the vertex 
292    * on the curve of the edge
293    * @return
294    *   value of parameter 
295    */
296   Standard_Real Parameter() const {
297     return myParameter;
298   }
299   
300  protected:
301   Standard_Real myParameter;
302   
303 };
304 /**
305  * The class BOPDS_InterfVF is is to store the information about
306  * the interference of the type vertex/face 
307 */
308 //=======================================================================
309 //function : BOPDS_InterfVF
310 //purpose  : 
311 //=======================================================================
312 class BOPDS_InterfVF  : public BOPDS_Interf {
313  public:
314   //
315   /**
316    *  Constructor
317    */
318   BOPDS_InterfVF()
319     : BOPDS_Interf(),
320       myU(0.),
321       myV(0.) {
322   }
323   //
324   /**
325    *  Constructor
326    * @param theAllocator
327    *   allocator to manage the memory
328    */
329   BOPDS_InterfVF(const Handle(NCollection_BaseAllocator)& theAllocator)
330     : BOPDS_Interf(theAllocator),
331       myU(0.),
332       myV(0.) {
333   }
334   //
335   /**
336    *  Destructor
337    */  
338   virtual ~BOPDS_InterfVF() {
339   }
340   //
341   /**
342    * Modifier
343    * Sets the value of parameters 
344    * of the point of the vertex 
345    * on the surface of of the face
346    * @param theU
347    *   value of U parameter
348    * @param theV 
349    *   value of U parameter 
350    */
351   void SetUV(const Standard_Real theU,
352              const Standard_Real theV) {
353     myU=theU;
354     myV=theV;
355   }
356   //
357   /**
358    * Selector
359    * Returns the value of parameters 
360    * of the point of the vertex 
361    * on the surface of of the face
362    * @param theU
363    *   value of U parameter
364    * @param theV 
365    *   value of U parameter 
366    */
367   void UV(Standard_Real& theU,Standard_Real& theV) const {
368     theU=myU;
369     theV=myV;
370   }
371   
372  protected:
373   Standard_Real myU;
374   Standard_Real myV;
375       
376 };
377 /**
378  * The class BOPDS_InterfEE is is to store the information about
379  * the interference of the type edge/edge. 
380 */
381 //=======================================================================
382 //function : BOPDS_InterfEE
383 //purpose  : 
384 //=======================================================================
385 class BOPDS_InterfEE  : public BOPDS_Interf {
386  public:
387   //
388   /**
389    *  Constructor
390    */
391   BOPDS_InterfEE() : BOPDS_Interf() {
392   }
393   //
394   /**
395    *  Constructor
396    * @param theAllocator
397    *   allocator to manage the memory
398    */
399   BOPDS_InterfEE(const Handle(NCollection_BaseAllocator)& theAllocator)
400     : BOPDS_Interf(theAllocator) {
401   }
402   //
403   /**
404    *  Destructor
405    */
406   virtual ~BOPDS_InterfEE() {
407   }
408   //
409   /**
410    *  Modifier
411    * Sets the info of common part 
412    * @param theCP
413    *   common part
414    */
415   void SetCommonPart(const IntTools_CommonPrt& theCP) {
416     myCommonPart=theCP;
417   }
418   //
419   /**
420    *  Selector
421    * Returns the info of common part 
422    * @return
423    *   common part
424    */
425   const IntTools_CommonPrt& CommonPart() const {
426     return myCommonPart;
427   }
428   
429  protected:
430   IntTools_CommonPrt myCommonPart;
431 };
432 /**
433  * The class BOPDS_InterfEF is is to store the information about
434  * the interference of the type edge/face. 
435 */
436 //=======================================================================
437 //function : BOPDS_InterfEF
438 //purpose  : 
439 //=======================================================================
440 class BOPDS_InterfEF  : public BOPDS_Interf {
441  public:
442   //
443   /**
444    *  Constructor
445    */
446   BOPDS_InterfEF(): BOPDS_Interf() {
447   }
448   //
449   /**
450    *  Constructor
451    * @param theAllocator
452    *   allocator to manage the memory
453    */
454   /**
455    *  Constructor
456    * @param theAllocator
457    *   allocator to manage the memory
458    */
459   BOPDS_InterfEF(const Handle(NCollection_BaseAllocator)& theAllocator)
460     : BOPDS_Interf(theAllocator) {
461   }
462   //
463   /**
464    *  Destructor
465    */
466   virtual ~BOPDS_InterfEF() {
467   }
468   //
469   /**
470    * Modifier
471    * Sets the info of common part 
472    * @param theCP
473    *   common part
474    */
475   void SetCommonPart(const IntTools_CommonPrt& theCP){
476     myCommonPart=theCP;
477   }
478   //
479   /**
480    *  Selector
481    * Returns the info of common part 
482    * @return
483    *   common part
484    */
485   const IntTools_CommonPrt& CommonPart() const {
486     return myCommonPart;
487   }
488   //
489  protected:
490   IntTools_CommonPrt myCommonPart;
491 }
492 /**
493  * The class BOPDS_InterfFF is is to store the information about
494  * the interference of the type face/face. 
495 */;
496 //=======================================================================
497 //function : BOPDS_InterfFF
498 //purpose  : 
499 //=======================================================================
500 class BOPDS_InterfFF  : public BOPDS_Interf {
501  public:
502   //
503   /**
504    *  Constructor
505    */
506   BOPDS_InterfFF()
507     : 
508       BOPDS_Interf(),
509       myTangentFaces(Standard_False),
510       myTolR3D(1.e-7),
511       myTolR2D(1.e-7),
512       myCurves(myAllocator),
513       myPoints(myAllocator) {
514   }
515   //
516   /**
517    *  Constructor
518    * @param theAllocator
519    *   allocator to manage the memory
520    */
521   /*
522   BOPDS_InterfFF(const Handle(NCollection_BaseAllocator)& theAllocator)
523     : 
524       BOPDS_Interf(theAllocator),
525       myTangentFaces(Standard_False),
526       myTolR3D(1.e-7),
527       myTolR2D(1.e-7),
528       myCurves(myAllocator),
529       myPoints(myAllocator) {
530   }
531   */
532   //
533   /**
534    *  Destructor
535    */
536   virtual ~BOPDS_InterfFF() {
537   }
538   //
539   /**
540    * Initializer
541    * @param theNbCurves
542    *   number of intersection curves
543    * @param theNbPoints
544    *   number of intersection points
545    */
546   void Init(const Standard_Integer theNbCurves,
547             const Standard_Integer theNbPoints) {
548     if (theNbCurves>0) {
549       myCurves.SetStartSize(theNbCurves);
550       myCurves.SetIncrement(theNbCurves);
551       myCurves.Init();
552     }
553     if (theNbPoints>0) {
554       myPoints.SetStartSize(theNbPoints);
555       myPoints.SetIncrement(theNbPoints);
556       myPoints.Init();
557     }
558   }
559   /**
560    * Modifier
561    * Sets the flag of whether the faces are tangent  
562    * @param theFlag
563    *   the flag 
564    */
565   void SetTangentFaces(const Standard_Boolean theFlag) {
566      myTangentFaces=theFlag;
567   }
568   /**
569    * Selector
570    * Returns the flag whether the faces are tangent  
571    * @return
572    *   the flag 
573    */
574   Standard_Boolean TangentFaces()const {
575     return myTangentFaces;
576   }
577   /**
578    * Modifier
579    * Sets the value of 3D tolerance  
580    * @param theTol
581    *   3D tolerance
582    */
583   void SetTolR3D(const Standard_Real theTol) {
584      myTolR3D=theTol;
585   }
586   //
587   /**
588    * Selector
589    * Returns the value of 3D tolerance  
590    * @return
591    *   3D tolerance
592    */
593   Standard_Real TolR3D()const {
594     return myTolR3D;
595   }
596   //
597   /**
598    * Modifier
599    * Sets the value of 2D tolerance  
600    * @param theTol
601    *   2D tolerance
602    */
603   void SetTolR2D(const Standard_Real theTol) {
604      myTolR2D=theTol;;
605   }
606   //
607   /**
608    * Selector 
609    * Returns the value of 2D tolerance  
610    * @return
611    *   2D tolerance
612    */
613   Standard_Real TolR2D()const {
614     return myTolR2D;
615   }
616   //
617   /**
618    * Selector
619    * Returns the intersection curves  
620    * @return
621    *   intersection curves 
622    */
623   const BOPDS_VectorOfCurve& Curves()const{
624     return myCurves;
625   }
626   //
627   /**
628    * Selector/Modifier
629    * Returns the intersection curves  
630    * @return
631    *   intersection curves 
632    */
633   BOPDS_VectorOfCurve& ChangeCurves(){
634     return myCurves;
635   }
636   //
637   /**
638    * Selector
639    * Returns the intersection points  
640    * @return
641    *   intersection points
642    */
643   const BOPDS_VectorOfPoint& Points()const{
644     return myPoints;
645   }
646   //
647   /**
648    * Selector/Modifier
649    * Returns the intersection points  
650    * @return
651    *   intersection points
652    */
653   BOPDS_VectorOfPoint& ChangePoints(){
654     return myPoints;
655   }
656   //
657  protected:
658   Standard_Boolean myTangentFaces;
659   Standard_Real myTolR3D;
660   Standard_Real myTolR2D;
661   BOPDS_VectorOfCurve myCurves;
662   BOPDS_VectorOfPoint myPoints;
663 };
664
665 /**
666  * The class BOPDS_InterfVZ is is to store the information about
667  * the interference of the type vertex/solid. 
668 */
669 //=======================================================================
670 //function : BOPDS_InterfVZ
671 //purpose  : 
672 //=======================================================================
673 class BOPDS_InterfVZ  : public BOPDS_Interf {
674  public:
675   //
676   /**
677    *  Constructor
678    */
679   BOPDS_InterfVZ() : BOPDS_Interf() {
680   };
681   //
682   /**
683    *  Constructor
684    * @param theAllocator
685    *   allocator to manage the memory
686    */
687   BOPDS_InterfVZ(const Handle(NCollection_BaseAllocator)& theAllocator) 
688     : BOPDS_Interf(theAllocator) {
689   };
690   //
691   /**
692    *  Destructor
693    */
694   virtual ~BOPDS_InterfVZ() {
695   };
696   //
697 };
698 /**
699  * The class BOPDS_InterfEZ is is to store the information about
700  * the interference of the type edge/solid. 
701 */
702 //=======================================================================
703 //function : BOPDS_InterfEZ
704 //purpose  : 
705 //=======================================================================
706 class BOPDS_InterfEZ  : public BOPDS_Interf {
707  public:
708   //
709   /**
710    *  Constructor
711    */
712   BOPDS_InterfEZ() : BOPDS_Interf() {
713   };
714   //
715   /**
716    *  Constructor
717    * @param theAllocator
718    *   allocator to manage the memory
719    */
720   BOPDS_InterfEZ(const Handle(NCollection_BaseAllocator)& theAllocator) 
721     : BOPDS_Interf(theAllocator) {
722   };
723   //
724   /**
725    *  Destructor
726    */
727   virtual ~BOPDS_InterfEZ() {
728   };
729   //
730 };
731 /**
732  * The class BOPDS_InterfFZ is is to store the information about
733  * the interference of the type face/solid. 
734 */
735 //=======================================================================
736 //function : BOPDS_InterfFZ
737 //purpose  : 
738 //=======================================================================
739 class BOPDS_InterfFZ  : public BOPDS_Interf {
740  public:
741   //
742   /**
743    *  Constructor
744    */
745   BOPDS_InterfFZ() : BOPDS_Interf() {
746   };
747   //
748   /**
749    *  Constructor
750    * @param theAllocator
751    *   allocator to manage the memory
752    */
753   BOPDS_InterfFZ(const Handle(NCollection_BaseAllocator)& theAllocator) 
754     : BOPDS_Interf(theAllocator) {
755   };
756   //
757   /**
758    *  Destructor
759    */
760   virtual ~BOPDS_InterfFZ() {
761   };
762   //
763 };
764 /**
765  * The class BOPDS_InterfZZ is is to store the information about
766  * the interference of the type solid/solid. 
767 */
768 //=======================================================================
769 //function : BOPDS_InterfZZ
770 //purpose  : 
771 //=======================================================================
772 class BOPDS_InterfZZ  : public BOPDS_Interf {
773  public:
774   //
775   /**
776    *  Constructor
777    */
778   BOPDS_InterfZZ() : BOPDS_Interf() {
779   };
780   //
781   /**
782    *  Constructor
783    * @param theAllocator
784    *   allocator to manage the memory
785    */
786   BOPDS_InterfZZ(const Handle(NCollection_BaseAllocator)& theAllocator) 
787     : BOPDS_Interf(theAllocator) {
788   };
789   //
790   /**
791    *  Destructor
792    */
793   virtual ~BOPDS_InterfZZ() {
794   };
795   //
796 };
797
798 #endif