-// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2011 CEA/DEN, EDF R&D, OPEN CASCADE
//
-// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// This library is 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.
+// 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
+// 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
+// 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_DataSetMapper.h"
#include "VTKViewer_ExtractUnstructuredGrid.h"
#include "VTKViewer_FramedTextActor.h"
#include "SALOME_InteractiveObject.hxx"
#include "SUIT_Session.h"
#include "SUIT_ResourceMgr.h"
+#ifndef DISABLE_PLOT2DVIEWER
+#include <SPlot2d_Histogram.h>
+#endif
+
#include <vtkProperty.h>
#include <vtkTimeStamp.h>
#include <vtkObjectFactory.h>
#include <vtkProperty2D.h>
#include <vtkPolyData.h>
#include <vtkMaskPoints.h>
-#include <vtkCellCenters.h>
#include <vtkTextProperty.h>
#include <vtkLabeledDataMapper.h>
#include <vtkSelectVisiblePoints.h>
-#include <vtkScalarBarActor.h>
#include <vtkLookupTable.h>
#include <vtkMath.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(){
const char* theName,
int theIsClear)
{
- SMESH_ActorDef* anActor = SMESH_ActorDef::New();
- if(!anActor->Init(theVisualObj,theEntry,theName,theIsClear)){
- anActor->Delete();
- anActor = NULL;
+ SMESH_ActorDef* anActor = NULL;
+ if(theVisualObj->IsValid() ) {
+ anActor = SMESH_ActorDef::New();
+ if(!anActor->Init(theVisualObj,theEntry,theName,theIsClear)){
+ anActor->Delete();
+ anActor = NULL;
+ }
+ if( anActor )
+ anActor->UpdateScalarBar();
}
- if( anActor )
- anActor->UpdateScalarBar();
return anActor;
}
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);
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);
+ aFilter->RegisterCellsWithType(VTK_POLYHEDRON);
//Definition 1D device of the actor
//---------------------------------
my1DProp = vtkProperty::New();
my1DProp->DeepCopy(myEdgeProp);
my1DProp->SetLineWidth(aLineWidth + aLineWidthInc);
- my1DProp->SetPointSize(aPointSize);
+ my1DProp->SetPointSize(aElem0DSize);
my1DExtProp = vtkProperty::New();
my1DExtProp->DeepCopy(myEdgeProp);
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);
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);
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);
myPickableActor = myBaseActor;
+ // VSR 13/07/2011: Revert back previous fix for issue 0020749 since it causes regressions, see issues 0021322, 0021323
+ // To be removed later or fix to be improved
+ //myMapper = VTKViewer_DataSetMapper::New();
+ //myMapper->SetInput( myPickableActor->GetUnstructuredGrid() );
+
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(std::max(aElem0DSize,aPointSize)); // ??
+ myHighlightProp->SetPointSize(aElem0DSize); // ??
myHighlightProp->SetRepresentation(1);
myPreselectProp = vtkProperty::New();
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();
//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);
myPtsLabeledDataMapper = vtkLabeledDataMapper::New();
myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput());
-#if (VTK_XVERSION >= 0x050200)
- myPtsLabeledDataMapper->SetLabelFormat("%d");
-#else
+#if (VTK_XVERSION < 0x050200)
myPtsLabeledDataMapper->SetLabelFormat("%g");
#endif
myPtsLabeledDataMapper->SetLabelModeToLabelScalars();
//---------------------------------------
myCellsNumDataSet = vtkUnstructuredGrid::New();
- myCellCenters = vtkCellCenters::New();
+ myCellCenters = VTKViewer_CellCenters::New();
myCellCenters->SetInput(myCellsNumDataSet);
myClsMaskPoints = vtkMaskPoints::New();
myClsLabeledDataMapper = vtkLabeledDataMapper::New();
myClsLabeledDataMapper->SetInput(myClsSelectVisiblePoints->GetOutput());
-#if (VTK_XVERSION >= 0x050200)
- myClsLabeledDataMapper->SetLabelFormat("%d");
-#else
+#if (VTK_XVERSION < 0x050200)
myClsLabeledDataMapper->SetLabelFormat("%g");
#endif
myClsLabeledDataMapper->SetLabelModeToLabelScalars();
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]);
+
+#ifndef DISABLE_PLOT2DVIEWER
+ my2dHistogram = 0;
+#endif
+
}
{
if(MYDEBUG) MESSAGE("~SMESH_ActorDef - "<<this);
+#ifndef DISABLE_PLOT2DVIEWER
+ if(my2dHistogram) {
+ SMESH::ProcessIn2DViewers(this,SMESH::RemoveFrom2dViewer);
+ delete my2dHistogram;
+ }
+#endif
+
+ // caught by SMESHGUI::ProcessEvents() static method
+ this->InvokeEvent( SMESH::DeleteActorEvent, NULL );
+
myScalarBarActor->Delete();
myLookupTable->Delete();
my2DExtProp->Delete();
my2DExtActor->Delete();
my3DActor->Delete();
+ my3DExtActor->Delete();
myNodeActor->Delete();
myBaseActor->Delete();
myImplicitBoolean->Delete();
+ // VSR 13/07/2011: Revert back previous fix for issue 0020749 since it causes regressions, see issues 0021322, 0021323
+ // To be removed later or fix to be improved
+ //myMapper->Delete();
+
myTimeStamp->Delete();
}
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::
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;
}
{
SMESH::Controls::Taper* aControl = new SMESH::Controls::Taper();
aControl->SetPrecision( myControlsPrecision );
- aFunctor.reset( aControl );
+ myFunctor.reset( aControl );
myControlActor = my2DActor;
break;
}
{
SMESH::Controls::AspectRatio* aControl = new SMESH::Controls::AspectRatio();
aControl->SetPrecision( myControlsPrecision );
- aFunctor.reset( aControl );
+ myFunctor.reset( aControl );
myControlActor = my2DActor;
break;
}
{
SMESH::Controls::AspectRatio3D* aControl = new SMESH::Controls::AspectRatio3D();
aControl->SetPrecision( myControlsPrecision );
- aFunctor.reset( aControl );
+ myFunctor.reset( aControl );
myControlActor = my3DActor;
break;
}
{
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;
}
{
SMESH::Controls::MinimumAngle* aControl = new SMESH::Controls::MinimumAngle();
aControl->SetPrecision( myControlsPrecision );
- aFunctor.reset( aControl );
+ myFunctor.reset( aControl );
myControlActor = my2DActor;
break;
}
{
SMESH::Controls::Warping* aControl = new SMESH::Controls::Warping();
aControl->SetPrecision( myControlsPrecision );
- aFunctor.reset( aControl );
+ myFunctor.reset( aControl );
myControlActor = my2DActor;
break;
}
{
SMESH::Controls::Skew* aControl = new SMESH::Controls::Skew();
aControl->SetPrecision( myControlsPrecision );
- aFunctor.reset( aControl );
+ myFunctor.reset( aControl );
myControlActor = my2DActor;
break;
}
myControlMode = theMode;
switch(myControlMode){
case eFreeNodes:
- myNodeExtActor->SetExtControlMode(aFunctor);
+ myNodeExtActor->SetExtControlMode(myFunctor);
break;
case eFreeEdges:
case eFreeBorders:
- my1DExtActor->SetExtControlMode(aFunctor);
+ my1DExtActor->SetExtControlMode(myFunctor);
break;
case eFreeFaces:
- my2DExtActor->SetExtControlMode(aFunctor);
+ 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);
+ my1DExtActor->SetExtControlMode(myFunctor,myScalarBarActor,myLookupTable);
+ UpdateDistribution();
break;
default:
- myControlActor->SetControlMode(aFunctor,myScalarBarActor,myLookupTable);
+ myControlActor->SetControlMode(myFunctor,myScalarBarActor,myLookupTable);
+ UpdateDistribution();
}
}
SetEntityMode(eVolumes);
}
- }else if(theCheckEntityMode){
- myEntityMode = eAllEntity;
+ }
+ else {
+ if(theCheckEntityMode)
+ myEntityMode = eAllEntity;
+ myFunctor.reset();
}
SetRepresentation(GetRepresentation());
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);
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){
my2DActor->RemoveFromRender(theRenderer);
my2DExtActor->RemoveFromRender(theRenderer);
my3DActor->RemoveFromRender(theRenderer);
+ my3DExtActor->RemoveFromRender(theRenderer);
theRenderer->RemoveActor(myScalarBarActor);
theRenderer->RemoveActor(myPointLabels);
my2DActor->Init(myVisualObj,myImplicitBoolean);
my2DExtActor->Init(myVisualObj,myImplicitBoolean);
my3DActor->Init(myVisualObj,myImplicitBoolean);
+ my3DExtActor->Init(myVisualObj,myImplicitBoolean);
my0DActor->GetMapper()->SetLookupTable(myLookupTable);
//my0DExtActor->GetMapper()->SetLookupTable(myLookupTable);
my2DActor->GetMapper()->SetLookupTable(myLookupTable);
my2DExtActor->GetMapper()->SetLookupTable(myLookupTable);
my3DActor->GetMapper()->SetLookupTable(myLookupTable);
+ my3DExtActor->GetMapper()->SetLookupTable(myLookupTable);
vtkFloatingPointType aFactor, aUnits;
my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
if( dynamic_cast<SMESH_GroupObj*>( 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;
my2DActor->SetTransform(theTransform);
my2DExtActor->SetTransform(theTransform);
my3DActor->SetTransform(theTransform);
+ my3DExtActor->SetTransform(theTransform);
Modified();
}
vtkMapper* SMESH_ActorDef::GetMapper(){
+ // VSR 13/07/2011: Revert back previous fix for issue 0020749 since it causes regressions, see issues 0021322, 0021323
+ // To be removed later or fix to be improved
+ //return myMapper;
return myPickableActor->GetMapper();
}
my2DActor->SetShrinkFactor(theValue);
my2DExtActor->SetShrinkFactor(theValue);
my3DActor->SetShrinkFactor(theValue);
+ my3DExtActor->SetShrinkFactor(theValue);
Modified();
}
my2DActor->SetShrink();
my2DExtActor->SetShrink();
my3DActor->SetShrink();
+ my3DExtActor->SetShrink();
myIsShrunk = true;
Modified();
my2DActor->UnShrink();
my2DExtActor->UnShrink();
my3DActor->UnShrink();
+ my3DExtActor->UnShrink();
myIsShrunk = false;
Modified();
my2DActor->VisibilityOff();
my2DExtActor->VisibilityOff();
my3DActor->VisibilityOff();
+ my3DExtActor->VisibilityOff();
myScalarBarActor->VisibilityOff();
myPointLabels->VisibilityOff();
my1DExtActor->VisibilityOn();
break;
case eFreeFaces:
+ case eBareBorderFace:
+ case eOverConstrainedFace:
my2DExtActor->VisibilityOn();
break;
+ case eBareBorderVolume:
+ case eOverConstrainedVolume:
+ my3DExtActor->VisibilityOn();
+ break;
case eLength2D:
case eMultiConnection2D:
my1DExtActor->VisibilityOn();
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();
}
if(myIsCellsLabeled)
myCellsLabels->VisibilityOn();
- }
+ }
+#ifndef DISABLE_PLOT2DVIEWER
+ else
+ SMESH::ProcessIn2DViewers(this,SMESH::RemoveFrom2dViewer);
+#endif
UpdateHighlight();
Modified();
}
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);
+ aHightFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
if (myEntityMode & e0DElements) {
if (MYDEBUG) MESSAGE("0D ELEMENTS");
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);
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());
//my0DExtActor->SetVisibility(false);
my1DExtActor->SetVisibility(false);
my2DExtActor->SetVisibility(false);
+ my3DExtActor->SetVisibility(false);
// ???
//my0DActor->SetProperty(aProp);
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);
}
}
}
::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<SMESH_GroupObj*>( 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();
}
-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 )
my2DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
my2DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
my3DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
+ my3DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
}
vtkIdType
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();
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<SMESH::Controls::NumericalFunctor*>(myFunctor.get()))
+ {
+ int nbIntervals = myScalarBarActor->GetMaximumNumberOfColors();
+ std::vector<int> nbEvents;
+ std::vector<double> funValues;
+ SMESH_VisualObjDef::TEntityList elems;
+ if ( ! dynamic_cast<SMESH_MeshObj*>(myVisualObj.get()))
+ dynamic_cast<SMESH_VisualObjDef*>(myVisualObj.get())->GetEntities( fun->GetType(), elems );
+ std::vector<int> elemIds;
+ for ( SMESH_VisualObjDef::TEntityList::iterator e = elems.begin(); e != elems.end(); ++e)
+ elemIds.push_back( (*e)->GetID());
+ vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
+ double * range = lookupTable->GetRange();
+ fun->GetHistogram(nbIntervals, nbEvents, funValues, elemIds, range);
+ myScalarBarActor->SetDistribution(nbEvents);
+ }
+}
+
void SMESH_ActorDef::SetQuadratic2DRepresentation(EQuadratic2DRepresentation theMode)
{
switch(theMode) {
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
+}
+
+#ifndef DISABLE_PLOT2DVIEWER
+SPlot2d_Histogram* SMESH_ActorDef::UpdatePlot2Histogram() {
+
+ if(my2dHistogram)
+ my2dHistogram->clearAllPoints();
+
+ if(SMESH::Controls::NumericalFunctor* fun =
+ dynamic_cast<SMESH::Controls::NumericalFunctor*>(myFunctor.get()))
+ {
+
+ if(!my2dHistogram) {
+ my2dHistogram = new SPlot2d_Histogram();
+ Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(getIO()->getEntry(),"SMESH",getName());
+ my2dHistogram->setIO(anIO);
+ }
+
+ int nbIntervals = myScalarBarActor->GetMaximumNumberOfColors();
+ std::vector<int> nbEvents;
+ std::vector<double> funValues;
+ SMESH_VisualObjDef::TEntityList elems;
+ if ( ! dynamic_cast<SMESH_MeshObj*>(myVisualObj.get()))
+ dynamic_cast<SMESH_VisualObjDef*>(myVisualObj.get())->GetEntities( fun->GetType(), elems );
+ std::vector<int> elemIds;
+
+ for ( SMESH_VisualObjDef::TEntityList::iterator e = elems.begin(); e != elems.end(); ++e)
+ elemIds.push_back( (*e)->GetID());
+
+ vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
+ double * range = lookupTable->GetRange();
+ fun->GetHistogram(nbIntervals, nbEvents, funValues, elemIds, range);
+
+ for ( int i = 0; i < std::min( nbEvents.size(), funValues.size() -1 ); i++ )
+ my2dHistogram->addPoint(funValues[i] + (funValues[i+1] - funValues[i])/2.0, static_cast<double>(nbEvents[i]));
+
+ if(funValues.size() >= 2)
+ my2dHistogram->setWidth((funValues[1] - funValues[0]) * 0.8) ;
+
+ }
+
+ //Color of the histogram
+ if(myScalarBarActor->GetDistributionColoringType() == SMESH_MULTICOLOR_TYPE)
+ my2dHistogram->setAutoAssign(true);
+ else {
+ double rgb[3];
+ myScalarBarActor->GetDistributionColor(rgb);
+ QColor aColor = QColor( (int)( rgb[0]*255 ), (int)( rgb[1]*255 ), (int)( rgb[2]*255 ) );
+ my2dHistogram->setColor(aColor);
+
+ }
+
+ return my2dHistogram;
+}
+#endif
