0023315: Duplicate comarison in an if-clause ib Prs2d_ToleranceFrame.cxx
[occt.git] / src / Prs2d / Prs2d_ToleranceFrame.cxx
CommitLineData
b311480e 1// Copyright (c) 1999-2012 OPEN CASCADE SAS
2//
3// The content of this file is subject to the Open CASCADE Technology Public
4// License Version 6.5 (the "License"). You may not use the content of this file
5// except in compliance with the License. Please obtain a copy of the License
6// at http://www.opencascade.org and read it completely before using this file.
7//
8// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
9// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
10//
11// The Original Code and all software distributed under the License is
12// distributed on an "AS IS" basis, without warranty of any kind, and the
13// Initial Developer hereby disclaims all such warranties, including without
14// limitation, any warranties of merchantability, fitness for a particular
15// purpose or non-infringement. Please see the License for the specific terms
16// and conditions governing the rights and limitations under the License.
17
7fd59977 18#include <Prs2d_ToleranceFrame.ixx>
19#include <Prs2d_Tolerance.hxx>
20#include <Prs2d_Straightness.hxx>
21#include <Prs2d_Flatness.hxx>
22#include <Prs2d_Circularity.hxx>
23#include <Prs2d_Cylindric.hxx>
24#include <Prs2d_LineProfile.hxx>
25#include <Prs2d_SurfProfile.hxx>
26#include <Prs2d_Parallelism.hxx>
27#include <Prs2d_Perpendicular.hxx>
28#include <Prs2d_Angularity.hxx>
29#include <Prs2d_Position.hxx>
30#include <Prs2d_Concentric.hxx>
31#include <Prs2d_Symmetry.hxx>
32#include <Prs2d_SymCircular.hxx>
33#include <Prs2d_SymTotal.hxx>
34#include <Prs2d_Taper.hxx>
35
36Prs2d_ToleranceFrame::Prs2d_ToleranceFrame( const Handle(Graphic2d_GraphicObject)& aGO,
37 const Quantity_Length aX,
38 const Quantity_Length aY,
39 const Quantity_Length aHeight,
40 const Prs2d_TypeOfTolerance aTolType,
41 const Standard_CString aTolTxt,
42 const Standard_CString aTxt1,
43 const Standard_CString aTxt2,
44 const Standard_Real anAngle,
45 const Standard_Real aScale )
46
47 : Graphic2d_Line( aGO ),
48
49 myX( Standard_ShortReal( aX ) ),
50 myY( Standard_ShortReal( aY ) ),
51 myTolTxt( TCollection_ExtendedString(aTolTxt) ),
52 myTxt1( TCollection_ExtendedString(aTxt1) ),
53 myTxt2( TCollection_ExtendedString(aTxt2) ),
54 myHeight( Standard_ShortReal( aHeight ) ),
55 myAngle( Standard_ShortReal( anAngle ) ),
56 myScale( Standard_ShortReal( aScale ) ),
57 myXVert( 1, 4 ),
58 myYVert( 1, 4 )
59
60{
61
62 gp_Pnt2d PntP( myX, myY );
63 gp_Vec2d theV1( gp_Pnt2d( myX, myY - myHeight/2 ), PntP );
64 theV1.Rotate( myAngle );
65 theV1.Reverse();
66 gp_Pnt2d Pnt0 = PntP.Translated( theV1 );
67 gp_Vec2d theVecG( Pnt0, gp_Pnt2d( Pnt0.X() + 1.0, Pnt0.Y() ) );
68 theVecG.Rotate( myAngle );
c6541a0c 69 gp_Vec2d theVecV = theVecG.Rotated( M_PI / 2 );
7fd59977 70 theVecG.Normalize();
71 theVecV.Normalize();
72
73 gp_Pnt2d Pnt1 = Pnt0.Translated( theVecV * myHeight );
74 myXVert(1) = Standard_ShortReal( Pnt0.X() );
75 myYVert(1) = Standard_ShortReal( Pnt0.Y() );
76 myXVert(2) = Standard_ShortReal( Pnt1.X() );
77 myYVert(2) = Standard_ShortReal( Pnt1.Y() );
78 gp_Pnt2d Pnt2 = Pnt0.Translated( theVecG * myHeight );
79 myXVert(4) = Standard_ShortReal( Pnt2.X() );
80 myYVert(4) = Standard_ShortReal( Pnt2.Y() );
81 Pnt2 = Pnt1.Translated( theVecG * myHeight );
82 myXVert(3) = Standard_ShortReal( Pnt2.X() );
83 myYVert(3) = Standard_ShortReal( Pnt2.Y() );
84
85 myMinX = myX;
86 myMinY = myY;
87 myMaxX = myX;
88 myMaxY = myY;
89
90 for ( Standard_Integer i = 1; i <= 4; i++ ) {
91 if ( myXVert(i) < myMinX ) myMinX = myXVert(i);
92 if ( myYVert(i) < myMinY ) myMinY = myYVert(i);
93 if ( myXVert(i) > myMaxX ) myMaxX = myXVert(i);
94 if ( myYVert(i) > myMaxY ) myMaxY = myYVert(i);
95 }
96
97 gp_Vec2d VecTol( PntP, gp_Pnt2d( myX + myHeight/2, myY ) );
98 VecTol.Rotate( myAngle );
99 PntP.Translate( VecTol );
100 Standard_Real xTTol = PntP.X(),
101 yTTol = PntP.Y(),
102 theSz1 = myHeight * 2/5,
103 theSz2 = myHeight * 3/5;
104
105 switch ( aTolType ) {
106 case Prs2d_TOT_TAPER:
107 myHTol = new Prs2d_Taper( aGO, xTTol, yTTol, theSz2, myAngle );
108 break;
109 case Prs2d_TOT_SYMTOTAL:
110 myHTol = new Prs2d_SymTotal( aGO, xTTol, yTTol, theSz2, myAngle );
111 break;
112 case Prs2d_TOT_SYMCIRCULAR:
113 myHTol = new Prs2d_SymCircular( aGO, xTTol, yTTol, theSz2, myAngle );
114 break;
115 case Prs2d_TOT_SYMMETRY:
116 myHTol = new Prs2d_Symmetry( aGO, xTTol, yTTol, theSz2, myAngle );
117 break;
118 case Prs2d_TOT_CONCENTRIC:
119 myHTol = new Prs2d_Concentric( aGO, xTTol, yTTol, theSz2, myAngle );
120 break;
121 case Prs2d_TOT_POSITION:
122 myHTol = new Prs2d_Position( aGO, xTTol, yTTol, theSz2, myAngle );
123 break;
124 case Prs2d_TOT_ANGULARITY:
125 myHTol = new Prs2d_Angularity( aGO, xTTol, yTTol, theSz2, myAngle );
126 break;
127 case Prs2d_TOT_PERPENDIC:
128 myHTol = new Prs2d_Perpendicular( aGO, xTTol, yTTol, theSz2, myAngle );
129 break;
130 case Prs2d_TOT_PARALLELISM:
131 myHTol = new Prs2d_Parallelism( aGO, xTTol, yTTol, theSz1, myAngle );
132 break;
133 case Prs2d_TOT_SURFACEPROF:
134 myHTol = new Prs2d_SurfProfile( aGO, xTTol, yTTol, theSz2, myAngle );
135 break;
136 case Prs2d_TOT_LINEPROF:
137 myHTol = new Prs2d_LineProfile( aGO, xTTol, yTTol, theSz2, myAngle );
138 break;
139 case Prs2d_TOT_CYLINDRIC:
140 myHTol = new Prs2d_Cylindric( aGO, xTTol, yTTol, theSz1, myAngle );
141 break;
142 case Prs2d_TOT_CIRCULARITY:
143 myHTol = new Prs2d_Circularity( aGO, xTTol, yTTol, theSz2, myAngle );
144 break;
145 case Prs2d_TOT_FLATNESS:
146 myHTol = new Prs2d_Flatness( aGO, xTTol, yTTol, theSz1, myAngle );
147 break;
148 case Prs2d_TOT_STRAIGHTNESS:
149 myHTol = new Prs2d_Straightness( aGO, xTTol, yTTol, theSz2, myAngle );
150 break;
151 case Prs2d_TOT_NONE:
152 default:
153 break;
154
155 }
156}
157
158void Prs2d_ToleranceFrame::Draw( const Handle(Graphic2d_Drawer)& aDrawer ) {
159
160 Standard_Boolean IsIn = Standard_False;
161
162 if ( ! myGOPtr->IsTransformed() )
163 IsIn = aDrawer->IsIn( myMinX, myMaxX, myMinY,myMaxY );
164 else {
165 Standard_ShortReal minx, miny, maxx, maxy;
166 MinMax(minx,maxx,miny,maxy);
167 IsIn = aDrawer->IsIn( minx, maxx, miny, maxy );
168 }
169
170 if ( IsIn ) {
171
172 DrawLineAttrib( aDrawer );
173
174 gp_GTrsf2d aTrsf;
175 Standard_Real a1, b1;
176
177 TShort_Array1OfShortReal Xpoint( 1, 4 ), Ypoint( 1, 4 );
178 Xpoint.Assign( myXVert );
179 Ypoint.Assign( myYVert );
180
181 if ( myGOPtr->IsTransformed() ) {
182 aTrsf = myGOPtr->Transform ();
183 for ( Standard_Integer j = 1; j <= 4; j++ ) {
184 a1 = Standard_Real( Xpoint(j) );
185 b1 = Standard_Real( Ypoint(j) );
186 aTrsf.Transforms( a1, b1 );
187 Xpoint(j) = Standard_ShortReal( a1 );
188 Ypoint(j) = Standard_ShortReal( b1 );
189 }
190 }
191 aDrawer->MapPolygonFromTo( Xpoint, Ypoint );
192
193 //------------additional text's cells
194
3f6213c3 195 if ( myTolTxt.Length() || myTxt1.Length() || myTxt2.Length() ) {
7fd59977 196 gp_Pnt2d PntP( myX, myY );
197 gp_Vec2d theV1( gp_Pnt2d( myX, myY - myHeight/2 ), PntP );
198 theV1.Rotate( myAngle );
199 theV1.Reverse();
200 gp_Pnt2d Pnt0 = PntP.Translated( theV1 ),
201 PntT = PntP.Translated( theV1 / 2 );
202 gp_Vec2d theVecT( PntT, gp_Pnt2d( PntT.X() + 1.0, PntT.Y() ) );
203 theVecT.Rotate( myAngle );
204 theVecT.Normalize();
205 gp_Vec2d theVecG( Pnt0, gp_Pnt2d( Pnt0.X() + 1.0, Pnt0.Y() ) );
206 theVecG.Rotate( myAngle );
c6541a0c 207 gp_Vec2d theVecV = theVecG.Rotated( M_PI / 2 );
7fd59977 208 theVecG.Normalize();
209 theVecV.Normalize();
210
211 gp_Pnt2d Pnt1 = Pnt0.Translated( theVecV * myHeight );
212 gp_Pnt2d Pnt2 = Pnt0.Translated( theVecG * myHeight );
213
214 const Standard_ShortReal offS = Standard_ShortReal( 5 );
215 aDrawer->SetTextAttrib( myColorIndex, 0, 0, Standard_ShortReal(myScale*aDrawer->Scale()),
216 Standard_ShortReal(myScale*aDrawer->Scale()), Standard_False );
217
218 Standard_ShortReal tVecSize = myHeight;
219 Standard_ShortReal ws = 0.0, hs;
220 gp_Pnt2d tmpPntTxt;
221 Standard_ShortReal X1=0., Y1=0., X2=0., Y2=0., X3, Y3, X4, Y4;
222 if ( myTolTxt.Length() ) {
223 tVecSize += offS;
224 tmpPntTxt = PntT.Translated( theVecT * tVecSize );
225 X1 = Standard_ShortReal( tmpPntTxt.X() );
226 Y1 = Standard_ShortReal( tmpPntTxt.Y() );
227 if ( myGOPtr->IsTransformed () ) {
228 aTrsf = myGOPtr->Transform();
229 a1 = Standard_Real( X1 );
230 b1 = Standard_Real( Y1 );
231 aTrsf.Transforms( a1, b1 );
232 X1 = Standard_ShortReal( a1 ); Y1 = Standard_ShortReal( b1 );
233 }
234 aDrawer->MapTextFromTo( myTolTxt, X1, Y1, myAngle, 0.0, 0.0, Aspect_TOT_SOLID );
235 aDrawer->GetTextSize( myTolTxt, ws, hs );
236 tVecSize += ws + offS;
237
238 Pnt2 = Pnt0.Translated( theVecG * tVecSize );
239 X1 = Standard_ShortReal( Pnt2.X() );
240 Y1 = Standard_ShortReal( Pnt2.Y() );
241 Pnt2 = Pnt1.Translated( theVecG * tVecSize );
242 X2 = Standard_ShortReal( Pnt2.X() );
243 Y2 = Standard_ShortReal( Pnt2.Y() );
244 if ( myGOPtr->IsTransformed () ) {
245 aTrsf = myGOPtr->Transform();
246 a1 = Standard_Real( X1 );
247 b1 = Standard_Real( Y1 );
248 aTrsf.Transforms( a1, b1 );
249 X1 = Standard_ShortReal( a1 ); Y1 = Standard_ShortReal( b1 );
250 a1 = Standard_Real( X2 );
251 b1 = Standard_Real( Y2 );
252 aTrsf.Transforms( a1, b1 );
253 X2 = Standard_ShortReal( a1 ); Y2 = Standard_ShortReal( b1 );
254 }
255 aDrawer->MapSegmentFromTo( X1, Y1, X2, Y2 );
256 }
257
258 if ( myTxt1.Length() ) {
259 tVecSize += offS;
260 tmpPntTxt = PntT.Translated( theVecT * tVecSize );
261 X1 = Standard_ShortReal( tmpPntTxt.X() ); Y1 = Standard_ShortReal( tmpPntTxt.Y() );
262 if ( myGOPtr->IsTransformed () ) {
263 aTrsf = myGOPtr->Transform();
264 a1 = Standard_Real( X1 );
265 b1 = Standard_Real( Y1 );
266 aTrsf.Transforms( a1, b1 );
267 X1 = Standard_ShortReal( a1 ); Y1 = Standard_ShortReal( b1 );
268 }
269 aDrawer->MapTextFromTo( myTxt1, X1, Y1, myAngle, 0., 0.,Aspect_TOT_SOLID );
270 aDrawer->GetTextSize( myTxt1, ws, hs );
271 tVecSize += ws + offS;
272
273 Pnt2 = Pnt0.Translated( theVecG * tVecSize );
274 X1 = Standard_ShortReal( Pnt2.X() );
275 Y1 = Standard_ShortReal( Pnt2.Y() );
276 Pnt2 = Pnt1.Translated( theVecG * tVecSize );
277 X2 = Standard_ShortReal( Pnt2.X() );
278 Y2 = Standard_ShortReal( Pnt2.Y() );
279 if ( myGOPtr->IsTransformed () ) {
280 aTrsf = myGOPtr->Transform();
281 a1 = Standard_Real( X1 );
282 b1 = Standard_Real( Y1 );
283 aTrsf.Transforms( a1, b1 );
284 X1 = Standard_ShortReal( a1 ); Y1 = Standard_ShortReal( b1 );
285 a1 = Standard_Real( X2 );
286 b1 = Standard_Real( Y2 );
287 aTrsf.Transforms( a1, b1 );
288 X2 = Standard_ShortReal( a1 ); Y2 = Standard_ShortReal( b1 );
289 }
290 aDrawer->MapSegmentFromTo( X1, Y1, X2, Y2 );
291 }
292
293 if ( myTxt2.Length() ) {
294 tVecSize += offS;
295 tmpPntTxt = PntT.Translated( theVecT * tVecSize );
296 X1 = Standard_ShortReal( tmpPntTxt.X() ); Y1 = Standard_ShortReal( tmpPntTxt.Y() );
297 if ( myGOPtr->IsTransformed () ) {
298 aTrsf = myGOPtr->Transform();
299 a1 = Standard_Real( X1 );
300 b1 = Standard_Real( Y1 );
301 aTrsf.Transforms( a1, b1 );
302 X1 = Standard_ShortReal( a1 ); Y1 = Standard_ShortReal( b1 );
303 }
304 aDrawer->MapTextFromTo( myTxt2, X1, Y1, myAngle, 0., 0., Aspect_TOT_SOLID );
305 aDrawer->GetTextSize( myTxt2, ws, hs );
306 tVecSize += ws + offS;
307
308 Pnt2 = Pnt0.Translated( theVecG * tVecSize );
309 X1 = Standard_ShortReal( Pnt2.X() );
310 Y1 = Standard_ShortReal( Pnt2.Y() );
311 Pnt2 = Pnt1.Translated( theVecG * tVecSize );
312 X2 = Standard_ShortReal( Pnt2.X() );
313 Y2 = Standard_ShortReal( Pnt2.Y() );
314 if ( myGOPtr->IsTransformed () ) {
315 aTrsf = myGOPtr->Transform();
316 a1 = Standard_Real( X1 );
317 b1 = Standard_Real( Y1 );
318 aTrsf.Transforms( a1, b1 );
319 X1 = Standard_ShortReal( a1 ); Y1 = Standard_ShortReal( b1 );
320 a1 = Standard_Real( X2 );
321 b1 = Standard_Real( Y2 );
322 aTrsf.Transforms( a1, b1 );
323 X2 = Standard_ShortReal( a1 ); Y2 = Standard_ShortReal( b1 );
324 }
325 aDrawer->MapSegmentFromTo( X1, Y1, X2, Y2 );
326 }
327
328 X3 = Standard_ShortReal( Pnt0.X() );
329 Y3 = Standard_ShortReal( Pnt0.Y() );
330 X4 = Standard_ShortReal( Pnt1.X() );
331 Y4 = Standard_ShortReal( Pnt1.Y() );
332 if ( myGOPtr->IsTransformed () ) {
333 aTrsf = myGOPtr->Transform();
334 a1 = Standard_Real( X3 );
335 b1 = Standard_Real( Y3 );
336 aTrsf.Transforms( a1, b1 );
337 X3 = Standard_ShortReal( a1 ); Y3 = Standard_ShortReal( b1 );
338 a1 = Standard_Real( X4 );
339 b1 = Standard_Real( Y4 );
340 aTrsf.Transforms( a1, b1 );
341 X4 = Standard_ShortReal( a1 ); Y4 = Standard_ShortReal( b1 );
342 }
343 aDrawer->MapSegmentFromTo( X1, Y1, X3, Y3 );
344 aDrawer->MapSegmentFromTo( X2, Y2, X4, Y4 );
345
346 } // end if one of text strings isn't empty
347 } // end if IsIn
348
349 if ( ! myHTol.IsNull() )
350 myHTol->Draw( aDrawer );
351
352}
353
354Standard_Boolean Prs2d_ToleranceFrame::Pick(
355 const Standard_ShortReal X,
356 const Standard_ShortReal Y,
357 const Standard_ShortReal aPrecision,
358 const Handle(Graphic2d_Drawer)& /*aDrawer*/ ) {
359 if ( IsInMinMax( X, Y, aPrecision ) )
360 return Standard_True;
361 return Standard_False;
362}
363
364void Prs2d_ToleranceFrame::SetHeight( const Standard_Real aHSize ) {
365
366 myHeight = Standard_ShortReal( aHSize );
367}
368
369Standard_Real Prs2d_ToleranceFrame::Height() const {
370
371 return myHeight;
372}
373
374void Prs2d_ToleranceFrame::Save(Aspect_FStream& aFStream) const
375{
376}
377
378const Handle(TColgp_HArray1OfPnt2d) Prs2d_ToleranceFrame::ArrayOfPnt2d( ) const
379{
380 Handle(TColgp_HArray1OfPnt2d) points = new TColgp_HArray1OfPnt2d( 1, 4 );
381
382 for ( Standard_Integer i = 1; i <= 4; i++ )
383 {
384 points->SetValue( i, gp_Pnt2d( myXVert(i), myYVert(i) ) );
385 }
386 return points;
387}
388
389void Prs2d_ToleranceFrame::SetTolText( const Standard_CString aTolTxt )
390{
391 myTolTxt = TCollection_ExtendedString(aTolTxt);
392}
393
394void Prs2d_ToleranceFrame::SetText1( const Standard_CString aTxt1 )
395{
396 myTxt1 = TCollection_ExtendedString(aTxt1);
397}
398
399void Prs2d_ToleranceFrame::SetText2( const Standard_CString aTxt2 )
400{
401 myTxt2 = TCollection_ExtendedString(aTxt2);
402}
403
404TCollection_ExtendedString Prs2d_ToleranceFrame::TolText( ) const
405{
406 return myTolTxt;
407}
408
409TCollection_ExtendedString Prs2d_ToleranceFrame::Text1() const
410{
411 return myTxt1;
412}
413
414TCollection_ExtendedString Prs2d_ToleranceFrame::Text2() const
415{
416 return myTxt2;
417}
418
419Standard_Real Prs2d_ToleranceFrame::TextScale( ) const
420{
421 return myScale;
422}