X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FOBJECT%2FSMESH_Actor.cxx;h=29a1f094bd6a1af283abcd59800a555786fa3fc0;hp=fb8dcf04ff8972089ee1e284fca48203c84f1b2c;hb=c3bf92bd87b770fd81631a3853f7f5bb1ac6a4e8;hpb=4791f5b30ea7a9c1247aa551750dc71cb83b99aa diff --git a/src/OBJECT/SMESH_Actor.cxx b/src/OBJECT/SMESH_Actor.cxx index fb8dcf04f..29a1f094b 100644 --- a/src/OBJECT/SMESH_Actor.cxx +++ b/src/OBJECT/SMESH_Actor.cxx @@ -26,592 +26,1262 @@ // Module : SMESH // $Header$ -using namespace std; -/*! - \class SMESH_Actor SMESH_Actor.h - \brief ... -*/ #include "SMESH_Actor.h" -#include "SMESH_Grid.h" +#include "SMESH_DeviceActor.h" +#include "SALOME_ExtractUnstructuredGrid.h" + +#include "QAD_Config.h" #include "utilities.h" +#include -// VTK Includes #include -#include -#include -#include -#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef _DEBUG_ +static int MYDEBUG = 1; +static int MYDEBUGWITHFILES = 0; +#else +static int MYDEBUG = 0; +static int MYDEBUGWITHFILES = 0; +#endif -//------------------------------------------------------------- -// Main methods -//------------------------------------------------------------- +using namespace std; -SMESH_Actor* SMESH_Actor::New() -{ - // First try to create the object from the vtkObjectFactory - vtkObject* ret = vtkObjectFactory::CreateInstance("SMESH_Actor"); - if(ret) - { - return (SMESH_Actor*)ret; - } - // If the factory was unable to create the object, then create it here. - return new SMESH_Actor; + +inline float GetFloat(const QString& theValue, float theDefault = 0){ + if(theValue.isEmpty()) return theDefault; + QString aValue = QAD_CONFIG->getSetting(theValue); + if(aValue.isEmpty()) return theDefault; + return aValue.toFloat(); +} + + +SMESH_Actor* SMESH_Actor::New(){ + return new SMESH_Actor(); } -SMESH_Actor::SMESH_Actor() +SMESH_Actor* SMESH_Actor::New(TVisualObjPtr theVisualObj, + SMESH::FilterManager_ptr theFilterMgr, + const char* theEntry, + const char* theName, + int theIsClear) { - this->Device = vtkActor::New(); + SMESH_Actor* anActor = SMESH_Actor::New(); + anActor->Init(theVisualObj,theFilterMgr,theEntry,theName,theIsClear); + return anActor; +} - this->EdgeDevice = vtkActor::New(); - EdgeDevice->VisibilityOff(); - EdgeDevice->PickableOff(); - this->EdgeShrinkDevice = vtkActor::New(); - EdgeShrinkDevice->VisibilityOff(); - EdgeShrinkDevice->PickableOff(); +SMESH_Actor::SMESH_Actor(){ + if(MYDEBUG) MESSAGE("SMESH_Actor"); + + myIsPointsVisible = false; + + myIsShrinkable = false; + myIsShrunk = false; + + float aPointSize = GetFloat("SMESH:SettingsNodesSize",3); + float aLineWidth = GetFloat("SMESH:SettingsWidth",1); + + vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New(); + SALOME_ExtractUnstructuredGrid* aFilter = NULL; + + //Definition 2D and 3D divices of the actor + //----------------------------------------- + float anRGB[3] = {1,1,1}; + mySurfaceProp = vtkProperty::New(); + anRGB[0] = GetFloat("SMESH:SettingsFillColorRed", 0)/255.; + anRGB[1] = GetFloat("SMESH:SettingsFillColorGreen", 170)/255.; + anRGB[2] = GetFloat("SMESH:SettingsFillColorBlue", 255)/255.; + mySurfaceProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); + + myBackSurfaceProp = vtkProperty::New(); + anRGB[0] = GetFloat("SMESH:SettingsBackFaceColorRed", 0)/255.; + anRGB[1] = GetFloat("SMESH:SettingsBackFaceColorGreen", 0)/255.; + anRGB[2] = GetFloat("SMESH:SettingsBackFaceColorBlue", 255)/255.; + myBackSurfaceProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); + + my2DActor = SMESH_DeviceActor::New(); + my2DActor->SetUserMatrix(aMatrix); + my2DActor->SetStoreMapping(true); + my2DActor->PickableOff(); + my2DActor->SetProperty(mySurfaceProp); + my2DActor->SetBackfaceProperty(myBackSurfaceProp); + my2DActor->SetRepresentation(SMESH_DeviceActor::eSurface); + aFilter = my2DActor->GetExtractUnstructuredGrid(); + aFilter->SetModeOfChanging(SALOME_ExtractUnstructuredGrid::eAdding); + aFilter->RegisterCellsWithType(VTK_TRIANGLE); + aFilter->RegisterCellsWithType(VTK_POLYGON); + aFilter->RegisterCellsWithType(VTK_QUAD); + + my3DActor = SMESH_DeviceActor::New(); + my3DActor->SetUserMatrix(aMatrix); + my3DActor->SetStoreMapping(true); + my3DActor->PickableOff(); + my3DActor->SetProperty(mySurfaceProp); + my3DActor->SetBackfaceProperty(myBackSurfaceProp); + my3DActor->SetRepresentation(SMESH_DeviceActor::eSurface); + aFilter = my3DActor->GetExtractUnstructuredGrid(); + aFilter->SetModeOfChanging(SALOME_ExtractUnstructuredGrid::eAdding); + aFilter->RegisterCellsWithType(VTK_TETRA); + aFilter->RegisterCellsWithType(VTK_VOXEL); + aFilter->RegisterCellsWithType(VTK_HEXAHEDRON); + aFilter->RegisterCellsWithType(VTK_WEDGE); + aFilter->RegisterCellsWithType(VTK_PYRAMID); + + + //Definition 1D divice of the actor + //--------------------------------- + myEdgeProp = vtkProperty::New(); + myEdgeProp->SetAmbient(1.0); + myEdgeProp->SetDiffuse(0.0); + myEdgeProp->SetSpecular(0.0); + anRGB[0] = GetFloat("SMESH:SettingsOutlineColorRed", 0)/255.; + anRGB[1] = GetFloat("SMESH:SettingsOutlineColorGreen", 170)/255.; + anRGB[2] = GetFloat("SMESH:SettingsOutlineColorBlue", 255)/255.; + myEdgeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); + myEdgeProp->SetLineWidth(aLineWidth); + + my1DActor = SMESH_DeviceActor::New(); + my1DActor->SetUserMatrix(aMatrix); + my1DActor->SetStoreMapping(true); + my1DActor->PickableOff(); + my1DActor->SetProperty(myEdgeProp); + my1DActor->SetRepresentation(SMESH_DeviceActor::eSurface); + aFilter = my1DActor->GetExtractUnstructuredGrid(); + aFilter->SetModeOfChanging(SALOME_ExtractUnstructuredGrid::eAdding); + aFilter->RegisterCellsWithType(VTK_LINE); + + my1DProp = vtkProperty::New(); + my1DProp->DeepCopy(myEdgeProp); + static int aCotnrolLineWidth = 3; + my1DProp->SetLineWidth(aCotnrolLineWidth); + my1DProp->SetPointSize(aPointSize); + + my1DExtProp = vtkProperty::New(); + my1DExtProp->DeepCopy(myEdgeProp); + anRGB[0] = 1 - anRGB[0]; + anRGB[1] = 1 - anRGB[1]; + anRGB[2] = 1 - anRGB[2]; + my1DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); + my1DExtProp->SetLineWidth(aCotnrolLineWidth); + + my1DExtActor = SMESH_DeviceActor::New(); + my1DExtActor->SetUserMatrix(aMatrix); + my1DExtActor->SetStoreMapping(true); + my1DExtActor->PickableOff(); + my1DExtActor->SetVisibility(false); + my1DExtActor->SetProperty(my1DExtProp); + my1DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe); + aFilter = my1DExtActor->GetExtractUnstructuredGrid(); + aFilter->SetModeOfChanging(SALOME_ExtractUnstructuredGrid::eAdding); + aFilter->RegisterCellsWithType(VTK_LINE); + + + //Definition 0D divice of the actor + //--------------------------------- + myNodeProp = vtkProperty::New(); + anRGB[0] = GetFloat("SMESH:SettingsNodeColorRed",255)/255.; + anRGB[1] = GetFloat("SMESH:SettingsNodeColorGreen",0)/255.; + anRGB[2] = GetFloat("SMESH:SettingsNodeColorBlue",0)/255.; + myNodeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); + myNodeProp->SetPointSize(aPointSize); + + myNodeActor = SMESH_DeviceActor::New(); + myNodeActor->SetUserMatrix(aMatrix); + myNodeActor->SetStoreMapping(true); + myNodeActor->PickableOff(); + myNodeActor->SetVisibility(false); + myNodeActor->SetProperty(myNodeProp); + myNodeActor->SetRepresentation(SMESH_DeviceActor::ePoint); + aFilter = myNodeActor->GetExtractUnstructuredGrid(); + aFilter->SetModeOfExtraction(SALOME_ExtractUnstructuredGrid::ePoints); + + + //Definition of Pickable and Highlitable engines + //---------------------------------------------- + + myBaseActor = SMESH_DeviceActor::New(); + myBaseActor->SetUserMatrix(aMatrix); + myBaseActor->SetStoreMapping(true); + myBaseActor->GetProperty()->SetOpacity(0.0); + + myPickableActor = myBaseActor; + + myHighlightProp = vtkProperty::New(); + myHighlightProp->SetAmbient(1.0); + myHighlightProp->SetDiffuse(0.0); + myHighlightProp->SetSpecular(0.0); + anRGB[0] = GetFloat("SMESH:SettingsSelectColorRed", 255)/255.; // 1; + anRGB[1] = GetFloat("SMESH:SettingsSelectColorGreen", 255)/255.; // 1; + anRGB[2] = GetFloat("SMESH:SettingsSelectColorBlue", 255)/255.; // 1; + myHighlightProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); + myHighlightProp->SetPointSize(aPointSize); + myHighlightProp->SetRepresentation(1); + + myPreselectProp = vtkProperty::New(); + myPreselectProp->SetAmbient(1.0); + myPreselectProp->SetDiffuse(0.0); + myPreselectProp->SetSpecular(0.0); + anRGB[0] = GetFloat("SMESH:SettingsPreSelectColorRed", 0)/255.; // 0; + anRGB[1] = GetFloat("SMESH:SettingsPreSelectColorGreen", 255)/255.; // 1; + anRGB[2] = GetFloat("SMESH:SettingsPreSelectColorBlue", 255)/255.; // 1; + myPreselectProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); + myPreselectProp->SetPointSize(aPointSize); + myPreselectProp->SetRepresentation(1); + + myHighlitableActor = SMESH_DeviceActor::New(); + myHighlitableActor->SetUserMatrix(aMatrix); + myHighlitableActor->SetStoreMapping(false); + myHighlitableActor->PickableOff(); + myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe); + + + SetShrinkFactor(GetFloat("SMESH:SettingsShrinkCoeff", 75)/100.); - myIO = NULL; myName = ""; + myIO = NULL; myDisplayMode = 0; ishighlighted = false; ispreselected = false; - edgeColor.r = 0.; - edgeColor.g = 0.; - edgeColor.b = 0.; - - edgeHighlightColor.r = 1.; - edgeHighlightColor.g = 1.; - edgeHighlightColor.b = 1.; + myColorMode = eNone; + my1DColorMode = e1DNone; + myControlActor = my2DActor; - edgePreselectedColor.r = 0.; - edgePreselectedColor.g = 1.; - edgePreselectedColor.b = 1.; + //Definition of myScalarBarActor + //------------------------------ + myLookupTable = vtkLookupTable::New(); + //Fix for Bug PAL5195 - SMESH764: + //Controls - Aspect Ratio: incorrect colors of the best and worst values + myLookupTable->SetHueRange(0.667,0.0); - actorColor.r = 1.; - actorColor.g = 1.; - actorColor.b = 0.; + myScalarBarActor = vtkScalarBarActor::New(); + myScalarBarActor->SetVisibility(false); + myScalarBarActor->SetLookupTable(myLookupTable); - actorHighlightColor.r = 1.; - actorHighlightColor.g = 1.; - actorHighlightColor.b = 1.; + vtkTextProperty* aScalarBarTitleProp = vtkTextProperty::New(); - actorPreselectedColor.r = 0.; - actorPreselectedColor.g = 1.; - actorPreselectedColor.b = 1.; + if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarTitleColor" ) ) { + QStringList aTColor = QStringList::split( ":", QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleColor" ), false ); + aScalarBarTitleProp->SetColor( ( aTColor.count() > 0 ? aTColor[0].toInt()/255. : 1.0 ), + ( aTColor.count() > 1 ? aTColor[1].toInt()/255. : 1.0 ), + ( aTColor.count() > 2 ? aTColor[2].toInt()/255. : 1.0 ) ); + } + else + aScalarBarTitleProp->SetColor( 1.0, 1.0, 1.0 ); + + aScalarBarTitleProp->SetFontFamilyToArial(); + if( QAD_CONFIG->hasSetting( "SMESH:ScalarBarTitleFont" ) ){ + if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleFont" ) == "Arial" ) + aScalarBarTitleProp->SetFontFamilyToArial(); + else if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleFont" ) == "Courier" ) + aScalarBarTitleProp->SetFontFamilyToCourier(); + else if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleFont" ) == "Times" ) + aScalarBarTitleProp->SetFontFamilyToTimes(); + } - actorNodeColor.r = 1.; - actorNodeColor.g = 1.; - actorNodeColor.b = 0.; + if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleBold" ) == "true" ) + aScalarBarTitleProp->BoldOn(); + else + aScalarBarTitleProp->BoldOff(); - actorNodeSize = 2 ; - -} + if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleItalic" ) == "true" ) + aScalarBarTitleProp->ItalicOn(); + else + aScalarBarTitleProp->ItalicOff(); -SMESH_Actor::~SMESH_Actor() -{ - this->EdgeDevice->Delete(); - this->EdgeShrinkDevice->Delete(); -} + if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarTitleShadow" ) == "true" ) + aScalarBarTitleProp->ShadowOn(); + else + aScalarBarTitleProp->ShadowOff(); -void SMESH_Actor::setReader(vtkUnstructuredGridReader* r) { - myReader=r; -} + myScalarBarActor->SetTitleTextProperty( aScalarBarTitleProp ); + aScalarBarTitleProp->Delete(); -vtkUnstructuredGridReader* SMESH_Actor::getReader() { - return (myReader); + vtkTextProperty* aScalarBarLabelProp = vtkTextProperty::New(); + + if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarLabelColor" ) ) { + QStringList aTColor = QStringList::split( ":", QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelColor" ), false ); + aScalarBarLabelProp->SetColor( ( aTColor.count() > 0 ? aTColor[0].toInt()/255. : 1.0 ), + ( aTColor.count() > 1 ? aTColor[1].toInt()/255. : 1.0 ), + ( aTColor.count() > 2 ? aTColor[2].toInt()/255. : 1.0 ) ); + } + else + aScalarBarLabelProp->SetColor( 1.0, 1.0, 1.0 ); + + aScalarBarLabelProp->SetFontFamilyToArial(); + if( QAD_CONFIG->hasSetting( "SMESH:ScalarBarLabelFont" ) ){ + if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelFont" ) == "Arial" ) + aScalarBarLabelProp->SetFontFamilyToArial(); + else if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelFont" ) == "Courier" ) + aScalarBarLabelProp->SetFontFamilyToCourier(); + else if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelFont" ) == "Times" ) + aScalarBarLabelProp->SetFontFamilyToTimes(); + } + + if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelBold" ) == "true" ) + aScalarBarLabelProp->BoldOn(); + else + aScalarBarLabelProp->BoldOff(); + + if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelItalic" ) == "true" ) + aScalarBarLabelProp->ItalicOn(); + else + aScalarBarLabelProp->ItalicOff(); + + if ( QAD_CONFIG->getSetting( "SMESH:ScalarBarLabelShadow" ) == "true" ) + aScalarBarLabelProp->ShadowOn(); + else + aScalarBarLabelProp->ShadowOff(); + + myScalarBarActor->SetLabelTextProperty( aScalarBarLabelProp ); + aScalarBarLabelProp->Delete(); + + if ( QAD_CONFIG->getSetting("SMESH:ScalarBarOrientation") == "Horizontal" ) + myScalarBarActor->SetOrientationToHorizontal(); + else + myScalarBarActor->SetOrientationToVertical(); + + float aXVal = QAD_CONFIG->getSetting("SMESH:ScalarBarOrientation") == "Horizontal" ? 0.20 : 0.01; + if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarXPosition" ) ) + aXVal = QAD_CONFIG->getSetting( "SMESH:ScalarBarXPosition" ).toFloat(); + float aYVal = QAD_CONFIG->getSetting("SMESH:ScalarBarOrientation") == "Horizontal" ? 0.01 : 0.1; + if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarYPosition" ) ) + aYVal = QAD_CONFIG->getSetting( "SMESH:ScalarBarYPosition" ).toFloat(); + myScalarBarActor->SetPosition( aXVal, aYVal ); + + float aWVal = QAD_CONFIG->getSetting("SMESH:ScalarBarOrientation") == "Horizontal" ? 0.60 : 0.10; + if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarWidth" ) ) + aWVal = QAD_CONFIG->getSetting( "SMESH:ScalarBarWidth" ).toFloat(); + myScalarBarActor->SetWidth( aWVal ); + + float aHVal = QAD_CONFIG->getSetting("SMESH:ScalarBarOrientation") == "Horizontal" ? 0.12 : 0.80; + if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarHeight" ) ) + aHVal = QAD_CONFIG->getSetting( "SMESH:ScalarBarHeight" ).toFloat(); + myScalarBarActor->SetHeight( aHVal ); + + int anIntVal = 5; + if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarNbOfLabels" ) ) + anIntVal = QAD_CONFIG->getSetting("SMESH:ScalarBarNbOfLabels").toInt(); + myScalarBarActor->SetNumberOfLabels(anIntVal == 0? 5: anIntVal); + + anIntVal = 64; + if ( QAD_CONFIG->hasSetting( "SMESH:ScalarBarNbOfColors" ) ) + anIntVal = QAD_CONFIG->getSetting("SMESH:ScalarBarNbOfColors").toInt(); + myScalarBarActor->SetMaximumNumberOfColors(anIntVal == 0? 64: anIntVal); + + + //Definition of points numbering pipeline + //--------------------------------------- + myPointsNumDataSet = vtkUnstructuredGrid::New(); + + myPtsMaskPoints = vtkMaskPoints::New(); + myPtsMaskPoints->SetInput(myPointsNumDataSet); + myPtsMaskPoints->SetOnRatio(1); + + myPtsSelectVisiblePoints = vtkSelectVisiblePoints::New(); + myPtsSelectVisiblePoints->SetInput(myPtsMaskPoints->GetOutput()); + myPtsSelectVisiblePoints->SelectInvisibleOff(); + myPtsSelectVisiblePoints->SetTolerance(0.1); + + myPtsLabeledDataMapper = vtkLabeledDataMapper::New(); + myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput()); + myPtsLabeledDataMapper->SetLabelFormat("%g"); + myPtsLabeledDataMapper->SetLabelModeToLabelScalars(); + + vtkTextProperty* aPtsTextProp = vtkTextProperty::New(); + aPtsTextProp->SetFontFamilyToTimes(); + static int aPointsFontSize = 10; + aPtsTextProp->SetFontSize(aPointsFontSize); + aPtsTextProp->SetBold(1); + aPtsTextProp->SetItalic(0); + aPtsTextProp->SetShadow(0); + myPtsLabeledDataMapper->SetLabelTextProperty(aPtsTextProp); + aPtsTextProp->Delete(); + + myIsPointsLabeled = false; + + myPointLabels = vtkActor2D::New(); + myPointLabels->SetMapper(myPtsLabeledDataMapper); + myPointLabels->GetProperty()->SetColor(1,1,1); + myPointLabels->SetVisibility(myIsPointsLabeled); + + + //Definition of cells numbering pipeline + //--------------------------------------- + myCellsNumDataSet = vtkUnstructuredGrid::New(); + + myCellCenters = vtkCellCenters::New(); + myCellCenters->SetInput(myCellsNumDataSet); + + myClsMaskPoints = vtkMaskPoints::New(); + myClsMaskPoints->SetInput(myCellCenters->GetOutput()); + myClsMaskPoints->SetOnRatio(1); + + myClsSelectVisiblePoints = vtkSelectVisiblePoints::New(); + myClsSelectVisiblePoints->SetInput(myClsMaskPoints->GetOutput()); + myClsSelectVisiblePoints->SelectInvisibleOff(); + myClsSelectVisiblePoints->SetTolerance(0.1); + + myClsLabeledDataMapper = vtkLabeledDataMapper::New(); + myClsLabeledDataMapper->SetInput(myClsSelectVisiblePoints->GetOutput()); + myClsLabeledDataMapper->SetLabelFormat("%g"); + myClsLabeledDataMapper->SetLabelModeToLabelScalars(); + + vtkTextProperty* aClsTextProp = vtkTextProperty::New(); + aClsTextProp->SetFontFamilyToTimes(); + static int aCellsFontSize = 12; + aClsTextProp->SetFontSize(aCellsFontSize); + aClsTextProp->SetBold(1); + aClsTextProp->SetItalic(0); + aClsTextProp->SetShadow(0); + myClsLabeledDataMapper->SetLabelTextProperty(aClsTextProp); + aClsTextProp->Delete(); + + myIsCellsLabeled = false; + + myCellsLabels = vtkActor2D::New(); + myCellsLabels->SetMapper(myClsLabeledDataMapper); + myCellsLabels->GetProperty()->SetColor(0,1,0); + myCellsLabels->SetVisibility(myIsCellsLabeled); } -vtkMapper* SMESH_Actor::getMapper() { - return (this->Mapper); + +SMESH_Actor::~SMESH_Actor(){ + if(MYDEBUG) MESSAGE("~SMESH_Actor"); + + myScalarBarActor->Delete(); + myLookupTable->Delete(); + + mySurfaceProp->Delete(); + myBackSurfaceProp->Delete(); + + myEdgeProp->Delete(); + myHighlightProp->Delete(); + myPreselectProp->Delete(); + + myNodeProp->Delete(); + + my1DProp->Delete(); + my1DActor->Delete(); + + my1DExtProp->Delete(); + my1DExtActor->Delete(); + + my2DActor->Delete(); + my3DActor->Delete(); + + myNodeActor->Delete(); + myBaseActor->Delete(); + myHighlitableActor->Delete(); + + + //Deleting of pints numbering pipeline + //--------------------------------------- + myPointsNumDataSet->Delete(); + + myPtsLabeledDataMapper->RemoveAllInputs(); + myPtsLabeledDataMapper->Delete(); + + myPtsSelectVisiblePoints->UnRegisterAllOutputs(); + myPtsSelectVisiblePoints->Delete(); + + myPtsMaskPoints->UnRegisterAllOutputs(); + myPtsMaskPoints->Delete(); + + myPointLabels->Delete(); + + + //Deleting of cells numbering pipeline + //--------------------------------------- + myCellsNumDataSet->Delete(); + + myClsLabeledDataMapper->RemoveAllInputs(); + myClsLabeledDataMapper->Delete(); + + myClsSelectVisiblePoints->UnRegisterAllOutputs(); + myClsSelectVisiblePoints->Delete(); + + myClsMaskPoints->UnRegisterAllOutputs(); + myClsMaskPoints->Delete(); + + myCellCenters->UnRegisterAllOutputs(); + myCellCenters->Delete(); + + myCellsLabels->Delete(); } -void SMESH_Actor::ShallowCopy(vtkProp *prop) + +void SMESH_Actor::SetPointsLabeled( bool theIsPointsLabeled ) { - SMESH_Actor *f = SMESH_Actor::SafeDownCast(prop); - if ( f != NULL ) + myIsPointsLabeled = theIsPointsLabeled; + + if ( myIsPointsLabeled ) + { + myPointsNumDataSet->ShallowCopy( GetUnstructuredGrid() ); + vtkDataSet *aDataSet = myPointsNumDataSet; + + int aNbElem = aDataSet->GetNumberOfPoints(); + + vtkIntArray *anArray = vtkIntArray::New(); + anArray->SetNumberOfValues( aNbElem ); + + for ( int anId = 0; anId < aNbElem; anId++ ) { - this->setName( f->getName() ); - if ( f->hasIO() ) - this->setIO( f->getIO() ); - this->setDisplayMode( f->getDisplayMode() ); - - // Copy devices - vtkActor* tempDev = vtkActor::New(); - tempDev->ShallowCopy(f->Device); - vtkProperty* prp = vtkProperty::New(); - prp->DeepCopy(f->Device->GetProperty()); - tempDev->SetProperty(prp); - prp = vtkProperty::New(); - prp->DeepCopy(f->Device->GetBackfaceProperty()); - tempDev->SetBackfaceProperty(prp); - this->Device = tempDev; - - tempDev = vtkActor::New(); - tempDev->ShallowCopy(f->EdgeDevice); - prp = vtkProperty::New(); - prp->DeepCopy(f->EdgeDevice->GetProperty()); - tempDev->SetProperty(prp); - prp = vtkProperty::New(); - prp->DeepCopy(f->EdgeDevice->GetBackfaceProperty()); - tempDev->SetBackfaceProperty(prp); - this->EdgeDevice = tempDev; - - tempDev = vtkActor::New(); - tempDev->ShallowCopy(f->EdgeShrinkDevice); - prp = vtkProperty::New(); - prp->DeepCopy(f->EdgeShrinkDevice->GetProperty()); - tempDev->SetProperty(prp); - prp = vtkProperty::New(); - prp->DeepCopy(f->EdgeShrinkDevice->GetBackfaceProperty()); - tempDev->SetBackfaceProperty(prp); - this->EdgeShrinkDevice = tempDev; - - // Copy data source - this->DataSource = f->DataSource; - - this->myReader = f->myReader; + int aSMDSId = myVisualObj->GetNodeObjId( anId ); + anArray->SetValue( anId, aSMDSId ); } - - // Now do superclass - this->SALOME_Actor::ShallowCopy(prop); - - // Here we need to modify default ShallowCopy() results - // Create copies of properties - if ( f != NULL ) { - vtkProperty* prp = vtkProperty::New(); - prp->DeepCopy(f->GetProperty()); - this->SetProperty(prp); - - prp = vtkProperty::New(); - prp->DeepCopy(f->GetBackfaceProperty()); - this->SetBackfaceProperty(prp); - - // Copy the mapper - vtkDataSetMapper* mpr = vtkDataSetMapper::New(); - mpr->ShallowCopy(f->GetMapper()); - mpr->SetInput(f->DataSource); - this->SetMapper(mpr); + + aDataSet->GetPointData()->SetScalars( anArray ); + anArray->Delete(); + myPtsMaskPoints->SetInput( aDataSet ); + myPointLabels->SetVisibility( GetVisibility() ); } + else + { + myPointLabels->SetVisibility( false ); + } + + SetRepresentation( GetRepresentation() ); } -void SMESH_Actor::Render(vtkRenderer *ren, vtkMapper *Mapper ) -{ - if (this->Mapper == NULL) { - MESSAGE ("No mapper for actor.") - return; - } - if ( myDisplayMode == 1 ) { - EdgeDevice->VisibilityOn(); - EdgeShrinkDevice->VisibilityOff(); - } else if ( myDisplayMode == 2 ) { - EdgeShrinkDevice->VisibilityOn(); - EdgeDevice->VisibilityOff(); - } else { - EdgeShrinkDevice->VisibilityOff(); - EdgeDevice->VisibilityOff(); - } - - - vtkMapper *bestMapper; - bestMapper = this->Mapper; - - /* render the property */ - if (!this->Property) { - // force creation of a property - this->GetProperty(); - } - - if ( ishighlighted ) { - if ( myDisplayMode == 1 ) { - EdgeDevice->GetProperty()->SetColor(edgeHighlightColor.r,edgeHighlightColor.g,edgeHighlightColor.b); - this->GetProperty()->SetColor(actorColor.r,actorColor.g,actorColor.b); - } else if ( myDisplayMode == 2 ) { - EdgeShrinkDevice->GetProperty()->SetColor(edgeHighlightColor.r,edgeHighlightColor.g,edgeHighlightColor.b); - } else { - this->GetProperty()->SetColor(actorHighlightColor.r,actorHighlightColor.g,actorHighlightColor.b); - } - } else if (! ispreselected ) { - if ( myDisplayMode == 1 ) { - EdgeDevice->GetProperty()->SetColor(edgeColor.r,edgeColor.g,edgeColor.b); - this->GetProperty()->SetColor(actorColor.r,actorColor.g,actorColor.b); +void SMESH_Actor::SetCellsLabeled(bool theIsCellsLabeled){ + myIsCellsLabeled = theIsCellsLabeled; + if(myIsCellsLabeled){ + myCellsNumDataSet->ShallowCopy(GetUnstructuredGrid()); + vtkDataSet *aDataSet = myCellsNumDataSet; + int aNbElem = aDataSet->GetNumberOfCells(); + vtkIntArray *anArray = vtkIntArray::New(); + anArray->SetNumberOfValues(aNbElem); + for(int anId = 0; anId < aNbElem; anId++){ + int aSMDSId = myVisualObj->GetElemObjId(anId); + anArray->SetValue(anId,aSMDSId); } - else if ( myDisplayMode == 2 ) - EdgeShrinkDevice->GetProperty()->SetColor(edgeColor.r,edgeColor.g,edgeColor.b); - else - this->GetProperty()->SetColor(actorColor.r,actorColor.g,actorColor.b); - } - else { - if ( myDisplayMode == 1 ) - EdgeDevice->GetProperty()->SetColor(edgePreselectedColor.r,edgePreselectedColor.g,edgePreselectedColor.b); - else if ( myDisplayMode == 2 ) - EdgeShrinkDevice->GetProperty()->SetColor(edgePreselectedColor.r,edgePreselectedColor.g,edgePreselectedColor.b); - else - this->GetProperty()->SetColor(actorPreselectedColor.r,actorPreselectedColor.g,actorPreselectedColor.b); + aDataSet->GetCellData()->SetScalars(anArray); + myCellCenters->SetInput(aDataSet); + myCellsLabels->SetVisibility(GetVisibility()); + }else{ + myCellsLabels->SetVisibility(false); } +} - this->Property->Render(this, ren); - if (this->BackfaceProperty) { - this->BackfaceProperty->BackfaceRender(this, ren); - this->Device->SetBackfaceProperty(this->BackfaceProperty); - } - this->Device->SetProperty(this->Property); - - /* render the texture */ - if (this->Texture) { - this->Texture->Render(ren); + +void SMESH_Actor::SetControlMode(eControl theMode){ + myColorMode = eNone; + my1DColorMode = e1DNone; + + my1DActor->GetMapper()->SetScalarVisibility(false); + my2DActor->GetMapper()->SetScalarVisibility(false); + my3DActor->GetMapper()->SetScalarVisibility(false); + myScalarBarActor->SetVisibility(false); + + bool anIsScalarVisible = theMode > eNone; + + if(anIsScalarVisible){ + SMESH::NumericalFunctor_var aFunctor; + SMESH::Predicate_var aPredicate; + + switch(theMode){ + case eLengthEdges: + aFunctor = myFilterMgr->CreateLength(); + myControlActor = my1DActor; + break; + case eFreeBorders: + aPredicate = myFilterMgr->CreateFreeBorders(); + myControlActor = my1DActor; + break; + case eMultiConnection: + aFunctor = myFilterMgr->CreateMultiConnection(); + myControlActor = my1DActor; + break; + case eArea: + aFunctor = myFilterMgr->CreateArea(); + myControlActor = my2DActor; + break; + case eTaper: + aFunctor = myFilterMgr->CreateTaper(); + myControlActor = my2DActor; + break; + case eAspectRatio: + aFunctor = myFilterMgr->CreateAspectRatio(); + myControlActor = my2DActor; + break; + case eMinimumAngle: + aFunctor = myFilterMgr->CreateMinimumAngle(); + myControlActor = my2DActor; + break; + case eWarping: + aFunctor = myFilterMgr->CreateWarping(); + myControlActor = my2DActor; + break; + case eSkew: + aFunctor = myFilterMgr->CreateSkew(); + myControlActor = my2DActor; + break; + default: + return; + } + + vtkUnstructuredGrid* aGrid = myControlActor->GetUnstructuredGrid(); + vtkIdType aNbCells = aGrid->GetNumberOfCells(); + if(aNbCells){ + if(theMode == eFreeBorders){ + if(!aPredicate->_is_nil()){ + myVisualObj->UpdateFunctor(aPredicate); + SALOME_ExtractUnstructuredGrid* aFilter = + my1DExtActor->GetExtractUnstructuredGrid(); + aFilter->SetModeOfChanging(SALOME_ExtractUnstructuredGrid::eAdding); + aFilter->ClearRegisteredCells(); + for( vtkIdType i = 0; i < aNbCells; i++ ){ + vtkIdType anObjId = myControlActor->GetElemObjId( i ); + CORBA::Boolean aValue = aPredicate->IsSatisfy(anObjId); + if(aValue) + aFilter->RegisterCell(i); + } + if(!aFilter->IsCellsRegistered()) + aFilter->RegisterCell(-1); + aPredicate->Destroy(); + } + myColorMode = theMode; + my1DColorMode = e1DHighlited; + }else{ + myColorMode = theMode; + if(myControlActor == my1DActor) + my1DColorMode = e1DColored; + + vtkUnstructuredGrid* aDataSet = vtkUnstructuredGrid::New(); + aDataSet->ShallowCopy(aGrid); + myScalarBarActor->SetVisibility(true); + myControlActor->GetMapper()->SetScalarVisibility(true); + + vtkDoubleArray *aScalars = vtkDoubleArray::New(); + aScalars->SetNumberOfComponents( 1 ); + aScalars->SetNumberOfTuples(aNbCells); + + if(!aFunctor->_is_nil()){ + myVisualObj->UpdateFunctor(aFunctor); + for( vtkIdType i = 0; i < aNbCells; i++ ){ + vtkIdType anObjId = myControlActor->GetElemObjId( i ); + CORBA::Double aValue = aFunctor->GetValue(anObjId); + aScalars->SetValue( i, aValue ); + } + aFunctor->Destroy(); + }else if(!aPredicate->_is_nil()){ + myVisualObj->UpdateFunctor(aPredicate); + for( vtkIdType i = 0; i < aNbCells; i++ ){ + vtkIdType anObjId = myControlActor->GetElemObjId( i ); + CORBA::Boolean aValue = aPredicate->IsSatisfy(anObjId); + aScalars->SetValue( i, aValue ); + } + aPredicate->Destroy(); + } + aDataSet->GetCellData()->SetScalars(aScalars); + aScalars->Delete(); + + float aRange[2]; + aScalars->GetRange(aRange); + myLookupTable->SetRange(aRange); + myLookupTable->Build(); + + myControlActor->GetMergeFilter()->SetScalars(aDataSet); + aDataSet->Delete(); + if(MYDEBUGWITHFILES) + WriteUnstructuredGrid(aDataSet,"/tmp/SetControlMode.vtk"); + } + } } + SetRepresentation(GetRepresentation()); - - // Store information on time it takes to render. - // We might want to estimate time from the number of polygons in mapper. - this->Device->Render(ren,bestMapper); - this->EstimatedRenderTime = bestMapper->GetTimeToDraw(); + Modified(); } -int SMESH_Actor::RenderOpaqueGeometry(vtkViewport *vp) + +void SMESH_Actor::AddToRender(vtkRenderer* theRenderer){ + SALOME_Actor::AddToRender(theRenderer); + + theRenderer->AddActor(myNodeActor); + theRenderer->AddActor(myBaseActor); + + theRenderer->AddActor(my3DActor); + theRenderer->AddActor(my2DActor); + + theRenderer->AddActor(my1DActor); + theRenderer->AddActor(my1DExtActor); + + theRenderer->AddActor(myHighlitableActor); + + theRenderer->AddActor2D(myScalarBarActor); + + myPtsSelectVisiblePoints->SetRenderer(theRenderer); + myClsSelectVisiblePoints->SetRenderer(theRenderer); + + theRenderer->AddActor2D(myPointLabels); + theRenderer->AddActor2D(myCellsLabels); +} + +void SMESH_Actor::RemoveFromRender(vtkRenderer* theRenderer){ + SALOME_Actor::RemoveFromRender(theRenderer); + + theRenderer->RemoveActor(myNodeActor); + theRenderer->RemoveActor(myBaseActor); + theRenderer->RemoveActor(myHighlitableActor); + + theRenderer->RemoveActor(my1DActor); + theRenderer->RemoveActor(my1DExtActor); + + theRenderer->RemoveActor(my2DActor); + theRenderer->RemoveActor(my3DActor); + + theRenderer->RemoveActor(myScalarBarActor); + theRenderer->RemoveActor(myPointLabels); + theRenderer->RemoveActor(myCellsLabels); +} + + +void SMESH_Actor::Init(TVisualObjPtr theVisualObj, + SMESH::FilterManager_ptr theFilterMgr, + const char* theEntry, + const char* theName, + int theIsClear) { - int renderedSomething = 0; - vtkRenderer *ren = (vtkRenderer *)vp; - - if ( ! this->Mapper ) { - return 0; - } - - // make sure we have a property - if (!this->Property) { - // force creation of a property - this->GetProperty(); - } + Handle(SALOME_InteractiveObject) anIO = + new SALOME_InteractiveObject(strdup(theEntry),strdup("MESH"),strdup(theName)); + setIO(anIO); + setName(strdup(theName)); + + myVisualObj = theVisualObj; + myNodeActor->myVisualObj = myVisualObj; + myBaseActor->myVisualObj = myVisualObj; + myHighlitableActor->myVisualObj = myVisualObj; + + my1DActor->myVisualObj = myVisualObj; + my1DExtActor->myVisualObj = myVisualObj; + + my2DActor->myVisualObj = myVisualObj; + my3DActor->myVisualObj = myVisualObj; + + myVisualObj->Update(theIsClear); + SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid()); - if ( ishighlighted ) { - if ( myDisplayMode == 1 ) { - EdgeDevice->GetProperty()->SetColor(edgeHighlightColor.r,edgeHighlightColor.g,edgeHighlightColor.b); - } else if ( myDisplayMode == 2 ) { - EdgeShrinkDevice->GetProperty()->SetColor(edgeHighlightColor.r,edgeHighlightColor.g,edgeHighlightColor.b); - } else { - this->GetProperty()->SetColor(actorHighlightColor.r,actorHighlightColor.g,actorHighlightColor.b); - } - } else if (! ispreselected ) { - if ( myDisplayMode == 1 ) - EdgeDevice->GetProperty()->SetColor(edgeColor.r,edgeColor.g,edgeColor.b); - else if ( myDisplayMode == 2 ) - EdgeShrinkDevice->GetProperty()->SetColor(edgeColor.r,edgeColor.g,edgeColor.b); - else - this->GetProperty()->SetColor(actorColor.r,actorColor.g,actorColor.b); + myFilterMgr = SMESH::FilterManager::_duplicate(theFilterMgr); + + QString aMode = QAD_CONFIG->getSetting("SMESH:DisplayMode"); + SetRepresentation(-1); + if(aMode.compare("Wireframe") == 0){ + SetRepresentation(eEdge); + }else if(aMode.compare("Shading") == 0){ + SetRepresentation(eSurface); + }else if(aMode.compare("Nodes") == 0){ + SetRepresentation(ePoint); } - else { - if ( myDisplayMode == 1 ) - EdgeDevice->GetProperty()->SetColor(edgePreselectedColor.r,edgePreselectedColor.g,edgePreselectedColor.b); - else if ( myDisplayMode == 2 ) - EdgeShrinkDevice->GetProperty()->SetColor(edgePreselectedColor.r,edgePreselectedColor.g,edgePreselectedColor.b); - else - this->GetProperty()->SetColor(actorPreselectedColor.r,actorPreselectedColor.g,actorPreselectedColor.b); + + aMode = QAD_CONFIG->getSetting("SMESH:Shrink"); + if(aMode == "yes"){ + SetShrink(); } - // is this actor opaque ? - if (this->GetIsOpaque()) { - this->Property->Render(this, ren); - - // render the backface property - if (this->BackfaceProperty) { - this->BackfaceProperty->BackfaceRender(this, ren); - } - - // render the texture - if (this->Texture) { - this->Texture->Render(ren); - } - this->Render(ren,this->Mapper); + Modified(); +} + + +vtkPolyData* SMESH_Actor::GetPolyDataInput(){ + return myPickableActor->GetPolyDataInput(); +} + + +void SMESH_Actor::SetTransform(SALOME_Transform* theTransform){ + myNodeActor->SetTransform(theTransform); + myBaseActor->SetTransform(theTransform); + myHighlitableActor->SetTransform(theTransform); + + my1DActor->SetTransform(theTransform); + my1DExtActor->SetTransform(theTransform); + + my2DActor->SetTransform(theTransform); + my3DActor->SetTransform(theTransform); + + Modified(); +} + + +void SMESH_Actor::SetUnstructuredGrid(vtkUnstructuredGrid* theGrid){ + if(theGrid){ + myNodeActor->SetUnstructuredGrid(theGrid); + myBaseActor->SetUnstructuredGrid(theGrid); + myHighlitableActor->SetUnstructuredGrid(theGrid); + + my1DActor->SetUnstructuredGrid(theGrid); + my1DExtActor->SetUnstructuredGrid(theGrid); + + my2DActor->SetUnstructuredGrid(theGrid); + my3DActor->SetUnstructuredGrid(theGrid); + + my1DActor->GetMapper()->SetLookupTable(myLookupTable); + my2DActor->GetMapper()->SetLookupTable(myLookupTable); + my3DActor->GetMapper()->SetLookupTable(myLookupTable); - renderedSomething = 1; + float aFactor, aUnits; + my2DActor->GetPolygonOffsetParameters(aFactor,aUnits); + my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75); + + //SetIsShrunkable(theGrid->GetNumberOfCells() > 10); + SetIsShrunkable(true); + + Modified(); } - - return renderedSomething; } -void SMESH_Actor::SetColor(float r,float g,float b) -{ - actorColor.r = r; - actorColor.g = g; - actorColor.b = b; +void SMESH_Actor::SetMapper(vtkMapper* theMapper){ + vtkLODActor::SetMapper(theMapper); } -void SMESH_Actor::GetColor(float& r,float& g,float& b) -{ - r = actorColor.r; - g = actorColor.g; - b = actorColor.b; + +void SMESH_Actor::ShallowCopy(vtkProp *prop){ + SALOME_Actor::ShallowCopy(prop); } -void SMESH_Actor::SetPreselectedColor(float r,float g,float b) -{ - actorPreselectedColor.r = r; - actorPreselectedColor.g = g; - actorPreselectedColor.b = b; + +vtkMapper* SMESH_Actor::GetMapper(){ + return myPickableActor->GetMapper(); } -void SMESH_Actor::GetPreselectedColor(float& r,float& g,float& b) -{ - r = actorPreselectedColor.r; - g = actorPreselectedColor.g; - b = actorPreselectedColor.b; + +vtkUnstructuredGrid* SMESH_Actor::GetUnstructuredGrid(){ + return myVisualObj->GetUnstructuredGrid(); } -void SMESH_Actor::SetHighlightColor(float r,float g,float b) -{ - actorHighlightColor.r = r; - actorHighlightColor.g = g; - actorHighlightColor.b = b; + +bool SMESH_Actor::IsInfinitive(){ + vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid(); + aDataSet->Update(); + myIsInfinite = aDataSet->GetNumberOfCells() == 0; + return SALOME_Actor::IsInfinitive(); } -void SMESH_Actor::GetHighlightColor(float& r,float& g,float& b) -{ - r = actorHighlightColor.r; - g = actorHighlightColor.g; - b = actorHighlightColor.b; + +void SMESH_Actor::SetIsShrunkable(bool theShrunkable){ + myIsShrinkable = theShrunkable; + Modified(); } -void SMESH_Actor::SetEdgeColor(float r,float g,float b) -{ - edgeColor.r = r; - edgeColor.g = g; - edgeColor.b = b; +float SMESH_Actor::GetShrinkFactor(){ + return myBaseActor->GetShrinkFactor(); } -void SMESH_Actor::GetEdgeColor(float& r,float& g,float& b) -{ - r = edgeColor.r; - g = edgeColor.g; - b = edgeColor.b; +void SMESH_Actor::SetShrinkFactor(float theValue){ + myBaseActor->SetShrinkFactor(theValue); + + my1DActor->SetShrinkFactor(theValue); + my1DExtActor->SetShrinkFactor(theValue); + + my2DActor->SetShrinkFactor(theValue); + my3DActor->SetShrinkFactor(theValue); + + Modified(); } -void SMESH_Actor::SetEdgeHighlightColor(float r,float g,float b) -{ - edgeHighlightColor.r = r; - edgeHighlightColor.g = g; - edgeHighlightColor.b = b; +void SMESH_Actor::SetShrink(){ + if(!myIsShrinkable) return; + + myBaseActor->SetShrink(); + + my1DActor->SetShrink(); + my1DExtActor->SetShrink(); + + my2DActor->SetShrink(); + my3DActor->SetShrink(); + + myIsShrunk = true; + Modified(); } -void SMESH_Actor::GetEdgeHighlightColor(float& r,float& g,float& b) -{ - r = edgeHighlightColor.r; - g = edgeHighlightColor.g; - b = edgeHighlightColor.b; +void SMESH_Actor::UnShrink(){ + if(!myIsShrunk) return; + + myBaseActor->UnShrink(); + + my1DActor->UnShrink(); + my1DExtActor->UnShrink(); + + my2DActor->UnShrink(); + my3DActor->UnShrink(); + + myIsShrunk = false; + Modified(); } -void SMESH_Actor::SetEdgePreselectedColor(float r,float g,float b) -{ - edgePreselectedColor.r = r; - edgePreselectedColor.g = g; - edgePreselectedColor.b = b; + +int SMESH_Actor::GetObjId(int theVtkID){ + if (GetRepresentation() == 0){ + return GetNodeObjId(theVtkID); + }else{ + return GetElemObjId(theVtkID); + } } -void SMESH_Actor::GetEdgePreselectedColor(float& r,float& g,float& b) -{ - r = edgePreselectedColor.r; - g = edgePreselectedColor.g; - b = edgePreselectedColor.b; +SALOME_Actor::TVectorId SMESH_Actor::GetVtkId(int theObjID){ + if (GetRepresentation() == 0){ + return GetNodeVtkId(theObjID); + }else{ + return GetElemVtkId(theObjID); + } } -void SMESH_Actor::SetNodeColor(float r,float g,float b) -{ - actorNodeColor.r = r ; - actorNodeColor.g = g ; - actorNodeColor.b = b ; +int SMESH_Actor::GetNodeObjId(int theVtkID){ + return myPickableActor->GetNodeObjId(theVtkID); } -void SMESH_Actor::GetNodeColor(float& r,float& g,float& b) -{ - r = actorNodeColor.r ; - g = actorNodeColor.g ; - b = actorNodeColor.b ; +SALOME_Actor::TVectorId SMESH_Actor::GetNodeVtkId(int theObjID){ + return myPickableActor->GetNodeVtkId(theObjID); } -void SMESH_Actor::SetNodeSize(int size) -{ - actorNodeSize = size ; + +int SMESH_Actor::GetElemObjId(int theVtkID){ + return myPickableActor->GetElemObjId(theVtkID); } -int SMESH_Actor::GetNodeSize() -{ - return actorNodeSize ; +SALOME_Actor::TVectorId SMESH_Actor::GetElemVtkId(int theObjID){ + return myPickableActor->GetElemVtkId(theObjID); } -void SMESH_Actor::AddNode(int idSMESHDSnode,int idVTKnode) -{ - if (DataSource->IsA("SMESH_Grid")) { - ((SMESH_Grid*)DataSource)->AddNode(idSMESHDSnode, idVTKnode); - } else - MESSAGE("AddNode() method has been moved to SMESH_Grid class"); +void SMESH_Actor::SetVisibility(int theMode){ + SALOME_Actor::SetVisibility(theMode); + if(GetVisibility()){ + SetRepresentation(GetRepresentation()); + + if(myColorMode != eNone){ + if(my1DColorMode == e1DHighlited) + my1DExtActor->VisibilityOn(); + else if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells()) + myScalarBarActor->VisibilityOn(); + } + + if(myRepresentation != ePoint) + myPickableActor->VisibilityOn(); + + my1DActor->VisibilityOn(); + + my2DActor->VisibilityOn(); + my3DActor->VisibilityOn(); + + if(myIsPointsLabeled) myPointLabels->VisibilityOn(); + if(myIsCellsLabeled) myCellsLabels->VisibilityOn(); + }else{ + myNodeActor->VisibilityOff(); + myBaseActor->VisibilityOff(); + + my1DActor->VisibilityOff(); + my1DExtActor->VisibilityOff(); + + my2DActor->VisibilityOff(); + my3DActor->VisibilityOff(); + + myScalarBarActor->VisibilityOff(); + myPointLabels->VisibilityOff(); + myCellsLabels->VisibilityOff(); + } + Modified(); } -void SMESH_Actor::AddElement(int idSMESHDSelement, int idVTKelement) -{ - if (DataSource->IsA("SMESH_Grid")) { - ((SMESH_Grid*)DataSource)->AddElement(idSMESHDSelement, idVTKelement); - } else - MESSAGE("AddElement() method has been moved to SMESH_Grid class"); + + +void SMESH_Actor::SetRepresentation(int theMode){ + int aNbEdges = myVisualObj->GetNbEntities(SMESH::EDGE); + int aNbFaces = myVisualObj->GetNbEntities(SMESH::FACE); + int aNbVolumes = myVisualObj->GetNbEntities(SMESH::VOLUME); + if(theMode < 0){ + myRepresentation = eSurface; + if(!aNbFaces && !aNbVolumes && aNbEdges){ + myRepresentation = eEdge; + }else if(!aNbFaces && !aNbVolumes && !aNbEdges){ + myRepresentation = ePoint; + } + }else{ + switch(theMode){ + case eEdge: + if(!aNbFaces && !aNbVolumes && !aNbEdges) return; + break; + case eSurface: + if(!aNbFaces && !aNbVolumes) return; + break; + } + myRepresentation = theMode; + } + + if(!GetUnstructuredGrid()->GetNumberOfCells()) + myRepresentation = ePoint; + + if(myIsShrunk){ + if(myRepresentation == ePoint){ + UnShrink(); + myIsShrunk = true; + }else{ + SetShrink(); + } + } + + myPickableActor = myBaseActor; + myNodeActor->SetVisibility(false); + vtkProperty *aProp = NULL, *aBackProp = NULL; + SMESH_DeviceActor::EReperesent aReperesent = SMESH_DeviceActor::EReperesent(-1); + switch(myRepresentation){ + case ePoint: + myPickableActor = myNodeActor; + aProp = aBackProp = myNodeProp; + aReperesent = SMESH_DeviceActor::ePoint; + break; + case eEdge: + aProp = aBackProp = myEdgeProp; + aReperesent = SMESH_DeviceActor::eInsideframe; + break; + case eSurface: + aProp = mySurfaceProp; + aBackProp = myBackSurfaceProp; + aReperesent = SMESH_DeviceActor::eSurface; + break; + } + + my2DActor->SetProperty(aProp); + my2DActor->SetBackfaceProperty(aBackProp); + my2DActor->SetRepresentation(aReperesent); + + my3DActor->SetProperty(aProp); + my3DActor->SetBackfaceProperty(aBackProp); + my3DActor->SetRepresentation(aReperesent); + + my1DExtActor->SetVisibility(false); + switch(my1DColorMode){ + case e1DColored: + aProp = aBackProp = my1DProp; + if(myRepresentation != ePoint) + aReperesent = SMESH_DeviceActor::eInsideframe; + break; + case e1DHighlited: + my1DExtActor->SetVisibility(true); + break; + } + + my1DActor->SetProperty(aProp); + my1DActor->SetBackfaceProperty(aBackProp); + my1DActor->SetRepresentation(aReperesent); + + if ( GetPointRepresentation() || !GetUnstructuredGrid()->GetNumberOfCells() || myIsPointsLabeled ) + { + myPickableActor = myNodeActor; + myNodeActor->SetVisibility(true); + } + + SetMapper(myPickableActor->GetMapper()); + + Modified(); } -void SMESH_Actor::SetIdsVTKNode(const TColStd_DataMapOfIntegerInteger& mapVTK) -{ - if (DataSource->IsA("SMESH_Grid")) { - ((SMESH_Grid*)DataSource)->SetIdsVTKNode(mapVTK); - } else - MESSAGE("SetIdsVTKNode() method has been moved to SMESH_Grid class"); + +void SMESH_Actor::SetPointRepresentation(int theIsPointsVisible){ + myIsPointsVisible = theIsPointsVisible; + SetRepresentation(GetRepresentation()); } -void SMESH_Actor::SetIdsSMESHDSNode(const TColStd_DataMapOfIntegerInteger& mapSMESHDS) -{ - if (DataSource->IsA("SMESH_Grid")) { - ((SMESH_Grid*)DataSource)->SetIdsSMESHDSNode(mapSMESHDS); - } else - MESSAGE("SetIdsSMESHDSNode() method has been moved to SMESH_Grid class"); + + +void SMESH_Actor::UpdateHighlight(){ + myHighlitableActor->SetVisibility(false); + myNodeActor->SetProperty(myNodeProp); + if(myPickableActor != myNodeActor) + myNodeActor->SetVisibility(false); + + if(ishighlighted){ + myHighlitableActor->SetProperty(myHighlightProp); + }else if(ispreselected){ + myHighlitableActor->SetProperty(myPreselectProp); + } + + if(ishighlighted || ispreselected){ + if(!GetUnstructuredGrid()->GetNumberOfCells()){ + myNodeActor->SetProperty(myHighlitableActor->GetProperty()); + myNodeActor->SetRepresentation(SMESH_DeviceActor::ePoint); + myNodeActor->SetVisibility(GetVisibility()); + }else{ + myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe); + myHighlitableActor->SetVisibility(GetVisibility()); + } + } } -void SMESH_Actor::SetIdsVTKElement(const TColStd_DataMapOfIntegerInteger& mapVTK) -{ - if (DataSource->IsA("SMESH_Grid")) { - ((SMESH_Grid*)DataSource)->SetIdsVTKElement(mapVTK); - } else - MESSAGE("SetIdsVTKElement() method has been moved to SMESH_Grid class"); + +void SMESH_Actor::highlight(Standard_Boolean highlight){ + ishighlighted = highlight; + UpdateHighlight(); } -void SMESH_Actor::SetIdsSMESHDSElement(const TColStd_DataMapOfIntegerInteger& mapSMESHDS) -{ - if (DataSource->IsA("SMESH_Grid")) { - ((SMESH_Grid*)DataSource)->SetIdsSMESHDSElement(mapSMESHDS); - } else - MESSAGE("SetIdsSMESHDSElement() method has been moved to SMESH_Grid class"); + + +void SMESH_Actor::SetPreSelected(Standard_Boolean presel){ + ispreselected = presel; + UpdateHighlight(); } -int SMESH_Actor::GetIdVTKNode(int idSMESHDSnode) + +// From vtkFollower +int SMESH_Actor::RenderOpaqueGeometry(vtkViewport *vp) { - if (DataSource->IsA("SMESH_Grid")) { - return ((SMESH_Grid*)DataSource)->GetIdVTKNode(idSMESHDSnode); - } else { - MESSAGE("GetIdVTKNode() method has been moved to SMESH_Grid class"); - return -1; - } + if (myPickableActor->GetIsOpaque()) + { + vtkRenderer *ren = static_cast(vp); + this->Render(ren); + return 1; + } + return 0; } -int SMESH_Actor::GetIdVTKElement(int idSMESHDSelement) + + +int SMESH_Actor::RenderTranslucentGeometry(vtkViewport *vp) { - if (DataSource->IsA("SMESH_Grid")) { - return ((SMESH_Grid*)DataSource)->GetIdVTKElement(idSMESHDSelement); - } else { - MESSAGE("GetIdVTKElement() method has been moved to SMESH_Grid class"); - return -1; - } + if (!myPickableActor->GetIsOpaque()) + { + vtkRenderer *ren = static_cast(vp); + this->Render(ren); + return 1; + } + return 0; +} + + +void SMESH_Actor::Render(vtkRenderer *ren){} + +void SMESH_Actor::ReleaseGraphicsResources(vtkWindow *renWin){ + SALOME_Actor::ReleaseGraphicsResources(renWin); + + myPickableActor->ReleaseGraphicsResources(renWin); } -int SMESH_Actor::GetIdSMESHDSNode(int idVTKnode) -{ - if (DataSource->IsA("SMESH_Grid")) { - return ((SMESH_Grid*)DataSource)->GetIdSMESHDSNode(idVTKnode); - } else { - MESSAGE("GetIdSMESHDSNode() method has been moved to SMESH_Grid class"); - return -1; - } + +static void GetColor(vtkProperty *theProperty, float& r,float& g,float& b){ + float* aColor = theProperty->GetColor(); + r = aColor[0]; + g = aColor[1]; + b = aColor[2]; } -int SMESH_Actor::GetIdSMESHDSElement(int idVTKelement) -{ - if (DataSource->IsA("SMESH_Grid")) { - return ((SMESH_Grid*)DataSource)->GetIdSMESHDSElement(idVTKelement); - } else { - MESSAGE("AddNode() method has been moved to SMESH_Grid class"); - return -1; - } + +void SMESH_Actor::SetOpacity(float theValue){ + mySurfaceProp->SetOpacity(theValue); + myBackSurfaceProp->SetOpacity(theValue); + myEdgeProp->SetOpacity(theValue); + myNodeProp->SetOpacity(theValue); + + my1DProp->SetOpacity(theValue); } -void SMESH_Actor::ClearNode() -{ - if (DataSource->IsA("SMESH_Grid")) { - ((SMESH_Grid*)DataSource)->ClearNode(); - } else - MESSAGE("ClearNode() method has been moved to SMESH_Grid class"); + +float SMESH_Actor::GetOpacity(){ + return mySurfaceProp->GetOpacity(); } -void SMESH_Actor::ClearElement() -{ - if (DataSource->IsA("SMESH_Grid")) { - ((SMESH_Grid*)DataSource)->ClearElement(); - } else - MESSAGE("ClearElement() method has been moved to SMESH_Grid class"); + +void SMESH_Actor::SetSufaceColor(float r,float g,float b){ + mySurfaceProp->SetColor(r,g,b); + Modified(); } -void SMESH_Actor::RemoveNode(int id) -{ - if (DataSource->IsA("SMESH_Grid")) { - ((SMESH_Grid*)DataSource)->RemoveNode(id); - } else - MESSAGE("RemoveNode() method has been moved to SMESH_Grid class"); +void SMESH_Actor::GetSufaceColor(float& r,float& g,float& b){ + ::GetColor(mySurfaceProp,r,g,b); } -void SMESH_Actor::RemoveElement(int id) -{ - if (DataSource->IsA("SMESH_Grid")) { - ((SMESH_Grid*)DataSource)->RemoveElement(id); - } else - MESSAGE("RemoveElement() method has been moved to SMESH_Grid class"); -} - -void SMESH_Actor::setDisplayMode(int thenewmode) { - myDisplayMode = thenewmode; - if ( myDisplayMode == 1 ) { - EdgeDevice->VisibilityOn(); - EdgeShrinkDevice->VisibilityOff(); - } else if ( myDisplayMode == 2 ) { - EdgeDevice->VisibilityOff(); - EdgeShrinkDevice->VisibilityOn(); - } else { - EdgeDevice->VisibilityOff(); - EdgeShrinkDevice->VisibilityOff(); - } + +void SMESH_Actor::SetBackSufaceColor(float r,float g,float b){ + myBackSurfaceProp->SetColor(r,g,b); + Modified(); } -float SMESH_Actor::GetShrinkFactor() -{ - return myShrinkFactor; +void SMESH_Actor::GetBackSufaceColor(float& r,float& g,float& b){ + ::GetColor(myBackSurfaceProp,r,g,b); } -void SMESH_Actor::SetShrinkFactor(float value ) -{ - if ( value <= 0.1 ) - value = 0.8; +void SMESH_Actor::SetEdgeColor(float r,float g,float b){ + myEdgeProp->SetColor(r,g,b); + my1DProp->SetColor(r,g,b); + my1DExtProp->SetColor(1.0-r,1.0-g,1.0-b); + Modified(); +} - myShrinkFactor = value; +void SMESH_Actor::GetEdgeColor(float& r,float& g,float& b){ + ::GetColor(myEdgeProp,r,g,b); } -void SMESH_Actor::GetChildActors(vtkActorCollection* actors) -{ - actors->AddItem(EdgeDevice); - actors->AddItem(EdgeShrinkDevice); +void SMESH_Actor::SetNodeColor(float r,float g,float b){ + myNodeProp->SetColor(r,g,b); + Modified(); } -void SMESH_Actor::SetVisibility(bool visibility) -{ - if ( visibility ) { - this->VisibilityOn(); - if ( myDisplayMode == 1 ) { - EdgeDevice->VisibilityOn(); - EdgeShrinkDevice->VisibilityOff(); - } else if ( myDisplayMode == 2 ) { - EdgeDevice->VisibilityOff(); - EdgeShrinkDevice->VisibilityOn(); - } else { - EdgeDevice->VisibilityOff(); - EdgeShrinkDevice->VisibilityOff(); - } - } else { - this->VisibilityOff(); - EdgeDevice->VisibilityOff(); - EdgeShrinkDevice->VisibilityOff(); - } +void SMESH_Actor::GetNodeColor(float& r,float& g,float& b){ + ::GetColor(myNodeProp,r,g,b); +} + +void SMESH_Actor::SetHighlightColor(float r,float g,float b){ + myHighlightProp->SetColor(r,g,b); + Modified(); +} + +void SMESH_Actor::GetHighlightColor(float& r,float& g,float& b){ + ::GetColor(myHighlightProp,r,g,b); +} + +void SMESH_Actor::SetPreHighlightColor(float r,float g,float b){ + myPreselectProp->SetColor(r,g,b); + Modified(); } +void SMESH_Actor::GetPreHighlightColor(float& r,float& g,float& b){ + ::GetColor(myPreselectProp,r,g,b); +} + + +float SMESH_Actor::GetLineWidth(){ + return myEdgeProp->GetLineWidth(); +} + + +void SMESH_Actor::SetLineWidth(float theVal){ + myEdgeProp->SetLineWidth(theVal); + Modified(); +} + + +void SMESH_Actor::SetNodeSize(float theSize){ + myNodeProp->SetPointSize(theSize); + myHighlightProp->SetPointSize(theSize); + myPreselectProp->SetPointSize(theSize); + + my1DExtProp->SetPointSize(theSize); + my1DProp->SetPointSize(theSize); + + Modified(); +} + +float SMESH_Actor::GetNodeSize(){ + return myNodeProp->GetPointSize(); +} + +int SMESH_Actor::GetObjDimension( const int theObjId ) +{ + return myVisualObj->GetElemDimension( theObjId ); +}