0026254: Inject GeomAbs_OffsetCurve into GeomAbs_CurveType enumeration

diff --git a/src/BOPTools/BOPTools_AlgoTools_2.cxx b/src/BOPTools/BOPTools_AlgoTools_2.cxx
index cac1dc564f168733eb704025782bd6c54ae8e4db..8dd871629ba2361042be4a70d89924bc5c942a7b 100644 (file)
--- a/src/BOPTools/BOPTools_AlgoTools_2.cxx
+++ b/src/BOPTools/BOPTools_AlgoTools_2.cxx
@@ -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){

diff --git a/src/BRepAlgo/BRepAlgo.cxx b/src/BRepAlgo/BRepAlgo.cxx
index b6a7cbdfcb3cae1263774813756a073b206c86d6..a6bdf8a1d20e8d26ba18287e3103a5f8f31ce358 100644 (file)
--- a/src/BRepAlgo/BRepAlgo.cxx
+++ b/src/BRepAlgo/BRepAlgo.cxx
@@ -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:
             {

diff --git a/src/BRepFill/BRepFill_TrimSurfaceTool.cxx b/src/BRepFill/BRepFill_TrimSurfaceTool.cxx
index 583e6c7d76c2424067481c751faf38761ff2d756..1f20fc6a6c8771e84c661586b64037b578216609 100644 (file)
--- a/src/BRepFill/BRepFill_TrimSurfaceTool.cxx
+++ b/src/BRepFill/BRepFill_TrimSurfaceTool.cxx
@@ -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);

diff --git a/src/BRepMAT2d/BRepMAT2d_Explorer.cxx b/src/BRepMAT2d/BRepMAT2d_Explorer.cxx
index ca8d20f3975d17b81ae9bc0a0f8dfa02f9e9de5a..662a0cd6225459c970ad6b817dbfe129e8b1cb6a 100644 (file)
--- a/src/BRepMAT2d/BRepMAT2d_Explorer.cxx
+++ b/src/BRepMAT2d/BRepMAT2d_Explorer.cxx
@@ -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;
   }

diff --git a/src/DBRep/DBRep_DrawableShape.cxx b/src/DBRep/DBRep_DrawableShape.cxx
index 36e7b6596fb254a1bfa65afee1704e06846d6ef4..fae127cd643e0432b4ae34a53829411ace3ab13d 100644 (file)
--- a/src/DBRep/DBRep_DrawableShape.cxx
+++ b/src/DBRep/DBRep_DrawableShape.cxx
@@ -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);

diff --git a/src/DrawTrSurf/DrawTrSurf_Drawable.cxx b/src/DrawTrSurf/DrawTrSurf_Drawable.cxx
index 26bf6d9e59d6bc18de19f932ea5b1a0f87712e60..1c652f085f65ec3c0f7f2e7a436354b9633aaa2f 100644 (file)
--- a/src/DrawTrSurf/DrawTrSurf_Drawable.cxx
+++ b/src/DrawTrSurf/DrawTrSurf_Drawable.cxx
@@ -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++)

diff --git a/src/Extrema/Extrema_ExtCC2d.cxx b/src/Extrema/Extrema_ExtCC2d.cxx
index cf93af4159f6e96047fb239b5283a6f8df31707e..957a044fc662138d4af5f11144a0e8f0cb339f51 100644 (file)
--- a/src/Extrema/Extrema_ExtCC2d.cxx
+++ b/src/Extrema/Extrema_ExtCC2d.cxx
@@ -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;
+
   };
     
 }

diff --git a/src/Extrema/Extrema_FuncExtCC.gxx b/src/Extrema/Extrema_FuncExtCC.gxx
index 7f98b46dd26b874bdf727a452cd261110950eac1..3c1134dea3d7e16133c579b7993a2c50359649d0 100644 (file)
--- a/src/Extrema/Extrema_FuncExtCC.gxx
+++ b/src/Extrema/Extrema_FuncExtCC.gxx
@@ -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);

diff --git a/src/Extrema/Extrema_FuncExtPC.gxx b/src/Extrema/Extrema_FuncExtPC.gxx
index 347079142ca98fb0ab1178482e551ee10a7f9a9d..a79915df84a5d90e4e93405a120704c8764f361b 100644 (file)
--- a/src/Extrema/Extrema_FuncExtPC.gxx
+++ b/src/Extrema/Extrema_FuncExtPC.gxx
@@ -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();

diff --git a/src/Extrema/Extrema_GExtPC.gxx b/src/Extrema/Extrema_GExtPC.gxx
index 7fdee7543a52c3db4f96fe4d93244e8909b92d51..400491b947b5f0bda5c7d637c281b8e6412bc98c 100644 (file)
--- a/src/Extrema/Extrema_GExtPC.gxx
+++ b/src/Extrema/Extrema_GExtPC.gxx
@@ -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

diff --git a/src/Extrema/Extrema_GLocateExtPC.gxx b/src/Extrema/Extrema_GLocateExtPC.gxx
index ed75c965bf3befb22fe9436cdd1d50b64b2ce6f2..5f9a911f44c740d65edc90c13281cd5dbd225114 100644 (file)
--- a/src/Extrema/Extrema_GLocateExtPC.gxx
+++ b/src/Extrema/Extrema_GLocateExtPC.gxx
@@ -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);

diff --git a/src/Geom2dAdaptor/Geom2dAdaptor.cxx b/src/Geom2dAdaptor/Geom2dAdaptor.cxx
index 37d990841927fb7469a52f0a77f73db04b34a423..87bb50a5bd061380e80020d78667cda0e7068b7a 100644 (file)
--- a/src/Geom2dAdaptor/Geom2dAdaptor.cxx
+++ b/src/Geom2dAdaptor/Geom2dAdaptor.cxx
@@ -89,7 +89,7 @@ Handle(Geom2d_Curve) Geom2dAdaptor::MakeCurve
     }
     break;
     
-  case GeomAbs_OtherCurve:
+  default:
     Standard_DomainError::Raise("Geom2dAdaptor::MakeCurve, OtherCurve");
 
   }

diff --git a/src/Geom2dAdaptor/Geom2dAdaptor_Curve.cxx b/src/Geom2dAdaptor/Geom2dAdaptor_Curve.cxx
index a956cb996d6401f61545961ceaf8537b36ae9ebd..5a9b93357d77d019a03a267d41f20b0f365d2268 100644 (file)
--- a/src/Geom2dAdaptor/Geom2dAdaptor_Curve.cxx
+++ b/src/Geom2dAdaptor/Geom2dAdaptor_Curve.cxx
@@ -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);

diff --git a/src/GeomAPI/GeomAPI.cxx b/src/GeomAPI/GeomAPI.cxx
index 8c1a59fe4bd50d8a2645b4d0778450e801152b06..24ab87a5fcc27f436f482d97f507d6f47d7cc14a 100644 (file)
--- a/src/GeomAPI/GeomAPI.cxx
+++ b/src/GeomAPI/GeomAPI.cxx
@@ -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);
   }
   

diff --git a/src/GeomAbs/GeomAbs_CurveType.hxx b/src/GeomAbs/GeomAbs_CurveType.hxx
index 40add0372c3c8ec74a0effa4e73ff8c48478f85d..3b9e3aa1fa697c600b040aaa74a51629c4079347 100644 (file)
--- a/src/GeomAbs/GeomAbs_CurveType.hxx
+++ b/src/GeomAbs/GeomAbs_CurveType.hxx
@@ -28,6 +28,7 @@ GeomAbs_Hyperbola,
 GeomAbs_Parabola,
 GeomAbs_BezierCurve,
 GeomAbs_BSplineCurve,
+GeomAbs_OffsetCurve,
 GeomAbs_OtherCurve
 };
 

diff --git a/src/GeomAdaptor/GeomAdaptor.cxx b/src/GeomAdaptor/GeomAdaptor.cxx
index 78805029ba754c5fdf64de04c8071361aaa19ddd..58b15d0332290157a756c7fcabf738bf323b0f54 100644 (file)
--- a/src/GeomAdaptor/GeomAdaptor.cxx
+++ b/src/GeomAdaptor/GeomAdaptor.cxx
@@ -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");
 
   }

diff --git a/src/GeomAdaptor/GeomAdaptor_Curve.cxx b/src/GeomAdaptor/GeomAdaptor_Curve.cxx
index cf6ca4f4f7e24db31eb37231089dbfb9114d39b1..215b3ce8a4deb74787f1f76518ff97bb4237666b 100644 (file)
--- a/src/GeomAdaptor/GeomAdaptor_Curve.cxx
+++ b/src/GeomAdaptor/GeomAdaptor_Curve.cxx
@@ -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);

diff --git a/src/HLRBRep/HLRBRep_Curve.cxx b/src/HLRBRep/HLRBRep_Curve.cxx
index 5ea765f7d5cff004965bfe2893ded457c34b0f8c..cf23bd9edd97a3bfacd0e397ea9b2bb6a2f17cac 100644 (file)
--- a/src/HLRBRep/HLRBRep_Curve.cxx
+++ b/src/HLRBRep/HLRBRep_Curve.cxx
@@ -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;
 }

diff --git a/src/IntCurve/IntCurve_IntCurveCurveGen.gxx b/src/IntCurve/IntCurve_IntCurveCurveGen.gxx
index c882ed98e17949f6b12367dcbe918dd616796468..6a3d98eabf5b219b9744e88aefcc8b388d20feca 100644 (file)
--- a/src/IntCurve/IntCurve_IntCurveCurveGen.gxx
+++ b/src/IntCurve/IntCurve_IntCurveCurveGen.gxx
@@ -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);

diff --git a/src/IntCurve/IntCurve_UserIntConicCurveGen.gxx b/src/IntCurve/IntCurve_UserIntConicCurveGen.gxx
index 3b24d38197d2a08e521499280ab47b2ccacdbed4..ed5478a9de9aea8d3d9e78503dbe2e8a4088d316 100644 (file)
--- a/src/IntCurve/IntCurve_UserIntConicCurveGen.gxx
+++ b/src/IntCurve/IntCurve_UserIntConicCurveGen.gxx
@@ -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,

diff --git a/src/IntTools/IntTools.cxx b/src/IntTools/IntTools.cxx
index ecaf16fd8348925e419dd508b1fcd848d73cd84a..b4d023318d285c24174892299443fbfc9660ba7d 100644 (file)
--- a/src/IntTools/IntTools.cxx
+++ b/src/IntTools/IntTools.cxx
@@ -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;

diff --git a/src/IntTools/IntTools_BeanFaceIntersector.cxx b/src/IntTools/IntTools_BeanFaceIntersector.cxx
index 5a925c96f71961d55bcaa1c2443bd79efe3fdda8..9c9f7be9c5590c3e5290b9f1372b2156bd7487cf 100644 (file)
--- a/src/IntTools/IntTools_BeanFaceIntersector.cxx
+++ b/src/IntTools/IntTools_BeanFaceIntersector.cxx
@@ -729,6 +729,7 @@ Standard_Integer IntTools_BeanFaceIntersector::FastComputeExactIntersection()
   //
   if((aCT==GeomAbs_BezierCurve) ||
      (aCT==GeomAbs_BSplineCurve) ||
+     (aCT==GeomAbs_OffsetCurve) ||
      (aCT==GeomAbs_OtherCurve)) {
     return aresult;
   }

diff --git a/src/IntTools/IntTools_EdgeEdge.cxx b/src/IntTools/IntTools_EdgeEdge.cxx
index 74cf87b7c6294204655c4c2cbcd5feaac1cce631..d9474f0401f8e2c6226e9ea7511946a9d6e8ea12 100644 (file)
--- a/src/IntTools/IntTools_EdgeEdge.cxx
+++ b/src/IntTools/IntTools_EdgeEdge.cxx
@@ -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;

diff --git a/src/ProjLib/ProjLib_ComputeApprox.cxx b/src/ProjLib/ProjLib_ComputeApprox.cxx
index 7b7ef7180fdefda2a7415df7382c001671fede96..894d7a8ab6b835bb287c004ab4571f7be6f6491a 100644 (file)
--- a/src/ProjLib/ProjLib_ComputeApprox.cxx
+++ b/src/ProjLib/ProjLib_ComputeApprox.cxx
@@ -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;

diff --git a/src/ProjLib/ProjLib_ProjectedCurve.cxx b/src/ProjLib/ProjLib_ProjectedCurve.cxx
index 625766b69aacc40067cc7dc9a8b8a2944efb6839..e78f04f9b81454a11f71616ee68c4edeab2a0d1e 100644 (file)
--- a/src/ProjLib/ProjLib_ProjectedCurve.cxx
+++ b/src/ProjLib/ProjLib_ProjectedCurve.cxx
@@ -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:

diff --git a/src/ShapeConstruct/ShapeConstruct_ProjectCurveOnSurface.cxx b/src/ShapeConstruct/ShapeConstruct_ProjectCurveOnSurface.cxx
index b20563e6243af71d474d76d20c9c09fbd8286d32..61053c7508be6031e07ab32d436ab88baaf05a2b 100644 (file)
--- a/src/ShapeConstruct/ShapeConstruct_ProjectCurveOnSurface.cxx
+++ b/src/ShapeConstruct/ShapeConstruct_ProjectCurveOnSurface.cxx
@@ -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;
     }

diff --git a/src/TestTopOpeDraw/TestTopOpeDraw_TTOT.cxx b/src/TestTopOpeDraw/TestTopOpeDraw_TTOT.cxx
index dd4ab1168a754e9813f927a9c546c00f9f2c963d..89d206d6dacd62c6e2e0ce6639a9bc24bc210411 100644 (file)
--- a/src/TestTopOpeDraw/TestTopOpeDraw_TTOT.cxx
+++ b/src/TestTopOpeDraw/TestTopOpeDraw_TTOT.cxx
@@ -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;  
   }

diff --git a/src/TopOpeBRepBuild/TopOpeBRepBuild_Griddump.cxx b/src/TopOpeBRepBuild/TopOpeBRepBuild_Griddump.cxx
index 586a164054f5530ab4854efa09df862378b5c669..1c99c504266f28e5de560df943485dd28671dc75 100644 (file)
--- a/src/TopOpeBRepBuild/TopOpeBRepBuild_Griddump.cxx
+++ b/src/TopOpeBRepBuild/TopOpeBRepBuild_Griddump.cxx
@@ -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();

diff --git a/src/TopOpeBRepTool/TopOpeBRepTool_CurveTool.cxx b/src/TopOpeBRepTool/TopOpeBRepTool_CurveTool.cxx
index b49113b2f3069d7c1a493fac0b5d10644a6a32b2..d66abadccb7a0626783b294dc0e89dfbf2dea5be 100644 (file)
--- a/src/TopOpeBRepTool/TopOpeBRepTool_CurveTool.cxx
+++ b/src/TopOpeBRepTool/TopOpeBRepTool_CurveTool.cxx
@@ -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;
   }