ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-27 11:00:32 +05:00
Code Issues Packages Projects Releases Wiki Activity

Fix for the bug "21427: EDF 2024 SMESH: numbering does not take into account clipping".

Browse Source
This commit is contained in:
rnv 2011-11-30 14:14:36 +00:00
parent e5dee33572
commit 6b6e2ef015
8 changed files with 641 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/OBJECT/Makefile.am
View File

@ -35,7 +35,9 @@ salomeinclude_HEADERS = \
SMESH_PreviewActorsCollection.h \ SMESH_PreviewActorsCollection.h \
SMESH_ExtractGeometry.h \ SMESH_ExtractGeometry.h \
SMESH_FaceOrientationFilter.h \ SMESH_FaceOrientationFilter.h \
SMESH_ScalarBarActor.h SMESH_ScalarBarActor.h \
SMESH_NodeLabelActor.h \
SMESH_CellLabelActor.h
# Libraries targets # Libraries targets
@ -48,7 +50,9 @@ dist_libSMESHObject_la_SOURCES = \
SMESH_ExtractGeometry.cxx \ SMESH_ExtractGeometry.cxx \
SMESH_ActorUtils.cxx \ SMESH_ActorUtils.cxx \
SMESH_FaceOrientationFilter.cxx \ SMESH_FaceOrientationFilter.cxx \
SMESH_ScalarBarActor.cxx SMESH_ScalarBarActor.cxx \
SMESH_NodeLabelActor.cxx \
SMESH_CellLabelActor.cxx
libSMESHObject_la_CPPFLAGS = \ libSMESHObject_la_CPPFLAGS = \
$(QT_INCLUDES) \ $(QT_INCLUDES) \

311
src/OBJECT/SMESH_Actor.cxx
View File

@ -28,11 +28,12 @@
#include "SMESH_ActorDef.h" #include "SMESH_ActorDef.h"
#include "SMESH_ActorUtils.h" #include "SMESH_ActorUtils.h"
#include "SMESH_DeviceActor.h" #include "SMESH_DeviceActor.h"
#include "SMESH_NodeLabelActor.h"
#include "SMESH_CellLabelActor.h"
#include "SMESH_ObjectDef.h" #include "SMESH_ObjectDef.h"
#include "SMESH_ControlsDef.hxx" #include "SMESH_ControlsDef.hxx"
#include "SMDS_UnstructuredGrid.hxx" #include "SMDS_UnstructuredGrid.hxx"
#include "SMESH_ScalarBarActor.h" #include "SMESH_ScalarBarActor.h"
#include "VTKViewer_CellCenters.h"
#include "VTKViewer_ExtractUnstructuredGrid.h" #include "VTKViewer_ExtractUnstructuredGrid.h"
#include "VTKViewer_FramedTextActor.h" #include "VTKViewer_FramedTextActor.h"
#include "SALOME_InteractiveObject.hxx" #include "SALOME_InteractiveObject.hxx"
@ -67,10 +68,7 @@
#include <vtkActor2D.h> #include <vtkActor2D.h>
#include <vtkProperty2D.h> #include <vtkProperty2D.h>
#include <vtkPolyData.h> #include <vtkPolyData.h>
#include <vtkMaskPoints.h>
#include <vtkTextProperty.h> #include <vtkTextProperty.h>
#include <vtkLabeledDataMapper.h>
#include <vtkSelectVisiblePoints.h>
#include <vtkLookupTable.h> #include <vtkLookupTable.h>
@ -121,7 +119,8 @@ SMESH_Actor* SMESH_Actor::New(TVisualObjPtr theVisualObj,
SMESH_ActorDef::SMESH_ActorDef() SMESH_ActorDef::SMESH_ActorDef()
{ {
if(MYDEBUG) MESSAGE("SMESH_ActorDef - "<<this); if(MYDEBUG) MESSAGE("SMESH_ActorDef - "<<this);
myBaseActor = SMESH_DeviceActor::New();
myTimeStamp = vtkTimeStamp::New(); myTimeStamp = vtkTimeStamp::New();
@ -158,7 +157,8 @@ SMESH_ActorDef::SMESH_ActorDef()
bfc = Qtx::mainColorToSecondary(ffc, delta); bfc = Qtx::mainColorToSecondary(ffc, delta);
myBackSurfaceProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. ); myBackSurfaceProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. );
my2DActor = SMESH_DeviceActor::New(); my2DActor = SMESH_CellLabelActor::New();
my2DActor->SetStoreGemetryMapping(true);
my2DActor->SetUserMatrix(aMatrix); my2DActor->SetUserMatrix(aMatrix);
my2DActor->PickableOff(); my2DActor->PickableOff();
my2DActor->SetProperty(mySurfaceProp); my2DActor->SetProperty(mySurfaceProp);
@ -193,7 +193,8 @@ SMESH_ActorDef::SMESH_ActorDef()
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE); aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD); aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
my3DActor = SMESH_DeviceActor::New(); my3DActor = SMESH_CellLabelActor::New();
my3DActor->SetStoreGemetryMapping(true);
my3DActor->SetUserMatrix(aMatrix); my3DActor->SetUserMatrix(aMatrix);
my3DActor->PickableOff(); my3DActor->PickableOff();
my3DActor->SetProperty(mySurfaceProp); my3DActor->SetProperty(mySurfaceProp);
@ -246,7 +247,8 @@ SMESH_ActorDef::SMESH_ActorDef()
myEdgeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); myEdgeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
myEdgeProp->SetLineWidth(aLineWidth); myEdgeProp->SetLineWidth(aLineWidth);
my1DActor = SMESH_DeviceActor::New(); my1DActor = SMESH_CellLabelActor::New();
my1DActor->SetStoreGemetryMapping(true);
my1DActor->SetUserMatrix(aMatrix); my1DActor->SetUserMatrix(aMatrix);
my1DActor->PickableOff(); my1DActor->PickableOff();
my1DActor->SetHighlited(true); my1DActor->SetHighlited(true);
@ -291,9 +293,9 @@ SMESH_ActorDef::SMESH_ActorDef()
my0DProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); my0DProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
my0DProp->SetPointSize(aElem0DSize); my0DProp->SetPointSize(aElem0DSize);
my0DActor = SMESH_DeviceActor::New(); my0DActor = SMESH_CellLabelActor::New();
my0DActor->SetUserMatrix(aMatrix); my0DActor->SetUserMatrix(aMatrix);
my0DActor->SetStoreClippingMapping(true); my0DActor->SetStoreGemetryMapping(true);
my0DActor->PickableOff(); my0DActor->PickableOff();
my0DActor->SetVisibility(false); my0DActor->SetVisibility(false);
my0DActor->SetProperty(my0DProp); my0DActor->SetProperty(my0DProp);
@ -331,7 +333,7 @@ SMESH_ActorDef::SMESH_ActorDef()
SMESH::GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 0, 0 ) ); SMESH::GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 0, 0 ) );
myNodeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); myNodeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
myNodeActor = SMESH_DeviceActor::New(); myNodeActor = SMESH_NodeLabelActor::New();
myNodeActor->SetUserMatrix(aMatrix); myNodeActor->SetUserMatrix(aMatrix);
myNodeActor->SetStoreClippingMapping(true); myNodeActor->SetStoreClippingMapping(true);
myNodeActor->PickableOff(); myNodeActor->PickableOff();
@ -363,11 +365,9 @@ SMESH_ActorDef::SMESH_ActorDef()
//Definition of Pickable and Highlitable engines //Definition of Pickable and Highlitable engines
//---------------------------------------------- //----------------------------------------------
myBaseActor = SMESH_DeviceActor::New();
myBaseActor->SetUserMatrix(aMatrix); myBaseActor->SetUserMatrix(aMatrix);
myBaseActor->SetStoreGemetryMapping(true); myBaseActor->SetStoreGemetryMapping(true);
myBaseActor->GetProperty()->SetOpacity(0.0); myBaseActor->GetProperty()->SetOpacity(0.0);
myPickableActor = myBaseActor; myPickableActor = myBaseActor;
myHighlightProp = vtkProperty::New(); myHighlightProp = vtkProperty::New();
@ -430,92 +430,12 @@ SMESH_ActorDef::SMESH_ActorDef()
if( !mgr ) if( !mgr )
return; return;
//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());
#if (VTK_XVERSION < 0x050200)
myPtsLabeledDataMapper->SetLabelFormat("%g");
#endif
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();
myEntityMode = eAllEntity; myEntityMode = eAllEntity;
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 = VTKViewer_CellCenters::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());
#if (VTK_XVERSION < 0x050200)
myClsLabeledDataMapper->SetLabelFormat("%g");
#endif
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);
// Clipping planes // Clipping planes
myImplicitBoolean = vtkImplicitBoolean::New(); myImplicitBoolean = vtkImplicitBoolean::New();
myImplicitBoolean->SetOperationTypeToIntersection(); myImplicitBoolean->SetOperationTypeToIntersection();
//Quadratic 2D elements representation //Quadratic 2D elements representation
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
int aQuadratic2DMode = mgr->integerValue( "SMESH", "quadratic_mode", 0); int aQuadratic2DMode = mgr->integerValue( "SMESH", "quadratic_mode", 0);
@ -596,50 +516,9 @@ SMESH_ActorDef::~SMESH_ActorDef()
myNodeActor->Delete(); myNodeActor->Delete();
myBaseActor->Delete(); myBaseActor->Delete();
myNodeExtActor->Delete(); myNodeExtActor->Delete();
myHighlitableActor->Delete(); myHighlitableActor->Delete();
//Deleting of points numbering pipeline
//---------------------------------------
myPointsNumDataSet->Delete();
// commented: porting to vtk 5.0
// myPtsLabeledDataMapper->RemoveAllInputs();
myPtsLabeledDataMapper->Delete();
// commented: porting to vtk 5.0
// myPtsSelectVisiblePoints->UnRegisterAllOutputs();
myPtsSelectVisiblePoints->Delete();
// commented: porting to vtk 5.0
// myPtsMaskPoints->UnRegisterAllOutputs();
myPtsMaskPoints->Delete();
myPointLabels->Delete();
//Deleting of cells numbering pipeline
//---------------------------------------
myCellsNumDataSet->Delete();
myClsLabeledDataMapper->RemoveAllInputs();
myClsLabeledDataMapper->Delete();
// commented: porting to vtk 5.0
// myClsSelectVisiblePoints->UnRegisterAllOutputs();
myClsSelectVisiblePoints->Delete();
// commented: porting to vtk 5.0
// myClsMaskPoints->UnRegisterAllOutputs();
myClsMaskPoints->Delete();
// commented: porting to vtk 5.0
// myCellCenters->UnRegisterAllOutputs();
myCellCenters->Delete();
myCellsLabels->Delete();
myImplicitBoolean->Delete(); myImplicitBoolean->Delete();
myTimeStamp->Delete(); myTimeStamp->Delete();
@ -648,61 +527,50 @@ SMESH_ActorDef::~SMESH_ActorDef()
void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled ) void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled )
{ {
vtkUnstructuredGrid* aGrid = GetUnstructuredGrid(); if(myNodeActor) {
myNodeActor->SetPointsLabeled(theIsPointsLabeled);
myIsPointsLabeled = theIsPointsLabeled && aGrid->GetNumberOfPoints(); SetRepresentation(GetRepresentation());
myTimeStamp->Modified();
}
}
if ( myIsPointsLabeled ) bool SMESH_ActorDef::GetPointsLabeled() {
{ return myNodeActor && myNodeActor->GetPointsLabeled();
myPointsNumDataSet->ShallowCopy(aGrid); }
vtkDataSet *aDataSet = myPointsNumDataSet;
void SMESH_ActorDef::SetCellsLabeled(bool theIsCellsLabeled)
int aNbElem = aDataSet->GetNumberOfPoints(); {
if(my3DActor)
vtkIntArray *anArray = vtkIntArray::New(); my3DActor->SetCellsLabeled(theIsCellsLabeled);
anArray->SetNumberOfValues( aNbElem );
if(my2DActor)
for ( vtkIdType anId = 0; anId < aNbElem; anId++ ) my2DActor->SetCellsLabeled(theIsCellsLabeled);
{
int aSMDSId = myVisualObj->GetNodeObjId( anId ); if(my1DActor)
anArray->SetValue( anId, aSMDSId ); my1DActor->SetCellsLabeled(theIsCellsLabeled);
}
if(my0DActor)
aDataSet->GetPointData()->SetScalars( anArray ); my0DActor->SetCellsLabeled(theIsCellsLabeled);
anArray->Delete();
myPtsMaskPoints->SetInput( aDataSet );
myPointLabels->SetVisibility( GetVisibility() );
}
else
{
myPointLabels->SetVisibility( false );
}
SetRepresentation(GetRepresentation());
myTimeStamp->Modified(); myTimeStamp->Modified();
} }
void SMESH_ActorDef::SetCellsLabeled(bool theIsCellsLabeled) bool SMESH_ActorDef::GetCellsLabeled() {
{ bool result = false;
vtkUnstructuredGrid* aGrid = GetUnstructuredGrid(); if(my3DActor)
myIsCellsLabeled = theIsCellsLabeled && aGrid->GetNumberOfPoints(); result = result || my3DActor->GetCellsLabeled();
if(myIsCellsLabeled){
myCellsNumDataSet->ShallowCopy(aGrid); if(my2DActor)
vtkDataSet *aDataSet = myCellsNumDataSet; result = result || my2DActor->GetCellsLabeled();
int aNbElem = aDataSet->GetNumberOfCells();
vtkIntArray *anArray = vtkIntArray::New(); if(my1DActor)
anArray->SetNumberOfValues(aNbElem); result = result || my1DActor->GetCellsLabeled();
for(int anId = 0; anId < aNbElem; anId++){
int aSMDSId = myVisualObj->GetElemObjId(anId); if(my0DActor)
anArray->SetValue(anId,aSMDSId); result = result || my0DActor->GetCellsLabeled();
}
aDataSet->GetCellData()->SetScalars(anArray); return result;
myCellCenters->SetInput(aDataSet);
myCellsLabels->SetVisibility(GetVisibility());
}else{
myCellsLabels->SetVisibility(false);
}
myTimeStamp->Modified();
} }
@ -993,32 +861,23 @@ SetControlMode(eControl theMode,
void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){ void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){
theRenderer->AddActor(myNodeActor); theRenderer->AddActor(myBaseActor);
theRenderer->AddActor(myBaseActor);
theRenderer->AddActor(myNodeExtActor); theRenderer->AddActor(myNodeExtActor);
theRenderer->AddActor(my1DExtActor);
my3DActor->AddToRender(theRenderer); my3DActor->AddToRender(theRenderer);
my3DExtActor->AddToRender(theRenderer); my3DExtActor->AddToRender(theRenderer);
my2DActor->AddToRender(theRenderer); my2DActor->AddToRender(theRenderer);
my2DExtActor->AddToRender(theRenderer); my2DExtActor->AddToRender(theRenderer);
myNodeActor->AddToRender(theRenderer);
theRenderer->AddActor(my1DActor); my1DActor->AddToRender(theRenderer);
theRenderer->AddActor(my1DExtActor); my0DActor->AddToRender(theRenderer);
theRenderer->AddActor(my0DActor);
//theRenderer->AddActor(my0DExtActor); //theRenderer->AddActor(my0DExtActor);
theRenderer->AddActor(myHighlitableActor); theRenderer->AddActor(myHighlitableActor);
theRenderer->AddActor2D(myScalarBarActor); theRenderer->AddActor2D(myScalarBarActor);
myPtsSelectVisiblePoints->SetRenderer(theRenderer);
myClsSelectVisiblePoints->SetRenderer(theRenderer);
theRenderer->AddActor2D(myPointLabels);
theRenderer->AddActor2D(myCellsLabels);
// the superclass' method should be called at the end // the superclass' method should be called at the end
// (in particular, for correct work of selection) // (in particular, for correct work of selection)
SALOME_Actor::AddToRender(theRenderer); SALOME_Actor::AddToRender(theRenderer);
@ -1027,27 +886,25 @@ void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){
void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer){ void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer){
SALOME_Actor::RemoveFromRender(theRenderer); SALOME_Actor::RemoveFromRender(theRenderer);
theRenderer->RemoveActor(myNodeActor);
theRenderer->RemoveActor(myBaseActor); theRenderer->RemoveActor(myBaseActor);
theRenderer->RemoveActor(myNodeExtActor); theRenderer->RemoveActor(myNodeExtActor);
theRenderer->RemoveActor(myHighlitableActor); theRenderer->RemoveActor(myHighlitableActor);
theRenderer->RemoveActor(my0DActor);
//theRenderer->RemoveActor(my0DExtActor); //theRenderer->RemoveActor(my0DExtActor);
theRenderer->RemoveActor(my1DActor);
theRenderer->RemoveActor(my1DExtActor); theRenderer->RemoveActor(my1DExtActor);
my2DActor->RemoveFromRender(theRenderer); my2DActor->RemoveFromRender(theRenderer);
my2DExtActor->RemoveFromRender(theRenderer); my2DExtActor->RemoveFromRender(theRenderer);
my3DActor->RemoveFromRender(theRenderer); my3DActor->RemoveFromRender(theRenderer);
my3DExtActor->RemoveFromRender(theRenderer); my3DExtActor->RemoveFromRender(theRenderer);
myNodeActor->RemoveFromRender(theRenderer);
my0DActor->RemoveFromRender(theRenderer);
my1DActor->RemoveFromRender(theRenderer);
theRenderer->RemoveActor(myScalarBarActor); theRenderer->RemoveActor(myScalarBarActor);
theRenderer->RemoveActor(myPointLabels);
theRenderer->RemoveActor(myCellsLabels);
} }
@ -1306,8 +1163,6 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){
my3DExtActor->VisibilityOff(); my3DExtActor->VisibilityOff();
myScalarBarActor->VisibilityOff(); myScalarBarActor->VisibilityOff();
myPointLabels->VisibilityOff();
myCellsLabels->VisibilityOff();
if(GetVisibility()){ if(GetVisibility()){
if(theIsUpdateRepersentation) if(theIsUpdateRepersentation)
@ -1362,13 +1217,21 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){
my3DActor->VisibilityOn(); my3DActor->VisibilityOn();
} }
if(myIsPointsLabeled){ if(myNodeActor->GetPointsLabeled()){
myPointLabels->VisibilityOn();
myNodeActor->VisibilityOn(); myNodeActor->VisibilityOn();
} }
if(myIsCellsLabeled) if(my0DActor)
myCellsLabels->VisibilityOn(); my0DActor->UpdateLabels();
if(my1DActor)
my1DActor->UpdateLabels();
if(my2DActor)
my2DActor->UpdateLabels();
if(my3DActor)
my3DActor->UpdateLabels();
} }
#ifndef DISABLE_PLOT2DVIEWER #ifndef DISABLE_PLOT2DVIEWER
else else
@ -1622,7 +1485,7 @@ void SMESH_ActorDef::SetPointRepresentation(bool theIsPointsVisible){
} }
bool SMESH_ActorDef::GetPointRepresentation(){ bool SMESH_ActorDef::GetPointRepresentation(){
return myIsPointsVisible || myIsPointsLabeled; return myIsPointsVisible || myNodeActor->GetPointsLabeled();
} }
@ -1729,12 +1592,22 @@ void SMESH_ActorDef::Update(){
if (anObjTime > aTime) if (anObjTime > aTime)
SetControlMode(GetControlMode(),false); SetControlMode(GetControlMode(),false);
} }
if(myIsPointsLabeled){
SetPointsLabeled(myIsPointsLabeled); if(myNodeActor)
} myNodeActor->UpdateLabels();
if(myIsCellsLabeled){
SetCellsLabeled(myIsCellsLabeled); if(my0DActor)
} my0DActor->UpdateLabels();
if(my1DActor)
my1DActor->UpdateLabels();
if(my2DActor)
my2DActor->UpdateLabels();
if(my3DActor)
my3DActor->UpdateLabels();
if(myIsFacesOriented){ if(myIsFacesOriented){
SetFacesOriented(myIsFacesOriented); SetFacesOriented(myIsFacesOriented);
} }
@ -1929,6 +1802,7 @@ SMESH_ActorDef::AddClippingPlane(vtkPlane* thePlane)
myCippingPlaneCont.push_back(thePlane); myCippingPlaneCont.push_back(thePlane);
if(!IsImplicitFunctionUsed()) if(!IsImplicitFunctionUsed())
SetImplicitFunctionUsed(true); SetImplicitFunctionUsed(true);
myNodeActor->UpdateLabels();
} }
return myCippingPlaneCont.size(); return myCippingPlaneCont.size();
} }
@ -1941,6 +1815,7 @@ RemoveAllClippingPlanes()
myImplicitBoolean->GetFunction()->Modified(); // VTK bug myImplicitBoolean->GetFunction()->Modified(); // VTK bug
myCippingPlaneCont.clear(); myCippingPlaneCont.clear();
SetImplicitFunctionUsed(false); SetImplicitFunctionUsed(false);
myNodeActor->UpdateLabels();
} }
vtkIdType vtkIdType

36
src/OBJECT/SMESH_ActorDef.h
View File

@ -61,17 +61,14 @@ class vtkMergeFilter;
class vtkPolyData; class vtkPolyData;
class vtkMapper; class vtkMapper;
class vtkActor2D; class vtkActor2D;
class vtkMaskPoints;
class vtkLabeledDataMapper;
class vtkSelectVisiblePoints;
class vtkLookupTable; class vtkLookupTable;
class vtkPlane; class vtkPlane;
class vtkImplicitBoolean; class vtkImplicitBoolean;
class vtkTimeStamp; class vtkTimeStamp;
class VTKViewer_CellCenters;
class SMESH_DeviceActor; class SMESH_DeviceActor;
class SMESH_NodeLabelActor;
class SMESH_CellLabelActor;
class SMESH_ScalarBarActor; class SMESH_ScalarBarActor;
#ifndef DISABLE_PLOT2DVIEWER #ifndef DISABLE_PLOT2DVIEWER
@ -167,10 +164,10 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void UnShrink(); virtual void UnShrink();
virtual void SetPointsLabeled(bool theIsPointsLabeled); virtual void SetPointsLabeled(bool theIsPointsLabeled);
virtual bool GetPointsLabeled(){ return myIsPointsLabeled;} virtual bool GetPointsLabeled();
virtual void SetCellsLabeled(bool theIsCellsLabeled); virtual void SetCellsLabeled(bool theIsCellsLabeled);
virtual bool GetCellsLabeled(){ return myIsCellsLabeled;} virtual bool GetCellsLabeled();
virtual void SetFacesOriented(bool theIsFacesOriented); virtual void SetFacesOriented(bool theIsFacesOriented);
virtual bool GetFacesOriented(); virtual bool GetFacesOriented();
@ -232,7 +229,7 @@ class SMESH_ActorDef : public SMESH_Actor
vtkProperty* myNodeProp; vtkProperty* myNodeProp;
SMESH_DeviceActor* myBaseActor; SMESH_DeviceActor* myBaseActor;
SMESH_DeviceActor* myNodeActor; SMESH_NodeLabelActor* myNodeActor;
SMESH_DeviceActor* myPickableActor; SMESH_DeviceActor* myPickableActor;
vtkProperty* myHighlightProp; vtkProperty* myHighlightProp;
@ -244,9 +241,9 @@ class SMESH_ActorDef : public SMESH_Actor
eControl myControlMode; eControl myControlMode;
SMESH::Controls::FunctorPtr myFunctor; SMESH::Controls::FunctorPtr myFunctor;
vtkProperty* my2DExtProp; vtkProperty* my2DExtProp;
SMESH_DeviceActor* my2DActor; SMESH_CellLabelActor* my2DActor;
SMESH_DeviceActor* my2DExtActor; SMESH_DeviceActor* my2DExtActor;
SMESH_DeviceActor* my3DActor; SMESH_CellLabelActor* my3DActor;
SMESH_DeviceActor* my3DExtActor; SMESH_DeviceActor* my3DExtActor;
SMESH_DeviceActor* myControlActor; SMESH_DeviceActor* myControlActor;
@ -254,12 +251,12 @@ class SMESH_ActorDef : public SMESH_Actor
SMESH_DeviceActor* myNodeExtActor; SMESH_DeviceActor* myNodeExtActor;
vtkProperty* my1DProp; vtkProperty* my1DProp;
SMESH_DeviceActor* my1DActor; SMESH_CellLabelActor* my1DActor;
vtkProperty* my1DExtProp; vtkProperty* my1DExtProp;
SMESH_DeviceActor* my1DExtActor; SMESH_DeviceActor* my1DExtActor;
vtkProperty* my0DProp; vtkProperty* my0DProp;
SMESH_DeviceActor* my0DActor; SMESH_CellLabelActor* my0DActor;
vtkProperty* my0DExtProp; vtkProperty* my0DExtProp;
SMESH_DeviceActor* my0DExtActor; SMESH_DeviceActor* my0DExtActor;
@ -270,21 +267,6 @@ class SMESH_ActorDef : public SMESH_Actor
bool myIsShrinkable; bool myIsShrinkable;
bool myIsShrunk; bool myIsShrunk;
bool myIsPointsLabeled;
vtkUnstructuredGrid* myPointsNumDataSet;
vtkActor2D *myPointLabels;
vtkMaskPoints* myPtsMaskPoints;
vtkLabeledDataMapper* myPtsLabeledDataMapper;
vtkSelectVisiblePoints* myPtsSelectVisiblePoints;
bool myIsCellsLabeled;
vtkUnstructuredGrid* myCellsNumDataSet;
vtkActor2D *myCellsLabels;
vtkMaskPoints* myClsMaskPoints;
VTKViewer_CellCenters* myCellCenters;
vtkLabeledDataMapper* myClsLabeledDataMapper;
vtkSelectVisiblePoints* myClsSelectVisiblePoints;
vtkImplicitBoolean* myImplicitBoolean; vtkImplicitBoolean* myImplicitBoolean;
typedef TVTKSmartPtr<vtkPlane> TPlanePtr; typedef TVTKSmartPtr<vtkPlane> TPlanePtr;
typedef std::vector<TPlanePtr> TCippingPlaneCont; typedef std::vector<TPlanePtr> TCippingPlaneCont;

185
src/OBJECT/SMESH_CellLabelActor.cxx Normal file
View File

@ -0,0 +1,185 @@
// Copyright (C) 2007-2011 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.
//
// 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
//
// File : SMESH_CellLabelActor.cxx
// Author : Roman NIKOLAEV
// Module : SMESH
//
#include "SMESH_CellLabelActor.h"
#include <VTKViewer_TransformFilter.h>
#include <VTKViewer_CellCenters.h>
#include <vtkObjectFactory.h>
#include <vtkCallbackCommand.h>
#include <vtkMaskPoints.h>
#include <vtkSelectVisiblePoints.h>
#include <vtkLabeledDataMapper.h>
#include <vtkActor2D.h>
#include <vtkTextProperty.h>
#include <vtkPointData.h>
#include <vtkProperty2D.h>
#include <vtkRenderer.h>
#include <vtkPolyData.h>
#include <vtkCellData.h>
vtkStandardNewMacro(SMESH_CellLabelActor);
/*!
Constructor.
*/
SMESH_CellLabelActor::SMESH_CellLabelActor() {
//Definition of cells numbering pipeline
//---------------------------------------
myCellsNumDataSet = vtkPolyData::New();
myCellCenters = VTKViewer_CellCenters::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("%d");
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);
vtkCallbackCommand* callBackCommand = vtkCallbackCommand::New();
callBackCommand->SetClientData(this);
callBackCommand->SetCallback(SMESH_CellLabelActor::ProcessEvents);
myTransformFilter->AddObserver("VTKViewer_TransformFilter::TransformationFinished",
callBackCommand);
callBackCommand->Delete();
}
/*!
Destructor.
*/
SMESH_CellLabelActor::~SMESH_CellLabelActor() {
//Deleting of cells numbering pipeline
//---------------------------------------
myCellsNumDataSet->Delete();
myClsLabeledDataMapper->RemoveAllInputs();
myClsLabeledDataMapper->Delete();
// commented: porting to vtk 5.0
// myClsSelectVisiblePoints->UnRegisterAllOutputs();
myClsSelectVisiblePoints->Delete();
// commented: porting to vtk 5.0
// myClsMaskPoints->UnRegisterAllOutputs();
myClsMaskPoints->Delete();
// commented: porting to vtk 5.0
// myCellCenters->UnRegisterAllOutputs();
myCellCenters->Delete();
myCellsLabels->Delete();
}
void SMESH_CellLabelActor::SetCellsLabeled(bool theIsCellsLabeled) {
myTransformFilter->Update();
vtkPolyData* aGrid = vtkPolyData::SafeDownCast(myTransformFilter->GetOutput());
if(!aGrid)
return;
myIsCellsLabeled = theIsCellsLabeled && aGrid->GetNumberOfPoints();
if(myIsCellsLabeled){
myCellsNumDataSet->ShallowCopy(aGrid);
vtkDataSet *aDataSet = myCellsNumDataSet;
int aNbElem = aDataSet->GetNumberOfCells();
vtkIntArray *anArray = vtkIntArray::New();
anArray->SetNumberOfValues(aNbElem);
for(int anId = 0; anId < aNbElem; anId++){
int aSMDSId = GetElemObjId(anId);
anArray->SetValue(anId,aSMDSId);
}
aDataSet->GetCellData()->SetScalars(anArray);
myCellCenters->SetInput(aDataSet);
myCellsLabels->SetVisibility(GetVisibility());
}else{
myCellsLabels->SetVisibility(false);
}
}
void SMESH_CellLabelActor::SetVisibility(int theMode)
{
SMESH_DeviceActor::SetVisibility(theMode);
myCellsLabels->VisibilityOff();
if(myIsCellsLabeled && theMode)
myCellsLabels->VisibilityOn();
}
void SMESH_CellLabelActor::AddToRender(vtkRenderer* theRenderer)
{
SMESH_DeviceActor::AddToRender(theRenderer);
myClsSelectVisiblePoints->SetRenderer(theRenderer);
theRenderer->AddActor2D(myCellsLabels);
}
void SMESH_CellLabelActor::RemoveFromRender(vtkRenderer* theRenderer)
{
theRenderer->RemoveActor(myCellsLabels);
SMESH_DeviceActor::RemoveFromRender(theRenderer);
}
void SMESH_CellLabelActor::UpdateLabels() {
if(myIsCellsLabeled)
SetCellsLabeled(myIsCellsLabeled);
}
void SMESH_CellLabelActor::ProcessEvents(vtkObject* vtkNotUsed(theObject),
unsigned long theEvent,
void* theClientData,
void* vtkNotUsed(theCallData)) {
SMESH_CellLabelActor* self = reinterpret_cast<SMESH_CellLabelActor*>(theClientData);
if(self)
self->UpdateLabels();
}

82
src/OBJECT/SMESH_CellLabelActor.h Normal file
View File

@ -0,0 +1,82 @@
// Copyright (C) 2007-2011 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.
//
// 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
//
// File : SMESH_CellLabelActor.h
// Author : Roman NIKOLAEV
// Module : SMESH
//
#ifndef SMESH_CELL_LABEL_ACTOR_H
#define SMESH_CELL_LABEL_ACTOR_H
#include "SMESH_DeviceActor.h"
class vtkSelectVisiblePoints;
class vtkLabeledDataMapper;
class vtkActor2D;
class vtkMaskPoints;
class vtkPolyData;
class VTKViewer_CellCenters;
class SMESHOBJECT_EXPORT SMESH_CellLabelActor : public SMESH_DeviceActor {
public:
static SMESH_CellLabelActor* New();
static void ProcessEvents(vtkObject* theObject,
unsigned long theEvent,
void* theClientData,
void* theCallData);
vtkTypeMacro(SMESH_CellLabelActor, SMESH_DeviceActor);
virtual void SetCellsLabeled(bool theIsCellsLabeled);
virtual bool GetCellsLabeled(){ return myIsCellsLabeled;}
virtual void SetVisibility(int theMode);
virtual void AddToRender(vtkRenderer* theRenderer);
virtual void RemoveFromRender(vtkRenderer* theRenderer);
void UpdateLabels();
protected:
SMESH_CellLabelActor();
~SMESH_CellLabelActor();
bool myIsCellsLabeled;
vtkPolyData* myCellsNumDataSet;
vtkActor2D *myCellsLabels;
vtkMaskPoints* myClsMaskPoints;
VTKViewer_CellCenters* myCellCenters;
vtkLabeledDataMapper* myClsLabeledDataMapper;
vtkSelectVisiblePoints* myClsSelectVisiblePoints;
SMESH_DeviceActor* myBaseActor; //Pointer to the base actor
protected:
// Not implemented.
SMESH_CellLabelActor(const SMESH_CellLabelActor&);
void operator=(const SMESH_CellLabelActor&);
};
#endif //SMESH_NODE_LABEL_ACTOR_H

2
src/OBJECT/SMESH_DeviceActor.cxx
View File

@ -626,7 +626,7 @@ void
SMESH_DeviceActor SMESH_DeviceActor
::SetFacesOriented(bool theIsFacesOriented) ::SetFacesOriented(bool theIsFacesOriented)
{ {
if ( vtkDataSet* aDataSet = myPassFilter[ 1 ]->GetOutput() ) if ( vtkDataSet* aDataSet = myTransformFilter->GetOutput() )
{ {
myIsFacesOriented = theIsFacesOriented; myIsFacesOriented = theIsFacesOriented;
if( theIsFacesOriented ) if( theIsFacesOriented )

187
src/OBJECT/SMESH_NodeLabelActor.cxx Normal file
View File

@ -0,0 +1,187 @@
// Copyright (C) 2007-2011 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.
//
// 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
//
// File : SMESH_NodeLabelActor.cxx
// Author : Roman NIKOLAEV
// Module : SMESH
//
#include "SMESH_NodeLabelActor.h"
#include <VTKViewer_TransformFilter.h>
#include <vtkObjectFactory.h>
#include <vtkCallbackCommand.h>
#include <vtkMaskPoints.h>
#include <vtkSelectVisiblePoints.h>
#include <vtkLabeledDataMapper.h>
#include <vtkActor2D.h>
#include <vtkTextProperty.h>
#include <vtkPointData.h>
#include <vtkProperty2D.h>
#include <vtkRenderer.h>
#include <vtkPolyData.h>
vtkStandardNewMacro(SMESH_NodeLabelActor);
/*!
Constructor.
*/
SMESH_NodeLabelActor::SMESH_NodeLabelActor() {
//Definition of points numbering pipeline
//---------------------------------------
myPointsNumDataSet = vtkPolyData::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("%d");
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);
vtkCallbackCommand* callBackCommand = vtkCallbackCommand::New();
callBackCommand->SetClientData(this);
callBackCommand->SetCallback(SMESH_NodeLabelActor::ProcessEvents);
myTransformFilter->AddObserver("VTKViewer_TransformFilter::TransformationFinished",
callBackCommand);
callBackCommand->Delete();
}
/*!
Destructor
*/
SMESH_NodeLabelActor::~SMESH_NodeLabelActor() {
//Deleting of points numbering pipeline
//---------------------------------------
myPointsNumDataSet->Delete();
// commented: porting to vtk 5.0
// myPtsLabeledDataMapper->RemoveAllInputs();
myPtsLabeledDataMapper->Delete();
// commented: porting to vtk 5.0
// myPtsSelectVisiblePoints->UnRegisterAllOutputs();
myPtsSelectVisiblePoints->Delete();
// commented: porting to vtk 5.0
// myPtsMaskPoints->UnRegisterAllOutputs();
myPtsMaskPoints->Delete();
myPointLabels->Delete();
}
void SMESH_NodeLabelActor::SetPointsLabeled(bool theIsPointsLabeled) {
myTransformFilter->Update();
vtkDataSet* aGrid = vtkPolyData::SafeDownCast(myTransformFilter->GetOutput());
if(!aGrid)
return;
myIsPointsLabeled = theIsPointsLabeled && aGrid->GetNumberOfPoints();
if ( myIsPointsLabeled )
{
myPointsNumDataSet->ShallowCopy(aGrid);
vtkDataSet *aDataSet = myPointsNumDataSet;
int aNbElem = aDataSet->GetNumberOfPoints();
vtkIntArray *anArray = vtkIntArray::New();
anArray->SetNumberOfValues( aNbElem );
for ( vtkIdType anId = 0; anId < aNbElem; anId++ )
{
int aSMDSId = GetNodeObjId( anId );
anArray->SetValue( anId, aSMDSId );
}
aDataSet->GetPointData()->SetScalars( anArray );
myPtsMaskPoints->SetInput( aDataSet );
myPointLabels->SetVisibility( GetVisibility() );
anArray->Delete();
}
else
{
myPointLabels->SetVisibility( false );
}
}
void SMESH_NodeLabelActor::SetVisibility(int theMode)
{
SMESH_DeviceActor::SetVisibility(theMode);
myPointLabels->VisibilityOff();
if(myIsPointsLabeled && theMode)
myPointLabels->VisibilityOn();
}
void SMESH_NodeLabelActor::AddToRender(vtkRenderer* theRenderer)
{
SMESH_DeviceActor::AddToRender(theRenderer);
myPtsSelectVisiblePoints->SetRenderer(theRenderer);
theRenderer->AddActor2D(myPointLabels);
}
void SMESH_NodeLabelActor::RemoveFromRender(vtkRenderer* theRenderer)
{
theRenderer->RemoveActor(myPointLabels);
SMESH_DeviceActor::RemoveFromRender(theRenderer);
}
void SMESH_NodeLabelActor::UpdateLabels() {
if(myIsPointsLabeled)
SetPointsLabeled(myIsPointsLabeled);
}
void SMESH_NodeLabelActor::ProcessEvents(vtkObject* vtkNotUsed(theObject),
unsigned long theEvent,
void* theClientData,
void* vtkNotUsed(theCallData)) {
SMESH_NodeLabelActor* self = reinterpret_cast<SMESH_NodeLabelActor*>(theClientData);
if(self)
self->UpdateLabels();
}

78
src/OBJECT/SMESH_NodeLabelActor.h Normal file
View File

@ -0,0 +1,78 @@
// Copyright (C) 2007-2011 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.
//
// 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
//
// File : SMESH_NodeLabelActor.h
// Author : Roman NIKOLAEV
// Module : SMESH
//
#ifndef SMESH_NODE_LABEL_ACTOR_H
#define SMESH_NODE_LABEL_ACTOR_H
#include "SMESH_DeviceActor.h"
class vtkSelectVisiblePoints;
class vtkLabeledDataMapper;
class vtkActor2D;
class vtkMaskPoints;
class vtkPolyData;
class SMESHOBJECT_EXPORT SMESH_NodeLabelActor : public SMESH_DeviceActor {
public:
static SMESH_NodeLabelActor* New();
static void ProcessEvents(vtkObject* theObject,
unsigned long theEvent,
void* theClientData,
void* theCallData);
vtkTypeMacro(SMESH_NodeLabelActor, SMESH_DeviceActor);
virtual void SetPointsLabeled(bool theIsPointsLabeled);
virtual bool GetPointsLabeled(){ return myIsPointsLabeled;}
virtual void SetVisibility(int theMode);
virtual void AddToRender(vtkRenderer* theRenderer);
virtual void RemoveFromRender(vtkRenderer* theRenderer);
void UpdateLabels();
protected:
SMESH_NodeLabelActor();
~SMESH_NodeLabelActor();
bool myIsPointsLabeled;
vtkPolyData* myPointsNumDataSet;
vtkActor2D *myPointLabels;
vtkMaskPoints* myPtsMaskPoints;
vtkLabeledDataMapper* myPtsLabeledDataMapper;
vtkSelectVisiblePoints* myPtsSelectVisiblePoints;
protected:
// Not implemented.
SMESH_NodeLabelActor(const SMESH_NodeLabelActor&);
void operator=(const SMESH_NodeLabelActor&);
};
#endif //SMESH_NODE_LABEL_ACTOR_H