src/ChFi2d/ChFi2d_Builder_0.cxx

   1 // Created on: 1995-07-07
   2 // Created by: Joelle CHAUVET
   3 // Copyright (c) 1995-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17 // Modified : 08/07/97 : JPI : traitement des edges degeneres comme pour les fillets 2D
  18 // Modified:    Fri Sep 25 09:38:04 1998
  19 //              status = ChFi2d_NotAuthorized si les aretes ne sont pas
  20 //              des droites ou des cercles; fonction IsLineOrCircle
  21 //              (BUC60288)
  22
  23 #include <BRep_Builder.hxx>
  24 #include <BRep_Tool.hxx>
  25 #include <BRepAdaptor_Curve.hxx>
  26 #include <BRepAdaptor_Surface.hxx>
  27 #include <BRepLib_MakeEdge.hxx>
  28 #include <BRepLib_MakeFace.hxx>
  29 #include <ChFi2d.hxx>
  30 #include <ChFi2d_Builder.hxx>
  31 #include <ElCLib.hxx>
  32 #include <GCPnts_AbscissaPoint.hxx>
  33 #include <Geom2d_Circle.hxx>
  34 #include <Geom2d_Curve.hxx>
  35 #include <Geom2d_Line.hxx>
  36 #include <Geom2d_TrimmedCurve.hxx>
  37 #include <Geom2dAdaptor_Curve.hxx>
  38 #include <Geom2dInt_GInter.hxx>
  39 #include <Geom_Curve.hxx>
  40 #include <Geom_Line.hxx>
  41 #include <Geom_Plane.hxx>
  42 #include <Geom_Surface.hxx>
  43 #include <GeomAdaptor_Curve.hxx>
  44 #include <GeomAPI.hxx>
  45 #include <gp_Pln.hxx>
  46 #include <gp_Pnt.hxx>
  47 #include <gp_Pnt2d.hxx>
  48 #include <IntRes2d_IntersectionPoint.hxx>
  49 #include <Precision.hxx>
  50 #include <TopAbs_Orientation.hxx>
  51 #include <TopExp.hxx>
  52 #include <TopExp_Explorer.hxx>
  53 #include <TopLoc_Location.hxx>
  54 #include <TopoDS.hxx>
  55 #include <TopoDS_Edge.hxx>
  56 #include <TopoDS_Face.hxx>
  57 #include <TopoDS_Shape.hxx>
  58 #include <TopoDS_Vertex.hxx>
  59 #include <TopoDS_Wire.hxx>
  60
  61 gp_Pnt ComputePoint(const TopoDS_Vertex& V,const TopoDS_Edge& E,
  62                     const Standard_Real D1, Standard_Real& Param1);
  63 gp_Pnt ComputePoint(const TopoDS_Face& F, const Handle(Geom_Line)& L,
  64                     const TopoDS_Edge& E, Standard_Real& Param);
  65 void OrientChamfer(TopoDS_Edge& chamfer,
  66                    const TopoDS_Edge& E,
  67                    const TopoDS_Vertex& V);
  68
  69 static Standard_Boolean IsLineOrCircle(const TopoDS_Edge& E,
  70                                        const TopoDS_Face& F);
  71
  72
  73 //=======================================================================
  74 //function : AddChamfer
  75 //purpose  :
  76 //=======================================================================
  77
  78 TopoDS_Edge ChFi2d_Builder::AddChamfer(const TopoDS_Edge& E1,
  79                                      const TopoDS_Edge& E2,
  80                                      const Standard_Real D1,
  81                                      const Standard_Real D2)
  82 {
  83   TopoDS_Vertex commonVertex;
  84   TopoDS_Edge basisEdge1, basisEdge2;
  85   TopoDS_Edge E1Mod, E2Mod, chamfer;
  86
  87   Standard_Boolean hasConnection = ChFi2d::CommonVertex(E1, E2, commonVertex);
  88   if (!hasConnection) return chamfer;
  89
  90   if (IsAFillet(E1) || IsAChamfer(E1) ||
  91       IsAFillet(E2) || IsAChamfer(E2)) {
  92     status = ChFi2d_NotAuthorized;
  93     return chamfer;
  94   } //  if (IsAChamfer ...
  95
  96   if (!IsLineOrCircle(E1,newFace)
  97       || !IsLineOrCircle(E2,newFace) ) {
  98     status = ChFi2d_NotAuthorized;
  99     return chamfer;
 100   } //  if (!IsLineOrCircle ...
 101
 102   // EE1 and EE2 are copies of E1 and E2 with the good orientation
 103   // on <newFace>
 104   TopoDS_Edge EE1, EE2;
 105   status = ChFi2d::FindConnectedEdges(newFace, commonVertex, EE1, EE2);
 106   if (EE1.IsSame(E2)) {
 107     TopAbs_Orientation orient = EE1.Orientation();
 108     EE1 = EE2;
 109     EE2 = E2;
 110     EE2.Orientation(orient);
 111   }
 112
 113   ComputeChamfer(commonVertex, EE1, EE2, D1, D2,
 114                  E1Mod, E2Mod, chamfer);
 115   if (status == ChFi2d_IsDone
 116       || status == ChFi2d_FirstEdgeDegenerated
 117       || status == ChFi2d_LastEdgeDegenerated
 118       || status == ChFi2d_BothEdgesDegenerated) {
 119 //  if (status == ChFi2d_IsDone) {
 120     BuildNewWire(EE1, EE2, E1Mod, chamfer, E2Mod);
 121     basisEdge1 = BasisEdge(EE1);
 122     basisEdge2 = BasisEdge(EE2);
 123     UpDateHistory(basisEdge1, basisEdge2,
 124                   E1Mod, E2Mod, chamfer, 2);
 125     status = ChFi2d_IsDone;
 126     return TopoDS::Edge(chamfers.Value(chamfers.Length()));
 127   }
 128   return chamfer;
 129 } // AddChamfer
 130
 131
 132 //=======================================================================
 133 //function : AddChamfer
 134 //purpose  :
 135 //=======================================================================
 136
 137 TopoDS_Edge ChFi2d_Builder::AddChamfer(const TopoDS_Edge& E,
 138                                      const TopoDS_Vertex& V,
 139                                      const Standard_Real D,
 140                                      const Standard_Real Ang)
 141 {
 142   TopoDS_Edge aChamfer, adjEdge1, adjEdge2;
 143   status = ChFi2d::FindConnectedEdges(newFace, V, adjEdge1, adjEdge2);
 144   if (status == ChFi2d_ConnexionError) return aChamfer;
 145
 146   // adjEdge1 is a copy of E  with the good orientation
 147   // on <newFace>
 148   if (adjEdge2.IsSame(E)) {
 149     TopAbs_Orientation orient = adjEdge2.Orientation();
 150     adjEdge2 = adjEdge1;
 151     adjEdge1 = E;
 152     adjEdge1.Orientation(orient);
 153   }
 154
 155   if (IsAFillet(adjEdge1) || IsAChamfer(adjEdge1) ||
 156       IsAFillet(adjEdge2) || IsAChamfer(adjEdge2)) {
 157     status = ChFi2d_NotAuthorized;
 158     return aChamfer;
 159   } //  if (IsAChamfer ...
 160
 161   if (!IsLineOrCircle(adjEdge1,newFace)
 162       || !IsLineOrCircle(adjEdge2,newFace) ) {
 163     status = ChFi2d_NotAuthorized;
 164     return aChamfer;
 165   } //  if (!IsLineOrCircle ...
 166
 167   TopoDS_Edge E1, E2;
 168   ComputeChamfer(V, adjEdge1, D, Ang,
 169                  adjEdge2, E1, E2, aChamfer);
 170   TopoDS_Edge basisEdge1, basisEdge2;
 171   if (status == ChFi2d_IsDone
 172       || status == ChFi2d_FirstEdgeDegenerated
 173       || status == ChFi2d_LastEdgeDegenerated
 174       || status == ChFi2d_BothEdgesDegenerated) {
 175 //  if (status == ChFi2d_IsDone) {
 176     BuildNewWire(adjEdge1, adjEdge2, E1, aChamfer, E2);
 177     basisEdge1 = BasisEdge(adjEdge1);
 178     basisEdge2 = BasisEdge(adjEdge2);
 179     UpDateHistory(basisEdge1, basisEdge2,
 180                   E1, E2, aChamfer, 2);
 181     status = ChFi2d_IsDone;
 182     return TopoDS::Edge(chamfers.Value(chamfers.Length()));
 183   }
 184   return aChamfer;
 185
 186 }
 187
 188
 189 //=======================================================================
 190 //function : ComputeChamfer
 191 //purpose  :
 192 //=======================================================================
 193
 194 void ChFi2d_Builder::ComputeChamfer(const TopoDS_Vertex& V,
 195                                   const TopoDS_Edge& E1,
 196                                   const TopoDS_Edge& E2,
 197                                   const Standard_Real D1,
 198                                   const Standard_Real D2,
 199                                   TopoDS_Edge& TrimE1,
 200                                   TopoDS_Edge& TrimE2,
 201                                   TopoDS_Edge& Chamfer)
 202 {
 203    TopoDS_Vertex newExtr1, newExtr2;
 204    Standard_Boolean Degen1, Degen2;
 205    Chamfer = BuildChamferEdge(V, E1, E2, D1, D2, newExtr1, newExtr2);
 206    if ( status != ChFi2d_IsDone) return;
 207   TrimE1 = BuildNewEdge(E1, V, newExtr1, Degen1);
 208   TrimE2 = BuildNewEdge(E2, V, newExtr2, Degen2);
 209   if (Degen1 && Degen2 ) status = ChFi2d_BothEdgesDegenerated;
 210   if (Degen1 && !Degen2 ) status = ChFi2d_FirstEdgeDegenerated;
 211   if (!Degen1 && Degen2 ) status = ChFi2d_LastEdgeDegenerated;
 212 //   TrimE1 = BuildNewEdge(E1, V, newExtr1);
 213 //  TrimE2 = BuildNewEdge(E2, V, newExtr2);
 214 } // ComputeChamfer
 215
 216
 217 //=======================================================================
 218 //function : ComputeChamfer
 219 //purpose  :
 220 //=======================================================================
 221
 222 void ChFi2d_Builder::ComputeChamfer(const TopoDS_Vertex& V,
 223                                   const TopoDS_Edge& E1,
 224                                   const Standard_Real D,
 225                                   const Standard_Real Ang,
 226                                   const TopoDS_Edge& E2,
 227                                   TopoDS_Edge& TrimE1,
 228                                   TopoDS_Edge& TrimE2,
 229                                   TopoDS_Edge& Chamfer)
 230 {
 231    TopoDS_Vertex newExtr1, newExtr2;
 232    Standard_Boolean Degen1, Degen2;
 233    Chamfer = BuildChamferEdge(V, E1, D, Ang, E2, newExtr1, newExtr2);
 234    if ( status != ChFi2d_IsDone) return;
 235   TrimE1 = BuildNewEdge(E1, V, newExtr1, Degen1);
 236   TrimE2 = BuildNewEdge(E2, V, newExtr2, Degen2);
 237   if (Degen1 && Degen2 ) status = ChFi2d_BothEdgesDegenerated;
 238   if (Degen1 && !Degen2 ) status = ChFi2d_FirstEdgeDegenerated;
 239   if (!Degen1 && Degen2 ) status = ChFi2d_LastEdgeDegenerated;
 240 //   TrimE1 = BuildNewEdge(E1, V, newExtr1);
 241 //   TrimE2 = BuildNewEdge(E2, V, newExtr2);
 242 } // ComputeChamfer
 243
 244
 245 //=======================================================================
 246 //function : ModifyFillet
 247 //purpose  :
 248 //=======================================================================
 249
 250 TopoDS_Edge ChFi2d_Builder::ModifyChamfer(const TopoDS_Edge& Chamfer,
 251                                         const TopoDS_Edge& /*E1*/,
 252                                         const TopoDS_Edge& E2,
 253                                         const Standard_Real D1,
 254                                         const Standard_Real D2)
 255 {
 256   TopoDS_Vertex aVertex = RemoveChamfer(Chamfer);
 257   TopoDS_Edge adjEdge1, adjEdge2;
 258   status = ChFi2d::FindConnectedEdges(newFace, aVertex, adjEdge1, adjEdge2);
 259   TopoDS_Edge aChamfer;
 260   if (status == ChFi2d_ConnexionError) return aChamfer;
 261
 262   // adjEdge1 and adjEdge2 are copies of E1 and E2 with the good orientation
 263   // on <newFace>
 264   if (adjEdge1.IsSame(E2)) {
 265     TopAbs_Orientation orient = adjEdge1.Orientation();
 266     adjEdge1 = adjEdge2;
 267     adjEdge2 = E2;
 268     adjEdge2.Orientation(orient);
 269   }
 270
 271   aChamfer = AddChamfer(adjEdge1, adjEdge2, D1, D2);
 272   return aChamfer;
 273 } // ModifyChamfer
 274
 275
 276 //=======================================================================
 277 //function : ModifyFillet
 278 //purpose  :
 279 //=======================================================================
 280
 281 TopoDS_Edge ChFi2d_Builder::ModifyChamfer(const TopoDS_Edge& Chamfer,
 282                                         const TopoDS_Edge& E,
 283                                         const Standard_Real D,
 284                                         const Standard_Real Ang)
 285 {
 286   TopoDS_Vertex aVertex = RemoveChamfer(Chamfer);
 287   TopoDS_Edge adjEdge1, adjEdge2;
 288   status = ChFi2d::FindConnectedEdges(newFace, aVertex, adjEdge1, adjEdge2);
 289   TopoDS_Edge aChamfer;
 290   if (status == ChFi2d_ConnexionError) return aChamfer;
 291
 292   if (adjEdge1.IsSame(E))
 293     aChamfer = AddChamfer(adjEdge1, aVertex, D, Ang);
 294   else aChamfer = AddChamfer(adjEdge2, aVertex, D, Ang);
 295   return aChamfer;
 296 } // ModifyChamfer
 297
 298
 299 //=======================================================================
 300 //function : RemoveChamfer
 301 //purpose  :
 302 //=======================================================================
 303
 304 TopoDS_Vertex ChFi2d_Builder::RemoveChamfer(const TopoDS_Edge& Chamfer)
 305 {
 306   TopoDS_Vertex commonVertex;
 307
 308   Standard_Integer i = 1;
 309   Standard_Integer IsFind = Standard_False;
 310   while (i <= chamfers.Length()) {
 311     const TopoDS_Edge& aChamfer = TopoDS::Edge(chamfers.Value(i));
 312     if (aChamfer.IsSame(Chamfer)) {
 313       chamfers.Remove(i);
 314       IsFind = Standard_True;
 315       break;
 316     }
 317     i++;
 318   }
 319   if (!IsFind) return commonVertex;
 320
 321   TopoDS_Vertex firstVertex, lastVertex;
 322   TopExp::Vertices(Chamfer, firstVertex, lastVertex);
 323
 324
 325   TopoDS_Edge adjEdge1, adjEdge2;
 326   status = ChFi2d::FindConnectedEdges(newFace, firstVertex,
 327                                      adjEdge1, adjEdge2);
 328   if (status == ChFi2d_ConnexionError) return commonVertex;
 329
 330   TopoDS_Edge basisEdge1, basisEdge2, E1, E2;
 331   // E1 and E2 are the adjacentes edges to Chamfer
 332
 333   if (adjEdge1.IsSame(Chamfer)) E1 = adjEdge2;
 334   else E1 = adjEdge1;
 335   basisEdge1 = BasisEdge(E1);
 336   status = ChFi2d::FindConnectedEdges(newFace, lastVertex,adjEdge1, adjEdge2);
 337   if (status == ChFi2d_ConnexionError) return commonVertex;
 338   if (adjEdge1.IsSame(Chamfer)) E2 = adjEdge2;
 339   else E2 = adjEdge1;
 340   basisEdge2 = BasisEdge(E2);
 341   TopoDS_Vertex connectionE1Chamfer, connectionE2Chamfer;
 342   Standard_Boolean hasConnection =
 343     ChFi2d::CommonVertex(basisEdge1, basisEdge2, commonVertex);
 344   if (!hasConnection) {
 345     status = ChFi2d_ConnexionError;
 346     return commonVertex;
 347   }
 348   hasConnection = ChFi2d::CommonVertex(E1, Chamfer, connectionE1Chamfer);
 349   if (!hasConnection) {
 350     status = ChFi2d_ConnexionError;
 351     return commonVertex;
 352   }
 353   hasConnection = ChFi2d::CommonVertex(E2, Chamfer, connectionE2Chamfer);
 354   if (!hasConnection) {
 355     status = ChFi2d_ConnexionError;
 356     return commonVertex;
 357   }
 358
 359   // rebuild edges on wire
 360   TopoDS_Edge newEdge1, newEdge2;
 361   TopoDS_Vertex v, v1, v2;
 362   BRepLib_MakeEdge makeEdge;
 363   TopLoc_Location loc;
 364   Standard_Real first, last;
 365
 366   TopExp::Vertices(E1, firstVertex, lastVertex);
 367   TopExp::Vertices(basisEdge1, v1, v2);
 368   if (v1.IsSame(commonVertex)) v = v2;
 369   else v = v1;
 370
 371   if ( firstVertex.IsSame(v) || lastVertex.IsSame(v))
 372     // It means the edge support only one fillet. In this case
 373     // the new edge must be the basis edge.
 374     newEdge1 = basisEdge1;
 375   else {
 376     // It means the edge support one fillet on each end.
 377     if (firstVertex.IsSame(connectionE1Chamfer)) {
 378 //  syntaxe invalide sur NT
 379 //      const Handle(Geom_Curve)& curve =
 380 //      BRep_Tool::Curve(E1, loc, first, last);
 381       Handle(Geom_Curve) curve = BRep_Tool::Curve(E1, loc, first, last);
 382       makeEdge.Init(curve, commonVertex, lastVertex);
 383       newEdge1 = makeEdge.Edge();
 384       newEdge1.Orientation(basisEdge1.Orientation());
 385       newEdge1.Location(basisEdge1.Location());
 386     } // if (firstVertex ...
 387     else if (lastVertex.IsSame(connectionE1Chamfer)) {
 388 //  syntaxe invalide sur NT
 389 //      const Handle(Geom_Curve)& curve =
 390 //      BRep_Tool::Curve(E1, loc, first, last);
 391       Handle(Geom_Curve) curve = BRep_Tool::Curve(E1, loc, first, last);
 392       makeEdge.Init(curve, firstVertex, commonVertex);
 393       newEdge1 = makeEdge.Edge();
 394       newEdge1.Orientation(basisEdge1.Orientation());
 395       newEdge1.Location(basisEdge1.Location());
 396     } // else if (lastVertex ...
 397   } // else ...
 398
 399   TopExp::Vertices(basisEdge2, v1, v2);
 400   if (v1.IsSame(commonVertex)) v = v2;
 401   else v = v1;
 402
 403   TopExp::Vertices(E2, firstVertex, lastVertex);
 404   if ( firstVertex.IsSame(v) || lastVertex.IsSame(v))
 405     // It means the edge support only one fillet. In this case
 406     // the new edge must be the basis edge.
 407     newEdge2 = basisEdge2;
 408   else {
 409     // It means the edge support one fillet on each end.
 410     if (firstVertex.IsSame(connectionE2Chamfer)) {
 411 //  syntaxe invalide sur NT
 412 //      const Handle(Geom_Curve)& curve =
 413 //      BRep_Tool::Curve(E2, loc, first, last);
 414       Handle(Geom_Curve) curve = BRep_Tool::Curve(E2, loc, first, last);
 415       makeEdge.Init(curve, commonVertex, lastVertex);
 416       newEdge2 = makeEdge.Edge();
 417       newEdge2.Orientation(basisEdge2.Orientation());
 418       newEdge2.Location(basisEdge2.Location());
 419     } // if (firstVertex ...
 420     else if (lastVertex.IsSame(connectionE2Chamfer)) {
 421 //  syntaxe invalide sur NT
 422 //      const Handle(Geom_Curve)& curve =
 423 //      BRep_Tool::Curve(E2, loc, first, last);
 424       Handle(Geom_Curve) curve = BRep_Tool::Curve(E2, loc, first, last);
 425       makeEdge.Init(curve, firstVertex, commonVertex);
 426       newEdge2 = makeEdge.Edge();
 427       newEdge2.Orientation(basisEdge2.Orientation());
 428       newEdge2.Location(basisEdge2.Location());
 429     } // else if (lastVertex ...
 430   } // else ...
 431
 432   // rebuild the newFace
 433   TopExp_Explorer Ex(newFace, TopAbs_EDGE);
 434   TopoDS_Wire newWire;
 435
 436   BRep_Builder B;
 437   B.MakeWire(newWire);
 438
 439   while (Ex.More()) {
 440     const TopoDS_Edge& theEdge = TopoDS::Edge(Ex.Current());
 441     if (!theEdge.IsSame(E1) &&
 442         !theEdge.IsSame(E2) &&
 443         !theEdge.IsSame(Chamfer) )
 444       B.Add(newWire, theEdge);
 445     else {
 446       if (theEdge == E1)
 447         B.Add(newWire, newEdge1);
 448       else if (theEdge == E2)
 449         B.Add(newWire, newEdge2);
 450     } // else
 451     Ex.Next();
 452   } // while ...
 453
 454   BRepAdaptor_Surface Adaptor3dSurface(refFace);
 455   BRepLib_MakeFace mFace(Adaptor3dSurface.Plane(), newWire);
 456   newFace.Nullify();
 457   newFace = mFace;
 458
 459   UpDateHistory(basisEdge1, basisEdge2, newEdge1, newEdge2);
 460
 461   return commonVertex;
 462 } // RemoveChamfer
 463
 464
 465 //=======================================================================
 466 //function : BuildChamferEdge
 467 //purpose  :
 468 //=======================================================================
 469 TopoDS_Edge ChFi2d_Builder::BuildChamferEdge(const TopoDS_Vertex& V,
 470                                            const TopoDS_Edge& AdjEdge1,
 471                                            const TopoDS_Edge& AdjEdge2,
 472                                            const Standard_Real D1,
 473                                            const Standard_Real D2,
 474                                            TopoDS_Vertex& NewExtr1,
 475                                            TopoDS_Vertex& NewExtr2)
 476 {
 477   TopoDS_Edge chamfer;
 478   if ( D1 <= 0 || D2 <= 0) {
 479     status = ChFi2d_ParametersError;
 480     return chamfer;
 481   } // if ( D1 <=0 ...
 482
 483   Standard_Real param1, param2;
 484   gp_Pnt p1 = ComputePoint(V, AdjEdge1, D1, param1);
 485   gp_Pnt p2 = ComputePoint(V, AdjEdge2, D2, param2);
 486
 487   Standard_Real tol = Precision::Confusion();
 488   BRep_Builder B;
 489   B.MakeVertex(NewExtr1, p1, tol);
 490   B.MakeVertex(NewExtr2, p2, tol);
 491   NewExtr1.Orientation(TopAbs_FORWARD);
 492   NewExtr2.Orientation(TopAbs_REVERSED);
 493
 494   // chamfer edge construction
 495   TopLoc_Location loc;
 496   const Handle(Geom_Surface) refSurf = BRep_Tool::Surface(refFace, loc);
 497   gp_Vec myVec( p1, p2);
 498   gp_Dir myDir(myVec);
 499   Handle(Geom_Line) newLine = new Geom_Line( p1, myDir);
 500   Standard_Real param = ElCLib::Parameter(newLine->Lin(), p2);
 501   B.MakeEdge(chamfer, newLine, tol);
 502   B.Range(chamfer,0., param);
 503   B.Add(chamfer, NewExtr1);
 504   B.UpdateVertex(NewExtr1,0., chamfer, tol);
 505   B.Add(chamfer, NewExtr2);
 506   B.UpdateVertex(NewExtr2,param, chamfer, tol);
 507   OrientChamfer(chamfer, AdjEdge1, V);
 508
 509   // set the orientation of NewExtr1 and NewExtr2 for the adjacent edges
 510   TopoDS_Vertex V1 = TopExp::FirstVertex(AdjEdge1);
 511   TopoDS_Vertex V2 = TopExp::LastVertex(AdjEdge1);
 512   if (V1.IsSame(V)) NewExtr1.Orientation(V1.Orientation());
 513   else NewExtr1.Orientation(V2.Orientation());
 514
 515   V1 = TopExp::FirstVertex(AdjEdge2);
 516   V2 = TopExp::LastVertex(AdjEdge2);
 517   if (V1.IsSame(V)) NewExtr2.Orientation(V1.Orientation());
 518   else NewExtr2.Orientation(V2.Orientation());
 519   B.UpdateVertex(NewExtr1, param1, AdjEdge1, tol);
 520   B.UpdateVertex(NewExtr2, param2, AdjEdge2, tol);
 521
 522   status = ChFi2d_IsDone;
 523   return chamfer;
 524 } // BuildChamferEdge
 525
 526
 527 //=======================================================================
 528 //function : BuildFilletEdge
 529 //purpose  :
 530 //=======================================================================
 531 TopoDS_Edge ChFi2d_Builder::BuildChamferEdge(const TopoDS_Vertex& V,
 532                                            const TopoDS_Edge& AdjEdge1,
 533                                            const Standard_Real D,
 534                                            const Standard_Real Ang,
 535                                            const TopoDS_Edge& AdjEdge2,
 536                                            TopoDS_Vertex& NewExtr1,
 537                                            TopoDS_Vertex& NewExtr2)
 538 {
 539   TopoDS_Edge chamfer;
 540   if ( D <= 0 || Ang <= 0) {
 541     status = ChFi2d_ParametersError;
 542     return chamfer;
 543   } // if ( D <= 0 ...
 544
 545   Standard_Real param1, param2;
 546   gp_Pnt p1 = ComputePoint(V, AdjEdge1, D, param1);
 547   gp_Pnt p = BRep_Tool::Pnt(V);
 548   gp_Vec myVec( p1, p);
 549
 550   // compute the tangent vector on AdjEdge2 at the vertex V.
 551   BRepAdaptor_Curve c(AdjEdge2, refFace);
 552   Standard_Real first, last;
 553   first = c.FirstParameter();
 554   last = c.LastParameter();
 555
 556   gp_Pnt aPoint;
 557   gp_Vec tan;
 558   c.D1(first, aPoint, tan);
 559   if (aPoint.Distance(p) > Precision::Confusion()) {
 560     c.D1(last, aPoint, tan);
 561   }
 562   // tangent orientation
 563   TopoDS_Vertex v1, v2;
 564   TopExp::Vertices(AdjEdge2, v1, v2);
 565   TopAbs_Orientation orient;
 566   if (v1.IsSame(V)) orient = v1.Orientation();
 567   else orient = v2.Orientation();
 568   if (orient == TopAbs_REVERSED) tan *= -1;
 569
 570   // compute the chamfer geometric support
 571   gp_Ax1 RotAxe(p1, tan^myVec);
 572   gp_Vec vecLin = myVec.Rotated(RotAxe, -Ang);
 573   gp_Dir myDir(vecLin);
 574   Handle(Geom_Line) newLine = new Geom_Line( p1, myDir);
 575   BRep_Builder B1;
 576   B1.MakeEdge(chamfer, newLine, Precision::Confusion());
 577   gp_Pnt p2 = ComputePoint(refFace, newLine, AdjEdge2, param2);
 578
 579
 580   Standard_Real tol = Precision::Confusion();
 581   BRep_Builder B;
 582   B.MakeVertex(NewExtr1, p1, tol);
 583   B.MakeVertex(NewExtr2, p2, tol);
 584   NewExtr1.Orientation(TopAbs_FORWARD);
 585   NewExtr2.Orientation(TopAbs_REVERSED);
 586
 587   // chamfer edge construction
 588   Standard_Real param = ElCLib::Parameter(newLine->Lin(), p2);
 589   B.MakeEdge(chamfer, newLine, tol);
 590   B.Range(chamfer,0., param);
 591   B.Add(chamfer, NewExtr1);
 592   B.UpdateVertex(NewExtr1,0., chamfer, tol);
 593   B.Add(chamfer, NewExtr2);
 594   B.UpdateVertex(NewExtr2,param, chamfer, tol);
 595   OrientChamfer(chamfer, AdjEdge1, V);
 596
 597   // set the orientation of NewExtr1 and NewExtr2 for the adjacent edges
 598   TopoDS_Vertex V1 = TopExp::FirstVertex(AdjEdge1);
 599   TopoDS_Vertex V2 = TopExp::LastVertex(AdjEdge1);
 600   if (V1.IsSame(V)) NewExtr1.Orientation(V1.Orientation());
 601   else NewExtr1.Orientation(V2.Orientation());
 602
 603   V1 = TopExp::FirstVertex(AdjEdge2);
 604   V2 = TopExp::LastVertex(AdjEdge2);
 605   if (V1.IsSame(V)) NewExtr2.Orientation(V1.Orientation());
 606   else NewExtr2.Orientation(V2.Orientation());
 607   B.UpdateVertex(NewExtr1, param1, AdjEdge1, tol);
 608   B.UpdateVertex(NewExtr2, param2, AdjEdge2, tol);
 609
 610   status = ChFi2d_IsDone;
 611   return chamfer;
 612 }
 613
 614
 615 //=======================================================================
 616 //function : ComputePoint
 617 //purpose  :
 618 //=======================================================================
 619
 620 gp_Pnt ComputePoint(const TopoDS_Vertex& V,const TopoDS_Edge& E,
 621                     const Standard_Real D, Standard_Real& Param)
 622 {
 623   // geometric support
 624   BRepAdaptor_Curve c(E);
 625   Standard_Real first, last;
 626   first = c.FirstParameter();
 627   last = c.LastParameter();
 628
 629   gp_Pnt thePoint;
 630   if (c.GetType() == GeomAbs_Line) {
 631     gp_Pnt p1, p2;
 632     TopoDS_Vertex v1, v2;
 633     TopExp::Vertices(E, v1, v2);
 634     p1 = BRep_Tool::Pnt(v1);
 635     p2 = BRep_Tool::Pnt(v2);
 636     gp_Vec myVec( p1, p2);
 637     myVec.Normalize();
 638     myVec *= D;
 639     if (v2.IsSame(V)) {
 640       myVec *= -1; // change the sense of myVec
 641       thePoint = p2.Translated(myVec);
 642     } // if (v2 ...
 643     else thePoint = p1.Translated(myVec);
 644
 645     Param = ElCLib::Parameter(c.Line(), thePoint);
 646         //szv:OCC20823-begin
 647     c.D0(Param, thePoint);
 648         //szv:OCC20823-end
 649     return thePoint;
 650   } // if (C->IsKind(TYPE ...
 651
 652   if (c.GetType() == GeomAbs_Circle) {
 653     gp_Circ cir = c.Circle();
 654     Standard_Real radius = cir.Radius();
 655     TopoDS_Vertex v1, v2;
 656     TopExp::Vertices(E, v1, v2);
 657     Standard_Real param1,param2;
 658     if (V.IsSame(v1)) {
 659       param1 = BRep_Tool::Parameter(v1,E);
 660       param2 = BRep_Tool::Parameter(v2,E);
 661     }
 662     else {
 663       param1 = BRep_Tool::Parameter(v2,E);
 664       param2 = BRep_Tool::Parameter(v1,E);
 665     }
 666     Standard_Real deltaAlpha = D/radius;
 667     if (param1 > param2) Param = param1 - deltaAlpha;
 668     else Param = param1 + deltaAlpha;
 669     c.D0(Param, thePoint);
 670     return thePoint;
 671   } // if (C->IsKind(TYPE ...
 672
 673   else {
 674     // in all other case than lines and circles.
 675     gp_Pnt p;
 676     TopoDS_Vertex v1, v2;
 677     TopExp::Vertices(E, v1, v2);
 678     if (V.IsSame(v1)) {
 679       p = BRep_Tool::Pnt(v1);
 680     }
 681     else {
 682       p = BRep_Tool::Pnt(v2);
 683     }
 684
 685     GeomAdaptor_Curve cc = c.Curve();
 686     if (p.Distance(c.Value(first)) <= Precision::Confusion()) {
 687       GCPnts_AbscissaPoint computePoint(cc, D, first);
 688       Param = computePoint.Parameter();
 689     }
 690     else {
 691       GCPnts_AbscissaPoint computePoint(cc, D, last);
 692       Param = computePoint.Parameter();
 693     }
 694     thePoint = cc.Value(Param);
 695     return thePoint;
 696   } // else ...
 697 } // ComputePoint
 698
 699
 700
 701 //=======================================================================
 702 //function : ComputePoint
 703 //purpose  :
 704 //=======================================================================
 705
 706 gp_Pnt ComputePoint(const TopoDS_Face& F,
 707                     const Handle(Geom_Line)& L,
 708                     const TopoDS_Edge& E,
 709                     Standard_Real& Param)
 710 {
 711   BRepAdaptor_Surface Adaptor3dSurface(F);
 712   Handle(Geom_Plane) refSurf = new Geom_Plane(Adaptor3dSurface.Plane());
 713   Handle(Geom2d_Curve) lin2d = GeomAPI::To2d(L, refSurf->Pln());
 714   Handle(Geom2d_Curve) c2d;
 715   Standard_Real first, last;
 716   c2d = BRep_Tool::CurveOnSurface(E, F, first, last);
 717   Geom2dAdaptor_Curve adaptorL(lin2d);
 718   Geom2dAdaptor_Curve adaptorC(c2d);
 719   Geom2dInt_GInter Intersection(adaptorL, adaptorC,
 720                                 Precision::PIntersection(),
 721                                 Precision::PIntersection());
 722   Standard_Real paramOnLine = 1E300;
 723   gp_Pnt2d p2d;
 724   if (Intersection.IsDone()) {
 725     Standard_Integer i = 1;
 726     while ( i <= Intersection.NbPoints()) {
 727       IntRes2d_IntersectionPoint iP = Intersection.Point(i);
 728       if (iP.ParamOnFirst() < paramOnLine) {
 729         p2d = iP.Value();
 730         paramOnLine = iP.ParamOnFirst();
 731         Param = iP.ParamOnSecond();
 732       } // if (iP.ParamOnFirst ...
 733       i++;
 734     } // while ( i <= ...
 735   } // if (Intersection.IsDone ...
 736
 737   gp_Pnt thePoint = Adaptor3dSurface.Value(p2d.X(), p2d.Y());
 738   return thePoint;
 739 } // ComputePoint
 740
 741 //=======================================================================
 742 //function : OrientChamfer
 743 //purpose  :
 744 //=======================================================================
 745
 746 void OrientChamfer(TopoDS_Edge& chamfer,
 747                    const TopoDS_Edge& E,
 748                    const TopoDS_Vertex& V)
 749 {
 750   TopAbs_Orientation vOrient, orient = E.Orientation();
 751   TopoDS_Vertex v1, v2;
 752   TopExp::Vertices(E, v1, v2);
 753   if (v1.IsSame(V)) vOrient = v2.Orientation();
 754   else vOrient = v1.Orientation();
 755
 756   if ((orient == TopAbs_FORWARD && vOrient == TopAbs_FORWARD) ||
 757       (orient == TopAbs_REVERSED && vOrient == TopAbs_REVERSED))
 758     chamfer.Orientation(TopAbs_FORWARD);
 759   else chamfer.Orientation(TopAbs_REVERSED);
 760 } // OrientChamfer
 761
 762
 763 //=======================================================================
 764 //function : IsLineOrCircle
 765 //purpose  :
 766 //=======================================================================
 767
 768 Standard_Boolean IsLineOrCircle(const TopoDS_Edge& E,
 769                                 const TopoDS_Face& F)
 770 {
 771   Standard_Real first, last;
 772   TopLoc_Location loc;
 773 //  syntaxe invalide sur NT
 774 //      const Handle(Geom2d_Curve)& C =
 775 //      BRep_Tool::CurveOnSurface(E,F,first,last);
 776   Handle(Geom2d_Curve) C = BRep_Tool::CurveOnSurface(E,F,first,last);
 777   Handle(Geom2d_Curve) basisC;
 778   Handle(Geom2d_TrimmedCurve) TC = Handle(Geom2d_TrimmedCurve)::DownCast(C);
 779   if (!TC.IsNull())
 780     basisC = TC->BasisCurve();
 781   else
 782     basisC = C;
 783
 784   if ( basisC->DynamicType() == STANDARD_TYPE(Geom2d_Circle)
 785       || basisC->DynamicType() == STANDARD_TYPE(Geom2d_Line) ) {
 786     return Standard_True;
 787   }
 788   else {
 789     return Standard_False;
 790   } // else ...
 791 } // IsLineOrCircle