src/VTKViewer/VTKViewer_Trihedron.cxx

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