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