blob: cd17ca89dac6d10c092b2ea3fb8267545a0a181d (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
// File gp_Vec2d.cxx, JCV 06/90
// File gp_Vec2d.cxx, REG 26/10/90 nouvelle version
// JCV 08/01/90 Modifs suite a l'introduction des classes XY et Mat2d dans gp
#define No_Standard_OutOfRange
#include <gp_Vec2d.ixx>
#include <gp.hxx>
#include <gp_VectorWithNullMagnitude.hxx>
Standard_Boolean gp_Vec2d::IsEqual
(const gp_Vec2d& Other,
const Standard_Real LinearTolerance,
const Standard_Real AngularTolerance) const
{
const Standard_Real theNorm = Magnitude();
const Standard_Real theOtherNorm = Other.Magnitude();
Standard_Real val = theNorm - theOtherNorm;
if (val < 0.0) val = -val;
// Check for equal lengths
const Standard_Boolean isEqualLength = (val <= LinearTolerance);
// Check for small vectors
if (theNorm > LinearTolerance && theOtherNorm > LinearTolerance)
{
Standard_Real Ang = Angle(Other);
if (Ang < 0.0) Ang = -Ang;
// Check for zero angle
return isEqualLength && (Ang <= AngularTolerance);
}
return isEqualLength;
}
Standard_Real gp_Vec2d::Angle (const gp_Vec2d& Other) const
{
// Commentaires :
// Au dessus de 45 degres l'arccos donne la meilleur precision pour le
// calcul de l'angle. Sinon il vaut mieux utiliser l'arcsin.
// Les erreurs commises sont loin d'etre negligeables lorsque l'on est
// proche de zero ou de 90 degres.
// En 2D les valeurs angulaires sont comprises entre -PI et PI
const Standard_Real theNorm = Magnitude();
const Standard_Real theOtherNorm = Other.Magnitude();
if (theNorm <= gp::Resolution() || theOtherNorm <= gp::Resolution())
gp_VectorWithNullMagnitude::Raise();
const Standard_Real D = theNorm * theOtherNorm;
const Standard_Real Cosinus = coord.Dot (Other.coord) / D;
const Standard_Real Sinus = coord.Crossed (Other.coord) / D;
if (Cosinus > -0.70710678118655 && Cosinus < 0.70710678118655)
{
if (Sinus > 0.0) return acos (Cosinus);
else return -acos (Cosinus);
}
else
{
if (Cosinus > 0.0) return asin (Sinus);
else
{
if (Sinus > 0.0) return PI - asin (Sinus);
else return - PI - asin (Sinus);
}
}
}
void gp_Vec2d::Mirror (const gp_Ax2d& A1)
{
const gp_XY& XY = A1.Direction().XY();
Standard_Real X = coord.X();
Standard_Real Y = coord.Y();
Standard_Real A = XY.X();
Standard_Real B = XY.Y();
Standard_Real M1 = 2.0 * A * B;
coord.SetX(((2.0 * A * A) - 1.) * X + M1 * Y);
coord.SetY(M1 * X + ((2. * B * B) - 1.0) * Y);
}
gp_Vec2d gp_Vec2d::Mirrored (const gp_Ax2d& A1) const
{
gp_Vec2d Vres = *this;
Vres.Mirror(A1);
return Vres;
}
void gp_Vec2d::Transform (const gp_Trsf2d& T)
{
if (T.Form() == gp_Identity || T.Form() == gp_Translation) { }
else if (T.Form() == gp_PntMirror) coord.Reverse ();
else if (T.Form() == gp_Scale) coord.Multiply (T.ScaleFactor ());
else coord.Multiply (T.VectorialPart ());
}
void gp_Vec2d::Mirror (const gp_Vec2d& V)
{
const Standard_Real D = V.coord.Modulus();
if (D > gp::Resolution())
{
const gp_XY& XY = V.coord;
Standard_Real X = XY.X();
Standard_Real Y = XY.Y();
Standard_Real A = X / D;
Standard_Real B = Y / D;
Standard_Real M1 = 2.0 * A * B;
coord.SetX(((2.0 * A * A) - 1.0) * X + M1 * Y);
coord.SetY(M1 * X + ((2.0 * B * B) - 1.0) * Y);
}
}
gp_Vec2d gp_Vec2d::Mirrored (const gp_Vec2d& V) const
{
gp_Vec2d Vres = *this;
Vres.Mirror(V);
return Vres;
}
|
