0026254: Inject GeomAbs_OffsetCurve into GeomAbs_CurveType enumeration
authorazv <azv@opencascade.com>
Wed, 7 Oct 2015 06:13:19 +0000 (09:13 +0300)
committerbugmaster <bugmaster@opencascade.com>
Thu, 22 Oct 2015 07:36:57 +0000 (10:36 +0300)
29 files changed:
src/BOPTools/BOPTools_AlgoTools_2.cxx
src/BRepAlgo/BRepAlgo.cxx
src/BRepFill/BRepFill_TrimSurfaceTool.cxx
src/BRepMAT2d/BRepMAT2d_Explorer.cxx
src/DBRep/DBRep_DrawableShape.cxx
src/DrawTrSurf/DrawTrSurf_Drawable.cxx
src/Extrema/Extrema_ExtCC2d.cxx
src/Extrema/Extrema_FuncExtCC.gxx
src/Extrema/Extrema_FuncExtPC.gxx
src/Extrema/Extrema_GExtPC.gxx
src/Extrema/Extrema_GLocateExtPC.gxx
src/Geom2dAdaptor/Geom2dAdaptor.cxx
src/Geom2dAdaptor/Geom2dAdaptor_Curve.cxx
src/GeomAPI/GeomAPI.cxx
src/GeomAbs/GeomAbs_CurveType.hxx
src/GeomAdaptor/GeomAdaptor.cxx
src/GeomAdaptor/GeomAdaptor_Curve.cxx
src/HLRBRep/HLRBRep_Curve.cxx
src/IntCurve/IntCurve_IntCurveCurveGen.gxx
src/IntCurve/IntCurve_UserIntConicCurveGen.gxx
src/IntTools/IntTools.cxx
src/IntTools/IntTools_BeanFaceIntersector.cxx
src/IntTools/IntTools_EdgeEdge.cxx
src/ProjLib/ProjLib_ComputeApprox.cxx
src/ProjLib/ProjLib_ProjectedCurve.cxx
src/ShapeConstruct/ShapeConstruct_ProjectCurveOnSurface.cxx
src/TestTopOpeDraw/TestTopOpeDraw_TTOT.cxx
src/TopOpeBRepBuild/TopOpeBRepBuild_Griddump.cxx
src/TopOpeBRepTool/TopOpeBRepTool_CurveTool.cxx

index cac1dc5..8dd8716 100644 (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){
index b6a7cbd..a6bdf8a 100644 (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:
             {
index 583e6c7..1f20fc6 100644 (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);
index ca8d20f..662a0cd 100644 (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;
   }
index 36e7b65..fae127c 100644 (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);
index 26bf6d9..1c652f0 100644 (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++)
index cf93af4..957a044 100644 (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;
+
   };
     
 }
index 7f98b46..3c1134d 100644 (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);
index 3470791..a79915d 100644 (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();
index 7fdee75..400491b 100644 (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
index ed75c96..5f9a911 100644 (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);
index 37d9908..87bb50a 100644 (file)
@@ -89,7 +89,7 @@ Handle(Geom2d_Curve) Geom2dAdaptor::MakeCurve
     }
     break;
     
-  case GeomAbs_OtherCurve:
+  default:
     Standard_DomainError::Raise("Geom2dAdaptor::MakeCurve, OtherCurve");
 
   }
index a956cb9..5a9b933 100644 (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);
index 8c1a59f..24ab87a 100644 (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);
   }
   
index 40add03..3b9e3aa 100644 (file)
@@ -28,6 +28,7 @@ GeomAbs_Hyperbola,
 GeomAbs_Parabola,
 GeomAbs_BezierCurve,
 GeomAbs_BSplineCurve,
+GeomAbs_OffsetCurve,
 GeomAbs_OtherCurve
 };
 
index 7880502..58b15d0 100644 (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");
 
   }
index cf6ca4f..215b3ce 100644 (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);
index 5ea765f..cf23bd9 100644 (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;
 }
index c882ed9..6a3d98e 100644 (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);
index 3b24d38..ed5478a 100644 (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,
index ecaf16f..b4d0233 100644 (file)
     }
     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;
index 5a925c9..9c9f7be 100644 (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;
   }
index 74cf87b..d9474f0 100644 (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;
index 7b7ef71..894d7a8 100644 (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;
index 625766b..e78f04f 100644 (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:
index b20563e..61053c7 100644 (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;
     }
index dd4ab11..89d206d 100644 (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;  
   }
index 586a164..1c99c50 100644 (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();
index b49113b..d66abad 100644 (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;
   }