#include <SMESH_ActorDef.h>
Public Types | |
| enum | EReperesent { ePoint, eEdge, eSurface } |
| enum | EEntityMode { e0DElements = 0x01, eEdges = 0x02, eFaces = 0x04, eVolumes = 0x08, eAllEntity = 0x0f } |
| enum | EQuadratic2DRepresentation { eLines = 0x01, eArcs = 0x02 } |
| enum | eControl { eNone, eLength, eLength2D, eFreeBorders, eFreeEdges, eFreeNodes, eFreeFaces, eMultiConnection, eArea, eTaper, eAspectRatio, eMinimumAngle, eWarping, eSkew, eAspectRatio3D, eMultiConnection2D, eVolume3D, eMaxElementLength2D, eMaxElementLength3D, eBareBorderFace, eBareBorderVolume, eOverConstrainedFace, eOverConstrainedVolume } |
Public Member Functions | |
| vtkTypeMacro (SMESH_ActorDef, SMESH_Actor) | |
| virtual void | ReleaseGraphicsResources (vtkWindow *renWin) |
| virtual int | RenderOpaqueGeometry (vtkViewport *viewport) |
| virtual int | RenderTranslucentGeometry (vtkViewport *viewport) |
| virtual void | Render (vtkRenderer *ren) |
| virtual void | AddToRender (vtkRenderer *theRenderer) |
| virtual void | RemoveFromRender (vtkRenderer *theRenderer) |
| virtual bool | hasHighlight () |
| virtual void | highlight (bool theHighlight) |
| virtual void | SetPreSelected (bool thePreselect=false) |
| virtual bool | IsInfinitive () |
| virtual void | SetOpacity (vtkFloatingPointType theValue) |
| virtual vtkFloatingPointType | GetOpacity () |
| virtual void | SetSufaceColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b) |
| virtual void | GetSufaceColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b) |
| virtual void | SetBackSufaceColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b) |
| virtual void | GetBackSufaceColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b) |
| virtual void | SetEdgeColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b) |
| virtual void | GetEdgeColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b) |
| virtual void | SetNodeColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b) |
| virtual void | GetNodeColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b) |
| virtual void | Set0DColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b) |
| virtual void | Get0DColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b) |
| virtual void | SetHighlightColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b) |
| virtual void | GetHighlightColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b) |
| virtual void | SetPreHighlightColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b) |
| virtual void | GetPreHighlightColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b) |
| virtual vtkFloatingPointType | GetLineWidth () |
| virtual void | SetLineWidth (vtkFloatingPointType theVal) |
| virtual void | Set0DSize (vtkFloatingPointType size) |
| virtual vtkFloatingPointType | Get0DSize () |
| virtual int | GetNodeObjId (int theVtkID) |
| virtual vtkFloatingPointType * | GetNodeCoord (int theObjID) |
| virtual int | GetElemObjId (int theVtkID) |
| virtual vtkCell * | GetElemCell (int theObjID) |
| virtual int | GetObjDimension (const int theObjId) |
| virtual void | SetVisibility (int theMode) |
| void | SetVisibility (int theMode, bool theIsUpdateRepersentation) |
| virtual void | SetRepresentation (int theMode) |
| virtual unsigned int | GetEntityMode () const |
| virtual void | SetEntityMode (unsigned int theMode) |
| virtual void | SetPointRepresentation (bool theIsPointsVisible) |
| virtual bool | GetPointRepresentation () |
| virtual vtkFloatingPointType * | GetBounds () |
| virtual void | SetTransform (VTKViewer_Transform *theTransform) |
| virtual vtkUnstructuredGrid * | GetUnstructuredGrid () |
| virtual vtkDataSet * | GetInput () |
| virtual vtkMapper * | GetMapper () |
| virtual vtkFloatingPointType | GetShrinkFactor () |
| virtual void | SetShrinkFactor (vtkFloatingPointType theValue) |
| virtual bool | IsShrunkable () |
| virtual bool | IsShrunk () |
| virtual void | SetShrink () |
| virtual void | UnShrink () |
| virtual void | SetPointsLabeled (bool theIsPointsLabeled) |
| virtual bool | GetPointsLabeled () |
| virtual void | SetCellsLabeled (bool theIsCellsLabeled) |
| virtual bool | GetCellsLabeled () |
| virtual void | SetFacesOriented (bool theIsFacesOriented) |
| virtual bool | GetFacesOriented () |
| virtual void | SetFacesOrientationColor (vtkFloatingPointType theColor[3]) |
| virtual void | GetFacesOrientationColor (vtkFloatingPointType theColor[3]) |
| virtual void | SetFacesOrientationScale (vtkFloatingPointType theScale) |
| virtual vtkFloatingPointType | GetFacesOrientationScale () |
| virtual void | SetFacesOrientation3DVectors (bool theState) |
| virtual bool | GetFacesOrientation3DVectors () |
| virtual void | SetControlMode (eControl theMode) |
| virtual eControl | GetControlMode () |
| virtual SMESH::Controls::FunctorPtr | GetFunctor () |
| virtual SMESH_ScalarBarActor * | GetScalarBarActor () |
| virtual void | RemoveAllClippingPlanes () |
| virtual vtkIdType | GetNumberOfClippingPlanes () |
| virtual vtkPlane * | GetClippingPlane (vtkIdType theID) |
| virtual vtkIdType | AddClippingPlane (vtkPlane *thePlane) |
| virtual TVisualObjPtr | GetObject () |
| virtual void | SetControlsPrecision (const long p) |
| virtual long | GetControlsPrecision () const |
| virtual void | UpdateScalarBar () |
| virtual void | UpdateDistribution () |
| virtual SPlot2d_Histogram * | GetPlot2Histogram () |
| virtual SPlot2d_Histogram * | UpdatePlot2Histogram () |
| virtual void | SetQuadratic2DRepresentation (EQuadratic2DRepresentation) |
| virtual EQuadratic2DRepresentation | GetQuadratic2DRepresentation () |
| virtual void | SetMarkerStd (VTK::MarkerType, VTK::MarkerScale) |
| virtual void | SetMarkerTexture (int, VTK::MarkerTexture) |
| vtkTypeMacro (SMESH_Actor, SALOME_Actor) | |
Static Public Member Functions | |
| static SMESH_Actor * | New (TVisualObjPtr theVisualObj, const char *theEntry, const char *theName, int theIsClear) |
Protected Types | |
| typedef TVTKSmartPtr< vtkPlane > | TPlanePtr |
| typedef std::vector< TPlanePtr > | TCippingPlaneCont |
Protected Member Functions | |
| void | SetControlMode (eControl theMode, bool theCheckEntityMode) |
| void | SetImplicitFunctionUsed (bool theIsImplicitFunctionUsed) |
| bool | IsImplicitFunctionUsed () const |
| SMESH_ActorDef () | |
| ~SMESH_ActorDef () | |
| bool | Init (TVisualObjPtr theVisualObj, const char *theEntry, const char *theName, int theIsClear) |
| void | SetIsShrunkable (bool theShrunkable) |
| void | UpdateHighlight () |
| void | Update () |
Protected Attributes | |
| TVisualObjPtr | myVisualObj |
| vtkTimeStamp * | myTimeStamp |
| SMESH_ScalarBarActor * | myScalarBarActor |
| vtkLookupTable * | myLookupTable |
| vtkProperty * | mySurfaceProp |
| vtkProperty * | myBackSurfaceProp |
| vtkProperty * | myEdgeProp |
| vtkProperty * | myNodeProp |
| VTKViewer_DataSetMapper * | myMapper |
| SMESH_DeviceActor * | myBaseActor |
| SMESH_DeviceActor * | myNodeActor |
| SMESH_DeviceActor * | myPickableActor |
| vtkProperty * | myHighlightProp |
| vtkProperty * | myPreselectProp |
| SMESH_DeviceActor * | myHighlitableActor |
| eControl | myControlMode |
| SMESH::Controls::FunctorPtr | myFunctor |
| vtkProperty * | my2DExtProp |
| SMESH_DeviceActor * | my2DActor |
| SMESH_DeviceActor * | my2DExtActor |
| SMESH_DeviceActor * | my3DActor |
| SMESH_DeviceActor * | my3DExtActor |
| SMESH_DeviceActor * | myControlActor |
| vtkProperty * | myNodeExtProp |
| SMESH_DeviceActor * | myNodeExtActor |
| vtkProperty * | my1DProp |
| SMESH_DeviceActor * | my1DActor |
| vtkProperty * | my1DExtProp |
| SMESH_DeviceActor * | my1DExtActor |
| vtkProperty * | my0DProp |
| SMESH_DeviceActor * | my0DActor |
| vtkProperty * | my0DExtProp |
| SMESH_DeviceActor * | my0DExtActor |
| unsigned int | myEntityMode |
| unsigned int | myEntityState |
| bool | myIsPointsVisible |
| bool | myIsShrinkable |
| bool | myIsShrunk |
| bool | myIsPointsLabeled |
| vtkUnstructuredGrid * | myPointsNumDataSet |
| vtkActor2D * | myPointLabels |
| vtkMaskPoints * | myPtsMaskPoints |
| vtkLabeledDataMapper * | myPtsLabeledDataMapper |
| vtkSelectVisiblePoints * | myPtsSelectVisiblePoints |
| bool | myIsCellsLabeled |
| vtkUnstructuredGrid * | myCellsNumDataSet |
| vtkActor2D * | myCellsLabels |
| vtkMaskPoints * | myClsMaskPoints |
| VTKViewer_CellCenters * | myCellCenters |
| vtkLabeledDataMapper * | myClsLabeledDataMapper |
| vtkSelectVisiblePoints * | myClsSelectVisiblePoints |
| vtkImplicitBoolean * | myImplicitBoolean |
| TCippingPlaneCont | myCippingPlaneCont |
| long | myControlsPrecision |
| SPlot2d_Histogram * | my2dHistogram |
| bool | myIsFacesOriented |
| VTK::MarkerTexture | myMarkerTexture |
Private Member Functions | |
| virtual void | Render (vtkRenderer *, vtkMapper *) |
| virtual void | ShallowCopy (vtkProp *prop) |
| virtual void | SetMapper (vtkMapper *) |
| SMESH_ActorDef (const SMESH_ActorDef &) | |
| void | operator= (const SMESH_ActorDef &) |
Static Private Member Functions | |
| static SMESH_ActorDef * | New () |
Friends | |
| class | SMESH_VisualObj |
| class | SMESH_Actor |
Detailed Description
Definition at line 83 of file SMESH_ActorDef.h.
Member Typedef Documentation
typedef std::vector<TPlanePtr> SMESH_ActorDef.TCippingPlaneCont [protected] |
Definition at line 290 of file SMESH_ActorDef.h.
typedef TVTKSmartPtr<vtkPlane> SMESH_ActorDef.TPlanePtr [protected] |
Definition at line 289 of file SMESH_ActorDef.h.
Member Enumeration Documentation
enum SMESH_Actor::eControl [inherited] |
- Enumerator:
Definition at line 128 of file SMESH_Actor.h.
{eNone, eLength, eLength2D, eFreeBorders, eFreeEdges, eFreeNodes,
eFreeFaces, eMultiConnection, eArea, eTaper, eAspectRatio,
eMinimumAngle, eWarping, eSkew, eAspectRatio3D, eMultiConnection2D, eVolume3D,
eMaxElementLength2D, eMaxElementLength3D, eBareBorderFace, eBareBorderVolume,
eOverConstrainedFace, eOverConstrainedVolume};
enum SMESH_Actor::EEntityMode [inherited] |
Definition at line 93 of file SMESH_Actor.h.
{ e0DElements = 0x01, eEdges = 0x02, eFaces = 0x04, eVolumes = 0x08, eAllEntity = 0x0f};
enum SMESH_Actor::EQuadratic2DRepresentation [inherited] |
Definition at line 95 of file SMESH_Actor.h.
enum SMESH_Actor::EReperesent [inherited] |
Definition at line 91 of file SMESH_Actor.h.
Constructor & Destructor Documentation
| SMESH_ActorDef::SMESH_ActorDef | ( | ) | [protected] |
Definition at line 121 of file SMESH_Actor.cxx.
References SMESH_Actor.eAllEntity, SMESH_DeviceActor.eInsideframe, SMESH_Actor.eNone, SMESH_DeviceActor.ePoint, SMESH_DeviceActor.eSurface, SMESH_DeviceActor.eWireframe, GetColor(), SMESH_DeviceActor.GetExtractUnstructuredGrid(), SMESH.GetFloat(), SMESH_DeviceActor.GetUnstructuredGrid(), MESSAGE, my0DActor, my0DProp, my1DActor, my1DExtActor, my1DExtProp, my1DProp, my2DActor, my2DExtActor, my2DExtProp, my2dHistogram, my3DActor, my3DExtActor, myBackSurfaceProp, myBaseActor, myCellCenters, myCellsLabels, myCellsNumDataSet, myClsLabeledDataMapper, myClsMaskPoints, myClsSelectVisiblePoints, myControlActor, myControlMode, myControlsPrecision, myEdgeProp, myEntityMode, myHighlightProp, myHighlitableActor, myImplicitBoolean, myIsCellsLabeled, myIsFacesOriented, myIsPointsLabeled, myIsPointsVisible, myIsShrinkable, myIsShrunk, myLookupTable, myMapper, myNodeActor, myNodeExtActor, myNodeExtProp, myNodeProp, myPickableActor, myPointLabels, myPointsNumDataSet, myPreselectProp, myPtsLabeledDataMapper, myPtsMaskPoints, myPtsSelectVisiblePoints, myScalarBarActor, mySurfaceProp, myTimeStamp, New(), SMESH_DeviceActor.SetHighlited(), SMESH_ScalarBarActor.SetLookupTable(), SMESH_DeviceActor.SetQuadraticArcAngle(), SMESH_DeviceActor.SetQuadraticArcMode(), SMESH_DeviceActor.SetRepresentation(), SMESH_DeviceActor.SetStoreClippingMapping(), SMESH_DeviceActor.SetStoreGemetryMapping(), and SMESH_DeviceActor.SetVisibility().
Referenced by New().
{
if(MYDEBUG) MESSAGE("SMESH_ActorDef - "<<this);
myTimeStamp = vtkTimeStamp::New();
myIsPointsVisible = false;
myIsShrinkable = false;
myIsShrunk = false;
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);
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 devices of the actor
//-----------------------------------------
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] );
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] );
my2DActor = SMESH_DeviceActor::New();
my2DActor->SetUserMatrix(aMatrix);
my2DActor->PickableOff();
my2DActor->SetProperty(mySurfaceProp);
my2DActor->SetBackfaceProperty(myBackSurfaceProp);
my2DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
aFilter = my2DActor->GetExtractUnstructuredGrid();
aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
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);
my3DActor->PickableOff();
my3DActor->SetProperty(mySurfaceProp);
my3DActor->SetBackfaceProperty(myBackSurfaceProp);
my3DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
aFilter = my3DActor->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);
//#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
//---------------------------------
myEdgeProp = vtkProperty::New();
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 ) );
myEdgeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
myEdgeProp->SetLineWidth(aLineWidth);
my1DActor = SMESH_DeviceActor::New();
my1DActor->SetUserMatrix(aMatrix);
my1DActor->PickableOff();
my1DActor->SetHighlited(true);
my1DActor->SetProperty(myEdgeProp);
my1DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
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(aElem0DSize);
my1DExtProp = vtkProperty::New();
my1DExtProp->DeepCopy(myEdgeProp);
anRGB[0] = 1 - anRGB[0];
anRGB[1] = 1 - anRGB[1];
anRGB[2] = 1 - anRGB[2];
my1DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
my1DExtProp->SetLineWidth(aLineWidth + aLineWidthInc);
my1DExtProp->SetPointSize(aElem0DSize);
my1DExtActor = SMESH_DeviceActor::New();
my1DExtActor->SetUserMatrix(aMatrix);
my1DExtActor->PickableOff();
my1DExtActor->SetHighlited(true);
my1DExtActor->SetVisibility(false);
my1DExtActor->SetProperty(my1DExtProp);
my1DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe);
aFilter = my1DExtActor->GetExtractUnstructuredGrid();
aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
aFilter->RegisterCellsWithType(VTK_LINE);
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->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]);
myNodeActor = SMESH_DeviceActor::New();
myNodeActor->SetUserMatrix(aMatrix);
myNodeActor->SetStoreClippingMapping(true);
myNodeActor->PickableOff();
myNodeActor->SetVisibility(false);
myNodeActor->SetProperty(myNodeProp);
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]);
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
//----------------------------------------------
myBaseActor = SMESH_DeviceActor::New();
myBaseActor->SetUserMatrix(aMatrix);
myBaseActor->SetStoreGemetryMapping(true);
myBaseActor->GetProperty()->SetOpacity(0.0);
myPickableActor = myBaseActor;
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(aElem0DSize); // ??
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(aElem0DSize); // ??
myPreselectProp->SetRepresentation(1);
myHighlitableActor = SMESH_DeviceActor::New();
myHighlitableActor->SetUserMatrix(aMatrix);
myHighlitableActor->PickableOff();
myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
aMatrix->Delete();
myName = "";
myIO = NULL;
myControlMode = eNone;
myControlActor = my2DActor;
//Definition of myScalarBarActor
//------------------------------
myLookupTable = vtkLookupTable::New();
//Fix for Bug PAL5195 - SMESH764:
//Controls - Aspect Ratio: incorrect colors of the best and worst values
myLookupTable->SetHueRange(0.667,0.0);
myScalarBarActor = SMESH_ScalarBarActor::New();
myScalarBarActor->SetVisibility(false);
myScalarBarActor->SetLookupTable(myLookupTable);
//Fix for Bug 13314:
//Incorrect "Min value" in Scalar Bar in Mesh:
// myScalarBarActor->SetLabelFormat("%.4g");
// changes was commented because of regression bug IPAL 19981
mgr = SUIT_Session::session()->resourceMgr();
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);
// 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 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
}
| SMESH_ActorDef::~SMESH_ActorDef | ( | ) | [protected] |
Definition at line 540 of file SMESH_Actor.cxx.
References SMESH.DeleteActorEvent, MESSAGE, my0DActor, my0DProp, my1DActor, my1DExtActor, my1DExtProp, my1DProp, my2DActor, my2DExtActor, my2DExtProp, my2dHistogram, my3DActor, my3DExtActor, myBackSurfaceProp, myBaseActor, myCellCenters, myCellsLabels, myCellsNumDataSet, myClsLabeledDataMapper, myClsMaskPoints, myClsSelectVisiblePoints, myEdgeProp, myHighlightProp, myHighlitableActor, myImplicitBoolean, myLookupTable, myMapper, myNodeActor, myNodeExtActor, myNodeExtProp, myNodeProp, myPointLabels, myPointsNumDataSet, myPreselectProp, myPtsLabeledDataMapper, myPtsMaskPoints, myPtsSelectVisiblePoints, myScalarBarActor, mySurfaceProp, myTimeStamp, SMESH.ProcessIn2DViewers(), and SMESH.RemoveFrom2dViewer.
{
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();
mySurfaceProp->Delete();
myBackSurfaceProp->Delete();
myEdgeProp->Delete();
myHighlightProp->Delete();
myPreselectProp->Delete();
myNodeProp->Delete();
myNodeExtProp->Delete();
my0DProp->Delete();
my0DActor->Delete();
//my0DExtProp->Delete();
//my0DExtActor->Delete();
my1DProp->Delete();
my1DActor->Delete();
my1DExtProp->Delete();
my1DExtActor->Delete();
my2DActor->Delete();
my2DExtProp->Delete();
my2DExtActor->Delete();
my3DActor->Delete();
my3DExtActor->Delete();
myNodeActor->Delete();
myBaseActor->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();
myMapper->Delete();
myTimeStamp->Delete();
}
| SMESH_ActorDef.SMESH_ActorDef | ( | const SMESH_ActorDef & | ) | [private] |
Member Function Documentation
| vtkIdType SMESH_ActorDef::AddClippingPlane | ( | vtkPlane * | thePlane | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1898 of file SMESH_Actor.cxx.
References IsImplicitFunctionUsed(), myCippingPlaneCont, myImplicitBoolean, and SetImplicitFunctionUsed().
{
if(thePlane){
myImplicitBoolean->GetFunction()->AddItem(thePlane);
myCippingPlaneCont.push_back(thePlane);
if(!IsImplicitFunctionUsed())
SetImplicitFunctionUsed(true);
}
return myCippingPlaneCont.size();
}
| void SMESH_ActorDef::AddToRender | ( | vtkRenderer * | theRenderer | ) | [virtual] |
Definition at line 986 of file SMESH_Actor.cxx.
References SMESH_DeviceActor.AddToRender(), my0DActor, my1DActor, my1DExtActor, my2DActor, my2DExtActor, my3DActor, my3DExtActor, myBaseActor, myCellsLabels, myClsSelectVisiblePoints, myHighlitableActor, myNodeActor, myNodeExtActor, myPointLabels, myPtsSelectVisiblePoints, and myScalarBarActor.
{
theRenderer->AddActor(myNodeActor);
theRenderer->AddActor(myBaseActor);
theRenderer->AddActor(myNodeExtActor);
my3DActor->AddToRender(theRenderer);
my3DExtActor->AddToRender(theRenderer);
my2DActor->AddToRender(theRenderer);
my2DExtActor->AddToRender(theRenderer);
theRenderer->AddActor(my1DActor);
theRenderer->AddActor(my1DExtActor);
theRenderer->AddActor(my0DActor);
//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::Get0DColor | ( | vtkFloatingPointType & | r, |
| vtkFloatingPointType & | g, | ||
| vtkFloatingPointType & | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1816 of file SMESH_Actor.cxx.
References GetColor(), and my0DProp.
{
::GetColor(my0DProp,r,g,b);
}
| vtkFloatingPointType SMESH_ActorDef::Get0DSize | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1859 of file SMESH_Actor.cxx.
References my0DProp.
{
return my0DProp->GetPointSize();
}
| void SMESH_ActorDef::GetBackSufaceColor | ( | vtkFloatingPointType & | r, |
| vtkFloatingPointType & | g, | ||
| vtkFloatingPointType & | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1777 of file SMESH_Actor.cxx.
References GetColor(), and myBackSurfaceProp.
{
::GetColor(myBackSurfaceProp,r,g,b);
}
| vtkFloatingPointType * SMESH_ActorDef::GetBounds | ( | ) | [virtual] |
Definition at line 1128 of file SMESH_Actor.cxx.
References myNodeActor.
{
return myNodeActor->GetBounds();
}
| virtual bool SMESH_ActorDef.GetCellsLabeled | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 173 of file SMESH_ActorDef.h.
References myIsCellsLabeled.
{ return myIsCellsLabeled;}
| vtkPlane * SMESH_ActorDef::GetClippingPlane | ( | vtkIdType | theID | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1928 of file SMESH_Actor.cxx.
References myCippingPlaneCont.
{
if(theID >= myCippingPlaneCont.size())
return NULL;
return myCippingPlaneCont[theID].Get();
}
| virtual eControl SMESH_ActorDef.GetControlMode | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 188 of file SMESH_ActorDef.h.
References myControlMode.
Referenced by Update().
{ return myControlMode;}
| virtual long SMESH_ActorDef.GetControlsPrecision | ( | ) | const [virtual] |
Implements SMESH_Actor.
Definition at line 201 of file SMESH_ActorDef.h.
References myControlsPrecision.
{ return myControlsPrecision; }
| void SMESH_ActorDef::GetEdgeColor | ( | vtkFloatingPointType & | r, |
| vtkFloatingPointType & | g, | ||
| vtkFloatingPointType & | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1791 of file SMESH_Actor.cxx.
References GetColor(), and myEdgeProp.
{
::GetColor(myEdgeProp,r,g,b);
}
| vtkCell * SMESH_ActorDef::GetElemCell | ( | int | theObjID | ) | [virtual] |
Definition at line 1266 of file SMESH_Actor.cxx.
References SMESH_DeviceActor.GetElemCell(), and myPickableActor.
{
return myPickableActor->GetElemCell(theObjID);
}
Definition at line 1262 of file SMESH_Actor.cxx.
References SMESH_DeviceActor.GetElemObjId(), and myPickableActor.
{
return myPickableActor->GetElemObjId(theVtkID);
}
| virtual unsigned int SMESH_ActorDef.GetEntityMode | ( | ) | const [virtual] |
Implements SMESH_Actor.
Definition at line 148 of file SMESH_ActorDef.h.
References myEntityMode.
Referenced by Update().
{ return myEntityMode;}
| bool SMESH_ActorDef::GetFacesOrientation3DVectors | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 743 of file SMESH_Actor.cxx.
References SMESH_DeviceActor.GetFacesOrientation3DVectors(), and my3DActor.
{
return my3DActor->GetFacesOrientation3DVectors();
}
| void SMESH_ActorDef::GetFacesOrientationColor | ( | vtkFloatingPointType | theColor[3] | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 721 of file SMESH_Actor.cxx.
References SMESH_DeviceActor.GetFacesOrientationColor(), and my3DActor.
{
my3DActor->GetFacesOrientationColor( theColor );
}
| vtkFloatingPointType SMESH_ActorDef::GetFacesOrientationScale | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 732 of file SMESH_Actor.cxx.
References SMESH_DeviceActor.GetFacesOrientationScale(), and my3DActor.
{
return my3DActor->GetFacesOrientationScale();
}
| bool SMESH_ActorDef::GetFacesOriented | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 710 of file SMESH_Actor.cxx.
References myIsFacesOriented.
{
return myIsFacesOriented;
}
| virtual SMESH::Controls::FunctorPtr SMESH_ActorDef.GetFunctor | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 189 of file SMESH_ActorDef.h.
References myFunctor.
{ return myFunctor; }
| void SMESH_ActorDef::GetHighlightColor | ( | vtkFloatingPointType & | r, |
| vtkFloatingPointType & | g, | ||
| vtkFloatingPointType & | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1825 of file SMESH_Actor.cxx.
References GetColor(), and myHighlightProp.
{
::GetColor(myHighlightProp,r,g,b);
}
| vtkDataSet * SMESH_ActorDef::GetInput | ( | ) | [virtual] |
Definition at line 1133 of file SMESH_Actor.cxx.
References GetUnstructuredGrid().
{
return GetUnstructuredGrid();
}
| vtkFloatingPointType SMESH_ActorDef::GetLineWidth | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1839 of file SMESH_Actor.cxx.
References myEdgeProp.
{
return myEdgeProp->GetLineWidth();
}
| vtkMapper * SMESH_ActorDef::GetMapper | ( | ) | [virtual] |
| void SMESH_ActorDef::GetNodeColor | ( | vtkFloatingPointType & | r, |
| vtkFloatingPointType & | g, | ||
| vtkFloatingPointType & | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1804 of file SMESH_Actor.cxx.
References GetColor(), and myNodeProp.
{
::GetColor(myNodeProp,r,g,b);
}
| vtkFloatingPointType * SMESH_ActorDef::GetNodeCoord | ( | int | theObjID | ) | [virtual] |
Definition at line 1257 of file SMESH_Actor.cxx.
References SMESH_DeviceActor.GetNodeCoord(), and myPickableActor.
{
return myPickableActor->GetNodeCoord(theObjID);
}
Definition at line 1253 of file SMESH_Actor.cxx.
References SMESH_DeviceActor.GetNodeObjId(), and myPickableActor.
{
return myPickableActor->GetNodeObjId(theVtkID);
}
| vtkIdType SMESH_ActorDef::GetNumberOfClippingPlanes | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1921 of file SMESH_Actor.cxx.
References myCippingPlaneCont.
{
return myCippingPlaneCont.size();
}
Definition at line 1863 of file SMESH_Actor.cxx.
References myVisualObj.
{
return myVisualObj->GetElemDimension( theObjId );
}
| virtual TVisualObjPtr SMESH_ActorDef.GetObject | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 198 of file SMESH_ActorDef.h.
References myVisualObj.
{ return myVisualObj;}
| vtkFloatingPointType SMESH_ActorDef::GetOpacity | ( | ) | [virtual] |
Definition at line 1753 of file SMESH_Actor.cxx.
References mySurfaceProp.
{
return mySurfaceProp->GetOpacity();
}
| virtual SPlot2d_Histogram* SMESH_ActorDef.GetPlot2Histogram | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 207 of file SMESH_ActorDef.h.
References my2dHistogram.
{ return my2dHistogram; }
| bool SMESH_ActorDef::GetPointRepresentation | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1611 of file SMESH_Actor.cxx.
References myIsPointsLabeled, and myIsPointsVisible.
Referenced by SetRepresentation(), and UpdateHighlight().
{
return myIsPointsVisible || myIsPointsLabeled;
}
| virtual bool SMESH_ActorDef.GetPointsLabeled | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 170 of file SMESH_ActorDef.h.
References myIsPointsLabeled.
{ return myIsPointsLabeled;}
| void SMESH_ActorDef::GetPreHighlightColor | ( | vtkFloatingPointType & | r, |
| vtkFloatingPointType & | g, | ||
| vtkFloatingPointType & | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1834 of file SMESH_Actor.cxx.
References GetColor(), and myPreselectProp.
{
::GetColor(myPreselectProp,r,g,b);
}
| SMESH_Actor::EQuadratic2DRepresentation SMESH_ActorDef::GetQuadratic2DRepresentation | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 2108 of file SMESH_Actor.cxx.
References SMESH_Actor.eArcs, SMESH_Actor.eLines, SMESH_DeviceActor.GetQuadraticArcMode(), and myHighlitableActor.
Referenced by SetRepresentation().
{
if(myHighlitableActor->GetQuadraticArcMode())
return SMESH_Actor::eArcs;
else
return SMESH_Actor::eLines;
}
| virtual SMESH_ScalarBarActor* SMESH_ActorDef.GetScalarBarActor | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 191 of file SMESH_ActorDef.h.
References myScalarBarActor.
{ return myScalarBarActor;}
| vtkFloatingPointType SMESH_ActorDef::GetShrinkFactor | ( | ) | [virtual] |
Definition at line 1200 of file SMESH_Actor.cxx.
References SMESH_DeviceActor.GetShrinkFactor(), and myBaseActor.
{
return myBaseActor->GetShrinkFactor();
}
| void SMESH_ActorDef::GetSufaceColor | ( | vtkFloatingPointType & | r, |
| vtkFloatingPointType & | g, | ||
| vtkFloatingPointType & | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1767 of file SMESH_Actor.cxx.
References GetColor(), my2DExtProp, and mySurfaceProp.
{
::GetColor(mySurfaceProp,r,g,b);
my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
}
| vtkUnstructuredGrid * SMESH_ActorDef::GetUnstructuredGrid | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1178 of file SMESH_Actor.cxx.
References myVisualObj.
Referenced by GetInput(), SetCellsLabeled(), SetPointsLabeled(), SetRepresentation(), and UpdateHighlight().
{
return myVisualObj->GetUnstructuredGrid();
}
| virtual bool SMESH_ActorDef.hasHighlight | ( | ) | [virtual] |
Definition at line 99 of file SMESH_ActorDef.h.
{ return true; }
| void SMESH_ActorDef::highlight | ( | bool | theHighlight | ) | [virtual] |
Definition at line 1652 of file SMESH_Actor.cxx.
References UpdateHighlight().
{
if ( myIsHighlighted == theHighlight )
return;
myIsHighlighted = theHighlight;
UpdateHighlight();
}
| bool SMESH_ActorDef::Init | ( | TVisualObjPtr | theVisualObj, |
| const char * | theEntry, | ||
| const char * | theName, | ||
| int | theIsClear | ||
| ) | [protected] |
Definition at line 1045 of file SMESH_Actor.cxx.
References SMESH_Actor.eEdge, SMESH_Actor.ePoint, SMESH_Actor.eSurface, SMESH.GetFloat(), SMESH_DeviceActor.GetPolygonOffsetParameters(), Handle(), SMESH_DeviceActor.Init(), my0DActor, my1DActor, my1DExtActor, my2DActor, my2DExtActor, my3DActor, my3DExtActor, myBaseActor, myHighlitableActor, myImplicitBoolean, myLookupTable, myNodeActor, myNodeExtActor, myTimeStamp, myVisualObj, SetIsShrunkable(), SetMarkerStd(), SMESH_DeviceActor.SetPolygonOffsetParameters(), SetRepresentation(), SetShrink(), and SetShrinkFactor().
Referenced by SMESH_Actor.New().
{
Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry,"SMESH",theName);
setIO(anIO);
setName(theName);
myVisualObj = theVisualObj;
myVisualObj->Update(theIsClear);
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);
my3DExtActor->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);
my3DExtActor->GetMapper()->SetLookupTable(myLookupTable);
vtkFloatingPointType aFactor, aUnits;
my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
my2DExtActor->SetPolygonOffsetParameters(aFactor,aUnits*0.5);
SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
if( !mgr )
return false;
//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 == 0){
SetRepresentation(eEdge);
}else if(aMode == 1){
SetRepresentation(eSurface);
}else if(aMode == 2){
SetRepresentation(ePoint);
}
if(aMode == 3){
SetShrink();
}
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;
}
| bool SMESH_ActorDef::IsImplicitFunctionUsed | ( | ) | const [protected] |
Definition at line 1870 of file SMESH_Actor.cxx.
References SMESH_DeviceActor.IsImplicitFunctionUsed(), and myBaseActor.
Referenced by AddClippingPlane().
{
return myBaseActor->IsImplicitFunctionUsed();
}
| bool SMESH_ActorDef::IsInfinitive | ( | ) | [virtual] |
Definition at line 1183 of file SMESH_Actor.cxx.
References SMESH_DeviceActor.GetUnstructuredGrid(), and myPickableActor.
{
vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid();
aDataSet->Update();
myIsInfinite = aDataSet->GetNumberOfCells() == 0 ||
( aDataSet->GetNumberOfCells() == 1 &&
aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX );
return SALOME_Actor::IsInfinitive();
}
| virtual bool SMESH_ActorDef.IsShrunk | ( | ) | [virtual] |
| virtual bool SMESH_ActorDef.IsShrunkable | ( | ) | [virtual] |
Definition at line 164 of file SMESH_ActorDef.h.
References myIsShrinkable.
{ return myIsShrinkable;}
| SMESH_ActorDef * SMESH_ActorDef::New | ( | ) | [static, private] |
Reimplemented from SMESH_Actor.
Definition at line 97 of file SMESH_Actor.cxx.
References SMESH_ActorDef().
Referenced by vtkPVUpdateSuppressor.RequestData(), SetCellsLabeled(), SetPointsLabeled(), SMESH_ActorDef(), and UpdateScalarBar().
{
return new SMESH_ActorDef();
}
| SMESH_Actor * SMESH_Actor::New | ( | TVisualObjPtr | theVisualObj, |
| const char * | theEntry, | ||
| const char * | theName, | ||
| int | theIsClear | ||
| ) | [static, inherited] |
Definition at line 102 of file SMESH_Actor.cxx.
References Init(), SMESH_Actor.New(), and UpdateScalarBar().
{
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();
}
return anActor;
}
| void SMESH_ActorDef.operator= | ( | const SMESH_ActorDef & | ) | [private] |
| void SMESH_ActorDef::ReleaseGraphicsResources | ( | vtkWindow * | renWin | ) | [virtual] |
Definition at line 1728 of file SMESH_Actor.cxx.
References myPickableActor.
{
SALOME_Actor::ReleaseGraphicsResources(renWin);
myPickableActor->ReleaseGraphicsResources(renWin);
}
| void SMESH_ActorDef::RemoveAllClippingPlanes | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1911 of file SMESH_Actor.cxx.
References myCippingPlaneCont, myImplicitBoolean, and SetImplicitFunctionUsed().
{
myImplicitBoolean->GetFunction()->RemoveAllItems();
myImplicitBoolean->GetFunction()->Modified(); // VTK bug
myCippingPlaneCont.clear();
SetImplicitFunctionUsed(false);
}
| void SMESH_ActorDef::RemoveFromRender | ( | vtkRenderer * | theRenderer | ) | [virtual] |
Definition at line 1018 of file SMESH_Actor.cxx.
References my0DActor, my1DActor, my1DExtActor, my2DActor, my2DExtActor, my3DActor, my3DExtActor, myBaseActor, myCellsLabels, myHighlitableActor, myNodeActor, myNodeExtActor, myPointLabels, myScalarBarActor, and SMESH_DeviceActor.RemoveFromRender().
{
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);
theRenderer->RemoveActor(myScalarBarActor);
theRenderer->RemoveActor(myPointLabels);
theRenderer->RemoveActor(myCellsLabels);
}
| void SMESH_ActorDef::Render | ( | vtkRenderer * | ren | ) | [virtual] |
Definition at line 1693 of file SMESH_Actor.cxx.
References myImplicitBoolean, myTimeStamp, myVisualObj, and Update().
Referenced by RenderOpaqueGeometry(), and RenderTranslucentGeometry().
{
unsigned long aTime = myTimeStamp->GetMTime();
unsigned long anObjTime = myVisualObj->GetUnstructuredGrid()->GetMTime();
unsigned long aClippingTime = myImplicitBoolean->GetMTime();
if(anObjTime > aTime || aClippingTime > aTime)
Update();
}
| virtual void SMESH_ActorDef.Render | ( | vtkRenderer * | , |
| vtkMapper * | |||
| ) | [private, virtual] |
Definition at line 316 of file SMESH_ActorDef.h.
{};
| int SMESH_ActorDef::RenderOpaqueGeometry | ( | vtkViewport * | viewport | ) | [virtual] |
Definition at line 1669 of file SMESH_Actor.cxx.
References myPickableActor, and Render().
{
if (myPickableActor->GetIsOpaque())
{
vtkRenderer *ren = static_cast<vtkRenderer *>(vp);
this->Render(ren);
return 1;
}
return 0;
}
| int SMESH_ActorDef::RenderTranslucentGeometry | ( | vtkViewport * | viewport | ) | [virtual] |
Definition at line 1681 of file SMESH_Actor.cxx.
References myPickableActor, and Render().
{
if (!myPickableActor->GetIsOpaque())
{
vtkRenderer *ren = static_cast<vtkRenderer *>(vp);
this->Render(ren);
return 1;
}
return 0;
}
| void SMESH_ActorDef::Set0DColor | ( | vtkFloatingPointType | r, |
| vtkFloatingPointType | g, | ||
| vtkFloatingPointType | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1808 of file SMESH_Actor.cxx.
References my0DProp, myVisualObj, and SMDSAbs_0DElement.
{
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::Set0DSize | ( | vtkFloatingPointType | size | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1854 of file SMESH_Actor.cxx.
References my0DProp.
{
my0DProp->SetPointSize(theVal);
Modified();
}
| void SMESH_ActorDef::SetBackSufaceColor | ( | vtkFloatingPointType | r, |
| vtkFloatingPointType | g, | ||
| vtkFloatingPointType | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1772 of file SMESH_Actor.cxx.
References myBackSurfaceProp.
{
myBackSurfaceProp->SetColor(r,g,b);
Modified();
}
| void SMESH_ActorDef::SetCellsLabeled | ( | bool | theIsCellsLabeled | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 676 of file SMESH_Actor.cxx.
References GetUnstructuredGrid(), myCellCenters, myCellsLabels, myCellsNumDataSet, myIsCellsLabeled, myTimeStamp, myVisualObj, and New().
Referenced by Update().
{
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);
}
myTimeStamp->Modified();
}
| void SMESH_ActorDef::SetControlMode | ( | eControl | theMode | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 751 of file SMESH_Actor.cxx.
Referenced by Update().
{
SetControlMode(theMode,true);
}
Definition at line 759 of file SMESH_Actor.cxx.
References SMESH_Actor.eAllEntity, SMESH_Actor.eArea, SMESH_Actor.eAspectRatio, SMESH_Actor.eAspectRatio3D, SMESH_Actor.eBareBorderFace, SMESH_Actor.eBareBorderVolume, SMESH_Actor.eEdges, SMESH_Actor.eFaces, SMESH_Actor.eFreeBorders, SMESH_Actor.eFreeEdges, SMESH_Actor.eFreeFaces, SMESH_Actor.eFreeNodes, SMESH_Actor.eLength, SMESH_Actor.eLength2D, SMESH_Actor.eMaxElementLength2D, SMESH_Actor.eMaxElementLength3D, SMESH_Actor.eMinimumAngle, SMESH_Actor.eMultiConnection, SMESH_Actor.eMultiConnection2D, SMESH_Actor.eNone, SMESH_Actor.eOverConstrainedFace, SMESH_Actor.eOverConstrainedVolume, SMESH_Actor.eSkew, SMESH_Actor.eTaper, SMESH_Actor.eVolume3D, SMESH_Actor.eVolumes, SMESH_Actor.eWarping, SMESH_DeviceActor.GetUnstructuredGrid(), my0DActor, my1DActor, my1DExtActor, my2DActor, my2DExtActor, my3DActor, my3DExtActor, myControlActor, myControlMode, myControlsPrecision, myEntityMode, myFunctor, myLookupTable, myNodeActor, myNodeExtActor, myScalarBarActor, myTimeStamp, SMESH_DeviceActor.SetControlMode(), SetEntityMode(), SMESH_DeviceActor.SetExtControlMode(), SMESH.Controls.NumericalFunctor.SetPrecision(), SetRepresentation(), and UpdateDistribution().
{
SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
if( !mgr )
return;
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);
myScalarBarActor->SetVisibility(false);
bool anIsScalarVisible = theMode > eNone;
if(anIsScalarVisible) {
switch(theMode) {
case eLength:
{
SMESH::Controls::Length* aControl = new SMESH::Controls::Length();
aControl->SetPrecision( myControlsPrecision );
myFunctor.reset( aControl );
myControlActor = my1DActor;
break;
}
case eLength2D:
{
myFunctor.reset(new SMESH::Controls::Length2D());
myControlActor = my2DActor;
break;
}
case eFreeBorders:
myFunctor.reset(new SMESH::Controls::FreeBorders());
myControlActor = my1DActor;
break;
case eFreeEdges:
myFunctor.reset(new SMESH::Controls::FreeEdges());
myControlActor = my2DActor;
break;
case eFreeNodes:
myFunctor.reset(new SMESH::Controls::FreeNodes());
myControlActor = myNodeActor;
break;
case eFreeFaces:
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:
myFunctor.reset(new SMESH::Controls::MultiConnection());
myControlActor = my1DActor;
break;
case eMultiConnection2D:
myFunctor.reset(new SMESH::Controls::MultiConnection2D());
myControlActor = my2DActor;
break;
case eArea:
{
SMESH::Controls::Area* aControl = new SMESH::Controls::Area();
aControl->SetPrecision( myControlsPrecision );
myFunctor.reset( aControl );
myControlActor = my2DActor;
break;
}
case eTaper:
{
SMESH::Controls::Taper* aControl = new SMESH::Controls::Taper();
aControl->SetPrecision( myControlsPrecision );
myFunctor.reset( aControl );
myControlActor = my2DActor;
break;
}
case eAspectRatio:
{
SMESH::Controls::AspectRatio* aControl = new SMESH::Controls::AspectRatio();
aControl->SetPrecision( myControlsPrecision );
myFunctor.reset( aControl );
myControlActor = my2DActor;
break;
}
case eAspectRatio3D:
{
SMESH::Controls::AspectRatio3D* aControl = new SMESH::Controls::AspectRatio3D();
aControl->SetPrecision( myControlsPrecision );
myFunctor.reset( aControl );
myControlActor = my3DActor;
break;
}
case eVolume3D:
{
SMESH::Controls::Volume* aControl = new SMESH::Controls::Volume();
aControl->SetPrecision( myControlsPrecision );
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;
}
case eMinimumAngle:
{
SMESH::Controls::MinimumAngle* aControl = new SMESH::Controls::MinimumAngle();
aControl->SetPrecision( myControlsPrecision );
myFunctor.reset( aControl );
myControlActor = my2DActor;
break;
}
case eWarping:
{
SMESH::Controls::Warping* aControl = new SMESH::Controls::Warping();
aControl->SetPrecision( myControlsPrecision );
myFunctor.reset( aControl );
myControlActor = my2DActor;
break;
}
case eSkew:
{
SMESH::Controls::Skew* aControl = new SMESH::Controls::Skew();
aControl->SetPrecision( myControlsPrecision );
myFunctor.reset( aControl );
myControlActor = my2DActor;
break;
}
default:
return;
}
vtkUnstructuredGrid* aGrid = myControlActor->GetUnstructuredGrid();
vtkIdType aNbCells = aGrid->GetNumberOfCells();
if(aNbCells){
myControlMode = theMode;
switch(myControlMode){
case eFreeNodes:
myNodeExtActor->SetExtControlMode(myFunctor);
break;
case eFreeEdges:
case eFreeBorders:
my1DExtActor->SetExtControlMode(myFunctor);
break;
case eFreeFaces:
case eBareBorderFace:
case eOverConstrainedFace:
my2DExtActor->SetExtControlMode(myFunctor);
break;
case eBareBorderVolume:
case eOverConstrainedVolume:
my3DExtActor->SetExtControlMode(myFunctor);
break;
case eLength2D:
case eMultiConnection2D:
my1DExtActor->SetExtControlMode(myFunctor,myScalarBarActor,myLookupTable);
UpdateDistribution();
break;
default:
myControlActor->SetControlMode(myFunctor,myScalarBarActor,myLookupTable);
UpdateDistribution();
}
}
if(theCheckEntityMode){
if(myControlActor == my1DActor)
SetEntityMode(eEdges);
else if(myControlActor == my2DActor){
switch(myControlMode){
case eLength2D:
case eFreeEdges:
case eFreeFaces:
case eMultiConnection2D:
//SetEntityMode(eEdges);
SetEntityMode(eFaces);
break;
default:
SetEntityMode(eFaces);
}
}else if(myControlActor == my3DActor)
SetEntityMode(eVolumes);
}
}
else {
if(theCheckEntityMode)
myEntityMode = eAllEntity;
myFunctor.reset();
}
SetRepresentation(GetRepresentation());
myTimeStamp->Modified();
Modified();
}
| virtual void SMESH_ActorDef.SetControlsPrecision | ( | const long | p | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 200 of file SMESH_ActorDef.h.
References myControlsPrecision.
{ myControlsPrecision = p; }
| void SMESH_ActorDef::SetEdgeColor | ( | vtkFloatingPointType | r, |
| vtkFloatingPointType | g, | ||
| vtkFloatingPointType | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1781 of file SMESH_Actor.cxx.
References my1DExtProp, my1DProp, myEdgeProp, myVisualObj, and SMDSAbs_Edge.
{
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<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_Edge )
myNameActor->SetBackgroundColor(r,g,b);
Modified();
}
| void SMESH_ActorDef::SetEntityMode | ( | unsigned int | theMode | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1369 of file SMESH_Actor.cxx.
References SMESH_Actor.e0DElements, SMESH_Actor.eAllEntity, SMESH_Actor.eEdges, SMESH_Actor.eFaces, SMESH_Actor.eVolumes, SMESH_DeviceActor.GetExtractUnstructuredGrid(), MESSAGE, myBaseActor, myEntityMode, myEntityState, SMESH_DeviceActor.myGeomFilter, myHighlitableActor, myVisualObj, SetVisibility(), SMDSAbs_0DElement, SMDSAbs_Edge, SMDSAbs_Face, and SMDSAbs_Volume.
Referenced by SetControlMode(), and Update().
{
myEntityState = eAllEntity;
if(!myVisualObj->GetNbEntities(SMDSAbs_0DElement)) {
myEntityState &= ~e0DElements;
theMode &= ~e0DElements;
}
if(!myVisualObj->GetNbEntities(SMDSAbs_Edge)) {
myEntityState &= ~eEdges;
theMode &= ~eEdges;
}
if(!myVisualObj->GetNbEntities(SMDSAbs_Face)) {
myEntityState &= ~eFaces;
theMode &= ~eFaces;
}
if(!myVisualObj->GetNbEntities(SMDSAbs_Volume)) {
myEntityState &= ~eVolumes;
theMode &= ~eVolumes;
}
if (!theMode) {
if(myVisualObj->GetNbEntities(SMDSAbs_0DElement))
theMode |= e0DElements;
if(myVisualObj->GetNbEntities(SMDSAbs_Edge))
theMode |= eEdges;
if(myVisualObj->GetNbEntities(SMDSAbs_Face))
theMode |= eFaces;
if(myVisualObj->GetNbEntities(SMDSAbs_Volume))
theMode |= eVolumes;
}
myBaseActor->myGeomFilter->SetInside(myEntityMode != myEntityState);
myEntityMode = theMode;
VTKViewer_ExtractUnstructuredGrid* aFilter = NULL;
aFilter = myBaseActor->GetExtractUnstructuredGrid();
aFilter->ClearRegisteredCellsWithType();
aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
VTKViewer_ExtractUnstructuredGrid* aHightFilter = myHighlitableActor->GetExtractUnstructuredGrid();
aHightFilter->ClearRegisteredCellsWithType();
aHightFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
if (myEntityMode & e0DElements) {
if (MYDEBUG) MESSAGE("0D ELEMENTS");
aFilter->RegisterCellsWithType(VTK_VERTEX);
aHightFilter->RegisterCellsWithType(VTK_VERTEX);
}
if (myEntityMode & eEdges) {
if (MYDEBUG) MESSAGE("EDGES");
aFilter->RegisterCellsWithType(VTK_LINE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE);
aHightFilter->RegisterCellsWithType(VTK_LINE);
aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE);
}
if (myEntityMode & eFaces) {
if (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 (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);
//#ifdef VTK_HAVE_POLYHEDRON
aFilter->RegisterCellsWithType(VTK_POLYHEDRON);
//#endif
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_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());
SetVisibility(GetVisibility(),false);
}
| void SMESH_ActorDef::SetFacesOrientation3DVectors | ( | bool | theState | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 737 of file SMESH_Actor.cxx.
References my2DActor, my3DActor, and SMESH_DeviceActor.SetFacesOrientation3DVectors().
{
my2DActor->SetFacesOrientation3DVectors( theState );
my3DActor->SetFacesOrientation3DVectors( theState );
}
| void SMESH_ActorDef::SetFacesOrientationColor | ( | vtkFloatingPointType | theColor[3] | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 715 of file SMESH_Actor.cxx.
References my2DActor, my3DActor, and SMESH_DeviceActor.SetFacesOrientationColor().
{
my2DActor->SetFacesOrientationColor( theColor );
my3DActor->SetFacesOrientationColor( theColor );
}
| void SMESH_ActorDef::SetFacesOrientationScale | ( | vtkFloatingPointType | theScale | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 726 of file SMESH_Actor.cxx.
References my2DActor, my3DActor, and SMESH_DeviceActor.SetFacesOrientationScale().
{
my2DActor->SetFacesOrientationScale( theScale );
my3DActor->SetFacesOrientationScale( theScale );
}
| void SMESH_ActorDef::SetFacesOriented | ( | bool | theIsFacesOriented | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 700 of file SMESH_Actor.cxx.
References my2DActor, my3DActor, myIsFacesOriented, myTimeStamp, and SMESH_DeviceActor.SetFacesOriented().
Referenced by Update().
{
myIsFacesOriented = theIsFacesOriented;
my2DActor->SetFacesOriented(theIsFacesOriented);
my3DActor->SetFacesOriented(theIsFacesOriented);
myTimeStamp->Modified();
}
| void SMESH_ActorDef::SetHighlightColor | ( | vtkFloatingPointType | r, |
| vtkFloatingPointType | g, | ||
| vtkFloatingPointType | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1820 of file SMESH_Actor.cxx.
References myHighlightProp.
{
myHighlightProp->SetColor(r,g,b);
Modified();
}
| void SMESH_ActorDef::SetImplicitFunctionUsed | ( | bool | theIsImplicitFunctionUsed | ) | [protected] |
Definition at line 1876 of file SMESH_Actor.cxx.
References my0DActor, my1DActor, my1DExtActor, my2DActor, my2DExtActor, my3DActor, my3DExtActor, myBaseActor, myHighlitableActor, myNodeActor, myNodeExtActor, and SMESH_DeviceActor.SetImplicitFunctionUsed().
Referenced by AddClippingPlane(), and RemoveAllClippingPlanes().
{
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);
my3DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
}
| void SMESH_ActorDef::SetIsShrunkable | ( | bool | theShrunkable | ) | [protected] |
Definition at line 1193 of file SMESH_Actor.cxx.
References myIsShrinkable.
Referenced by Init().
{
if ( myIsShrinkable == theShrunkable )
return;
myIsShrinkable = theShrunkable;
Modified();
}
| void SMESH_ActorDef::SetLineWidth | ( | vtkFloatingPointType | theVal | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1844 of file SMESH_Actor.cxx.
References my1DExtProp, my1DProp, and myEdgeProp.
{
myEdgeProp->SetLineWidth(theVal);
my1DProp->SetLineWidth(theVal + aLineWidthInc);
my1DExtProp->SetLineWidth(theVal + aLineWidthInc);
Modified();
}
| void SMESH_ActorDef::SetMapper | ( | vtkMapper * | theMapper | ) | [private, virtual] |
Definition at line 1163 of file SMESH_Actor.cxx.
Referenced by SetRepresentation().
{
vtkLODActor::SetMapper(theMapper);
}
| void SMESH_ActorDef::SetMarkerStd | ( | VTK::MarkerType | theMarkerType, |
| VTK::MarkerScale | theMarkerScale | ||
| ) | [virtual] |
Definition at line 2116 of file SMESH_Actor.cxx.
References myNodeActor, myNodeExtActor, and SMESH_DeviceActor.SetMarkerStd().
Referenced by Init().
{
SALOME_Actor::SetMarkerStd( theMarkerType, theMarkerScale );
myNodeActor->SetMarkerStd( theMarkerType, theMarkerScale );
myNodeExtActor->SetMarkerStd( theMarkerType, theMarkerScale );
}
| void SMESH_ActorDef::SetMarkerTexture | ( | int | theMarkerId, |
| VTK::MarkerTexture | theMarkerTexture | ||
| ) | [virtual] |
Definition at line 2123 of file SMESH_Actor.cxx.
References myMarkerTexture, myNodeActor, myNodeExtActor, and SMESH_DeviceActor.SetMarkerTexture().
{
SALOME_Actor::SetMarkerTexture( theMarkerId, theMarkerTexture );
myNodeActor->SetMarkerTexture( theMarkerId, theMarkerTexture );
myNodeExtActor->SetMarkerTexture( theMarkerId, theMarkerTexture );
myMarkerTexture = theMarkerTexture; // for deferred update of myHighlightActor
}
| void SMESH_ActorDef::SetNodeColor | ( | vtkFloatingPointType | r, |
| vtkFloatingPointType | g, | ||
| vtkFloatingPointType | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1795 of file SMESH_Actor.cxx.
References myNodeExtProp, myNodeProp, myVisualObj, and SMDSAbs_Node.
{
myNodeProp->SetColor(r,g,b);
myNodeExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_Node )
myNameActor->SetBackgroundColor(r,g,b);
Modified();
}
| void SMESH_ActorDef::SetOpacity | ( | vtkFloatingPointType | theValue | ) | [virtual] |
Definition at line 1743 of file SMESH_Actor.cxx.
References my1DProp, myBackSurfaceProp, myEdgeProp, myNodeProp, and mySurfaceProp.
{
mySurfaceProp->SetOpacity(theValue);
myBackSurfaceProp->SetOpacity(theValue);
myEdgeProp->SetOpacity(theValue);
myNodeProp->SetOpacity(theValue);
my1DProp->SetOpacity(theValue);
}
| void SMESH_ActorDef::SetPointRepresentation | ( | bool | theIsPointsVisible | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1604 of file SMESH_Actor.cxx.
References myIsPointsVisible, and SetRepresentation().
{
if ( myIsPointsVisible == theIsPointsVisible )
return;
myIsPointsVisible = theIsPointsVisible;
SetRepresentation(GetRepresentation());
}
| void SMESH_ActorDef::SetPointsLabeled | ( | bool | theIsPointsLabeled | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 640 of file SMESH_Actor.cxx.
References GetUnstructuredGrid(), myIsPointsLabeled, myPointLabels, myPointsNumDataSet, myPtsMaskPoints, myTimeStamp, myVisualObj, New(), and SetRepresentation().
Referenced by Update().
{
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() );
}
else
{
myPointLabels->SetVisibility( false );
}
SetRepresentation(GetRepresentation());
myTimeStamp->Modified();
}
| void SMESH_ActorDef::SetPreHighlightColor | ( | vtkFloatingPointType | r, |
| vtkFloatingPointType | g, | ||
| vtkFloatingPointType | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1829 of file SMESH_Actor.cxx.
References myPreselectProp.
{
myPreselectProp->SetColor(r,g,b);
Modified();
}
| void SMESH_ActorDef::SetPreSelected | ( | bool | thePreselect = false | ) | [virtual] |
Definition at line 1660 of file SMESH_Actor.cxx.
References UpdateHighlight().
{
if ( myIsPreselected == thePreselect )
return;
myIsPreselected = thePreselect;
UpdateHighlight();
}
| void SMESH_ActorDef::SetQuadratic2DRepresentation | ( | EQuadratic2DRepresentation | theMode | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 2087 of file SMESH_Actor.cxx.
References SMESH_Actor.eArcs, SMESH_Actor.eLines, SMESH_Actor.ePoint, my1DActor, my2DActor, myHighlitableActor, and SMESH_DeviceActor.SetQuadraticArcMode().
{
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;
}
}
| void SMESH_ActorDef::SetRepresentation | ( | int | theMode | ) | [virtual] |
Definition at line 1483 of file SMESH_Actor.cxx.
References SMESH_Actor.eArcs, SMESH_Actor.eEdge, SMESH_DeviceActor.eInsideframe, SMESH_Actor.eLength, SMESH_Actor.eLines, SMESH_Actor.eMultiConnection, SMESH_Actor.ePoint, SMESH_Actor.eSurface, GetPointRepresentation(), GetQuadratic2DRepresentation(), GetUnstructuredGrid(), my0DActor, my1DActor, my1DExtActor, my1DProp, my2DActor, my2DExtActor, my3DActor, my3DExtActor, myBackSurfaceProp, myBaseActor, myControlMode, myEdgeProp, myIsPointsVisible, myIsShrunk, myNodeActor, myNodeExtActor, myNodeProp, myPickableActor, mySurfaceProp, myVisualObj, SetMapper(), SMESH_DeviceActor.SetQuadraticArcMode(), SMESH_DeviceActor.SetRepresentation(), SetShrink(), SetVisibility(), SMESH_DeviceActor.SetVisibility(), SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_Volume, and UnShrink().
Referenced by Init(), SetControlMode(), SetPointRepresentation(), SetPointsLabeled(), and SetVisibility().
{
int aNbEdges = myVisualObj->GetNbEntities(SMDSAbs_Edge);
int aNbFaces = myVisualObj->GetNbEntities(SMDSAbs_Face);
int aNbVolumes = myVisualObj->GetNbEntities(SMDSAbs_Volume);
if (theMode < 0) {
myRepresentation = eSurface;
if (!aNbFaces && !aNbVolumes && aNbEdges) {
myRepresentation = eEdge;
} else if (!aNbFaces && !aNbVolumes && !aNbEdges) {
myRepresentation = ePoint;
}
} else {
switch (theMode) {
case eEdge:
if (!aNbFaces && !aNbVolumes && !aNbEdges) return;
break;
case eSurface:
if (!aNbFaces && !aNbVolumes) return;
break;
}
myRepresentation = theMode;
}
if (!GetUnstructuredGrid()->GetNumberOfCells())
myRepresentation = ePoint;
if (myIsShrunk) {
if (myRepresentation == ePoint) {
UnShrink();
myIsShrunk = true;
} else {
SetShrink();
}
}
myPickableActor = myBaseActor;
myNodeActor->SetVisibility(false);
myNodeExtActor->SetVisibility(false);
vtkProperty *aProp = NULL, *aBackProp = NULL;
SMESH_DeviceActor::EReperesent aReperesent = SMESH_DeviceActor::EReperesent(-1);
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;
case eEdge:
aProp = aBackProp = myEdgeProp;
aReperesent = SMESH_DeviceActor::eInsideframe;
break;
case eSurface:
aProp = mySurfaceProp;
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);
my3DExtActor->SetVisibility(false);
// ???
//my0DActor->SetProperty(aProp);
//my0DActor->SetBackfaceProperty(aBackProp);
my0DActor->SetRepresentation(aReperesent);
//my0DExtActor->SetRepresentation(aReperesent);
switch(myControlMode){
case eLength:
case eMultiConnection:
aProp = aBackProp = my1DProp;
if(myRepresentation != ePoint)
aReperesent = SMESH_DeviceActor::eInsideframe;
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())
myNodeActor->SetVisibility(true);
SetMapper(myPickableActor->GetMapper());
SetVisibility(GetVisibility(),false);
Modified();
}
| void SMESH_ActorDef::SetShrink | ( | ) | [virtual] |
Definition at line 1218 of file SMESH_Actor.cxx.
References my1DActor, my1DExtActor, my2DActor, my2DExtActor, my3DActor, my3DExtActor, myBaseActor, myIsShrinkable, myIsShrunk, and SMESH_DeviceActor.SetShrink().
Referenced by Init(), and SetRepresentation().
{
if(!myIsShrinkable) return;
myBaseActor->SetShrink();
my1DActor->SetShrink();
my1DExtActor->SetShrink();
my2DActor->SetShrink();
my2DExtActor->SetShrink();
my3DActor->SetShrink();
my3DExtActor->SetShrink();
myIsShrunk = true;
Modified();
}
| void SMESH_ActorDef::SetShrinkFactor | ( | vtkFloatingPointType | theValue | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1204 of file SMESH_Actor.cxx.
References my1DActor, my1DExtActor, my2DActor, my2DExtActor, my3DActor, my3DExtActor, myBaseActor, and SMESH_DeviceActor.SetShrinkFactor().
Referenced by Init().
{
myBaseActor->SetShrinkFactor(theValue);
my1DActor->SetShrinkFactor(theValue);
my1DExtActor->SetShrinkFactor(theValue);
my2DActor->SetShrinkFactor(theValue);
my2DExtActor->SetShrinkFactor(theValue);
my3DActor->SetShrinkFactor(theValue);
my3DExtActor->SetShrinkFactor(theValue);
Modified();
}
| void SMESH_ActorDef::SetSufaceColor | ( | vtkFloatingPointType | r, |
| vtkFloatingPointType | g, | ||
| vtkFloatingPointType | b | ||
| ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1758 of file SMESH_Actor.cxx.
References mySurfaceProp, myVisualObj, SMDSAbs_Face, and SMDSAbs_Volume.
{
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);
Modified();
}
| void SMESH_ActorDef::SetTransform | ( | VTKViewer_Transform * | theTransform | ) | [virtual] |
Definition at line 1138 of file SMESH_Actor.cxx.
References my0DActor, my1DActor, my1DExtActor, my2DActor, my2DExtActor, my3DActor, my3DExtActor, myBaseActor, myHighlitableActor, myNodeActor, myNodeExtActor, and SMESH_DeviceActor.SetTransform().
{
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);
my3DExtActor->SetTransform(theTransform);
Modified();
}
Definition at line 1276 of file SMESH_Actor.cxx.
References SMESH_Actor.e0DElements, SMESH_Actor.eBareBorderFace, SMESH_Actor.eBareBorderVolume, SMESH_Actor.eEdges, SMESH_Actor.eFaces, SMESH_Actor.eFreeBorders, SMESH_Actor.eFreeEdges, SMESH_Actor.eFreeFaces, SMESH_Actor.eFreeNodes, SMESH_Actor.eLength2D, SMESH_Actor.eMultiConnection2D, SMESH_Actor.eNone, SMESH_Actor.eOverConstrainedFace, SMESH_Actor.eOverConstrainedVolume, SMESH_Actor.ePoint, SMESH_Actor.eVolumes, SMESH_DeviceActor.GetUnstructuredGrid(), my0DActor, my1DActor, my1DExtActor, my2DActor, my2DExtActor, my3DActor, my3DExtActor, myBaseActor, myCellsLabels, myControlActor, myControlMode, myEntityMode, myIsCellsLabeled, myIsPointsLabeled, myNodeActor, myNodeExtActor, myPickableActor, myPointLabels, myScalarBarActor, SMESH.ProcessIn2DViewers(), SMESH.RemoveFrom2dViewer, SetRepresentation(), SetVisibility(), and UpdateHighlight().
{
SALOME_Actor::SetVisibility(theMode);
myNodeActor->VisibilityOff();
myBaseActor->VisibilityOff();
myNodeExtActor->VisibilityOff();
my0DActor->VisibilityOff();
//my0DExtActor->VisibilityOff();
my1DActor->VisibilityOff();
my1DExtActor->VisibilityOff();
my2DActor->VisibilityOff();
my2DExtActor->VisibilityOff();
my3DActor->VisibilityOff();
my3DExtActor->VisibilityOff();
myScalarBarActor->VisibilityOff();
myPointLabels->VisibilityOff();
myCellsLabels->VisibilityOff();
if(GetVisibility()){
if(theIsUpdateRepersentation)
SetRepresentation(GetRepresentation());
if(myControlMode != eNone){
switch(myControlMode){
case eFreeNodes:
myNodeExtActor->VisibilityOn();
break;
case eFreeEdges:
case eFreeBorders:
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();
default:
if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells())
myScalarBarActor->VisibilityOn();
}
}
if(myRepresentation != ePoint)
myPickableActor->VisibilityOn();
else {
myNodeActor->VisibilityOn();
}
if(myEntityMode & e0DElements){
my0DActor->VisibilityOn();
}
if(myEntityMode & eEdges && GetRepresentation() != ePoint){
my1DActor->VisibilityOn();
}
if(myEntityMode & eFaces && GetRepresentation() != ePoint){
my2DActor->VisibilityOn();
}
if(myEntityMode & eVolumes && GetRepresentation() != ePoint){
my3DActor->VisibilityOn();
}
if(myIsPointsLabeled){
myPointLabels->VisibilityOn();
myNodeActor->VisibilityOn();
}
if(myIsCellsLabeled)
myCellsLabels->VisibilityOn();
}
#ifndef DISABLE_PLOT2DVIEWER
else
SMESH::ProcessIn2DViewers(this,SMESH::RemoveFrom2dViewer);
#endif
UpdateHighlight();
Modified();
}
| void SMESH_ActorDef::SetVisibility | ( | int | theMode | ) | [virtual] |
Definition at line 1271 of file SMESH_Actor.cxx.
Referenced by SetEntityMode(), SetRepresentation(), SetVisibility(), and Update().
{
SetVisibility(theMode,true);
}
| void SMESH_ActorDef::ShallowCopy | ( | vtkProp * | prop | ) | [private, virtual] |
Definition at line 1168 of file SMESH_Actor.cxx.
{
SALOME_Actor::ShallowCopy(prop);
}
| void SMESH_ActorDef::UnShrink | ( | ) | [virtual] |
Definition at line 1235 of file SMESH_Actor.cxx.
References my1DActor, my1DExtActor, my2DActor, my2DExtActor, my3DActor, my3DExtActor, myBaseActor, myIsShrunk, and SMESH_DeviceActor.UnShrink().
Referenced by SetRepresentation().
{
if(!myIsShrunk) return;
myBaseActor->UnShrink();
my1DActor->UnShrink();
my1DExtActor->UnShrink();
my2DActor->UnShrink();
my2DExtActor->UnShrink();
my3DActor->UnShrink();
my3DExtActor->UnShrink();
myIsShrunk = false;
Modified();
}
| void SMESH_ActorDef::Update | ( | ) | [protected] |
Definition at line 1702 of file SMESH_Actor.cxx.
References SMESH_Actor.eNone, GetControlMode(), GetEntityMode(), MESSAGE, myIsCellsLabeled, myIsFacesOriented, myIsPointsLabeled, myTimeStamp, myVisualObj, SetCellsLabeled(), SetControlMode(), SetEntityMode(), SetFacesOriented(), SetPointsLabeled(), and SetVisibility().
Referenced by Render().
{
if(MYDEBUG) MESSAGE("SMESH_ActorDef::Update");
if(GetControlMode() != eNone) {
unsigned long aTime = myTimeStamp->GetMTime();
unsigned long anObjTime = myVisualObj->GetUnstructuredGrid()->GetMTime();
if (anObjTime > aTime)
SetControlMode(GetControlMode(),false);
}
if(myIsPointsLabeled){
SetPointsLabeled(myIsPointsLabeled);
}
if(myIsCellsLabeled){
SetCellsLabeled(myIsCellsLabeled);
}
if(myIsFacesOriented){
SetFacesOriented(myIsFacesOriented);
}
SetEntityMode(GetEntityMode());
SetVisibility(GetVisibility());
myTimeStamp->Modified();
Modified();
}
| void SMESH_ActorDef::UpdateDistribution | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 2066 of file SMESH_Actor.cxx.
References myFunctor, myScalarBarActor, myVisualObj, and SMESH_ScalarBarActor.SetDistribution().
Referenced by SetControlMode().
{
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::UpdateHighlight | ( | ) | [protected] |
Definition at line 1616 of file SMESH_Actor.cxx.
References SMESH_DeviceActor.ePoint, SMESH_Actor.ePoint, SMESH_DeviceActor.eWireframe, SMESH_DeviceActor.GetExtractUnstructuredGrid(), GetPointRepresentation(), GetUnstructuredGrid(), myHighlightProp, myHighlitableActor, myMarkerTexture, myPreselectProp, SMESH_DeviceActor.SetHighlited(), SMESH_DeviceActor.SetMarkerStd(), SMESH_DeviceActor.SetMarkerTexture(), SMESH_DeviceActor.SetRepresentation(), and SMESH_DeviceActor.SetVisibility().
Referenced by highlight(), SetPreSelected(), and SetVisibility().
{
myHighlitableActor->SetVisibility(false);
myHighlitableActor->SetHighlited(false);
if(myIsHighlighted){
myHighlitableActor->SetProperty(myHighlightProp);
}else if(myIsPreselected){
myHighlitableActor->SetProperty(myPreselectProp);
}
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);
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);
}
}
}
| SPlot2d_Histogram * SMESH_ActorDef::UpdatePlot2Histogram | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 2132 of file SMESH_Actor.cxx.
References SMESH_ScalarBarActor.GetDistributionColor(), SMESH_ScalarBarActor.GetDistributionColoringType(), Handle(), my2dHistogram, myFunctor, myScalarBarActor, myVisualObj, and SMESH_MULTICOLOR_TYPE.
{
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;
}
| void SMESH_ActorDef::UpdateScalarBar | ( | ) | [virtual] |
Implements SMESH_Actor.
Definition at line 1935 of file SMESH_Actor.cxx.
References myScalarBarActor, ex21_lamp.name, New(), SMESH_ScalarBarActor.SetDistributionColor(), SMESH_ScalarBarActor.SetDistributionColoringType(), SMESH_ScalarBarActor.SetDistributionVisibility(), SMESH_ScalarBarActor.SetLabelTextProperty(), SMESH_ScalarBarActor.SetOrientationToHorizontal(), SMESH_ScalarBarActor.SetOrientationToVertical(), and SMESH_ScalarBarActor.SetTitleTextProperty().
Referenced by SMESH_Actor.New().
{
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 );
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);
}
| SMESH_ActorDef.vtkTypeMacro | ( | SMESH_ActorDef | , |
| SMESH_Actor | |||
| ) |
| SMESH_Actor.vtkTypeMacro | ( | SMESH_Actor | , |
| SALOME_Actor | |||
| ) | [inherited] |
Friends And Related Function Documentation
friend class SMESH_Actor [friend] |
Definition at line 86 of file SMESH_ActorDef.h.
friend class SMESH_VisualObj [friend] |
Definition at line 85 of file SMESH_ActorDef.h.
Field Documentation
SMESH_DeviceActor* SMESH_ActorDef.my0DActor [protected] |
Definition at line 262 of file SMESH_ActorDef.h.
Referenced by AddToRender(), Init(), RemoveFromRender(), SetControlMode(), SetImplicitFunctionUsed(), SetRepresentation(), SetTransform(), SetVisibility(), SMESH_ActorDef(), and ~SMESH_ActorDef().
SMESH_DeviceActor* SMESH_ActorDef.my0DExtActor [protected] |
Definition at line 264 of file SMESH_ActorDef.h.
vtkProperty* SMESH_ActorDef.my0DExtProp [protected] |
Definition at line 263 of file SMESH_ActorDef.h.
vtkProperty* SMESH_ActorDef.my0DProp [protected] |
Definition at line 261 of file SMESH_ActorDef.h.
Referenced by Get0DColor(), Get0DSize(), Set0DColor(), Set0DSize(), SMESH_ActorDef(), and ~SMESH_ActorDef().
SMESH_DeviceActor* SMESH_ActorDef.my1DActor [protected] |
Definition at line 257 of file SMESH_ActorDef.h.
Referenced by AddToRender(), Init(), RemoveFromRender(), SetControlMode(), SetImplicitFunctionUsed(), SetQuadratic2DRepresentation(), SetRepresentation(), SetShrink(), SetShrinkFactor(), SetTransform(), SetVisibility(), SMESH_ActorDef(), UnShrink(), and ~SMESH_ActorDef().
SMESH_DeviceActor* SMESH_ActorDef.my1DExtActor [protected] |
Definition at line 259 of file SMESH_ActorDef.h.
Referenced by AddToRender(), Init(), RemoveFromRender(), SetControlMode(), SetImplicitFunctionUsed(), SetRepresentation(), SetShrink(), SetShrinkFactor(), SetTransform(), SetVisibility(), SMESH_ActorDef(), UnShrink(), and ~SMESH_ActorDef().
vtkProperty* SMESH_ActorDef.my1DExtProp [protected] |
Definition at line 258 of file SMESH_ActorDef.h.
Referenced by SetEdgeColor(), SetLineWidth(), SMESH_ActorDef(), and ~SMESH_ActorDef().
vtkProperty* SMESH_ActorDef.my1DProp [protected] |
Definition at line 256 of file SMESH_ActorDef.h.
Referenced by SetEdgeColor(), SetLineWidth(), SetOpacity(), SetRepresentation(), SMESH_ActorDef(), and ~SMESH_ActorDef().
SMESH_DeviceActor* SMESH_ActorDef.my2DActor [protected] |
Definition at line 247 of file SMESH_ActorDef.h.
Referenced by AddToRender(), Init(), RemoveFromRender(), SetControlMode(), SetFacesOrientation3DVectors(), SetFacesOrientationColor(), SetFacesOrientationScale(), SetFacesOriented(), SetImplicitFunctionUsed(), SetQuadratic2DRepresentation(), SetRepresentation(), SetShrink(), SetShrinkFactor(), SetTransform(), SetVisibility(), SMESH_ActorDef(), UnShrink(), and ~SMESH_ActorDef().
SMESH_DeviceActor* SMESH_ActorDef.my2DExtActor [protected] |
Definition at line 248 of file SMESH_ActorDef.h.
Referenced by AddToRender(), Init(), RemoveFromRender(), SetControlMode(), SetImplicitFunctionUsed(), SetRepresentation(), SetShrink(), SetShrinkFactor(), SetTransform(), SetVisibility(), SMESH_ActorDef(), UnShrink(), and ~SMESH_ActorDef().
vtkProperty* SMESH_ActorDef.my2DExtProp [protected] |
Definition at line 246 of file SMESH_ActorDef.h.
Referenced by GetSufaceColor(), SMESH_ActorDef(), and ~SMESH_ActorDef().
SPlot2d_Histogram* SMESH_ActorDef.my2dHistogram [protected] |
Definition at line 295 of file SMESH_ActorDef.h.
Referenced by GetPlot2Histogram(), SMESH_ActorDef(), UpdatePlot2Histogram(), and ~SMESH_ActorDef().
SMESH_DeviceActor* SMESH_ActorDef.my3DActor [protected] |
Definition at line 249 of file SMESH_ActorDef.h.
Referenced by AddToRender(), GetFacesOrientation3DVectors(), GetFacesOrientationColor(), GetFacesOrientationScale(), Init(), RemoveFromRender(), SetControlMode(), SetFacesOrientation3DVectors(), SetFacesOrientationColor(), SetFacesOrientationScale(), SetFacesOriented(), SetImplicitFunctionUsed(), SetRepresentation(), SetShrink(), SetShrinkFactor(), SetTransform(), SetVisibility(), SMESH_ActorDef(), UnShrink(), and ~SMESH_ActorDef().
SMESH_DeviceActor* SMESH_ActorDef.my3DExtActor [protected] |
Definition at line 250 of file SMESH_ActorDef.h.
Referenced by AddToRender(), Init(), RemoveFromRender(), SetControlMode(), SetImplicitFunctionUsed(), SetRepresentation(), SetShrink(), SetShrinkFactor(), SetTransform(), SetVisibility(), SMESH_ActorDef(), UnShrink(), and ~SMESH_ActorDef().
vtkProperty* SMESH_ActorDef.myBackSurfaceProp [protected] |
Definition at line 230 of file SMESH_ActorDef.h.
Referenced by GetBackSufaceColor(), SetBackSufaceColor(), SetOpacity(), SetRepresentation(), SMESH_ActorDef(), and ~SMESH_ActorDef().
SMESH_DeviceActor* SMESH_ActorDef.myBaseActor [protected] |
Definition at line 236 of file SMESH_ActorDef.h.
Referenced by AddToRender(), GetShrinkFactor(), Init(), IsImplicitFunctionUsed(), RemoveFromRender(), SetEntityMode(), SetImplicitFunctionUsed(), SetRepresentation(), SetShrink(), SetShrinkFactor(), SetTransform(), SetVisibility(), SMESH_ActorDef(), UnShrink(), and ~SMESH_ActorDef().
VTKViewer_CellCenters* SMESH_ActorDef.myCellCenters [protected] |
Definition at line 284 of file SMESH_ActorDef.h.
Referenced by SetCellsLabeled(), SMESH_ActorDef(), and ~SMESH_ActorDef().
vtkActor2D* SMESH_ActorDef.myCellsLabels [protected] |
Definition at line 282 of file SMESH_ActorDef.h.
Referenced by AddToRender(), RemoveFromRender(), SetCellsLabeled(), SetVisibility(), SMESH_ActorDef(), and ~SMESH_ActorDef().
vtkUnstructuredGrid* SMESH_ActorDef.myCellsNumDataSet [protected] |
Definition at line 281 of file SMESH_ActorDef.h.
Referenced by SetCellsLabeled(), SMESH_ActorDef(), and ~SMESH_ActorDef().
TCippingPlaneCont SMESH_ActorDef.myCippingPlaneCont [protected] |
Definition at line 291 of file SMESH_ActorDef.h.
Referenced by AddClippingPlane(), GetClippingPlane(), GetNumberOfClippingPlanes(), and RemoveAllClippingPlanes().
vtkLabeledDataMapper* SMESH_ActorDef.myClsLabeledDataMapper [protected] |
Definition at line 285 of file SMESH_ActorDef.h.
Referenced by SMESH_ActorDef(), and ~SMESH_ActorDef().
vtkMaskPoints* SMESH_ActorDef.myClsMaskPoints [protected] |
Definition at line 283 of file SMESH_ActorDef.h.
Referenced by SMESH_ActorDef(), and ~SMESH_ActorDef().
vtkSelectVisiblePoints* SMESH_ActorDef.myClsSelectVisiblePoints [protected] |
Definition at line 286 of file SMESH_ActorDef.h.
Referenced by AddToRender(), SMESH_ActorDef(), and ~SMESH_ActorDef().
SMESH_DeviceActor* SMESH_ActorDef.myControlActor [protected] |
Definition at line 251 of file SMESH_ActorDef.h.
Referenced by SetControlMode(), SetVisibility(), and SMESH_ActorDef().
eControl SMESH_ActorDef.myControlMode [protected] |
Definition at line 244 of file SMESH_ActorDef.h.
Referenced by GetControlMode(), SetControlMode(), SetRepresentation(), SetVisibility(), and SMESH_ActorDef().
long SMESH_ActorDef.myControlsPrecision [protected] |
Definition at line 292 of file SMESH_ActorDef.h.
Referenced by GetControlsPrecision(), SetControlMode(), SetControlsPrecision(), and SMESH_ActorDef().
vtkProperty* SMESH_ActorDef.myEdgeProp [protected] |
Definition at line 231 of file SMESH_ActorDef.h.
Referenced by GetEdgeColor(), GetLineWidth(), SetEdgeColor(), SetLineWidth(), SetOpacity(), SetRepresentation(), SMESH_ActorDef(), and ~SMESH_ActorDef().
unsigned int SMESH_ActorDef.myEntityMode [protected] |
Definition at line 266 of file SMESH_ActorDef.h.
Referenced by GetEntityMode(), SetControlMode(), SetEntityMode(), SetVisibility(), and SMESH_ActorDef().
unsigned int SMESH_ActorDef.myEntityState [protected] |
Definition at line 267 of file SMESH_ActorDef.h.
Referenced by SetEntityMode().
SMESH::Controls::FunctorPtr SMESH_ActorDef.myFunctor [protected] |
Definition at line 245 of file SMESH_ActorDef.h.
Referenced by GetFunctor(), SetControlMode(), UpdateDistribution(), and UpdatePlot2Histogram().
vtkProperty* SMESH_ActorDef.myHighlightProp [protected] |
Definition at line 240 of file SMESH_ActorDef.h.
Referenced by GetHighlightColor(), SetHighlightColor(), SMESH_ActorDef(), UpdateHighlight(), and ~SMESH_ActorDef().
SMESH_DeviceActor* SMESH_ActorDef.myHighlitableActor [protected] |
Definition at line 242 of file SMESH_ActorDef.h.
Referenced by AddToRender(), GetQuadratic2DRepresentation(), Init(), RemoveFromRender(), SetEntityMode(), SetImplicitFunctionUsed(), SetQuadratic2DRepresentation(), SetTransform(), SMESH_ActorDef(), UpdateHighlight(), and ~SMESH_ActorDef().
vtkImplicitBoolean* SMESH_ActorDef.myImplicitBoolean [protected] |
Definition at line 288 of file SMESH_ActorDef.h.
Referenced by AddClippingPlane(), Init(), RemoveAllClippingPlanes(), Render(), SMESH_ActorDef(), and ~SMESH_ActorDef().
bool SMESH_ActorDef.myIsCellsLabeled [protected] |
Definition at line 280 of file SMESH_ActorDef.h.
Referenced by GetCellsLabeled(), SetCellsLabeled(), SetVisibility(), SMESH_ActorDef(), and Update().
bool SMESH_ActorDef.myIsFacesOriented [protected] |
Definition at line 298 of file SMESH_ActorDef.h.
Referenced by SMESH_DeviceActor.GetFacesOriented(), GetFacesOriented(), SetFacesOriented(), SMESH_ActorDef(), and Update().
bool SMESH_ActorDef.myIsPointsLabeled [protected] |
Definition at line 273 of file SMESH_ActorDef.h.
Referenced by GetPointRepresentation(), GetPointsLabeled(), SetPointsLabeled(), SetVisibility(), SMESH_ActorDef(), and Update().
bool SMESH_ActorDef.myIsPointsVisible [protected] |
Definition at line 268 of file SMESH_ActorDef.h.
Referenced by GetPointRepresentation(), SetPointRepresentation(), SetRepresentation(), and SMESH_ActorDef().
bool SMESH_ActorDef.myIsShrinkable [protected] |
Definition at line 270 of file SMESH_ActorDef.h.
Referenced by SMESH_DeviceActor.IsShrunkable(), IsShrunkable(), SetIsShrunkable(), SetShrink(), and SMESH_ActorDef().
bool SMESH_ActorDef.myIsShrunk [protected] |
Definition at line 271 of file SMESH_ActorDef.h.
Referenced by SMESH_DeviceActor.IsShrunk(), IsShrunk(), SetRepresentation(), SetShrink(), SMESH_ActorDef(), and UnShrink().
vtkLookupTable* SMESH_ActorDef.myLookupTable [protected] |
Definition at line 227 of file SMESH_ActorDef.h.
Referenced by Init(), SetControlMode(), SMESH_ActorDef(), and ~SMESH_ActorDef().
VTKViewer_DataSetMapper* SMESH_ActorDef.myMapper [protected] |
Definition at line 234 of file SMESH_ActorDef.h.
Referenced by GetMapper(), SMESH_ActorDef(), and ~SMESH_ActorDef().
VTK::MarkerTexture SMESH_ActorDef.myMarkerTexture [protected] |
Definition at line 300 of file SMESH_ActorDef.h.
Referenced by SetMarkerTexture(), and UpdateHighlight().
SMESH_DeviceActor* SMESH_ActorDef.myNodeActor [protected] |
Definition at line 237 of file SMESH_ActorDef.h.
Referenced by AddToRender(), GetBounds(), Init(), RemoveFromRender(), SetControlMode(), SetImplicitFunctionUsed(), SetMarkerStd(), SetMarkerTexture(), SetRepresentation(), SetTransform(), SetVisibility(), SMESH_ActorDef(), and ~SMESH_ActorDef().
SMESH_DeviceActor* SMESH_ActorDef.myNodeExtActor [protected] |
Definition at line 254 of file SMESH_ActorDef.h.
Referenced by AddToRender(), Init(), RemoveFromRender(), SetControlMode(), SetImplicitFunctionUsed(), SetMarkerStd(), SetMarkerTexture(), SetRepresentation(), SetTransform(), SetVisibility(), SMESH_ActorDef(), and ~SMESH_ActorDef().
vtkProperty* SMESH_ActorDef.myNodeExtProp [protected] |
Definition at line 253 of file SMESH_ActorDef.h.
Referenced by SetNodeColor(), SMESH_ActorDef(), and ~SMESH_ActorDef().
vtkProperty* SMESH_ActorDef.myNodeProp [protected] |
Definition at line 232 of file SMESH_ActorDef.h.
Referenced by GetNodeColor(), SetNodeColor(), SetOpacity(), SetRepresentation(), SMESH_ActorDef(), and ~SMESH_ActorDef().
SMESH_DeviceActor* SMESH_ActorDef.myPickableActor [protected] |
Definition at line 238 of file SMESH_ActorDef.h.
Referenced by GetElemCell(), GetElemObjId(), GetNodeCoord(), GetNodeObjId(), IsInfinitive(), ReleaseGraphicsResources(), RenderOpaqueGeometry(), RenderTranslucentGeometry(), SetRepresentation(), SetVisibility(), and SMESH_ActorDef().
vtkActor2D* SMESH_ActorDef.myPointLabels [protected] |
Definition at line 275 of file SMESH_ActorDef.h.
Referenced by AddToRender(), RemoveFromRender(), SetPointsLabeled(), SetVisibility(), SMESH_ActorDef(), and ~SMESH_ActorDef().
vtkUnstructuredGrid* SMESH_ActorDef.myPointsNumDataSet [protected] |
Definition at line 274 of file SMESH_ActorDef.h.
Referenced by SetPointsLabeled(), SMESH_ActorDef(), and ~SMESH_ActorDef().
vtkProperty* SMESH_ActorDef.myPreselectProp [protected] |
Definition at line 241 of file SMESH_ActorDef.h.
Referenced by GetPreHighlightColor(), SetPreHighlightColor(), SMESH_ActorDef(), UpdateHighlight(), and ~SMESH_ActorDef().
vtkLabeledDataMapper* SMESH_ActorDef.myPtsLabeledDataMapper [protected] |
Definition at line 277 of file SMESH_ActorDef.h.
Referenced by SMESH_ActorDef(), and ~SMESH_ActorDef().
vtkMaskPoints* SMESH_ActorDef.myPtsMaskPoints [protected] |
Definition at line 276 of file SMESH_ActorDef.h.
Referenced by SetPointsLabeled(), SMESH_ActorDef(), and ~SMESH_ActorDef().
vtkSelectVisiblePoints* SMESH_ActorDef.myPtsSelectVisiblePoints [protected] |
Definition at line 278 of file SMESH_ActorDef.h.
Referenced by AddToRender(), SMESH_ActorDef(), and ~SMESH_ActorDef().
SMESH_ScalarBarActor* SMESH_ActorDef.myScalarBarActor [protected] |
Definition at line 226 of file SMESH_ActorDef.h.
Referenced by AddToRender(), GetScalarBarActor(), RemoveFromRender(), SetControlMode(), SetVisibility(), SMESH_ActorDef(), UpdateDistribution(), UpdatePlot2Histogram(), UpdateScalarBar(), and ~SMESH_ActorDef().
vtkProperty* SMESH_ActorDef.mySurfaceProp [protected] |
Definition at line 229 of file SMESH_ActorDef.h.
Referenced by GetOpacity(), GetSufaceColor(), SetOpacity(), SetRepresentation(), SetSufaceColor(), SMESH_ActorDef(), and ~SMESH_ActorDef().
vtkTimeStamp* SMESH_ActorDef.myTimeStamp [protected] |
Definition at line 224 of file SMESH_ActorDef.h.
Referenced by Init(), Render(), SetCellsLabeled(), SetControlMode(), SetFacesOriented(), SetPointsLabeled(), SMESH_ActorDef(), Update(), and ~SMESH_ActorDef().
TVisualObjPtr SMESH_ActorDef.myVisualObj [protected] |
Definition at line 223 of file SMESH_ActorDef.h.
Referenced by GetObjDimension(), GetObject(), GetUnstructuredGrid(), Init(), Render(), Set0DColor(), SetCellsLabeled(), SetEdgeColor(), SetEntityMode(), SetNodeColor(), SetPointsLabeled(), SetRepresentation(), SetSufaceColor(), Update(), UpdateDistribution(), and UpdatePlot2Histogram().