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

0022792: Globally defined symbol PI conflicts with VTK definition (Intel compiler)

Browse Source
This commit is contained in:
DBV 2011-12-16 08:50:03 +00:00 committed by bugmaster
parent bc650d4170
commit c6541a0c86
438 changed files with 2142 additions and 2188 deletions
src
AIS
AIS.cxxAIS_AngleDimension.cxxAIS_Circle.cxxAIS_ConcentricRelation.cxxAIS_DiameterDimension.cxxAIS_EllipseRadiusDimension.cxxAIS_EqualDistanceRelation.cxxAIS_EqualRadiusRelation.cxxAIS_FixRelation.cxxAIS_IdenticRelation.cxxAIS_InteractiveContext.cxxAIS_LengthDimension.cxxAIS_MidPointRelation.cxxAIS_RadiusDimension.cxxAIS_TangentRelation.cxx
Adaptor3d
Adaptor3d_CurveOnSurface.cxxAdaptor3d_SurfaceOfRevolution.cxxAdaptor3d_TopolTool.cxx
AppParCurves
AppParCurves_Variational.gxx
ApproxInt
ApproxInt_ImpPrmSvSurfaces.gxx
Aspect
Aspect_CircularGrid.cxxAspect_MarkerStyle.cxxAspect_RectangularGrid.cxx
BOP
BOP_WireSplitter.cxx
BOPTools
BOPTools_PaveFiller_3.cxxBOPTools_Tools2D.cxxBOPTools_Tools3D.cxx
BRepAlgo
BRepAlgo_DSAccess.cxx
BRepBlend
BRepBlend_RstRstConstRad.cxxBRepBlend_RstRstEvolRad.cxxBRepBlend_SurfRstConstRad.cxxBRepBlend_SurfRstEvolRad.cxx
BRepBuilderAPI
BRepBuilderAPI_Sewing.cxx
BRepCheck
BRepCheck_Wire.cxx
BRepFeat
BRepFeat.cxxBRepFeat_MakeLinearForm.cxxBRepFeat_MakeRevol.cxxBRepFeat_MakeRevolutionForm.cxxBRepFeat_RibSlot.cxx
BRepFill
BRepFill.cxxBRepFill_CompatibleWires.cxxBRepFill_Draft.cxxBRepFill_Evolved.cxxBRepFill_Filling.cxxBRepFill_MultiLine.cxxBRepFill_OffsetWire.cxxBRepFill_Sweep.cxxBRepFill_TrimShellCorner.cxxBRepFill_TrimSurfaceTool.cxx
BRepGProp
BRepGProp_Face.cxx
BRepLib
BRepLib.cxx
BRepMesh
BRepMesh_Classifier.cxx
BRepOffset
BRepOffset.cxxBRepOffset_MakeOffset.cxxBRepOffset_Offset.cxxBRepOffset_Tool.cxx
BRepOffsetAPI
BRepOffsetAPI_DraftAngle.cxx
BRepPrim
BRepPrim_Cone.cxxBRepPrim_Sphere.cxxBRepPrim_Torus.cxx
BRepSweep
BRepSweep_Revol.cxxBRepSweep_Rotation.cxx
BRepTest
BRepTest_BasicCommands.cxxBRepTest_ChamferCommands.cxxBRepTest_CurveCommands.cxxBRepTest_DraftAngleCommands.cxxBRepTest_FeatureCommands.cxxBRepTest_Fillet2DCommands.cxxBRepTest_PrimitiveCommands.cxxBRepTest_SurfaceCommands.cxxBRepTest_SweepCommands.cxx
BRepToIGES
BRepToIGES_BRWire.cxx
BRepTools
BRepTools_WireExplorer.cxx
BRepTopAdaptor
BRepTopAdaptor_FClass2d.cxx
BiTgte
BiTgte_Blend.cxx
Bisector
Bisector_BisecAna.cxxBisector_BisecCC.cxx
BlendFunc
BlendFunc.cxxBlendFunc_CSCircular.cxxBlendFunc_CSConstRad.cxxBlendFunc_ConstRad.cxxBlendFunc_EvolRad.cxx
BndLib
BndLib.cxxBndLib_AddSurface.cxxBndLib_Compute.gxx
CGM
CGM_Driver.cxxcgmlib.hxxcgmpar.h
CSLib
CSLib.cxx
ChFi2d
ChFi2d_Builder.cxx
ChFi3d
ChFi3d.cxxChFi3d_Builder_0.cxxChFi3d_Builder_1.cxxChFi3d_Builder_2.cxxChFi3d_Builder_C1.cxxChFi3d_Builder_CnCrn.cxxChFi3d_Builder_SpKP.cxxChFi3d_ChBuilder.cxxChFi3d_FilBuilder.cxxChFi3d_FilBuilder_C2.cxx
Show More

32
src/AIS/AIS.cxx

@ -979,7 +979,7 @@ void AIS::ComputeAngleBetweenCurvilinearFaces( const TopoDS_Face & FirstFac
if (! Xdirection.IsEqual( ToFirstAttach, Precision::Angular() ) &&
! Xdirection.IsOpposite( ToFirstAttach, Precision::Angular() ) &&
(Xdirection ^ ToFirstAttach) * Cone2->Cone().Axis().Direction() < 0.0e0)
SecondU = 2*PI - SecondU ;
SecondU = 2*M_PI - SecondU ;
SecondLine = Handle( Geom_Line )::DownCast( Cone2->UIso( SecondU ) );
@ -1233,18 +1233,18 @@ Standard_Boolean AIS::InDomain(const Standard_Real fpar,
if(lpar > fpar)
return ((para >= fpar) && (para <= lpar));
else { // fpar > lpar
Standard_Real delta = 2*PI-fpar;
Standard_Real delta = 2*M_PI-fpar;
Standard_Real lp, par, fp;
lp = lpar + delta;
par = para + delta;
while(lp > 2*PI) lp-=2*PI;
while(par > 2*PI) par-=2*PI;
while(lp > 2*M_PI) lp-=2*M_PI;
while(par > 2*M_PI) par-=2*M_PI;
fp = 0.;
return ((par >= fp) && (par <= lp));
}
}
if (para >= (fpar+2*PI)) return Standard_True;
if (para >= (fpar+2*M_PI)) return Standard_True;
if (para <= lpar) return Standard_True;
return Standard_False;
}
@ -1260,37 +1260,37 @@ Standard_Real AIS::DistanceFromApex(const gp_Elips & elips,
{
Standard_Real dist;
Standard_Real parApex = ElCLib::Parameter ( elips, Apex );
if(parApex == 0.0 || parApex == PI)
if(parApex == 0.0 || parApex == M_PI)
{//Major case
if(parApex == 0.0) //pos Apex
dist = (par < PI) ? par : (2*PI - par);
dist = (par < M_PI) ? par : (2*M_PI - par);
else //neg Apex
dist = (par < PI) ? ( PI - par) : ( par - PI );
dist = (par < M_PI) ? ( M_PI - par) : ( par - M_PI );
}
else
{// Minor case
if(parApex == PI / 2) //pos Apex
if(parApex == M_PI / 2) //pos Apex
{
if(par <= parApex + PI && par > parApex) // 3/2*PI < par < PI/2
if(par <= parApex + M_PI && par > parApex) // 3/2*M_PI < par < M_PI/2
dist = par - parApex;
else
{
if(par > parApex + PI) // 3/2*PI < par < 2*PI
dist = 2*PI - par + parApex;
if(par > parApex + M_PI) // 3/2*M_PI < par < 2*M_PI
dist = 2*M_PI - par + parApex;
else
dist = parApex - par;
}
}
else //neg Apex == 3/2*PI
else //neg Apex == 3/2*M_PI
{
if(par <= parApex && par >= PI/2) // PI/2 < par < 3/2*PI
if(par <= parApex && par >= M_PI/2) // M_PI/2 < par < 3/2*M_PI
dist = parApex - par;
else
{
if(par > parApex) // 3/2*PI < par < 2*PI
if(par > parApex) // 3/2*M_PI < par < 2*M_PI
dist = par - parApex;
else
dist = par + PI/2; // 0 < par < PI/2
dist = par + M_PI/2; // 0 < par < M_PI/2
}
}
}

64
src/AIS/AIS_AngleDimension.cxx

@ -592,7 +592,7 @@ void AIS_AngleDimension::ComputeConeAngle(const Handle(Prs3d_Presentation)& aPre
aCurve = aSurf->VIso(midV);
myCircle = Handle(Geom_Circle)::DownCast(aCurve)->Circ();
myPosition = ElCLib::Value(Standard_PI/2.0, myCircle);
myPosition = ElCLib::Value(M_PI / 2.0, myCircle);
myAutomaticPosition = Standard_False;
}
else {
@ -678,7 +678,7 @@ void AIS_AngleDimension::ComputeTwoCurvilinearFacesAngle(const Handle(Prs3d_Pres
#endif
if (myVal <= Precision::Angular() || Abs( PI-myVal ) <= Precision::Angular())
if (myVal <= Precision::Angular() || Abs( M_PI-myVal ) <= Precision::Angular())
DsgPrs_AnglePresentation::Add(aPresentation,
myDrawer,
myVal,
@ -931,7 +931,7 @@ void AIS_AngleDimension::ComputeTwoEdgesNotNullAngle(const Handle(Prs3d_Presenta
Standard_Boolean In1(Standard_False);
Standard_Boolean In2(Standard_False);
if ( !(Abs(d1.Angle(d2) - Abs(myVal)) <= Precision::Confusion())
&& (Abs(myVal) < PI) ) {
&& (Abs(myVal) < M_PI) ) {
Standard_Real parcent1 = ElCLib::Parameter(l1->Lin(), myCenter);
Standard_Real par11 = ElCLib::Parameter(l1->Lin(), ptat11);
Standard_Real par12 = ElCLib::Parameter(l1->Lin(), ptat12);
@ -961,7 +961,7 @@ void AIS_AngleDimension::ComputeTwoEdgesNotNullAngle(const Handle(Prs3d_Presenta
gp_Lin gpl2 = l2->Lin();
theaxis = gp_Lin(myCenter,myFDir^mySDir);
if (myVal > PI) {
if (myVal > M_PI) {
theaxis.Reverse();
}
@ -1022,7 +1022,7 @@ void AIS_AngleDimension::ComputeTwoEdgesNotNullAngle(const Handle(Prs3d_Presenta
mySAttach = ElCLib::Value(par_p2_attach,gpl2);
}
}
if ( myVal < PI) curpos.SetXYZ(.5*(myFAttach.XYZ()+mySAttach.XYZ()));
if ( myVal < M_PI) curpos.SetXYZ(.5*(myFAttach.XYZ()+mySAttach.XYZ()));
else {
curpos.SetXYZ(.5*(myFAttach.XYZ()+mySAttach.XYZ()));
gp_Vec transl(curpos, myCenter);
@ -1074,9 +1074,9 @@ void AIS_AngleDimension::ComputeTwoEdgesNotNullAngle(const Handle(Prs3d_Presenta
Standard_Real udeb = uc1;
Standard_Real ufin = uc2;
if (uco > ufin) {
if (Abs(myVal)<PI) {
if (Abs(myVal)<M_PI) {
// test if uco is in the opposite sector
if (uco > udeb+PI && uco < ufin+PI){
if (uco > udeb+M_PI && uco < ufin+M_PI){
dist = -dist;
}
}
@ -1493,7 +1493,7 @@ void AIS_AngleDimension::Compute3DSelection( const Handle( SelectMgr_Selection )
Standard_Real FirstParAngleCirc, LastParAngleCirc, FirstParAttachCirc, LastParAttachCirc;
gp_Pnt EndOfArrow1, EndOfArrow2, ProjAttachPoint2;
gp_Dir DirOfArrow1, DirOfArrow2;
gp_Dir axisdir = (myVal <= Precision::Angular() || Abs( PI-myVal ) <= Precision::Angular())?
gp_Dir axisdir = (myVal <= Precision::Angular() || Abs( M_PI-myVal ) <= Precision::Angular())?
myPlane->Pln().Axis().Direction() : (myFDir ^ mySDir);
Standard_Boolean isPlane = (myFirstSurfType == AIS_KOS_Plane)? Standard_True : Standard_False;
@ -1527,7 +1527,7 @@ void AIS_AngleDimension::Compute3DSelection( const Handle( SelectMgr_Selection )
Handle( Select3D_SensitiveCurve ) SensCurve;
// Angle's arc or line
if (myVal > Precision::Angular() && Abs( PI-myVal ) > Precision::Angular())
if (myVal > Precision::Angular() && Abs( M_PI-myVal ) > Precision::Angular())
{
curve = new Geom_TrimmedCurve( new Geom_Circle( AngleCirc ), FirstParAngleCirc, LastParAngleCirc );
SensCurve = new Select3D_SensitiveCurve( own, curve );
@ -1611,12 +1611,12 @@ void AIS_AngleDimension::Compute2DSelection(const Handle(SelectMgr_Selection)& a
gp_Lin l2(cu2.Line());
// it is patch!
if (Abs( myVal ) <= Precision::Angular() || Abs( PI - myVal ) <= Precision::Angular())
if (Abs( myVal ) <= Precision::Angular() || Abs( M_PI - myVal ) <= Precision::Angular())
/*
//---------------------------------------------------------
// Cas de droites paralleles ( <=> angle nul a PI pres)
// Cas de droites paralleles ( <=> angle nul a M_PI pres)
if ((Abs(l1.Angle(l2)) < Precision::Angular()) ||
(Abs((l1.Angle(l2) - PI)) < Precision::Angular()) )
(Abs((l1.Angle(l2) - M_PI)) < Precision::Angular()) )
*/
{
@ -1677,19 +1677,19 @@ void AIS_AngleDimension::Compute2DSelection(const Handle(SelectMgr_Selection)& a
Standard_Real ufin = uc2;
if (uco > ufin) {
if (Abs(myVal)<PI) {
if (Abs(myVal)<M_PI) {
// test if uco is in the opposing sector
if (uco > udeb+PI && uco < ufin+PI){
udeb = udeb + PI;
ufin = ufin + PI;
if (uco > udeb+M_PI && uco < ufin+M_PI){
udeb = udeb + M_PI;
ufin = ufin + M_PI;
uc1 = udeb;
uc2 = ufin;
}
}
}
if (uco > ufin) {
if ((uco-uc2) < (uc1-uco+(2*PI))) ufin = uco;
else udeb = uco - 2*PI;
if ((uco-uc2) < (uc1-uco+(2*M_PI))) ufin = uco;
else udeb = uco - 2*M_PI;
}
p1 = ElCLib::Value(udeb,cer);
p2 = ElCLib::Value(ufin,cer);
@ -1770,11 +1770,11 @@ void AIS_AngleDimension::ComputeNull2DSelection(
Standard_Real ufin = uc2;
if (uco > ufin) {
if (Abs(myVal)<PI) {
if (Abs(myVal)<M_PI) {
// test if uco is in the opposing sector
if (uco > udeb+PI && uco < ufin+PI){
udeb = udeb + PI;
ufin = ufin + PI;
if (uco > udeb+M_PI && uco < ufin+M_PI){
udeb = udeb + M_PI;
ufin = ufin + M_PI;
uc1 = udeb;
uc2 = ufin;
}
@ -1782,11 +1782,11 @@ void AIS_AngleDimension::ComputeNull2DSelection(
}
if (uco > ufin) {
if ((uco-uc2) < (uc1-uco+(2*PI))) {
if ((uco-uc2) < (uc1-uco+(2*M_PI))) {
ufin = uco;
}
else {
udeb = uco - 2*PI;
udeb = uco - 2*M_PI;
}
}
@ -1929,7 +1929,7 @@ void AIS_AngleDimension::ComputeConeAngleSelection(const Handle(SelectMgr_Select
aCurve = aSurf->VIso(midV);
myCircle = Handle(Geom_Circle)::DownCast(aCurve)->Circ();
myPosition = ElCLib::Value(Standard_PI / 2.0, myCircle);
myPosition = ElCLib::Value(M_PI / 2.0, myCircle);
myAutomaticPosition = Standard_False;
}
else {
@ -1966,7 +1966,7 @@ void AIS_AngleDimension::ComputeConeAngleSelection(const Handle(SelectMgr_Select
aPnt = Apex;
gp_Pnt P1 = ElCLib::Value(0., myCircle);
gp_Pnt P2 = ElCLib::Value(Standard_PI, myCircle);
gp_Pnt P2 = ElCLib::Value(M_PI, myCircle);
gce_MakePln mkPln(P1, P2, aPnt); // create a plane whitch defines plane for projection aPosition on it
@ -1994,8 +1994,8 @@ void AIS_AngleDimension::ComputeConeAngleSelection(const Handle(SelectMgr_Select
Standard_Real AttParam = ElCLib::Parameter(aCircle2, AttachmentPnt);
Standard_Real OppParam = ElCLib::Parameter(aCircle2, OppositePnt);
while ( AttParam >= 2*Standard_PI ) AttParam -= 2*Standard_PI;
while ( OppParam >= 2*Standard_PI ) OppParam -= 2*Standard_PI;
while ( AttParam >= 2 * M_PI ) AttParam -= 2 * M_PI;
while ( OppParam >= 2 * M_PI ) OppParam -= 2 * M_PI;
if( myPosition.Distance( myCircle.Location() ) <= myCircle.Radius() )
if( 2 * myCircle.Radius() > aCircle2.Radius() * 0.4 ) IsArrowOut = Standard_False; //four times more than an arrow size
@ -2006,10 +2006,10 @@ void AIS_AngleDimension::ComputeConeAngleSelection(const Handle(SelectMgr_Select
param = ElCLib::Parameter(aCircle2, tmpPnt);
if(IsArrowOut) {
angle = OppParam - AttParam + Standard_PI/6; //An angle between AttParam and OppParam + 30 degrees
param = AttParam - Standard_PI/12; //out parts of dimension line are 15 degrees
angle = OppParam - AttParam + M_PI / 6; //An angle between AttParam and OppParam + 30 degrees
param = AttParam - M_PI / 12; //out parts of dimension line are 15 degrees
while ( angle > 2*Standard_PI ) angle -= 2*Standard_PI;
while ( angle > 2 * M_PI ) angle -= 2 * M_PI;
for( i = 0; i <= 11; i++ ) { //calculating of arc
aPnt = ElCLib::Value(param + angle/11 * i, aCircle2);
aPnt.Coord(X, Y, Z);
@ -2020,7 +2020,7 @@ void AIS_AngleDimension::ComputeConeAngleSelection(const Handle(SelectMgr_Select
else {
angle = OppParam - AttParam;
param = AttParam;
while ( angle > 2*Standard_PI ) angle -= 2*Standard_PI;
while ( angle > 2 * M_PI ) angle -= 2 * M_PI;
for( i = 0; i <= 11; i++ ) { //calculating of arc
aPnt = ElCLib::Value(param + angle/11 * i, aCircle2);
aPnt.Coord(X, Y, Z);

2
src/AIS/AIS_Circle.cxx

@ -34,7 +34,7 @@ AIS_Circle::AIS_Circle(const Handle(Geom_Circle)& aComponent):
AIS_InteractiveObject(PrsMgr_TOP_AllView),
myComponent(aComponent),
myUStart(0.),
myUEnd(2*PI),
myUEnd(2*M_PI),
myCircleIsArc(Standard_False)
{
}

4
src/AIS/AIS_ConcentricRelation.cxx

@ -266,8 +266,8 @@ void AIS_ConcentricRelation::ComputeSelection(const Handle(SelectMgr_Selection)&
aSelection->Add(seg);
gp_Ax1 RotateAxis(myCenter, myDir);
gp_Pnt FPnt = myCenter.Rotated(RotateAxis, PI/2);
gp_Pnt SPnt = myCenter.Rotated(RotateAxis, -PI/2);
gp_Pnt FPnt = myCenter.Rotated(RotateAxis, M_PI/2);
gp_Pnt SPnt = myCenter.Rotated(RotateAxis, -M_PI/2);
seg = new Select3D_SensitiveSegment(own,
FPnt,
SPnt);

14
src/AIS/AIS_DiameterDimension.cxx

@ -242,17 +242,17 @@ void AIS_DiameterDimension::ComputeArcSelection(const Handle(SelectMgr_Selection
Handle(SelectMgr_EntityOwner) own = new SelectMgr_EntityOwner(this,7);
gp_Pnt theCenter = myCircle.Location();
while (lpara > 2*PI) {
fpara -= 2*PI;
lpara -= 2*PI;
while (lpara > 2*M_PI) {
fpara -= 2*M_PI;
lpara -= 2*M_PI;
}
Standard_Real parat = ElCLib::Parameter(myCircle,myPosition);
Standard_Boolean otherside(Standard_False);
gp_Pnt attpoint = myPosition;
if (!AIS::InDomain(fpara,lpara,parat)) {
Standard_Real otherpar = parat + PI;
if (otherpar > 2*PI) otherpar -= 2*PI;
Standard_Real otherpar = parat + M_PI;
if (otherpar > 2*M_PI) otherpar -= 2*M_PI;
if (AIS::InDomain(fpara,lpara,otherpar)) {
parat = otherpar;
otherside = Standard_True;
@ -530,7 +530,7 @@ void AIS_DiameterDimension::ComputeArcDiameter(
myFirstPar = parfirst;
myLastPar = parend;
if ( parfirst > parend) {
parfirst -= 2*PI;
parfirst -= 2*M_PI;
}
if (myAutomaticPosition) {
Standard_Real pcurpos = (parfirst + parend)/2.;
@ -667,7 +667,7 @@ void AIS_DiameterDimension::ComputeOnePlanarFaceDiameter(const Handle(Prs3d_Pres
parfirst = ElCLib::Parameter(myCircle, ptfirst);
parend = ElCLib::Parameter(myCircle, ptend);
if ( parfirst > parend) {
parfirst -= 2*PI;
parfirst -= 2*M_PI;
}
Standard_Real parcurPos = (parfirst + parend) * 0.5;
curPos = ElCLib::Value(parcurPos, myCircle);

8
src/AIS/AIS_EllipseRadiusDimension.cxx

@ -79,10 +79,10 @@ void AIS_EllipseRadiusDimension::ComputeGeometry()
default:
break;
}
while (myFirstPar > 2*PI) myFirstPar -= 2*PI;
while (myLastPar > 2*PI) myLastPar -= 2*PI;
while (myFirstPar < 0.0) myFirstPar += 2*PI;
while (myLastPar < 0.0) myLastPar += 2*PI;
while (myFirstPar > 2*M_PI) myFirstPar -= 2*M_PI;
while (myLastPar > 2*M_PI) myLastPar -= 2*M_PI;
while (myFirstPar < 0.0) myFirstPar += 2*M_PI;
while (myLastPar < 0.0) myLastPar += 2*M_PI;
}
//=======================================================================

18
src/AIS/AIS_EqualDistanceRelation.cxx

@ -278,7 +278,7 @@ void AIS_EqualDistanceRelation::ComputeSelection( const Handle( SelectMgr_Select
Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve.Curve().Curve());
Standard_Real FirstPar = ElCLib::Parameter(aCircle->Circ(), myAttachPoint1),
LastPar = ElCLib::Parameter(aCircle->Circ(), myPoint1);
if (LastPar < FirstPar ) LastPar+=PI*2;
if (LastPar < FirstPar ) LastPar+=M_PI*2;
//add sensetive arc
Handle(Select3D_SensitiveCircle) circ =
new Select3D_SensitiveCircle( own, aCircle, FirstPar, LastPar);
@ -301,7 +301,7 @@ void AIS_EqualDistanceRelation::ComputeSelection( const Handle( SelectMgr_Select
Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve.Curve().Curve());
Standard_Real FirstPar = ElCLib::Parameter(aCircle->Circ(), myAttachPoint2),
LastPar = ElCLib::Parameter(aCircle->Circ(), myPoint2);
if (LastPar < FirstPar ) LastPar+=PI*2;
if (LastPar < FirstPar ) LastPar+=M_PI*2;
//add sensetive arc
Handle(Select3D_SensitiveCircle) circ =
new Select3D_SensitiveCircle( own,aCircle, FirstPar, LastPar);
@ -324,7 +324,7 @@ void AIS_EqualDistanceRelation::ComputeSelection( const Handle( SelectMgr_Select
Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve.Curve().Curve());
Standard_Real FirstPar = ElCLib::Parameter(aCircle->Circ(), myAttachPoint3),
LastPar = ElCLib::Parameter(aCircle->Circ(), myPoint3);
if (LastPar < FirstPar ) LastPar+=PI*2;
if (LastPar < FirstPar ) LastPar+=M_PI*2;
Handle(Select3D_SensitiveCircle) circ =
new Select3D_SensitiveCircle( own, aCircle, FirstPar, LastPar);
aSelection->Add( circ );
@ -350,7 +350,7 @@ void AIS_EqualDistanceRelation::ComputeSelection( const Handle( SelectMgr_Select
Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve.Curve().Curve());
Standard_Real FirstPar = ElCLib::Parameter(aCircle->Circ(), myAttachPoint4),
LastPar = ElCLib::Parameter(aCircle->Circ(), myPoint4);
if (LastPar < FirstPar ) LastPar+=PI*2;
if (LastPar < FirstPar ) LastPar+=M_PI*2;
//add sensetive arc
Handle(Select3D_SensitiveCircle) circ =
new Select3D_SensitiveCircle( own,aCircle, FirstPar, LastPar);
@ -530,18 +530,18 @@ void AIS_EqualDistanceRelation::ComputeTwoEdgesLength( const Handle( Prs3d_Prese
if (PrPnt12.Distance(PrCenter) >Precision::Confusion())
{
gp_Dir aDir1(PrPnt12.XYZ() - PrCenter.XYZ());
Standard_Real anAngle = aDir1.Angle(XDir); //Get the angle in range [0, PI]
Standard_Real anAngle = aDir1.Angle(XDir); //Get the angle in range [0, M_PI]
if (aDir1.Dot(YDir) < 0)
anAngle = 2*Standard_PI - anAngle;
anAngle = 2 * M_PI - anAngle;
par1 = anAngle;
}
if (PrPnt22.Distance(PrCenter) >Precision::Confusion())
{
gp_Dir aDir2(PrPnt22.XYZ() - PrCenter.XYZ());
Standard_Real anAngle = aDir2.Angle(XDir); //Get the angle in range [0, PI]
Standard_Real anAngle = aDir2.Angle(XDir); //Get the angle in range [0, M_PI]
if (aDir2.Dot(YDir) < 0)
anAngle = 2*Standard_PI - anAngle;
anAngle = 2 * M_PI - anAngle;
par2 = anAngle;
}
@ -627,7 +627,7 @@ void AIS_EqualDistanceRelation::ComputeTwoVerticesLength( const Handle( Prs3d_Pr
else {
if (!samePoint) {
DirAttach.SetXYZ(SecondAttach.XYZ() - FirstAttach.XYZ());
DirAttach.Rotate(Plane->Pln().Axis(),PI/2.);
DirAttach.Rotate(Plane->Pln().Axis(),M_PI/2.);
}
}

8
src/AIS/AIS_EqualRadiusRelation.cxx

@ -84,8 +84,8 @@ void AIS_EqualRadiusRelation::Compute( const Handle( PrsMgr_PresentationManager3
}
else {
Standard_Real aPar = ElCLib::Parameter(FirstCirc, myFirstPoint);
if (IntegerPart(0.5*LastPar1/PI) != 0 && aPar < FirstPar1 )
aPar +=2*PI*IntegerPart(0.5*LastPar1/PI);
if (IntegerPart(0.5*LastPar1/M_PI) != 0 && aPar < FirstPar1 )
aPar +=2*M_PI*IntegerPart(0.5*LastPar1/M_PI);
Standard_Real aRadius = FirstCirc.Radius();
if (Abs(myFirstPoint.Distance(myFirstCenter) - aRadius) >= Precision::Confusion())
@ -104,8 +104,8 @@ void AIS_EqualRadiusRelation::Compute( const Handle( PrsMgr_PresentationManager3
aPar = ElCLib::Parameter(SecondCirc, mySecondPoint);
if (IntegerPart(0.5*LastPar2/PI) != 0 && aPar < FirstPar2 )
aPar +=2*PI*IntegerPart(0.5*LastPar2/PI);
if (IntegerPart(0.5*LastPar2/M_PI) != 0 && aPar < FirstPar2 )
aPar +=2*M_PI*IntegerPart(0.5*LastPar2/M_PI);
aRadius = SecondCirc.Radius();
if (Abs(mySecondPoint.Distance(mySecondCenter) - aRadius) >= Precision::Confusion())

22
src/AIS/AIS_FixRelation.cxx

@ -61,7 +61,7 @@ static Standard_Boolean InDomain(const Standard_Real fpar,
if (fpar >= 0.) {
return ((para >= fpar) && (para <= lpar));
}
if (para >= (fpar+2*PI)) return Standard_True;
if (para >= (fpar+2*M_PI)) return Standard_True;
if (para <= lpar) return Standard_True;
return Standard_False;
}
@ -270,7 +270,7 @@ void AIS_FixRelation::ComputeSelection(const Handle(SelectMgr_Selection)& aSelec
dirac.Normalize();
gp_Vec norac = dirac.Crossed(gp_Vec(norm));
gp_Ax1 ax(myPosition, norm);
norac.Rotate(ax, PI/8);
norac.Rotate(ax, M_PI/8);
norac*=(myArrowSize/2);
gp_Pnt P1 = myPosition.Translated(norac);
@ -414,7 +414,7 @@ gp_Pnt AIS_FixRelation::ComputePosition(const Handle(Geom_Curve)& curv,
gp_Vec transvec = vec*myArrowSize;
curpos = myPntAttach.Translated(transvec);
gp_Ax1 RotAx( myPntAttach, NormPln);
curpos.Rotate(RotAx, PI/10);
curpos.Rotate(RotAx, M_PI/10);
}
return curpos;
@ -526,10 +526,10 @@ void AIS_FixRelation::ComputeCirclePosition(
Standard_Real& plast)
{
// readjust parametres on the circle
if (plast > 2*PI ) {
Standard_Real nbtours = Floor(plast / (2*PI));
plast -= nbtours*2*PI;
pfirst -= nbtours*2*PI;
if (plast > 2*M_PI ) {
Standard_Real nbtours = Floor(plast / (2*M_PI));
plast -= nbtours*2*M_PI;
pfirst -= nbtours*2*M_PI;
}
if (myAutomaticPosition) {
@ -539,8 +539,8 @@ void AIS_FixRelation::ComputeCirclePosition(
Standard_Real circparam = (pfirst + plast)/2.;
if ( !InDomain(pfirst,plast,circparam)) {
Standard_Real otherpar = circparam + PI;
if (otherpar > 2*PI) otherpar -= 2*PI;
Standard_Real otherpar = circparam + M_PI;
if (otherpar > 2*M_PI) otherpar -= 2*M_PI;
circparam = otherpar;
}
@ -563,8 +563,8 @@ void AIS_FixRelation::ComputeCirclePosition(
Standard_Real circparam = ElCLib::Parameter(gcirc, pos);
if ( !InDomain(pfirst,plast,circparam)) {
Standard_Real otherpar = circparam + PI;
if (otherpar > 2*PI) otherpar -= 2*PI;
Standard_Real otherpar = circparam + M_PI;
if (otherpar > 2*M_PI) otherpar -= 2*M_PI;
circparam = otherpar;
}

38
src/AIS/AIS_IdenticRelation.cxx

@ -58,8 +58,8 @@
static Standard_Real Modulo2PI(const Standard_Real ANGLE)
{
if ( ANGLE < 0 ) return Modulo2PI(ANGLE + 2*PI);
else if ( ANGLE >= 2*PI ) return Modulo2PI(ANGLE - 2*PI);
if ( ANGLE < 0 ) return Modulo2PI(ANGLE + 2*M_PI);
else if ( ANGLE >= 2*M_PI ) return Modulo2PI(ANGLE - 2*M_PI);
return ANGLE;
}
@ -68,7 +68,7 @@ static Standard_Boolean IsEqual2PI(const Standard_Real angle1,
{
Standard_Real diff = Abs(angle1-angle2);
if ( diff < precision ) return Standard_True;
else if ( Abs(diff-2*PI) < precision ) return Standard_True;
else if ( Abs(diff-2*M_PI) < precision ) return Standard_True;
return Standard_False;
}
// jfa 15/10/2000 end
@ -187,18 +187,18 @@ static Standard_Boolean ComputeAttach(const gp_Circ& thecirc,
Standard_Real deltap = pSAttachM - pFAttach;
if ( deltap < 0 )
{
deltap += 2*Standard_PI;
pSAttachM += 2*Standard_PI;
deltap += 2 * M_PI;
pSAttachM += 2 * M_PI;
}
pSAttachM -= pFAttach;
Standard_Real pmiddleout = pSAttachM/2.0 + Standard_PI;
Standard_Real pmiddleout = pSAttachM/2.0 + M_PI;
Standard_Real pcurpos1 = pcurpos;
// define where curpos lays
if ( pcurpos1 < pFAttach )
{
pcurpos1 = pcurpos1 + 2*Standard_PI - pFAttach;
pcurpos1 = pcurpos1 + 2 * M_PI - pFAttach;
if ( pcurpos1 > pSAttachM ) // out
{
if ( pcurpos1 > pmiddleout ) pcurpos = pFAttach;
@ -255,18 +255,18 @@ static Standard_Boolean ComputeAttach(const gp_Elips& theEll,
Standard_Real deltap = pSAttachM - pFAttach;
if ( deltap < 0 )
{
deltap += 2*Standard_PI;
pSAttachM += 2*Standard_PI;
deltap += 2 * M_PI;
pSAttachM += 2 * M_PI;
}
pSAttachM -= pFAttach;
Standard_Real pmiddleout = pSAttachM/2.0 + Standard_PI;
Standard_Real pmiddleout = pSAttachM/2.0 + M_PI;
Standard_Real pcurpos1 = pcurpos;
// define where curpos lays
if ( pcurpos1 < pFAttach )
{
pcurpos1 = pcurpos1 + 2*Standard_PI - pFAttach;
pcurpos1 = pcurpos1 + 2 * M_PI - pFAttach;
if ( pcurpos1 > pSAttachM ) // out
{
if ( pcurpos1 > pmiddleout ) pcurpos = pFAttach;
@ -746,7 +746,7 @@ void AIS_IdenticRelation::ComputeTwoCirclesPresentation(const Handle(Prs3d_Prese
myCenter = thecirc->Location();
Standard_Real aSegSize = thecirc->Radius()/5.0;
Standard_Real rad = Standard_PI/5.0;
Standard_Real rad = M_PI / 5.0;
// I. Case of 2 complete circles
if ( circ1complete && circ2complete )
@ -984,7 +984,7 @@ void AIS_IdenticRelation::ComputeAutoArcPresentation(const Handle(Geom_Circle)&
const Standard_Boolean isstatic)
{
Standard_Real aSegSize = thecirc->Radius()/5.0;
Standard_Real rad = Standard_PI/5.0;
Standard_Real rad = M_PI / 5.0;
Standard_Real pFA = ElCLib::Parameter(thecirc->Circ(),firstp);
Standard_Real pSA = ElCLib::Parameter(thecirc->Circ(),lastp);
@ -1027,7 +1027,7 @@ void AIS_IdenticRelation::ComputeNotAutoCircPresentation(const Handle(Geom_Circl
curpos.Translate(vprec*1e-5);
}
Standard_Real rad = Standard_PI/5.0;
Standard_Real rad = M_PI / 5.0;
Standard_Real pcurpos = ElCLib::Parameter(cirNotAuto->Circ(),curpos);
Standard_Real pFAttach = pcurpos - rad;
Standard_Real pSAttach = pcurpos + rad;
@ -1055,7 +1055,7 @@ void AIS_IdenticRelation::ComputeNotAutoArcPresentation(const Handle(Geom_Circle
Standard_Real pSPnt = ElCLib::Parameter(cirNotAuto, pntlast);
Standard_Real deltap = Modulo2PI(pSPnt - pFPnt)/2.0;
Standard_Real rad = Standard_PI/5;
Standard_Real rad = M_PI / 5;
if ( deltap < rad )
{
myFAttach = pntfirst;
@ -1101,7 +1101,7 @@ void AIS_IdenticRelation::ComputeTwoEllipsesPresentation(const Handle(Prs3d_Pres
myCenter = theEll->Location();
Standard_Real aSegSize = theEll->MajorRadius()/5.0;
Standard_Real rad = Standard_PI/5.0;
Standard_Real rad = M_PI / 5.0;
// I. Case of 2 complete ellipses
if ( circ1complete && circ2complete )
@ -1338,7 +1338,7 @@ void AIS_IdenticRelation::ComputeAutoArcPresentation(const Handle(Geom_Ellipse)&
const Standard_Boolean isstatic)
{
Standard_Real aSegSize = theEll->MajorRadius()/5.0;
Standard_Real rad = Standard_PI/5.0;
Standard_Real rad = M_PI / 5.0;
gp_Elips anEll = theEll->Elips();
@ -1383,7 +1383,7 @@ void AIS_IdenticRelation::ComputeNotAutoElipsPresentation(const Handle(Geom_Elli
curpos.Translate(vprec*1e-5);
}
Standard_Real rad = Standard_PI/5.0;
Standard_Real rad = M_PI / 5.0;
// Standard_Real pcurpos = ElCLib::Parameter(anEll,curpos);
GeomAPI_ProjectPointOnCurve aProj (curpos, theEll);
Standard_Real pcurpos = aProj.LowerDistanceParameter();
@ -1414,7 +1414,7 @@ void AIS_IdenticRelation::ComputeNotAutoArcPresentation(const Handle(Geom_Ellips
Standard_Real pSPnt = ElCLib::Parameter(anEll, pntlast);
Standard_Real deltap = Modulo2PI(pSPnt - pFPnt)/2.0;
Standard_Real rad = Standard_PI/5;
Standard_Real rad = M_PI / 5;
if ( deltap < rad )
{
myFAttach = pntfirst;

6
src/AIS/AIS_InteractiveContext.cxx

@ -1650,7 +1650,7 @@ void AIS_InteractiveContext::SetDeviationAngle(const Standard_Real anAngle)
Standard_Real AIS_InteractiveContext::DeviationAngle() const
{
return PI/180.0e0 ;
return M_PI/180.0e0 ;
// return myDefaultDrawer->DeviationAngle();
}
@ -1963,7 +1963,7 @@ void AIS_InteractiveContext::SetColor(const Handle(AIS_InteractiveObject)& anIOb
// gp_Dir D =Tr->Component()->XDirection();
// gp_Pnt O = Tr->Component()->Location();
// gp_Vec V(D);V*=Lx/5.;
// T.SetRotation(gp_Ax1(O,D),PI/6.);
// T.SetRotation(gp_Ax1(O,D),M_PI/6.);
// T.SetTranslationPart(V);
// TopLoc_Location L,IncLoc(T);
@ -2128,7 +2128,7 @@ void AIS_InteractiveContext::SetAngleAndDeviation(
{
// cout<<" Angle:"<< anAngle <<endl;
if(anIObj.IsNull()) return ;
// Standard_Real anAngleRad = PI*anAngle/180; test rob...
// Standard_Real anAngleRad = M_PI*anAngle/180; test rob...
if(!anIObj->HasInteractiveContext())
anIObj->SetContext(this);

2
src/AIS/AIS_LengthDimension.cxx

@ -930,7 +930,7 @@ void AIS_LengthDimension::ComputeTwoVerticesLength( const Handle( Prs3d_Presenta
else {
if (!samePoint) {
DirAttach = gce_MakeDir(FirstAttach,SecondAttach);
DirAttach.Rotate(Plane->Pln().Axis(),PI/2.);
DirAttach.Rotate(Plane->Pln().Axis(),M_PI/2.);
}
}

20
src/AIS/AIS_MidPointRelation.cxx

@ -487,7 +487,7 @@ void AIS_MidPointRelation::ComputePointsOnCirc(const gp_Circ& aCirc,
Standard_Real pcurpos = ElCLib::Parameter(aCirc,curpos);
Standard_Real rad = Standard_PI/5.0;
Standard_Real rad = M_PI / 5.0;
Standard_Real segm;
Standard_Real pFPnt;
@ -507,18 +507,18 @@ void AIS_MidPointRelation::ComputePointsOnCirc(const gp_Circ& aCirc,
Standard_Real deltap = pSAttachM - pFAttach;
if ( deltap < 0 )
{
deltap += 2*Standard_PI;
pSAttachM += 2*Standard_PI;
deltap += 2 * M_PI;
pSAttachM += 2 * M_PI;
}
pSAttachM -= pFAttach;
Standard_Real pmiddleout = pSAttachM/2.0 + Standard_PI;
Standard_Real pmiddleout = pSAttachM/2.0 + M_PI;
Standard_Real pcurpos1 = pcurpos;
// define where curpos lays
if ( pcurpos1 < pFAttach )
{
pcurpos1 = pcurpos1 + 2*Standard_PI - pFAttach;
pcurpos1 = pcurpos1 + 2 * M_PI - pFAttach;
if ( pcurpos1 > pSAttachM ) // out
{
segm = Min(rad,deltap*0.75);
@ -614,7 +614,7 @@ void AIS_MidPointRelation::ComputePointsOnElips(const gp_Elips& anEll,
Standard_Real pcurpos = ElCLib::Parameter(anEll,curpos);
Standard_Real rad = Standard_PI/5.0;
Standard_Real rad = M_PI / 5.0;
Standard_Real segm;
Standard_Real pFPnt;
@ -634,18 +634,18 @@ void AIS_MidPointRelation::ComputePointsOnElips(const gp_Elips& anEll,
Standard_Real deltap = pSAttachM - pFAttach;
if ( deltap < 0 )
{
deltap += 2*Standard_PI;
pSAttachM += 2*Standard_PI;
deltap += 2 * M_PI;
pSAttachM += 2 * M_PI;
}
pSAttachM -= pFAttach;
Standard_Real pmiddleout = pSAttachM/2.0 + Standard_PI;
Standard_Real pmiddleout = pSAttachM / 2.0 + M_PI;
Standard_Real pcurpos1 = pcurpos;
// define where curpos lays
if ( pcurpos1 < pFAttach )
{
pcurpos1 = pcurpos1 + 2*Standard_PI - pFAttach;
pcurpos1 = pcurpos1 + 2 * M_PI - pFAttach;
if ( pcurpos1 > pSAttachM ) // out
{
segm = Min(rad,deltap*0.75);

20
src/AIS/AIS_RadiusDimension.cxx

@ -232,10 +232,10 @@ void AIS_RadiusDimension::InitFirstShape()
myCenter = myCircle.Location();
myCircle.SetRadius(myVal);
while (myFirstPar > 2*PI) myFirstPar -= 2*PI;
while (myFirstPar < 0.0 ) myFirstPar += 2*PI;
while (myLastPar > 2*PI) myLastPar -= 2*PI;
while (myLastPar < 0.0 ) myLastPar += 2*PI;
while (myFirstPar > 2*M_PI) myFirstPar -= 2*M_PI;
while (myFirstPar < 0.0 ) myFirstPar += 2*M_PI;
while (myLastPar > 2*M_PI) myLastPar -= 2*M_PI;
while (myLastPar < 0.0 ) myLastPar += 2*M_PI;
myPlane = new Geom_Plane(gp_Pln(gp_Ax3(myCircle.Position())));
myFirstLine = gce_MakeLin( myCenter, ElCLib::Value( myFirstPar, myCircle ) );
myLastLine = gce_MakeLin( myCenter, ElCLib::Value( myLastPar, myCircle ) );
@ -359,18 +359,18 @@ void AIS_RadiusDimension::ComputeRadius( const Handle( Prs3d_Presentation )& aPr
Standard_Real PosPar = ElCLib::Parameter( myCircle, myPosition );
if (!AIS::InDomain(myFirstPar, myLastPar, PosPar))
{ // not in domain
Standard_Real otherpar = PosPar + PI;
if (otherpar > 2*PI) otherpar -= 2*PI;
Standard_Real otherpar = PosPar + M_PI;
if (otherpar > 2*M_PI) otherpar -= 2*M_PI;
if (AIS::InDomain(myFirstPar, myLastPar, otherpar)){
PosPar = otherpar;// parameter on circle
myEndOfArrow = ElCLib::Value( PosPar, myCircle );
}
else {
Standard_Real Teta1 = Abs( PosPar - myFirstPar ), Teta2 = Abs( PosPar - myLastPar );
if (Teta1 > PI)
Teta1 = 2.0*PI - Teta1;
if (Teta2 > PI)
Teta2 = 2.0*PI - Teta2;
if (Teta1 > M_PI)
Teta1 = 2.0*M_PI - Teta1;
if (Teta2 > M_PI)
Teta2 = 2.0*M_PI - Teta2;
if (Teta1 < Teta2)
{
if(myFirstLine.Contains(myPosition,Precision::Confusion()))

2
src/AIS/AIS_TangentRelation.cxx

@ -227,7 +227,7 @@ static Standard_Boolean ComputeTangencyPoint(const Handle(Geom_Curve)& GC1,
ElCLib::D1(par_inter,ellipse->Elips(),P2,aVector2);
}
// if ( aVector1.IsParallel(aVector2, 100*Precision::Angular()) ) break;
if ( aVector1.IsParallel(aVector2, Standard_PI/360.0) ) break; // 0.5 graduce
if ( aVector1.IsParallel(aVector2, M_PI / 360.0) ) break; // 0.5 graduce
}
}
aPoint = PC1;

2
src/Adaptor3d/Adaptor3d_CurveOnSurface.cxx

@ -1323,7 +1323,7 @@ void Adaptor3d_CurveOnSurface::EvalKPart()
if ( D.IsParallel(gp::DX2d(),Precision::Angular())) { // Iso V.
if ( STy == GeomAbs_Sphere) {
gp_Pnt2d P = myCurve->Line().Location();
if ( Abs( Abs(P.Y()) -PI/2. ) >= Precision::PConfusion()) {
if ( Abs( Abs(P.Y()) -M_PI/2. ) >= Precision::PConfusion()) {
myType = GeomAbs_Circle;
gp_Sphere Sph = mySurface->Sphere();
gp_Ax3 Axis = Sph.Position();

10
src/Adaptor3d/Adaptor3d_SurfaceOfRevolution.cxx

@ -160,7 +160,7 @@ Standard_Real Adaptor3d_SurfaceOfRevolution::FirstUParameter() const
Standard_Real Adaptor3d_SurfaceOfRevolution::LastUParameter() const
{
return 2*PI;
return 2*M_PI;
}
//=======================================================================
@ -236,7 +236,7 @@ void Adaptor3d_SurfaceOfRevolution::UIntervals (TColStd_Array1OfReal& T,
const GeomAbs_Shape ) const
{
T(T.Lower() ) = 0.;
T(T.Lower()+1) = 2*PI;
T(T.Lower()+1) = 2*M_PI;
}
@ -276,7 +276,7 @@ Handle(Adaptor3d_HSurface) Adaptor3d_SurfaceOfRevolution::UTrim
Standard_Real Eps = Precision::PConfusion();
#endif
Standard_OutOfRange_Raise_if
( Abs(First) > Eps || Abs(Last - 2.*PI) > Eps,
( Abs(First) > Eps || Abs(Last - 2.*M_PI) > Eps,
"Adaptor3d_SurfaceOfRevolution : UTrim : Parameters out of range");
Handle(Adaptor3d_HSurfaceOfRevolution) HR =
@ -341,7 +341,7 @@ Standard_Boolean Adaptor3d_SurfaceOfRevolution::IsUPeriodic() const
Standard_Real Adaptor3d_SurfaceOfRevolution::UPeriod() const
{
return 2*PI;
return 2*M_PI;
}
//=======================================================================
@ -493,7 +493,7 @@ gp_Vec Adaptor3d_SurfaceOfRevolution::DN(const Standard_Real U,
}
else {
Standard_Real DNR = DNv * myAxeRev.XDirection();
gp_Vec DNu = ( myAxeRev.XDirection()).Rotated( myAxis, U + NU*PI/2);
gp_Vec DNu = ( myAxeRev.XDirection()).Rotated( myAxis, U + NU*M_PI/2);
return ( DNR * DNu);
}
}

2
src/Adaptor3d/Adaptor3d_TopolTool.cxx

@ -30,7 +30,7 @@ static void GetConeApexParam(const gp_Cone& C, Standard_Real& U, Standard_Real&
else {
U = atan2(Ploc.Y(),Ploc.X());
}
if (U < -1.e-16) U += (PI+PI);
if (U < -1.e-16) U += (M_PI+M_PI);
else if (U < 0) U = 0;
V = sin(SAngle) * ( Ploc.X() * cos(U) + Ploc.Y() * sin(U) - Radius)

4
src/AppParCurves/AppParCurves_Variational.gxx

@ -315,7 +315,7 @@ void AppParCurves_Variational::Init()
Vt2d=TabV2d.Value(jp2d);
Vt2d.Normalize();
Vc2d=TabV2dcurv.Value(jp2d);
if (Abs(Abs(Vc2d.Angle(Vt2d)) - PI/2.) > Precision::Angular())
if (Abs(Abs(Vc2d.Angle(Vt2d)) - M_PI/2.) > Precision::Angular())
Standard_ConstructionError::Raise();
myTabConstraints->SetValue(jndex++,Vt2d.X());
myTabConstraints->SetValue(jndex++,Vt2d.Y());
@ -373,7 +373,7 @@ void AppParCurves_Variational::Init()
Vt2d=TabV2d.Value(jp2d);
Vt2d.Normalize();
Vc2d=TabV2dcurv.Value(jp2d);
if (Abs(Abs(Vc2d.Angle(Vt2d)) - PI/2.) > Precision::Angular())
if (Abs(Abs(Vc2d.Angle(Vt2d)) - M_PI/2.) > Precision::Angular())
Standard_ConstructionError::Raise();
myTabConstraints->SetValue(jndex++,Vt2d.X());
myTabConstraints->SetValue(jndex++,Vt2d.Y());

8
src/ApproxInt/ApproxInt_ImpPrmSvSurfaces.gxx

@ -329,8 +329,8 @@ Standard_Boolean ApproxInt_ImpPrmSvSurfaces::Compute( Standard_Real& u1
v2 = X(2)-TranslationV;
ComputeParametersOnImplicitSurface(MyISurf,P,u1,v1);
if(MyISurf.TypeQuadric() != GeomAbs_Plane) {
while(u1-tu1>PI) u1-=PI+PI;
while(tu1-u1>PI) u1+=PI+PI;
while(u1-tu1>M_PI) u1-=M_PI+M_PI;
while(tu1-u1>M_PI) u1+=M_PI+M_PI;
}
MyParOnS1.SetCoord(tu1,tv1);
MyParOnS2.SetCoord(tu2,tv2);
@ -342,8 +342,8 @@ Standard_Boolean ApproxInt_ImpPrmSvSurfaces::Compute( Standard_Real& u1
v1 = X(2)-TranslationV;
ComputeParametersOnImplicitSurface(MyISurf,P,u2,v2);
if(MyISurf.TypeQuadric() != GeomAbs_Plane) {
while(u2-tu2>PI) u2-=PI+PI;
while(tu2-u2>PI) u2+=PI+PI;
while(u2-tu2>M_PI) u2-=M_PI+M_PI;
while(tu2-u2>M_PI) u2+=M_PI+M_PI;
}
MyParOnS1.SetCoord(tu1,tv1);
MyParOnS2.SetCoord(tu2,tu2);

4
src/Aspect/Aspect_CircularGrid.cxx

@ -71,7 +71,7 @@ void Aspect_CircularGrid::Compute(const Quantity_Length X,
Standard_Real cosinus = (X-xo)/d;
Standard_Real a = ACos(cosinus);
Standard_Real ra = RotationAngle();
if ( Y < yo ) a = 2*Standard_PI - a;
if ( Y < yo ) a = 2 * M_PI - a;
#ifdef OCC192_193
n = (Standard_Integer ) ((a-ra)/myAlpha + Sign(0.5, a-ra)) ;
#else
@ -149,6 +149,6 @@ return myDivisionNumber;
}
void Aspect_CircularGrid::Init () {
myAlpha = Standard_PI /Standard_Real(myDivisionNumber);
myAlpha = M_PI / Standard_Real(myDivisionNumber);
myA1 = Cos(myAlpha); myB1=Sin(myAlpha);
}

18
src/Aspect/Aspect_MarkerStyle.cxx

@ -252,7 +252,7 @@ void Aspect_MarkerStyle::SetPredefinedStyle() {
MySpoint = new TColStd_HArray1OfBoolean(1,MAX_O_POINT+1) ;
{ Standard_Integer i;
Standard_Real da = 2.*Standard_PI/MAX_O_POINT;
Standard_Real da = 2. * M_PI / MAX_O_POINT;
Standard_Real a = 0.;
for( i=1 ; i<= MAX_O_POINT+1 ; i++,a += da ) {
MyXpoint->SetValue(i,(float ) Cos(a));
@ -290,7 +290,7 @@ void Aspect_MarkerStyle::SetPredefinedStyle() {
MyYpoint = new TShort_HArray1OfShortReal(1,MAX_O_POINT+6) ;
MySpoint = new TColStd_HArray1OfBoolean(1,MAX_O_POINT+6) ;
{ Standard_Integer i;
Standard_Real da = 2.*Standard_PI/MAX_O_POINT;
Standard_Real da = 2. * M_PI / MAX_O_POINT;
Standard_Real a = 0.;
for( i=1 ; i<= MAX_O_POINT+1 ; i++,a += da ) {
MyXpoint->SetValue(i,(float ) Cos(a));
@ -328,7 +328,7 @@ void Aspect_MarkerStyle::SetPredefinedStyle() {
MySpoint = new TColStd_HArray1OfBoolean(1,MAX_O_POINT+5) ;
{ Standard_Integer i;
Standard_Real da = 2.*Standard_PI/MAX_O_POINT;
Standard_Real da = 2. * M_PI / MAX_O_POINT;
Standard_Real a = 0.;
for( i=1 ; i<= MAX_O_POINT+1 ; i++,a += da ) {
MyXpoint->SetValue(i,(float ) Cos(a));
@ -362,7 +362,7 @@ void Aspect_MarkerStyle::SetPredefinedStyle() {
MySpoint = new TColStd_HArray1OfBoolean(1,MAX_O_POINT+9) ;
{ Standard_Integer i;
Standard_Real da = 2.*Standard_PI/MAX_O_POINT;
Standard_Real da = 2. * M_PI / MAX_O_POINT;
Standard_Real a = 0.;
for( i=1 ; i<= MAX_O_POINT+1 ; i++,a += da ) {
MyXpoint->SetValue(i,(float ) Cos(a));
@ -412,7 +412,7 @@ void Aspect_MarkerStyle::SetPredefinedStyle() {
MySpoint = new TColStd_HArray1OfBoolean(1,MAX_O_POINT+5) ;
{ Standard_Integer i;
Standard_Real da = 2.*Standard_PI/MAX_O_POINT;
Standard_Real da = 2. * M_PI / MAX_O_POINT;
Standard_Real a = 0.;
for( i=1 ; i<= MAX_O_POINT+1 ; i++,a += da ) {
MyXpoint->SetValue(i,(float ) Cos(a));
@ -449,7 +449,7 @@ void Aspect_MarkerStyle::SetPredefinedStyle() {
MAX_BALL_LINE*(MAX_O_POINT+1)) ;
{ Standard_Integer i,j,n = 0;
Standard_Real da = 2.*Standard_PI/MAX_O_POINT;
Standard_Real da = 2. * M_PI / MAX_O_POINT;
Standard_Real dr = 1./MAX_BALL_LINE;
Standard_Real a,r = 1.;
@ -476,7 +476,7 @@ void Aspect_MarkerStyle::SetPredefinedStyle() {
(MAX_BALL_LINE/4)*(MAX_O_POINT+1)) ;
{ Standard_Integer i,j,n = 0;
Standard_Real da = 2.*Standard_PI/MAX_O_POINT;
Standard_Real da = 2. * M_PI / MAX_O_POINT;
Standard_Real dr = 1./MAX_BALL_LINE;
Standard_Real a,r = 1.;
@ -503,7 +503,7 @@ void Aspect_MarkerStyle::SetPredefinedStyle() {
(MAX_BALL_LINE/3)*(MAX_O_POINT+1)) ;
{ Standard_Integer i,j,n = 0;
Standard_Real da = 2.*Standard_PI/MAX_O_POINT;
Standard_Real da = 2. * M_PI / MAX_O_POINT;
Standard_Real dr = 1./MAX_BALL_LINE;
Standard_Real a,r = 1.;
@ -530,7 +530,7 @@ void Aspect_MarkerStyle::SetPredefinedStyle() {
(MAX_BALL_LINE)/2*(MAX_O_POINT+1)) ;
{ Standard_Integer i,j,n = 0;
Standard_Real da = 2.*Standard_PI/MAX_O_POINT;
Standard_Real da = 2. * M_PI / MAX_O_POINT;
Standard_Real dr = 1./MAX_BALL_LINE;
Standard_Real a,r = 1.;

12
src/Aspect/Aspect_RectangularGrid.cxx

@ -126,8 +126,8 @@ void Aspect_RectangularGrid::Init () {
// b1 = Sin (myFirstAngle + RotationAngle() );
// c1 = XOrigin() * b1 - YOrigin() * a1;
//
// a2 = Cos (mySecondAngle + RotationAngle() + Standard_PI/2.);
// b2 = Sin (mySecondAngle + RotationAngle() + Standard_PI/2.);
// a2 = Cos (mySecondAngle + RotationAngle() + M_PI / 2.);
// b2 = Sin (mySecondAngle + RotationAngle() + M_PI / 2.);
// c2 = XOrigin() * b2 - YOrigin() * a2;
#ifdef CSR577
@ -142,7 +142,7 @@ void Aspect_RectangularGrid::Init () {
}
if ( angle2 != 0. ) {
angle2 += Standard_PI/2.;
angle2 += M_PI / 2.;
a2 = -Sin (angle2);
b2 = Cos (angle2);
c2 = XOrigin() * b2 - YOrigin() * a2;
@ -154,8 +154,8 @@ void Aspect_RectangularGrid::Init () {
b1 = Cos (myFirstAngle + RotationAngle());
c1 = XOrigin() * b1 - YOrigin() * a1;
a2 = -Sin (mySecondAngle + RotationAngle() + Standard_PI/2.);
b2 = Cos (mySecondAngle + RotationAngle() + Standard_PI/2.);
a2 = -Sin (mySecondAngle + RotationAngle() + M_PI / 2.);
b2 = Cos (mySecondAngle + RotationAngle() + M_PI / 2.);
c2 = XOrigin() * b2 - YOrigin() * a2;
#endif
//-zov
@ -163,7 +163,7 @@ void Aspect_RectangularGrid::Init () {
Standard_Boolean Aspect_RectangularGrid::CheckAngle(const Standard_Real alpha,
const Standard_Real beta) const {
return (Abs( Sin(alpha) * Cos(beta+Standard_PI/2.) - Cos(alpha) * Sin(beta+Standard_PI/2.)) != 0) ;
return (Abs( Sin(alpha) * Cos(beta + M_PI / 2.) - Cos(alpha) * Sin(beta + M_PI / 2.)) != 0) ;
}

8
src/BOP/BOP_WireSplitter.cxx

@ -715,7 +715,7 @@ Standard_Real AngleIn(const TopoDS_Edge& aEIn,
Standard_Real ClockWiseAngle(const Standard_Real aAngleIn,
const Standard_Real aAngleOut)
{
const Standard_Real aTwoPi=Standard_PI+Standard_PI;
const Standard_Real aTwoPi = M_PI + M_PI;
Standard_Real dA, A1, A2, AIn, AOut ;
AIn=aAngleIn;
@ -728,7 +728,7 @@ Standard_Real ClockWiseAngle(const Standard_Real aAngleIn,
AOut=AOut-aTwoPi;
}
A1=AIn+Standard_PI;
A1 = AIn + M_PI;
if (A1 >= aTwoPi) {
A1=A1-aTwoPi;
@ -815,7 +815,7 @@ Standard_Real Angle2D (const TopoDS_Vertex& aV,
Standard_Real Angle (const gp_Dir2d& aDir2D)
{
const Standard_Real anAngle = gp_Dir2d(1.,0.).Angle(aDir2D);
return ((anAngle < 0.)? anAngle + Standard_PI + Standard_PI : anAngle);
return ((anAngle < 0.)? anAngle + M_PI + M_PI : anAngle);
}
//=======================================================================
@ -974,7 +974,7 @@ Standard_Boolean RecomputeAngles(const BOP_ListOfEdgeInfo& aLEInfo,
bIgnore = (aD > theTol2D);
}
if(!bIgnore && (theTol2D > PI)) {
if(!bIgnore && (theTol2D > M_PI)) {
Standard_Real udist = fabs(aP2Dx.X() - thePb.X());
Standard_Real vdist = fabs(aP2Dx.Y() - thePb.Y());
Standard_Real aTolU = 2. * UTolerance2D(theVb, theGAS);

4
src/BOPTools/BOPTools_PaveFiller_3.cxx

@ -3304,8 +3304,8 @@ void CorrectTolR3D(BOPTools_PaveFiller& aPF,
//
aA=aDN[0].Angle(aDN[1]);
aA=fabs(aA);
if (aA>0.5*PI) {
aA=PI-aA;
if (aA>0.5*M_PI) {
aA=M_PI-aA;
}
//
if (aA<aAmin || aA>aAmax) {

2
src/BOPTools/BOPTools_Tools2D.cxx

@ -674,7 +674,7 @@ static
Standard_Real BOPTools_Tools2D::IntermediatePoint (const Standard_Real aFirst,
const Standard_Real aLast)
{
//define parameter division number as 10*e^(-PI) = 0.43213918
//define parameter division number as 10*e^(-M_PI) = 0.43213918
const Standard_Real PAR_T = 0.43213918;
Standard_Real aParm;
aParm=(1.-PAR_T)*aFirst + PAR_T*aLast;

2
src/BOPTools/BOPTools_Tools3D.cxx

@ -1022,7 +1022,7 @@ static void GetApproxNormalToFaceOnEdgeEx(const TopoDS_Edge& aE,
{
Standard_Real d12, d1, anAlfa12, anAlfa1, aTwoPI;
aTwoPI=Standard_PI+Standard_PI;
aTwoPI = M_PI + M_PI;
gp_Vec aVx1(aPx, aPx1);
gp_Dir aDBx1 (aVx1);

2
src/BRepAlgo/BRepAlgo_DSAccess.cxx

@ -1408,7 +1408,7 @@ void BRepAlgo_DSAccess::PntVtxOnCurve
if(iMother) igoodC = iMother;
//#ifndef DEB
TopOpeBRepDS_PointIterator PII = myHDS->CurvePoints(igoodC);
TopOpeBRepDS_PointIterator& PIt = PII; // skl : I change "PI" to "PIt"
TopOpeBRepDS_PointIterator& PIt = PII; // skl : I change "M_PI" to "PIt"
//#else
// TopOpeBRepDS_PointIterator& PIt = myHDS->CurvePoints(igoodC);
//#endif

4
src/BRepBlend/BRepBlend_RstRstConstRad.cxx

@ -290,7 +290,7 @@ Standard_Boolean BRepBlend_RstRstConstRad::IsSolution(const math_Vector& Sol,
Angle = ACos(Cosa);
if (Sina < 0.) {
Angle = 2.*PI - Angle;
Angle = 2.*M_PI - Angle;
}
if (Angle > maxang) {maxang = Angle;}
@ -609,7 +609,7 @@ void BRepBlend_RstRstConstRad::Section(const Standard_Real Param,
Pfin = ElCLib::Parameter(C, ptrst2);
// Test of angles negative and almost null : Special Case
if (Pfin > 1.5 * PI) {
if (Pfin > 1.5 * M_PI) {
np.Reverse();
C.SetPosition(gp_Ax2(Center, np, ns));
Pfin = ElCLib::Parameter(C, ptrst2);

4
src/BRepBlend/BRepBlend_RstRstEvolRad.cxx

@ -361,7 +361,7 @@ Standard_Boolean BRepBlend_RstRstEvolRad::IsSolution(const math_Vector& Sol,
Angle = ACos(Cosa);
if (Sina < 0.) {
Angle = 2.*PI - Angle;
Angle = 2.*M_PI - Angle;
}
if (Angle > maxang) {maxang = Angle;}
@ -678,7 +678,7 @@ void BRepBlend_RstRstEvolRad::Section(const Standard_Real Param,
Pfin = ElCLib::Parameter(C, ptrst2);
// Test negative and quasi null angles: Special case
if (Pfin > 1.5 * PI) {
if (Pfin > 1.5 * M_PI) {
np.Reverse();
C.SetPosition(gp_Ax2(Center, np, ns));
Pfin = ElCLib::Parameter(C, ptrst2);

4
src/BRepBlend/BRepBlend_SurfRstConstRad.cxx

@ -406,7 +406,7 @@ Standard_Boolean BRepBlend_SurfRstConstRad::IsSolution(const math_Vector& Sol,
Angle = ACos(Cosa);
if (Sina <0.) {
Angle = 2.*PI - Angle;
Angle = 2.*M_PI - Angle;
}
if (Angle>maxang) {maxang = Angle;}
@ -663,7 +663,7 @@ void BRepBlend_SurfRstConstRad::Section(const Standard_Real Param,
Pfin = ElCLib::Parameter(C,ptrst);
// Test negative and almost null angles : Special case
if (Pfin>1.5*PI) {
if (Pfin>1.5*M_PI) {
np.Reverse();
C.SetPosition(gp_Ax2(Center,np,ns));
Pfin = ElCLib::Parameter(C,ptrst);

4
src/BRepBlend/BRepBlend_SurfRstEvolRad.cxx

@ -463,7 +463,7 @@ const Standard_Real Tol)
Angle = ACos(Cosa);
if (Sina <0.) {
Angle = 2.*PI - Angle;
Angle = 2.*M_PI - Angle;
}
if (Angle>maxang) {maxang = Angle;}
@ -708,7 +708,7 @@ gp_Circ& C)
Pfin = ElCLib::Parameter(C,ptrst);
// Test negative and almost null angles : Single Case
if (Pfin>1.5*PI) {
if (Pfin>1.5*M_PI) {
np.Reverse();
C.SetPosition(gp_Ax2(Center,np,ns));
Pfin = ElCLib::Parameter(C,ptrst);

4
src/BRepBuilderAPI/BRepBuilderAPI_Sewing.cxx

@ -196,7 +196,7 @@ static Standard_Boolean IsClosedShape(const TopoDS_Shape& theshape,
if (TotLength > 0.0) {
gp_Pnt p1 = BRep_Tool::Pnt(TopoDS::Vertex(v1));
gp_Pnt p2 = BRep_Tool::Pnt(TopoDS::Vertex(v2));
return (p1.Distance(p2) < TotLength/(1.2 * PI));
return (p1.Distance(p2) < TotLength/(1.2 * M_PI));
}
return Standard_False;
}
@ -983,7 +983,7 @@ void BRepBuilderAPI_Sewing::EvaluateAngulars(TopTools_SequenceOfShape& sequenceS
else if ((n.Magnitude()>gp::Resolution()) && (normRef(j).Magnitude()>gp::Resolution())) {
nbComputedAngle++;
Standard_Real angular = n.Angle(normRef(j));
if (angular > PI/2.) angular = PI - angular;
if (angular > M_PI/2.) angular = M_PI - angular;
cumulateAngular += angular;
}
}

2
src/BRepCheck/BRepCheck_Wire.cxx

@ -1549,7 +1549,7 @@ static TopAbs_Orientation GetOrientation(const TopTools_MapOfShape& mapE,
angle = DerRef.Angle( Der );
angle *= -1.;
if (angle < 0.)
angle += 2.*PI;
angle += 2.*M_PI;
if (F.Orientation() == TopAbs_FORWARD) {
if (angle < MinAngle) {

4
src/BRepFeat/BRepFeat.cxx

@ -511,11 +511,11 @@ void BRepFeat::FaceUntil(const TopoDS_Shape& Sbase,
}
else if (styp == STANDARD_TYPE(Geom_CylindricalSurface)) {
str = new Geom_RectangularTrimmedSurface
(s, 0., 2.*PI, bnd, -bnd, Standard_True, Standard_True);
(s, 0., 2.*M_PI, bnd, -bnd, Standard_True, Standard_True);
}
else if (styp == STANDARD_TYPE(Geom_ConicalSurface)) {
str = new Geom_RectangularTrimmedSurface
(s, 0., 2.*PI, bnd, -bnd, Standard_True, Standard_True);
(s, 0., 2.*M_PI, bnd, -bnd, Standard_True, Standard_True);
}
else {
FUntil.Nullify();

2
src/BRepFeat/BRepFeat_MakeLinearForm.cxx

@ -199,7 +199,7 @@ void BRepFeat_MakeLinearForm::Init(const TopoDS_Shape& Sbase,
gp_Vec nulldir(0, 0, 0);
if(!myDir1.IsEqual(nulldir, myTol, myTol)) {
Standard_Real ang = myDir1.Angle(myDir);
if(ang != PI) {
if(ang != M_PI) {
#ifdef DEB
if (trc) cout << " Directions must be opposite" << endl;
#endif

20
src/BRepFeat/BRepFeat_MakeRevol.cxx

@ -229,7 +229,7 @@ void BRepFeat_MakeRevol::Perform(const Standard_Real Angle)
myGluedF.Clear();
myPerfSelection = BRepFeat_NoSelection;
PerfSelectionValid();
Standard_Boolean RevolComp = (2*PI-Abs(Angle) <= Precision::Angular());
Standard_Boolean RevolComp = (2*M_PI-Abs(Angle) <= Precision::Angular());
LocOpe_Revol theRevol;
Standard_Real angledec = 0.;
TopExp_Explorer exp;
@ -238,7 +238,7 @@ void BRepFeat_MakeRevol::Perform(const Standard_Real Angle)
if (!mySkface.IsNull() || !mySlface.IsEmpty()) {
for (exp.Init(mySbase,TopAbs_FACE); exp.More(); exp.Next()) {
if (exp.Current().IsSame(mySkface)) {
angledec = PI/5; // pourquoi pas
angledec = M_PI/5; // pourquoi pas
if (myFuse) angledec = -angledec;
break;
}
@ -362,7 +362,7 @@ void BRepFeat_MakeRevol::Perform(const TopoDS_Shape& Until)
Standard_ConstructionError::Raise();
}
if (!mySkface.IsNull() && Until.IsSame(mySkface)) {
Angle = 2*PI;
Angle = 2*M_PI;
TourComplet = Standard_True;
}
myGluedF.Clear();
@ -375,10 +375,10 @@ void BRepFeat_MakeRevol::Perform(const TopoDS_Shape& Until)
ShapeUntilValid();
// Do systematically almost complete revolution
// BRepSweep_Revol theRevol(myPbase,myAxis,2.*PI-10.*Precision::Angular());
// BRepSweep_Revol theRevol(myPbase,myAxis,2.*M_PI-10.*Precision::Angular());
LocOpe_Revol theRevol;
if(!TourComplet) {
Angle = 2.*PI- 3*PI/180.;
Angle = 2.*M_PI- 3*M_PI/180.;
#ifdef DEB
if (trc) cout << " No complete Revolution" << endl;
#endif
@ -565,7 +565,7 @@ void BRepFeat_MakeRevol::Perform(const TopoDS_Shape& From,
}
LocOpe_Revol theRevol;
theRevol.Perform(myPbase, myAxis, 2*PI);
theRevol.Perform(myPbase, myAxis, 2*M_PI);
TopoDS_Shape VraiRevol = theRevol.Shape();
MajMap(myPbase,theRevol,myMap,myFShape,myLShape);
@ -607,9 +607,9 @@ void BRepFeat_MakeRevol::Perform(const TopoDS_Shape& From,
}
if (ASI2.IsDone() && ASI2.NbPoints(1) >=1) {
Standard_Real pr1 = ASI2.Point(1,1).Parameter();
pr1 = ElCLib::InPeriod(pr1,PrU-2*PI,PrU);
pr1 = ElCLib::InPeriod(pr1,PrU-2*M_PI,PrU);
Standard_Real pr2 = ASI2.Point(1,ASI2.NbPoints(1)).Parameter();
pr2 = ElCLib::InPeriod(pr2,PrU-2*PI,PrU);
pr2 = ElCLib::InPeriod(pr2,PrU-2*M_PI,PrU);
OrF = OrU;
FFrom = ASI2.Point(1,1).Face();
PrF = Max(pr1, pr2);
@ -689,7 +689,7 @@ void BRepFeat_MakeRevol::PerformThruAll()
Standard_Boolean trc = BRepFeat_GettraceFEAT();
if (trc) cout << "BRepFeat_MakeRevol::PerformThruAll()" << endl;
#endif
Perform(2.*PI);
Perform(2.*M_PI);
}
//=======================================================================
@ -728,7 +728,7 @@ void BRepFeat_MakeRevol::PerformUntilAngle(const TopoDS_Shape& Until,
ShapeUntilValid();
// Produce systematicallt an almost complete revolution
// BRepSweep_Revol theRevol(myPbase,myAxis,2.*PI-10.*Precision::Angular());
// BRepSweep_Revol theRevol(myPbase,myAxis,2.*M_PI-10.*Precision::Angular());
LocOpe_Revol theRevol;
theRevol.Perform(myPbase, myAxis, Angle);
TopoDS_Shape VraiRevol = theRevol.Shape();

12
src/BRepFeat/BRepFeat_MakeRevolutionForm.cxx

@ -221,13 +221,13 @@ void BRepFeat_MakeRevolutionForm::Init(const TopoDS_Shape& Sbase,
if(Rad <= height) Rad = height + 0.01*height;
myAngle1 = asin(H1/Rad) + PI/10.;
myAngle2 = asin(H2/Rad) + PI/10.;
myAngle1 = asin(H1/Rad) + M_PI/10.;
myAngle2 = asin(H2/Rad) + M_PI/10.;
if((myAngle1 - PI/2) > Precision::Confusion())
myAngle1 = PI/2;
if((myAngle2 - PI/2) > Precision::Confusion())
myAngle2 = PI/2;
if((myAngle1 - M_PI/2) > Precision::Confusion())
myAngle1 = M_PI/2;
if((myAngle2 - M_PI/2) > Precision::Confusion())
myAngle2 = M_PI/2;
mySkface.Nullify();
myPbase.Nullify();

2
src/BRepFeat/BRepFeat_RibSlot.cxx

@ -1023,7 +1023,7 @@ TopoDS_Face BRepFeat_RibSlot::ChoiceOfFaces(TopTools_ListOfShape& faces,
gp_Ax1 Axe(pp, Pln->Position().Direction());
for ( Standard_Integer i = 1; i <=8; i++) {
Handle(Geom_Curve) L =
Handle(Geom_Curve)::DownCast(l1->Rotated(Axe, i*PI/9.));
Handle(Geom_Curve)::DownCast(l1->Rotated(Axe, i*M_PI/9.));
scur.Append(L);
Counter++;
}

4
src/BRepFill/BRepFill.cxx

@ -912,8 +912,8 @@ void BRepFill::SearchOrigin(TopoDS_Wire & W,
Ve *= -1;
}
angle = Ve.Angle(Dir);
if (angle > PI) angle = 2*PI - angle;
forward = (angle <= PI/2);
if (angle > M_PI) angle = 2*M_PI - angle;
forward = (angle <= M_PI/2);
// Reconstruction
MakeWire( Edges, rangdeb, forward, W);

20
src/BRepFill/BRepFill_CompatibleWires.cxx

@ -554,8 +554,8 @@ static void Transform (const Standard_Boolean WithRotation,
gp_Ax1 Norm(Pos2,norm2);
Standard_Real ang = axe1.AngleWithRef(axe2,norm2);
if (!WithRotation) {
if (ang>PI/2) ang = ang - PI;
if (ang<-PI/2) ang = ang + PI;
if (ang>M_PI/2) ang = ang - M_PI;
if (ang<-M_PI/2) ang = ang + M_PI;
}
ang *= sign;
Pnew = Pnew.Rotated (Norm,ang);
@ -1742,7 +1742,7 @@ void BRepFill_CompatibleWires::ComputeOrigin(const Standard_Boolean polar )
// recherche du vertex correspondant a la projection conique
Standard_Real angmin, angV, eta = Precision::Angular();
TopoDS_Vertex Vopti;
angmin = PI/2;
angmin = M_PI/2;
distmini = Precision::Infinite();
gp_Dir dir0(gp_Vec(Pnew,P.Location()));
for (Standard_Integer ii=1;ii<=SeqV.Length();ii++) {
@ -1755,7 +1755,7 @@ void BRepFill_CompatibleWires::ComputeOrigin(const Standard_Boolean polar )
gp_Dir dir1(gp_Vec(Pnew,P1));
angV = dir1.Angle(dir0);
}
if (angV>PI/2) angV = PI - angV;
if (angV>M_PI/2) angV = M_PI - angV;
if (angmin>angV+eta) {
distmini = dist;
angmin = angV;
@ -2009,11 +2009,11 @@ void BRepFill_CompatibleWires::SearchOrigin()
norm = vec1 ^ vec2;
gp_Ax1 Norm(P.Location(),norm);
Standard_Real ang = vec1.AngleWithRef(vec2,norm);
if (ang > PI/2.0)
ang = PI - ang;
if (ang < -PI/2.0)
ang = -PI - ang;
if (Abs(ang-PI/2.0)<Precision::Angular()) {
if (ang > M_PI/2.0)
ang = M_PI - ang;
if (ang < -M_PI/2.0)
ang = -M_PI - ang;
if (Abs(ang-M_PI/2.0)<Precision::Angular()) {
// cas d'ambiguite
gp_Vec Vtrans(P0.Location(),P.Location()),Vsign;
Standard_Real alpha,beta,sign=1;
@ -2037,7 +2037,7 @@ void BRepFill_CompatibleWires::SearchOrigin()
};
gp_Vec VDebFin0(P1o,P2o), VDebFin(P1,P2);
Standard_Real AStraight = VDebFin0.Angle(VDebFin);
parcours = (AStraight < PI/2.0? Standard_True: Standard_False);
parcours = (AStraight < M_PI/2.0? Standard_True: Standard_False);
}
// reconstruction of the wire

6
src/BRepFill/BRepFill_Draft.cxx

@ -479,7 +479,7 @@ static Standard_Boolean GoodOrientation(const Bnd_Box& B,
gp_Dir BN(M.Column(2));
Standard_Real ang = myDir.Angle(BN);
if (ang > PI/2) D.Reverse();
if (ang > M_PI/2) D.Reverse();
Handle(Geom_Line) L = new (Geom_Line) (P, D);
Handle(Geom_Curve) TC = new (Geom_TrimmedCurve) (L, 0, Length);
@ -534,7 +534,7 @@ static Standard_Boolean GoodOrientation(const Bnd_Box& B,
V = V1.Crossed(V2);
if (F.Orientation() == TopAbs_REVERSED) V.Reverse();
if (V.Magnitude() > 1.e-10) {
out = myDir.Angle(V) > PI/2;
out = myDir.Angle(V) > M_PI/2;
}
if (out == IsInternal) {
myShell.Reverse();
@ -705,7 +705,7 @@ static Standard_Boolean GoodOrientation(const Bnd_Box& B,
}
// Subtract State1
if (myDir.Angle(SP.Normal()) < PI/2) State1 = TopAbs_IN;
if (myDir.Angle(SP.Normal()) < M_PI/2) State1 = TopAbs_IN;
else State1 = TopAbs_OUT;
}

6
src/BRepFill/BRepFill_Evolved.cxx

@ -2189,7 +2189,7 @@ void BRepFill_Evolved::MakePipe(const TopoDS_Edge& SE,
gp_Trsf trsf;
if (Side(myProfile,BRepFill_Confusion()) > 3) { // side right
trsf.SetRotation(gp::OZ(),PI);
trsf.SetRotation(gp::OZ(),M_PI);
}
TopLoc_Location DumLoc (trsf);
TopoDS_Shape aLocalShape = myProfile.Moved(DumLoc);
@ -2276,7 +2276,7 @@ void BRepFill_Evolved::MakeRevol(const TopoDS_Edge& SE,
gp_Trsf trsf;
if (Side(myProfile,BRepFill_Confusion()) > 3) { // side right
trsf.SetRotation(gp::OZ(),PI);
trsf.SetRotation(gp::OZ(),M_PI);
}
TopLoc_Location DumLoc (trsf);
TopoDS_Shape aLocalShape = myProfile.Moved(DumLoc);
@ -2294,7 +2294,7 @@ void BRepFill_Evolved::MakeRevol(const TopoDS_Edge& SE,
// Position of the sewing on the edge of the spine
// so that the bissectrices didn't cross the sewings.
gp_Trsf dummy;
dummy.SetRotation(AxeRev, 1.5*PI);
dummy.SetRotation(AxeRev, 1.5*M_PI);
TopLoc_Location DummyLoc(dummy);
GenProf.Move(DummyLoc);

2
src/BRepFill/BRepFill_Filling.cxx

@ -396,7 +396,7 @@ void BRepFill_Filling::FindExtremitiesOfHoles( TopTools_MapOfShape& WireMap, TCo
#else
Standard_Boolean IsLast ;
#endif
Standard_Real MinAngle = PI;
Standard_Real MinAngle = M_PI;
for (MapIt.Initialize( WireMap ); MapIt.More(); MapIt.Next())
{

10
src/BRepFill/BRepFill_MultiLine.cxx

@ -215,11 +215,11 @@ myKPart(0)
}
if (GAS1.GetType() == GeomAbs_Sphere) {
if (myIsoU1)
ElCLib::AdjustPeriodic(-PI/2.,PI/2.,
ElCLib::AdjustPeriodic(-M_PI/2.,M_PI/2.,
Precision::PConfusion(),
Umin, Umax);
else
ElCLib::AdjustPeriodic(-PI/2.,PI/2.,
ElCLib::AdjustPeriodic(-M_PI/2.,M_PI/2.,
Precision::PConfusion(),
Vmin, Vmax);
}
@ -331,11 +331,11 @@ myKPart(0)
}
if (GAS2.GetType() == GeomAbs_Sphere) {
if (myIsoU2)
ElCLib::AdjustPeriodic(-PI/2.,PI/2.,
ElCLib::AdjustPeriodic(-M_PI/2.,M_PI/2.,
Precision::PConfusion(),
Umin, Umax);
else
ElCLib::AdjustPeriodic(-PI/2.,PI/2.,
ElCLib::AdjustPeriodic(-M_PI/2.,M_PI/2.,
Precision::PConfusion(),
Vmin, Vmax);
}
@ -612,7 +612,7 @@ static gp_Pnt2d ValueOnFace(const Standard_Real U,
Standard_Real Ang = Axis.Angle(D12d);
if ( !TheU.Circle().IsDirect()) Ang = -Ang;
UU = ElCLib::InPeriod( Ang, TheU.FirstParameter(),
TheU.FirstParameter() + 2*PI);
TheU.FirstParameter() + 2*M_PI);
Dist = TheU.Circle().Radius();
}
else {

4
src/BRepFill/BRepFill_OffsetWire.cxx

@ -1601,7 +1601,7 @@ Standard_Integer CutEdge (const TopoDS_Edge& E,
//if (E.Orientation() == TopAbs_REVERSED) CT2d->Reverse();
if (CT2d->BasisCurve()->IsKind(STANDARD_TYPE(Geom2d_Circle)) &&
( Abs(f-l) >= PI) ) {
( Abs(f-l) >= M_PI) ) {
return 0;
//---------------------------
// Cut closed circle.
@ -1844,7 +1844,7 @@ void MakeOffset (const TopoDS_Edge& E,
Adaptor3d_OffsetCurve Off(AHC,-anOffset);
Handle(Geom2d_Circle) CC = new Geom2d_Circle(Off.Circle());
Standard_Real Delta = 2*PI - l + f;
Standard_Real Delta = 2*M_PI - l + f;
f -= 0.2*Delta; l += 0.2*Delta;
G2dOC = new Geom2d_TrimmedCurve(CC,f,l);

6
src/BRepFill/BRepFill_Sweep.cxx

@ -842,11 +842,11 @@ static Standard_Boolean Filling(const TopoDS_Shape& EF,
Standard_Boolean ToReverseResult = Standard_False;
gp_Vec d1u;
d1u = Surf->DN(0, (f1+l1)/2, 1, 0);
if (d1u.Angle(TangentOnPart1) > PI/2) { //Invert everything
if (d1u.Angle(TangentOnPart1) > M_PI/2) { //Invert everything
ToReverseResult = Standard_True;
/*
axe.Reverse();
Angle = 2*PI - Angle;
Angle = 2*M_PI - Angle;
Rev = new (Geom_SurfaceOfRevolution) (Prof1, axe);
Surf = new (Geom_RectangularTrimmedSurface)
(Rev, 0, Angle, f1, l1);
@ -1148,7 +1148,7 @@ static Standard_Boolean Filling(const TopoDS_Shape& EF,
AS->D1(P2d.X(), P2d.Y(), P, D1U, D1V);
N2 = D1U^D1V;
if ( (F1.Orientation() == TopAbs_REVERSED) ^ (N1.Angle(N2)>PI/2) )
if ( (F1.Orientation() == TopAbs_REVERSED) ^ (N1.Angle(N2)>M_PI/2) )
Result.Orientation(TopAbs_REVERSED);
else Result.Orientation(TopAbs_FORWARD);

16
src/BRepFill/BRepFill_TrimShellCorner.cxx

@ -2281,8 +2281,8 @@ static Standard_Boolean ChooseSection(const TopoDS_Shape& Comp,
continue;
Standard_Real Angle = aPln.Axis().Angle( bis.Axis() );
if (Angle > PI/2)
Angle = PI - Angle;
if (Angle > M_PI/2)
Angle = M_PI - Angle;
if (Angle < MinAngle)
{
@ -2341,7 +2341,7 @@ static Standard_Boolean ChoosePlane(const TopoDS_Shape& Comp,
TColgp_Array1OfPnt Origins( 0, NumberOfEdges*2-1 );
TColgp_Array1OfDir Normals( 0, NumberOfEdges*2-1 );
TColStd_Array1OfBoolean IsSingular( 0, NumberOfEdges*2-1 );
Standard_Real MinAngle = PI/2;
Standard_Real MinAngle = M_PI/2;
Standard_Integer MinInd;
for (ind = 0; ind < NumberOfEdges*2; ind++)
{
@ -2355,8 +2355,8 @@ static Standard_Boolean ChoosePlane(const TopoDS_Shape& Comp,
Origins(ind) = Axe.Location();
Normals(ind) = Axe.Direction();
Standard_Real Angle = bis.Angle( Axe );
if (Angle > PI/2)
Angle = PI - Angle;
if (Angle > M_PI/2)
Angle = M_PI - Angle;
if (Angle < MinAngle)
{
MinAngle = Angle;
@ -2366,15 +2366,15 @@ static Standard_Boolean ChoosePlane(const TopoDS_Shape& Comp,
}
gp_Ax2 TheAxe( Origins(MinInd), Normals(MinInd) );
Standard_Real MaxAngleWithPln = PI/16;
Standard_Real MaxAngleWithPln = M_PI/16;
TColStd_SequenceOfInteger iseq;
TColgp_SequenceOfPnt Pseq;
for (ind = 0; ind < NumberOfEdges*2; ind++)
if (!IsSingular(ind))
{
Standard_Real Angle = Normals(ind).Angle( TheAxe.Direction() );
if (Angle > PI/2)
Angle = PI - Angle;
if (Angle > M_PI/2)
Angle = M_PI - Angle;
if (Angle <= MaxAngleWithPln)
{
iseq.Append(ind);

8
src/BRepFill/BRepFill_TrimSurfaceTool.cxx

@ -166,7 +166,7 @@ static Standard_Real EvalPhase(const TopoDS_Edge& Edge,
gp_Pnt P = GAS.Value(0., V);
if ( gp_Vec(Axis.Location(), P).Dot(Axis.XDirection()) < 0.)
return PI;
return M_PI;
else
return 0.;
}
@ -339,7 +339,7 @@ static void EvalParameters(const TopoDS_Edge& Edge,
case GeomAbs_Cone: {
//----------------------------------------------------------
// if myFace1 is not at the same side of the apex as the point
// of parameter 0 0 on the cone => phase = PI.
// of parameter 0 0 on the cone => phase = M_PI.
//----------------------------------------------------------
Axis = GAS.Cone().Position();
Phase = EvalPhase(Edge,Face,GAS,Axis);
@ -352,7 +352,7 @@ static void EvalParameters(const TopoDS_Edge& Edge,
case GeomAbs_SurfaceOfRevolution: {
//----------------------------------------------------------
// if myFace1 is not at the same side of the apex as the point
// of parameter 0 0 on the cone => phase = PI.
// of parameter 0 0 on the cone => phase = M_PI.
//----------------------------------------------------------
Handle(Geom_SurfaceOfRevolution) GSRev =
Handle(Geom_SurfaceOfRevolution)::DownCast(GS);
@ -373,7 +373,7 @@ static void EvalParameters(const TopoDS_Edge& Edge,
Standard_Real U = Axis.XDirection().
AngleWithRef(D1,Axis.XDirection()^Axis.YDirection());
U += Phase;
if ( U < 0.) U += 2*PI;
if ( U < 0.) U += 2*M_PI;
P = gp_Pnt(Bis->FirstParameter(), U, 0.);
Seq.Append(P);

8
src/BRepGProp/BRepGProp_Face.cxx

@ -318,7 +318,7 @@ void BRepGProp_Face::UKnots(TColStd_Array1OfReal& Knots) const
case GeomAbs_Cone:
case GeomAbs_Sphere:
case GeomAbs_Torus:
Knots(1) = 0.0; Knots(2) = PI*2.0/3.0; Knots(3) = PI*4.0/3.0; Knots(4) = PI*6.0/3.0;
Knots(1) = 0.0; Knots(2) = M_PI*2.0/3.0; Knots(3) = M_PI*4.0/3.0; Knots(4) = M_PI*6.0/3.0;
break;
case GeomAbs_BSplineSurface:
(*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->UKnots(Knots);
@ -343,10 +343,10 @@ void BRepGProp_Face::VKnots(TColStd_Array1OfReal& Knots) const
Knots(1) = mySurface.FirstUParameter(); Knots(2) = mySurface.LastUParameter();
break;
case GeomAbs_Sphere:
Knots(1) = -PI/2.0; Knots(2) = 0.0; Knots(3) = +PI/2.0;
Knots(1) = -M_PI/2.0; Knots(2) = 0.0; Knots(3) = +M_PI/2.0;
break;
case GeomAbs_Torus:
Knots(1) = 0.0; Knots(2) = PI*2.0/3.0; Knots(3) = PI*4.0/3.0; Knots(4) = PI*6.0/3.0;
Knots(1) = 0.0; Knots(2) = M_PI*2.0/3.0; Knots(3) = M_PI*4.0/3.0; Knots(4) = M_PI*6.0/3.0;
break;
case GeomAbs_BSplineSurface:
(*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->VKnots(Knots);
@ -450,7 +450,7 @@ void BRepGProp_Face::LKnots(TColStd_Array1OfReal& Knots) const
break;
case GeomAbs_Circle:
case GeomAbs_Ellipse:
Knots(1) = 0.0; Knots(2) = PI*2.0/3.0; Knots(3) = PI*4.0/3.0; Knots(2) = PI*6.0/3.0;
Knots(1) = 0.0; Knots(2) = M_PI*2.0/3.0; Knots(3) = M_PI*4.0/3.0; Knots(2) = M_PI*6.0/3.0;
break;
case GeomAbs_Parabola:
case GeomAbs_Hyperbola:

2
src/BRepLib/BRepLib.cxx

@ -1511,7 +1511,7 @@ static Standard_Boolean tgtfaces(const TopoDS_Edge& Ed,
Standard_Boolean rev1 = (F1.Orientation() == TopAbs_REVERSED);
Standard_Boolean rev2 = (F2.Orientation() == TopAbs_REVERSED);
Standard_Real f,l,eps, angmax = -PI;
Standard_Real f,l,eps, angmax = -M_PI;
#ifndef DEB
Standard_Real ang =0.;
#else

6
src/BRepMesh/BRepMesh_Classifier.cxx

@ -48,7 +48,7 @@ static Standard_Integer debclass = 0;
#endif
static const Standard_Real MIN_DIST = 2.E-5; //EPA: real mesh is created in the grid 10E5x10E5, so intersection should be cheched
// with double of discretization.
static const Standard_Real PARALL_COND = Sin(PI/3.0);
static const Standard_Real PARALL_COND = Sin(M_PI/3.0);
static const Standard_Real RESOLUTION = 1.0E-16; //OCC319
@ -119,7 +119,7 @@ void BRepMesh_Classifier::AnalizeWire (const TColgp_SequenceOfPnt2d& theSeqPnt2
const Standard_Real a = A.Angle(B);
const Standard_Real aa = Abs(a);
// Check if vectors are opposite
if (aa > Precision::Angular() && (PI - aa) > Precision::Angular())
if (aa > Precision::Angular() && (M_PI - aa) > Precision::Angular())
{
theangle += a;
p1 = p2;
@ -340,7 +340,7 @@ static Standard_Boolean checkWiresIntersection(const Standard_Integer
aLoopArea += triangle2Area(p2, p3);
aLoopArea += triangle2Area(p3, aStartPoint); // Last triangle area
if( Abs(aLoopArea)/2 > PI*MIN_DIST )
if( Abs(aLoopArea)/2 > M_PI*MIN_DIST )
{
if ( findNextIntersection )
{

6
src/BRepOffset/BRepOffset.cxx

@ -60,7 +60,7 @@ Handle(Geom_Surface) BRepOffset::Surface(const Handle(Geom_Surface)& Surface,
Result = new Geom_CylindricalSurface( Axis, Radius);
}
else if ( Radius <= -Tol ){
Axis.Rotate(gp_Ax1(Axis.Location(),Axis.Direction()),PI);
Axis.Rotate(gp_Ax1(Axis.Location(),Axis.Direction()),M_PI);
Result = new Geom_CylindricalSurface( Axis, Abs(Radius));
Status = BRepOffset_Reversed;
}
@ -84,7 +84,7 @@ Handle(Geom_Surface) BRepOffset::Surface(const Handle(Geom_Surface)& Surface,
gp_Vec Z( Axis.Direction());
Z *= - Offset * Sin(Alpha);
Axis.Translate(Z);
Axis.Rotate(gp_Ax1(Axis.Location(),Axis.Direction()),PI);
Axis.Rotate(gp_Ax1(Axis.Location(),Axis.Direction()),M_PI);
Alpha = -Alpha;
}
Result = new Geom_ConicalSurface(Axis, Alpha, Radius);
@ -102,7 +102,7 @@ Handle(Geom_Surface) BRepOffset::Surface(const Handle(Geom_Surface)& Surface,
Result = new Geom_SphericalSurface(Axis, Radius);
}
else if ( Radius <= -Tol ) {
Axis.Rotate(gp_Ax1(Axis.Location(),Axis.Direction()),PI);
Axis.Rotate(gp_Ax1(Axis.Location(),Axis.Direction()),M_PI);
Axis.ZReverse();
Result = new Geom_SphericalSurface(Axis, -Radius);
Status = BRepOffset_Reversed;

22
src/BRepOffset/BRepOffset_MakeOffset.cxx

@ -1946,7 +1946,7 @@ void BRepOffset_MakeOffset::CorrectConicalFaces()
ElSLib::Parameters( theSphere, fPnt, Uf, Vf );
ElSLib::Parameters( theSphere, lPnt, Ul, Vl );
if (Abs(Ul) <= Precision::Confusion())
Ul = 2.*PI;
Ul = 2.*M_PI;
Handle(Geom_Curve) aCurv = aSphSurf->VIso(Vf);
/*
if (!isFirstFace)
@ -2078,11 +2078,11 @@ void BRepOffset_MakeOffset::CorrectConicalFaces()
Standard_Real Vfirst, Vlast;
if (p2d1.Y() > 0.)
{
Vfirst = p2d1.Y(); Vlast = PI/2.;
Vfirst = p2d1.Y(); Vlast = M_PI/2.;
}
else
{
Vfirst = -PI/2.; Vlast = p2d1.Y();
Vfirst = -M_PI/2.; Vlast = p2d1.Y();
}
TopoDS_Face NewSphericalFace = BRepLib_MakeFace(aSphSurf, Ufirst, Ulast, Vfirst, Vlast, Precision::Confusion());
TopoDS_Edge OldEdge;
@ -2154,12 +2154,12 @@ void BRepOffset_MakeOffset::CorrectConicalFaces()
apex = OffSurf->Value( Uapex, Vapex );
//Making new degenerated edge
Handle(Geom2d_Line) theLine = GCE2d_MakeLine( gp_Pnt2d( 0., Vapex ), gp_Pnt2d( 2.*PI, Vapex ) );
Handle(Geom2d_Line) theLine = GCE2d_MakeLine( gp_Pnt2d( 0., Vapex ), gp_Pnt2d( 2.*M_PI, Vapex ) );
TopoDS_Edge NewEdge;
BB.MakeEdge( NewEdge );
NewEdge.Orientation(TopAbs_FORWARD);
BB.UpdateEdge( NewEdge, theLine, Cone, Precision::Confusion() );
BB.Range( NewEdge, 0., 2.*PI );
BB.Range( NewEdge, 0., 2.*M_PI );
BB.SameParameter( NewEdge, Standard_True );
BB.SameRange( NewEdge, Standard_True );
BB.Degenerated( NewEdge, Standard_True );
@ -2250,12 +2250,12 @@ void BRepOffset_MakeOffset::CorrectConicalFaces()
apex = OffSurf->Value( Uapex, Vapex );
//Making new degenerated edge
Handle(Geom2d_Line) theLine = GCE2d_MakeLine( gp_Pnt2d( 0., Vapex ), gp_Pnt2d( 2.*PI, Vapex ) );
Handle(Geom2d_Line) theLine = GCE2d_MakeLine( gp_Pnt2d( 0., Vapex ), gp_Pnt2d( 2.*M_PI, Vapex ) );
TopoDS_Edge NewEdge;
BB.MakeEdge( NewEdge );
NewEdge.Orientation(TopAbs_FORWARD);
BB.UpdateEdge( NewEdge, theLine, Cone, BRep_Tool::Tolerance( Circ ) );
BB.Range( NewEdge, 0., 2.*PI );
BB.Range( NewEdge, 0., 2.*M_PI );
BB.SameParameter( NewEdge, Standard_True );
BB.SameRange( NewEdge, Standard_True );
BB.Degenerated( NewEdge, Standard_True );
@ -2358,9 +2358,9 @@ void BRepOffset_MakeOffset::CorrectConicalFaces()
ElSLib::Parameters( theSphere, OrPnt, Uor, Vor );
TopoDS_Face NewFace;
if (Vor > 0.)
NewFace = BRepLib_MakeFace( theSphere, 0., 2.*PI, Vor, PI/2. );
NewFace = BRepLib_MakeFace( theSphere, 0., 2.*M_PI, Vor, M_PI/2. );
else
NewFace = BRepLib_MakeFace( theSphere, 0., 2.*PI, -PI/2., Vor );
NewFace = BRepLib_MakeFace( theSphere, 0., 2.*M_PI, -M_PI/2., Vor );
//Updating the bound of NewFace
TopoDS_Edge Bound;
@ -2436,12 +2436,12 @@ void BRepOffset_MakeOffset::CorrectConicalFaces()
apex = OffSurf->Value( Uapex, Vapex );
//Making new degenerated edge
Handle(Geom2d_Line) theLine = GCE2d_MakeLine( gp_Pnt2d( 0., Vapex ), gp_Pnt2d( 2.*PI, Vapex ) );
Handle(Geom2d_Line) theLine = GCE2d_MakeLine( gp_Pnt2d( 0., Vapex ), gp_Pnt2d( 2.*M_PI, Vapex ) );
TopoDS_Edge NewEdge;
BB.MakeEdge( NewEdge );
NewEdge.Orientation(TopAbs_FORWARD);
BB.UpdateEdge( NewEdge, theLine, Cone, BRep_Tool::Tolerance( Circ ) );
BB.Range( NewEdge, 0., 2.*PI );
BB.Range( NewEdge, 0., 2.*M_PI );
BB.SameParameter( NewEdge, Standard_True );
BB.SameRange( NewEdge, Standard_True );
BB.Degenerated( NewEdge, Standard_True );

14
src/BRepOffset/BRepOffset_Offset.cxx

@ -203,7 +203,7 @@ static void ComputeCurve3d(TopoDS_Edge Edge,
if ( D.IsParallel(gp::DX2d(),Precision::Angular())) { // Iso V.
if ( STy == GeomAbs_Sphere) {
gp_Pnt2d P = C.Line().Location();
if ( Abs( Abs(P.Y()) -PI/2. ) < Precision::PConfusion()) {
if ( Abs( Abs(P.Y()) -M_PI/2. ) < Precision::PConfusion()) {
TheBuilder.Degenerated(Edge, Standard_True);
}
else {
@ -1391,18 +1391,18 @@ void BRepOffset_Offset::Init(const TopoDS_Vertex& Vertex,
// V` = +/- PI + 2 k` PI
gp_Pnt2d P2d = PCurve->Value(f);
Standard_Boolean IsToAdjust = Standard_False;
if ( P2d.Y() < -PI/2.) {
if ( P2d.Y() < -M_PI/2.) {
IsToAdjust = Standard_True;
PCurve->Mirror(gp_Ax2d(gp_Pnt2d(0.,-PI/2.),gp::DX2d()));
PCurve->Mirror(gp_Ax2d(gp_Pnt2d(0.,-M_PI/2.),gp::DX2d()));
}
else if ( P2d.Y() > PI/2.) {
else if ( P2d.Y() > M_PI/2.) {
IsToAdjust = Standard_True;
PCurve->Mirror(gp_Ax2d(gp_Pnt2d(0., PI/2.),gp::DX2d()));
PCurve->Mirror(gp_Ax2d(gp_Pnt2d(0., M_PI/2.),gp::DX2d()));
}
if ( IsToAdjust) {
// set the u firstpoint in [0,2*pi]
gp_Vec2d Tr( PI, 0.);
if ( P2d.X() > PI) Tr.Reverse();
gp_Vec2d Tr( M_PI, 0.);
if ( P2d.X() > M_PI) Tr.Reverse();
PCurve->Translate(Tr);
}

6
src/BRepOffset/BRepOffset_Tool.cxx

@ -994,7 +994,7 @@ static Standard_Boolean BSplineEdges(const TopoDS_Edge& E1,
if (Der1.Magnitude() <= gp::Resolution() ||
Der2.Magnitude() <= gp::Resolution())
angle = PI/2.;
angle = M_PI/2.;
else
angle = Der1.Angle(Der2);
@ -1031,7 +1031,7 @@ static Standard_Real AngleWireEdge(const TopoDS_Wire& aWire,
if (V11.IsSame(CV) && V21.IsSame(CV))
{
BSplineEdges( FirstEdge, anEdge, 0, 0, Angle );
Angle = PI - Angle;
Angle = M_PI - Angle;
}
else if (V11.IsSame(CV) && V22.IsSame(CV))
BSplineEdges( FirstEdge, anEdge, 0, 1, Angle );
@ -1040,7 +1040,7 @@ static Standard_Real AngleWireEdge(const TopoDS_Wire& aWire,
else
{
BSplineEdges( FirstEdge, anEdge, 1, 1, Angle );
Angle = PI - Angle;
Angle = M_PI - Angle;
}
return Angle;
}

10
src/BRepOffsetAPI/BRepOffsetAPI_DraftAngle.cxx

@ -804,18 +804,18 @@ void BRepOffsetAPI_DraftAngle::CorrectWires()
Pmid = bc2d.Value( (bc2d.FirstParameter()+bc2d.LastParameter())/2. );
gp_Vec2d offset;
Standard_Boolean translate = Standard_False;
if (Pfirst.X()-2.*PI > Precision::Confusion() ||
Plast.X()-2.*PI > Precision::Confusion() ||
Pmid.X()-2.*PI > Precision::Confusion())
if (Pfirst.X()-2.*M_PI > Precision::Confusion() ||
Plast.X()-2.*M_PI > Precision::Confusion() ||
Pmid.X()-2.*M_PI > Precision::Confusion())
{
offset.SetCoord( -2.*PI, 0 );
offset.SetCoord( -2.*M_PI, 0 );
translate = Standard_True;
}
if (Pfirst.X() < -Precision::Confusion() ||
Plast.X() < -Precision::Confusion() ||
Pmid.X() < -Precision::Confusion())
{
offset.SetCoord( 2.*PI, 0 );
offset.SetCoord( 2.*M_PI, 0 );
translate = Standard_True;
}
if (translate)

8
src/BRepPrim/BRepPrim_Cone.cxx

@ -31,7 +31,7 @@ BRepPrim_Cone::BRepPrim_Cone(const Standard_Real Angle,
Standard_DomainError::Raise("cone with null height");
if (myHalfAngle*Height < Precision::Confusion())
Standard_DomainError::Raise("cone with null angle");
if ((PI/2 - myHalfAngle)*Height < Precision::Confusion())
if ((M_PI/2 - myHalfAngle)*Height < Precision::Confusion())
Standard_DomainError::Raise("cone with angle > PI/2");
// cut at top
@ -50,7 +50,7 @@ BRepPrim_Cone::BRepPrim_Cone(const Standard_Real Angle) :
myHalfAngle(Angle),
myRadius(0.)
{
if ((Angle < 0) || (Angle > PI/2))
if ((Angle < 0) || (Angle > M_PI/2))
Standard_DomainError::Raise("cone with angle <0 or > PI/2");
VMin(0.);
SetMeridian();
@ -68,7 +68,7 @@ BRepPrim_Cone::BRepPrim_Cone(const Standard_Real Angle,
myHalfAngle(Angle),
myRadius(0.)
{
if ((Angle < 0) || (Angle > PI/2))
if ((Angle < 0) || (Angle > M_PI/2))
Standard_DomainError::Raise("cone with angle <0 or > PI/2");
VMin(0.);
SetMeridian();
@ -84,7 +84,7 @@ BRepPrim_Cone::BRepPrim_Cone(const Standard_Real Angle,
BRepPrim_Revolution( Axes, 0,RealLast()),
myHalfAngle(Angle)
{
if ((Angle < 0) || (Angle > PI/2))
if ((Angle < 0) || (Angle > M_PI/2))
Standard_DomainError::Raise("cone with angle <0 or > PI/2");
VMin(0.);
SetMeridian();

6
src/BRepPrim/BRepPrim_Sphere.cxx

@ -16,8 +16,8 @@
// parameters on the meridian
#define PMIN (-0.5*PI)
#define PMAX (0.5*PI)
#define PMIN (-0.5*M_PI)
#define PMAX (0.5*M_PI)
//=======================================================================
//function : BRepPrim_Sphere
@ -82,7 +82,7 @@ void BRepPrim_Sphere::SetMeridian()
// Offset the parameters on the meridian
// to trim the edge in 3pi/2, 5pi/2
SetMeridianOffset(2*PI);
SetMeridianOffset(2*M_PI);
gp_Dir D = Axes().YDirection();
D.Reverse();

6
src/BRepPrim/BRepPrim_Torus.cxx

@ -24,7 +24,7 @@
BRepPrim_Torus::BRepPrim_Torus(const gp_Ax2& Position,
const Standard_Real Major,
const Standard_Real Minor) :
BRepPrim_Revolution(Position,0,2*PI),
BRepPrim_Revolution(Position,0,2*M_PI),
myMajor(Major),
myMinor(Minor)
{
@ -38,7 +38,7 @@ BRepPrim_Torus::BRepPrim_Torus(const gp_Ax2& Position,
BRepPrim_Torus::BRepPrim_Torus(const Standard_Real Major,
const Standard_Real Minor) :
BRepPrim_Revolution(gp::XOY(),0,2*PI),
BRepPrim_Revolution(gp::XOY(),0,2*M_PI),
myMajor(Major),
myMinor(Minor)
{
@ -54,7 +54,7 @@ BRepPrim_Torus::BRepPrim_Torus(const gp_Pnt& Center,
const Standard_Real Major,
const Standard_Real Minor) :
BRepPrim_Revolution(gp_Ax2(Center,gp_Dir(0,0,1),gp_Dir(1,0,0)),
0,2*PI),
0,2*M_PI),
myMajor(Major),
myMinor(Minor)
{

14
src/BRepSweep/BRepSweep_Revol.cxx

@ -41,10 +41,10 @@ BRepSweep_Revol::BRepSweep_Revol
const gp_Ax1& Ax,
const Standard_Boolean C):
myRotation(S.Oriented(TopAbs_FORWARD),
NumShape(2*PI),
Location(Ax,2*PI),
Axe(Ax,2*PI),
Angle(2*PI),
NumShape(2*M_PI),
Location(Ax,2*M_PI),
Axe(Ax,2*M_PI),
Angle(2*M_PI),
C)
{
@ -125,7 +125,7 @@ TopoDS_Shape BRepSweep_Revol::LastShape(const TopoDS_Shape& aGenS)
Sweep_NumShape BRepSweep_Revol::NumShape(const Standard_Real D)const
{
Sweep_NumShape N;
if (Abs(Angle(D) - 2*PI)<=Precision::Angular()){
if (Abs(Angle(D) - 2*M_PI)<=Precision::Angular()){
N.Init(2,TopAbs_EDGE,Standard_True,
Standard_False,Standard_False);
}
@ -172,8 +172,8 @@ gp_Ax1 BRepSweep_Revol::Axe(const gp_Ax1& Ax, const Standard_Real D)const
Standard_Real BRepSweep_Revol::Angle(const Standard_Real D)const
{
Standard_Real d = Abs(D);
while(d>(2*PI + Precision::Angular())){
d = d - 2*PI;
while(d>(2*M_PI + Precision::Angular())){
d = d - 2*M_PI;
}
return d;
}

24
src/BRepSweep/BRepSweep_Rotation.cxx

@ -454,7 +454,7 @@ void BRepSweep_Rotation::SetGeneratingPCurve
Standard_Real U = BC.FirstParameter();
point = BC.Value(U);
if (point.Distance(tor.Location()) < Precision::Confusion()) {
v = PI;
v = M_PI;
// modified by NIZHNY-EAP Wed Mar 1 17:49:29 2000 ___BEGIN___
u = 0.;
}
@ -463,15 +463,15 @@ void BRepSweep_Rotation::SetGeneratingPCurve
tor.MinorRadius(),point,u,v);
}
// u = 0.;
v = ElCLib::InPeriod(v,0.,2*PI);
if((2*PI - v) <= Precision::PConfusion()) v -= 2*PI;
v = ElCLib::InPeriod(v,0.,2*M_PI);
if((2*M_PI - v) <= Precision::PConfusion()) v -= 2*M_PI;
if (aDirV.Index() == 2) {
Standard_Real uLeft = u-myAng;
ElCLib::AdjustPeriodic(-PI,PI,Precision::PConfusion(),uLeft,u);
ElCLib::AdjustPeriodic(-M_PI,M_PI,Precision::PConfusion(),uLeft,u);
}
else {
Standard_Real uRight = u+myAng;
ElCLib::AdjustPeriodic(-PI,PI,Precision::PConfusion(),u,uRight);
ElCLib::AdjustPeriodic(-M_PI,M_PI,Precision::PConfusion(),u,uRight);
}
// modified by NIZHNY-EAP Wed Mar 1 17:49:32 2000 ___END___
pnt2d.SetCoord(u,v-U);
@ -575,7 +575,7 @@ void BRepSweep_Rotation::SetDirectingPCurve
BRepAdaptor_Curve BC(TopoDS::Edge(aGenE));
p1 = BC.Value(BC.FirstParameter());
if (p1.Distance(tor.Location()) < Precision::Confusion()){
v1 = PI;
v1 = M_PI;
// modified by NIZHNY-EAP Thu Mar 2 09:43:26 2000 ___BEGIN___
u1 = 0.;
// modified by NIZHNY-EAP Thu Mar 2 15:28:59 2000 ___END___
@ -586,16 +586,16 @@ void BRepSweep_Rotation::SetDirectingPCurve
}
p2 = BC.Value(BC.LastParameter());
if (p2.Distance(tor.Location()) < Precision::Confusion()){
v2 = PI;
v2 = M_PI;
}
else {
ElSLib::TorusParameters(tor.Position(),tor.MajorRadius(),
tor.MinorRadius(),p2,u2,v2);
}
ElCLib::AdjustPeriodic(0.,2*PI,Precision::PConfusion(),v1,v2);
ElCLib::AdjustPeriodic(0.,2*M_PI,Precision::PConfusion(),v1,v2);
// modified by NIZHNY-EAP Thu Mar 2 15:29:04 2000 ___BEGIN___
u2 = u1 + myAng;
ElCLib::AdjustPeriodic(-PI,PI,Precision::PConfusion(),u1,u2);
ElCLib::AdjustPeriodic(-M_PI,M_PI,Precision::PConfusion(),u1,u2);
if (aGenV.Orientation()==TopAbs_FORWARD){
p22d.SetCoord(u1,v1);
}
@ -747,7 +747,7 @@ Standard_Boolean BRepSweep_Rotation::GDDShapeIsToAdd
aGenS.ShapeType() == TopAbs_FACE &&
aDirS.Type() == TopAbs_EDGE &&
aSubDirS.Type() == TopAbs_VERTEX ){
return ( Abs(myAng - 2 * PI) > Precision::Angular() );
return ( Abs(myAng - 2 * M_PI) > Precision::Angular() );
}
else if ( aNewShape.ShapeType() == TopAbs_FACE &&
aNewSubShape.ShapeType() == TopAbs_EDGE &&
@ -757,7 +757,7 @@ Standard_Boolean BRepSweep_Rotation::GDDShapeIsToAdd
TopLoc_Location Loc;
GeomAdaptor_Surface AS(BRep_Tool::Surface(TopoDS::Face(aNewShape),Loc));
if (AS.GetType()==GeomAbs_Plane){
return ( Abs(myAng - 2 * PI) > Precision::Angular() );
return ( Abs(myAng - 2 * M_PI) > Precision::Angular() );
}
else {
return Standard_True;
@ -789,7 +789,7 @@ Standard_Boolean BRepSweep_Rotation::SeparatedWires
TopLoc_Location Loc;
GeomAdaptor_Surface AS(BRep_Tool::Surface(TopoDS::Face(aNewShape),Loc));
if (AS.GetType()==GeomAbs_Plane){
return (Abs(myAng-2*PI) <= Precision::Angular());
return (Abs(myAng-2*M_PI) <= Precision::Angular());
}
else{
return Standard_False;

2
src/BRepTest/BRepTest_BasicCommands.cxx

@ -105,7 +105,7 @@ static Standard_Integer transform(Draw_Interpretor& di,Standard_Integer n,const
if (n < 9) return 1;
T.SetRotation(gp_Ax1(gp_Pnt(atof(a[n-7]),atof(a[n-6]),atof(a[n-5])),
gp_Vec(atof(a[n-4]),atof(a[n-3]),atof(a[n-2]))),
atof(a[n-1])* PI180);
atof(a[n-1])* (M_PI / 180.0));
last = n-7;
}
else if (!strcmp(a[0],"tmirror")) {

4
src/BRepTest/BRepTest_ChamferCommands.cxx

@ -103,11 +103,11 @@ static Standard_Integer chamfer(Draw_Interpretor& di,
if (!E.IsNull() && !F.IsNull() && (aMCh.Contour(E) == 0) ) {
d1 = atof(a[i + 3]);
angle = atof(a[i + 4]);
angle *= PI / 180.;
angle *= M_PI / 180.;
if ( (d1 > Precision::Confusion())
&& (angle > Precision::Confusion())
&& (PI / 2.- angle > Precision::Confusion()) )
&& (M_PI / 2.- angle > Precision::Confusion()) )
aMCh.AddDA(d1, angle, E, F);
}
i += 5;

8
src/BRepTest/BRepTest_CurveCommands.cxx

@ -700,7 +700,7 @@ static Standard_Integer profile(Draw_Interpretor& di,
case 'r':
i++;
if (i >= n) goto badargs;
angle = atof(a[i]) * PI180;
angle = atof(a[i]) * (M_PI / 180.0);
if ((a[i-1][1] == 'R') || (a[i-1][1] == 'r')) {
dx = Cos(angle);
dy = Sin(angle);
@ -736,7 +736,7 @@ static Standard_Integer profile(Draw_Interpretor& di,
if (i >= n) goto badargs;
radius = atof(a[i-1]);
if (Abs(radius) > Precision::Confusion()) {
angle = atof(a[i]) * PI180;
angle = atof(a[i]) * (M_PI / 180.0);
move = circle;
}
break;
@ -1288,7 +1288,7 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
case 'r':
i++;
if (i >= n) goto badargs;
angle = atof(a[i]) * PI180;
angle = atof(a[i]) * (M_PI / 180.0);
if ((a[i-1][1] == 'R') || (a[i-1][1] == 'r')) {
dx = Cos(angle);
dy = Sin(angle);
@ -1324,7 +1324,7 @@ static Standard_Integer profile2d(Draw_Interpretor& di,
if (i >= n) goto badargs;
radius = atof(a[i-1]);
if (Abs(radius) > Precision::Confusion()) {
angle = atof(a[i]) * PI180;
angle = atof(a[i]) * (M_PI / 180.0);
move = circle;
}
break;

4
src/BRepTest/BRepTest_DraftAngleCommands.cxx

@ -58,7 +58,7 @@ static Standard_Integer DEP(Draw_Interpretor& theCommands,
TopoDS_Shape aLocalShape(DBRep::Get(a[8*ii+6],TopAbs_FACE));
F = TopoDS::Face(aLocalShape);
// F = TopoDS::Face(DBRep::Get(a[8*ii+6],TopAbs_FACE));
Angle = atof(a[8*ii+7])*PI/180.;
Angle = atof(a[8*ii+7])*M_PI/180.;
Pax.SetCoord(atof(a[8*ii+8]),atof(a[8*ii+9]),atof(a[8*ii+10]));
Dax.SetCoord(atof(a[8*ii+11]),atof(a[8*ii+12]),atof(a[8*ii+13]));
drft.Add(F,Dirextract,Angle,gp_Pln(Pax,Dax));
@ -122,7 +122,7 @@ static Standard_Integer NDEP(Draw_Interpretor& theCommands,
//#else
Flag = (Standard_Boolean ) atof(a[9*ii+7]);
//#endif
Angle = atof(a[9*ii+8])*PI/180.;
Angle = atof(a[9*ii+8])*M_PI/180.;
Pax.SetCoord(atof(a[9*ii+9]),atof(a[9*ii+10]),atof(a[9*ii+11]));
Dax.SetCoord(atof(a[9*ii+12]),atof(a[9*ii+13]),atof(a[9*ii+14]));
drft.Add(F,Dirextract,Angle,gp_Pln(Pax,Dax), Flag);

10
src/BRepTest/BRepTest_FeatureCommands.cxx

@ -1107,7 +1107,7 @@ static Standard_Integer ROW(Draw_Interpretor& theCommands,
FFrom = DBRep::Get(a[4],TopAbs_SHAPE);
if (FFrom.IsNull()) {
Angle = atof(a[4]);
Angle *=PI/180.;
Angle *=M_PI/180.;
i = 5;
}
else {
@ -1268,7 +1268,7 @@ static Standard_Integer ROF(Draw_Interpretor& theCommands,
FFrom = DBRep::Get(a[4],TopAbs_SHAPE);
if (FFrom.IsNull()) {
Angle = atof(a[4]);
Angle *=PI/180.;
Angle *=M_PI/180.;
i = 5;
}
else {
@ -1589,7 +1589,7 @@ static Standard_Integer DEFIN(Draw_Interpretor& theCommands,
theCommands << "Invalid DPrism base";
return 1;
}
Standard_Real Angle = atof(a[4])*PI/360;
Standard_Real Angle = atof(a[4])*M_PI/360;
dprdef = Standard_True;
theDPrism.Init(Sbase,TopoDS::Face(Pbase),Skface,Angle,Fuse,Modify);
}
@ -1773,7 +1773,7 @@ static Standard_Integer PERF(Draw_Interpretor& theCommands,
thePrism.Perform(Val);
}
else if (Kas == 2) {
Val *=(PI/180.);
Val *=(M_PI/180.);
theRevol.Perform(Val);
}
else if (Kas == 4) {
@ -1795,7 +1795,7 @@ static Standard_Integer PERF(Draw_Interpretor& theCommands,
thePrism.PerformUntilHeight(FUntil, Val);
}
else if (Kas == 2) {
Val *=(PI/180.);
Val *=(M_PI/180.);
theRevol.PerformUntilAngle(FUntil, Val);
}
else if (Kas == 4) {

2
src/BRepTest/BRepTest_Fillet2DCommands.cxx

@ -106,7 +106,7 @@ static Standard_Integer chfi2d(Draw_Interpretor& di, Standard_Integer n, const c
MF.AddChamfer(E1,E2,p1,p2);
}
else {
MF.AddChamfer(E1,V,p1,p2*PI180);
MF.AddChamfer(E1,V,p1,p2 * (M_PI / 180.0));
}
}

32
src/BRepTest/BRepTest_PrimitiveCommands.cxx

@ -108,7 +108,7 @@ static Standard_Integer cylinder(Draw_Interpretor& , Standard_Integer n, const c
}
else if (n == 5) {
if (P.IsNull())
S = BRepPrimAPI_MakeCylinder(atof(a[2]),atof(a[3]),atof(a[4]) * PI180);
S = BRepPrimAPI_MakeCylinder(atof(a[2]),atof(a[3]),atof(a[4]) * (M_PI / 180.0));
else
S = BRepPrimAPI_MakeCylinder(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]));
}
@ -116,7 +116,7 @@ static Standard_Integer cylinder(Draw_Interpretor& , Standard_Integer n, const c
if (P.IsNull())
return 1;
else
S = BRepPrimAPI_MakeCylinder(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]),atof(a[5]) * PI180);
S = BRepPrimAPI_MakeCylinder(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]),atof(a[5]) * (M_PI / 180.0));
}
else
return 1;
@ -142,12 +142,12 @@ static Standard_Integer cone(Draw_Interpretor& , Standard_Integer n, const char*
}
else if (n == 6) {
if (P.IsNull())
S = BRepPrimAPI_MakeCone(atof(a[2]),atof(a[3]),atof(a[4]),atof(a[5]) * PI180);
S = BRepPrimAPI_MakeCone(atof(a[2]),atof(a[3]),atof(a[4]),atof(a[5]) * (M_PI / 180.0));
else
S = BRepPrimAPI_MakeCone(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]),atof(a[5]));
}
else if (n == 7) {
S = BRepPrimAPI_MakeCone(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]),atof(a[5]),atof(a[6]) * PI180);
S = BRepPrimAPI_MakeCone(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]),atof(a[5]),atof(a[6]) * (M_PI / 180.0));
}
else
return 1;
@ -173,24 +173,24 @@ static Standard_Integer sphere(Draw_Interpretor& , Standard_Integer n, const cha
}
else if (n == 4) {
if (P.IsNull())
S = BRepPrimAPI_MakeSphere(atof(a[2]),atof(a[3]) * PI180);
S = BRepPrimAPI_MakeSphere(atof(a[2]),atof(a[3]) * (M_PI / 180.0));
else
S = BRepPrimAPI_MakeSphere(P->Pln().Position().Ax2(),atof(a[3]));
}
else if (n == 5) {
if (P.IsNull())
S = BRepPrimAPI_MakeSphere(atof(a[2]),atof(a[3]) * PI180,atof(a[4]) * PI180);
S = BRepPrimAPI_MakeSphere(atof(a[2]),atof(a[3]) * (M_PI / 180.0),atof(a[4]) * (M_PI / 180.0));
else
S = BRepPrimAPI_MakeSphere(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]) * PI180);
S = BRepPrimAPI_MakeSphere(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]) * (M_PI / 180.0));
}
else if (n == 6) {
if (P.IsNull())
S = BRepPrimAPI_MakeSphere(atof(a[2]),atof(a[3]) * PI180,atof(a[4]) * PI180,atof(a[5]) * PI180);
S = BRepPrimAPI_MakeSphere(atof(a[2]),atof(a[3]) * (M_PI / 180.0),atof(a[4]) * (M_PI / 180.0),atof(a[5]) * (M_PI / 180.0));
else
S = BRepPrimAPI_MakeSphere(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]) * PI180,atof(a[5]) * PI180);
S = BRepPrimAPI_MakeSphere(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]) * (M_PI / 180.0),atof(a[5]) * (M_PI / 180.0));
}
else if (n == 7) {
S = BRepPrimAPI_MakeSphere(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]) * PI180,atof(a[5]) * PI180,atof(a[6]) * PI180);
S = BRepPrimAPI_MakeSphere(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]) * (M_PI / 180.0),atof(a[5]) * (M_PI / 180.0),atof(a[6]) * (M_PI / 180.0));
}
else
return 1;
@ -216,29 +216,29 @@ static Standard_Integer torus(Draw_Interpretor& , Standard_Integer n, const char
}
else if (n == 5) {
if (P.IsNull())
S = BRepPrimAPI_MakeTorus(atof(a[2]),atof(a[3]),atof(a[4]) * PI180);
S = BRepPrimAPI_MakeTorus(atof(a[2]),atof(a[3]),atof(a[4]) * (M_PI / 180.0));
else
S = BRepPrimAPI_MakeTorus(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]));
}
else if (n == 6) {
if (P.IsNull())
S = BRepPrimAPI_MakeTorus(atof(a[2]),atof(a[3]),
atof(a[4]) * PI180,atof(a[5]) * PI180);
atof(a[4]) * (M_PI / 180.0),atof(a[5]) * (M_PI / 180.0));
else
S = BRepPrimAPI_MakeTorus(P->Pln().Position().Ax2(),
atof(a[3]),atof(a[4]),atof(a[5]) * PI180);
atof(a[3]),atof(a[4]),atof(a[5]) * (M_PI / 180.0));
}
else if (n == 7) {
if (P.IsNull())
S = BRepPrimAPI_MakeTorus(atof(a[2]),atof(a[3]),
atof(a[4]) * PI180,atof(a[5]) * PI180,atof(a[6]) * PI180);
atof(a[4]) * (M_PI / 180.0),atof(a[5]) * (M_PI / 180.0),atof(a[6]) * (M_PI / 180.0));
else
S = BRepPrimAPI_MakeTorus(P->Pln().Position().Ax2(),atof(a[3]),
atof(a[4]),atof(a[5]) * PI180,atof(a[6]) * PI180);
atof(a[4]),atof(a[5]) * (M_PI / 180.0),atof(a[6]) * (M_PI / 180.0));
}
else if (n == 8) {
S = BRepPrimAPI_MakeTorus(P->Pln().Position().Ax2(),atof(a[3]),atof(a[4]),
atof(a[5]) * PI180,atof(a[6]) * PI180,atof(a[7]) * PI180);
atof(a[5]) * (M_PI / 180.0),atof(a[6]) * (M_PI / 180.0),atof(a[7]) * (M_PI / 180.0));
}
else
return 1;

2
src/BRepTest/BRepTest_SurfaceCommands.cxx

@ -456,7 +456,7 @@ static Standard_Integer encoderegularity (Draw_Interpretor& ,
BRepLib::EncodeRegularity(sh);
else {
Standard_Real Tol = atof(a[2]);
Tol *= PI/180.;
Tol *= M_PI/180.;
BRepLib::EncodeRegularity(sh, Tol);
}
return 0;

2
src/BRepTest/BRepTest_SweepCommands.cxx

@ -100,7 +100,7 @@ static Standard_Integer revol(Draw_Interpretor& ,
gp_Dir D(atof(a[6]),atof(a[7]),atof(a[8]));
gp_Ax1 A(P,D);
Standard_Real angle = atof(a[9]) * PI180;
Standard_Real angle = atof(a[9]) * (M_PI / 180.0);
Standard_Boolean copy = n > 10;

8
src/BRepToIGES/BRepToIGES_BRWire.cxx

@ -382,24 +382,24 @@ Handle(IGESData_IGESEntity) BRepToIGES_BRWire ::TransferEdge (const TopoDS_Edge&
//#30 rln 19.10.98 transformation of pcurves for IGES Surface of Revolution
Curve2d->Mirror (gp_Ax2d (gp::Origin2d(), gp_Dir2d (1.,1.)));
Curve2d->Mirror (gp::OX2d());
Curve2d->Translate (gp_Vec2d (0, 2 * PI));
Curve2d->Translate (gp_Vec2d (0, 2 * M_PI));
}
if(Surf->IsKind(STANDARD_TYPE(Geom_SurfaceOfRevolution))||
(Surf->IsKind(STANDARD_TYPE(Geom_ToroidalSurface)))){
Curve2d->Mirror (gp_Ax2d (gp::Origin2d(), gp_Dir2d (1.,1.)));
Curve2d->Mirror (gp::OX2d());
Curve2d->Translate (gp_Vec2d (0, 2 * PI));
Curve2d->Translate (gp_Vec2d (0, 2 * M_PI));
}
if (analyticMode&&(Surf->IsKind(STANDARD_TYPE(Geom_CylindricalSurface)) ||
Surf->IsKind(STANDARD_TYPE(Geom_ConicalSurface))))
myLen = PI/180.;
myLen = M_PI/180.;
if (analyticMode&&(Surf->IsKind(STANDARD_TYPE(Geom_SphericalSurface)) ||
Surf->IsKind(STANDARD_TYPE(Geom_ToroidalSurface)))) {
gp_Trsf2d trans;
trans.SetScale(gp_Pnt2d(0,0),180./PI);
trans.SetScale(gp_Pnt2d(0,0),180./M_PI);
Curve2d->Transform(trans);
First = Curve2d->TransformedParameter(First,trans);
Last = Curve2d->TransformedParameter(Last, trans);

2
src/BRepTools/BRepTools_WireExplorer.cxx

@ -442,7 +442,7 @@ void BRepTools_WireExplorer::Next()
Standard_Integer k = 1, kMin = 0, iDone = 0;
Standard_Boolean isDegenerated = Standard_True;
Standard_Real dmin = RealLast();
Standard_Real dfMinAngle = 3.0*PI, dfCurAngle = 3.0*PI;
Standard_Real dfMinAngle = 3.0*M_PI, dfCurAngle = 3.0*M_PI;
for(iDone = 0; iDone < 2; iDone++)
{

8
src/BRepTopAdaptor/BRepTopAdaptor_FClass2d.cxx

@ -358,19 +358,19 @@ BRepTopAdaptor_FClass2d::BRepTopAdaptor_FClass2d(const TopoDS_Face& aFace,const
|| surf->GetType()==GeomAbs_SurfaceOfRevolution)
{
Standard_Real uuu=PI+PI-(Umax-Umin);
Standard_Real uuu=M_PI+M_PI-(Umax-Umin);
if(uuu<0) uuu=0;
U1 = 0.0; // modified by NIZHNY-OFV Thu May 31 14:24:10 2001 ---> //Umin-uuu*0.5;
U2 = 2*PI; // modified by NIZHNY-OFV Thu May 31 14:24:35 2001 ---> //U1+PI+PI;
U2 = 2*M_PI; // modified by NIZHNY-OFV Thu May 31 14:24:35 2001 ---> //U1+M_PI+M_PI;
}
else { U1=U2=0.0; }
if(surf->GetType()==GeomAbs_Torus)
{
Standard_Real uuu=PI+PI-(Vmax-Vmin);
Standard_Real uuu=M_PI+M_PI-(Vmax-Vmin);
if(uuu<0) uuu=0;
V1 = 0.0; // modified by NIZHNY-OFV Thu May 31 14:24:55 2001 ---> //Vmin-uuu*0.5;
V2 = 2*PI; // modified by NIZHNY-OFV Thu May 31 14:24:59 2001 ---> //V1+PI+PI;
V2 = 2*M_PI; // modified by NIZHNY-OFV Thu May 31 14:24:59 2001 ---> //V1+M_PI+M_PI;
}
else { V1=V2=0.0; }
}

2
src/BiTgte/BiTgte_Blend.cxx

@ -236,7 +236,7 @@ static void KPartCurve3d(TopoDS_Edge Edge,
if ( D.IsParallel(gp::DX2d(),Precision::Angular())) { // Iso V.
if ( STy == GeomAbs_Sphere) {
gp_Pnt2d P = C.Line().Location();
if ( Abs( Abs(P.Y()) -PI/2. ) < Precision::PConfusion()) {
if ( Abs( Abs(P.Y()) -M_PI/2. ) < Precision::PConfusion()) {
TheBuilder.Degenerated(Edge, Standard_True);
}
else {

18
src/Bisector/Bisector_BisecAna.cxx

@ -491,10 +491,10 @@ void Bisector_BisecAna::Perform(const Handle(Geom2d_Curve)& afirstcurve ,
bisectorcurve = new Geom2d_Circle(TheSol->Circle());
if (!thesense)
thebisector = new Geom2d_TrimmedCurve
(bisectorcurve,firstparameter-2.0*PI,firstparameter,thesense);
(bisectorcurve,firstparameter-2.0*M_PI,firstparameter,thesense);
else
thebisector = new Geom2d_TrimmedCurve
(bisectorcurve,firstparameter,firstparameter+2.0*PI,thesense);
(bisectorcurve,firstparameter,firstparameter+2.0*M_PI,thesense);
}
else if (type == GccInt_Hpr) {
bisectorcurve = new Geom2d_Hyperbola(TheSol->Hyperbola());
@ -509,10 +509,10 @@ void Bisector_BisecAna::Perform(const Handle(Geom2d_Curve)& afirstcurve ,
bisectorcurve = new Geom2d_Ellipse(TheSol->Ellipse());
if (!thesense)
thebisector = new Geom2d_TrimmedCurve
(bisectorcurve,firstparameter-2.0*PI,firstparameter,thesense);
(bisectorcurve,firstparameter-2.0*M_PI,firstparameter,thesense);
else
thebisector = new Geom2d_TrimmedCurve
(bisectorcurve,firstparameter,firstparameter+2.0*PI,thesense);
(bisectorcurve,firstparameter,firstparameter+2.0*M_PI,thesense);
}
}
}
@ -862,13 +862,13 @@ void Bisector_BisecAna::Perform(const Handle(Geom2d_Curve)& afirstcurve ,
bisectorcurve = new Geom2d_Circle(TheSol->Circle());
if (!thesense)
thebisector = new Geom2d_TrimmedCurve(bisectorcurve,
firstparameter-2.0*PI,
firstparameter-2.0*M_PI,
firstparameter,
thesense);
else
thebisector = new Geom2d_TrimmedCurve(bisectorcurve,
firstparameter,
firstparameter+2.0*PI,
firstparameter+2.0*M_PI,
thesense);
}
else if (type == GccInt_Hpr) {
@ -886,13 +886,13 @@ void Bisector_BisecAna::Perform(const Handle(Geom2d_Curve)& afirstcurve ,
bisectorcurve = new Geom2d_Ellipse(TheSol->Ellipse());
if (!thesense)
thebisector = new Geom2d_TrimmedCurve(bisectorcurve,
firstparameter-2.0*PI,
firstparameter-2.0*M_PI,
firstparameter,
thesense);
else
thebisector = new Geom2d_TrimmedCurve(bisectorcurve,
firstparameter,
firstparameter+2.0*PI,
firstparameter+2.0*M_PI,
thesense);
}
}
@ -1195,7 +1195,7 @@ void Bisector_BisecAna::SetTrim(const Handle(Geom2d_Curve)& )
thebisector->Value(UB2), UB2, Tolerance);
if (thebisector->BasisCurve()->IsPeriodic()) {
DomainBisector.SetEquivalentParameters(0.0,2.*PI);
DomainBisector.SetEquivalentParameters(0.0,2.*M_PI);
}
FirstPointBisector = thebisector->Value(UB1);

2
src/Bisector/Bisector_BisecCC.cxx

@ -200,7 +200,7 @@ void Bisector_BisecCC::Perform(const Handle(Geom2d_Curve)& Cu1,
// - one of two curves is concave.
// - the curves have a common point at the beginning and/or the end
// - the angle of opening at the common point between two curves
// values PI.
// values M_PI.
// the extension at the beginning is taken into account if the origin is found above.
// ie : the origin is not the in the polygon.
//-----------------------------------------------------------------------------

2
src/BlendFunc/BlendFunc.cxx

@ -41,7 +41,7 @@ void BlendFunc::GetShape (const BlendFunc_SectionShape SShape,
case BlendFunc_Rational:
{
Standard_Integer NbSpan =
(Standard_Integer)(Ceiling(3.*Abs(MaxAng)/2./PI));
(Standard_Integer)(Ceiling(3.*Abs(MaxAng)/2./M_PI));
NbPoles = 2*NbSpan+1;
NbKnots = NbSpan+1;
Degree = 2;

4
src/BlendFunc/BlendFunc_CSCircular.cxx

@ -237,7 +237,7 @@ Standard_Boolean BlendFunc_CSCircular::IsSolution(const math_Vector& Sol, const
Angle = ACos(Cosa);
if (Sina <0.) {
Angle = 2.*PI - Angle;
Angle = 2.*M_PI - Angle;
}
if (Angle>maxang) {maxang = Angle;}
@ -686,7 +686,7 @@ Standard_Boolean BlendFunc_CSCircular::GetSection(const Standard_Real Param,
Sina = nplan.Dot(ns.Crossed(ns2));
Angle = ACos(Cosa);
if (Sina <0.) {
Angle = 2.*PI - Angle;
Angle = 2.*M_PI - Angle;
}
Dangle = -(dnw.Dot(ns2) + ns.Dot(dn2w))/Sina;
ncrn = nplan.Crossed(ns);

4
src/BlendFunc/BlendFunc_CSConstRad.cxx

@ -207,7 +207,7 @@ Standard_Boolean BlendFunc_CSConstRad::IsSolution(const math_Vector& Sol, const
Angle = ACos(Cosa);
if (Sina <0.) {
Angle = 2.*PI - Angle;
Angle = 2.*M_PI - Angle;
}
if (Angle>maxang) {maxang = Angle;}
@ -649,7 +649,7 @@ Standard_Boolean BlendFunc_CSConstRad::GetSection(const Standard_Real Param,
Sina = nplan.Dot(ns.Crossed(ns2));
Angle = ACos(Cosa);
if (Sina <0.) {
Angle = 2.*PI - Angle;
Angle = 2.*M_PI - Angle;
}
Dangle = -(dnw.Dot(ns2) + ns.Dot(dn2w))/Sina;
ncrn = nplan.Crossed(ns);

6
src/BlendFunc/BlendFunc_ConstRad.cxx

@ -902,11 +902,11 @@ Standard_Boolean BlendFunc_ConstRad::IsSolution(const math_Vector& Sol, const St
// Reframing on ]-pi/2, 3pi/2]
if (Sina <0.) {
if (Cosa > 0.) Angle = -Angle;
else Angle = 2.*PI - Angle;
else Angle = 2.*M_PI - Angle;
}
// cout << "Angle : " <<Angle << endl;
// if ((Angle < 0) || (Angle > PI)) {
// if ((Angle < 0) || (Angle > M_PI)) {
// cout << "t = " << param << endl;
// }
@ -1176,7 +1176,7 @@ void BlendFunc_ConstRad::Section(const Standard_Real Param,
Pdeb = 0.;
Pfin = ElCLib::Parameter(C,pts2);
// Test negative and almost null angles : Singular Case
if (Pfin>1.5*PI) {
if (Pfin>1.5*M_PI) {
np.Reverse();
C.SetPosition(gp_Ax2(Center,np,ns1));
Pfin = ElCLib::Parameter(C,pts2);

4
src/BlendFunc/BlendFunc_EvolRad.cxx

@ -971,7 +971,7 @@ Standard_Boolean BlendFunc_EvolRad::IsSolution(const math_Vector& Sol,
// Reframing on ]-pi/2, 3pi/2]
if (Sina <0.) {
if (Cosa > 0.) Angle = -Angle;
else Angle = 2.*PI - Angle;
else Angle = 2.*M_PI - Angle;
}
if (Abs(Angle)>maxang) {maxang = Abs(Angle);}
@ -1160,7 +1160,7 @@ void BlendFunc_EvolRad::Section(const Standard_Real Param,
Pdeb = 0.;
Pfin = ElCLib::Parameter(C,pts2);
// Test of negative and almost null angles : Single Case
if (Pfin>1.5*PI) {
if (Pfin>1.5*M_PI) {
np.Reverse();
C.SetPosition(gp_Ax2(Center,np,ns1));
Pfin = ElCLib::Parameter(C,pts2);

12
src/BndLib/BndLib.cxx

@ -517,7 +517,7 @@ void BndLib::Add( const gp_Cylinder& S,const Standard_Real UMin,
void BndLib::Add( const gp_Cylinder& S,const Standard_Real VMin,
const Standard_Real VMax,const Standard_Real Tol, Bnd_Box& B) {
BndLib::Add(S,0.,2.*PI,VMin,VMax,Tol,B);
BndLib::Add(S,0.,2.*M_PI,VMin,VMax,Tol,B);
}
void BndLib::Add(const gp_Cone& S,const Standard_Real UMin,
@ -594,7 +594,7 @@ void BndLib::Add(const gp_Cone& S,const Standard_Real UMin,
void BndLib::Add( const gp_Cone& S,const Standard_Real VMin,
const Standard_Real VMax,const Standard_Real Tol, Bnd_Box& B) {
BndLib::Add(S,0.,2.*PI,VMin,VMax,Tol,B);
BndLib::Add(S,0.,2.*M_PI,VMin,VMax,Tol,B);
}
void BndLib::Add(const gp_Sphere& S,const Standard_Real UMin,
@ -703,12 +703,12 @@ void BndLib::Add(const gp_Torus& S,const Standard_Real UMin,
Standard_Integer Fi1;
Standard_Integer Fi2;
if (VMax<VMin) {
Fi1 = (Standard_Integer )( VMax/(PI/4.));
Fi2 = (Standard_Integer )( VMin/(PI/4.));
Fi1 = (Standard_Integer )( VMax/(M_PI/4.));
Fi2 = (Standard_Integer )( VMin/(M_PI/4.));
}
else {
Fi1 = (Standard_Integer )( VMin/(PI/4.));
Fi2 = (Standard_Integer )( VMax/(PI/4.));
Fi1 = (Standard_Integer )( VMin/(M_PI/4.));
Fi2 = (Standard_Integer )( VMax/(M_PI/4.));
}
Fi2++;

6
src/BndLib/BndLib_AddSurface.cxx

@ -240,9 +240,9 @@ void BndLib_AddSurface::Add(const Adaptor3d_Surface& S,
case GeomAbs_Sphere:
{
if (Abs(UMin) < Precision::Angular() &&
Abs(UMax - 2.*PI) < Precision::Angular() &&
Abs(VMin + PI/2.) < Precision::Angular() &&
Abs(VMax - PI/2.) < Precision::Angular()) // a whole sphere
Abs(UMax - 2.*M_PI) < Precision::Angular() &&
Abs(VMin + M_PI/2.) < Precision::Angular() &&
Abs(VMax - M_PI/2.) < Precision::Angular()) // a whole sphere
BndLib::Add(S.Sphere(),Tol,B);
else
BndLib::Add(S.Sphere(),UMin,UMax,VMin,VMax,Tol,B);

18
src/BndLib/BndLib_Compute.gxx

@ -22,17 +22,17 @@ void Compute(const Standard_Real P1,
}
Standard_Real Delta =Abs(Teta2-Teta1);
if (Delta > 2. * PI) {
if (Delta > 2. * M_PI) {
Teta1 = 0.;
Teta2 = 2. * PI;
Teta2 = 2. * M_PI;
}
else {
if (Teta1 < 0.) {
do { Teta1+=2.*PI;} while (Teta1< 0.);
do { Teta1+=2.*M_PI;} while (Teta1< 0.);
}
else if (Teta1> 2.*PI) {
do { Teta1-=2.*PI;} while (Teta1> 2.*PI);
else if (Teta1> 2.*M_PI) {
do { Teta1-=2.*M_PI;} while (Teta1> 2.*M_PI);
}
Teta2 = Teta1 + Delta;
@ -46,7 +46,7 @@ void Compute(const Standard_Real P1,
B.Add(Point(O +Ra*Cn2*Xd +Rb*Sn2*Yd));
Standard_Real Ram,Rbm;
if (Delta > PI/8.) {
if (Delta > M_PI/8.) {
// Main radiuses to take into account only 8 points (/cos(Pi/8.))
Ram=Ra/0.92387953251128674;
Rbm=Rb/0.92387953251128674;
@ -61,7 +61,7 @@ void Compute(const Standard_Real P1,
B.Add(Point(O +Ram*Cn2*Xd +Rbm*Sn2*Yd));
// cos or sin PI/4.
// cos or sin M_PI/4.
#define PI4 0.70710678118654746
// 8 points of the polygon
@ -74,8 +74,8 @@ void Compute(const Standard_Real P1,
#define addP6 B.Add(Point(O -Rbm*Yd));
#define addP7 B.Add(Point(O +Ram*PI4*Xd -Rbm*PI4*Yd))
Standard_Integer deb = (Standard_Integer )( Teta1/(PI/4.));
Standard_Integer fin = (Standard_Integer )( Teta2/(PI/4.));
Standard_Integer deb = (Standard_Integer )( Teta1/(M_PI/4.));
Standard_Integer fin = (Standard_Integer )( Teta2/(M_PI/4.));
deb++;
if (deb>fin) return;

6
src/CGM/CGM_Driver.cxx

@ -38,7 +38,7 @@ static Handle(Image_Image) myImage;
#define TRANSFORMCOLOR(c) \
{ if (TypeOfCgm == CgmCharEncoding) c = (((c+1) << 2) - 1); }
#define DRAD (PI/180.)
#define DRAD (M_PI/180.)
#define DEFPLOTTER "DIRECT_CGM"
//-----------------------------------------------------------------
@ -541,7 +541,7 @@ Standard_Boolean CGM_Driver::PlotArc (const Standard_ShortReal Xpos,
{
Standard_ShortReal san = sAngle;
Standard_ShortReal fan = sAngle + oAngle;
if (oAngle >= 2*PI) {
if (oAngle >= 2*M_PI) {
PlotPolyAttrib (myLineColorIndex, -1, Standard_True);
if (aXradius == aYradius) {
ptabreal[0] = (float)Xpos; ptabreal[1] = (float)Ypos;
@ -582,7 +582,7 @@ Standard_Boolean CGM_Driver::PlotPolyArc (const Standard_ShortReal Xpos,
{
Standard_ShortReal san = sAngle;
Standard_ShortReal fan = sAngle + oAngle;
if (oAngle >= 2.*PI) {
if (oAngle >= 2.*M_PI) {
if (aXradius == aYradius) {
ptabreal[0] = (float)Xpos; ptabreal[1] = (float)Ypos;
ptabreal[2] = (float)aXradius;

5
src/CGM/cgmlib.hxx

@ -632,11 +632,6 @@ struct flags {
#define LOG2 0.30103
#define PARABIT 0x40
#ifndef PI
#define PI 3.1415926535
#endif
/* All default values set within the control program */
/* with Character encoding defaults */

4
src/CGM/cgmpar.h

@ -230,8 +230,4 @@
#define LOG2 0.30103
#define PARABIT 0x40
#ifndef PI
#define PI 3.1415926535
#endif
#endif /* end of cgmpar.h */

48
src/CSLib/CSLib.cxx

@ -239,8 +239,8 @@ void CSLib::Normal(const Standard_Integer MaxOrder,
{ //All lambda i exist
Standard_Integer SP;
Standard_Real inf,sup;
inf=0.0-Standard_PI;
sup=0.0+Standard_PI;
inf = 0.0 - M_PI;
sup = 0.0 + M_PI;
Standard_Boolean FU,LU,FV,LV;
//Creation of the domain of definition depending on the position
@ -249,29 +249,41 @@ void CSLib::Normal(const Standard_Integer MaxOrder,
LU=(Abs(U-Umax) < Precision::PConfusion() );
FV=(Abs(V-Vmin) < Precision::PConfusion() );
LV=(Abs(V-Vmax) < Precision::PConfusion() );
if(LU)
if (LU)
{
inf=Standard_PI/2;
sup=3*inf;
if(LV){inf=Standard_PI;}
if(FV){sup=Standard_PI;}
inf = M_PI / 2;
sup = 3 * inf;
if (LV)
{
inf = M_PI;
}
if (FV)
{
sup = M_PI;
}
}
else if(FU)
else if (FU)
{
sup=Standard_PI/2;
inf=-sup;
if(LV){sup=0;}
if(FV){inf=0;}
sup = M_PI / 2;
inf = -sup;
if (LV)
{
sup = 0;
}
if (FV)
{
inf = 0;
}
}
else if(LV)
else if (LV)
{
inf=0.0-Standard_PI;
sup=0;
inf = 0.0 - M_PI;
sup = 0;
}
else if(FV)
else if (FV)
{
inf=0;
sup=Standard_PI;
inf = 0;
sup = M_PI;
}
Standard_Boolean CS=0;
Standard_Real Vprec=0,Vsuiv;

26
src/ChFi2d/ChFi2d_Builder.cxx

@ -975,13 +975,13 @@ TopoDS_Edge ChFi2d_Builder::BuildFilletEdge(const TopoDS_Vertex& V,
inside = (PPU2<param3 && PPU2>param4) || (PPU2<param4 && PPU2>param3);
// case of arc of circle passing on the sewing
if ( ( basisC2->DynamicType() == STANDARD_TYPE(Geom2d_Circle) ) &&
( (2*PI<param3 && 2*PI>param4) || (2*PI<param4 && 2*PI>param3) ) ) {
( (2*M_PI<param3 && 2*M_PI>param4) || (2*M_PI<param4 && 2*M_PI>param3) ) ) {
// cas param3<param4
inside = (param3<PPU2 && PPU2<2*PI)
|| (0<=PPU2 && PPU2<param4-2*PI);
inside = (param3<PPU2 && PPU2<2*M_PI)
|| (0<=PPU2 && PPU2<param4-2*M_PI);
// cas param4<param3
inside = inside || (param4<PPU2 && PPU2<2*PI)
|| (0<=PPU2 && PPU2<param3-2*PI);
inside = inside || (param4<PPU2 && PPU2<2*M_PI)
|| (0<=PPU2 && PPU2<param3-2*M_PI);
}
if ( inside && dist < dist1) {
numsol = nsol;
@ -1005,12 +1005,12 @@ TopoDS_Edge ChFi2d_Builder::BuildFilletEdge(const TopoDS_Vertex& V,
inside = (U2 < param1 && U2 >= param2) || (U2 <= param2 && U2 > param1);
/////////////////////////////////////////////////////
if ( (basisC1->DynamicType() == STANDARD_TYPE(Geom2d_Circle))
&& ( (2*PI<param1 && 2*PI>param2) || (2*PI<param2 && 2*PI>param1) ) ) {
&& ( (2*M_PI<param1 && 2*M_PI>param2) || (2*M_PI<param2 && 2*M_PI>param1) ) ) {
// arc of circle containing the circle origin
// case param1<param2
inside = (param1<U2 && U2<2*PI) || (0<=U2 && U2<param2-2*PI);
inside = (param1<U2 && U2<2*M_PI) || (0<=U2 && U2<param2-2*M_PI);
// case param2<param1
inside = inside || (param2<U2 && U2<2*PI) || (0<=U2 && U2<param1-2*PI);
inside = inside || (param2<U2 && U2<2*M_PI) || (0<=U2 && U2<param1-2*M_PI);
}
if (!inside) {
status = ChFi2d_ComputationError;
@ -1022,12 +1022,12 @@ TopoDS_Edge ChFi2d_Builder::BuildFilletEdge(const TopoDS_Vertex& V,
inside = (Vv2 < param3 && Vv2 >= param4) || (Vv2 <= param4 && Vv2 > param3);
/////////////////////////////////////////////////////
if ( (basisC2->DynamicType() == STANDARD_TYPE(Geom2d_Circle))
&& ( (2*PI<param3 && 2*PI>param4) || (2*PI<param4 && 2*PI>param3) ) ) {
&& ( (2*M_PI<param3 && 2*M_PI>param4) || (2*M_PI<param4 && 2*M_PI>param3) ) ) {
// arc of circle containing the circle origin
// cas param3<param4
inside = (param3<Vv2 && Vv2<2*PI) || (0<=Vv2 && Vv2<param4-2*PI);
inside = (param3<Vv2 && Vv2<2*M_PI) || (0<=Vv2 && Vv2<param4-2*M_PI);
// cas param4<param3
inside = inside || (param4<Vv2 && Vv2<2*PI) || (0<=Vv2 && Vv2<param3-2*PI);
inside = inside || (param4<Vv2 && Vv2<2*M_PI) || (0<=Vv2 && Vv2<param3-2*M_PI);
}
if (!inside) {
status = ChFi2d_ComputationError;
@ -1098,8 +1098,8 @@ TopoDS_Edge ChFi2d_Builder::BuildFilletEdge(const TopoDS_Vertex& V,
} // if (OE1 ...
Standard_Real cross = vec1*vec;
Standard_Boolean Sense = cross > 0.;
if (U1 > Vv1 && U1 > 2.*PI) {
ElCLib::AdjustPeriodic(0.,2.*PI,Precision::Confusion(),U1,Vv1);
if (U1 > Vv1 && U1 > 2.*M_PI) {
ElCLib::AdjustPeriodic(0.,2.*M_PI,Precision::Confusion(),U1,Vv1);
} // if (U1 ...
if (O1 == TopAbs_FORWARD && OE1 == TopAbs_FORWARD ||
O1 == TopAbs_REVERSED && OE1 == TopAbs_REVERSED ) {

4
src/ChFi3d/ChFi3d.cxx

@ -98,7 +98,7 @@ Standard_Integer ChFi3d::ConcaveSide(const BRepAdaptor_Surface& S1,
dint1 = ns1.Crossed(tgE1);
dint2 = ns2.Crossed(tgE2);
Standard_Real ang = ns1.CrossMagnitude(ns2);
if(ang > 0.0001*PI){
if(ang > 0.0001*M_PI){
Standard_Real scal = ns2.Dot(dint1);
if ( scal <= 0. ){
ns2.Reverse();
@ -129,7 +129,7 @@ Standard_Integer ChFi3d::ConcaveSide(const BRepAdaptor_Surface& S1,
dint1 = ns1.Crossed(tgE1);
dint2 = ns2.Crossed(tgE2);
ang = ns1.CrossMagnitude(ns2);
if(ang > 0.0001*PI){
if(ang > 0.0001*M_PI){
Standard_Real scal = ns2.Dot(dint1);
if ( scal <= 0. ){
ns2.Reverse();

14
src/ChFi3d/ChFi3d_Builder_0.cxx

@ -752,7 +752,7 @@ Handle(Geom_BezierCurve) ChFi3d_Spine(const gp_Pnt& pd,
const Standard_Real R)
{
TColgp_Array1OfPnt pol(1,4);
const Standard_Real fac = 0.5 * tan((PI-vd.Angle(vf)) * 0.5);
const Standard_Real fac = 0.5 * tan((M_PI-vd.Angle(vf)) * 0.5);
pol(1) = pd;
vd.Multiply(fac*R);
pol(2).SetCoord(pd.X()+vd.X(),pd.Y()+vd.Y(),pd.Z()+vd.Z());
@ -3099,11 +3099,11 @@ Standard_Boolean ChFi3d_ComputeCurves(Handle(Adaptor3d_HSurface)& S1,
Ufin = -Ufin;
}
else{
Udeb = 2*PI - Udeb;
Ufin = 2*PI - Ufin;
Udeb = 2*M_PI - Udeb;
Ufin = 2*M_PI - Ufin;
}
}
if(!c1line) ElCLib::AdjustPeriodic(0.,2*PI,Precision::Angular(),Udeb,Ufin);
if(!c1line) ElCLib::AdjustPeriodic(0.,2*M_PI,Precision::Angular(),Udeb,Ufin);
Handle(GeomAdaptor_HCurve) HC = new GeomAdaptor_HCurve();
HC->ChangeCurve().Load(C3d,Udeb,Ufin);
ChFi3d_ProjectPCurv(HC,S1,Pc1,tol3d,tolr1);
@ -3629,7 +3629,7 @@ Handle(GeomAdaptor_HSurface) ChFi3d_BoundSurf(TopOpeBRepDS_DataStructure& DSt
//In the case of a torus or cone, it is not necessary that the bounds create a surface with period more than 2PI.
else if (styp == GeomAbs_Torus ||
styp == GeomAbs_Cone) {
Du = Min(PI-0.5*Du,0.1*Du);
Du = Min(M_PI-0.5*Du,0.1*Du);
Dv = 0.;
S1.Load(DStr.Surface(Fd1->Surf()).Surface(),
mu-Du,Mu+Du,mv,Mv);
@ -4126,7 +4126,7 @@ Standard_EXPORT
//
caredeb = 0;
carefin = 0;
Angle = PI*0.75;
Angle = M_PI*0.75;
LocalWL = WL;
LocalWF = WF;
if (!ES.IsPeriodic() && !PDeb.IsEqual(BSpline->Pole(1), tol) ) {
@ -4748,7 +4748,7 @@ Standard_Boolean ChFi3d_IsSmooth( const Handle(Geom_Curve)& C )
LProp.CentreOfCurvature(P2);
gp_Vec Vec(P1, P2);
Standard_Real Angle = PrevVec.Angle( Vec );
if (Angle > PI/3.)
if (Angle > M_PI/3.)
return Standard_False;
Standard_Real Ratio = Vec.Magnitude() / PrevVec.Magnitude();
if (Ratio < 1.)

16
src/ChFi3d/ChFi3d_Builder_1.cxx

@ -700,12 +700,12 @@ Standard_Boolean ChFi3d_Builder::PerformElement(const Handle(ChFiDS_Spine)& Spin
// there is no need of tolerance
// to make a decision (PRO9486) the regularity is enough.
// However, the abcense of turn-back is checked (PRO9810)
OnAjoute = ((!rev && av1v2 < PI/2)
||(rev && av1v2 > PI/2));
OnAjoute = ((!rev && av1v2 < M_PI/2)
||(rev && av1v2 > M_PI/2));
// mate attention to the single case (cf CTS21610_1)
if (OnAjoute && (degeneOnEc ||
TangentOnVertex(LVEc, Ev,myEFMap, ta)) )
OnAjoute=((!rev && av1v2 < ta) || (rev && (PI - av1v2) < ta));
OnAjoute=((!rev && av1v2 < ta) || (rev && (M_PI - av1v2) < ta));
}
if (OnAjoute) {
Fini = Standard_False; // If this can be useful (Cf PRO14713)
@ -729,7 +729,7 @@ Standard_Boolean ChFi3d_Builder::PerformElement(const Handle(ChFiDS_Spine)& Spin
for (Jt.Initialize(myEFMap(Ev)), Nbface= 0 ;Jt.More();Jt.Next(),
Nbface++) {}
if (Nbface> 1) CurSt = ChFiDS_BreakPoint;
Fini = ((!rev && av1v2 < ta) || (rev && (PI - av1v2) < ta));
Fini = ((!rev && av1v2 < ta) || (rev && (M_PI - av1v2) < ta));
}
}
}
@ -772,11 +772,11 @@ Standard_Boolean ChFi3d_Builder::PerformElement(const Handle(ChFiDS_Spine)& Spin
Standard_Boolean rev = (Or1 != curor);
Standard_Boolean OnAjoute = Standard_False;
if (FaceTangency(Ec,Ev,LVEv)) {
OnAjoute = ((!rev && av1v2 < PI/2)
||(rev && av1v2 > PI/2));
OnAjoute = ((!rev && av1v2 < M_PI/2)
||(rev && av1v2 > M_PI/2));
if (OnAjoute && (degeneOnEc ||
TangentOnVertex(FVEc, Ev,myEFMap, ta)) )
OnAjoute=((!rev && av1v2 < ta) || (rev && (PI-av1v2) < ta));
OnAjoute=((!rev && av1v2 < ta) || (rev && (M_PI-av1v2) < ta));
}
if (OnAjoute) {
Ec = Ev;
@ -791,7 +791,7 @@ Standard_Boolean ChFi3d_Builder::PerformElement(const Handle(ChFiDS_Spine)& Spin
for(Jt.Initialize(myEFMap(Ev)),Nbface= 0 ;Jt.More();Jt.Next(),
Nbface++) {}
if (Nbface> 1) CurSt = ChFiDS_BreakPoint;
Fini = ((!rev && av1v2 < ta) || (rev && (PI - av1v2) < ta));
Fini = ((!rev && av1v2 < ta) || (rev && (M_PI - av1v2) < ta));
}
}
}

2
src/ChFi3d/ChFi3d_Builder_2.cxx

@ -853,7 +853,7 @@ void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)& Stripe,
// There are ponts on the border, and internal points are found
if (derive.Magnitude() > Precision::PConfusion()) {
derive.Normalized();
derive.Rotate(PI/2);
derive.Rotate(M_PI/2);
AS.Initialize(f1);
ResU = AS.UResolution(TolE);
ResV = AS.VResolution(TolE);

32
src/ChFi3d/ChFi3d_Builder_C1.cxx

@ -2041,7 +2041,7 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
trouve=Standard_False;
ChFi3d_cherche_vertex ( Edge[0],Edge[1],Vcom,trouve);
if (Vcom.IsSame(Vtx)) ang1=ChFi3d_AngleEdge(Vtx,Edge[0],Edge[1]);
if (Abs(ang1-PI)<0.01) {
if (Abs(ang1-M_PI)<0.01) {
oneintersection1=Standard_True;
facesau=Face[0];
edgesau=Edge[1];
@ -2054,7 +2054,7 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
trouve=Standard_False;
ChFi3d_cherche_vertex ( Edge[1],Edge[2],Vcom,trouve);
if (Vcom.IsSame(Vtx)) ang1=ChFi3d_AngleEdge(Vtx,Edge[1],Edge[2]);
if (Abs(ang1-PI)<0.01) {
if (Abs(ang1-M_PI)<0.01) {
oneintersection2=Standard_True;
facesau=Face[1];
edgesau=Edge[1];
@ -2414,17 +2414,17 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
// deb=pfildeb.X();
// xx1=pfil1.X();
// xx2=pfil2.X();
// moins2pi=Abs(deb)< Abs(Abs(deb)-2*PI);
// moins2pi1=Abs(xx1)< Abs(Abs(xx1)-2*PI);
// moins2pi2=Abs(xx2)< Abs(Abs(xx2)-2*PI);
// moins2pi=Abs(deb)< Abs(Abs(deb)-2*M_PI);
// moins2pi1=Abs(xx1)< Abs(Abs(xx1)-2*M_PI);
// moins2pi2=Abs(xx2)< Abs(Abs(xx2)-2*M_PI);
// if (moins2pi1!=moins2pi2) {
// if (moins2pi) {
// if (!moins2pi1) xx1=xx1-2*PI;
// if (!moins2pi2) xx2=xx2-2*PI;
// if (!moins2pi1) xx1=xx1-2*M_PI;
// if (!moins2pi2) xx2=xx2-2*M_PI;
// }
// else {
// if (moins2pi1) xx1=xx1+2*PI;
// if (moins2pi2) xx2=xx2+2*PI;
// if (moins2pi1) xx1=xx1+2*M_PI;
// if (moins2pi2) xx2=xx2+2*M_PI;
// }
// }
// pfil1.SetX(xx1);
@ -2437,17 +2437,17 @@ void ChFi3d_Builder::PerformIntersectionAtEnd(const Standard_Integer Index)
// deb=ufmin;
// xx1=pfac1.X();
// xx2=pfac2.X();
// moins2pi=Abs(deb)< Abs(Abs(deb)-2*PI);
// moins2pi1=Abs(xx1)< Abs(Abs(xx1)-2*PI);
// moins2pi2=Abs(xx2)< Abs(Abs(xx2)-2*PI);
// moins2pi=Abs(deb)< Abs(Abs(deb)-2*M_PI);
// moins2pi1=Abs(xx1)< Abs(Abs(xx1)-2*M_PI);
// moins2pi2=Abs(xx2)< Abs(Abs(xx2)-2*M_PI);
// if (moins2pi1!=moins2pi2) {
// if (moins2pi) {
// if (!moins2pi1) xx1=xx1-2*PI;
// if (!moins2pi2) xx2=xx2-2*PI;
// if (!moins2pi1) xx1=xx1-2*M_PI;
// if (!moins2pi2) xx2=xx2-2*M_PI;
// }
// else {
// if (moins2pi1) xx1=xx1+2*PI;
// if (moins2pi2) xx2=xx2+2*PI;
// if (moins2pi1) xx1=xx1+2*M_PI;
// if (moins2pi2) xx2=xx2+2*M_PI;
// }
// }
// pfac1.SetX(xx1);

34
src/ChFi3d/ChFi3d_Builder_CnCrn.cxx

@ -491,15 +491,15 @@ static void CalculBatten (const Handle (GeomAdaptor_HSurface) ASurf,
Bat.SetFreeSliding (Standard_True);
Standard_Real ang1,ang2;
ang1=dir1.Angle(dir3);
if (dir1.Angle(dir4) >0 ) ang2=PI-dir1.Angle(dir4);
else ang2=-PI-dir1.Angle(dir4);
if (dir1.Angle(dir4) >0 ) ang2=M_PI-dir1.Angle(dir4);
else ang2=-M_PI-dir1.Angle(dir4);
if (contraint1&&contraint2)
anglebig=(Abs(ang1)>1.2)|| (Abs(ang2)>1.2 );
else if (contraint1)
anglebig=Abs(ang1)>1.2;
else if (contraint2)
anglebig=Abs(ang2)>1.2;
if (isplane && (Abs(ang1)>PI/2 || Abs(ang2)>PI/2))
if (isplane && (Abs(ang1)>M_PI/2 || Abs(ang2)>M_PI/2))
isplane=Standard_False;
if (anglebig && !isplane) {
CalculDroite(p2d1,xdir,ydir,pcurve);
@ -994,7 +994,7 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
Standard_Boolean droit=Standard_False;
if (bordlibre) {nedge=(nedge-2)/2 +2;
Standard_Real angedg=Abs(ChFi3d_AngleEdge(V1,edgelibre1,edgelibre2));
droit=Abs(angedg-PI)<0.01;
droit=Abs(angedg-M_PI)<0.01;
}
else nedge=nedge/2;
Standard_Integer size=nedge*2;
@ -1248,7 +1248,7 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
if (ind!=ic) {
TopoDS_Edge ecur=TopoDS::Edge(Evive.Value(ind));
Standard_Real ang=Abs(ChFi3d_AngleEdge(V1,ecur,ereg));
if (ang<0.01 || Abs(ang-PI) <0.01) {
if (ang<0.01 || Abs(ang-M_PI) <0.01) {
regul.SetValue(ic,Standard_False);
tangentregul.SetValue(ic,Standard_True);
trouve=Standard_True;
@ -1290,7 +1290,7 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
if ( !E1.IsSame(edgelibre1) && !E1.IsSame(edgelibre2) &&
!E2.IsSame(edgelibre1) && !E2.IsSame(edgelibre2)){
Standard_Real ang=Abs(ChFi3d_AngleEdge(V1 ,E1,E2));
deuxconges=(ang<0.01 || Abs(ang-PI)<0.01);
deuxconges=(ang<0.01 || Abs(ang-M_PI)<0.01);
}
}
}
@ -1339,7 +1339,7 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
Indices(nedge,ic,icplus,icmoins);
TopoDS_Edge Arc=TopoDS::Edge(Evive.Value(ic));
ChFiDS_CommonPoint cp1, cp2;
Standard_Real angedg=PI;
Standard_Real angedg=M_PI;
TopoDS_Vertex Vcom;
if (!sharp.Value(icplus)) {
isfirst=(sens.Value(icplus)==1);
@ -1349,7 +1349,7 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
if (cp1.IsOnArc()){
ChFi3d_cherche_vertex(Arc,cp1.Arc(),Vcom,trouve);
if (trouve) angedg=Abs(ChFi3d_AngleEdge(Vcom,Arc,cp1.Arc()));
if (!cp1.Arc().IsSame(Arc) && Abs(angedg-PI)<0.01){
if (!cp1.Arc().IsSame(Arc) && Abs(angedg-M_PI)<0.01){
Evive.SetValue(ic,cp1.Arc());
ChFi3d_edge_common_faces(myEFMap(cp1.Arc()),F1,F2);
if (!Fvive.Value(ic,icplus).IsSame(F1) && !Fvive.Value(ic,icplus).IsSame(F2)) {
@ -1378,10 +1378,10 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
cp2 = CD.Value(icmoins)->SetOfSurfData()->Value(Index.Value(icmoins))->
ChangeVertex (isfirst,jf.Value(icmoins));
if (cp2.IsOnArc()) {
angedg=PI;
angedg=M_PI;
ChFi3d_cherche_vertex(Arc,cp2.Arc(),Vcom,trouve);
if (trouve) angedg=Abs(ChFi3d_AngleEdge(Vcom,Arc,cp2.Arc()));
if (!cp2.Arc().IsSame(Arc)&&Abs(angedg-PI)<0.01) {
if (!cp2.Arc().IsSame(Arc)&&Abs(angedg-M_PI)<0.01) {
Evive.SetValue(ic,cp2.Arc());
ChFi3d_edge_common_faces(myEFMap(cp2.Arc()),F1,F2);
if (!Fvive.Value(ic,icmoins).IsSame(F1) && !Fvive.Value(ic,icmoins).IsSame(F2)) {
@ -1459,7 +1459,7 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
Standard_Integer iface;
// if two edges are tangent the intersection is not attempted (cts60046)
angedg=Abs(ChFi3d_AngleEdge(V1,TopoDS::Edge(Evive.Value(ic)),TopoDS::Edge(Evive.Value(icplus))));
if (Abs(angedg-PI)>0.01)
if (Abs(angedg-M_PI)>0.01)
ok = ChFi3d_SearchFD(DStr,CD.Value(ic),CD.Value(icplus),sens.Value(ic),sens.Value(icplus),
i1,i2,pa1,pa2,
Index.Value(ic),Index.Value(icplus),
@ -2230,20 +2230,20 @@ void ChFi3d_Builder::PerformMoreThreeCorner(const Standard_Integer Jndex,
if (couture) {
Standard_Boolean PI1=Standard_False, PI2=Standard_False;
Standard_Real xx;
PI1=0<=p2d1.X() && p2d1.X() <=PI;
PI2=0<=p2d2.X() && p2d2.X() <=PI;
PI1=0<=p2d1.X() && p2d1.X() <=M_PI;
PI2=0<=p2d2.X() && p2d2.X() <=M_PI;
if (Evive.Value(ic).IsSame(edgecouture)){
xx=p2d1.X();
if (PI2&&!PI1) xx=xx-2*PI;
if (!PI2&&PI1) xx=xx+2*PI;
if (PI2&&!PI1) xx=xx-2*M_PI;
if (!PI2&&PI1) xx=xx+2*M_PI;
p2d1.SetX(xx);
}
if (Evive.Value(icplus).IsSame(edgecouture)){
xx=p2d2.X();
if (PI2&&!PI1) xx=xx+2*PI;
if (!PI2&&PI1) xx=xx-2*PI;
if (PI2&&!PI1) xx=xx+2*M_PI;
if (!PI2&&PI1) xx=xx-2*M_PI;
p2d2.SetX(xx);
}
}

2
src/ChFi3d/ChFi3d_Builder_SpKP.cxx

@ -363,7 +363,7 @@ void ChFi3d_Builder::Trunc(const Handle(ChFiDS_SurfData)& SD,
Standard_Real Ang = dsp.Angle(ded);
Standard_Real dis1 = psp.Distance(ped);
Standard_Real dis2 = p1.Distance(p2);
if(Ang > PI/18.) tron = Standard_True;
if(Ang > M_PI/18.) tron = Standard_True;
if(dis1 >= 0.1*dis2) tron = Standard_True;
Standard_Integer ivois;
if(!tron && YaUnVoisin(Spine,iedge,ivois,isfirst)) {

6
src/ChFi3d/ChFi3d_ChBuilder.cxx

@ -746,9 +746,9 @@ void ChFi3d_ChBuilder::SimulKPart(const Handle(ChFiDS_SurfData)& SD ) const
gp_Cone Co = AS.Cone();
Standard_Real rad = Co.RefRadius(), sang = Co.SemiAngle();
//#ifndef DEB
Standard_Integer n = (Standard_Integer) (36.*ang/PI + 1);
Standard_Integer n = (Standard_Integer) (36.*ang/M_PI + 1);
//#else
// Standard_Integer n = 36.*ang/PI + 1;
// Standard_Integer n = 36.*ang/M_PI + 1;
//#endif
if(n<2) n = 2;
sec = new ChFiDS_SecHArray1(1, n);
@ -2133,7 +2133,7 @@ void ChFi3d_ChBuilder::SetRegul()
gp_Pnt p;
gp_Vec n1,n2,du,dv;
BRep_Builder B;
Standard_Real Seuil = PI/360.;
Standard_Real Seuil = M_PI/360.;
Standard_Real Seuil2 = Seuil * Seuil;
for (it.Initialize(myRegul); it.More(); it.Next()){
const ChFiDS_Regul& reg = it.Value();

8
src/ChFi3d/ChFi3d_FilBuilder.cxx

@ -542,9 +542,9 @@ void ChFi3d_FilBuilder::SimulKPart(const Handle(ChFiDS_SurfData)& SD) const
gp_Torus To = AS.Torus();
Standard_Real majr = To.MajorRadius(), minr = To.MinorRadius();
//#ifndef DEB
Standard_Integer n = (Standard_Integer) (36.*ang/PI + 1);
Standard_Integer n = (Standard_Integer) (36.*ang/M_PI + 1);
//#else
// Standard_Integer n = 36.*ang/PI + 1;
// Standard_Integer n = 36.*ang/M_PI + 1;
//#endif
if(n<2) n = 2;
sec = new ChFiDS_SecHArray1(1, n);
@ -565,9 +565,9 @@ void ChFi3d_FilBuilder::SimulKPart(const Handle(ChFiDS_SurfData)& SD) const
gp_Sphere Sp = AS.Sphere();
Standard_Real rad = Sp.Radius();
//#ifndef DEB
Standard_Integer n = (Standard_Integer) (36.*ang/PI + 1);
Standard_Integer n = (Standard_Integer) (36.*ang/M_PI + 1);
//#else
// Standard_Integer n = 36.*ang/PI + 1;
// Standard_Integer n = 36.*ang/M_PI + 1;
//#endif
if(n<2) n = 2;
sec = new ChFiDS_SecHArray1(1, n);

2
src/ChFi3d/ChFi3d_FilBuilder_C2.cxx

@ -220,7 +220,7 @@ void ChFi3d_FilBuilder::PerformTwoCorner(const Standard_Integer Index)
if (Sens2==-1) dir2.Reverse();
Standard_Real ang1;
ang1=Abs(dir1.Angle(dir2));
if (ang1<PI/180.) {
if (ang1<M_PI/180.) {
PerformMoreThreeCorner(Index,2);
done=1;
return;

Some files were not shown because too many files have changed in this diff Show More