OCC22324 Mistakes with parenthesis position in abs calls
[occt.git] / src / Aspect / Aspect_RectangularGrid.cxx
1 // Modified     23/02/98 : FMN ; Remplacement PI par Standard_PI
2
3 #define CSR577  //GG 25/09/00 Avoid to have unaccuracy coordinates computation
4 //              when the grid is activated.
5
6 #define xTRACE
7
8 #include <Aspect_RectangularGrid.ixx>
9
10
11 Aspect_RectangularGrid::Aspect_RectangularGrid(
12                                const Quantity_Length aXStep,
13                                const Quantity_Length aYStep,
14                                const Quantity_Length anXOrigin,
15                                const Quantity_Length anYOrigin,
16                                const Quantity_PlaneAngle aFirstAngle,
17                                const Quantity_PlaneAngle aSecondAngle,
18                                const Quantity_PlaneAngle aRotationAngle)
19 :Aspect_Grid(anXOrigin,anYOrigin,aRotationAngle),myXStep(aXStep),myYStep(aYStep),myFirstAngle(aFirstAngle),mySecondAngle(aSecondAngle)
20
21 {
22   Standard_NumericError_Raise_if(!CheckAngle (aFirstAngle,mySecondAngle),
23                                  "networks are parallel");
24
25   Standard_NegativeValue_Raise_if(aXStep < 0. , "invalid x step");
26   Standard_NegativeValue_Raise_if(aYStep < 0. , "invalid y step");
27   Standard_NullValue_Raise_if(aXStep == 0. , "invalid x step");
28   Standard_NullValue_Raise_if(aYStep == 0. , "invalid y step");
29 }
30
31
32
33 void Aspect_RectangularGrid::SetXStep(const Quantity_Length aStep) {
34   Standard_NegativeValue_Raise_if(aStep < 0. , "invalid x step");
35   Standard_NullValue_Raise_if(aStep == 0. , "invalid y step");
36   myXStep = aStep;
37   Init();
38   UpdateDisplay();
39 }
40
41 void Aspect_RectangularGrid::SetYStep(const Quantity_Length aStep) {
42   Standard_NegativeValue_Raise_if(aStep < 0. , "invalid x step");
43   Standard_NullValue_Raise_if(aStep == 0. , "invalid y step");
44   myYStep = aStep;
45   Init();
46   UpdateDisplay();
47 }
48
49 void Aspect_RectangularGrid::SetAngle(const Quantity_PlaneAngle anAngle1,
50                                             const Quantity_PlaneAngle anAngle2){
51
52   Standard_NumericError_Raise_if(!CheckAngle (anAngle1,anAngle2 ),
53                                  "axis are parallel");
54   myFirstAngle = anAngle1;
55   mySecondAngle = anAngle2;
56   Init();
57   UpdateDisplay();
58 }
59
60 void Aspect_RectangularGrid::SetGridValues(
61         const Quantity_Length theXOrigin,
62         const Quantity_Length theYOrigin,
63         const Quantity_Length theXStep,
64         const Quantity_Length theYStep,
65         const Quantity_PlaneAngle theRotationAngle) {
66
67   myXOrigin = theXOrigin;
68   myYOrigin = theYOrigin;
69   Standard_NegativeValue_Raise_if(theXStep < 0. , "invalid x step");
70   Standard_NullValue_Raise_if(theXStep == 0. , "invalid x step");
71   myXStep = theXStep;
72   Standard_NegativeValue_Raise_if(theYStep < 0. , "invalid y step");
73   Standard_NullValue_Raise_if(theYStep == 0. , "invalid y step");
74   myYStep = theYStep;
75   myRotationAngle = theRotationAngle;
76   Init();
77   UpdateDisplay();
78 }
79
80 void Aspect_RectangularGrid::Compute(const Quantity_Length X,
81                          const Quantity_Length Y,
82                          Quantity_Length& gridX,
83                          Quantity_Length& gridY) const {
84     Standard_Real D1 = b1 * X - a1 * Y - c1;
85     Standard_Real D2 = b2 * X - a2 * Y - c2;
86     Standard_Integer n1 = Standard_Integer ( Abs(D1)/myXStep + 0.5);
87     Standard_Integer n2 = Standard_Integer ( Abs(D2)/myYStep + 0.5);
88     Standard_Real offset1 = c1 + Standard_Real(n1) * Sign (myXStep , D1);
89     Standard_Real offset2 = c2 + Standard_Real(n2) * Sign (myYStep , D2);
90 #ifdef CSR577
91     Standard_Real Delta = a1*b2 - b1*a2;
92     gridX = ( offset2*a1 - offset1*a2) /Delta;
93     gridY = ( offset2*b1 - offset1*b2) /Delta;
94 #else
95     Standard_Real Delta = b1*a2 - a1*b2;
96     gridX = ( offset1*a2 - offset2*a1) /Delta;
97     gridY = ( offset1*b2 - offset2*b1) /Delta;
98 #endif
99 #ifdef TRACE
100     cout << "Aspect_RectangularGrid::Compute (" << Quantity_Length (X) << ", "
101          << Quantity_Length (Y) << ", " << Quantity_Length (gridX) << ", "
102          << Quantity_Length (gridY) << ")" << endl;
103 #endif
104 }
105
106 Quantity_Length Aspect_RectangularGrid::XStep() const {
107   return myXStep;
108 }
109
110 Quantity_Length Aspect_RectangularGrid::YStep() const {
111   return myYStep;
112 }
113
114 Quantity_Length Aspect_RectangularGrid::FirstAngle() const {
115   return myFirstAngle;
116 }
117
118 Quantity_Length Aspect_RectangularGrid::SecondAngle() const {
119   return mySecondAngle;
120 }
121
122 void Aspect_RectangularGrid::Init () {
123
124 //+zov Fixing CTS17856
125 //  a1 = Cos (myFirstAngle + RotationAngle() ); 
126 //  b1 = Sin (myFirstAngle + RotationAngle() );
127 //  c1 = XOrigin() * b1 - YOrigin() * a1;
128 //
129 //  a2 = Cos (mySecondAngle + RotationAngle() + Standard_PI/2.); 
130 //  b2 = Sin (mySecondAngle + RotationAngle() + Standard_PI/2.);
131 //  c2 = XOrigin() * b2 - YOrigin() * a2;
132
133 #ifdef CSR577
134   Standard_Real angle1 = myFirstAngle + RotationAngle();
135   Standard_Real angle2 = mySecondAngle + RotationAngle();
136   if ( angle1 != 0. ) {
137     a1 = -Sin (angle1); 
138     b1 = Cos (angle1);
139     c1 = XOrigin() * b1 - YOrigin() * a1;
140   } else {
141     a1 = 0.; b1 = 1.; c1 = XOrigin();
142   }
143
144   if ( angle2 != 0. ) {
145     angle2 += Standard_PI/2.;
146     a2 = -Sin (angle2); 
147     b2 = Cos (angle2);
148     c2 = XOrigin() * b2 - YOrigin() * a2;
149   } else {
150     a2 = -1.; b2 = 0.; c2 = YOrigin();
151   }
152 #else
153   a1 = -Sin (myFirstAngle + RotationAngle()); 
154   b1 = Cos (myFirstAngle + RotationAngle());
155   c1 = XOrigin() * b1 - YOrigin() * a1;
156
157   a2 = -Sin (mySecondAngle + RotationAngle() + Standard_PI/2.); 
158   b2 = Cos (mySecondAngle + RotationAngle() + Standard_PI/2.);
159   c2 = XOrigin() * b2 - YOrigin() * a2;
160 #endif
161 //-zov
162 }
163
164 Standard_Boolean Aspect_RectangularGrid::CheckAngle(const Standard_Real alpha,
165                                             const Standard_Real beta) const {
166   return (Abs( Sin(alpha) * Cos(beta+Standard_PI/2.) - Cos(alpha) * Sin(beta+Standard_PI/2.)) != 0) ;
167 }
168
169