0023315: Duplicate comarison in an if-clause ib Prs2d_ToleranceFrame.cxx
[occt.git] / src / Prs2d / Prs2d_ToleranceFrame.cxx
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
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
36 Prs2d_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 );
69     gp_Vec2d theVecV = theVecG.Rotated( M_PI / 2 );
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
158 void 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
195     if ( myTolTxt.Length() || myTxt1.Length() || myTxt2.Length() ) {
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 );
207       gp_Vec2d theVecV = theVecG.Rotated( M_PI / 2 );
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
354 Standard_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
364 void Prs2d_ToleranceFrame::SetHeight( const Standard_Real aHSize ) {
365     
366   myHeight = Standard_ShortReal( aHSize ); 
367 }
368
369 Standard_Real Prs2d_ToleranceFrame::Height() const {
370     
371   return myHeight;    
372 }
373
374 void Prs2d_ToleranceFrame::Save(Aspect_FStream& aFStream) const
375 {
376 }
377
378 const 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
389 void Prs2d_ToleranceFrame::SetTolText( const Standard_CString aTolTxt ) 
390 {
391   myTolTxt = TCollection_ExtendedString(aTolTxt);
392 }
393
394 void Prs2d_ToleranceFrame::SetText1( const Standard_CString aTxt1 ) 
395 {
396   myTxt1 = TCollection_ExtendedString(aTxt1);
397 }
398
399 void Prs2d_ToleranceFrame::SetText2( const Standard_CString aTxt2 ) 
400 {
401   myTxt2 = TCollection_ExtendedString(aTxt2);
402 }
403
404 TCollection_ExtendedString Prs2d_ToleranceFrame::TolText( ) const 
405 {
406   return myTolTxt;
407 }
408
409 TCollection_ExtendedString Prs2d_ToleranceFrame::Text1() const 
410 {
411   return myTxt1;
412 }
413
414 TCollection_ExtendedString Prs2d_ToleranceFrame::Text2() const 
415 {
416   return myTxt2;
417 }
418
419 Standard_Real Prs2d_ToleranceFrame::TextScale( ) const
420 {
421   return myScale;
422 }