]> SALOME platform Git repositories - modules/geom.git/blob - src/OBJECT/GEOM_VTKTrihedron.cxx
Salome HOME
bos #29484 Merge branch 'vsr/29484'
[modules/geom.git] / 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