Added @code tags to documentation of several classes in the package gp.
//! This coordinate system is the "local coordinate system"
//! of the ellipse. In this coordinate system, the equation of
//! the ellipse is:
+//! @code
//! X*X / (MajorRadius**2) + Y*Y / (MinorRadius**2) = 1.0
+//! @endcode
//! The "main Direction" of the local coordinate system gives
//! the normal vector to the plane of the ellipse. This vector
//! gives an implicit orientation to the ellipse (definition of the
//! of the ellipse. Its orientation (direct or indirect) gives an
//! implicit orientation to the ellipse. In this coordinate
//! system, the equation of the ellipse is:
+//! @code
//! X*X / (MajorRadius**2) + Y*Y / (MinorRadius**2) = 1.0
+//! @endcode
//! See Also
//! gce_MakeElips2d which provides functions for more
//! complex ellipse constructions
//! Defines a non-persistent transformation in 3D space.
//! This transformation is a general transformation.
-//! It can be a Trsf from gp, an affinity, or you can define
+//! It can be a gp_Trsf, an affinity, or you can define
//! your own transformation giving the matrix of transformation.
//!
-//! With a Gtrsf you can transform only a triplet of coordinates
-//! XYZ. It is not possible to transform other geometric objects
-//! because these transformations can change the nature of non-
-//! elementary geometric objects.
-//! The transformation GTrsf can be represented as follow :
-//!
-//! V1 V2 V3 T XYZ XYZ
+//! With a gp_GTrsf you can transform only a triplet of coordinates gp_XYZ.
+//! It is not possible to transform other geometric objects
+//! because these transformations can change the nature of non-elementary geometric objects.
+//! The transformation gp_GTrsf can be represented as follow:
+//! @code
+//! V1 V2 V3 T XYZ XYZ
//! | a11 a12 a13 a14 | | x | | x'|
//! | a21 a22 a23 a24 | | y | | y'|
//! | a31 a32 a33 a34 | | z | = | z'|
//! | 0 0 0 1 | | 1 | | 1 |
-//!
+//! @endcode
//! where {V1, V2, V3} define the vectorial part of the
-//! transformation and T defines the translation part of the
-//! transformation.
+//! transformation and T defines the translation part of the transformation.
//! Warning
-//! A GTrsf transformation is only applicable to
-//! coordinates. Be careful if you apply such a
-//! transformation to all points of a geometric object, as
-//! this can change the nature of the object and thus
-//! render it incoherent!
-//! Typically, a circle is transformed into an ellipse by an
-//! affinity transformation. To avoid modifying the nature of
-//! an object, use a gp_Trsf transformation instead, as
-//! objects of this class respect the nature of geometric objects.
+//! A gp_GTrsf transformation is only applicable to coordinates.
+//! Be careful if you apply such a transformation to all points of a geometric object,
+//! as this can change the nature of the object and thus render it incoherent!
+//! Typically, a circle is transformed into an ellipse by an affinity transformation.
+//! To avoid modifying the nature of an object, use a gp_Trsf transformation instead,
+//! as objects of this class respect the nature of geometric objects.
class gp_GTrsf
{
public:
//! verify and set the shape of the GTrsf Other or CompoundTrsf
//! Ex :
+ //! @code
//! myGTrsf.SetValue(row1,col1,val1);
//! myGTrsf.SetValue(row2,col2,val2);
//! ...
//! myGTrsf.SetForm();
+ //! @endcode
Standard_EXPORT void SetForm();
//! Returns the translation part of the GTrsf.
//! Computes the transformation composed from T and <me>.
//! In a C++ implementation you can also write Tcomposed = <me> * T.
//! Example :
- //! GTrsf T1, T2, Tcomp; ...............
+ //! @code
+ //! gp_GTrsf T1, T2, Tcomp; ...............
//! //composition :
//! Tcomp = T2.Multiplied(T1); // or (Tcomp = T2 * T1)
//! // transformation of a point
- //! XYZ P(10.,3.,4.);
- //! XYZ P1(P);
+ //! gp_XYZ P(10.,3.,4.);
+ //! gp_XYZ P1(P);
//! Tcomp.Transforms(P1); //using Tcomp
- //! XYZ P2(P);
+ //! gp_XYZ P2(P);
//! T1.Transforms(P2); //using T1 then T2
//! T2.Transforms(P2); // P1 = P2 !!!
+ //! @endcode
Standard_NODISCARD gp_GTrsf Multiplied (const gp_GTrsf& T) const;
Standard_NODISCARD gp_GTrsf operator * (const gp_GTrsf& T) const
{
//! Defines a non persistent transformation in 2D space.
//! This transformation is a general transformation.
-//! It can be a Trsf2d from package gp, an affinity, or you can
-//! define your own transformation giving the corresponding
-//! matrix of transformation.
+//! It can be a gp_Trsf2d, an affinity, or you can
+//! define your own transformation giving the corresponding matrix of transformation.
//!
-//! With a GTrsf2d you can transform only a doublet of coordinates
-//! XY. It is not possible to transform other geometric objects
-//! because these transformations can change the nature of non-
-//! elementary geometric objects.
-//! A GTrsf2d is represented with a 2 rows * 3 columns matrix :
-//!
-//! V1 V2 T XY XY
+//! With a gp_GTrsf2d you can transform only a doublet of coordinates gp_XY.
+//! It is not possible to transform other geometric objects
+//! because these transformations can change the nature of non-elementary geometric objects.
+//! A gp_GTrsf2d is represented with a 2 rows * 3 columns matrix:
+//! @code
+//! V1 V2 T XY XY
//! | a11 a12 a14 | | x | | x'|
-//! | a21 a22 a24 | | y | | y'|
+//! | a21 a22 a24 | | y | = | y'|
//! | 0 0 1 | | 1 | | 1 |
-//!
+//! @endcode
//! where {V1, V2} defines the vectorial part of the
-//! transformation and T defines the translation part of
-//! the transformation.
+//! transformation and T defines the translation part of the transformation.
//! Warning
-//! A GTrsf2d transformation is only applicable on
-//! coordinates. Be careful if you apply such a
-//! transformation to all the points of a geometric object,
-//! as this can change the nature of the object and thus
-//! render it incoherent!
-//! Typically, a circle is transformed into an ellipse by an
-//! affinity transformation. To avoid modifying the nature of
-//! an object, use a gp_Trsf2d transformation instead, as
-//! objects of this class respect the nature of geometric objects.
+//! A gp_GTrsf2d transformation is only applicable on coordinates.
+//! Be careful if you apply such a transformation to all the points of a geometric object,
+//! as this can change the nature of the object and thus render it incoherent!
+//! Typically, a circle is transformed into an ellipse by an affinity transformation.
+//! To avoid modifying the nature of an object, use a gp_Trsf2d transformation instead,
+//! as objects of this class respect the nature of geometric objects.
class gp_GTrsf2d
{
public:
//! Raises OutOfRange if Row < 1 or Row > 2 or Col < 1 or Col > 3
void SetValue (const Standard_Integer Row, const Standard_Integer Col, const Standard_Real Value);
- //! Replacesthe translation part of this
+ //! Replaces the translation part of this
//! transformation by the coordinates of the number pair Coord.
Standard_EXPORT void SetTranslationPart (const gp_XY& Coord);
//! Computes the transformation composed with T and <me>.
//! In a C++ implementation you can also write Tcomposed = <me> * T.
//! Example :
- //! GTrsf2d T1, T2, Tcomp; ...............
+ //! @code
+ //! gp_GTrsf2d T1, T2, Tcomp; ...............
//! //composition :
//! Tcomp = T2.Multiplied(T1); // or (Tcomp = T2 * T1)
//! // transformation of a point
- //! XY P(10.,3.);
- //! XY P1(P);
+ //! gp_XY P(10.,3.);
+ //! gp_XY P1(P);
//! Tcomp.Transforms(P1); //using Tcomp
- //! XY P2(P);
+ //! gp_XY P2(P);
//! T1.Transforms(P2); //using T1 then T2
//! T2.Transforms(P2); // P1 = P2 !!!
+ //! @endcode
Standard_NODISCARD gp_GTrsf2d Multiplied (const gp_GTrsf2d& T) const;
Standard_NODISCARD gp_GTrsf2d operator * (const gp_GTrsf2d& T) const
{
//! and in it, the respective positions of the three branches of
//! hyperbolas constructed with the functions OtherBranch,
//! ConjugateBranch1, and ConjugateBranch2:
-//!
+//! @code
//! ^YAxis
//! |
//! FirstConjugateBranch
//! |
//! SecondConjugateBranch
//! | ^YAxis
+//! @endcode
//! Warning
//! The major radius can be less than the minor radius.
//! See Also
//! and in it, the respective positions of the three branches of
//! hyperbolas constructed with the functions OtherBranch,
//! ConjugateBranch1, and ConjugateBranch2:
+//! @code
//! ^YAxis
//! |
//! FirstConjugateBranch
//! |
//! SecondConjugateBranch
//! |
-//!
+//! @endcode
//! Warning
//! The major radius can be less than the minor radius.
//! See Also
//! Modifies the main diagonal of the matrix.
+ //! @code
//! <me>.Value (1, 1) = X1
//! <me>.Value (2, 2) = X2
//! <me>.Value (3, 3) = X3
+ //! @endcode
//! The other coefficients of the matrix are not modified.
void SetDiagonal (const Standard_Real X1, const Standard_Real X2, const Standard_Real X3);
//! Modifies the matrix so that it represents
//! a scaling transformation, where S is the scale factor. :
- //! | S 0.0 0.0 |
+ //! @code
+ //! | S 0.0 0.0 |
//! <me> = | 0.0 S 0.0 |
- //! | 0.0 0.0 S |
+ //! | 0.0 0.0 S |
+ //! @endcode
void SetScale (const Standard_Real S);
//! Assigns <Value> to the coefficient of row Row, column Col of this matrix.
//! Modifies the main diagonal of the matrix.
+ //! @code
//! <me>.Value (1, 1) = X1
//! <me>.Value (2, 2) = X2
+ //! @endcode
//! The other coefficients of the matrix are not modified.
void SetDiagonal (const Standard_Real X1, const Standard_Real X2);
void SetIdentity();
- //! Modifies this matrix, so that it representso a rotation. Ang is the angular
+ //! Modifies this matrix, so that it represents a rotation. Ang is the angular
//! value in radian of the rotation.
void SetRotation (const Standard_Real Ang);
//! Modifies the matrix such that it
//! represents a scaling transformation, where S is the scale factor :
- //! | S 0.0 |
+ //! @code
+ //! | S 0.0 |
//! <me> = | 0.0 S |
+ //! @endcode
void SetScale (const Standard_Real S);
//! Assigns <Value> to the coefficient of row Row, column Col of this matrix.
//! Computes the sum of this matrix and the matrix
//! Other.for each coefficient of the matrix :
+ //! @code
//! <me>.Coef(i,j) + <Other>.Coef(i,j)
+ //! @endcode
//! Note:
//! - operator += assigns the result to this matrix, while
//! - operator + creates a new one.
//! Computes for each coefficient of the matrix :
+ //! @code
//! <me>.Coef(i,j) - <Other>.Coef(i,j)
+ //! @endcode
Standard_NODISCARD gp_Mat2d Subtracted (const gp_Mat2d& Other) const;
Standard_NODISCARD gp_Mat2d operator - (const gp_Mat2d& Other) const
{
//! coordinate system define the plane of the parabola.
//! The equation of the parabola in this coordinate system,
//! which is the "local coordinate system" of the parabola, is:
+//! @code
//! Y**2 = (2*P) * X.
+//! @endcode
//! where P, referred to as the parameter of the parabola, is
//! the distance between the focus and the directrix (P is
//! twice the focal length).
//! of the parabola. Its orientation (direct or indirect sense)
//! gives an implicit orientation to the parabola.
//! In this coordinate system, the equation for the parabola is:
+//! @code
//! Y**2 = (2*P) * X.
+//! @endcode
//! where P, referred to as the parameter of the parabola, is
//! the distance between the focus and the directrix (P is
//! twice the focal length).
//! Computes the coefficients of the implicit equation of the parabola
//! (in WCS - World Coordinate System).
+ //! @code
//! A * (X**2) + B * (Y**2) + 2*C*(X*Y) + 2*D*X + 2*E*Y + F = 0.
+ //! @endcode
Standard_EXPORT void Coefficients (Standard_Real& A, Standard_Real& B,
Standard_Real& C, Standard_Real& D,
Standard_Real& E, Standard_Real& F) const;
//! Creates a plane from its cartesian equation :
+ //! @code
//! A * X + B * Y + C * Z + D = 0.0
+ //! @endcode
//! Raises ConstructionError if Sqrt (A*A + B*B + C*C) <= Resolution from gp.
Standard_EXPORT gp_Pln(const Standard_Real A, const Standard_Real B, const Standard_Real C, const Standard_Real D);
//! Returns the coefficients of the plane's cartesian equation :
+ //! @code
//! A * X + B * Y + C * Z + D = 0.
+ //! @endcode
void Coefficients (Standard_Real& A, Standard_Real& B, Standard_Real& C, Standard_Real& D) const;
//! Modifies this plane, by redefining its local coordinate system so that
class gp_Mat;
-//! Represents operation of rotation in 3d space as queternion
+//! Represents operation of rotation in 3d space as quaternion
//! and implements operations with rotations basing on
//! quaternion mathematics.
//!
//! In addition, provides methods for conversion to and from other
-//! representatons of rotation (3*3 matrix, vector and
+//! representations of rotation (3*3 matrix, vector and
//! angle, Euler angles)
class gp_Quaternion
{
}
//! Multiply function - work the same as Matrices multiplying.
+ //! @code
//! qq' = (cross(v,v') + wv' + w'v, ww' - dot(v,v'))
+ //! @endcode
//! Result is rotation combination: q' than q (here q=this, q'=theQ).
- //! Notices than:
+ //! Notices that:
+ //! @code
//! qq' != q'q;
//! qq^-1 = q;
+ //! @endcode
Standard_NODISCARD gp_Quaternion Multiplied (const gp_Quaternion& theOther) const;
Standard_NODISCARD gp_Quaternion operator * (const gp_Quaternion& theOther) const
{
return Multiplied(theOther);
}
- //! Adds componnets of other quaternion; result is "rotations mix"
+ //! Adds components of other quaternion; result is "rotations mix"
void Add (const gp_Quaternion& theOther);
void operator += (const gp_Quaternion& theOther)
{
Add(theOther);
}
- //! Subtracts componnets of other quaternion; result is "rotations mix"
+ //! Subtracts components of other quaternion; result is "rotations mix"
void Subtract (const gp_Quaternion& theOther);
void operator -= (const gp_Quaternion& theOther)
{
void SetRadius (const Standard_Real R);
- //! Computes the aera of the sphere.
+ //! Computes the area of the sphere.
Standard_Real Area() const;
//! Computes the coefficients of the implicit equation of the quadric
//! in the absolute cartesian coordinates system :
+ //! @code
//! A1.X**2 + A2.Y**2 + A3.Z**2 + 2.(B1.X.Y + B2.X.Z + B3.Y.Z) +
//! 2.(C1.X + C2.Y + C3.Z) + D = 0.0
+ //! @endcode
Standard_EXPORT void Coefficients (Standard_Real& A1, Standard_Real& A2, Standard_Real& A3, Standard_Real& B1, Standard_Real& B2, Standard_Real& B3, Standard_Real& C1, Standard_Real& C2, Standard_Real& C3, Standard_Real& D) const;
//! Reverses the U parametrization of the sphere
//! Computes the coefficients of the implicit equation of the surface
//! in the absolute Cartesian coordinate system:
+ //! @code
//! Coef(1) * X^4 + Coef(2) * Y^4 + Coef(3) * Z^4 +
//! Coef(4) * X^3 * Y + Coef(5) * X^3 * Z + Coef(6) * Y^3 * X +
//! Coef(7) * Y^3 * Z + Coef(8) * Z^3 * X + Coef(9) * Z^3 * Y +
//! Coef(29) * X * Y + Coef(30) * X * Z + Coef(31) * Y * Z +
//! Coef(32) * X + Coef(33) * Y + Coef(34) * Z +
//! Coef(35) = 0.0
+ //! @endcode
//! Raises DimensionError if the length of Coef is lower than 35.
Standard_EXPORT void Coefficients (TColStd_Array1OfReal& Coef) const;
//! previous elementary transformations using the method
//! Multiply.
//! The transformations can be represented as follow :
-//!
-//! V1 V2 V3 T XYZ XYZ
+//! @code
+//! V1 V2 V3 T XYZ XYZ
//! | a11 a12 a13 a14 | | x | | x'|
//! | a21 a22 a23 a24 | | y | | y'|
//! | a31 a32 a33 a34 | | z | = | z'|
//! | 0 0 0 1 | | 1 | | 1 |
-//!
+//! @endcode
//! where {V1, V2, V3} defines the vectorial part of the
//! transformation and T defines the translation part of the
//! transformation.
//! The transformation is from the coordinate
//! system "FromSystem1" to the coordinate system "ToSystem2".
//! Example :
- //! In a C++ implementation :
- //! Real x1, y1, z1; // are the coordinates of a point in the
- //! // local system FromSystem1
- //! Real x2, y2, z2; // are the coordinates of a point in the
- //! // local system ToSystem2
+ //! @code
+ //! gp_Ax3 FromSystem1, ToSystem2;
+ //! double x1, y1, z1; // are the coordinates of a point in the local system FromSystem1
+ //! double x2, y2, z2; // are the coordinates of a point in the local system ToSystem2
//! gp_Pnt P1 (x1, y1, z1)
- //! Trsf T;
+ //! gp_Trsf T;
//! T.SetTransformation (FromSystem1, ToSystem2);
//! gp_Pnt P2 = P1.Transformed (T);
//! P2.Coord (x2, y2, z2);
+ //! @endcode
Standard_EXPORT void SetTransformation (const gp_Ax3& FromSystem1, const gp_Ax3& ToSystem2);
//! Modifies this transformation so that it transforms the
//! are relative to a target coordinate system, but which
//! represent the same point
//! The transformation is from the default coordinate system
+ //! @code
//! {P(0.,0.,0.), VX (1.,0.,0.), VY (0.,1.,0.), VZ (0., 0. ,1.) }
+ //! @endcode
//! to the local coordinate system defined with the Ax3 ToSystem.
//! Use in the same way as the previous method. FromSystem1 is
//! defaulted to the absolute coordinate system.
//! Sets the coefficients of the transformation. The
//! transformation of the point x,y,z is the point
//! x',y',z' with :
- //!
+ //! @code
//! x' = a11 x + a12 y + a13 z + a14
//! y' = a21 x + a22 y + a23 z + a24
//! z' = a31 x + a32 y + a33 z + a34
- //!
+ //! @endcode
//! The method Value(i,j) will return aij.
//! Raises ConstructionError if the determinant of the aij is null.
//! The matrix is orthogonalized before future using.
//! Computes the transformation composed with T and <me>.
//! In a C++ implementation you can also write Tcomposed = <me> * T.
//! Example :
- //! Trsf T1, T2, Tcomp; ...............
+ //! @code
+ //! gp_Trsf T1, T2, Tcomp; ...............
//! Tcomp = T2.Multiplied(T1); // or (Tcomp = T2 * T1)
- //! Pnt P1(10.,3.,4.);
- //! Pnt P2 = P1.Transformed(Tcomp); //using Tcomp
- //! Pnt P3 = P1.Transformed(T1); //using T1 then T2
+ //! gp_Pnt P1(10.,3.,4.);
+ //! gp_Pnt P2 = P1.Transformed(Tcomp); // using Tcomp
+ //! gp_Pnt P3 = P1.Transformed(T1); // using T1 then T2
//! P3.Transform(T2); // P3 = P2 !!!
+ //! @endcode
Standard_NODISCARD gp_Trsf Inverted() const;
Standard_NODISCARD gp_Trsf Multiplied (const gp_Trsf& T) const;
//! Defines a non-persistent transformation in 2D space.
//! The following transformations are implemented :
-//! . Translation, Rotation, Scale
-//! . Symmetry with respect to a point and a line.
+//! - Translation, Rotation, Scale
+//! - Symmetry with respect to a point and a line.
//! Complex transformations can be obtained by combining the
//! previous elementary transformations using the method Multiply.
//! The transformations can be represented as follow :
-//!
-//! V1 V2 T XY XY
+//! @code
+//! V1 V2 T XY XY
//! | a11 a12 a13 | | x | | x'|
//! | a21 a22 a23 | | y | | y'|
//! | 0 0 1 | | 1 | | 1 |
-//!
+//! @endcode
//! where {V1, V2} defines the vectorial part of the transformation
//! and T defines the translation part of the transformation.
//! This transformation never change the nature of the objects.
//! Sets the coefficients of the transformation. The
//! transformation of the point x,y is the point
//! x',y' with :
- //!
+ //! @code
//! x' = a11 x + a12 y + a13
//! y' = a21 x + a22 y + a23
- //!
+ //! @endcode
//! The method Value(i,j) will return aij.
//! Raises ConstructionError if the determinant of the aij is null.
//! If the matrix as not a uniform scale it will be orthogonalized before future using.
Standard_EXPORT Standard_Boolean IsEqual (const gp_XY& Other, const Standard_Real Tolerance) const;
//! Computes the sum of this number pair and number pair Other
+ //! @code
//! <me>.X() = <me>.X() + Other.X()
//! <me>.Y() = <me>.Y() + Other.Y()
+ //! @endcode
void Add (const gp_XY& Other);
void operator += (const gp_XY& Other)
{
}
//! Computes the sum of this number pair and number pair Other
+ //! @code
//! new.X() = <me>.X() + Other.X()
//! new.Y() = <me>.Y() + Other.Y()
+ //! @endcode
Standard_NODISCARD gp_XY Added (const gp_XY& Other) const;
Standard_NODISCARD gp_XY operator + (const gp_XY& Other) const
{
}
- //! Real D = <me>.X() * Other.Y() - <me>.Y() * Other.X()
+ //! @code
+ //! double D = <me>.X() * Other.Y() - <me>.Y() * Other.X()
+ //! @endcode
Standard_NODISCARD Standard_Real Crossed (const gp_XY& Right) const;
Standard_NODISCARD Standard_Real operator ^ (const gp_XY& Right) const
{
}
+ //! @code
//! <me>.X() = <me>.X() * Scalar;
//! <me>.Y() = <me>.Y() * Scalar;
+ //! @endcode
void Multiply (const Standard_Real Scalar);
void operator *= (const Standard_Real Scalar)
{
Multiply(Scalar);
}
-
+ //! @code
//! <me>.X() = <me>.X() * Other.X();
//! <me>.Y() = <me>.Y() * Other.Y();
+ //! @endcode
void Multiply (const gp_XY& Other);
void operator *= (const gp_XY& Other)
{
Multiply(Other);
}
-
+
+ //! @code
//! <me> = Matrix * <me>
+ //! @endcode
void Multiply (const gp_Mat2d& Matrix);
void operator *= (const gp_Mat2d& Matrix)
{
Multiply(Matrix);
}
-
+ //! @code
//! New.X() = <me>.X() * Scalar;
//! New.Y() = <me>.Y() * Scalar;
+ //! @endcode
Standard_NODISCARD gp_XY Multiplied (const Standard_Real Scalar) const;
Standard_NODISCARD gp_XY operator * (const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}
-
+ //! @code
//! new.X() = <me>.X() * Other.X();
//! new.Y() = <me>.Y() * Other.Y();
+ //! @endcode
Standard_NODISCARD gp_XY Multiplied (const gp_XY& Other) const;
-
+
+ //! @code
//! New = Matrix * <me>
+ //! @endcode
Standard_NODISCARD gp_XY Multiplied (const gp_Mat2d& Matrix) const;
Standard_NODISCARD gp_XY operator * (const gp_Mat2d& Matrix) const
{
return Multiplied(Matrix);
}
-
+ //! @code
//! <me>.X() = <me>.X()/ <me>.Modulus()
//! <me>.Y() = <me>.Y()/ <me>.Modulus()
+ //! @endcode
//! Raises ConstructionError if <me>.Modulus() <= Resolution from gp
void Normalize();
-
+ //! @code
//! New.X() = <me>.X()/ <me>.Modulus()
//! New.Y() = <me>.Y()/ <me>.Modulus()
+ //! @endcode
//! Raises ConstructionError if <me>.Modulus() <= Resolution from gp
Standard_NODISCARD gp_XY Normalized() const;
-
+ //! @code
//! <me>.X() = -<me>.X()
//! <me>.Y() = -<me>.Y()
+ //! @endcode
void Reverse();
-
+ //! @code
//! New.X() = -<me>.X()
//! New.Y() = -<me>.Y()
+ //! @endcode
Standard_NODISCARD gp_XY Reversed() const;
Standard_NODISCARD gp_XY operator -() const
{
//! Computes the following linear combination and
//! assigns the result to this number pair:
+ //! @code
//! A1 * XY1 + A2 * XY2
+ //! @endcode
void SetLinearForm (const Standard_Real A1, const gp_XY& XY1, const Standard_Real A2, const gp_XY& XY2);
//! -- Computes the following linear combination and
//! assigns the result to this number pair:
+ //! @code
//! A1 * XY1 + A2 * XY2 + XY3
+ //! @endcode
void SetLinearForm (const Standard_Real A1, const gp_XY& XY1, const Standard_Real A2, const gp_XY& XY2, const gp_XY& XY3);
//! Computes the following linear combination and
//! assigns the result to this number pair:
+ //! @code
//! A1 * XY1 + XY2
+ //! @endcode
void SetLinearForm (const Standard_Real A1, const gp_XY& XY1, const gp_XY& XY2);
//! Computes the following linear combination and
//! assigns the result to this number pair:
+ //! @code
//! XY1 + XY2
+ //! @endcode
void SetLinearForm (const gp_XY& XY1, const gp_XY& XY2);
-
+ //! @code
//! <me>.X() = <me>.X() - Other.X()
//! <me>.Y() = <me>.Y() - Other.Y()
+ //! @endcode
void Subtract (const gp_XY& Right);
void operator -= (const gp_XY& Right)
{
Subtract(Right);
}
-
+ //! @code
//! new.X() = <me>.X() - Other.X()
//! new.Y() = <me>.Y() - Other.Y()
+ //! @endcode
Standard_NODISCARD gp_XY Subtracted (const gp_XY& Right) const;
Standard_NODISCARD gp_XY operator - (const gp_XY& Right) const
{
//! abs(<me>.Z() - Other.Z()) <= Tolerance.
Standard_EXPORT Standard_Boolean IsEqual (const gp_XYZ& Other, const Standard_Real Tolerance) const;
-
+ //! @code
//! <me>.X() = <me>.X() + Other.X()
//! <me>.Y() = <me>.Y() + Other.Y()
//! <me>.Z() = <me>.Z() + Other.Z()
+ //! @endcode
void Add (const gp_XYZ& Other);
void operator += (const gp_XYZ& Other)
{
Add(Other);
}
-
+ //! @code
//! new.X() = <me>.X() + Other.X()
//! new.Y() = <me>.Y() + Other.Y()
//! new.Z() = <me>.Z() + Other.Z()
+ //! @endcode
Standard_NODISCARD gp_XYZ Added (const gp_XYZ& Other) const;
Standard_NODISCARD gp_XYZ operator + (const gp_XYZ& Other) const
{
return Added(Other);
}
-
+ //! @code
//! <me>.X() = <me>.Y() * Other.Z() - <me>.Z() * Other.Y()
//! <me>.Y() = <me>.Z() * Other.X() - <me>.X() * Other.Z()
//! <me>.Z() = <me>.X() * Other.Y() - <me>.Y() * Other.X()
+ //! @endcode
void Cross (const gp_XYZ& Right);
void operator ^= (const gp_XYZ& Right)
{
Cross(Right);
}
-
+ //! @code
//! new.X() = <me>.Y() * Other.Z() - <me>.Z() * Other.Y()
//! new.Y() = <me>.Z() * Other.X() - <me>.X() * Other.Z()
//! new.Z() = <me>.X() * Other.Y() - <me>.Y() * Other.X()
+ //! @endcode
Standard_NODISCARD gp_XYZ Crossed (const gp_XYZ& Right) const;
Standard_NODISCARD gp_XYZ operator ^ (const gp_XYZ& Right) const
{
//! computes the triple scalar product
Standard_Real DotCross (const gp_XYZ& Coord1, const gp_XYZ& Coord2) const;
-
+ //! @code
//! <me>.X() = <me>.X() * Scalar;
//! <me>.Y() = <me>.Y() * Scalar;
//! <me>.Z() = <me>.Z() * Scalar;
+ //! @endcode
void Multiply (const Standard_Real Scalar);
void operator *= (const Standard_Real Scalar)
{
Multiply(Scalar);
}
-
+ //! @code
//! <me>.X() = <me>.X() * Other.X();
//! <me>.Y() = <me>.Y() * Other.Y();
//! <me>.Z() = <me>.Z() * Other.Z();
+ //! @endcode
void Multiply (const gp_XYZ& Other);
void operator *= (const gp_XYZ& Other)
{
Multiply(Other);
}
-
+
+ //! @code
//! <me> = Matrix * <me>
+ //! @endcode
void Multiply (const gp_Mat& Matrix);
void operator *= (const gp_Mat& Matrix)
{
Multiply(Matrix);
}
-
+ //! @code
//! New.X() = <me>.X() * Scalar;
//! New.Y() = <me>.Y() * Scalar;
//! New.Z() = <me>.Z() * Scalar;
+ //! @endcode
Standard_NODISCARD gp_XYZ Multiplied (const Standard_Real Scalar) const;
Standard_NODISCARD gp_XYZ operator * (const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}
-
+ //! @code
//! new.X() = <me>.X() * Other.X();
//! new.Y() = <me>.Y() * Other.Y();
//! new.Z() = <me>.Z() * Other.Z();
+ //! @endcode
Standard_NODISCARD gp_XYZ Multiplied (const gp_XYZ& Other) const;
-
+
+ //! @code
//! New = Matrix * <me>
+ //! @endcode
Standard_NODISCARD gp_XYZ Multiplied (const gp_Mat& Matrix) const;
Standard_NODISCARD gp_XYZ operator * (const gp_Mat& Matrix) const
{
return Multiplied(Matrix);
}
-
+ //! @code
//! <me>.X() = <me>.X()/ <me>.Modulus()
//! <me>.Y() = <me>.Y()/ <me>.Modulus()
//! <me>.Z() = <me>.Z()/ <me>.Modulus()
+ //! @endcode
//! Raised if <me>.Modulus() <= Resolution from gp
void Normalize();
-
+ //! @code
//! New.X() = <me>.X()/ <me>.Modulus()
//! New.Y() = <me>.Y()/ <me>.Modulus()
//! New.Z() = <me>.Z()/ <me>.Modulus()
+ //! @endcode
//! Raised if <me>.Modulus() <= Resolution from gp
Standard_NODISCARD gp_XYZ Normalized() const;
-
+ //! @code
//! <me>.X() = -<me>.X()
//! <me>.Y() = -<me>.Y()
//! <me>.Z() = -<me>.Z()
+ //! @endcode
void Reverse();
-
+ //! @code
//! New.X() = -<me>.X()
//! New.Y() = -<me>.Y()
//! New.Z() = -<me>.Z()
+ //! @endcode
Standard_NODISCARD gp_XYZ Reversed() const;
-
+ //! @code
//! <me>.X() = <me>.X() - Other.X()
//! <me>.Y() = <me>.Y() - Other.Y()
//! <me>.Z() = <me>.Z() - Other.Z()
+ //! @endcode
void Subtract (const gp_XYZ& Right);
void operator -= (const gp_XYZ& Right)
{
Subtract(Right);
}
-
+ //! @code
//! new.X() = <me>.X() - Other.X()
//! new.Y() = <me>.Y() - Other.Y()
//! new.Z() = <me>.Z() - Other.Z()
+ //! @endcode
Standard_NODISCARD gp_XYZ Subtracted (const gp_XYZ& Right) const;
Standard_NODISCARD gp_XYZ operator - (const gp_XYZ& Right) const
{
//! <me> is set to the following linear form :
+ //! @code
//! A1 * XYZ1 + A2 * XYZ2 + A3 * XYZ3 + XYZ4
+ //! @endcode
void SetLinearForm (const Standard_Real A1, const gp_XYZ& XYZ1, const Standard_Real A2, const gp_XYZ& XYZ2, const Standard_Real A3, const gp_XYZ& XYZ3, const gp_XYZ& XYZ4);
//! <me> is set to the following linear form :
+ //! @code
//! A1 * XYZ1 + A2 * XYZ2 + A3 * XYZ3
+ //! @endcode
void SetLinearForm (const Standard_Real A1, const gp_XYZ& XYZ1, const Standard_Real A2, const gp_XYZ& XYZ2, const Standard_Real A3, const gp_XYZ& XYZ3);
//! <me> is set to the following linear form :
+ //! @code
//! A1 * XYZ1 + A2 * XYZ2 + XYZ3
+ //! @endcode
void SetLinearForm (const Standard_Real A1, const gp_XYZ& XYZ1, const Standard_Real A2, const gp_XYZ& XYZ2, const gp_XYZ& XYZ3);
//! <me> is set to the following linear form :
+ //! @code
//! A1 * XYZ1 + A2 * XYZ2
+ //! @endcode
void SetLinearForm (const Standard_Real A1, const gp_XYZ& XYZ1, const Standard_Real A2, const gp_XYZ& XYZ2);
//! <me> is set to the following linear form :
+ //! @code
//! A1 * XYZ1 + XYZ2
+ //! @endcode
void SetLinearForm (const Standard_Real A1, const gp_XYZ& XYZ1, const gp_XYZ& XYZ2);
//! <me> is set to the following linear form :
+ //! @code
//! XYZ1 + XYZ2
+ //! @endcode
void SetLinearForm (const gp_XYZ& XYZ1, const gp_XYZ& XYZ2);
projects / occt.git / commitdiff