Wrong border 1.0e-9 jump has deleted. Added periodicity information when projecting to surface.
Period "jump" bug fixes.
AppCont_LeastSquare conversion to non cdl class.
AppCont_Function + AppCont_FunctionTool combined in one class providing the same functionality and converted to non cdl.
Testcase modification.
Test cases for issue CR24988
Fixed incorrect comparison.
---Level : Advanced.
-- All methods of all classes will be advanced.
-
-
-
uses AppParCurves, Geom, math, StdFail, TCollection, TColStd, gp,
TColgp, Standard
-
is
-------------------------------
--- Algorithms:
-------------------------------
- generic class LeastSquare;
+ imported LeastSquare;
------------------------------------------------------
--- Necessary class for approximation a function f(t):
------------------------------------------------------
- deferred class Function;
-
- class FunctionTool;
-
-
- ---------------------------------------------------------
- --- Necessary class for approximation a 2d function f(t):
- ---------------------------------------------------------
-
- deferred class Function2d;
-
- class FunctionTool2d;
-
-
- class FitFunction instantiates LeastSquare from AppCont
- (Function from AppCont, FunctionTool from AppCont);
-
- class FitFunction2d instantiates LeastSquare from AppCont
- (Function2d from AppCont, FunctionTool2d from AppCont);
-
+ imported Function;
end AppCont;
+++ /dev/null
--- Created on: 1993-09-01
--- Created by: Laurent PAINNOT
--- 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.
-
-deferred class Function from AppCont
-
- ---Purpose: deferred class describing a continous 3d function f(u)
- -- This class must be provided by the user to use the
- -- approximation algorithm FittingCurve.
-
-uses Pnt from gp,
- Vec from gp
-
-is
-
- Delete(me:out) is virtual;
- ---C++: alias "Standard_EXPORT virtual ~AppCont_Function(){Delete() ; }"
-
-
- FirstParameter(me) returns Real
- ---Purpose: returns the first parameter of the function.
- is deferred;
-
- LastParameter(me) returns Real
- ---Purpose: returns the last parameter of the function.
- is deferred;
-
- Value(me; U: Real) returns Pnt
- ---Purpose: returns the point at parameter <U>.
- is deferred;
-
- D1(me; U: Real; P: in out Pnt; V: in out Vec) returns Boolean
- ---Purpose: returns the point and the derivative values at
- -- the parameter <U>.
- is deferred;
-
-
-end Function;
+++ /dev/null
-// Copyright (c) 1995-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 <AppCont_Function.ixx>
-
-void AppCont_Function::Delete()
-{}
--- /dev/null
+// Copyright (c) 1995-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.
+
+#ifndef AppCont_Function_HeaderFile
+#define AppCont_Function_HeaderFile
+
+#include <gp_Pnt.hxx>
+#include <gp_Pnt2d.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Vec2d.hxx>
+#include <NCollection_Array1.hxx>
+#include <Standard_Integer.hxx>
+
+//! Class describing a continous 3d and/or function f(u).
+//! This class must be provided by the user to use the approximation algorithm FittingCurve.
+class AppCont_Function
+{
+public:
+
+ Standard_EXPORT AppCont_Function()
+ {
+ myNbPnt = -1;
+ myNbPnt2d = -1;
+ }
+
+ //! Get number of 3d and 2d points returned by "Value" and "D1" functions.
+ Standard_EXPORT void GetNumberOfPoints(Standard_Integer& theNbPnt,
+ Standard_Integer& theNbPnt2d) const
+ {
+ theNbPnt = myNbPnt;
+ theNbPnt2d = myNbPnt2d;
+ }
+
+ //! Get number of 3d points returned by "Value" and "D1" functions.
+ Standard_EXPORT Standard_Integer GetNbOf3dPoints() const
+ {
+ return myNbPnt;
+ }
+
+ //! Get number of 2d points returned by "Value" and "D1" functions.
+ Standard_EXPORT Standard_Integer GetNbOf2dPoints() const
+ {
+ return myNbPnt2d;
+ }
+
+ Standard_EXPORT virtual ~AppCont_Function() {}
+
+ //! Returns the first parameter of the function.
+ Standard_EXPORT virtual Standard_Real FirstParameter() const = 0;
+
+ //! Returns the last parameter of the function.
+ Standard_EXPORT virtual Standard_Real LastParameter() const = 0;
+
+ //! Returns the point at parameter <theU>.
+ Standard_EXPORT virtual Standard_Boolean Value(const Standard_Real theU,
+ NCollection_Array1<gp_Pnt2d>& thePnt2d,
+ NCollection_Array1<gp_Pnt>& thePnt) const = 0;
+
+ //! Returns the derivative at parameter <theU>.
+ Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real theU,
+ NCollection_Array1<gp_Vec2d>& theVec2d,
+ NCollection_Array1<gp_Vec>& theVec) const = 0;
+
+ //! Return information about peridicity in output paramateters space.
+ //! @param theDimIdx Defines index in output parameters space. 1 <= theDimIdx <= 3 * myNbPnt + 2 * myNbPnt2d.
+ Standard_EXPORT virtual void PeriodInformation(const Standard_Integer /*theDimIdx*/,
+ Standard_Boolean& IsPeriodic,
+ Standard_Real& thePeriod) const
+ {
+ IsPeriodic = Standard_False;
+ thePeriod = 0.0;
+ };
+
+
+protected:
+ Standard_Integer myNbPnt;
+ Standard_Integer myNbPnt2d;
+};
+
+#endif
+++ /dev/null
--- Created on: 1993-09-01
--- Created by: Laurent PAINNOT
--- 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.
-
-deferred class Function2d from AppCont
-
- ---Purpose: deferred class describing a continous 2d function f(u)
- -- This class must be provided by the user to use the
- -- approximation algorithm FittingCurve2d.
-
-uses Pnt2d from gp,
- Vec2d from gp
-
-is
-
- Delete(me:out) is virtual;
- ---C++: alias "Standard_EXPORT virtual ~AppCont_Function2d(){Delete() ; }"
-
-
- FirstParameter(me) returns Real
- ---Purpose: returns the first parameter of the function.
- is deferred;
-
- LastParameter(me) returns Real
- ---Purpose: returns the last parameter of the function.
- is deferred;
-
- Value(me; U: Real) returns Pnt2d
- ---Purpose: returns the point at parameter <U>.
- is deferred;
-
- D1(me; U: Real; P: in out Pnt2d; V: in out Vec2d) returns Boolean
- ---Purpose: returns the point and the derivative values at
- -- the parameter <U>.
- is deferred;
-
-
-end Function2d;
+++ /dev/null
-// Copyright (c) 1995-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 <AppCont_Function2d.ixx>
-
-void AppCont_Function2d::Delete()
-{}
+++ /dev/null
--- Created on: 1993-09-01
--- Created by: Laurent PAINNOT
--- 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.
-
-class FunctionTool from AppCont
- ---Purpose: This class is the inteface between the Function
- -- class and the tool asked by LeastSquare.
-
-uses Function from AppCont,
- Pnt from gp,
- Pnt2d from gp,
- Vec from gp,
- Vec2d from gp,
- Array1OfPnt from TColgp,
- Array1OfPnt2d from TColgp,
- Array1OfVec from TColgp,
- Array1OfVec2d from TColgp
-
-is
-
- FirstParameter(myclass; C: Function from AppCont) returns Real;
- ---Purpose: returns the first parameter of the Function.
-
- LastParameter(myclass; C: Function from AppCont) returns Real;
- ---Purpose: returns the last parameter of the Function.
-
- NbP2d(myclass; C: Function from AppCont) returns Integer;
- ---Purpose: Returns 0.
-
-
- NbP3d(myclass; C: Function from AppCont) returns Integer;
- ---Purpose: Returns 1. (the approximation will be done only for one
- -- function.
-
-
- Value(myclass; C: Function from AppCont; U: Real; tabPt: out Array1OfPnt);
- ---Purpose: <tabP> is an array of only 1 element, the point value at
- -- the parameter <U>.
-
-
- D1(myclass; C: Function from AppCont; U: Real; tabV: out Array1OfVec)
- returns Boolean;
- ---Purpose: <tabV> is an array of only 1 element, the derivative
- -- value at the parameter <U>.
-
-
- ----------------------------------------------------------
- -- the following methods won t be called by the algorithms
- -- but the description must exist in the tool.
- ----------------------------------------------------------
-
-
-
- Value(myclass; C: Function from AppCont;U: Real;
- tabPt2d: out Array1OfPnt2d);
-
- Value(myclass; C: Function from AppCont; U: Real;
- tabPt: out Array1OfPnt;
- tabPt2d: out Array1OfPnt2d);
-
-
- D1(myclass;C: Function from AppCont;U: Real;
- tabV2d: out Array1OfVec2d)
- returns Boolean;
-
-
- D1(myclass; C: Function from AppCont; U: Real;
- tabV: out Array1OfVec;
- tabV2d: out Array1OfVec2d)
- returns Boolean;
-
-
-end FunctionTool;
-
+++ /dev/null
-// Copyright (c) 1995-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 <AppCont_FunctionTool.ixx>
-
-#include <AppCont_Function.hxx>
-#include <TColgp_Array1OfPnt.hxx>
-#include <TColgp_Array1OfVec.hxx>
-#include <gp_Pnt.hxx>
-#include <gp_Vec.hxx>
-
-
-Standard_Real AppCont_FunctionTool::FirstParameter
- (const AppCont_Function& F)
-{
- return F.FirstParameter();
-}
-
-Standard_Real AppCont_FunctionTool::LastParameter
- (const AppCont_Function& F)
-{
- return F.LastParameter();
-}
-
-Standard_Integer AppCont_FunctionTool::NbP2d
- (const AppCont_Function&)
-{
- return (0);
-}
-
-
-Standard_Integer AppCont_FunctionTool::NbP3d
- (const AppCont_Function&)
-{
- return (1);
-}
-
-void AppCont_FunctionTool::Value(const AppCont_Function& F,
- const Standard_Real U,
- TColgp_Array1OfPnt& tabPt)
-{
- tabPt(tabPt.Lower()) = F.Value(U);
-}
-
-
-
-
-Standard_Boolean AppCont_FunctionTool::D1
- (const AppCont_Function& F,
- const Standard_Real U,
- TColgp_Array1OfVec& tabV)
-{
- gp_Pnt P;
- gp_Vec V;
- Standard_Boolean Ok = F.D1(U, P, V);
- tabV(tabV.Lower()) = V;
- return Ok;
-}
-
-
-
-
-
-
-void AppCont_FunctionTool::Value(const AppCont_Function&,
- const Standard_Real,
- TColgp_Array1OfPnt2d&)
-{
-}
-
-
-void AppCont_FunctionTool::Value(const AppCont_Function&,
- const Standard_Real,
- TColgp_Array1OfPnt&,
- TColgp_Array1OfPnt2d&)
-{
-}
-
-
-
-Standard_Boolean AppCont_FunctionTool::D1
- (const AppCont_Function&,
- const Standard_Real,
- TColgp_Array1OfVec2d&)
-{
- return (Standard_True);
-}
-
-
-Standard_Boolean AppCont_FunctionTool::D1
- (const AppCont_Function&,
- const Standard_Real,
- TColgp_Array1OfVec&,
- TColgp_Array1OfVec2d&)
-{
- return (Standard_True);
-}
-
+++ /dev/null
--- Created on: 1993-09-01
--- Created by: Laurent PAINNOT
--- 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.
-
-class FunctionTool2d from AppCont
- ---Purpose: This class is the inteface between the Function2d
- -- class and the tool asked by LeastSquare.
-
-uses Function2d from AppCont,
- Pnt from gp,
- Pnt2d from gp,
- Vec from gp,
- Vec2d from gp,
- Array1OfPnt from TColgp,
- Array1OfPnt2d from TColgp,
- Array1OfVec from TColgp,
- Array1OfVec2d from TColgp
-
-is
-
- FirstParameter(myclass; C: Function2d from AppCont) returns Real;
- ---Purpose: returns the first parameter of the Function.
-
- LastParameter(myclass; C: Function2d from AppCont) returns Real;
- ---Purpose: returns the last parameter of the Function.
-
- NbP2d(myclass; C: Function2d from AppCont) returns Integer;
- ---Purpose: Returns 1. (the approximation will be done only for one
- -- function.
-
-
- NbP3d(myclass; C: Function2d from AppCont) returns Integer;
- ---Purpose: Returns 0.
-
- Value(myclass; C: Function2d from AppCont;
- U: Real; tabPt: out Array1OfPnt2d);
- ---Purpose: <tabP> is an array of only 1 element, the point value at
- -- the parameter <U>.
-
-
- D1(myclass; C: Function2d from AppCont; U: Real; tabV: out Array1OfVec2d)
- returns Boolean;
- ---Purpose: <tabV> is an array of only 1 element, the derivative
- -- value at the parameter <U>.
-
-
- ----------------------------------------------------------
- -- the following methods won t be called by the algorithms
- -- but the description must exist in the tool.
- ----------------------------------------------------------
-
-
-
- Value(myclass; C: Function2d from AppCont;U: Real;
- tabPt2d: out Array1OfPnt);
-
- Value(myclass; C: Function2d from AppCont; U: Real;
- tabPt: out Array1OfPnt;
- tabPt2d: out Array1OfPnt2d);
-
-
- D1(myclass;C: Function2d from AppCont;U: Real;
- tabV2d: out Array1OfVec)
- returns Boolean;
-
-
- D1(myclass; C: Function2d from AppCont; U: Real;
- tabV: out Array1OfVec;
- tabV2d: out Array1OfVec2d)
- returns Boolean;
-
-
-end FunctionTool2d;
-
+++ /dev/null
-// Copyright (c) 1995-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 <AppCont_FunctionTool2d.ixx>
-
-#include <AppCont_Function2d.hxx>
-#include <TColgp_Array1OfPnt2d.hxx>
-#include <TColgp_Array1OfVec2d.hxx>
-#include <gp_Pnt2d.hxx>
-#include <gp_Vec2d.hxx>
-
-
-Standard_Real AppCont_FunctionTool2d::FirstParameter
- (const AppCont_Function2d& F)
-{
- return F.FirstParameter();
-}
-
-Standard_Real AppCont_FunctionTool2d::LastParameter
- (const AppCont_Function2d& F)
-{
- return F.LastParameter();
-}
-
-Standard_Integer AppCont_FunctionTool2d::NbP2d
- (const AppCont_Function2d&)
-{
- return (1);
-}
-
-
-Standard_Integer AppCont_FunctionTool2d::NbP3d
- (const AppCont_Function2d&)
-{
- return (0);
-}
-
-void AppCont_FunctionTool2d::Value(const AppCont_Function2d& F,
- const Standard_Real U,
- TColgp_Array1OfPnt2d& tabPt)
-{
- tabPt(tabPt.Lower()) = F.Value(U);
-}
-
-
-
-
-Standard_Boolean AppCont_FunctionTool2d::D1
- (const AppCont_Function2d& F,
- const Standard_Real U,
- TColgp_Array1OfVec2d& tabV)
-{
- gp_Pnt2d P;
- gp_Vec2d V;
- Standard_Boolean Ok = F.D1(U, P, V);
- tabV(tabV.Lower()) = V;
- return Ok;
-}
-
-
-
-
-
-
-void AppCont_FunctionTool2d::Value(const AppCont_Function2d&,
- const Standard_Real,
- TColgp_Array1OfPnt&)
-{
-}
-
-
-void AppCont_FunctionTool2d::Value(const AppCont_Function2d&,
- const Standard_Real,
- TColgp_Array1OfPnt&,
- TColgp_Array1OfPnt2d&)
-{
-}
-
-
-
-Standard_Boolean AppCont_FunctionTool2d::D1
- (const AppCont_Function2d&,
- const Standard_Real,
- TColgp_Array1OfVec&)
-{
- return (Standard_False);
-}
-
-
-Standard_Boolean AppCont_FunctionTool2d::D1
- (const AppCont_Function2d&,
- const Standard_Real,
- TColgp_Array1OfVec&,
- TColgp_Array1OfVec2d&)
-{
- return (Standard_False);
-}
-
+++ /dev/null
--- Created on: 1993-04-22
--- Created by: Laurent PAINNOT
--- 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.
-
-generic class LeastSquare from AppCont(MultiLine as any;
- LineTool as any)
- ---as TheToolLine(MultiLine)
-
- ---Purpose: Makes an approximation of a continous Line described by
- -- the tool TheLineTool.
- -- Minimizing the difference between the approximate result
- -- Curve and a continous MultiLine
-
-uses Matrix from math,
- Vector from math,
- Constraint from AppParCurves,
- MultiCurve from AppParCurves
-
-
-raises NotDone from StdFail,
- OutOfRange from Standard,
- DimensionError from Standard
-
-
-
-is
-
- Create(SSP: MultiLine; U0, U1: Real; FirstCons, LastCons: Constraint;
- Deg: Integer; NbPoints: Integer = 24)
- ---Purpose: given a continous MultiLine, this algorithm computes
- -- the approximation into Bezier curves.
- -- NbPoints points are taken on the initial MultiLine for
- -- minimizing the surface between the MultiLine and the
- -- Bezier curves doing the approximation.
- -- The first point will be the point of parameter U0 with
- -- a constraint FirstCons.
- -- The last point will be the point of parameter U1 with
- -- a constraint LastCons.
-
- returns LeastSquare from AppCont
- raises DimensionError from Standard;
-
-
-
- IsDone(me)
- ---Purpose: returns True if all has been correctly done.
-
- returns Boolean
- is static;
-
-
- Value(me: in out)
- ---Purpose: returns the result of the approximation, i.e. a
- -- MultiCurve.
- -- An exception is raised if NotDone.
- ---C++: return const &
-
- returns MultiCurve from AppParCurves
- raises NotDone from StdFail
- is static;
-
-
- NbBColumns(me; SSP: MultiLine)
- ---Purpose: is internally used by the constuctor.
-
- returns Integer
- is static protected;
-
-
- Error(me; F: in out Real; MaxE3d, MaxE2d: in out Real)
- ---Purpose: F is the sum of the square errors at each of the
- -- NbPoints of the MultiLine.
- -- MaxE3d is the maximum 3d value of these errors.
- -- MaxE2d is the maximum 2d value of these errors.
- -- An exception is raised if NotDone.
-
- raises NotDone from StdFail
- is static;
-
-
-
-fields
-
-Done: Boolean;
-SCU: MultiCurve from AppParCurves;
-Degre: Integer;
-Nbdiscret: Integer;
-nbP: Integer;
-nbP2d: Integer;
-Points: Matrix;
-Poles: Matrix;
-myParam: Vector;
-VB: Matrix;
-
-end LeastSquare from AppCont;
-
--- /dev/null
+// Created on: 1995-03-14
+// Created by: Modelistation
+// Copyright (c) 1995-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.
+
+#ifndef OCCT_DEBUG
+#define No_Standard_OutOfRange
+#define No_Standard_RangeError
+#endif
+#include <AppCont_LeastSquare.hxx>
+
+#include <math.hxx>
+#include <AppParCurves_MultiPoint.hxx>
+#include <AppCont_ContMatrices.hxx>
+#include <PLib.hxx>
+
+
+//=======================================================================
+//function : AppCont_LeastSquare
+//purpose :
+//=======================================================================
+void AppCont_LeastSquare::FixSingleBorderPoint(const AppCont_Function& theSSP,
+ const Standard_Real theU,
+ const Standard_Real theU0,
+ const Standard_Real theU1,
+ NCollection_Array1<gp_Pnt2d>& theFix2d,
+ NCollection_Array1<gp_Pnt>& theFix)
+{
+ Standard_Real aMaxIter = 15.0;
+ Standard_Integer j, i2;
+ NCollection_Array1<gp_Pnt> aTabP(1, Max (myNbP, 1)), aPrevP(1, Max (myNbP, 1));
+ NCollection_Array1<gp_Pnt2d> aTabP2d(1, Max (myNbP2d, 1)), aPrevP2d(1, Max (myNbP2d, 1));
+ Standard_Real aMult = ((theU - theU0) > (theU1 - theU)) ? 1.0: -1.0;
+ Standard_Real aStartParam = (theU0 + theU1) / 2.0,
+ aCurrParam, aPrevDist = 1.0, aCurrDist = 1.0;
+
+ for (Standard_Real anIter = 1.0; anIter < aMaxIter; anIter += 1.0)
+ {
+ aCurrParam = aStartParam + aMult * (1 - pow(10, -anIter)) * (theU1 - theU0) / 2.0;
+ theSSP.Value(aCurrParam, aTabP2d, aTabP);
+
+ // from second iteration
+ if (anIter > 1.5)
+ {
+ aCurrDist = 0.0;
+
+ i2 = 1;
+ for (j = 1; j <= myNbP; j++)
+ {
+ aCurrDist += aTabP(j).Distance(aPrevP(j));
+ i2 += 3;
+ }
+ for (j = 1; j <= myNbP2d; j++)
+ {
+ aCurrDist += aTabP2d(j).Distance(aPrevP2d(j));
+ i2 += 2;
+ }
+
+ // from the third iteration
+ if (anIter > 2.5 && aCurrDist / aPrevDist > 10.0)
+ break;
+ }
+ aPrevP = aTabP;
+ aPrevP2d = aTabP2d;
+ aPrevDist = aCurrDist;
+ }
+ theFix2d = aPrevP2d;
+ theFix = aPrevP;
+}
+
+
+//=======================================================================
+//function : AppCont_LeastSquare
+//purpose :
+//=======================================================================
+
+AppCont_LeastSquare::AppCont_LeastSquare(const AppCont_Function& SSP,
+ const Standard_Real U0,
+ const Standard_Real U1,
+ const AppParCurves_Constraint FirstCons,
+ const AppParCurves_Constraint LastCons,
+ const Standard_Integer Deg,
+ const Standard_Integer myNbPoints)
+: mySCU(Deg+1),
+ myPoints(1, myNbPoints, 1, 3 * SSP.GetNbOf3dPoints() + 2 * SSP.GetNbOf2dPoints()),
+ myPoles(1, Deg + 1, 1, 3 * SSP.GetNbOf3dPoints() + 2 * SSP.GetNbOf2dPoints(), 0.0),
+ myParam(1, myNbPoints),
+ myVB(1, Deg+1, 1, myNbPoints),
+ myPerInfo(1, 3 * SSP.GetNbOf3dPoints() + 2 * SSP.GetNbOf2dPoints() )
+{
+ myDone = Standard_False;
+ myDegre = Deg;
+ math_Matrix InvM(1, Deg+1, 1, Deg + 1);
+ Standard_Integer i, j, k, c, i2;
+ Standard_Integer classe = Deg + 1, cl1 = Deg;
+ Standard_Real U, dU, Coeff, Coeff2;
+ Standard_Real IBij, IBPij;
+
+ Standard_Integer FirstP = 1, LastP = myNbPoints;
+ Standard_Integer nbcol = 3 * SSP.GetNbOf3dPoints() + 2 * SSP.GetNbOf2dPoints();
+ math_Matrix B(1, classe, 1, nbcol, 0.0);
+ Standard_Integer bdeb = 1, bfin = classe;
+ AppParCurves_Constraint myFirstC = FirstCons, myLastC = LastCons;
+ SSP.GetNumberOfPoints(myNbP, myNbP2d);
+
+ Standard_Integer i2plus1, i2plus2;
+ myNbdiscret = myNbPoints;
+ NCollection_Array1<gp_Pnt> aTabP(1, Max (myNbP, 1));
+ NCollection_Array1<gp_Pnt2d> aTabP2d(1, Max (myNbP2d, 1));
+ NCollection_Array1<gp_Vec> aTabV(1, Max (myNbP, 1));
+ NCollection_Array1<gp_Vec2d> aTabV2d(1, Max (myNbP2d, 1));
+
+ for(Standard_Integer aDimIdx = 1; aDimIdx <= myNbP * 3 + myNbP2d * 2; aDimIdx++)
+ {
+ SSP.PeriodInformation(aDimIdx,
+ myPerInfo(aDimIdx).isPeriodic,
+ myPerInfo(aDimIdx).myPeriod);
+ }
+
+ Standard_Boolean Ok;
+ if (myFirstC == AppParCurves_TangencyPoint)
+ {
+ Ok = SSP.D1(U0, aTabV2d, aTabV);
+ if (!Ok) myFirstC = AppParCurves_PassPoint;
+ }
+
+ if (myLastC == AppParCurves_TangencyPoint)
+ {
+ Ok = SSP.D1(U1, aTabV2d, aTabV);
+ if (!Ok) myLastC = AppParCurves_PassPoint;
+ }
+
+ // Compute control points params on which approximation will be built.
+ math_Vector GaussP(1, myNbPoints), GaussW(1, myNbPoints);
+ math::GaussPoints(myNbPoints, GaussP);
+ math::GaussWeights(myNbPoints, GaussW);
+ math_Vector TheWeights(1, myNbPoints), VBParam(1, myNbPoints);
+ dU = 0.5*(U1-U0);
+ for (i = FirstP; i <= LastP; i++)
+ {
+ U = 0.5 * (U1 + U0) + dU * GaussP(i);
+ if (i <= (myNbPoints+1)/2)
+ {
+ myParam(LastP - i + 1) = U;
+ VBParam(LastP - i + 1) = 0.5 * (1 + GaussP(i));
+ TheWeights(LastP - i + 1) = 0.5 * GaussW(i);
+ }
+ else
+ {
+ VBParam(i - (myNbPoints + 1) / 2) = 0.5*(1 + GaussP(i));
+ myParam(i - (myNbPoints + 1) / 2) = U;
+ TheWeights(i - (myNbPoints+ 1) / 2) = 0.5 * GaussW(i);
+ }
+ }
+
+ // Compute control points.
+ for (i = FirstP; i <= LastP; i++)
+ {
+ U = myParam(i);
+ SSP.Value(U, aTabP2d, aTabP);
+
+ i2 = 1;
+ for (j = 1; j <= myNbP; j++)
+ {
+ (aTabP(j)).Coord(myPoints(i, i2), myPoints(i, i2+1), myPoints(i, i2+2));
+ i2 += 3;
+ }
+ for (j = 1; j <= myNbP2d; j++)
+ {
+ (aTabP2d(j)).Coord(myPoints(i, i2), myPoints(i, i2+1));
+ i2 += 2;
+ }
+ }
+
+ // Fix possible "period jump".
+ Standard_Integer aMaxDim = 3 * myNbP + 2 * myNbP2d;
+ for(Standard_Integer aDimIdx = 1; aDimIdx <= aMaxDim; aDimIdx++)
+ {
+ if (myPerInfo(aDimIdx).isPeriodic &&
+ Abs (myPoints(1, aDimIdx) - myPoints(2, aDimIdx)) > myPerInfo(aDimIdx).myPeriod / 2.01 &&
+ Abs (myPoints(2, aDimIdx) - myPoints(3, aDimIdx)) < myPerInfo(aDimIdx).myPeriod / 2.01)
+ {
+ Standard_Real aPeriodMult = (myPoints(1, aDimIdx) < myPoints(2, aDimIdx)) ? 1.0 : -1.0;
+ Standard_Real aNewParam = myPoints(1, aDimIdx) + aPeriodMult * myPerInfo(aDimIdx).myPeriod;
+ myPoints(1, aDimIdx) = aNewParam;
+ }
+ }
+ for (Standard_Integer aPntIdx = 1; aPntIdx < myNbPoints; aPntIdx++)
+ {
+ for(Standard_Integer aDimIdx = 1; aDimIdx <= aMaxDim; aDimIdx++)
+ {
+ if (myPerInfo(aDimIdx).isPeriodic &&
+ Abs ( myPoints(aPntIdx, aDimIdx) - myPoints(aPntIdx + 1, aDimIdx) ) > myPerInfo(aDimIdx).myPeriod / 2.01)
+ {
+ Standard_Real aPeriodMult = (myPoints(aPntIdx, aDimIdx) > myPoints(aPntIdx + 1, aDimIdx)) ? 1.0 : -1.0;
+ Standard_Real aNewParam = myPoints(aPntIdx + 1, aDimIdx) + aPeriodMult * myPerInfo(aDimIdx).myPeriod;
+ myPoints(aPntIdx + 1, aDimIdx) = aNewParam;
+ }
+ }
+ }
+
+ VBernstein(classe, myNbPoints, myVB);
+
+ // Traitement du second membre:
+ NCollection_Array1<Standard_Real> tmppoints(1, nbcol);
+
+ for (c = 1; c <= classe; c++)
+ {
+ tmppoints.Init(0.0);
+ for (i = 1; i <= myNbPoints; i++)
+ {
+ Coeff = TheWeights(i) * myVB(c, i);
+ for (j = 1; j <= nbcol; j++)
+ {
+ tmppoints(j) += myPoints(i, j)*Coeff;
+ }
+ }
+ for (k = 1; k <= nbcol; k++)
+ {
+ B(c, k) += tmppoints(k);
+ }
+ }
+
+ if (myFirstC == AppParCurves_NoConstraint &&
+ myLastC == AppParCurves_NoConstraint) {
+
+ math_Matrix InvM(1, classe, 1, classe);
+ InvMMatrix(classe, InvM);
+ // Calcul direct des poles:
+
+ for (i = 1; i <= classe; i++) {
+ for (j = 1; j <= classe; j++) {
+ IBij = InvM(i, j);
+ for (k = 1; k <= nbcol; k++) {
+ myPoles(i, k) += IBij * B(j, k);
+ }
+ }
+ }
+ }
+
+
+ else
+ {
+ math_Matrix M(1, classe, 1, classe);
+ MMatrix(classe, M);
+ NCollection_Array1<gp_Pnt2d> aFixP2d(1, Max (myNbP2d, 1));
+ NCollection_Array1<gp_Pnt> aFixP(1, Max (myNbP, 1));
+
+ if (myFirstC == AppParCurves_PassPoint ||
+ myFirstC == AppParCurves_TangencyPoint)
+ {
+ SSP.Value(U0, aTabP2d, aTabP);
+ FixSingleBorderPoint(SSP, U0, U0, U1, aFixP2d, aFixP);
+
+ i2 = 1;
+ for (k = 1; k<= myNbP; k++)
+ {
+ if (aFixP(k).Distance(aTabP(k)) > 0.1)
+ (aFixP(k)).Coord(myPoles(1, i2), myPoles(1, i2 + 1), myPoles(1, i2 + 2));
+ else
+ (aTabP(k)).Coord(myPoles(1, i2), myPoles(1, i2 + 1), myPoles(1, i2 + 2));
+ i2 += 3;
+ }
+ for (k = 1; k<= myNbP2d; k++)
+ {
+ if (aFixP2d(k).Distance(aTabP2d(k)) > 0.1)
+ (aFixP2d(k)).Coord(myPoles(1, i2), myPoles(1, i2 + 1));
+ else
+ (aTabP2d(k)).Coord(myPoles(1, i2), myPoles(1, i2 + 1));
+ i2 += 2;
+ }
+
+ for (Standard_Integer aDimIdx = 1; aDimIdx <= aMaxDim; aDimIdx++)
+ {
+ if (myPerInfo(aDimIdx).isPeriodic &&
+ Abs ( myPoles(1, aDimIdx) - myPoints(1, aDimIdx) ) > myPerInfo(aDimIdx).myPeriod / 2.01 )
+ {
+ Standard_Real aMult = myPoles(1, aDimIdx) < myPoints(1, aDimIdx)? 1.0: -1.0;
+ myPoles(1,aDimIdx) += aMult * myPerInfo(aDimIdx).myPeriod;
+ }
+ }
+ }
+
+ if (myLastC == AppParCurves_PassPoint ||
+ myLastC == AppParCurves_TangencyPoint)
+ {
+ SSP.Value(U1, aTabP2d, aTabP);
+ FixSingleBorderPoint(SSP, U1, U0, U1, aFixP2d, aFixP);
+
+ i2 = 1;
+ for (k = 1; k<= myNbP; k++)
+ {
+ if (aFixP(k).Distance(aTabP(k)) > 0.1)
+ (aFixP(k)).Coord(myPoles(classe, i2), myPoles(classe, i2 + 1), myPoles(classe, i2 + 2));
+ else
+ (aTabP(k)).Coord(myPoles(classe, i2), myPoles(classe, i2 + 1), myPoles(classe, i2 + 2));
+ i2 += 3;
+ }
+ for (k = 1; k<= myNbP2d; k++)
+ {
+ if (aFixP2d(k).Distance(aTabP2d(k)) > 0.1)
+ (aFixP2d(k)).Coord(myPoles(classe, i2), myPoles(classe, i2 + 1));
+ else
+ (aTabP2d(k)).Coord(myPoles(classe, i2), myPoles(classe, i2 + 1));
+ i2 += 2;
+ }
+
+
+ for (Standard_Integer aDimIdx = 1; aDimIdx <= 2; aDimIdx++)
+ {
+ if (myPerInfo(aDimIdx).isPeriodic &&
+ Abs ( myPoles(classe, aDimIdx) - myPoints(myNbPoints, aDimIdx) ) > myPerInfo(aDimIdx).myPeriod / 2.01 )
+ {
+ Standard_Real aMult = myPoles(classe, aDimIdx) < myPoints(myNbPoints, aDimIdx)? 1.0: -1.0;
+ myPoles(classe,aDimIdx) += aMult * myPerInfo(aDimIdx).myPeriod;
+ }
+ }
+ }
+
+ if (myFirstC == AppParCurves_PassPoint) {
+ bdeb = 2;
+ // mise a jour du second membre:
+ for (i = 1; i <= classe; i++) {
+ Coeff = M(i, 1);
+ for (k = 1; k <= nbcol; k++) {
+ B(i, k) -= myPoles(1, k)*Coeff;
+ }
+ }
+ }
+
+ if (myLastC == AppParCurves_PassPoint) {
+ bfin = cl1;
+ for (i = 1; i <= classe; i++) {
+ Coeff = M(i, classe);
+ for (k = 1; k <= nbcol; k++) {
+ B(i, k) -= myPoles(classe, k)*Coeff;
+ }
+ }
+ }
+
+ if (myFirstC == AppParCurves_TangencyPoint) {
+ // On fixe le second pole::
+ bdeb = 3;
+ SSP.D1(U0, aTabV2d, aTabV);
+
+ i2 = 1;
+ Coeff = (U1-U0)/myDegre;
+ for (k = 1; k<= myNbP; k++) {
+ i2plus1 = i2+1; i2plus2 = i2+2;
+ myPoles(2, i2) = myPoles(1, i2) + aTabV(k).X()*Coeff;
+ myPoles(2, i2plus1) = myPoles(1, i2plus1) + aTabV(k).Y()*Coeff;
+ myPoles(2, i2plus2) = myPoles(1, i2plus2) + aTabV(k).Z()*Coeff;
+ i2 += 3;
+ }
+ for (k = 1; k<= myNbP2d; k++) {
+ i2plus1 = i2+1;
+ myPoles(2, i2) = myPoles(1, i2) + aTabV2d(k).X()*Coeff;
+ myPoles(2, i2plus1) = myPoles(1, i2plus1) + aTabV2d(k).Y()*Coeff;
+ i2 += 2;
+ }
+
+ for (i = 1; i <= classe; i++) {
+ Coeff = M(i, 1); Coeff2 = M(i, 2);
+ for (k = 1; k <= nbcol; k++) {
+ B(i, k) -= myPoles(1, k)*Coeff+myPoles(2, k)*Coeff2;
+ }
+ }
+ }
+
+ if (myLastC == AppParCurves_TangencyPoint) {
+ bfin = classe-2;
+ SSP.D1(U1, aTabV2d, aTabV);
+ i2 = 1;
+ Coeff = (U1-U0)/myDegre;
+ for (k = 1; k<= myNbP; k++) {
+ i2plus1 = i2+1; i2plus2 = i2+2;
+ myPoles(cl1,i2) = myPoles(classe, i2) - aTabV(k).X()*Coeff;
+ myPoles(cl1,i2plus1) = myPoles(classe, i2plus1) - aTabV(k).Y()*Coeff;
+ myPoles(cl1,i2plus2) = myPoles(classe, i2plus2) - aTabV(k).Z()*Coeff;
+ i2 += 3;
+ }
+ for (k = 1; k<= myNbP2d; k++) {
+ i2plus1 = i2+1;
+ myPoles(cl1,i2) = myPoles(classe, i2) - aTabV2d(k).X()*Coeff;
+ myPoles(cl1,i2plus1) = myPoles(classe, i2plus1) - aTabV2d(k).Y()*Coeff;
+ i2 += 2;
+ }
+
+ for (i = 1; i <= classe; i++) {
+ Coeff = M(i, classe); Coeff2 = M(i, cl1);
+ for (k = 1; k <= nbcol; k++) {
+ B(i, k) -= myPoles(classe, k)*Coeff + myPoles(cl1, k)*Coeff2;
+ }
+ }
+ }
+
+
+ if (bdeb <= bfin) {
+ math_Matrix B2(bdeb, bfin, 1, B.UpperCol(), 0.0);
+
+ for (i = bdeb; i <= bfin; i++) {
+ for (j = 1; j <= classe; j++) {
+ Coeff = M(i, j);
+ for (k = 1; k <= nbcol; k++) {
+ B2(i, k) += B(j, k)*Coeff;
+ }
+ }
+ }
+
+ // Resolution:
+ // ===========
+ math_Matrix IBP(bdeb, bfin, bdeb, bfin);
+
+ // dans IBPMatrix at IBTMatrix ne sont stockees que les resultats pour
+ // une classe inferieure ou egale a 26 (pour l instant du moins.)
+
+ if (bdeb == 2 && bfin == classe-1 && classe <= 26) {
+ IBPMatrix(classe, IBP);
+ }
+ else if (bdeb == 3 && bfin == classe-2 && classe <= 26) {
+ IBTMatrix(classe, IBP);
+ }
+ else {
+ math_Matrix MP(1, classe, bdeb, bfin);
+ for (i = 1; i <= classe; i++) {
+ for (j = bdeb; j <= bfin; j++) {
+ MP(i, j) = M(i, j);
+ }
+ }
+ math_Matrix IBP1(bdeb, bfin, bdeb, bfin);
+ IBP1 = MP.Transposed()*MP;
+ IBP = IBP1.Inverse();
+ }
+
+ myDone = Standard_True;
+ for (i = bdeb; i <= bfin; i++) {
+ for (j = bdeb; j <= bfin; j++) {
+ IBPij = IBP(i, j);;
+ for (k = 1; k<= nbcol; k++) {
+ myPoles(i, k) += IBPij * B2(j, k);
+ }
+ }
+ }
+ }
+ }
+}
+
+//=======================================================================
+//function : Value
+//purpose :
+//=======================================================================
+
+const AppParCurves_MultiCurve& AppCont_LeastSquare::Value()
+{
+
+ Standard_Integer i, j, j2;
+ gp_Pnt Pt;
+ gp_Pnt2d Pt2d;
+ Standard_Integer ideb = 1, ifin = myDegre+1;
+
+ // On met le resultat dans les curves correspondantes
+ for (i = ideb; i <= ifin; i++) {
+ j2 = 1;
+ AppParCurves_MultiPoint MPole(myNbP, myNbP2d);
+ for (j = 1; j <= myNbP; j++) {
+ Pt.SetCoord(myPoles(i, j2), myPoles(i, j2+1), myPoles(i,j2+2));
+ MPole.SetPoint(j, Pt);
+ j2 += 3;
+ }
+ for (j = myNbP+1;j <= myNbP+myNbP2d; j++) {
+ Pt2d.SetCoord(myPoles(i, j2), myPoles(i, j2+1));
+ MPole.SetPoint2d(j, Pt2d);
+ j2 += 2;
+ }
+ mySCU.SetValue(i, MPole);
+ }
+ return mySCU;
+}
+
+
+
+//=======================================================================
+//function : Error
+//purpose :
+//=======================================================================
+
+void AppCont_LeastSquare::Error(Standard_Real& F,
+ Standard_Real& MaxE3d,
+ Standard_Real& MaxE2d) const
+{
+ Standard_Integer i, j, k, c, i2, classe = myDegre + 1;
+ Standard_Real Coeff, err3d = 0.0, err2d = 0.0;
+ Standard_Integer ncol = myPoints.UpperCol() - myPoints.LowerCol() + 1;
+
+ math_Matrix MyPoints(1, myNbdiscret, 1, ncol);
+ MyPoints = myPoints;
+
+ MaxE3d = MaxE2d = F = 0.0;
+
+ NCollection_Array1<Standard_Real> tmppoles(1, ncol);
+
+ for (c = 1; c <= classe; c++)
+ {
+ for (k = 1; k <= ncol; k++)
+ {
+ tmppoles(k) = myPoles(c, k);
+ }
+ for (i = 1; i <= myNbdiscret; i++)
+ {
+ Coeff = myVB(c, i);
+ for (j = 1; j <= ncol; j++)
+ {
+ MyPoints(i, j) -= tmppoles(j) * Coeff;
+ }
+ }
+ }
+
+ Standard_Real e1, e2, e3;
+ for (i = 1; i <= myNbdiscret; i++)
+ {
+ i2 = 1;
+ for (j = 1; j<= myNbP; j++) {
+ e1 = MyPoints(i, i2);
+ e2 = MyPoints(i, i2+1);
+ e3 = MyPoints(i, i2+2);
+ err3d = e1*e1+e2*e2+e3*e3;
+ MaxE3d = Max(MaxE3d, err3d);
+ F += err3d;
+ i2 += 3;
+ }
+ for (j = 1; j<= myNbP2d; j++) {
+ e1 = MyPoints(i, i2);
+ e2 = MyPoints(i, i2+1);
+ err2d = e1*e1+e2*e2;
+ MaxE2d = Max(MaxE2d, err2d);
+ F += err2d;
+ i2 += 2;
+ }
+ }
+
+ MaxE3d = Sqrt(MaxE3d);
+ MaxE2d = Sqrt(MaxE2d);
+
+}
+
+
+//=======================================================================
+//function : IsDone
+//purpose :
+//=======================================================================
+
+Standard_Boolean AppCont_LeastSquare::IsDone() const
+{
+ return myDone;
+}
+++ /dev/null
-// Created on: 1995-03-14
-// Created by: Modelistation
-// Copyright (c) 1995-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.
-
-#ifndef OCCT_DEBUG
-#define No_Standard_OutOfRange
-#define No_Standard_RangeError
-#endif
-
-
-
-#include <math.hxx>
-#include <math_Vector.hxx>
-#include <math_Matrix.hxx>
-#include <TColgp_Array1OfPnt.hxx>
-#include <TColgp_Array1OfPnt2d.hxx>
-#include <gp_Pnt2d.hxx>
-#include <gp_Pnt.hxx>
-#include <gp_Vec.hxx>
-#include <gp_Vec2d.hxx>
-#include <TColgp_Array1OfVec.hxx>
-#include <TColgp_Array1OfVec2d.hxx>
-#include <AppParCurves_MultiPoint.hxx>
-#include <AppCont_ContMatrices.hxx>
-#include <PLib.hxx>
-
-
-
-
-//=======================================================================
-//function : AppCont_LeastSquare
-//purpose :
-//=======================================================================
-
-AppCont_LeastSquare::AppCont_LeastSquare
- (const MultiLine& SSP,
- const Standard_Real U0,
- const Standard_Real U1,
- const AppParCurves_Constraint FirstCons,
- const AppParCurves_Constraint LastCons,
- const Standard_Integer Deg,
- const Standard_Integer NbPoints):
- SCU(Deg+1),
- Points(1, NbPoints, 1, NbBColumns(SSP)),
- Poles(1, Deg+1, 1, NbBColumns(SSP), 0.0),
- myParam(1, NbPoints),
- VB(1, Deg+1, 1, NbPoints)
-
-{
- Done = Standard_False;
- Degre = Deg;
- math_Matrix InvM(1, Deg+1, 1, Deg+1);
- Standard_Integer i, j, k, c, i2;
- Standard_Integer classe = Deg+1, cl1 = Deg;
- Standard_Real U, dU, Coeff, Coeff2;
- Standard_Real IBij, IBPij;
-
- Standard_Integer FirstP = 1, LastP = NbPoints;
- Standard_Integer nbcol = NbBColumns(SSP);
- math_Matrix B(1, classe, 1, nbcol, 0.0);
- Standard_Integer bdeb = 1, bfin = classe;
- AppParCurves_Constraint myFirstC = FirstCons, myLastC = LastCons;
- nbP = LineTool::NbP3d(SSP);
- nbP2d = LineTool::NbP2d(SSP);
- Standard_Integer mynbP = nbP, mynbP2d = nbP2d;
- if (nbP == 0) mynbP = 1;
- if (nbP2d == 0) mynbP2d = 1;
-
- Standard_Integer i2plus1, i2plus2;
- Nbdiscret = NbPoints;
- TColgp_Array1OfPnt TabP(1, mynbP);
- TColgp_Array1OfVec TabV(1, mynbP);
- TColgp_Array1OfPnt2d TabP2d(1, mynbP2d);
- TColgp_Array1OfVec2d TabV2d(1, mynbP2d);
-
- Standard_Boolean Ok;
- if (myFirstC == AppParCurves_TangencyPoint) {
- if (nbP != 0 && nbP2d != 0) Ok=LineTool::D1(SSP, U0, TabV, TabV2d);
- else if (nbP != 0) Ok=LineTool::D1(SSP, U0, TabV);
- else Ok=LineTool::D1(SSP, U0, TabV2d);
- if (!Ok) myFirstC = AppParCurves_PassPoint;
- }
-
- if (myLastC == AppParCurves_TangencyPoint) {
- if (nbP != 0 && nbP2d != 0) Ok=LineTool::D1(SSP, U1, TabV, TabV2d);
- else if (nbP != 0) Ok=LineTool::D1(SSP, U1, TabV);
- else Ok=LineTool::D1(SSP, U1, TabV2d);
- if (!Ok) myLastC = AppParCurves_PassPoint;
- }
-
- math_Vector GaussP(1, NbPoints), GaussW(1, NbPoints);
- math::GaussPoints(NbPoints, GaussP);
- math::GaussWeights(NbPoints, GaussW);
-
- math_Vector TheWeights(1, NbPoints), VBParam(1, NbPoints);
-
- dU = 0.5*(U1-U0);
-
- // calcul et mise en ordre des parametres et des poids:
- for (i = FirstP; i <= LastP; i++) {
- U = 0.5*(U1+U0) + dU*GaussP(i);
- if (i <= (NbPoints+1)/2) {
- myParam(LastP-i+1) = U;
- VBParam(LastP-i+1) = 0.5*(1 + GaussP(i));
- TheWeights(LastP-i+1) = 0.5*GaussW(i);
- }
- else {
- VBParam(i-(NbPoints+1)/2) = 0.5*(1 + GaussP(i));
- myParam(i-(NbPoints+1)/2) = U;
- TheWeights(i-(NbPoints+1)/2) = 0.5*GaussW(i);
- }
- }
-
-
- for (i = FirstP; i <= LastP; i++) {
- U = myParam(i);
- if (nbP != 0 && nbP2d != 0) LineTool::Value(SSP, U, TabP, TabP2d);
- else if (nbP != 0) LineTool::Value(SSP, U, TabP);
- else LineTool::Value(SSP, U, TabP2d);
-
- i2 = 1;
- for (j = 1; j <= nbP; j++) {
- (TabP(j)).Coord(Points(i, i2), Points(i, i2+1), Points(i, i2+2));
- i2 += 3;
- }
- for (j = 1; j <= nbP2d; j++) {
- (TabP2d(j)).Coord(Points(i, i2), Points(i, i2+1));
- i2 += 2;
- }
- }
-
- // Calcul du VB ( Valeur des fonctions de Bernstein):
-
-// for (i = 1; i <= classe; i++) {
-// for (j = 1; j <= NbPoints; j++) {
-// VB(i,j)=PLib::Binomial(cl1,i-1)*Pow((1-VBParam(j)),classe-i)*
-// Pow(VBParam(j),i-1);
-// }
-// }
-
- VBernstein(classe, NbPoints, VB);
-
- // Traitement du second membre:
-
- Standard_Real *tmppoints, *tmpbis;
- tmppoints = new Standard_Real[nbcol];
-
- for (c = 1; c <= classe; c++) {
- tmpbis = tmppoints;
- for (k = 1; k <= nbcol; k++, tmpbis++) {
- *tmpbis = 0.0;
- }
- for (i = 1; i <= NbPoints; i++) {
- Coeff = TheWeights(i)*VB(c, i);
- tmpbis = tmppoints;
- for (j = 1; j <= nbcol; j++, tmpbis++) {
- *tmpbis += Points(i, j)*Coeff;
- //B(c, j) += Points(i, j)*Coeff;
- }
- }
- tmpbis = tmppoints;
- for (k = 1; k <= nbcol; k++, tmpbis++) {
- B(c, k) += *tmpbis;
- }
- }
-
- delete [] tmppoints;
-
- if (myFirstC == AppParCurves_NoConstraint &&
- myLastC == AppParCurves_NoConstraint) {
-
- math_Matrix InvM(1, classe, 1, classe);
- InvMMatrix(classe, InvM);
- // Calcul direct des poles:
-
- for (i = 1; i <= classe; i++) {
- for (j = 1; j <= classe; j++) {
- IBij = InvM(i, j);
- for (k = 1; k <= nbcol; k++) {
- Poles(i, k) += IBij * B(j, k);
- }
- }
- }
- }
-
-
- else {
- math_Matrix M(1, classe, 1, classe);
- MMatrix(classe, M);
-
- if (myFirstC == AppParCurves_PassPoint ||
- myFirstC == AppParCurves_TangencyPoint) {
-
- if (nbP != 0 && nbP2d != 0) LineTool::Value(SSP, U0, TabP, TabP2d);
- else if (nbP != 0) LineTool::Value(SSP, U0, TabP);
- else LineTool::Value(SSP, U0, TabP2d);
- i2 =1;
- for (k = 1; k<= nbP; k++) {
- (TabP(k)).Coord(Poles(1, i2), Poles(1, i2+1), Poles(1, i2+2));
- i2 += 3;
- }
- for (k = 1; k<= nbP2d; k++) {
- (TabP2d(k)).Coord(Poles(1, i2), Poles(1, i2+1));
- i2 += 2;
- }
-
- }
-
- if (myLastC == AppParCurves_PassPoint ||
- myLastC == AppParCurves_TangencyPoint) {
-
- i2 = 1;
- if (nbP != 0 && nbP2d != 0) LineTool::Value(SSP, U1, TabP, TabP2d);
- else if (nbP != 0) LineTool::Value(SSP, U1, TabP);
- else LineTool::Value(SSP, U1, TabP2d);
- for (k = 1; k<= nbP; k++) {
- (TabP(k)).Coord(Poles(classe,i2),
- Poles(classe,i2+1),
- Poles(classe,i2+2));
- i2 += 3;
- }
- for (k = 1; k<= nbP2d; k++) {
- (TabP2d(k)).Coord(Poles(classe, i2), Poles(classe, i2+1));
- i2 += 2;
- }
- }
-
-
-
- if (myFirstC == AppParCurves_PassPoint) {
- bdeb = 2;
- // mise a jour du second membre:
- for (i = 1; i <= classe; i++) {
- Coeff = M(i, 1);
- for (k = 1; k <= nbcol; k++) {
- B(i, k) -= Poles(1, k)*Coeff;
- }
- }
- }
-
-
- if (myLastC == AppParCurves_PassPoint) {
- bfin = cl1;
- for (i = 1; i <= classe; i++) {
- Coeff = M(i, classe);
- for (k = 1; k <= nbcol; k++) {
- B(i, k) -= Poles(classe, k)*Coeff;
- }
- }
- }
-
-
- if (myFirstC == AppParCurves_TangencyPoint) {
- // On fixe le second pole::
- bdeb = 3;
- if (nbP != 0 && nbP2d != 0) LineTool::D1(SSP, U0, TabV, TabV2d);
- else if (nbP != 0) LineTool::D1(SSP, U0, TabV);
- else LineTool::D1(SSP, U0, TabV2d);
- i2 = 1;
- Coeff = (U1-U0)/Degre;
- for (k = 1; k<= nbP; k++) {
- i2plus1 = i2+1; i2plus2 = i2+2;
- Poles(2, i2) = Poles(1, i2) + TabV(k).X()*Coeff;
- Poles(2, i2plus1) = Poles(1, i2plus1) + TabV(k).Y()*Coeff;
- Poles(2, i2plus2) = Poles(1, i2plus2) + TabV(k).Z()*Coeff;
- i2 += 3;
- }
- for (k = 1; k<= nbP2d; k++) {
- i2plus1 = i2+1;
- Poles(2, i2) = Poles(1, i2) + TabV2d(k).X()*Coeff;
- Poles(2, i2plus1) = Poles(1, i2plus1) + TabV2d(k).Y()*Coeff;
- i2 += 2;
- }
-
-
- for (i = 1; i <= classe; i++) {
- Coeff = M(i, 1); Coeff2 = M(i, 2);
- for (k = 1; k <= nbcol; k++) {
- B(i, k) -= Poles(1, k)*Coeff+Poles(2, k)*Coeff2;
- }
- }
- }
-
- if (myLastC == AppParCurves_TangencyPoint) {
- bfin = classe-2;
-
- if (nbP != 0 && nbP2d != 0) LineTool::D1(SSP, U1, TabV, TabV2d);
- else if (nbP != 0) LineTool::D1(SSP, U1, TabV);
- else LineTool::D1(SSP, U1, TabV2d);
- i2 = 1;
- Coeff = (U1-U0)/Degre;
- for (k = 1; k<= nbP; k++) {
- i2plus1 = i2+1; i2plus2 = i2+2;
- Poles(cl1,i2) = Poles(classe, i2) - TabV(k).X()*Coeff;
- Poles(cl1,i2plus1) = Poles(classe, i2plus1) - TabV(k).Y()*Coeff;
- Poles(cl1,i2plus2) = Poles(classe, i2plus2) - TabV(k).Z()*Coeff;
- i2 += 3;
- }
- for (k = 1; k<= nbP2d; k++) {
- i2plus1 = i2+1;
- Poles(cl1,i2) = Poles(classe, i2) - TabV2d(k).X()*Coeff;
- Poles(cl1,i2plus1) = Poles(classe, i2plus1) - TabV2d(k).Y()*Coeff;
- i2 += 2;
- }
-
- for (i = 1; i <= classe; i++) {
- Coeff = M(i, classe); Coeff2 = M(i, cl1);
- for (k = 1; k <= nbcol; k++) {
- B(i, k) -= Poles(classe, k)*Coeff + Poles(cl1, k)*Coeff2;
- }
- }
- }
-
- if (bdeb <= bfin) {
- math_Matrix B2(bdeb, bfin, 1, B.UpperCol(), 0.0);
-
- for (i = bdeb; i <= bfin; i++) {
- for (j = 1; j <= classe; j++) {
- Coeff = M(i, j);
- for (k = 1; k <= nbcol; k++) {
- B2(i, k) += B(j, k)*Coeff;
- }
- }
- }
-
-
- // Resolution:
- // ===========
- math_Matrix IBP(bdeb, bfin, bdeb, bfin);
-
- // dans IBPMatrix at IBTMatrix ne sont stockees que les resultats pour
- // une classe inferieure ou egale a 26 (pour l instant du moins.)
-
- if (bdeb == 2 && bfin == classe-1 && classe <= 26) {
- IBPMatrix(classe, IBP);
- }
- else if (bdeb == 3 && bfin == classe-2 && classe <= 26) {
- IBTMatrix(classe, IBP);
- }
- else {
- math_Matrix MP(1, classe, bdeb, bfin);
-
- for (i = 1; i <= classe; i++) {
- for (j = bdeb; j <= bfin; j++) {
- MP(i, j) = M(i, j);
- }
- }
- math_Matrix IBP1(bdeb, bfin, bdeb, bfin);
- IBP1 = MP.Transposed()*MP;
- IBP = IBP1.Inverse();
- }
-
-
- Done = Standard_True;
- for (i = bdeb; i <= bfin; i++) {
- for (j = bdeb; j <= bfin; j++) {
- IBPij = IBP(i, j);;
- for (k = 1; k<= nbcol; k++) {
- Poles(i, k) += IBPij * B2(j, k);
- }
- }
- }
- }
- }
-}
-
-
-
-
-//=======================================================================
-//function : NbBColumns
-//purpose :
-//=======================================================================
-
-Standard_Integer AppCont_LeastSquare::NbBColumns(
- const MultiLine& SSP) const
-{
- Standard_Integer BCol;
- BCol = (LineTool::NbP3d(SSP))*3 +
- (LineTool::NbP2d(SSP))*2;
- return BCol;
-}
-
-
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
-
-const AppParCurves_MultiCurve& AppCont_LeastSquare::Value()
-{
-
- Standard_Integer i, j, j2;
- gp_Pnt Pt;
- gp_Pnt2d Pt2d;
- Standard_Integer ideb = 1, ifin = Degre+1;
-
- // On met le resultat dans les curves correspondantes
- for (i = ideb; i <= ifin; i++) {
- j2 = 1;
- AppParCurves_MultiPoint MPole(nbP, nbP2d);
- for (j = 1; j <= nbP; j++) {
- Pt.SetCoord(Poles(i, j2), Poles(i, j2+1), Poles(i,j2+2));
- MPole.SetPoint(j, Pt);
- j2 += 3;
- }
- for (j = nbP+1;j <= nbP+nbP2d; j++) {
- Pt2d.SetCoord(Poles(i, j2), Poles(i, j2+1));
- MPole.SetPoint2d(j, Pt2d);
- j2 += 2;
- }
- SCU.SetValue(i, MPole);
- }
- return SCU;
-}
-
-
-
-//=======================================================================
-//function : Error
-//purpose :
-//=======================================================================
-
-void AppCont_LeastSquare::Error(Standard_Real& F,
- Standard_Real& MaxE3d,
- Standard_Real& MaxE2d) const
-{
- Standard_Integer i, j, k, c, i2, classe = Degre+1;
-// Standard_Real Coeff, val = 0.0, err3d = 0.0, err2d =0.0;
- Standard_Real Coeff, err3d = 0.0, err2d =0.0;
- Standard_Integer ncol = Points.UpperCol()-Points.LowerCol()+1;
-
- math_Matrix MyPoints(1, Nbdiscret, 1, ncol);
- MyPoints = Points;
-
- MaxE3d = MaxE2d = F = 0.0;
-
- Standard_Real *tmppoles, *tmpbis;
- tmppoles = new Standard_Real[ncol];
-
- for (c = 1; c <= classe; c++) {
- tmpbis = tmppoles;
- for (k = 1; k <= ncol; k++, tmpbis++) {
- *tmpbis = Poles(c, k);
- }
- for (i = 1; i <= Nbdiscret; i++) {
- Coeff = VB(c, i);
- tmpbis = tmppoles;
- for (j = 1; j <= ncol; j++, tmpbis++) {
- MyPoints(i, j) -= (*tmpbis)*Coeff; // Poles(c, j)*Coeff;
- }
- }
- }
- delete [] tmppoles;
-
- Standard_Real e1, e2, e3;
- for (i = 1; i <= Nbdiscret; i++) {
- i2 = 1;
- for (j = 1; j<= nbP; j++) {
- e1 = MyPoints(i, i2);
- e2 = MyPoints(i, i2+1);
- e3 = MyPoints(i, i2+2);
- err3d = e1*e1+e2*e2+e3*e3;
- MaxE3d = Max(MaxE3d, err3d);
- F += err3d;
- i2 += 3;
- }
- for (j = 1; j<= nbP2d; j++) {
- e1 = MyPoints(i, i2);
- e2 = MyPoints(i, i2+1);
- err2d = e1*e1+e2*e2;
- MaxE2d = Max(MaxE2d, err2d);
- F += err2d;
- i2 += 2;
- }
- }
-
- MaxE3d = Sqrt(MaxE3d);
- MaxE2d = Sqrt(MaxE2d);
-
-}
-
-
-//=======================================================================
-//function : IsDone
-//purpose :
-//=======================================================================
-
-Standard_Boolean AppCont_LeastSquare::IsDone() const
-{
- return Done;
-}
--- /dev/null
+// Created on: 1995-03-14
+// Created by: Modelistation
+// Copyright (c) 1995-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.
+
+#ifndef AppCont_LeastSquare_HeaderFile
+#define AppCont_LeastSquare_HeaderFile
+
+#include <AppCont_Function.hxx>
+#include <AppParCurves_MultiCurve.hxx>
+#include <math_Vector.hxx>
+#include <math_Matrix.hxx>
+#include <NCollection_Array1.hxx>
+#include <AppParCurves_Constraint.hxx>
+
+
+struct PeriodicityInfo
+{
+ Standard_Boolean isPeriodic;
+ Standard_Real myPeriod;
+};
+
+class AppCont_LeastSquare
+{
+public:
+
+ Standard_EXPORT AppCont_LeastSquare(const AppCont_Function& SSP,
+ const Standard_Real U0,
+ const Standard_Real U1,
+ const AppParCurves_Constraint FirstCons,
+ const AppParCurves_Constraint LastCons,
+ const Standard_Integer Deg,
+ const Standard_Integer NbPoints);
+
+ Standard_EXPORT const AppParCurves_MultiCurve& Value();
+
+ Standard_EXPORT void Error(Standard_Real& F,
+ Standard_Real& MaxE3d,
+ Standard_Real& MaxE2d) const;
+
+ Standard_EXPORT Standard_Boolean IsDone() const;
+
+private:
+
+ //! Fix border point evaluation.
+ void FixSingleBorderPoint(const AppCont_Function& theSSP,
+ const Standard_Real theU,
+ const Standard_Real theU0,
+ const Standard_Real theU1,
+ NCollection_Array1<gp_Pnt2d>& theFix2d,
+ NCollection_Array1<gp_Pnt>& theFix);
+
+ AppParCurves_MultiCurve mySCU;
+ math_Matrix myPoints;
+ math_Matrix myPoles;
+ math_Vector myParam;
+ math_Matrix myVB;
+ NCollection_Array1<PeriodicityInfo> myPerInfo;
+ Standard_Boolean myDone;
+ Standard_Integer myDegre;
+ Standard_Integer myNbdiscret, myNbP, myNbP2d;
+};
+
+#endif
AppCont_ContMatrices_2.cxx
AppCont_ContMatrices_3.cxx
AppCont_ContMatrices_4.cxx
+AppCont_Function.hxx
+AppCont_LeastSquare.hxx
+AppCont_LeastSquare.cxx
\ No newline at end of file
generic class ComputeLine, MyGradient;
- generic class ComputeCLine, MyLeastSquare;
+ generic class ComputeCLine;
----------------------------------------------
---Algorithms for BSpline curves construction:
-----------------------------------------------------------------
class FitAndDivide instantiates ComputeCLine from Approx
- (Function from AppCont, FunctionTool from AppCont);
+ (Function from AppCont);
class FitAndDivide2d instantiates ComputeCLine from Approx
- (Function2d from AppCont, FunctionTool2d from AppCont);
+ (Function from AppCont);
class SameParameter from Approx ;
-- commercial license or contractual agreement.
generic class ComputeCLine from Approx
- (MultiLine as any;
- LineTool as any)
+ (MultiLine as any)
---Purpose: Approximate a continous MultiLine with a cutting.
-- The Tool of the line is the tool from AppCont.
Vector from math
-
-private class MyLeastSquare instantiates LeastSquare from AppCont
- (MultiLine,
- LineTool);
-
is
currenttol2d: Real;
mycut: Boolean;
myfirstC: Constraint;
-mylastC: Constraint;
+mylastC: Constraint;
end ComputeCLine;
#include <Approx_ParametrizationType.hxx>
-#include Approx_MyLeastSquare_hxx
+#include <AppCont_LeastSquare.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <AppParCurves_Constraint.hxx>
#include <Approx_Status.hxx>
Standard_Boolean Finish = Standard_False,
begin = Standard_True, Ok = Standard_False;
Standard_Real thetol3d = Precision::Confusion(), thetol2d = Precision::Confusion();
- UFirst = LineTool::FirstParameter(Line);
- ULast = LineTool::LastParameter(Line);
+ UFirst = Line.FirstParameter();
+ ULast = Line.LastParameter();
Standard_Real TolU = (ULast-UFirst)*1.e-05;
Standard_Real myfirstU = UFirst;
Standard_Real mylastU = ULast;
for (deg = mydegremin; deg <= mydegremax; deg++) {
AppParCurves_MultiCurve mySCU(deg+1);
- Approx_MyLeastSquare LSquare(Line, Ufirst, Ulast, myfirstC, mylastC,
- deg, NbPoints);
+ AppCont_LeastSquare LSquare(Line, Ufirst, Ulast, myfirstC, mylastC, deg, NbPoints);
mydone = LSquare.IsDone();
if (mydone) {
LSquare.Error(Fv, TheTol3d, TheTol2d);
List from TCollection (OffsetWire from BRepFill);
private class ApproxSeewing;
- private class MultiLine;
-
- private class MultiLineTool;
+ imported MultiLine;
private class ComputeCLine instantiates
- ComputeCLine from Approx ( MultiLine, MultiLineTool);
+ ComputeCLine from Approx (MultiLine);
private class TrimSurfaceTool;
+++ /dev/null
--- Created on: 1994-11-14
--- Created by: Bruno DUMORTIER
--- Copyright (c) 1994-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.
-
-private class MultiLine from BRepFill
-
- ---Purpose: Private class used to compute the 3d curve and the
- -- two 2d curves resulting from the intersection of a
- -- surface of linear extrusion( Bissec, Dz) and the 2
- -- faces.
- -- This 3 curves will have the same parametrization
- -- as the Bissectrice.
- -- This class is to be send to an approximation
- -- routine.
-
-uses
- Face from TopoDS,
- Edge from TopoDS,
- Curve from Geom,
- Curve from Geom2d,
- Curve from Geom2dAdaptor,
- Pnt from gp,
- Pnt2d from gp,
- Shape from GeomAbs
-
-raises
- DomainError from Standard
-
-is
- Create;
-
- Create( Face1, Face2 : Face from TopoDS;
- Edge1, Edge2 : Edge from TopoDS;
- Inv1 , Inv2 : Boolean from Standard;
- Bissec : Curve from Geom2d );
-
- IsParticularCase(me)
- returns Boolean from Standard
- ---Purpose: Search if the Projection of the Bissectrice on the
- -- faces needs an approximation or not.
- -- Returns true if the approximation is not needed.
- is static;
-
- Continuity (me) returns Shape from GeomAbs
- ---Purpose: Returns the continuity betwwen the two faces
- -- seShape from GeomAbsparated by myBis.
- is static;
-
- Curves(me; Curve : in out Curve from Geom;
- PCurve1 : in out Curve from Geom2d;
- PCurve2 : in out Curve from Geom2d)
- raises
- DomainError from Standard
- ---Purpose: raises if IsParticularCase is <False>.
- is static;
-
- FirstParameter(me)
- ---Purpose: returns the first parameter of the Bissectrice.
- returns Real from Standard is static;
-
- LastParameter(me)
- ---Purpose: returns the last parameter of the Bissectrice.
- returns Real from Standard is static;
-
- Value ( me; U : Real from Standard)
- ---Purpose: Returns the current point on the 3d curve
- returns Pnt from gp is static;
-
- ValueOnF1(me; U : Real from Standard)
- ---Purpose: returns the current point on the PCurve of the
- -- first face
- returns Pnt2d from gp is static;
-
- ValueOnF2(me; U : Real from Standard)
- ---Purpose: returns the current point on the PCurve of the
- -- first face
- returns Pnt2d from gp is static;
-
- Value3dOnF1OnF2(me;
- U : Real from Standard;
- P3d : in out Pnt from gp;
- PF1 : in out Pnt2d from gp;
- PF2 : in out Pnt2d from gp)
- is static;
-
-
-fields
- myFace1 : Face from TopoDS;
- myFace2 : Face from TopoDS;
- myU1 : Curve from Geom2dAdaptor;
- myV1 : Curve from Geom2dAdaptor;
- myU2 : Curve from Geom2dAdaptor;
- myV2 : Curve from Geom2dAdaptor;
- myIsoU1 : Boolean from Standard;
- myIsoU2 : Boolean from Standard;
- myBis : Curve from Geom2dAdaptor;
- myKPart : Integer from Standard;
- myCont : Shape from GeomAbs;
-
-end MultiLine;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-#include <BRepFill_MultiLine.ixx>
+#include <BRepFill_MultiLine.hxx>
#include <BRepIntCurveSurface_Inter.hxx>
#include <gp.hxx>
}
-
-
//=======================================================================
//function : BRepFill_MultiLine
//purpose :
BRepFill_MultiLine::BRepFill_MultiLine()
{
+ myNbPnt2d = 2;
+ myNbPnt = 1;
}
//=======================================================================
BRepFill_MultiLine::BRepFill_MultiLine(const TopoDS_Face& Face1,
- const TopoDS_Face& Face2,
- const TopoDS_Edge& Edge1,
- const TopoDS_Edge& Edge2,
- const Standard_Boolean Inv1,
- const Standard_Boolean Inv2,
- const Handle(Geom2d_Curve)& Bissec) :
-myFace1(Face1 ),
-myFace2(Face2 ),
-myBis (Bissec),
-myKPart(0)
+ const TopoDS_Face& Face2,
+ const TopoDS_Edge& Edge1,
+ const TopoDS_Edge& Edge2,
+ const Standard_Boolean Inv1,
+ const Standard_Boolean Inv2,
+ const Handle(Geom2d_Curve)& Bissec)
+: myFace1(Face1 ),
+ myFace2(Face2 ),
+ myBis (Bissec),
+ myKPart(0)
{
+ myNbPnt2d = 2;
+ myNbPnt = 1;
+
// eval if myedges are IsoU or not
myIsoU1 = isIsoU(Face1, Edge1);
myIsoU2 = isIsoU(Face2, Edge2);
Vmax = Max(Vmax,V);
}
}
-
// return isos in their domain of restriction.
Handle(Geom_Curve) UU1, UU2, VV1, VV2;
{
return myCont;
}
+
+//=======================================================================
+//function : Value
+//purpose :
+//=======================================================================
+
+Standard_Boolean BRepFill_MultiLine::Value(const Standard_Real theT,
+ NCollection_Array1<gp_Pnt2d>& thePnt2d,
+ NCollection_Array1<gp_Pnt>& thePnt) const
+ {
+ thePnt(1) = Value(theT);
+ thePnt2d(1) = ValueOnF1(theT);
+ thePnt2d(2) = ValueOnF2(theT);
+ return Standard_True;
+ }
+
+//=======================================================================
+//function : Value
+//purpose :
+//=======================================================================
+
+Standard_Boolean BRepFill_MultiLine::D1(const Standard_Real /*theT*/,
+ NCollection_Array1<gp_Vec2d>& /*theVec2d*/,
+ NCollection_Array1<gp_Vec>& /*theVec*/) const
+{
+ return Standard_False;
+}
--- /dev/null
+// Created on: 1994-11-14
+// Created by: Bruno DUMORTIER
+// Copyright (c) 1994-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.
+
+#ifndef _BRepFill_MultiLine_HeaderFile
+#define _BRepFill_MultiLine_HeaderFile
+
+#include <AppCont_Function.hxx>
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Macro.hxx>
+
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Face.hxx>
+#include <Geom2dAdaptor_Curve.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Integer.hxx>
+#include <GeomAbs_Shape.hxx>
+#include <Handle_Geom2d_Curve.hxx>
+#include <Handle_Geom_Curve.hxx>
+#include <Standard_Real.hxx>
+
+class Standard_DomainError;
+class TopoDS_Face;
+class TopoDS_Edge;
+class Geom2d_Curve;
+class Geom_Curve;
+class gp_Pnt;
+class gp_Pnt2d;
+
+
+//! Class used to compute the 3d curve and the
+//! two 2d curves resulting from the intersection of a
+//! surface of linear extrusion( Bissec, Dz) and the 2
+//! faces.
+//! This 3 curves will have the same parametrization
+//! as the Bissectrice.
+//! This class is to be send to an approximation
+//! routine.
+class BRepFill_MultiLine : public AppCont_Function
+{
+public:
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT BRepFill_MultiLine();
+
+ Standard_EXPORT BRepFill_MultiLine(const TopoDS_Face& Face1, const TopoDS_Face& Face2, const TopoDS_Edge& Edge1, const TopoDS_Edge& Edge2, const Standard_Boolean Inv1, const Standard_Boolean Inv2, const Handle(Geom2d_Curve)& Bissec);
+
+ //! Search if the Projection of the Bissectrice on the
+ //! faces needs an approximation or not.
+ //! Returns true if the approximation is not needed.
+ Standard_EXPORT Standard_Boolean IsParticularCase() const;
+
+ //! Returns the continuity betwwen the two faces
+ //! seShape from GeomAbsparated by myBis.
+ Standard_EXPORT GeomAbs_Shape Continuity() const;
+
+ //! raises if IsParticularCase is <False>.
+ Standard_EXPORT void Curves (Handle(Geom_Curve)& Curve, Handle(Geom2d_Curve)& PCurve1, Handle(Geom2d_Curve)& PCurve2) const;
+
+ //! returns the first parameter of the Bissectrice.
+ Standard_EXPORT virtual Standard_Real FirstParameter() const;
+
+ //! returns the last parameter of the Bissectrice.
+ Standard_EXPORT virtual Standard_Real LastParameter() const;
+
+ //! Returns the current point on the 3d curve
+ Standard_EXPORT gp_Pnt Value (const Standard_Real U) const;
+
+ //! returns the current point on the PCurve of the
+ //! first face
+ Standard_EXPORT gp_Pnt2d ValueOnF1 (const Standard_Real U) const;
+
+ //! returns the current point on the PCurve of the
+ //! first face
+ Standard_EXPORT gp_Pnt2d ValueOnF2 (const Standard_Real U) const;
+
+ Standard_EXPORT void Value3dOnF1OnF2 (const Standard_Real U, gp_Pnt& P3d, gp_Pnt2d& PF1, gp_Pnt2d& PF2) const;
+
+ //! Returns the point at parameter <theU>.
+ Standard_EXPORT virtual Standard_Boolean Value(const Standard_Real theU,
+ NCollection_Array1<gp_Pnt2d>& thePnt2d,
+ NCollection_Array1<gp_Pnt>& thePnt) const;
+
+ //! Returns the derivative at parameter <theU>.
+ Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real theU,
+ NCollection_Array1<gp_Vec2d>& theVec2d,
+ NCollection_Array1<gp_Vec>& theVec) const;
+
+private:
+ TopoDS_Face myFace1;
+ TopoDS_Face myFace2;
+ Geom2dAdaptor_Curve myU1;
+ Geom2dAdaptor_Curve myV1;
+ Geom2dAdaptor_Curve myU2;
+ Geom2dAdaptor_Curve myV2;
+ Standard_Boolean myIsoU1;
+ Standard_Boolean myIsoU2;
+ Geom2dAdaptor_Curve myBis;
+ Standard_Integer myKPart;
+ GeomAbs_Shape myCont;
+};
+
+#endif // _BRepFill_MultiLine_HeaderFile
+++ /dev/null
--- Created on: 1994-11-14
--- Created by: Bruno DUMORTIER
--- Copyright (c) 1994-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.
-
-private class MultiLineTool from BRepFill
-
- ---Purpose: private class used to instantiate the continuous
- -- approximations routines.
-
-uses
- Pnt from gp,
- Pnt2d from gp,
- Vec from gp,
- Vec2d from gp,
- Array1OfPnt from TColgp,
- Array1OfPnt2d from TColgp,
- Array1OfVec from TColgp,
- Array1OfVec2d from TColgp,
- MultiLine from BRepFill
-
-is
-
- FirstParameter(myclass; ML: MultiLine from BRepFill)
- ---Purpose: returns the first parameter of the Line.
- returns Real from Standard;
-
-
- LastParameter(myclass; ML: MultiLine from BRepFill)
- ---Purpose: returns the last parameter of the Line.
- returns Real from Standard;
-
-
- NbP2d(myclass; ML: MultiLine from BRepFill)
- ---Purpose: Returns the number of 2d points of a MLine
- returns Integer from Standard;
-
-
- NbP3d(myclass; ML: MultiLine from BRepFill)
- ---Purpose: Returns the number of 3d points of a MLine.
- returns Integer from Standard;
-
-
- Value(myclass; ML : MultiLine from BRepFill;
- U : Real from Standard;
- tabPt: out Array1OfPnt from TColgp);
- ---Purpose: returns the 3d points of the multipoint <MPointIndex>
- -- when only 3d points exist.
-
-
- Value(myclass; ML : MultiLine from BRepFill;
- U : Real from Standard;
- tabPt2d: out Array1OfPnt2d from TColgp);
- ---Purpose: returns the 2d points of the multipoint <MPointIndex>
- -- when only 2d points exist.
-
-
- Value(myclass; ML : MultiLine from BRepFill;
- U : Real from Standard;
- tabPt : out Array1OfPnt from TColgp;
- tabPt2d: out Array1OfPnt2d from TColgp);
- ---Purpose: returns the 3d and 2d points of the multipoint
- -- <MPointIndex>.
-
-
- D1(myclass; ML : MultiLine from BRepFill;
- U : Real from Standard;
- tabV: out Array1OfVec from TColgp)
- returns Boolean from Standard;
- ---Purpose: returns the 3d derivative values of the multipoint
- -- <MPointIndex> when only 3d points exist.
- -- returns False if the derivative cannot be computed.
-
-
- D1(myclass; ML : MultiLine from BRepFill;
- U : Real from Standard;
- tabV2d: out Array1OfVec2d from TColgp)
- returns Boolean from Standard;
- ---Purpose: returns the 2d derivative values of the multipoint
- -- <MPointIndex> only when 2d points exist.
- -- returns False if the derivative cannot be computed.
-
-
- D1(myclass; ML : MultiLine from BRepFill;
- U : Real from Standard;
- tabV : out Array1OfVec from TColgp;
- tabV2d: out Array1OfVec2d from TColgp)
- returns Boolean from Standard;
- ---Purpose: returns the 3d and 2d derivative values of the
- -- multipoint <MPointIndex>.
- -- returns False if the derivative cannot be computed.
-
-end MultiLineTool;
-
+++ /dev/null
-// Created on: 1994-11-14
-// Created by: Bruno DUMORTIER
-// Copyright (c) 1994-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 <BRepFill_MultiLineTool.ixx>
-
-
-#include <gp_Pnt.hxx>
-#include <gp_Pnt2d.hxx>
-
-//=======================================================================
-//function : FirstParameter
-//purpose :
-//=======================================================================
-
-Standard_Real BRepFill_MultiLineTool::FirstParameter
-(const BRepFill_MultiLine& ML)
-{
- return ML.FirstParameter();
-}
-
-
-//=======================================================================
-//function : LastParameter
-//purpose :
-//=======================================================================
-
-Standard_Real BRepFill_MultiLineTool::LastParameter
-(const BRepFill_MultiLine& ML)
-{
- return ML.LastParameter();
-}
-
-
-//=======================================================================
-//function : NbP2d
-//purpose :
-//=======================================================================
-
-Standard_Integer BRepFill_MultiLineTool::NbP2d
-(const BRepFill_MultiLine&)
-{
- return 2;
-}
-
-
-//=======================================================================
-//function : NbP3d
-//purpose :
-//=======================================================================
-
-Standard_Integer BRepFill_MultiLineTool::NbP3d(const BRepFill_MultiLine&)
-{
- return 1;
-}
-
-
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
-
-void BRepFill_MultiLineTool::Value(const BRepFill_MultiLine& ,
- const Standard_Real,
- TColgp_Array1OfPnt&)
-{
-}
-
-
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
-
-void BRepFill_MultiLineTool::Value(const BRepFill_MultiLine&,
- const Standard_Real,
- TColgp_Array1OfPnt2d&)
-{
-}
-
-
-//=======================================================================
-//function : Value
-//purpose :
-//=======================================================================
-
-void BRepFill_MultiLineTool::Value(const BRepFill_MultiLine& ML,
- const Standard_Real U,
- TColgp_Array1OfPnt& tabPt,
- TColgp_Array1OfPnt2d& tabPt2d)
-{
- tabPt(1) = ML.Value(U);
- tabPt2d(1) = ML.ValueOnF1(U);
- tabPt2d(2) = ML.ValueOnF2(U);
-}
-
-
-//=======================================================================
-//function : D1
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepFill_MultiLineTool::D1(const BRepFill_MultiLine&,
- const Standard_Real,
- TColgp_Array1OfVec&)
-{
- return Standard_False;
-}
-
-
-//=======================================================================
-//function : D1
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepFill_MultiLineTool::D1(const BRepFill_MultiLine&,
- const Standard_Real,
- TColgp_Array1OfVec2d&)
-{
- return Standard_False;
-}
-
-
-//=======================================================================
-//function : D1
-//purpose :
-//=======================================================================
-
-Standard_Boolean BRepFill_MultiLineTool::D1(const BRepFill_MultiLine&,
- const Standard_Real,
- TColgp_Array1OfVec&,
- TColgp_Array1OfVec2d&)
-{
- return Standard_False;
-}
--- /dev/null
+BRepFill_MultiLine.hxx
+BRepFill_MultiLine.cxx
\ No newline at end of file
class MakeCurve_Function : public AppCont_Function
{
BiTgte_CurveOnEdge myCurve;
-
+
public :
-
- MakeCurve_Function(const BiTgte_CurveOnEdge& C) : myCurve(C) {};
+
+ MakeCurve_Function(const BiTgte_CurveOnEdge& C)
+ : myCurve(C)
+ {
+ myNbPnt = 1;
+ myNbPnt2d = 0;
+ }
Standard_Real FirstParameter() const
- {return myCurve.FirstParameter();}
-
+ {
+ return myCurve.FirstParameter();
+ }
+
Standard_Real LastParameter() const
- {return myCurve.LastParameter();}
-
- gp_Pnt Value(const Standard_Real t) const
- {return myCurve.Value(t);}
+ {
+ return myCurve.LastParameter();
+ }
+
+ Standard_Boolean Value(const Standard_Real theT,
+ NCollection_Array1<gp_Pnt2d>& /*thePnt2d*/,
+ NCollection_Array1<gp_Pnt>& thePnt) const
+ {
+ thePnt(1) = myCurve.Value(theT);
+ return Standard_True;
+ }
- Standard_Boolean D1(const Standard_Real /*t*/, gp_Pnt& /*P*/, gp_Vec& /*V*/) const
- {return Standard_False;}
+ Standard_Boolean D1(const Standard_Real /*theT*/,
+ NCollection_Array1<gp_Vec2d>& /*theVec2d*/,
+ NCollection_Array1<gp_Vec>& /*theVec*/) const
+ {
+ return Standard_False;
+ }
};
ang = -M_PI;
}
- if ((dist < tol) && (ang > angmax)) {
+ if ((dist - tol < Epsilon(1.0)) && (ang > angmax)) {
imin = index;
angmax = ang;
}
#include <GeomAbs_SurfaceType.hxx>
#include <GeomAbs_CurveType.hxx>
-#include <AppCont_Function2d.hxx>
+#include <AppCont_Function.hxx>
#include <Convert_CompBezierCurves2dToBSplineCurve2d.hxx>
#include <ElSLib.hxx>
#include <ElCLib.hxx>
if ( UCouture) {
if(S < U1 || S > U2)
- S = ElCLib::InPeriod(S, U1, U2);
+ {
+ S = ElCLib::InPeriod(S, U1, U2);
+ }
}
if ( VCouture) {
//classn : ProjLib_Function
//purpose :
//=======================================================================
-class ProjLib_Function : public AppCont_Function2d
+class ProjLib_Function : public AppCont_Function
{
Handle(Adaptor3d_HCurve) myCurve;
Handle(Adaptor3d_HSurface) mySurface;
-
+ Standard_Boolean myIsPeriodic[2];
+ Standard_Real myPeriod[2];
public :
Standard_Real myU1,myU2,myV1,myV2;
Standard_Boolean UCouture,VCouture;
-
+
ProjLib_Function(const Handle(Adaptor3d_HCurve)& C,
- const Handle(Adaptor3d_HSurface)& S) :
- myCurve(C), mySurface(S),
+ const Handle(Adaptor3d_HSurface)& S)
+: myCurve(C),
+ mySurface(S),
myU1(0.0),
myU2(0.0),
myV1(0.0),
myV2(0.0),
UCouture(Standard_False),
VCouture(Standard_False)
- {Function_SetUVBounds(myU1,myU2,myV1,myV2,UCouture,VCouture,myCurve,mySurface);}
-
+ {
+ myNbPnt = 0;
+ myNbPnt2d = 1;
+ Function_SetUVBounds(myU1,myU2,myV1,myV2,UCouture,VCouture,myCurve,mySurface);
+ myIsPeriodic[0] = mySurface->IsUPeriodic();
+ myIsPeriodic[1] = mySurface->IsVPeriodic();
+
+ if (myIsPeriodic[0])
+ myPeriod[0] = mySurface->UPeriod();
+ else
+ myPeriod[0] = 0.0;
+
+ if (myIsPeriodic[1])
+ myPeriod[1] = mySurface->VPeriod();
+ else
+ myPeriod[1] = 0.0;
+ }
+
+ void PeriodInformation(const Standard_Integer theDimIdx,
+ Standard_Boolean& IsPeriodic,
+ Standard_Real& thePeriod) const
+ {
+ IsPeriodic = myIsPeriodic[theDimIdx - 1];
+ thePeriod = myPeriod[theDimIdx - 1];
+ }
+
Standard_Real FirstParameter() const
- {return (myCurve->FirstParameter() + 1.e-9);}
-
+ {
+ return (myCurve->FirstParameter());
+ }
+
Standard_Real LastParameter() const
- {return (myCurve->LastParameter() -1.e-9);}
-
-
- gp_Pnt2d Value(const Standard_Real t) const
- {return Function_Value(t,myCurve,mySurface,myU1,myU2,myV1,myV2,UCouture,VCouture);}
-
- Standard_Boolean D1(const Standard_Real t, gp_Pnt2d& P, gp_Vec2d& V) const
- {return Function_D1(t,P,V,myCurve,mySurface,myU1,myU2,myV1,myV2,UCouture,VCouture);}
+ {
+ return (myCurve->LastParameter());
+ }
+
+ Standard_Boolean Value(const Standard_Real theT,
+ NCollection_Array1<gp_Pnt2d>& thePnt2d,
+ NCollection_Array1<gp_Pnt>& /*thePnt*/) const
+ {
+ thePnt2d(1) = Function_Value(theT, myCurve, mySurface, myU1, myU2, myV1, myV2, UCouture, VCouture);
+ return Standard_True;
+ }
+
+ gp_Pnt2d Value(const Standard_Real theT) const
+ {
+ return Function_Value(theT, myCurve, mySurface, myU1, myU2, myV1, myV2, UCouture, VCouture);
+ }
+
+ Standard_Boolean D1(const Standard_Real theT,
+ NCollection_Array1<gp_Vec2d>& theVec2d,
+ NCollection_Array1<gp_Vec>& /*theVec*/) const
+ {
+ gp_Pnt2d aPnt2d;
+ gp_Vec2d aVec2d;
+ Standard_Boolean isOk = Function_D1(theT, aPnt2d,aVec2d, myCurve, mySurface, myU1, myU2, myV1, myV2, UCouture, VCouture);
+ theVec2d(1) = aVec2d;
+ return isOk;
+ }
};
//=======================================================================
Conv.AddCurve(Poles2d);
}
-
- //mise a jour des fields de ProjLib_Approx
+
+ //mise a jour des fields de ProjLib_Approx
Conv.Perform();
-
NbPoles = Conv.NbPoles();
NbKnots = Conv.NbKnots();
- //7626
if(NbPoles <= 0 || NbPoles > 100000)
- return;
+ return;
if(NbKnots <= 0 || NbKnots > 100000)
- return;
+ return;
TColgp_Array1OfPnt2d NewPoles(1,NbPoles);
TColStd_Array1OfReal NewKnots(1,NbKnots);
TColStd_Array1OfInteger NewMults(1,NbKnots);
-
+
Conv.KnotsAndMults(NewKnots,NewMults);
Conv.Poles(NewPoles);
-
+
BSplCLib::Reparametrize(C->FirstParameter(),
- C->LastParameter(),
- NewKnots);
-
+ C->LastParameter(),
+ NewKnots);
+
+ /*cout << endl;
+ for (int i = 1; i <= NbPoles; i++)
+ {
+ cout << NewPoles.Value(i).X() << " " << NewPoles.Value(i).Y() << endl;
+ }
+ cout << endl; */
+
// il faut recadrer les poles de debut et de fin:
// ( Car pour les problemes de couture, on a du ouvrir l`intervalle
// de definition de la courbe.)
// On choisit de calculer ces poles par prolongement de la courbe
// approximee.
-
- gp_Pnt2d P;
- Standard_Real U;
-
- U = C->FirstParameter() - 1.e-9;
- BSplCLib::D0(U,
- 0,
- Conv.Degree(),
- Standard_False,
- NewPoles,
- BSplCLib::NoWeights(),
- NewKnots,
- NewMults,
- P);
- NewPoles.SetValue(1,P);
- U = C->LastParameter() + 1.e-9;
- BSplCLib::D0(U,
- 0,
- Conv.Degree(),
- Standard_False,
- NewPoles,
- BSplCLib::NoWeights(),
- NewKnots,
- NewMults,
- P);
- NewPoles.SetValue(NbPoles,P);
myBSpline = new Geom2d_BSplineCurve (NewPoles,
- NewKnots,
- NewMults,
- Conv.Degree());
+ NewKnots,
+ NewMults,
+ Conv.Degree());
}
else {
Standard_Integer NbCurves = Fit.NbMultiCurves();
// commercial license or contractual agreement.
#include <ProjLib_ComputeApproxOnPolarSurface.hxx>
-#include <AppCont_Function2d.hxx>
+#include <AppCont_Function.hxx>
#include <ElSLib.hxx>
#include <ElCLib.hxx>
#include <BSplCLib.hxx>
//purpose : (OCC217 - apo)- This class produce interface to call "gp_Pnt2d Function_Value(...)"
//=======================================================================
-class ProjLib_PolarFunction : public AppCont_Function2d
+class ProjLib_PolarFunction : public AppCont_Function
{
Handle(Adaptor3d_HCurve) myCurve;
- Handle(Adaptor2d_HCurve2d) myInitialCurve2d ;
- Handle(Adaptor3d_HSurface) mySurface ;
- //OCC217
- Standard_Real myTolU, myTolV;
- Standard_Real myDistTol3d;
- //Standard_Real myTolerance ;
-
+ Handle(Adaptor2d_HCurve2d) myInitialCurve2d;
+ Handle(Adaptor3d_HSurface) mySurface;
+ Standard_Real myTolU, myTolV;
+ Standard_Real myDistTol3d;
+
public :
-
+
ProjLib_PolarFunction(const Handle(Adaptor3d_HCurve) & C,
- const Handle(Adaptor3d_HSurface)& Surf,
- const Handle(Adaptor2d_HCurve2d)& InitialCurve2d,
- //OCC217
- const Standard_Real Tol3d) :
- //const Standard_Real Tolerance) :
- myCurve(C),
+ const Handle(Adaptor3d_HSurface)& Surf,
+ const Handle(Adaptor2d_HCurve2d)& InitialCurve2d,
+ const Standard_Real Tol3d)
+: myCurve(C),
myInitialCurve2d(InitialCurve2d),
mySurface(Surf),
- //OCC217
myTolU(Surf->UResolution(Tol3d)),
myTolV(Surf->VResolution(Tol3d)),
- myDistTol3d(100.0*Tol3d){} ;
- //myTolerance(Tolerance){} ;
-
+ myDistTol3d(100.0*Tol3d)
+ {
+ myNbPnt = 0;
+ myNbPnt2d = 1;
+ }
+
~ProjLib_PolarFunction() {}
-
+
Standard_Real FirstParameter() const
- {return (myCurve->FirstParameter()/*+1.e-9*/);}
-
+ {
+ return myCurve->FirstParameter();
+ }
+
Standard_Real LastParameter() const
- {return (myCurve->LastParameter()/*-1.e-9*/);}
-
- gp_Pnt2d Value(const Standard_Real t) const {
- return Function_Value
- (t,mySurface,myCurve,myInitialCurve2d,myDistTol3d,myTolU,myTolV) ; //OCC217
- //(t,mySurface,myCurve,myInitialCurve2d,myTolerance) ;
+ {
+ return myCurve->LastParameter();
}
-
-// Standard_Boolean D1(const Standard_Real t, gp_Pnt2d& P, gp_Vec2d& V) const
- Standard_Boolean D1(const Standard_Real , gp_Pnt2d& , gp_Vec2d& ) const
+
+ Standard_Boolean Value(const Standard_Real theT,
+ NCollection_Array1<gp_Pnt2d>& thePnt2d,
+ NCollection_Array1<gp_Pnt>& /*thePnt*/) const
+ {
+ thePnt2d(1) = Function_Value(theT, mySurface, myCurve, myInitialCurve2d, myDistTol3d, myTolU, myTolV);
+ return Standard_True;
+ }
+
+ Standard_Boolean D1(const Standard_Real /*theT*/,
+ NCollection_Array1<gp_Vec2d>& /*theVec2d*/,
+ NCollection_Array1<gp_Vec>& /*theVec*/) const
{return Standard_False;}
};
//update of fields of ProjLib_Approx
Standard_Integer NbKnots = NbCurves + 1;
-
- // The start and end nodes are not correct : Cf: opening of the interval
- //Knots( 1) -= 1.e-9;
- //Knots(NbKnots) += 1.e-9;
-
-
+
TColStd_Array1OfInteger Mults( 1, NbKnots);
Mults.Init(MaxDeg);
Mults.SetValue( 1, MaxDeg + 1);
Handle(Adaptor3d_HCurve) myCurve;
gp_Ax3 myPlane;
gp_Dir myDirection;
-
- public :
-
+
+public :
+
ProjLib_OnPlane(const Handle(Adaptor3d_HCurve)& C,
- const gp_Ax3& Pl,
- const gp_Dir& D)
- : myCurve(C), myPlane(Pl), myDirection(D)
- {}
+ const gp_Ax3& Pl,
+ const gp_Dir& D)
+: myCurve(C),
+ myPlane(Pl),
+ myDirection(D)
+ {
+ myNbPnt = 1;
+ myNbPnt2d = 0;
+ }
Standard_Real FirstParameter() const
{return myCurve->FirstParameter();}
Standard_Real LastParameter() const
{return myCurve->LastParameter();}
- gp_Pnt Value( const Standard_Real t) const
- {return OnPlane_Value(t,myCurve,myPlane,myDirection);}
+ Standard_Boolean Value(const Standard_Real theT,
+ NCollection_Array1<gp_Pnt2d>& /*thePnt2d*/,
+ NCollection_Array1<gp_Pnt>& thePnt) const
+ {
+ thePnt(1) = OnPlane_Value(theT, myCurve, myPlane, myDirection);
+ return Standard_True;
+ }
- Standard_Boolean D1(const Standard_Real t, gp_Pnt& P, gp_Vec& V) const
- {return OnPlane_D1(t,P,V,myCurve,myPlane,myDirection);}
+ Standard_Boolean D1(const Standard_Real theT,
+ NCollection_Array1<gp_Vec2d>& /*theVec2d*/,
+ NCollection_Array1<gp_Vec>& theVec) const
+ {
+ gp_Pnt aDummyPnt;
+ return OnPlane_D1(theT, aDummyPnt, theVec(1),myCurve,myPlane,myDirection);
+ }
};
public :
ProjLib_OnSurface(const Handle(Adaptor3d_HCurve) & C,
- const Handle(Adaptor3d_HSurface) & S)
- : myCurve(C)
- {Standard_Real U = myCurve->FirstParameter();
- gp_Pnt P = myCurve->Value(U);
- Standard_Real Tol = Precision::PConfusion();
- myExtPS = new Extrema_ExtPS(P,S->Surface(),Tol,Tol);}
+ const Handle(Adaptor3d_HSurface) & S)
+ : myCurve(C)
+ {
+ myNbPnt = 1;
+ myNbPnt2d = 0;
+ Standard_Real U = myCurve->FirstParameter();
+ gp_Pnt P = myCurve->Value(U);
+ Standard_Real Tol = Precision::PConfusion();
+ myExtPS = new Extrema_ExtPS(P,S->Surface(),Tol,Tol);
+ }
~ProjLib_OnSurface() { delete myExtPS; }
Standard_Real FirstParameter() const
{return myCurve->FirstParameter();}
-
+
Standard_Real LastParameter() const
{return myCurve->LastParameter();}
- gp_Pnt Value( const Standard_Real t) const
- {return OnSurface_Value(t,myCurve,myExtPS);}
+ Standard_Boolean Value(const Standard_Real theT,
+ NCollection_Array1<gp_Pnt2d>& /*thePnt2d*/,
+ NCollection_Array1<gp_Pnt>& thePnt) const
+ {
+ thePnt(1) = OnSurface_Value(theT, myCurve, myExtPS);
+ return Standard_True;
+ }
- Standard_Boolean D1(const Standard_Real t, gp_Pnt& P, gp_Vec& V) const
- {return OnSurface_D1(t,P,V,myCurve,myExtPS);}
+ Standard_Boolean D1(const Standard_Real theT,
+ NCollection_Array1<gp_Vec2d>& /*theVec2d*/,
+ NCollection_Array1<gp_Vec>& theVec) const
+ {
+ gp_Pnt aPnt;
+ return OnSurface_D1(theT, aPnt, theVec(1), myCurve, myExtPS);
+ }
};
-
-
//=====================================================================//
# Original bug : pro10658
# Date : 24mar98
-
+puts "TODO ALL Error : The area of the resulting shape is"
restore [locate_data_file CTO900_pro10658a.rle] a
restore [locate_data_file pro10658b.rle] b
# pro10658
-
+puts "TODO ALL Error : The area of the resulting shape is"
restore [locate_data_file CTO900_pro10658a.rle] a
restore [locate_data_file pro10658b.rle] b
--- /dev/null
+puts "============"
+puts "OCC24988"
+puts "============"
+puts ""
+#######################################################################
+# Wrong result done by projection algorithm
+#######################################################################
+
+restore [locate_data_file bug24988_s.draw] s
+restore [locate_data_file bug24988_c.draw] c3d
+
+project c2d c3d s
+
+set log [dump c2d]
+
+regexp {Degree +([-0-9.+eE]+), +([-0-9.+eE]+) Poles, +([-0-9.+eE]+)} ${log} full Degree Poles KnotsPoles
+puts "Degree=${Degree}"
+puts "Poles=${Poles}"
+puts "KnotsPoles=${KnotsPoles}"
+puts ""
+
+set Pole ${Poles}
+set exp_string " +${Pole} : +(\[-0-9.+eE\]+), +(\[-0-9.+eE\]+)"
+regexp ${exp_string} ${log} full U_end V_end
+
+puts "Pole=${Pole}"
+puts "U_end=${U_end}"
+puts "V_end=${V_end}"
+puts ""
+
+set tol_abs 1.e-7
+set tol_rel 0.01
+
+set expected_U_end 1.01988594864493
+checkreal "U_end" ${U_end} ${expected_U_end} ${tol_abs} ${tol_rel}
+
+set expected_V_end -1000.4963642098
+checkreal "V_end" ${V_end} ${expected_V_end} ${tol_abs} ${tol_rel}
#F6----------------------------------------------
-puts "TODO OCC22803 All:Faulty shapes in variables faulty_1 to faulty_"
-puts "TODO OCC22803 All:Error : The area of the resulting shape is"
+puts "TODO OCC22803 All:Error in depouille"
+puts "TODO OCC22803 All:Error : The skin cannot be built."
polyline p 0 0 3 0 0 0 10 0 0 10 0 3
beziercurve bc 4 10 0 3 7 0 2 3 0 3 0 0 3
mkedge bc bc
nexplode f f
depouille result f 0 0 1 f_4 1 0 0 25 0 0 1
-set square 2558.48
+set square 2046.52
# Date : 02 Dec 98
puts "TODO OCC22803 All:Error: The tolerance of the resulting shape is too big"
-puts "TODO OCC23511 Debian60-64: The area of the resulting shape is 186543"
+#puts "TODO OCC23511 Debian60-64: The area of the resulting shape is 186543"
restore [locate_data_file CFE903_pro12ggx.rle] base
fsameparameter result
-set square 200050
+set square 186543