X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FOBJECT%2FSMESH_Actor.cxx;h=cafd4b00045fe5cd1a883905e8a4c51a10b5f4b9;hp=4709f9357bd26325684bdbd5b79d82a0fd8f2cd8;hb=10363c830c5bc84c9a9a5d3378eeef687297d119;hpb=bcbdd40a304aafd5521495fa84a3539c9353459d diff --git a/src/OBJECT/SMESH_Actor.cxx b/src/OBJECT/SMESH_Actor.cxx index 4709f9357..cafd4b000 100644 --- a/src/OBJECT/SMESH_Actor.cxx +++ b/src/OBJECT/SMESH_Actor.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE +// 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 @@ -19,17 +19,20 @@ // // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // + // SMESH OBJECT : interactive object for SMESH visualization // File : SMESH_Actor.cxx // Author : Nicolas REJNERI // Module : SMESH - - +// #include "SMESH_ActorDef.h" #include "SMESH_ActorUtils.h" #include "SMESH_DeviceActor.h" #include "SMESH_ObjectDef.h" #include "SMESH_ControlsDef.hxx" +#include "SMDS_UnstructuredGrid.hxx" +#include "SMESH_ScalarBarActor.h" +#include "VTKViewer_CellCenters.h" #include "VTKViewer_ExtractUnstructuredGrid.h" #include "VTKViewer_FramedTextActor.h" #include "SALOME_InteractiveObject.hxx" @@ -59,12 +62,10 @@ #include #include #include -#include #include #include #include -#include #include #include @@ -72,16 +73,20 @@ #include #include +#include +#if !defined(VTK_XVERSION) +#define VTK_XVERSION (VTK_MAJOR_VERSION<<16)+(VTK_MINOR_VERSION<<8)+(VTK_BUILD_VERSION) +#endif + #include "utilities.h" #ifdef _DEBUG_ static int MYDEBUG = 1; #else -static int MYDEBUG = 0; +static int MYDEBUG = 1; #endif static int aLineWidthInc = 2; -static int aPointSizeInc = 2; SMESH_ActorDef* SMESH_ActorDef::New(){ @@ -90,9 +95,9 @@ SMESH_ActorDef* SMESH_ActorDef::New(){ SMESH_Actor* SMESH_Actor::New(TVisualObjPtr theVisualObj, - const char* theEntry, - const char* theName, - int theIsClear) + const char* theEntry, + const char* theName, + int theIsClear) { SMESH_ActorDef* anActor = SMESH_ActorDef::New(); if(!anActor->Init(theVisualObj,theEntry,theName,theIsClear)){ @@ -124,7 +129,6 @@ SMESH_ActorDef::SMESH_ActorDef() if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) ) myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1); - vtkFloatingPointType aPointSize = SMESH::GetFloat("SMESH:node_size",3); vtkFloatingPointType aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5); vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1); @@ -193,6 +197,30 @@ SMESH_ActorDef::SMESH_ActorDef() aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA); aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON); aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE); + aFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID); + aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET); +//#ifdef VTK_HAVE_POLYHEDRON + MESSAGE("RegisterCellsWithType(VTK_POLYHEDRON)"); + aFilter->RegisterCellsWithType(VTK_POLYHEDRON); +//#endif + + my3DExtActor = SMESH_DeviceActor::New(); + my3DExtActor->SetUserMatrix(aMatrix); + my3DExtActor->PickableOff(); + my3DExtActor->SetProperty(my2DExtProp); + my3DExtActor->SetBackfaceProperty(my2DExtProp); + my3DExtActor->SetRepresentation(SMESH_DeviceActor::eSurface); + aFilter = my3DExtActor->GetExtractUnstructuredGrid(); + aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding); + aFilter->RegisterCellsWithType(VTK_TETRA); + aFilter->RegisterCellsWithType(VTK_VOXEL); + aFilter->RegisterCellsWithType(VTK_HEXAHEDRON); + aFilter->RegisterCellsWithType(VTK_WEDGE); + aFilter->RegisterCellsWithType(VTK_PYRAMID); + aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA); + aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON); + aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE); + aFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID); aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET); //Definition 1D device of the actor @@ -219,7 +247,7 @@ SMESH_ActorDef::SMESH_ActorDef() my1DProp = vtkProperty::New(); my1DProp->DeepCopy(myEdgeProp); my1DProp->SetLineWidth(aLineWidth + aLineWidthInc); - my1DProp->SetPointSize(aPointSize); + my1DProp->SetPointSize(aElem0DSize); my1DExtProp = vtkProperty::New(); my1DExtProp->DeepCopy(myEdgeProp); @@ -228,7 +256,7 @@ SMESH_ActorDef::SMESH_ActorDef() anRGB[2] = 1 - anRGB[2]; my1DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); my1DExtProp->SetLineWidth(aLineWidth + aLineWidthInc); - my1DExtProp->SetPointSize(aPointSize + aPointSizeInc); + my1DExtProp->SetPointSize(aElem0DSize); my1DExtActor = SMESH_DeviceActor::New(); my1DExtActor->SetUserMatrix(aMatrix); @@ -289,7 +317,6 @@ SMESH_ActorDef::SMESH_ActorDef() myNodeProp = vtkProperty::New(); SMESH::GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 0, 0 ) ); myNodeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); - myNodeProp->SetPointSize(aPointSize); myNodeActor = SMESH_DeviceActor::New(); myNodeActor->SetUserMatrix(aMatrix); @@ -307,7 +334,6 @@ SMESH_ActorDef::SMESH_ActorDef() anRGB[1] = 1 - anRGB[1]; anRGB[2] = 1 - anRGB[2]; myNodeExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); - myNodeExtProp->SetPointSize(aPointSize); myNodeExtActor = SMESH_DeviceActor::New(); myNodeExtActor->SetUserMatrix(aMatrix); @@ -337,8 +363,7 @@ SMESH_ActorDef::SMESH_ActorDef() myHighlightProp->SetSpecular(0.0); SMESH::GetColor( "SMESH", "selection_object_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 255, 255 ) ); myHighlightProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); - //myHighlightProp->SetPointSize(aPointSize); - myHighlightProp->SetPointSize(std::max(aElem0DSize,aPointSize)); // ?? + myHighlightProp->SetPointSize(aElem0DSize); // ?? myHighlightProp->SetRepresentation(1); myPreselectProp = vtkProperty::New(); @@ -347,8 +372,7 @@ SMESH_ActorDef::SMESH_ActorDef() myPreselectProp->SetSpecular(0.0); SMESH::GetColor( "SMESH", "highlight_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 255 ) ); myPreselectProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); - //myPreselectProp->SetPointSize(aPointSize); - myPreselectProp->SetPointSize(std::max(aElem0DSize,aPointSize)); // ?? + myPreselectProp->SetPointSize(aElem0DSize); // ?? myPreselectProp->SetRepresentation(1); myHighlitableActor = SMESH_DeviceActor::New(); @@ -371,7 +395,7 @@ SMESH_ActorDef::SMESH_ActorDef() //Controls - Aspect Ratio: incorrect colors of the best and worst values myLookupTable->SetHueRange(0.667,0.0); - myScalarBarActor = vtkScalarBarActor::New(); + myScalarBarActor = SMESH_ScalarBarActor::New(); myScalarBarActor->SetVisibility(false); myScalarBarActor->SetLookupTable(myLookupTable); @@ -399,7 +423,9 @@ SMESH_ActorDef::SMESH_ActorDef() myPtsLabeledDataMapper = vtkLabeledDataMapper::New(); myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput()); +#if (VTK_XVERSION < 0x050200) myPtsLabeledDataMapper->SetLabelFormat("%g"); +#endif myPtsLabeledDataMapper->SetLabelModeToLabelScalars(); vtkTextProperty* aPtsTextProp = vtkTextProperty::New(); @@ -426,7 +452,7 @@ SMESH_ActorDef::SMESH_ActorDef() //--------------------------------------- myCellsNumDataSet = vtkUnstructuredGrid::New(); - myCellCenters = vtkCellCenters::New(); + myCellCenters = VTKViewer_CellCenters::New(); myCellCenters->SetInput(myCellsNumDataSet); myClsMaskPoints = vtkMaskPoints::New(); @@ -440,7 +466,9 @@ SMESH_ActorDef::SMESH_ActorDef() myClsLabeledDataMapper = vtkLabeledDataMapper::New(); myClsLabeledDataMapper->SetInput(myClsSelectVisiblePoints->GetOutput()); +#if (VTK_XVERSION < 0x050200) myClsLabeledDataMapper->SetLabelFormat("%g"); +#endif myClsLabeledDataMapper->SetLabelModeToLabelScalars(); vtkTextProperty* aClsTextProp = vtkTextProperty::New(); @@ -484,9 +512,11 @@ SMESH_ActorDef::SMESH_ActorDef() myHighlitableActor->SetQuadraticArcAngle(aQuadraticAngle); my2DActor->SetQuadraticArcAngle(aQuadraticAngle); - // Set color of the name actor + // Set colors of the name actor SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); myNameActor->SetBackgroundColor(anRGB[0], anRGB[1], anRGB[2]); + SMESH::GetColor( "SMESH", "group_name_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 255, 255 ) ); + myNameActor->SetForegroundColor(anRGB[0], anRGB[1], anRGB[2]); } @@ -494,6 +524,9 @@ SMESH_ActorDef::~SMESH_ActorDef() { if(MYDEBUG) MESSAGE("~SMESH_ActorDef - "<InvokeEvent( SMESH::DeleteActorEvent, NULL ); + myScalarBarActor->Delete(); myLookupTable->Delete(); @@ -523,6 +556,7 @@ SMESH_ActorDef::~SMESH_ActorDef() my2DExtProp->Delete(); my2DExtActor->Delete(); my3DActor->Delete(); + my3DExtActor->Delete(); myNodeActor->Delete(); myBaseActor->Delete(); @@ -593,7 +627,7 @@ void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled ) vtkIntArray *anArray = vtkIntArray::New(); anArray->SetNumberOfValues( aNbElem ); - for ( int anId = 0; anId < aNbElem; anId++ ) + for ( vtkIdType anId = 0; anId < aNbElem; anId++ ) { int aSMDSId = myVisualObj->GetNodeObjId( anId ); anArray->SetValue( anId, aSMDSId ); @@ -652,6 +686,39 @@ bool SMESH_ActorDef::GetFacesOriented() return myIsFacesOriented; } +void SMESH_ActorDef::SetFacesOrientationColor(vtkFloatingPointType theColor[3]) +{ + my2DActor->SetFacesOrientationColor( theColor ); + my3DActor->SetFacesOrientationColor( theColor ); +} + +void SMESH_ActorDef::GetFacesOrientationColor(vtkFloatingPointType theColor[3]) +{ + my3DActor->GetFacesOrientationColor( theColor ); +} + +void SMESH_ActorDef::SetFacesOrientationScale(vtkFloatingPointType theScale) +{ + my2DActor->SetFacesOrientationScale( theScale ); + my3DActor->SetFacesOrientationScale( theScale ); +} + +vtkFloatingPointType SMESH_ActorDef::GetFacesOrientationScale() +{ + return my3DActor->GetFacesOrientationScale(); +} + +void SMESH_ActorDef::SetFacesOrientation3DVectors(bool theState) +{ + my2DActor->SetFacesOrientation3DVectors( theState ); + my3DActor->SetFacesOrientation3DVectors( theState ); +} + +bool SMESH_ActorDef::GetFacesOrientation3DVectors() +{ + return my3DActor->GetFacesOrientation3DVectors(); +} + void SMESH_ActorDef:: @@ -664,7 +731,7 @@ SetControlMode(eControl theMode) void SMESH_ActorDef:: SetControlMode(eControl theMode, - bool theCheckEntityMode) + bool theCheckEntityMode) { SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); if( !mgr ) @@ -681,52 +748,59 @@ SetControlMode(eControl theMode, bool anIsScalarVisible = theMode > eNone; - if(anIsScalarVisible){ - SMESH::Controls::FunctorPtr aFunctor; - switch(theMode){ + if(anIsScalarVisible) { + switch(theMode) { case eLength: { SMESH::Controls::Length* aControl = new SMESH::Controls::Length(); aControl->SetPrecision( myControlsPrecision ); - aFunctor.reset( aControl ); + myFunctor.reset( aControl ); myControlActor = my1DActor; break; } case eLength2D: { - aFunctor.reset(new SMESH::Controls::Length2D()); + myFunctor.reset(new SMESH::Controls::Length2D()); myControlActor = my2DActor; break; } case eFreeBorders: - aFunctor.reset(new SMESH::Controls::FreeBorders()); + myFunctor.reset(new SMESH::Controls::FreeBorders()); myControlActor = my1DActor; break; case eFreeEdges: - aFunctor.reset(new SMESH::Controls::FreeEdges()); + myFunctor.reset(new SMESH::Controls::FreeEdges()); myControlActor = my2DActor; break; case eFreeNodes: - aFunctor.reset(new SMESH::Controls::FreeNodes()); + myFunctor.reset(new SMESH::Controls::FreeNodes()); myControlActor = myNodeActor; break; case eFreeFaces: - aFunctor.reset(new SMESH::Controls::FreeFaces()); + myFunctor.reset(new SMESH::Controls::FreeFaces()); + myControlActor = my2DActor; + break; + case eBareBorderFace: + myFunctor.reset(new SMESH::Controls::BareBorderFace()); + myControlActor = my2DActor; + break; + case eOverConstrainedFace: + myFunctor.reset(new SMESH::Controls::OverConstrainedFace()); myControlActor = my2DActor; break; case eMultiConnection: - aFunctor.reset(new SMESH::Controls::MultiConnection()); + myFunctor.reset(new SMESH::Controls::MultiConnection()); myControlActor = my1DActor; break; case eMultiConnection2D: - aFunctor.reset(new SMESH::Controls::MultiConnection2D()); + myFunctor.reset(new SMESH::Controls::MultiConnection2D()); myControlActor = my2DActor; break; case eArea: { SMESH::Controls::Area* aControl = new SMESH::Controls::Area(); aControl->SetPrecision( myControlsPrecision ); - aFunctor.reset( aControl ); + myFunctor.reset( aControl ); myControlActor = my2DActor; break; } @@ -734,7 +808,7 @@ SetControlMode(eControl theMode, { SMESH::Controls::Taper* aControl = new SMESH::Controls::Taper(); aControl->SetPrecision( myControlsPrecision ); - aFunctor.reset( aControl ); + myFunctor.reset( aControl ); myControlActor = my2DActor; break; } @@ -742,7 +816,7 @@ SetControlMode(eControl theMode, { SMESH::Controls::AspectRatio* aControl = new SMESH::Controls::AspectRatio(); aControl->SetPrecision( myControlsPrecision ); - aFunctor.reset( aControl ); + myFunctor.reset( aControl ); myControlActor = my2DActor; break; } @@ -750,7 +824,7 @@ SetControlMode(eControl theMode, { SMESH::Controls::AspectRatio3D* aControl = new SMESH::Controls::AspectRatio3D(); aControl->SetPrecision( myControlsPrecision ); - aFunctor.reset( aControl ); + myFunctor.reset( aControl ); myControlActor = my3DActor; break; } @@ -758,7 +832,35 @@ SetControlMode(eControl theMode, { SMESH::Controls::Volume* aControl = new SMESH::Controls::Volume(); aControl->SetPrecision( myControlsPrecision ); - aFunctor.reset( aControl ); + myFunctor.reset( aControl ); + myControlActor = my3DActor; + break; + } + case eMaxElementLength2D: + { + SMESH::Controls::MaxElementLength2D* aControl = new SMESH::Controls::MaxElementLength2D(); + aControl->SetPrecision( myControlsPrecision ); + myFunctor.reset( aControl ); + myControlActor = my2DActor; + break; + } + case eMaxElementLength3D: + { + SMESH::Controls::MaxElementLength3D* aControl = new SMESH::Controls::MaxElementLength3D(); + aControl->SetPrecision( myControlsPrecision ); + myFunctor.reset( aControl ); + myControlActor = my3DActor; + break; + } + case eBareBorderVolume: + { + myFunctor.reset(new SMESH::Controls::BareBorderVolume()); + myControlActor = my3DActor; + break; + } + case eOverConstrainedVolume: + { + myFunctor.reset(new SMESH::Controls::OverConstrainedVolume()); myControlActor = my3DActor; break; } @@ -766,7 +868,7 @@ SetControlMode(eControl theMode, { SMESH::Controls::MinimumAngle* aControl = new SMESH::Controls::MinimumAngle(); aControl->SetPrecision( myControlsPrecision ); - aFunctor.reset( aControl ); + myFunctor.reset( aControl ); myControlActor = my2DActor; break; } @@ -774,7 +876,7 @@ SetControlMode(eControl theMode, { SMESH::Controls::Warping* aControl = new SMESH::Controls::Warping(); aControl->SetPrecision( myControlsPrecision ); - aFunctor.reset( aControl ); + myFunctor.reset( aControl ); myControlActor = my2DActor; break; } @@ -782,7 +884,7 @@ SetControlMode(eControl theMode, { SMESH::Controls::Skew* aControl = new SMESH::Controls::Skew(); aControl->SetPrecision( myControlsPrecision ); - aFunctor.reset( aControl ); + myFunctor.reset( aControl ); myControlActor = my2DActor; break; } @@ -796,45 +898,56 @@ SetControlMode(eControl theMode, myControlMode = theMode; switch(myControlMode){ case eFreeNodes: - myNodeExtActor->SetExtControlMode(aFunctor); - break; + myNodeExtActor->SetExtControlMode(myFunctor); + break; case eFreeEdges: case eFreeBorders: - my1DExtActor->SetExtControlMode(aFunctor); - break; + my1DExtActor->SetExtControlMode(myFunctor); + break; case eFreeFaces: - my2DExtActor->SetExtControlMode(aFunctor); - break; + case eBareBorderFace: + case eOverConstrainedFace: + my2DExtActor->SetExtControlMode(myFunctor); + break; + case eBareBorderVolume: + case eOverConstrainedVolume: + my3DExtActor->SetExtControlMode(myFunctor); + break; case eLength2D: case eMultiConnection2D: - my1DExtActor->SetExtControlMode(aFunctor,myScalarBarActor,myLookupTable); - break; + my1DExtActor->SetExtControlMode(myFunctor,myScalarBarActor,myLookupTable); + UpdateDistribution(); + break; default: - myControlActor->SetControlMode(aFunctor,myScalarBarActor,myLookupTable); + myControlActor->SetControlMode(myFunctor,myScalarBarActor,myLookupTable); + UpdateDistribution(); } } if(theCheckEntityMode){ if(myControlActor == my1DActor) - SetEntityMode(eEdges); + SetEntityMode(eEdges); else if(myControlActor == my2DActor){ - switch(myControlMode){ - case eLength2D: - case eFreeEdges: - case eFreeFaces: - case eMultiConnection2D: - //SetEntityMode(eEdges); - SetEntityMode(eFaces); - break; - default: - SetEntityMode(eFaces); - } + switch(myControlMode){ + case eLength2D: + case eFreeEdges: + case eFreeFaces: + case eMultiConnection2D: + //SetEntityMode(eEdges); + SetEntityMode(eFaces); + break; + default: + SetEntityMode(eFaces); + } }else if(myControlActor == my3DActor) - SetEntityMode(eVolumes); + SetEntityMode(eVolumes); } - }else if(theCheckEntityMode){ - myEntityMode = eAllEntity; + } + else { + if(theCheckEntityMode) + myEntityMode = eAllEntity; + myFunctor.reset(); } SetRepresentation(GetRepresentation()); @@ -845,14 +958,13 @@ SetControlMode(eControl theMode, void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){ - SALOME_Actor::AddToRender(theRenderer); - theRenderer->AddActor(myNodeActor); theRenderer->AddActor(myBaseActor); theRenderer->AddActor(myNodeExtActor); my3DActor->AddToRender(theRenderer); + my3DExtActor->AddToRender(theRenderer); my2DActor->AddToRender(theRenderer); my2DExtActor->AddToRender(theRenderer); @@ -871,6 +983,10 @@ void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){ theRenderer->AddActor2D(myPointLabels); theRenderer->AddActor2D(myCellsLabels); + + // the superclass' method should be called at the end + // (in particular, for correct work of selection) + SALOME_Actor::AddToRender(theRenderer); } void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer){ @@ -892,6 +1008,7 @@ void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer){ my2DActor->RemoveFromRender(theRenderer); my2DExtActor->RemoveFromRender(theRenderer); my3DActor->RemoveFromRender(theRenderer); + my3DExtActor->RemoveFromRender(theRenderer); theRenderer->RemoveActor(myScalarBarActor); theRenderer->RemoveActor(myPointLabels); @@ -900,9 +1017,9 @@ void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer){ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj, - const char* theEntry, - const char* theName, - int theIsClear) + const char* theEntry, + const char* theName, + int theIsClear) { Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry,"SMESH",theName); setIO(anIO); @@ -927,6 +1044,7 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj, my2DActor->Init(myVisualObj,myImplicitBoolean); my2DExtActor->Init(myVisualObj,myImplicitBoolean); my3DActor->Init(myVisualObj,myImplicitBoolean); + my3DExtActor->Init(myVisualObj,myImplicitBoolean); my0DActor->GetMapper()->SetLookupTable(myLookupTable); //my0DExtActor->GetMapper()->SetLookupTable(myLookupTable); @@ -937,6 +1055,7 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj, my2DActor->GetMapper()->SetLookupTable(myLookupTable); my2DExtActor->GetMapper()->SetLookupTable(myLookupTable); my3DActor->GetMapper()->SetLookupTable(myLookupTable); + my3DExtActor->GetMapper()->SetLookupTable(myLookupTable); vtkFloatingPointType aFactor, aUnits; my2DActor->GetPolygonOffsetParameters(aFactor,aUnits); @@ -970,6 +1089,10 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj, if( dynamic_cast( myVisualObj.get() ) ) SetIsDisplayNameActor( true ); + int aMarkerType = mgr->integerValue( "SMESH", "type_of_marker", 1 ); // dot + int aMarkerScale = mgr->integerValue( "SMESH", "marker_scale", 9 ); // 5 pixels + SetMarkerStd( (VTK::MarkerType)aMarkerType, (VTK::MarkerScale)aMarkerScale ); + myTimeStamp->Modified(); Modified(); return true; @@ -1005,6 +1128,7 @@ void SMESH_ActorDef::SetTransform(VTKViewer_Transform* theTransform){ my2DActor->SetTransform(theTransform); my2DExtActor->SetTransform(theTransform); my3DActor->SetTransform(theTransform); + my3DExtActor->SetTransform(theTransform); Modified(); } @@ -1034,8 +1158,8 @@ bool SMESH_ActorDef::IsInfinitive(){ vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid(); aDataSet->Update(); myIsInfinite = aDataSet->GetNumberOfCells() == 0 || - aDataSet->GetNumberOfCells() == 1 && - aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX; + ( aDataSet->GetNumberOfCells() == 1 && + aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX ); return SALOME_Actor::IsInfinitive(); } @@ -1060,6 +1184,7 @@ void SMESH_ActorDef::SetShrinkFactor(vtkFloatingPointType theValue){ my2DActor->SetShrinkFactor(theValue); my2DExtActor->SetShrinkFactor(theValue); my3DActor->SetShrinkFactor(theValue); + my3DExtActor->SetShrinkFactor(theValue); Modified(); } @@ -1075,6 +1200,7 @@ void SMESH_ActorDef::SetShrink(){ my2DActor->SetShrink(); my2DExtActor->SetShrink(); my3DActor->SetShrink(); + my3DExtActor->SetShrink(); myIsShrunk = true; Modified(); @@ -1091,6 +1217,7 @@ void SMESH_ActorDef::UnShrink(){ my2DActor->UnShrink(); my2DExtActor->UnShrink(); my3DActor->UnShrink(); + my3DExtActor->UnShrink(); myIsShrunk = false; Modified(); @@ -1137,6 +1264,7 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){ my2DActor->VisibilityOff(); my2DExtActor->VisibilityOff(); my3DActor->VisibilityOff(); + my3DExtActor->VisibilityOff(); myScalarBarActor->VisibilityOff(); myPointLabels->VisibilityOff(); @@ -1149,21 +1277,27 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){ if(myControlMode != eNone){ switch(myControlMode){ case eFreeNodes: - myNodeExtActor->VisibilityOn(); - break; + myNodeExtActor->VisibilityOn(); + break; case eFreeEdges: case eFreeBorders: - my1DExtActor->VisibilityOn(); - break; + my1DExtActor->VisibilityOn(); + break; case eFreeFaces: - my2DExtActor->VisibilityOn(); - break; + case eBareBorderFace: + case eOverConstrainedFace: + my2DExtActor->VisibilityOn(); + break; + case eBareBorderVolume: + case eOverConstrainedVolume: + my3DExtActor->VisibilityOn(); + break; case eLength2D: case eMultiConnection2D: - my1DExtActor->VisibilityOn(); + my1DExtActor->VisibilityOn(); default: - if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells()) - myScalarBarActor->VisibilityOn(); + if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells()) + myScalarBarActor->VisibilityOn(); } } @@ -1177,15 +1311,15 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){ my0DActor->VisibilityOn(); } - if(myEntityMode & eEdges){ + if(myEntityMode & eEdges && GetRepresentation() != ePoint){ my1DActor->VisibilityOn(); } - if(myEntityMode & eFaces){ + if(myEntityMode & eFaces && GetRepresentation() != ePoint){ my2DActor->VisibilityOn(); } - if(myEntityMode & eVolumes){ + if(myEntityMode & eVolumes && GetRepresentation() != ePoint){ my3DActor->VisibilityOn(); } @@ -1293,6 +1427,9 @@ void SMESH_ActorDef::SetEntityMode(unsigned int theMode) aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON); aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE); aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET); +//#ifdef VTK_HAVE_POLYHEDRON + aFilter->RegisterCellsWithType(VTK_POLYHEDRON); +//#endif aHightFilter->RegisterCellsWithType(VTK_TETRA); aHightFilter->RegisterCellsWithType(VTK_VOXEL); @@ -1302,7 +1439,11 @@ void SMESH_ActorDef::SetEntityMode(unsigned int theMode) aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA); aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON); aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE); + aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID); aHightFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET); +//#ifdef VTK_HAVE_POLYHEDRON + aHightFilter->RegisterCellsWithType(VTK_POLYHEDRON); +//#endif } aFilter->Update(); if (MYDEBUG) MESSAGE(aFilter->GetOutput()->GetNumberOfCells()); @@ -1389,6 +1530,7 @@ void SMESH_ActorDef::SetRepresentation (int theMode) //my0DExtActor->SetVisibility(false); my1DExtActor->SetVisibility(false); my2DExtActor->SetVisibility(false); + my3DExtActor->SetVisibility(false); // ??? //my0DActor->SetProperty(aProp); @@ -1458,14 +1600,20 @@ void SMESH_ActorDef::UpdateHighlight(){ myHighlitableActor->SetHighlited(anIsVisible); myHighlitableActor->SetVisibility(anIsVisible); myHighlitableActor->GetExtractUnstructuredGrid()-> - SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::eCells); + SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::eCells); myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe); }else if(myRepresentation == ePoint || GetPointRepresentation()){ myHighlitableActor->SetHighlited(anIsVisible); myHighlitableActor->GetExtractUnstructuredGrid()-> - SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints); + SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints); myHighlitableActor->SetVisibility(anIsVisible); myHighlitableActor->SetRepresentation(SMESH_DeviceActor::ePoint); + + VTK::MarkerType aMarkerType = GetMarkerType(); + if(aMarkerType != VTK::MT_USER) + myHighlitableActor->SetMarkerStd(aMarkerType, GetMarkerScale()); + else + myHighlitableActor->SetMarkerTexture(GetMarkerTexture(), myMarkerTexture); } } } @@ -1581,7 +1729,7 @@ void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType mySurfaceProp->SetColor(r,g,b); if( SMESH_GroupObj* aGroupObj = dynamic_cast( myVisualObj.get() ) ) if( aGroupObj->GetElementType() == SMDSAbs_Face || - aGroupObj->GetElementType() == SMDSAbs_Volume ) + aGroupObj->GetElementType() == SMDSAbs_Volume ) myNameActor->SetBackgroundColor(r,g,b); Modified(); } @@ -1627,6 +1775,18 @@ void SMESH_ActorDef::GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& ::GetColor(myNodeProp,r,g,b); } +void SMESH_ActorDef::Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ + my0DProp->SetColor(r,g,b); + if( SMESH_GroupObj* aGroupObj = dynamic_cast( myVisualObj.get() ) ) + if( aGroupObj->GetElementType() == SMDSAbs_0DElement ) + myNameActor->SetBackgroundColor(r,g,b); + Modified(); +} + +void SMESH_ActorDef::Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ + ::GetColor(my0DProp,r,g,b); +} + void SMESH_ActorDef::SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ myHighlightProp->SetColor(r,g,b); Modified(); @@ -1661,24 +1821,13 @@ void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){ } -void SMESH_ActorDef::SetNodeSize(vtkFloatingPointType theVal){ - myNodeProp->SetPointSize(theVal); - myNodeExtProp->SetPointSize(theVal); - - vtkFloatingPointType aPointSize = my0DProp->GetPointSize() > theVal ? my0DProp->GetPointSize() : theVal; - //myHighlightProp->SetPointSize(theVal); - myHighlightProp->SetPointSize(aPointSize); // ?? - //myPreselectProp->SetPointSize(theVal); - myPreselectProp->SetPointSize(aPointSize); // ?? - - my1DProp->SetPointSize(theVal + aPointSizeInc); - my1DExtProp->SetPointSize(theVal + aPointSizeInc); - +void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){ + my0DProp->SetPointSize(theVal); Modified(); } -vtkFloatingPointType SMESH_ActorDef::GetNodeSize(){ - return myNodeProp->GetPointSize(); +vtkFloatingPointType SMESH_ActorDef::Get0DSize(){ + return my0DProp->GetPointSize(); } int SMESH_ActorDef::GetObjDimension( const int theObjId ) @@ -1712,6 +1861,7 @@ SMESH_ActorDef::SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed) my2DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); my2DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); my3DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); + my3DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); } vtkIdType @@ -1752,92 +1902,6 @@ GetClippingPlane(vtkIdType theID) return myCippingPlaneCont[theID].Get(); } - -static void ComputeBoundsParam(vtkDataSet* theDataSet, - vtkFloatingPointType theDirection[3], vtkFloatingPointType theMinPnt[3], - vtkFloatingPointType& theMaxBoundPrj, vtkFloatingPointType& theMinBoundPrj) -{ - vtkFloatingPointType aBounds[6]; - theDataSet->GetBounds(aBounds); - - //Enlarge bounds in order to avoid conflicts of precision - for(int i = 0; i < 6; i += 2){ - static double EPS = 1.0E-3; - vtkFloatingPointType aDelta = (aBounds[i+1] - aBounds[i])*EPS; - aBounds[i] -= aDelta; - aBounds[i+1] += aDelta; - } - - vtkFloatingPointType aBoundPoints[8][3] = { {aBounds[0],aBounds[2],aBounds[4]}, - {aBounds[1],aBounds[2],aBounds[4]}, - {aBounds[0],aBounds[3],aBounds[4]}, - {aBounds[1],aBounds[3],aBounds[4]}, - {aBounds[0],aBounds[2],aBounds[5]}, - {aBounds[1],aBounds[2],aBounds[5]}, - {aBounds[0],aBounds[3],aBounds[5]}, - {aBounds[1],aBounds[3],aBounds[5]}}; - - int aMaxId = 0, aMinId = aMaxId; - theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]); - theMinBoundPrj = theMaxBoundPrj; - for(int i = 1; i < 8; i++){ - vtkFloatingPointType aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]); - if(theMaxBoundPrj < aTmp){ - theMaxBoundPrj = aTmp; - aMaxId = i; - } - if(theMinBoundPrj > aTmp){ - theMinBoundPrj = aTmp; - aMinId = i; - } - } - vtkFloatingPointType *aMinPnt = aBoundPoints[aMaxId]; - theMinPnt[0] = aMinPnt[0]; - theMinPnt[1] = aMinPnt[1]; - theMinPnt[2] = aMinPnt[2]; -} - - -static void DistanceToPosition(vtkDataSet* theDataSet, - vtkFloatingPointType theDirection[3], vtkFloatingPointType theDist, vtkFloatingPointType thePos[3]) -{ - vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; - ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); - vtkFloatingPointType aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist; - thePos[0] = aMinPnt[0]-theDirection[0]*aLength; - thePos[1] = aMinPnt[1]-theDirection[1]*aLength; - thePos[2] = aMinPnt[2]-theDirection[2]*aLength; -} - - -static void PositionToDistance(vtkDataSet* theDataSet, - vtkFloatingPointType theDirection[3], vtkFloatingPointType thePos[3], vtkFloatingPointType& theDist) -{ - vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; - ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); - vtkFloatingPointType aPrj = vtkMath::Dot(theDirection,thePos); - theDist = (aPrj-aMinBoundPrj)/(aMaxBoundPrj-aMinBoundPrj); -} - - -void SMESH_ActorDef::SetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType theDist, vtkPlane* thePlane) -{ - thePlane->SetNormal(theDir); - vtkFloatingPointType anOrigin[3]; - ::DistanceToPosition(GetUnstructuredGrid(),theDir,theDist,anOrigin); - thePlane->SetOrigin(anOrigin); -} - - -void SMESH_ActorDef::GetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType& theDist, vtkPlane* thePlane) -{ - thePlane->GetNormal(theDir); - - vtkFloatingPointType anOrigin[3]; - thePlane->GetOrigin(anOrigin); - ::PositionToDistance(GetUnstructuredGrid(),theDir,anOrigin,theDist); -} - void SMESH_ActorDef::UpdateScalarBar() { SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); @@ -1951,9 +2015,45 @@ void SMESH_ActorDef::UpdateScalarBar() if( mgr->hasValue( "SMESH", "scalar_bar_num_colors" ) ) anIntVal = mgr->integerValue( "SMESH", "scalar_bar_num_colors", anIntVal ); myScalarBarActor->SetMaximumNumberOfColors( anIntVal == 0 ? 64 : anIntVal ); + + bool distributionVisibility = mgr->booleanValue("SMESH","distribution_visibility"); + myScalarBarActor->SetDistributionVisibility(distributionVisibility); + + int coloringType = mgr->integerValue("SMESH", "distribution_coloring_type", 0); + myScalarBarActor->SetDistributionColoringType(coloringType); + + QColor distributionColor = mgr->colorValue("SMESH", "distribution_color", + QColor(255, 255, 255)); + double rgb[3]; + rgb[0]= distributionColor.red()/255.; + rgb[1]= distributionColor.green()/255.; + rgb[2]= distributionColor.blue()/255.; + myScalarBarActor->SetDistributionColor(rgb); + } +void SMESH_ActorDef::UpdateDistribution() +{ + if(SMESH::Controls::NumericalFunctor* fun = + dynamic_cast(myFunctor.get())) + { + int nbIntervals = myScalarBarActor->GetMaximumNumberOfColors(); + std::vector nbEvents; + std::vector funValues; + SMESH_VisualObjDef::TEntityList elems; + if ( ! dynamic_cast(myVisualObj.get())) + dynamic_cast(myVisualObj.get())->GetEntities( fun->GetType(), elems ); + std::vector elemIds; + for ( SMESH_VisualObjDef::TEntityList::iterator e = elems.begin(); e != elems.end(); ++e) + elemIds.push_back( (*e)->GetID()); + vtkLookupTable* lookupTable = static_cast(myScalarBarActor->GetLookupTable()); + double * range = lookupTable->GetRange(); + fun->GetHistogram(nbIntervals, nbEvents, funValues, elemIds, range); + myScalarBarActor->SetDistribution(nbEvents); + } +} + void SMESH_ActorDef::SetQuadratic2DRepresentation(EQuadratic2DRepresentation theMode) { switch(theMode) { @@ -1982,3 +2082,18 @@ SMESH_Actor::EQuadratic2DRepresentation SMESH_ActorDef::GetQuadratic2DRepresenta else return SMESH_Actor::eLines; } + +void SMESH_ActorDef::SetMarkerStd( VTK::MarkerType theMarkerType, VTK::MarkerScale theMarkerScale ) +{ + SALOME_Actor::SetMarkerStd( theMarkerType, theMarkerScale ); + myNodeActor->SetMarkerStd( theMarkerType, theMarkerScale ); + myNodeExtActor->SetMarkerStd( theMarkerType, theMarkerScale ); +} + +void SMESH_ActorDef::SetMarkerTexture( int theMarkerId, VTK::MarkerTexture theMarkerTexture ) +{ + SALOME_Actor::SetMarkerTexture( theMarkerId, theMarkerTexture ); + myNodeActor->SetMarkerTexture( theMarkerId, theMarkerTexture ); + myNodeExtActor->SetMarkerTexture( theMarkerId, theMarkerTexture ); + myMarkerTexture = theMarkerTexture; // for deferred update of myHighlightActor +}