src/VTKViewer/VTKViewer_Trihedron.cxx

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