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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// Modified 23/02/98 : FMN ; Remplacement PI par Standard_PI
#define CSR577 //GG 25/09/00 Avoid to have unaccuracy coordinates computation
// when the grid is activated.
#define OCC192_193 // jfa 27/02/2002
// for big rotation angles - error of negative values expression in round numbers
#define xTRACE
#include <Aspect_CircularGrid.ixx>
#include <Aspect_Grid.hxx>
#include <Standard_NumericError.hxx>
Aspect_CircularGrid::Aspect_CircularGrid
(const Quantity_Length aRadiusStep,
const Standard_Integer aDivisionNumber,
const Quantity_Length anXOrigin,
const Quantity_Length anYOrigin,
const Quantity_PlaneAngle aRotationAngle)
:Aspect_Grid(anXOrigin,anYOrigin,aRotationAngle),myRadiusStep(aRadiusStep),
myDivisionNumber(aDivisionNumber) {
}
void Aspect_CircularGrid::SetRadiusStep(const Standard_Real aRadiusStep) {
Standard_NegativeValue_Raise_if(aRadiusStep < 0., "invalid radius step");
Standard_NullValue_Raise_if(aRadiusStep == 0. , "invalid radius step");
myRadiusStep= aRadiusStep;
Init();
UpdateDisplay();
}
void Aspect_CircularGrid::SetDivisionNumber(const Standard_Integer aNumber) {
Standard_NegativeValue_Raise_if(aNumber < 0., "invalid division number");
Standard_NullValue_Raise_if(aNumber == 0. , "invalid division number");
myDivisionNumber = aNumber;
Init();
UpdateDisplay();
}
void Aspect_CircularGrid::SetGridValues
(const Quantity_Length theXOrigin,
const Quantity_Length theYOrigin,
const Quantity_Length theRadiusStep,
const Standard_Integer theDivisionNumber,
const Quantity_PlaneAngle theRotationAngle) {
myXOrigin = theXOrigin;
myYOrigin = theYOrigin;
Standard_NegativeValue_Raise_if(theRadiusStep < 0., "invalid radius step");
Standard_NullValue_Raise_if(theRadiusStep == 0. , "invalid radius step");
myRadiusStep= theRadiusStep;
Standard_NegativeValue_Raise_if(theDivisionNumber < 0., "invalid division number");
Standard_NullValue_Raise_if(theDivisionNumber == 0. , "invalid division number");
myDivisionNumber = theDivisionNumber;
myRotationAngle = theRotationAngle;
Init();
UpdateDisplay();
}
void Aspect_CircularGrid::Compute(const Quantity_Length X,
const Quantity_Length Y,
Quantity_Length& gridX,
Quantity_Length& gridY) const {
#ifdef TRACE
if( X == 0. || Y == 0. ) {
cout << " Aspect_CircularGrid" << endl;
}
#endif
Standard_Real xo = XOrigin();
Standard_Real yo = YOrigin();
Standard_Real d = Sqrt( (xo-X)*(xo-X) + (yo-Y)*(yo-Y) );
Standard_Integer n = (Standard_Integer ) ( d/myRadiusStep + 0.5 ) ;
Standard_Real radius = Standard_Real(n) * myRadiusStep;
Standard_Real cosinus = (X-xo)/d;
Standard_Real a = ACos(cosinus);
Standard_Real ra = RotationAngle();
if ( Y < yo ) a = 2*Standard_PI - a;
#ifdef OCC192_193
n = (Standard_Integer ) ((a-ra)/myAlpha + Sign(0.5, a-ra)) ;
#else
n = (Standard_Integer ) ((a-ra)/myAlpha +0.5 ) ;
#endif
#ifdef CSR577
Standard_Real cs=0,sn=0;
Standard_Boolean done = Standard_False;
Standard_Integer nmax = 2*myDivisionNumber;
Standard_Integer nquad,qmax;
if( ra == 0. ) {
nquad = 4; qmax = nmax/nquad;
if( (n == 0) || (!(nmax % nquad) && !(n % qmax)) ) {
Standard_Integer q = n/qmax;
switch (q) {
default:
case 0:
cs = 1.; sn = 0.;
break;
case 1:
cs = 0.; sn = 1.;
break;
case 2:
cs = -1.; sn = 0.;
break;
case 3:
cs = 0.; sn = -1.;
break;
}
done = Standard_True;
} else {
nquad = 2; qmax = nmax/nquad;
if( !(nmax % nquad) && !(n % qmax) ) {
Standard_Integer q = n/qmax;
switch (q) {
default:
case 0:
cs = 1.; sn = 0.;
break;
case 1:
cs = -1.; sn = 0.;
break;
}
done = Standard_True;
}
}
}
if( !done ) {
Standard_Real ang = ra + Standard_Real(n)*myAlpha;
cs = Cos(ang); sn = Sin(ang);
}
#else
Standard_Real ang = RotationAngle()+ Standard_Real(n)*myAlpha;
Standard_Real cs = Cos(ang);
Standard_Real sn = Sin(ang);
#endif
gridX = xo + cs * radius;
gridY = yo + sn * radius;
#ifdef TRACE
cout << "Aspect_CircularGrid::Compute (" << Quantity_Length (X) << ", "
<< Quantity_Length (Y) << ", " << Quantity_Length (gridX) << ", "
<< Quantity_Length (gridY) << ")" << endl;
#endif
}
Quantity_Length Aspect_CircularGrid::RadiusStep() const {
return myRadiusStep;
}
Standard_Integer Aspect_CircularGrid::DivisionNumber () const {
return myDivisionNumber;
}
void Aspect_CircularGrid::Init () {
myAlpha = Standard_PI /Standard_Real(myDivisionNumber);
myA1 = Cos(myAlpha); myB1=Sin(myAlpha);
}
|
