OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-04 13:13:25 +03:00
Code Activity

0022550: Fixing data races

Browse Source
This commit is contained in:
KGV
2012-01-27 14:12:59 +00:00
committed by bugmaster
parent 46921bd5c8
commit 41194117bf
62 changed files with 1170 additions and 1274 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/Intf/Intf_Interference.cxx
View File

@@ -12,8 +12,6 @@
//purpose : Initialize for a deferred interference.
//=======================================================================
static Standard_Integer debug=0;
Intf_Interference::Intf_Interference (const Standard_Boolean Self)
: SelfIntf(Self)
{}
@@ -114,21 +112,9 @@ Standard_Boolean Intf_Interference::Insert(const Intf_TangentZone& LaZone)
Standard_Integer npcz=-1; // Number of points in the current zone
Standard_Integer nplz=LaZone.NumberOfPoints(); // in the new zone
if (debug>0) {
cout << "Zone of insertion : \n";
LaZone.Dump(2);
cout << endl;
}
// Loop on TangentZone :
for (Standard_Integer Iz=1; Iz<=myTZones.Length(); Iz++) {
if (debug>0) {
cout << "Zone : "<< Iz << "\n";
myTZones(Iz).Dump(2);
cout << endl;
}
// Loop on edges of the TangentZone :
npcz=myTZones(Iz).NumberOfPoints();
Standard_Integer Ipz0, Ipz1, Ipz2;
@@ -201,13 +187,6 @@ Standard_Boolean Intf_Interference::Insert(const Intf_TangentZone& LaZone)
Inserted =Standard_False;
}
if (debug>0) {
if (Inserted) {
cout << "Zone agrandie : "<< lzin <<" \n";
myTZones(lzin).Dump(2);
cout << endl;
}
}
if (Inserted) {
Intf_TangentZone theNew=myTZones(lzin);
myTZones.Remove(lzin);

6
src/Intf/Intf_InterferencePolygon2d.cdl
View File

@@ -86,4 +86,10 @@ is
---Purpose: Computes the intersection between two segments
-- <BegO><EndO> et <BegT><EndT>.
fields
oClos, tClos : Boolean from Standard;
iObje1, iObje2, nbso : Integer from Standard;
BeginOfNotClosedObje1: Boolean from Standard;
BeginOfNotClosedObje2: Boolean from Standard;
end InterferencePolygon2d;

45
src/Intf/Intf_InterferencePolygon2d.gxx
View File

@@ -12,11 +12,12 @@
#include <Precision.hxx>
#include <TColStd_ListOfInteger.hxx>
static Standard_Integer debug=0;
// Angular precision (sinus) below that value two right segments
// are considered as having a potential zone of tangency.
static Standard_Real PRCANG=Precision::Angular();
namespace
{
static const Standard_Real PRCANG = Precision::Angular();
};
//=======================================================================
//function : Intf_InterferencePolygon2d
@@ -24,7 +25,14 @@ static Standard_Real PRCANG=Precision::Angular();
//=======================================================================
Intf_InterferencePolygon2d::Intf_InterferencePolygon2d()
: Intf_Interference(Standard_False)
: Intf_Interference (Standard_False),
oClos (Standard_False),
tClos (Standard_False),
iObje1 (0),
iObje2 (0),
nbso (0),
BeginOfNotClosedObje1 (Standard_False),
BeginOfNotClosedObje2 (Standard_False)
{}
//=======================================================================
@@ -32,12 +40,16 @@ Intf_InterferencePolygon2d::Intf_InterferencePolygon2d()
//purpose : Constructor of the interference beetween two Polygon.
//=======================================================================
static Standard_Boolean oClos, tClos;
static Standard_Integer iObje1, iObje2, nbso;
Intf_InterferencePolygon2d::Intf_InterferencePolygon2d
(const Polygon2d1& Obje1, const Polygon2d2& Obje2)
: Intf_Interference(Standard_False)
: Intf_Interference (Standard_False),
oClos (Standard_False),
tClos (Standard_False),
iObje1 (0),
iObje2 (0),
nbso (0),
BeginOfNotClosedObje1 (Standard_False),
BeginOfNotClosedObje2 (Standard_False)
{
if (!ToolPolygon2d1::Bounding(Obje1).IsOut
(ToolPolygon2d2::Bounding(Obje2))) {
@@ -61,7 +73,14 @@ Intf_InterferencePolygon2d::Intf_InterferencePolygon2d
Intf_InterferencePolygon2d::Intf_InterferencePolygon2d
(const Polygon2d1& Obje)
: Intf_Interference(Standard_True)
: Intf_Interference (Standard_True),
oClos (Standard_False),
tClos (Standard_False),
iObje1 (0),
iObje2 (0),
nbso (0),
BeginOfNotClosedObje1 (Standard_False),
BeginOfNotClosedObje2 (Standard_False)
{
Tolerance=ToolPolygon2d1::DeflectionOverEstimation(Obje)*2;
if (Tolerance==0.)
@@ -129,8 +148,6 @@ gp_Pnt2d Intf_InterferencePolygon2d::Pnt2dValue
//function : Interference
//purpose :
//=======================================================================
static Standard_Boolean BeginOfNotClosedObje1;
static Standard_Boolean BeginOfNotClosedObje2;
void Intf_InterferencePolygon2d::Interference
(const Polygon2d1& Obje1,
@@ -234,12 +251,6 @@ void Intf_InterferencePolygon2d::Clean()
if (delta1<1. && delta2<1.) Only1Seg=Standard_True;
if (delta1==0. || delta2==0.) Only1Seg=Standard_True;
if (debug==1) {
cout<<"\n tz("<<ltz<<") Avant retrait First("<<pr1mi<<","<<pr1ma<<") "
<<"Second("<<pr2mi<<","<<pr2ma<<")\n";
myTZones(ltz-decal).Dump(2);
}
for (lpi=1; lpi<=myTZones(ltz-decal).NumberOfPoints(); lpi++) {
if (PI1.Incidence()<=PRCANG) {tsp=tsps=0;break;}
PI1.InfoFirst(dim1,addr1,par);

8
src/Intf/Intf_InterferencePolygon3d.cdl
View File

@@ -129,7 +129,11 @@ is
-- <BegT><EndT> and points <BegO>,<EndO>.
fields IndexMin : Integer from Standard;
MinimalDist : Real from Standard;
fields IndexMin : Integer from Standard;
MinimalDist : Real from Standard;
iObje1, iObje2 : Integer from Standard;
beginOfNotClosedFirst: Boolean from Standard;
beginOfNotClosedSecon: Boolean from Standard;
end InterferencePolygon3d;

26
src/Intf/Intf_InterferencePolygon3d.gxx
View File

@@ -18,7 +18,12 @@
//=======================================================================
Intf_InterferencePolygon3d::Intf_InterferencePolygon3d()
: Intf_Interference(Standard_False), IndexMin(0)
: Intf_Interference (Standard_False),
IndexMin (0),
iObje1 (0),
iObje2 (0),
beginOfNotClosedFirst (Standard_True),
beginOfNotClosedSecon (Standard_True)
{}
//=======================================================================
@@ -26,11 +31,14 @@ Intf_InterferencePolygon3d::Intf_InterferencePolygon3d()
//purpose : Constructor of the interference beetween two Polygon.
//=======================================================================
static Standard_Integer iObje1, iObje2;
Intf_InterferencePolygon3d::Intf_InterferencePolygon3d
(const Polygon3d1& Obje1, const Polygon3d2& Obje2)
: Intf_Interference(Standard_False), IndexMin(0)
: Intf_Interference (Standard_False),
IndexMin (0),
iObje1 (0),
iObje2 (0),
beginOfNotClosedFirst (Standard_True),
beginOfNotClosedSecon (Standard_True)
{
Tolerance=ToolPolygon3d1::DeflectionOverEstimation(Obje1)+
ToolPolygon3d2::DeflectionOverEstimation(Obje2);
@@ -46,7 +54,12 @@ Intf_InterferencePolygon3d::Intf_InterferencePolygon3d
Intf_InterferencePolygon3d::Intf_InterferencePolygon3d
(const Polygon3d1& Obje)
: Intf_Interference(Standard_True), IndexMin(0)
: Intf_Interference (Standard_True),
IndexMin(0),
iObje1 (0),
iObje2 (0),
beginOfNotClosedFirst (Standard_True),
beginOfNotClosedSecon (Standard_True)
{
Tolerance=ToolPolygon3d1::DeflectionOverEstimation(Obje)*2;
Interference(Obje);
@@ -139,9 +152,6 @@ Standard_Integer Intf_InterferencePolygon3d::MinimalResult () const
//purpose :
//=======================================================================
static Standard_Boolean beginOfNotClosedFirst=Standard_True;
static Standard_Boolean beginOfNotClosedSecon=Standard_True;
void Intf_InterferencePolygon3d::Interference
(const Polygon3d1& Obje1,
const Polygon3d2& Obje2)

4
src/Intf/Intf_InterferencePolygonPolyhedron.cdl
View File

@@ -170,4 +170,8 @@ is
---Purpose: Computes the intersection between the segment <BegO><EndO>
-- and the triangle <TTri> of <thePolyh>.
fields
BeginOfClosedPolygon: Boolean from Standard;
iLin : Integer from Standard;
end InterferencePolygonPolyhedron;

108
src/Intf/Intf_InterferencePolygonPolyhedron.gxx
View File

@@ -17,22 +17,11 @@
#include <Intf_SeqOfTangentZone.hxx>
#include <Intf.hxx>
#ifdef DEB
static Standard_Integer debug=0;
#endif
#if 0
static Standard_Real PRCANG=0.1;
#endif
//#ifndef DEB
static int Pourcent3[4]={0,1,2,0};
//#else
//static Pourcent3[4]={0,1,2,0};
//#endif
#include <Extrema_ExtElC.hxx>
#include <Extrema_POnCurv.hxx>
static const int Pourcent3[4] = {0, 1, 2, 0};
static Standard_Boolean IsInSegment(const gp_Vec& P1P2,
const gp_Vec& P1P,
const Standard_Real NP1P2,
@@ -57,7 +46,9 @@ static Standard_Boolean IsInSegment(const gp_Vec& P1P2,
//=======================================================================
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron()
: Intf_Interference(Standard_False)
: Intf_Interference (Standard_False),
BeginOfClosedPolygon (Standard_False),
iLin (0)
{}
//=======================================================================
@@ -66,12 +57,11 @@ Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron()
// and a Polyhedron.
//=======================================================================
static Standard_Boolean BeginOfClosedPolygon;
static Standard_Integer iLin;
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
(const Polygon3d& thePolyg, const Polyhedron& thePolyh)
: Intf_Interference(Standard_False)
: Intf_Interference (Standard_False),
BeginOfClosedPolygon (Standard_False),
iLin (0)
{
Tolerance=ToolPolygon3d::DeflectionOverEstimation(thePolyg)+
ToolPolyh::DeflectionOverEstimation(thePolyh);
@@ -84,12 +74,12 @@ Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
}
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
(const Polygon3d& thePolyg, const Polyhedron& thePolyh,
Bnd_BoundSortBox &PolyhGrid)
: Intf_Interference(Standard_False)
: Intf_Interference (Standard_False),
BeginOfClosedPolygon (Standard_False),
iLin (0)
{
Tolerance=ToolPolygon3d::DeflectionOverEstimation(thePolyg)+
ToolPolyh::DeflectionOverEstimation(thePolyh);
@@ -109,7 +99,9 @@ Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
(const gp_Lin& theLin, const Polyhedron& thePolyh)
: Intf_Interference(Standard_False)
: Intf_Interference (Standard_False),
BeginOfClosedPolygon (Standard_False),
iLin (0)
{
Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
if (Tolerance==0.)
@@ -148,7 +140,9 @@ Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
Intf_InterferencePolygonPolyhedron::Intf_InterferencePolygonPolyhedron
(const Intf_Array1OfLin& theLins, const Polyhedron& thePolyh)
: Intf_Interference(Standard_False)
: Intf_Interference (Standard_False),
BeginOfClosedPolygon (Standard_False),
iLin (0)
{
Tolerance=ToolPolyh::DeflectionOverEstimation(thePolyh);
if (Tolerance==0.)
@@ -636,19 +630,6 @@ void Intf_InterferencePolygonPolyhedron::Interference
}
//=======================================================================
//function : Intersect
//purpose : Compute the intersection beetween the segment or the line
@@ -787,23 +768,9 @@ void Intf_InterferencePolygonPolyhedron::Intersect
Standard_Real dEndTri=(triNor*EndO.XYZ())-triDp; // Distance <EndO> plan
gp_XYZ segO=EndO.XYZ()-BegO.XYZ();
segO.Normalize();
#if 0
Standard_Real angl=triNor*segO;
#endif
Standard_Boolean NoIntersectionWithTriangle = Standard_False;
Standard_Boolean PolygonCutsPlane = Standard_True;
#if 0
if (((!Infinite && Abs(dBegTri)<=Tolerance && Abs(dEndTri)<=Tolerance) ||
(Infinite && angl<=PRCANG)) || (dBegTri-dEndTri)==0.) {
// On est dans la Zone d influence calculer sur quel partie :
// !!cout<<" AAAA ";
// !!cout<<" Beg End :"<<dBegTri<<" "<<dEndTri<<endl;
}
#endif
Standard_Real param;
t = dBegTri-dEndTri;
if (t >= 1.e-16 || t<=-1.e-16)
@@ -829,39 +796,9 @@ void Intf_InterferencePolygonPolyhedron::Intersect
if(NoIntersectionWithTriangle == Standard_False) {
gp_XYZ spLieu=BegO.XYZ()+((EndO.XYZ()-BegO.XYZ())*param);
Standard_Real dPiE[3], dPtPi[3], sigd;
#ifndef DEB
Standard_Integer is =0;
#else
Standard_Integer is;
#endif
Standard_Integer is = 0;
Standard_Integer sEdge=-1;
Standard_Integer sVertex=-1;
/* for (is=0; is<3; is++) {
gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[(is+1)%3]).XYZ()-
ToolPolyh::Point(thePolyh, pTri[is]).XYZ());
gp_XYZ vecP(spLieu-ToolPolyh::Point(thePolyh, pTri[is]).XYZ());
dPtPi[is]=vecP.Modulus();
if (dPtPi[is]<=floatgap) {
sVertex=is;
break;
}
gp_XYZ segT_x_vecP(segT^vecP);
Standard_Real Modulus_segT_x_vecP = segT_x_vecP.Modulus();
sigd = segT_x_vecP*triNor;
if(sigd>floatgap)
sigd = 1.0;
else if(sigd<-floatgap)
sigd = -1.0;
else {
sigd = 0.0;
}
dPiE[is]=sigd*(Modulus_segT_x_vecP/segT.Modulus());
if (Abs(dPiE[is])<=floatgap) {
sEdge=is;
break;
}
}
*/
Standard_Integer tbreak=0;
{ //-- is = 0
gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[1]).XYZ()-
@@ -892,7 +829,7 @@ void Intf_InterferencePolygonPolyhedron::Intersect
}
}
}
if(tbreak==0) { //-- is = 1
gp_XYZ segT(ToolPolyh::Point(thePolyh, pTri[2]).XYZ()-
ToolPolyh::Point(thePolyh, pTri[1]).XYZ());
@@ -1136,11 +1073,7 @@ void Intf_InterferencePolygonPolyhedron::Intersect
if(NoIntersectionWithTriangle == Standard_False) {
gp_XYZ spLieu=BegO.XYZ()+((EndO.XYZ()-BegO.XYZ())*param);
Standard_Real dPiE[3], dPtPi[3], sigd;
#ifndef DEB
Standard_Integer is =0;
#else
Standard_Integer is;
#endif
Standard_Integer is = 0;
Standard_Integer sEdge=-1;
Standard_Integer sVertex=-1;
Standard_Integer tbreak=0;
@@ -1370,4 +1303,3 @@ void Intf_InterferencePolygonPolyhedron::Intersect
}
}
}
// end of File: Intf_InterferencePolygonPolyhedron.gxx

13
src/Intf/Intf_InterferencePolyhedron.cdl
View File

@@ -16,6 +16,7 @@ generic class InterferencePolyhedron from Intf
-- self interference of a polyhedron.
uses Pnt from gp,
XYZ from gp,
Box from Bnd,
SectionPoint from Intf,
SeqOfSectionPoint from Intf,
@@ -85,5 +86,17 @@ is
---Purpose: Computes the zone of tangence between the facet <Tri1> of
-- <FirstPol> and the facet <Tri2> of <SecondPol>.
CoupleCharacteristics (me: in out;
FirstPol: Polyhedron1;
SeconPol: Polyhedron2) is private;
fields
OI : Integer from Standard[3]; -- index des sommets de l objet
TI : Integer from Standard[3]; -- index des sommets du tool
dpOpT : Real from Standard[3, 3]; -- distance point Objet - point Tool
dpOeT : Real from Standard[3, 3]; -- distance point Objet - edge Tool
deOpT : Real from Standard[3, 3]; -- distance edge Objet - point Tool
voo : XYZ from gp[3]; -- vecteur point point Obje
vtt : XYZ from gp[3]; -- vecteur point point Tool
Incidence: Real from Standard; -- angle entre les deux plans
end InterferencePolyhedron;

68
src/Intf/Intf_InterferencePolyhedron.gxx
View File

@@ -18,9 +18,7 @@
#include <TColStd_ListIteratorOfListOfInteger.hxx>
#include <Bnd_BoundSortBox.hxx>
//static Pourcent3[9]={0,1,2,0,1,2,0,1,2};
static int Pourcent3[9]={0,1,2,0,1,2,0,1,2};
static const int Pourcent3[9] = {0, 1, 2, 0, 1, 2, 0, 1, 2};
//=======================================================================
//function : Intf_InterferencePolyhedron
@@ -36,8 +34,6 @@ Intf_InterferencePolyhedron::Intf_InterferencePolyhedron ()
//purpose :
//=======================================================================
static Standard_Integer debug=0;
Intf_InterferencePolyhedron::Intf_InterferencePolyhedron
(const Polyhedron1& FirstPol, const Polyhedron2& SeconPol)
: Intf_Interference(Standard_False)
@@ -108,8 +104,6 @@ void Intf_InterferencePolyhedron::Perform
//purpose :
//=======================================================================
static Standard_Integer iFirst, iSecon;
void Intf_InterferencePolyhedron::Interference
(const Polyhedron1&)
{}
@@ -120,6 +114,7 @@ void Intf_InterferencePolyhedron::Interference
Standard_Boolean gridOnFirst=Standard_True;
Standard_Integer NbTrianglesFirstPol = ToolPolyhe1::NbTriangles(FirstPol);
Standard_Integer NbTrianglesSecondPol = ToolPolyhe2::NbTriangles(SeconPol);
Standard_Integer iFirst, iSecon;
//------------------------------------------------------------------------------------------
//-- the same number of triangles it is necessary to test better on
@@ -196,18 +191,6 @@ void Intf_InterferencePolyhedron::Interference
//purpose : Intersection of two triangles issue from two Polyhedron.
//=======================================================================
void CoupleCharacteristics(const Polyhedron1& FirstPol,
const Polyhedron2& SeconPol);
static Standard_Integer OI[3]; // index des sommets de l objet
static Standard_Integer TI[3]; // index des sommets du tool
static Standard_Real dpOpT[3][3]; // distance point Objet - point Tool
static Standard_Real dpOeT[3][3]; // distance point Objet - edge Tool
static Standard_Real deOpT[3][3]; // distance edge Objet - point Tool
static gp_XYZ voo[3]; // vecteur point point Obje
static gp_XYZ vtt[3]; // vecteur point point Tool
static Standard_Real Incidence; // angle entre les deux plans
void Intf_InterferencePolyhedron::Intersect
(const Standard_Integer Tri1, const Polyhedron1& FirstPol,
const Standard_Integer Tri2, const Polyhedron2& SeconPol)
@@ -290,12 +273,8 @@ void Intf_InterferencePolyhedron::Intersect
(Abs(dpOfT[0]+dpOfT[1]+dpOfT[2])!=
Abs(dpOfT[0])+Abs(dpOfT[1])+Abs(dpOfT[2]))){
if (TangentZoneValue(TheTZ, FirstPol, Tri1, SeconPol, Tri2)) {
if (debug==2) {
cout<< "Zone de tangence Couple Tri1, Tri2 : "
<< Tri1 << ", " << Tri2 << " : " << endl;
TheTZ.Dump(2);
}
if (TangentZoneValue(TheTZ, FirstPol, Tri1, SeconPol, Tri2))
{
if (!Insert(TheTZ)) myTZones.Append(TheTZ);
}
}
@@ -662,10 +641,6 @@ void Intf_InterferencePolyhedron::Intersect
ifin=id[2]; //
}
else {
if(debug==2) {
cout << "Impossible calculation problem in pointersec!"
<< endl;
}
ideb=-999; // No line of section possible
ifin=-999;
}
@@ -684,10 +659,6 @@ void Intf_InterferencePolyhedron::Intersect
ifin=id[2]; //
}
else {
if(debug==2) {
cout << "Impossible calculation problem in pointersec !"
<< endl;
}
ideb=-999; // No line of section possible
ifin=-999;
}
@@ -882,9 +853,6 @@ Standard_Boolean Intf_InterferencePolyhedron::TangentZoneValue
deOpT[nob][nou]*deOpT[nob][nou2]<0.) {
if (nbpInt>=6) {
if(debug==2) {
cout << "Nombre de P.I. > 6 dans une TZ ! " << endl;
}
break;
}
else {
@@ -926,12 +894,6 @@ Standard_Boolean Intf_InterferencePolyhedron::TangentZoneValue
}
}
if (nbNoInserted>0) {
if(debug==2) {
cout << "Insertion impossible ! \n";
cout << " La Zone : \n";
TheTZ.Dump(4);
cout << " Le(s) Point(s) : \n";
}
nob=nbNoInserted-1;
while (nob>=0) {
Tpi(piToInsert[nob--]).Dump(4);
@@ -948,8 +910,8 @@ Standard_Boolean Intf_InterferencePolyhedron::TangentZoneValue
//purpose :
//=======================================================================
void CoupleCharacteristics(const Polyhedron1& FirstPol,
const Polyhedron2& SeconPol)
void Intf_InterferencePolyhedron::CoupleCharacteristics (const Polyhedron1& FirstPol,
const Polyhedron2& SeconPol)
{
Standard_Integer n1, n2;
Standard_Real lg;
@@ -994,22 +956,4 @@ void CoupleCharacteristics(const Polyhedron1& FirstPol,
deOpT[n1][n2]=dpOpT[n1][n2];
}
}
#if 0
if (debug==1) {
cout<<"dpOpT: "<<dpOpT[0][0]<<" , "<<dpOpT[0][1]<<" , "<<dpOpT[0][2]<<"\n";
cout<<" : "<<dpOpT[1][0]<<" , "<<dpOpT[1][1]<<" , "<<dpOpT[1][2]<<"\n";
cout<<" : "<<dpOpT[2][0]<<" , "<<dpOpT[2][1]<<" , "<<dpOpT[2][2]<<"\n";
cout << endl;
cout<<"dpOeT: "<<dpOeT[0][0]<<" , "<<dpOeT[0][1]<<" , "<<dpOeT[0][2]<<"\n";
cout<<" : "<<dpOeT[1][0]<<" , "<<dpOeT[1][1]<<" , "<<dpOeT[1][2]<<"\n";
cout<<" : "<<dpOeT[2][0]<<" , "<<dpOeT[2][1]<<" , "<<dpOeT[2][2]<<"\n";
cout << endl;
cout<<"deOpT: "<<deOpT[0][0]<<" , "<<deOpT[0][1]<<" , "<<deOpT[0][2]<<"\n";
cout<<" : "<<deOpT[1][0]<<" , "<<deOpT[1][1]<<" , "<<deOpT[1][2]<<"\n";
cout<<" : "<<deOpT[2][0]<<" , "<<deOpT[2][1]<<" , "<<deOpT[2][2]<<"\n";
cout << endl;
}
#endif
}
// EOF File: Intf_InterferencePolyhedron.gxx

5
src/Intf/Intf_Tool.cdl
View File

@@ -106,5 +106,10 @@ is Create returns Tool from Intf;
fields nbSeg : Integer from Standard;
beginOnCurve : Real from Standard [6];
endOnCurve : Real from Standard [6];
bord : Integer from Standard [12];
xint : Real from Standard [12];
yint : Real from Standard [12];
zint : Real from Standard [12];
parint : Real from Standard [12];
end Tool;

5
src/Intf/Intf_Tool.cxx
View File

@@ -126,11 +126,6 @@ void Intf_Tool::Lin2dBox(const gp_Lin2d& L2d,
//function : Hypr2dBox
//purpose :
//=======================================================================
static Standard_Integer bord[12];
static Standard_Real xint[12];
static Standard_Real yint[12];
static Standard_Real zint[12];
static Standard_Real parint[12];
void Intf_Tool::Hypr2dBox(const gp_Hypr2d& theHypr2d,
const Bnd_Box2d& domain,