src/DsgPrs/DsgPrs_AnglePresentation.cxx

   1 // Created on: 1995-02-07
   2 // Copyright (c) 1995-1999 Matra Datavision
   3 // Copyright (c) 1999-2012 OPEN CASCADE SAS
   4 //
   5 // The content of this file is subject to the Open CASCADE Technology Public
   6 // License Version 6.5 (the "License"). You may not use the content of this file
   7 // except in compliance with the License. Please obtain a copy of the License
   8 // at http://www.opencascade.org and read it completely before using this file.
   9 //
  10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  12 //
  13 // The Original Code and all software distributed under the License is
  14 // distributed on an "AS IS" basis, without warranty of any kind, and the
  15 // Initial Developer hereby disclaims all such warranties, including without
  16 // limitation, any warranties of merchantability, fitness for a particular
  17 // purpose or non-infringement. Please see the License for the specific terms
  18 // and conditions governing the rights and limitations under the License.
  19
  20 #include <DsgPrs_AnglePresentation.ixx>
  21 #include <gp_Lin.hxx>
  22 #include <gp_Dir.hxx>
  23 #include <ElCLib.hxx>
  24 #include <Graphic3d_Group.hxx>
  25 #include <Graphic3d_ArrayOfSegments.hxx>
  26 #include <Graphic3d_ArrayOfPolylines.hxx>
  27 #include <Prs3d_AngleAspect.hxx>
  28 #include <Prs3d_Arrow.hxx>
  29 #include <Prs3d_ArrowAspect.hxx>
  30 #include <Prs3d_LineAspect.hxx>
  31 #include <Prs3d_LengthAspect.hxx>
  32 #include <Prs3d_Text.hxx>
  33 #include <TCollection_AsciiString.hxx>
  34 #include <TCollection_ExtendedString.hxx>
  35
  36 #include <ElCLib.hxx>
  37
  38 #include <Graphic3d_Vertex.hxx>
  39 #include <Graphic3d_AspectMarker3d.hxx>
  40 #include <Graphic3d_AspectLine3d.hxx>
  41 #include <Aspect_TypeOfLine.hxx>
  42 #include <Aspect_TypeOfMarker.hxx>
  43 #include <Aspect_AspectMarker.hxx>
  44 #include <Quantity_Color.hxx>
  45 #include <DsgPrs.hxx>
  46 #include <Precision.hxx>
  47
  48 #include <Geom_Circle.hxx>
  49 #include <Geom_Line.hxx>
  50 #include <GeomAPI_ExtremaCurveCurve.hxx>
  51 #include <GC_MakeCircle.hxx>
  52 #include <gce_MakePln.hxx>
  53
  54 #include <UnitsAPI.hxx>
  55
  56 #include <stdio.h>
  57
  58 //------------------------------------------------------------------------------------------------------------------
  59 // Returns 1 if C is above of CMin; 0 if C is bitween CMin and CMax; -1 if C is Below CMax
  60 //-----------------------------------------------------------------------------------------------------------------
  61 static Standard_Integer AboveInBelowCone(const gp_Circ &CMax, const gp_Circ &CMin, const gp_Circ &C)
  62 {
  63   const Standard_Real D = CMax.Location().Distance( CMin.Location() );
  64   const Standard_Real D1 = CMax.Location().Distance( C.Location() );
  65   const Standard_Real D2 = CMin.Location().Distance( C.Location() );
  66
  67   if ( D >= D1 && D >= D2 ) return 0;
  68   if ( D < D2 && D1 < D2 ) return -1;
  69   if ( D < D1 && D2 < D1 ) return 1;
  70
  71   return 0;
  72 }
  73
  74
  75 //==========================================================================
  76 // function : DsgPrs_AnglePresentation::Add
  77 // purpose  : draws the presentation of the cone's angle;
  78 //==========================================================================
  79 void DsgPrs_AnglePresentation::Add (const Handle(Prs3d_Presentation)& aPresentation,
  80                                     const Handle(Prs3d_Drawer)& aDrawer,
  81                                     const Standard_Real aVal,
  82                                     const TCollection_ExtendedString& aText,
  83                                     const gp_Circ& aCircle,
  84                                     const gp_Pnt& aPosition,
  85                                     const gp_Pnt& Apex,
  86                                     const gp_Circ& VminCircle,
  87                                     const gp_Circ& VmaxCircle,
  88                                     const Standard_Real aArrowSize)
  89 {
  90   Handle(Prs3d_AngleAspect) anAngleAspect = aDrawer->AngleAspect();
  91   Handle(Prs3d_LengthAspect) aLengthAspect = aDrawer->LengthAspect();
  92
  93   TCollection_ExtendedString txt(aText);
  94
  95   const Standard_Real myArrowSize = ( aArrowSize == 0.0 )? (0.1 * aCircle.Radius()) : aArrowSize;
  96
  97   anAngleAspect->ArrowAspect()->SetLength(myArrowSize);
  98   aDrawer->ArrowAspect()->SetLength(myArrowSize);
  99
 100   Standard_Boolean IsConeTrimmed = Standard_False;
 101   gp_Circ myCircle = aCircle;
 102   if( VminCircle.Radius() > 0.01 ) {
 103     IsConeTrimmed = Standard_True;
 104     if( AboveInBelowCone( VmaxCircle, VminCircle, myCircle ) == 1 ) myCircle = VminCircle;
 105   }
 106
 107   gp_Pnt P1 = ElCLib::Value(0., myCircle);
 108   gp_Pnt P2 = ElCLib::Value(M_PI, myCircle);
 109
 110   gce_MakePln mkPln(P1, P2, Apex); // create a plane whitch defines plane for projection aPosition on it
 111
 112   gp_Vec aVector( mkPln.Value().Location(), aPosition );     //project aPosition on a plane
 113   gp_Vec Normal = mkPln.Value().Axis().Direction();
 114   Normal = (aVector * Normal) * Normal;
 115
 116   gp_Pnt aPnt = aPosition;
 117   aPnt = aPnt.Translated( -Normal );
 118
 119   gp_Pnt tmpPnt = aPnt;
 120
 121   gp_Pnt AttachmentPnt, OppositePnt;
 122   if( aPnt.Distance(P1) <  aPnt.Distance(P2) ) {
 123     AttachmentPnt = P1;
 124     OppositePnt = P2;
 125   }
 126   else {
 127     AttachmentPnt = P2;
 128     OppositePnt = P1;
 129   }
 130
 131   aPnt = AttachmentPnt ;                          // Creating of circle whitch defines a plane for a dimension arc
 132   gp_Vec Vec(AttachmentPnt, Apex);                // Dimension arc is a part of the circle
 133   Vec.Scale(2.);
 134   aPnt.Translate(Vec);
 135   GC_MakeCircle mkCirc(AttachmentPnt, OppositePnt, aPnt);
 136   gp_Circ aCircle2 = mkCirc.Value()->Circ();
 137
 138   Standard_Integer i;
 139   Standard_Real AttParam = ElCLib::Parameter(aCircle2, AttachmentPnt);  //must be equal to zero (look circle construction)
 140   Standard_Real OppParam = ElCLib::Parameter(aCircle2, OppositePnt);
 141
 142   while ( AttParam >= 2. * M_PI ) AttParam -= 2. * M_PI;
 143   while ( OppParam >= 2. * M_PI ) OppParam -= 2. * M_PI;
 144
 145   //-------------------------- Compute angle ------------------------
 146   if( txt.Length() == 0 ) {
 147     Standard_Real angle = UnitsAPI::CurrentFromLS( Abs( OppParam ),"PLANE ANGLE");
 148     char res[80];
 149     sprintf(res, "%g", angle );
 150     txt = TCollection_ExtendedString(res);
 151   }
 152   //-----------------------------------------------------------------
 153
 154   Standard_Boolean IsArrowOut = Standard_True;    //Is arrows inside or outside of the cone
 155   if( ElCLib::Parameter(aCircle2, tmpPnt) < OppParam )
 156     if( 2. * myCircle.Radius() > 4. * myArrowSize ) IsArrowOut = Standard_False;  //four times more than an arrow size
 157
 158   Standard_Real angle = OppParam - AttParam;
 159   Standard_Real param = AttParam;
 160
 161   gp_Dir aDir, aDir2;
 162   if(IsArrowOut) {
 163     aDir = gp_Dir( ( gp_Vec( ElCLib::Value( AttParam - M_PI / 12., aCircle2 ), AttachmentPnt) ) );
 164     aDir2 = gp_Dir( ( gp_Vec( ElCLib::Value( OppParam + M_PI / 12., aCircle2 ), OppositePnt) ) );
 165   }
 166   else {
 167     aDir = gp_Dir( ( gp_Vec( ElCLib::Value( AttParam + M_PI / 12., aCircle2 ), AttachmentPnt ) ) );
 168     aDir2 = gp_Dir( ( gp_Vec( ElCLib::Value( OppParam - M_PI / 12., aCircle2 ), OppositePnt ) ) );
 169   }
 170
 171   while ( angle > 2. * M_PI ) angle -= 2. * M_PI;
 172
 173   Handle(Graphic3d_ArrayOfPrimitives) aPrims = new Graphic3d_ArrayOfPolylines(12);
 174   for( i = 0; i <= 11; i++ )
 175     aPrims->AddVertex(ElCLib::Value(param + angle/11 * i, aCircle2));
 176   Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(aPrims);
 177
 178   DsgPrs::ComputeSymbol(aPresentation, anAngleAspect, AttachmentPnt,
 179                         AttachmentPnt, aDir, aDir, DsgPrs_AS_LASTAR);
 180   DsgPrs::ComputeSymbol(aPresentation, anAngleAspect, OppositePnt,
 181                         OppositePnt, aDir2, aDir2, DsgPrs_AS_LASTAR);
 182
 183   param = ElCLib::Parameter(aCircle2, tmpPnt);
 184   tmpPnt = ElCLib::Value(param, aCircle2);
 185   tmpPnt = tmpPnt.Translated(gp_Vec(0, 0, -2));
 186   Prs3d_Text::Draw(aPresentation, aLengthAspect->TextAspect(), txt, tmpPnt);   //add the TCollection_ExtendedString
 187
 188   angle = 2. * M_PI - param ;
 189   if( param > OppParam )
 190   {
 191     while ( angle > 2. * M_PI ) angle -= 2. * M_PI;
 192     aPrims = new Graphic3d_ArrayOfPolylines(12);
 193     for( i = 11; i >= 0; i-- )
 194       aPrims->AddVertex(ElCLib::Value(-angle/11 * i, aCircle2));
 195     Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(aPrims);
 196   }
 197
 198   if( AboveInBelowCone( VmaxCircle, VminCircle, myCircle ) == 1 && !IsConeTrimmed )         //above
 199   {
 200     aPrims = new Graphic3d_ArrayOfPolylines(3);
 201     aPrims->AddVertex(AttachmentPnt);
 202     aPrims->AddVertex(Apex);
 203     aPrims->AddVertex(OppositePnt);
 204   }
 205   else
 206   {
 207     aPnt = OppositePnt ;
 208     if ( AboveInBelowCone( VmaxCircle, VminCircle, myCircle ) == 0 ) return;
 209
 210     gp_Pnt P11 = ElCLib::Value( 0., VmaxCircle );
 211     gp_Pnt P12 = ElCLib::Value( M_PI, VmaxCircle );
 212
 213     aPrims = new Graphic3d_ArrayOfSegments(4);
 214     aPrims->AddVertex(AttachmentPnt);
 215     aPrims->AddVertex(( aPnt.Distance(P1) < aPnt.Distance(P2) )? P12 : P11);
 216     aPrims->AddVertex(OppositePnt);
 217     aPrims->AddVertex(( aPnt.Distance(P1) < aPnt.Distance(P2) )? P11 : P12);
 218   }
 219   Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(aPrims);
 220 }
 221
 222
 223 //==========================================================================
 224 // function : DsgPrs_AnglePresentation::Add
 225 // purpose  :
 226 //
 227 //==========================================================================
 228
 229 void DsgPrs_AnglePresentation::Add (const Handle(Prs3d_Presentation)& aPresentation,
 230                                     const Handle(Prs3d_Drawer)& aDrawer,
 231                                     const Standard_Real theval,
 232                                     const TCollection_ExtendedString& aText,
 233                                     const gp_Pnt& CenterPoint,
 234                                     const gp_Pnt& AttachmentPoint1,
 235                                     const gp_Pnt& AttachmentPoint2,
 236                                     const gp_Dir& dir1,
 237                                     const gp_Dir& dir2,
 238                                     const gp_Dir& axisdir,
 239                                     const gp_Pnt& OffsetPoint)
 240 {
 241   char valcar[80];
 242   sprintf(valcar,"%5.2f",theval);
 243
 244   Handle(Prs3d_AngleAspect) LA = aDrawer->AngleAspect();
 245   Prs3d_Root::CurrentGroup(aPresentation)->SetPrimitivesAspect(LA->LineAspect()->Aspect());
 246
 247   gp_Ax2 ax(CenterPoint,axisdir,dir1);
 248   gp_Circ cer(ax,CenterPoint.Distance(OffsetPoint));
 249   gp_Vec vec1(dir1);
 250   vec1 *= cer.Radius();
 251   gp_Vec vec2(dir2);
 252   vec2 *= cer.Radius();
 253   gp_Pnt p2 = CenterPoint.Translated(vec2);
 254
 255   Standard_Real uc1 = 0.;
 256   Standard_Real uc2 = ElCLib::Parameter(cer,p2);
 257   Standard_Real uco = ElCLib::Parameter(cer,OffsetPoint);
 258
 259   Standard_Real udeb = uc1;
 260   Standard_Real ufin = uc2;
 261
 262   if (uco > ufin) {
 263     if (Abs(theval)<M_PI) {
 264       // test if uco is in the opposite sector
 265       if (uco > udeb+M_PI && uco < ufin+M_PI) {
 266         udeb += M_PI;
 267         ufin += M_PI;
 268         uc1 = udeb;
 269         uc2 = ufin;
 270       }
 271     }
 272   }
 273
 274   if (uco > ufin) {
 275     if ((uco-uc2) < (uc1-uco+(2.*M_PI))) {
 276       ufin = uco;
 277     }
 278     else {
 279       udeb = uco - 2.*M_PI;
 280     }
 281   }
 282
 283   const Standard_Real alpha = Abs(ufin-udeb);
 284   const Standard_Integer nbp = Max (4 , Standard_Integer (50. * alpha / M_PI));
 285   const Standard_Real dteta = alpha/(nbp-1);
 286
 287   Handle(Graphic3d_ArrayOfPolylines) aPrims = new Graphic3d_ArrayOfPolylines(nbp+4,3);
 288   aPrims->AddBound(nbp);
 289   for (Standard_Integer i = 1; i<=nbp; i++)
 290     aPrims->AddVertex(ElCLib::Value(udeb+ dteta*(i-1),cer));
 291
 292   Prs3d_Text::Draw(aPresentation,LA->TextAspect(),aText,OffsetPoint);
 293
 294   Standard_Real length = LA->ArrowAspect()->Length();
 295   if (length <  Precision::Confusion()) length = 1.e-04;
 296
 297   gp_Vec vecarr;
 298   gp_Pnt ptarr;
 299   ElCLib::D1(uc1,cer,ptarr,vecarr);
 300
 301   gp_Ax1 ax1(ptarr, axisdir);
 302   gp_Dir dirarr(-vecarr);
 303
 304   //calculate angle of rotation
 305   gp_Pnt ptarr2(ptarr.XYZ() + length*dirarr.XYZ());
 306   const Standard_Real parcir = ElCLib::Parameter(cer, ptarr2);
 307   gp_Pnt ptarr3 = ElCLib::Value(parcir, cer);
 308   gp_Vec v1(ptarr,ptarr2);
 309   gp_Vec v2(ptarr,ptarr3);
 310   const Standard_Real beta = v1.Angle(v2);
 311   dirarr.Rotate(ax1, beta);
 312   Prs3d_Arrow::Draw(aPresentation,ptarr,dirarr,LA->ArrowAspect()->Angle(),length);
 313
 314   aPrims->AddBound(2);
 315   aPrims->AddVertex(AttachmentPoint1);
 316   aPrims->AddVertex(ptarr);
 317
 318   ElCLib::D1(uc2,cer,ptarr,vecarr);
 319
 320   ax1.SetLocation(ptarr);
 321   gp_Dir dirarr2(vecarr);
 322   dirarr2.Rotate(ax1,-beta);
 323   Prs3d_Arrow::Draw(aPresentation,ptarr,dirarr2,LA->ArrowAspect()->Angle(),length);
 324
 325   aPrims->AddBound(2);
 326   aPrims->AddVertex(AttachmentPoint2);
 327   aPrims->AddVertex(ptarr);
 328
 329   Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(aPrims);
 330 }
 331
 332
 333 //==========================================================================
 334 // function : DsgPrs_AnglePresentation::Add
 335 // purpose  : Adds prezentation of angle between two faces
 336 //==========================================================================
 337
 338 void DsgPrs_AnglePresentation::Add (const Handle(Prs3d_Presentation)& aPresentation,
 339                                     const Handle(Prs3d_Drawer)& aDrawer,
 340                                     const Standard_Real theval,
 341                                     const TCollection_ExtendedString& aText,
 342                                     const gp_Pnt& CenterPoint,
 343                                     const gp_Pnt& AttachmentPoint1,
 344                                     const gp_Pnt& AttachmentPoint2,
 345                                     const gp_Dir& dir1,
 346                                     const gp_Dir& dir2,
 347                                     const gp_Dir& axisdir,
 348                                     const Standard_Boolean isPlane,
 349                                     const gp_Ax1& AxisOfSurf,
 350                                     const gp_Pnt& OffsetPoint,
 351                                     const DsgPrs_ArrowSide ArrowPrs )
 352 {
 353   char valcar[80];
 354   sprintf(valcar,"%5.2f",theval);
 355
 356   Handle( Prs3d_AngleAspect ) LA = aDrawer->AngleAspect();
 357   Prs3d_Root::CurrentGroup( aPresentation )->SetPrimitivesAspect( LA->LineAspect()->Aspect() );
 358
 359   gp_Circ AngleCirc, AttachCirc;
 360   Standard_Real FirstParAngleCirc, LastParAngleCirc, FirstParAttachCirc, LastParAttachCirc;
 361   gp_Pnt EndOfArrow1, EndOfArrow2, ProjAttachPoint2;
 362   gp_Dir DirOfArrow1, DirOfArrow2;
 363   DsgPrs::ComputeFacesAnglePresentation( LA->ArrowAspect()->Length(),
 364                                          theval,
 365                                          CenterPoint,
 366                                          AttachmentPoint1,
 367                                          AttachmentPoint2,
 368                                          dir1,
 369                                          dir2,
 370                                          axisdir,
 371                                          isPlane,
 372                                          AxisOfSurf,
 373                                          OffsetPoint,
 374                                          AngleCirc,
 375                                          FirstParAngleCirc,
 376                                          LastParAngleCirc,
 377                                          EndOfArrow1,
 378                                          EndOfArrow2,
 379                                          DirOfArrow1,
 380                                          DirOfArrow2,
 381                                          ProjAttachPoint2,
 382                                          AttachCirc,
 383                                          FirstParAttachCirc,
 384                                          LastParAttachCirc );
 385
 386   // Creating the angle's arc or line if null angle
 387   Handle(Graphic3d_ArrayOfPrimitives) aPrims;
 388   if (theval > Precision::Angular() && Abs( M_PI-theval ) > Precision::Angular())
 389   {
 390     const Standard_Real Alpha  = Abs( LastParAngleCirc - FirstParAngleCirc );
 391     const Standard_Integer NodeNumber = Max (4 , Standard_Integer (50. * Alpha / M_PI));
 392     const Standard_Real delta = Alpha / (Standard_Real)( NodeNumber - 1 );
 393
 394     aPrims = new Graphic3d_ArrayOfPolylines(NodeNumber+4,3);
 395     aPrims->AddBound(NodeNumber);
 396     for (Standard_Integer i = 0; i < NodeNumber; i++, FirstParAngleCirc += delta)
 397       aPrims->AddVertex(ElCLib::Value( FirstParAngleCirc, AngleCirc ));
 398
 399     Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(aPrims);
 400     aPrims = new Graphic3d_ArrayOfSegments(4);
 401   }
 402   else // null angle
 403   {
 404     aPrims = new Graphic3d_ArrayOfSegments(6);
 405     aPrims->AddVertex(OffsetPoint);
 406     aPrims->AddVertex(EndOfArrow1);
 407   }
 408
 409   // Add presentation of arrows
 410   DsgPrs::ComputeSymbol( aPresentation, LA, EndOfArrow1, EndOfArrow2, DirOfArrow1, DirOfArrow2, ArrowPrs );
 411
 412   // Drawing the text
 413   Prs3d_Text::Draw( aPresentation, LA->TextAspect(), aText, OffsetPoint );
 414
 415   // Line from AttachmentPoint1 to end of Arrow1
 416   aPrims->AddVertex(AttachmentPoint1);
 417   aPrims->AddVertex(EndOfArrow1);
 418   // Line from "projection" of AttachmentPoint2 to end of Arrow2
 419   aPrims->AddVertex(ProjAttachPoint2);
 420   aPrims->AddVertex(EndOfArrow2);
 421
 422   Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(aPrims);
 423
 424   // Line or arc from AttachmentPoint2 to its "projection"
 425   if (AttachmentPoint2.Distance( ProjAttachPoint2 ) > Precision::Confusion())
 426   {
 427     if (isPlane)
 428         {
 429           // Creating the line from AttachmentPoint2 to its projection
 430       aPrims = new Graphic3d_ArrayOfSegments(2);
 431       aPrims->AddVertex(AttachmentPoint2);
 432       aPrims->AddVertex(ProjAttachPoint2);
 433         }
 434     else
 435         {
 436           // Creating the arc from AttachmentPoint2 to its projection
 437       const Standard_Real Alpha = Abs( LastParAttachCirc - FirstParAttachCirc );
 438           const Standard_Integer NodeNumber = Max (4 , Standard_Integer (50. * Alpha / M_PI));
 439       const Standard_Real delta = Alpha / (Standard_Real)( NodeNumber - 1 );
 440
 441       aPrims = new Graphic3d_ArrayOfPolylines(NodeNumber);
 442           for (Standard_Integer i = 0; i < NodeNumber; i++, FirstParAttachCirc += delta)
 443         aPrims->AddVertex(ElCLib::Value( FirstParAttachCirc, AttachCirc ));
 444         }
 445     Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(aPrims);
 446   }
 447 }
 448
 449
 450 //==========================================================================
 451 // function : DsgPrs_AnglePresentation::Add
 452 // purpose  :
 453 //
 454 //==========================================================================
 455
 456 void DsgPrs_AnglePresentation::Add (const Handle(Prs3d_Presentation)& aPresentation,
 457                                     const Handle(Prs3d_Drawer)& aDrawer,
 458                                     const Standard_Real theval,
 459                                     const TCollection_ExtendedString& aText,
 460                                     const gp_Pnt& CenterPoint,
 461                                     const gp_Pnt& AttachmentPoint1,
 462                                     const gp_Pnt& AttachmentPoint2,
 463                                     const gp_Dir& dir1,
 464                                     const gp_Dir& dir2,
 465                                     const gp_Pnt& OffsetPoint)
 466 {
 467   char valcar[80];
 468   sprintf(valcar,"%5.2f",theval);
 469
 470   Handle(Prs3d_AngleAspect) LA = aDrawer->AngleAspect();
 471   Prs3d_Root::CurrentGroup(aPresentation)->SetPrimitivesAspect(LA->LineAspect()->Aspect());
 472
 473   gp_Dir Norm;
 474   if (!dir1.IsParallel(dir2, Precision::Angular())) {
 475     Norm = dir1.Crossed(dir2);
 476   }
 477   else {
 478     gp_Dir dir2B = gp_Dir(gp_Vec(CenterPoint, OffsetPoint));
 479     Norm = dir1.Crossed(dir2B);
 480   }
 481
 482   if (Abs(theval) > M_PI) Norm.Reverse();
 483
 484   gp_Ax2 ax(CenterPoint,Norm,dir1);
 485   gp_Circ cer(ax,CenterPoint.Distance(OffsetPoint));
 486   gp_Vec vec1(dir1);
 487   vec1 *= cer.Radius();
 488   gp_Vec vec2(dir2);
 489   vec2 *= cer.Radius();
 490   gp_Pnt p2 = CenterPoint.Translated(vec2);
 491
 492   Standard_Real uc1 = 0.;
 493   Standard_Real uc2 = ElCLib::Parameter(cer,p2);
 494   Standard_Real uco = ElCLib::Parameter(cer,OffsetPoint);
 495
 496   Standard_Real udeb = uc1;
 497   Standard_Real ufin = uc2;
 498
 499   if (uco > ufin) {
 500     if (Abs(theval)<M_PI) {
 501       // test if uco is in the opposite sector
 502       if (uco > udeb+M_PI && uco < ufin+M_PI) {
 503         udeb += M_PI;
 504         ufin += M_PI;
 505         uc1 = udeb;
 506         uc2 = ufin;
 507       }
 508     }
 509   }
 510
 511   if (uco > ufin) {
 512     if ((uco-uc2) < (uc1-uco+(2.*M_PI))) {
 513       ufin = uco;
 514     }
 515     else {
 516       udeb = uco - 2.*M_PI;
 517     }
 518   }
 519
 520   const Standard_Real alpha = Abs(ufin-udeb);
 521   const Standard_Integer nbp = Max (4 , Standard_Integer (50. * alpha / M_PI));
 522   const Standard_Real dteta = alpha/(nbp-1);
 523
 524   Handle(Graphic3d_ArrayOfPolylines) aPrims = new Graphic3d_ArrayOfPolylines(nbp+4,3);
 525   aPrims->AddBound(nbp);
 526   for (Standard_Integer i = 1; i<=nbp; i++)
 527     aPrims->AddVertex(ElCLib::Value(udeb+ dteta*(i-1),cer));
 528
 529   Prs3d_Text::Draw(aPresentation,LA->TextAspect(),aText,OffsetPoint);
 530
 531   Standard_Real length = LA->ArrowAspect()->Length();
 532   if (length <  Precision::Confusion()) length = 1.e-04;
 533
 534   gp_Vec vecarr;
 535   gp_Pnt ptarr;
 536   ElCLib::D1(uc1,cer,ptarr,vecarr);
 537
 538   gp_Ax1 ax1(ptarr, Norm);
 539   gp_Dir dirarr(-vecarr);
 540   //calculate the angle of rotation
 541   gp_Pnt ptarr2(ptarr.XYZ() + length*dirarr.XYZ());
 542   const Standard_Real parcir = ElCLib::Parameter(cer, ptarr2);
 543   gp_Pnt ptarr3 = ElCLib::Value(parcir, cer);
 544   gp_Vec v1(ptarr,ptarr2);
 545   gp_Vec v2(ptarr,ptarr3);
 546   const Standard_Real beta = v1.Angle(v2);
 547   dirarr.Rotate(ax1, beta);
 548   Prs3d_Arrow::Draw(aPresentation,ptarr,dirarr,LA->ArrowAspect()->Angle(),length);
 549
 550   aPrims->AddBound(2);
 551   aPrims->AddVertex(AttachmentPoint1);
 552   aPrims->AddVertex(ptarr);
 553
 554   ElCLib::D1(uc2,cer,ptarr,vecarr);
 555
 556   ax1.SetLocation(ptarr);
 557   gp_Dir dirarr2(vecarr);
 558   dirarr2.Rotate(ax1,  - beta);
 559   Prs3d_Arrow::Draw(aPresentation,ptarr,dirarr2,LA->ArrowAspect()->Angle(),length);
 560
 561   aPrims->AddBound(2);
 562   aPrims->AddVertex(AttachmentPoint2);
 563   aPrims->AddVertex(ptarr);
 564
 565   Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(aPrims);
 566 }
 567
 568
 569 //==========================================================================
 570 // function : DsgPrs_AnglePresentation::Add
 571 // purpose  : It is possible to choose the symbol of extremities of the face (arrow, point...)
 572 //==========================================================================
 573
 574 void DsgPrs_AnglePresentation::Add (const Handle(Prs3d_Presentation)& aPresentation,
 575                                     const Handle(Prs3d_Drawer)& aDrawer,
 576                                     const Standard_Real theval,
 577                                     const TCollection_ExtendedString& aText,
 578                                     const gp_Pnt& CenterPoint,
 579                                     const gp_Pnt& AttachmentPoint1,
 580                                     const gp_Pnt& AttachmentPoint2,
 581                                     const gp_Dir& dir1,
 582                                     const gp_Dir& dir2,
 583                                     const gp_Pnt& OffsetPoint,
 584                                     const DsgPrs_ArrowSide ArrowPrs)
 585 {
 586   char valcar[80];
 587   sprintf(valcar,"%5.2f",theval);
 588
 589   Handle(Prs3d_AngleAspect) LA = aDrawer->AngleAspect();
 590   Prs3d_Root::CurrentGroup(aPresentation)->SetPrimitivesAspect(LA->LineAspect()->Aspect());
 591
 592   gp_Dir Norm = dir1.Crossed(dir2);
 593   if (Abs(theval) > M_PI) Norm.Reverse();
 594
 595   gp_Ax2 ax(CenterPoint,Norm,dir1);
 596   gp_Circ cer(ax,CenterPoint.Distance(OffsetPoint));
 597   gp_Vec vec1(dir1);
 598   vec1 *= cer.Radius();
 599   gp_Vec vec2(dir2);
 600   vec2 *= cer.Radius();
 601   gp_Pnt p2 = CenterPoint.Translated(vec2);
 602
 603   Standard_Real uc1 = 0.;
 604   Standard_Real uc2 = ElCLib::Parameter(cer,p2);
 605   Standard_Real uco = ElCLib::Parameter(cer,OffsetPoint);
 606
 607   Standard_Real udeb = uc1;
 608   Standard_Real ufin = uc2;
 609
 610   if (uco > ufin) {
 611     if (Abs(theval)<M_PI) {
 612       // test if uco is in the opposite sector
 613       if (uco > udeb+M_PI && uco < ufin+M_PI) {
 614         udeb += M_PI;
 615         ufin += M_PI;
 616         uc1 = udeb;
 617         uc2 = ufin;
 618       }
 619     }
 620   }
 621
 622   if (uco > ufin) {
 623     if ((uco-uc2) < (uc1-uco+(2.*M_PI))) {
 624       ufin = uco;
 625     }
 626     else {
 627       udeb = uco - 2.*M_PI;
 628     }
 629   }
 630
 631   const Standard_Real alpha = Abs(ufin-udeb);
 632   const Standard_Integer nbp = Max (4 , Standard_Integer (50. * alpha / M_PI));
 633   const Standard_Real dteta = alpha/(nbp-1);
 634
 635   Handle(Graphic3d_ArrayOfPolylines) aPrims = new Graphic3d_ArrayOfPolylines(nbp+4,3);
 636   aPrims->AddBound(nbp);
 637   for (Standard_Integer i = 1; i<=nbp; i++)
 638     aPrims->AddVertex(ElCLib::Value(udeb+ dteta*(i-1),cer));
 639
 640   Prs3d_Text::Draw(aPresentation,LA->TextAspect(),aText,OffsetPoint);
 641
 642   Standard_Real length = LA->ArrowAspect()->Length();
 643   if (length <  Precision::Confusion()) length = 1.e-04;
 644
 645   // Lines of recall
 646   gp_Vec vecarr;
 647   gp_Pnt ptarr;
 648   ElCLib::D1(uc1,cer,ptarr,vecarr);
 649
 650   gp_Ax1 ax1(ptarr, Norm);
 651   gp_Dir dirarr(-vecarr);
 652   //calculate angle of rotation
 653   gp_Pnt ptarr2(ptarr.XYZ() + length*dirarr.XYZ());
 654   const Standard_Real parcir = ElCLib::Parameter(cer, ptarr2);
 655   gp_Pnt ptarr3 = ElCLib::Value(parcir, cer);
 656   gp_Vec v1(ptarr,ptarr2 );
 657   gp_Vec v2(ptarr, ptarr3);
 658   const Standard_Real beta = v1.Angle(v2);
 659   dirarr.Rotate(ax1, beta);
 660
 661   aPrims->AddBound(2);
 662   aPrims->AddVertex(AttachmentPoint1);
 663   aPrims->AddVertex(ptarr);
 664
 665   gp_Vec vecarr1;
 666   gp_Pnt ptarr1;
 667   ElCLib::D1(uc2,cer,ptarr1,vecarr1);
 668   ax1.SetLocation(ptarr1);
 669   gp_Dir dirarr2(vecarr1);
 670   dirarr2.Rotate(ax1,  - beta);
 671
 672   aPrims->AddBound(2);
 673   aPrims->AddVertex(AttachmentPoint2);
 674   aPrims->AddVertex(ptarr1);
 675
 676   Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(aPrims);
 677
 678   // One traces the arrows
 679   DsgPrs::ComputeSymbol(aPresentation,LA,ptarr,ptarr1,dirarr,dirarr2,ArrowPrs);
 680 }
 681
 682
 683 //==========================================================================
 684 // function : DsgPrs_AnglePresentation::Add
 685 // purpose  :
 686 //
 687 //==========================================================================
 688
 689 void DsgPrs_AnglePresentation::Add (const Handle(Prs3d_Presentation)& aPresentation,
 690                                     const Handle(Prs3d_Drawer)& aDrawer,
 691                                     const Standard_Real theval,
 692                                     const gp_Pnt& CenterPoint,
 693                                     const gp_Pnt& AttachmentPoint1,
 694                                     const gp_Pnt& AttachmentPoint2,
 695                                     const gp_Dir& dir1,
 696                                     const gp_Dir& dir2,
 697                                     const gp_Pnt& OffsetPoint)
 698 {
 699   char valcar[80];
 700   sprintf(valcar,"%5.2f",theval);
 701
 702   TCollection_AsciiString valas(valcar);
 703   TCollection_ExtendedString aText(valas);
 704
 705   Handle(Prs3d_AngleAspect) LA = aDrawer->AngleAspect();
 706   Prs3d_Root::CurrentGroup(aPresentation)->SetPrimitivesAspect(LA->LineAspect()->Aspect());
 707
 708   gp_Dir Norm = dir1.Crossed(dir2);
 709   if (Abs(theval) > M_PI) Norm.Reverse();
 710
 711   gp_Ax2 ax(CenterPoint,Norm,dir1);
 712   gp_Circ cer(ax,CenterPoint.Distance(OffsetPoint));
 713   gp_Vec vec1(dir1);
 714   vec1 *= cer.Radius();
 715   gp_Vec vec2(dir2);
 716   vec2 *= cer.Radius();
 717   gp_Pnt p2 = CenterPoint.Translated(vec2);
 718
 719   Standard_Real uc1 = 0.;
 720   Standard_Real uc2 = ElCLib::Parameter(cer,p2);
 721   Standard_Real uco = ElCLib::Parameter(cer,OffsetPoint);
 722
 723   Standard_Real udeb = uc1;
 724   Standard_Real ufin = uc2;
 725
 726   if (uco > ufin) {
 727     if (Abs(theval)<M_PI) {
 728       // test if uco is in the opposite sector
 729       if (uco > udeb+M_PI && uco < ufin+M_PI) {
 730         udeb += M_PI;
 731         ufin += M_PI;
 732         uc1 = udeb;
 733         uc2 = ufin;
 734       }
 735     }
 736   }
 737
 738   if (uco > ufin) {
 739     if ((uco-uc2) < (uc1-uco+(2.*M_PI))) {
 740       ufin = uco;
 741     }
 742     else {
 743       udeb = uco - 2.*M_PI;
 744     }
 745   }
 746
 747   const Standard_Real alpha = Abs(ufin-udeb);
 748   const Standard_Integer nbp = Max (4 , Standard_Integer (50. * alpha / M_PI));
 749   const Standard_Real dteta = alpha/(nbp-1);
 750
 751   Handle(Graphic3d_ArrayOfPolylines) aPrims = new Graphic3d_ArrayOfPolylines(nbp+4,3);
 752   aPrims->AddBound(nbp);
 753   for (Standard_Integer i = 1; i<=nbp; i++)
 754     aPrims->AddVertex(ElCLib::Value(udeb+ dteta*(i-1),cer));
 755
 756   Prs3d_Text::Draw(aPresentation,LA->TextAspect(),aText,OffsetPoint);
 757
 758   Standard_Real length = LA->ArrowAspect()->Length();
 759   if (length <  Precision::Confusion()) length = 1.e-04;
 760
 761   gp_Vec vecarr;
 762   gp_Pnt ptarr;
 763   ElCLib::D1(uc1,cer,ptarr,vecarr);
 764
 765   gp_Ax1 ax1(ptarr, Norm);
 766   gp_Dir dirarr(-vecarr);
 767   //calculate the angle of rotation
 768   gp_Pnt ptarr2(ptarr.XYZ() + length*dirarr.XYZ());
 769   const Standard_Real parcir = ElCLib::Parameter(cer, ptarr2);
 770   gp_Pnt ptarr3 = ElCLib::Value(parcir, cer);
 771   gp_Vec v1(ptarr,ptarr2 );
 772   gp_Vec v2(ptarr, ptarr3);
 773   const Standard_Real beta = v1.Angle(v2);
 774   dirarr.Rotate(ax1, beta);
 775
 776   Prs3d_Arrow::Draw(aPresentation,ptarr,dirarr,LA->ArrowAspect()->Angle(),length);
 777
 778   aPrims->AddBound(2);
 779   aPrims->AddVertex(AttachmentPoint1);
 780   aPrims->AddVertex(ptarr);
 781
 782   ElCLib::D1(uc2,cer,ptarr,vecarr);
 783   ax1.SetLocation(ptarr);
 784   gp_Dir dirarr2(vecarr);
 785   dirarr2.Rotate(ax1, -beta);
 786
 787   Prs3d_Arrow::Draw(aPresentation,ptarr,dirarr2,LA->ArrowAspect()->Angle(),length);
 788
 789   aPrims->AddBound(2);
 790   aPrims->AddVertex(AttachmentPoint2);
 791   aPrims->AddVertex(ptarr);
 792
 793   Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(aPrims);
 794 }
 795
 796 void DsgPrs_AnglePresentation::Add (const Handle(Prs3d_Presentation)& aPresentation,
 797                                     const Handle(Prs3d_Drawer)& aDrawer,
 798                                     const Standard_Real theval,
 799                                     const gp_Pnt& CenterPoint,
 800                                     const gp_Pnt& AttachmentPoint1,
 801                                     const gp_Ax1& theAxe,
 802                                     const DsgPrs_ArrowSide ArrowSide)
 803 {
 804   Handle(Prs3d_AngleAspect) LA = aDrawer->AngleAspect();
 805   Prs3d_Root::CurrentGroup(aPresentation)->SetPrimitivesAspect(LA->LineAspect()->Aspect());
 806
 807   gp_Dir dir1(gp_Vec(CenterPoint, AttachmentPoint1));
 808   gp_Ax2 ax(CenterPoint,theAxe.Direction(),dir1);
 809   gp_Circ cer(ax,CenterPoint.Distance(AttachmentPoint1));
 810
 811   const Standard_Integer nbp = Max (4 , Standard_Integer (50. * theval / M_PI));
 812   const Standard_Real dteta = theval/(nbp-1);
 813
 814   Handle(Graphic3d_ArrayOfPolylines) aPrims = new Graphic3d_ArrayOfPolylines(nbp);
 815   for (Standard_Integer i = 1; i<=nbp; i++)
 816     aPrims->AddVertex(ElCLib::Value(dteta*(i-1),cer));
 817   Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(aPrims);
 818
 819   Standard_Real uc1 = 0.;
 820   Standard_Real uc2 = ElCLib::Parameter(cer,AttachmentPoint1.Rotated(theAxe,theval));
 821
 822   Standard_Real length = LA->ArrowAspect()->Length();
 823   if (length < Precision::Confusion()) length = 1.e-04;
 824
 825   gp_Vec vecarr;
 826   gp_Pnt ptarr;
 827   switch(ArrowSide)
 828   {
 829     case DsgPrs_AS_FIRSTAR:
 830     {
 831       ElCLib::D1(uc1,cer,ptarr,vecarr);
 832       Prs3d_Arrow::Draw(aPresentation,ptarr,gp_Dir(-vecarr),LA->ArrowAspect()->Angle(),length);
 833       break;
 834     }
 835     case DsgPrs_AS_LASTAR:
 836     {
 837       ElCLib::D1(uc2,cer,ptarr,vecarr);
 838       Prs3d_Arrow::Draw(aPresentation,ptarr,gp_Dir(vecarr),LA->ArrowAspect()->Angle(),length);
 839       break;
 840     }
 841     case DsgPrs_AS_BOTHAR:
 842     {
 843       ElCLib::D1(uc1,cer,ptarr,vecarr);
 844       Prs3d_Arrow::Draw(aPresentation,ptarr,gp_Dir(-vecarr),LA->ArrowAspect()->Angle(),length);
 845       ElCLib::D1(uc2,cer,ptarr,vecarr);
 846       Prs3d_Arrow::Draw(aPresentation,ptarr,gp_Dir(vecarr),LA->ArrowAspect()->Angle(),length);
 847       break;
 848     }
 849     default: break;
 850   }
 851 }