1 // Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 // GEOM OBJECT : interactive object for Geometry entities visualization
24 // File : GEOM_Actor.cxx
25 // Author : Christophe ATTANASIO
29 \class GEOM_Actor GEOM_Actor.h
30 \brief This class allows to display an OpenCASCADE CAD model in a VTK viewer.
32 #include "GEOM_Actor.h"
34 #include "GEOM_DeviceActor.h"
35 #include "GEOM_VertexSource.h"
36 #include "GEOM_EdgeSource.h"
37 #include "GEOM_WireframeFace.h"
38 #include "GEOM_ShadingFace.h"
39 #include "GEOM_PainterPolyDataMapper.h"
40 #include "GEOMUtils.hxx"
41 #include "SVTK_Actor.h"
43 #include <OCC2VTK_Tools.h>
44 #include <GEOMUtils.hxx>
46 #include <vtkObjectFactory.h>
47 #include <vtkRenderer.h>
48 #include <vtkTextActor.h>
49 #include <vtkTextProperty.h>
50 #include <vtkProperty.h>
51 #include <vtkPointPicker.h>
52 #include <vtkCellPicker.h>
54 #include <TopAbs_ShapeEnum.hxx>
55 #include <TopExp_Explorer.hxx>
57 #include <BRep_Tool.hxx>
60 #include <vtkPolyDataWriter.h>
62 #include <vtkAppendPolyData.h>
63 #include <vtkPolyDataMapper.h>
64 #include <vtkPolyData.h>
65 #include <vtkTransform.h>
66 #include <vtkMatrix4x4.h>
68 #include <vtkCamera.h>
70 #include "utilities.h"
72 #include "SALOME_InteractiveObject.hxx"
74 //vtkStandardNewMacro(GEOM_Actor);
80 GEOM_Actor::GEOM_Actor():
86 // myDisplayMode(eWireframe),
89 myVerticesMode(false),
92 myVertexActor(GEOM_DeviceActor::New(),true),
93 myVertexSource(GEOM_VertexSource::New(),true),
95 myStandaloneVertexActor(GEOM_DeviceActor::New(),true),
96 myStandaloneVertexSource(GEOM_VertexSource::New(),true),
98 myIsolatedEdgeActor(GEOM_DeviceActor::New(),true),
99 myIsolatedEdgeSource(GEOM_EdgeSource::New(),true),
101 myOneFaceEdgeActor(GEOM_DeviceActor::New(),true),
102 myOneFaceEdgeSource(GEOM_EdgeSource::New(),true),
104 mySharedEdgeActor(GEOM_DeviceActor::New(),true),
105 mySharedEdgeSource(GEOM_EdgeSource::New(),true),
107 myWireframeFaceActor(GEOM_DeviceActor::New(),true),
108 myWireframeFaceSource(GEOM_WireframeFace::New(),true),
110 myShadingFaceActor(GEOM_DeviceActor::New(),true),
111 myShadingFaceSource(GEOM_ShadingFace::New(),true),
113 myHighlightActor(GEOM_DeviceActor::New(),true),
114 myAppendFilter(vtkAppendPolyData::New(),true),
115 // Use mapper as an instance of GEOM_PainterPolyDataMapper class
116 // to prevent drawing of mappers' content (due to an empty definition
117 // of GEOM_PainterPolyDataMapper::RenderPiece(...)).
118 // !!! Presentation of GEOM_Actor is drawing only with help of actors
119 // defined in this class !!!
120 myPolyDataMapper(GEOM_PainterPolyDataMapper::New(),true),
122 myTextActor( vtkTextActor::New() ),
124 myHighlightProp(vtkProperty::New()),
125 myPreHighlightProp(vtkProperty::New()),
126 myShadingFaceProp(vtkProperty::New()),
127 myShadingBackFaceProp(vtkProperty::New())
130 MESSAGE (this<< " GEOM_Actor::GEOM_Actor");
133 myPolyDataMapper->SetInputConnection(myAppendFilter->GetOutputPort());
134 vtkProperty* aProperty;
136 myHighlightProp->SetAmbient(0.5);
137 myHighlightProp->SetDiffuse(0.3);
138 myHighlightProp->SetSpecular(0.2);
139 myHighlightProp->SetRepresentationToSurface();
140 myHighlightProp->SetAmbientColor(1, 1, 1);
141 myHighlightProp->SetDiffuseColor(1, 1, 1);
142 myHighlightProp->SetSpecularColor(0.5, 0.5, 0.5);
143 myHighlightProp->SetPointSize(SALOME_POINT_SIZE+2);
144 myHighlightActor->SetProperty(myHighlightProp.GetPointer());
146 this->myHighlightActor->SetInput(myAppendFilter->GetOutputPort(),false);
148 myPreHighlightProp->SetColor(0,1,1);
149 myPreHighlightProp->SetPointSize(SALOME_POINT_SIZE);
150 myPreHighlightProp->SetLineWidth(SALOME_LINE_WIDTH+1);
151 myPreHighlightProp->SetRepresentationToWireframe();
153 myAppendFilter->AddInputConnection(myVertexSource->GetOutputPort());
154 myVertexActor->SetInput(myVertexSource->GetOutputPort(),false);
155 aProperty = myVertexActor->GetProperty();
156 aProperty->SetRepresentation(VTK_POINTS);
157 aProperty->SetPointSize(3);
158 aProperty->SetColor(1, 1, 0);
160 myAppendFilter->AddInputConnection(myStandaloneVertexSource->GetOutputPort());
161 myStandaloneVertexActor->SetInput(myStandaloneVertexSource->GetOutputPort(),false);
162 aProperty = myStandaloneVertexActor->GetProperty();
163 aProperty->SetRepresentation(VTK_POINTS);
164 aProperty->SetPointSize(3);
165 aProperty->SetColor(1, 1, 0);
167 myAppendFilter->AddInputConnection(myIsolatedEdgeSource->GetOutputPort());
168 myIsolatedEdgeActor->SetInput(myIsolatedEdgeSource->GetOutputPort(),false);
169 aProperty = myIsolatedEdgeActor->GetProperty();
170 aProperty->SetRepresentation(VTK_WIREFRAME);
171 myIsolatedEdgeColor[0] = 1; myIsolatedEdgeColor[1] = 0; myIsolatedEdgeColor[2] = 0;
172 aProperty->SetColor(myIsolatedEdgeColor[0], myIsolatedEdgeColor[1], myIsolatedEdgeColor[2]);
174 myAppendFilter->AddInputConnection(myOneFaceEdgeSource->GetOutputPort());
175 myOneFaceEdgeActor->SetInput(myOneFaceEdgeSource->GetOutputPort(),false);
176 aProperty = myOneFaceEdgeActor->GetProperty();
177 aProperty->SetRepresentation(VTK_WIREFRAME);
178 myOneFaceEdgeColor[0] = 0; myOneFaceEdgeColor[1] = 1; myOneFaceEdgeColor[2] = 0;
179 aProperty->SetColor(myOneFaceEdgeColor[0], myOneFaceEdgeColor[1], myOneFaceEdgeColor[2]);
181 myAppendFilter->AddInputConnection(mySharedEdgeSource->GetOutputPort());
182 mySharedEdgeActor->SetInput(mySharedEdgeSource->GetOutputPort(),false);
183 aProperty = mySharedEdgeActor->GetProperty();
184 aProperty->SetRepresentation(VTK_WIREFRAME);
185 mySharedEdgeColor[0] = 1; mySharedEdgeColor[1] = 1; mySharedEdgeColor[2] = 0;
186 aProperty->SetColor(mySharedEdgeColor[0], mySharedEdgeColor[1], mySharedEdgeColor[2]);
188 myAppendFilter->AddInputConnection(myWireframeFaceSource->GetOutputPort());
189 myWireframeFaceActor->SetInput(myWireframeFaceSource->GetOutputPort(),false);
190 aProperty = myWireframeFaceActor->GetProperty();
191 aProperty->SetRepresentation(VTK_WIREFRAME);
192 aProperty->SetColor(0.5, 0.5, 0.5);
194 myShadingFaceActor->SetInput(myShadingFaceSource->GetOutputPort(),true);
196 myShadingFaceProp->SetRepresentation(VTKViewer::Representation::Surface);
197 myShadingFaceProp->SetInterpolationToGouraud();
198 myShadingFaceProp->SetAmbient(1.0);
199 myShadingFaceProp->SetDiffuse(1.0);
200 myShadingFaceProp->SetSpecular(0.4);
201 myShadingFaceProp->SetAmbientColor(0.329412, 0.223529, 0.027451);
202 myShadingFaceProp->SetDiffuseColor(0.780392, 0.568627, 0.113725);
203 myShadingFaceProp->SetSpecularColor(0.992157, 0.941176, 0.807843);
205 myShadingFaceActor->SetProperty(myShadingFaceProp.GetPointer());
207 // Toggle display mode
208 setDisplayMode(0); // WIRE FRAME
210 SetVerticesMode(0); //
215 GEOM_Actor::~GEOM_Actor()
218 MESSAGE (this<< " ~GEOM_Actor::GEOM_Actor");
220 myHighlightProp->Delete();
221 myPreHighlightProp->Delete();
222 myShadingFaceProp->Delete();
223 myShadingBackFaceProp->Delete();
230 GEOM_Actor* anObject = new GEOM_Actor();
231 anObject->SetMapper(anObject->myPolyDataMapper.Get());
236 void Write(vtkPolyData* theDataSet, const char* theFileName){
237 vtkPolyDataWriter* aWriter = vtkPolyDataWriter::New();
238 MESSAGE ("Write - "<<theFileName<<"' : "<<theDataSet->GetNumberOfPoints()<<"; "<<theDataSet->GetNumberOfCells());
239 aWriter->SetInputData(theDataSet);
240 aWriter->SetFileName(theFileName);
249 this->myVertexSource->Modified();
250 this->myStandaloneVertexSource->Modified();
251 this->myIsolatedEdgeSource->Modified();
252 this->myOneFaceEdgeSource->Modified();
253 this->mySharedEdgeSource->Modified();
254 this->myWireframeFaceSource->Modified();
255 this->myShadingFaceSource->Modified();
256 this->myTextActor->Modified();
261 SetMapper(vtkMapper* theMapper)
263 SALOME_Actor::SetMapper(theMapper);
268 AddToRender(vtkRenderer* theRenderer)
270 //SALOME_Actor::AddToRender(theRenderer);
272 theRenderer->AddActor(this);
274 this->myHighlightActor->AddToRender(theRenderer);
277 myShadingFaceActor->AddToRender(theRenderer);
278 myWireframeFaceActor->AddToRender(theRenderer);
280 mySharedEdgeActor->AddToRender(theRenderer);
281 myOneFaceEdgeActor->AddToRender(theRenderer);
282 myIsolatedEdgeActor->AddToRender(theRenderer);
284 myVertexActor->AddToRender(theRenderer);
285 myStandaloneVertexActor->AddToRender(theRenderer);
287 theRenderer->AddActor( myTextActor );
292 RemoveFromRender(vtkRenderer* theRenderer)
294 //SALOME_Actor::RemoveFromRender(theRenderer);
297 theRenderer->RemoveActor(this);
299 myHighlightActor->RemoveFromRender(theRenderer);
300 myShadingFaceActor->RemoveFromRender(theRenderer);
301 myWireframeFaceActor->RemoveFromRender(theRenderer);
303 mySharedEdgeActor->RemoveFromRender(theRenderer);
304 myOneFaceEdgeActor->RemoveFromRender(theRenderer);
305 myIsolatedEdgeActor->RemoveFromRender(theRenderer);
307 myVertexActor->RemoveFromRender(theRenderer);
308 myStandaloneVertexActor->RemoveFromRender(theRenderer);
310 theRenderer->RemoveActor( myTextActor );
313 SetVisibility(false);
318 setDisplayMode(int theMode)
321 MESSAGE ( "GEOM_Actor::setDisplayMode = "<<theMode );
324 if ( theMode == (int)eShadingWithEdges ) {
326 myIsolatedEdgeActor->GetProperty()->SetColor(myIsolatedEdgeColor[0],
327 myIsolatedEdgeColor[1],
328 myIsolatedEdgeColor[2]);
329 myOneFaceEdgeActor->GetProperty()->SetColor(myEdgesInShadingColor[0],
330 myEdgesInShadingColor[1],
331 myEdgesInShadingColor[2]);
332 mySharedEdgeActor->GetProperty()->SetColor(myEdgesInShadingColor[0],
333 myEdgesInShadingColor[1],
334 myEdgesInShadingColor[2]);
338 myIsolatedEdgeActor->GetProperty()->SetColor(myIsolatedEdgeColor[0],
339 myIsolatedEdgeColor[1],
340 myIsolatedEdgeColor[2]);
341 mySharedEdgeActor->GetProperty()->SetColor(myIsolatedEdgeColor[0],
342 myIsolatedEdgeColor[1],
343 myIsolatedEdgeColor[2]);
344 myOneFaceEdgeActor->GetProperty()->SetColor(myOneFaceEdgeColor[0],
345 myOneFaceEdgeColor[1],
346 myOneFaceEdgeColor[2]);
349 VTKViewer_Actor::setDisplayMode(theMode);
350 SetVisibility(GetVisibility());
355 SetSelected(bool theIsSelected)
358 MESSAGE ( "GEOM_Actor::SetSelected = "<<theIsSelected );
361 myIsSelected = theIsSelected;
362 SetVisibility(GetVisibility());
367 SetVisibility(int theVisibility)
370 MESSAGE ( "GEOM_Actor::SetVisibility = "<<theVisibility <<" myIsSelected="<< myIsSelected
371 << " theVisibility="<<theVisibility<<" myIsPreselected="<<myIsPreselected );
374 SALOME_Actor::SetVisibility(theVisibility);
376 this->myHighlightActor->SetVisibility(theVisibility && (myIsSelected || myIsPreselected));
378 myShadingFaceActor->SetVisibility(theVisibility && (myDisplayMode == (int)eShading || myDisplayMode == (int)eShadingWithEdges) && (!myIsSelected || !myIsPreselected));
379 myWireframeFaceActor->SetVisibility(theVisibility && (myDisplayMode == (int)eWireframe) && !myIsSelected);
381 mySharedEdgeActor->SetVisibility(theVisibility && (myDisplayMode == (int)eWireframe || myDisplayMode == (int)eShadingWithEdges) && !myIsSelected);
382 myOneFaceEdgeActor->SetVisibility(theVisibility && (myDisplayMode == (int)eWireframe || myDisplayMode == (int)eShadingWithEdges) && !myIsSelected);
383 myIsolatedEdgeActor->SetVisibility(theVisibility && !myIsSelected);
385 myVertexActor->SetVisibility(theVisibility && (isOnlyVertex || (myVerticesMode && (!myIsSelected && !myIsPreselected))));// must be added new mode points
387 myStandaloneVertexActor->SetVisibility(theVisibility);
389 myTextActor->SetVisibility( theVisibility && myNameMode );
395 ::SetNbIsos(const int theNb[2])
397 myWireframeFaceSource->SetNbIso(theNb);
402 ::GetNbIsos(int &theNbU,int &theNbV)
404 myWireframeFaceSource->GetNbIso(theNbU, theNbV);
409 ::SetVectorMode(bool theMode)
411 myVectorMode = theMode;
412 myIsolatedEdgeSource->SetVectorMode(theMode);
413 myOneFaceEdgeSource->SetVectorMode(theMode);
414 mySharedEdgeSource->SetVectorMode(theMode);
427 ::SetVerticesMode(bool theMode)
429 myVerticesMode = theMode;
430 if ( theMode || isOnlyVertex ) {
431 myAppendFilter->AddInputConnection(myVertexSource->GetOutputPort());
433 myAppendFilter->RemoveInputConnection(0, myVertexSource->GetOutputPort());
442 return myVerticesMode;
449 if( !getIO() || myShape.IsNull() )
452 gp_Ax3 anAx3 = GEOMUtils::GetPosition(myShape);
453 double center[3] = { anAx3.Location().X(),
454 anAx3.Location().Y(),
455 anAx3.Location().Z() };
456 double* pos = center;
457 myTextActor->GetTextProperty()->SetFontSize( 16 );
458 myTextActor->GetTextProperty()->ShadowOn();
459 myTextActor->GetPositionCoordinate()->SetCoordinateSystemToWorld();
460 myTextActor->GetPositionCoordinate()->SetValue(pos);
461 myTextActor->SetInput( getIO()->getName() );
466 ::SetNameMode(bool theMode)
468 myNameMode = theMode;
469 myTextActor->SetVisibility(theMode);
482 SetDeflection(double theDeflection)
484 double aDeflection = ( theDeflection <= 0 ) ? GEOMUtils::DefaultDeflection() : theDeflection;
486 if ( myDeflection != aDeflection ) {
487 myDeflection = aDeflection;
488 GEOMUtils::MeshShape( myShape, myDeflection );
493 void GEOM_Actor::SetShape (const TopoDS_Shape& theShape,
494 double theDeflection,
499 myVertexSource->Clear();
500 myStandaloneVertexSource->Clear();
501 myIsolatedEdgeSource->Clear();
502 myOneFaceEdgeSource->Clear();
503 mySharedEdgeSource->Clear();
504 myWireframeFaceSource->Clear();
505 myShadingFaceSource->Clear();
507 TopExp_Explorer aVertexExp (theShape,TopAbs_VERTEX);
508 for (; aVertexExp.More(); aVertexExp.Next())
510 const TopoDS_Vertex& aVertex = TopoDS::Vertex(aVertexExp.Current());
511 myVertexSource->AddVertex(aVertex);
514 SetDeflection(theDeflection);
516 // look if edges are free or shared
517 TopTools_IndexedDataMapOfShapeListOfShape anEdgeMap;
518 TopExp::MapShapesAndAncestors(theShape,TopAbs_EDGE,TopAbs_FACE,anEdgeMap);
520 GEOM::ShapeToVTK(theShape,anEdgeMap,theIsVector,
521 myStandaloneVertexSource.Get(),
522 myIsolatedEdgeSource.Get(),
523 myOneFaceEdgeSource.Get(),
524 mySharedEdgeSource.Get(),
525 myWireframeFaceSource.Get(),
526 myShadingFaceSource.Get());
528 myIsolatedEdgeSource->IsEmpty() &&
529 myOneFaceEdgeSource->IsEmpty() &&
530 mySharedEdgeSource->IsEmpty() &&
531 myWireframeFaceSource->IsEmpty() &&
532 myShadingFaceSource->IsEmpty();
535 if((bool)myShape.Infinite() || isOnlyVertex ){
536 myVertexActor->GetDeviceActor()->SetInfinitive(true);
537 myStandaloneVertexActor->GetDeviceActor()->SetInfinitive(true);
538 myHighlightActor->GetDeviceActor()->SetInfinitive(true);
543 // 0051777: TC7.2.0: Element could not be selected in Hypothesis Construction
544 myAppendFilter->Update();
547 // warning! must be checked!
548 // SetHighlightProperty
549 // SetWireframeProperty
550 // SetShadingProperty
552 void GEOM_Actor::SetHighlightProperty(vtkProperty* Prop)
555 MESSAGE ( "GEOM_Actor::SetHighlightProperty" );
557 this->myHighlightActor->GetProperty()->DeepCopy(Prop);
561 void GEOM_Actor::SetWireframeProperty(vtkProperty* Prop)
564 MESSAGE ( this << " GEOM_Actor::SetWireframeProperty" );
567 myWireframeFaceActor->SetProperty(Prop);
571 vtkProperty* GEOM_Actor::GetWireframeProperty()
573 return myWireframeFaceActor->GetProperty();
576 vtkProperty* GEOM_Actor::GetIsolatedEdgeProperty()
578 return myIsolatedEdgeActor->GetProperty();
581 vtkProperty* GEOM_Actor::GetVertexProperty()
583 return myVertexActor->GetProperty();
586 vtkProperty* GEOM_Actor::GetStandaloneVertexProperty()
588 return myStandaloneVertexActor->GetProperty();
591 vtkProperty* GEOM_Actor::GetSharedEdgeProperty()
593 return mySharedEdgeActor->GetProperty();
596 vtkProperty* GEOM_Actor::GetFaceEdgeProperty()
598 return myOneFaceEdgeActor->GetProperty();
601 void GEOM_Actor::SetShadingProperty(vtkProperty* Prop)
604 MESSAGE ( "GEOM_Actor::SetShadingProperty" );
606 myShadingFaceProp->DeepCopy(Prop);
610 vtkProperty* GEOM_Actor::GetShadingProperty()
612 return myShadingFaceProp;
616 void GEOM_Actor::Render(vtkRenderer *ren, vtkMapper *theMapper)
619 MESSAGE ( "GEOM_Actor::Render" );
625 /* render the property */
626 if (!this->Property) {
627 // force creation of a property
629 this->Property->SetInterpolation(1);
630 this->Property->SetRepresentationToSurface();
631 this->Property->SetAmbient(0.3);
632 this->Property->SetAmbientColor(0.88,0.86,0.2);
633 this->Property->SetDiffuseColor(0.99,0.7,0.21);
634 this->Property->SetSpecularColor(0.99,0.98,0.83);
637 switch(myDisplayMode){
638 case eWireframe://wireframe
639 myPreHighlightProp->SetRepresentationToWireframe();
640 myHighlightProp->SetRepresentationToWireframe();
642 case eShading://shading
643 case eShadingWithEdges://shading with edges
644 myPreHighlightProp->SetRepresentationToSurface();
645 myHighlightProp->SetRepresentationToSurface();
646 myShadingFaceProp->SetRepresentationToSurface();
647 myShadingBackFaceProp->SetRepresentationToSurface();
653 this->myHighlightActor->SetProperty(myPreHighlightProp.GetPointer());
654 myShadingFaceActor->SetProperty(myPreHighlightProp.GetPointer());
655 myShadingFaceActor->SetBackfaceProperty(myPreHighlightProp.GetPointer());
657 this->myHighlightActor->SetProperty(myShadingFaceProp.GetPointer());
658 myShadingFaceActor->SetProperty(myShadingFaceProp.GetPointer());
659 myShadingFaceActor->SetBackfaceProperty(myShadingBackFaceProp.GetPointer());
663 this->myHighlightActor->SetProperty(myHighlightProp.GetPointer());
664 myShadingFaceActor->SetProperty(myHighlightProp.GetPointer());
665 myShadingFaceActor->SetBackfaceProperty(myHighlightProp.GetPointer());
668 this->Property->Render(this, ren);
669 if (this->BackfaceProperty) {
670 this->BackfaceProperty->BackfaceRender(this, ren);
671 this->Device->SetBackfaceProperty(this->BackfaceProperty);
673 this->Device->SetProperty(this->Property);
674 /* if(myShape.ShapeType() == TopAbs_VERTEX) {
676 //The parameter determine size of vertex actor relate to diagonal of RendererWindow
677 static double delta = 0.01;
678 double X1 = -1, Y1 = -1, Z1 = 0;
679 ren->ViewToWorld(X1,Y1,Z1);
680 double X2 = +1, Y2 = +1, Z2 = 0;
681 ren->ViewToWorld(X2,Y2,Z2);
682 Z2 = sqrt((X2-X1)*(X2-X1) + (Y2-Y1)*(Y2-Y1) + (Z2-Z1)*(Z2-Z1));
683 this->SetScale(Z2*delta);
685 vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
686 this->GetMatrix(ren->GetActiveCamera(), aMatrix);
687 this->Device->SetUserMatrix(aMatrix);
688 this->Device->Render(ren,theMapper);
691 this->Device->Render(ren, theMapper);
694 void GEOM_Actor::ReleaseGraphicsResources(vtkWindow *)
697 MESSAGE ( "GEOM_Actor::ReleaseGraphicsResources" );
703 void GEOM_Actor::ShallowCopy(vtkProp *prop)
706 MESSAGE ( "GEOM_Actor::ShallowCopy" );
708 GEOM_Actor *f = GEOM_Actor::SafeDownCast(prop);
711 this->SetShape(f->getTopo(),f->GetDeflection());
715 this->SALOME_Actor::ShallowCopy(prop);
718 const TopoDS_Shape& GEOM_Actor::getTopo() {
720 MESSAGE ( "GEOM_Actor::getTopo" );
725 void GEOM_Actor::setInputShape(const TopoDS_Shape& ashape, double adef1,
726 int imode, bool isVector)
729 MESSAGE ( "GEOM_Actor::setInputShape" );
733 double GEOM_Actor::isVector()
736 MESSAGE ( "GEOM_Actor::isVector" );
741 void GEOM_Actor::SubShapeOn()
744 MESSAGE ( "GEOM_Actor::SubShapeOn" );
748 void GEOM_Actor::SubShapeOff()
751 MESSAGE ( "GEOM_Actor::SubShapeOff" );
755 void GEOM_Actor::highlight(bool highlight)
758 MESSAGE ( this << " GEOM_Actor::highlight highlight="<<highlight );
760 SALOME_Actor::highlight(highlight);
763 void GEOM_Actor::SetOpacity(double opa)
766 myShadingFaceProp->SetOpacity(opa);
767 myShadingBackFaceProp->SetOpacity(opa);
768 myHighlightProp->SetOpacity(opa);
769 myPreHighlightProp->SetOpacity(opa);
770 myVertexActor->GetProperty()->SetOpacity(opa);
771 myStandaloneVertexActor->GetProperty()->SetOpacity(opa);
774 double GEOM_Actor::GetOpacity()
777 return myShadingFaceProp->GetOpacity();
780 void GEOM_Actor::SetColor(double r,double g,double b)
782 // set the same color to all sub-actors:
784 // - standalone edges
787 // - shading color (front and back faces)
788 SetPointColor(r, g, b);
789 SetIsolatedEdgeColor(r, g, b);
790 SetSharedEdgeColor(r, g, b);
791 SetFreeEdgeColor(r, g, b);
792 myShadingFaceProp->SetColor(r,g,b); // shading color
793 myShadingBackFaceProp->SetColor(r,g,b); // back face shading color
796 void GEOM_Actor::GetColor(double& r,double& g,double& b)
799 myShadingFaceProp->GetColor(aRGB);
806 \brief Set color of points
807 Points actor is shown in Wireframe mode only, see SetVisibility()
809 void GEOM_Actor::SetPointColor(double r, double g, double b)
811 myVertexActor->GetProperty()->SetColor(r, g, b);
812 myStandaloneVertexActor->GetProperty()->SetColor(r, g, b);
816 \brief Set color of standalone edges, wires, vectors
817 This actor is shown in all display mode, see SetVisibility()
818 TODO: check - this color seems to be used not only for standalone edges
820 void GEOM_Actor::SetIsolatedEdgeColor(double r, double g, double b)
822 myIsolatedEdgeColor[0] = r; myIsolatedEdgeColor[1] = g; myIsolatedEdgeColor[2] = b;
823 myIsolatedEdgeActor->GetProperty()->SetColor(r, g, b);
827 \brief Set color of shared edges
828 This actor is shown only in wireframe and shading+edges display modes, see SetVisibility()
829 TODO: check - this seems to be not working currently
831 void GEOM_Actor::SetSharedEdgeColor(double r, double g, double b)
833 mySharedEdgeColor[0] = r; mySharedEdgeColor[1] = g; mySharedEdgeColor[2] = b;
834 if ( myDisplayMode != (int)eShadingWithEdges )
835 mySharedEdgeActor->GetProperty()->SetColor(r, g, b);
839 \brief Set color of edges for standalone faces
840 This actor is shown only in wireframe and shading+edges display modes, see SetVisibility()
841 TODO: this color should be used not only for faces
843 void GEOM_Actor::SetFreeEdgeColor(double r, double g, double b)
845 myOneFaceEdgeColor[0] = r; myOneFaceEdgeColor[1] = g; myOneFaceEdgeColor[2] = b;
846 if ( myDisplayMode != (int)eShadingWithEdges )
847 myOneFaceEdgeActor->GetProperty()->SetColor(r, g, b);
851 \brief Set color of iso-lines
852 This actor is shown only in wireframe display mode, see SetVisibility()
854 void GEOM_Actor::SetIsosColor(double r, double g, double b)
856 myWireframeFaceActor->GetProperty()->SetColor(r, g, b);
860 \brief Set color of labels
861 This actor is shown only if 'Show name' is switched-on, see SetVisibility()
863 void GEOM_Actor::SetLabelColor(double r, double g, double b)
865 myTextActor->GetTextProperty()->SetColor(r, g, b);
868 void GEOM_Actor::SetMaterial(std::vector<vtkProperty*> theProps)
870 // we set material properties as back and front material
871 int aSize = theProps.size();
873 if ( aSize < 1 || aSize > 2)
876 // theProps[0] -- front material properties
877 // theProps[1] -- back material properties (if exist)
881 // Set reflection coefficients
882 aCoefnt = theProps[0]->GetAmbient();
883 myShadingFaceProp->SetAmbient(aCoefnt);
884 myVertexActor->GetProperty()->SetAmbient(aCoefnt);
885 myStandaloneVertexActor->GetProperty()->SetAmbient(aCoefnt);
887 aCoefnt = theProps[1]->GetAmbient();
888 myShadingBackFaceProp->SetAmbient(aCoefnt);
890 // Set diffuse coefficients
891 aCoefnt = theProps[0]->GetDiffuse();
892 myShadingFaceProp->SetDiffuse(aCoefnt);
893 myVertexActor->GetProperty()->SetDiffuse(aCoefnt);
894 myStandaloneVertexActor->GetProperty()->SetDiffuse(aCoefnt);
896 aCoefnt = theProps[1]->GetDiffuse();
897 myShadingBackFaceProp->SetDiffuse(aCoefnt);
899 // Set specular coefficients
900 aCoefnt = theProps[0]->GetSpecular();
901 myShadingFaceProp->SetSpecular(aCoefnt);
902 myVertexActor->GetProperty()->SetSpecular(aCoefnt);
903 myStandaloneVertexActor->GetProperty()->SetSpecular(aCoefnt);
905 aCoefnt = theProps[1]->GetSpecular();
906 myShadingBackFaceProp->SetSpecular(aCoefnt);
911 // Set reflection colors
912 aColor = theProps[0]->GetAmbientColor();
913 myShadingFaceProp->SetAmbientColor(aColor[0], aColor[1], aColor[2]);
914 myVertexActor->GetProperty()->SetAmbientColor(aColor[0], aColor[1], aColor[2]);
915 myStandaloneVertexActor->GetProperty()->SetAmbientColor(aColor[0], aColor[1], aColor[2]);
917 aColor = theProps[1]->GetAmbientColor();
918 myShadingBackFaceProp->SetAmbientColor(aColor[0], aColor[1], aColor[2]);
920 // Set diffuse colors
921 aColor = theProps[0]->GetDiffuseColor();
922 myShadingFaceProp->SetDiffuseColor(aColor[0], aColor[1], aColor[2]);
923 myVertexActor->GetProperty()->SetDiffuseColor(aColor[0], aColor[1], aColor[2]);
924 myStandaloneVertexActor->GetProperty()->SetDiffuseColor(aColor[0], aColor[1], aColor[2]);
926 aColor = theProps[1]->GetDiffuseColor();
927 myShadingBackFaceProp->SetDiffuseColor(aColor[0], aColor[1], aColor[2]);
929 // Set specular colors
930 aColor = theProps[0]->GetSpecularColor();
931 myShadingFaceProp->SetSpecularColor(aColor[0], aColor[1], aColor[2]);
932 myVertexActor->GetProperty()->SetSpecularColor(aColor[0], aColor[1], aColor[2]);
933 myStandaloneVertexActor->GetProperty()->SetSpecularColor(aColor[0], aColor[1], aColor[2]);
935 aColor = theProps[1]->GetSpecularColor();
936 myShadingBackFaceProp->SetSpecularColor(aColor[0], aColor[1], aColor[2]);
939 aCoefnt = theProps[0]->GetSpecularPower();
940 myShadingFaceProp->SetSpecularPower(aCoefnt);
941 myVertexActor->GetProperty()->SetSpecularPower(aCoefnt);
942 myStandaloneVertexActor->GetProperty()->SetSpecularPower(aCoefnt);
944 aCoefnt = theProps[1]->GetSpecularPower();
945 myShadingBackFaceProp->SetSpecularPower(aCoefnt);
947 // Set back face material property
948 myShadingFaceActor->SetBackfaceProperty(myShadingBackFaceProp.GetPointer());
951 vtkProperty* GEOM_Actor::GetFrontMaterial()
953 return myShadingFaceProp;
956 vtkProperty* GEOM_Actor::GetBackMaterial()
958 return myShadingBackFaceProp;
961 bool GEOM_Actor::IsInfinitive()
963 return ((bool)myShape.Infinite() || isOnlyVertex);
967 To map current selection to VTK representation
971 ::Highlight(bool theIsHighlight)
973 myIsSelected = theIsHighlight;
975 MESSAGE ( this << " GEOM_Actor::Highlight myIsSelected="<<myIsSelected );
978 SALOME_Actor::Highlight(theIsHighlight); // this method call ::highlight(theIsHighlight) in the end
979 SetVisibility(GetVisibility());
983 To process prehighlight (called from SVTK_InteractorStyle)
987 ::PreHighlight(vtkInteractorStyle *theInteractorStyle,
988 SVTK_SelectionEvent* theSelectionEvent,
992 MESSAGE ( this<<" GEOM_Actor::PreHighlight (3) theIsHighlight="<<theIsHighlight );
995 if ( !GetPickable() )
998 myPreHighlightActor->SetVisibility( false );
999 bool anIsPreselected = myIsPreselected;
1001 Selection_Mode aSelectionMode = theSelectionEvent->mySelectionMode;
1002 bool anIsChanged = (mySelectionMode != aSelectionMode);
1004 if( !theIsHighlight ) {
1005 SetPreSelected( false );
1007 switch(aSelectionMode){
1008 case ActorSelection :
1010 // cout << "=============== " << myIO->getEntry() << endl;
1011 // int nbio = mySelector->IObjectCount();
1012 // cout << " nbio = " << nbio << endl;
1014 if( !mySelector->IsSelected( myIO ) ) {
1015 // printf ("!!!!!!!!!!!!!!!!\n");
1016 SetPreSelected( true );
1024 mySelectionMode = aSelectionMode;
1025 anIsChanged |= (anIsPreselected != myIsPreselected);
1027 SetVisibility(GetVisibility());
1032 To process highlight (called from SVTK_InteractorStyle)
1036 ::Highlight(vtkInteractorStyle *theInteractorStyle,
1037 SVTK_SelectionEvent* theSelectionEvent,
1038 bool theIsHighlight)
1040 // define the selection of object
1042 MESSAGE ( std::endl << this << " GEOM_Actor::Highlight (3) myIsSelected="<<myIsSelected );
1044 bool aRet = SALOME_Actor::Highlight(theInteractorStyle,theSelectionEvent,theIsHighlight);
1045 SetSelected(theIsHighlight);
1047 SetPreSelected(false);
1053 // Copy the follower's composite 4x4 matrix into the matrix provided.
1054 void GEOM_Actor::GetMatrix(vtkCamera* theCam, vtkMatrix4x4 *result)
1057 double Rx[3], Ry[3], Rz[3], p1[3];
1058 vtkMatrix4x4 *matrix = vtkMatrix4x4::New();
1062 this->GetOrientation();
1063 this->Transform->Push();
1064 this->Transform->PostMultiply();
1065 this->Transform->Identity();
1067 // apply user defined matrix last if there is one
1068 if (this->UserMatrix)
1070 this->Transform->Concatenate(this->UserMatrix);
1073 this->Transform->Translate(-this->Origin[0],
1077 this->Transform->Scale(this->Scale[0],
1082 this->Transform->RotateY(this->Orientation[1]);
1083 this->Transform->RotateX(this->Orientation[0]);
1084 this->Transform->RotateZ(this->Orientation[2]);
1090 pos = theCam->GetPosition();
1091 vup = theCam->GetViewUp();
1093 if (theCam->GetParallelProjection())
1095 theCam->GetDirectionOfProjection(Rz);
1100 (pos[0] - this->Position[0])*(pos[0] - this->Position[0]) +
1101 (pos[1] - this->Position[1])*(pos[1] - this->Position[1]) +
1102 (pos[2] - this->Position[2])*(pos[2] - this->Position[2]));
1103 for (i = 0; i < 3; i++)
1105 Rz[i] = (pos[i] - this->Position[i])/distance;
1109 vtkMath::Cross(vup,Rz,Rx);
1110 vtkMath::Normalize(Rx);
1111 vtkMath::Cross(Rz,Rx,Ry);
1113 matrix->Element[0][0] = Rx[0];
1114 matrix->Element[1][0] = Rx[1];
1115 matrix->Element[2][0] = Rx[2];
1116 matrix->Element[0][1] = Ry[0];
1117 matrix->Element[1][1] = Ry[1];
1118 matrix->Element[2][1] = Ry[2];
1119 matrix->Element[0][2] = Rz[0];
1120 matrix->Element[1][2] = Rz[1];
1121 matrix->Element[2][2] = Rz[2];
1123 this->Transform->Concatenate(matrix);
1126 // translate to projection reference point PRP
1127 // this is the camera's position blasted through
1128 // the current matrix
1129 p1[0] = this->Origin[0] + this->Position[0];
1130 p1[1] = this->Origin[1] + this->Position[1];
1131 p1[2] = this->Origin[2] + this->Position[2];
1133 this->Transform->Translate(p1[0],p1[1],p1[2]);
1134 this->Transform->GetMatrix(result);
1137 this->Transform->Pop();
1140 void GEOM_Actor::SetEdgesInShadingColor(double r,double g,double b)
1142 myEdgesInShadingColor[0] = r;
1143 myEdgesInShadingColor[1] = g;
1144 myEdgesInShadingColor[2] = b;
1147 void GEOM_Actor::SetIsosWidth(const int width) {
1148 myWireframeFaceActor->GetProperty()->SetLineWidth(width);
1151 int GEOM_Actor::GetIsosWidth() const {
1152 return (int)myWireframeFaceActor->GetProperty()->GetLineWidth();
1155 void GEOM_Actor::SetWidth(const int width) {
1156 myIsolatedEdgeActor->GetProperty()->SetLineWidth(width);
1157 myOneFaceEdgeActor->GetProperty()->SetLineWidth(width);
1158 mySharedEdgeActor->GetProperty()->SetLineWidth(width);
1159 myHighlightProp->SetLineWidth(width);
1160 myPreHighlightProp->SetLineWidth(width+1);
1164 int GEOM_Actor::GetWidth() const {
1165 return (int)myIsolatedEdgeActor->GetProperty()->GetLineWidth();