0027234: Code duplication: Convert_CompBezierCurvesToBSplineCurve* in ShapeConstruct
[occt.git] / src / Convert / Convert_CompBezierCurvesToBSplineCurve.cxx
old mode 100755 (executable)
new mode 100644 (file)
index a77a681..24b766f
@@ -1,28 +1,34 @@
-// File:       Convert_CompBezierCurvesToBSplineCurve.cxx
-// Created:    Wed Oct 20 14:55:08 1993
-// Author:     Bruno DUMORTIER
-//             <dub@topsn3>
-// modified 25/06/1996 PMN : Ajout d'une tolerance Angulaire dans le 
-//  constructeur pour le test de continuite G1 (1 Radians c'etait trop
-//  cf BUG PRO4481) 
+// Created on: 1993-10-20
+// Created by: Bruno DUMORTIER
+// Copyright (c) 1993-1999 Matra Datavision
+// Copyright (c) 1999-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
 
-#include <Convert_CompBezierCurvesToBSplineCurve.ixx>
 
-#include <Precision.hxx>
 #include <BSplCLib.hxx>
-#include <PLib.hxx>
-#include <gp_Pnt.hxx>
+#include <Convert_CompBezierCurvesToBSplineCurve.hxx>
 #include <gp.hxx>
+#include <gp_Pnt.hxx>
 #include <gp_Vec.hxx>
+#include <PLib.hxx>
+#include <Precision.hxx>
+#include <Standard_ConstructionError.hxx>
 #include <TColgp_HArray1OfPnt.hxx>
 
-
 //=======================================================================
 //function : Convert_CompBezierCurvesToBSplineCurve
 //purpose  : 
 //=======================================================================
-
-
 Convert_CompBezierCurvesToBSplineCurve::
 Convert_CompBezierCurvesToBSplineCurve(
                  const Standard_Real AngularTolerance) :
@@ -45,9 +51,10 @@ void  Convert_CompBezierCurvesToBSplineCurve::AddCurve
     P1 = mySequence.Last()->Value(mySequence.Last()->Upper());
     P2 = Poles(Poles.Lower());
 
-    // NYI
-  if ( !P1.IsEqual(P2,Precision::Confusion()))
-      cout << "Convert_CompBezierCurvesToBSplineCurve::Addcurve" << endl;;
+#ifdef OCCT_DEBUG
+    if (!P1.IsEqual(P2, Precision::Confusion()))
+      cout << "Convert_CompBezierCurvesToBSplineCurve::Addcurve" << endl;
+#endif
   }
   myDone = Standard_False;
   Handle(TColgp_HArray1OfPnt) HPoles = 
@@ -152,31 +159,31 @@ void Convert_CompBezierCurvesToBSplineCurve::Perform()
     myDegree = Max( myDegree, (mySequence(i))->Length() -1);
   }
 
-  Standard_Real D1, D2, Lambda, Det=0;
+  Standard_Real Det=0;
   gp_Pnt P1, P2, P3;
   Standard_Integer Deg, Inc, MaxDegree = myDegree;
   TColgp_Array1OfPnt Points(1, myDegree+1);
 
   for (i = LowerI ; i <= UpperI ; i++) {
-    // 1- Elever la courbe de Bezier au degre maximum.
+    // 1- Raise the Bezier curve to the maximum degree.
     Deg = mySequence(i)->Length()-1;
     Inc = myDegree - Deg;
     if ( Inc > 0) {
       BSplCLib::IncreaseDegree(myDegree, 
-                              mySequence(i)->Array1(), PLib::NoWeights(), 
-                              Points, PLib::NoWeights());
+                              mySequence(i)->Array1(), BSplCLib::NoWeights(), 
+                              Points, BSplCLib::NoWeights());
     }
     else {
       Points = mySequence(i)->Array1();
     }
 
-    // 2- Traiter le noeud de jonction entre 2 courbes de Bezier.
+    // 2- Process the node of junction between 2 Bezier curves.
     if (i == LowerI) {
-      // Traitement du noeud initial de la BSpline.
+      // Processing of the initial node of the BSpline.
       for (Standard_Integer j = 1 ; j <= MaxDegree ; j++) {
-       CurvePoles.Append(Points(j));
+        CurvePoles.Append(Points(j));
       }
-      CurveKnVals(1)         = 1.; // Pour amorcer la serie.
+      CurveKnVals(1)         = 1.; // To begin the series.
       KnotsMultiplicities.Append(MaxDegree+1);
       Det = 1.;
     }
@@ -186,54 +193,51 @@ void Convert_CompBezierCurvesToBSplineCurve::Perform()
       P2 = Points(1);
       P3 = Points(2);
       gp_Vec V1(P1, P2), V2(P2, P3);
-      D1 = P1.SquareDistance(P2);
-      D2 = P3.SquareDistance(P2);
-      Lambda = Sqrt(D2/D1);
-//      cout << "D1, D2, Lambda : " << D1 << " " <<  D2 << " " << Lambda << endl;
-
-      // Traitement de la tangence entre la Bezier et sa precedente.
-      // Ceci permet d''assurer au moins une continuite C1 si 
-      // les tangentes sont coherentes.
+
+      // Processing of the tangency between Bezier and the previous.
+      // This allows to guarantee at least a C1 continuity if the tangents are  
+      // coherent.
       
-      if (V1.Magnitude() > gp::Resolution() &&
-         V2.Magnitude() > gp::Resolution() &&
-         V1.IsParallel(V2, myAngular )) {
-       if(CurveKnVals(i-1) * Lambda > 10. * Epsilon(Det)) {
-         KnotsMultiplicities.Append(MaxDegree-1);
-         CurveKnVals(i) = CurveKnVals(i-1) * Lambda;
-         Det += CurveKnVals(i);
-       }
-       else {
-         CurvePoles.Append(Points(1));
-         KnotsMultiplicities.Append(MaxDegree);
-         CurveKnVals(i) = 1.0 ;
-         Det += CurveKnVals(i) ;
-       }
+      Standard_Real D1 = V1.SquareMagnitude();
+      Standard_Real D2 = V2.SquareMagnitude();
+      if (MaxDegree > 1 && //rln 20.06.99 work-around
+          D1 > gp::Resolution() && D2 > gp::Resolution() && V1.IsParallel(V2, myAngular ))
+      {
+          Standard_Real Lambda = Sqrt(D2/D1);
+          if(CurveKnVals(i-1) * Lambda > 10. * Epsilon(Det)) {
+            KnotsMultiplicities.Append(MaxDegree-1);
+            CurveKnVals(i) = CurveKnVals(i-1) * Lambda;
+          }
+          else {
+            CurvePoles.Append(Points(1));
+            KnotsMultiplicities.Append(MaxDegree);
+            CurveKnVals(i) = 1.0 ;
+          }
       }
       else {
-       CurvePoles.Append(Points(1));
-       KnotsMultiplicities.Append(MaxDegree);
+        CurvePoles.Append(Points(1));
+        KnotsMultiplicities.Append(MaxDegree);
         CurveKnVals(i) = 1.0 ;
-        Det += CurveKnVals(i) ;
       }
+      Det += CurveKnVals(i);
 
-      // Stocker les poles.
+      // Store the poles.
       for (Standard_Integer j = 2 ; j <= MaxDegree ; j++) {
-       CurvePoles.Append(Points(j));
+        CurvePoles.Append(Points(j));
       }
 
     }
 
 
     if (i == UpperI) {
-      // Traitement du noeud terminal de la BSpline.
+      // Processing of the end node of the BSpline.
       CurvePoles.Append(Points(MaxDegree+1));
       KnotsMultiplicities.Append(MaxDegree+1);
     }
     P1 = Points(MaxDegree);
   }
 
-  // Corriger les valeurs nodales pour les faire varier dans [0.,1.].
+  // Correct nodal values to make them variable within [0.,1.].
   CurveKnots.Append(0.0);
 //  cout << "Convert : Det = " << Det << endl;
   for (i = 2 ; i <= NbrCurv ; i++) {