src/OBJECT/GEOM_VTKTrihedron.cxx

   1 // Copyright (C) 2007-2021  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, or (at your option) any later version.
  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
  23 //  SALOME GEOM :
  24 //  File   : GEOM_VTKTrihedron.cxx
  25 //  Author : Sergey LITONIN
  26 //  Module : SALOME
  27 //
  28 #include "GEOM_VTKTrihedron.hxx"
  29
  30 #include <Geom_Axis2Placement.hxx>
  31 #include <gp_Ax2.hxx>
  32 #include <gp_Ax3.hxx>
  33 #include <gp_Pnt.hxx>
  34
  35 #include <vtkMapper.h>
  36 #include <vtkRenderer.h>
  37 #include <vtkObjectFactory.h>
  38 #include <vtkActor.h>
  39 #include <vtkActorCollection.h>
  40 #include <vtkProperty.h>
  41 #include <vtkLineSource.h>
  42 #include <vtkPolyDataMapper.h>
  43 #include <vtkAppendPolyData.h>
  44 #include <vtkMatrix4x4.h>
  45 #include <vtkTransform.h>
  46 #include <vtkVectorText.h>
  47 #include <vtkCoordinate.h>
  48 #include <vtkTextActor.h>
  49 #include <vtkTextMapper.h>
  50
  51 /*
  52   Class       : GEOM_VTKTrihedron
  53   Description : Class for displaying axis of trihedron in VTK viewer.
  54                 Placement of trihedron is changed with SetPlacement() method
  55 */
  56 class GEOM_VTKTrihedronAxis : public VTKViewer_Axis
  57 {
  58 protected:
  59
  60                                 GEOM_VTKTrihedronAxis();
  61                                 GEOM_VTKTrihedronAxis( const GEOM_VTKTrihedronAxis& );
  62                                 ~GEOM_VTKTrihedronAxis();
  63
  64 public:
  65
  66                                 vtkTypeMacro( GEOM_VTKTrihedronAxis, VTKViewer_Axis )
  67   static GEOM_VTKTrihedronAxis* New();
  68
  69   void                          SetAxis( const gp_Ax1& theAxis, const int theRot, double theColor[ 3 ] );
  70   virtual void                  Render( vtkRenderer* theRenderer );
  71   virtual void                  SetSize( double theSize );
  72   gp_Pnt                        GetOri() const;
  73   void                          SetColor( const double theColor[ 3 ] );
  74
  75 private:
  76
  77   double          myOri[ 3 ];
  78   vtkMatrix4x4*                 myMatrix;
  79   vtkTransform*                 myTrsf;
  80 };
  81
  82 vtkStandardNewMacro( GEOM_VTKTrihedronAxis )
  83
  84 GEOM_VTKTrihedronAxis::GEOM_VTKTrihedronAxis()
  85 {
  86   VTKViewer_Axis::SetColor( 0.0, 0.0, 1.0 );
  87   myMatrix = vtkMatrix4x4::New();
  88   myTrsf = vtkTransform::New();
  89 }
  90
  91 GEOM_VTKTrihedronAxis::~GEOM_VTKTrihedronAxis()
  92 {
  93   myMatrix->Delete();
  94   myTrsf->Delete();
  95 }
  96
  97 void GEOM_VTKTrihedronAxis::SetSize( double theSize )
  98 {
  99   double aPosition[ 3 ] = { myOri[ 0 ] + myDir[ 0 ] * theSize,
 100                                           myOri[ 1 ] + myDir[ 1 ] * theSize,
 101                                           myOri[ 2 ] + myDir[ 2 ] * theSize };
 102
 103   myLineSource->SetPoint1( myOri[ 0 ], myOri[ 1 ], myOri[ 2 ] );
 104   myLineSource->SetPoint2( aPosition );
 105
 106   myArrowActor->SetPosition( 0, 0, 0 );
 107   myArrowActor->SetOrientation( 0, 0, 0 );
 108   myArrowActor->SetUserMatrix( 0 );
 109
 110
 111   gp_Trsf aTrsf;
 112   aTrsf.SetDisplacement( gp_Ax3( gp_Pnt( 0, 0, 0 ), gp_Dir( 1, 0, 0 ) ),
 113                          gp_Ax3( GetOri(), gp_Dir( myDir[ 0 ], myDir[ 1 ], myDir[ 2 ] ) ) );
 114
 115 //   const gp_XYZ& aTrans = aTrsf.TranslationPart();
 116   gp_Mat aRot = aTrsf.VectorialPart();
 117
 118   for ( int i = 1; i <= 3; i++ )
 119   {
 120     for ( int j = 1; j <= 3; j++ )
 121       myMatrix->SetElement( i - 1, j - 1, aRot( i, j ) );
 122
 123   // Set Arrow Position
 124   myMatrix->SetElement( i - 1 , 3, aPosition[ i - 1 ] );
 125   }
 126
 127   myArrowActor->SetUserMatrix( myMatrix );
 128
 129 #ifdef IPAL21440
 130   if( vtkCoordinate* aCoord = myLabelActor->GetPositionCoordinate()->GetReferenceCoordinate() )
 131     aCoord->SetValue( aPosition );
 132 #else
 133   myLabelActor->SetPosition( 0, 0, 0 );
 134   myLabelActor->AddPosition( aPosition );
 135 #endif
 136 }
 137
 138 void GEOM_VTKTrihedronAxis::Render(vtkRenderer* theRenderer)
 139 {
 140   myLineActor->Render( theRenderer );
 141   myArrowActor->Render( theRenderer );
 142 #ifndef IPAL21440
 143   myLabelActor->Render( theRenderer );
 144 #endif
 145
 146   vtkCamera* aCamera = theRenderer->GetActiveCamera();
 147   SetCamera( aCamera );
 148 }
 149
 150 gp_Pnt GEOM_VTKTrihedronAxis::GetOri() const
 151 {
 152   return gp_Pnt( myOri[ 0 ], myOri[ 1 ], myOri[ 2 ] );
 153 }
 154
 155 void GEOM_VTKTrihedronAxis::SetAxis( const gp_Ax1& theAxis,
 156                                      const int     theRot,
 157                                      double theColor[ 3 ] )
 158 {
 159   gp_Pnt aLoc = theAxis.Location();
 160   gp_Dir aDir = theAxis.Direction();
 161
 162   myOri[ 0 ] = aLoc.X();
 163   myOri[ 1 ] = aLoc.Y();
 164   myOri[ 2 ] = aLoc.Z();
 165
 166   myDir[ 0 ] = aDir.X();
 167   myDir[ 1 ] = aDir.Y();
 168   myDir[ 2 ] = aDir.Z();
 169
 170   double aColor[ 3 ] = { 0, 0, 0 };
 171   aColor[ theRot ] = 1;
 172   if ( theColor[ 0 ] == -1 )
 173     VTKViewer_Axis::SetColor( aColor[ 0 ], aColor[ 1 ], aColor[ 2 ] );
 174   else
 175     VTKViewer_Axis::SetColor( theColor[ 0 ], theColor[ 1 ], theColor[ 2 ] );
 176
 177 #ifdef IPAL21440
 178   if      ( theRot == 0 ) myTextMapper->SetInput( "X" );
 179   else if ( theRot == 1 ) myTextMapper->SetInput( "Y" );
 180   else if ( theRot == 2 ) myTextMapper->SetInput( "Z" );
 181 #else
 182   if      ( theRot == 0 ) myVectorText->SetText( "X" );
 183   else if ( theRot == 1 ) myVectorText->SetText( "Y" );
 184   else if ( theRot == 2 ) myVectorText->SetText( "Z" );
 185 #endif
 186 }
 187
 188 void GEOM_VTKTrihedronAxis::SetColor( const double theColor[ 3 ] )
 189 {
 190   VTKViewer_Axis::SetColor( theColor[ 0 ], theColor[ 1 ], theColor[ 2 ] );
 191 }
 192
 193
 194 /*
 195   Class       : GEOM_VTKTrihedron
 196   Description : Class for displaying trihedron of local CS in VTK viewer.
 197                 Placement of trihedron is changed with SetPlacement() method
 198 */
 199
 200 vtkStandardNewMacro( GEOM_VTKTrihedron )
 201
 202 GEOM_VTKTrihedron::GEOM_VTKTrihedron()
 203 {
 204   myMapper = vtkPolyDataMapper::New();
 205   myAxis[ 0 ] = myAxis[ 1 ] = myAxis[ 2 ] = 0;
 206   mySize = 100;
 207
 208   myColor[ 0 ] = myColor[ 1 ] = myColor[ 2 ] = -1;
 209
 210   myDefaultColor[ 0 ] = myDefaultColor[ 1 ] = myDefaultColor[ 2 ] = 1;
 211
 212   myPreHighlightColor[ 0 ] = 0;
 213   myPreHighlightColor[ 1 ] = myPreHighlightColor[ 2 ] = 1;
 214
 215   myHighlightColor[ 0 ] = myHighlightColor[ 1 ] = myHighlightColor[ 2 ] = 1;
 216
 217   //SetInfinitive( true );
 218   SetPickable( true );
 219 }
 220
 221 GEOM_VTKTrihedron::~GEOM_VTKTrihedron()
 222 {
 223   for ( int i = 0; i < 3; i++ )
 224     myAxis[i]->Delete();
 225
 226   if ( myMapper )
 227     myMapper->Delete();
 228 }
 229
 230 void GEOM_VTKTrihedron::SetSize( double theSize )
 231 {
 232   mySize = theSize;
 233   for ( int i = 0; i < 3; i++ )
 234     myAxis[i]->SetSize( theSize );
 235
 236
 237   // Calculate new sensitive area
 238   gp_Pnt anOri = ( (GEOM_VTKTrihedronAxis*)myAxis[ 0 ] )->GetOri();
 239   gp_Pnt aEndX( myLocation.XYZ() + myDirX.XYZ() * mySize );
 240   gp_Pnt aEndY( myLocation.XYZ() + myDirY.XYZ() * mySize );
 241   gp_Pnt aEndZ( myLocation.XYZ() + myDirZ.XYZ() * mySize );
 242
 243   vtkLineSource* aSrcX = vtkLineSource::New();
 244   vtkLineSource* aSrcY = vtkLineSource::New();
 245   vtkLineSource* aSrcZ = vtkLineSource::New();
 246
 247   aSrcX->SetPoint1( anOri.X(), anOri.Y(), anOri.Z() );
 248   aSrcX->SetPoint2( aEndX.X(), aEndX.Y(), aEndX.Z() );
 249
 250   aSrcY->SetPoint1( anOri.X(), anOri.Y(), anOri.Z() );
 251   aSrcY->SetPoint2( aEndY.X(), aEndY.Y(), aEndY.Z() );
 252
 253   aSrcZ->SetPoint1( anOri.X(), anOri.Y(), anOri.Z() );
 254   aSrcZ->SetPoint2( aEndZ.X(), aEndZ.Y(), aEndZ.Z() );
 255
 256   vtkAppendPolyData* aRes = vtkAppendPolyData::New();
 257   aRes->AddInputConnection( aSrcX->GetOutputPort() );
 258   aRes->AddInputConnection( aSrcY->GetOutputPort() );
 259   aRes->AddInputConnection( aSrcZ->GetOutputPort() );
 260
 261   myMapper->SetInputConnection( aRes->GetOutputPort() );
 262   aRes->Update();
 263   SALOME_Actor::SetMapper( myMapper );
 264
 265   aSrcX->Delete();
 266   aSrcY->Delete();
 267   aSrcZ->Delete();
 268   aRes->Delete();
 269 }
 270
 271 void GEOM_VTKTrihedron::SetVisibility( int theVisibility )
 272 {
 273   Superclass::SetVisibility( theVisibility );
 274   SetVisibility( theVisibility == 1 ? VTKViewer_Trihedron::eOn : VTKViewer_Trihedron::eOff );
 275 }
 276
 277 void GEOM_VTKTrihedron::SetVisibility( VTKViewer_Trihedron::TVisibility theVis )
 278 {
 279   for ( int i = 0; i < 3; i++ )
 280     myAxis[i]->SetVisibility( theVis );
 281 }
 282
 283 void GEOM_VTKTrihedron::AddToRender( vtkRenderer* theRenderer )
 284 {
 285   vtkCamera* aCamera = theRenderer->GetActiveCamera();
 286   for(int i = 0; i < 3; i++)
 287   {
 288     myAxis[i]->AddToRender(theRenderer);
 289     myAxis[i]->SetCamera(aCamera);
 290   }
 291
 292   theRenderer->AddActor( this );
 293 }
 294
 295 void GEOM_VTKTrihedron::RemoveFromRender( vtkRenderer* theRenderer )
 296 {
 297   for(int i = 0; i < 3; i++)
 298   {
 299     myAxis[i]->RemoveFromRender(theRenderer);
 300   }
 301
 302   theRenderer->RemoveActor( this );
 303 }
 304
 305 int GEOM_VTKTrihedron::GetVisibleActorCount(vtkRenderer* theRenderer)
 306 {
 307   vtkActorCollection* aCollection = theRenderer->GetActors();
 308   aCollection->InitTraversal();
 309   int aCount = 0;
 310   while( vtkActor* prop = aCollection->GetNextActor() )
 311     if ( prop->GetVisibility() )
 312       if ( SALOME_Actor* anActor = SALOME_Actor::SafeDownCast( prop ) )
 313     if ( !anActor->IsInfinitive() )
 314       aCount++;
 315
 316   vtkCamera* aCamera = theRenderer->GetActiveCamera();
 317   for(int i = 0; i < 3; i++)
 318     myAxis[i]->SetCamera( aCamera );
 319
 320   return aCount;
 321 }
 322
 323 void GEOM_VTKTrihedron::SetCamera( vtkCamera* theCamera )
 324 {
 325   for(int i = 0; i < 3; i++)
 326     myAxis[i]->SetCamera( theCamera );
 327 }
 328
 329 void GEOM_VTKTrihedron::SetPlacement( const Handle(Geom_Axis2Placement)& thePlc )
 330 {
 331   gp_Ax2 anAx2 = thePlc->Ax2();
 332
 333   myDirX = anAx2.XDirection();
 334   myDirY = anAx2.YDirection();
 335   myDirZ = anAx2.Direction();
 336
 337   myLocation = anAx2.Axis().Location();
 338
 339   if ( myAxis[ 0 ] != 0 ) myAxis[ 0 ]->Delete();
 340   if ( myAxis[ 1 ] != 0 ) myAxis[ 1 ]->Delete();
 341   if ( myAxis[ 2 ] != 0 ) myAxis[ 2 ]->Delete();
 342
 343   myAxis[ 0 ] = GEOM_VTKTrihedronAxis::New();
 344   myAxis[ 1 ] = GEOM_VTKTrihedronAxis::New();
 345   myAxis[ 2 ] = GEOM_VTKTrihedronAxis::New();
 346
 347   ( (GEOM_VTKTrihedronAxis*)myAxis[ 0 ] )->SetAxis( gp_Ax1( myLocation, myDirX ), 0, myColor );
 348   ( (GEOM_VTKTrihedronAxis*)myAxis[ 1 ] )->SetAxis( gp_Ax1( myLocation, myDirY ), 1, myColor );
 349   ( (GEOM_VTKTrihedronAxis*)myAxis[ 2 ] )->SetAxis( gp_Ax1( myLocation, myDirZ ), 2, myColor );
 350
 351   SetSize( mySize );
 352 }
 353
 354 vtkMapper* GEOM_VTKTrihedron::GetMapper()
 355 {
 356   return myMapper;
 357 }
 358
 359 void GEOM_VTKTrihedron::Render(vtkRenderer* r, vtkMapper *)
 360 {
 361   ( (GEOM_VTKTrihedronAxis*)myAxis[ 0 ] )->Render( r );
 362   ( (GEOM_VTKTrihedronAxis*)myAxis[ 1 ] )->Render( r );
 363   ( (GEOM_VTKTrihedronAxis*)myAxis[ 2 ] )->Render( r );
 364 }
 365
 366 void GEOM_VTKTrihedron::SetColor( double r, double g, double b )
 367 {
 368   myColor[ 0 ] = r;
 369   myColor[ 1 ] = g;
 370   myColor[ 2 ] = b;
 371
 372   if ( myAxis[ 0 ] ) ( (GEOM_VTKTrihedronAxis*)myAxis[ 0 ] )->SetColor( myColor );
 373   if ( myAxis[ 1 ] ) ( (GEOM_VTKTrihedronAxis*)myAxis[ 1 ] )->SetColor( myColor );
 374   if ( myAxis[ 2 ] ) ( (GEOM_VTKTrihedronAxis*)myAxis[ 2 ] )->SetColor( myColor );
 375 }
 376
 377 void GEOM_VTKTrihedron::GetColor( double& r, double& g, double& b )
 378 {
 379   r = myColor[ 0 ];
 380   g = myColor[ 1 ];
 381   b = myColor[ 2 ];
 382 }
 383
 384 bool GEOM_VTKTrihedron::IsSetCamera() const
 385 {
 386   return true;
 387 }
 388
 389 bool GEOM_VTKTrihedron::IsResizable() const
 390 {
 391   return false;
 392 }
 393
 394 void GEOM_VTKTrihedron::Highlight( bool theIsHighlight )
 395 {
 396   if( theIsHighlight )
 397     SetAxesColors( myHighlightColor );
 398   else
 399     ResetAxesColors();
 400
 401   Superclass::Highlight( theIsHighlight );
 402 }
 403
 404 bool GEOM_VTKTrihedron::PreHighlight( vtkInteractorStyle *theInteractorStyle,
 405                                       SVTK_SelectionEvent* theSelectionEvent,
 406                                       bool theIsHighlight )
 407 {
 408   if ( !GetPickable() )
 409     return false;
 410
 411   if ( !isHighlighted() )
 412   {
 413     if( theIsHighlight )
 414       SetAxesColors( myPreHighlightColor );
 415     else
 416       ResetAxesColors();
 417   }
 418
 419   return Superclass::PreHighlight( theInteractorStyle, theSelectionEvent, theIsHighlight );
 420 }
 421
 422 void GEOM_VTKTrihedron::ResetAxesColors()
 423 {
 424   if( myColor[0] != -1 )
 425     SetAxesColors( myColor );
 426   else
 427     SetAxesColors( myDefaultColor, true );
 428 }
 429
 430 void GEOM_VTKTrihedron::SetAxesColors( double theColor[3], bool theIsDiffuse )
 431 {
 432   myAxis[ 0 ]->SetColor( theColor[0], theIsDiffuse ? 0.0 : theColor[1], theIsDiffuse ? 0.0 : theColor[2] );
 433   myAxis[ 1 ]->SetColor( theIsDiffuse ? 0.0 : theColor[0], theColor[1], theIsDiffuse ? 0.0 : theColor[2] );
 434   myAxis[ 2 ]->SetColor( theIsDiffuse ? 0.0 : theColor[0], theIsDiffuse ? 0.0 : theColor[1], theColor[2] );
 435 }
 436