src/VTKViewer/VTKViewer_Trihedron.cxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 #include "VTKViewer_Trihedron.h"
  23 #include "VTKViewer_Actor.h"
  24
  25 // VTK Includes
  26 #include <vtkMath.h>
  27 #include <vtkMapper.h>
  28 #include <vtkDataSet.h>
  29 #include <vtkRenderer.h>
  30 #include <vtkRenderWindow.h>
  31 #include <vtkObjectFactory.h>
  32
  33 #include <vtkActor.h>
  34 #include <vtkProperty.h>
  35 #include <vtkLineSource.h>
  36 #include <vtkConeSource.h>
  37 #include <vtkPolyDataMapper.h>
  38 #include <vtkVectorText.h>
  39
  40 vtkStandardNewMacro(VTKViewer_UnScaledActor);
  41
  42 /*!Constructor*/
  43 VTKViewer_UnScaledActor::VTKViewer_UnScaledActor()
  44 {
  45   Bounds[0] = Bounds[2] = Bounds[4] = VTK_LARGE_FLOAT;
  46   Bounds[1] = Bounds[3] = Bounds[5] = -VTK_LARGE_FLOAT;
  47 }
  48
  49 /*!
  50   \return bounding box
  51 */
  52 vtkFloatingPointType*
  53 VTKViewer_UnScaledActor
  54 ::GetBounds()
  55 {
  56   return Bounds;
  57 }
  58
  59 /*! Sets \a mySize= \a theSize variable.
  60  * \param  theSize - integer size
  61  */
  62 void VTKViewer_UnScaledActor::SetSize(int theSize)
  63 {
  64   mySize = theSize;
  65 }
  66
  67 /*!This causes the actor to be rendered.
  68  * Set new scale for actor.
  69  */
  70 void VTKViewer_UnScaledActor::Render(vtkRenderer *theRenderer)
  71 {
  72   if(theRenderer){
  73     vtkFloatingPointType P[2][3] = {{-1.0, -1.0, 0.0},{+1.0, +1.0, 0.0}};
  74     theRenderer->ViewToWorld(P[0][0],P[0][1],P[0][2]);
  75     theRenderer->ViewToWorld(P[1][0],P[1][1],P[1][2]);
  76     vtkFloatingPointType aWorldDiag = sqrt((P[1][0]-P[0][0])*(P[1][0]-P[0][0])+
  77                                            (P[1][1]-P[0][1])*(P[1][1]-P[0][1])+
  78                                            (P[1][2]-P[0][2])*(P[1][2]-P[0][2]));
  79     int* aSize = theRenderer->GetRenderWindow()->GetSize();
  80     vtkFloatingPointType aWinDiag = sqrt(vtkFloatingPointType(aSize[0]*aSize[0]+aSize[1]*aSize[1]));
  81     vtkDataSet* aDataSet = GetMapper()->GetInput();
  82     aDataSet->Update();
  83     vtkFloatingPointType aLength = aDataSet->GetLength();
  84     vtkFloatingPointType aPrecision = 1.0E-3;
  85     vtkFloatingPointType anOldScale = GetScale()[0];
  86     vtkFloatingPointType aScale;
  87     if (aSize[1] > aSize[0])
  88       aScale = mySize*aWorldDiag/aWinDiag/aLength*sqrt(vtkFloatingPointType(aSize[0])/vtkFloatingPointType(aSize[1]));
  89     else
  90       aScale = mySize*aWorldDiag/aWinDiag/aLength*sqrt(vtkFloatingPointType(aSize[1])/vtkFloatingPointType(aSize[0]));
  91     if(aScale != 0.0&& fabs(aScale - anOldScale)/aScale > aPrecision){
  92       SetScale(aScale);
  93     }
  94   }
  95   vtkFollower::Render(theRenderer);
  96 }
  97
  98 vtkStandardNewMacro(VTKViewer_LineActor);
  99
 100 vtkCxxSetObjectMacro(VTKViewer_LineActor,LabelActor,VTKViewer_UnScaledActor);
 101 vtkCxxSetObjectMacro(VTKViewer_LineActor,ArrowActor,vtkFollower);
 102
 103 /*!Adds Label and Arrow actors to \a theRenderer.*/
 104 void VTKViewer_LineActor::Render(vtkRenderer *theRenderer)
 105 {
 106   if(LabelActor && LabelActor->GetVisibility()){
 107     LabelActor->Modified();
 108     LabelActor->Render(theRenderer);
 109   }
 110   if(ArrowActor && ArrowActor->GetVisibility()){
 111     ArrowActor->Modified();
 112     ArrowActor->Render(theRenderer);
 113   }
 114   vtkFollower::Render(theRenderer);
 115 }
 116
 117 /*!
 118   Constructor
 119 */
 120 VTKViewer_Axis::VTKViewer_Axis()
 121 {
 122   /*! \li Initialize the Line pipe-line representation*/
 123   myLineSource = vtkLineSource::New();
 124   myLineSource->SetPoint1(0.0,0.0,0.0);
 125
 126   myMapper[0] = vtkPolyDataMapper::New();
 127   myMapper[0]->SetInput(myLineSource->GetOutput());
 128
 129   myLineActor = VTKViewer_LineActor::New();
 130   myLineActor->SetMapper(myMapper[0]);
 131   myLineActor->PickableOff();
 132
 133   /*! \li Initialize the Arrow pipe-line representation*/
 134   myConeSource =  vtkConeSource::New();
 135   myConeSource->SetResolution(16);
 136   myConeSource->SetAngle(10);
 137   myConeSource->SetCenter(-0.5,0.0,0.0);
 138
 139   myMapper[1] = vtkPolyDataMapper::New();
 140   myMapper[1]->SetInput(myConeSource->GetOutput());
 141
 142   myArrowActor = vtkFollower::New();
 143   myArrowActor->SetMapper(myMapper[1]);
 144   static int aArrowActorSize = 16;
 145   myArrowActor->SetScale(aArrowActorSize);
 146   myArrowActor->PickableOff();
 147
 148   myLineActor->SetArrowActor(myArrowActor);
 149
 150   /*! \li Initialize the Label pipe-line representation */
 151   myVectorText = vtkVectorText::New();
 152
 153   myMapper[2] = vtkPolyDataMapper::New();
 154   myMapper[2]->SetInput(myVectorText->GetOutput());
 155
 156   myLabelActor = VTKViewer_UnScaledActor::New();
 157   myLabelActor->SetMapper(myMapper[2]);
 158   static int aLabelActorSize = 12;
 159   myLabelActor->SetSize(aLabelActorSize);
 160   myLabelActor->PickableOff();
 161   //myLabelActor->DebugOn();
 162
 163   myLineActor->SetLabelActor(myLabelActor);
 164
 165   /*! \li Initialise visibility param.*/
 166   myVisibility = VTKViewer_Trihedron::eOn;
 167 }
 168
 169 /*!
 170   Destructor
 171 */
 172 VTKViewer_Axis::~VTKViewer_Axis()
 173 {
 174   /*! \li Destroy of the Label pipe-line representation */
 175   myLabelActor->Delete();
 176
 177   myMapper[0]->RemoveAllInputs();
 178   myMapper[0]->Delete();
 179
 180   myVectorText->Delete();
 181
 182   /*! \li Destroy of the Arrow pipe-line representation */
 183   myArrowActor->Delete();
 184
 185   myMapper[1]->RemoveAllInputs();
 186   myMapper[1]->Delete();
 187
 188   myConeSource->Delete();
 189
 190   /*! \li Destroy of the Line pipe-line representation */
 191   myLineActor->Delete();
 192
 193   myMapper[2]->RemoveAllInputs();
 194   myMapper[2]->Delete();
 195
 196   myLineSource->Delete();
 197 }
 198
 199 /*! Add to renderer
 200  * \param theRenderer - vtkRenderer pointer
 201  */
 202 void VTKViewer_Axis::AddToRender(vtkRenderer* theRenderer){
 203   /*! \li Order of the calls are important*/
 204   theRenderer->AddActor(myLineActor);
 205   theRenderer->AddActor(myLabelActor);
 206   theRenderer->AddActor(myArrowActor);
 207 }
 208
 209 /*! Remove actor of acis from \a theRenderer which are in myPresent.
 210  * \param theRenderer - vtkRenderer pointer
 211  */
 212 void VTKViewer_Axis::RemoveFromRender(vtkRenderer* theRenderer){
 213   /*! \li Order of the calls are important*/
 214   theRenderer->RemoveActor(myLineActor);
 215   theRenderer->RemoveActor(myLabelActor);
 216   theRenderer->RemoveActor(myArrowActor);
 217 }
 218
 219 /*! Sets visibility for all Axis to \a theVis*/
 220 void VTKViewer_Axis::SetVisibility(VTKViewer_Trihedron::TVisibility theVis)
 221 {
 222   switch(theVis){
 223   case VTKViewer_Trihedron::eOff:
 224   case VTKViewer_Trihedron::eOn:
 225     myLabelActor->SetVisibility(theVis);
 226     myArrowActor->SetVisibility(theVis);
 227     myLineActor->SetVisibility(theVis);
 228     break;
 229   case VTKViewer_Trihedron::eOnlyLineOn:
 230     myLabelActor->VisibilityOff();
 231     myArrowActor->VisibilityOff();
 232     myLineActor->VisibilityOn();
 233     break;
 234   default:
 235     return;
 236   }
 237   myVisibility = theVis;
 238 }
 239
 240 /*! Set camera for myLabelActor
 241  */
 242 void VTKViewer_Axis::SetCamera(vtkCamera* theCamera){
 243   myLabelActor->SetCamera(theCamera);
 244 }
 245
 246 /*! Sets \a theProperty for actors: myLineActor,myLabelActor,myArrowActor
 247  */
 248 void VTKViewer_Axis::SetProperty(vtkProperty* theProperty){
 249   myLabelActor->SetProperty(theProperty);
 250   myArrowActor->SetProperty(theProperty);
 251   myLineActor->SetProperty(theProperty);
 252 }
 253
 254 /*! Set size of VTKViewer_Axis
 255  */
 256 void VTKViewer_Axis::SetSize(vtkFloatingPointType theSize)
 257 {
 258   vtkFloatingPointType aPosition[3] = {myDir[0]*theSize, myDir[1]*theSize, myDir[2]*theSize};
 259
 260   vtkFloatingPointType aCoef = 0.99;
 261   vtkFloatingPointType aLinePosition[3] = {aPosition[0]*aCoef, aPosition[1]*aCoef, aPosition[2]*aCoef};
 262   myLineSource->SetPoint2(aLinePosition);
 263
 264   myArrowActor->SetPosition(0.0,0.0,0.0);
 265   myArrowActor->AddPosition(aPosition);
 266   myArrowActor->SetOrientation(myRot);
 267   myArrowActor->SetScale(theSize / 10.);
 268
 269   myLabelActor->SetPosition(0.0,0.0,0.0);
 270   myLabelActor->AddPosition(aPosition);
 271 }
 272
 273 /*! Check if actor belongs to the axis object
 274  * \param theActor - vtkActor pointer
 275  * \retval Return true if the actor belongs to the axis object
 276  */
 277 bool VTKViewer_Axis::OwnActor(const vtkActor* theActor)
 278 {
 279   return theActor == myLineActor  ||
 280          theActor == myArrowActor ||
 281          theActor == myLabelActor;
 282 }
 283
 284 /*! \class VTKViewer_XAxis
 285  * \brief X Axis actor
 286  */
 287 class VTKViewer_XAxis : public VTKViewer_Axis
 288 {
 289 protected:
 290   VTKViewer_XAxis();
 291   VTKViewer_XAxis(const VTKViewer_XAxis&);
 292 public:
 293   vtkTypeMacro(VTKViewer_XAxis,VTKViewer_Axis);
 294   static VTKViewer_XAxis *New();
 295 };
 296
 297 vtkStandardNewMacro(VTKViewer_XAxis);
 298
 299 /*!Initialize X Axis*/
 300 VTKViewer_XAxis::VTKViewer_XAxis(){
 301   myDir[0] = 1.0; myDir[1] = 0.0; myDir[2] = 0.0;
 302   myRot[0] = 0.0; myRot[1] = 0.0; myRot[2] = 0.0;
 303   myVectorText->SetText("X");
 304   vtkProperty* aProperty = vtkProperty::New();
 305   aProperty->SetColor(1.0,0.0,0.0);
 306   SetProperty(aProperty);
 307   aProperty->Delete();
 308 }
 309
 310 /*! \class VTKViewer_YAxis
 311  * \brief Y Axis actor
 312  */
 313 class VTKViewer_YAxis : public VTKViewer_Axis{
 314 protected:
 315   VTKViewer_YAxis();
 316   VTKViewer_YAxis(const VTKViewer_YAxis&);
 317 public:
 318   vtkTypeMacro(VTKViewer_YAxis,VTKViewer_Axis);
 319   static VTKViewer_YAxis *New();
 320 };
 321
 322 vtkStandardNewMacro(VTKViewer_YAxis);
 323
 324 /*!Initialize Y Axis*/
 325 VTKViewer_YAxis::VTKViewer_YAxis()
 326 {
 327   myDir[0] = 0.0; myDir[1] = 1.0; myDir[2] = 0.0;
 328   myRot[0] = 0.0; myRot[1] = 0.0; myRot[2] = 90.;
 329   myVectorText->SetText("Y");
 330   vtkProperty* aProperty = vtkProperty::New();
 331   aProperty->SetColor(0.0,1.0,0.0);
 332   SetProperty(aProperty);
 333   aProperty->Delete();
 334 }
 335
 336 /*! \class VTKViewer_ZAxis
 337  * \brief Z Axis actor
 338  */
 339 class VTKViewer_ZAxis : public VTKViewer_Axis
 340 {
 341 protected:
 342   VTKViewer_ZAxis();
 343   VTKViewer_ZAxis(const VTKViewer_ZAxis&);
 344 public:
 345   vtkTypeMacro(VTKViewer_ZAxis,VTKViewer_Axis);
 346   static VTKViewer_ZAxis *New();
 347 };
 348
 349 vtkStandardNewMacro(VTKViewer_ZAxis);
 350
 351 /*!Initialize Z Axis*/
 352 VTKViewer_ZAxis::VTKViewer_ZAxis()
 353 {
 354   myDir[0] = 0.0; myDir[1] = 0.0; myDir[2] = 1.0;
 355   myRot[0] = 0.0; myRot[1] = -90; myRot[2] = 0.0;
 356   myVectorText->SetText("Z");
 357   vtkProperty* aProperty = vtkProperty::New();
 358   aProperty->SetColor(0.0,0.0,1.0);
 359   SetProperty(aProperty);
 360   aProperty->Delete();
 361 }
 362
 363 vtkStandardNewMacro(VTKViewer_Trihedron);
 364
 365 /*!
 366   Constructor
 367 */
 368 VTKViewer_Trihedron::VTKViewer_Trihedron()
 369 {
 370   myPresent = vtkActorCollection::New();
 371   myAxis[0] = VTKViewer_XAxis::New();
 372   myAxis[1] = VTKViewer_YAxis::New();
 373   myAxis[2] = VTKViewer_ZAxis::New();
 374   static vtkFloatingPointType aSize = 100;
 375   SetSize(aSize);
 376 }
 377
 378 /*!
 379   Destructor
 380 */
 381 VTKViewer_Trihedron::~VTKViewer_Trihedron()
 382 {
 383   myPresent->RemoveAllItems();
 384   myPresent->Delete();
 385   for(int i = 0; i < 3; i++)
 386     myAxis[i]->Delete();
 387 }
 388
 389 /*! Set size of axes
 390  */
 391 void VTKViewer_Trihedron::SetSize(vtkFloatingPointType theSize)
 392 {
 393   mySize = theSize;
 394   for(int i = 0; i < 3; i++)
 395     myAxis[i]->SetSize(theSize);
 396 }
 397
 398 /*! Set visibility of axes
 399  */
 400 void VTKViewer_Trihedron::SetVisibility(TVisibility theVis)
 401 {
 402   for(int i = 0; i < 3; i++)
 403     myAxis[i]->SetVisibility(theVis);
 404 }
 405
 406 /*!
 407   \return visibility of first axis
 408 */
 409 VTKViewer_Trihedron::TVisibility VTKViewer_Trihedron::GetVisibility()
 410 {
 411   return myAxis[0]->GetVisibility();
 412 }
 413
 414 /*! Add to render all Axis
 415  * \param theRenderer - vtkRenderer pointer
 416  */
 417 void VTKViewer_Trihedron::AddToRender(vtkRenderer* theRenderer)
 418 {
 419   vtkCamera* aCamera = theRenderer->GetActiveCamera();
 420   for(int i = 0; i < 3; i++){
 421     myAxis[i]->AddToRender(theRenderer);
 422     myAxis[i]->SetCamera(aCamera);
 423   }
 424 }
 425
 426 /*! Remove all actors from \a theRenderer which are in myPresent.
 427  * \param theRenderer - vtkRenderer pointer
 428  */
 429 void VTKViewer_Trihedron::RemoveFromRender(vtkRenderer* theRenderer)
 430 {
 431   myPresent->InitTraversal();
 432   while(vtkActor* anActor = myPresent->GetNextActor())
 433     theRenderer->RemoveActor(anActor);
 434   for(int i = 0; i < 3; i++)
 435     myAxis[i]->RemoveFromRender(theRenderer);
 436 }
 437
 438 /*! Return count of visible actors.
 439  * \param theRenderer - vtkRenderer pointer
 440  */
 441 int VTKViewer_Trihedron::GetVisibleActorCount(vtkRenderer* theRenderer)
 442 {
 443   //TVisibility aVis = GetVisibility();
 444   //SetVisibility(eOff);
 445   vtkActorCollection* aCollection = theRenderer->GetActors();
 446   aCollection->InitTraversal();
 447   int aCount = 0;
 448   while(vtkActor* prop = aCollection->GetNextActor()) {
 449     if( prop->GetVisibility())
 450       if(VTKViewer_Actor* anActor = VTKViewer_Actor::SafeDownCast(prop)) {
 451         if(!anActor->IsInfinitive())
 452           aCount++;
 453       }
 454       else if ( !OwnActor( anActor ) ) {
 455         aCount++;
 456       }
 457         //int aCount = theRenderer->VisibleActorCount();
 458         //SetVisibility(aVis);
 459   }
 460   return aCount;
 461 }
 462
 463 /*! Check if actor belongs to the axis object
 464  * \param theActor - vtkActor pointer
 465  * \retval Return true if the actor belongs to the axis object
 466  */
 467 bool VTKViewer_Trihedron::OwnActor(const vtkActor* theActor)
 468 {
 469   myPresent->InitTraversal();
 470   while(vtkActor* anActor = myPresent->GetNextActor()) {
 471     if ( anActor == theActor ) return true;
 472   }
 473   for(int i = 0; i < 3; i++) {
 474     if ( myAxis[i]->OwnActor(theActor) ) return true;
 475   }
 476   return false;
 477 }