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

0026254: Inject GeomAbs_OffsetCurve into GeomAbs_CurveType enumeration

Browse Source
This commit is contained in:
azv 2015-10-07 09:13:19 +03:00 committed by bugmaster
parent 79f4f03618
commit 1aec33207e
29 changed files with 138 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/BOPTools/BOPTools_AlgoTools_2.cxx
View File

@ -301,6 +301,7 @@ void BOPTools_AlgoTools::CorrectRange(const TopoDS_Edge& aE1,
//
if (aCT==GeomAbs_BezierCurve ||
aCT==GeomAbs_BSplineCurve||
aCT==GeomAbs_OffsetCurve ||
aCT==GeomAbs_OtherCurve) {
if(!i){
@ -369,6 +370,7 @@ void BOPTools_AlgoTools::CorrectRange(const TopoDS_Edge& aE,
if (aCT==GeomAbs_BezierCurve ||
aCT==GeomAbs_BSplineCurve||
aCT==GeomAbs_OffsetCurve ||
aCT==GeomAbs_OtherCurve) {
if(!i){

5
src/BRepAlgo/BRepAlgo.cxx
View File

@ -254,10 +254,7 @@ TopoDS_Edge BRepAlgo::ConcatenateWireC0(const TopoDS_Wire& aWire)
NewFpar = fpar;
NewLpar = lpar;
isSameCurve = Standard_True;
} else if (aType == CurType &&
aType != GeomAbs_BezierCurve &&
aType != GeomAbs_BSplineCurve &&
aType != GeomAbs_OtherCurve) {
} else if (aType == CurType) {
switch (aType) {
case GeomAbs_Line:
{

14
src/BRepFill/BRepFill_TrimSurfaceTool.cxx
View File

@ -236,12 +236,14 @@ static void EvalParameters(const TopoDS_Edge& Edge,
// extra solutions those would cause *Exception*: incoherent intersection
GeomAbs_CurveType CType = AC.GetType(), BisType = ABis.GetType();
Standard_Boolean canElongateC = !(CType == GeomAbs_BezierCurve ||
CType == GeomAbs_BSplineCurve ||
CType == GeomAbs_OtherCurve);
Standard_Boolean canElongateBis = !(BisType == GeomAbs_BezierCurve ||
BisType == GeomAbs_BSplineCurve ||
BisType == GeomAbs_OtherCurve);
Standard_Boolean canElongateC = !(CType == GeomAbs_BezierCurve ||
CType == GeomAbs_BSplineCurve ||
CType == GeomAbs_OffsetCurve ||
CType == GeomAbs_OtherCurve);
Standard_Boolean canElongateBis = !(BisType == GeomAbs_BezierCurve ||
BisType == GeomAbs_BSplineCurve ||
BisType == GeomAbs_OffsetCurve ||
BisType == GeomAbs_OtherCurve);
Handle(Geom2d_TrimmedCurve) TBis = Handle(Geom2d_TrimmedCurve)::DownCast(Bis);
Handle(Geom2d_TrimmedCurve) TC2d = Handle(Geom2d_TrimmedCurve)::DownCast(C2d);

4
src/BRepMAT2d/BRepMAT2d_Explorer.cxx
View File

@ -31,6 +31,7 @@
#include <Geom2d_Ellipse.hxx>
#include <Geom2d_Hyperbola.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2d_OffsetCurve.hxx>
#include <Geom2d_Parabola.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2dConvert.hxx>
@ -598,6 +599,9 @@ GeomAbs_CurveType GetCurveType(const Handle(Geom2d_Curve)& theC2d)
else if ( TheType == STANDARD_TYPE(Geom2d_BSplineCurve)) {
aTypeCurve = GeomAbs_BSplineCurve;
}
else if ( TheType == STANDARD_TYPE(Geom2d_OffsetCurve)) {
aTypeCurve = GeomAbs_OffsetCurve;
}
else {
aTypeCurve = GeomAbs_OtherCurve;
}

2
src/DBRep/DBRep_DrawableShape.cxx
View File

@ -573,6 +573,7 @@ void DBRep_DrawableShape::DrawOn(Draw_Display& dis) const
case GeomAbs_Hyperbola :
case GeomAbs_BezierCurve :
case GeomAbs_BSplineCurve :
case GeomAbs_OffsetCurve :
case GeomAbs_OtherCurve :
for (j = 1; j <= myDiscret/2; j++) {
Handle(DBRep_Face) aLocalFace = F;
@ -697,6 +698,7 @@ void DBRep_DrawableShape::DrawOn(Draw_Display& dis) const
case GeomAbs_Hyperbola :
case GeomAbs_BezierCurve :
case GeomAbs_BSplineCurve :
case GeomAbs_OffsetCurve :
case GeomAbs_OtherCurve :
for (j = 1; j <= myDiscret/2; j++) {
Handle(DBRep_Edge) aLocaLEdge(E);

1
src/DrawTrSurf/DrawTrSurf_Drawable.cxx
View File

@ -174,6 +174,7 @@ void DrawTrSurf_Drawable::DrawCurveOn (Adaptor3d_Curve& C,
case GeomAbs_Hyperbola:
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_OtherCurve:
const Standard_Integer nIter = myDiscret/2;
for (j = 1; j < nIter; j++)

110
src/Extrema/Extrema_ExtCC2d.cxx
View File

@ -117,6 +117,12 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
case GeomAbs_Circle: {
switch(type2) {
case GeomAbs_Line: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Circle(C1), Tol);
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
case GeomAbs_Circle: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1), Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 2*M_PI);
@ -137,9 +143,7 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0. );
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_OtherCurve:
case GeomAbs_BSplineCurve: {
default: {
Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
@ -148,12 +152,6 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
Results(aParamSolver, U11, U12, U21, U22, 2*M_PI,Period2);
}
break;
case GeomAbs_Line: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Circle(C1), Tol);
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
}; // switch(type2)
}
break;
@ -164,6 +162,12 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
case GeomAbs_Ellipse: {
switch(type2) {
case GeomAbs_Line: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Ellipse(C1));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
case GeomAbs_Circle: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Ellipse(C1));
@ -194,9 +198,7 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
Results(aParamSolver, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_OtherCurve:
case GeomAbs_BSplineCurve: {
default: {
Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
@ -205,12 +207,6 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
Results(aParamSolver, U11, U12, U21, U22, 2*M_PI,Period2);
}
break;
case GeomAbs_Line: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Ellipse(C1));
Results(Xtrem, U11, U12, U21, U22, 2*M_PI, 0.);
}
break;
}; // switch(type2)
}
break;
@ -221,6 +217,12 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
case GeomAbs_Parabola: {
switch(type2) {
case GeomAbs_Line: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Parabola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Circle: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Parabola(C1));
@ -253,9 +255,7 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_OtherCurve:
case GeomAbs_BSplineCurve: {
default: {
Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
@ -264,12 +264,6 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
Results(aParamSolver, U11, U12, U21, U22, 0., Period2);
}
break;
case GeomAbs_Line: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Parabola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
}; // switch(type2)
}
break;
@ -280,6 +274,12 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
case GeomAbs_Hyperbola: {
switch(type2) {
case GeomAbs_Line: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Hyperbola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Circle: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Hyperbola(C1));
@ -311,9 +311,7 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_OtherCurve:
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve: {
default: {
Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
@ -322,39 +320,21 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
Results(aParamSolver, U11, U12, U21, U22, 0., Period2);
}
break;
case GeomAbs_Line: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Extrema_Curve2dTool::Hyperbola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
}; // switch(type2)
}
break;
//
// La premiere courbe est une BezierCurve ou une BSplineCurve:
//
case GeomAbs_BezierCurve:
case GeomAbs_OtherCurve:
case GeomAbs_BSplineCurve: {
Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period1 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(C1)) Period1 = Extrema_Curve2dTool::Period(C1);
Standard_Real Period2 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
Results(aParamSolver, U11, U12, U21, U22, Period1, Period2);
}
break;
//
// La premiere courbe est une Line:
//
case GeomAbs_Line: {
switch(type2) {
case GeomAbs_Line: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Tol);
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Circle: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Circle(*((Adaptor2d_Curve2d*)myC)), Tol);
Results(Xtrem, U11, U12, U21, U22, 0., 2*M_PI);
@ -375,9 +355,7 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_OtherCurve:
case GeomAbs_BSplineCurve: {
default: {
Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
@ -386,15 +364,25 @@ void Extrema_ExtCC2d::Perform (const Adaptor2d_Curve2d& C1,
Results(aParamSolver, U11, U12, U21, U22, 0., Period2);
}
break;
case GeomAbs_Line: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Line(*((Adaptor2d_Curve2d*)myC)), Tol);
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
}
break;
}; // switch(type2)
}
break;
//
// La premiere courbe est une BezierCurve ou une BSplineCurve:
//
default: {
Extrema_ECC2d aParamSolver(C1, *((Adaptor2d_Curve2d*)myC));
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Standard_Real Period1 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(C1)) Period1 = Extrema_Curve2dTool::Period(C1);
Standard_Real Period2 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(*((Adaptor2d_Curve2d*)myC))) Period2 = Extrema_Curve2dTool::Period(*((Adaptor2d_Curve2d*)myC));
Results(aParamSolver, U11, U12, U21, U22, Period1, Period2);
}
break;
};
}

4
src/Extrema/Extrema_FuncExtCC.gxx
View File

@ -125,6 +125,7 @@ myTol (thetol)
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_OtherCurve:
myMaxDerivOrderC1 = MaxOrder;
myTolC1 = SearchOfTolerance((Standard_Address)&C1);
@ -139,6 +140,7 @@ myTol (thetol)
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_OtherCurve:
myMaxDerivOrderC2 = MaxOrder;
myTolC2 = SearchOfTolerance((Standard_Address)&C2);
@ -162,6 +164,7 @@ void Extrema_FuncExtCC::SetCurve (const Standard_Integer theRank, const Curve1&
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_OtherCurve:
myMaxDerivOrderC1 = MaxOrder;
myTolC1 = SearchOfTolerance((Standard_Address)&C);
@ -179,6 +182,7 @@ void Extrema_FuncExtCC::SetCurve (const Standard_Integer theRank, const Curve1&
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_OtherCurve:
myMaxDerivOrderC2 = MaxOrder;
myTolC2 = SearchOfTolerance((Standard_Address)&C);

2
src/Extrema/Extrema_FuncExtPC.gxx
View File

@ -98,6 +98,7 @@ Extrema_FuncExtPC::Extrema_FuncExtPC (const Pnt& P,
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_OtherCurve:
myMaxDerivOrder = MaxOrder;
myTol = SearchOfTolerance();
@ -125,6 +126,7 @@ void Extrema_FuncExtPC::Initialize(const Curve& C)
{
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_OtherCurve:
myMaxDerivOrder = MaxOrder;
myTol = SearchOfTolerance();

3
src/Extrema/Extrema_GExtPC.gxx
View File

@ -249,7 +249,7 @@ void Extrema_GExtPC::Perform(const ThePoint& P)
mydone = Standard_True;
break;
}
case GeomAbs_OtherCurve:
default:
{
Standard_Boolean IntExtIsDone = Standard_False;
Standard_Boolean IntIsNotValid;
@ -310,6 +310,7 @@ void Extrema_GExtPC::Perform(const ThePoint& P)
// Postprocessing.
if (type == GeomAbs_BSplineCurve ||
type == GeomAbs_OffsetCurve ||
type == GeomAbs_OtherCurve)
{
// Additional checking if the point is on the first or last point of the curve

19
src/Extrema/Extrema_GLocateExtPC.gxx
View File

@ -88,8 +88,10 @@ void Extrema_GLocateExtPC::Initialize(const TheCurve& C,
type = TheCurveTool::GetType(C);
Standard_Real tolu = TheCurveTool::Resolution(C, Precision::Confusion());
if ((type == GeomAbs_BSplineCurve) ||
(type == GeomAbs_BezierCurve) ||
(type == GeomAbs_OtherCurve)) {
(type == GeomAbs_BezierCurve) ||
(type == GeomAbs_OffsetCurve) ||
(type == GeomAbs_OtherCurve))
{
myLocExtPC.Initialize(C, Umin, Usup, tolu);
}
else {
@ -116,6 +118,7 @@ void Extrema_GLocateExtPC::Perform(const ThePoint& P,
switch(type)
{
case GeomAbs_OtherCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_BSplineCurve:
{
// La recherche de l extremum est faite intervalle continu C2 par
@ -311,7 +314,9 @@ Standard_Real Extrema_GLocateExtPC::SquareDistance () const
if ((type == GeomAbs_BezierCurve)) {
d = myLocExtPC.SquareDistance();
}
else if(type == GeomAbs_BSplineCurve || type == GeomAbs_OtherCurve) {
else if(type == GeomAbs_BSplineCurve ||
type == GeomAbs_OffsetCurve ||
type == GeomAbs_OtherCurve) {
d = mydist2;
}
else {
@ -335,7 +340,9 @@ Standard_Boolean Extrema_GLocateExtPC::IsMin () const
if ((type == GeomAbs_BezierCurve)) {
b = myLocExtPC.IsMin();
}
else if(type == GeomAbs_BSplineCurve || type == GeomAbs_OtherCurve) {
else if(type == GeomAbs_BSplineCurve ||
type == GeomAbs_OffsetCurve ||
type == GeomAbs_OtherCurve) {
b = myismin;
}
else {
@ -358,7 +365,9 @@ const ThePOnC & Extrema_GLocateExtPC::Point () const
if (type == GeomAbs_BezierCurve) {
return myLocExtPC.Point();
}
else if(type == GeomAbs_BSplineCurve || type == GeomAbs_OtherCurve) {
else if(type == GeomAbs_BSplineCurve ||
type == GeomAbs_OffsetCurve ||
type == GeomAbs_OtherCurve) {
return mypp;
}
return myExtremPC.Point(numberext);

2
src/Geom2dAdaptor/Geom2dAdaptor.cxx
View File

@ -89,7 +89,7 @@ Handle(Geom2d_Curve) Geom2dAdaptor::MakeCurve
}
break;
case GeomAbs_OtherCurve:
default:
Standard_DomainError::Raise("Geom2dAdaptor::MakeCurve, OtherCurve");
}

20
src/Geom2dAdaptor/Geom2dAdaptor_Curve.cxx
View File

@ -227,7 +227,7 @@ void Geom2dAdaptor_Curve::load(const Handle(Geom2d_Curve)& C,
}
else if ( TheType == STANDARD_TYPE(Geom2d_OffsetCurve))
{
myTypeCurve = GeomAbs_OtherCurve;
myTypeCurve = GeomAbs_OffsetCurve;
// Create nested adaptor for base curve
Handle(Geom2d_Curve) aBase = Handle(Geom2d_OffsetCurve)::DownCast(myCurve)->BasisCurve();
myOffsetBaseCurveAdaptor = new Geom2dAdaptor_HCurve(aBase);
@ -252,7 +252,7 @@ GeomAbs_Shape Geom2dAdaptor_Curve::Continuity() const
if (myTypeCurve == GeomAbs_BSplineCurve) {
return LocalContinuity(myFirst, myLast);
}
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom2d_OffsetCurve)){
else if (myTypeCurve == GeomAbs_OffsetCurve){
GeomAbs_Shape S =
Handle(Geom2d_OffsetCurve)::DownCast (myCurve)->GetBasisCurveContinuity();
switch(S){
@ -364,7 +364,7 @@ Standard_Integer Geom2dAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
}
}
}
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom2d_OffsetCurve)){
else if (myTypeCurve == GeomAbs_OffsetCurve){
GeomAbs_Shape BaseS=GeomAbs_C0;
switch(S){
case GeomAbs_G1:
@ -479,7 +479,7 @@ void Geom2dAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
}
}
}
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom2d_OffsetCurve)){
else if (myTypeCurve == GeomAbs_OffsetCurve){
GeomAbs_Shape BaseS=GeomAbs_C0;
switch(S){
case GeomAbs_G1:
@ -575,7 +575,7 @@ gp_Pnt2d Geom2dAdaptor_Curve::Value(const Standard_Real U) const
{
if (myTypeCurve == GeomAbs_BSplineCurve)
return ValueBSpline(U);
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom2d_OffsetCurve))
else if (myTypeCurve == GeomAbs_OffsetCurve)
return ValueOffset(U);
return myCurve->Value(U);
@ -646,7 +646,7 @@ void Geom2dAdaptor_Curve::D0(const Standard_Real U, gp_Pnt2d& P) const
D0BSpline(U, P);
return;
}
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom2d_OffsetCurve))
else if (myTypeCurve == GeomAbs_OffsetCurve)
{
D0Offset(U, P);
return;
@ -709,7 +709,7 @@ void Geom2dAdaptor_Curve::D1(const Standard_Real U,
D1BSpline(U, P, V);
return;
}
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom2d_OffsetCurve))
else if (myTypeCurve == GeomAbs_OffsetCurve)
{
D1Offset(U, P, V);
return;
@ -785,7 +785,7 @@ void Geom2dAdaptor_Curve::D2(const Standard_Real U,
D2BSpline(U, P, V1, V2);
return;
}
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom2d_OffsetCurve))
else if (myTypeCurve == GeomAbs_OffsetCurve)
{
D2Offset(U, P, V1, V2);
return;
@ -866,7 +866,7 @@ void Geom2dAdaptor_Curve::D3(const Standard_Real U,
D3BSpline(U, P, V1, V2, V3);
return;
}
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom2d_OffsetCurve))
else if (myTypeCurve == GeomAbs_OffsetCurve)
{
D3Offset(U, P, V1, V2, V3);
return;
@ -950,7 +950,7 @@ gp_Vec2d Geom2dAdaptor_Curve::DN(const Standard_Real U,
{
if (myTypeCurve == GeomAbs_BSplineCurve)
return DNBSpline(U, N);
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom2d_OffsetCurve))
else if (myTypeCurve == GeomAbs_OffsetCurve)
return DNOffset(U, N);
return myCurve->DN(U, N);

3
src/GeomAPI/GeomAPI.cxx
View File

@ -55,7 +55,8 @@ Handle(Geom2d_Curve) GeomAPI::To2d(const Handle(Geom_Curve)& C,
ProjLib_ProjectedCurve Proj(HS,HC);
if (Proj.GetType() != GeomAbs_OtherCurve) {
if (Proj.GetType() != GeomAbs_OffsetCurve &&
Proj.GetType() != GeomAbs_OtherCurve) {
result = Geom2dAdaptor::MakeCurve(Proj);
}

1
src/GeomAbs/GeomAbs_CurveType.hxx
View File

@ -28,6 +28,7 @@ GeomAbs_Hyperbola,
GeomAbs_Parabola,
GeomAbs_BezierCurve,
GeomAbs_BSplineCurve,
GeomAbs_OffsetCurve,
GeomAbs_OtherCurve
};

2
src/GeomAdaptor/GeomAdaptor.cxx
View File

@ -80,7 +80,7 @@ Handle(Geom_Curve) GeomAdaptor::MakeCurve (const Adaptor3d_Curve& HC)
C = Handle(Geom_BSplineCurve)::DownCast(HC.BSpline()->Copy());
break;
case GeomAbs_OtherCurve:
default:
Standard_DomainError::Raise("GeomAdaptor::MakeCurve : OtherCurve");
}

20
src/GeomAdaptor/GeomAdaptor_Curve.cxx
View File

@ -182,7 +182,7 @@ void GeomAdaptor_Curve::load(const Handle(Geom_Curve)& C,
myBspl->KnotSequence(), myBspl->Poles(), myBspl->Weights());
}
else if ( TheType == STANDARD_TYPE(Geom_OffsetCurve)) {
myTypeCurve = GeomAbs_OtherCurve;
myTypeCurve = GeomAbs_OffsetCurve;
// Create nested adaptor for base curve
Handle(Geom_Curve) aBase = Handle(Geom_OffsetCurve)::DownCast(myCurve)->BasisCurve();
myOffsetBaseCurveAdaptor = new GeomAdaptor_HCurve(aBase);
@ -207,7 +207,7 @@ GeomAbs_Shape GeomAdaptor_Curve::Continuity() const
if (myTypeCurve == GeomAbs_BSplineCurve)
return LocalContinuity(myFirst, myLast);
if (myCurve->IsKind(STANDARD_TYPE(Geom_OffsetCurve)))
if (myTypeCurve == GeomAbs_OffsetCurve)
{
const GeomAbs_Shape S =
Handle(Geom_OffsetCurve)::DownCast (myCurve)->GetBasisCurveContinuity();
@ -316,7 +316,7 @@ Standard_Integer GeomAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
}
}
else if (myCurve->IsKind(STANDARD_TYPE(Geom_OffsetCurve))){
else if (myTypeCurve == GeomAbs_OffsetCurve) {
GeomAbs_Shape BaseS=GeomAbs_C0;
switch(S){
case GeomAbs_G1:
@ -452,7 +452,7 @@ void GeomAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
}
}
else if (myCurve->IsKind(STANDARD_TYPE(Geom_OffsetCurve))){
else if (myTypeCurve == GeomAbs_OffsetCurve){
GeomAbs_Shape BaseS=GeomAbs_C0;
switch(S){
case GeomAbs_G1:
@ -557,7 +557,7 @@ gp_Pnt GeomAdaptor_Curve::Value(const Standard_Real U) const
{
if (myTypeCurve == GeomAbs_BSplineCurve)
return ValueBSpline(U);
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom_OffsetCurve))
else if (myTypeCurve == GeomAbs_OffsetCurve)
return ValueOffset(U);
return myCurve->Value(U);
}
@ -624,7 +624,7 @@ void GeomAdaptor_Curve::D0(const Standard_Real U, gp_Pnt& P) const
{
if (myTypeCurve == GeomAbs_BSplineCurve)
D0BSpline(U, P);
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom_OffsetCurve))
else if (myTypeCurve == GeomAbs_OffsetCurve)
D0Offset(U, P);
else
myCurve->D0(U, P);
@ -680,7 +680,7 @@ void GeomAdaptor_Curve::D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V) const
{
if (myTypeCurve == GeomAbs_BSplineCurve)
D1BSpline(U, P, V);
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom_OffsetCurve))
else if (myTypeCurve == GeomAbs_OffsetCurve)
D1Offset(U, P, V);
else
myCurve->D1(U, P, V);
@ -748,7 +748,7 @@ void GeomAdaptor_Curve::D2(const Standard_Real U,
{
if (myTypeCurve == GeomAbs_BSplineCurve)
D2BSpline(U, P, V1, V2);
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom_OffsetCurve))
else if (myTypeCurve == GeomAbs_OffsetCurve)
D2Offset(U, P, V1, V2);
else
myCurve->D2(U, P, V1, V2);
@ -818,7 +818,7 @@ void GeomAdaptor_Curve::D3(const Standard_Real U,
{
if (myTypeCurve == GeomAbs_BSplineCurve)
D3BSpline(U, P, V1, V2, V3);
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom_OffsetCurve))
else if (myTypeCurve == GeomAbs_OffsetCurve)
D3Offset(U, P, V1, V2, V3);
else
myCurve->D3(U, P, V1, V2, V3);
@ -890,7 +890,7 @@ gp_Vec GeomAdaptor_Curve::DN(const Standard_Real U,
{
if (myTypeCurve == GeomAbs_BSplineCurve)
return DNBSpline(U, N);
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom_OffsetCurve))
else if (myTypeCurve == GeomAbs_OffsetCurve)
return DNOffset(U, N);
return myCurve->DN(U, N);

3
src/HLRBRep/HLRBRep_Curve.cxx
View File

@ -85,6 +85,9 @@ HLRBRep_Curve::Parameter2d (const Standard_Real P3d) const
case GeomAbs_Ellipse:
return P3d + myOX;
default: // implemented to avoid gcc compiler warnings
break;
}
return P3d;
}

28
src/IntCurve/IntCurve_IntCurveCurveGen.gxx
View File

@ -344,9 +344,7 @@ void IntCurve_IntCurveCurveGen::InternalPerform (const TheCurve& C1,
break;
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OtherCurve:
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(TheCurveTool::Line(C1),D1,
@ -471,9 +469,7 @@ void IntCurve_IntCurveCurveGen::InternalPerform (const TheCurve& C1,
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OtherCurve:
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(TheCurveTool::Circle(C1),D1,
@ -602,9 +598,7 @@ void IntCurve_IntCurveCurveGen::InternalPerform (const TheCurve& C1,
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OtherCurve:
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(TheCurveTool::Ellipse(C1),D1,
@ -729,9 +723,7 @@ void IntCurve_IntCurveCurveGen::InternalPerform (const TheCurve& C1,
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OtherCurve:
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(TheCurveTool::Parabola(C1),D1,
@ -833,9 +825,7 @@ void IntCurve_IntCurveCurveGen::InternalPerform (const TheCurve& C1,
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OtherCurve:
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(TheCurveTool::Hyperbola(C1),D1,
@ -851,9 +841,7 @@ void IntCurve_IntCurveCurveGen::InternalPerform (const TheCurve& C1,
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OtherCurve:
default:
switch (typ2)
{
case GeomAbs_Line:
@ -952,9 +940,7 @@ void IntCurve_IntCurveCurveGen::InternalPerform (const TheCurve& C1,
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OtherCurve:
default:
{
intcurvcurv.SetReversedParameters(Standard_False);
intcurvcurv.Perform(C1,D1, C2,D2,TolConf,Tol);

20
src/IntCurve/IntCurve_UserIntConicCurveGen.gxx
View File

@ -388,9 +388,7 @@ void IntCurve_UserIntConicCurveGen::InternalPerform (const gp_Lin2d& Lin1,
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OtherCurve:
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(Lin1,D1,C2,D2,TolConf,Tol);
@ -483,9 +481,7 @@ void IntCurve_UserIntConicCurveGen::InternalPerform (const gp_Circ2d& Circ1,
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OtherCurve:
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(Circ1,D1,C2,D2,TolConf,Tol);
@ -578,9 +574,7 @@ void IntCurve_UserIntConicCurveGen::InternalPerform (const gp_Elips2d& Elips1,
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OtherCurve:
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(Elips1,D1,C2,D2,TolConf,Tol);
@ -673,9 +667,7 @@ void IntCurve_UserIntConicCurveGen::InternalPerform (const gp_Parab2d& Parab1,
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OtherCurve:
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(Parab1,D1,C2,D2,TolConf,Tol);
@ -768,9 +760,7 @@ void IntCurve_UserIntConicCurveGen::InternalPerform (const gp_Hypr2d& Hyper1,
}
break;
case GeomAbs_BezierCurve:
case GeomAbs_BSplineCurve:
case GeomAbs_OtherCurve:
default:
{
intconicurv.SetReversedParameters(Standard_False);
intconicurv.Perform(Hyper1,D1,

1
src/IntTools/IntTools.cxx
View File

@ -119,6 +119,7 @@
}
if (aCurveType==GeomAbs_BSplineCurve||
aCurveType==GeomAbs_BezierCurve ||
aCurveType==GeomAbs_OffsetCurve ||
aCurveType==GeomAbs_Ellipse ||
aCurveType==GeomAbs_OtherCurve) { //modified by NIZNHY-PKV Fri Sep 24 09:52:42 2004ft
continue;

1
src/IntTools/IntTools_BeanFaceIntersector.cxx
View File

@ -729,6 +729,7 @@ Standard_Integer IntTools_BeanFaceIntersector::FastComputeExactIntersection()
//
if((aCT==GeomAbs_BezierCurve) ||
(aCT==GeomAbs_BSplineCurve) ||
(aCT==GeomAbs_OffsetCurve) ||
(aCT==GeomAbs_OtherCurve)) {
return aresult;
}

1
src/IntTools/IntTools_EdgeEdge.cxx
View File

@ -1305,6 +1305,7 @@ Standard_Real ResolutionCoeff(const BRepAdaptor_Curve& theBAC,
break;
case GeomAbs_Hyperbola :
case GeomAbs_Parabola :
case GeomAbs_OffsetCurve :
case GeomAbs_OtherCurve :{
Standard_Real k, kMin, aDist, aDt, aT1, aT2, aT;
Standard_Integer aNbP, i;

1
src/ProjLib/ProjLib_ComputeApprox.cxx
View File

@ -868,6 +868,7 @@ ProjLib_ComputeApprox::ProjLib_ComputeApprox
Standard_Boolean CurvIsAnal = (CType != GeomAbs_BSplineCurve) &&
(CType != GeomAbs_BezierCurve) &&
(CType != GeomAbs_OffsetCurve) &&
(CType != GeomAbs_OtherCurve) ;
Standard_Boolean simplecase = SurfIsAnal && CurvIsAnal;

1
src/ProjLib/ProjLib_ProjectedCurve.cxx
View File

@ -246,6 +246,7 @@ static void Project(ProjLib_Projector& P, Handle(Adaptor3d_HCurve)& C)
break;
case GeomAbs_BSplineCurve:
case GeomAbs_BezierCurve:
case GeomAbs_OffsetCurve:
case GeomAbs_OtherCurve: // try the approximation
break;
default:

3
src/ShapeConstruct/ShapeConstruct_ProjectCurveOnSurface.cxx
View File

@ -427,8 +427,7 @@ Standard_Boolean ShapeConstruct_ProjectCurveOnSurface::PerformByProjLib(Handle(G
case GeomAbs_BSplineCurve :
c2d = Projector.BSpline();
break;
case GeomAbs_BezierCurve :
case GeomAbs_OtherCurve :
default:
// Not possible, handling added to avoid gcc warning.
break;
}

1
src/TestTopOpeDraw/TestTopOpeDraw_TTOT.cxx
View File

@ -185,6 +185,7 @@ void TestTopOpeDraw_TTOT::CurveToString
case GeomAbs_Parabola : N = "PARABOLA"; break;
case GeomAbs_BezierCurve : N = "BEZIER"; break;
case GeomAbs_BSplineCurve : N = "BSPLINE"; break;
case GeomAbs_OffsetCurve : N = "OFFSET"; break;
case GeomAbs_OtherCurve : N = "OTHER"; break;
default : N = "UNKNOWN"; break;
}

1
src/TopOpeBRepBuild/TopOpeBRepBuild_Griddump.cxx
View File

@ -174,6 +174,7 @@ void TopOpeBRepBuild_Builder::PrintCur(const TopoDS_Edge& E)
case GeomAbs_Parabola : cout<<"PARABOLA"; break;
case GeomAbs_BezierCurve : cout<<"BEZIERCURVE"; break;
case GeomAbs_BSplineCurve : cout<<"BSPLINECURVE "<<GC.BSpline()->Degree(); break;
case GeomAbs_OffsetCurve : cout<<"OFFSETCURVE"; break;
case GeomAbs_OtherCurve : cout<<"OTHERCURVE"; break;
}
cout.flush();

2
src/TopOpeBRepTool/TopOpeBRepTool_CurveTool.cxx
View File

@ -154,7 +154,7 @@ Standard_EXPORT Handle(Geom2d_Curve) MakePCurve(const ProjLib_ProjectedCurve& PC
case GeomAbs_Parabola : C2D = new Geom2d_Parabola(PC.Parabola()); break;
case GeomAbs_Hyperbola : C2D = new Geom2d_Hyperbola(PC.Hyperbola()); break;
case GeomAbs_BSplineCurve : C2D = PC.BSpline(); break;
case GeomAbs_BezierCurve : case GeomAbs_OtherCurve : default :
default :
Standard_NotImplemented::Raise("CurveTool::MakePCurve");
break;
}