OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-14 13:30:48 +03:00
Code Activity

0024002: Overall code and build procedure refactoring -- automatic

Browse Source 
Automatic upgrade of OCCT code by command "occt_upgrade . -nocdl":
- WOK-generated header files from inc and sources from drv are moved to src
- CDL files removed
- All packages are converted to nocdlpack
This commit is contained in:
abv
2015-07-12 07:42:38 +03:00
parent 543a996496
commit 42cf5bc1ca
15354 changed files with 623957 additions and 509844 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/Geom2d/FILES
View File

@@ -1 +1,43 @@
Geom2d_AxisPlacement.cxx
Geom2d_AxisPlacement.hxx
Geom2d_BezierCurve.cxx
Geom2d_BezierCurve.hxx
Geom2d_BoundedCurve.cxx
Geom2d_BoundedCurve.hxx
Geom2d_BSplineCurve.cxx
Geom2d_BSplineCurve.hxx
Geom2d_BSplineCurve_1.cxx
Geom2d_CartesianPoint.cxx
Geom2d_CartesianPoint.hxx
Geom2d_Circle.cxx
Geom2d_Circle.hxx
Geom2d_Conic.cxx
Geom2d_Conic.hxx
Geom2d_Curve.cxx
Geom2d_Curve.hxx
Geom2d_Direction.cxx
Geom2d_Direction.hxx
Geom2d_Ellipse.cxx
Geom2d_Ellipse.hxx
Geom2d_Geometry.cxx
Geom2d_Geometry.hxx
Geom2d_Hyperbola.cxx
Geom2d_Hyperbola.hxx
Geom2d_Line.cxx
Geom2d_Line.hxx
Geom2d_OffsetCurve.cxx
Geom2d_OffsetCurve.hxx
Geom2d_Parabola.cxx
Geom2d_Parabola.hxx
Geom2d_Point.cxx
Geom2d_Point.hxx
Geom2d_Transformation.cxx
Geom2d_Transformation.hxx
Geom2d_TrimmedCurve.cxx
Geom2d_TrimmedCurve.hxx
Geom2d_UndefinedDerivative.hxx
Geom2d_UndefinedValue.hxx
Geom2d_Vector.cxx
Geom2d_Vector.hxx
Geom2d_VectorWithMagnitude.cxx
Geom2d_VectorWithMagnitude.hxx

91
src/Geom2d/Geom2d.cdl
View File

@@ -1,91 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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.
package Geom2d
--- Purpose :
-- This package contains the definition of the geometric objects
-- such as point, vector, axis placement, curves and the
-- description of the geometric transformations available
-- for these objects.
-- All these entities are defined in 2D space.
-- This package gives the possibility :
-- . to create geometric objects,
-- . to have information about them,
-- . to modify these objects.
-- This package uses the services of the package gp (Geometric
-- processor) which describes non-persistent objects for algebraic
-- calculus and basic analytic geometry. The purpose of this package
-- is to create persistent geometric objects and to read geometric
-- information about these objects. Complexes geometric algorithmes
-- are not described in this package. At construction time,
-- elementary verifications are done to verify that the objects
-- are coherents, but some verifications which require complex
-- algorithmes (for example to check that a curve has not null
-- length or does not self-intersect) must be done before the
-- construction of the geometric objects.
uses MMgt, GeomAbs, TColStd, gp, TColgp
is
exception UndefinedDerivative inherits DomainError from Standard;
exception UndefinedValue inherits DomainError from Standard ;
class Transformation;
deferred class Geometry;
deferred class Point;
class CartesianPoint;
deferred class Vector;
class Direction;
class VectorWithMagnitude;
class AxisPlacement;
deferred class Curve;
class Line;
deferred class Conic;
class Circle;
class Ellipse;
class Hyperbola;
class Parabola;
deferred class BoundedCurve;
class BezierCurve;
class BSplineCurve;
class TrimmedCurve;
class OffsetCurve;
end Geom2d;

109
src/Geom2d/Geom2d_AxisPlacement.cdl
View File

@@ -1,109 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 AxisPlacement from Geom2d inherits Geometry from Geom2d
--- Purpose : Describes an axis in 2D space.
-- An axis is defined by:
-- - its origin, also termed the "Location point" of the axis,
-- - its unit vector, termed the "Direction" of the axis.
-- Note: Geom2d_AxisPlacement axes provide the
-- same kind of "geometric" services as gp_Ax2d axes
-- but have more complex data structures. The
-- geometric objects provided by the Geom2d package
-- use gp_Ax2d objects to include axes in their data
-- structures, or to define an axis of symmetry or axis of rotation.
-- Geom2d_AxisPlacement axes are used in a context
-- where they can be shared by several objects
-- contained inside a common data structure.
uses Ax2d from gp,
Dir2d from gp,
Pnt2d from gp,
Trsf2d from gp,
Vec2d from gp
is
Create (A : Ax2d) returns AxisPlacement;
--- Purpose : Constructs an axis by conversion of the gp_Ax2d axis A.
Create (P : Pnt2d; V : Dir2d) returns AxisPlacement;
--- Purpose : Constructs an axis from a given origin P and unit vector V.
Reverse (me : mutable);
Reversed (me) returns AxisPlacement is static;
---Purpose: Reverses the unit vector of this axis.
-- Note:
-- - Reverse assigns the result to this axis, while
-- - Reversed creates a new one.
SetAxis (me : mutable; A : Ax2d);
--- Purpose : Changes the complete definition of the axis placement.
SetDirection (me : mutable; V : Dir2d);
--- Purpose :
-- Changes the "Direction" of the axis placement.
SetLocation (me : mutable; P : Pnt2d);
--- Purpose :
-- Changes the "Location" point (origin) of the axis placement.
Angle (me; Other : AxisPlacement) returns Real;
--- Purpose :
-- Computes the angle between the "Direction" of
-- two axis placement in radians.
-- The result is comprised between -Pi and Pi.
Ax2d (me) returns Ax2d;
--- Purpose : Converts this axis into a gp_Ax2d axis.
Direction (me) returns Dir2d;
--- Purpose : Returns the "Direction" of <me>.
-- -C++: return const&
Location (me) returns Pnt2d;
--- Purpose :
-- Returns the "Location" point (origin) of the axis placement.
-- -C++: return const&
Transform (me : mutable; T : Trsf2d);
---Purpose: Applies the transformation T to this axis.
Copy (me) returns like me;
---Purpose: Creates a new object which is a copy of this axis.
fields
axis : Ax2d;
end;

9
src/Geom2d/Geom2d_AxisPlacement.cxx
View File

@@ -14,9 +14,14 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_AxisPlacement.ixx>
#include <Geom2d_AxisPlacement.hxx>
#include <Geom2d_Geometry.hxx>
#include <gp_Ax2d.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_AxisPlacement AxisPlacement;
typedef gp_Dir2d Dir2d;

128
src/Geom2d/Geom2d_AxisPlacement.hxx Normal file
View File

@@ -0,0 +1,128 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_AxisPlacement_HeaderFile
#define _Geom2d_AxisPlacement_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <gp_Ax2d.hxx>
#include <Geom2d_Geometry.hxx>
#include <Standard_Real.hxx>
class gp_Ax2d;
class gp_Pnt2d;
class gp_Dir2d;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_AxisPlacement;
DEFINE_STANDARD_HANDLE(Geom2d_AxisPlacement, Geom2d_Geometry)
//! Describes an axis in 2D space.
//! An axis is defined by:
//! - its origin, also termed the "Location point" of the axis,
//! - its unit vector, termed the "Direction" of the axis.
//! Note: Geom2d_AxisPlacement axes provide the
//! same kind of "geometric" services as gp_Ax2d axes
//! but have more complex data structures. The
//! geometric objects provided by the Geom2d package
//! use gp_Ax2d objects to include axes in their data
//! structures, or to define an axis of symmetry or axis of rotation.
//! Geom2d_AxisPlacement axes are used in a context
//! where they can be shared by several objects
//! contained inside a common data structure.
class Geom2d_AxisPlacement : public Geom2d_Geometry
{
public:
//! Constructs an axis by conversion of the gp_Ax2d axis A.
Standard_EXPORT Geom2d_AxisPlacement(const gp_Ax2d& A);
//! Constructs an axis from a given origin P and unit vector V.
Standard_EXPORT Geom2d_AxisPlacement(const gp_Pnt2d& P, const gp_Dir2d& V);
Standard_EXPORT void Reverse();
//! Reverses the unit vector of this axis.
//! Note:
//! - Reverse assigns the result to this axis, while
//! - Reversed creates a new one.
Standard_EXPORT Handle(Geom2d_AxisPlacement) Reversed() const;
//! Changes the complete definition of the axis placement.
Standard_EXPORT void SetAxis (const gp_Ax2d& A);
//! Changes the "Direction" of the axis placement.
Standard_EXPORT void SetDirection (const gp_Dir2d& V);
//! Changes the "Location" point (origin) of the axis placement.
Standard_EXPORT void SetLocation (const gp_Pnt2d& P);
//! Computes the angle between the "Direction" of
//! two axis placement in radians.
//! The result is comprised between -Pi and Pi.
Standard_EXPORT Standard_Real Angle (const Handle(Geom2d_AxisPlacement)& Other) const;
//! Converts this axis into a gp_Ax2d axis.
Standard_EXPORT gp_Ax2d Ax2d() const;
//! Returns the "Direction" of <me>.
//! -C++: return const&
Standard_EXPORT gp_Dir2d Direction() const;
//! Returns the "Location" point (origin) of the axis placement.
//! -C++: return const&
Standard_EXPORT gp_Pnt2d Location() const;
//! Applies the transformation T to this axis.
Standard_EXPORT void Transform (const gp_Trsf2d& T);
//! Creates a new object which is a copy of this axis.
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const;
DEFINE_STANDARD_RTTI(Geom2d_AxisPlacement,Geom2d_Geometry)
protected:
private:
gp_Ax2d axis;
};
#endif // _Geom2d_AxisPlacement_HeaderFile

1033
src/Geom2d/Geom2d_BSplineCurve.cdl
View File

File diff suppressed because it is too large Load Diff

18
src/Geom2d/Geom2d_BSplineCurve.cxx
View File

@@ -28,21 +28,31 @@
#define No_Standard_OutOfRange
#include <Geom2d_BSplineCurve.ixx>
#include <gp.hxx>
#include <BSplCLib.hxx>
#include <BSplCLib_KnotDistribution.hxx>
#include <BSplCLib_MultDistribution.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_Geometry.hxx>
#include <Geom2d_UndefinedDerivative.hxx>
#include <gp.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <Precision.hxx>
#include <Standard_NotImplemented.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_DimensionError.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_NotImplemented.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Type.hxx>
//=======================================================================
//function : CheckCurveData
//purpose : Internal use only
//=======================================================================
static void CheckCurveData
(const TColgp_Array1OfPnt2d& CPoles,
const TColStd_Array1OfReal& CKnots,

861
src/Geom2d/Geom2d_BSplineCurve.hxx Normal file
View File

@@ -0,0 +1,861 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_BSplineCurve_HeaderFile
#define _Geom2d_BSplineCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
#include <GeomAbs_BSplKnotDistribution.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
#include <TColgp_HArray1OfPnt2d.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <Standard_Real.hxx>
#include <Geom2d_BoundedCurve.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array1OfInteger.hxx>
class Standard_ConstructionError;
class Standard_DimensionError;
class Standard_DomainError;
class Standard_OutOfRange;
class Standard_RangeError;
class Standard_NoSuchObject;
class Geom2d_UndefinedDerivative;
class gp_Pnt2d;
class gp_Vec2d;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_BSplineCurve;
DEFINE_STANDARD_HANDLE(Geom2d_BSplineCurve, Geom2d_BoundedCurve)
//! Describes a BSpline curve.
//! A BSpline curve can be:
//! - uniform or non-uniform,
//! - rational or non-rational,
//! - periodic or non-periodic.
//! A BSpline curve is defined by:
//! - its degree; the degree for a
//! Geom2d_BSplineCurve is limited to a value (25)
//! which is defined and controlled by the system. This
//! value is returned by the function MaxDegree;
//! - its periodic or non-periodic nature;
//! - a table of poles (also called control points), with
//! their associated weights if the BSpline curve is
//! rational. The poles of the curve are "control points"
//! used to deform the curve. If the curve is
//! non-periodic, the first pole is the start point of the
//! curve, and the last pole is the end point of the
//! curve. The segment, which joins the first pole to the
//! second pole, is the tangent to the curve at its start
//! point, and the segment, which joins the last pole to
//! the second-from-last pole, is the tangent to the
//! curve at its end point. If the curve is periodic, these
//! geometric properties are not verified. It is more
//! difficult to give a geometric signification to the
//! weights but they are useful for providing exact
//! representations of the arcs of a circle or ellipse.
//! Moreover, if the weights of all the poles are equal,
//! the curve has a polynomial equation; it is
//! therefore a non-rational curve.
//! - a table of knots with their multiplicities. For a
//! Geom2d_BSplineCurve, the table of knots is an
//! increasing sequence of reals without repetition; the
//! multiplicities define the repetition of the knots. A
//! BSpline curve is a piecewise polynomial or rational
//! curve. The knots are the parameters of junction
//! points between two pieces. The multiplicity
//! Mult(i) of the knot Knot(i) of the BSpline
//! curve is related to the degree of continuity of the
//! curve at the knot Knot(i), which is equal to
//! Degree - Mult(i) where Degree is the
//! degree of the BSpline curve.
//! If the knots are regularly spaced (i.e. the difference
//! between two consecutive knots is a constant), three
//! specific and frequently used cases of knot distribution
//! can be identified:
//! - "uniform" if all multiplicities are equal to 1,
//! - "quasi-uniform" if all multiplicities are equal to 1,
//! except the first and the last knot which have a
//! multiplicity of Degree + 1, where Degree is
//! the degree of the BSpline curve,
//! - "Piecewise Bezier" if all multiplicities are equal to
//! Degree except the first and last knot which have
//! a multiplicity of Degree + 1, where Degree is
//! the degree of the BSpline curve. A curve of this
//! type is a concatenation of arcs of Bezier curves.
//! If the BSpline curve is not periodic:
//! - the bounds of the Poles and Weights tables are 1
//! and NbPoles, where NbPoles is the number of
//! poles of the BSpline curve,
//! - the bounds of the Knots and Multiplicities tables are
//! 1 and NbKnots, where NbKnots is the number
//! of knots of the BSpline curve.
//! If the BSpline curve is periodic, and if there are k
//! periodic knots and p periodic poles, the period is:
//! period = Knot(k + 1) - Knot(1)
//! and the poles and knots tables can be considered as
//! infinite tables, such that:
//! - Knot(i+k) = Knot(i) + period
//! - Pole(i+p) = Pole(i)
//! Note: data structures of a periodic BSpline curve are
//! more complex than those of a non-periodic one.
//! Warnings :
//! In this class we consider that a weight value is zero if
//! Weight <= Resolution from package gp.
//! For two parametric values (or two knot values) U1, U2 we
//! consider that U1 = U2 if Abs (U2 - U1) <= Epsilon (U1).
//! For two weights values W1, W2 we consider that W1 = W2 if
//! Abs (W2 - W1) <= Epsilon (W1). The method Epsilon is
//! defined in the class Real from package Standard.
//!
//! References :
//! . A survey of curve and surface methods in CADG Wolfgang BOHM
//! CAGD 1 (1984)
//! . On de Boor-like algorithms and blossoming Wolfgang BOEHM
//! cagd 5 (1988)
//! . Blossoming and knot insertion algorithms for B-spline curves
//! Ronald N. GOLDMAN
//! . Modelisation des surfaces en CAO, Henri GIAUME Peugeot SA
//! . Curves and Surfaces for Computer Aided Geometric Design,
//! a practical guide Gerald Farin
class Geom2d_BSplineCurve : public Geom2d_BoundedCurve
{
public:
//! Creates a non-rational B_spline curve on the
//! basis <Knots, Multiplicities> of degree <Degree>.
//! The following conditions must be verified.
//! 0 < Degree <= MaxDegree.
//!
//! Knots.Length() == Mults.Length() >= 2
//!
//! Knots(i) < Knots(i+1) (Knots are increasing)
//!
//! 1 <= Mults(i) <= Degree
//!
//! On a non periodic curve the first and last multiplicities
//! may be Degree+1 (this is even recommanded if you want the
//! curve to start and finish on the first and last pole).
//!
//! On a periodic curve the first and the last multicities
//! must be the same.
//!
//! on non-periodic curves
//!
//! Poles.Length() == Sum(Mults(i)) - Degree - 1 >= 2
//!
//! on periodic curves
//!
//! Poles.Length() == Sum(Mults(i)) except the first or last
Standard_EXPORT Geom2d_BSplineCurve(const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Multiplicities, const Standard_Integer Degree, const Standard_Boolean Periodic = Standard_False);
//! Creates a rational B_spline curve on the basis
//! <Knots, Multiplicities> of degree <Degree>.
//! The following conditions must be verified.
//! 0 < Degree <= MaxDegree.
//!
//! Knots.Length() == Mults.Length() >= 2
//!
//! Knots(i) < Knots(i+1) (Knots are increasing)
//!
//! 1 <= Mults(i) <= Degree
//!
//! On a non periodic curve the first and last multiplicities
//! may be Degree+1 (this is even recommanded if you want the
//! curve to start and finish on the first and last pole).
//!
//! On a periodic curve the first and the last multicities
//! must be the same.
//!
//! on non-periodic curves
//!
//! Poles.Length() == Sum(Mults(i)) - Degree - 1 >= 2
//!
//! on periodic curves
//!
//! Poles.Length() == Sum(Mults(i)) except the first or last
Standard_EXPORT Geom2d_BSplineCurve(const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal& Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Multiplicities, const Standard_Integer Degree, const Standard_Boolean Periodic = Standard_False);
//! Increases the degree of this BSpline curve to
//! Degree. As a result, the poles, weights and
//! multiplicities tables are modified; the knots table is
//! not changed. Nothing is done if Degree is less than
//! or equal to the current degree.
//! Exceptions
//! Standard_ConstructionError if Degree is greater than
//! Geom2d_BSplineCurve::MaxDegree().
Standard_EXPORT void IncreaseDegree (const Standard_Integer Degree);
//! Increases the multiplicity of the knot <Index> to
//! <M>.
//!
//! If <M> is lower or equal to the current
//! multiplicity nothing is done. If <M> is higher than
//! the degree the degree is used.
//! If <Index> is not in [FirstUKnotIndex, LastUKnotIndex]
Standard_EXPORT void IncreaseMultiplicity (const Standard_Integer Index, const Standard_Integer M);
//! Increases the multiplicities of the knots in
//! [I1,I2] to <M>.
//!
//! For each knot if <M> is lower or equal to the
//! current multiplicity nothing is done. If <M> is
//! higher than the degree the degree is used.
//! As a result, the poles and weights tables of this curve are modified.
//! Warning
//! It is forbidden to modify the multiplicity of the first or
//! last knot of a non-periodic curve. Be careful as
//! Geom2d does not protect against this.
//! Exceptions
//! Standard_OutOfRange if either Index, I1 or I2 is
//! outside the bounds of the knots table.
Standard_EXPORT void IncreaseMultiplicity (const Standard_Integer I1, const Standard_Integer I2, const Standard_Integer M);
//! Increases by M the multiplicity of the knots of indexes
//! I1 to I2 in the knots table of this BSpline curve. For
//! each knot, the resulting multiplicity is limited to the
//! degree of this curve. If M is negative, nothing is done.
//! As a result, the poles and weights tables of this
//! BSpline curve are modified.
//! Warning
//! It is forbidden to modify the multiplicity of the first or
//! last knot of a non-periodic curve. Be careful as
//! Geom2d does not protect against this.
//! Exceptions
//! Standard_OutOfRange if I1 or I2 is outside the
//! bounds of the knots table.
Standard_EXPORT void IncrementMultiplicity (const Standard_Integer I1, const Standard_Integer I2, const Standard_Integer M);
//! Inserts a knot value in the sequence of knots. If
//! <U> is an existing knot the multiplicity is
//! increased by <M>.
//!
//! If U is not on the parameter range nothing is
//! done.
//!
//! If the multiplicity is negative or null nothing is
//! done. The new multiplicity is limited to the
//! degree.
//!
//! The tolerance criterion for knots equality is
//! the max of Epsilon(U) and ParametricTolerance.
//! Warning
//! - If U is less than the first parameter or greater than
//! the last parameter of this BSpline curve, nothing is done.
//! - If M is negative or null, nothing is done.
//! - The multiplicity of a knot is limited to the degree of
//! this BSpline curve.
Standard_EXPORT void InsertKnot (const Standard_Real U, const Standard_Integer M = 1, const Standard_Real ParametricTolerance = 0.0);
//! Inserts the values of the array Knots, with the
//! respective multiplicities given by the array Mults, into
//! the knots table of this BSpline curve.
//! If a value of the array Knots is an existing knot, its multiplicity is:
//! - increased by M, if Add is true, or
//! - increased to M, if Add is false (default value).
//! The tolerance criterion used for knot equality is the
//! larger of the values ParametricTolerance (defaulted
//! to 0.) and Standard_Real::Epsilon(U),
//! where U is the current knot value.
//! Warning
//! - For a value of the array Knots which is less than
//! the first parameter or greater than the last
//! parameter of this BSpline curve, nothing is done.
//! - For a value of the array Mults which is negative or
//! null, nothing is done.
//! - The multiplicity of a knot is limited to the degree of
//! this BSpline curve.
Standard_EXPORT void InsertKnots (const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, const Standard_Real ParametricTolerance = 0.0, const Standard_Boolean Add = Standard_False);
//! Reduces the multiplicity of the knot of index Index
//! to M. If M is equal to 0, the knot is removed.
//! With a modification of this type, the array of poles is also modified.
//! Two different algorithms are systematically used to
//! compute the new poles of the curve. If, for each
//! pole, the distance between the pole calculated
//! using the first algorithm and the same pole
//! calculated using the second algorithm, is less than
//! Tolerance, this ensures that the curve is not
//! modified by more than Tolerance. Under these
//! conditions, true is returned; otherwise, false is returned.
//! A low tolerance is used to prevent modification of
//! the curve. A high tolerance is used to "smooth" the curve.
//! Exceptions
//! Standard_OutOfRange if Index is outside the
//! bounds of the knots table.
Standard_EXPORT Standard_Boolean RemoveKnot (const Standard_Integer Index, const Standard_Integer M, const Standard_Real Tolerance);
//! The new pole is inserted after the pole of range Index.
//! If the curve was non rational it can become rational.
//!
//! Raised if the B-spline is NonUniform or PiecewiseBezier or if
//! Weight <= 0.0
//! Raised if Index is not in the range [1, Number of Poles]
Standard_EXPORT void InsertPoleAfter (const Standard_Integer Index, const gp_Pnt2d& P, const Standard_Real Weight = 1.0);
//! The new pole is inserted before the pole of range Index.
//! If the curve was non rational it can become rational.
//!
//! Raised if the B-spline is NonUniform or PiecewiseBezier or if
//! Weight <= 0.0
//! Raised if Index is not in the range [1, Number of Poles]
Standard_EXPORT void InsertPoleBefore (const Standard_Integer Index, const gp_Pnt2d& P, const Standard_Real Weight = 1.0);
//! Removes the pole of range Index
//! If the curve was rational it can become non rational.
//!
//! Raised if the B-spline is NonUniform or PiecewiseBezier.
//! Raised if the number of poles of the B-spline curve is lower or
//! equal to 2 before removing.
//! Raised if Index is not in the range [1, Number of Poles]
Standard_EXPORT void RemovePole (const Standard_Integer Index);
//! Reverses the orientation of this BSpline curve. As a result
//! - the knots and poles tables are modified;
//! - the start point of the initial curve becomes the end
//! point of the reversed curve;
//! - the end point of the initial curve becomes the start
//! point of the reversed curve.
Standard_EXPORT void Reverse();
//! Computes the parameter on the reversed curve for
//! the point of parameter U on this BSpline curve.
//! The returned value is: UFirst + ULast - U,
//! where UFirst and ULast are the values of the
//! first and last parameters of this BSpline curve.
Standard_EXPORT Standard_Real ReversedParameter (const Standard_Real U) const;
//! Modifies this BSpline curve by segmenting it
//! between U1 and U2. Either of these values can be
//! outside the bounds of the curve, but U2 must be greater than U1.
//! All data structure tables of this BSpline curve are
//! modified, but the knots located between U1 and U2
//! are retained. The degree of the curve is not modified.
//! Warnings :
//! Even if <me> is not closed it can become closed after the
//! segmentation for example if U1 or U2 are out of the bounds
//! of the curve <me> or if the curve makes loop.
//! After the segmentation the length of a curve can be null.
//! - The segmentation of a periodic curve over an
//! interval corresponding to its period generates a
//! non-periodic curve with equivalent geometry.
//! Exceptions
//! Standard_DomainError if U2 is less than U1.
//! raises if U2 < U1.
Standard_EXPORT void Segment (const Standard_Real U1, const Standard_Real U2);
//! Modifies this BSpline curve by assigning the value K
//! to the knot of index Index in the knots table. This is a
//! relatively local modification because K must be such that:
//! Knots(Index - 1) < K < Knots(Index + 1)
//! Exceptions
//! Standard_ConstructionError if:
//! - K is not such that:
//! Knots(Index - 1) < K < Knots(Index + 1)
//! - M is greater than the degree of this BSpline curve
//! or lower than the previous multiplicity of knot of
//! index Index in the knots table.
//! Standard_OutOfRange if Index is outside the bounds of the knots table.
Standard_EXPORT void SetKnot (const Standard_Integer Index, const Standard_Real K);
//! Modifies this BSpline curve by assigning the array
//! K to its knots table. The multiplicity of the knots is not modified.
//! Exceptions
//! Standard_ConstructionError if the values in the
//! array K are not in ascending order.
//! Standard_OutOfRange if the bounds of the array
//! K are not respectively 1 and the number of knots of this BSpline curve.
Standard_EXPORT void SetKnots (const TColStd_Array1OfReal& K);
//! Modifies this BSpline curve by assigning the value K
//! to the knot of index Index in the knots table. This is a
//! relatively local modification because K must be such that:
//! Knots(Index - 1) < K < Knots(Index + 1)
//! The second syntax allows you also to increase the
//! multiplicity of the knot to M (but it is not possible to
//! decrease the multiplicity of the knot with this function).
//! Exceptions
//! Standard_ConstructionError if:
//! - K is not such that:
//! Knots(Index - 1) < K < Knots(Index + 1)
//! - M is greater than the degree of this BSpline curve
//! or lower than the previous multiplicity of knot of
//! index Index in the knots table.
//! Standard_OutOfRange if Index is outside the bounds of the knots table.
Standard_EXPORT void SetKnot (const Standard_Integer Index, const Standard_Real K, const Standard_Integer M);
//! Computes the parameter normalized within the
//! "first" period of this BSpline curve, if it is periodic:
//! the returned value is in the range Param1 and
//! Param1 + Period, where:
//! - Param1 is the "first parameter", and
//! - Period the period of this BSpline curve.
//! Note: If this curve is not periodic, U is not modified.
Standard_EXPORT void PeriodicNormalization (Standard_Real& U) const;
//! Changes this BSpline curve into a periodic curve.
//! To become periodic, the curve must first be closed.
//! Next, the knot sequence must be periodic. For this,
//! FirstUKnotIndex and LastUKnotIndex are used to
//! compute I1 and I2, the indexes in the knots array
//! of the knots corresponding to the first and last
//! parameters of this BSpline curve.
//! The period is therefore Knot(I2) - Knot(I1).
//! Consequently, the knots and poles tables are modified.
//! Exceptions
//! Standard_ConstructionError if this BSpline curve is not closed.
Standard_EXPORT void SetPeriodic();
//! Assigns the knot of index Index in the knots table as
//! the origin of this periodic BSpline curve. As a
//! consequence, the knots and poles tables are modified.
//! Exceptions
//! Standard_NoSuchObject if this curve is not periodic.
//! Standard_DomainError if Index is outside the
//! bounds of the knots table.
Standard_EXPORT void SetOrigin (const Standard_Integer Index);
//! Changes this BSpline curve into a non-periodic
//! curve. If this curve is already non-periodic, it is not modified.
//! Note that the poles and knots tables are modified.
//! Warning
//! If this curve is periodic, as the multiplicity of the first
//! and last knots is not modified, and is not equal to
//! Degree + 1, where Degree is the degree of
//! this BSpline curve, the start and end points of the
//! curve are not its first and last poles.
Standard_EXPORT void SetNotPeriodic();
//! Modifies this BSpline curve by assigning P to the
//! pole of index Index in the poles table.
//! Exceptions
//! Standard_OutOfRange if Index is outside the
//! bounds of the poles table.
//! Standard_ConstructionError if Weight is negative or null.
Standard_EXPORT void SetPole (const Standard_Integer Index, const gp_Pnt2d& P);
//! Modifies this BSpline curve by assigning P to the
//! pole of index Index in the poles table.
//! The second syntax also allows you to modify the
//! weight of the modified pole, which becomes Weight.
//! In this case, if this BSpline curve is non-rational, it
//! can become rational and vice versa.
//! Exceptions
//! Standard_OutOfRange if Index is outside the
//! bounds of the poles table.
//! Standard_ConstructionError if Weight is negative or null.
Standard_EXPORT void SetPole (const Standard_Integer Index, const gp_Pnt2d& P, const Standard_Real Weight);
//! Assigns the weight Weight to the pole of index Index of the poles table.
//! If the curve was non rational it can become rational.
//! If the curve was rational it can become non rational.
//! Exceptions
//! Standard_OutOfRange if Index is outside the
//! bounds of the poles table.
//! Standard_ConstructionError if Weight is negative or null.
Standard_EXPORT void SetWeight (const Standard_Integer Index, const Standard_Real Weight);
//! Moves the point of parameter U of this BSpline
//! curve to P. Index1 and Index2 are the indexes in the
//! table of poles of this BSpline curve of the first and
//! last poles designated to be moved.
//! FirstModifiedPole and LastModifiedPole are the
//! indexes of the first and last poles, which are
//! effectively modified.
//! In the event of incompatibility between Index1,
//! Index2 and the value U:
//! - no change is made to this BSpline curve, and
//! - the FirstModifiedPole and LastModifiedPole are returned null.
//! Exceptions
//! Standard_OutOfRange if:
//! - Index1 is greater than or equal to Index2, or
//! - Index1 or Index2 is less than 1 or greater than the
//! number of poles of this BSpline curve.
Standard_EXPORT void MovePoint (const Standard_Real U, const gp_Pnt2d& P, const Standard_Integer Index1, const Standard_Integer Index2, Standard_Integer& FirstModifiedPole, Standard_Integer& LastModifiedPole);
//! Move a point with parameter U to P.
//! and makes it tangent at U be Tangent.
//! StartingCondition = -1 means first can move
//! EndingCondition = -1 means last point can move
//! StartingCondition = 0 means the first point cannot move
//! EndingCondition = 0 means the last point cannot move
//! StartingCondition = 1 means the first point and tangent cannot move
//! EndingCondition = 1 means the last point and tangent cannot move
//! and so forth
//! ErrorStatus != 0 means that there are not enought degree of freedom
//! with the constrain to deform the curve accordingly
Standard_EXPORT void MovePointAndTangent (const Standard_Real U, const gp_Pnt2d& P, const gp_Vec2d& Tangent, const Standard_Real Tolerance, const Standard_Integer StartingCondition, const Standard_Integer EndingCondition, Standard_Integer& ErrorStatus);
//! Returns true if the degree of continuity of this
//! BSpline curve is at least N. A BSpline curve is at least GeomAbs_C0.
//! Exceptions Standard_RangeError if N is negative.
Standard_EXPORT Standard_Boolean IsCN (const Standard_Integer N) const;
//! Check if curve has at least G1 continuity in interval [theTf, theTl]
//! Returns true if IsCN(1)
//! or
//! angle betweem "left" and "right" first derivatives at
//! knots with C0 continuity is less then theAngTol
//! only knots in interval [theTf, theTl] is checked
Standard_EXPORT Standard_Boolean IsG1 (const Standard_Real theTf, const Standard_Real theTl, const Standard_Real theAngTol) const;
//! Returns true if the distance between the first point and the
//! last point of the curve is lower or equal to Resolution
//! from package gp.
//! Warnings :
//! The first and the last point can be different from the first
//! pole and the last pole of the curve.
Standard_EXPORT Standard_Boolean IsClosed() const;
//! Returns True if the curve is periodic.
Standard_EXPORT Standard_Boolean IsPeriodic() const;
//! Returns True if the weights are not identical.
//! The tolerance criterion is Epsilon of the class Real.
Standard_EXPORT Standard_Boolean IsRational() const;
//! Returns the global continuity of the curve :
//! C0 : only geometric continuity,
//! C1 : continuity of the first derivative all along the Curve,
//! C2 : continuity of the second derivative all along the Curve,
//! C3 : continuity of the third derivative all along the Curve,
//! CN : the order of continuity is infinite.
//! For a B-spline curve of degree d if a knot Ui has a
//! multiplicity p the B-spline curve is only Cd-p continuous
//! at Ui. So the global continuity of the curve can't be greater
//! than Cd-p where p is the maximum multiplicity of the interior
//! Knots. In the interior of a knot span the curve is infinitely
//! continuously differentiable.
Standard_EXPORT GeomAbs_Shape Continuity() const;
//! Returns the degree of this BSpline curve.
//! In this class the degree of the basis normalized B-spline
//! functions cannot be greater than "MaxDegree"
//! Computation of value and derivatives
Standard_EXPORT Standard_Integer Degree() const;
Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt2d& P) const;
//! Raised if the continuity of the curve is not C1.
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1) const;
//! Raised if the continuity of the curve is not C2.
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const;
//! For this BSpline curve, computes
//! - the point P of parameter U, or
//! - the point P and one or more of the following values:
//! - V1, the first derivative vector,
//! - V2, the second derivative vector,
//! - V3, the third derivative vector.
//! Warning
//! On a point where the continuity of the curve is not the
//! one requested, these functions impact the part
//! defined by the parameter with a value greater than U,
//! i.e. the part of the curve to the "right" of the singularity.
//! Raises UndefinedDerivative if the continuity of the curve is not C3.
Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const;
//! For the point of parameter U of this BSpline curve,
//! computes the vector corresponding to the Nth derivative.
//! Warning
//! On a point where the continuity of the curve is not the
//! one requested, this function impacts the part defined
//! by the parameter with a value greater than U, i.e. the
//! part of the curve to the "right" of the singularity.
//! Raises UndefinedDerivative if the continuity of the curve is not CN.
//! RangeError if N < 1.
//! The following functions computes the point of parameter U
//! and the derivatives at this point on the B-spline curve
//! arc defined between the knot FromK1 and the knot ToK2.
//! U can be out of bounds [Knot (FromK1), Knot (ToK2)] but
//! for the computation we only use the definition of the curve
//! between these two knots. This method is useful to compute
//! local derivative, if the order of continuity of the whole
//! curve is not greater enough. Inside the parametric
//! domain Knot (FromK1), Knot (ToK2) the evaluations are
//! the same as if we consider the whole definition of the
//! curve. Of course the evaluations are different outside
//! this parametric domain.
Standard_EXPORT gp_Vec2d DN (const Standard_Real U, const Standard_Integer N) const;
//! Raised if FromK1 = ToK2.
//!
//! Raised if FromK1 and ToK2 are not in the range
//! [FirstUKnotIndex, LastUKnotIndex].
Standard_EXPORT gp_Pnt2d LocalValue (const Standard_Real U, const Standard_Integer FromK1, const Standard_Integer ToK2) const;
Standard_EXPORT void LocalD0 (const Standard_Real U, const Standard_Integer FromK1, const Standard_Integer ToK2, gp_Pnt2d& P) const;
//! Raised if the local continuity of the curve is not C1
//! between the knot K1 and the knot K2.
//! Raised if FromK1 = ToK2.
//!
//! Raised if FromK1 and ToK2 are not in the range
//! [FirstUKnotIndex, LastUKnotIndex].
Standard_EXPORT void LocalD1 (const Standard_Real U, const Standard_Integer FromK1, const Standard_Integer ToK2, gp_Pnt2d& P, gp_Vec2d& V1) const;
//! Raised if the local continuity of the curve is not C2
//! between the knot K1 and the knot K2.
//! Raised if FromK1 = ToK2.
//!
//! Raised if FromK1 and ToK2 are not in the range
//! [FirstUKnotIndex, LastUKnotIndex].
Standard_EXPORT void LocalD2 (const Standard_Real U, const Standard_Integer FromK1, const Standard_Integer ToK2, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const;
//! Raised if the local continuity of the curve is not C3
//! between the knot K1 and the knot K2.
//! Raised if FromK1 = ToK2.
//!
//! Raised if FromK1 and ToK2 are not in the range
//! [FirstUKnotIndex, LastUKnotIndex].
Standard_EXPORT void LocalD3 (const Standard_Real U, const Standard_Integer FromK1, const Standard_Integer ToK2, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const;
//! Raised if the local continuity of the curve is not CN
//! between the knot K1 and the knot K2.
//! Raised if FromK1 = ToK2.
//! Raised if N < 1.
//!
//! Raises if FromK1 and ToK2 are not in the range
//! [FirstUKnotIndex, LastUKnotIndex].
Standard_EXPORT gp_Vec2d LocalDN (const Standard_Real U, const Standard_Integer FromK1, const Standard_Integer ToK2, const Standard_Integer N) const;
//! Returns the last point of the curve.
//! Warnings :
//! The last point of the curve is different from the last
//! pole of the curve if the multiplicity of the last knot
//! is lower than Degree.
Standard_EXPORT gp_Pnt2d EndPoint() const;
//! For a B-spline curve the first parameter (which gives the start
//! point of the curve) is a knot value but if the multiplicity of
//! the first knot index is lower than Degree + 1 it is not the
//! first knot of the curve. This method computes the index of the
//! knot corresponding to the first parameter.
Standard_EXPORT Standard_Integer FirstUKnotIndex() const;
//! Computes the parametric value of the start point of the curve.
//! It is a knot value.
Standard_EXPORT Standard_Real FirstParameter() const;
//! Returns the knot of range Index. When there is a knot
//! with a multiplicity greater than 1 the knot is not repeated.
//! The method Multiplicity can be used to get the multiplicity
//! of the Knot.
//! Raised if Index < 1 or Index > NbKnots
Standard_EXPORT Standard_Real Knot (const Standard_Integer Index) const;
//! returns the knot values of the B-spline curve;
//!
//! Raised if the length of K is not equal to the number of knots.
Standard_EXPORT void Knots (TColStd_Array1OfReal& K) const;
//! returns the knot values of the B-spline curve;
Standard_EXPORT const TColStd_Array1OfReal& Knots() const;
//! Returns the knots sequence.
//! In this sequence the knots with a multiplicity greater than 1
//! are repeated.
//! Example :
//! K = {k1, k1, k1, k2, k3, k3, k4, k4, k4}
//!
//! Raised if the length of K is not equal to NbPoles + Degree + 1
Standard_EXPORT void KnotSequence (TColStd_Array1OfReal& K) const;
//! Returns the knots sequence.
//! In this sequence the knots with a multiplicity greater than 1
//! are repeated.
//! Example :
//! K = {k1, k1, k1, k2, k3, k3, k4, k4, k4}
Standard_EXPORT const TColStd_Array1OfReal& KnotSequence() const;
//! Returns NonUniform or Uniform or QuasiUniform or PiecewiseBezier.
//! If all the knots differ by a positive constant from the
//! preceding knot the BSpline Curve can be :
//! - Uniform if all the knots are of multiplicity 1,
//! - QuasiUniform if all the knots are of multiplicity 1 except for
//! the first and last knot which are of multiplicity Degree + 1,
//! - PiecewiseBezier if the first and last knots have multiplicity
//! Degree + 1 and if interior knots have multiplicity Degree
//! A piecewise Bezier with only two knots is a BezierCurve.
//! else the curve is non uniform.
//! The tolerance criterion is Epsilon from class Real.
Standard_EXPORT GeomAbs_BSplKnotDistribution KnotDistribution() const;
//! For a BSpline curve the last parameter (which gives the
//! end point of the curve) is a knot value but if the
//! multiplicity of the last knot index is lower than
//! Degree + 1 it is not the last knot of the curve. This
//! method computes the index of the knot corresponding to
//! the last parameter.
Standard_EXPORT Standard_Integer LastUKnotIndex() const;
//! Computes the parametric value of the end point of the curve.
//! It is a knot value.
Standard_EXPORT Standard_Real LastParameter() const;
//! Locates the parametric value U in the sequence of knots.
//! If "WithKnotRepetition" is True we consider the knot's
//! representation with repetition of multiple knot value,
//! otherwise we consider the knot's representation with
//! no repetition of multiple knot values.
//! Knots (I1) <= U <= Knots (I2)
//! . if I1 = I2 U is a knot value (the tolerance criterion
//! ParametricTolerance is used).
//! . if I1 < 1 => U < Knots (1) - Abs(ParametricTolerance)
//! . if I2 > NbKnots => U > Knots (NbKnots) + Abs(ParametricTolerance)
Standard_EXPORT void LocateU (const Standard_Real U, const Standard_Real ParametricTolerance, Standard_Integer& I1, Standard_Integer& I2, const Standard_Boolean WithKnotRepetition = Standard_False) const;
//! Returns the multiplicity of the knots of range Index.
//! Raised if Index < 1 or Index > NbKnots
Standard_EXPORT Standard_Integer Multiplicity (const Standard_Integer Index) const;
//! Returns the multiplicity of the knots of the curve.
//!
//! Raised if the length of M is not equal to NbKnots.
Standard_EXPORT void Multiplicities (TColStd_Array1OfInteger& M) const;
//! returns the multiplicity of the knots of the curve.
Standard_EXPORT const TColStd_Array1OfInteger& Multiplicities() const;
//! Returns the number of knots. This method returns the number of
//! knot without repetition of multiple knots.
Standard_EXPORT Standard_Integer NbKnots() const;
//! Returns the number of poles
Standard_EXPORT Standard_Integer NbPoles() const;
//! Returns the pole of range Index.
//! Raised if Index < 1 or Index > NbPoles.
Standard_EXPORT gp_Pnt2d Pole (const Standard_Integer Index) const;
//! Returns the poles of the B-spline curve;
//!
//! Raised if the length of P is not equal to the number of poles.
Standard_EXPORT void Poles (TColgp_Array1OfPnt2d& P) const;
//! Returns the poles of the B-spline curve;
Standard_EXPORT const TColgp_Array1OfPnt2d& Poles() const;
//! Returns the start point of the curve.
//! Warnings :
//! This point is different from the first pole of the curve if the
//! multiplicity of the first knot is lower than Degree.
Standard_EXPORT gp_Pnt2d StartPoint() const;
//! Returns the weight of the pole of range Index .
//! Raised if Index < 1 or Index > NbPoles.
Standard_EXPORT Standard_Real Weight (const Standard_Integer Index) const;
//! Returns the weights of the B-spline curve;
//!
//! Raised if the length of W is not equal to NbPoles.
Standard_EXPORT void Weights (TColStd_Array1OfReal& W) const;
//! Returns the weights of the B-spline curve;
Standard_EXPORT const TColStd_Array1OfReal& Weights() const;
//! Applies the transformation T to this BSpline curve.
Standard_EXPORT void Transform (const gp_Trsf2d& T);
//! Returns the value of the maximum degree of the normalized
//! B-spline basis functions in this package.
Standard_EXPORT static Standard_Integer MaxDegree();
//! Computes for this BSpline curve the parametric
//! tolerance UTolerance for a given tolerance
//! Tolerance3D (relative to dimensions in the plane).
//! If f(t) is the equation of this BSpline curve,
//! UTolerance ensures that:
//! | t1 - t0| < Utolerance ===>
//! |f(t1) - f(t0)| < ToleranceUV
Standard_EXPORT void Resolution (const Standard_Real ToleranceUV, Standard_Real& UTolerance);
//! Creates a new object which is a copy of this BSpline curve.
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const;
DEFINE_STANDARD_RTTI(Geom2d_BSplineCurve,Geom2d_BoundedCurve)
protected:
private:
//! Recompute the flatknots, the knotsdistribution, the continuity.
Standard_EXPORT void UpdateKnots();
Standard_Boolean rational;
Standard_Boolean periodic;
GeomAbs_BSplKnotDistribution knotSet;
GeomAbs_Shape smooth;
Standard_Integer deg;
Handle(TColgp_HArray1OfPnt2d) poles;
Handle(TColStd_HArray1OfReal) weights;
Handle(TColStd_HArray1OfReal) flatknots;
Handle(TColStd_HArray1OfReal) knots;
Handle(TColStd_HArray1OfInteger) mults;
Standard_Real maxderivinv;
Standard_Boolean maxderivinvok;
};
#endif // _Geom2d_BSplineCurve_HeaderFile

20
src/Geom2d/Geom2d_BSplineCurve_1.cxx
View File

@@ -21,16 +21,22 @@
#define No_Standard_OutOfRange
#define No_Standard_DimensionError
#include <Geom2d_BSplineCurve.jxx>
#include <BSplCLib.hxx>
#include <gp.hxx>
#include <BSplCLib.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_Geometry.hxx>
#include <Geom2d_UndefinedDerivative.hxx>
#include <Standard_DimensionError.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_RangeError.hxx>
#include <gp.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <Precision.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_DimensionError.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_RangeError.hxx>
#define POLES (poles->Array1())
#define KNOTS (knots->Array1())

419
src/Geom2d/Geom2d_BezierCurve.cdl
View File

@@ -1,419 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 BezierCurve from Geom2d inherits BoundedCurve from Geom2d
--- Purpose : Describes a rational or non-rational Bezier curve
-- - a non-rational Bezier curve is defined by a table
-- of poles (also called control points),
-- - a rational Bezier curve is defined by a table of
-- poles with varying weights.
-- These data are manipulated by two parallel arrays:
-- - the poles table, which is an array of gp_Pnt2d points, and
-- - the weights table, which is an array of reals.
-- The bounds of these arrays are 1 and "the number of poles" of the curve.
-- The poles of the curve are "control points" used to deform the curve.
-- The first pole is the start point of the curve, and the
-- last pole is the end point of the curve. The segment
-- which joins the first pole to the second pole is the
-- tangent to the curve at its start point, and the
-- segment which joins the last pole to the
-- second-from-last pole is the tangent to the curve
-- at its end point.
-- It is more difficult to give a geometric signification
-- to the weights but they are useful for providing
-- exact representations of the arcs of a circle or
-- ellipse. Moreover, if the weights of all the poles are
-- equal, the curve is polynomial; it is therefore a
-- non-rational curve. The non-rational curve is a
-- special and frequently used case. The weights are
-- defined and used only in case of a rational curve.
-- The degree of a Bezier curve is equal to the
-- number of poles, minus 1. It must be greater than or
-- equal to 1. However, the degree of a
-- Geom2d_BezierCurve curve is limited to a value
-- (25) which is defined and controlled by the system.
-- This value is returned by the function MaxDegree.
-- The parameter range for a Bezier curve is [ 0, 1 ].
-- If the first and last control points of the Bezier
-- curve are the same point then the curve is closed.
-- For example, to create a closed Bezier curve with
-- four control points, you have to give a set of control
-- points P1, P2, P3 and P1.
-- The continuity of a Bezier curve is infinite.
-- It is not possible to build a Bezier curve with
-- negative weights. We consider that a weight value
-- is zero if it is less than or equal to
-- gp::Resolution(). We also consider that
-- two weight values W1 and W2 are equal if:
-- |W2 - W1| <= gp::Resolution().
-- Warning
-- - When considering the continuity of a closed
-- Bezier curve at the junction point, remember that
-- a curve of this type is never periodic. This means
-- that the derivatives for the parameter u = 0
-- have no reason to be the same as the
-- derivatives for the parameter u = 1 even if the curve is closed.
-- - The length of a Bezier curve can be null.
uses Array1OfReal from TColStd,
HArray1OfReal from TColStd,
Array1OfPnt2d from TColgp,
Ax2d from gp,
Pnt2d from gp,
HArray1OfPnt2d from TColgp,
Vec2d from gp,
Trsf2d from gp,
Geometry from Geom2d,
Shape from GeomAbs
raises ConstructionError from Standard,
DimensionError from Standard,
RangeError from Standard,
OutOfRange from Standard
is
Create (CurvePoles : Array1OfPnt2d from TColgp) returns BezierCurve
--- Purpose :
-- Creates a non rational Bezier curve with a set of poles :
-- CurvePoles. The weights are defaulted to all being 1.
-- Raises ConstructionError if the number of poles is greater than MaxDegree + 1
-- or lower than 2.
raises ConstructionError;
Create (CurvePoles : Array1OfPnt2d from TColgp;
PoleWeights : Array1OfReal from TColStd)
returns BezierCurve
--- Purpose :
-- Creates a rational Bezier curve with the set of poles
-- CurvePoles and the set of weights PoleWeights .
-- If all the weights are identical the curve is considered
-- as non rational. Raises ConstructionError if
-- the number of poles is greater than MaxDegree + 1 or lower
-- than 2 or CurvePoles and CurveWeights have not the same length
-- or one weight value is lower or equal to Resolution from
-- package gp.
raises ConstructionError;
Increase (me : mutable; Degree : Integer)
--- Purpose :
-- Increases the degree of a bezier curve. Degree is the new
-- degree of <me>.
-- raises ConstructionError if Degree is greater than MaxDegree or lower than 2
-- or lower than the initial degree of <me>.
raises ConstructionError;
InsertPoleAfter (me : mutable; Index : Integer; P : Pnt2d;
Weight : Real = 1.0)
--- Purpose :
-- Inserts a pole with its weight in the set of poles after the
-- pole of range Index. If the curve was non rational it can
-- become rational if all the weights are not identical.
raises OutOfRange,
--- Purpose : Raised if Index is not in the range [0, NbPoles]
ConstructionError;
--- Purpose :
-- Raised if the resulting number of poles is greater than
-- MaxDegree + 1.
InsertPoleBefore (me : mutable; Index : Integer; P : Pnt2d;
Weight : Real = 1.0)
--- Purpose :
-- Inserts a pole with its weight in the set of poles after
-- the pole of range Index. If the curve was non rational it
-- can become rational if all the weights are not identical.
raises OutOfRange,
--- Purpose : Raised if Index is not in the range [1, NbPoles+1]
ConstructionError;
--- Purpose :
-- Raised if the resulting number of poles is greater than
-- MaxDegree + 1.
RemovePole (me : mutable; Index : Integer)
--- Purpose : Removes the pole of range Index.
-- If the curve was rational it can become non rational.
raises OutOfRange,
--- Purpose : Raised if Index is not in the range [1, NbPoles]
ConstructionError;
-- Purpose : Raised if Degree is lower than 2.
Reverse (me : mutable);
--- Purpose :
-- Reverses the direction of parametrization of <me>
-- Value (NewU) = Value (1 - OldU)
ReversedParameter(me; U : Real) returns Real;
---Purpose: Returns the parameter on the reversed curve for
-- the point of parameter U on <me>.
--
-- returns 1-U
Segment (me : mutable; U1, U2 : Real);
--- Purpose :
-- Segments the curve between U1 and U2 which can be out
-- of the bounds of the curve. The curve is oriented from U1
-- to U2.
-- The control points are modified, the first and the last point
-- are not the same but the parametrization range is [0, 1]
-- else it could not be a Bezier curve.
-- Warnings :
-- Even if <me> is not closed it can become closed after the
-- segmentation for example if U1 or U2 are out of the bounds
-- of the curve <me> or if the curve makes loop.
-- After the segmentation the length of a curve can be null.
SetPole (me : mutable; Index : Integer; P : Pnt2d)
--- Purpose :
-- Substitutes the pole of range index with P.
-- If the curve <me> is rational the weight of range Index
-- is not modified.
raises OutOfRange;
--- Purpose : raiseD if Index is not in the range [1, NbPoles]
SetPole (me : mutable; Index : Integer; P : Pnt2d; Weight : Real)
--- Purpose :
-- Substitutes the pole and the weights of range Index.
-- If the curve <me> is not rational it can become rational
-- if all the weights are not identical.
-- If the curve was rational it can become non rational if
-- all the weights are identical.
raises OutOfRange,
--- Purpose : Raised if Index is not in the range [1, NbPoles]
ConstructionError;
--- Purpose : Raised if Weight <= Resolution from package gp
SetWeight (me : mutable; Index : Integer; Weight : Real)
--- Purpose :
-- Changes the weight of the pole of range Index.
-- If the curve <me> is not rational it can become rational
-- if all the weights are not identical.
-- If the curve was rational it can become non rational if
-- all the weights are identical.
raises OutOfRange,
--- Purpose : Raised if Index is not in the range [1, NbPoles]
ConstructionError;
--- Purpose : Raised if Weight <= Resolution from package gp
IsClosed (me) returns Boolean;
--- Purpose :
-- Returns True if the distance between the first point
-- and the last point of the curve is lower or equal to
-- the Resolution from package gp.
IsCN (me; N : Integer) returns Boolean;
--- Purpose : Continuity of the curve, returns True.
IsPeriodic (me) returns Boolean;
--- Purpose :
-- Returns False. A BezierCurve cannot be periodic in this
-- package
IsRational (me) returns Boolean;
--- Purpose :
-- Returns false if all the weights are identical. The tolerance
-- criterion is Resolution from package gp.
Continuity (me) returns Shape from GeomAbs;
--- Purpose : Returns GeomAbs_CN, which is the continuity of any Bezier curve.
Degree (me) returns Integer;
--- Purpose :
-- Returns the polynomial degree of the curve. It is the number
-- of poles less one. In this package the Degree of a Bezier
-- curve cannot be greater than "MaxDegree".
D0 (me; U : Real; P : out Pnt2d);
D1 (me; U : Real; P : out Pnt2d; V1 : out Vec2d);
D2 (me; U : Real; P : out Pnt2d; V1, V2 : out Vec2d);
D3 (me; U : Real; P : out Pnt2d; V1, V2, V3 : out Vec2d);
DN (me; U : Real; N : Integer) returns Vec2d
--- Purpose : For this Bezier curve, computes
-- - the point P of parameter U, or
-- - the point P and one or more of the following values:
-- - V1, the first derivative vector,
-- - V2, the second derivative vector,
-- - V3, the third derivative vector.
-- Note: the parameter U can be outside the bounds of the curve.
-- Raises RangeError if N < 1.
raises RangeError;
EndPoint (me) returns Pnt2d;
--- Purpose : Returns the end point or start point of this Bezier curve.
FirstParameter (me) returns Real;
--- Purpose : Returns the value of the first parameter of this
-- Bezier curve. This is 0.0, which gives the start point of this Bezier curve.
LastParameter (me) returns Real;
--- Purpose : Returns the value of the last parameter of this
-- Bezier curve. This is 1.0, which gives the end point of this Bezier curve.
NbPoles (me) returns Integer;
---Purpose: Returns the number of poles for this Bezier curve.
Pole (me; Index : Integer) returns Pnt2d
--- Purpose : Returns the pole of range Index.
raises OutOfRange;
--- Purpose : Raised if Index is not in the range [1, NbPoles]
Poles (me; P : out Array1OfPnt2d from TColgp)
--- Purpose : Returns all the poles of the curve.
raises DimensionError;
--- Purpose :
-- Raised if the length of P is not equal to the number of poles.
StartPoint (me) returns Pnt2d;
--- Purpose :
-- Returns Value (U=1), it is the first control point
-- of the curve.
Weight (me; Index : Integer) returns Real
--- Purpose : Returns the weight of range Index.
raises OutOfRange;
--- Purpose : Raised if Index is not in the range [1, NbPoles]
Weights (me; W : out Array1OfReal from TColStd)
--- Purpose : Returns all the weights of the curve.
raises DimensionError;
--- Purpose :
-- Raised if the length of W is not equal to the number of poles.
Transform (me : mutable; T : Trsf2d);
---Purpose: Applies the transformation T to this Bezier curve.
MaxDegree (myclass) returns Integer;
--- Purpose:
-- Returns the value of the maximum polynomial degree of a
-- BezierCurve. This value is 25.
Resolution(me : mutable;
ToleranceUV : Real;
UTolerance : out Real);
---Purpose: Computes for this Bezier curve the parametric
-- tolerance UTolerance for a given tolerance
-- Tolerance3D (relative to dimensions in the plane).
-- If f(t) is the equation of this Bezier curve,
-- UTolerance ensures that
-- | t1 - t0| < Utolerance ===>
-- |f(t1) - f(t0)| < ToleranceUV
Copy (me) returns like me;
---Purpose: Creates a new object which is a copy of this Bezier curve.
Init (me : mutable; Poles : HArray1OfPnt2d from TColgp;
Weights : HArray1OfReal from TColStd)
---Purpose : Set poles to Poles, weights to Weights (not
-- copied). If Weights is null the curve is non
-- rational. Create the arrays of coefficients. Poles
-- and Weights are assumed to have the first
-- coefficient 1.
--
-- Update rational and closed.
--
raises ConstructionError -- if nbpoles < 2 or nbboles > MaDegree + 1
is static private;
CoefficientsOK(me; U : Real) returns Boolean
---Purpose : returns true if the coefficients have been
-- computed with the right value of cacheparameter
-- for the given U value.
--
is static private;
UpdateCoefficients(me : mutable; U : Real from Standard = 0.0)
---Purpose: Recompute the coeficients.
is static private;
fields
rational : Boolean;
closed : Boolean;
poles : HArray1OfPnt2d from TColgp;
weights : HArray1OfReal from TColStd;
coeffs : HArray1OfPnt2d from TColgp;
wcoeffs : HArray1OfReal from TColStd;
validcache : Integer;
-- = 1 the cache is valid
-- = 0 the cache is invalid
parametercache : Real;
-- Parameter at which the Taylor expension is stored in
-- the cache, often 0., sometimes 1..
spanlenghtcache : Real;
-- always 1. for the moment.
-- usefull to evaluate the parametric resolution
maxderivinv : Real from Standard;
maxderivinvok : Boolean from Standard;
end;

13
src/Geom2d/Geom2d_BezierCurve.cxx
View File

@@ -27,23 +27,28 @@
#define No_Standard_OutOfRange
#define No_Standard_DimensionError
#include <Geom2d_BezierCurve.ixx>
#include <PLib.hxx>
#include <BSplCLib.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_Geometry.hxx>
#include <gp.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <gp_XY.hxx>
#include <PLib.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_DimensionError.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_RangeError.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Type.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
//=======================================================================
//function : Rational
//purpose : check rationality of an array of weights
//=======================================================================
static Standard_Boolean Rational(const TColStd_Array1OfReal& W)
{
Standard_Integer i, n = W.Length();

361
src/Geom2d/Geom2d_BezierCurve.hxx Normal file
View File

@@ -0,0 +1,361 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_BezierCurve_HeaderFile
#define _Geom2d_BezierCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
#include <TColgp_HArray1OfPnt2d.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Geom2d_BoundedCurve.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <GeomAbs_Shape.hxx>
class Standard_ConstructionError;
class Standard_DimensionError;
class Standard_RangeError;
class Standard_OutOfRange;
class gp_Pnt2d;
class gp_Vec2d;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_BezierCurve;
DEFINE_STANDARD_HANDLE(Geom2d_BezierCurve, Geom2d_BoundedCurve)
//! Describes a rational or non-rational Bezier curve
//! - a non-rational Bezier curve is defined by a table
//! of poles (also called control points),
//! - a rational Bezier curve is defined by a table of
//! poles with varying weights.
//! These data are manipulated by two parallel arrays:
//! - the poles table, which is an array of gp_Pnt2d points, and
//! - the weights table, which is an array of reals.
//! The bounds of these arrays are 1 and "the number of poles" of the curve.
//! The poles of the curve are "control points" used to deform the curve.
//! The first pole is the start point of the curve, and the
//! last pole is the end point of the curve. The segment
//! which joins the first pole to the second pole is the
//! tangent to the curve at its start point, and the
//! segment which joins the last pole to the
//! second-from-last pole is the tangent to the curve
//! at its end point.
//! It is more difficult to give a geometric signification
//! to the weights but they are useful for providing
//! exact representations of the arcs of a circle or
//! ellipse. Moreover, if the weights of all the poles are
//! equal, the curve is polynomial; it is therefore a
//! non-rational curve. The non-rational curve is a
//! special and frequently used case. The weights are
//! defined and used only in case of a rational curve.
//! The degree of a Bezier curve is equal to the
//! number of poles, minus 1. It must be greater than or
//! equal to 1. However, the degree of a
//! Geom2d_BezierCurve curve is limited to a value
//! (25) which is defined and controlled by the system.
//! This value is returned by the function MaxDegree.
//! The parameter range for a Bezier curve is [ 0, 1 ].
//! If the first and last control points of the Bezier
//! curve are the same point then the curve is closed.
//! For example, to create a closed Bezier curve with
//! four control points, you have to give a set of control
//! points P1, P2, P3 and P1.
//! The continuity of a Bezier curve is infinite.
//! It is not possible to build a Bezier curve with
//! negative weights. We consider that a weight value
//! is zero if it is less than or equal to
//! gp::Resolution(). We also consider that
//! two weight values W1 and W2 are equal if:
//! |W2 - W1| <= gp::Resolution().
//! Warning
//! - When considering the continuity of a closed
//! Bezier curve at the junction point, remember that
//! a curve of this type is never periodic. This means
//! that the derivatives for the parameter u = 0
//! have no reason to be the same as the
//! derivatives for the parameter u = 1 even if the curve is closed.
//! - The length of a Bezier curve can be null.
class Geom2d_BezierCurve : public Geom2d_BoundedCurve
{
public:
//! Creates a non rational Bezier curve with a set of poles :
//! CurvePoles. The weights are defaulted to all being 1.
//! Raises ConstructionError if the number of poles is greater than MaxDegree + 1
//! or lower than 2.
Standard_EXPORT Geom2d_BezierCurve(const TColgp_Array1OfPnt2d& CurvePoles);
//! Creates a rational Bezier curve with the set of poles
//! CurvePoles and the set of weights PoleWeights .
//! If all the weights are identical the curve is considered
//! as non rational. Raises ConstructionError if
//! the number of poles is greater than MaxDegree + 1 or lower
//! than 2 or CurvePoles and CurveWeights have not the same length
//! or one weight value is lower or equal to Resolution from
//! package gp.
Standard_EXPORT Geom2d_BezierCurve(const TColgp_Array1OfPnt2d& CurvePoles, const TColStd_Array1OfReal& PoleWeights);
//! Increases the degree of a bezier curve. Degree is the new
//! degree of <me>.
//! raises ConstructionError if Degree is greater than MaxDegree or lower than 2
//! or lower than the initial degree of <me>.
Standard_EXPORT void Increase (const Standard_Integer Degree);
//! Inserts a pole with its weight in the set of poles after the
//! pole of range Index. If the curve was non rational it can
//! become rational if all the weights are not identical.
//! Raised if Index is not in the range [0, NbPoles]
//!
//! Raised if the resulting number of poles is greater than
//! MaxDegree + 1.
Standard_EXPORT void InsertPoleAfter (const Standard_Integer Index, const gp_Pnt2d& P, const Standard_Real Weight = 1.0);
//! Inserts a pole with its weight in the set of poles after
//! the pole of range Index. If the curve was non rational it
//! can become rational if all the weights are not identical.
//! Raised if Index is not in the range [1, NbPoles+1]
//!
//! Raised if the resulting number of poles is greater than
//! MaxDegree + 1.
Standard_EXPORT void InsertPoleBefore (const Standard_Integer Index, const gp_Pnt2d& P, const Standard_Real Weight = 1.0);
//! Removes the pole of range Index.
//! If the curve was rational it can become non rational.
//! Raised if Index is not in the range [1, NbPoles]
Standard_EXPORT void RemovePole (const Standard_Integer Index);
//! Reverses the direction of parametrization of <me>
//! Value (NewU) = Value (1 - OldU)
Standard_EXPORT void Reverse();
//! Returns the parameter on the reversed curve for
//! the point of parameter U on <me>.
//!
//! returns 1-U
Standard_EXPORT Standard_Real ReversedParameter (const Standard_Real U) const;
//! Segments the curve between U1 and U2 which can be out
//! of the bounds of the curve. The curve is oriented from U1
//! to U2.
//! The control points are modified, the first and the last point
//! are not the same but the parametrization range is [0, 1]
//! else it could not be a Bezier curve.
//! Warnings :
//! Even if <me> is not closed it can become closed after the
//! segmentation for example if U1 or U2 are out of the bounds
//! of the curve <me> or if the curve makes loop.
//! After the segmentation the length of a curve can be null.
Standard_EXPORT void Segment (const Standard_Real U1, const Standard_Real U2);
//! Substitutes the pole of range index with P.
//! If the curve <me> is rational the weight of range Index
//! is not modified.
//! raiseD if Index is not in the range [1, NbPoles]
Standard_EXPORT void SetPole (const Standard_Integer Index, const gp_Pnt2d& P);
//! Substitutes the pole and the weights of range Index.
//! If the curve <me> is not rational it can become rational
//! if all the weights are not identical.
//! If the curve was rational it can become non rational if
//! all the weights are identical.
//! Raised if Index is not in the range [1, NbPoles]
//! Raised if Weight <= Resolution from package gp
Standard_EXPORT void SetPole (const Standard_Integer Index, const gp_Pnt2d& P, const Standard_Real Weight);
//! Changes the weight of the pole of range Index.
//! If the curve <me> is not rational it can become rational
//! if all the weights are not identical.
//! If the curve was rational it can become non rational if
//! all the weights are identical.
//! Raised if Index is not in the range [1, NbPoles]
//! Raised if Weight <= Resolution from package gp
Standard_EXPORT void SetWeight (const Standard_Integer Index, const Standard_Real Weight);
//! Returns True if the distance between the first point
//! and the last point of the curve is lower or equal to
//! the Resolution from package gp.
Standard_EXPORT Standard_Boolean IsClosed() const;
//! Continuity of the curve, returns True.
Standard_EXPORT Standard_Boolean IsCN (const Standard_Integer N) const;
//! Returns False. A BezierCurve cannot be periodic in this
//! package
Standard_EXPORT Standard_Boolean IsPeriodic() const;
//! Returns false if all the weights are identical. The tolerance
//! criterion is Resolution from package gp.
Standard_EXPORT Standard_Boolean IsRational() const;
//! Returns GeomAbs_CN, which is the continuity of any Bezier curve.
Standard_EXPORT GeomAbs_Shape Continuity() const;
//! Returns the polynomial degree of the curve. It is the number
//! of poles less one. In this package the Degree of a Bezier
//! curve cannot be greater than "MaxDegree".
Standard_EXPORT Standard_Integer Degree() const;
Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt2d& P) const;
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1) const;
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const;
Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const;
//! For this Bezier curve, computes
//! - the point P of parameter U, or
//! - the point P and one or more of the following values:
//! - V1, the first derivative vector,
//! - V2, the second derivative vector,
//! - V3, the third derivative vector.
//! Note: the parameter U can be outside the bounds of the curve.
//! Raises RangeError if N < 1.
Standard_EXPORT gp_Vec2d DN (const Standard_Real U, const Standard_Integer N) const;
//! Returns the end point or start point of this Bezier curve.
Standard_EXPORT gp_Pnt2d EndPoint() const;
//! Returns the value of the first parameter of this
//! Bezier curve. This is 0.0, which gives the start point of this Bezier curve.
Standard_EXPORT Standard_Real FirstParameter() const;
//! Returns the value of the last parameter of this
//! Bezier curve. This is 1.0, which gives the end point of this Bezier curve.
Standard_EXPORT Standard_Real LastParameter() const;
//! Returns the number of poles for this Bezier curve.
Standard_EXPORT Standard_Integer NbPoles() const;
//! Returns the pole of range Index.
//! Raised if Index is not in the range [1, NbPoles]
Standard_EXPORT gp_Pnt2d Pole (const Standard_Integer Index) const;
//! Returns all the poles of the curve.
//!
//! Raised if the length of P is not equal to the number of poles.
Standard_EXPORT void Poles (TColgp_Array1OfPnt2d& P) const;
//! Returns Value (U=1), it is the first control point
//! of the curve.
Standard_EXPORT gp_Pnt2d StartPoint() const;
//! Returns the weight of range Index.
//! Raised if Index is not in the range [1, NbPoles]
Standard_EXPORT Standard_Real Weight (const Standard_Integer Index) const;
//! Returns all the weights of the curve.
//!
//! Raised if the length of W is not equal to the number of poles.
Standard_EXPORT void Weights (TColStd_Array1OfReal& W) const;
//! Applies the transformation T to this Bezier curve.
Standard_EXPORT void Transform (const gp_Trsf2d& T);
//! Returns the value of the maximum polynomial degree of a
//! BezierCurve. This value is 25.
Standard_EXPORT static Standard_Integer MaxDegree();
//! Computes for this Bezier curve the parametric
//! tolerance UTolerance for a given tolerance
//! Tolerance3D (relative to dimensions in the plane).
//! If f(t) is the equation of this Bezier curve,
//! UTolerance ensures that
//! | t1 - t0| < Utolerance ===>
//! |f(t1) - f(t0)| < ToleranceUV
Standard_EXPORT void Resolution (const Standard_Real ToleranceUV, Standard_Real& UTolerance);
//! Creates a new object which is a copy of this Bezier curve.
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const;
DEFINE_STANDARD_RTTI(Geom2d_BezierCurve,Geom2d_BoundedCurve)
protected:
private:
//! Set poles to Poles, weights to Weights (not
//! copied). If Weights is null the curve is non
//! rational. Create the arrays of coefficients. Poles
//! and Weights are assumed to have the first
//! coefficient 1.
//!
//! Update rational and closed.
//!
//! if nbpoles < 2 or nbboles > MaDegree + 1
Standard_EXPORT void Init (const Handle(TColgp_HArray1OfPnt2d)& Poles, const Handle(TColStd_HArray1OfReal)& Weights);
//! returns true if the coefficients have been
//! computed with the right value of cacheparameter
//! for the given U value.
Standard_EXPORT Standard_Boolean CoefficientsOK (const Standard_Real U) const;
//! Recompute the coeficients.
Standard_EXPORT void UpdateCoefficients (const Standard_Real U = 0.0);
Standard_Boolean rational;
Standard_Boolean closed;
Handle(TColgp_HArray1OfPnt2d) poles;
Handle(TColStd_HArray1OfReal) weights;
Handle(TColgp_HArray1OfPnt2d) coeffs;
Handle(TColStd_HArray1OfReal) wcoeffs;
Standard_Integer validcache;
Standard_Real parametercache;
Standard_Real spanlenghtcache;
Standard_Real maxderivinv;
Standard_Boolean maxderivinvok;
};
#endif // _Geom2d_BezierCurve_HeaderFile

55
src/Geom2d/Geom2d_BoundedCurve.cdl
View File

@@ -1,55 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 BoundedCurve from Geom2d inherits Curve from Geom2d
--- Purpose : The abstract class BoundedCurve describes the
-- common behavior of bounded curves in 2D space. A
-- bounded curve is limited by two finite values of the
-- parameter, termed respectively "first parameter" and
-- "last parameter". The "first parameter" gives the "start
-- point" of the bounded curve, and the "last parameter"
-- gives the "end point" of the bounded curve.
-- The length of a bounded curve is finite.
-- The Geom2d package provides three concrete
-- classes of bounded curves:
-- - two frequently used mathematical formulations of complex curves:
-- - Geom2d_BezierCurve,
-- - Geom2d_BSplineCurve, and
-- - Geom2d_TrimmedCurve to trim a curve, i.e. to
-- only take part of the curve limited by two values of
-- the parameter of the basis curve.
uses Pnt2d from gp
is
EndPoint (me) returns Pnt2d is deferred;
--- Purpose :
-- Returns the end point of the curve.
-- The end point is the value of the curve for the
-- "LastParameter" of the curve.
StartPoint (me) returns Pnt2d is deferred;
--- Purpose :
-- Returns the start point of the curve.
-- The start point is the value of the curve for the
-- "FirstParameter" of the curve.
end;

5
src/Geom2d/Geom2d_BoundedCurve.cxx
View File

@@ -14,6 +14,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_BoundedCurve.ixx>
#include <Geom2d_BoundedCurve.hxx>
#include <gp_Pnt2d.hxx>
#include <Standard_Type.hxx>

87
src/Geom2d/Geom2d_BoundedCurve.hxx Normal file
View File

@@ -0,0 +1,87 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_BoundedCurve_HeaderFile
#define _Geom2d_BoundedCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Geom2d_Curve.hxx>
class gp_Pnt2d;
class Geom2d_BoundedCurve;
DEFINE_STANDARD_HANDLE(Geom2d_BoundedCurve, Geom2d_Curve)
//! The abstract class BoundedCurve describes the
//! common behavior of bounded curves in 2D space. A
//! bounded curve is limited by two finite values of the
//! parameter, termed respectively "first parameter" and
//! "last parameter". The "first parameter" gives the "start
//! point" of the bounded curve, and the "last parameter"
//! gives the "end point" of the bounded curve.
//! The length of a bounded curve is finite.
//! The Geom2d package provides three concrete
//! classes of bounded curves:
//! - two frequently used mathematical formulations of complex curves:
//! - Geom2d_BezierCurve,
//! - Geom2d_BSplineCurve, and
//! - Geom2d_TrimmedCurve to trim a curve, i.e. to
//! only take part of the curve limited by two values of
//! the parameter of the basis curve.
class Geom2d_BoundedCurve : public Geom2d_Curve
{
public:
//! Returns the end point of the curve.
//! The end point is the value of the curve for the
//! "LastParameter" of the curve.
Standard_EXPORT virtual gp_Pnt2d EndPoint() const = 0;
//! Returns the start point of the curve.
//! The start point is the value of the curve for the
//! "FirstParameter" of the curve.
Standard_EXPORT virtual gp_Pnt2d StartPoint() const = 0;
DEFINE_STANDARD_RTTI(Geom2d_BoundedCurve,Geom2d_Curve)
protected:
private:
};
#endif // _Geom2d_BoundedCurve_HeaderFile

87
src/Geom2d/Geom2d_CartesianPoint.cdl
View File

@@ -1,87 +0,0 @@
-- Created on: 1993-03-24
-- Created by: Philippe DAUTRY
-- 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 CartesianPoint from Geom2d inherits Point from Geom2d
--- Purpose : Describes a point in 2D space. A
-- Geom2d_CartesianPoint is defined by a gp_Pnt2d
-- point, with its two Cartesian coordinates X and Y.
uses Ax2d from gp,
Pnt2d from gp,
Trsf2d from gp,
Vec2d from gp,
Geometry from Geom2d
is
Create (P : Pnt2d) returns CartesianPoint;
--- Purpose : Returns a persistent copy of P.
Create (X, Y : Real) returns CartesianPoint;
SetCoord (me : mutable; X, Y : Real);
--- Purpose : Set <me> to X, Y coordinates.
SetPnt2d (me : mutable; P : Pnt2d);
--- Purpose : Set <me> to P.X(), P.Y() coordinates.
SetX (me : mutable; X : Real);
--- Purpose : Changes the X coordinate of me.
SetY (me : mutable; Y : Real);
--- Purpose : Changes the Y coordinate of me.
Coord (me; X, Y : out Real);
--- Purpose : Returns the coordinates of <me>.
Pnt2d (me) returns Pnt2d;
--- Purpose :
-- Returns a non persistent cartesian point with
-- the same coordinates as <me>.
-- -C++: return const&
X (me) returns Real;
--- Purpose : Returns the X coordinate of <me>.
Y (me) returns Real;
--- Purpose : Returns the Y coordinate of <me>.
Transform (me : mutable; T : Trsf2d);
Copy (me) returns like me;
fields
gpPnt2d : Pnt2d;
end;

7
src/Geom2d/Geom2d_CartesianPoint.cxx
View File

@@ -14,7 +14,12 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_CartesianPoint.ixx>
#include <Geom2d_CartesianPoint.hxx>
#include <Geom2d_Geometry.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_CartesianPoint CartesianPoint;
typedef gp_Ax2d Ax2d;

103
src/Geom2d/Geom2d_CartesianPoint.hxx Normal file
View File

@@ -0,0 +1,103 @@
// Created on: 1993-03-24
// Created by: Philippe DAUTRY
// 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.
#ifndef _Geom2d_CartesianPoint_HeaderFile
#define _Geom2d_CartesianPoint_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <gp_Pnt2d.hxx>
#include <Geom2d_Point.hxx>
#include <Standard_Real.hxx>
class gp_Pnt2d;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_CartesianPoint;
DEFINE_STANDARD_HANDLE(Geom2d_CartesianPoint, Geom2d_Point)
//! Describes a point in 2D space. A
//! Geom2d_CartesianPoint is defined by a gp_Pnt2d
//! point, with its two Cartesian coordinates X and Y.
class Geom2d_CartesianPoint : public Geom2d_Point
{
public:
//! Returns a persistent copy of P.
Standard_EXPORT Geom2d_CartesianPoint(const gp_Pnt2d& P);
Standard_EXPORT Geom2d_CartesianPoint(const Standard_Real X, const Standard_Real Y);
//! Set <me> to X, Y coordinates.
Standard_EXPORT void SetCoord (const Standard_Real X, const Standard_Real Y);
//! Set <me> to P.X(), P.Y() coordinates.
Standard_EXPORT void SetPnt2d (const gp_Pnt2d& P);
//! Changes the X coordinate of me.
Standard_EXPORT void SetX (const Standard_Real X);
//! Changes the Y coordinate of me.
Standard_EXPORT void SetY (const Standard_Real Y);
//! Returns the coordinates of <me>.
Standard_EXPORT void Coord (Standard_Real& X, Standard_Real& Y) const;
//! Returns a non persistent cartesian point with
//! the same coordinates as <me>.
//! -C++: return const&
Standard_EXPORT gp_Pnt2d Pnt2d() const;
//! Returns the X coordinate of <me>.
Standard_EXPORT Standard_Real X() const;
//! Returns the Y coordinate of <me>.
Standard_EXPORT Standard_Real Y() const;
Standard_EXPORT void Transform (const gp_Trsf2d& T);
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const;
DEFINE_STANDARD_RTTI(Geom2d_CartesianPoint,Geom2d_Point)
protected:
private:
gp_Pnt2d gpPnt2d;
};
#endif // _Geom2d_CartesianPoint_HeaderFile

180
src/Geom2d/Geom2d_Circle.cdl
View File

@@ -1,180 +0,0 @@
-- Created on: 1993-03-24
-- Created by: Philippe DAUTRY
-- 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 Circle from Geom2d inherits Conic from Geom2d
--- Purpose : Describes a circle in the plane (2D space).
-- A circle is defined by its radius and, as with any conic
-- curve, is positioned in the plane with a coordinate
-- system (gp_Ax22d object) where the origin is the
-- center of the circle.
-- The coordinate system is the local coordinate
-- system of the circle.
-- The orientation (direct or indirect) of the local
-- coordinate system gives an explicit orientation to the
-- circle, determining the direction in which the
-- parameter increases along the circle.
-- The Geom2d_Circle circle is parameterized by an angle:
-- P(U) = O + R*Cos(U)*XDir + R*Sin(U)*YDir
-- where:
-- - P is the point of parameter U,
-- - O, XDir and YDir are respectively the origin, "X
-- Direction" and "Y Direction" of its local coordinate system,
-- - R is the radius of the circle.
-- The "X Axis" of the local coordinate system therefore
-- defines the origin of the parameter of the circle. The
-- parameter is the angle with this "X Direction".
-- A circle is a closed and periodic curve. The period is
-- 2.*Pi and the parameter range is [ 0,2.*Pi [.
-- See Also
-- GCE2d_MakeCircle which provides functions for
-- more complex circle constructions
-- gp_Ax22d and gp_Circ2d for an equivalent, non-parameterized data structure.
uses Ax2d from gp,
Ax22d from gp,
Circ2d from gp,
Pnt2d from gp,
Trsf2d from gp,
Vec2d from gp,
Geometry from Geom2d
raises ConstructionError from Standard,
RangeError from Standard
is
Create (C : Circ2d) returns Circle;
--- Purpose : Constructs a circle by conversion of the gp_Circ2d circle C.
Create (A : Ax2d; Radius : Real;
Sense: Boolean from Standard = Standard_True)
returns Circle
--- Purpose : Constructs a circle of radius Radius, whose center is the origin of axis
-- A; A is the "X Axis" of the local coordinate system
-- of the circle; this coordinate system is direct if
-- Sense is true (default value) or indirect if Sense is false.
-- Note: It is possible to create a circle where Radius is equal to 0.0.
-- Exceptions Standard_ConstructionError if Radius is negative.
raises ConstructionError;
Create (A : Ax22d; Radius : Real) returns Circle
--- Purpose : Constructs a circle
-- of radius Radius, where the coordinate system A
-- locates the circle and defines its orientation in the plane such that:
-- - the center of the circle is the origin of A,
-- - the orientation (direct or indirect) of A gives the
-- orientation of the circle.
raises ConstructionError;
SetCirc2d (me : mutable; C : Circ2d);
--- Purpose :
-- Converts the gp_Circ2d circle C into this circle.
SetRadius (me : mutable; R : Real)
--- Warnings : Assigns the value R to the radius of this circle.
-- Note: It is possible to have a circle with a radius equal to 0.0.
-- Exceptions Standard_ConstructionError if R is negative.
raises ConstructionError;
Circ2d (me) returns Circ2d;
--- Purpose :
-- Returns the non persistent circle from gp with the same
-- geometric properties as <me>.
Radius(me) returns Real
is static;
---Purpose: Returns the radius of this circle.
ReversedParameter(me; U : Real) returns Real is redefined static;
---Purpose: Computes the parameter on the reversed circle for
-- the point of parameter U on this circle.
-- For a circle, the returned value is: 2.*Pi - U.
Eccentricity (me) returns Real is redefined static;
--- Purpose : Returns 0., which is the eccentricity of any circle.
FirstParameter (me) returns Real is redefined static;
--- Purpose : Returns 0.0
LastParameter (me) returns Real is redefined static;
--- Purpose : Returns 2*PI.
IsClosed (me) returns Boolean is redefined static;
--- Purpose : returns True.
IsPeriodic (me) returns Boolean is redefined static;
--- Purpose : returns True. The period of a circle is 2.*Pi.
D0(me; U : Real; P : out Pnt2d) is redefined static;
---Purpose: Returns in P the point of parameter U.
-- P = C + R * Cos (U) * XDir + R * Sin (U) * YDir
-- where C is the center of the circle , XDir the XDirection and
-- YDir the YDirection of the circle's local coordinate system.
D1 (me; U : Real; P : out Pnt2d; V1 : out Vec2d) is redefined static;
--- Purpose :
-- Returns the point P of parameter U and the first derivative V1.
D2 (me; U : Real; P : out Pnt2d; V1, V2 : out Vec2d) is redefined static;
--- Purpose :
-- Returns the point P of parameter U, the first and second
-- derivatives V1 and V2.
D3 (me; U : Real; P : out Pnt2d; V1, V2, V3 : out Vec2d) is redefined static;
--- Purpose :
-- Returns the point P of parameter u, the first second and third
-- derivatives V1 V2 and V3.
DN (me; U : Real; N : Integer) returns Vec2d
--- Purpose : For the point of parameter U of this circle, computes
-- the vector corresponding to the Nth derivative.
-- Exceptions: Standard_RangeError if N is less than 1.
raises RangeError
is redefined static;
Transform (me : mutable; T : Trsf2d) is redefined static;
---Purpose: Applies the transformation T to this circle.
Copy (me) returns like me
is redefined static;
---Purpose: Creates a new object which is a copy of this circle.
fields
radius : Real;
end;

18
src/Geom2d/Geom2d_Circle.cxx
View File

@@ -14,12 +14,20 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_Circle.ixx>
#include <ElCLib.hxx>
#include <gp_XY.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_ConstructionError.hxx>
#include <ElCLib.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom2d_Geometry.hxx>
#include <gp_Ax2d.hxx>
#include <gp_Ax22d.hxx>
#include <gp_Circ2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <gp_XY.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Circle Circle;
typedef gp_Ax2d Ax2d;

182
src/Geom2d/Geom2d_Circle.hxx Normal file
View File

@@ -0,0 +1,182 @@
// Created on: 1993-03-24
// Created by: Philippe DAUTRY
// 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.
#ifndef _Geom2d_Circle_HeaderFile
#define _Geom2d_Circle_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
#include <Geom2d_Conic.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Standard_ConstructionError;
class Standard_RangeError;
class gp_Circ2d;
class gp_Ax2d;
class gp_Ax22d;
class gp_Pnt2d;
class gp_Vec2d;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_Circle;
DEFINE_STANDARD_HANDLE(Geom2d_Circle, Geom2d_Conic)
//! Describes a circle in the plane (2D space).
//! A circle is defined by its radius and, as with any conic
//! curve, is positioned in the plane with a coordinate
//! system (gp_Ax22d object) where the origin is the
//! center of the circle.
//! The coordinate system is the local coordinate
//! system of the circle.
//! The orientation (direct or indirect) of the local
//! coordinate system gives an explicit orientation to the
//! circle, determining the direction in which the
//! parameter increases along the circle.
//! The Geom2d_Circle circle is parameterized by an angle:
//! P(U) = O + R*Cos(U)*XDir + R*Sin(U)*YDir
//! where:
//! - P is the point of parameter U,
//! - O, XDir and YDir are respectively the origin, "X
//! Direction" and "Y Direction" of its local coordinate system,
//! - R is the radius of the circle.
//! The "X Axis" of the local coordinate system therefore
//! defines the origin of the parameter of the circle. The
//! parameter is the angle with this "X Direction".
//! A circle is a closed and periodic curve. The period is
//! 2.*Pi and the parameter range is [ 0,2.*Pi [.
//! See Also
//! GCE2d_MakeCircle which provides functions for
//! more complex circle constructions
//! gp_Ax22d and gp_Circ2d for an equivalent, non-parameterized data structure.
class Geom2d_Circle : public Geom2d_Conic
{
public:
//! Constructs a circle by conversion of the gp_Circ2d circle C.
Standard_EXPORT Geom2d_Circle(const gp_Circ2d& C);
//! Constructs a circle of radius Radius, whose center is the origin of axis
//! A; A is the "X Axis" of the local coordinate system
//! of the circle; this coordinate system is direct if
//! Sense is true (default value) or indirect if Sense is false.
//! Note: It is possible to create a circle where Radius is equal to 0.0.
//! Exceptions Standard_ConstructionError if Radius is negative.
Standard_EXPORT Geom2d_Circle(const gp_Ax2d& A, const Standard_Real Radius, const Standard_Boolean Sense = Standard_True);
//! Constructs a circle
//! of radius Radius, where the coordinate system A
//! locates the circle and defines its orientation in the plane such that:
//! - the center of the circle is the origin of A,
//! - the orientation (direct or indirect) of A gives the
//! orientation of the circle.
Standard_EXPORT Geom2d_Circle(const gp_Ax22d& A, const Standard_Real Radius);
//! Converts the gp_Circ2d circle C into this circle.
Standard_EXPORT void SetCirc2d (const gp_Circ2d& C);
Standard_EXPORT void SetRadius (const Standard_Real R);
//! Returns the non persistent circle from gp with the same
//! geometric properties as <me>.
Standard_EXPORT gp_Circ2d Circ2d() const;
//! Returns the radius of this circle.
Standard_EXPORT Standard_Real Radius() const;
//! Computes the parameter on the reversed circle for
//! the point of parameter U on this circle.
//! For a circle, the returned value is: 2.*Pi - U.
Standard_EXPORT Standard_Real ReversedParameter (const Standard_Real U) const Standard_OVERRIDE;
//! Returns 0., which is the eccentricity of any circle.
Standard_EXPORT Standard_Real Eccentricity() const Standard_OVERRIDE;
//! Returns 0.0
Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE;
//! Returns 2*PI.
Standard_EXPORT Standard_Real LastParameter() const Standard_OVERRIDE;
//! returns True.
Standard_EXPORT Standard_Boolean IsClosed() const Standard_OVERRIDE;
//! returns True. The period of a circle is 2.*Pi.
Standard_EXPORT Standard_Boolean IsPeriodic() const Standard_OVERRIDE;
//! Returns in P the point of parameter U.
//! P = C + R * Cos (U) * XDir + R * Sin (U) * YDir
//! where C is the center of the circle , XDir the XDirection and
//! YDir the YDirection of the circle's local coordinate system.
Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt2d& P) const Standard_OVERRIDE;
//! Returns the point P of parameter U and the first derivative V1.
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1) const Standard_OVERRIDE;
//! Returns the point P of parameter U, the first and second
//! derivatives V1 and V2.
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const Standard_OVERRIDE;
//! Returns the point P of parameter u, the first second and third
//! derivatives V1 V2 and V3.
Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const Standard_OVERRIDE;
//! For the point of parameter U of this circle, computes
//! the vector corresponding to the Nth derivative.
//! Exceptions: Standard_RangeError if N is less than 1.
Standard_EXPORT gp_Vec2d DN (const Standard_Real U, const Standard_Integer N) const Standard_OVERRIDE;
//! Applies the transformation T to this circle.
Standard_EXPORT void Transform (const gp_Trsf2d& T) Standard_OVERRIDE;
//! Creates a new object which is a copy of this circle.
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const Standard_OVERRIDE;
DEFINE_STANDARD_RTTI(Geom2d_Circle,Geom2d_Conic)
protected:
private:
Standard_Real radius;
};
#endif // _Geom2d_Circle_HeaderFile

142
src/Geom2d/Geom2d_Conic.cdl
View File

@@ -1,142 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 Conic from Geom2d inherits Curve from Geom2d
--- Purpose : The abstract class Conic describes the common
-- behavior of conic curves in 2D space and, in
-- particular, their general characteristics. The Geom2d
-- package provides four specific classes of conics:
-- Geom2d_Circle, Geom2d_Ellipse,
-- Geom2d_Hyperbola and Geom2d_Parabola.
-- A conic is positioned in the plane with a coordinate
-- system (gp_Ax22d object), where the origin is the
-- center of the conic (or the apex in case of a parabola).
-- This coordinate system is the local coordinate
-- system of the conic. It gives the conic an explicit
-- orientation, determining the direction in which the
-- parameter increases along the conic. The "X Axis" of
-- the local coordinate system also defines the origin of
-- the parameter of the conic.
uses Ax2d from gp,
Ax22d from gp,
Pnt2d from gp,
Vec2d from gp,
Shape from GeomAbs
raises ConstructionError from Standard,
DomainError from Standard
is
SetAxis (me: mutable; A: Ax22d);
---Purpose: Modifies this conic, redefining its local coordinate system
-- partially, by assigning P as its origin
SetXAxis (me : mutable; A : Ax2d);
SetYAxis (me : mutable; A : Ax2d);
---Purpose: Assigns the origin and unit vector of axis A to the
-- origin of the local coordinate system of this conic and either:
-- - its "X Direction", or
-- - its "Y Direction".
-- The other unit vector of the local coordinate system
-- of this conic is recomputed normal to A, without
-- changing the orientation of the local coordinate
-- system (right-handed or left-handed).
SetLocation (me : mutable; P : Pnt2d);
--- Purpose : Modifies this conic, redefining its local coordinate
-- system fully, by assigning A as this coordinate system.
XAxis (me) returns Ax2d;
--- Purpose :
-- Returns the "XAxis" of the conic.
-- This axis defines the origin of parametrization of the conic.
-- This axis and the "Yaxis" define the local coordinate system
-- of the conic.
-- -C++: return const&
YAxis (me) returns Ax2d;
--- Purpose :
-- Returns the "YAxis" of the conic.
-- The "YAxis" is perpendicular to the "Xaxis".
Eccentricity (me) returns Real
--- Purpose :
-- returns the eccentricity value of the conic e.
-- e = 0 for a circle
-- 0 < e < 1 for an ellipse (e = 0 if MajorRadius = MinorRadius)
-- e > 1 for a hyperbola
-- e = 1 for a parabola
raises DomainError
is deferred;
Location (me) returns Pnt2d;
--- Purpose :
-- Returns the location point of the conic.
-- For the circle, the ellipse and the hyperbola it is the center of
-- the conic. For the parabola it is the vertex of the parabola.
Position (me) returns Ax22d;
---Purpose :
-- Returns the local coordinates system of the conic.
---C++: return const&
Reverse (me : mutable);
--- Purpose :
-- Reverses the direction of parameterization of <me>.
-- The local coordinate system of the conic is modified.
ReversedParameter(me; U : Real) returns Real
---Purpose: Returns the parameter on the reversed curve for
-- the point of parameter U on <me>.
--
is deferred;
Continuity (me) returns Shape from GeomAbs;
--- Purpose : Returns GeomAbs_CN which is the global continuity of any conic.
IsCN (me; N : Integer) returns Boolean;
--- Purpose :
-- Returns True, the order of continuity of a conic is infinite.
fields
pos : Ax22d is protected;
end;

9
src/Geom2d/Geom2d_Conic.cxx
View File

@@ -14,8 +14,15 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_Conic.ixx>
#include <Geom2d_Conic.hxx>
#include <gp_Ax2d.hxx>
#include <gp_Ax22d.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Pnt2d.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Conic Conic;
typedef Handle(Geom2d_Conic) Handle(Conic);

151
src/Geom2d/Geom2d_Conic.hxx Normal file
View File

@@ -0,0 +1,151 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_Conic_HeaderFile
#define _Geom2d_Conic_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <gp_Ax22d.hxx>
#include <Geom2d_Curve.hxx>
#include <Standard_Real.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Standard_ConstructionError;
class Standard_DomainError;
class gp_Ax22d;
class gp_Ax2d;
class gp_Pnt2d;
class Geom2d_Conic;
DEFINE_STANDARD_HANDLE(Geom2d_Conic, Geom2d_Curve)
//! The abstract class Conic describes the common
//! behavior of conic curves in 2D space and, in
//! particular, their general characteristics. The Geom2d
//! package provides four specific classes of conics:
//! Geom2d_Circle, Geom2d_Ellipse,
//! Geom2d_Hyperbola and Geom2d_Parabola.
//! A conic is positioned in the plane with a coordinate
//! system (gp_Ax22d object), where the origin is the
//! center of the conic (or the apex in case of a parabola).
//! This coordinate system is the local coordinate
//! system of the conic. It gives the conic an explicit
//! orientation, determining the direction in which the
//! parameter increases along the conic. The "X Axis" of
//! the local coordinate system also defines the origin of
//! the parameter of the conic.
class Geom2d_Conic : public Geom2d_Curve
{
public:
//! Modifies this conic, redefining its local coordinate system
//! partially, by assigning P as its origin
Standard_EXPORT void SetAxis (const gp_Ax22d& A);
Standard_EXPORT void SetXAxis (const gp_Ax2d& A);
//! Assigns the origin and unit vector of axis A to the
//! origin of the local coordinate system of this conic and either:
//! - its "X Direction", or
//! - its "Y Direction".
//! The other unit vector of the local coordinate system
//! of this conic is recomputed normal to A, without
//! changing the orientation of the local coordinate
//! system (right-handed or left-handed).
Standard_EXPORT void SetYAxis (const gp_Ax2d& A);
//! Modifies this conic, redefining its local coordinate
//! system fully, by assigning A as this coordinate system.
Standard_EXPORT void SetLocation (const gp_Pnt2d& P);
//! Returns the "XAxis" of the conic.
//! This axis defines the origin of parametrization of the conic.
//! This axis and the "Yaxis" define the local coordinate system
//! of the conic.
//! -C++: return const&
Standard_EXPORT gp_Ax2d XAxis() const;
//! Returns the "YAxis" of the conic.
//! The "YAxis" is perpendicular to the "Xaxis".
Standard_EXPORT gp_Ax2d YAxis() const;
//! returns the eccentricity value of the conic e.
//! e = 0 for a circle
//! 0 < e < 1 for an ellipse (e = 0 if MajorRadius = MinorRadius)
//! e > 1 for a hyperbola
//! e = 1 for a parabola
Standard_EXPORT virtual Standard_Real Eccentricity() const = 0;
//! Returns the location point of the conic.
//! For the circle, the ellipse and the hyperbola it is the center of
//! the conic. For the parabola it is the vertex of the parabola.
Standard_EXPORT gp_Pnt2d Location() const;
//! Returns the local coordinates system of the conic.
Standard_EXPORT const gp_Ax22d& Position() const;
//! Reverses the direction of parameterization of <me>.
//! The local coordinate system of the conic is modified.
Standard_EXPORT void Reverse();
//! Returns the parameter on the reversed curve for
//! the point of parameter U on <me>.
Standard_EXPORT virtual Standard_Real ReversedParameter (const Standard_Real U) const = 0;
//! Returns GeomAbs_CN which is the global continuity of any conic.
Standard_EXPORT GeomAbs_Shape Continuity() const;
//! Returns True, the order of continuity of a conic is infinite.
Standard_EXPORT Standard_Boolean IsCN (const Standard_Integer N) const;
DEFINE_STANDARD_RTTI(Geom2d_Conic,Geom2d_Curve)
protected:
gp_Ax22d pos;
private:
};
#endif // _Geom2d_Conic_HeaderFile

263
src/Geom2d/Geom2d_Curve.cdl
View File

@@ -1,263 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 Curve from Geom2d inherits Geometry from Geom2d
--- Purpose : The abstract class Curve describes the common
-- behavior of curves in 2D space. The Geom2d
-- package provides numerous concrete classes of
-- derived curves, including lines, circles, conics, Bezier
-- or BSpline curves, etc.
-- The main characteristic of these curves is that they
-- are parameterized. The Geom2d_Curve class shows:
-- - how to work with the parametric equation of a
-- curve in order to calculate the point of parameter
-- u, together with the vector tangent and the
-- derivative vectors of order 2, 3,..., N at this point;
-- - how to obtain general information about the curve
-- (for example, level of continuity, closed
-- characteristics, periodicity, bounds of the parameter field);
-- - how the parameter changes when a geometric
-- transformation is applied to the curve or when the
-- orientation of the curve is inverted.
-- All curves must have a geometric continuity: a curve is
-- at least "C0". Generally, this property is checked at
-- the time of construction or when the curve is edited.
-- Where this is not the case, the documentation
-- explicitly states so.
-- Warning
-- The Geom2d package does not prevent the
-- construction of curves with null length or curves which
-- self-intersect.
uses Pnt2d from gp,
Vec2d from gp,
Trsf2d from gp,
Shape from GeomAbs
raises RangeError from Standard,
NoSuchObject from Standard,
UndefinedDerivative from Geom2d,
UndefinedValue from Geom2d
is
Reverse (me : mutable)
--- Purpose :
-- Changes the direction of parametrization of <me>.
-- The "FirstParameter" and the "LastParameter" are not changed
-- but the orientation of the curve is modified. If the curve
-- is bounded the StartPoint of the initial curve becomes the
-- EndPoint of the reversed curve and the EndPoint of the initial
-- curve becomes the StartPoint of the reversed curve.
is deferred;
ReversedParameter(me; U : Real) returns Real
---Purpose: Computes the parameter on the reversed curve for
-- the point of parameter U on this curve.
-- Note: The point of parameter U on this curve is
-- identical to the point of parameter
-- ReversedParameter(U) on the reversed curve.
is deferred;
TransformedParameter(me; U : Real; T : Trsf2d from gp) returns Real
---Purpose: Computes the parameter on the curve transformed by
-- T for the point of parameter U on this curve.
-- Note: this function generally returns U but it can be
-- redefined (for example, on a line).
is virtual;
ParametricTransformation(me; T : Trsf2d from gp) returns Real
---Purpose: Returns the coefficient required to compute the
-- parametric transformation of this curve when
-- transformation T is applied. This coefficient is the
-- ratio between the parameter of a point on this curve
-- and the parameter of the transformed point on the
-- new curve transformed by T.
-- Note: this function generally returns 1. but it can be
-- redefined (for example, on a line).
is virtual;
Reversed (me) returns like me
--- Purpose : Creates a reversed duplicate Changes the orientation of this curve. The first and
-- last parameters are not changed, but the parametric
-- direction of the curve is reversed.
-- If the curve is bounded:
-- - the start point of the initial curve becomes the end
-- point of the reversed curve, and
-- - the end point of the initial curve becomes the start
-- point of the reversed curve.
-- - Reversed creates a new curve.
is static;
FirstParameter (me) returns Real
--- Purpose : Returns the value of the first parameter.
-- Warnings :
-- It can be RealFirst or RealLast from package Standard
-- if the curve is infinite
is deferred;
LastParameter (me) returns Real
--- Purpose : Value of the last parameter.
-- Warnings :
-- It can be RealFirst or RealLast from package Standard
-- if the curve is infinite
is deferred;
IsClosed (me) returns Boolean
--- Purpose : Returns true if the curve is closed.
-- Examples :
-- Some curves such as circle are always closed, others such as line
-- are never closed (by definition).
-- Some Curves such as OffsetCurve can be closed or not. These curves
-- are considered as closed if the distance between the first point
-- and the last point of the curve is lower or equal to the Resolution
-- from package gp wich is a fixed criterion independant of the
-- application.
is deferred;
IsPeriodic (me) returns Boolean
--- Purpose :
-- Returns true if the parameter of the curve is periodic.
-- It is possible only if the curve is closed and if the
-- following relation is satisfied :
-- for each parametric value U the distance between the point
-- P(u) and the point P (u + T) is lower or equal to Resolution
-- from package gp, T is the period and must be a constant.
-- There are three possibilities :
-- . the curve is never periodic by definition (SegmentLine)
-- . the curve is always periodic by definition (Circle)
-- . the curve can be defined as periodic (BSpline). In this case
-- a function SetPeriodic allows you to give the shape of the
-- curve. The general rule for this case is : if a curve can be
-- periodic or not the default periodicity set is non periodic
-- and you have to turn (explicitly) the curve into a periodic
-- curve if you want the curve to be periodic.
is deferred;
Period (me) returns Real from Standard
---Purpose: Returns thne period of this curve.
raises
NoSuchObject from Standard
---Purpose: raises if the curve is not periodic
is virtual;
Continuity (me) returns Shape from GeomAbs
--- Purpose :
-- It is the global continuity of the curve :
-- C0 : only geometric continuity,
-- C1 : continuity of the first derivative all along the Curve,
-- C2 : continuity of the second derivative all along the Curve,
-- C3 : continuity of the third derivative all along the Curve,
-- G1 : tangency continuity all along the Curve,
-- G2 : curvature continuity all along the Curve,
-- CN : the order of continuity is infinite.
is deferred;
IsCN (me; N : Integer) returns Boolean
--- Purpose : Returns true if the degree of continuity of this curve is at least N.
-- Exceptions Standard_RangeError if N is less than 0.
raises RangeError
is deferred;
D0(me; U : Real; P : out Pnt2d)
---Purpose: Returns in P the point of parameter U.
-- If the curve is periodic then the returned point is P(U) with
-- U = Ustart + (U - Uend) where Ustart and Uend are the
-- parametric bounds of the curve.
raises UndefinedValue
---Purpose :
-- Raised only for the "OffsetCurve" if it is not possible to
-- compute the current point. For example when the first
-- derivative on the basis curve and the offset direction
-- are parallel.
is deferred;
D1 (me; U : Real; P : out Pnt2d; V1 : out Vec2d)
--- Purpose :
-- Returns the point P of parameter U and the first derivative V1.
raises UndefinedDerivative
--- Purpose : Raised if the continuity of the curve is not C1.
is deferred;
D2 (me; U : Real; P : out Pnt2d; V1, V2 : out Vec2d)
--- Purpose :
-- Returns the point P of parameter U, the first and second
-- derivatives V1 and V2.
raises UndefinedDerivative
--- Purpose : Raised if the continuity of the curve is not C2.
is deferred;
D3 (me; U : Real; P : out Pnt2d; V1, V2, V3 : out Vec2d)
--- Purpose :
-- Returns the point P of parameter U, the first, the second
-- and the third derivative.
raises UndefinedDerivative
--- Purpose : Raised if the continuity of the curve is not C3.
is deferred;
DN (me; U : Real; N : Integer) returns Vec2d
--- Purpose : For the point of parameter U of this curve, computes
-- the vector corresponding to the Nth derivative.
-- Exceptions
-- StdFail_UndefinedDerivative if:
-- - the continuity of the curve is not "CN", or
-- - the derivative vector cannot be computed easily;
-- this is the case with specific types of curve (for
-- example, a rational BSpline curve where N is greater than 3).
-- Standard_RangeError if N is less than 1.
raises UndefinedDerivative,
RangeError
is deferred;
Value (me; U : Real) returns Pnt2d
--- Purpose : Computes the point of parameter U on <me>.
-- If the curve is periodic then the returned point is P(U) with
-- U = Ustart + (U - Uend) where Ustart and Uend are the
-- parametric bounds of the curve.
--
-- it is implemented with D0.
raises UndefinedValue
--- Purpose :
-- Raised only for the "OffsetCurve" if it is not possible to
-- compute the current point. For example when the first
-- derivative on the basis curve and the offset direction
-- are parallel.
is static;
end;

11
src/Geom2d/Geom2d_Curve.cxx
View File

@@ -14,9 +14,16 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_Curve.ixx>
#include <Geom2d_Curve.hxx>
#include <Geom2d_UndefinedDerivative.hxx>
#include <Geom2d_UndefinedValue.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Curve Curve;

250
src/Geom2d/Geom2d_Curve.hxx Normal file
View File

@@ -0,0 +1,250 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_Curve_HeaderFile
#define _Geom2d_Curve_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Geom2d_Geometry.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
class Standard_RangeError;
class Standard_NoSuchObject;
class Geom2d_UndefinedDerivative;
class Geom2d_UndefinedValue;
class gp_Trsf2d;
class gp_Pnt2d;
class gp_Vec2d;
class Geom2d_Curve;
DEFINE_STANDARD_HANDLE(Geom2d_Curve, Geom2d_Geometry)
//! The abstract class Curve describes the common
//! behavior of curves in 2D space. The Geom2d
//! package provides numerous concrete classes of
//! derived curves, including lines, circles, conics, Bezier
//! or BSpline curves, etc.
//! The main characteristic of these curves is that they
//! are parameterized. The Geom2d_Curve class shows:
//! - how to work with the parametric equation of a
//! curve in order to calculate the point of parameter
//! u, together with the vector tangent and the
//! derivative vectors of order 2, 3,..., N at this point;
//! - how to obtain general information about the curve
//! (for example, level of continuity, closed
//! characteristics, periodicity, bounds of the parameter field);
//! - how the parameter changes when a geometric
//! transformation is applied to the curve or when the
//! orientation of the curve is inverted.
//! All curves must have a geometric continuity: a curve is
//! at least "C0". Generally, this property is checked at
//! the time of construction or when the curve is edited.
//! Where this is not the case, the documentation
//! explicitly states so.
//! Warning
//! The Geom2d package does not prevent the
//! construction of curves with null length or curves which
//! self-intersect.
class Geom2d_Curve : public Geom2d_Geometry
{
public:
//! Changes the direction of parametrization of <me>.
//! The "FirstParameter" and the "LastParameter" are not changed
//! but the orientation of the curve is modified. If the curve
//! is bounded the StartPoint of the initial curve becomes the
//! EndPoint of the reversed curve and the EndPoint of the initial
//! curve becomes the StartPoint of the reversed curve.
Standard_EXPORT virtual void Reverse() = 0;
//! Computes the parameter on the reversed curve for
//! the point of parameter U on this curve.
//! Note: The point of parameter U on this curve is
//! identical to the point of parameter
//! ReversedParameter(U) on the reversed curve.
Standard_EXPORT virtual Standard_Real ReversedParameter (const Standard_Real U) const = 0;
//! Computes the parameter on the curve transformed by
//! T for the point of parameter U on this curve.
//! Note: this function generally returns U but it can be
//! redefined (for example, on a line).
Standard_EXPORT virtual Standard_Real TransformedParameter (const Standard_Real U, const gp_Trsf2d& T) const;
//! Returns the coefficient required to compute the
//! parametric transformation of this curve when
//! transformation T is applied. This coefficient is the
//! ratio between the parameter of a point on this curve
//! and the parameter of the transformed point on the
//! new curve transformed by T.
//! Note: this function generally returns 1. but it can be
//! redefined (for example, on a line).
Standard_EXPORT virtual Standard_Real ParametricTransformation (const gp_Trsf2d& T) const;
//! Creates a reversed duplicate Changes the orientation of this curve. The first and
//! last parameters are not changed, but the parametric
//! direction of the curve is reversed.
//! If the curve is bounded:
//! - the start point of the initial curve becomes the end
//! point of the reversed curve, and
//! - the end point of the initial curve becomes the start
//! point of the reversed curve.
//! - Reversed creates a new curve.
Standard_EXPORT Handle(Geom2d_Curve) Reversed() const;
//! Returns the value of the first parameter.
//! Warnings :
//! It can be RealFirst or RealLast from package Standard
//! if the curve is infinite
Standard_EXPORT virtual Standard_Real FirstParameter() const = 0;
//! Value of the last parameter.
//! Warnings :
//! It can be RealFirst or RealLast from package Standard
//! if the curve is infinite
Standard_EXPORT virtual Standard_Real LastParameter() const = 0;
//! Returns true if the curve is closed.
//! Examples :
//! Some curves such as circle are always closed, others such as line
//! are never closed (by definition).
//! Some Curves such as OffsetCurve can be closed or not. These curves
//! are considered as closed if the distance between the first point
//! and the last point of the curve is lower or equal to the Resolution
//! from package gp wich is a fixed criterion independant of the
//! application.
Standard_EXPORT virtual Standard_Boolean IsClosed() const = 0;
//! Returns true if the parameter of the curve is periodic.
//! It is possible only if the curve is closed and if the
//! following relation is satisfied :
//! for each parametric value U the distance between the point
//! P(u) and the point P (u + T) is lower or equal to Resolution
//! from package gp, T is the period and must be a constant.
//! There are three possibilities :
//! . the curve is never periodic by definition (SegmentLine)
//! . the curve is always periodic by definition (Circle)
//! . the curve can be defined as periodic (BSpline). In this case
//! a function SetPeriodic allows you to give the shape of the
//! curve. The general rule for this case is : if a curve can be
//! periodic or not the default periodicity set is non periodic
//! and you have to turn (explicitly) the curve into a periodic
//! curve if you want the curve to be periodic.
Standard_EXPORT virtual Standard_Boolean IsPeriodic() const = 0;
//! Returns thne period of this curve.
//! raises if the curve is not periodic
Standard_EXPORT virtual Standard_Real Period() const;
//! It is the global continuity of the curve :
//! C0 : only geometric continuity,
//! C1 : continuity of the first derivative all along the Curve,
//! C2 : continuity of the second derivative all along the Curve,
//! C3 : continuity of the third derivative all along the Curve,
//! G1 : tangency continuity all along the Curve,
//! G2 : curvature continuity all along the Curve,
//! CN : the order of continuity is infinite.
Standard_EXPORT virtual GeomAbs_Shape Continuity() const = 0;
//! Returns true if the degree of continuity of this curve is at least N.
//! Exceptions Standard_RangeError if N is less than 0.
Standard_EXPORT virtual Standard_Boolean IsCN (const Standard_Integer N) const = 0;
//! Returns in P the point of parameter U.
//! If the curve is periodic then the returned point is P(U) with
//! U = Ustart + (U - Uend) where Ustart and Uend are the
//! parametric bounds of the curve.
//!
//! Raised only for the "OffsetCurve" if it is not possible to
//! compute the current point. For example when the first
//! derivative on the basis curve and the offset direction
//! are parallel.
Standard_EXPORT virtual void D0 (const Standard_Real U, gp_Pnt2d& P) const = 0;
//! Returns the point P of parameter U and the first derivative V1.
//! Raised if the continuity of the curve is not C1.
Standard_EXPORT virtual void D1 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1) const = 0;
//! Returns the point P of parameter U, the first and second
//! derivatives V1 and V2.
//! Raised if the continuity of the curve is not C2.
Standard_EXPORT virtual void D2 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const = 0;
//! Returns the point P of parameter U, the first, the second
//! and the third derivative.
//! Raised if the continuity of the curve is not C3.
Standard_EXPORT virtual void D3 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const = 0;
//! For the point of parameter U of this curve, computes
//! the vector corresponding to the Nth derivative.
//! Exceptions
//! StdFail_UndefinedDerivative if:
//! - the continuity of the curve is not "CN", or
//! - the derivative vector cannot be computed easily;
//! this is the case with specific types of curve (for
//! example, a rational BSpline curve where N is greater than 3).
//! Standard_RangeError if N is less than 1.
Standard_EXPORT virtual gp_Vec2d DN (const Standard_Real U, const Standard_Integer N) const = 0;
//! Computes the point of parameter U on <me>.
//! If the curve is periodic then the returned point is P(U) with
//! U = Ustart + (U - Uend) where Ustart and Uend are the
//! parametric bounds of the curve.
//!
//! it is implemented with D0.
//!
//! Raised only for the "OffsetCurve" if it is not possible to
//! compute the current point. For example when the first
//! derivative on the basis curve and the offset direction
//! are parallel.
Standard_EXPORT gp_Pnt2d Value (const Standard_Real U) const;
DEFINE_STANDARD_RTTI(Geom2d_Curve,Geom2d_Geometry)
protected:
private:
};
#endif // _Geom2d_Curve_HeaderFile

103
src/Geom2d/Geom2d_Direction.cdl
View File

@@ -1,103 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 Direction from Geom2d inherits Vector from Geom2d
--- Purpose :
-- The class Direction specifies a vector that is never null.
-- It is a unit vector.
uses Dir2d from gp,
Pnt2d from gp,
Trsf2d from gp,
Vec2d from gp,
Geometry from Geom2d
raises ConstructionError from Standard
is
Create (X, Y :Real) returns Direction
--- Purpose : Creates a unit vector with it 2 cartesian coordinates.
raises ConstructionError;
--- Purpose :
-- Raised if Sqrt( X*X + Y*Y) <= Resolution from gp.
Create (V : Dir2d) returns Direction;
--- Purpose : Creates a persistent copy of <me>.
SetCoord (me : mutable; X, Y : Real)
--- Purpose : Assigns the coordinates X and Y to this unit vector,
-- then normalizes it.
-- Exceptions
-- Standard_ConstructionError if Sqrt(X*X +
-- Y*Y) is less than or equal to gp::Resolution().
raises ConstructionError;
SetDir2d (me : mutable; V : Dir2d);
--- Purpose : Converts the gp_Dir2d unit vector V into this unit vector.
SetX (me : mutable; X : Real)
--- Purpose :
-- Assigns a value to the X coordinate of this unit vector, then normalizes it.
-- Exceptions
-- Standard_ConstructionError if the value assigned
-- causes the magnitude of the vector to become less
-- than or equal to gp::Resolution().
raises ConstructionError;
SetY (me : mutable; Y : Real)
--- Purpose : Assigns a value to the Y coordinate of this unit vector, then normalizes it.
-- Exceptions
-- Standard_ConstructionError if the value assigned
-- causes the magnitude of the vector to become less
-- than or equal to gp::Resolution().
raises ConstructionError;
Dir2d (me) returns Dir2d;
--- Purpose : Converts this unit vector into a gp_Dir2d unit vector.
Magnitude (me) returns Real;
--- Purpose : returns 1.0
SquareMagnitude (me) returns Real;
--- Purpose : returns 1.0
Crossed (me; Other : Vector) returns Real;
--- Purpose : Computes the cross product between <me> and <Other>.
---C++: alias operator ^
Transform (me : mutable; T : Trsf2d);
---Purpose: Applies the transformation T to this unit vector, then normalizes it.
Copy (me) returns like me;
---Purpose: Creates a new object which is a copy of this unit vector.
end;

8
src/Geom2d/Geom2d_Direction.cxx
View File

@@ -14,9 +14,15 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_Direction.ixx>
#include <Geom2d_Direction.hxx>
#include <Geom2d_Geometry.hxx>
#include <Geom2d_Vector.hxx>
#include <gp.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Trsf2d.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Direction Direction;
typedef gp_Ax2d Ax2d;

122
src/Geom2d/Geom2d_Direction.hxx Normal file
View File

@@ -0,0 +1,122 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_Direction_HeaderFile
#define _Geom2d_Direction_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Geom2d_Vector.hxx>
#include <Standard_Real.hxx>
class Standard_ConstructionError;
class gp_Dir2d;
class Geom2d_Vector;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_Direction;
DEFINE_STANDARD_HANDLE(Geom2d_Direction, Geom2d_Vector)
//! The class Direction specifies a vector that is never null.
//! It is a unit vector.
class Geom2d_Direction : public Geom2d_Vector
{
public:
//! Creates a unit vector with it 2 cartesian coordinates.
//!
//! Raised if Sqrt( X*X + Y*Y) <= Resolution from gp.
Standard_EXPORT Geom2d_Direction(const Standard_Real X, const Standard_Real Y);
//! Creates a persistent copy of <me>.
Standard_EXPORT Geom2d_Direction(const gp_Dir2d& V);
//! Assigns the coordinates X and Y to this unit vector,
//! then normalizes it.
//! Exceptions
//! Standard_ConstructionError if Sqrt(X*X +
//! Y*Y) is less than or equal to gp::Resolution().
Standard_EXPORT void SetCoord (const Standard_Real X, const Standard_Real Y);
//! Converts the gp_Dir2d unit vector V into this unit vector.
Standard_EXPORT void SetDir2d (const gp_Dir2d& V);
//! Assigns a value to the X coordinate of this unit vector, then normalizes it.
//! Exceptions
//! Standard_ConstructionError if the value assigned
//! causes the magnitude of the vector to become less
//! than or equal to gp::Resolution().
Standard_EXPORT void SetX (const Standard_Real X);
//! Assigns a value to the Y coordinate of this unit vector, then normalizes it.
//! Exceptions
//! Standard_ConstructionError if the value assigned
//! causes the magnitude of the vector to become less
//! than or equal to gp::Resolution().
Standard_EXPORT void SetY (const Standard_Real Y);
//! Converts this unit vector into a gp_Dir2d unit vector.
Standard_EXPORT gp_Dir2d Dir2d() const;
//! returns 1.0
Standard_EXPORT Standard_Real Magnitude() const;
//! returns 1.0
Standard_EXPORT Standard_Real SquareMagnitude() const;
//! Computes the cross product between <me> and <Other>.
Standard_EXPORT Standard_Real Crossed (const Handle(Geom2d_Vector)& Other) const;
Standard_Real operator ^ (const Handle(Geom2d_Vector)& Other) const
{
return Crossed(Other);
}
//! Applies the transformation T to this unit vector, then normalizes it.
Standard_EXPORT void Transform (const gp_Trsf2d& T);
//! Creates a new object which is a copy of this unit vector.
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const;
DEFINE_STANDARD_RTTI(Geom2d_Direction,Geom2d_Vector)
protected:
private:
};
#endif // _Geom2d_Direction_HeaderFile

282
src/Geom2d/Geom2d_Ellipse.cdl
View File

@@ -1,282 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 Ellipse from Geom2d inherits Conic from Geom2d
--- Purpose : Describes an ellipse in the plane (2D space).
-- An ellipse is defined by its major and minor radii and,
-- as with any conic curve, is positioned in the plane
-- with a coordinate system (gp_Ax22d object) where:
-- - the origin is the center of the ellipse,
-- - the "X Direction" defines the major axis, and
-- - the "Y Direction" defines the minor axis.
-- This coordinate system is the local coordinate system of the ellipse.
-- The orientation (direct or indirect) of the local
-- coordinate system gives an explicit orientation to the
-- ellipse, determining the direction in which the
-- parameter increases along the ellipse.
-- The Geom2d_Ellipse ellipse is parameterized by an angle:
-- P(U) = O + MajorRad*Cos(U)*XDir + MinorRad*Sin(U)*YDir
-- where:
-- - P is the point of parameter U,
-- - O, XDir and YDir are respectively the origin, "X
-- Direction" and "Y Direction" of its local coordinate system,
-- - MajorRad and MinorRad are the major and
-- minor radii of the ellipse.
-- The "X Axis" of the local coordinate system therefore
-- defines the origin of the parameter of the ellipse.
-- An ellipse is a closed and periodic curve. The period
-- is 2.*Pi and the parameter range is [ 0,2.*Pi [.
-- See Also
-- GCE2d_MakeEllipse which provides functions for
-- more complex ellipse constructions
-- gp_Ax22d
-- gp_Elips2d for an equivalent, non-parameterized data structure
uses Ax2d from gp,
Ax22d from gp,
Elips2d from gp,
Pnt2d from gp,
Trsf2d from gp,
Vec2d from gp,
Geometry from Geom2d
raises ConstructionError from Standard,
RangeError from Standard
is
Create (E : Elips2d) returns Ellipse;
--- Purpose :
-- Creates an ellipse by conversion of the gp_Elips2d ellipse E.
Create (MajorAxis : Ax2d; MajorRadius, MinorRadius : Real;
Sense: Boolean from Standard = Standard_True)
returns Ellipse
--- Purpose : Creates an ellipse defined by its major and minor radii,
-- MajorRadius and MinorRadius, and positioned
-- in the plane by its major axis MajorAxis; the
-- center of the ellipse is the origin of MajorAxis
-- and the unit vector of MajorAxis is the "X
-- Direction" of the local coordinate system of the
-- ellipse; this coordinate system is direct if Sense
-- is true (default value) or indirect if Sense is false.
-- Warnings :
-- It is not forbidden to create an ellipse with MajorRadius =
-- MinorRadius.
-- Exceptions
-- Standard_ConstructionError if:
-- - MajorRadius is less than MinorRadius, or
-- - MinorRadius is less than 0.
raises ConstructionError;
Create (Axis : Ax22d; MajorRadius, MinorRadius : Real)
returns Ellipse
--- Purpose : Creates an ellipse defined by its major and minor radii,
-- MajorRadius and MinorRadius, where the
-- coordinate system Axis locates the ellipse and
-- defines its orientation in the plane such that:
-- - the center of the ellipse is the origin of Axis,
-- - the "X Direction" of Axis defines the major
-- axis of the ellipse,
-- - the "Y Direction" of Axis defines the minor
-- axis of the ellipse,
-- - the orientation of Axis (direct or indirect)
-- gives the orientation of the ellipse.
-- Warnings :
-- It is not forbidden to create an ellipse with MajorRadius =
-- MinorRadius.
-- Exceptions
-- Standard_ConstructionError if:
-- - MajorRadius is less than MinorRadius, or
-- - MinorRadius is less than 0.
raises ConstructionError;
SetElips2d (me : mutable; E : Elips2d);
--- Purpose: Converts the gp_Elips2d ellipse E into this ellipse.
SetMajorRadius (me : mutable; MajorRadius : Real)
raises ConstructionError;
--- Purpose : Assigns a value to the major radius of this ellipse.
-- Exceptions
-- Standard_ConstructionError if:
-- - the major radius of this ellipse becomes less than
-- the minor radius, or
-- - MinorRadius is less than 0.
SetMinorRadius (me : mutable; MinorRadius : Real)
raises ConstructionError;
--- Purpose : Assigns a value to the minor radius of this ellipse.
-- Exceptions
-- Standard_ConstructionError if:
-- - the major radius of this ellipse becomes less than
-- the minor radius, or
-- - MinorRadius is less than 0.
Elips2d (me) returns Elips2d;
--- Purpose : Converts this ellipse into a gp_Elips2d ellipse.
ReversedParameter(me; U : Real) returns Real is redefined static;
---Purpose: Computes the parameter on the reversed ellipse for
-- the point of parameter U on this ellipse.
-- For an ellipse, the returned value is: 2.*Pi - U.
Directrix1 (me) returns Ax2d
--- Purpose : Computes the directrices of this ellipse.
-- This directrix is the line normal to the XAxis of the ellipse
-- in the local plane (Z = 0) at a distance d = MajorRadius / e
-- from the center of the ellipse, where e is the eccentricity of
-- the ellipse.
-- This line is parallel to the "YAxis". The intersection point
-- between directrix1 and the "XAxis" is the "Location" point
-- of the directrix1. This point is on the positive side of
-- the "XAxis".
-- Raises ConstructionError if Eccentricity = 0.0. (The ellipse degenerates
-- into a circle)
raises ConstructionError;
Directrix2 (me) returns Ax2d
--- Purpose :
-- This line is obtained by the symmetrical transformation
-- of "Directrix1" with respect to the "YAxis" of the ellipse.
-- Raises ConstructionError if Eccentricity = 0.0. (The ellipse degenerates into a
-- circle).
raises ConstructionError;
Eccentricity (me) returns Real is redefined static;
--- Purpose :
-- Returns the eccentricity of the ellipse between 0.0 and 1.0
-- If f is the distance between the center of the ellipse and
-- the Focus1 then the eccentricity e = f / MajorRadius.
-- Returns 0 if MajorRadius = 0
Focal (me) returns Real;
--- Purpose :
-- Computes the focal distance. The focal distance is the distance between the center
-- and a focus of the ellipse.
Focus1 (me) returns Pnt2d;
--- Purpose :
-- Returns the first focus of the ellipse. This focus is on the
-- positive side of the "XAxis" of the ellipse.
Focus2 (me) returns Pnt2d;
--- Purpose :
-- Returns the second focus of the ellipse. This focus is on
-- the negative side of the "XAxis" of the ellipse.
MajorRadius (me) returns Real;
---Purpose: Returns the major radius of this ellipse.
MinorRadius (me) returns Real;
---Purpose: Returns the minor radius of this ellipse.
Parameter (me) returns Real;
--- Purpose :
-- Computes the parameter of this ellipse. This value is
-- given by the formula p = (1 - e * e) * MajorRadius where e is the eccentricity
-- of the ellipse.
-- Returns 0 if MajorRadius = 0
FirstParameter (me) returns Real is redefined static;
--- Purpose : Returns the value of the first parameter of this
-- ellipse. This is 0.0, which gives the start point of this ellipse.
-- The start point and end point of an ellipse are coincident.
LastParameter (me) returns Real is redefined static;
--- Purpose : Returns the value of the last parameter of this
-- ellipse. This is 2.*Pi, which gives the end point of this ellipse.
-- The start point and end point of an ellipse are coincident.
IsClosed (me) returns Boolean is redefined static;
--- Purpose : return True.
IsPeriodic (me) returns Boolean is redefined static;
--- Purpose : return True.
D0(me; U : Real; P : out Pnt2d) is redefined static;
---Purpose: Returns in P the point of parameter U.
-- P = C + MajorRadius * Cos (U) * XDir + MinorRadius * Sin (U) * YDir
-- where C is the center of the ellipse , XDir the direction of
-- the "XAxis" and "YDir" the "YAxis" of the ellipse.
D1 (me; U : Real; P : out Pnt2d; V1 : out Vec2d) is redefined static;
-- Purpose :
-- Returns the point P of parameter U and the first derivative
-- at this point.
D2 (me; U : Real; P : out Pnt2d; V1, V2 : out Vec2d) is redefined static;
--- Purpose :
-- Returns the point P of parameter U. The vectors V1 and V2
-- are the first and second derivatives at this point.
D3 (me; U : Real; P : out Pnt2d; V1, V2, V3 : out Vec2d) is redefined static;
--- Purpose :
-- Returns the point P of parameter U, the first second and
-- third derivatives V1 V2 and V3.
DN (me; U : Real; N : Integer) returns Vec2d
--- Purpose : For the point of parameter U of this ellipse,
-- computes the vector corresponding to the Nth derivative.
-- Exceptions Standard_RangeError if N is less than 1.
raises RangeError
is redefined static;
Transform (me : mutable; T : Trsf2d) is redefined static;
---Purpose: Applies the transformation T to this ellipse.
Copy (me) returns like me
is redefined static;
---Purpose: Creates a new object which is a copy of this ellipse.
fields
majorRadius : Real;
minorRadius : Real;
end;

19
src/Geom2d/Geom2d_Ellipse.cxx
View File

@@ -14,13 +14,22 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_Ellipse.ixx>
#include <gp.hxx>
#include <gp_Dir2d.hxx>
#include <gp_XYZ.hxx>
#include <ElCLib.hxx>
#include <Standard_RangeError.hxx>
#include <Geom2d_Ellipse.hxx>
#include <Geom2d_Geometry.hxx>
#include <gp.hxx>
#include <gp_Ax2d.hxx>
#include <gp_Ax22d.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Elips2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <gp_XYZ.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Ellipse Ellipse;
typedef gp_Ax2d Ax2d;

269
src/Geom2d/Geom2d_Ellipse.hxx Normal file
View File

@@ -0,0 +1,269 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_Ellipse_HeaderFile
#define _Geom2d_Ellipse_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
#include <Geom2d_Conic.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Standard_ConstructionError;
class Standard_RangeError;
class gp_Elips2d;
class gp_Ax2d;
class gp_Ax22d;
class gp_Pnt2d;
class gp_Vec2d;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_Ellipse;
DEFINE_STANDARD_HANDLE(Geom2d_Ellipse, Geom2d_Conic)
//! Describes an ellipse in the plane (2D space).
//! An ellipse is defined by its major and minor radii and,
//! as with any conic curve, is positioned in the plane
//! with a coordinate system (gp_Ax22d object) where:
//! - the origin is the center of the ellipse,
//! - the "X Direction" defines the major axis, and
//! - the "Y Direction" defines the minor axis.
//! This coordinate system is the local coordinate system of the ellipse.
//! The orientation (direct or indirect) of the local
//! coordinate system gives an explicit orientation to the
//! ellipse, determining the direction in which the
//! parameter increases along the ellipse.
//! The Geom2d_Ellipse ellipse is parameterized by an angle:
//! P(U) = O + MajorRad*Cos(U)*XDir + MinorRad*Sin(U)*YDir
//! where:
//! - P is the point of parameter U,
//! - O, XDir and YDir are respectively the origin, "X
//! Direction" and "Y Direction" of its local coordinate system,
//! - MajorRad and MinorRad are the major and
//! minor radii of the ellipse.
//! The "X Axis" of the local coordinate system therefore
//! defines the origin of the parameter of the ellipse.
//! An ellipse is a closed and periodic curve. The period
//! is 2.*Pi and the parameter range is [ 0,2.*Pi [.
//! See Also
//! GCE2d_MakeEllipse which provides functions for
//! more complex ellipse constructions
//! gp_Ax22d
//! gp_Elips2d for an equivalent, non-parameterized data structure
class Geom2d_Ellipse : public Geom2d_Conic
{
public:
//! Creates an ellipse by conversion of the gp_Elips2d ellipse E.
Standard_EXPORT Geom2d_Ellipse(const gp_Elips2d& E);
//! Creates an ellipse defined by its major and minor radii,
//! MajorRadius and MinorRadius, and positioned
//! in the plane by its major axis MajorAxis; the
//! center of the ellipse is the origin of MajorAxis
//! and the unit vector of MajorAxis is the "X
//! Direction" of the local coordinate system of the
//! ellipse; this coordinate system is direct if Sense
//! is true (default value) or indirect if Sense is false.
//! Warnings :
//! It is not forbidden to create an ellipse with MajorRadius =
//! MinorRadius.
//! Exceptions
//! Standard_ConstructionError if:
//! - MajorRadius is less than MinorRadius, or
//! - MinorRadius is less than 0.
Standard_EXPORT Geom2d_Ellipse(const gp_Ax2d& MajorAxis, const Standard_Real MajorRadius, const Standard_Real MinorRadius, const Standard_Boolean Sense = Standard_True);
//! Creates an ellipse defined by its major and minor radii,
//! MajorRadius and MinorRadius, where the
//! coordinate system Axis locates the ellipse and
//! defines its orientation in the plane such that:
//! - the center of the ellipse is the origin of Axis,
//! - the "X Direction" of Axis defines the major
//! axis of the ellipse,
//! - the "Y Direction" of Axis defines the minor
//! axis of the ellipse,
//! - the orientation of Axis (direct or indirect)
//! gives the orientation of the ellipse.
//! Warnings :
//! It is not forbidden to create an ellipse with MajorRadius =
//! MinorRadius.
//! Exceptions
//! Standard_ConstructionError if:
//! - MajorRadius is less than MinorRadius, or
//! - MinorRadius is less than 0.
Standard_EXPORT Geom2d_Ellipse(const gp_Ax22d& Axis, const Standard_Real MajorRadius, const Standard_Real MinorRadius);
//! Converts the gp_Elips2d ellipse E into this ellipse.
Standard_EXPORT void SetElips2d (const gp_Elips2d& E);
//! Assigns a value to the major radius of this ellipse.
//! Exceptions
//! Standard_ConstructionError if:
//! - the major radius of this ellipse becomes less than
//! the minor radius, or
//! - MinorRadius is less than 0.
Standard_EXPORT void SetMajorRadius (const Standard_Real MajorRadius);
//! Assigns a value to the minor radius of this ellipse.
//! Exceptions
//! Standard_ConstructionError if:
//! - the major radius of this ellipse becomes less than
//! the minor radius, or
//! - MinorRadius is less than 0.
Standard_EXPORT void SetMinorRadius (const Standard_Real MinorRadius);
//! Converts this ellipse into a gp_Elips2d ellipse.
Standard_EXPORT gp_Elips2d Elips2d() const;
//! Computes the parameter on the reversed ellipse for
//! the point of parameter U on this ellipse.
//! For an ellipse, the returned value is: 2.*Pi - U.
Standard_EXPORT Standard_Real ReversedParameter (const Standard_Real U) const Standard_OVERRIDE;
//! Computes the directrices of this ellipse.
//! This directrix is the line normal to the XAxis of the ellipse
//! in the local plane (Z = 0) at a distance d = MajorRadius / e
//! from the center of the ellipse, where e is the eccentricity of
//! the ellipse.
//! This line is parallel to the "YAxis". The intersection point
//! between directrix1 and the "XAxis" is the "Location" point
//! of the directrix1. This point is on the positive side of
//! the "XAxis".
//! Raises ConstructionError if Eccentricity = 0.0. (The ellipse degenerates
//! into a circle)
Standard_EXPORT gp_Ax2d Directrix1() const;
//! This line is obtained by the symmetrical transformation
//! of "Directrix1" with respect to the "YAxis" of the ellipse.
//! Raises ConstructionError if Eccentricity = 0.0. (The ellipse degenerates into a
//! circle).
Standard_EXPORT gp_Ax2d Directrix2() const;
//! Returns the eccentricity of the ellipse between 0.0 and 1.0
//! If f is the distance between the center of the ellipse and
//! the Focus1 then the eccentricity e = f / MajorRadius.
//! Returns 0 if MajorRadius = 0
Standard_EXPORT Standard_Real Eccentricity() const Standard_OVERRIDE;
//! Computes the focal distance. The focal distance is the distance between the center
//! and a focus of the ellipse.
Standard_EXPORT Standard_Real Focal() const;
//! Returns the first focus of the ellipse. This focus is on the
//! positive side of the "XAxis" of the ellipse.
Standard_EXPORT gp_Pnt2d Focus1() const;
//! Returns the second focus of the ellipse. This focus is on
//! the negative side of the "XAxis" of the ellipse.
Standard_EXPORT gp_Pnt2d Focus2() const;
//! Returns the major radius of this ellipse.
Standard_EXPORT Standard_Real MajorRadius() const;
//! Returns the minor radius of this ellipse.
Standard_EXPORT Standard_Real MinorRadius() const;
//! Computes the parameter of this ellipse. This value is
//! given by the formula p = (1 - e * e) * MajorRadius where e is the eccentricity
//! of the ellipse.
//! Returns 0 if MajorRadius = 0
Standard_EXPORT Standard_Real Parameter() const;
//! Returns the value of the first parameter of this
//! ellipse. This is 0.0, which gives the start point of this ellipse.
//! The start point and end point of an ellipse are coincident.
Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE;
//! Returns the value of the last parameter of this
//! ellipse. This is 2.*Pi, which gives the end point of this ellipse.
//! The start point and end point of an ellipse are coincident.
Standard_EXPORT Standard_Real LastParameter() const Standard_OVERRIDE;
//! return True.
Standard_EXPORT Standard_Boolean IsClosed() const Standard_OVERRIDE;
//! return True.
Standard_EXPORT Standard_Boolean IsPeriodic() const Standard_OVERRIDE;
//! Returns in P the point of parameter U.
//! P = C + MajorRadius * Cos (U) * XDir + MinorRadius * Sin (U) * YDir
//! where C is the center of the ellipse , XDir the direction of
//! the "XAxis" and "YDir" the "YAxis" of the ellipse.
Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt2d& P) const Standard_OVERRIDE;
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1) const Standard_OVERRIDE;
//! Returns the point P of parameter U. The vectors V1 and V2
//! are the first and second derivatives at this point.
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const Standard_OVERRIDE;
//! Returns the point P of parameter U, the first second and
//! third derivatives V1 V2 and V3.
Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const Standard_OVERRIDE;
//! For the point of parameter U of this ellipse,
//! computes the vector corresponding to the Nth derivative.
//! Exceptions Standard_RangeError if N is less than 1.
Standard_EXPORT gp_Vec2d DN (const Standard_Real U, const Standard_Integer N) const Standard_OVERRIDE;
//! Applies the transformation T to this ellipse.
Standard_EXPORT void Transform (const gp_Trsf2d& T) Standard_OVERRIDE;
//! Creates a new object which is a copy of this ellipse.
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const Standard_OVERRIDE;
DEFINE_STANDARD_RTTI(Geom2d_Ellipse,Geom2d_Conic)
protected:
private:
Standard_Real majorRadius;
Standard_Real minorRadius;
};
#endif // _Geom2d_Ellipse_HeaderFile

129
src/Geom2d/Geom2d_Geometry.cdl
View File

@@ -1,129 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 Geometry from Geom2d inherits TShared from MMgt
--- Purpose :
-- The general abstract class Geometry in 2D space describes
-- the common behaviour of all the geometric entities.
--
-- All the objects derived from this class can be move with a
-- geometric transformation. Only the transformations which
-- doesn't modify the nature of the geometry are available in
-- this package.
-- The method Transform which defines a general transformation
-- is deferred. The other specifics transformations used the
-- method Transform.
-- All the following transformations modify the object itself.
-- Warning
-- Only transformations which do not modify the nature
-- of the geometry can be applied to Geom2d objects:
-- this is the case with translations, rotations,
-- symmetries and scales; this is also the case with
-- gp_Trsf2d composite transformations which are
-- used to define the geometric transformations applied
-- using the Transform or Transformed functions.
-- Note: Geometry defines the "prototype" of the
-- abstract method Transform which is defined for each
-- concrete type of derived object. All other
-- transformations are implemented using the Transform method.
uses Ax2d from gp,
Pnt2d from gp,
Trsf2d from gp,
Vec2d from gp
raises ConstructionError from Standard
is
Mirror (me : mutable; P : Pnt2d)
--- Purpose : Performs the symmetrical transformation of a Geometry
-- with respect to the point P which is the center of the
-- symmetry and assigns the result to this geometric object.
is static;
Mirror (me : mutable; A : Ax2d)
--- Purpose : Performs the symmetrical transformation of a Geometry
-- with respect to an axis placement which is the axis of the symmetry.
is static;
Rotate (me : mutable; P : Pnt2d; Ang : Real)
--- Purpose : Rotates a Geometry. P is the center of the rotation.
-- Ang is the angular value of the rotation in radians.
is static;
Scale (me : mutable; P : Pnt2d; S : Real)
--- Purpose : Scales a Geometry. S is the scaling value.
is static;
Translate (me : mutable; V : Vec2d)
--- Purpose : Translates a Geometry. V is the vector of the tanslation.
is static;
Translate (me : mutable; P1, P2 : Pnt2d)
--- Purpose : Translates a Geometry from the point P1 to the point P2.
is static;
Transform (me : mutable; T : Trsf2d)
--- Purpose : Transformation of a geometric object. This tansformation
-- can be a translation, a rotation, a symmetry, a scaling
-- or a complex transformation obtained by combination of
-- the previous elementaries transformations.
-- (see class Transformation of the package Geom2d).
is deferred;
--- Purpose : The following transformations have the same properties
-- as the previous ones but they don't modified the object
-- itself. A copy of the object is returned.
Mirrored (me; P : Pnt2d) returns like me
is static;
Mirrored (me; A : Ax2d) returns like me
is static;
Rotated (me; P : Pnt2d; Ang : Real) returns like me
is static;
Scaled (me; P : Pnt2d; S : Real) returns like me
is static;
Transformed (me; T : Trsf2d) returns like me
is static;
Translated (me; V : Vec2d) returns like me
is static;
Translated (me; P1, P2 : Pnt2d) returns like me
is static;
Copy (me) returns like me is deferred;
end;

8
src/Geom2d/Geom2d_Geometry.cxx
View File

@@ -14,8 +14,14 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_Geometry.ixx>
#include <Geom2d_Geometry.hxx>
#include <gp_Ax2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Geometry Geometry;
typedef gp_Ax2d Ax2d;

136
src/Geom2d/Geom2d_Geometry.hxx Normal file
View File

@@ -0,0 +1,136 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_Geometry_HeaderFile
#define _Geom2d_Geometry_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <MMgt_TShared.hxx>
#include <Standard_Real.hxx>
class Standard_ConstructionError;
class gp_Pnt2d;
class gp_Ax2d;
class gp_Vec2d;
class gp_Trsf2d;
class Geom2d_Geometry;
DEFINE_STANDARD_HANDLE(Geom2d_Geometry, MMgt_TShared)
//! The general abstract class Geometry in 2D space describes
//! the common behaviour of all the geometric entities.
//!
//! All the objects derived from this class can be move with a
//! geometric transformation. Only the transformations which
//! doesn't modify the nature of the geometry are available in
//! this package.
//! The method Transform which defines a general transformation
//! is deferred. The other specifics transformations used the
//! method Transform.
//! All the following transformations modify the object itself.
//! Warning
//! Only transformations which do not modify the nature
//! of the geometry can be applied to Geom2d objects:
//! this is the case with translations, rotations,
//! symmetries and scales; this is also the case with
//! gp_Trsf2d composite transformations which are
//! used to define the geometric transformations applied
//! using the Transform or Transformed functions.
//! Note: Geometry defines the "prototype" of the
//! abstract method Transform which is defined for each
//! concrete type of derived object. All other
//! transformations are implemented using the Transform method.
class Geom2d_Geometry : public MMgt_TShared
{
public:
//! Performs the symmetrical transformation of a Geometry
//! with respect to the point P which is the center of the
//! symmetry and assigns the result to this geometric object.
Standard_EXPORT void Mirror (const gp_Pnt2d& P);
//! Performs the symmetrical transformation of a Geometry
//! with respect to an axis placement which is the axis of the symmetry.
Standard_EXPORT void Mirror (const gp_Ax2d& A);
//! Rotates a Geometry. P is the center of the rotation.
//! Ang is the angular value of the rotation in radians.
Standard_EXPORT void Rotate (const gp_Pnt2d& P, const Standard_Real Ang);
//! Scales a Geometry. S is the scaling value.
Standard_EXPORT void Scale (const gp_Pnt2d& P, const Standard_Real S);
//! Translates a Geometry. V is the vector of the tanslation.
Standard_EXPORT void Translate (const gp_Vec2d& V);
//! Translates a Geometry from the point P1 to the point P2.
Standard_EXPORT void Translate (const gp_Pnt2d& P1, const gp_Pnt2d& P2);
//! Transformation of a geometric object. This tansformation
//! can be a translation, a rotation, a symmetry, a scaling
//! or a complex transformation obtained by combination of
//! the previous elementaries transformations.
//! (see class Transformation of the package Geom2d).
//! The following transformations have the same properties
//! as the previous ones but they don't modified the object
//! itself. A copy of the object is returned.
Standard_EXPORT virtual void Transform (const gp_Trsf2d& T) = 0;
Standard_EXPORT Handle(Geom2d_Geometry) Mirrored (const gp_Pnt2d& P) const;
Standard_EXPORT Handle(Geom2d_Geometry) Mirrored (const gp_Ax2d& A) const;
Standard_EXPORT Handle(Geom2d_Geometry) Rotated (const gp_Pnt2d& P, const Standard_Real Ang) const;
Standard_EXPORT Handle(Geom2d_Geometry) Scaled (const gp_Pnt2d& P, const Standard_Real S) const;
Standard_EXPORT Handle(Geom2d_Geometry) Transformed (const gp_Trsf2d& T) const;
Standard_EXPORT Handle(Geom2d_Geometry) Translated (const gp_Vec2d& V) const;
Standard_EXPORT Handle(Geom2d_Geometry) Translated (const gp_Pnt2d& P1, const gp_Pnt2d& P2) const;
Standard_EXPORT virtual Handle(Geom2d_Geometry) Copy() const = 0;
DEFINE_STANDARD_RTTI(Geom2d_Geometry,MMgt_TShared)
protected:
private:
};
#endif // _Geom2d_Geometry_HeaderFile

335
src/Geom2d/Geom2d_Hyperbola.cdl
View File

@@ -1,335 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 Hyperbola from Geom2d inherits Conic from Geom2d
--- Purpose : Describes a branch of a hyperbola in the plane (2D space).
-- A hyperbola is defined by its major and minor radii
-- and, as with any conic curve, is positioned in the
-- plane with a coordinate system (gp_Ax22d object) where:
-- - the origin is the center of the hyperbola,
-- - the "X Direction" defines the major axis, and
-- - the "Y Direction" defines the minor axis.
-- This coordinate system is the local coordinate
-- system of the hyperbola.
-- The branch of the hyperbola described is the one
-- located on the positive side of the major axis.
-- The orientation (direct or indirect) of the local
-- coordinate system gives an explicit orientation to the
-- hyperbola, determining the direction in which the
-- parameter increases along the hyperbola.
-- The Geom2d_Hyperbola hyperbola is parameterized as follows:
-- P(U) = O + MajRad*Cosh(U)*XDir + MinRad*Sinh(U)*YDir
-- where:
-- - P is the point of parameter U,
-- - O, XDir and YDir are respectively the origin, "X
-- Direction" and "Y Direction" of its local coordinate system,
-- - MajRad and MinRad are the major and minor radii of the hyperbola.
-- The "X Axis" of the local coordinate system therefore
-- defines the origin of the parameter of the hyperbola.
-- The parameter range is ] -infinite,+infinite [.
-- The following diagram illustrates the respective
-- positions, in the plane of the hyperbola, of the three
-- branches of hyperbolas constructed using the
-- functions OtherBranch, ConjugateBranch1 and
-- ConjugateBranch2:
-- ^YAxis
-- |
-- FirstConjugateBranch
-- |
-- Other | Main
-- --------------------- C
-- --------------------->XAxis
-- Branch |
-- Branch
-- |
-- SecondConjugateBranch
-- |
-- Warning
-- The value of the major radius (on the major axis) can
-- be less than the value of the minor radius (on the minor axis).
-- See Also
-- GCE2d_MakeHyperbola which provides functions for
-- more complex hyperbola constructions
-- gp_Ax22d
-- gp_Hypr2d for an equivalent, non-parameterized data structure
uses Ax2d from gp,
Ax22d from gp,
Hypr2d from gp,
Pnt2d from gp,
Trsf2d from gp,
Vec2d from gp,
Geometry from Geom2d
raises ConstructionError from Standard,
DomainError from Standard,
RangeError from Standard
is
Create (H : Hypr2d) returns Hyperbola;
--- Purpose : Creates an Hyperbola from a non persistent one from package gp
Create (MajorAxis : Ax2d; MajorRadius, MinorRadius : Real;
Sense: Boolean from Standard = Standard_True)
returns Hyperbola
--- Purpose :
-- MajorAxis is the "XAxis" of the hyperbola.
-- The YAxis is in the direct sense if "Sense" is True;
-- The major radius of the hyperbola is on this "XAxis" and
-- the minor radius is on the "YAxis" of the hyperbola.
raises ConstructionError;
--- Purpose : Raised if MajorRadius < 0.0 or if MinorRadius < 0.0
Create (Axis : Ax22d; MajorRadius, MinorRadius : Real)
returns Hyperbola
--- Purpose :
-- The XDirection of "Axis" is the "XAxis" of the hyperbola and
-- the YDirection of "Axis" is the "YAxis".
-- The major radius of the hyperbola is on this "XAxis" and
-- the minor radius is on the "YAxis" of the hyperbola.
raises ConstructionError;
--- Purpose : Raised if MajorRadius < 0.0 or if MinorRadius < 0.0
SetHypr2d (me : mutable; H : Hypr2d);
--- Purpose: Converts the gp_Hypr2d hyperbola H into this hyperbola.
SetMajorRadius (me : mutable; MajorRadius : Real)
raises ConstructionError;
---Purpose : Assigns a value to the major or minor radius of this hyperbola.
-- Exceptions
-- Standard_ConstructionError if:
-- - MajorRadius is less than 0.0,
-- - MinorRadius is less than 0.0.
SetMinorRadius (me : mutable; MinorRadius : Real)
raises ConstructionError;
--- Purpose : Assigns a value to the major or minor radius of this hyperbola.
-- Exceptions
-- Standard_ConstructionError if:
-- - MajorRadius is less than 0.0,
-- - MinorRadius is less than 0.0.
Hypr2d (me) returns Hypr2d;
--- Purpose : Converts this hyperbola into a gp_Hypr2d one.
ReversedParameter(me; U : Real) returns Real is redefined static;
---Purpose: Computes the parameter on the reversed hyperbola,
-- for the point of parameter U on this hyperbola.
-- For a hyperbola, the returned value is -U.
FirstParameter (me) returns Real is redefined static;
--- Purpose : Returns RealFirst from Standard.
LastParameter (me) returns Real is redefined static;
--- Purpose : returns RealLast from Standard.
IsClosed (me) returns Boolean is redefined static;
--- Purpose : Returns False.
IsPeriodic (me) returns Boolean is redefined static;
--- Purpose : return False for an hyperbola.
Asymptote1 (me) returns Ax2d
--- Purpose :
-- In the local coordinate system of the hyperbola the
-- equation of the hyperbola is (X*X)/(A*A) - (Y*Y)/(B*B) = 1.0
-- and the equation of the first asymptote is Y = (B/A)*X
-- where A is the major radius of the hyperbola and B is the
-- minor radius of the hyperbola.
raises ConstructionError;
--- Purpose : Raised if MajorRadius = 0.0
Asymptote2 (me) returns Ax2d
--- Purpose :
-- In the local coordinate system of the hyperbola the
-- equation of the hyperbola is (X*X)/(A*A) - (Y*Y)/(B*B) = 1.0
-- and the equation of the first asymptote is Y = -(B/A)*X.
-- where A is the major radius of the hyperbola and B is the
-- minor radius of the hyperbola.
raises ConstructionError;
--- Purpose : raised if MajorRadius = 0.0
ConjugateBranch1 (me) returns Hypr2d;
--- Purpose : Computes the first conjugate branch relative to this hyperbola.
-- Note: The diagram given under the class purpose
-- indicates where these two branches of hyperbola are
-- positioned in relation to this branch of hyperbola.
ConjugateBranch2 (me) returns Hypr2d;
--- Purpose : Computes the second conjugate branch relative to this hyperbola.
-- Note: The diagram given under the class purpose
-- indicates where these two branches of hyperbola are
-- positioned in relation to this branch of hyperbola.
Directrix1 (me) returns Ax2d;
--- Purpose :
-- This directrix is the line normal to the XAxis of the hyperbola
-- in the local plane (Z = 0) at a distance d = MajorRadius / e
-- from the center of the hyperbola, where e is the eccentricity of
-- the hyperbola.
-- This line is parallel to the "YAxis". The intersection point
-- between directrix1 and the "XAxis" is the location point of the
-- directrix1. This point is on the positive side of the "XAxis".
Directrix2 (me) returns Ax2d;
--- Purpose :
-- This line is obtained by the symmetrical transformation
-- of "Directrix1" with respect to the "YAxis" of the hyperbola.
Eccentricity (me) returns Real
--- Purpose :
-- Returns the excentricity of the hyperbola (e > 1).
-- If f is the distance between the location of the hyperbola
-- and the Focus1 then the eccentricity e = f / MajorRadius.
raises DomainError is redefined static;
--- Purpose : raised if MajorRadius = 0.0
Focal (me) returns Real;
--- Purpose :
-- Computes the focal distance. It is the distance between the
-- two focus of the hyperbola.
Focus1 (me) returns Pnt2d;
--- Purpose :
-- Returns the first focus of the hyperbola. This focus is on the
-- positive side of the "XAxis" of the hyperbola.
Focus2 (me) returns Pnt2d;
--- Purpose :
-- Returns the second focus of the hyperbola. This focus is on the
-- negative side of the "XAxis" of the hyperbola.
MajorRadius (me) returns Real;
---Purpose: Returns the major or minor radius of this hyperbola.
-- The major radius is also the distance between the
-- center of the hyperbola and the apex of the main
-- branch (located on the "X Axis" of the hyperbola).
MinorRadius (me) returns Real;
---Purpose: Returns the major or minor radius of this hyperbola.
-- The minor radius is also the distance between the
-- center of the hyperbola and the apex of a conjugate
-- branch (located on the "Y Axis" of the hyperbola).
OtherBranch (me) returns Hypr2d;
--- Purpose :
-- Computes the "other" branch of this hyperbola. This
-- is a symmetrical branch with respect to the center of this hyperbola.
-- Note: The diagram given under the class purpose
-- indicates where the "other" branch is positioned in
-- relation to this branch of the hyperbola.
-- ^ YAxis
-- |
-- FirstConjugateBranch
-- |
-- Other | Main
-- ---------------------------- C
-- ------------------------------------------&gtXAxis
-- Branch | Branch
-- |
-- |
-- SecondConjugateBranch
-- |
-- Warning
-- The major radius can be less than the minor radius.
Parameter (me) returns Real
--- Purpose : Computes the parameter of this hyperbola.
-- The parameter is:
-- p = (e*e - 1) * MajorRadius
-- where e is the eccentricity of this hyperbola and
-- MajorRadius its major radius.
-- Exceptions
-- Standard_DomainError if the major radius of this
-- hyperbola is null.
raises DomainError;
D0(me; U : Real; P : out Pnt2d) is redefined static;
---Purpose: Returns in P the point of parameter U.
-- P = C + MajorRadius * Cosh (U) * XDir +
-- MinorRadius * Sinh (U) * YDir
-- where C is the center of the hyperbola , XDir the XDirection and
-- YDir the YDirection of the hyperbola's local coordinate system.
D1 (me; U : Real; P : out Pnt2d; V1 : out Vec2d) is redefined static;
--- Purpose :
-- Returns the point P of parameter U and the first derivative V1.
D2 (me; U : Real; P : out Pnt2d; V1, V2 : out Vec2d) is redefined static;
--- Purpose :
-- Returns the point P of parameter U, the first and second
-- derivatives V1 and V2.
D3 (me; U : Real; P : out Pnt2d; V1, V2, V3 : out Vec2d) is redefined static;
--- Purpose :
-- Returns the point P of parameter U, the first second and
-- third derivatives V1 V2 and V3.
DN (me; U : Real; N : Integer) returns Vec2d
--- Purpose : For the point of parameter U of this hyperbola,
-- computes the vector corresponding to the Nth derivative.
-- Exceptions Standard_RangeError if N is less than 1.
raises RangeError is redefined static;
Transform (me : mutable; T : Trsf2d) is redefined static;
---Purpose: Applies the transformation T to this hyperbola.
Copy (me) returns like me is redefined static;
---Purpose: Creates a new object which is a copy of this hyperbola.
fields
majorRadius : Real;
minorRadius : Real;
end;

16
src/Geom2d/Geom2d_Hyperbola.cxx
View File

@@ -14,16 +14,24 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_Hyperbola.ixx>
#include <Precision.hxx>
#include <ElCLib.hxx>
#include <gp_Dir2d.hxx>
#include <gp_XY.hxx>
#include <Geom2d_Geometry.hxx>
#include <Geom2d_Hyperbola.hxx>
#include <gp.hxx>
#include <gp_Ax2d.hxx>
#include <gp_Ax22d.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Hypr2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <gp_XY.hxx>
#include <Precision.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Hyperbola Hyperbola;
typedef gp_Ax2d Ax2d;

322
src/Geom2d/Geom2d_Hyperbola.hxx Normal file
View File

@@ -0,0 +1,322 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_Hyperbola_HeaderFile
#define _Geom2d_Hyperbola_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
#include <Geom2d_Conic.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Standard_ConstructionError;
class Standard_DomainError;
class Standard_RangeError;
class gp_Hypr2d;
class gp_Ax2d;
class gp_Ax22d;
class gp_Pnt2d;
class gp_Vec2d;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_Hyperbola;
DEFINE_STANDARD_HANDLE(Geom2d_Hyperbola, Geom2d_Conic)
//! Describes a branch of a hyperbola in the plane (2D space).
//! A hyperbola is defined by its major and minor radii
//! and, as with any conic curve, is positioned in the
//! plane with a coordinate system (gp_Ax22d object) where:
//! - the origin is the center of the hyperbola,
//! - the "X Direction" defines the major axis, and
//! - the "Y Direction" defines the minor axis.
//! This coordinate system is the local coordinate
//! system of the hyperbola.
//! The branch of the hyperbola described is the one
//! located on the positive side of the major axis.
//! The orientation (direct or indirect) of the local
//! coordinate system gives an explicit orientation to the
//! hyperbola, determining the direction in which the
//! parameter increases along the hyperbola.
//! The Geom2d_Hyperbola hyperbola is parameterized as follows:
//! P(U) = O + MajRad*Cosh(U)*XDir + MinRad*Sinh(U)*YDir
//! where:
//! - P is the point of parameter U,
//! - O, XDir and YDir are respectively the origin, "X
//! Direction" and "Y Direction" of its local coordinate system,
//! - MajRad and MinRad are the major and minor radii of the hyperbola.
//! The "X Axis" of the local coordinate system therefore
//! defines the origin of the parameter of the hyperbola.
//! The parameter range is ] -infinite,+infinite [.
//! The following diagram illustrates the respective
//! positions, in the plane of the hyperbola, of the three
//! branches of hyperbolas constructed using the
//! functions OtherBranch, ConjugateBranch1 and
//! ConjugateBranch2:
//! ^YAxis
//! |
//! FirstConjugateBranch
//! |
//! Other | Main
//! --------------------- C
//! --------------------->XAxis
//! Branch |
//! Branch
//! |
//! SecondConjugateBranch
//! |
//! Warning
//! The value of the major radius (on the major axis) can
//! be less than the value of the minor radius (on the minor axis).
//! See Also
//! GCE2d_MakeHyperbola which provides functions for
//! more complex hyperbola constructions
//! gp_Ax22d
//! gp_Hypr2d for an equivalent, non-parameterized data structure
class Geom2d_Hyperbola : public Geom2d_Conic
{
public:
//! Creates an Hyperbola from a non persistent one from package gp
Standard_EXPORT Geom2d_Hyperbola(const gp_Hypr2d& H);
//! MajorAxis is the "XAxis" of the hyperbola.
//! The YAxis is in the direct sense if "Sense" is True;
//! The major radius of the hyperbola is on this "XAxis" and
//! the minor radius is on the "YAxis" of the hyperbola.
//! Raised if MajorRadius < 0.0 or if MinorRadius < 0.0
Standard_EXPORT Geom2d_Hyperbola(const gp_Ax2d& MajorAxis, const Standard_Real MajorRadius, const Standard_Real MinorRadius, const Standard_Boolean Sense = Standard_True);
//! The XDirection of "Axis" is the "XAxis" of the hyperbola and
//! the YDirection of "Axis" is the "YAxis".
//! The major radius of the hyperbola is on this "XAxis" and
//! the minor radius is on the "YAxis" of the hyperbola.
//! Raised if MajorRadius < 0.0 or if MinorRadius < 0.0
Standard_EXPORT Geom2d_Hyperbola(const gp_Ax22d& Axis, const Standard_Real MajorRadius, const Standard_Real MinorRadius);
//! Converts the gp_Hypr2d hyperbola H into this hyperbola.
Standard_EXPORT void SetHypr2d (const gp_Hypr2d& H);
//! Assigns a value to the major or minor radius of this hyperbola.
//! Exceptions
//! Standard_ConstructionError if:
//! - MajorRadius is less than 0.0,
//! - MinorRadius is less than 0.0.
Standard_EXPORT void SetMajorRadius (const Standard_Real MajorRadius);
//! Assigns a value to the major or minor radius of this hyperbola.
//! Exceptions
//! Standard_ConstructionError if:
//! - MajorRadius is less than 0.0,
//! - MinorRadius is less than 0.0.
Standard_EXPORT void SetMinorRadius (const Standard_Real MinorRadius);
//! Converts this hyperbola into a gp_Hypr2d one.
Standard_EXPORT gp_Hypr2d Hypr2d() const;
//! Computes the parameter on the reversed hyperbola,
//! for the point of parameter U on this hyperbola.
//! For a hyperbola, the returned value is -U.
Standard_EXPORT Standard_Real ReversedParameter (const Standard_Real U) const Standard_OVERRIDE;
//! Returns RealFirst from Standard.
Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE;
//! returns RealLast from Standard.
Standard_EXPORT Standard_Real LastParameter() const Standard_OVERRIDE;
//! Returns False.
Standard_EXPORT Standard_Boolean IsClosed() const Standard_OVERRIDE;
//! return False for an hyperbola.
Standard_EXPORT Standard_Boolean IsPeriodic() const Standard_OVERRIDE;
//! In the local coordinate system of the hyperbola the
//! equation of the hyperbola is (X*X)/(A*A) - (Y*Y)/(B*B) = 1.0
//! and the equation of the first asymptote is Y = (B/A)*X
//! where A is the major radius of the hyperbola and B is the
//! minor radius of the hyperbola.
//! Raised if MajorRadius = 0.0
Standard_EXPORT gp_Ax2d Asymptote1() const;
//! In the local coordinate system of the hyperbola the
//! equation of the hyperbola is (X*X)/(A*A) - (Y*Y)/(B*B) = 1.0
//! and the equation of the first asymptote is Y = -(B/A)*X.
//! where A is the major radius of the hyperbola and B is the
//! minor radius of the hyperbola.
//! raised if MajorRadius = 0.0
Standard_EXPORT gp_Ax2d Asymptote2() const;
//! Computes the first conjugate branch relative to this hyperbola.
//! Note: The diagram given under the class purpose
//! indicates where these two branches of hyperbola are
//! positioned in relation to this branch of hyperbola.
Standard_EXPORT gp_Hypr2d ConjugateBranch1() const;
//! Computes the second conjugate branch relative to this hyperbola.
//! Note: The diagram given under the class purpose
//! indicates where these two branches of hyperbola are
//! positioned in relation to this branch of hyperbola.
Standard_EXPORT gp_Hypr2d ConjugateBranch2() const;
//! This directrix is the line normal to the XAxis of the hyperbola
//! in the local plane (Z = 0) at a distance d = MajorRadius / e
//! from the center of the hyperbola, where e is the eccentricity of
//! the hyperbola.
//! This line is parallel to the "YAxis". The intersection point
//! between directrix1 and the "XAxis" is the location point of the
//! directrix1. This point is on the positive side of the "XAxis".
Standard_EXPORT gp_Ax2d Directrix1() const;
//! This line is obtained by the symmetrical transformation
//! of "Directrix1" with respect to the "YAxis" of the hyperbola.
Standard_EXPORT gp_Ax2d Directrix2() const;
//! Returns the excentricity of the hyperbola (e > 1).
//! If f is the distance between the location of the hyperbola
//! and the Focus1 then the eccentricity e = f / MajorRadius.
//! raised if MajorRadius = 0.0
Standard_EXPORT Standard_Real Eccentricity() const Standard_OVERRIDE;
//! Computes the focal distance. It is the distance between the
//! two focus of the hyperbola.
Standard_EXPORT Standard_Real Focal() const;
//! Returns the first focus of the hyperbola. This focus is on the
//! positive side of the "XAxis" of the hyperbola.
Standard_EXPORT gp_Pnt2d Focus1() const;
//! Returns the second focus of the hyperbola. This focus is on the
//! negative side of the "XAxis" of the hyperbola.
Standard_EXPORT gp_Pnt2d Focus2() const;
//! Returns the major or minor radius of this hyperbola.
//! The major radius is also the distance between the
//! center of the hyperbola and the apex of the main
//! branch (located on the "X Axis" of the hyperbola).
Standard_EXPORT Standard_Real MajorRadius() const;
//! Returns the major or minor radius of this hyperbola.
//! The minor radius is also the distance between the
//! center of the hyperbola and the apex of a conjugate
//! branch (located on the "Y Axis" of the hyperbola).
Standard_EXPORT Standard_Real MinorRadius() const;
//! Computes the "other" branch of this hyperbola. This
//! is a symmetrical branch with respect to the center of this hyperbola.
//! Note: The diagram given under the class purpose
//! indicates where the "other" branch is positioned in
//! relation to this branch of the hyperbola.
//! ^ YAxis
//! |
//! FirstConjugateBranch
//! |
//! Other | Main
//! ---------------------------- C
//! ------------------------------------------&gtXAxis
//! Branch | Branch
//! |
//! |
//! SecondConjugateBranch
//! |
//! Warning
//! The major radius can be less than the minor radius.
Standard_EXPORT gp_Hypr2d OtherBranch() const;
//! Computes the parameter of this hyperbola.
//! The parameter is:
//! p = (e*e - 1) * MajorRadius
//! where e is the eccentricity of this hyperbola and
//! MajorRadius its major radius.
//! Exceptions
//! Standard_DomainError if the major radius of this
//! hyperbola is null.
Standard_EXPORT Standard_Real Parameter() const;
//! Returns in P the point of parameter U.
//! P = C + MajorRadius * Cosh (U) * XDir +
//! MinorRadius * Sinh (U) * YDir
//! where C is the center of the hyperbola , XDir the XDirection and
//! YDir the YDirection of the hyperbola's local coordinate system.
Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt2d& P) const Standard_OVERRIDE;
//! Returns the point P of parameter U and the first derivative V1.
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1) const Standard_OVERRIDE;
//! Returns the point P of parameter U, the first and second
//! derivatives V1 and V2.
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const Standard_OVERRIDE;
//! Returns the point P of parameter U, the first second and
//! third derivatives V1 V2 and V3.
Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const Standard_OVERRIDE;
//! For the point of parameter U of this hyperbola,
//! computes the vector corresponding to the Nth derivative.
//! Exceptions Standard_RangeError if N is less than 1.
Standard_EXPORT gp_Vec2d DN (const Standard_Real U, const Standard_Integer N) const Standard_OVERRIDE;
//! Applies the transformation T to this hyperbola.
Standard_EXPORT void Transform (const gp_Trsf2d& T) Standard_OVERRIDE;
//! Creates a new object which is a copy of this hyperbola.
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const Standard_OVERRIDE;
DEFINE_STANDARD_RTTI(Geom2d_Hyperbola,Geom2d_Conic)
protected:
private:
Standard_Real majorRadius;
Standard_Real minorRadius;
};
#endif // _Geom2d_Hyperbola_HeaderFile

205
src/Geom2d/Geom2d_Line.cdl
View File

@@ -1,205 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 Line from Geom2d inherits Curve from Geom2d
--- Purpose : Describes an infinite line in the plane (2D space).
-- A line is defined and positioned in the plane with an
-- axis (gp_Ax2d object) which gives it an origin and a unit vector.
-- The Geom2d_Line line is parameterized as follows:
-- P (U) = O + U*Dir
-- where:
-- - P is the point of parameter U,
-- - O is the origin and Dir the unit vector of its positioning axis.
-- The parameter range is ] -infinite, +infinite [.
-- The orientation of the line is given by the unit vector
-- of its positioning axis.
-- See Also
-- GCE2d_MakeLine which provides functions for more
-- complex line constructions
-- gp_Ax2d
-- gp_Lin2d for an equivalent, non-parameterized data structure.
uses Ax2d from gp,
Dir2d from gp,
Lin2d from gp,
Pnt2d from gp,
Vec2d from gp,
Trsf2d from gp,
Geometry from Geom2d,
Shape from GeomAbs
raises RangeError from Standard
is
Create (A : Ax2d) returns Line;
--- Purpose :
-- Creates a line located in 2D space with the axis placement A.
-- The Location of A is the origin of the line.
Create (L : Lin2d) returns Line;
--- Purpose :
-- Creates a line by conversion of the gp_Lin2d line L.
Create (P : Pnt2d; V : Dir2d) returns Line;
--- Purpose : Constructs a line passing through point P and parallel to
-- vector V (P and V are, respectively, the origin
-- and the unit vector of the positioning axis of the line).
SetLin2d (me : mutable; L : Lin2d);
--- Purpose :
-- Set <me> so that <me> has the same geometric properties as L.
SetDirection (me : mutable; V : Dir2d);
--- Purpose : changes the direction of the line.
Direction (me) returns Dir2d from gp;
--- Purpose : changes the direction of the line.
---C++: return const &
SetLocation (me : mutable; P : Pnt2d);
--- Purpose :
-- Changes the "Location" point (origin) of the line.
Location (me) returns Pnt2d from gp;
--- Purpose :
-- Changes the "Location" point (origin) of the line.
---C++: return const &
SetPosition (me : mutable; A : Ax2d);
--- Purpose :
-- Changes the "Location" and a the "Direction" of <me>.
Position(me) returns Ax2d from gp
---C++: return const &
is static;
Lin2d (me) returns Lin2d;
--- Purpose :
-- Returns non persistent line from gp with the same geometric
-- properties as <me>
Reverse (me : mutable);
--- Purpose : Changes the orientation of this line. As a result, the
-- unit vector of the positioning axis of this line is reversed.
ReversedParameter(me; U : Real) returns Real;
---Purpose: Computes the parameter on the reversed line for the
-- point of parameter U on this line.
-- For a line, the returned value is -U.
FirstParameter (me) returns Real;
--- Purpose : Returns RealFirst from Standard.
LastParameter (me) returns Real;
--- Purpose : Returns RealLast from Standard
IsClosed (me) returns Boolean;
--- Purpose : Returns False
IsPeriodic (me) returns Boolean;
--- Purpose : Returns False
Continuity (me) returns Shape from GeomAbs;
--- Purpose : Returns GeomAbs_CN, which is the global continuity of any line.
Distance (me; P : Pnt2d) returns Real;
--- Purpose : Computes the distance between <me> and the point P.
IsCN (me; N : Integer) returns Boolean;
--- Purpose : Returns True.
D0(me; U : Real; P : out Pnt2d);
---Purpose: Returns in P the point of parameter U.
-- P (U) = O + U * Dir where O is the "Location" point of the
-- line and Dir the direction of the line.
D1 (me; U : Real; P : out Pnt2d; V1 : out Vec2d);
--- Purpose :
-- Returns the point P of parameter u and the first derivative V1.
D2 (me; U : Real; P : out Pnt2d; V1, V2 : out Vec2d);
--- Purpose :
-- Returns the point P of parameter U, the first and second
-- derivatives V1 and V2. V2 is a vector with null magnitude
-- for a line.
D3 (me; U : Real; P : out Pnt2d; V1, V2, V3 : out Vec2d);
--- Purpose :
-- V2 and V3 are vectors with null magnitude for a line.
DN (me; U : Real; N : Integer) returns Vec2d
--- Purpose : For the point of parameter U of this line, computes
-- the vector corresponding to the Nth derivative.
-- Note: if N is greater than or equal to 2, the result is a
-- vector with null magnitude.
-- Exceptions Standard_RangeError if N is less than 1.
raises RangeError;
Transform (me : mutable; T : Trsf2d);
---Purpose: Applies the transformation T to this line.
TransformedParameter(me; U : Real; T : Trsf2d from gp) returns Real
---Purpose: Computes the parameter on the line transformed by
-- T for the point of parameter U on this line.
-- For a line, the returned value is equal to U multiplied
-- by the scale factor of transformation T.
is redefined;
ParametricTransformation(me; T : Trsf2d from gp) returns Real
---Purpose: Returns the coefficient required to compute the
-- parametric transformation of this line when
-- transformation T is applied. This coefficient is the
-- ratio between the parameter of a point on this line
-- and the parameter of the transformed point on the
-- new line transformed by T.
-- For a line, the returned value is the scale factor of the transformation T.
is redefined;
Copy (me) returns like me;
---Purpose: Creates a new object, which is a copy of this line.
fields
pos : Ax2d;
end;

12
src/Geom2d/Geom2d_Line.cxx
View File

@@ -14,12 +14,20 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_Line.ixx>
#include <Precision.hxx>
#include <ElCLib.hxx>
#include <Geom2d_Geometry.hxx>
#include <Geom2d_Line.hxx>
#include <gp_Ax2d.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <gp_XY.hxx>
#include <Precision.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Line Line;
typedef gp_Ax2d Ax2d;

208
src/Geom2d/Geom2d_Line.hxx Normal file
View File

@@ -0,0 +1,208 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_Line_HeaderFile
#define _Geom2d_Line_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <gp_Ax2d.hxx>
#include <Geom2d_Curve.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
class Standard_RangeError;
class gp_Ax2d;
class gp_Lin2d;
class gp_Pnt2d;
class gp_Dir2d;
class gp_Vec2d;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_Line;
DEFINE_STANDARD_HANDLE(Geom2d_Line, Geom2d_Curve)
//! Describes an infinite line in the plane (2D space).
//! A line is defined and positioned in the plane with an
//! axis (gp_Ax2d object) which gives it an origin and a unit vector.
//! The Geom2d_Line line is parameterized as follows:
//! P (U) = O + U*Dir
//! where:
//! - P is the point of parameter U,
//! - O is the origin and Dir the unit vector of its positioning axis.
//! The parameter range is ] -infinite, +infinite [.
//! The orientation of the line is given by the unit vector
//! of its positioning axis.
//! See Also
//! GCE2d_MakeLine which provides functions for more
//! complex line constructions
//! gp_Ax2d
//! gp_Lin2d for an equivalent, non-parameterized data structure.
class Geom2d_Line : public Geom2d_Curve
{
public:
//! Creates a line located in 2D space with the axis placement A.
//! The Location of A is the origin of the line.
Standard_EXPORT Geom2d_Line(const gp_Ax2d& A);
//! Creates a line by conversion of the gp_Lin2d line L.
Standard_EXPORT Geom2d_Line(const gp_Lin2d& L);
//! Constructs a line passing through point P and parallel to
//! vector V (P and V are, respectively, the origin
//! and the unit vector of the positioning axis of the line).
Standard_EXPORT Geom2d_Line(const gp_Pnt2d& P, const gp_Dir2d& V);
//! Set <me> so that <me> has the same geometric properties as L.
Standard_EXPORT void SetLin2d (const gp_Lin2d& L);
//! changes the direction of the line.
Standard_EXPORT void SetDirection (const gp_Dir2d& V);
//! changes the direction of the line.
Standard_EXPORT const gp_Dir2d& Direction() const;
//! Changes the "Location" point (origin) of the line.
Standard_EXPORT void SetLocation (const gp_Pnt2d& P);
//! Changes the "Location" point (origin) of the line.
Standard_EXPORT const gp_Pnt2d& Location() const;
//! Changes the "Location" and a the "Direction" of <me>.
Standard_EXPORT void SetPosition (const gp_Ax2d& A);
Standard_EXPORT const gp_Ax2d& Position() const;
//! Returns non persistent line from gp with the same geometric
//! properties as <me>
Standard_EXPORT gp_Lin2d Lin2d() const;
//! Changes the orientation of this line. As a result, the
//! unit vector of the positioning axis of this line is reversed.
Standard_EXPORT void Reverse();
//! Computes the parameter on the reversed line for the
//! point of parameter U on this line.
//! For a line, the returned value is -U.
Standard_EXPORT Standard_Real ReversedParameter (const Standard_Real U) const;
//! Returns RealFirst from Standard.
Standard_EXPORT Standard_Real FirstParameter() const;
//! Returns RealLast from Standard
Standard_EXPORT Standard_Real LastParameter() const;
//! Returns False
Standard_EXPORT Standard_Boolean IsClosed() const;
//! Returns False
Standard_EXPORT Standard_Boolean IsPeriodic() const;
//! Returns GeomAbs_CN, which is the global continuity of any line.
Standard_EXPORT GeomAbs_Shape Continuity() const;
//! Computes the distance between <me> and the point P.
Standard_EXPORT Standard_Real Distance (const gp_Pnt2d& P) const;
//! Returns True.
Standard_EXPORT Standard_Boolean IsCN (const Standard_Integer N) const;
//! Returns in P the point of parameter U.
//! P (U) = O + U * Dir where O is the "Location" point of the
//! line and Dir the direction of the line.
Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt2d& P) const;
//! Returns the point P of parameter u and the first derivative V1.
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1) const;
//! Returns the point P of parameter U, the first and second
//! derivatives V1 and V2. V2 is a vector with null magnitude
//! for a line.
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const;
//! V2 and V3 are vectors with null magnitude for a line.
Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const;
//! For the point of parameter U of this line, computes
//! the vector corresponding to the Nth derivative.
//! Note: if N is greater than or equal to 2, the result is a
//! vector with null magnitude.
//! Exceptions Standard_RangeError if N is less than 1.
Standard_EXPORT gp_Vec2d DN (const Standard_Real U, const Standard_Integer N) const;
//! Applies the transformation T to this line.
Standard_EXPORT void Transform (const gp_Trsf2d& T);
//! Computes the parameter on the line transformed by
//! T for the point of parameter U on this line.
//! For a line, the returned value is equal to U multiplied
//! by the scale factor of transformation T.
Standard_EXPORT virtual Standard_Real TransformedParameter (const Standard_Real U, const gp_Trsf2d& T) const Standard_OVERRIDE;
//! Returns the coefficient required to compute the
//! parametric transformation of this line when
//! transformation T is applied. This coefficient is the
//! ratio between the parameter of a point on this line
//! and the parameter of the transformed point on the
//! new line transformed by T.
//! For a line, the returned value is the scale factor of the transformation T.
Standard_EXPORT virtual Standard_Real ParametricTransformation (const gp_Trsf2d& T) const Standard_OVERRIDE;
//! Creates a new object, which is a copy of this line.
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const;
DEFINE_STANDARD_RTTI(Geom2d_Line,Geom2d_Curve)
protected:
private:
gp_Ax2d pos;
};
#endif // _Geom2d_Line_HeaderFile

357
src/Geom2d/Geom2d_OffsetCurve.cdl
View File

@@ -1,357 +0,0 @@
-- Created on: 1993-03-24
-- Created by: Philippe DAUTRY
-- 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 OffsetCurve from Geom2d inherits Curve from Geom2d
--- Purpose :
-- This class implements the basis services for the creation,
-- edition, modification and evaluation of planar offset curve.
-- The offset curve is obtained by offsetting by distance along
-- the normal to a basis curve defined in 2D space.
-- The offset curve in this package can be a self intersecting
-- curve even if the basis curve does not self-intersect.
-- The self intersecting portions are not deleted at the
-- construction time.
-- An offset curve is a curve at constant distance (Offset) from a
-- basis curve and the offset curve takes its parametrization from
-- the basis curve. The Offset curve is in the direction of the
-- normal to the basis curve N.
-- The distance offset may be positive or negative to indicate the
-- preferred side of the curve :
-- . distance offset >0 => the curve is in the direction of N
-- . distance offset >0 => the curve is in the direction of - N
-- On the Offset curve :
-- Value(u) = BasisCurve.Value(U) + (Offset * (T ^ Z)) / ||T ^ Z||
-- where T is the tangent vector to the basis curve and Z the
-- direction of the normal vector to the plane of the curve,
-- N = T ^ Z defines the offset direction and should not have
-- null length.
--
-- Warnings :
-- In this package we suppose that the continuity of the offset
-- curve is one degree less than the continuity of the
-- basis curve and we don't check that at any point ||T^Z|| != 0.0
--
-- So to evaluate the curve it is better to check that the offset
-- curve is well defined at any point because an exception could
-- be raised. The check is not done in this package at the creation
-- of the offset curve because the control needs the use of an
-- algorithm which cannot be implemented in this package.
-- The OffsetCurve is closed if the first point and the last point
-- are the same (The distance between these two points is lower or
-- equal to the Resolution sea package gp) . The OffsetCurve can be
-- closed even if the basis curve is not closed.
uses Dir2d from gp,
Pnt2d from gp,
Trsf2d from gp,
Vec2d from gp,
Curve from Geom2d,
Geometry from Geom2d,
Shape from GeomAbs
raises ConstructionError from Standard,
RangeError from Standard,
NoSuchObject from Standard,
UndefinedDerivative from Geom2d,
UndefinedValue from Geom2d,
NotImplemented from Standard
is
Create (C : Curve from Geom2d;
Offset : Real;
isNotCheckC0 : Boolean = Standard_False)
returns OffsetCurve
--- Purpose : Constructs a curve offset from the basis curve C,
-- where Offset is the distance between the offset
-- curve and the basis curve at any point.
-- A point on the offset curve is built by measuring the
-- offset value along a normal vector at a point on C.
-- This normal vector is obtained by rotating the
-- vector tangential to C at 90 degrees in the
-- anti-trigonometric sense. The side of C on which
-- the offset value is measured is indicated by this
-- normal vector if Offset is positive, or in the inverse
-- sense if Offset is negative.
-- If isNotCheckC0 = TRUE checking if basis curve has C0-continuity
-- is not made.
-- Warnings :
-- In this package the entities are not shared. The OffsetCurve is
-- built with a copy of the curve C. So when C is modified the
-- OffsetCurve is not modified
-- Warning! if isNotCheckC0 = false,
-- ConstructionError raised if the basis curve C is not at least C1.
-- No check is done to know if ||V^Z|| != 0.0 at any point.
raises ConstructionError;
Reverse (me : mutable);
--- Purpose : Changes the direction of parametrization of <me>.
-- As a result:
-- - the basis curve is reversed,
-- - the start point of the initial curve becomes the end
-- point of the reversed curve,
-- - the end point of the initial curve becomes the start
-- point of the reversed curve, and
-- - the first and last parameters are recomputed.
ReversedParameter(me; U : Real) returns Real;
---Purpose: Computes the parameter on the reversed curve for
-- the point of parameter U on this offset curve.
SetBasisCurve ( me : mutable;
C : Curve from Geom2d;
isNotCheckC0 : Boolean = Standard_False)
raises ConstructionError;
--- Purpose : Changes this offset curve by assigning C as the
-- basis curve from which it is built.
-- If isNotCheckC0 = TRUE checking if basis curve has C0-continuity
-- is not made.
-- Exceptions
-- if isNotCheckC0 = false,
-- Standard_ConstructionError if the curve C is not at least "C1" continuous.
SetOffsetValue (me : mutable; D : Real);
--- Purpose : Changes this offset curve by assigning D as the offset value.
BasisCurve (me) returns Curve from Geom2d;
--- Purpose : Returns the basis curve of this offset curve. The basis curve can be an offset curve.
Continuity (me) returns Shape from GeomAbs;
--- Purpose :
-- Continuity of the Offset curve :
-- C0 : only geometric continuity,
-- C1 : continuity of the first derivative all along the Curve,
-- C2 : continuity of the second derivative all along the Curve,
-- C3 : continuity of the third derivative all along the Curve,
-- G1 : tangency continuity all along the Curve,
-- G2 : curvature continuity all along the Curve,
-- CN : the order of continuity is infinite.
-- Warnings :
-- Returns the continuity of the basis curve - 1.
-- The offset curve must have a unique normal direction defined
-- at any point.
--- Purpose : Value and derivatives
--
-- Warnings :
-- The exception UndefinedValue or UndefinedDerivative is
-- raised if it is not possible to compute a unique offset
-- direction.
-- If T is the first derivative with not null length and
-- Z the direction normal to the plane of the curve, the
-- relation ||T(U) ^ Z|| != 0 must be satisfied to evaluate
-- the offset curve.
-- No check is done at the creation time and we suppose
-- in this package that the offset curve is well defined.
D0 (me; U : Real; P : out Pnt2d)
raises UndefinedValue;
---Purpose: Warning! this should not be called
-- if the basis curve is not at least C1. Nevertheless
-- if used on portion where the curve is C1, it is OK
D1 (me; U : Real; P : out Pnt2d; V1 : out Vec2d)
raises UndefinedDerivative;
---Purpose: Warning! this should not be called
-- if the continuity of the basis curve is not C2.
-- Nevertheless, it's OK to use it on portion
-- where the curve is C2
D2 (me; U : Real; P : out Pnt2d; V1, V2 : out Vec2d)
raises UndefinedDerivative;
---Purpose: Warning! This should not be called
-- if the continuity of the basis curve is not C3.
-- Nevertheless, it's OK to use it on portion
-- where the curve is C3
D3 (me; U : Real; P : out Pnt2d; V1, V2, V3 : out Vec2d)
raises UndefinedDerivative;
---Purpose: Warning! This should not be called
-- if the continuity of the basis curve is not C4.
-- Nevertheless, it's OK to use it on portion
-- where the curve is C4
DN (me; U : Real; N : Integer) returns Vec2d
--- Purpose : The returned vector gives the value of the derivative
-- for the order of derivation N.
-- Warning! this should not be called
-- raises UndefunedDerivative if the continuity of the basis curve is not CN+1.
-- Nevertheless, it's OK to use it on portion
-- where the curve is CN+1
-- raises RangeError if N < 1.
-- raises NotImplemented if N > 3.
raises UndefinedDerivative,
RangeError,
NotImplemented;
--- Purpose : The following functions compute the value and derivatives
-- on the offset curve and returns the derivatives on the
-- basis curve too.
-- The computation of the value and derivatives on the basis
-- curve are used to evaluate the offset curve
-- Warnings :
-- The exception UndefinedValue or UndefinedDerivative is
-- raised if it is not possible to compute a unique offset direction.
Value (me; U : Real; P, Pbasis : out Pnt2d; V1basis : out Vec2d)
raises UndefinedValue;
---Purpose: Warning! this should not be called
-- if the basis curve is not at least C1. Nevertheless
-- if used on portion where the curve is C1, it is OK
D1 (me; U : Real; P, Pbasis : out Pnt2d;
V1, V1basis, V2basis : out Vec2d)
raises UndefinedDerivative;
---Purpose: Warning! this should not be called
-- if the continuity of the basis curve is not C1.
-- Nevertheless, it's OK to use it on portion
-- where the curve is C1
D2 (me; U : Real; P, Pbasis : out Pnt2d; V1, V2, V1basis, V2basis,
V3basis : out Vec2d)
raises UndefinedDerivative;
---Purpose: Warning! this should not be called
-- if the continuity of the basis curve is not C3.
-- Nevertheless, it's OK to use it on portion
-- where the curve is C3
FirstParameter (me) returns Real;
LastParameter (me) returns Real;
---Purpose: Returns the value of the first or last parameter of this
-- offset curve. The first parameter corresponds to the
-- start point of the curve. The last parameter
-- corresponds to the end point.
-- Note: the first and last parameters of this offset curve
-- are also the ones of its basis curve.
Offset (me) returns Real;
---Purpose: Returns the offset value of this offset curve.
IsClosed (me) returns Boolean;
--- Purpose :
-- Returns True if the distance between the start point
-- and the end point of the curve is lower or equal to
-- Resolution from package gp.
IsCN (me; N : Integer) returns Boolean
--- Purpose : Is the order of continuity of the curve N ?
-- Warnings :
-- This method answer True if the continuity of the basis curve
-- is N + 1. We suppose in this class that a normal direction
-- to the basis curve (used to compute the offset curve) is
-- defined at any point on the basis curve.
raises RangeError;
--- Purpose : Raised if N < 0.
IsPeriodic (me) returns Boolean;
--- Purpose : Is the parametrization of a curve is periodic ?
-- If the basis curve is a circle or an ellipse the corresponding
-- OffsetCurve is periodic. If the basis curve can't be periodic
-- (for example BezierCurve) the OffsetCurve can't be periodic.
Period (me) returns Real from Standard
---Purpose: Returns the period of this offset curve, i.e. the period
-- of the basis curve of this offset curve.
-- Exceptions
-- Standard_NoSuchObject if the basis curve is not periodic.
raises NoSuchObject from Standard
is redefined;
Transform (me : mutable; T : Trsf2d);
---Purpose : Applies the transformation T to this offset curve.
-- Note: the basis curve is also modified.
TransformedParameter(me; U : Real; T : Trsf2d from gp) returns Real
---Purpose: Returns the parameter on the transformed curve for
-- the transform of the point of parameter U on <me>.
--
-- me->Transformed(T)->Value(me->TransformedParameter(U,T))
--
-- is the same point as
--
-- me->Value(U).Transformed(T)
--
-- This methods calls the basis curve method.
is redefined;
ParametricTransformation(me; T : Trsf2d from gp) returns Real
---Purpose: Returns a coefficient to compute the parameter on
-- the transformed curve for the transform of the
-- point on <me>.
--
-- Transformed(T)->Value(U * ParametricTransformation(T))
--
-- is the same point as
--
-- Value(U).Transformed(T)
--
-- This methods calls the basis curve method.
is redefined;
Copy (me) returns like me;
---Purpose: Creates a new object, which is a copy of this offset curve.
GetBasisCurveContinuity(me)
returns Shape from GeomAbs;
---Purpose: Returns continuity of the basis curve.
fields
basisCurve : Curve from Geom2d;
offsetValue : Real;
myBasisCurveContinuity : Shape from GeomAbs;
end;

33
src/Geom2d/Geom2d_OffsetCurve.cxx
View File

@@ -16,26 +16,31 @@
// modified by Edward AGAPOV (eap) Jan 28 2002 --- DN(), occ143(BUC60654)
#include <Geom2d_OffsetCurve.ixx>
#include <gp.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_NotImplemented.hxx>
#include <CSLib_Offset.hxx>
#include <Geom2d_UndefinedDerivative.hxx>
#include <Geom2d_UndefinedValue.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom2d_Ellipse.hxx>
#include <Geom2d_Hyperbola.hxx>
#include <Geom2d_Parabola.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom2d_Ellipse.hxx>
#include <Geom2d_Geometry.hxx>
#include <Geom2d_Hyperbola.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2d_OffsetCurve.hxx>
#include <Geom2d_Parabola.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2d_UndefinedDerivative.hxx>
#include <Geom2d_UndefinedValue.hxx>
#include <gp.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <gp_XY.hxx>
#include <Precision.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_NotImplemented.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_OffsetCurve OffsetCurve;
typedef Geom2d_Curve Curve;

325
src/Geom2d/Geom2d_OffsetCurve.hxx Normal file
View File

@@ -0,0 +1,325 @@
// Created on: 1993-03-24
// Created by: Philippe DAUTRY
// 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.
#ifndef _Geom2d_OffsetCurve_HeaderFile
#define _Geom2d_OffsetCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
#include <GeomAbs_Shape.hxx>
#include <Geom2d_Curve.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Geom2d_Curve;
class Standard_ConstructionError;
class Standard_RangeError;
class Standard_NoSuchObject;
class Geom2d_UndefinedDerivative;
class Geom2d_UndefinedValue;
class Standard_NotImplemented;
class gp_Pnt2d;
class gp_Vec2d;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_OffsetCurve;
DEFINE_STANDARD_HANDLE(Geom2d_OffsetCurve, Geom2d_Curve)
//! This class implements the basis services for the creation,
//! edition, modification and evaluation of planar offset curve.
//! The offset curve is obtained by offsetting by distance along
//! the normal to a basis curve defined in 2D space.
//! The offset curve in this package can be a self intersecting
//! curve even if the basis curve does not self-intersect.
//! The self intersecting portions are not deleted at the
//! construction time.
//! An offset curve is a curve at constant distance (Offset) from a
//! basis curve and the offset curve takes its parametrization from
//! the basis curve. The Offset curve is in the direction of the
//! normal to the basis curve N.
//! The distance offset may be positive or negative to indicate the
//! preferred side of the curve :
//! . distance offset >0 => the curve is in the direction of N
//! . distance offset >0 => the curve is in the direction of - N
//! On the Offset curve :
//! Value(u) = BasisCurve.Value(U) + (Offset * (T ^ Z)) / ||T ^ Z||
//! where T is the tangent vector to the basis curve and Z the
//! direction of the normal vector to the plane of the curve,
//! N = T ^ Z defines the offset direction and should not have
//! null length.
//!
//! Warnings :
//! In this package we suppose that the continuity of the offset
//! curve is one degree less than the continuity of the
//! basis curve and we don't check that at any point ||T^Z|| != 0.0
//!
//! So to evaluate the curve it is better to check that the offset
//! curve is well defined at any point because an exception could
//! be raised. The check is not done in this package at the creation
//! of the offset curve because the control needs the use of an
//! algorithm which cannot be implemented in this package.
//! The OffsetCurve is closed if the first point and the last point
//! are the same (The distance between these two points is lower or
//! equal to the Resolution sea package gp) . The OffsetCurve can be
//! closed even if the basis curve is not closed.
class Geom2d_OffsetCurve : public Geom2d_Curve
{
public:
//! Constructs a curve offset from the basis curve C,
//! where Offset is the distance between the offset
//! curve and the basis curve at any point.
//! A point on the offset curve is built by measuring the
//! offset value along a normal vector at a point on C.
//! This normal vector is obtained by rotating the
//! vector tangential to C at 90 degrees in the
//! anti-trigonometric sense. The side of C on which
//! the offset value is measured is indicated by this
//! normal vector if Offset is positive, or in the inverse
//! sense if Offset is negative.
//! If isNotCheckC0 = TRUE checking if basis curve has C0-continuity
//! is not made.
//! Warnings :
//! In this package the entities are not shared. The OffsetCurve is
//! built with a copy of the curve C. So when C is modified the
//! OffsetCurve is not modified
//! Warning! if isNotCheckC0 = false,
//! ConstructionError raised if the basis curve C is not at least C1.
//! No check is done to know if ||V^Z|| != 0.0 at any point.
Standard_EXPORT Geom2d_OffsetCurve(const Handle(Geom2d_Curve)& C, const Standard_Real Offset, const Standard_Boolean isNotCheckC0 = Standard_False);
//! Changes the direction of parametrization of <me>.
//! As a result:
//! - the basis curve is reversed,
//! - the start point of the initial curve becomes the end
//! point of the reversed curve,
//! - the end point of the initial curve becomes the start
//! point of the reversed curve, and
//! - the first and last parameters are recomputed.
Standard_EXPORT void Reverse();
//! Computes the parameter on the reversed curve for
//! the point of parameter U on this offset curve.
Standard_EXPORT Standard_Real ReversedParameter (const Standard_Real U) const;
//! Changes this offset curve by assigning C as the
//! basis curve from which it is built.
//! If isNotCheckC0 = TRUE checking if basis curve has C0-continuity
//! is not made.
//! Exceptions
//! if isNotCheckC0 = false,
//! Standard_ConstructionError if the curve C is not at least "C1" continuous.
Standard_EXPORT void SetBasisCurve (const Handle(Geom2d_Curve)& C, const Standard_Boolean isNotCheckC0 = Standard_False);
//! Changes this offset curve by assigning D as the offset value.
Standard_EXPORT void SetOffsetValue (const Standard_Real D);
//! Returns the basis curve of this offset curve. The basis curve can be an offset curve.
Standard_EXPORT Handle(Geom2d_Curve) BasisCurve() const;
//! Continuity of the Offset curve :
//! C0 : only geometric continuity,
//! C1 : continuity of the first derivative all along the Curve,
//! C2 : continuity of the second derivative all along the Curve,
//! C3 : continuity of the third derivative all along the Curve,
//! G1 : tangency continuity all along the Curve,
//! G2 : curvature continuity all along the Curve,
//! CN : the order of continuity is infinite.
//! Warnings :
//! Returns the continuity of the basis curve - 1.
//! The offset curve must have a unique normal direction defined
//! at any point.
//! Value and derivatives
//!
//! Warnings :
//! The exception UndefinedValue or UndefinedDerivative is
//! raised if it is not possible to compute a unique offset
//! direction.
//! If T is the first derivative with not null length and
//! Z the direction normal to the plane of the curve, the
//! relation ||T(U) ^ Z|| != 0 must be satisfied to evaluate
//! the offset curve.
//! No check is done at the creation time and we suppose
//! in this package that the offset curve is well defined.
Standard_EXPORT GeomAbs_Shape Continuity() const;
//! Warning! this should not be called
//! if the basis curve is not at least C1. Nevertheless
//! if used on portion where the curve is C1, it is OK
Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt2d& P) const;
//! Warning! this should not be called
//! if the continuity of the basis curve is not C2.
//! Nevertheless, it's OK to use it on portion
//! where the curve is C2
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1) const;
//! Warning! This should not be called
//! if the continuity of the basis curve is not C3.
//! Nevertheless, it's OK to use it on portion
//! where the curve is C3
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const;
//! Warning! This should not be called
//! if the continuity of the basis curve is not C4.
//! Nevertheless, it's OK to use it on portion
//! where the curve is C4
Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const;
//! The returned vector gives the value of the derivative
//! for the order of derivation N.
//! Warning! this should not be called
//! raises UndefunedDerivative if the continuity of the basis curve is not CN+1.
//! Nevertheless, it's OK to use it on portion
//! where the curve is CN+1
//! raises RangeError if N < 1.
//! raises NotImplemented if N > 3.
//! The following functions compute the value and derivatives
//! on the offset curve and returns the derivatives on the
//! basis curve too.
//! The computation of the value and derivatives on the basis
//! curve are used to evaluate the offset curve
//! Warnings :
//! The exception UndefinedValue or UndefinedDerivative is
//! raised if it is not possible to compute a unique offset direction.
Standard_EXPORT gp_Vec2d DN (const Standard_Real U, const Standard_Integer N) const;
//! Warning! this should not be called
//! if the basis curve is not at least C1. Nevertheless
//! if used on portion where the curve is C1, it is OK
Standard_EXPORT void Value (const Standard_Real U, gp_Pnt2d& P, gp_Pnt2d& Pbasis, gp_Vec2d& V1basis) const;
//! Warning! this should not be called
//! if the continuity of the basis curve is not C1.
//! Nevertheless, it's OK to use it on portion
//! where the curve is C1
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt2d& P, gp_Pnt2d& Pbasis, gp_Vec2d& V1, gp_Vec2d& V1basis, gp_Vec2d& V2basis) const;
//! Warning! this should not be called
//! if the continuity of the basis curve is not C3.
//! Nevertheless, it's OK to use it on portion
//! where the curve is C3
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt2d& P, gp_Pnt2d& Pbasis, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V1basis, gp_Vec2d& V2basis, gp_Vec2d& V3basis) const;
Standard_EXPORT Standard_Real FirstParameter() const;
//! Returns the value of the first or last parameter of this
//! offset curve. The first parameter corresponds to the
//! start point of the curve. The last parameter
//! corresponds to the end point.
//! Note: the first and last parameters of this offset curve
//! are also the ones of its basis curve.
Standard_EXPORT Standard_Real LastParameter() const;
//! Returns the offset value of this offset curve.
Standard_EXPORT Standard_Real Offset() const;
//! Returns True if the distance between the start point
//! and the end point of the curve is lower or equal to
//! Resolution from package gp.
Standard_EXPORT Standard_Boolean IsClosed() const;
//! Is the order of continuity of the curve N ?
//! Warnings :
//! This method answer True if the continuity of the basis curve
//! is N + 1. We suppose in this class that a normal direction
//! to the basis curve (used to compute the offset curve) is
//! defined at any point on the basis curve.
//! Raised if N < 0.
Standard_EXPORT Standard_Boolean IsCN (const Standard_Integer N) const;
//! Is the parametrization of a curve is periodic ?
//! If the basis curve is a circle or an ellipse the corresponding
//! OffsetCurve is periodic. If the basis curve can't be periodic
//! (for example BezierCurve) the OffsetCurve can't be periodic.
Standard_EXPORT Standard_Boolean IsPeriodic() const;
//! Returns the period of this offset curve, i.e. the period
//! of the basis curve of this offset curve.
//! Exceptions
//! Standard_NoSuchObject if the basis curve is not periodic.
Standard_EXPORT virtual Standard_Real Period() const Standard_OVERRIDE;
//! Applies the transformation T to this offset curve.
//! Note: the basis curve is also modified.
Standard_EXPORT void Transform (const gp_Trsf2d& T);
//! Returns the parameter on the transformed curve for
//! the transform of the point of parameter U on <me>.
//!
//! me->Transformed(T)->Value(me->TransformedParameter(U,T))
//!
//! is the same point as
//!
//! me->Value(U).Transformed(T)
//!
//! This methods calls the basis curve method.
Standard_EXPORT virtual Standard_Real TransformedParameter (const Standard_Real U, const gp_Trsf2d& T) const Standard_OVERRIDE;
//! Returns a coefficient to compute the parameter on
//! the transformed curve for the transform of the
//! point on <me>.
//!
//! Transformed(T)->Value(U * ParametricTransformation(T))
//!
//! is the same point as
//!
//! Value(U).Transformed(T)
//!
//! This methods calls the basis curve method.
Standard_EXPORT virtual Standard_Real ParametricTransformation (const gp_Trsf2d& T) const Standard_OVERRIDE;
//! Creates a new object, which is a copy of this offset curve.
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const;
//! Returns continuity of the basis curve.
Standard_EXPORT GeomAbs_Shape GetBasisCurveContinuity() const;
DEFINE_STANDARD_RTTI(Geom2d_OffsetCurve,Geom2d_Curve)
protected:
private:
Handle(Geom2d_Curve) basisCurve;
Standard_Real offsetValue;
GeomAbs_Shape myBasisCurveContinuity;
};
#endif // _Geom2d_OffsetCurve_HeaderFile

232
src/Geom2d/Geom2d_Parabola.cdl
View File

@@ -1,232 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 Parabola from Geom2d inherits Conic from Geom2d
--- Purpose : Describes a parabola in the plane (2D space).
-- A parabola is defined by its focal length (i.e. the
-- distance between its focus and its apex) and is
-- positioned in the plane with a coordinate system
-- (gp_Ax22d object) where:
-- - the origin is the apex of the parabola, and
-- - the "X Axis" defines the axis of symmetry; the
-- parabola is on the positive side of this axis.
-- This coordinate system is the local coordinate
-- system of the parabola.
-- The orientation (direct or indirect) of the local
-- coordinate system gives an explicit orientation to the
-- parabola, determining the direction in which the
-- parameter increases along the parabola.
-- The Geom_Parabola parabola is parameterized as follows:
-- P(U) = O + U*U/(4.*F)*XDir + U*YDir, where:
-- - P is the point of parameter U,
-- - O, XDir and YDir are respectively the origin, "X
-- Direction" and "Y Direction" of its local coordinate system,
-- - F is the focal length of the parabola.
-- The parameter of the parabola is therefore its Y
-- coordinate in the local coordinate system, with the "X
-- Axis" of the local coordinate system defining the
-- origin of the parameter.
-- The parameter range is ] -infinite,+infinite [.
uses Ax2d from gp,
Ax22d from gp,
Parab2d from gp,
Pnt2d from gp,
Trsf2d from gp,
Vec2d from gp,
Geometry from Geom2d
raises ConstructionError from Standard,
RangeError from Standard
is
Create (Prb : Parab2d) returns Parabola;
--- Purpose : Creates a parabola from a non persistent one.
Create (MirrorAxis : Ax2d; Focal : Real;
Sense: Boolean from Standard = Standard_True)
returns Parabola
--- Purpose :
-- Creates a parabola with its "MirrorAxis" and it's focal
-- length "Focal".
-- MirrorAxis is the axis of symmetry of the curve, it is the
-- "XAxis". The "YAxis" is parallel to the directrix of the
-- parabola and is in the direct sense if Sense is True.
-- The "Location" point of "MirrorAxis" is the vertex of the parabola
raises ConstructionError;
--- Purpose : Raised if Focal < 0.0
Create (Axis : Ax22d; Focal : Real) returns Parabola
--- Purpose :
-- Creates a parabola with its Axis and it's focal
-- length "Focal".
-- The XDirection of Axis is the axis of symmetry of the curve,
-- it is the "XAxis". The "YAxis" is parallel to the directrix of the
-- parabola. The "Location" point of "Axis" is the vertex
-- of the parabola.
raises ConstructionError;
--- Purpose : Raised if Focal < 0.0
Create (D : Ax2d; F : Pnt2d) returns Parabola;
--- Purpose :
-- D is the directrix of the parabola and F the focus point.
-- The symmetry axis "XAxis" of the parabola is normal to the
-- directrix and pass through the focus point F, but its
-- "Location" point is the vertex of the parabola.
-- The "YAxis" of the parabola is parallel to D and its "Location"
-- point is the vertex of the parabola.
SetFocal (me : mutable; Focal : Real)
--- Purpose : Assigns the value Focal to the focal length of this parabola.
-- Exceptions Standard_ConstructionError if Focal is negative.
raises ConstructionError;
SetParab2d (me : mutable; Prb : Parab2d);
--- Purpose: Converts the gp_Parab2d parabola Prb into this parabola.
Parab2d (me) returns Parab2d;
--- Purpose :
-- Returns the non persistent parabola from gp with the same
-- geometric properties as <me>.
ReversedParameter(me; U : Real) returns Real is redefined static;
---Purpose: Computes the parameter on the reversed parabola
-- for the point of parameter U on this parabola.
-- For a parabola, the returned value is -U.
FirstParameter (me) returns Real is redefined static;
--- Purpose : Returns RealFirst from Standard.
LastParameter (me) returns Real is redefined static;
--- Purpose : Returns RealLast from Standard.
IsClosed (me) returns Boolean is redefined static;
--- Purpose : Returns False
IsPeriodic (me) returns Boolean is redefined static;
--- Purpose : Returns False
Directrix (me) returns Ax2d;
--- Purpose : The directrix is parallel to the "YAxis" of the parabola.
-- The "Location" point of the directrix is the intersection
-- point between the directrix and the symmetry axis ("XAxis") of the parabola.
Eccentricity (me) returns Real is redefined static;
--- Purpose : Returns the eccentricity e = 1.0
Focus (me) returns Pnt2d;
---Purpose: Computes the focus of this parabola The focus is on the
-- positive side of the "X Axis" of the local coordinate system of the parabola.
Focal (me) returns Real;
--- Purpose : Computes the focal length of this parabola.
-- The focal length is the distance between the apex and the focus of the parabola.
Parameter (me) returns Real;
--- Purpose : Computes the parameter of this parabola, which is
-- the distance between its focus and its directrix. This
-- distance is twice the focal length.
-- If P is the parameter of the parabola, the equation of
-- the parabola in its local coordinate system is: Y**2 = 2.*P*X.
D0(me; U : Real; P : out Pnt2d) is redefined static;
---Purpose: Returns in P the point of parameter U.
-- If U = 0 the returned point is the origin of the XAxis and
-- the YAxis of the parabola and it is the vertex of the parabola.
-- P = S + F * (U * U * XDir + * U * YDir)
-- where S is the vertex of the parabola, XDir the XDirection and
-- YDir the YDirection of the parabola's local coordinate system.
D1 (me; U : Real; P : out Pnt2d; V1 : out Vec2d) is redefined static;
--- Purpose :
-- Returns the point P of parameter U and the first derivative V1.
D2 (me; U : Real; P : out Pnt2d; V1, V2 : out Vec2d) is redefined static;
--- Purpose :
-- Returns the point P of parameter U, the first and second
-- derivatives V1 and V2.
D3 (me; U : Real; P : out Pnt2d; V1, V2, V3 : out Vec2d) is redefined static;
--- Purpose :
-- Returns the point P of parameter U, the first second and third
-- derivatives V1 V2 and V3.
DN (me; U : Real; N : Integer) returns Vec2d
--- Purpose : For the point of parameter U of this parabola,
-- computes the vector corresponding to the Nth derivative.
-- Exceptions Standard_RangeError if N is less than 1.
raises RangeError
is redefined static;
Transform (me : mutable; T : Trsf2d) is redefined static;
---Purpose: Applies the transformation T to this parabola.
TransformedParameter(me; U : Real; T : Trsf2d from gp) returns Real
---Purpose: Computes the parameter on the transformed
-- parabola, for the point of parameter U on this parabola.
-- For a parabola, the returned value is equal to U
-- multiplied by the scale factor of transformation T.
is redefined static;
ParametricTransformation(me; T : Trsf2d from gp) returns Real
---Purpose: Returns a coefficient to compute the parameter on
-- the transformed curve for the transform of the
-- point on <me>.
--
-- Transformed(T)->Value(U * ParametricTransformation(T))
--
-- is the same point as
--
-- Value(U).Transformed(T)
--
-- This methods returns T.ScaleFactor()
is redefined static;
Copy (me) returns like me
is redefined static;
---Purpose: Creates a new object, which is a copy of this parabola.
fields
focalLength : Real;
end;

14
src/Geom2d/Geom2d_Parabola.cxx
View File

@@ -14,14 +14,22 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_Parabola.ixx>
#include <Precision.hxx>
#include <gp_XY.hxx>
#include <ElCLib.hxx>
#include <Geom2d_Geometry.hxx>
#include <Geom2d_Parabola.hxx>
#include <gp_Ax2d.hxx>
#include <gp_Ax22d.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Parab2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <gp_XY.hxx>
#include <Precision.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Parabola Parabola;
typedef gp_Ax2d Ax2d;

232
src/Geom2d/Geom2d_Parabola.hxx Normal file
View File

@@ -0,0 +1,232 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_Parabola_HeaderFile
#define _Geom2d_Parabola_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
#include <Geom2d_Conic.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Standard_ConstructionError;
class Standard_RangeError;
class gp_Parab2d;
class gp_Ax2d;
class gp_Ax22d;
class gp_Pnt2d;
class gp_Vec2d;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_Parabola;
DEFINE_STANDARD_HANDLE(Geom2d_Parabola, Geom2d_Conic)
//! Describes a parabola in the plane (2D space).
//! A parabola is defined by its focal length (i.e. the
//! distance between its focus and its apex) and is
//! positioned in the plane with a coordinate system
//! (gp_Ax22d object) where:
//! - the origin is the apex of the parabola, and
//! - the "X Axis" defines the axis of symmetry; the
//! parabola is on the positive side of this axis.
//! This coordinate system is the local coordinate
//! system of the parabola.
//! The orientation (direct or indirect) of the local
//! coordinate system gives an explicit orientation to the
//! parabola, determining the direction in which the
//! parameter increases along the parabola.
//! The Geom_Parabola parabola is parameterized as follows:
//! P(U) = O + U*U/(4.*F)*XDir + U*YDir, where:
//! - P is the point of parameter U,
//! - O, XDir and YDir are respectively the origin, "X
//! Direction" and "Y Direction" of its local coordinate system,
//! - F is the focal length of the parabola.
//! The parameter of the parabola is therefore its Y
//! coordinate in the local coordinate system, with the "X
//! Axis" of the local coordinate system defining the
//! origin of the parameter.
//! The parameter range is ] -infinite,+infinite [.
class Geom2d_Parabola : public Geom2d_Conic
{
public:
//! Creates a parabola from a non persistent one.
Standard_EXPORT Geom2d_Parabola(const gp_Parab2d& Prb);
//! Creates a parabola with its "MirrorAxis" and it's focal
//! length "Focal".
//! MirrorAxis is the axis of symmetry of the curve, it is the
//! "XAxis". The "YAxis" is parallel to the directrix of the
//! parabola and is in the direct sense if Sense is True.
//! The "Location" point of "MirrorAxis" is the vertex of the parabola
//! Raised if Focal < 0.0
Standard_EXPORT Geom2d_Parabola(const gp_Ax2d& MirrorAxis, const Standard_Real Focal, const Standard_Boolean Sense = Standard_True);
//! Creates a parabola with its Axis and it's focal
//! length "Focal".
//! The XDirection of Axis is the axis of symmetry of the curve,
//! it is the "XAxis". The "YAxis" is parallel to the directrix of the
//! parabola. The "Location" point of "Axis" is the vertex
//! of the parabola.
//! Raised if Focal < 0.0
Standard_EXPORT Geom2d_Parabola(const gp_Ax22d& Axis, const Standard_Real Focal);
//! D is the directrix of the parabola and F the focus point.
//! The symmetry axis "XAxis" of the parabola is normal to the
//! directrix and pass through the focus point F, but its
//! "Location" point is the vertex of the parabola.
//! The "YAxis" of the parabola is parallel to D and its "Location"
//! point is the vertex of the parabola.
Standard_EXPORT Geom2d_Parabola(const gp_Ax2d& D, const gp_Pnt2d& F);
//! Assigns the value Focal to the focal length of this parabola.
//! Exceptions Standard_ConstructionError if Focal is negative.
Standard_EXPORT void SetFocal (const Standard_Real Focal);
//! Converts the gp_Parab2d parabola Prb into this parabola.
Standard_EXPORT void SetParab2d (const gp_Parab2d& Prb);
//! Returns the non persistent parabola from gp with the same
//! geometric properties as <me>.
Standard_EXPORT gp_Parab2d Parab2d() const;
//! Computes the parameter on the reversed parabola
//! for the point of parameter U on this parabola.
//! For a parabola, the returned value is -U.
Standard_EXPORT Standard_Real ReversedParameter (const Standard_Real U) const Standard_OVERRIDE;
//! Returns RealFirst from Standard.
Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE;
//! Returns RealLast from Standard.
Standard_EXPORT Standard_Real LastParameter() const Standard_OVERRIDE;
//! Returns False
Standard_EXPORT Standard_Boolean IsClosed() const Standard_OVERRIDE;
//! Returns False
Standard_EXPORT Standard_Boolean IsPeriodic() const Standard_OVERRIDE;
//! The directrix is parallel to the "YAxis" of the parabola.
//! The "Location" point of the directrix is the intersection
//! point between the directrix and the symmetry axis ("XAxis") of the parabola.
Standard_EXPORT gp_Ax2d Directrix() const;
//! Returns the eccentricity e = 1.0
Standard_EXPORT Standard_Real Eccentricity() const Standard_OVERRIDE;
//! Computes the focus of this parabola The focus is on the
//! positive side of the "X Axis" of the local coordinate system of the parabola.
Standard_EXPORT gp_Pnt2d Focus() const;
//! Computes the focal length of this parabola.
//! The focal length is the distance between the apex and the focus of the parabola.
Standard_EXPORT Standard_Real Focal() const;
//! Computes the parameter of this parabola, which is
//! the distance between its focus and its directrix. This
//! distance is twice the focal length.
//! If P is the parameter of the parabola, the equation of
//! the parabola in its local coordinate system is: Y**2 = 2.*P*X.
Standard_EXPORT Standard_Real Parameter() const;
//! Returns in P the point of parameter U.
//! If U = 0 the returned point is the origin of the XAxis and
//! the YAxis of the parabola and it is the vertex of the parabola.
//! P = S + F * (U * U * XDir + * U * YDir)
//! where S is the vertex of the parabola, XDir the XDirection and
//! YDir the YDirection of the parabola's local coordinate system.
Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt2d& P) const Standard_OVERRIDE;
//! Returns the point P of parameter U and the first derivative V1.
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1) const Standard_OVERRIDE;
//! Returns the point P of parameter U, the first and second
//! derivatives V1 and V2.
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const Standard_OVERRIDE;
//! Returns the point P of parameter U, the first second and third
//! derivatives V1 V2 and V3.
Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const Standard_OVERRIDE;
//! For the point of parameter U of this parabola,
//! computes the vector corresponding to the Nth derivative.
//! Exceptions Standard_RangeError if N is less than 1.
Standard_EXPORT gp_Vec2d DN (const Standard_Real U, const Standard_Integer N) const Standard_OVERRIDE;
//! Applies the transformation T to this parabola.
Standard_EXPORT void Transform (const gp_Trsf2d& T) Standard_OVERRIDE;
//! Computes the parameter on the transformed
//! parabola, for the point of parameter U on this parabola.
//! For a parabola, the returned value is equal to U
//! multiplied by the scale factor of transformation T.
Standard_EXPORT Standard_Real TransformedParameter (const Standard_Real U, const gp_Trsf2d& T) const Standard_OVERRIDE;
//! Returns a coefficient to compute the parameter on
//! the transformed curve for the transform of the
//! point on <me>.
//!
//! Transformed(T)->Value(U * ParametricTransformation(T))
//!
//! is the same point as
//!
//! Value(U).Transformed(T)
//!
//! This methods returns T.ScaleFactor()
Standard_EXPORT Standard_Real ParametricTransformation (const gp_Trsf2d& T) const Standard_OVERRIDE;
//! Creates a new object, which is a copy of this parabola.
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const Standard_OVERRIDE;
DEFINE_STANDARD_RTTI(Geom2d_Parabola,Geom2d_Conic)
protected:
private:
Standard_Real focalLength;
};
#endif // _Geom2d_Parabola_HeaderFile

58
src/Geom2d/Geom2d_Point.cdl
View File

@@ -1,58 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 Point from Geom2d inherits Geometry from Geom2d
--- Purpose : The abstract class Point describes the common
-- behavior of geometric points in 2D space.
-- The Geom2d package also provides the concrete
-- class Geom2d_CartesianPoint.
uses Pnt2d from gp
is
Coord (me; X, Y : out Real)
--- Purpose : returns the Coordinates of <me>.
is deferred;
Pnt2d (me) returns Pnt2d
--- Purpose : returns a non persistent copy of <me>
is deferred;
X (me) returns Real
--- Purpose : returns the X coordinate of <me>.
is deferred;
Y (me) returns Real
--- Purpose : returns the Y coordinate of <me>.
is deferred;
Distance (me; Other : Point) returns Real;
--- Purpose : computes the distance between <me> and <Other>.
SquareDistance (me; Other : Point) returns Real;
--- Purpose : computes the square distance between <me> and <Other>.
end;

5
src/Geom2d/Geom2d_Point.cxx
View File

@@ -14,7 +14,10 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_Point.ixx>
#include <Geom2d_Point.hxx>
#include <gp_Pnt2d.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Point Point;

82
src/Geom2d/Geom2d_Point.hxx Normal file
View File

@@ -0,0 +1,82 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_Point_HeaderFile
#define _Geom2d_Point_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Geom2d_Geometry.hxx>
#include <Standard_Real.hxx>
class gp_Pnt2d;
class Geom2d_Point;
DEFINE_STANDARD_HANDLE(Geom2d_Point, Geom2d_Geometry)
//! The abstract class Point describes the common
//! behavior of geometric points in 2D space.
//! The Geom2d package also provides the concrete
//! class Geom2d_CartesianPoint.
class Geom2d_Point : public Geom2d_Geometry
{
public:
//! returns the Coordinates of <me>.
Standard_EXPORT virtual void Coord (Standard_Real& X, Standard_Real& Y) const = 0;
//! returns a non persistent copy of <me>
Standard_EXPORT virtual gp_Pnt2d Pnt2d() const = 0;
//! returns the X coordinate of <me>.
Standard_EXPORT virtual Standard_Real X() const = 0;
//! returns the Y coordinate of <me>.
Standard_EXPORT virtual Standard_Real Y() const = 0;
//! computes the distance between <me> and <Other>.
Standard_EXPORT Standard_Real Distance (const Handle(Geom2d_Point)& Other) const;
//! computes the square distance between <me> and <Other>.
Standard_EXPORT Standard_Real SquareDistance (const Handle(Geom2d_Point)& Other) const;
DEFINE_STANDARD_RTTI(Geom2d_Point,Geom2d_Geometry)
protected:
private:
};
#endif // _Geom2d_Point_HeaderFile

239
src/Geom2d/Geom2d_Transformation.cdl
View File

@@ -1,239 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 Transformation from Geom2d inherits TShared from MMgt
--- Purpose :
-- The class Transformation allows to create Translation,
-- Rotation, Symmetry, Scaling and complex transformations
-- obtained by combination of the previous elementary
-- transformations.
-- The Transformation class can also be used to
-- construct complex transformations by combining
-- these elementary transformations.
-- However, these transformations can never change
-- the type of an object. For example, the projection
-- transformation can change a circle into an ellipse,
-- and therefore change the real type of the object.
-- Such a transformation is forbidden in this
-- environment and cannot be a Geom2d_Transformation.
-- The transformation can be represented as follow :
--
-- V1 V2 T
-- | a11 a12 a14 | | x | | x'|
-- | a21 a22 a24 | | y | | y'|
-- | 0 0 1 | | 1 | | 1 |
--
-- where {V1, V2} defines the vectorial part of the
-- transformation and T defines the translation part of
-- the transformation.
-- - Geom2d_Transformation transformations provide
-- the same kind of "geometric" services as
-- gp_Trsf2d ones but have more complex data
-- structures. The geometric objects provided by the
-- Geom2d package use gp_Trsf2d transformations
-- in the syntaxes Transform and Transformed.
-- - Geom2d_Transformation transformations are
-- used in a context where they can be shared by
-- several objects contained inside a common data structure.
uses Ax2d from gp,
Pnt2d from gp,
Trsf2d from gp,
TrsfForm from gp,
Vec2d from gp
raises ConstructionError from Standard,
OutOfRange from Standard
is
Create returns Transformation;
--- Purpose : Creates an identity transformation.
Create (T : Trsf2d) returns Transformation;
--- Purpose : Creates a persistent copy of T.
SetMirror (me : mutable; P : Pnt2d);
--- Purpose :
-- Makes the transformation into a symmetrical transformation
-- with respect to a point P.
-- P is the center of the symmetry.
SetMirror (me : mutable; A : Ax2d);
--- Purpose :
-- Makes the transformation into a symmetrical transformation
-- with respect to an axis A.
-- A is the center of the axial symmetry.
SetRotation (me : mutable; P : Pnt2d; Ang : Real);
--- Purpose : Assigns to this transformation the geometric
-- properties of a rotation at angle Ang (in radians) about point P.
SetScale (me : mutable; P : Pnt2d; S : Real);
--- Purpose :
-- Makes the transformation into a scale. P is the center of
-- the scale and S is the scaling value.
SetTransformation (me : mutable; FromSystem1, ToSystem2 : Ax2d);
--- Purpose :
-- Makes a transformation allowing passage from the coordinate
-- system "FromSystem1" to the coordinate system "ToSystem2".
SetTransformation (me : mutable; ToSystem : Ax2d);
--- Purpose :
-- Makes the transformation allowing passage from the basic
-- coordinate system
-- {P(0.,0.,0.), VX (1.,0.,0.), VY (0.,1.,0.)}
-- to the local coordinate system defined with the Ax2d ToSystem.
SetTranslation (me : mutable; V : Vec2d);
--- Purpose :
-- Makes the transformation into a translation.
-- V is the vector of the translation.
SetTranslation(me : mutable; P1, P2 : Pnt2d);
--- Purpose :
-- Makes the transformation into a translation from the point
-- P1 to the point P2.
SetTrsf2d (me : mutable; T : Trsf2d);
--- Purpose :
-- Makes the transformation into a transformation T from
-- package gp.
IsNegative (me) returns Boolean;
--- Purpose : Checks whether this transformation is an indirect
-- transformation: returns true if the determinant of the
-- matrix of the vectorial part of the transformation is less than 0.
Form (me) returns TrsfForm;
--- Purpose : Returns the nature of this transformation as a value
-- of the gp_TrsfForm enumeration.
-- Returns the nature of the transformation. It can be
-- Identity, Rotation, Translation, PntMirror, Ax1Mirror,
-- Scale, CompoundTrsf
ScaleFactor (me) returns Real;
--- Purpose : Returns the scale value of the transformation.
Trsf2d (me) returns Trsf2d;
--- Purpose : Converts this transformation into a gp_Trsf2d transformation.
-- Returns a non persistent copy of <me>.
-- -C++: return const&
Value (me; Row, Col : Integer) returns Real
--- Purpose :
-- Returns the coefficients of the global matrix of tranformation.
-- It is a 2 rows X 3 columns matrix.
raises OutOfRange;
--- Purpose :
-- Raised if Row < 1 or Row > 2 or Col < 1 or Col > 2
--- Purpose :
-- Computes the reverse transformation.
Invert (me : mutable)
---Purpose: Computes the inverse of this transformation.
-- and assigns the result to this transformatio
raises ConstructionError;
--- Purpose :
-- Raised if the the transformation is singular. This means that
-- the ScaleFactor is lower or equal to Resolution from
-- package gp.
Inverted (me) returns Transformation
raises ConstructionError;
---Purpose: Computes the inverse of this transformation and creates a new one.
-- Raises ConstructionError if the the transformation is singular. This means that
-- the ScaleFactor is lower or equal to Resolution from package gp.
Multiplied (me; Other : Transformation) returns Transformation;
--- Purpose :
-- Computes the transformation composed with Other and <me>.
-- <me> * Other.
-- Returns a new transformation
---C++: alias operator *
Multiply (me : mutable; Other : Transformation);
--- Purpose :
-- Computes the transformation composed with Other and <me> .
-- <me> = <me> * Other.
---C++: alias operator *=
--- Purpose :
-- Computes the following composition of transformations
-- if N > 0 <me> * <me> * .......* <me>.
-- if N = 0 Identity
-- if N < 0 <me>.Invert() * .........* <me>.Invert()
Power (me : mutable; N : Integer)
raises ConstructionError;
--- Purpose :
-- Raised if N < 0 and if the transformation is not inversible
Powered (me; N : Integer) returns Transformation
raises ConstructionError;
--- Purpose :
-- Raised if N < 0 and if the transformation is not inversible
PreMultiply (me : mutable; Other : Transformation);
--- Purpose :
-- Computes the matrix of the transformation composed with
-- <me> and Other. <me> = Other * <me>
Transforms (me; X, Y : in out Real);
--- Purpose :
-- Applies the transformation <me> to the triplet {X, Y}.
Copy (me) returns Transformation;
--- Purpose: Creates a new object, which is a copy of this transformation.
fields
gpTrsf2d : Trsf2d;
end;

9
src/Geom2d/Geom2d_Transformation.cxx
View File

@@ -14,8 +14,15 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_Transformation.ixx>
#include <Geom2d_Transformation.hxx>
#include <gp_Ax2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Transformation Transformation;
typedef gp_Ax2d Ax2d;

243
src/Geom2d/Geom2d_Transformation.hxx Normal file
View File

@@ -0,0 +1,243 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_Transformation_HeaderFile
#define _Geom2d_Transformation_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <gp_Trsf2d.hxx>
#include <MMgt_TShared.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <gp_TrsfForm.hxx>
#include <Standard_Integer.hxx>
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_Trsf2d;
class gp_Pnt2d;
class gp_Ax2d;
class gp_Vec2d;
class Geom2d_Transformation;
DEFINE_STANDARD_HANDLE(Geom2d_Transformation, MMgt_TShared)
//! The class Transformation allows to create Translation,
//! Rotation, Symmetry, Scaling and complex transformations
//! obtained by combination of the previous elementary
//! transformations.
//! The Transformation class can also be used to
//! construct complex transformations by combining
//! these elementary transformations.
//! However, these transformations can never change
//! the type of an object. For example, the projection
//! transformation can change a circle into an ellipse,
//! and therefore change the real type of the object.
//! Such a transformation is forbidden in this
//! environment and cannot be a Geom2d_Transformation.
//! The transformation can be represented as follow :
//!
//! V1 V2 T
//! | a11 a12 a14 | | x | | x'|
//! | a21 a22 a24 | | y | | y'|
//! | 0 0 1 | | 1 | | 1 |
//!
//! where {V1, V2} defines the vectorial part of the
//! transformation and T defines the translation part of
//! the transformation.
//! - Geom2d_Transformation transformations provide
//! the same kind of "geometric" services as
//! gp_Trsf2d ones but have more complex data
//! structures. The geometric objects provided by the
//! Geom2d package use gp_Trsf2d transformations
//! in the syntaxes Transform and Transformed.
//! - Geom2d_Transformation transformations are
//! used in a context where they can be shared by
//! several objects contained inside a common data structure.
class Geom2d_Transformation : public MMgt_TShared
{
public:
//! Creates an identity transformation.
Standard_EXPORT Geom2d_Transformation();
//! Creates a persistent copy of T.
Standard_EXPORT Geom2d_Transformation(const gp_Trsf2d& T);
//! Makes the transformation into a symmetrical transformation
//! with respect to a point P.
//! P is the center of the symmetry.
Standard_EXPORT void SetMirror (const gp_Pnt2d& P);
//! Makes the transformation into a symmetrical transformation
//! with respect to an axis A.
//! A is the center of the axial symmetry.
Standard_EXPORT void SetMirror (const gp_Ax2d& A);
//! Assigns to this transformation the geometric
//! properties of a rotation at angle Ang (in radians) about point P.
Standard_EXPORT void SetRotation (const gp_Pnt2d& P, const Standard_Real Ang);
//! Makes the transformation into a scale. P is the center of
//! the scale and S is the scaling value.
Standard_EXPORT void SetScale (const gp_Pnt2d& P, const Standard_Real S);
//! Makes a transformation allowing passage from the coordinate
//! system "FromSystem1" to the coordinate system "ToSystem2".
Standard_EXPORT void SetTransformation (const gp_Ax2d& FromSystem1, const gp_Ax2d& ToSystem2);
//! Makes the transformation allowing passage from the basic
//! coordinate system
//! {P(0.,0.,0.), VX (1.,0.,0.), VY (0.,1.,0.)}
//! to the local coordinate system defined with the Ax2d ToSystem.
Standard_EXPORT void SetTransformation (const gp_Ax2d& ToSystem);
//! Makes the transformation into a translation.
//! V is the vector of the translation.
Standard_EXPORT void SetTranslation (const gp_Vec2d& V);
//! Makes the transformation into a translation from the point
//! P1 to the point P2.
Standard_EXPORT void SetTranslation (const gp_Pnt2d& P1, const gp_Pnt2d& P2);
//! Makes the transformation into a transformation T from
//! package gp.
Standard_EXPORT void SetTrsf2d (const gp_Trsf2d& T);
//! Checks whether this transformation is an indirect
//! transformation: returns true if the determinant of the
//! matrix of the vectorial part of the transformation is less than 0.
Standard_EXPORT Standard_Boolean IsNegative() const;
//! Returns the nature of this transformation as a value
//! of the gp_TrsfForm enumeration.
//! Returns the nature of the transformation. It can be
//! Identity, Rotation, Translation, PntMirror, Ax1Mirror,
//! Scale, CompoundTrsf
Standard_EXPORT gp_TrsfForm Form() const;
//! Returns the scale value of the transformation.
Standard_EXPORT Standard_Real ScaleFactor() const;
//! Converts this transformation into a gp_Trsf2d transformation.
//! Returns a non persistent copy of <me>.
//! -C++: return const&
Standard_EXPORT gp_Trsf2d Trsf2d() const;
//! Returns the coefficients of the global matrix of tranformation.
//! It is a 2 rows X 3 columns matrix.
//!
//! Raised if Row < 1 or Row > 2 or Col < 1 or Col > 2
//!
//! Computes the reverse transformation.
Standard_EXPORT Standard_Real Value (const Standard_Integer Row, const Standard_Integer Col) const;
//! Computes the inverse of this transformation.
//! and assigns the result to this transformatio
//!
//! Raised if the the transformation is singular. This means that
//! the ScaleFactor is lower or equal to Resolution from
//! package gp.
Standard_EXPORT void Invert();
//! Computes the inverse of this transformation and creates a new one.
//! Raises ConstructionError if the the transformation is singular. This means that
//! the ScaleFactor is lower or equal to Resolution from package gp.
Standard_EXPORT Handle(Geom2d_Transformation) Inverted() const;
//! Computes the transformation composed with Other and <me>.
//! <me> * Other.
//! Returns a new transformation
Standard_EXPORT Handle(Geom2d_Transformation) Multiplied (const Handle(Geom2d_Transformation)& Other) const;
Handle(Geom2d_Transformation) operator * (const Handle(Geom2d_Transformation)& Other) const
{
return Multiplied(Other);
}
//! Computes the transformation composed with Other and <me> .
//! <me> = <me> * Other.
//!
//! Computes the following composition of transformations
//! if N > 0 <me> * <me> * .......* <me>.
//! if N = 0 Identity
//! if N < 0 <me>.Invert() * .........* <me>.Invert()
Standard_EXPORT void Multiply (const Handle(Geom2d_Transformation)& Other);
void operator *= (const Handle(Geom2d_Transformation)& Other)
{
Multiply(Other);
}
//! Raised if N < 0 and if the transformation is not inversible
Standard_EXPORT void Power (const Standard_Integer N);
//! Raised if N < 0 and if the transformation is not inversible
Standard_EXPORT Handle(Geom2d_Transformation) Powered (const Standard_Integer N) const;
//! Computes the matrix of the transformation composed with
//! <me> and Other. <me> = Other * <me>
Standard_EXPORT void PreMultiply (const Handle(Geom2d_Transformation)& Other);
//! Applies the transformation <me> to the triplet {X, Y}.
Standard_EXPORT void Transforms (Standard_Real& X, Standard_Real& Y) const;
//! Creates a new object, which is a copy of this transformation.
Standard_EXPORT Handle(Geom2d_Transformation) Copy() const;
DEFINE_STANDARD_RTTI(Geom2d_Transformation,MMgt_TShared)
protected:
private:
gp_Trsf2d gpTrsf2d;
};
#endif // _Geom2d_Transformation_HeaderFile

296
src/Geom2d/Geom2d_TrimmedCurve.cdl
View File

@@ -1,296 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 TrimmedCurve from Geom2d inherits BoundedCurve from Geom2d
--- Purpose :
-- Defines a portion of a curve limited by two values of
-- parameters inside the parametric domain of the curve.
-- The trimmed curve is defined by:
-- - the basis curve, and
-- - the two parameter values which limit it.
-- The trimmed curve can either have the same
-- orientation as the basis curve or the opposite orientation.
uses Ax2d from gp,
Pnt2d from gp,
Trsf2d from gp,
Vec2d from gp,
Curve from Geom2d,
Geometry from Geom2d,
Shape from GeomAbs
raises ConstructionError from Standard,
RangeError from Standard,
NoSuchObject from Standard,
UndefinedDerivative from Geom2d,
UndefinedValue from Geom2d
is
Create (C : Curve; U1, U2 : Real; Sense : Boolean = Standard_True;
theAdjustPeriodic : Boolean = Standard_True)
returns TrimmedCurve
--- Purpose :
-- Creates a trimmed curve from the basis curve C limited between
-- U1 and U2.
--
-- . U1 can be greater or lower than U2.
-- . The returned curve is oriented from U1 to U2.
-- . If the basis curve C is periodic there is an ambiguity
-- because two parts are available. In this case by default
-- the trimmed curve has the same orientation as the basis
-- curve (Sense = True). If Sense = False then the orientation
-- of the trimmed curve is opposite to the orientation of the
-- basis curve C.
-- If the curve is closed but not periodic it is not possible
-- to keep the part of the curve including the junction point
-- (except if the junction point is at the beginning or
-- at the end of the trimmed curve) because you could lose the
-- fundamental characteristics of the basis curve which are
-- used for example to compute the derivatives of the trimmed
-- curve. So for a closed curve the rules are the same as for
-- a open curve.
-- Warnings :
-- In this package the entities are not shared. The TrimmedCurve is
-- built with a copy of the curve C. So when C is modified the
-- TrimmedCurve is not modified
-- Warnings :
-- If <C> is periodic and <theAdjustPeriodic> is True, parametrics
-- bounds of the TrimmedCurve, can be different to [<U1>;<U2>},
-- if <U1> or <U2> are not in the principal period.
-- Include :
-- For more explanation see the scheme given with this class.
-- Raises ConstructionError the C is not periodic and U1 or U2 are out of
-- the bounds of C.
-- Raised if U1 = U2.
raises ConstructionError;
Reverse (me : mutable);
--- Purpose :
-- Changes the direction of parametrization of <me>. The first and
-- the last parametric values are modified. The "StartPoint"
-- of the initial curve becomes the "EndPoint" of the reversed
-- curve and the "EndPoint" of the initial curve becomes the
-- "StartPoint" of the reversed curve.
-- Example - If the trimmed curve is defined by:
-- - a basis curve whose parameter range is [ 0.,1. ], and
-- - the two trim values U1 (first parameter) and U2 (last parameter),
-- the reversed trimmed curve is defined by:
-- - the reversed basis curve, whose parameter range is still [ 0.,1. ], and
-- - the two trim values 1. - U2 (first parameter)
-- and 1. - U1 (last parameter).
ReversedParameter(me; U : Real) returns Real;
---Purpose: Returns the parameter on the reversed curve for
-- the point of parameter U on <me>.
--
-- returns UFirst + ULast - U
SetTrim (me : mutable; U1, U2 : Real; Sense : Boolean = Standard_True;
theAdjustPeriodic : Boolean = Standard_True)
--- Purpose : Changes this trimmed curve, by redefining the
-- parameter values U1 and U2, which limit its basis curve.
-- Note: If the basis curve is periodic, the trimmed curve
-- has the same orientation as the basis curve if Sense
-- is true (default value) or the opposite orientation if Sense is false.
-- Warning
-- If the basis curve is periodic and theAdjustPeriodic is True,
-- the bounds of the trimmed curve may be different from U1 and U2 if the
-- parametric origin of the basis curve is within the arc
-- of the trimmed curve. In this case, the modified
-- parameter will be equal to U1 or U2 plus or minus the period.
-- If theAdjustPeriodic is False, parameters U1 and U2 will stay unchanged.
-- Exceptions
-- Standard_ConstructionError if:
-- - the basis curve is not periodic, and either U1 or U2
-- are outside the bounds of the basis curve, or
-- - U1 is equal to U2.
raises ConstructionError;
BasisCurve (me) returns Curve;
--- Purpose : Returns the basis curve.
-- Warning
-- This function does not return a constant reference.
-- Consequently, any modification of the returned value
-- directly modifies the trimmed curve.
Continuity (me) returns Shape from GeomAbs;
--- Purpose :
-- Returns the global continuity of the basis curve of this trimmed curve.
-- C0 : only geometric continuity,
-- C1 : continuity of the first derivative all along the Curve,
-- C2 : continuity of the second derivative all along the Curve,
-- C3 : continuity of the third derivative all along the Curve,
-- CN : the order of continuity is infinite.
IsCN (me; N : Integer) returns Boolean
--- Purpose
-- Returns True if the order of continuity of the
-- trimmed curve is N. A trimmed curve is at least "C0" continuous.
-- Warnings :
-- The continuity of the trimmed curve can be greater than
-- the continuity of the basis curve because you consider
-- only a part of the basis curve.
raises RangeError;
--- Purpose : Raised if N < 0.
EndPoint (me) returns Pnt2d;
--- Purpose :
-- Returns the end point of <me>. This point is the
-- evaluation of the curve for the "LastParameter".
FirstParameter (me) returns Real;
--- Purpose :
-- Returns the value of the first parameter of <me>.
-- The first parameter is the parameter of the "StartPoint"
-- of the trimmed curve.
IsClosed (me) returns Boolean;
--- Purpose :
-- Returns True if the distance between the StartPoint and
-- the EndPoint is lower or equal to Resolution from package
-- gp.
IsPeriodic (me) returns Boolean;
--- Purpose : Returns true if the basis curve of this trimmed curve is periodic.
Period (me) returns Real from Standard
---Purpose: Returns the period of the basis curve of this trimmed curve.
-- Exceptions
-- Standard_NoSuchObject if the basis curve is not periodic.
raises
NoSuchObject from Standard
is redefined;
LastParameter (me) returns Real;
--- Purpose :
-- Returns the value of the last parameter of <me>.
-- The last parameter is the parameter of the "EndPoint" of the
-- trimmed curve.
StartPoint (me) returns Pnt2d;
--- Purpose :
-- Returns the start point of <me>.
-- This point is the evaluation of the curve from the
-- "FirstParameter".
--- Purpose : value and derivatives
--- Warnings :
-- The returned derivatives have the same orientation as the
-- derivatives of the basis curve.
D0 (me; U : Real; P : out Pnt2d)
raises UndefinedValue;
--- Purpose:
-- If the basis curve is an OffsetCurve sometimes it is not
-- possible to do the evaluation of the curve at the parameter
-- U (see class OffsetCurve).
D1 (me; U : Real; P : out Pnt2d; V1 : out Vec2d)
raises UndefinedDerivative;
--- Purpose : Raised if the continuity of the curve is not C1.
D2 (me; U : Real; P : out Pnt2d; V1, V2 : out Vec2d)
raises UndefinedDerivative;
--- Purpose : Raised if the continuity of the curve is not C2.
D3 (me; U : Real; P : out Pnt2d; V1, V2, V3 : out Vec2d)
raises UndefinedDerivative;
--- Purpose : Raised if the continuity of the curve is not C3.
DN (me; U : Real; N : Integer) returns Vec2d
--- Purpose : For the point of parameter U of this trimmed curve,
-- computes the vector corresponding to the Nth derivative.
-- Warning
-- The returned derivative vector has the same
-- orientation as the derivative vector of the basis curve,
-- even if the trimmed curve does not have the same
-- orientation as the basis curve.
-- Exceptions
-- Standard_RangeError if N is less than 1.
raises UndefinedDerivative,
RangeError;
--- Purpose : geometric transformations
Transform (me : mutable; T : Trsf2d);
--- Purpose : Applies the transformation T to this trimmed curve.
-- Warning The basis curve is also modified.
TransformedParameter(me; U : Real; T : Trsf2d from gp) returns Real
---Purpose: Returns the parameter on the transformed curve for
-- the transform of the point of parameter U on <me>.
--
-- me->Transformed(T)->Value(me->TransformedParameter(U,T))
--
-- is the same point as
--
-- me->Value(U).Transformed(T)
--
-- This methods calls the basis curve method.
is redefined;
ParametricTransformation(me; T : Trsf2d from gp) returns Real
---Purpose: Returns a coefficient to compute the parameter on
-- the transformed curve for the transform of the
-- point on <me>.
--
-- Transformed(T)->Value(U * ParametricTransformation(T))
--
-- is the same point as
--
-- Value(U).Transformed(T)
--
-- This methods calls the basis curve method.
is redefined;
Copy (me) returns like me;
---Purpose:
-- Creates a new object, which is a copy of this trimmed curve.
fields
basisCurve : Curve from Geom2d;
uTrim1 : Real;
uTrim2 : Real;
end;

38
src/Geom2d/Geom2d_TrimmedCurve.cxx
View File

@@ -14,22 +14,30 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_TrimmedCurve.ixx>
#include <gp.hxx>
#include <Geom2d_Geometry.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_OffsetCurve.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom2d_Ellipse.hxx>
#include <Geom2d_Hyperbola.hxx>
#include <Geom2d_Parabola.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_RangeError.hxx>
#include <ElCLib.hxx>
#include <Precision.hxx>
#include <ElCLib.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom2d_Ellipse.hxx>
#include <Geom2d_Geometry.hxx>
#include <Geom2d_Hyperbola.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2d_OffsetCurve.hxx>
#include <Geom2d_Parabola.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2d_UndefinedDerivative.hxx>
#include <Geom2d_UndefinedValue.hxx>
#include <gp.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <Precision.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_TrimmedCurve TrimmedCurve;
typedef gp_Ax2d Ax2d;

285
src/Geom2d/Geom2d_TrimmedCurve.hxx Normal file
View File

@@ -0,0 +1,285 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_TrimmedCurve_HeaderFile
#define _Geom2d_TrimmedCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
#include <Geom2d_BoundedCurve.hxx>
#include <Standard_Boolean.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
class Geom2d_Curve;
class Standard_ConstructionError;
class Standard_RangeError;
class Standard_NoSuchObject;
class Geom2d_UndefinedDerivative;
class Geom2d_UndefinedValue;
class gp_Pnt2d;
class gp_Vec2d;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_TrimmedCurve;
DEFINE_STANDARD_HANDLE(Geom2d_TrimmedCurve, Geom2d_BoundedCurve)
//! Defines a portion of a curve limited by two values of
//! parameters inside the parametric domain of the curve.
//! The trimmed curve is defined by:
//! - the basis curve, and
//! - the two parameter values which limit it.
//! The trimmed curve can either have the same
//! orientation as the basis curve or the opposite orientation.
class Geom2d_TrimmedCurve : public Geom2d_BoundedCurve
{
public:
//! Creates a trimmed curve from the basis curve C limited between
//! U1 and U2.
//!
//! . U1 can be greater or lower than U2.
//! . The returned curve is oriented from U1 to U2.
//! . If the basis curve C is periodic there is an ambiguity
//! because two parts are available. In this case by default
//! the trimmed curve has the same orientation as the basis
//! curve (Sense = True). If Sense = False then the orientation
//! of the trimmed curve is opposite to the orientation of the
//! basis curve C.
//! If the curve is closed but not periodic it is not possible
//! to keep the part of the curve including the junction point
//! (except if the junction point is at the beginning or
//! at the end of the trimmed curve) because you could lose the
//! fundamental characteristics of the basis curve which are
//! used for example to compute the derivatives of the trimmed
//! curve. So for a closed curve the rules are the same as for
//! a open curve.
//! Warnings :
//! In this package the entities are not shared. The TrimmedCurve is
//! built with a copy of the curve C. So when C is modified the
//! TrimmedCurve is not modified
//! Warnings :
//! If <C> is periodic and <theAdjustPeriodic> is True, parametrics
//! bounds of the TrimmedCurve, can be different to [<U1>;<U2>},
//! if <U1> or <U2> are not in the principal period.
//! Include :
//! For more explanation see the scheme given with this class.
//! Raises ConstructionError the C is not periodic and U1 or U2 are out of
//! the bounds of C.
//! Raised if U1 = U2.
Standard_EXPORT Geom2d_TrimmedCurve(const Handle(Geom2d_Curve)& C, const Standard_Real U1, const Standard_Real U2, const Standard_Boolean Sense = Standard_True, const Standard_Boolean theAdjustPeriodic = Standard_True);
//! Changes the direction of parametrization of <me>. The first and
//! the last parametric values are modified. The "StartPoint"
//! of the initial curve becomes the "EndPoint" of the reversed
//! curve and the "EndPoint" of the initial curve becomes the
//! "StartPoint" of the reversed curve.
//! Example - If the trimmed curve is defined by:
//! - a basis curve whose parameter range is [ 0.,1. ], and
//! - the two trim values U1 (first parameter) and U2 (last parameter),
//! the reversed trimmed curve is defined by:
//! - the reversed basis curve, whose parameter range is still [ 0.,1. ], and
//! - the two trim values 1. - U2 (first parameter)
//! and 1. - U1 (last parameter).
Standard_EXPORT void Reverse();
//! Returns the parameter on the reversed curve for
//! the point of parameter U on <me>.
//!
//! returns UFirst + ULast - U
Standard_EXPORT Standard_Real ReversedParameter (const Standard_Real U) const;
//! Changes this trimmed curve, by redefining the
//! parameter values U1 and U2, which limit its basis curve.
//! Note: If the basis curve is periodic, the trimmed curve
//! has the same orientation as the basis curve if Sense
//! is true (default value) or the opposite orientation if Sense is false.
//! Warning
//! If the basis curve is periodic and theAdjustPeriodic is True,
//! the bounds of the trimmed curve may be different from U1 and U2 if the
//! parametric origin of the basis curve is within the arc
//! of the trimmed curve. In this case, the modified
//! parameter will be equal to U1 or U2 plus or minus the period.
//! If theAdjustPeriodic is False, parameters U1 and U2 will stay unchanged.
//! Exceptions
//! Standard_ConstructionError if:
//! - the basis curve is not periodic, and either U1 or U2
//! are outside the bounds of the basis curve, or
//! - U1 is equal to U2.
Standard_EXPORT void SetTrim (const Standard_Real U1, const Standard_Real U2, const Standard_Boolean Sense = Standard_True, const Standard_Boolean theAdjustPeriodic = Standard_True);
//! Returns the basis curve.
//! Warning
//! This function does not return a constant reference.
//! Consequently, any modification of the returned value
//! directly modifies the trimmed curve.
Standard_EXPORT Handle(Geom2d_Curve) BasisCurve() const;
//! Returns the global continuity of the basis curve of this trimmed curve.
//! C0 : only geometric continuity,
//! C1 : continuity of the first derivative all along the Curve,
//! C2 : continuity of the second derivative all along the Curve,
//! C3 : continuity of the third derivative all along the Curve,
//! CN : the order of continuity is infinite.
Standard_EXPORT GeomAbs_Shape Continuity() const;
//! --- Purpose
//! Returns True if the order of continuity of the
//! trimmed curve is N. A trimmed curve is at least "C0" continuous.
//! Warnings :
//! The continuity of the trimmed curve can be greater than
//! the continuity of the basis curve because you consider
//! only a part of the basis curve.
//! Raised if N < 0.
Standard_EXPORT Standard_Boolean IsCN (const Standard_Integer N) const;
//! Returns the end point of <me>. This point is the
//! evaluation of the curve for the "LastParameter".
Standard_EXPORT gp_Pnt2d EndPoint() const;
//! Returns the value of the first parameter of <me>.
//! The first parameter is the parameter of the "StartPoint"
//! of the trimmed curve.
Standard_EXPORT Standard_Real FirstParameter() const;
//! Returns True if the distance between the StartPoint and
//! the EndPoint is lower or equal to Resolution from package
//! gp.
Standard_EXPORT Standard_Boolean IsClosed() const;
//! Returns true if the basis curve of this trimmed curve is periodic.
Standard_EXPORT Standard_Boolean IsPeriodic() const;
//! Returns the period of the basis curve of this trimmed curve.
//! Exceptions
//! Standard_NoSuchObject if the basis curve is not periodic.
Standard_EXPORT virtual Standard_Real Period() const Standard_OVERRIDE;
//! Returns the value of the last parameter of <me>.
//! The last parameter is the parameter of the "EndPoint" of the
//! trimmed curve.
Standard_EXPORT Standard_Real LastParameter() const;
//! Returns the start point of <me>.
//! This point is the evaluation of the curve from the
//! "FirstParameter".
//! value and derivatives
//! Warnings :
//! The returned derivatives have the same orientation as the
//! derivatives of the basis curve.
Standard_EXPORT gp_Pnt2d StartPoint() const;
//! If the basis curve is an OffsetCurve sometimes it is not
//! possible to do the evaluation of the curve at the parameter
//! U (see class OffsetCurve).
Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt2d& P) const;
//! Raised if the continuity of the curve is not C1.
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1) const;
//! Raised if the continuity of the curve is not C2.
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const;
//! Raised if the continuity of the curve is not C3.
Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const;
//! For the point of parameter U of this trimmed curve,
//! computes the vector corresponding to the Nth derivative.
//! Warning
//! The returned derivative vector has the same
//! orientation as the derivative vector of the basis curve,
//! even if the trimmed curve does not have the same
//! orientation as the basis curve.
//! Exceptions
//! Standard_RangeError if N is less than 1.
//! geometric transformations
Standard_EXPORT gp_Vec2d DN (const Standard_Real U, const Standard_Integer N) const;
//! Applies the transformation T to this trimmed curve.
//! Warning The basis curve is also modified.
Standard_EXPORT void Transform (const gp_Trsf2d& T);
//! Returns the parameter on the transformed curve for
//! the transform of the point of parameter U on <me>.
//!
//! me->Transformed(T)->Value(me->TransformedParameter(U,T))
//!
//! is the same point as
//!
//! me->Value(U).Transformed(T)
//!
//! This methods calls the basis curve method.
Standard_EXPORT virtual Standard_Real TransformedParameter (const Standard_Real U, const gp_Trsf2d& T) const Standard_OVERRIDE;
//! Returns a coefficient to compute the parameter on
//! the transformed curve for the transform of the
//! point on <me>.
//!
//! Transformed(T)->Value(U * ParametricTransformation(T))
//!
//! is the same point as
//!
//! Value(U).Transformed(T)
//!
//! This methods calls the basis curve method.
Standard_EXPORT virtual Standard_Real ParametricTransformation (const gp_Trsf2d& T) const Standard_OVERRIDE;
//! Creates a new object, which is a copy of this trimmed curve.
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const;
DEFINE_STANDARD_RTTI(Geom2d_TrimmedCurve,Geom2d_BoundedCurve)
protected:
private:
Handle(Geom2d_Curve) basisCurve;
Standard_Real uTrim1;
Standard_Real uTrim2;
};
#endif // _Geom2d_TrimmedCurve_HeaderFile

37
src/Geom2d/Geom2d_UndefinedDerivative.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_UndefinedDerivative_HeaderFile
#define _Geom2d_UndefinedDerivative_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_DomainError.hxx>
class Geom2d_UndefinedDerivative;
DEFINE_STANDARD_HANDLE(Geom2d_UndefinedDerivative, Standard_DomainError)
#if !defined No_Exception && !defined No_Geom2d_UndefinedDerivative
#define Geom2d_UndefinedDerivative_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Geom2d_UndefinedDerivative::Raise(MESSAGE);
#else
#define Geom2d_UndefinedDerivative_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Geom2d_UndefinedDerivative, Standard_DomainError)
#endif // _Geom2d_UndefinedDerivative_HeaderFile

37
src/Geom2d/Geom2d_UndefinedValue.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_UndefinedValue_HeaderFile
#define _Geom2d_UndefinedValue_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_DomainError.hxx>
class Geom2d_UndefinedValue;
DEFINE_STANDARD_HANDLE(Geom2d_UndefinedValue, Standard_DomainError)
#if !defined No_Exception && !defined No_Geom2d_UndefinedValue
#define Geom2d_UndefinedValue_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Geom2d_UndefinedValue::Raise(MESSAGE);
#else
#define Geom2d_UndefinedValue_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Geom2d_UndefinedValue, Standard_DomainError)
#endif // _Geom2d_UndefinedValue_HeaderFile

93
src/Geom2d/Geom2d_Vector.cdl
View File

@@ -1,93 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 Vector from Geom2d inherits Geometry from Geom2d
--- Purpose : The abstract class Vector describes the common
-- behavior of vectors in 2D space.
-- The Geom2d package provides two concrete
-- classes of vectors: Geom2d_Direction (unit vector)
-- and Geom2d_VectorWithMagnitude.
uses Ax2d from gp,
Pnt2d from gp,
Vec2d from gp
raises DomainError from Standard,
VectorWithNullMagnitude from gp
is
Reverse (me : mutable);
--- Purpose : Reverses the vector <me>.
Reversed (me) returns like me
--- Purpose : Returns a copy of <me> reversed.
is static;
Angle (me; Other : Vector) returns Real
--- Purpose : Computes the angular value, in radians, between this
-- vector and vector Other. The result is a value
-- between -Pi and Pi. The orientation is from this
-- vector to vector Other.
-- Raises VectorWithNullMagnitude if one of the two vectors is a vector with
-- null magnitude because the angular value is indefinite.
raises VectorWithNullMagnitude;
Coord (me; X, Y : out Real);
--- Purpose : Returns the coordinates of <me>.
Magnitude (me) returns Real
--- Purpose : Returns the Magnitude of <me>.
is deferred;
SquareMagnitude (me) returns Real
--- Purpose : Returns the square magnitude of <me>.
is deferred;
X (me) returns Real;
--- Purpose : Returns the X coordinate of <me>.
Y (me) returns Real;
--- Purpose : Returns the Y coordinate of <me>.
Crossed (me; Other : Vector) returns Real
--- Purpose : Cross product of <me> with the vector <Other>.
is deferred;
Dot (me; Other : Vector) returns Real;
--- Purpose : Returns the scalar product of 2 Vectors.
Vec2d (me) returns Vec2d;
--- Purpose : Returns a non persistent copy of <me>.
fields
gpVec2d : Vec2d is protected;
end;

7
src/Geom2d/Geom2d_Vector.cxx
View File

@@ -14,7 +14,12 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_Vector.ixx>
#include <Geom2d_Vector.hxx>
#include <gp_Vec2d.hxx>
#include <gp_VectorWithNullMagnitude.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Vector Vector;
typedef gp_Ax2d Ax2d;

107
src/Geom2d/Geom2d_Vector.hxx Normal file
View File

@@ -0,0 +1,107 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_Vector_HeaderFile
#define _Geom2d_Vector_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <gp_Vec2d.hxx>
#include <Geom2d_Geometry.hxx>
#include <Standard_Real.hxx>
class Standard_DomainError;
class gp_VectorWithNullMagnitude;
class gp_Vec2d;
class Geom2d_Vector;
DEFINE_STANDARD_HANDLE(Geom2d_Vector, Geom2d_Geometry)
//! The abstract class Vector describes the common
//! behavior of vectors in 2D space.
//! The Geom2d package provides two concrete
//! classes of vectors: Geom2d_Direction (unit vector)
//! and Geom2d_VectorWithMagnitude.
class Geom2d_Vector : public Geom2d_Geometry
{
public:
//! Reverses the vector <me>.
Standard_EXPORT void Reverse();
//! Returns a copy of <me> reversed.
Standard_EXPORT Handle(Geom2d_Vector) Reversed() const;
//! Computes the angular value, in radians, between this
//! vector and vector Other. The result is a value
//! between -Pi and Pi. The orientation is from this
//! vector to vector Other.
//! Raises VectorWithNullMagnitude if one of the two vectors is a vector with
//! null magnitude because the angular value is indefinite.
Standard_EXPORT Standard_Real Angle (const Handle(Geom2d_Vector)& Other) const;
//! Returns the coordinates of <me>.
Standard_EXPORT void Coord (Standard_Real& X, Standard_Real& Y) const;
//! Returns the Magnitude of <me>.
Standard_EXPORT virtual Standard_Real Magnitude() const = 0;
//! Returns the square magnitude of <me>.
Standard_EXPORT virtual Standard_Real SquareMagnitude() const = 0;
//! Returns the X coordinate of <me>.
Standard_EXPORT Standard_Real X() const;
//! Returns the Y coordinate of <me>.
Standard_EXPORT Standard_Real Y() const;
//! Cross product of <me> with the vector <Other>.
Standard_EXPORT virtual Standard_Real Crossed (const Handle(Geom2d_Vector)& Other) const = 0;
//! Returns the scalar product of 2 Vectors.
Standard_EXPORT Standard_Real Dot (const Handle(Geom2d_Vector)& Other) const;
//! Returns a non persistent copy of <me>.
Standard_EXPORT gp_Vec2d Vec2d() const;
DEFINE_STANDARD_RTTI(Geom2d_Vector,Geom2d_Geometry)
protected:
gp_Vec2d gpVec2d;
private:
};
#endif // _Geom2d_Vector_HeaderFile

158
src/Geom2d/Geom2d_VectorWithMagnitude.cdl
View File

@@ -1,158 +0,0 @@
-- Created on: 1993-03-24
-- Created by: JCV
-- 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 VectorWithMagnitude from Geom2d inherits Vector from Geom2d
--- Purpose :
-- Defines a vector with magnitude.
-- A vector with magnitude can have a zero length.
uses Pnt2d from gp,
Trsf2d from gp,
Vec2d from gp,
Geometry from Geom2d
raises ConstructionError from Standard
is
Create (V : Vec2d) returns VectorWithMagnitude;
--- Purpose : Creates a persistent copy of V.
Create (X, Y : Real) returns VectorWithMagnitude;
--- Purpose : Creates a vector with two cartesian coordinates.
Create (P1, P2 : Pnt2d) returns VectorWithMagnitude;
--- Purpose :
-- Creates a vector from the point P1 to the point P2.
-- The magnitude of the vector is the distance between P1 and P2
SetCoord (me : mutable; X, Y : Real);
--- Purpose : Set <me> to X, Y coordinates.
SetVec2d (me : mutable; V : Vec2d);
-- Purpose : Set <me> to V.X(), V.Y() coordinates.
SetX (me : mutable; X : Real);
--- Purpose : Changes the X coordinate of <me>.
SetY (me : mutable; Y : Real);
--- Purpose : Changes the Y coordinate of <me>
Magnitude (me) returns Real;
--- Purpose : Returns the magnitude of <me>.
SquareMagnitude (me) returns Real;
--- Purpose : Returns the square magnitude of <me>.
Add (me : mutable; Other : Vector);
--- Purpose :
-- Adds the Vector Other to <me>.
---C++: alias operator +=
Added (me; Other : Vector) returns VectorWithMagnitude
--- Purpose :
-- Adds the vector Other to <me>.
---C++: alias operator +
is static;
Crossed (me; Other : Vector) returns Real;
--- Purpose :
-- Computes the cross product between <me> and Other
-- <me> ^ Other. A new vector is returned.
---C++: alias operator ^
Divide (me : mutable; Scalar : Real);
--- Purpose : Divides <me> by a scalar.
---C++: alias operator /=
Divided (me; Scalar : Real) returns VectorWithMagnitude
--- Purpose :
-- Divides <me> by a scalar. A new vector is returned.
---C++: alias operator /
is static;
Multiplied (me; Scalar : Real) returns VectorWithMagnitude
--- Purpose :
-- Computes the product of the vector <me> by a scalar.
-- A new vector is returned.
--
-- -C++: alias operator *
-- Collision with same operator defined for the class Vector!
is static;
Multiply (me : mutable; Scalar : Real);
--- Purpose :
-- Computes the product of the vector <me> by a scalar.
---C++: alias operator *=
Normalize (me : mutable)
--- Purpose : Normalizes <me>.
raises ConstructionError;
--- Purpose :
-- Raised if the magnitude of the vector is lower or equal to
-- Resolution from package gp.
Normalized (me) returns VectorWithMagnitude
--- Purpose : Returns a copy of <me> Normalized.
raises ConstructionError
--- Purpose :
-- Raised if the magnitude of the vector is lower or equal to
-- Resolution from package gp.
is static;
Subtract (me : mutable; Other : Vector);
--- Purpose : Subtracts the Vector Other to <me>.
---C++: alias operator -=
Subtracted (me; Other : Vector) returns VectorWithMagnitude
--- Purpose :
-- Subtracts the vector Other to <me>. A new vector is returned.
---C++: alias operator -
is static;
Transform (me: mutable; T : Trsf2d);
---Purpose: Applies the transformation T to this vector.
Copy (me) returns like me;
--- Purpose: Creates a new object which is a copy of this vector.
end;

9
src/Geom2d/Geom2d_VectorWithMagnitude.cxx
View File

@@ -14,8 +14,15 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Geom2d_VectorWithMagnitude.ixx>
#include <Geom2d_Geometry.hxx>
#include <Geom2d_Vector.hxx>
#include <Geom2d_VectorWithMagnitude.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Vec2d.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_Type.hxx>
typedef Geom2d_Vector Vector;
typedef Geom2d_VectorWithMagnitude VectorWithMagnitude;

185
src/Geom2d/Geom2d_VectorWithMagnitude.hxx Normal file
View File

@@ -0,0 +1,185 @@
// Created on: 1993-03-24
// Created by: JCV
// 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.
#ifndef _Geom2d_VectorWithMagnitude_HeaderFile
#define _Geom2d_VectorWithMagnitude_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Geom2d_Vector.hxx>
#include <Standard_Real.hxx>
class Standard_ConstructionError;
class gp_Vec2d;
class gp_Pnt2d;
class Geom2d_Vector;
class gp_Trsf2d;
class Geom2d_Geometry;
class Geom2d_VectorWithMagnitude;
DEFINE_STANDARD_HANDLE(Geom2d_VectorWithMagnitude, Geom2d_Vector)
//! Defines a vector with magnitude.
//! A vector with magnitude can have a zero length.
class Geom2d_VectorWithMagnitude : public Geom2d_Vector
{
public:
//! Creates a persistent copy of V.
Standard_EXPORT Geom2d_VectorWithMagnitude(const gp_Vec2d& V);
//! Creates a vector with two cartesian coordinates.
Standard_EXPORT Geom2d_VectorWithMagnitude(const Standard_Real X, const Standard_Real Y);
//! Creates a vector from the point P1 to the point P2.
//! The magnitude of the vector is the distance between P1 and P2
Standard_EXPORT Geom2d_VectorWithMagnitude(const gp_Pnt2d& P1, const gp_Pnt2d& P2);
//! Set <me> to X, Y coordinates.
Standard_EXPORT void SetCoord (const Standard_Real X, const Standard_Real Y);
Standard_EXPORT void SetVec2d (const gp_Vec2d& V);
//! Changes the X coordinate of <me>.
Standard_EXPORT void SetX (const Standard_Real X);
//! Changes the Y coordinate of <me>
Standard_EXPORT void SetY (const Standard_Real Y);
//! Returns the magnitude of <me>.
Standard_EXPORT Standard_Real Magnitude() const;
//! Returns the square magnitude of <me>.
Standard_EXPORT Standard_Real SquareMagnitude() const;
//! Adds the Vector Other to <me>.
Standard_EXPORT void Add (const Handle(Geom2d_Vector)& Other);
void operator += (const Handle(Geom2d_Vector)& Other)
{
Add(Other);
}
//! Adds the vector Other to <me>.
Standard_EXPORT Handle(Geom2d_VectorWithMagnitude) Added (const Handle(Geom2d_Vector)& Other) const;
Handle(Geom2d_VectorWithMagnitude) operator + (const Handle(Geom2d_Vector)& Other) const
{
return Added(Other);
}
//! Computes the cross product between <me> and Other
//! <me> ^ Other. A new vector is returned.
Standard_EXPORT Standard_Real Crossed (const Handle(Geom2d_Vector)& Other) const;
Standard_Real operator ^ (const Handle(Geom2d_Vector)& Other) const
{
return Crossed(Other);
}
//! Divides <me> by a scalar.
Standard_EXPORT void Divide (const Standard_Real Scalar);
void operator /= (const Standard_Real Scalar)
{
Divide(Scalar);
}
//! Divides <me> by a scalar. A new vector is returned.
Standard_EXPORT Handle(Geom2d_VectorWithMagnitude) Divided (const Standard_Real Scalar) const;
Handle(Geom2d_VectorWithMagnitude) operator / (const Standard_Real Scalar) const
{
return Divided(Scalar);
}
//! Computes the product of the vector <me> by a scalar.
//! A new vector is returned.
//!
//! -C++: alias operator *
//! Collision with same operator defined for the class Vector!
Standard_EXPORT Handle(Geom2d_VectorWithMagnitude) Multiplied (const Standard_Real Scalar) const;
//! Computes the product of the vector <me> by a scalar.
Standard_EXPORT void Multiply (const Standard_Real Scalar);
void operator *= (const Standard_Real Scalar)
{
Multiply(Scalar);
}
//! Normalizes <me>.
//!
//! Raised if the magnitude of the vector is lower or equal to
//! Resolution from package gp.
Standard_EXPORT void Normalize();
//! Returns a copy of <me> Normalized.
//!
//! Raised if the magnitude of the vector is lower or equal to
//! Resolution from package gp.
Standard_EXPORT Handle(Geom2d_VectorWithMagnitude) Normalized() const;
//! Subtracts the Vector Other to <me>.
Standard_EXPORT void Subtract (const Handle(Geom2d_Vector)& Other);
void operator -= (const Handle(Geom2d_Vector)& Other)
{
Subtract(Other);
}
//! Subtracts the vector Other to <me>. A new vector is returned.
Standard_EXPORT Handle(Geom2d_VectorWithMagnitude) Subtracted (const Handle(Geom2d_Vector)& Other) const;
Handle(Geom2d_VectorWithMagnitude) operator - (const Handle(Geom2d_Vector)& Other) const
{
return Subtracted(Other);
}
//! Applies the transformation T to this vector.
Standard_EXPORT void Transform (const gp_Trsf2d& T);
//! Creates a new object which is a copy of this vector.
Standard_EXPORT Handle(Geom2d_Geometry) Copy() const;
DEFINE_STANDARD_RTTI(Geom2d_VectorWithMagnitude,Geom2d_Vector)
protected:
private:
};
#endif // _Geom2d_VectorWithMagnitude_HeaderFile