src/ShapeUpgrade/ShapeUpgrade_ShapeConvertToBezier.cxx

   1 // Created on: 1999-05-14
   2 // Created by: data exchange team
   3 // Copyright (c) 1999-1999 Matra Datavision
   4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
   5 //
   6 // The content of this file is subject to the Open CASCADE Technology Public
   7 // License Version 6.5 (the "License"). You may not use the content of this file
   8 // except in compliance with the License. Please obtain a copy of the License
   9 // at http://www.opencascade.org and read it completely before using this file.
  10 //
  11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  13 //
  14 // The Original Code and all software distributed under the License is
  15 // distributed on an "AS IS" basis, without warranty of any kind, and the
  16 // Initial Developer hereby disclaims all such warranties, including without
  17 // limitation, any warranties of merchantability, fitness for a particular
  18 // purpose or non-infringement. Please see the License for the specific terms
  19 // and conditions governing the rights and limitations under the License.
  20
  21 // 15.06 2000 gka fix against small edges ; merging ends pcurves and 3d curves
  22
  23
  24 #include <ShapeUpgrade_ShapeConvertToBezier.ixx>
  25 #include <ShapeUpgrade_WireDivide.hxx>
  26 #include <ShapeUpgrade_ConvertCurve3dToBezier.hxx>
  27 #include <ShapeUpgrade_ConvertCurve2dToBezier.hxx>
  28 #include <TopExp_Explorer.hxx>
  29 #include <TopoDS_Face.hxx>
  30 #include <TopoDS.hxx>
  31 #include <BRep_Builder.hxx>
  32 #include <ShapeAnalysis_Edge.hxx>
  33 #include <ShapeBuild_Edge.hxx>
  34 #include <Geom_Curve.hxx>
  35 #include <Geom_BezierCurve.hxx>
  36 #include <Precision.hxx>
  37 #include <Geom2d_Curve.hxx>
  38 #include <Geom2d_BezierCurve.hxx>
  39 #include <BRep_Tool.hxx>
  40 #include <GeomLib.hxx>
  41 #include <TopoDS_Edge.hxx>
  42 #include <ShapeUpgrade_ConvertSurfaceToBezierBasis.hxx>
  43 #include <TopExp.hxx>
  44 #include <TopExp.hxx>
  45 #include <gp_Pnt2d.hxx>
  46 #include <gp_Pnt.hxx>
  47 #include <ShapeFix_Wire.hxx>
  48 #include <ShapeExtend_WireData.hxx>
  49 #include <TopoDS_Vertex.hxx>
  50 #include <ShapeUpgrade_FixSmallBezierCurves.hxx>
  51 #include <ShapeUpgrade_FixSmallBezierCurves.hxx>
  52 #include <ShapeUpgrade_FixSmallBezierCurves.hxx>
  53 #include <BRepTools.hxx>
  54
  55 //=======================================================================
  56 //function : ShapeUpgrade_ShapeConvertToBezier
  57 //purpose  :
  58 //=======================================================================
  59
  60 ShapeUpgrade_ShapeConvertToBezier::ShapeUpgrade_ShapeConvertToBezier()
  61 {
  62   myLevel = 0;
  63   my2dMode = Standard_False;
  64   my3dMode = Standard_False;
  65   mySurfaceMode = Standard_False;
  66   //set spesial flags to true
  67   my3dLineMode = Standard_True;
  68   my3dCircleMode = Standard_True;
  69   my3dConicMode = Standard_True;
  70   myPlaneMode      = Standard_True;
  71   myRevolutionMode = Standard_True;
  72   myExtrusionMode  = Standard_True;
  73   myBSplineMode    = Standard_True;
  74 }
  75
  76 //=======================================================================
  77 //function : ShapeUpgrade_ShapeConvertToBezier
  78 //purpose  :
  79 //=======================================================================
  80
  81 ShapeUpgrade_ShapeConvertToBezier::ShapeUpgrade_ShapeConvertToBezier(const TopoDS_Shape& S):
  82        ShapeUpgrade_ShapeDivide(S)
  83 {
  84   myLevel = 0;
  85   my2dMode = Standard_False;
  86   my3dMode = Standard_False;
  87   mySurfaceMode = Standard_False;
  88   //set spesial flags to true
  89   my3dLineMode = Standard_True;
  90   my3dCircleMode = Standard_True;
  91   my3dConicMode = Standard_True;
  92   myPlaneMode      = Standard_True;
  93   myRevolutionMode = Standard_True;
  94   myExtrusionMode  = Standard_True;
  95   myBSplineMode    = Standard_True;
  96 }
  97
  98 //=======================================================================
  99 //function : Perform
 100 //purpose  :
 101 //=======================================================================
 102
 103 Standard_Boolean ShapeUpgrade_ShapeConvertToBezier::Perform (const Standard_Boolean newContext)
 104 {
 105   myLevel++;
 106
 107   Standard_Boolean res = Standard_False;
 108   if ( myLevel ==1 ) {
 109     Standard_Boolean isNewContext = newContext;
 110     if ( mySurfaceMode ) {
 111       Standard_Boolean mode2d = my2dMode, mode3d = my3dMode;
 112       my2dMode = my3dMode = Standard_False;
 113       res = ShapeUpgrade_ShapeDivide::Perform(isNewContext);
 114       isNewContext = Standard_False;
 115       myShape = myResult;
 116       my2dMode = mode2d;
 117       my3dMode = mode3d;
 118     }
 119     if ( my2dMode || my3dMode ) {
 120       Standard_Boolean modeS = mySurfaceMode;
 121       mySurfaceMode = Standard_False;
 122       res = ShapeUpgrade_ShapeDivide::Perform(isNewContext);
 123       mySurfaceMode = modeS;
 124     }
 125   }
 126   else res = ShapeUpgrade_ShapeDivide::Perform(newContext);
 127   //pdn Hereafter the fix on GeomLib:SameParameter.
 128   //In order to fix this bug all edges that are based on
 129   //bezier curves (2d or 3d) and have range not equal to [0,1]
 130   //are performed the following sequence:
 131   // 1. Segment on bezier curve
 132   // 2. Changing rande of edge to [0,1]
 133   if(myLevel == 1) {
 134     BRep_Builder B;
 135     ShapeAnalysis_Edge sae;
 136     ShapeBuild_Edge sbe;
 137     Standard_Real preci = Precision::PConfusion();
 138     for(TopExp_Explorer exp(myResult,TopAbs_FACE); exp.More(); exp.Next()) {
 139       TopoDS_Face face = TopoDS::Face(exp.Current());
 140       face.Orientation(TopAbs_FORWARD);
 141       for(TopExp_Explorer exp1(face, TopAbs_WIRE); exp1.More(); exp1.Next()) {
 142         TopoDS_Wire wire= TopoDS::Wire(exp1.Current());
 143         Handle(ShapeFix_Wire) sfw = new ShapeFix_Wire(wire,face,myPrecision);
 144         sfw->FixReorder();
 145         sfw->FixShifted(); // for cylinders.brep
 146         Handle(ShapeExtend_WireData) sewd = sfw->WireData();
 147         for(Standard_Integer i =1; i <= sewd->NbEdges(); i++) {
 148           TopoDS_Edge edge = sewd->Edge(i);
 149           //TopoDS_Edge edge = TopoDS::Edge(exp1.Current());
 150           Handle(Geom_Curve) c3d;
 151           Standard_Real first, last;
 152           TopoDS_Vertex V1,V2;
 153           TopExp::Vertices(edge,V1,V2);
 154           if(sae.Curve3d(edge,c3d,first,last,Standard_False)) {
 155             if(c3d->IsKind(STANDARD_TYPE(Geom_BezierCurve))) {
 156               //B.SameRange(edge, Standard_False);
 157               Handle(Geom_BezierCurve) bezier = Handle(Geom_BezierCurve)::DownCast(c3d);
 158               if(first!= 0 || last !=1) {
 159                 if(first > preci || last < 1 - preci) {
 160                   bezier->Segment(first,last);
 161                   B.UpdateEdge(edge,bezier,0.);
 162                 }
 163                 sbe.SetRange3d(edge,0,1);
 164               }
 165               if(!bezier.IsNull()) { //gka fix against small edges ; merging ends of 3d curves
 166                 gp_Pnt p1 = bezier->Value(first);
 167                 gp_Pnt p2 = bezier->Value(last);
 168                 gp_Pnt p1v = BRep_Tool::Pnt(V1);
 169                 gp_Pnt p2v = BRep_Tool::Pnt(V2);
 170                 if(p1.Distance(p1v) > Precision::Confusion())
 171                   bezier->SetPole(1,p1v);
 172                 if(p2.Distance(p2v) > Precision::Confusion())
 173                   bezier->SetPole(bezier->NbPoles(),p2v);
 174                 B.UpdateEdge(edge,bezier,0.);
 175               }
 176             }
 177             else if(my2dMode)
 178               B.SameRange(edge, Standard_True);
 179           }
 180           Handle(Geom2d_Curve) c2d,c2drev;
 181           Handle(Geom2d_BezierCurve) bezier,bezierR;
 182           Standard_Boolean isSeam = BRep_Tool::IsClosed ( edge, face );
 183           if(!sae.PCurve(edge,face,c2d,first,last,Standard_False)) continue ;
 184           if(!c2d->IsKind(STANDARD_TYPE(Geom2d_BezierCurve))) continue;
 185           Handle(Geom2d_Curve) newRevCurve,newCurve;
 186           bezier = Handle(Geom2d_BezierCurve)::DownCast(c2d);
 187           if(isSeam) {
 188            TopoDS_Shape aLocalShape = edge.Reversed();
 189            TopoDS_Edge tmpedge = TopoDS::Edge(aLocalShape);
 190 //         TopoDS_Edge tmpedge = TopoDS::Edge(edge.Reversed());
 191            if(sae.PCurve(tmpedge,face,c2drev,first,last,Standard_False)) {
 192               if(c2drev->IsKind(STANDARD_TYPE(Geom2d_BezierCurve))) {
 193                 bezierR = Handle(Geom2d_BezierCurve)::DownCast(c2drev);
 194               }
 195             }
 196          }
 197           if(first!= 0 || last !=1) {
 198             if(first > preci || last < 1 - preci) {
 199               if(!bezier.IsNull()) {
 200                 bezier->Segment(first,last);
 201                 newCurve = bezier;
 202               }
 203               else
 204                 GeomLib::SameRange(preci, c2d, first, last, 0, 1, newCurve);
 205               if(isSeam) {
 206                 if(!bezierR.IsNull()) {
 207                   bezierR->Segment(first, last);
 208                   newRevCurve = bezierR;
 209                 }
 210                 else if(!c2drev.IsNull())
 211                   GeomLib::SameRange(preci, c2drev, first, last, 0, 1, newRevCurve);
 212                 if(edge.Orientation()==TopAbs_FORWARD)
 213                   B.UpdateEdge ( edge, newCurve, newRevCurve, face, 0. );
 214                 else
 215                   B.UpdateEdge ( edge, newRevCurve, newCurve, face, 0. );
 216               }
 217             }
 218             B.Range(edge,face,0,1);
 219           }
 220
 221
 222           TopoDS_Edge edgenext = sewd->Edge((i == sewd->NbEdges() ? 1 : i+1));
 223           Handle(Geom2d_Curve) c2dnext,c2drevnext,newnextCurve;
 224           Standard_Real first2,last2;
 225           Handle(Geom2d_BezierCurve) beziernext,bezierRnext;
 226           if(!sae.PCurve(edgenext,face,c2dnext,first2,last2,Standard_False)) continue ;
 227           if(!c2dnext->IsKind(STANDARD_TYPE(Geom2d_BezierCurve)) ) continue;
 228              beziernext = Handle(Geom2d_BezierCurve)::DownCast(c2dnext);
 229           //Handle(Geom2d_Curve) newRevCurve;
 230           if(isSeam) {
 231             TopoDS_Shape aLocalShape = edgenext.Reversed();
 232             TopoDS_Edge tmpedge = TopoDS::Edge(aLocalShape);
 233 //          TopoDS_Edge tmpedge = TopoDS::Edge(edgenext.Reversed());
 234             if(sae.PCurve(tmpedge,face,c2drevnext,first,last,Standard_False)) {
 235               if(c2drevnext->IsKind(STANDARD_TYPE(Geom2d_BezierCurve))) {
 236                 bezierRnext = Handle(Geom2d_BezierCurve)::DownCast(c2drevnext);
 237               }
 238            }
 239           }
 240           if(first2!= 0 || last2 !=1) {
 241             if(first2 > preci || last2 < 1 - preci) {
 242              if(!beziernext.IsNull()) {
 243                beziernext->Segment(first2,last2);
 244                newnextCurve = beziernext;
 245              }
 246              else
 247                GeomLib::SameRange(preci, c2dnext, first2, last2, 0, 1, newnextCurve);
 248               if(isSeam) {
 249                 if(!bezierRnext.IsNull()) {
 250                   bezierRnext->Segment(first2, last2);
 251                   newRevCurve = bezierRnext;
 252                 }
 253                 else if(!c2drevnext.IsNull())
 254                   GeomLib::SameRange(preci, c2drevnext, first2, last2, 0, 1, newRevCurve);
 255                 if(edge.Orientation()==TopAbs_FORWARD)
 256                   B.UpdateEdge ( edgenext, newnextCurve, newRevCurve, face, 0. );
 257                 else
 258                   B.UpdateEdge ( edgenext, newRevCurve, newnextCurve, face, 0. );
 259               }
 260            }
 261             B.Range(edgenext,face,0,1);
 262           }
 263
 264           if(bezier.IsNull()  || beziernext.IsNull() ) continue; //gka fix against small edges ; merging ends of pcurves
 265           Standard_Real f1,l1,f2,l2;
 266           f1 = bezier->FirstParameter();
 267           l1 = bezier->LastParameter();
 268           f2 = beziernext->FirstParameter();
 269           l2 = beziernext->LastParameter();
 270           gp_Pnt2d p2d1 = bezier->Value(f1);
 271           gp_Pnt2d p2d2 = bezier->Value(l1);
 272           gp_Pnt2d p2d1next = beziernext->Value(f2);
 273           gp_Pnt2d p2d2next = beziernext->Value(l2);
 274           if(edge.Orientation() == TopAbs_FORWARD && edgenext.Orientation() == TopAbs_FORWARD) {
 275             if(p2d2.Distance(p2d1next) > Precision::PConfusion()) {
 276               gp_Pnt2d pmid = 0.5*(p2d2.XY() + p2d1next.XY());
 277 //            gp_Pnt2d p1 =  bezier->Pole(bezier->NbPoles());
 278 //            gp_Pnt2d p2 =  beziernext->Pole(1);
 279               bezier->SetPole(bezier->NbPoles(),pmid);
 280               beziernext->SetPole(1,pmid);
 281             }
 282           }
 283           if(edge.Orientation() == TopAbs_FORWARD && edgenext.Orientation() == TopAbs_REVERSED) {
 284             if(p2d2.Distance(p2d2next) > Precision::PConfusion()) {
 285               gp_Pnt2d pmid = 0.5*(p2d2.XY() + p2d2next.XY());
 286 //            gp_Pnt2d p1 =  bezier->Pole(bezier->NbPoles());
 287 //            gp_Pnt2d p2 =  beziernext->Pole(beziernext->NbPoles());
 288               bezier->SetPole(bezier->NbPoles(),pmid);
 289               beziernext->SetPole(beziernext->NbPoles(),pmid);
 290             }
 291           }
 292           if(edge.Orientation() == TopAbs_REVERSED && edgenext.Orientation() == TopAbs_FORWARD) {
 293             if(p2d1.Distance(p2d1next) > Precision::PConfusion()) {
 294               gp_Pnt2d pmid = 0.5*(p2d1.XY() + p2d1next.XY());
 295 //            gp_Pnt2d p1 =  bezier->Pole(1);
 296 //            gp_Pnt2d p2 =  beziernext->Pole(1);
 297               bezier->SetPole(1,pmid);
 298               beziernext->SetPole(1,pmid);
 299             }
 300           }
 301           if(edge.Orientation() == TopAbs_REVERSED && edgenext.Orientation() == TopAbs_REVERSED) {
 302             if(p2d1.Distance(p2d2next) > Precision::PConfusion()) {
 303               gp_Pnt2d pmid = 0.5*(p2d1.XY() + p2d2next.XY());
 304 //            gp_Pnt2d p1 =  bezier->Pole(1);
 305 //            gp_Pnt2d p2 =  beziernext->Pole(beziernext->NbPoles());
 306               bezier->SetPole(1,pmid);
 307               beziernext->SetPole(beziernext->NbPoles(),pmid);
 308             }
 309           }
 310
 311         }
 312         BRepTools::Update(face);
 313       }
 314     }
 315
 316   }
 317
 318   myLevel--;
 319
 320   return res;
 321 }
 322
 323 //=======================================================================
 324 //function : GetSplitFaceTool
 325 //purpose  :
 326 //=======================================================================
 327
 328 Handle(ShapeUpgrade_FaceDivide) ShapeUpgrade_ShapeConvertToBezier::GetSplitFaceTool() const
 329 {
 330   Handle(ShapeUpgrade_FaceDivide) tool = new ShapeUpgrade_FaceDivide;
 331   Handle(ShapeUpgrade_WireDivide) wtool = new ShapeUpgrade_WireDivide;
 332   if(my3dMode) {
 333     Handle(ShapeUpgrade_ConvertCurve3dToBezier) curve3dConverter = new ShapeUpgrade_ConvertCurve3dToBezier;
 334     curve3dConverter->SetLineMode(my3dLineMode);
 335     curve3dConverter->SetCircleMode(my3dCircleMode);
 336     curve3dConverter->SetConicMode(my3dConicMode);
 337     wtool->SetSplitCurve3dTool(curve3dConverter);
 338   }
 339   if(my2dMode)
 340     wtool->SetSplitCurve2dTool(new ShapeUpgrade_ConvertCurve2dToBezier);
 341   wtool->SetEdgeMode(myEdgeMode);
 342   Handle(ShapeUpgrade_FixSmallBezierCurves) FixSmallBezierCurvesTool = new ShapeUpgrade_FixSmallBezierCurves;
 343   wtool->SetFixSmallCurveTool(FixSmallBezierCurvesTool);
 344   tool->SetWireDivideTool(wtool);
 345   if(mySurfaceMode) {
 346     Handle(ShapeUpgrade_ConvertSurfaceToBezierBasis) stool = new ShapeUpgrade_ConvertSurfaceToBezierBasis;
 347     stool->SetPlaneMode(myPlaneMode);
 348     stool->SetRevolutionMode(myRevolutionMode);
 349     stool->SetExtrusionMode(myExtrusionMode);
 350     stool->SetBSplineMode(myBSplineMode);
 351     tool->SetSplitSurfaceTool(stool);
 352   }
 353   return tool;
 354 }
 355