X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FOBJECT%2FSMESH_Actor.cxx;h=7805e50bbab33fcabf6464126cab4865edfe567d;hb=refs%2Ftags%2FV5_1_3rc3;hp=a9877109f7895952d34e856bb6a4aec1ad606aa0;hpb=59f97a60c591ba0125c2e0590767e6aadd3160ee;p=modules%2Fsmesh.git diff --git a/src/OBJECT/SMESH_Actor.cxx b/src/OBJECT/SMESH_Actor.cxx index a9877109f..7805e50bb 100644 --- a/src/OBJECT/SMESH_Actor.cxx +++ b/src/OBJECT/SMESH_Actor.cxx @@ -1,43 +1,43 @@ -// SMESH OBJECT : interactive object for SMESH visualization +// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // +// SMESH OBJECT : interactive object for SMESH visualization // File : SMESH_Actor.cxx // Author : Nicolas REJNERI // Module : SMESH -// $Header$ #include "SMESH_ActorDef.h" #include "SMESH_ActorUtils.h" #include "SMESH_DeviceActor.h" +#include "SMESH_ObjectDef.h" #include "SMESH_ControlsDef.hxx" -#include +#include "VTKViewer_ExtractUnstructuredGrid.h" +#include "VTKViewer_FramedTextActor.h" +#include "SALOME_InteractiveObject.hxx" #include "SUIT_Session.h" #include "SUIT_ResourceMgr.h" -#include - +#include #include #include #include @@ -90,15 +90,17 @@ 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)){ anActor->Delete(); anActor = NULL; } + if( anActor ) + anActor->UpdateScalarBar(); return anActor; } @@ -114,17 +116,24 @@ SMESH_ActorDef::SMESH_ActorDef() myIsShrinkable = false; myIsShrunk = false; - myControlsPrecision = (long)SMESH::GetFloat( "SMESH:controls_precision", -1 ); + myIsFacesOriented = false; + + myControlsPrecision = -1; + SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); + + if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) ) + myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1); - float aPointSize = SMESH::GetFloat("SMESH:node_size",3); - float 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 //----------------------------------------- - float anRGB[3] = {1,1,1}; + vtkFloatingPointType anRGB[3] = {1,1,1}; mySurfaceProp = vtkProperty::New(); SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); mySurfaceProp->SetColor( anRGB[0], anRGB[1], anRGB[2] ); @@ -144,6 +153,29 @@ SMESH_ActorDef::SMESH_ActorDef() aFilter->RegisterCellsWithType(VTK_TRIANGLE); aFilter->RegisterCellsWithType(VTK_POLYGON); aFilter->RegisterCellsWithType(VTK_QUAD); + aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE); + aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD); + + my2DExtProp = vtkProperty::New(); + my2DExtProp->DeepCopy(mySurfaceProp); + SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); + anRGB[0] = 1 - anRGB[0]; + anRGB[1] = 1 - anRGB[1]; + anRGB[2] = 1 - anRGB[2]; + my2DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); + + my2DExtActor = SMESH_DeviceActor::New(); + my2DExtActor->SetUserMatrix(aMatrix); + my2DExtActor->PickableOff(); + my2DExtActor->SetProperty(my2DExtProp); + my2DExtActor->SetBackfaceProperty(my2DExtProp); + my2DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe); + aFilter = my2DExtActor->GetExtractUnstructuredGrid(); + aFilter->RegisterCellsWithType(VTK_TRIANGLE); + aFilter->RegisterCellsWithType(VTK_POLYGON); + aFilter->RegisterCellsWithType(VTK_QUAD); + aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE); + aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD); my3DActor = SMESH_DeviceActor::New(); my3DActor->SetUserMatrix(aMatrix); @@ -158,9 +190,12 @@ SMESH_ActorDef::SMESH_ActorDef() 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_CONVEX_POINT_SET); - //Definition 1D divice of the actor + //Definition 1D device of the actor //--------------------------------- myEdgeProp = vtkProperty::New(); myEdgeProp->SetAmbient(1.0); @@ -179,12 +214,13 @@ SMESH_ActorDef::SMESH_ActorDef() aFilter = my1DActor->GetExtractUnstructuredGrid(); aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding); aFilter->RegisterCellsWithType(VTK_LINE); + aFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE); my1DProp = vtkProperty::New(); my1DProp->DeepCopy(myEdgeProp); my1DProp->SetLineWidth(aLineWidth + aLineWidthInc); my1DProp->SetPointSize(aPointSize); - + my1DExtProp = vtkProperty::New(); my1DExtProp->DeepCopy(myEdgeProp); anRGB[0] = 1 - anRGB[0]; @@ -204,10 +240,52 @@ SMESH_ActorDef::SMESH_ActorDef() aFilter = my1DExtActor->GetExtractUnstructuredGrid(); aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding); aFilter->RegisterCellsWithType(VTK_LINE); - - - //Definition 0D divice of the actor - //--------------------------------- + aFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE); + + + //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]); @@ -222,7 +300,26 @@ SMESH_ActorDef::SMESH_ActorDef() myNodeActor->SetRepresentation(SMESH_DeviceActor::ePoint); aFilter = myNodeActor->GetExtractUnstructuredGrid(); aFilter->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints); - + + myNodeExtProp = vtkProperty::New(); + myNodeExtProp->DeepCopy(myNodeProp); + anRGB[0] = 1 - anRGB[0]; + 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); + myNodeExtActor->SetStoreClippingMapping(true); + myNodeExtActor->PickableOff(); + myNodeExtActor->SetHighlited(true); + myNodeExtActor->SetVisibility(false); + myNodeExtActor->SetProperty(myNodeExtProp); + myNodeExtActor->SetRepresentation(SMESH_DeviceActor::ePoint); + aFilter = myNodeExtActor->GetExtractUnstructuredGrid(); + aFilter->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints); + aFilter->RegisterCellsWithType(VTK_VERTEX); //Definition of Pickable and Highlitable engines //---------------------------------------------- @@ -233,23 +330,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(); @@ -257,7 +356,7 @@ SMESH_ActorDef::SMESH_ActorDef() myHighlitableActor->PickableOff(); myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe); - SetShrinkFactor( SMESH::GetFloat( "SMESH", "shrink_coeff", 0.75 ) ); + aMatrix->Delete(); myName = ""; myIO = NULL; @@ -276,119 +375,15 @@ SMESH_ActorDef::SMESH_ActorDef() myScalarBarActor->SetVisibility(false); myScalarBarActor->SetLookupTable(myLookupTable); - vtkTextProperty* aScalarBarTitleProp = vtkTextProperty::New(); + //Fix for Bug 13314: + //Incorrect "Min value" in Scalar Bar in Mesh: + // myScalarBarActor->SetLabelFormat("%.4g"); + // changes was commented because of regression bug IPAL 19981 - SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); + mgr = SUIT_Session::session()->resourceMgr(); if( !mgr ) return; - QColor aTColor = mgr->colorValue( "SMESH", "scalar_bar_title_color", QColor( 255, 255, 255 ) ); - aScalarBarTitleProp->SetColor( aTColor.red()/255., aTColor.green()/255., aTColor.blue()/255. ); - - aScalarBarTitleProp->SetFontFamilyToArial(); - - if ( mgr->hasValue( "SMESH", "scalar_bar_title_font" ) ) - { - QFont f = mgr->fontValue( "SMESH", "scalar_bar_title_font" ); - if ( f.family() == "Arial" ) - aScalarBarTitleProp->SetFontFamilyToArial(); - else if ( f.family() == "Courier" ) - aScalarBarTitleProp->SetFontFamilyToCourier(); - else if ( f.family() == "Times" ) - aScalarBarTitleProp->SetFontFamilyToTimes(); - - if ( f.bold() ) - aScalarBarTitleProp->BoldOn(); - else - aScalarBarTitleProp->BoldOff(); - - if ( f.italic() ) - aScalarBarTitleProp->ItalicOn(); - else - aScalarBarTitleProp->ItalicOff(); - - if ( f.underline() ) - aScalarBarTitleProp->ShadowOn(); - else - aScalarBarTitleProp->ShadowOff(); - } - - myScalarBarActor->SetTitleTextProperty( aScalarBarTitleProp ); - aScalarBarTitleProp->Delete(); - - vtkTextProperty* aScalarBarLabelProp = vtkTextProperty::New(); - - aTColor = mgr->colorValue( "SMESH", "scalar_bar_label_color", QColor( 255, 255, 255 ) ); - aScalarBarLabelProp->SetColor( aTColor.red()/255., aTColor.green()/255., aTColor.blue()/255. ); - - aScalarBarLabelProp->SetFontFamilyToArial(); - if( mgr->hasValue( "SMESH", "scalar_bar_label_font" ) ) - { - QFont f = mgr->stringValue( "SMESH", "scalar_bar_label_font" ); - if( f.family() == "Arial" ) - aScalarBarLabelProp->SetFontFamilyToArial(); - else if( f.family() == "Courier" ) - aScalarBarLabelProp->SetFontFamilyToCourier(); - else if( f.family() == "Times" ) - aScalarBarLabelProp->SetFontFamilyToTimes(); - - if ( f.bold() ) - aScalarBarLabelProp->BoldOn(); - else - aScalarBarLabelProp->BoldOff(); - - if ( f.italic() ) - aScalarBarLabelProp->ItalicOn(); - else - aScalarBarLabelProp->ItalicOff(); - - if( f.underline() ) - aScalarBarLabelProp->ShadowOn(); - else - aScalarBarLabelProp->ShadowOff(); - } - - myScalarBarActor->SetLabelTextProperty( aScalarBarLabelProp ); - aScalarBarLabelProp->Delete(); - - bool horiz = ( mgr->integerValue( "SMESH", "scalar_bar_orientation" ) == 1 ); - QString name = QString( "scalar_bar_%1_" ).arg( horiz ? "horizontal" : "vertical" ); - if( horiz ) - myScalarBarActor->SetOrientationToHorizontal(); - else - myScalarBarActor->SetOrientationToVertical(); - - - float aXVal = horiz ? 0.20 : 0.01; - if( mgr->hasValue( "SMESH", name + "x" ) ) - aXVal = mgr->doubleValue( "SMESH", name + "x", aXVal ); - - float aYVal = horiz ? 0.01 : 0.1; - if( mgr->hasValue( "SMESH", name + "y" ) ) - aYVal = mgr->doubleValue( "SMESH", name + "y", aYVal ); - myScalarBarActor->SetPosition( aXVal, aYVal ); - - float aWVal = horiz ? 0.60 : 0.10; - if( mgr->hasValue( "SMESH", name + "width" ) ) - aWVal = mgr->doubleValue( "SMESH", name + "width", aWVal ); - myScalarBarActor->SetWidth( aWVal ); - - float aHVal = horiz ? 0.12 : 0.80; - if( mgr->hasValue( "SMESH", name + "height" ) ) - aHVal = mgr->doubleValue( "SMESH", name + "height", aHVal ); - myScalarBarActor->SetHeight( aHVal ); - - int anIntVal = 5; - if( mgr->hasValue( "SMESH", "scalar_bar_num_labels" ) ) - anIntVal = mgr->integerValue( "SMESH", "scalar_bar_num_labels", anIntVal ); - myScalarBarActor->SetNumberOfLabels( anIntVal == 0 ? 5: anIntVal ); - - anIntVal = 64; - if( mgr->hasValue( "SMESH", "scalar_bar_num_colors" ) ) - anIntVal = mgr->integerValue( "SMESH", "scalar_bar_num_colors", anIntVal ); - myScalarBarActor->SetMaximumNumberOfColors( anIntVal == 0 ? 64 : anIntVal ); - - //Definition of points numbering pipeline //--------------------------------------- myPointsNumDataSet = vtkUnstructuredGrid::New(); @@ -404,7 +399,7 @@ SMESH_ActorDef::SMESH_ActorDef() myPtsLabeledDataMapper = vtkLabeledDataMapper::New(); myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput()); - myPtsLabeledDataMapper->SetLabelFormat("%g"); + myPtsLabeledDataMapper->SetLabelFormat("%u"); myPtsLabeledDataMapper->SetLabelModeToLabelScalars(); vtkTextProperty* aPtsTextProp = vtkTextProperty::New(); @@ -445,7 +440,7 @@ SMESH_ActorDef::SMESH_ActorDef() myClsLabeledDataMapper = vtkLabeledDataMapper::New(); myClsLabeledDataMapper->SetInput(myClsSelectVisiblePoints->GetOutput()); - myClsLabeledDataMapper->SetLabelFormat("%g"); + myClsLabeledDataMapper->SetLabelFormat("%u"); myClsLabeledDataMapper->SetLabelModeToLabelScalars(); vtkTextProperty* aClsTextProp = vtkTextProperty::New(); @@ -468,6 +463,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]); } @@ -486,7 +505,14 @@ SMESH_ActorDef::~SMESH_ActorDef() myPreselectProp->Delete(); myNodeProp->Delete(); + myNodeExtProp->Delete(); + + my0DProp->Delete(); + my0DActor->Delete(); + //my0DExtProp->Delete(); + //my0DExtActor->Delete(); + my1DProp->Delete(); my1DActor->Delete(); @@ -494,24 +520,31 @@ SMESH_ActorDef::~SMESH_ActorDef() my1DExtActor->Delete(); my2DActor->Delete(); + my2DExtProp->Delete(); + my2DExtActor->Delete(); my3DActor->Delete(); myNodeActor->Delete(); myBaseActor->Delete(); + myNodeExtActor->Delete(); + myHighlitableActor->Delete(); - //Deleting of pints numbering pipeline + //Deleting of points numbering pipeline //--------------------------------------- myPointsNumDataSet->Delete(); - myPtsLabeledDataMapper->RemoveAllInputs(); + // commented: porting to vtk 5.0 + // myPtsLabeledDataMapper->RemoveAllInputs(); myPtsLabeledDataMapper->Delete(); - myPtsSelectVisiblePoints->UnRegisterAllOutputs(); + // commented: porting to vtk 5.0 + // myPtsSelectVisiblePoints->UnRegisterAllOutputs(); myPtsSelectVisiblePoints->Delete(); - myPtsMaskPoints->UnRegisterAllOutputs(); + // commented: porting to vtk 5.0 + // myPtsMaskPoints->UnRegisterAllOutputs(); myPtsMaskPoints->Delete(); myPointLabels->Delete(); @@ -524,13 +557,16 @@ SMESH_ActorDef::~SMESH_ActorDef() myClsLabeledDataMapper->RemoveAllInputs(); myClsLabeledDataMapper->Delete(); - myClsSelectVisiblePoints->UnRegisterAllOutputs(); + // commented: porting to vtk 5.0 + // myClsSelectVisiblePoints->UnRegisterAllOutputs(); myClsSelectVisiblePoints->Delete(); - myClsMaskPoints->UnRegisterAllOutputs(); + // commented: porting to vtk 5.0 + // myClsMaskPoints->UnRegisterAllOutputs(); myClsMaskPoints->Delete(); - myCellCenters->UnRegisterAllOutputs(); + // commented: porting to vtk 5.0 + // myCellCenters->UnRegisterAllOutputs(); myCellCenters->Delete(); myCellsLabels->Delete(); @@ -542,8 +578,9 @@ SMESH_ActorDef::~SMESH_ActorDef() void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled ) -{ +{ vtkUnstructuredGrid* aGrid = GetUnstructuredGrid(); + myIsPointsLabeled = theIsPointsLabeled && aGrid->GetNumberOfPoints(); if ( myIsPointsLabeled ) @@ -556,7 +593,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 ); @@ -600,6 +637,22 @@ void SMESH_ActorDef::SetCellsLabeled(bool theIsCellsLabeled) } +void SMESH_ActorDef::SetFacesOriented(bool theIsFacesOriented) +{ + myIsFacesOriented = theIsFacesOriented; + + my2DActor->SetFacesOriented(theIsFacesOriented); + my3DActor->SetFacesOriented(theIsFacesOriented); + + myTimeStamp->Modified(); +} + +bool SMESH_ActorDef::GetFacesOriented() +{ + return myIsFacesOriented; +} + + void SMESH_ActorDef:: SetControlMode(eControl theMode) @@ -611,7 +664,7 @@ SetControlMode(eControl theMode) void SMESH_ActorDef:: SetControlMode(eControl theMode, - bool theCheckEntityMode) + bool theCheckEntityMode) { SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); if( !mgr ) @@ -620,6 +673,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); @@ -652,6 +706,14 @@ SetControlMode(eControl theMode, aFunctor.reset(new SMESH::Controls::FreeEdges()); myControlActor = my2DActor; break; + case eFreeNodes: + aFunctor.reset(new SMESH::Controls::FreeNodes()); + myControlActor = myNodeActor; + break; + case eFreeFaces: + aFunctor.reset(new SMESH::Controls::FreeFaces()); + myControlActor = my2DActor; + break; case eMultiConnection: aFunctor.reset(new SMESH::Controls::MultiConnection()); myControlActor = my1DActor; @@ -692,6 +754,14 @@ SetControlMode(eControl theMode, myControlActor = my3DActor; break; } + case eVolume3D: + { + SMESH::Controls::Volume* aControl = new SMESH::Controls::Volume(); + aControl->SetPrecision( myControlsPrecision ); + aFunctor.reset( aControl ); + myControlActor = my3DActor; + break; + } case eMinimumAngle: { SMESH::Controls::MinimumAngle* aControl = new SMESH::Controls::MinimumAngle(); @@ -725,35 +795,42 @@ SetControlMode(eControl theMode, if(aNbCells){ myControlMode = theMode; switch(myControlMode){ + case eFreeNodes: + myNodeExtActor->SetExtControlMode(aFunctor); + break; case eFreeEdges: case eFreeBorders: - my1DExtActor->SetExtControlMode(aFunctor); - break; + my1DExtActor->SetExtControlMode(aFunctor); + break; + case eFreeFaces: + 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 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){ @@ -772,15 +849,21 @@ void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){ theRenderer->AddActor(myNodeActor); theRenderer->AddActor(myBaseActor); + + theRenderer->AddActor(myNodeExtActor); - theRenderer->AddActor(my3DActor); - theRenderer->AddActor(my2DActor); + my3DActor->AddToRender(theRenderer); + my2DActor->AddToRender(theRenderer); + my2DExtActor->AddToRender(theRenderer); theRenderer->AddActor(my1DActor); theRenderer->AddActor(my1DExtActor); - theRenderer->AddActor(myHighlitableActor); + theRenderer->AddActor(my0DActor); + //theRenderer->AddActor(my0DExtActor); + theRenderer->AddActor(myHighlitableActor); + theRenderer->AddActor2D(myScalarBarActor); myPtsSelectVisiblePoints->SetRenderer(theRenderer); @@ -796,13 +879,19 @@ void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer){ theRenderer->RemoveActor(myNodeActor); theRenderer->RemoveActor(myBaseActor); + theRenderer->RemoveActor(myNodeExtActor); + theRenderer->RemoveActor(myHighlitableActor); + theRenderer->RemoveActor(my0DActor); + //theRenderer->RemoveActor(my0DExtActor); + theRenderer->RemoveActor(my1DActor); theRenderer->RemoveActor(my1DExtActor); - theRenderer->RemoveActor(my2DActor); - theRenderer->RemoveActor(my3DActor); + my2DActor->RemoveFromRender(theRenderer); + my2DExtActor->RemoveFromRender(theRenderer); + my3DActor->RemoveFromRender(theRenderer); theRenderer->RemoveActor(myScalarBarActor); theRenderer->RemoveActor(myPointLabels); @@ -811,9 +900,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); @@ -824,55 +913,70 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj, myNodeActor->Init(myVisualObj,myImplicitBoolean); myBaseActor->Init(myVisualObj,myImplicitBoolean); - + myHighlitableActor->Init(myVisualObj,myImplicitBoolean); + + myNodeExtActor->Init(myVisualObj,myImplicitBoolean); + + my0DActor->Init(myVisualObj,myImplicitBoolean); + //my0DExtActor->Init(myVisualObj,myImplicitBoolean); my1DActor->Init(myVisualObj,myImplicitBoolean); my1DExtActor->Init(myVisualObj,myImplicitBoolean); my2DActor->Init(myVisualObj,myImplicitBoolean); + my2DExtActor->Init(myVisualObj,myImplicitBoolean); my3DActor->Init(myVisualObj,myImplicitBoolean); + my0DActor->GetMapper()->SetLookupTable(myLookupTable); + //my0DExtActor->GetMapper()->SetLookupTable(myLookupTable); + my1DActor->GetMapper()->SetLookupTable(myLookupTable); my1DExtActor->GetMapper()->SetLookupTable(myLookupTable); my2DActor->GetMapper()->SetLookupTable(myLookupTable); + my2DExtActor->GetMapper()->SetLookupTable(myLookupTable); my3DActor->GetMapper()->SetLookupTable(myLookupTable); - float aFactor, aUnits; + vtkFloatingPointType aFactor, aUnits; my2DActor->GetPolygonOffsetParameters(aFactor,aUnits); my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75); - - //SetIsShrunkable(theGrid->GetNumberOfCells() > 10); - SetIsShrunkable(true); + my2DExtActor->SetPolygonOffsetParameters(aFactor,aUnits*0.5); SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); if( !mgr ) return false; - QString aMode = mgr->stringValue( "DisplayMode", "SMESH" ); + //SetIsShrunkable(theGrid->GetNumberOfCells() > 10); + SetIsShrunkable(true); + + SetShrinkFactor( SMESH::GetFloat( "SMESH:shrink_coeff", 75 ) / 100. ); + + int aMode = mgr->integerValue( "SMESH", "display_mode" ); SetRepresentation(-1); - if(aMode.compare("Wireframe") == 0){ + if(aMode == 0){ SetRepresentation(eEdge); - }else if(aMode.compare("Shading") == 0){ + }else if(aMode == 1){ SetRepresentation(eSurface); - }else if(aMode.compare("Nodes") == 0){ + }else if(aMode == 2){ SetRepresentation(ePoint); } - aMode = mgr->stringValue( "Shrink", "SMESH" ); - if(aMode == "yes"){ + if(aMode == 3){ SetShrink(); } + if( dynamic_cast( myVisualObj.get() ) ) + SetIsDisplayNameActor( true ); + myTimeStamp->Modified(); Modified(); return true; } -float* SMESH_ActorDef::GetBounds(){ +vtkFloatingPointType* SMESH_ActorDef::GetBounds(){ return myNodeActor->GetBounds(); } @@ -883,15 +987,23 @@ vtkDataSet* SMESH_ActorDef::GetInput(){ void SMESH_ActorDef::SetTransform(VTKViewer_Transform* theTransform){ + Superclass::SetTransform(theTransform); + myNodeActor->SetTransform(theTransform); myBaseActor->SetTransform(theTransform); - + myHighlitableActor->SetTransform(theTransform); + myNodeExtActor->SetTransform(theTransform); + + my0DActor->SetTransform(theTransform); + //my0DExtActor->SetTransform(theTransform); + my1DActor->SetTransform(theTransform); my1DExtActor->SetTransform(theTransform); my2DActor->SetTransform(theTransform); + my2DExtActor->SetTransform(theTransform); my3DActor->SetTransform(theTransform); Modified(); @@ -922,28 +1034,31 @@ 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(); } void SMESH_ActorDef::SetIsShrunkable(bool theShrunkable){ + if ( myIsShrinkable == theShrunkable ) + return; myIsShrinkable = theShrunkable; Modified(); } -float SMESH_ActorDef::GetShrinkFactor(){ +vtkFloatingPointType SMESH_ActorDef::GetShrinkFactor(){ return myBaseActor->GetShrinkFactor(); } -void SMESH_ActorDef::SetShrinkFactor(float theValue){ +void SMESH_ActorDef::SetShrinkFactor(vtkFloatingPointType theValue){ myBaseActor->SetShrinkFactor(theValue); my1DActor->SetShrinkFactor(theValue); my1DExtActor->SetShrinkFactor(theValue); my2DActor->SetShrinkFactor(theValue); + my2DExtActor->SetShrinkFactor(theValue); my3DActor->SetShrinkFactor(theValue); Modified(); @@ -958,6 +1073,7 @@ void SMESH_ActorDef::SetShrink(){ my1DExtActor->SetShrink(); my2DActor->SetShrink(); + my2DExtActor->SetShrink(); my3DActor->SetShrink(); myIsShrunk = true; @@ -973,6 +1089,7 @@ void SMESH_ActorDef::UnShrink(){ my1DExtActor->UnShrink(); my2DActor->UnShrink(); + my2DExtActor->UnShrink(); my3DActor->UnShrink(); myIsShrunk = false; @@ -984,7 +1101,7 @@ int SMESH_ActorDef::GetNodeObjId(int theVtkID){ return myPickableActor->GetNodeObjId(theVtkID); } -float* SMESH_ActorDef::GetNodeCoord(int theObjID){ +vtkFloatingPointType* SMESH_ActorDef::GetNodeCoord(int theObjID){ return myPickableActor->GetNodeCoord(theObjID); } @@ -1009,10 +1126,16 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){ myNodeActor->VisibilityOff(); myBaseActor->VisibilityOff(); + myNodeExtActor->VisibilityOff(); + + my0DActor->VisibilityOff(); + //my0DExtActor->VisibilityOff(); + my1DActor->VisibilityOff(); my1DExtActor->VisibilityOff(); my2DActor->VisibilityOff(); + my2DExtActor->VisibilityOff(); my3DActor->VisibilityOff(); myScalarBarActor->VisibilityOff(); @@ -1022,19 +1145,25 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){ if(GetVisibility()){ if(theIsUpdateRepersentation) SetRepresentation(GetRepresentation()); - + if(myControlMode != eNone){ switch(myControlMode){ + case eFreeNodes: + myNodeExtActor->VisibilityOn(); + break; case eFreeEdges: case eFreeBorders: - my1DExtActor->VisibilityOn(); - break; + my1DExtActor->VisibilityOn(); + break; + case eFreeFaces: + my2DExtActor->VisibilityOn(); + break; case eLength2D: case eMultiConnection2D: - my1DExtActor->VisibilityOn(); + my1DExtActor->VisibilityOn(); default: - if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells()) - myScalarBarActor->VisibilityOn(); + if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells()) + myScalarBarActor->VisibilityOn(); } } @@ -1044,6 +1173,10 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){ myNodeActor->VisibilityOn(); } + if(myEntityMode & e0DElements){ + my0DActor->VisibilityOn(); + } + if(myEntityMode & eEdges){ my1DActor->VisibilityOn(); } @@ -1064,30 +1197,39 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){ if(myIsCellsLabeled) myCellsLabels->VisibilityOn(); } - + UpdateHighlight(); Modified(); } -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; @@ -1105,77 +1247,120 @@ 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(); + + // The following row has been commented (initially added in 1.28.2.3.1 revision) + // Reason: seems to be unnecessary, this filter should always have default (ePassAll) mode of changing + // In addition, it leads to exception (see bug IPAL21372) + //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); 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_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(); } } myPickableActor = myBaseActor; myNodeActor->SetVisibility(false); + 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; @@ -1188,17 +1373,32 @@ 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: @@ -1209,12 +1409,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()) @@ -1229,6 +1434,8 @@ void SMESH_ActorDef::SetRepresentation(int theMode){ void SMESH_ActorDef::SetPointRepresentation(bool theIsPointsVisible){ + if ( myIsPointsVisible == theIsPointsVisible ) + return; myIsPointsVisible = theIsPointsVisible; SetRepresentation(GetRepresentation()); } @@ -1255,13 +1462,13 @@ 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->SetVisibility(anIsVisible); myHighlitableActor->GetExtractUnstructuredGrid()-> - SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints); + SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints); + myHighlitableActor->SetVisibility(anIsVisible); myHighlitableActor->SetRepresentation(SMESH_DeviceActor::ePoint); } } @@ -1269,12 +1476,16 @@ void SMESH_ActorDef::UpdateHighlight(){ void SMESH_ActorDef::highlight(bool theHighlight){ + if ( myIsHighlighted == theHighlight ) + return; myIsHighlighted = theHighlight; UpdateHighlight(); } void SMESH_ActorDef::SetPreSelected(bool thePreselect){ + if ( myIsPreselected == thePreselect ) + return; myIsPreselected = thePreselect; UpdateHighlight(); } @@ -1329,6 +1540,9 @@ void SMESH_ActorDef::Update(){ if(myIsCellsLabeled){ SetCellsLabeled(myIsCellsLabeled); } + if(myIsFacesOriented){ + SetFacesOriented(myIsFacesOriented); + } SetEntityMode(GetEntityMode()); SetVisibility(GetVisibility()); @@ -1344,15 +1558,15 @@ void SMESH_ActorDef::ReleaseGraphicsResources(vtkWindow *renWin){ } -static void GetColor(vtkProperty *theProperty, float& r,float& g,float& b){ - float* aColor = theProperty->GetColor(); +static void GetColor(vtkProperty *theProperty, vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ + vtkFloatingPointType* aColor = theProperty->GetColor(); r = aColor[0]; g = aColor[1]; b = aColor[2]; } -void SMESH_ActorDef::SetOpacity(float theValue){ +void SMESH_ActorDef::SetOpacity(vtkFloatingPointType theValue){ mySurfaceProp->SetOpacity(theValue); myBackSurfaceProp->SetOpacity(theValue); myEdgeProp->SetOpacity(theValue); @@ -1362,74 +1576,86 @@ void SMESH_ActorDef::SetOpacity(float theValue){ } -float SMESH_ActorDef::GetOpacity(){ +vtkFloatingPointType SMESH_ActorDef::GetOpacity(){ return mySurfaceProp->GetOpacity(); } -void SMESH_ActorDef::SetSufaceColor(float r,float g,float b){ +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(); } -void SMESH_ActorDef::GetSufaceColor(float& r,float& g,float& b){ +void SMESH_ActorDef::GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ ::GetColor(mySurfaceProp,r,g,b); + my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b); } -void SMESH_ActorDef::SetBackSufaceColor(float r,float g,float b){ +void SMESH_ActorDef::SetBackSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ myBackSurfaceProp->SetColor(r,g,b); Modified(); } -void SMESH_ActorDef::GetBackSufaceColor(float& r,float& g,float& b){ +void SMESH_ActorDef::GetBackSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ ::GetColor(myBackSurfaceProp,r,g,b); } -void SMESH_ActorDef::SetEdgeColor(float r,float g,float b){ +void SMESH_ActorDef::SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ 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(); } -void SMESH_ActorDef::GetEdgeColor(float& r,float& g,float& b){ +void SMESH_ActorDef::GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ ::GetColor(myEdgeProp,r,g,b); } -void SMESH_ActorDef::SetNodeColor(float r,float g,float b){ +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(); } -void SMESH_ActorDef::GetNodeColor(float& r,float& g,float& b){ +void SMESH_ActorDef::GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ ::GetColor(myNodeProp,r,g,b); } -void SMESH_ActorDef::SetHighlightColor(float r,float g,float b){ +void SMESH_ActorDef::SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ myHighlightProp->SetColor(r,g,b); Modified(); } -void SMESH_ActorDef::GetHighlightColor(float& r,float& g,float& b){ +void SMESH_ActorDef::GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ ::GetColor(myHighlightProp,r,g,b); } -void SMESH_ActorDef::SetPreHighlightColor(float r,float g,float b){ +void SMESH_ActorDef::SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ myPreselectProp->SetColor(r,g,b); Modified(); } -void SMESH_ActorDef::GetPreHighlightColor(float& r,float& g,float& b){ +void SMESH_ActorDef::GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ ::GetColor(myPreselectProp,r,g,b); } -float SMESH_ActorDef::GetLineWidth(){ +vtkFloatingPointType SMESH_ActorDef::GetLineWidth(){ return myEdgeProp->GetLineWidth(); } -void SMESH_ActorDef::SetLineWidth(float theVal){ +void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){ myEdgeProp->SetLineWidth(theVal); my1DProp->SetLineWidth(theVal + aLineWidthInc); @@ -1439,10 +1665,15 @@ void SMESH_ActorDef::SetLineWidth(float theVal){ } -void SMESH_ActorDef::SetNodeSize(float theVal){ +void SMESH_ActorDef::SetNodeSize(vtkFloatingPointType theVal){ myNodeProp->SetPointSize(theVal); - myHighlightProp->SetPointSize(theVal); - myPreselectProp->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); @@ -1450,7 +1681,7 @@ void SMESH_ActorDef::SetNodeSize(float theVal){ Modified(); } -float SMESH_ActorDef::GetNodeSize(){ +vtkFloatingPointType SMESH_ActorDef::GetNodeSize(){ return myNodeProp->GetPointSize(); } @@ -1467,24 +1698,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); @@ -1523,34 +1758,34 @@ GetClippingPlane(vtkIdType theID) static void ComputeBoundsParam(vtkDataSet* theDataSet, - float theDirection[3], float theMinPnt[3], - float& theMaxBoundPrj, float& theMinBoundPrj) + vtkFloatingPointType theDirection[3], vtkFloatingPointType theMinPnt[3], + vtkFloatingPointType& theMaxBoundPrj, vtkFloatingPointType& theMinBoundPrj) { - float aBounds[6]; + 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; - float aDelta = (aBounds[i+1] - aBounds[i])*EPS; + vtkFloatingPointType aDelta = (aBounds[i+1] - aBounds[i])*EPS; aBounds[i] -= aDelta; aBounds[i+1] += aDelta; } - float 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]}}; + 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++){ - float aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]); + vtkFloatingPointType aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]); if(theMaxBoundPrj < aTmp){ theMaxBoundPrj = aTmp; aMaxId = i; @@ -1560,7 +1795,7 @@ static void ComputeBoundsParam(vtkDataSet* theDataSet, aMinId = i; } } - float *aMinPnt = aBoundPoints[aMaxId]; + vtkFloatingPointType *aMinPnt = aBoundPoints[aMaxId]; theMinPnt[0] = aMinPnt[0]; theMinPnt[1] = aMinPnt[1]; theMinPnt[2] = aMinPnt[2]; @@ -1568,11 +1803,11 @@ static void ComputeBoundsParam(vtkDataSet* theDataSet, static void DistanceToPosition(vtkDataSet* theDataSet, - float theDirection[3], float theDist, float thePos[3]) + vtkFloatingPointType theDirection[3], vtkFloatingPointType theDist, vtkFloatingPointType thePos[3]) { - float aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; + vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); - float aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist; + 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; @@ -1580,29 +1815,174 @@ static void DistanceToPosition(vtkDataSet* theDataSet, static void PositionToDistance(vtkDataSet* theDataSet, - float theDirection[3], float thePos[3], float& theDist) + vtkFloatingPointType theDirection[3], vtkFloatingPointType thePos[3], vtkFloatingPointType& theDist) { - float aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; + vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); - float aPrj = vtkMath::Dot(theDirection,thePos); + vtkFloatingPointType aPrj = vtkMath::Dot(theDirection,thePos); theDist = (aPrj-aMinBoundPrj)/(aMaxBoundPrj-aMinBoundPrj); } -void SMESH_ActorDef::SetPlaneParam(float theDir[3], float theDist, vtkPlane* thePlane) +void SMESH_ActorDef::SetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType theDist, vtkPlane* thePlane) { thePlane->SetNormal(theDir); - float anOrigin[3]; + vtkFloatingPointType anOrigin[3]; ::DistanceToPosition(GetUnstructuredGrid(),theDir,theDist,anOrigin); thePlane->SetOrigin(anOrigin); } -void SMESH_ActorDef::GetPlaneParam(float theDir[3], float& theDist, vtkPlane* thePlane) +void SMESH_ActorDef::GetPlaneParam(vtkFloatingPointType theDir[3], vtkFloatingPointType& theDist, vtkPlane* thePlane) { thePlane->GetNormal(theDir); - float anOrigin[3]; + vtkFloatingPointType anOrigin[3]; thePlane->GetOrigin(anOrigin); ::PositionToDistance(GetUnstructuredGrid(),theDir,anOrigin,theDist); } + +void SMESH_ActorDef::UpdateScalarBar() +{ + SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); + if( !mgr ) + return; + + vtkTextProperty* aScalarBarTitleProp = vtkTextProperty::New(); + + QColor aTColor = mgr->colorValue( "SMESH", "scalar_bar_title_color", QColor( 255, 255, 255 ) ); + aScalarBarTitleProp->SetColor( aTColor.red()/255., aTColor.green()/255., aTColor.blue()/255. ); + + aScalarBarTitleProp->SetFontFamilyToArial(); + + if ( mgr->hasValue( "SMESH", "scalar_bar_title_font" ) ) + { + QFont f = mgr->fontValue( "SMESH", "scalar_bar_title_font" ); + if ( f.family() == "Arial" ) + aScalarBarTitleProp->SetFontFamilyToArial(); + else if ( f.family() == "Courier" ) + aScalarBarTitleProp->SetFontFamilyToCourier(); + else if ( f.family() == "Times" ) + aScalarBarTitleProp->SetFontFamilyToTimes(); + + if ( f.bold() ) + aScalarBarTitleProp->BoldOn(); + else + aScalarBarTitleProp->BoldOff(); + + if ( f.italic() ) + aScalarBarTitleProp->ItalicOn(); + else + aScalarBarTitleProp->ItalicOff(); + + if ( f.overline() ) + aScalarBarTitleProp->ShadowOn(); + else + aScalarBarTitleProp->ShadowOff(); + } + + myScalarBarActor->SetTitleTextProperty( aScalarBarTitleProp ); + aScalarBarTitleProp->Delete(); + + vtkTextProperty* aScalarBarLabelProp = vtkTextProperty::New(); + + aTColor = mgr->colorValue( "SMESH", "scalar_bar_label_color", QColor( 255, 255, 255 ) ); + aScalarBarLabelProp->SetColor( aTColor.red()/255., aTColor.green()/255., aTColor.blue()/255. ); + + aScalarBarLabelProp->SetFontFamilyToArial(); + if( mgr->hasValue( "SMESH", "scalar_bar_label_font" ) ) + { + QFont f = mgr->fontValue( "SMESH", "scalar_bar_label_font" ); + if( f.family() == "Arial" ) + aScalarBarLabelProp->SetFontFamilyToArial(); + else if( f.family() == "Courier" ) + aScalarBarLabelProp->SetFontFamilyToCourier(); + else if( f.family() == "Times" ) + aScalarBarLabelProp->SetFontFamilyToTimes(); + + if ( f.bold() ) + aScalarBarLabelProp->BoldOn(); + else + aScalarBarLabelProp->BoldOff(); + + if ( f.italic() ) + aScalarBarLabelProp->ItalicOn(); + else + aScalarBarLabelProp->ItalicOff(); + + if( f.overline() ) + aScalarBarLabelProp->ShadowOn(); + else + aScalarBarLabelProp->ShadowOff(); + } + + myScalarBarActor->SetLabelTextProperty( aScalarBarLabelProp ); + aScalarBarLabelProp->Delete(); + + bool horiz = ( mgr->integerValue( "SMESH", "scalar_bar_orientation" ) == 1 ); + QString name = QString( "scalar_bar_%1_" ).arg( horiz ? "horizontal" : "vertical" ); + if( horiz ) + myScalarBarActor->SetOrientationToHorizontal(); + else + myScalarBarActor->SetOrientationToVertical(); + + + vtkFloatingPointType aXVal = horiz ? 0.20 : 0.01; + if( mgr->hasValue( "SMESH", name + "x" ) ) + aXVal = mgr->doubleValue( "SMESH", name + "x", aXVal ); + + vtkFloatingPointType aYVal = horiz ? 0.01 : 0.1; + if( mgr->hasValue( "SMESH", name + "y" ) ) + aYVal = mgr->doubleValue( "SMESH", name + "y", aYVal ); + myScalarBarActor->SetPosition( aXVal, aYVal ); + + vtkFloatingPointType aWVal = horiz ? 0.60 : 0.10; + if( mgr->hasValue( "SMESH", name + "width" ) ) + aWVal = mgr->doubleValue( "SMESH", name + "width", aWVal ); + myScalarBarActor->SetWidth( aWVal ); + + vtkFloatingPointType aHVal = horiz ? 0.12 : 0.80; + if( mgr->hasValue( "SMESH", name + "height" ) ) + aHVal = mgr->doubleValue( "SMESH", name + "height", aHVal ); + myScalarBarActor->SetHeight( aHVal ); + + int anIntVal = 5; + if( mgr->hasValue( "SMESH", "scalar_bar_num_labels" ) ) + anIntVal = mgr->integerValue( "SMESH", "scalar_bar_num_labels", anIntVal ); + myScalarBarActor->SetNumberOfLabels( anIntVal == 0 ? 5: anIntVal ); + + anIntVal = 64; + if( mgr->hasValue( "SMESH", "scalar_bar_num_colors" ) ) + anIntVal = mgr->integerValue( "SMESH", "scalar_bar_num_colors", anIntVal ); + 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; +}