0024002: Overall code and build procedure refactoring -- automatic
[occt.git] / src / Aspect / Aspect_RectangularGrid.cxx
1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14 // Modified     23/02/98 : FMN ; Remplacement PI par Standard_PI
15
16 #include <Aspect_RectangularGrid.hxx>
17 #include <Standard_NegativeValue.hxx>
18 #include <Standard_NullValue.hxx>
19 #include <Standard_NumericError.hxx>
20 #include <Standard_Type.hxx>
21
22 Aspect_RectangularGrid::Aspect_RectangularGrid(
23                                const Quantity_Length aXStep,
24                                const Quantity_Length aYStep,
25                                const Quantity_Length anXOrigin,
26                                const Quantity_Length anYOrigin,
27                                const Quantity_PlaneAngle aFirstAngle,
28                                const Quantity_PlaneAngle aSecondAngle,
29                                const Quantity_PlaneAngle aRotationAngle)
30 :Aspect_Grid(anXOrigin,anYOrigin,aRotationAngle),myXStep(aXStep),myYStep(aYStep),myFirstAngle(aFirstAngle),mySecondAngle(aSecondAngle)
31
32 {
33   Standard_NumericError_Raise_if(!CheckAngle (aFirstAngle,mySecondAngle),
34                                  "networks are parallel");
35
36   Standard_NegativeValue_Raise_if(aXStep < 0. , "invalid x step");
37   Standard_NegativeValue_Raise_if(aYStep < 0. , "invalid y step");
38   Standard_NullValue_Raise_if(aXStep == 0. , "invalid x step");
39   Standard_NullValue_Raise_if(aYStep == 0. , "invalid y step");
40 }
41
42
43
44 void Aspect_RectangularGrid::SetXStep(const Quantity_Length aStep) {
45   Standard_NegativeValue_Raise_if(aStep < 0. , "invalid x step");
46   Standard_NullValue_Raise_if(aStep == 0. , "invalid y step");
47   myXStep = aStep;
48   Init();
49   UpdateDisplay();
50 }
51
52 void Aspect_RectangularGrid::SetYStep(const Quantity_Length aStep) {
53   Standard_NegativeValue_Raise_if(aStep < 0. , "invalid x step");
54   Standard_NullValue_Raise_if(aStep == 0. , "invalid y step");
55   myYStep = aStep;
56   Init();
57   UpdateDisplay();
58 }
59
60 void Aspect_RectangularGrid::SetAngle(const Quantity_PlaneAngle anAngle1,
61                                             const Quantity_PlaneAngle anAngle2){
62
63   Standard_NumericError_Raise_if(!CheckAngle (anAngle1,anAngle2 ),
64                                  "axis are parallel");
65   myFirstAngle = anAngle1;
66   mySecondAngle = anAngle2;
67   Init();
68   UpdateDisplay();
69 }
70
71 void Aspect_RectangularGrid::SetGridValues(
72         const Quantity_Length theXOrigin,
73         const Quantity_Length theYOrigin,
74         const Quantity_Length theXStep,
75         const Quantity_Length theYStep,
76         const Quantity_PlaneAngle theRotationAngle) {
77
78   myXOrigin = theXOrigin;
79   myYOrigin = theYOrigin;
80   Standard_NegativeValue_Raise_if(theXStep < 0. , "invalid x step");
81   Standard_NullValue_Raise_if(theXStep == 0. , "invalid x step");
82   myXStep = theXStep;
83   Standard_NegativeValue_Raise_if(theYStep < 0. , "invalid y step");
84   Standard_NullValue_Raise_if(theYStep == 0. , "invalid y step");
85   myYStep = theYStep;
86   myRotationAngle = theRotationAngle;
87   Init();
88   UpdateDisplay();
89 }
90
91 void Aspect_RectangularGrid::Compute(const Quantity_Length X,
92                          const Quantity_Length Y,
93                          Quantity_Length& gridX,
94                          Quantity_Length& gridY) const {
95     Standard_Real D1 = b1 * X - a1 * Y - c1;
96     Standard_Real D2 = b2 * X - a2 * Y - c2;
97     Standard_Integer n1 = Standard_Integer ( Abs(D1)/myXStep + 0.5);
98     Standard_Integer n2 = Standard_Integer ( Abs(D2)/myYStep + 0.5);
99     Standard_Real offset1 = c1 + Standard_Real(n1) * Sign (myXStep , D1);
100     Standard_Real offset2 = c2 + Standard_Real(n2) * Sign (myYStep , D2);
101     Standard_Real Delta = a1*b2 - b1*a2;
102     gridX = ( offset2*a1 - offset1*a2) /Delta;
103     gridY = ( offset2*b1 - offset1*b2) /Delta;
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() + M_PI / 2.); 
130 //  b2 = Sin (mySecondAngle + RotationAngle() + M_PI / 2.);
131 //  c2 = XOrigin() * b2 - YOrigin() * a2;
132
133   Standard_Real angle1 = myFirstAngle + RotationAngle();
134   Standard_Real angle2 = mySecondAngle + RotationAngle();
135   if ( angle1 != 0. ) {
136     a1 = -Sin (angle1); 
137     b1 = Cos (angle1);
138     c1 = XOrigin() * b1 - YOrigin() * a1;
139   } else {
140     a1 = 0.; b1 = 1.; c1 = XOrigin();
141   }
142
143   if ( angle2 != 0. ) {
144     angle2 += M_PI / 2.;
145     a2 = -Sin (angle2); 
146     b2 = Cos (angle2);
147     c2 = XOrigin() * b2 - YOrigin() * a2;
148   } else {
149     a2 = -1.; b2 = 0.; c2 = YOrigin();
150   }
151 //-zov
152 }
153
154 Standard_Boolean Aspect_RectangularGrid::CheckAngle(const Standard_Real alpha,
155                                             const Standard_Real beta) const {
156   return (Abs( Sin(alpha) * Cos(beta + M_PI / 2.) - Cos(alpha) * Sin(beta + M_PI / 2.)) != 0) ;
157 }
158
159