X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FOBJECT%2FGEOM_Actor.cxx;h=b152bafd2b357d2d40dce3af3f218ac26e0ff1eb;hb=7e21a68ba07185cd1dddcf9e1522a28111c2cee4;hp=e29c665cbd465c69308d824bf5810aa1d031f2ff;hpb=0f1369c27fd6a84ba1149c3c5f3ed181acc055f1;p=modules%2Fgeom.git diff --git a/src/OBJECT/GEOM_Actor.cxx b/src/OBJECT/GEOM_Actor.cxx index e29c665cb..b152bafd2 100644 --- a/src/OBJECT/GEOM_Actor.cxx +++ b/src/OBJECT/GEOM_Actor.cxx @@ -1,212 +1,550 @@ -// GEOM OBJECT : interactive object for Geometry entities visualization +// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // + +// GEOM OBJECT : interactive object for Geometry entities visualization // File : GEOM_Actor.cxx // Author : Christophe ATTANASIO // Module : GEOM // $Header$ - -using namespace std; +// /*! \class GEOM_Actor GEOM_Actor.h \brief This class allows to display an OpenCASCADE CAD model in a VTK viewer. */ +#include "GEOM_Actor.h" + +#include "GEOM_DeviceActor.h" +#include "GEOM_VertexSource.h" +#include "GEOM_EdgeSource.h" +#include "GEOM_WireframeFace.h" +#include "GEOM_ShadingFace.h" +#include "SVTK_Actor.h" + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "utilities.h" + +#include "SALOME_InteractiveObject.hxx" + +//vtkStandardNewMacro(GEOM_Actor); + +#ifndef MYDEBUG +//#define MYDEBUG +#endif + +GEOM_Actor::GEOM_Actor(): + // myDisplayMode(eWireframe), + myIsSelected(false), + myVectorMode(false), + myVertexActor(GEOM_DeviceActor::New(),true), + myVertexSource(GEOM_VertexSource::New(),true), + + myIsolatedEdgeActor(GEOM_DeviceActor::New(),true), + myIsolatedEdgeSource(GEOM_EdgeSource::New(),true), + + myOneFaceEdgeActor(GEOM_DeviceActor::New(),true), + myOneFaceEdgeSource(GEOM_EdgeSource::New(),true), + + mySharedEdgeActor(GEOM_DeviceActor::New(),true), + mySharedEdgeSource(GEOM_EdgeSource::New(),true), + + myWireframeFaceActor(GEOM_DeviceActor::New(),true), + myWireframeFaceSource(GEOM_WireframeFace::New(),true), + + myShadingFaceActor(GEOM_DeviceActor::New(),true), + myShadingFaceSource(GEOM_ShadingFace::New(),true), + + myHighlightActor(GEOM_DeviceActor::New(),true), + myAppendFilter(vtkAppendPolyData::New(),true), + myPolyDataMapper(vtkPolyDataMapper::New(),true), + + myHighlightProp(vtkProperty::New()), + myPreHighlightProp(vtkProperty::New()), + myShadingFaceProp(vtkProperty::New()), + isOnlyVertex(false) +{ +#ifdef MYDEBUG + MESSAGE (this<< " GEOM_Actor::GEOM_Actor"); +#endif + + myPolyDataMapper->SetInput(myAppendFilter->GetOutput()); + vtkProperty* aProperty; + + myHighlightProp->SetAmbient(0.5); + myHighlightProp->SetDiffuse(0.3); + myHighlightProp->SetSpecular(0.2); + myHighlightProp->SetRepresentationToSurface(); + myHighlightProp->SetAmbientColor(1, 1, 1); + myHighlightProp->SetDiffuseColor(1, 1, 1); + myHighlightProp->SetSpecularColor(0.5, 0.5, 0.5); + myHighlightProp->SetPointSize(SALOME_POINT_SIZE); + myHighlightActor->SetProperty(myHighlightProp.GetPointer()); + + this->myHighlightActor->SetInput(myAppendFilter->GetOutput(),false); + + myPreHighlightProp->SetColor(0,1,1); + myPreHighlightProp->SetPointSize(SALOME_POINT_SIZE+2); + myPreHighlightProp->SetLineWidth(SALOME_LINE_WIDTH+1); + myPreHighlightProp->SetRepresentationToWireframe(); + + myAppendFilter->AddInput(myVertexSource->GetOutput()); + myVertexActor->SetInput(myVertexSource->GetOutput(),false); + aProperty = myVertexActor->GetProperty(); + aProperty->SetRepresentation(VTK_POINTS); + aProperty->SetPointSize(3); + aProperty->SetColor(1, 1, 0); + + myAppendFilter->AddInput(myIsolatedEdgeSource->GetOutput()); + myIsolatedEdgeActor->SetInput(myIsolatedEdgeSource->GetOutput(),false); + aProperty = myIsolatedEdgeActor->GetProperty(); + aProperty->SetRepresentation(VTK_WIREFRAME); + aProperty->SetColor(1, 0, 0); + + myAppendFilter->AddInput(myOneFaceEdgeSource->GetOutput()); + myOneFaceEdgeActor->SetInput(myOneFaceEdgeSource->GetOutput(),false); + aProperty = myOneFaceEdgeActor->GetProperty(); + aProperty->SetRepresentation(VTK_WIREFRAME); + aProperty->SetColor(0, 1, 0); + + myAppendFilter->AddInput(mySharedEdgeSource->GetOutput()); + mySharedEdgeActor->SetInput(mySharedEdgeSource->GetOutput(),false); + aProperty = mySharedEdgeActor->GetProperty(); + aProperty->SetRepresentation(VTK_WIREFRAME); + aProperty->SetColor(1, 1, 0); + + myAppendFilter->AddInput(myWireframeFaceSource->GetOutput()); + myWireframeFaceActor->SetInput(myWireframeFaceSource->GetOutput(),false); + aProperty = myWireframeFaceActor->GetProperty(); + aProperty->SetRepresentation(VTK_WIREFRAME); + aProperty->SetColor(0.5, 0.5, 0.5); -#include "GEOM_Actor.h" + myShadingFaceActor->SetInput(myShadingFaceSource->GetOutput(),true); -// OpenCASCADE Includes -#include "GEOM_OCCReader.h" -#include + myShadingFaceProp->SetRepresentation(VTK_SURFACE); + myShadingFaceProp->SetInterpolationToGouraud(); + myShadingFaceProp->SetAmbient(1.0); + myShadingFaceProp->SetDiffuse(1.0); + myShadingFaceProp->SetSpecular(0.4); + myShadingFaceProp->SetAmbientColor(0.329412, 0.223529, 0.027451); + myShadingFaceProp->SetDiffuseColor(0.780392, 0.568627, 0.113725); + myShadingFaceProp->SetSpecularColor(0.992157, 0.941176, 0.807843); -//------------------------------------------------------------- -// Main methods -//------------------------------------------------------------- + myShadingFaceActor->SetProperty(myShadingFaceProp.GetPointer()); + // Toggle display mode + setDisplayMode(0); // WIRE FRAME -GEOM_Actor* GEOM_Actor::New() +} + + +GEOM_Actor::~GEOM_Actor() +{ +#ifdef MYDEBUG + MESSAGE (this<< " ~GEOM_Actor::GEOM_Actor"); +#endif + myHighlightProp->Delete(); + myPreHighlightProp->Delete(); + myShadingFaceProp->Delete(); +} + +GEOM_Actor* +GEOM_Actor:: +New() +{ + GEOM_Actor* anObject = new GEOM_Actor(); + anObject->SetMapper(anObject->myPolyDataMapper.Get()); + return anObject; +} + + +void Write(vtkPolyData* theDataSet, const char* theFileName){ + vtkPolyDataWriter* aWriter = vtkPolyDataWriter::New(); + MESSAGE ("Write - "<GetNumberOfPoints()<<"; "<GetNumberOfCells()); + aWriter->SetInput(theDataSet); + aWriter->SetFileName(theFileName); + //aWriter->Write(); + aWriter->Delete(); +} + +void +GEOM_Actor:: +SetModified() +{ + this->myVertexSource->Modified(); + this->myIsolatedEdgeSource->Modified(); + this->myOneFaceEdgeSource->Modified(); + this->mySharedEdgeSource->Modified(); + this->myWireframeFaceSource->Modified(); + this->myShadingFaceSource->Modified(); +} + +void +GEOM_Actor:: +SetMapper(vtkMapper* theMapper) +{ + SALOME_Actor::SetMapper(theMapper); +} + +void +GEOM_Actor:: +AddToRender(vtkRenderer* theRenderer) { - // First try to create the object from the vtkObjectFactory - vtkObject* ret = vtkObjectFactory::CreateInstance("GEOM_Actor"); - if(ret) - { - return (GEOM_Actor*)ret; - } - // If the factory was unable to create the object, then create it here. - return new GEOM_Actor; -} - + //SALOME_Actor::AddToRender(theRenderer); + + theRenderer->AddActor(this); + + this->myHighlightActor->AddToRender(theRenderer); + -GEOM_Actor::GEOM_Actor() + myShadingFaceActor->AddToRender(theRenderer); + myWireframeFaceActor->AddToRender(theRenderer); + + mySharedEdgeActor->AddToRender(theRenderer); + myOneFaceEdgeActor->AddToRender(theRenderer); + myIsolatedEdgeActor->AddToRender(theRenderer); + + myVertexActor->AddToRender(theRenderer); +} + +void +GEOM_Actor:: +RemoveFromRender(vtkRenderer* theRenderer) { - this->Device = vtkActor::New(); + //SALOME_Actor::RemoveFromRender(theRenderer); - this->WireframeMapper = NULL; - this->ShadingMapper = NULL; + + theRenderer->RemoveActor(this); - this->ShadingProperty = NULL; - this->WireframeProperty = NULL; + myHighlightActor->RemoveFromRender(theRenderer); + myShadingFaceActor->RemoveFromRender(theRenderer); + myWireframeFaceActor->RemoveFromRender(theRenderer); + + mySharedEdgeActor->RemoveFromRender(theRenderer); + myOneFaceEdgeActor->RemoveFromRender(theRenderer); + myIsolatedEdgeActor->RemoveFromRender(theRenderer); + + myVertexActor->RemoveFromRender(theRenderer); - this->deflection = 0; - myDisplayMode = 0; + + SetSelected(false); + SetVisibility(false); +} - this->myIO = NULL; - this->myName = ""; +void +GEOM_Actor:: +setDisplayMode(int theMode) +{ +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::SetDisplayMode = "<ShadingMapper = NULL; - this->WireframeMapper = NULL; - } - - // Now do superclass - this->SALOME_Actor::ShallowCopy(prop); + myWireframeFaceSource->GetNbIso(theNbU, theNbV); } -//------------------------------------------------------------- -// Set parameters -//------------------------------------------------------------- - - -void GEOM_Actor::setDisplayMode(int thenewmode) { - myDisplayMode = thenewmode; - if ( thenewmode >=1 ) { - if ((myShape.ShapeType() == TopAbs_WIRE) || - (myShape.ShapeType() == TopAbs_EDGE) || - (myShape.ShapeType() == TopAbs_VERTEX)) { - if ( !subshape ) - CreateWireframeMapper(); - else - return; - } else - CreateShadingMapper(); - } else - CreateWireframeMapper(); +void +GEOM_Actor +::SetVectorMode(bool theMode) +{ + myVectorMode = theMode; + myIsolatedEdgeSource->SetVectorMode(theMode); + myOneFaceEdgeSource->SetVectorMode(theMode); + mySharedEdgeSource->SetVectorMode(theMode); + SetModified(); } -void GEOM_Actor::setDeflection(double adef) { - deflection = adef; +bool +GEOM_Actor +::GetVectorMode() +{ + return myVectorMode; } -void GEOM_Actor::setInputShape(const TopoDS_Shape& aShape,double adef,int imode) { - myShape = aShape; - deflection = adef; - setDisplayMode(imode); +static +void +MeshShape(const TopoDS_Shape& theShape, + float& theDeflection, + bool theIsRelative) +{ + static Standard_Real RELATIVE_DEFLECTION = 0.0001; + Standard_Real aDeflection = theDeflection; + + if(theDeflection <= 0) { // Compute default theDeflection + Bnd_Box B; + BRepBndLib::Add(theShape, B); + Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax; + B.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax); + Standard_Real aDiagonal = (aXmax-aXmin)*(aXmax-aXmin) + + (aYmax-aYmin)*(aYmax-aYmin) + + (aZmax-aZmin)*(aZmax-aZmin); + aDiagonal = sqrt(aDiagonal); + aDeflection = aDiagonal*RELATIVE_DEFLECTION; + + if(theIsRelative) + theDeflection = RELATIVE_DEFLECTION; + else + theDeflection = aDeflection; + } + + BRepMesh_IncrementalMesh aMesh(theShape,aDeflection); } -//------------------------------------------------------------- -// Get parameters -//------------------------------------------------------------- +void +GEOM_Actor:: +SetDeflection(float theDeflection, bool theIsRelative) +{ + myDeflection = theDeflection; + myIsRelative = theIsRelative; + + MeshShape(myShape,myDeflection,myIsRelative); + + SetModified(); +} -const TopoDS_Shape& GEOM_Actor::getTopo() { - return myShape; -} +void GEOM_Actor::SetShape (const TopoDS_Shape& theShape, + float theDeflection, + bool theIsRelative, + bool theIsVector) +{ + myShape = theShape; + + myVertexSource->Clear(); + myIsolatedEdgeSource->Clear(); + myOneFaceEdgeSource->Clear(); + mySharedEdgeSource->Clear(); + myWireframeFaceSource->Clear(); + myShadingFaceSource->Clear(); + + TopExp_Explorer aVertexExp (theShape,TopAbs_VERTEX); + for (; aVertexExp.More(); aVertexExp.Next()) + { + const TopoDS_Vertex& aVertex = TopoDS::Vertex(aVertexExp.Current()); + myVertexSource->AddVertex(aVertex); + } + SetDeflection(theDeflection, theIsRelative); + + // look if edges are free or shared + TopTools_IndexedDataMapOfShapeListOfShape anEdgeMap; + TopExp::MapShapesAndAncestors(theShape,TopAbs_EDGE,TopAbs_FACE,anEdgeMap); + + SetShape(theShape,anEdgeMap,theIsVector); + isOnlyVertex = + myIsolatedEdgeSource->IsEmpty() && + myOneFaceEdgeSource->IsEmpty() && + mySharedEdgeSource->IsEmpty() && + myWireframeFaceSource->IsEmpty() && + myShadingFaceSource->IsEmpty(); -double GEOM_Actor::getDeflection() { - return deflection; + + if((bool)myShape.Infinite() || isOnlyVertex ){ + myVertexActor->GetDeviceActor()->SetInfinitive(true); + myHighlightActor->GetDeviceActor()->SetInfinitive(true); + } } -void GEOM_Actor::SetWireframeProperty(vtkProperty* Prop) { - this->WireframeProperty = Prop; +void GEOM_Actor::SetShape (const TopoDS_Shape& theShape, + const TopTools_IndexedDataMapOfShapeListOfShape& theEdgeMap, + bool theIsVector) +{ + if (theShape.ShapeType() == TopAbs_COMPOUND) { + TopoDS_Iterator anItr(theShape); + for (; anItr.More(); anItr.Next()) { + SetShape(anItr.Value(),theEdgeMap,theIsVector); + } + } + + switch (theShape.ShapeType()) { + case TopAbs_WIRE: { + TopExp_Explorer anEdgeExp(theShape,TopAbs_EDGE); + for (; anEdgeExp.More(); anEdgeExp.Next()){ + const TopoDS_Edge& anEdge = TopoDS::Edge(anEdgeExp.Current()); + if (!BRep_Tool::Degenerated(anEdge)) + myIsolatedEdgeSource->AddEdge(anEdge,theIsVector); + } + break; + } + case TopAbs_EDGE: { + const TopoDS_Edge& anEdge = TopoDS::Edge(theShape); + if (!BRep_Tool::Degenerated(anEdge)) + myIsolatedEdgeSource->AddEdge(anEdge,theIsVector); + break; + } + case TopAbs_VERTEX: { + break; + } + default: { + TopExp_Explorer aFaceExp (theShape,TopAbs_FACE); + for(; aFaceExp.More(); aFaceExp.Next()) { + const TopoDS_Face& aFace = TopoDS::Face(aFaceExp.Current()); + myWireframeFaceSource->AddFace(aFace); + myShadingFaceSource->AddFace(aFace); + TopExp_Explorer anEdgeExp(aFaceExp.Current(), TopAbs_EDGE); + for(; anEdgeExp.More(); anEdgeExp.Next()) { + const TopoDS_Edge& anEdge = TopoDS::Edge(anEdgeExp.Current()); + if(!BRep_Tool::Degenerated(anEdge)){ + // compute the number of faces + int aNbOfFaces = theEdgeMap.FindFromKey(anEdge).Extent(); + switch(aNbOfFaces){ + case 0: // isolated edge + myIsolatedEdgeSource->AddEdge(anEdge,theIsVector); + break; + case 1: // edge in only one face + myOneFaceEdgeSource->AddEdge(anEdge,theIsVector); + break; + default: // edge shared by at least two faces + mySharedEdgeSource->AddEdge(anEdge,theIsVector); + } + } + } + } + } + } } -void GEOM_Actor::SetShadingProperty(vtkProperty* Prop) { - this->ShadingProperty = Prop; +// OLD METHODS +void GEOM_Actor::setDeflection(double adef) { +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::setDeflection" ); +#endif + SetDeflection((float)adef,GetIsRelative()); } -//------------------------------------------------------------- -// Mapper creating function -//------------------------------------------------------------- -void GEOM_Actor::CreateMapper(int theMode) { - if(myShape.ShapeType() == TopAbs_VERTEX) { - gp_Pnt aPnt = BRep_Tool::Pnt(TopoDS::Vertex(myShape)); - this->SetPosition(aPnt.X(),aPnt.Y(),aPnt.Z()); - } - GEOM_OCCReader* aread = GEOM_OCCReader::New(); - aread->setTopo(myShape); - aread->setDisplayMode(theMode); - aread->GetOutput()->ReleaseDataFlagOn(); - - vtkPolyDataMapper* aMapper = vtkPolyDataMapper::New(); - if (theMode == 0) { - aMapper->SetInput(aread->GetOutput()); - } else { - vtkPolyDataNormals *normals = vtkPolyDataNormals::New(); - normals->SetInput(aread->GetOutput()); - aMapper->SetInput(normals->GetOutput()); - } - aread->Delete(); - this->SetMapper(theMode == 0? WireframeMapper = aMapper : ShadingMapper = aMapper); -} +// warning! must be checked! +// SetHighlightProperty +// SetWireframeProperty +// SetShadingProperty -void GEOM_Actor::CreateShadingMapper() { - CreateMapper(1); +void GEOM_Actor::SetHighlightProperty(vtkProperty* Prop) +{ +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::SetHighlightProperty" ); +#endif + this->myHighlightActor->GetProperty()->DeepCopy(Prop); + } +void GEOM_Actor::SetWireframeProperty(vtkProperty* Prop) +{ +#ifdef MYDEBUG + MESSAGE ( this << " GEOM_Actor::SetWireframeProperty" ); +#endif + // must be filled + myWireframeFaceActor->SetProperty(Prop); +} -void GEOM_Actor::CreateWireframeMapper() { - CreateMapper(0); +void GEOM_Actor::SetShadingProperty(vtkProperty* Prop) +{ +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::SetShadingProperty" ); +#endif + myShadingFaceProp->DeepCopy(Prop); } -//------------------------------------------------------------- -// Render function -//------------------------------------------------------------- -void GEOM_Actor::Render(vtkRenderer *ren, vtkMapper *Mapper) +void GEOM_Actor::Render(vtkRenderer *ren, vtkMapper *theMapper) { +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::Render" ); +#endif + + if(!GetVisibility()) + return; + /* render the property */ if (!this->Property) { // force creation of a property @@ -219,17 +557,29 @@ void GEOM_Actor::Render(vtkRenderer *ren, vtkMapper *Mapper) this->Property->SetSpecularColor(0.99,0.98,0.83); } - if(!ishighlighted) { - if(myDisplayMode >= 1) { - // SHADING - this->Property = ShadingProperty; - } - else { - this->Property = WireframeProperty; - } + switch(myDisplayMode){ + case 0://wireframe + myPreHighlightProp->SetRepresentationToWireframe(); + myHighlightProp->SetRepresentationToWireframe(); + break; + case 1://shading + myPreHighlightProp->SetRepresentationToSurface(); + myHighlightProp->SetRepresentationToSurface(); + break; + } - if ( ispreselected ) - this->Property = PreviewProperty; + if(!myIsSelected){ + if(myIsPreselected){ + this->myHighlightActor->SetProperty(myPreHighlightProp.GetPointer()); + myShadingFaceActor->SetProperty(myPreHighlightProp.GetPointer()); + } else { + this->myHighlightActor->SetProperty(myShadingFaceProp.GetPointer()); + myShadingFaceActor->SetProperty(myShadingFaceProp.GetPointer()); + } + } + else{ + this->myHighlightActor->SetProperty(myHighlightProp.GetPointer()); + myShadingFaceActor->SetProperty(myHighlightProp.GetPointer()); } this->Property->Render(this, ren); @@ -238,31 +588,13 @@ void GEOM_Actor::Render(vtkRenderer *ren, vtkMapper *Mapper) this->Device->SetBackfaceProperty(this->BackfaceProperty); } this->Device->SetProperty(this->Property); - // Store information on time it takes to render. - // We might want to estimate time from the number of polygons in mapper. - if(myDisplayMode >= 1) { - if((myShape.ShapeType() == TopAbs_WIRE) || - (myShape.ShapeType() == TopAbs_EDGE) || - (myShape.ShapeType() == TopAbs_VERTEX)) { - if ( !subshape ) { - if(WireframeMapper==NULL) CreateWireframeMapper(); - } else - return; - } - else { - if(ShadingMapper==NULL) CreateShadingMapper(); - } - } - else { - if(WireframeMapper==NULL) CreateWireframeMapper(); - } - if(myShape.ShapeType() == TopAbs_VERTEX) { + /* if(myShape.ShapeType() == TopAbs_VERTEX) { if(ren){ //The parameter determine size of vertex actor relate to diagonal of RendererWindow - static float delta = 0.01; - float X1 = -1, Y1 = -1, Z1 = 0; + static vtkFloatingPointType delta = 0.01; + vtkFloatingPointType X1 = -1, Y1 = -1, Z1 = 0; ren->ViewToWorld(X1,Y1,Z1); - float X2 = +1, Y2 = +1, Z2 = 0; + vtkFloatingPointType X2 = +1, Y2 = +1, Z2 = 0; ren->ViewToWorld(X2,Y2,Z2); Z2 = sqrt((X2-X1)*(X2-X1) + (Y2-Y1)*(Y2-Y1) + (Z2-Z1)*(Z2-Z1)); this->SetScale(Z2*delta); @@ -270,111 +602,216 @@ void GEOM_Actor::Render(vtkRenderer *ren, vtkMapper *Mapper) vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New(); this->GetMatrix(ren->GetActiveCamera(), aMatrix); this->Device->SetUserMatrix(aMatrix); - this->Device->Render(ren,this->Mapper); + this->Device->Render(ren,theMapper); aMatrix->Delete(); - } else - this->Device->Render(ren, this->Mapper); - this->EstimatedRenderTime = WireframeMapper->GetTimeToDraw(); + } else*/ + this->Device->Render(ren, theMapper); } -// SubShape -void GEOM_Actor::SubShapeOn() +void GEOM_Actor::ReleaseGraphicsResources(vtkWindow *) { - subshape = true; +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::ReleaseGraphicsResources" ); +#endif } -void GEOM_Actor::SubShapeOff() + + + +void GEOM_Actor::ShallowCopy(vtkProp *prop) +{ +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::ShallowCopy" ); +#endif + GEOM_Actor *f = GEOM_Actor::SafeDownCast(prop); + if ( f != NULL ) + { + this->SetShape(f->getTopo(),f->GetDeflection(),f->GetIsRelative()); + } + + // Now do superclass + this->SALOME_Actor::ShallowCopy(prop); +} + +const TopoDS_Shape& GEOM_Actor::getTopo() { +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::getTopo" ); +#endif + return myShape; +} + +void GEOM_Actor::setInputShape(const TopoDS_Shape& ashape, double adef1, + int imode, bool isVector) { - subshape = false; +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::setInputShape" ); +#endif +} + +double GEOM_Actor::getDeflection() +{ +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::getDeflection" ); +#endif + return (double) GetDeflection(); } -//------------------------------------------------------------- -// Opacity methods -//------------------------------------------------------------- -void GEOM_Actor::SetOpacity(float opa) +double GEOM_Actor::isVector() { - //HighlightProperty->SetOpacity(opa); - SALOME_Actor::SetOpacity(opa); - ShadingProperty->SetOpacity(opa); +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::isVector" ); +#endif + return 0; } -float GEOM_Actor::GetOpacity() { - return ShadingProperty->GetOpacity(); +void GEOM_Actor::SubShapeOn() +{ +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::SubShapeOn" ); +#endif } -//------------------------------------------------------------- -// Color methods -//------------------------------------------------------------- -void GEOM_Actor::SetColor(float r,float g,float b) { - ShadingProperty->SetColor(r,g,b); +void GEOM_Actor::SubShapeOff() +{ +#ifdef MYDEBUG + MESSAGE ( "GEOM_Actor::SubShapeOff" ); +#endif } -void GEOM_Actor::GetColor(float& r,float& g,float& b) { - float color[3]; - ShadingProperty->GetColor(color); - r = color[0]; - g = color[1]; - b = color[2]; +void GEOM_Actor::highlight(bool highlight) +{ +#ifdef MYDEBUG + MESSAGE ( this << " GEOM_Actor::highlight highlight="<SetOpacity(opa); + myHighlightProp->SetOpacity(opa); + myPreHighlightProp->SetOpacity(opa); + myVertexActor->GetProperty()->SetOpacity(opa); +} -void GEOM_Actor::highlight(Standard_Boolean highlight) { +vtkFloatingPointType GEOM_Actor::GetOpacity() +{ + // enk:tested OK + return myShadingFaceProp->GetOpacity(); +} - if(highlight && !ishighlighted) { - ishighlighted=true; - // build highlight property is necessary - if(HighlightProperty==NULL) { - HighlightProperty = vtkProperty::New(); - HighlightProperty->SetAmbient(0.5); - HighlightProperty->SetDiffuse(0.3); - HighlightProperty->SetSpecular(0.2); - HighlightProperty->SetRepresentationToSurface(); - HighlightProperty->SetAmbientColor(1, 1, 1); - HighlightProperty->SetDiffuseColor(1, 1, 1); - HighlightProperty->SetSpecularColor(0.5, 0.5, 0.5); - } - - this->Property = HighlightProperty; - - } - else if (!highlight) { - if(ishighlighted) { - ishighlighted=false; - if(myDisplayMode==1) { - //unhilight in shading - this->Property = ShadingProperty; - } - else { - //unhilight in wireframe - this->Property = WireframeProperty; - } - } - } +void GEOM_Actor::SetColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) +{ + // enk:tested OK + myShadingFaceProp->SetColor(r,g,b); // shading color (Shading) + myIsolatedEdgeActor->GetProperty()->SetColor(r,g,b); // standalone edge color (Wireframe) + myVertexActor->GetProperty()->SetColor(r,g,b); // vertex actor (Shading/Wireframe) + myOneFaceEdgeActor->GetProperty()->SetColor(r,g,b); // standalone face edge color (Wireframe) + mySharedEdgeActor->GetProperty()->SetColor(r,g,b); // share edge color (Wireframe) } -bool GEOM_Actor::hasHighlight() +void GEOM_Actor::GetColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) { - return true; + // enk:tested OK + vtkFloatingPointType aRGB[3]; + myShadingFaceProp->GetColor(aRGB); + r = aRGB[0]; + g = aRGB[1]; + b = aRGB[2]; } -void GEOM_Actor::SetHighlightProperty(vtkProperty* Prop) { - this->HighlightProperty = Prop; +bool GEOM_Actor::IsInfinitive() +{ + return ((bool)myShape.Infinite() || isOnlyVertex); } +/*! + To map current selection to VTK representation +*/ +void +GEOM_Actor +::Highlight(bool theIsHighlight) +{ + myIsSelected = theIsHighlight; +#ifdef MYDEBUG + MESSAGE ( this << " GEOM_Actor::Highlight myIsSelected="<getEntry() << endl; + int nbio = mySelector->IObjectCount(); + // cout << " nbio = " << nbio << endl; - if(WireframeMapper) this->WireframeMapper->ReleaseGraphicsResources(renWin); - if(ShadingMapper) this->ShadingMapper->ReleaseGraphicsResources(renWin); + if( !mySelector->IsSelected( myIO ) ) { + // printf ("!!!!!!!!!!!!!!!!\n"); + SetPreSelected( true ); + } + } + default: + break; + } + } + + mySelectionMode = aSelectionMode; + anIsChanged |= (anIsPreselected != myIsPreselected); + + SetVisibility(GetVisibility()); + return anIsChanged; } +/*! + To process highlight (called from SVTK_InteractorStyle) +*/ +bool +GEOM_Actor +::Highlight(vtkInteractorStyle *theInteractorStyle, + SVTK_SelectionEvent* theSelectionEvent, + bool theIsHighlight) +{ + // define the selection of object +#ifdef MYDEBUG + MESSAGE ( std::endl << this << " GEOM_Actor::Highlight (3) myIsSelected="<Position[0])*(pos[0] - this->Position[0]) + + (pos[0] - this->Position[0])*(pos[0] - this->Position[0]) + (pos[1] - this->Position[1])*(pos[1] - this->Position[1]) + (pos[2] - this->Position[2])*(pos[2] - this->Position[2])); for (i = 0; i < 3; i++) - { + { Rz[i] = (pos[i] - this->Position[i])/distance; - } + } } vtkMath::Cross(vup,Rz,Rx);