-// 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 "VTKViewer_ExtractUnstructuredGrid.h"
#include "VTKViewer_FramedTextActor.h"
#include "SALOME_InteractiveObject.hxx"
+#include "SMESH_SVTKActor.h"
#include "SUIT_Session.h"
#include "SUIT_ResourceMgr.h"
myIsPointsVisible = false;
myIsEntityModeCache = false;
+ myHighlightActor = SMESH_SVTKActor::New();
+ myHighlightActor->Initialize();
+
+ myPreHighlightActor = SMESH_SVTKActor::New();
+ myPreHighlightActor->Initialize();
+
myIsShrinkable = false;
myIsShrunk = false;
if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1);
- vtkFloatingPointType aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
- vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
+ vtkFloatingPointType aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
+ vtkFloatingPointType aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10);
+ vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
+ vtkFloatingPointType aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1);
vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
VTKViewer_ExtractUnstructuredGrid* aFilter = NULL;
bfc = Qtx::mainColorToSecondary(ffc, delta);
myBackSurfaceProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. );
+ myNormalVProp = vtkProperty::New();
+ SMESH::GetColor( "SMESH", "volume_color", ffc, delta, "255,0,170|-100" );
+ myNormalVProp->SetColor( ffc.redF(), ffc.greenF(), ffc.blueF() );
+ myDeltaVBrightness = delta;
+
+ myReversedVProp = vtkProperty::New();
+ bfc = Qtx::mainColorToSecondary(ffc, delta);
+ myReversedVProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. );
+
my2DActor = SMESH_CellLabelActor::New();
my2DActor->SetStoreGemetryMapping(true);
my2DActor->SetUserMatrix(aMatrix);
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_CellLabelActor::New();
my3DActor->SetStoreGemetryMapping(true);
my3DActor->SetUserMatrix(aMatrix);
my3DActor->PickableOff();
- my3DActor->SetProperty(mySurfaceProp);
- my3DActor->SetBackfaceProperty(myBackSurfaceProp);
+ my3DActor->SetProperty(myNormalVProp);
+ my3DActor->SetBackfaceProperty(myReversedVProp);
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);
aFilter->RegisterCellsWithType(VTK_POLYHEDRON);
//#endif
+ my3DExtProp = vtkProperty::New();
+ my3DExtProp->DeepCopy(myNormalVProp);
+ SMESH::GetColor( "SMESH", "volume_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 0, 170 ) );
+ anRGB[0] = 1 - anRGB[0];
+ anRGB[1] = 1 - anRGB[1];
+ anRGB[2] = 1 - anRGB[2];
+ my3DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
+
my3DExtActor = SMESH_DeviceActor::New();
my3DExtActor->SetUserMatrix(aMatrix);
my3DExtActor->PickableOff();
- my3DExtActor->SetProperty(my2DExtProp);
- my3DExtActor->SetBackfaceProperty(my2DExtProp);
+ my3DExtActor->SetProperty(my3DExtProp);
+ my3DExtActor->SetBackfaceProperty(my3DExtProp);
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);
aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
aFilter->RegisterCellsWithType(VTK_VERTEX);
+ //Definition 0D device of the actor (ball elements)
+ //-----------------------------------------------
+ myBallProp = vtkProperty::New();
+ SMESH::GetColor( "SMESH", "ball_elem_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 85, 255 ) );
+ myBallProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
+ myBallProp->SetPointSize(aBallElemSize);
+
+ myBallActor = SMESH_CellLabelActor::New();
+ myBallActor->SetUserMatrix(aMatrix);
+ myBallActor->SetStoreGemetryMapping(true);
+ myBallActor->PickableOff();
+ myBallActor->SetVisibility(false);
+ myBallActor->SetProperty(myBallProp);
+ myBallActor->SetRepresentation(SMESH_DeviceActor::eSurface);
+ aFilter = myBallActor->GetExtractUnstructuredGrid();
+ aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
+ aFilter->RegisterCellsWithType(VTK_POLY_VERTEX);
+
//my0DExtProp = vtkProperty::New();
//my0DExtProp->DeepCopy(my0DProp);
//anRGB[0] = 1 - anRGB[0];
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);
+ myBallHighlightProp = vtkProperty::New();
+ myBallHighlightProp->DeepCopy(myHighlightProp);
+ myBallHighlightProp->SetPointSize(aBallElemSize);
+
+
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(aOutlineWidth);
myOutLineProp->SetRepresentation(1);
myPreselectProp = vtkProperty::New();
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);
+ myBallPreselectProp = vtkProperty::New();
+ myBallPreselectProp->DeepCopy(myPreselectProp);
+ myBallPreselectProp->SetPointSize(aBallElemSize);
+
myHighlitableActor = SMESH_DeviceActor::New();
myHighlitableActor->SetUserMatrix(aMatrix);
myHighlitableActor->PickableOff();
myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
+ myHighlitableActor->SetCoincident3DAllowed(true);
aMatrix->Delete();
my2DActor->SetQuadraticArcAngle(aQuadraticAngle);
// Set colors of the name actor
- SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
+ SMESH::GetColor( "SMESH", "default_grp_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]);
my2dHistogram = 0;
#endif
+ SetBallSize(aBallElemSize);
+ Set0DSize(aElem0DSize);
}
}
#endif
- // caught by SMESHGUI::ProcessEvents() static method
- this->InvokeEvent( SMESH::DeleteActorEvent, NULL );
-
myScalarBarActor->Delete();
myLookupTable->Delete();
mySurfaceProp->Delete();
myBackSurfaceProp->Delete();
+ myNormalVProp->Delete();
+ myReversedVProp->Delete();
myOutLineProp->Delete();
myEdgeProp->Delete();
my0DProp->Delete();
my0DActor->Delete();
+ myBallActor->Delete();
//my0DExtProp->Delete();
//my0DExtActor->Delete();
my2DExtProp->Delete();
my2DExtActor->Delete();
my3DActor->Delete();
+ my3DExtProp->Delete();
my3DExtActor->Delete();
myNodeActor->Delete();
myImplicitBoolean->Delete();
myTimeStamp->Delete();
+ myBallHighlightProp->Delete();
+ myBallPreselectProp->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 )
{
if(my0DActor)
my0DActor->SetCellsLabeled(theIsCellsLabeled);
+ if(myBallActor)
+ myBallActor->SetCellsLabeled(theIsCellsLabeled);
+
myTimeStamp->Modified();
}
if(my0DActor)
result = result || my0DActor->GetCellsLabeled();
+ if(myBallActor)
+ result = result || myBallActor->GetCellsLabeled();
+
return result;
}
return myIsFacesOriented;
}
-void SMESH_ActorDef::SetFacesOrientationColor(vtkFloatingPointType theColor[3])
+void SMESH_ActorDef::SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b)
{
- my2DActor->SetFacesOrientationColor( theColor );
- my3DActor->SetFacesOrientationColor( theColor );
+ my2DActor->SetFacesOrientationColor( r, g, b );
+ my3DActor->SetFacesOrientationColor( r, g, b );
}
-void SMESH_ActorDef::GetFacesOrientationColor(vtkFloatingPointType theColor[3])
+void SMESH_ActorDef::GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b)
{
- my3DActor->GetFacesOrientationColor( theColor );
+ my3DActor->GetFacesOrientationColor( r, g, b );
}
void SMESH_ActorDef::SetFacesOrientationScale(vtkFloatingPointType theScale)
my1DActor->GetMapper()->SetScalarVisibility(false);
my2DActor->GetMapper()->SetScalarVisibility(false);
my3DActor->GetMapper()->SetScalarVisibility(false);
+ myBallActor->GetMapper()->SetScalarVisibility(false);
myScalarBarActor->SetVisibility(false);
bool anIsScalarVisible = theMode > eNone;
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 (!myIsEntityModeCache){
myEntityModeCache = GetEntityMode();
myIsEntityModeCache=true;
- }
+ }
SetEntityMode(eFaces);
break;
default:
if (!myIsEntityModeCache){
myEntityModeCache = GetEntityMode();
myIsEntityModeCache=true;
- }
+ }
SetEntityMode(eFaces);
}
}else if(myControlActor == my3DActor) {
if (!myIsEntityModeCache){
myEntityModeCache = GetEntityMode();
myIsEntityModeCache=true;
- }
+ }
SetEntityMode(eVolumes);
}
}
void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){
+
+ //myHighlightActor->AddToRender(theRenderer);
+
theRenderer->AddActor(myBaseActor);
theRenderer->AddActor(myNodeExtActor);
theRenderer->AddActor(my1DExtActor);
- my3DActor->AddToRender(theRenderer);
+ my3DActor ->AddToRender(theRenderer);
my3DExtActor->AddToRender(theRenderer);
- my2DActor->AddToRender(theRenderer);
+ my2DActor ->AddToRender(theRenderer);
my2DExtActor->AddToRender(theRenderer);
- myNodeActor->AddToRender(theRenderer);
- my1DActor->AddToRender(theRenderer);
- my0DActor->AddToRender(theRenderer);
+ myNodeActor ->AddToRender(theRenderer);
+ my1DActor ->AddToRender(theRenderer);
+ my0DActor ->AddToRender(theRenderer);
+ myBallActor ->AddToRender(theRenderer);
//theRenderer->AddActor(my0DExtActor);
theRenderer->AddActor(myHighlitableActor);
my3DExtActor->RemoveFromRender(theRenderer);
myNodeActor->RemoveFromRender(theRenderer);
my0DActor->RemoveFromRender(theRenderer);
+ myBallActor->RemoveFromRender(theRenderer);
my1DActor->RemoveFromRender(theRenderer);
theRenderer->RemoveActor(myScalarBarActor);
myNodeExtActor->Init(myVisualObj,myImplicitBoolean);
my0DActor->Init(myVisualObj,myImplicitBoolean);
+ myBallActor->Init(myVisualObj,myImplicitBoolean);
//my0DExtActor->Init(myVisualObj,myImplicitBoolean);
my1DActor->Init(myVisualObj,myImplicitBoolean);
my3DExtActor->Init(myVisualObj,myImplicitBoolean);
my0DActor->GetMapper()->SetLookupTable(myLookupTable);
+ myBallActor->GetMapper()->SetLookupTable(myLookupTable);
//my0DExtActor->GetMapper()->SetLookupTable(myLookupTable);
my1DActor->GetMapper()->SetLookupTable(myLookupTable);
my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
my2DExtActor->SetPolygonOffsetParameters(aFactor,aUnits*0.5);
+ my3DActor->SetPolygonOffsetParameters(2*aFactor,aUnits);
SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
if( !mgr )
myNodeExtActor->SetTransform(theTransform);
my0DActor->SetTransform(theTransform);
+ myBallActor->SetTransform(theTransform);
//my0DExtActor->SetTransform(theTransform);
my1DActor->SetTransform(theTransform);
myNodeExtActor->VisibilityOff();
my0DActor->VisibilityOff();
+ myBallActor->VisibilityOff();
//my0DExtActor->VisibilityOff();
my1DActor->VisibilityOff();
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:
myNodeActor->VisibilityOn();
}
- if(myEntityMode & e0DElements){
+ if(myEntityMode & e0DElements && GetRepresentation() != ePoint ){
my0DActor->VisibilityOn();
}
+ if(myEntityMode & eBallElem && GetRepresentation() != ePoint ){
+ myBallActor->VisibilityOn();
+ }
if(myEntityMode & eEdges && GetRepresentation() != ePoint){
my1DActor->VisibilityOn();
if(my0DActor)
my0DActor->UpdateLabels();
+ if(myBallActor)
+ myBallActor->UpdateLabels();
+
if(my1DActor)
my1DActor->UpdateLabels();
theMode &= ~e0DElements;
}
+ if(!myVisualObj->GetNbEntities(SMDSAbs_Ball)) {
+ myEntityState &= ~eBallElem;
+ theMode &= ~eBallElem;
+ }
+
if(!myVisualObj->GetNbEntities(SMDSAbs_Edge)) {
myEntityState &= ~eEdges;
theMode &= ~eEdges;
if(myVisualObj->GetNbEntities(SMDSAbs_0DElement))
theMode |= e0DElements;
+ if(myVisualObj->GetNbEntities(SMDSAbs_Ball))
+ theMode |= eBallElem;
+
if(myVisualObj->GetNbEntities(SMDSAbs_Edge))
theMode |= eEdges;
aHightFilter->RegisterCellsWithType(VTK_VERTEX);
}
+ if (myEntityMode & eBallElem) {
+ aFilter->RegisterCellsWithType(VTK_POLY_VERTEX);
+ aHightFilter->RegisterCellsWithType(VTK_POLY_VERTEX);
+ }
+
if (myEntityMode & eEdges) {
if (MYDEBUG) MESSAGE("EDGES");
aFilter->RegisterCellsWithType(VTK_LINE);
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);
int aNbEdges = myVisualObj->GetNbEntities(SMDSAbs_Edge);
int aNbFaces = myVisualObj->GetNbEntities(SMDSAbs_Face);
int aNbVolumes = myVisualObj->GetNbEntities(SMDSAbs_Volume);
+ int aNb0Ds = myVisualObj->GetNbEntities(SMDSAbs_0DElement);
+ int aNbBalls = myVisualObj->GetNbEntities(SMDSAbs_Ball);
if (theMode < 0) {
myRepresentation = eSurface;
} else {
switch (theMode) {
case eEdge:
- if (!aNbFaces && !aNbVolumes && !aNbEdges) return;
+ if (!aNbFaces && !aNbVolumes && !aNbEdges && !aNb0Ds && !aNbBalls) return;
break;
case eSurface:
- if (!aNbFaces && !aNbVolumes) return;
+ if (!aNbFaces && !aNbVolumes && !aNb0Ds && !aNbBalls) return;
break;
}
myRepresentation = theMode;
myNodeActor->SetVisibility(false);
myNodeExtActor->SetVisibility(false);
vtkProperty *aProp = NULL, *aBackProp = NULL;
+ vtkProperty *aPropVN = NULL, *aPropVR = NULL;
SMESH_DeviceActor::EReperesent aReperesent = SMESH_DeviceActor::EReperesent(-1);
SMESH_Actor::EQuadratic2DRepresentation aQuadraticMode = GetQuadratic2DRepresentation();
switch (myRepresentation) {
myPickableActor = myNodeActor;
myNodeActor->SetVisibility(true);
aQuadraticMode = SMESH_Actor::eLines;
- aProp = aBackProp = myNodeProp;
+ aProp = aBackProp = aPropVN = aPropVR = myNodeProp;
aReperesent = SMESH_DeviceActor::ePoint;
break;
case eEdge:
- aProp = aBackProp = myEdgeProp;
+ aProp = aBackProp = aPropVN = aPropVR = myEdgeProp;
aReperesent = SMESH_DeviceActor::eInsideframe;
break;
case eSurface:
aProp = mySurfaceProp;
aBackProp = myBackSurfaceProp;
+ aPropVN = myNormalVProp;
+ aPropVR = myReversedVProp;
aReperesent = SMESH_DeviceActor::eSurface;
break;
}
my2DExtActor->SetRepresentation(aReperesent);
- my3DActor->SetProperty(aProp);
- my3DActor->SetBackfaceProperty(aBackProp);
+ my3DActor->SetProperty(aPropVN);
+ my3DActor->SetBackfaceProperty(aPropVR);
my3DActor->SetRepresentation(aReperesent);
//my0DExtActor->SetVisibility(false);
//my0DActor->SetProperty(aProp);
//my0DActor->SetBackfaceProperty(aBackProp);
my0DActor->SetRepresentation(aReperesent);
+ myBallActor->SetRepresentation(aReperesent);
//my0DExtActor->SetRepresentation(aReperesent);
switch(myControlMode){
{
if(myIsHighlighted) {
myHighlitableActor->SetProperty(myHighlightProp);
+ myBallActor->SetProperty(myBallHighlightProp);
}else if(myIsPreselected){
myHighlitableActor->SetProperty(myPreselectProp);
+ myBallActor->SetProperty(myBallPreselectProp);
} else if(anIsVisible){
+ myBallActor->SetProperty(myBallProp);
(myRepresentation == eSurface) ?
myHighlitableActor->SetProperty(myOutLineProp) : myHighlitableActor->SetProperty(myEdgeProp);
}
if(my0DActor)
my0DActor->UpdateLabels();
+ if(myBallActor)
+ myBallActor->UpdateLabels();
+
if(my1DActor)
my1DActor->UpdateLabels();
void SMESH_ActorDef::SetOpacity(vtkFloatingPointType theValue){
mySurfaceProp->SetOpacity(theValue);
myBackSurfaceProp->SetOpacity(theValue);
+ myNormalVProp->SetOpacity(theValue);
+ myReversedVProp->SetOpacity(theValue);
myEdgeProp->SetOpacity(theValue);
+ myOutLineProp->SetOpacity(theValue);
myNodeProp->SetOpacity(theValue);
my1DProp->SetOpacity(theValue);
+ my0DProp->SetOpacity(theValue);
+ myBallProp->SetOpacity(theValue);
}
void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta){
mySurfaceProp->SetColor(r,g,b);
+ my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
- if( aGroupObj->GetElementType() == SMDSAbs_Face ||
- aGroupObj->GetElementType() == SMDSAbs_Volume )
+ if( aGroupObj->GetElementType() == SMDSAbs_Face )
myNameActor->SetBackgroundColor(r,g,b);
myDeltaBrightness = delta;
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);
delta = myDeltaBrightness;
}
+void SMESH_ActorDef::SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta){
+ myNormalVProp->SetColor(r,g,b);
+ my3DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
+ if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
+ if( aGroupObj->GetElementType() == SMDSAbs_Volume )
+ myNameActor->SetBackgroundColor(r,g,b);
+
+ myDeltaVBrightness = delta;
+ QColor bfc = Qtx::mainColorToSecondary(QColor(int(r*255),int(g*255),int(b*255)), delta);
+ myReversedVProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. );
+ Modified();
+}
+
+void SMESH_ActorDef::GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta){
+ ::GetColor(myNormalVProp,r,g,b);
+ delta = myDeltaVBrightness;
+}
+
void SMESH_ActorDef::SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
myEdgeProp->SetColor(r,g,b);
my1DProp->SetColor(r,g,b);
::GetColor(my0DProp,r,g,b);
}
+void SMESH_ActorDef::SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+ myBallProp->SetColor(r,g,b);
+ if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
+ if( aGroupObj->GetElementType() == SMDSAbs_Ball )
+ myNameActor->SetBackgroundColor(r,g,b);
+ Modified();
+}
+
+void SMESH_ActorDef::GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+ ::GetColor(myBallProp,r,g,b);
+}
+
void SMESH_ActorDef::SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
myHighlightProp->SetColor(r,g,b);
+ myBallHighlightProp->SetColor(r,g,b);
Modified();
}
void SMESH_ActorDef::SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
myPreselectProp->SetColor(r,g,b);
+ myBallPreselectProp->SetColor(r,g,b);
Modified();
}
myEdgeProp->SetLineWidth(theVal);
my1DProp->SetLineWidth(theVal + aLineWidthInc);
- my1DExtProp->SetLineWidth(theVal + aLineWidthInc);
-
+ my1DExtProp->SetLineWidth(theVal + aLineWidthInc);
+ my2DExtProp->SetLineWidth(theVal + aLineWidthInc);
+ my3DExtProp->SetLineWidth(theVal + aLineWidthInc);
+ myOutLineProp->SetLineWidth(theVal);
+ myHighlightProp->SetLineWidth(theVal);
+ myPreselectProp->SetLineWidth(theVal);
Modified();
}
+vtkFloatingPointType SMESH_ActorDef::GetOutlineWidth()
+{
+ return myOutLineProp->GetLineWidth();
+}
+
+void SMESH_ActorDef::SetOutlineWidth(vtkFloatingPointType theVal)
+{
+ myOutLineProp->SetLineWidth(theVal);
+ Modified();
+}
void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){
my0DProp->SetPointSize(theVal);
+ myHighlightProp->SetPointSize(theVal);
+ myPreselectProp->SetPointSize(theVal);
+
+ if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myHighlightActor )) {
+ aCustom->Set0DSize(theVal);
+ }
+ if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myPreHighlightActor )) {
+ aCustom->Set0DSize(theVal);
+ }
+
Modified();
}
return my0DProp->GetPointSize();
}
+void SMESH_ActorDef::SetBallSize(vtkFloatingPointType theVal){
+ myBallProp->SetPointSize(theVal);
+ myBallHighlightProp->SetPointSize(theVal);
+ myBallPreselectProp->SetPointSize(theVal);
+ if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myHighlightActor )) {
+ aCustom->SetBallSize(theVal);
+ }
+ if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myPreHighlightActor )) {
+ aCustom->SetBallSize(theVal);
+ }
+
+ Modified();
+}
+
+vtkFloatingPointType SMESH_ActorDef::GetBallSize(){
+ return myBallProp->GetPointSize();
+}
+
int SMESH_ActorDef::GetObjDimension( const int theObjId )
{
return myVisualObj->GetElemDimension( theObjId );
myNodeExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
my0DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
+ myBallActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
//my0DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
my1DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
