OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0024058: Eliminate compiler warning C4702 in MSVC++ with warning level 4

Browse Source 
Got rid of most of warnings of C4702 type: unreachable code.
Returned some #ifdef DEB
Fixed tabs formatting
Fixed some mistakes in code
This commit is contained in:
omy 2013-07-12 12:54:01 +04:00
parent c1746a0ac9
commit d3f26155b5
59 changed files with 494 additions and 672 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/AIS/AIS_Selection.cxx
View File

@ -283,9 +283,7 @@ AIS_SelectStatus AIS_Selection::Select(const Handle(Standard_Transient)& anObjec
S->myresult.Append( anObject, aListIter ); S->myresult.Append( anObject, aListIter );
S->myResultMap.Bind( anObject, aListIter ); S->myResultMap.Bind( anObject, aListIter );
return AIS_SS_Added; return AIS_SS_Added;
#endif //USE_MAP #endif //USE_MAP
return AIS_SS_Removed;
} }
//======================================================================= //=======================================================================

9
src/APIHeaderSection/APIHeaderSection_EditHeader.cxx
View File

@ -38,19 +38,16 @@ static Standard_Boolean IsTimeStamp
case 4 : if (uncar < '0' || uncar > '9') return Standard_False; break; case 4 : if (uncar < '0' || uncar > '9') return Standard_False; break;
case 5 : if (uncar != '-') return Standard_False; case 5 : if (uncar != '-') return Standard_False;
case 6 : if (uncar != '0' && uncar != '1') return Standard_False; break; case 6 : if (uncar != '0' && uncar != '1') return Standard_False; break;
case 7 : if (uncar < '0' || uncar > '9') return Standard_False; break; case 7 : if (uncar < '0' || uncar > '9') return Standard_False;
if (dizmois == '1' && (uncar < '0' || uncar > '2')) return Standard_False; if (dizmois == '1' && (uncar < '0' || uncar > '2')) return Standard_False; break;
break;
case 8 : if (uncar != '-') return Standard_False; case 8 : if (uncar != '-') return Standard_False;
case 9 : if (uncar < '0' || uncar > '3') return Standard_False; break; case 9 : if (uncar < '0' || uncar > '3') return Standard_False; break;
case 10 : if (uncar < '0' || uncar > '9') return Standard_False; case 10 : if (uncar < '0' || uncar > '9') return Standard_False;
if (dizjour == '3' && (uncar != '0' && uncar != '1')) return Standard_False; if (dizjour == '3' && (uncar != '0' && uncar != '1')) return Standard_False; break;
break;
case 11 : if (uncar != 'T') return Standard_False; case 11 : if (uncar != 'T') return Standard_False;
case 12 : if (uncar < '0' || uncar > '2') return Standard_False; break; case 12 : if (uncar < '0' || uncar > '2') return Standard_False; break;
case 13 : if (uncar < '0' || uncar > '9') return Standard_False; case 13 : if (uncar < '0' || uncar > '9') return Standard_False;
if (dizheur == '2' && (uncar < '0' || uncar > '3')) return Standard_False; break; if (dizheur == '2' && (uncar < '0' || uncar > '3')) return Standard_False; break;
break;
case 14 : if (uncar != ':') return Standard_False; case 14 : if (uncar != ':') return Standard_False;
case 15 : if (uncar < '0' || uncar > '5') return Standard_False; break; case 15 : if (uncar < '0' || uncar > '5') return Standard_False; break;
case 16 : if (uncar < '0' || uncar > '9') return Standard_False; break; case 16 : if (uncar < '0' || uncar > '9') return Standard_False; break;

5
src/Adaptor3d/Adaptor3d_IsoCurve.cxx
View File

@ -805,11 +805,8 @@ gp_Elips Adaptor3d_IsoCurve::Ellipse() const
default: default:
{ {
Standard_NoSuchObject::Raise("Adaptor3d_IsoCurve:Ellipse"); Standard_NoSuchObject::Raise("Adaptor3d_IsoCurve:Ellipse");
} }
} }
// portage WNT
return gp_Elips();
} }
//======================================================================= //=======================================================================

69
src/Adaptor3d/Adaptor3d_SurfaceOfLinearExtrusion.cxx
View File

@ -193,9 +193,8 @@ Handle(Adaptor3d_HSurface) Adaptor3d_SurfaceOfLinearExtrusion::VTrim
const Standard_Real Tol) const const Standard_Real Tol) const
{ {
Handle(Adaptor3d_HCurve) newBasisCurve = Handle(Adaptor3d_HCurve) newBasisCurve =
myBasisCurve->Trim(First, myBasisCurve->Trim(First, Last, Tol);
Last,
Tol) ;
Adaptor3d_SurfaceOfLinearExtrusion * SurfacePtr = Adaptor3d_SurfaceOfLinearExtrusion * SurfacePtr =
new Adaptor3d_SurfaceOfLinearExtrusion(newBasisCurve, myDirection) ; new Adaptor3d_SurfaceOfLinearExtrusion(newBasisCurve, myDirection) ;
@ -288,7 +287,7 @@ Standard_Real Adaptor3d_SurfaceOfLinearExtrusion::VPeriod() const
//======================================================================= //=======================================================================
gp_Pnt Adaptor3d_SurfaceOfLinearExtrusion::Value(const Standard_Real U, gp_Pnt Adaptor3d_SurfaceOfLinearExtrusion::Value(const Standard_Real U,
const Standard_Real V) const Standard_Real V)
const const
{ {
gp_Pnt P; gp_Pnt P;
@ -303,8 +302,8 @@ gp_Pnt Adaptor3d_SurfaceOfLinearExtrusion::Value(const Standard_Real U,
//======================================================================= //=======================================================================
void Adaptor3d_SurfaceOfLinearExtrusion::D0(const Standard_Real U, void Adaptor3d_SurfaceOfLinearExtrusion::D0(const Standard_Real U,
const Standard_Real V, const Standard_Real V,
gp_Pnt& P) const gp_Pnt& P) const
{ {
myBasisCurve->D0(U,P); myBasisCurve->D0(U,P);
P.Translate( V * gp_Vec(myDirection)); P.Translate( V * gp_Vec(myDirection));
@ -316,10 +315,10 @@ void Adaptor3d_SurfaceOfLinearExtrusion::D0(const Standard_Real U,
//======================================================================= //=======================================================================
void Adaptor3d_SurfaceOfLinearExtrusion::D1(const Standard_Real U, void Adaptor3d_SurfaceOfLinearExtrusion::D1(const Standard_Real U,
const Standard_Real V, const Standard_Real V,
gp_Pnt& P, gp_Pnt& P,
gp_Vec& D1U, gp_Vec& D1U,
gp_Vec& D1V) const gp_Vec& D1V) const
{ {
myBasisCurve->D1(U,P,D1U); myBasisCurve->D1(U,P,D1U);
D0(U,V,P); D0(U,V,P);
@ -332,13 +331,13 @@ void Adaptor3d_SurfaceOfLinearExtrusion::D1(const Standard_Real U,
//======================================================================= //=======================================================================
void Adaptor3d_SurfaceOfLinearExtrusion::D2(const Standard_Real U, void Adaptor3d_SurfaceOfLinearExtrusion::D2(const Standard_Real U,
const Standard_Real V, const Standard_Real V,
gp_Pnt& P, gp_Pnt& P,
gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D1U, gp_Vec& D1V,
gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2U, gp_Vec& D2V,
gp_Vec& D2UV) const gp_Vec& D2UV) const
{ {
myBasisCurve->D2(U,P,D1U,D2U); myBasisCurve->D2(U,P,D1U,D2U);
D1V = gp_Vec(myDirection); D1V = gp_Vec(myDirection);
D2V.SetCoord( 0., 0., 0.); D2V.SetCoord( 0., 0., 0.);
D2UV.SetCoord( 0., 0., 0.); D2UV.SetCoord( 0., 0., 0.);
@ -351,13 +350,13 @@ void Adaptor3d_SurfaceOfLinearExtrusion::D2(const Standard_Real U,
//======================================================================= //=======================================================================
void Adaptor3d_SurfaceOfLinearExtrusion::D3(const Standard_Real U, void Adaptor3d_SurfaceOfLinearExtrusion::D3(const Standard_Real U,
const Standard_Real V, const Standard_Real V,
gp_Pnt& P, gp_Pnt& P,
gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D1U, gp_Vec& D1V,
gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2U, gp_Vec& D2V,
gp_Vec& D2UV, gp_Vec& D2UV,
gp_Vec& D3U, gp_Vec& D3V, gp_Vec& D3U, gp_Vec& D3V,
gp_Vec& D3UUV, gp_Vec& D3UVV) const gp_Vec& D3UUV, gp_Vec& D3UVV) const
{ {
myBasisCurve->D3(U,P,D1U,D2U,D3U); myBasisCurve->D3(U,P,D1U,D2U,D3U);
D1V = gp_Vec(myDirection); D1V = gp_Vec(myDirection);
@ -427,10 +426,10 @@ GeomAbs_SurfaceType Adaptor3d_SurfaceOfLinearExtrusion::GetType() const
{ {
gp_Dir D = myBasisCurve->Line().Direction(); gp_Dir D = myBasisCurve->Line().Direction();
if (myDirection.IsParallel( D, Precision::Angular())) { if (myDirection.IsParallel( D, Precision::Angular())) {
return GeomAbs_SurfaceOfExtrusion; return GeomAbs_SurfaceOfExtrusion;
} }
else { else {
return GeomAbs_Plane; return GeomAbs_Plane;
} }
break; break;
} }
@ -439,14 +438,14 @@ GeomAbs_SurfaceType Adaptor3d_SurfaceOfLinearExtrusion::GetType() const
{ {
gp_Dir D = (myBasisCurve->Circle()).Axis().Direction(); gp_Dir D = (myBasisCurve->Circle()).Axis().Direction();
if ( myDirection.IsParallel( D, Precision::Angular())) { if ( myDirection.IsParallel( D, Precision::Angular())) {
return GeomAbs_Cylinder; return GeomAbs_Cylinder;
} }
// JAG 10.11.95 // JAG 10.11.95
else if (myDirection.IsNormal(D, Precision::Angular())) { else if (myDirection.IsNormal(D, Precision::Angular())) {
return GeomAbs_Plane; return GeomAbs_Plane;
} }
else { else {
return GeomAbs_SurfaceOfExtrusion; return GeomAbs_SurfaceOfExtrusion;
} }
break; break;
} }
@ -456,10 +455,10 @@ GeomAbs_SurfaceType Adaptor3d_SurfaceOfLinearExtrusion::GetType() const
{ {
gp_Dir D = (myBasisCurve->Ellipse()).Axis().Direction(); gp_Dir D = (myBasisCurve->Ellipse()).Axis().Direction();
if (myDirection.IsNormal(D, Precision::Angular())) { if (myDirection.IsNormal(D, Precision::Angular())) {
return GeomAbs_Plane; return GeomAbs_Plane;
} }
else { else {
return GeomAbs_SurfaceOfExtrusion; return GeomAbs_SurfaceOfExtrusion;
} }
break; break;
} }
@ -468,10 +467,10 @@ GeomAbs_SurfaceType Adaptor3d_SurfaceOfLinearExtrusion::GetType() const
{ {
gp_Dir D = (myBasisCurve->Parabola()).Axis().Direction(); gp_Dir D = (myBasisCurve->Parabola()).Axis().Direction();
if (myDirection.IsNormal(D, Precision::Angular())) { if (myDirection.IsNormal(D, Precision::Angular())) {
return GeomAbs_Plane; return GeomAbs_Plane;
} }
else { else {
return GeomAbs_SurfaceOfExtrusion; return GeomAbs_SurfaceOfExtrusion;
} }
break; break;
} }
@ -480,10 +479,10 @@ GeomAbs_SurfaceType Adaptor3d_SurfaceOfLinearExtrusion::GetType() const
{ {
gp_Dir D = (myBasisCurve->Hyperbola()).Axis().Direction(); gp_Dir D = (myBasisCurve->Hyperbola()).Axis().Direction();
if (myDirection.IsNormal(D, Precision::Angular())) { if (myDirection.IsNormal(D, Precision::Angular())) {
return GeomAbs_Plane; return GeomAbs_Plane;
} }
else { else {
return GeomAbs_SurfaceOfExtrusion; return GeomAbs_SurfaceOfExtrusion;
} }
break; break;
} }
@ -502,7 +501,7 @@ GeomAbs_SurfaceType Adaptor3d_SurfaceOfLinearExtrusion::GetType() const
gp_Pln Adaptor3d_SurfaceOfLinearExtrusion::Plane() const gp_Pln Adaptor3d_SurfaceOfLinearExtrusion::Plane() const
{ {
Standard_NoSuchObject_Raise_if (GetType() != GeomAbs_Plane, Standard_NoSuchObject_Raise_if (GetType() != GeomAbs_Plane,
"Adaptor3d_SurfaceOfLinearExtrusion::Plane"); "Adaptor3d_SurfaceOfLinearExtrusion::Plane");
/* /*
gp_Pnt P; gp_Pnt P;
gp_Vec Ox, Oy; gp_Vec Ox, Oy;

1
src/BOPTest/BOPTest_BOPCommands.cxx
View File

@ -416,7 +416,6 @@ Standard_Integer bsection(Draw_Interpretor& di,
di << usage; di << usage;
return 1; return 1;
} }
return 0;
} }
//======================================================================= //=======================================================================
//function : bsmt //function : bsmt

9
src/BOPTools/BOPTools_AlgoTools_1.cxx
View File

@ -169,7 +169,6 @@ void CorrectWires(const TopoDS_Face& aFx)
GeomAbs_SurfaceType aType; GeomAbs_SurfaceType aType;
// //
const Handle(Geom_Surface)& aS=BRep_Tool::Surface(aFx); const Handle(Geom_Surface)& aS=BRep_Tool::Surface(aFx);
//BRepAdaptor_Surface aBAS (aFx, Standard_False);
GeomAdaptor_Surface aGAS (aS); GeomAdaptor_Surface aGAS (aS);
aType=aGAS.GetType(); aType=aGAS.GetType();
if (aType!=GeomAbs_Cylinder) { if (aType!=GeomAbs_Cylinder) {
@ -205,7 +204,6 @@ void CorrectWires(const TopoDS_Face& aFx)
aT=BRep_Tool::Parameter(aV, aE); aT=BRep_Tool::Parameter(aV, aE);
const Handle(Geom2d_Curve)& aC2D=BRep_Tool::CurveOnSurface(aE, aF, aT1, aT2); const Handle(Geom2d_Curve)& aC2D=BRep_Tool::CurveOnSurface(aE, aF, aT1, aT2);
aC2D->D0(aT, aP2D); aC2D->D0(aT, aP2D);
//aP=aBAS.Value(aP2D.X(), aP2D.Y());
aS->D0(aP2D.X(), aP2D.Y(), aP); aS->D0(aP2D.X(), aP2D.Y(), aP);
aD2=aPV.SquareDistance(aP); aD2=aPV.SquareDistance(aP);
if (aD2>aD2max) { if (aD2>aD2max) {
@ -325,7 +323,6 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
Standard_Boolean SameRange = TE->SameRange(); Standard_Boolean SameRange = TE->SameRange();
Standard_Real First = myHCurve->FirstParameter(); Standard_Real First = myHCurve->FirstParameter();
Standard_Real Last = myHCurve->LastParameter(); Standard_Real Last = myHCurve->LastParameter();
//Standard_Real Delta =1.e-14;
Standard_Real Delta =1.e-12; Standard_Real Delta =1.e-12;
Handle(BRep_TFace)& TF = *((Handle(BRep_TFace)*) &S.TShape()); Handle(BRep_TFace)& TF = *((Handle(BRep_TFace)*) &S.TShape());
@ -333,7 +330,6 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
const TopLoc_Location& TFloc = TF->Location(); const TopLoc_Location& TFloc = TF->Location();
const Handle(Geom_Surface)& Su = TF->Surface(); const Handle(Geom_Surface)& Su = TF->Surface();
TopLoc_Location L = (Floc * TFloc).Predivided(myShape.Location()); TopLoc_Location L = (Floc * TFloc).Predivided(myShape.Location());
// Standard_Boolean checkclosed = Standard_False;
Standard_Boolean pcurvefound = Standard_False; Standard_Boolean pcurvefound = Standard_False;
BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves()); BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
@ -345,10 +341,7 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
Standard_Real f,l; Standard_Real f,l;
GC->Range(f,l); GC->Range(f,l);
if (SameRange && (f != First || l != Last)) { if (SameRange && (f != First || l != Last)) {
return ;//BRepCheck_InvalidSameRangeFlag); return ;//BRepCheck_InvalidSameRangeFlag;
if (SameParameter) {
return; //BRepCheck_InvalidSameParameterFlag);
}
} }
Handle(Geom_Surface) Sb = cr->Surface(); Handle(Geom_Surface) Sb = cr->Surface();

115
src/BRepAlgo/BRepAlgo_FaceRestrictor.cxx
View File

@ -54,8 +54,8 @@ BRepAlgo_FaceRestrictor::BRepAlgo_FaceRestrictor()
//======================================================================= //=======================================================================
void BRepAlgo_FaceRestrictor::Init(const TopoDS_Face& F, void BRepAlgo_FaceRestrictor::Init(const TopoDS_Face& F,
const Standard_Boolean Proj, const Standard_Boolean Proj,
const Standard_Boolean CorrectionOrientation) const Standard_Boolean CorrectionOrientation)
{ {
myFace = F; modeProj = Proj; myCorrection = CorrectionOrientation; myFace = F; modeProj = Proj; myCorrection = CorrectionOrientation;
} }
@ -89,8 +89,8 @@ void BRepAlgo_FaceRestrictor::Clear()
//======================================================================= //=======================================================================
static Standard_Boolean ChangePCurve (TopoDS_Edge& E, static Standard_Boolean ChangePCurve (TopoDS_Edge& E,
const Handle(Geom_Surface)& S, const Handle(Geom_Surface)& S,
TopLoc_Location& L) TopLoc_Location& L)
{ {
BRep_Builder BB; BRep_Builder BB;
Handle(Geom_Surface) SE; Handle(Geom_Surface) SE;
@ -110,8 +110,8 @@ static Standard_Boolean ChangePCurve (TopoDS_Edge& E,
//======================================================================= //=======================================================================
static void ProjCurve3d (TopoDS_Edge& E, static void ProjCurve3d (TopoDS_Edge& E,
const Handle(Geom_Surface)& S, const Handle(Geom_Surface)& S,
TopLoc_Location& L) TopLoc_Location& L)
{ {
BRep_Builder BB; BRep_Builder BB;
TopLoc_Location LE; TopLoc_Location LE;
@ -124,7 +124,7 @@ static void ProjCurve3d (TopoDS_Edge& E,
Handle(Geom2d_Curve) C2 = GeomProjLib::Curve2d (CT,S); Handle(Geom2d_Curve) C2 = GeomProjLib::Curve2d (CT,S);
BB.UpdateEdge(E,C2,S,L,Precision::Confusion()); BB.UpdateEdge(E,C2,S,L,Precision::Confusion());
} }
//======================================================================= //=======================================================================
//function : Perform //function : Perform
@ -168,19 +168,18 @@ void BRepAlgo_FaceRestrictor::Perform()
Handle(Geom2d_Curve) C2 = BRep_Tool::CurveOnSurface(E,S,L,f,l); Handle(Geom2d_Curve) C2 = BRep_Tool::CurveOnSurface(E,S,L,f,l);
if (C2.IsNull()) { if (C2.IsNull()) {
// no pcurve on the reference surface. // no pcurve on the reference surface.
if (modeProj) { if (modeProj) {
// Projection of the 3D curve on surface. // Projection of the 3D curve on surface.
ProjCurve3d ( E, S, L); ProjCurve3d ( E, S, L);
} }
else { else {
// return the first pcurve glued on <S> // return the first pcurve glued on <S>
Standard_Boolean YaPCurve = ChangePCurve (E, S, L); Standard_Boolean YaPCurve = ChangePCurve (E, S, L);
if (!YaPCurve) { if (!YaPCurve) {
ProjCurve3d (E, S, L); ProjCurve3d (E, S, L);
} }
}
}
} }
} }
WTF.AddWire(W); WTF.AddWire(W);
@ -256,11 +255,9 @@ static Standard_Boolean IsClosed (const TopoDS_Wire& W)
//======================================================================= //=======================================================================
static Standard_Boolean IsInside(const TopoDS_Wire& wir, static Standard_Boolean IsInside(const TopoDS_Wire& wir,
const TopoDS_Face& F, const TopoDS_Face& F,
BRepTopAdaptor_FClass2d& /*FClass2d*/) BRepTopAdaptor_FClass2d& /*FClass2d*/)
{ {
//Standard_Real U,V;
TopExp_Explorer exp; TopExp_Explorer exp;
for (exp.Init(wir,TopAbs_EDGE); for (exp.Init(wir,TopAbs_EDGE);
exp.More(); exp.More();
@ -270,20 +267,18 @@ static Standard_Boolean IsInside(const TopoDS_Wire& wir,
Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(edg,F,f,l); Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(edg,F,f,l);
Standard_Real prm; Standard_Real prm;
if (!Precision::IsNegativeInfinite(f) && if (!Precision::IsNegativeInfinite(f) && !Precision::IsPositiveInfinite(l)) {
!Precision::IsPositiveInfinite(l)) {
prm = (f+l)/2.; prm = (f+l)/2.;
} }
else { else {
if (Precision::IsNegativeInfinite(f) && if (Precision::IsNegativeInfinite(f) && Precision::IsPositiveInfinite(l)){
Precision::IsPositiveInfinite(l)){ prm = 0.;
prm = 0.;
} }
else if (Precision::IsNegativeInfinite(f)) { else if (Precision::IsNegativeInfinite(f)) {
prm = l-1.; prm = l-1.;
} }
else { else {
prm = f+1.; prm = f+1.;
} }
} }
@ -300,9 +295,9 @@ static Standard_Boolean IsInside(const TopoDS_Wire& wir,
//======================================================================= //=======================================================================
static void Store (const TopoDS_Wire& W2, static void Store (const TopoDS_Wire& W2,
const TopoDS_Wire& W1, const TopoDS_Wire& W1,
TopTools_DataMapOfShapeListOfShape& keyIsIn, TopTools_DataMapOfShapeListOfShape& keyIsIn,
TopTools_DataMapOfShapeListOfShape& keyContains) TopTools_DataMapOfShapeListOfShape& keyContains)
{ {
if (!keyIsIn.IsBound(W2)) { if (!keyIsIn.IsBound(W2)) {
TopTools_ListOfShape empty; TopTools_ListOfShape empty;
@ -320,12 +315,12 @@ static void Store (const TopoDS_Wire& W2,
//purpose : //purpose :
//======================================================================= //=======================================================================
static void BuildFaceIn( TopoDS_Face& F, static void BuildFaceIn( TopoDS_Face& F,
const TopoDS_Wire& W, const TopoDS_Wire& W,
TopTools_DataMapOfShapeListOfShape& KeyContains, TopTools_DataMapOfShapeListOfShape& KeyContains,
TopTools_DataMapOfShapeListOfShape& KeyIsIn, TopTools_DataMapOfShapeListOfShape& KeyIsIn,
TopAbs_Orientation Orientation, TopAbs_Orientation Orientation,
TopTools_ListOfShape& Faces) TopTools_ListOfShape& Faces)
{ {
BRep_Builder B; BRep_Builder B;
@ -341,8 +336,8 @@ static void BuildFaceIn( TopoDS_Face& F,
TopTools_ListIteratorOfListOfShape it2; TopTools_ListIteratorOfListOfShape it2;
for (it2.Initialize(L2); it2.More(); it2.Next()) { for (it2.Initialize(L2); it2.More(); it2.Next()) {
if (it2.Value().IsSame(W)) { if (it2.Value().IsSame(W)) {
L2.Remove(it2); L2.Remove(it2);
break; break;
} }
} }
} }
@ -363,19 +358,19 @@ static void BuildFaceIn( TopoDS_Face& F,
TopTools_ListOfShape& L2 = KeyIsIn(WI); TopTools_ListOfShape& L2 = KeyIsIn(WI);
if (L2.IsEmpty()) { if (L2.IsEmpty()) {
if (Orientation == TopAbs_FORWARD) { if (Orientation == TopAbs_FORWARD) {
TopoDS_Wire NWI(WI); TopoDS_Wire NWI(WI);
NWI.Reverse(); NWI.Reverse();
// TopoDS_Wire NWI = TopoDS::Wire(WI.Reversed()); // TopoDS_Wire NWI = TopoDS::Wire(WI.Reversed());
B.Add(F,NWI); B.Add(F,NWI);
BuildFaceIn (F,WI,KeyContains, KeyIsIn,TopAbs_REVERSED,Faces); BuildFaceIn (F,WI,KeyContains, KeyIsIn,TopAbs_REVERSED,Faces);
} }
else { else {
TopoDS_Shape aLocalShape = Faces.First().EmptyCopied(); TopoDS_Shape aLocalShape = Faces.First().EmptyCopied();
TopoDS_Face NF = TopoDS::Face(aLocalShape); TopoDS_Face NF = TopoDS::Face(aLocalShape);
// TopoDS_Face NF = TopoDS::Face(Faces.First().EmptyCopied());; // TopoDS_Face NF = TopoDS::Face(Faces.First().EmptyCopied());;
B.Add (NF,WI); B.Add (NF,WI);
Faces.Append (NF); Faces.Append (NF);
BuildFaceIn (NF, WI, KeyContains, KeyIsIn, TopAbs_FORWARD,Faces); BuildFaceIn (NF, WI, KeyContains, KeyIsIn, TopAbs_FORWARD,Faces);
} }
} }
} }
@ -406,7 +401,7 @@ void BRepAlgo_FaceRestrictor::PerformWithCorrection()
if (IsClosed(W)) { if (IsClosed(W)) {
BRepTopAdaptor_FClass2d FClass2d(NF,Precision::PConfusion()); BRepTopAdaptor_FClass2d FClass2d(NF,Precision::PConfusion());
if(FClass2d.PerformInfinitePoint() != TopAbs_OUT) { if(FClass2d.PerformInfinitePoint() != TopAbs_OUT) {
W.Reverse(); W.Reverse();
} }
} }
} }
@ -429,12 +424,12 @@ void BRepAlgo_FaceRestrictor::PerformWithCorrection()
BRepTopAdaptor_FClass2d FClass2d(NF,Precision::PConfusion()); BRepTopAdaptor_FClass2d FClass2d(NF,Precision::PConfusion());
while (it2.More()) { while (it2.More()) {
const TopoDS_Wire& W2 = TopoDS::Wire(it2.Value()); const TopoDS_Wire& W2 = TopoDS::Wire(it2.Value());
if (!W1.IsSame(W2) && IsInside (W2,NF,FClass2d)) { if (!W1.IsSame(W2) && IsInside (W2,NF,FClass2d)) {
Store (W2,W1,keyIsIn,keyContains); Store (W2,W1,keyIsIn,keyContains);
} }
it2.Next(); it2.Next();
j++; j++;
} }
} }
i++; i++;

1
src/BRepFill/BRepFill_Pipe.cxx
View File

@ -635,7 +635,6 @@ TopoDS_Shape BRepFill_Pipe::MakeShape(const TopoDS_Shape& S,
else { else {
return result; return result;
} }
return result;
} }
//============================================================================ //============================================================================

2
src/BRepGProp/BRepGProp_EdgeTool.cxx
View File

@ -65,8 +65,6 @@ Standard_Integer BRepGProp_EdgeTool::IntegrationOrder(const BRepAdaptor_Curve&
default : default :
return 10; return 10;
} }
//POP WE should return something : -> Default
return 10;
} }
gp_Pnt BRepGProp_EdgeTool::Value(const BRepAdaptor_Curve& C, const Standard_Real U) gp_Pnt BRepGProp_EdgeTool::Value(const BRepAdaptor_Curve& C, const Standard_Real U)

6
src/BRepTest/BRepTest_CurveCommands.cxx
View File

@ -73,7 +73,6 @@
#include <TopOpeBRep_Point2d.hxx> #include <TopOpeBRep_Point2d.hxx>
#include <TopOpeBRepDS_Transition.hxx> #include <TopOpeBRepDS_Transition.hxx>
//#ifdef WNT
#include <stdio.h> #include <stdio.h>
#ifdef WNT #ifdef WNT
Standard_IMPORT Draw_Viewer dout; Standard_IMPORT Draw_Viewer dout;
@ -1142,11 +1141,6 @@ static Standard_Integer bsplineprof(Draw_Interpretor& di,
DBRep::Set(a[1],S); DBRep::Set(a[1],S);
return 0; return 0;
#ifdef DEB
di << "profile : bad number of arguments";
return 1;
#endif
} }

163
src/BRepTools/BRepTools_NurbsConvertModification.cxx
View File

@ -69,25 +69,25 @@
#include <BRep_ListIteratorOfListOfCurveRepresentation.hxx> #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
static void GeomLib_ChangeUBounds(Handle(Geom_BSplineSurface)& aSurface, static void GeomLib_ChangeUBounds(Handle(Geom_BSplineSurface)& aSurface,
const Standard_Real newU1, const Standard_Real newU1,
const Standard_Real newU2) const Standard_Real newU2)
{ {
TColStd_Array1OfReal knots(1,aSurface->NbUKnots()) ; TColStd_Array1OfReal knots(1,aSurface->NbUKnots()) ;
aSurface->UKnots(knots) ; aSurface->UKnots(knots) ;
BSplCLib::Reparametrize(newU1, BSplCLib::Reparametrize(newU1,
newU2, newU2,
knots) ; knots) ;
aSurface->SetUKnots(knots) ; aSurface->SetUKnots(knots) ;
} }
static void GeomLib_ChangeVBounds(Handle(Geom_BSplineSurface)& aSurface, static void GeomLib_ChangeVBounds(Handle(Geom_BSplineSurface)& aSurface,
const Standard_Real newV1, const Standard_Real newV1,
const Standard_Real newV2) const Standard_Real newV2)
{ {
TColStd_Array1OfReal knots(1,aSurface->NbVKnots()) ; TColStd_Array1OfReal knots(1,aSurface->NbVKnots()) ;
aSurface->VKnots(knots) ; aSurface->VKnots(knots) ;
BSplCLib::Reparametrize(newV1, BSplCLib::Reparametrize(newV1,
newV2, newV2,
knots) ; knots) ;
aSurface->SetVKnots(knots) ; aSurface->SetVKnots(knots) ;
} }
@ -417,45 +417,45 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
Handle(Standard_Type) myT = S->DynamicType(); Handle(Standard_Type) myT = S->DynamicType();
if(myT != STANDARD_TYPE(Geom_Plane)) { if(myT != STANDARD_TYPE(Geom_Plane)) {
if(newF.IsNull()) { if(newF.IsNull()) {
Handle(Standard_Type) st = C2d->DynamicType(); Handle(Standard_Type) st = C2d->DynamicType();
if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) || if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) ||
(st == STANDARD_TYPE(Geom2d_BezierCurve))) { (st == STANDARD_TYPE(Geom2d_BezierCurve))) {
if(isConvert2d) { if(isConvert2d) {
Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy()); Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
return Standard_True; return Standard_True;
} }
return Standard_False; return Standard_False;
} }
} }
else { else {
S = BRep_Tool::Surface(newF); S = BRep_Tool::Surface(newF);
} }
S->Bounds(Uinf, Usup, Vinf, Vsup); S->Bounds(Uinf, Usup, Vinf, Vsup);
//Uinf -= 1e-9; Usup += 1e-9; Vinf -= 1e-9; Vsup += 1e-9; //Uinf -= 1e-9; Usup += 1e-9; Vinf -= 1e-9; Vsup += 1e-9;
u = (Usup - Uinf)*0.1; u = (Usup - Uinf)*0.1;
v = (Vsup - Vinf)*0.1; v = (Vsup - Vinf)*0.1;
if(S->IsUPeriodic()) { if(S->IsUPeriodic()) {
Standard_Real uperiod = S->UPeriod(); Standard_Real uperiod = S->UPeriod();
if(uperiod < (Usup+2*u-Uinf)) { if(uperiod < (Usup+2*u-Uinf)) {
if(uperiod <= (Usup-Uinf)) { if(uperiod <= (Usup-Uinf)) {
u = 0; u = 0;
} }
else { else {
u = (uperiod-(Usup-Uinf))*0.5; u = (uperiod-(Usup-Uinf))*0.5;
} }
} }
} }
if(S->IsVPeriodic()) { if(S->IsVPeriodic()) {
Standard_Real vperiod = S->VPeriod(); Standard_Real vperiod = S->VPeriod();
if(vperiod < (Vsup+2*v-Vinf)) { if(vperiod < (Vsup+2*v-Vinf)) {
if(vperiod <= (Vsup-Vinf)) { if(vperiod <= (Vsup-Vinf)) {
v = 0; v = 0;
} }
else { else {
v = (vperiod-(Vsup-Vinf))*0.5; v = (vperiod-(Vsup-Vinf))*0.5;
} }
} }
} }
} }
else { else {
@ -464,8 +464,8 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS); Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);
ProjLib_ComputeApprox ProjOnCurve(G3dAHC,GAHS,Tol); ProjLib_ComputeApprox ProjOnCurve(G3dAHC,GAHS,Tol);
if(ProjOnCurve.BSpline().IsNull()) { if(ProjOnCurve.BSpline().IsNull()) {
Curve2d = Geom2dConvert::CurveToBSplineCurve(ProjOnCurve.Bezier()); Curve2d = Geom2dConvert::CurveToBSplineCurve(ProjOnCurve.Bezier());
return Standard_True; return Standard_True;
} }
Curve2d = ProjOnCurve.BSpline(); Curve2d = ProjOnCurve.BSpline();
return Standard_True; return Standard_True;
@ -491,11 +491,12 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
TColStd_ListIteratorOfListOfTransient itlcu; TColStd_ListIteratorOfListOfTransient itlcu;
for (itled.Initialize(myled), itlcu.Initialize(mylcu); for (itled.Initialize(myled), itlcu.Initialize(mylcu);
itled.More(); // itlcu.More() itled.More(); // itlcu.More()
itled.Next(),itlcu.Next()) { itled.Next(),itlcu.Next())
{
if (itled.Value().IsSame(E)) { if (itled.Value().IsSame(E)) {
// deja traitee // deja traitee
break; break;
} }
} }
if (!itled.More()) { // on stocke l`edge et la curve2d if (!itled.More()) { // on stocke l`edge et la curve2d
@ -521,10 +522,10 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
return Standard_True; return Standard_True;
} }
return Standard_False; return Standard_False;
} }
if(!newE.IsNull()) { if(!newE.IsNull()) {
C3d = BRep_Tool::Curve(newE, f3d,l3d); C3d = BRep_Tool::Curve(newE, f3d,l3d);
} }
GeomAdaptor_Curve G3dAC(C3d, f3d, l3d); GeomAdaptor_Curve G3dAC(C3d, f3d, l3d);
Handle(GeomAdaptor_HCurve) G3dAHC = new GeomAdaptor_HCurve(G3dAC); Handle(GeomAdaptor_HCurve) G3dAHC = new GeomAdaptor_HCurve(G3dAC);
@ -532,19 +533,19 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
Handle(Geom_Surface) S = BRep_Tool::Surface(F); Handle(Geom_Surface) S = BRep_Tool::Surface(F);
Handle(Standard_Type) myT = S->DynamicType(); Handle(Standard_Type) myT = S->DynamicType();
if(newF.IsNull()) { if(newF.IsNull()) {
mylcu.Append(C2dBis); mylcu.Append(C2dBis);
Handle(Standard_Type) st = C2d->DynamicType(); Handle(Standard_Type) st = C2d->DynamicType();
if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) || if ((st == STANDARD_TYPE(Geom2d_BSplineCurve)) ||
(st == STANDARD_TYPE(Geom2d_BezierCurve))) { (st == STANDARD_TYPE(Geom2d_BezierCurve))) {
if(isConvert2d) { if(isConvert2d) {
Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy()); Curve2d = Handle(Geom2d_Curve)::DownCast(C2d->Copy());
return Standard_True; return Standard_True;
} }
return Standard_False; return Standard_False;
} }
} }
else { else {
S = BRep_Tool::Surface(newF);// S est une BSplineSurface : pas besoin de la trimmed S = BRep_Tool::Surface(newF);// S est une BSplineSurface : pas besoin de la trimmed
} }
Standard_Real Uinf, Usup, Vinf, Vsup, u = 0, v = 0; Standard_Real Uinf, Usup, Vinf, Vsup, u = 0, v = 0;
S->Bounds(Uinf, Usup, Vinf, Vsup); S->Bounds(Uinf, Usup, Vinf, Vsup);
@ -552,52 +553,50 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewCurve2d
u = (Usup - Uinf)*0.1; u = (Usup - Uinf)*0.1;
v = (Vsup - Vinf)*0.1; v = (Vsup - Vinf)*0.1;
if(S->IsUPeriodic()) { if(S->IsUPeriodic()) {
Standard_Real uperiod = S->UPeriod(); Standard_Real uperiod = S->UPeriod();
if(uperiod < (Usup+2*u-Uinf)) if(uperiod < (Usup+2*u-Uinf))
if(uperiod <= (Usup-Uinf)) if(uperiod <= (Usup-Uinf))
u = 0; u = 0;
else else
u = (uperiod-(Usup-Uinf))*0.5; u = (uperiod-(Usup-Uinf))*0.5;
} }
if(S->IsVPeriodic()) { if(S->IsVPeriodic()) {
Standard_Real vperiod = S->VPeriod(); Standard_Real vperiod = S->VPeriod();
if(vperiod < (Vsup+2*v-Vinf)) if(vperiod < (Vsup+2*v-Vinf))
if(vperiod <= (Vsup-Vinf)) if(vperiod <= (Vsup-Vinf))
v = 0; v = 0;
else else
v = (vperiod-(Vsup-Vinf))*0.5; v = (vperiod-(Vsup-Vinf))*0.5;
} }
GeomAdaptor_Surface GAS(S, Uinf-u,Usup+u,Vinf-v,Vsup+v); GeomAdaptor_Surface GAS(S, Uinf-u,Usup+u,Vinf-v,Vsup+v);
Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS); Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(GAS);
myled.Append(E); myled.Append(E);
ProjLib_ComputeApproxOnPolarSurface ProjLib_ComputeApproxOnPolarSurface
ProjOnCurve(G2dAHC,G2dAHCBis,G3dAHC,GAHS,Tol); ProjOnCurve(G2dAHC,G2dAHCBis,G3dAHC,GAHS,Tol);
if(ProjOnCurve.IsDone()) { if(ProjOnCurve.IsDone()) {
Curve2d = ProjOnCurve.BSpline(); Curve2d = ProjOnCurve.BSpline();
mylcu.Append(ProjOnCurve.Curve2d()); mylcu.Append(ProjOnCurve.Curve2d());
return Standard_True; return Standard_True;
} }
else { else {
Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d); Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
mylcu.Append(C2dBis); mylcu.Append(C2dBis);
return Standard_True; return Standard_True;
} }
} }
else { // on est au 2ieme tour else { // on est au 2ieme tour
C2d = Handle(Geom2d_Curve)::DownCast(itlcu.Value()); C2d = Handle(Geom2d_Curve)::DownCast(itlcu.Value());
Handle(Standard_Type) st = C2d->DynamicType(); Handle(Standard_Type) st = C2d->DynamicType();
if (!(st == STANDARD_TYPE(Geom2d_BSplineCurve)) && if (!(st == STANDARD_TYPE(Geom2d_BSplineCurve)) &&
!(st == STANDARD_TYPE(Geom2d_BezierCurve))) { !(st == STANDARD_TYPE(Geom2d_BezierCurve))) {
return Standard_False; return Standard_False;
} }
Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d); Curve2d = Geom2dConvert::CurveToBSplineCurve(C2d);
return Standard_True; return Standard_True;
} }
} }
Curve2d = C2d;
return Standard_True;
} }
//======================================================================= //=======================================================================
@ -632,7 +631,7 @@ Standard_Boolean BRepTools_NurbsConvertModification::NewParameter
if(proj.IsDone()) { if(proj.IsDone()) {
Standard_Real Dist2Min = proj.SquareDistance(); Standard_Real Dist2Min = proj.SquareDistance();
if (Dist2Min < Tol*Tol) { if (Dist2Min < Tol*Tol) {
// Standard_Real U_final_point,V_final_point; // Standard_Real U_final_point,V_final_point;
P = proj.Point().Parameter(); P = proj.Point().Parameter();
return Standard_True; return Standard_True;
} }

1
src/ChFi2d/ChFi2d_Builder_0.cxx
View File

@ -707,7 +707,6 @@ gp_Pnt ComputePoint(const TopoDS_Vertex& V,const TopoDS_Edge& E,
thePoint = cc.Value(Param); thePoint = cc.Value(Param);
return thePoint; return thePoint;
} // else ... } // else ...
return thePoint;
} // ComputePoint } // ComputePoint

1
src/ChFi3d/ChFi3d_Builder_CnCrn.cxx
View File

@ -917,7 +917,6 @@ static Standard_Integer SurfIndex(const ChFiDS_StripeArray1& StripeArray1,
case FACE2: return aSurfData->IndexOfS2(); case FACE2: return aSurfData->IndexOfS2();
default: return -1; default: return -1;
} }
return -1;
} }
//======================================================================= //=======================================================================

2
src/ChFi3d/ChFi3d_Builder_SpKP.cxx
View File

@ -199,8 +199,6 @@ static Standard_Real ComputeAbscissa(const BRepAdaptor_Curve& C,
default: default:
return 0; return 0;
} }
Standard_NotImplemented::Raise("calculate abscisse non-processed");
return 0.;
} }
//======================================================================= //=======================================================================

30
src/DDataStd/DDataStd_DrawDriver.cxx
View File

@ -209,13 +209,13 @@ Handle(Draw_Drawable3D) DDataStd_DrawDriver::DrawableConstraint (const Handle(TD
case TDataXtd_RADIUS: case TDataXtd_RADIUS:
{ {
if (A->IsPlanar()) { if (A->IsPlanar()) {
D = new DrawDim_PlanarRadius (TNaming_Tool::GetShape(A->GetGeometry(1))); D = new DrawDim_PlanarRadius (TNaming_Tool::GetShape(A->GetGeometry(1)));
} }
else { else {
TopoDS_Shape aLocalShape = Geometry(A,1,TopAbs_FACE); TopoDS_Shape aLocalShape = Geometry(A,1,TopAbs_FACE);
TopoDS_Face F1 = TopoDS::Face(aLocalShape); TopoDS_Face F1 = TopoDS::Face(aLocalShape);
// TopoDS_Face F1 = TopoDS::Face(Geometry(A,1,TopAbs_FACE)); // TopoDS_Face F1 = TopoDS::Face(Geometry(A,1,TopAbs_FACE));
if (!F1.IsNull()) D = new DrawDim_Radius(F1); if (!F1.IsNull()) D = new DrawDim_Radius(F1);
} }
} }
break; break;
@ -250,25 +250,11 @@ Handle(Draw_Drawable3D) DDataStd_DrawDriver::DrawableConstraint (const Handle(TD
case TDataXtd_DISTANCE: case TDataXtd_DISTANCE:
{ {
if (A->IsPlanar()) { if (A->IsPlanar()) {
D = new DrawDim_PlanarDistance (TNaming_Tool::GetShape(A->GetGeometry(1)), D = new DrawDim_PlanarDistance (TNaming_Tool::GetShape(A->GetGeometry(1)),
TNaming_Tool::GetShape(A->GetGeometry(2))); TNaming_Tool::GetShape(A->GetGeometry(2)));
}
else {
break;
TopoDS_Shape aLocalShape = (Geometry (A, 1, TopAbs_FACE));
TopoDS_Face F1 = TopoDS::Face (aLocalShape);
// TopoDS_Face F1 = TopoDS::Face (Geometry (A, 1, TopAbs_FACE));
if (A->NbGeometries() == 1) D = new DrawDim_Distance (F1);
else {
TopoDS_Shape aLocalShape = Geometry(A,2,TopAbs_FACE);
TopoDS_Face F2 = TopoDS::Face(aLocalShape);
// TopoDS_Face F2 = TopoDS::Face(Geometry(A,2,TopAbs_FACE));
D = new DrawDim_Distance(F1,F2);
}
} }
break;
} }
break;
case TDataXtd_ANGLE: case TDataXtd_ANGLE:
{ {
if (A->IsPlanar()) { if (A->IsPlanar()) {

2
src/DPrsStd/DPrsStd_AISPresentationCommands.cxx
View File

@ -89,8 +89,6 @@ static Standard_Integer DPrsStd_AISDisplay (Draw_Interpretor& di,
TPrsStd_AISViewer::Update(L); TPrsStd_AISViewer::Update(L);
return 0; return 0;
} }
di << "DPrsStd_AISDisplay : Error" << "\n";
return 1;
} }
//======================================================================= //=======================================================================

3
src/Draw/Draw_BasicCommands.cxx
View File

@ -416,10 +416,9 @@ static unsigned int __stdcall CpuFunc (void * param)
{ {
cout << "Process killed by CPU limit (" << CPU_LIMIT << " sec)" << endl; cout << "Process killed by CPU limit (" << CPU_LIMIT << " sec)" << endl;
ExitProcess (2); ExitProcess (2);
return 0; // return 0;
} }
} }
return 0;
} }
#else #else
static void CpuFunc (int) static void CpuFunc (int)

1
src/Draw/Draw_Window.cxx
View File

@ -1405,7 +1405,6 @@ LRESULT APIENTRY DrawWindow::DrawProc(HWND hWnd, UINT wMsg, WPARAM wParam, LPARA
else else
return(DefMDIChildProc(hWnd, wMsg, wParam, lParam)); return(DefMDIChildProc(hWnd, wMsg, wParam, lParam));
} }
return (0l);
} }

1
src/GCPnts/GCPnts_QuasiUniformDeflection.gxx
View File

@ -229,7 +229,6 @@ static Standard_Boolean PerformComposite (TColStd_SequenceOfReal& Parameters,
Ua = Ub; Ua = Ub;
} }
return Standard_True;
} }

1
src/GCPnts/GCPnts_UniformDeflection.gxx
View File

@ -194,7 +194,6 @@ static Standard_Boolean PerformComposite (TColStd_SequenceOfReal& Parameters,
Ua = Ub; Ua = Ub;
} }
return Standard_True;
} }

3
src/Geom2dGcc/Geom2dGcc_Circ2d2TanOn.cxx
View File

@ -715,7 +715,6 @@ Standard_Boolean Geom2dGcc_Circ2d2TanOn::
if (TheSame1(Index) == 0) { return Standard_False; } if (TheSame1(Index) == 0) { return Standard_False; }
else { return Standard_True; } else { return Standard_True; }
} }
return Standard_False;
} }
Standard_Boolean Geom2dGcc_Circ2d2TanOn:: Standard_Boolean Geom2dGcc_Circ2d2TanOn::
@ -731,5 +730,5 @@ Standard_Boolean Geom2dGcc_Circ2d2TanOn::
if (TheSame1(Index) == 0) { return Standard_False; } if (TheSame1(Index) == 0) { return Standard_False; }
else { return Standard_True; } else { return Standard_True; }
} }
return Standard_True; // return Standard_True;
} }

3
src/Geom2dGcc/Geom2dGcc_Circ2d2TanRad.cxx
View File

@ -496,7 +496,6 @@ Standard_Boolean Geom2dGcc_Circ2d2TanRad::
if (TheSame1(Index) == 0) { return Standard_False; } if (TheSame1(Index) == 0) { return Standard_False; }
else { return Standard_True; } else { return Standard_True; }
} }
return Standard_True;
} }
Standard_Boolean Geom2dGcc_Circ2d2TanRad:: Standard_Boolean Geom2dGcc_Circ2d2TanRad::
@ -512,5 +511,5 @@ Standard_Boolean Geom2dGcc_Circ2d2TanRad::
if (TheSame1(Index) == 0) { return Standard_False; } if (TheSame1(Index) == 0) { return Standard_False; }
else { return Standard_True; } else { return Standard_True; }
} }
return Standard_True; // return Standard_True;
} }

3
src/GeomFill/GeomFill.cxx
View File

@ -579,7 +579,7 @@ Standard_Boolean GeomFill::GetCircle(const Convert_ParameterisationType TConv,
} }
return Standard_True; return Standard_True;
} }
return Standard_False; // return Standard_False;
} }
Standard_Boolean GeomFill::GetCircle(const Convert_ParameterisationType TConv, Standard_Boolean GeomFill::GetCircle(const Convert_ParameterisationType TConv,
@ -763,5 +763,4 @@ Standard_Boolean GeomFill::GetCircle(const Convert_ParameterisationType TConv,
} }
return Standard_True; return Standard_True;
} }
return Standard_False;
} }

44
src/GeometryTest/GeometryTest_ConstraintCommands.cxx
View File

@ -344,45 +344,43 @@ static Standard_Integer cirtang (Draw_Interpretor& di,Standard_Integer n, const
} }
else { else {
// R-C-R // R-C-R
di << "Radius - Curve - Radius ??"<<"\n"; di << "Radius - Curve - Radius ??"<<"\n";
return 1; return 1;
} }
} }
else if (ip2) { else if (ip2) {
// R-P-.. // R-P-..
if (!C3.IsNull()) { if (!C3.IsNull()) {
// R-P-C // R-P-C
Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C3), Geom2dGcc_Circ2d2TanRad ct3(Geom2dGcc::Unqualified(C3),
new Geom2d_CartesianPoint(P2), new Geom2d_CartesianPoint(P2),
Draw::Atof(a[2]), Draw::Atof(a[2]),
tol); tol);
return solutions(di,ct3,a[1]); return solutions(di,ct3,a[1]);
}
else if (ip3) {
// R-P-P
Geom2dGcc_Circ2d2TanRad ct3(new Geom2d_CartesianPoint(P2),
new Geom2d_CartesianPoint(P3),
Draw::Atof(a[2]),
tol);
return solutions(di,ct3,a[1]);
} }
else if (ip3)
{
// R-P-P
Geom2dGcc_Circ2d2TanRad ct3(new Geom2d_CartesianPoint(P2),
new Geom2d_CartesianPoint(P3),
Draw::Atof(a[2]),
tol);
return solutions(di,ct3,a[1]);
}
else { else {
// R-P-R // R-P-R
di << "Radius - Point - Radius ??"<<"\n"; di << "Radius - Point - Radius ??"<<"\n";
return 1; return 1;
} }
} }
else { else {
// R-R-.. // R-R-..
di << "radius, radius ???"<<"\n"; di << "radius, radius ???"<<"\n";
return 1; return 1;
} }
} }
return 0;
} }

3
src/IntPatch/IntPatch_LineConstructor.cxx
View File

@ -262,7 +262,7 @@ static Standard_Real LocalFirstParameter (const Handle(IntPatch_Line)& L)
return firstp; return firstp;
} }
} }
return firstp; // return firstp;
} }
//======================================================================= //=======================================================================
@ -344,7 +344,6 @@ static Standard_Real LocalLastParameter (const Handle(IntPatch_Line)& L)
return lastp; return lastp;
} }
} }
return lastp;
} }

3
src/IntPatch/IntPatch_Polyhedron.cxx
View File

@ -518,8 +518,7 @@ Standard_Integer IntPatch_Polyhedron::TriConnex (const Standard_Integer Triang,
TempOtherP = OtherP; TempOtherP = OtherP;
return(0); //-- BUG NON CORRIGE ( a revoir le role de nbdeltaU et nbdeltaV) return(0); //-- BUG NON CORRIGE ( a revoir le role de nbdeltaU et nbdeltaV)
// return(TriConnex(TempTri,Pivot,TempOtherP,TriCon,OtherP));
return(TriConnex(TempTri,Pivot,TempOtherP,TriCon,OtherP));
} }
return TriCon; return TriCon;
} }

16
src/IntSurf/IntSurf_Quadric.cxx
View File

@ -262,10 +262,10 @@ gp_Pnt IntSurf_Quadric::Value(const Standard_Real U,
gp_Pnt p(0,0,0); gp_Pnt p(0,0,0);
return(p); return(p);
} }
break; //break;
} }
// pop : pour NT // pop : pour NT
return gp_Pnt(0,0,0); // return gp_Pnt(0,0,0);
} }
// ============================================================ // ============================================================
void IntSurf_Quadric::D1(const Standard_Real U, void IntSurf_Quadric::D1(const Standard_Real U,
@ -313,10 +313,10 @@ gp_Vec IntSurf_Quadric::DN(const Standard_Real U,
gp_Vec v(0,0,0); gp_Vec v(0,0,0);
return(v); return(v);
} }
break; //break;
} }
// pop : pour NT // pop : pour NT
return gp_Vec(0,0,0); // return gp_Vec(0,0,0);
} }
// ============================================================ // ============================================================
gp_Vec IntSurf_Quadric::Normale(const Standard_Real U, gp_Vec IntSurf_Quadric::Normale(const Standard_Real U,
@ -348,10 +348,10 @@ gp_Vec IntSurf_Quadric::Normale(const Standard_Real U,
gp_Vec v(0,0,0); gp_Vec v(0,0,0);
return(v); return(v);
} }
break; // break;
} }
// pop : pour NT // pop : pour NT
return gp_Vec(0,0,0); // return gp_Vec(0,0,0);
} }
// ============================================================ // ============================================================
gp_Vec IntSurf_Quadric::Normale (const gp_Pnt& P) const gp_Vec IntSurf_Quadric::Normale (const gp_Pnt& P) const
@ -394,10 +394,8 @@ gp_Vec IntSurf_Quadric::Normale (const gp_Pnt& P) const
{ {
gp_Vec v(0,0,0); gp_Vec v(0,0,0);
return(v); return(v);
} break; } // break;
} }
// pop : pour NT
return gp_Vec(0,0,0);
} }
// ============================================================ // ============================================================
void IntSurf_Quadric::Parameters (const gp_Pnt& P, void IntSurf_Quadric::Parameters (const gp_Pnt& P,

2
src/IntTools/IntTools_EdgeFace.cxx
View File

@ -941,7 +941,7 @@ void IntTools_EdgeFace::CheckData()
} }
} }
*/ */
return 0; // return 0;
} }

1
src/MAT2d/MAT2d_Circuit.cxx
View File

@ -828,7 +828,6 @@ static Standard_Boolean IsSharpCorner (const Handle(Geom2d_Geometry)& Geom1,
else { else {
return Standard_True; return Standard_True;
} }
return Standard_False;
} }

5
src/MNaming/MNaming_NamingRetrievalDriver.cxx
View File

@ -49,10 +49,9 @@ static TopAbs_ShapeEnum IntegerToShapeEnum (const Standard_Integer I)
case 5 : return TopAbs_WIRE; case 5 : return TopAbs_WIRE;
case 6 : return TopAbs_EDGE; case 6 : return TopAbs_EDGE;
case 7 : return TopAbs_VERTEX; case 7 : return TopAbs_VERTEX;
default : default :
return TopAbs_SHAPE; return TopAbs_SHAPE;
} }
return TopAbs_SHAPE;
} }
//======================================================================= //=======================================================================

7
src/MNaming/MNaming_NamingRetrievalDriver_1.cxx
View File

@ -51,10 +51,9 @@ static TopAbs_ShapeEnum IntegerToShapeEnum (const Standard_Integer I)
case 5 : return TopAbs_WIRE; case 5 : return TopAbs_WIRE;
case 6 : return TopAbs_EDGE; case 6 : return TopAbs_EDGE;
case 7 : return TopAbs_VERTEX; case 7 : return TopAbs_VERTEX;
default : default :
return TopAbs_SHAPE; return TopAbs_SHAPE;
} }
return TopAbs_SHAPE;
} }
//======================================================================= //=======================================================================
@ -78,7 +77,7 @@ static TNaming_NameType IntegerToNameType (const Standard_Integer I)
case 9 : return TNaming_ORIENTATION; case 9 : return TNaming_ORIENTATION;
case 10 : return TNaming_WIREIN; case 10 : return TNaming_WIREIN;
default : default :
Standard_DomainError::Raise("TNaming_NameType; enum term unknown "); Standard_DomainError::Raise("TNaming_NameType; enum term unknown ");
} }
return TNaming_INTERSECTION; return TNaming_INTERSECTION;
} }

36
src/MeshVS/MeshVS_MeshOwner.cxx
View File

@ -136,8 +136,8 @@ void MeshVS_MeshOwner::SetDetectedEntities (const Handle(TColStd_HPackedMapOfInt
// Purpose : // Purpose :
//================================================================ //================================================================
void MeshVS_MeshOwner::HilightWithColor (const Handle(PrsMgr_PresentationManager3d)& thePM, void MeshVS_MeshOwner::HilightWithColor (const Handle(PrsMgr_PresentationManager3d)& thePM,
const Quantity_NameOfColor theColor, const Quantity_NameOfColor theColor,
const Standard_Integer /*theMode*/) const Standard_Integer /*theMode*/)
{ {
Handle( SelectMgr_SelectableObject ) aSelObj; Handle( SelectMgr_SelectableObject ) aSelObj;
if ( HasSelectable() ) if ( HasSelectable() )
@ -151,21 +151,17 @@ void MeshVS_MeshOwner::HilightWithColor (const Handle(PrsMgr_PresentationManager
if( !aNodes.IsNull() && aNodes->Map().Extent() == 1 ) if( !aNodes.IsNull() && aNodes->Map().Extent() == 1 )
{ {
TColStd_MapIteratorOfPackedMapOfInteger anIt( aNodes->Map() ); TColStd_MapIteratorOfPackedMapOfInteger anIt( aNodes->Map() );
for( ; anIt.More(); anIt.Next() ) if( myLastID != anIt.Key() )
{ {
if( myLastID != anIt.Key() ) myLastID = anIt.Key();
myLastID = anIt.Key();
break;
} }
} }
else if( !aElems.IsNull() && aElems->Map().Extent() == 1 ) else if( !aElems.IsNull() && aElems->Map().Extent() == 1 )
{ {
TColStd_MapIteratorOfPackedMapOfInteger anIt( aElems->Map() ); TColStd_MapIteratorOfPackedMapOfInteger anIt( aElems->Map() );
for( ; anIt.More(); anIt.Next() ) if( myLastID != anIt.Key() )
{ {
if( myLastID != anIt.Key() ) myLastID = anIt.Key();
myLastID = anIt.Key();
break;
} }
} }
@ -201,24 +197,20 @@ Standard_Boolean MeshVS_MeshOwner::IsForcedHilight () const
if( !aNodes.IsNull() && aNodes->Map().Extent() == 1 ) if( !aNodes.IsNull() && aNodes->Map().Extent() == 1 )
{ {
TColStd_MapIteratorOfPackedMapOfInteger anIt( aNodes->Map() ); TColStd_MapIteratorOfPackedMapOfInteger anIt( aNodes->Map() );
for( ; anIt.More(); anIt.Next() ) aKey = anIt.Key();
{ if( myLastID == aKey )
aKey = anIt.Key(); {
if( myLastID == aKey ) aHilight = Standard_False;
aHilight = Standard_False;
break;
} }
} }
Handle(TColStd_HPackedMapOfInteger) aElems = GetDetectedElements(); Handle(TColStd_HPackedMapOfInteger) aElems = GetDetectedElements();
if( !aElems.IsNull() && aElems->Map().Extent() == 1 ) if( !aElems.IsNull() && aElems->Map().Extent() == 1 )
{ {
TColStd_MapIteratorOfPackedMapOfInteger anIt( aElems->Map() ); TColStd_MapIteratorOfPackedMapOfInteger anIt( aElems->Map() );
for( ; anIt.More(); anIt.Next() ) aKey = anIt.Key();
if( myLastID == aKey )
{ {
aKey = anIt.Key(); aHilight = Standard_False;
if( myLastID == aKey )
aHilight = Standard_False;
break;
} }
} }
} }

1
src/OpenGl/OpenGl_GraphicDriver_7.cxx
View File

@ -345,7 +345,6 @@ Standard_Boolean OpenGl_GraphicDriver::BufferDump (const Graphic3d_CView& t
{ {
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView; const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
return (aCView != NULL) && aCView->WS->BufferDump ((OpenGl_FrameBuffer* )theCView.ptrFBO, theImage, theBufferType); return (aCView != NULL) && aCView->WS->BufferDump ((OpenGl_FrameBuffer* )theCView.ptrFBO, theImage, theBufferType);
return Standard_False;
} }
Standard_Boolean OpenGl_Workspace::BufferDump (OpenGl_FrameBuffer* theFBOPtr, Standard_Boolean OpenGl_Workspace::BufferDump (OpenGl_FrameBuffer* theFBOPtr,

3
src/ProjLib/ProjLib_ComputeApproxOnPolarSurface.cxx
View File

@ -1207,11 +1207,10 @@ Handle(Adaptor2d_HCurve2d)
// Modified by Sergey KHROMOV - Thu Apr 18 10:57:51 2002 End // Modified by Sergey KHROMOV - Thu Apr 18 10:57:51 2002 End
return Handle(Adaptor2d_HCurve2d)(); return Handle(Adaptor2d_HCurve2d)();
} }
myProjIsDone = Standard_False; // myProjIsDone = Standard_False;
// Modified by Sergey KHROMOV - Thu Apr 18 10:58:01 2002 Begin // Modified by Sergey KHROMOV - Thu Apr 18 10:58:01 2002 Begin
// Standard_NoSuchObject_Raise_if(1,"ProjLib_ComputeOnPS: build echec"); // Standard_NoSuchObject_Raise_if(1,"ProjLib_ComputeOnPS: build echec");
// Modified by Sergey KHROMOV - Thu Apr 18 10:58:02 2002 End // Modified by Sergey KHROMOV - Thu Apr 18 10:58:02 2002 End
return Handle(Adaptor2d_HCurve2d)();
} }

64
src/QABugs/QABugs_10.cxx
View File

@ -149,10 +149,10 @@ static Standard_Integer OCC426 (Draw_Interpretor& di, Standard_Integer argc, con
TopLoc_Location loc; TopLoc_Location loc;
Handle(Poly_Triangulation) facing = BRep_Tool::Triangulation(TopologicalFace, loc); Handle(Poly_Triangulation) facing = BRep_Tool::Triangulation(TopologicalFace, loc);
if (facing.IsNull()) if (facing.IsNull())
{ {
di << "Triangulation FAILED for this face" << "\n"; di << "Triangulation FAILED for this face" << "\n";
continue; continue;
} }
di << "No of Triangles = " << facing->NbTriangles() << "\n"; di << "No of Triangles = " << facing->NbTriangles() << "\n";
} }
di<<"Triangulation of all Faces Completed. "<< "\n" << "\n"; di<<"Triangulation of all Faces Completed. "<< "\n" << "\n";
@ -246,40 +246,36 @@ static Standard_Integer OCC486(Draw_Interpretor& di, Standard_Integer argc, cons
Standard_Integer nPSurf = ( myExtPS.IsDone() ? myExtPS.NbExt() : 0 ); Standard_Integer nPSurf = ( myExtPS.IsDone() ? myExtPS.NbExt() : 0 );
if ( nPSurf > 0 ) if ( nPSurf > 0 )
{ {
//Standard_Real distMin = myExtPS.Value ( 1 );
Standard_Real distMin = myExtPS.SquareDistance ( 1 );
Standard_Integer indMin=1;
for (Standard_Integer sol = 2; sol <= nPSurf ; sol++)
{
//Standard_Real dist = myExtPS.Value(sol);
Standard_Real dist = myExtPS.SquareDistance(sol);
if ( distMin > dist )
{
distMin = dist;
indMin = sol;
}
}
distMin = sqrt(distMin);
Standard_Real S, T;
myExtPS.Point(indMin).Parameter ( S, T );
gp_Pnt aCheckPnt = aSurf.Value( S, T );
Standard_Real aCheckDist = P3D.Distance(aCheckPnt);
di << "Solution is : U = "<< S << "\t V = "<< T << "\n";
di << "Solution is : X = "<< aCheckPnt.X() << "\t Y = "<< aCheckPnt.Y() << "\t Z = "<< aCheckPnt.Z() << "\n";
di << "ExtremaDistance = " << distMin << "\n";
di << "CheckDistance = " << aCheckDist << "\n";
//Standard_Real distMin = myExtPS.Value ( 1 ); if(fabs(distMin - aCheckDist) < Precision::Confusion()) return 0;
Standard_Real distMin = myExtPS.SquareDistance ( 1 ); else return 1;
Standard_Integer indMin=1; }
for (Standard_Integer sol = 2; sol <= nPSurf ; sol++)
{
//Standard_Real dist = myExtPS.Value(sol);
Standard_Real dist = myExtPS.SquareDistance(sol);
if ( distMin > dist )
{
distMin = dist;
indMin = sol;
}
}
//
distMin = sqrt(distMin);
Standard_Real S, T;
myExtPS.Point(indMin).Parameter ( S, T );
gp_Pnt aCheckPnt = aSurf.Value( S, T );
Standard_Real aCheckDist = P3D.Distance(aCheckPnt);
di << "Solution is : U = "<< S << "\t V = "<< T << "\n";
di << "Solution is : X = "<< aCheckPnt.X() << "\t Y = "<< aCheckPnt.Y() << "\t Z = "<< aCheckPnt.Z() << "\n";
di << "ExtremaDistance = " << distMin << "\n";
di << "CheckDistance = " << aCheckDist << "\n";
if(fabs(distMin - aCheckDist) < Precision::Confusion()) return 0;
else return 1;
}
else return 1; else return 1;
} }
catch (Standard_Failure) {di << "OCC486 Exception \n" ;return 1;} catch (Standard_Failure) {di << "OCC486 Exception \n" ;return 1;}
return 0;
} }
#include <GC_MakeArcOfCircle.hxx> #include <GC_MakeArcOfCircle.hxx>

76
src/QABugs/QABugs_4.cxx
View File

@ -53,12 +53,12 @@ static Standard_Integer BUC60738 (Draw_Interpretor& di, Standard_Integer /*argc*
//display mode = Shading //display mode = Shading
theAISShape->SetDisplayMode(1); theAISShape->SetDisplayMode(1);
//get the drawer //get the drawer
Handle_AIS_Drawer theDrawer = theAISShape->Attributes(); Handle_AIS_Drawer theDrawer = theAISShape->Attributes();
Handle_Prs3d_ShadingAspect theShadingAspect = theDrawer->ShadingAspect(); Handle_Prs3d_ShadingAspect theShadingAspect = theDrawer->ShadingAspect();
Handle_Graphic3d_AspectFillArea3d theAspectFillArea3d = theShadingAspect->Aspect(); Handle_Graphic3d_AspectFillArea3d theAspectFillArea3d = theShadingAspect->Aspect();
//allow to display the edges //allow to display the edges
theAspectFillArea3d->SetEdgeOn(); theAspectFillArea3d->SetEdgeOn();
//set the style to Dash //set the style to Dash
@ -76,80 +76,10 @@ static Standard_Integer BUC60738 (Draw_Interpretor& di, Standard_Integer /*argc*
return 0; return 0;
} }
static int BUC60606(Draw_Interpretor& di, Standard_Integer argc, const char ** argv) {
di << "Use satread command instead of " << argv[0] << "\n";
return -1;
if(argc!=3) {
di << "Usage : " << argv[0] << "name filename" << "\n";
return -1;
}
// Handle_AcisData_AcisModel satModel = new AcisData_AcisModel();
// Standard_Character *DD = Tcl_GetVar(di.Interp(),"Draw_DataDir",TCL_GLOBAL_ONLY);
// Standard_Character *filename = new Standard_Character [strlen(DD)+strlen(argv[2])+1];
// Sprintf(filename,"%s/%s",DD,argv[2]);
// satModel->ReadSaveFile(filename);
// Standard_Boolean success = !satModel.IsNull();
// cout << "n<-- SAT model read : " << (success?"true":"false") << endl << flush;
// if ( success ) {
// Standard_Character *Ch=new Standard_Character [strlen(argv[1])+3];
// Handle_TopTools_HSequenceOfShape satShapes = satModel->GetShapes();
// Standard_Integer nbs=satShapes->Length();
// for(Standard_Integer i=1;i<=nbs;i++) {
// TopoDS_Shape xShape = satShapes->Value(i);
// if(!xShape.IsNull()) {
// Sprintf(Ch,"%s_%i",argv[1],i);
// DBRep::Set(Ch,xShape);
// } else cout << "The shape " << argv[1] << "_" << i << " is NULL !" << endl;
// }
// }
return 0;
}
static int BUC60627(Draw_Interpretor& di, Standard_Integer argc, const char ** argv) {
di << "Use satread command instead of " << argv[0] << "\n";
return -1;
// perform the conversion
// as in AcisData.cdl --- that's alright
// if(argc!=3) {
// cerr << "Usage : " << argv[0] << " BREP file" << endl;
// return -1;
// }
// TopoDS_Shape shapeModel=DBRep::Get(argv[1]);
// Handle(AcisData_AcisModel) satModel = new AcisData_AcisModel();
// satModel->AddShape( shapeModel ); // memorizes "kegel2.brep"
// Standard_CString stringData;
// Standard_Integer nbChar; // write intermediate stringin order to compute ACIS data
// satModel->WriteStringData( stringData, nbChar );
// if ( satModel->IsDone() ) {
// satModel = new AcisData_AcisModel();
// satModel->ReadStringData( stringData );
// if ( satModel->IsDone() ) {
// // write into file
// satModel->WriteSaveFile( argv[2] );
// if ( ! satModel->IsDone() ) {
// cout << "The SAT madel does not wroute." << endl;
// }
// } else cout << "The SAT model does not read from a string." << endl;
// // satModel->ReadStringData( stringData );
// } else cout << "The SAT model does not wroute into a string." << endl;
// // satModel->WriteStringData( stringData, nbChar );
return 1;
}
void QABugs::Commands_4(Draw_Interpretor& theCommands) { void QABugs::Commands_4(Draw_Interpretor& theCommands) {
const char *group = "QABugs"; const char *group = "QABugs";
theCommands.Add("BUC60738","BUC60738",__FILE__,BUC60738,group); theCommands.Add("BUC60738","BUC60738",__FILE__,BUC60738,group);
theCommands.Add("BUC60606","BUC60606 name",__FILE__,BUC60606,group);
theCommands.Add("BUC60627","BUC60627 name",__FILE__,BUC60627,group);
return; return;
} }

24
src/QANewBRepNaming/QANewBRepNaming_BooleanOperationFeat.cxx
View File

@ -129,8 +129,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::ModifiedFaces() const {
const TDF_Label& ModifiedFacesLabel = ResultLabel().NewChild(); const TDF_Label& ModifiedFacesLabel = ResultLabel().NewChild();
TDataStd_Name::Set(ModifiedFacesLabel, "ModifiedFaces"); TDataStd_Name::Set(ModifiedFacesLabel, "ModifiedFaces");
return ModifiedFacesLabel; return ModifiedFacesLabel;
#endif #else
return ResultLabel().NewChild(); return ResultLabel().NewChild();
#endif
} }
//======================================================================= //=======================================================================
@ -143,8 +144,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::ModifiedEdges() const {
const TDF_Label& ModifiedEdgesLabel = ResultLabel().NewChild(); const TDF_Label& ModifiedEdgesLabel = ResultLabel().NewChild();
TDataStd_Name::Set(ModifiedEdgesLabel, "ModifiedEdges"); TDataStd_Name::Set(ModifiedEdgesLabel, "ModifiedEdges");
return ModifiedEdgesLabel; return ModifiedEdgesLabel;
#endif #else
return ResultLabel().NewChild(); return ResultLabel().NewChild();
#endif
} }
//======================================================================= //=======================================================================
@ -157,8 +159,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::DeletedFaces() const {
const TDF_Label& DeletedFacesLabel = ResultLabel().NewChild(); const TDF_Label& DeletedFacesLabel = ResultLabel().NewChild();
TDataStd_Name::Set(DeletedFacesLabel, "DeletedFaces"); TDataStd_Name::Set(DeletedFacesLabel, "DeletedFaces");
return DeletedFacesLabel; return DeletedFacesLabel;
#endif #else
return ResultLabel().NewChild(); return ResultLabel().NewChild();
#endif
} }
//======================================================================= //=======================================================================
@ -171,8 +174,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::DeletedEdges() const {
const TDF_Label& DeletedEdgesLabel = ResultLabel().NewChild(); const TDF_Label& DeletedEdgesLabel = ResultLabel().NewChild();
TDataStd_Name::Set(DeletedEdgesLabel, "DeletedEdges"); TDataStd_Name::Set(DeletedEdgesLabel, "DeletedEdges");
return DeletedEdgesLabel; return DeletedEdgesLabel;
#endif #else
return ResultLabel().NewChild(); return ResultLabel().NewChild();
#endif
} }
//======================================================================= //=======================================================================
@ -185,8 +189,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::DeletedVertices() const {
const TDF_Label& DeletedVerticesLabel = ResultLabel().NewChild(); const TDF_Label& DeletedVerticesLabel = ResultLabel().NewChild();
TDataStd_Name::Set(DeletedVerticesLabel, "DeletedVertices"); TDataStd_Name::Set(DeletedVerticesLabel, "DeletedVertices");
return DeletedVerticesLabel; return DeletedVerticesLabel;
#endif #else
return ResultLabel().NewChild(); return ResultLabel().NewChild();
#endif
} }
//======================================================================= //=======================================================================
@ -199,8 +204,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::NewShapes() const {
const TDF_Label& NewShapesLabel = ResultLabel().NewChild(); const TDF_Label& NewShapesLabel = ResultLabel().NewChild();
TDataStd_Name::Set(NewShapesLabel, "NewShapes"); TDataStd_Name::Set(NewShapesLabel, "NewShapes");
return NewShapesLabel; return NewShapesLabel;
#endif #else
return ResultLabel().NewChild(); return ResultLabel().NewChild();
#endif
} }
//======================================================================= //=======================================================================
@ -213,8 +219,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::Content() const {
const TDF_Label& ContentLabel = ResultLabel().NewChild(); const TDF_Label& ContentLabel = ResultLabel().NewChild();
TDataStd_Name::Set(ContentLabel, "Content"); TDataStd_Name::Set(ContentLabel, "Content");
return ContentLabel; return ContentLabel;
#endif #else
return ResultLabel().NewChild(); return ResultLabel().NewChild();
#endif
} }
//======================================================================= //=======================================================================
@ -227,8 +234,9 @@ TDF_Label QANewBRepNaming_BooleanOperationFeat::DeletedDegeneratedEdges() const
const TDF_Label& DegeneratedLabel = ResultLabel().NewChild(); const TDF_Label& DegeneratedLabel = ResultLabel().NewChild();
TDataStd_Name::Set(DegeneratedLabel, "DeletedDegeneratedEdges"); TDataStd_Name::Set(DegeneratedLabel, "DeletedDegeneratedEdges");
return DegeneratedLabel; return DegeneratedLabel;
#endif #else
return ResultLabel().NewChild(); return ResultLabel().NewChild();
#endif
} }
//======================================================================= //=======================================================================

3
src/QANewBRepNaming/QANewBRepNaming_Gluing.cxx
View File

@ -497,8 +497,9 @@ TDF_Label QANewBRepNaming_Gluing::Content() const {
const TDF_Label& ContentLabel = ResultLabel().NewChild(); const TDF_Label& ContentLabel = ResultLabel().NewChild();
TDataStd_Name::Set(ContentLabel, "Content"); TDataStd_Name::Set(ContentLabel, "Content");
return ContentLabel; return ContentLabel;
#endif #else
return ResultLabel().NewChild(); return ResultLabel().NewChild();
#endif
} }
//======================================================================= //=======================================================================

50
src/QANewModTopOpe/QANewModTopOpe_Glue_wire.cxx
View File

@ -928,8 +928,8 @@ static Standard_Boolean IsOverlapped(const TopoDS_Edge &theEdge1,
//======================================================================= //=======================================================================
static void SplitEdge(const TopoDS_Edge &theEdge, static void SplitEdge(const TopoDS_Edge &theEdge,
const TopTools_IndexedMapOfShape &theVertices, const TopTools_IndexedMapOfShape &theVertices,
TopTools_ListOfShape &theSplits) TopTools_ListOfShape &theSplits)
{ {
//const TopoDS_Edge aNewEdge; //const TopoDS_Edge aNewEdge;
TopoDS_Vertex aV1; TopoDS_Vertex aV1;
@ -945,7 +945,8 @@ static void SplitEdge(const TopoDS_Edge &theEdge,
Standard_Integer i; Standard_Integer i;
for (i = 1; i <= theVertices.Extent(); i++) { for (i = 1; i <= theVertices.Extent(); i++)
{
const TopoDS_Shape &theVtx = theVertices.FindKey(i); const TopoDS_Shape &theVtx = theVertices.FindKey(i);
if (!aV1.IsSame(theVtx) && !aV2.IsSame(theVtx)) if (!aV1.IsSame(theVtx) && !aV2.IsSame(theVtx))
@ -956,7 +957,7 @@ static void SplitEdge(const TopoDS_Edge &theEdge,
theSplits.Clear(); theSplits.Clear();
// Splitting of the new edge. // Splitting of the new edge.
if (!TopOpeBRepTool_TOOL::SplitE(aNewEdge, theSplits)) { if (!TopOpeBRepTool_TOOL::SplitE(aNewEdge, theSplits)) {
theSplits.Clear(); theSplits.Clear();
theSplits.Append(theEdge); theSplits.Append(theEdge);
@ -964,32 +965,33 @@ static void SplitEdge(const TopoDS_Edge &theEdge,
return; return;
} }
// Addition of the other internal vertices into the corresponding splits. // Addition of the other internal vertices into the corresponding splits.
TopoDS_Iterator anIter(theEdge, Standard_False); TopoDS_Iterator anIter(theEdge, Standard_False);
for (; anIter.More(); anIter.Next()) { for (; anIter.More(); anIter.Next())
{
TopoDS_Vertex aCurVtx = TopoDS::Vertex(anIter.Value()); TopoDS_Vertex aCurVtx = TopoDS::Vertex(anIter.Value());
// for each vertex which is not the same as aV1, aV2, theIntV1 or theIntV2. // for each vertex which is not the same as aV1, aV2, theIntV1 or theIntV2.
if (!aCurVtx.IsSame(aV1) && !aCurVtx.IsSame(aV2) && if (!aCurVtx.IsSame(aV1) && !aCurVtx.IsSame(aV2) && !theVertices.Contains(aCurVtx))
!theVertices.Contains(aCurVtx)) { {
TopTools_ListIteratorOfListOfShape anEdgeIter(theSplits); TopTools_ListIteratorOfListOfShape anEdgeIter(theSplits);
Standard_Real aCurPar; Standard_Real aCurPar = BRep_Tool::Parameter(aCurVtx, theEdge);
aCurPar = BRep_Tool::Parameter(aCurVtx, theEdge); // Search for the split the current vertex belongs to.
for (; anEdgeIter.More(); anEdgeIter.Next())
{
TopoDS_Edge anEdge = TopoDS::Edge(anEdgeIter.Value());
Standard_Real aFPar;
Standard_Real aLPar;
// Search for the split the current vertex belongs to. BRep_Tool::Range(anEdge, aFPar, aLPar);
for (; anEdgeIter.More(); anEdgeIter.Next()) {
TopoDS_Edge anEdge = TopoDS::Edge(anEdgeIter.Value());
Standard_Real aFPar;
Standard_Real aLPar;
BRep_Tool::Range(anEdge, aFPar, aLPar); if (aCurPar > aFPar && aCurPar < aLPar)
{
if (aCurPar > aFPar && aCurPar < aLPar) { aBuilder.Add(anEdge, aCurVtx);
aBuilder.Add(anEdge, aCurVtx); }
} break;
break;
} }
} }
} }
@ -998,9 +1000,9 @@ static void SplitEdge(const TopoDS_Edge &theEdge,
TopTools_ListIteratorOfListOfShape anEdgeIter(theSplits); TopTools_ListIteratorOfListOfShape anEdgeIter(theSplits);
TopAbs_Orientation anOri = theEdge.Orientation(); TopAbs_Orientation anOri = theEdge.Orientation();
for (; anEdgeIter.More(); anEdgeIter.Next()) { for (; anEdgeIter.More(); anEdgeIter.Next())
{
TopoDS_Shape &anEdge = anEdgeIter.Value(); TopoDS_Shape &anEdge = anEdgeIter.Value();
anEdge.Orientation(anOri); anEdge.Orientation(anOri);
} }
} }

1
src/ShapeAnalysis/ShapeAnalysis.cxx
View File

@ -249,7 +249,6 @@ Standard_Boolean ShapeAnalysis::IsOuterBound(const TopoDS_Face& face)
Standard_Boolean rescl = (fcl.PerformInfinitePoint () == TopAbs_OUT); Standard_Boolean rescl = (fcl.PerformInfinitePoint () == TopAbs_OUT);
return rescl; return rescl;
} }
return Standard_True;
} }
//======================================================================= //=======================================================================

1
src/ShapeBuild/ShapeBuild_Edge.cxx
View File

@ -566,7 +566,6 @@ Handle(Geom2d_Curve) ShapeBuild_Edge::TransformPCurve(const Handle(Geom2d_Curve)
} }
return aBSpline2d; return aBSpline2d;
} }
return result;
} }
//======================================================================= //=======================================================================

1
src/ShapeConstruct/ShapeConstruct_ProjectCurveOnSurface.cxx
View File

@ -1563,7 +1563,6 @@ Handle(Geom_Curve) ShapeConstruct_ProjectCurveOnSurface::InterpolateCurve3d(cons
#endif #endif
return Standard_False; return Standard_False;
} }
return Standard_False; // ramasse-miette
} }
/* S4135 : BestExtremum is commented after IsAnIsoparametric works with Precision::Confusion() /* S4135 : BestExtremum is commented after IsAnIsoparametric works with Precision::Confusion()

1
src/ShapeCustom/ShapeCustom_BSplineRestriction.cxx
View File

@ -760,7 +760,6 @@ Standard_Boolean ShapeCustom_BSplineRestriction::ConvertSurface(const Handle(Geo
//else //else
//Surface is not BSpline or Bezier //Surface is not BSpline or Bezier
// return Standard_False; // return Standard_False;
return Standard_True;
} }
//======================================================================= //=======================================================================

1
src/ShapeFix/ShapeFix_EdgeProjAux.cxx
View File

@ -217,7 +217,6 @@ static Standard_Boolean FindParameterWithExt (const gp_Pnt& Pt1,
#endif #endif
return Standard_False; return Standard_False;
} }
return Standard_False; // normalement, on n y passe jamais
} }
//======================================================================= //=======================================================================

1
src/ShapeFix/ShapeFix_Wireframe.cxx
View File

@ -396,7 +396,6 @@ ShapeFix_Wireframe::ShapeFix_Wireframe(const TopoDS_Shape& shape)
#endif #endif
return ReplaceFirst; return ReplaceFirst;
} }
return ReplaceFirst;
} }
//======================================================================= //=======================================================================

3
src/TNaming/TNaming.cxx
View File

@ -990,7 +990,8 @@ static Standard_Boolean IsInternal(const TopoDS_Shape& aSx)
TopoDS_Iterator aIt; TopoDS_Iterator aIt;
bInternal = Standard_False; bInternal = Standard_False;
aIt.Initialize(aSx); aIt.Initialize(aSx);
for (; aIt.More(); aIt.Next()) { for (; aIt.More(); aIt.Next())
{
const TopoDS_Shape& aSy=aIt.Value(); const TopoDS_Shape& aSy=aIt.Value();
aOr=aSy.Orientation(); aOr=aSy.Orientation();
bInternal = (aOr == TopAbs_INTERNAL || aOr == TopAbs_EXTERNAL); bInternal = (aOr == TopAbs_INTERNAL || aOr == TopAbs_EXTERNAL);

24
src/TNaming/TNaming_Localizer.cxx
View File

@ -330,26 +330,26 @@ void TNaming_Localizer::GoBack (const TopoDS_Shape& S,
FindFeaturesInAncestors (S, Sol, AncInFeature); FindFeaturesInAncestors (S, Sol, AncInFeature);
TopTools_MapIteratorOfMapOfShape itF(AncInFeature); TopTools_MapIteratorOfMapOfShape itF(AncInFeature);
for ( ; itF.More(); itF.Next()) { for ( ; itF.More(); itF.Next()) {
const TopoDS_Shape& AncOfS = itF.Key(); const TopoDS_Shape& AncOfS = itF.Key();
LBS .Append(AncOfS); LBS .Append(AncOfS);
LBNS.Append(TNaming_Tool::NamedShape(AncOfS,Lab)); LBNS.Append(TNaming_Tool::NamedShape(AncOfS,Lab));
} }
} }
} }
else { else {
for ( ; it.More(); it.Next()) { for ( ; it.More(); it.Next()) {
// if (it.NamedShape()->Evolution() != TNaming_SELECTED) { // if (it.NamedShape()->Evolution() != TNaming_SELECTED) {
if (it.NamedShape()->Evolution() == Evol) { if (it.NamedShape()->Evolution() == Evol) {
Handle(TNaming_NamedShape) NS = TNaming_Tool::NamedShape(it.Shape(),Lab); Handle(TNaming_NamedShape) NS = TNaming_Tool::NamedShape(it.Shape(),Lab);
if (!NS.IsNull()) { if (!NS.IsNull()) {
LBS.Append (it.Shape()); LBS.Append (it.Shape());
LBNS.Append (TNaming_Tool::NamedShape(it.Shape(),Lab)); LBNS.Append (TNaming_Tool::NamedShape(it.Shape(),Lab));
} }
else { else {
#ifdef DEB #ifdef DEB
cout <<"TNaming_Localizer: Shape modifie sans avoir ete cree"<<endl; cout <<"TNaming_Localizer: Shape modifie sans avoir ete cree"<<endl;
#endif #endif
} }
} }
} }
} }

12
src/TNaming/TNaming_Name.cxx
View File

@ -1185,13 +1185,13 @@ static TopoDS_Shape FindShape(const TNaming_DataMapOfShapeMapOfShape& DM)
Standard_Boolean isCand(Standard_True); // aS is a Candidate Standard_Boolean isCand(Standard_True); // aS is a Candidate
TNaming_DataMapIteratorOfDataMapOfShapeMapOfShape it2(DM); TNaming_DataMapIteratorOfDataMapOfShapeMapOfShape it2(DM);
for (;it2.More();it2.Next()) { for (;it2.More();it2.Next()) {
const TopoDS_Shape& aKey2 = it2.Key(); const TopoDS_Shape& aKey2 = it2.Key();
if(aKey2 == aKey1) continue; if(aKey2 == aKey1) continue;
const TNaming_MapOfShape& aMap2 = it2.Value(); const TNaming_MapOfShape& aMap2 = it2.Value();
if(!aMap2.Contains(aS)) isCand = Standard_False; if(!aMap2.Contains(aS)) isCand = Standard_False;
} }
if(isCand) if(isCand)
List.Append(aS); List.Append(aS);
} }
break; break;
} }

5
src/TopOpeBRep/TopOpeBRep_FFDumper.cxx
View File

@ -258,6 +258,8 @@ void TopOpeBRep_FFDumper::DumpVP(const TopOpeBRep_VPointInter& VP,const Standard
#ifndef DEB #ifndef DEB
Standard_Integer TopOpeBRep_FFDumper::ExploreIndex(const TopoDS_Shape& , const Standard_Integer ) const Standard_Integer TopOpeBRep_FFDumper::ExploreIndex(const TopoDS_Shape& , const Standard_Integer ) const
{ {
return 0;
}
#else #else
Standard_Integer TopOpeBRep_FFDumper::ExploreIndex(const TopoDS_Shape& S, const Standard_Integer ISI) const Standard_Integer TopOpeBRep_FFDumper::ExploreIndex(const TopoDS_Shape& S, const Standard_Integer ISI) const
{ {
@ -265,9 +267,8 @@ Standard_Integer TopOpeBRep_FFDumper::ExploreIndex(const TopoDS_Shape& S, const
if (ISI == 1) r = myEM1.Find(S); if (ISI == 1) r = myEM1.Find(S);
if (ISI == 2) r = myEM2.Find(S); if (ISI == 2) r = myEM2.Find(S);
return r; return r;
#endif
return 0;
} }
#endif
//======================================================================= //=======================================================================
//function : DumpDSP //function : DumpDSP

1
src/TopOpeBRep/TopOpeBRep_sort.cxx
View File

@ -39,7 +39,6 @@ int compll(const void* v1, const void* v2) {
if (p1 < p2) return (-1); if (p1 < p2) return (-1);
else if (p1 > p2) return (1); else if (p1 > p2) return (1);
else return (0); else return (0);
return (0);
} }
Standard_EXPORT void BREP_sortonparameter2(TopOpeBRepDS_ListOfInterference& LOI) Standard_EXPORT void BREP_sortonparameter2(TopOpeBRepDS_ListOfInterference& LOI)

1
src/TopOpeBRep/TopOpeBRep_traceBOOPNINT.cxx
View File

@ -62,7 +62,6 @@ Standard_Integer BOOPNINTL::Set(const Standard_Boolean b,Standard_Integer n,char
else { else {
return 1; return 1;
} }
return 0;
} }
Standard_Boolean BOOPNINTL::Get(Standard_Integer n,char**a){ Standard_Boolean BOOPNINTL::Get(Standard_Integer n,char**a){

73
src/TopOpeBRepBuild/TopOpeBRepBuild_Builder1.cxx
View File

@ -1732,59 +1732,58 @@ Standard_Integer TopOpeBRepBuild_Builder1::TwoPiecesON (const TopTools_SequenceO
// case IV !RevSense && DifOriented // case IV !RevSense && DifOriented
if (!IsEdgesRevSense && IsFacesDifOriented) { if (!IsEdgesRevSense && IsFacesDifOriented) {
if (Opefus()) {// Fusion if (Opefus()) {// Fusion
if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_OUT) { if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_OUT) {
Rejected1=Standard_False; Rejected1=Standard_False;
Rejected2=Standard_False; Rejected2=Standard_False;
} }
else if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_IN) { else if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_IN) {
Rejected2=Standard_False; Rejected2=Standard_False;
} }
else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_OUT) { else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_OUT) {
Rejected1=Standard_False; Rejected1=Standard_False;
} }
else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_IN) { else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_IN) {
if(!myProcessedPartsON2d.Contains(aPieceObj)) {//we proceed IsSame only if we didn't it before if(!myProcessedPartsON2d.Contains(aPieceObj)) {//we proceed IsSame only if we didn't it before
myProcessedPartsON2d.Add(aPieceObj); myProcessedPartsON2d.Add(aPieceObj);
IsSame2d (aSeq, aListOfPiecesOut2d); //Perform IsSame 2d and keep periodic parts IsSame2d (aSeq, aListOfPiecesOut2d); //Perform IsSame 2d and keep periodic parts
} }
} }
} }
if (Opecom()) {// Common if (Opecom()) {// Common
if (aStateObj==TopAbs_IN && aStateTool==TopAbs_IN) { if (aStateObj==TopAbs_IN && aStateTool==TopAbs_IN) {
Rejected1=Standard_False; Rejected1=Standard_False;
Rejected2=Standard_False; Rejected2=Standard_False;
} }
else if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_IN) { else if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_IN) {
Rejected1=Standard_False; Rejected1=Standard_False;
} }
else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_OUT) { else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_OUT) {
Rejected2=Standard_False; Rejected2=Standard_False;
} }
} }
if (Opec12()) { //Cut if (Opec12()) { //Cut
if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_OUT) { if (aStateObj==TopAbs_OUT && aStateTool==TopAbs_OUT) {
Rejected1=Standard_False; Rejected1=Standard_False;
} }
else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_IN) { else if (aStateObj==TopAbs_IN && aStateTool==TopAbs_IN) {
Rejected2=Standard_False; Rejected2=Standard_False;
} }
} }
if (!Rejected1) { if (!Rejected1) {
aListOfPieces.Append(aPieceObj); aListOfPieces.Append(aPieceObj);
aListOfFaces.Append (aFaceObj); aListOfFaces.Append (aFaceObj);
} }
if (!Rejected2) { if (!Rejected2) {
aListOfPieces.Append(aPieceTool); aListOfPieces.Append(aPieceTool);
aListOfFaces.Append (aFaceTool); aListOfFaces.Append (aFaceTool);
} }
return 4; return 4;
} }
// Unknowm case for existing adjacents // Unknowm case for existing adjacents
return 0; return 0;
} }
return -1;
} }
//======================================================================= //=======================================================================

6
src/TopOpeBRepBuild/TopOpeBRepBuild_GTopo.cxx
View File

@ -367,8 +367,8 @@ Standard_Boolean TopOpeBRepBuild_GTopo::IsToReverse1() const
else IsToRev = (s1 == TopAbs_IN); else IsToRev = (s1 == TopAbs_IN);
return IsToRev; return IsToRev;
} }
Standard_ProgramError::Raise("GTopo::IsToReverse1"); // Standard_ProgramError::Raise("GTopo::IsToReverse1");
return Standard_False; // dummy // return Standard_False; // dummy
} }
@ -390,8 +390,6 @@ Standard_Boolean TopOpeBRepBuild_GTopo::IsToReverse2() const
else IsToRev = (s2 == TopAbs_IN); else IsToRev = (s2 == TopAbs_IN);
return IsToRev; return IsToRev;
} }
Standard_ProgramError::Raise("GTopo::IsToReverse2");
return Standard_False; // dummy
} }
//======================================================================= //=======================================================================

249
src/TopOpeBRepBuild/TopOpeBRepBuild_Tools_1.cxx
View File

@ -140,8 +140,8 @@ static
// purpose : Correct tolerances for Edge // purpose : Correct tolerances for Edge
//======================================================================= //=======================================================================
void CorrectEdgeTolerance (const TopoDS_Edge& myShape, void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
const TopoDS_Face& S, const TopoDS_Face& S,
const Standard_Real aMaxTol) const Standard_Real aMaxTol)
{ {
// //
// 1. Minimum of conditions to Perform // 1. Minimum of conditions to Perform
@ -169,7 +169,7 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
if (cr->IsCurve3D()) { if (cr->IsCurve3D()) {
unique++; unique++;
if (myCref.IsNull() && !cr->Curve3D().IsNull()) { if (myCref.IsNull() && !cr->Curve3D().IsNull()) {
myCref = cr; myCref = cr;
} }
} }
itcr.Next(); itcr.Next();
@ -187,8 +187,8 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
while (itcr.More()) { while (itcr.More()) {
const Handle(BRep_CurveRepresentation)& cr = itcr.Value(); const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
if (cr->IsCurveOnSurface()) { if (cr->IsCurveOnSurface()) {
myCref = cr; myCref = cr;
break; break;
} }
itcr.Next(); itcr.Next();
} }
@ -209,19 +209,19 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
else { else {
if (myCref->IsCurve3D()) { if (myCref->IsCurve3D()) {
Handle(Geom_Curve) C3d = Handle(Geom_Curve)::DownCast Handle(Geom_Curve) C3d = Handle(Geom_Curve)::DownCast
(myCref->Curve3D()->Transformed (myCref->Location().Transformation())); (myCref->Curve3D()->Transformed (myCref->Location().Transformation()));
GeomAdaptor_Curve GAC3d(C3d,First,Last); GeomAdaptor_Curve GAC3d(C3d,First,Last);
myHCurve = new GeomAdaptor_HCurve(GAC3d); myHCurve = new GeomAdaptor_HCurve(GAC3d);
} }
else { // curve on surface else { // curve on surface
Handle(Geom_Surface) Sref = myCref->Surface(); Handle(Geom_Surface) Sref = myCref->Surface();
Sref = Handle(Geom_Surface)::DownCast(Sref->Transformed(myCref->Location().Transformation())); Sref = Handle(Geom_Surface)::DownCast(Sref->Transformed(myCref->Location().Transformation()));
const Handle(Geom2d_Curve)& PCref = myCref->PCurve(); const Handle(Geom2d_Curve)& PCref = myCref->PCurve();
Handle(GeomAdaptor_HSurface) GAHSref = new GeomAdaptor_HSurface(Sref); Handle(GeomAdaptor_HSurface) GAHSref = new GeomAdaptor_HSurface(Sref);
Handle(Geom2dAdaptor_HCurve) GHPCref = new Geom2dAdaptor_HCurve(PCref, First, Last); Handle(Geom2dAdaptor_HCurve) GHPCref = new Geom2dAdaptor_HCurve(PCref, First, Last);
Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref); Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref);
myHCurve = new Adaptor3d_HCurveOnSurface(ACSref); myHCurve = new Adaptor3d_HCurveOnSurface(ACSref);
} }
} }
} }
@ -244,62 +244,43 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
const TopLoc_Location& TFloc = TF->Location(); const TopLoc_Location& TFloc = TF->Location();
const Handle(Geom_Surface)& Su = TF->Surface(); const Handle(Geom_Surface)& Su = TF->Surface();
TopLoc_Location L = (Floc * TFloc).Predivided(myShape.Location()); TopLoc_Location L = (Floc * TFloc).Predivided(myShape.Location());
// Standard_Boolean checkclosed = Standard_False;
Standard_Boolean pcurvefound = Standard_False; Standard_Boolean pcurvefound = Standard_False;
itcr.Initialize(TE->Curves()); itcr.Initialize(TE->Curves());
while (itcr.More()) { while (itcr.More()) {
const Handle(BRep_CurveRepresentation)& cr = itcr.Value(); const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
if (cr != myCref && cr->IsCurveOnSurface(Su,L)) { if (cr != myCref && cr->IsCurveOnSurface(Su,L)) {
pcurvefound = Standard_True; pcurvefound = Standard_True;
const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr); const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr);
Standard_Real f,l; Standard_Real f,l;
GC->Range(f,l); GC->Range(f,l);
if (SameRange && (f != First || l != Last)) { if (SameRange && (f != First || l != Last)) {
return ;//BRepCheck_InvalidSameRangeFlag); return ;//BRepCheck_InvalidSameRangeFlag;
if (SameParameter) { }
return; //BRepCheck_InvalidSameParameterFlag);
} Handle(Geom_Surface) Sb = cr->Surface();
Sb = Handle(Geom_Surface)::DownCast (Su->Transformed(L.Transformation()));
Handle(Geom2d_Curve) PC = cr->PCurve();
Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(Sb);
Handle(Geom2dAdaptor_HCurve) GHPC = new Geom2dAdaptor_HCurve(PC,f,l);
Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
ok = Validate(myHCurve->Curve(), ACS, Tol, SameParameter, aNewTol);
if (ok) {
// printf("(Edge,1) Tolerance=%15.10lg\n", aNewTol);
if (aNewTol<aMaxTol)
TE->UpdateTolerance(aNewTol);
}
if (cr->IsCurveOnClosedSurface()) {
// checkclosed = Standard_True;
GHPC->ChangeCurve2d().Load(cr->PCurve2(),f,l); // same bounds
ACS.Load(GAHS); // sans doute inutile
ACS.Load(GHPC); // meme remarque...
ok = Validate(myHCurve->Curve(),ACS,Tol,SameParameter, aNewTol);
if (ok) {
if (aNewTol<aMaxTol)
TE->UpdateTolerance(aNewTol);
}
} }
Handle(Geom_Surface) Sb = cr->Surface();
Sb = Handle(Geom_Surface)::DownCast (Su->Transformed(L.Transformation()));
Handle(Geom2d_Curve) PC = cr->PCurve();
Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(Sb);
Handle(Geom2dAdaptor_HCurve) GHPC = new Geom2dAdaptor_HCurve(PC,f,l);
Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
ok = Validate(myHCurve->Curve(), ACS, Tol, SameParameter, aNewTol);
if (ok) {
if (cr->IsCurveOnClosedSurface()) {
//return ;// BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
}
else {
//return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
}
if (SameParameter) {
//return;//BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
}
// printf("(Edge,1) Tolerance=%15.10lg\n", aNewTol);
if (aNewTol<aMaxTol)
TE->UpdateTolerance(aNewTol);
}
if (cr->IsCurveOnClosedSurface()) {
// checkclosed = Standard_True;
GHPC->ChangeCurve2d().Load(cr->PCurve2(),f,l); // same bounds
ACS.Load(GAHS); // sans doute inutile
ACS.Load(GHPC); // meme remarque...
ok = Validate(myHCurve->Curve(),ACS,Tol,SameParameter, aNewTol);
if (ok) {
//return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
if (SameParameter) {
//return;//BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
}
// printf("(Edge,2) Tolerance=%15.10lg\n", aNewTol);
if (aNewTol<aMaxTol)
TE->UpdateTolerance(aNewTol);
}
}
} }
itcr.Next(); itcr.Next();
} }
@ -308,46 +289,44 @@ void CorrectEdgeTolerance (const TopoDS_Edge& myShape,
Handle(Geom_Plane) P; Handle(Geom_Plane) P;
Handle(Standard_Type) styp = Su->DynamicType(); Handle(Standard_Type) styp = Su->DynamicType();
if (styp == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) { if (styp == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
P = Handle(Geom_Plane)::DownCast(Handle(Geom_RectangularTrimmedSurface):: P = Handle(Geom_Plane)::DownCast(Handle(Geom_RectangularTrimmedSurface)::
DownCast(Su)->BasisSurface()); DownCast(Su)->BasisSurface());
} }
else { else {
P = Handle(Geom_Plane)::DownCast(Su); P = Handle(Geom_Plane)::DownCast(Su);
} }
if (P.IsNull()) { // not a plane if (P.IsNull()) { // not a plane
return;//BRepCheck::Add(lst,BRepCheck_NoCurveOnSurface); return;//BRepCheck::Add(lst,BRepCheck_NoCurveOnSurface);
} }
else
else {// on fait la projection a la volee, comme BRep_Tool { // on fait la projection a la volee, comme BRep_Tool
P = Handle(Geom_Plane)::DownCast(P->Transformed(L.Transformation())); P = Handle(Geom_Plane)::DownCast(P->Transformed(L.Transformation()));
//on projette Cref sur ce plan //on projette Cref sur ce plan
Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(P); Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(P);
// Dub - Normalement myHCurve est une GeomAdaptor_HCurve // Dub - Normalement myHCurve est une GeomAdaptor_HCurve
GeomAdaptor_Curve& Gac = Handle(GeomAdaptor_HCurve)::DownCast(myHCurve)->ChangeCurve(); GeomAdaptor_Curve& Gac = Handle(GeomAdaptor_HCurve)::DownCast(myHCurve)->ChangeCurve();
Handle(Geom_Curve) C3d = Gac.Curve(); Handle(Geom_Curve) C3d = Gac.Curve();
Handle(Geom_Curve) ProjOnPlane = GeomProjLib::ProjectOnPlane Handle(Geom_Curve) ProjOnPlane = GeomProjLib::ProjectOnPlane
(new Geom_TrimmedCurve(C3d,First,Last), P, P->Position().Direction(), Standard_True); (new Geom_TrimmedCurve(C3d,First,Last), P, P->Position().Direction(), Standard_True);
Handle(GeomAdaptor_HCurve) aHCurve = new GeomAdaptor_HCurve(ProjOnPlane); Handle(GeomAdaptor_HCurve) aHCurve = new GeomAdaptor_HCurve(ProjOnPlane);
ProjLib_ProjectedCurve proj(GAHS,aHCurve); ProjLib_ProjectedCurve proj(GAHS,aHCurve);
Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj); Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj);
Handle(Geom2dAdaptor_HCurve) GHPC = Handle(Geom2dAdaptor_HCurve) GHPC =
new Geom2dAdaptor_HCurve(PC, myHCurve->FirstParameter(), myHCurve->LastParameter()); new Geom2dAdaptor_HCurve(PC, myHCurve->FirstParameter(), myHCurve->LastParameter());
Adaptor3d_CurveOnSurface ACS(GHPC,GAHS); Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
ok = Validate(myHCurve->Curve(),ACS, ok = Validate(myHCurve->Curve(),ACS,
Tol,Standard_True, aNewTol); // voir dub... Tol,Standard_True, aNewTol); // voir dub...
if (ok) { if (ok)
//return;//BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface); {
// printf("(Edge,3) Tolerance=%15.10lg\n", aNewTol); if (aNewTol<aMaxTol)
if (aNewTol<aMaxTol) TE->UpdateTolerance(aNewTol);
TE->UpdateTolerance(aNewTol); }
}
} }
}//end of if (!pcurvefound) { }//end of if (!pcurvefound) {
} // end of 2. Tolerances in InContext } // end of 2. Tolerances in InContext
@ -499,45 +478,43 @@ void CheckEdge (const TopoDS_Edge& Ed, const Standard_Real aMaxTol)
TopLoc_Location L = (Eloc * loc).Predivided(aVertex.Location()); TopLoc_Location L = (Eloc * loc).Predivided(aVertex.Location());
if (cr->IsCurve3D()) { if (cr->IsCurve3D()) {
const Handle(Geom_Curve)& C = cr->Curve3D(); const Handle(Geom_Curve)& C = cr->Curve3D();
if (!C.IsNull()) { if (!C.IsNull()) {
itpr.Initialize(TV->Points()); itpr.Initialize(TV->Points());
while (itpr.More()) { while (itpr.More()) {
const Handle(BRep_PointRepresentation)& pr = itpr.Value(); const Handle(BRep_PointRepresentation)& pr = itpr.Value();
if (pr->IsPointOnCurve(C,L)) { if (pr->IsPointOnCurve(C,L)) {
Controlp = C->Value(pr->Parameter()); Controlp = C->Value(pr->Parameter());
Controlp.Transform(L.Transformation()); Controlp.Transform(L.Transformation());
aD2=prep.SquareDistance(Controlp); aD2=prep.SquareDistance(Controlp);
if (aD2 > Tol) { if (aD2 > Tol) {
aNewTolerance=sqrt(aD2)+dd; aNewTolerance=sqrt(aD2)+dd;
// printf("(Vert,1) Tolerance=%15.10lg\n", aNewTolerance); if (aNewTolerance<aMaxTol)
if (aNewTolerance<aMaxTol) TV->UpdateTolerance(aNewTolerance);
TV->UpdateTolerance(aNewTolerance); }
} }
} itpr.Next();
itpr.Next(); }
}
TopAbs_Orientation orv = aVertex.Orientation();
TopAbs_Orientation orv = aVertex.Orientation(); if (orv == TopAbs_FORWARD || orv == TopAbs_REVERSED) {
if (orv == TopAbs_FORWARD || orv == TopAbs_REVERSED) { const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr);
const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr);
if (orv==TopAbs_FORWARD)
if (orv==TopAbs_FORWARD) Controlp = C->Value(GC->First());
Controlp = C->Value(GC->First()); else
else Controlp = C->Value(GC->Last());
Controlp = C->Value(GC->Last());
Controlp.Transform(L.Transformation()); Controlp.Transform(L.Transformation());
aD2=prep.SquareDistance(Controlp); aD2=prep.SquareDistance(Controlp);
if (aD2 > Tol) { if (aD2 > Tol) {
aNewTolerance=sqrt(aD2)+dd; aNewTolerance=sqrt(aD2)+dd;
// printf("(Vert,2) Tolerance=%15.10lg\n", aNewTolerance); if (aNewTolerance<aMaxTol)
if (aNewTolerance<aMaxTol) TV->UpdateTolerance(aNewTolerance);
TV->UpdateTolerance(aNewTolerance); }
} }
} }
}
} }
itcr.Next(); itcr.Next();
} }

1
src/TopOpeBRepDS/TopOpeBRepDS.cxx
View File

@ -137,7 +137,6 @@ Standard_Boolean TopOpeBRepDS::IsTopology(const TopOpeBRepDS_Kind k)
case TopOpeBRepDS_VERTEX : return Standard_True; break; case TopOpeBRepDS_VERTEX : return Standard_True; break;
default : return Standard_False; default : return Standard_False;
} }
return Standard_False;
} }
//======================================================================= //=======================================================================

3
src/TopOpeBRepDS/TopOpeBRepDS_BuildTool.cxx
View File

@ -168,7 +168,7 @@ static Standard_Boolean GetOrigin(const Handle(Geom2d_Curve)& PCIN, gp_Pnt2d& o)
else { else {
return Standard_False; return Standard_False;
} }
return Standard_False; // return Standard_False;
} }
#endif #endif
@ -199,7 +199,6 @@ static Standard_Boolean GetOrigin(const Handle(Geom_Curve)& CIN, gp_Pnt& o)
else { else {
return Standard_False; return Standard_False;
} }
return Standard_False;
} }
#endif #endif

5
src/TopOpeBRepDS/TopOpeBRepDS_PointIterator.cxx
View File

@ -100,7 +100,7 @@ Standard_Real TopOpeBRepDS_PointIterator::Parameter()const
Standard_ProgramError::Raise("TopOpeBRepDS_PointIterator::Parameter()"); Standard_ProgramError::Raise("TopOpeBRepDS_PointIterator::Parameter()");
return 0.; // windowsNT return 0.; // windowsNT
} }
return 0.; // windowsNT // return 0.; // windowsNT
} }
//======================================================================= //=======================================================================
@ -139,7 +139,7 @@ Standard_Boolean TopOpeBRepDS_PointIterator::DiffOriented() const
Standard_ProgramError::Raise("TopOpeBRepDS_PointIterator::DiffOriented()"); Standard_ProgramError::Raise("TopOpeBRepDS_PointIterator::DiffOriented()");
return Standard_False; // windowsNT return Standard_False; // windowsNT
} }
return Standard_False; // windowsNT // return Standard_False; // windowsNT
} }
//======================================================================= //=======================================================================
@ -158,7 +158,6 @@ Standard_Boolean TopOpeBRepDS_PointIterator::SameOriented() const
Standard_ProgramError::Raise("TopOpeBRepDS_PointIterator::SameOriented()"); Standard_ProgramError::Raise("TopOpeBRepDS_PointIterator::SameOriented()");
return Standard_False; // windowsNT return Standard_False; // windowsNT
} }
return Standard_False; // windowsNT
} }
//======================================================================= //=======================================================================

3
src/TopOpeBRepTool/TopOpeBRepTool_makeTransition.cxx
View File

@ -182,7 +182,7 @@ static Standard_Integer FUN_mkT2dquad(const Standard_Real curvC1, const Standard
if (samec) return isON2ifss;//is ON if curves are on same side/tg line if (samec) return isON2ifss;//is ON if curves are on same side/tg line
if (curvC1 > curvC2) return isIN2ifss;//is IN if curves are on same side/tg line if (curvC1 > curvC2) return isIN2ifss;//is IN if curves are on same side/tg line
else return isOU2ifss;//is OU if curves are on same side/tg line else return isOU2ifss;//is OU if curves are on same side/tg line
return 0; // return 0;
} }
static Standard_Boolean FUN_getnearpar(const TopoDS_Edge& e,const Standard_Real par,const Standard_Real f,const Standard_Real l, static Standard_Boolean FUN_getnearpar(const TopoDS_Edge& e,const Standard_Real par,const Standard_Real f,const Standard_Real l,
@ -255,7 +255,6 @@ static Standard_Boolean FUN_getsta(const Standard_Integer mkt,const gp_Dir& tga1
sta = TopAbs_ON; sta = TopAbs_ON;
return Standard_True; return Standard_True;
} }
return Standard_False;
} }
static Standard_Boolean FUN_mkT2dquad(const TopoDS_Edge& e1,const Standard_Real par1,const Standard_Real f1,const Standard_Real l1, static Standard_Boolean FUN_mkT2dquad(const TopoDS_Edge& e1,const Standard_Real par1,const Standard_Real f1,const Standard_Real l1,
const TopoDS_Edge& e2,const Standard_Real par2, const TopoDS_Edge& e2,const Standard_Real par2,

1
src/XSControl/XSControl_Functions.cxx
View File

@ -140,7 +140,6 @@ static IFSelect_ReturnStatus XSControl_xnorm(const Handle(IFSelect_SessionPilot)
IFSelect_Activator::SetCurrentAlias (WS->SelectedNorm(Standard_True)); IFSelect_Activator::SetCurrentAlias (WS->SelectedNorm(Standard_True));
return IFSelect_RetDone; return IFSelect_RetDone;
} }
return IFSelect_RetVoid;
} }