-// Copyright (C) 2007-2011 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2012 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
#include "SMESH_ActorDef.h"
#include "SMESH_ActorUtils.h"
#include "SMESH_DeviceActor.h"
+#include "SMESH_NodeLabelActor.h"
+#include "SMESH_CellLabelActor.h"
#include "SMESH_ObjectDef.h"
#include "SMESH_ControlsDef.hxx"
#include "SMDS_UnstructuredGrid.hxx"
#include "SMESH_ScalarBarActor.h"
-#include "VTKViewer_CellCenters.h"
#include "VTKViewer_ExtractUnstructuredGrid.h"
#include "VTKViewer_FramedTextActor.h"
#include "SALOME_InteractiveObject.hxx"
#include "SUIT_Session.h"
#include "SUIT_ResourceMgr.h"
+#include <Qtx.h>
+
#ifndef DISABLE_PLOT2DVIEWER
#include <SPlot2d_Histogram.h>
#endif
#include <vtkActor2D.h>
#include <vtkProperty2D.h>
#include <vtkPolyData.h>
-#include <vtkMaskPoints.h>
#include <vtkTextProperty.h>
-#include <vtkLabeledDataMapper.h>
-#include <vtkSelectVisiblePoints.h>
#include <vtkLookupTable.h>
SMESH_ActorDef::SMESH_ActorDef()
{
- if(MYDEBUG) MESSAGE("SMESH_ActorDef - "<<this);
+ if(MYDEBUG) MESSAGE("SMESH_ActorDef - "<<this);
+ myBaseActor = SMESH_DeviceActor::New();
myTimeStamp = vtkTimeStamp::New();
myIsPointsVisible = false;
+ myIsEntityModeCache = false;
myIsShrinkable = false;
myIsShrunk = false;
//-----------------------------------------
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] );
+ QColor ffc, bfc;
+ int delta;
+ SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "0,170,255|-100" ) ;
+ mySurfaceProp->SetColor( ffc.red() / 255. , ffc.green() / 255. , ffc.blue() / 255. );
+ myDeltaBrightness = delta;
myBackSurfaceProp = vtkProperty::New();
- SMESH::GetColor( "SMESH", "backface_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 0, 255 ) );
- myBackSurfaceProp->SetColor( anRGB[0], anRGB[1], anRGB[2] );
+ bfc = Qtx::mainColorToSecondary(ffc, delta);
+ myBackSurfaceProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. );
- my2DActor = SMESH_DeviceActor::New();
+ my2DActor = SMESH_CellLabelActor::New();
+ my2DActor->SetStoreGemetryMapping(true);
my2DActor->SetUserMatrix(aMatrix);
my2DActor->PickableOff();
my2DActor->SetProperty(mySurfaceProp);
aFilter->RegisterCellsWithType(VTK_QUAD);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
+ aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
my2DExtProp = vtkProperty::New();
my2DExtProp->DeepCopy(mySurfaceProp);
aFilter->RegisterCellsWithType(VTK_QUAD);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
+ aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
- my3DActor = SMESH_DeviceActor::New();
+ my3DActor = SMESH_CellLabelActor::New();
+ my3DActor->SetStoreGemetryMapping(true);
my3DActor->SetUserMatrix(aMatrix);
my3DActor->PickableOff();
my3DActor->SetProperty(mySurfaceProp);
my3DActor->SetBackfaceProperty(myBackSurfaceProp);
my3DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
+ my3DActor->SetCoincident3DAllowed(true);
aFilter = my3DActor->GetExtractUnstructuredGrid();
aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
aFilter->RegisterCellsWithType(VTK_TETRA);
aFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
aFilter->RegisterCellsWithType(VTK_WEDGE);
aFilter->RegisterCellsWithType(VTK_PYRAMID);
+ aFilter->RegisterCellsWithType(VTK_HEXAGONAL_PRISM);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
+ aFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID);
aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
my3DExtActor->SetProperty(my2DExtProp);
my3DExtActor->SetBackfaceProperty(my2DExtProp);
my3DExtActor->SetRepresentation(SMESH_DeviceActor::eSurface);
+ my3DExtActor->SetCoincident3DAllowed(true);
aFilter = my3DExtActor->GetExtractUnstructuredGrid();
aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
aFilter->RegisterCellsWithType(VTK_TETRA);
aFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
aFilter->RegisterCellsWithType(VTK_WEDGE);
aFilter->RegisterCellsWithType(VTK_PYRAMID);
+ aFilter->RegisterCellsWithType(VTK_HEXAGONAL_PRISM);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
+ aFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID);
aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
myEdgeProp->SetAmbient(1.0);
myEdgeProp->SetDiffuse(0.0);
myEdgeProp->SetSpecular(0.0);
- SMESH::GetColor( "SMESH", "outline_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
+ SMESH::GetColor( "SMESH", "wireframe_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
myEdgeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
myEdgeProp->SetLineWidth(aLineWidth);
- my1DActor = SMESH_DeviceActor::New();
+ my1DActor = SMESH_CellLabelActor::New();
+ my1DActor->SetStoreGemetryMapping(true);
my1DActor->SetUserMatrix(aMatrix);
my1DActor->PickableOff();
my1DActor->SetHighlited(true);
my0DProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
my0DProp->SetPointSize(aElem0DSize);
- my0DActor = SMESH_DeviceActor::New();
+ my0DActor = SMESH_CellLabelActor::New();
my0DActor->SetUserMatrix(aMatrix);
- my0DActor->SetStoreClippingMapping(true);
+ my0DActor->SetStoreGemetryMapping(true);
my0DActor->PickableOff();
my0DActor->SetVisibility(false);
my0DActor->SetProperty(my0DProp);
SMESH::GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 0, 0 ) );
myNodeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
- myNodeActor = SMESH_DeviceActor::New();
+ myNodeActor = SMESH_NodeLabelActor::New();
myNodeActor->SetUserMatrix(aMatrix);
myNodeActor->SetStoreClippingMapping(true);
myNodeActor->PickableOff();
//Definition of Pickable and Highlitable engines
//----------------------------------------------
- myBaseActor = SMESH_DeviceActor::New();
myBaseActor->SetUserMatrix(aMatrix);
myBaseActor->SetStoreGemetryMapping(true);
myBaseActor->GetProperty()->SetOpacity(0.0);
-
myPickableActor = myBaseActor;
-
+
myHighlightProp = vtkProperty::New();
myHighlightProp->SetAmbient(1.0);
myHighlightProp->SetDiffuse(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(aElem0DSize); // ??
+ myHighlightProp->SetLineWidth(aLineWidth);
myHighlightProp->SetRepresentation(1);
+ myOutLineProp = vtkProperty::New();
+ myOutLineProp->SetAmbient(1.0);
+ myOutLineProp->SetDiffuse(0.0);
+ myOutLineProp->SetSpecular(0.0);
+ SMESH::GetColor( "SMESH", "outline_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 70, 0 ) );
+ myOutLineProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
+ myOutLineProp->SetPointSize(aElem0DSize); // ??
+ myOutLineProp->SetLineWidth(aLineWidth);
+ myOutLineProp->SetRepresentation(1);
+
myPreselectProp = vtkProperty::New();
myPreselectProp->SetAmbient(1.0);
myPreselectProp->SetDiffuse(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(aElem0DSize); // ??
+ myPreselectProp->SetLineWidth(aLineWidth);
myPreselectProp->SetRepresentation(1);
myHighlitableActor = SMESH_DeviceActor::New();
myHighlitableActor->SetUserMatrix(aMatrix);
myHighlitableActor->PickableOff();
myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
+ myHighlitableActor->SetCoincident3DAllowed(true);
aMatrix->Delete();
if( !mgr )
return;
- //Definition of points numbering pipeline
- //---------------------------------------
- myPointsNumDataSet = vtkUnstructuredGrid::New();
-
- myPtsMaskPoints = vtkMaskPoints::New();
- myPtsMaskPoints->SetInput(myPointsNumDataSet);
- myPtsMaskPoints->SetOnRatio(1);
-
- myPtsSelectVisiblePoints = vtkSelectVisiblePoints::New();
- myPtsSelectVisiblePoints->SetInput(myPtsMaskPoints->GetOutput());
- myPtsSelectVisiblePoints->SelectInvisibleOff();
- myPtsSelectVisiblePoints->SetTolerance(0.1);
-
- myPtsLabeledDataMapper = vtkLabeledDataMapper::New();
- myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput());
-#if (VTK_XVERSION < 0x050200)
- myPtsLabeledDataMapper->SetLabelFormat("%g");
-#endif
- myPtsLabeledDataMapper->SetLabelModeToLabelScalars();
-
- vtkTextProperty* aPtsTextProp = vtkTextProperty::New();
- aPtsTextProp->SetFontFamilyToTimes();
- static int aPointsFontSize = 10;
- aPtsTextProp->SetFontSize(aPointsFontSize);
- aPtsTextProp->SetBold(1);
- aPtsTextProp->SetItalic(0);
- aPtsTextProp->SetShadow(0);
- myPtsLabeledDataMapper->SetLabelTextProperty(aPtsTextProp);
- aPtsTextProp->Delete();
-
myEntityMode = eAllEntity;
-
- myIsPointsLabeled = false;
-
- myPointLabels = vtkActor2D::New();
- myPointLabels->SetMapper(myPtsLabeledDataMapper);
- myPointLabels->GetProperty()->SetColor(1,1,1);
- myPointLabels->SetVisibility(myIsPointsLabeled);
-
-
- //Definition of cells numbering pipeline
- //---------------------------------------
- myCellsNumDataSet = vtkUnstructuredGrid::New();
-
- myCellCenters = VTKViewer_CellCenters::New();
- myCellCenters->SetInput(myCellsNumDataSet);
-
- myClsMaskPoints = vtkMaskPoints::New();
- myClsMaskPoints->SetInput(myCellCenters->GetOutput());
- myClsMaskPoints->SetOnRatio(1);
-
- myClsSelectVisiblePoints = vtkSelectVisiblePoints::New();
- myClsSelectVisiblePoints->SetInput(myClsMaskPoints->GetOutput());
- myClsSelectVisiblePoints->SelectInvisibleOff();
- myClsSelectVisiblePoints->SetTolerance(0.1);
-
- myClsLabeledDataMapper = vtkLabeledDataMapper::New();
- myClsLabeledDataMapper->SetInput(myClsSelectVisiblePoints->GetOutput());
-#if (VTK_XVERSION < 0x050200)
- myClsLabeledDataMapper->SetLabelFormat("%g");
-#endif
- myClsLabeledDataMapper->SetLabelModeToLabelScalars();
-
- vtkTextProperty* aClsTextProp = vtkTextProperty::New();
- aClsTextProp->SetFontFamilyToTimes();
- static int aCellsFontSize = 12;
- aClsTextProp->SetFontSize(aCellsFontSize);
- aClsTextProp->SetBold(1);
- aClsTextProp->SetItalic(0);
- aClsTextProp->SetShadow(0);
- myClsLabeledDataMapper->SetLabelTextProperty(aClsTextProp);
- aClsTextProp->Delete();
-
- myIsCellsLabeled = false;
-
- myCellsLabels = vtkActor2D::New();
- myCellsLabels->SetMapper(myClsLabeledDataMapper);
- myCellsLabels->GetProperty()->SetColor(0,1,0);
- myCellsLabels->SetVisibility(myIsCellsLabeled);
-
+ myEntityModeCache = eAllEntity;
+
// Clipping planes
myImplicitBoolean = vtkImplicitBoolean::New();
myImplicitBoolean->SetOperationTypeToIntersection();
-
-
//Quadratic 2D elements representation
//-----------------------------------------------------------------------------
int aQuadratic2DMode = mgr->integerValue( "SMESH", "quadratic_mode", 0);
}
#endif
- // caught by SMESHGUI::ProcessEvents() static method
- this->InvokeEvent( SMESH::DeleteActorEvent, NULL );
-
myScalarBarActor->Delete();
myLookupTable->Delete();
mySurfaceProp->Delete();
myBackSurfaceProp->Delete();
+ myOutLineProp->Delete();
myEdgeProp->Delete();
myHighlightProp->Delete();
myNodeActor->Delete();
myBaseActor->Delete();
- myNodeExtActor->Delete();
-
+ myNodeExtActor->Delete();
myHighlitableActor->Delete();
- //Deleting of points numbering pipeline
- //---------------------------------------
- myPointsNumDataSet->Delete();
-
- // commented: porting to vtk 5.0
- // myPtsLabeledDataMapper->RemoveAllInputs();
- myPtsLabeledDataMapper->Delete();
-
- // commented: porting to vtk 5.0
- // myPtsSelectVisiblePoints->UnRegisterAllOutputs();
- myPtsSelectVisiblePoints->Delete();
-
- // commented: porting to vtk 5.0
- // myPtsMaskPoints->UnRegisterAllOutputs();
- myPtsMaskPoints->Delete();
-
- myPointLabels->Delete();
-
-
- //Deleting of cells numbering pipeline
- //---------------------------------------
- myCellsNumDataSet->Delete();
-
- myClsLabeledDataMapper->RemoveAllInputs();
- myClsLabeledDataMapper->Delete();
-
- // commented: porting to vtk 5.0
- // myClsSelectVisiblePoints->UnRegisterAllOutputs();
- myClsSelectVisiblePoints->Delete();
-
- // commented: porting to vtk 5.0
- // myClsMaskPoints->UnRegisterAllOutputs();
- myClsMaskPoints->Delete();
-
- // commented: porting to vtk 5.0
- // myCellCenters->UnRegisterAllOutputs();
- myCellCenters->Delete();
-
- myCellsLabels->Delete();
-
myImplicitBoolean->Delete();
myTimeStamp->Delete();
}
+void SMESH_ActorDef::Delete()
+{
+ // This is just to guarantee that the DeleteActorEvent (which was previously invoked
+ // from the actor's destructor) will be thrown before removing the actor's observers,
+ // that is done inside the Superclass::Delete() method but before the destructor itself
+ // (see the issue 0021562: EDF SMESH: clipping and delete mesh clipped leads to crash).
+ // The event is caught by SMESHGUI::ProcessEvents() static method.
+ this->InvokeEvent( SMESH::DeleteActorEvent, NULL );
+
+ Superclass::Delete();
+}
void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled )
{
- vtkUnstructuredGrid* aGrid = GetUnstructuredGrid();
-
- myIsPointsLabeled = theIsPointsLabeled && aGrid->GetNumberOfPoints();
-
- if ( myIsPointsLabeled )
- {
- myPointsNumDataSet->ShallowCopy(aGrid);
- vtkDataSet *aDataSet = myPointsNumDataSet;
-
- int aNbElem = aDataSet->GetNumberOfPoints();
-
- vtkIntArray *anArray = vtkIntArray::New();
- anArray->SetNumberOfValues( aNbElem );
-
- for ( vtkIdType anId = 0; anId < aNbElem; anId++ )
- {
- int aSMDSId = myVisualObj->GetNodeObjId( anId );
- anArray->SetValue( anId, aSMDSId );
- }
-
- aDataSet->GetPointData()->SetScalars( anArray );
- anArray->Delete();
- myPtsMaskPoints->SetInput( aDataSet );
- myPointLabels->SetVisibility( GetVisibility() );
+ if(myNodeActor) {
+ myNodeActor->SetPointsLabeled(theIsPointsLabeled);
+ SetRepresentation(GetRepresentation());
+ myTimeStamp->Modified();
}
- else
- {
- myPointLabels->SetVisibility( false );
- }
- SetRepresentation(GetRepresentation());
- myTimeStamp->Modified();
}
+bool SMESH_ActorDef::GetPointsLabeled() {
+ return myNodeActor && myNodeActor->GetPointsLabeled();
+}
void SMESH_ActorDef::SetCellsLabeled(bool theIsCellsLabeled)
{
- vtkUnstructuredGrid* aGrid = GetUnstructuredGrid();
- myIsCellsLabeled = theIsCellsLabeled && aGrid->GetNumberOfPoints();
- if(myIsCellsLabeled){
- myCellsNumDataSet->ShallowCopy(aGrid);
- vtkDataSet *aDataSet = myCellsNumDataSet;
- int aNbElem = aDataSet->GetNumberOfCells();
- vtkIntArray *anArray = vtkIntArray::New();
- anArray->SetNumberOfValues(aNbElem);
- for(int anId = 0; anId < aNbElem; anId++){
- int aSMDSId = myVisualObj->GetElemObjId(anId);
- anArray->SetValue(anId,aSMDSId);
- }
- aDataSet->GetCellData()->SetScalars(anArray);
- myCellCenters->SetInput(aDataSet);
- myCellsLabels->SetVisibility(GetVisibility());
- }else{
- myCellsLabels->SetVisibility(false);
- }
+ if(my3DActor)
+ my3DActor->SetCellsLabeled(theIsCellsLabeled);
+
+ if(my2DActor)
+ my2DActor->SetCellsLabeled(theIsCellsLabeled);
+
+ if(my1DActor)
+ my1DActor->SetCellsLabeled(theIsCellsLabeled);
+
+ if(my0DActor)
+ my0DActor->SetCellsLabeled(theIsCellsLabeled);
+
myTimeStamp->Modified();
}
+bool SMESH_ActorDef::GetCellsLabeled() {
+ bool result = false;
+ if(my3DActor)
+ result = result || my3DActor->GetCellsLabeled();
+
+ if(my2DActor)
+ result = result || my2DActor->GetCellsLabeled();
+
+ if(my1DActor)
+ result = result || my1DActor->GetCellsLabeled();
+
+ if(my0DActor)
+ result = result || my0DActor->GetCellsLabeled();
+
+ return result;
+}
+
+
void SMESH_ActorDef::SetFacesOriented(bool theIsFacesOriented)
{
myIsFacesOriented = theIsFacesOriented;
myFunctor.reset(new SMESH::Controls::FreeFaces());
myControlActor = my2DActor;
break;
+ case eCoincidentNodes:
+ {
+ SMESH::Controls::CoincidentNodes* cn = new SMESH::Controls::CoincidentNodes();
+ double tol = mgr->doubleValue( "SMESH", "equal_nodes_tolerance", 1e-7 );
+ cn->SetTolerance( tol );
+ myFunctor.reset(cn);
+ myControlActor = myNodeActor;
+ break;
+ }
+ case eCoincidentElems1D:
+ myFunctor.reset(new SMESH::Controls::CoincidentElements1D());
+ myControlActor = my1DActor;
+ break;
+ case eCoincidentElems2D:
+ myFunctor.reset(new SMESH::Controls::CoincidentElements2D());
+ myControlActor = my2DActor;
+ break;
+ case eCoincidentElems3D:
+ myFunctor.reset(new SMESH::Controls::CoincidentElements3D());
+ myControlActor = my3DActor;
+ break;
case eBareBorderFace:
myFunctor.reset(new SMESH::Controls::BareBorderFace());
myControlActor = my2DActor;
myControlMode = theMode;
switch(myControlMode){
case eFreeNodes:
+ case eCoincidentNodes:
myNodeExtActor->SetExtControlMode(myFunctor);
break;
case eFreeEdges:
case eFreeBorders:
+ case eCoincidentElems1D:
my1DExtActor->SetExtControlMode(myFunctor);
break;
case eFreeFaces:
case eBareBorderFace:
case eOverConstrainedFace:
+ case eCoincidentElems2D:
my2DExtActor->SetExtControlMode(myFunctor);
break;
case eBareBorderVolume:
case eOverConstrainedVolume:
+ case eCoincidentElems3D:
my3DExtActor->SetExtControlMode(myFunctor);
break;
case eLength2D:
}
}
- if(theCheckEntityMode){
- if(myControlActor == my1DActor)
+ if(theCheckEntityMode) {
+ if(myControlActor == my1DActor) {
+ if (!myIsEntityModeCache){
+ myEntityModeCache = GetEntityMode();
+ myIsEntityModeCache=true;
+ }
SetEntityMode(eEdges);
- else if(myControlActor == my2DActor){
- switch(myControlMode){
+ }
+ else if(myControlActor == my2DActor) {
+ switch(myControlMode) {
case eLength2D:
case eFreeEdges:
case eFreeFaces:
case eMultiConnection2D:
- //SetEntityMode(eEdges);
+ if (!myIsEntityModeCache){
+ myEntityModeCache = GetEntityMode();
+ myIsEntityModeCache=true;
+ }
SetEntityMode(eFaces);
break;
default:
+ if (!myIsEntityModeCache){
+ myEntityModeCache = GetEntityMode();
+ myIsEntityModeCache=true;
+ }
SetEntityMode(eFaces);
}
- }else if(myControlActor == my3DActor)
+ }else if(myControlActor == my3DActor) {
+ if (!myIsEntityModeCache){
+ myEntityModeCache = GetEntityMode();
+ myIsEntityModeCache=true;
+ }
SetEntityMode(eVolumes);
}
+ }
}
else {
- if(theCheckEntityMode)
- myEntityMode = eAllEntity;
+ if(theCheckEntityMode){
+ myEntityMode = myEntityModeCache;
+ myIsEntityModeCache = false;
+ }
myFunctor.reset();
}
myTimeStamp->Modified();
Modified();
+ Update();
}
void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){
- theRenderer->AddActor(myNodeActor);
- theRenderer->AddActor(myBaseActor);
-
+ theRenderer->AddActor(myBaseActor);
theRenderer->AddActor(myNodeExtActor);
+ theRenderer->AddActor(my1DExtActor);
my3DActor->AddToRender(theRenderer);
my3DExtActor->AddToRender(theRenderer);
my2DActor->AddToRender(theRenderer);
my2DExtActor->AddToRender(theRenderer);
-
- theRenderer->AddActor(my1DActor);
- theRenderer->AddActor(my1DExtActor);
-
- theRenderer->AddActor(my0DActor);
+ myNodeActor->AddToRender(theRenderer);
+ my1DActor->AddToRender(theRenderer);
+ my0DActor->AddToRender(theRenderer);
//theRenderer->AddActor(my0DExtActor);
theRenderer->AddActor(myHighlitableActor);
theRenderer->AddActor2D(myScalarBarActor);
- myPtsSelectVisiblePoints->SetRenderer(theRenderer);
- myClsSelectVisiblePoints->SetRenderer(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){
SALOME_Actor::RemoveFromRender(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);
my2DActor->RemoveFromRender(theRenderer);
my2DExtActor->RemoveFromRender(theRenderer);
my3DActor->RemoveFromRender(theRenderer);
my3DExtActor->RemoveFromRender(theRenderer);
+ myNodeActor->RemoveFromRender(theRenderer);
+ my0DActor->RemoveFromRender(theRenderer);
+ my1DActor->RemoveFromRender(theRenderer);
theRenderer->RemoveActor(myScalarBarActor);
- theRenderer->RemoveActor(myPointLabels);
- theRenderer->RemoveActor(myCellsLabels);
}
my2DExtActor->SetShrinkFactor(theValue);
my3DActor->SetShrinkFactor(theValue);
my3DExtActor->SetShrinkFactor(theValue);
+ my3DExtActor->SetShrinkFactor(theValue);
+ myHighlitableActor->SetShrinkFactor(theValue);
Modified();
}
my2DExtActor->SetShrink();
my3DActor->SetShrink();
my3DExtActor->SetShrink();
+ myHighlitableActor->SetShrink();
myIsShrunk = true;
Modified();
my2DExtActor->UnShrink();
my3DActor->UnShrink();
my3DExtActor->UnShrink();
+ myHighlitableActor->UnShrink();
myIsShrunk = false;
Modified();
my3DExtActor->VisibilityOff();
myScalarBarActor->VisibilityOff();
- myPointLabels->VisibilityOff();
- myCellsLabels->VisibilityOff();
if(GetVisibility()){
if(theIsUpdateRepersentation)
if(myControlMode != eNone){
switch(myControlMode){
case eFreeNodes:
+ case eCoincidentNodes:
myNodeExtActor->VisibilityOn();
break;
case eFreeEdges:
case eFreeBorders:
+ case eCoincidentElems1D:
my1DExtActor->VisibilityOn();
break;
case eFreeFaces:
case eBareBorderFace:
case eOverConstrainedFace:
+ case eCoincidentElems2D:
my2DExtActor->VisibilityOn();
break;
case eBareBorderVolume:
case eOverConstrainedVolume:
+ case eCoincidentElems3D:
my3DExtActor->VisibilityOn();
break;
case eLength2D:
my3DActor->VisibilityOn();
}
- if(myIsPointsLabeled){
- myPointLabels->VisibilityOn();
+ if(myNodeActor->GetPointsLabeled()){
myNodeActor->VisibilityOn();
}
- if(myIsCellsLabeled)
- myCellsLabels->VisibilityOn();
+ if(my0DActor)
+ my0DActor->UpdateLabels();
+
+ if(my1DActor)
+ my1DActor->UpdateLabels();
+
+ if(my2DActor)
+ my2DActor->UpdateLabels();
+
+ if(my3DActor)
+ my3DActor->UpdateLabels();
}
#ifndef DISABLE_PLOT2DVIEWER
else
aFilter->RegisterCellsWithType(VTK_QUAD);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
+ aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
aHightFilter->RegisterCellsWithType(VTK_TRIANGLE);
aHightFilter->RegisterCellsWithType(VTK_POLYGON);
aHightFilter->RegisterCellsWithType(VTK_QUAD);
aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
+ aHightFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
}
if (myEntityMode & eVolumes) {
aFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
aFilter->RegisterCellsWithType(VTK_WEDGE);
aFilter->RegisterCellsWithType(VTK_PYRAMID);
+ aFilter->RegisterCellsWithType(VTK_HEXAGONAL_PRISM);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
+ aFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
//#ifdef VTK_HAVE_POLYHEDRON
aHightFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
aHightFilter->RegisterCellsWithType(VTK_WEDGE);
aHightFilter->RegisterCellsWithType(VTK_PYRAMID);
+ aHightFilter->RegisterCellsWithType(VTK_HEXAGONAL_PRISM);
aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
+ aHightFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID);
aHightFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
}
bool SMESH_ActorDef::GetPointRepresentation(){
- return myIsPointsVisible || myIsPointsLabeled;
+ return myIsPointsVisible || myNodeActor->GetPointsLabeled();
}
void SMESH_ActorDef::UpdateHighlight(){
- myHighlitableActor->SetVisibility(false);
myHighlitableActor->SetHighlited(false);
-
- if(myIsHighlighted){
- myHighlitableActor->SetProperty(myHighlightProp);
- }else if(myIsPreselected){
- myHighlitableActor->SetProperty(myPreselectProp);
- }
+ myHighlitableActor->SetVisibility(false);
bool anIsVisible = GetVisibility();
- if(myIsHighlighted || myIsPreselected){
- if(GetUnstructuredGrid()->GetNumberOfCells()){
- myHighlitableActor->SetHighlited(anIsVisible);
- myHighlitableActor->SetVisibility(anIsVisible);
- myHighlitableActor->GetExtractUnstructuredGrid()->
- SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::eCells);
- myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
- }else if(myRepresentation == ePoint || GetPointRepresentation()){
- myHighlitableActor->SetHighlited(anIsVisible);
- myHighlitableActor->GetExtractUnstructuredGrid()->
- SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
+ switch(myRepresentation){
+ case SMESH_DeviceActor::eSurface:
+ case SMESH_DeviceActor::eWireframe:
+ {
+ if(myIsHighlighted) {
+ myHighlitableActor->SetProperty(myHighlightProp);
+ }else if(myIsPreselected){
+ myHighlitableActor->SetProperty(myPreselectProp);
+ } else if(anIsVisible){
+ (myRepresentation == eSurface) ?
+ myHighlitableActor->SetProperty(myOutLineProp) : myHighlitableActor->SetProperty(myEdgeProp);
+ }
+ if(GetUnstructuredGrid()->GetNumberOfCells()) {
+ myHighlitableActor->SetHighlited(anIsVisible);
+ myHighlitableActor->GetExtractUnstructuredGrid()->
+ SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::eCells);
+ myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
+ }
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);
+ break;
+ }
+ case SMESH_DeviceActor::ePoint:
+ {
+ if(myIsHighlighted) {
+ myNodeActor->SetProperty(myHighlightProp);
+ }else if(myIsPreselected) {
+ myNodeActor->SetProperty(myPreselectProp);
+ } else if(anIsVisible) {
+ myNodeActor->SetProperty(myNodeProp);
+ }
+ myNodeActor->SetRepresentation(SMESH_DeviceActor::ePoint);
+ myNodeActor->GetExtractUnstructuredGrid()->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
+ break;
}
}
}
if (anObjTime > aTime)
SetControlMode(GetControlMode(),false);
}
- if(myIsPointsLabeled){
- SetPointsLabeled(myIsPointsLabeled);
- }
- if(myIsCellsLabeled){
- SetCellsLabeled(myIsCellsLabeled);
- }
+
+ if(myNodeActor)
+ myNodeActor->UpdateLabels();
+
+ if(my0DActor)
+ my0DActor->UpdateLabels();
+
+ if(my1DActor)
+ my1DActor->UpdateLabels();
+
+ if(my2DActor)
+ my2DActor->UpdateLabels();
+
+ if(my3DActor)
+ my3DActor->UpdateLabels();
+
if(myIsFacesOriented){
SetFacesOriented(myIsFacesOriented);
}
+
+ if(myVisualObj->GetEntitiesFlag()) {
+ myEntityMode |= myVisualObj->GetEntitiesState();
+ }
+
SetEntityMode(GetEntityMode());
SetVisibility(GetVisibility());
}
-void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta){
mySurfaceProp->SetColor(r,g,b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_Face ||
aGroupObj->GetElementType() == SMDSAbs_Volume )
myNameActor->SetBackgroundColor(r,g,b);
+
+ myDeltaBrightness = delta;
+ QColor bfc = Qtx::mainColorToSecondary(QColor(int(r*255),int(g*255),int(b*255)), delta);
+ myBackSurfaceProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. );
Modified();
}
-void SMESH_ActorDef::GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta){
::GetColor(mySurfaceProp,r,g,b);
my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
-}
-
-void SMESH_ActorDef::SetBackSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
- myBackSurfaceProp->SetColor(r,g,b);
- Modified();
-}
-
-void SMESH_ActorDef::GetBackSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
- ::GetColor(myBackSurfaceProp,r,g,b);
+ delta = myDeltaBrightness;
}
void SMESH_ActorDef::SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
::GetColor(myEdgeProp,r,g,b);
}
+void SMESH_ActorDef::SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+ myOutLineProp->SetColor(r,g,b);
+ Modified();
+}
+
+void SMESH_ActorDef::GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+ ::GetColor(myOutLineProp,r,g,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);
myEdgeProp->SetLineWidth(theVal);
my1DProp->SetLineWidth(theVal + aLineWidthInc);
- my1DExtProp->SetLineWidth(theVal + aLineWidthInc);
-
+ my1DExtProp->SetLineWidth(theVal + aLineWidthInc);
+ my2DExtProp->SetLineWidth(theVal + aLineWidthInc);
+ myOutLineProp->SetLineWidth(theVal);
+ myHighlightProp->SetLineWidth(theVal);
+ myPreselectProp->SetLineWidth(theVal);
Modified();
}
myCippingPlaneCont.push_back(thePlane);
if(!IsImplicitFunctionUsed())
SetImplicitFunctionUsed(true);
+ myNodeActor->UpdateLabels();
}
return myCippingPlaneCont.size();
}
myImplicitBoolean->GetFunction()->Modified(); // VTK bug
myCippingPlaneCont.clear();
SetImplicitFunctionUsed(false);
+ myNodeActor->UpdateLabels();
}
vtkIdType
