X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FOBJECT%2FSMESH_Actor.cxx;h=16d71448f669a6831d419a478516cd8f938a56e3;hb=7ca0689d938aee0f059ecdb6ec7dc9b8f33dcf6e;hp=49d838bac3d47d7efb04ad0f9d7404b28692f3af;hpb=0635c9fc80f67d1e5dc0e94ec85f487286a92070;p=modules%2Fsmesh.git diff --git a/src/OBJECT/SMESH_Actor.cxx b/src/OBJECT/SMESH_Actor.cxx index 49d838bac..16d71448f 100644 --- a/src/OBJECT/SMESH_Actor.cxx +++ b/src/OBJECT/SMESH_Actor.cxx @@ -28,8 +28,10 @@ #include "SMESH_ActorDef.h" #include "SMESH_ActorUtils.h" #include "SMESH_DeviceActor.h" +#include "SMESH_ObjectDef.h" #include "SMESH_ControlsDef.hxx" #include "VTKViewer_ExtractUnstructuredGrid.h" +#include "VTKViewer_FramedTextActor.h" #include "SALOME_InteractiveObject.hxx" #include "SUIT_Session.h" @@ -70,6 +72,11 @@ #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_ @@ -88,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)){ @@ -118,17 +125,18 @@ SMESH_ActorDef::SMESH_ActorDef() myControlsPrecision = -1; SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); - + if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) ) myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1); - vtkFloatingPointType aPointSize = SMESH::GetFloat("SMESH:node_size",3); - vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",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); vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New(); VTKViewer_ExtractUnstructuredGrid* aFilter = NULL; - //Definition 2D and 3D divices of the actor + //Definition 2D and 3D devices of the actor //----------------------------------------- vtkFloatingPointType anRGB[3] = {1,1,1}; mySurfaceProp = vtkProperty::New(); @@ -192,7 +200,7 @@ SMESH_ActorDef::SMESH_ActorDef() aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE); aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET); - //Definition 1D divice of the actor + //Definition 1D device of the actor //--------------------------------- myEdgeProp = vtkProperty::New(); myEdgeProp->SetAmbient(1.0); @@ -240,8 +248,49 @@ SMESH_ActorDef::SMESH_ActorDef() aFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE); - //Definition 0D divice of the actor - //--------------------------------- + //Definition 0D device of the actor (0d elements) + //----------------------------------------------- + my0DProp = vtkProperty::New(); + SMESH::GetColor( "SMESH", "elem0d_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 0 ) ); + my0DProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); + my0DProp->SetPointSize(aElem0DSize); + + my0DActor = SMESH_DeviceActor::New(); + my0DActor->SetUserMatrix(aMatrix); + my0DActor->SetStoreClippingMapping(true); + my0DActor->PickableOff(); + my0DActor->SetVisibility(false); + my0DActor->SetProperty(my0DProp); + my0DActor->SetRepresentation(SMESH_DeviceActor::eSurface); + aFilter = my0DActor->GetExtractUnstructuredGrid(); + //aFilter->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints); + aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding); + aFilter->RegisterCellsWithType(VTK_VERTEX); + + //my0DExtProp = vtkProperty::New(); + //my0DExtProp->DeepCopy(my0DProp); + //anRGB[0] = 1 - anRGB[0]; + //anRGB[1] = 1 - anRGB[1]; + //anRGB[2] = 1 - anRGB[2]; + //my0DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); + //my0DExtProp->SetPointSize(aElem0DSize); + // + //my0DExtActor = SMESH_DeviceActor::New(); + //my0DExtActor->SetUserMatrix(aMatrix); + //my0DExtActor->SetStoreClippingMapping(true); + //my0DExtActor->PickableOff(); + //my0DExtActor->SetHighlited(true); + //my0DExtActor->SetVisibility(false); + //my0DExtActor->SetProperty(my0DExtProp); + //my0DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe); + //aFilter = my0DExtActor->GetExtractUnstructuredGrid(); + ////aFilter->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints); + //aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding); + //aFilter->RegisterCellsWithType(VTK_VERTEX); + + + //Definition 0D device of the actor (nodes) + //----------------------------------------- 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]); @@ -286,23 +335,25 @@ SMESH_ActorDef::SMESH_ActorDef() myBaseActor->GetProperty()->SetOpacity(0.0); myPickableActor = myBaseActor; - + myHighlightProp = vtkProperty::New(); myHighlightProp->SetAmbient(1.0); myHighlightProp->SetDiffuse(0.0); 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(aPointSize); + myHighlightProp->SetPointSize(std::max(aElem0DSize,aPointSize)); // ?? myHighlightProp->SetRepresentation(1); - + myPreselectProp = vtkProperty::New(); myPreselectProp->SetAmbient(1.0); myPreselectProp->SetDiffuse(0.0); 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(aPointSize); + myPreselectProp->SetPointSize(std::max(aElem0DSize,aPointSize)); // ?? myPreselectProp->SetRepresentation(1); myHighlitableActor = SMESH_DeviceActor::New(); @@ -310,6 +361,8 @@ SMESH_ActorDef::SMESH_ActorDef() myHighlitableActor->PickableOff(); myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe); + aMatrix->Delete(); + myName = ""; myIO = NULL; @@ -351,7 +404,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(); @@ -392,7 +447,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(); @@ -415,6 +472,30 @@ SMESH_ActorDef::SMESH_ActorDef() // Clipping planes myImplicitBoolean = vtkImplicitBoolean::New(); myImplicitBoolean->SetOperationTypeToIntersection(); + + + + //Quadratic 2D elements representation + //----------------------------------------------------------------------------- + int aQuadratic2DMode = mgr->integerValue( "SMESH", "quadratic_mode", 0); + if(aQuadratic2DMode == 0){ + myHighlitableActor->SetQuadraticArcMode(false); + my2DActor->SetQuadraticArcMode(false); + my1DActor->SetQuadraticArcMode(false); + } + else if(aQuadratic2DMode == 1){ + myHighlitableActor->SetQuadraticArcMode(true); + my2DActor->SetQuadraticArcMode(true); + my1DActor->SetQuadraticArcMode(true); + } + + int aQuadraticAngle = mgr->integerValue( "SMESH", "max_angle", 2); + myHighlitableActor->SetQuadraticArcAngle(aQuadraticAngle); + my2DActor->SetQuadraticArcAngle(aQuadraticAngle); + + // Set color 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]); } @@ -435,6 +516,12 @@ SMESH_ActorDef::~SMESH_ActorDef() myNodeProp->Delete(); myNodeExtProp->Delete(); + my0DProp->Delete(); + my0DActor->Delete(); + + //my0DExtProp->Delete(); + //my0DExtActor->Delete(); + my1DProp->Delete(); my1DActor->Delete(); @@ -453,7 +540,7 @@ SMESH_ActorDef::~SMESH_ActorDef() myHighlitableActor->Delete(); - //Deleting of pints numbering pipeline + //Deleting of points numbering pipeline //--------------------------------------- myPointsNumDataSet->Delete(); @@ -500,8 +587,9 @@ SMESH_ActorDef::~SMESH_ActorDef() void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled ) -{ +{ vtkUnstructuredGrid* aGrid = GetUnstructuredGrid(); + myIsPointsLabeled = theIsPointsLabeled && aGrid->GetNumberOfPoints(); if ( myIsPointsLabeled ) @@ -514,7 +602,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 ); @@ -573,6 +661,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:: @@ -585,7 +706,7 @@ SetControlMode(eControl theMode) void SMESH_ActorDef:: SetControlMode(eControl theMode, - bool theCheckEntityMode) + bool theCheckEntityMode) { SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); if( !mgr ) @@ -594,6 +715,7 @@ SetControlMode(eControl theMode, myControlMode = eNone; theCheckEntityMode &= mgr->booleanValue( "SMESH", "display_entity", false ); + my0DActor->GetMapper()->SetScalarVisibility(false); my1DActor->GetMapper()->SetScalarVisibility(false); my2DActor->GetMapper()->SetScalarVisibility(false); my3DActor->GetMapper()->SetScalarVisibility(false); @@ -716,41 +838,41 @@ SetControlMode(eControl theMode, myControlMode = theMode; switch(myControlMode){ case eFreeNodes: - myNodeExtActor->SetExtControlMode(aFunctor); - break; + myNodeExtActor->SetExtControlMode(aFunctor); + break; case eFreeEdges: case eFreeBorders: - my1DExtActor->SetExtControlMode(aFunctor); - break; + my1DExtActor->SetExtControlMode(aFunctor); + break; case eFreeFaces: - my2DExtActor->SetExtControlMode(aFunctor); - break; + my2DExtActor->SetExtControlMode(aFunctor); + break; case eLength2D: case eMultiConnection2D: - my1DExtActor->SetExtControlMode(aFunctor,myScalarBarActor,myLookupTable); - break; + my1DExtActor->SetExtControlMode(aFunctor,myScalarBarActor,myLookupTable); + break; default: - myControlActor->SetControlMode(aFunctor,myScalarBarActor,myLookupTable); + myControlActor->SetControlMode(aFunctor,myScalarBarActor,myLookupTable); } } 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){ @@ -779,6 +901,9 @@ void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){ theRenderer->AddActor(my1DActor); theRenderer->AddActor(my1DExtActor); + theRenderer->AddActor(my0DActor); + //theRenderer->AddActor(my0DExtActor); + theRenderer->AddActor(myHighlitableActor); theRenderer->AddActor2D(myScalarBarActor); @@ -800,6 +925,9 @@ void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer){ theRenderer->RemoveActor(myHighlitableActor); + theRenderer->RemoveActor(my0DActor); + //theRenderer->RemoveActor(my0DExtActor); + theRenderer->RemoveActor(my1DActor); theRenderer->RemoveActor(my1DExtActor); @@ -814,9 +942,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); @@ -832,6 +960,9 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj, myNodeExtActor->Init(myVisualObj,myImplicitBoolean); + my0DActor->Init(myVisualObj,myImplicitBoolean); + //my0DExtActor->Init(myVisualObj,myImplicitBoolean); + my1DActor->Init(myVisualObj,myImplicitBoolean); my1DExtActor->Init(myVisualObj,myImplicitBoolean); @@ -839,6 +970,9 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj, my2DExtActor->Init(myVisualObj,myImplicitBoolean); my3DActor->Init(myVisualObj,myImplicitBoolean); + my0DActor->GetMapper()->SetLookupTable(myLookupTable); + //my0DExtActor->GetMapper()->SetLookupTable(myLookupTable); + my1DActor->GetMapper()->SetLookupTable(myLookupTable); my1DExtActor->GetMapper()->SetLookupTable(myLookupTable); @@ -875,6 +1009,9 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj, SetShrink(); } + if( dynamic_cast( myVisualObj.get() ) ) + SetIsDisplayNameActor( true ); + myTimeStamp->Modified(); Modified(); return true; @@ -901,6 +1038,9 @@ void SMESH_ActorDef::SetTransform(VTKViewer_Transform* theTransform){ myNodeExtActor->SetTransform(theTransform); + my0DActor->SetTransform(theTransform); + //my0DExtActor->SetTransform(theTransform); + my1DActor->SetTransform(theTransform); my1DExtActor->SetTransform(theTransform); @@ -936,8 +1076,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(); } @@ -1030,6 +1170,9 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){ myNodeExtActor->VisibilityOff(); + my0DActor->VisibilityOff(); + //my0DExtActor->VisibilityOff(); + my1DActor->VisibilityOff(); my1DExtActor->VisibilityOff(); @@ -1048,21 +1191,21 @@ 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; + my2DExtActor->VisibilityOn(); + break; case eLength2D: case eMultiConnection2D: - my1DExtActor->VisibilityOn(); + my1DExtActor->VisibilityOn(); default: - if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells()) - myScalarBarActor->VisibilityOn(); + if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells()) + myScalarBarActor->VisibilityOn(); } } @@ -1072,6 +1215,10 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){ myNodeActor->VisibilityOn(); } + if(myEntityMode & e0DElements){ + my0DActor->VisibilityOn(); + } + if(myEntityMode & eEdges){ my1DActor->VisibilityOn(); } @@ -1097,25 +1244,34 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){ } -void SMESH_ActorDef::SetEntityMode(unsigned int theMode){ +void SMESH_ActorDef::SetEntityMode(unsigned int theMode) +{ myEntityState = eAllEntity; - if(!myVisualObj->GetNbEntities(SMDSAbs_Edge)){ + if(!myVisualObj->GetNbEntities(SMDSAbs_0DElement)) { + myEntityState &= ~e0DElements; + theMode &= ~e0DElements; + } + + if(!myVisualObj->GetNbEntities(SMDSAbs_Edge)) { myEntityState &= ~eEdges; theMode &= ~eEdges; } - if(!myVisualObj->GetNbEntities(SMDSAbs_Face)){ + if(!myVisualObj->GetNbEntities(SMDSAbs_Face)) { myEntityState &= ~eFaces; theMode &= ~eFaces; } - if(!myVisualObj->GetNbEntities(SMDSAbs_Volume)){ + if(!myVisualObj->GetNbEntities(SMDSAbs_Volume)) { myEntityState &= ~eVolumes; theMode &= ~eVolumes; } - if(!theMode){ + if (!theMode) { + if(myVisualObj->GetNbEntities(SMDSAbs_0DElement)) + theMode |= e0DElements; + if(myVisualObj->GetNbEntities(SMDSAbs_Edge)) theMode |= eEdges; @@ -1133,23 +1289,42 @@ void SMESH_ActorDef::SetEntityMode(unsigned int theMode){ aFilter = myBaseActor->GetExtractUnstructuredGrid(); aFilter->ClearRegisteredCellsWithType(); aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding); - - if(myEntityMode & eEdges){ + + VTKViewer_ExtractUnstructuredGrid* aHightFilter = myHighlitableActor->GetExtractUnstructuredGrid(); + aHightFilter->ClearRegisteredCellsWithType(); + aHightFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding); + + if (myEntityMode & e0DElements) { + if (MYDEBUG) MESSAGE("0D ELEMENTS"); + aFilter->RegisterCellsWithType(VTK_VERTEX); + aHightFilter->RegisterCellsWithType(VTK_VERTEX); + } + + if (myEntityMode & eEdges) { if (MYDEBUG) MESSAGE("EDGES"); aFilter->RegisterCellsWithType(VTK_LINE); aFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE); + + aHightFilter->RegisterCellsWithType(VTK_LINE); + aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE); } - if(myEntityMode & eFaces){ + if (myEntityMode & eFaces) { if (MYDEBUG) MESSAGE("FACES"); aFilter->RegisterCellsWithType(VTK_TRIANGLE); aFilter->RegisterCellsWithType(VTK_POLYGON); aFilter->RegisterCellsWithType(VTK_QUAD); aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE); aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD); + + aHightFilter->RegisterCellsWithType(VTK_TRIANGLE); + aHightFilter->RegisterCellsWithType(VTK_POLYGON); + aHightFilter->RegisterCellsWithType(VTK_QUAD); + aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE); + aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD); } - if(myEntityMode & eVolumes){ + if (myEntityMode & eVolumes) { if (MYDEBUG) MESSAGE("VOLUMES"); aFilter->RegisterCellsWithType(VTK_TETRA); aFilter->RegisterCellsWithType(VTK_VOXEL); @@ -1160,43 +1335,55 @@ void SMESH_ActorDef::SetEntityMode(unsigned int theMode){ aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON); aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE); aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET); + + aHightFilter->RegisterCellsWithType(VTK_TETRA); + aHightFilter->RegisterCellsWithType(VTK_VOXEL); + aHightFilter->RegisterCellsWithType(VTK_HEXAHEDRON); + aHightFilter->RegisterCellsWithType(VTK_WEDGE); + aHightFilter->RegisterCellsWithType(VTK_PYRAMID); + aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA); + aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON); + aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE); + aHightFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET); } aFilter->Update(); if (MYDEBUG) MESSAGE(aFilter->GetOutput()->GetNumberOfCells()); SetVisibility(GetVisibility(),false); } -void SMESH_ActorDef::SetRepresentation(int theMode){ +void SMESH_ActorDef::SetRepresentation (int theMode) +{ int aNbEdges = myVisualObj->GetNbEntities(SMDSAbs_Edge); int aNbFaces = myVisualObj->GetNbEntities(SMDSAbs_Face); int aNbVolumes = myVisualObj->GetNbEntities(SMDSAbs_Volume); - if(theMode < 0){ + + if (theMode < 0) { myRepresentation = eSurface; - if(!aNbFaces && !aNbVolumes && aNbEdges){ + if (!aNbFaces && !aNbVolumes && aNbEdges) { myRepresentation = eEdge; - }else if(!aNbFaces && !aNbVolumes && !aNbEdges){ + } else if (!aNbFaces && !aNbVolumes && !aNbEdges) { myRepresentation = ePoint; } - }else{ - switch(theMode){ + } else { + switch (theMode) { case eEdge: - if(!aNbFaces && !aNbVolumes && !aNbEdges) return; + if (!aNbFaces && !aNbVolumes && !aNbEdges) return; break; case eSurface: - if(!aNbFaces && !aNbVolumes) return; + if (!aNbFaces && !aNbVolumes) return; break; } myRepresentation = theMode; } - if(!GetUnstructuredGrid()->GetNumberOfCells()) + if (!GetUnstructuredGrid()->GetNumberOfCells()) myRepresentation = ePoint; - if(myIsShrunk){ - if(myRepresentation == ePoint){ + if (myIsShrunk) { + if (myRepresentation == ePoint) { UnShrink(); myIsShrunk = true; - }else{ + } else { SetShrink(); } } @@ -1206,11 +1393,12 @@ void SMESH_ActorDef::SetRepresentation(int theMode){ myNodeExtActor->SetVisibility(false); vtkProperty *aProp = NULL, *aBackProp = NULL; SMESH_DeviceActor::EReperesent aReperesent = SMESH_DeviceActor::EReperesent(-1); - switch(myRepresentation){ + SMESH_Actor::EQuadratic2DRepresentation aQuadraticMode = GetQuadratic2DRepresentation(); + switch (myRepresentation) { case ePoint: myPickableActor = myNodeActor; myNodeActor->SetVisibility(true); - + aQuadraticMode = SMESH_Actor::eLines; aProp = aBackProp = myNodeProp; aReperesent = SMESH_DeviceActor::ePoint; break; @@ -1223,21 +1411,33 @@ void SMESH_ActorDef::SetRepresentation(int theMode){ aBackProp = myBackSurfaceProp; aReperesent = SMESH_DeviceActor::eSurface; break; - } + } my2DActor->SetProperty(aProp); my2DActor->SetBackfaceProperty(aBackProp); my2DActor->SetRepresentation(aReperesent); + if(aQuadraticMode == SMESH_Actor::eLines) + my2DActor->SetQuadraticArcMode(false); + else if(aQuadraticMode == SMESH_Actor::eArcs) + my2DActor->SetQuadraticArcMode(true); + my2DExtActor->SetRepresentation(aReperesent); my3DActor->SetProperty(aProp); my3DActor->SetBackfaceProperty(aBackProp); my3DActor->SetRepresentation(aReperesent); + //my0DExtActor->SetVisibility(false); my1DExtActor->SetVisibility(false); my2DExtActor->SetVisibility(false); + // ??? + //my0DActor->SetProperty(aProp); + //my0DActor->SetBackfaceProperty(aBackProp); + my0DActor->SetRepresentation(aReperesent); + //my0DExtActor->SetRepresentation(aReperesent); + switch(myControlMode){ case eLength: case eMultiConnection: @@ -1247,12 +1447,17 @@ void SMESH_ActorDef::SetRepresentation(int theMode){ break; } + if(aQuadraticMode == SMESH_Actor::eLines) + my1DActor->SetQuadraticArcMode(false); + else if(aQuadraticMode == SMESH_Actor::eArcs) + my1DActor->SetQuadraticArcMode(true); + my1DActor->SetProperty(aProp); my1DActor->SetBackfaceProperty(aBackProp); my1DActor->SetRepresentation(aReperesent); my1DExtActor->SetRepresentation(aReperesent); - + if(myIsPointsVisible) myPickableActor = myNodeActor; if(GetPointRepresentation()) @@ -1295,12 +1500,12 @@ 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); } @@ -1416,6 +1621,10 @@ vtkFloatingPointType SMESH_ActorDef::GetOpacity(){ void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ mySurfaceProp->SetColor(r,g,b); + if( SMESH_GroupObj* aGroupObj = dynamic_cast( myVisualObj.get() ) ) + if( aGroupObj->GetElementType() == SMDSAbs_Face || + aGroupObj->GetElementType() == SMDSAbs_Volume ) + myNameActor->SetBackgroundColor(r,g,b); Modified(); } @@ -1437,6 +1646,9 @@ void SMESH_ActorDef::SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g, myEdgeProp->SetColor(r,g,b); my1DProp->SetColor(r,g,b); my1DExtProp->SetColor(1.0-r,1.0-g,1.0-b); + if( SMESH_GroupObj* aGroupObj = dynamic_cast( myVisualObj.get() ) ) + if( aGroupObj->GetElementType() == SMDSAbs_Edge ) + myNameActor->SetBackgroundColor(r,g,b); Modified(); } @@ -1447,6 +1659,9 @@ void SMESH_ActorDef::GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& void SMESH_ActorDef::SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ myNodeProp->SetColor(r,g,b); myNodeExtProp->SetColor(1.0-r,1.0-g,1.0-b); + if( SMESH_GroupObj* aGroupObj = dynamic_cast( myVisualObj.get() ) ) + if( aGroupObj->GetElementType() == SMDSAbs_Node ) + myNameActor->SetBackgroundColor(r,g,b); Modified(); } @@ -1454,6 +1669,15 @@ 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); + 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(); @@ -1491,8 +1715,12 @@ void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){ void SMESH_ActorDef::SetNodeSize(vtkFloatingPointType theVal){ myNodeProp->SetPointSize(theVal); myNodeExtProp->SetPointSize(theVal); - myHighlightProp->SetPointSize(theVal); - myPreselectProp->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); @@ -1504,6 +1732,22 @@ vtkFloatingPointType SMESH_ActorDef::GetNodeSize(){ return myNodeProp->GetPointSize(); } +void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){ + my0DProp->SetPointSize(theVal); + + vtkFloatingPointType aPointSize = myNodeProp->GetPointSize() > theVal ? myNodeProp->GetPointSize() : theVal; + //myHighlightProp->SetPointSize(theVal); + myHighlightProp->SetPointSize(aPointSize); // ?? + //myPreselectProp->SetPointSize(theVal); + myPreselectProp->SetPointSize(aPointSize); // ?? + + Modified(); +} + +vtkFloatingPointType SMESH_ActorDef::Get0DSize(){ + return my0DProp->GetPointSize(); +} + int SMESH_ActorDef::GetObjDimension( const int theObjId ) { return myVisualObj->GetElemDimension( theObjId ); @@ -1517,27 +1761,28 @@ IsImplicitFunctionUsed() const } void -SMESH_ActorDef:: -SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed) +SMESH_ActorDef::SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed) { myNodeActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); myBaseActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); - + myHighlitableActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); myNodeExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); - + + my0DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); + //my0DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); + my1DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); my1DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); - + my2DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); my2DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); my3DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed); } vtkIdType -SMESH_ActorDef:: -AddClippingPlane(vtkPlane* thePlane) +SMESH_ActorDef::AddClippingPlane(vtkPlane* thePlane) { if(thePlane){ myImplicitBoolean->GetFunction()->AddItem(thePlane); @@ -1576,8 +1821,8 @@ GetClippingPlane(vtkIdType theID) static void ComputeBoundsParam(vtkDataSet* theDataSet, - vtkFloatingPointType theDirection[3], vtkFloatingPointType theMinPnt[3], - vtkFloatingPointType& theMaxBoundPrj, vtkFloatingPointType& theMinBoundPrj) + vtkFloatingPointType theDirection[3], vtkFloatingPointType theMinPnt[3], + vtkFloatingPointType& theMaxBoundPrj, vtkFloatingPointType& theMinBoundPrj) { vtkFloatingPointType aBounds[6]; theDataSet->GetBounds(aBounds); @@ -1591,13 +1836,13 @@ static void ComputeBoundsParam(vtkDataSet* theDataSet, } 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]}}; + {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]); @@ -1621,7 +1866,7 @@ static void ComputeBoundsParam(vtkDataSet* theDataSet, static void DistanceToPosition(vtkDataSet* theDataSet, - vtkFloatingPointType theDirection[3], vtkFloatingPointType theDist, vtkFloatingPointType thePos[3]) + vtkFloatingPointType theDirection[3], vtkFloatingPointType theDist, vtkFloatingPointType thePos[3]) { vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); @@ -1633,7 +1878,7 @@ static void DistanceToPosition(vtkDataSet* theDataSet, static void PositionToDistance(vtkDataSet* theDataSet, - vtkFloatingPointType theDirection[3], vtkFloatingPointType thePos[3], vtkFloatingPointType& theDist) + vtkFloatingPointType theDirection[3], vtkFloatingPointType thePos[3], vtkFloatingPointType& theDist) { vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); @@ -1775,3 +2020,32 @@ void SMESH_ActorDef::UpdateScalarBar() myScalarBarActor->SetMaximumNumberOfColors( anIntVal == 0 ? 64 : anIntVal ); } + +void SMESH_ActorDef::SetQuadratic2DRepresentation(EQuadratic2DRepresentation theMode) +{ + switch(theMode) { + case SMESH_Actor::eLines : + myHighlitableActor->SetQuadraticArcMode(false); + my2DActor->SetQuadraticArcMode(false); + my1DActor->SetQuadraticArcMode(false); + break; + case SMESH_Actor::eArcs : + myHighlitableActor->SetQuadraticArcMode(true); + if(GetRepresentation() != SMESH_Actor::ePoint) { + my2DActor->SetQuadraticArcMode(true); + my1DActor->SetQuadraticArcMode(true); + } + break; + default: + break; + } +} + + +SMESH_Actor::EQuadratic2DRepresentation SMESH_ActorDef::GetQuadratic2DRepresentation() +{ + if(myHighlitableActor->GetQuadraticArcMode()) + return SMESH_Actor::eArcs; + else + return SMESH_Actor::eLines; +}