-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "utilities.h"
#ifdef _DEBUG_
-static int MYDEBUG = 1;
+static int MYDEBUG = 0;
#else
-static int MYDEBUG = 1;
+static int MYDEBUG = 0;
#endif
static int aLineWidthInc = 2;
if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1);
- double aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
- double aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10);
- double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
- double aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1);
+ double aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
+ double aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10);
+ double aBallElemScale = SMESH::GetFloat("SMESH:ball_elem_scale",1.0);
+ double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
+ double aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1);
SMESH::LabelFont aFamilyNd = SMESH::FntTimes;
bool aBoldNd = true;
aFilter = my2DActor->GetExtractUnstructuredGrid();
aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
aFilter->RegisterCellsWithType(VTK_TRIANGLE);
- aFilter->RegisterCellsWithType(VTK_POLYGON);
aFilter->RegisterCellsWithType(VTK_QUAD);
+ aFilter->RegisterCellsWithType(VTK_POLYGON);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
+ aFilter->RegisterCellsWithType(VTK_QUADRATIC_POLYGON);
aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_TRIANGLE);
my2DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe);
aFilter = my2DExtActor->GetExtractUnstructuredGrid();
aFilter->RegisterCellsWithType(VTK_TRIANGLE);
- aFilter->RegisterCellsWithType(VTK_POLYGON);
aFilter->RegisterCellsWithType(VTK_QUAD);
+ aFilter->RegisterCellsWithType(VTK_POLYGON);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
+ aFilter->RegisterCellsWithType(VTK_QUADRATIC_POLYGON);
aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_TRIANGLE);
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
my3DExtProp = vtkProperty::New();
my3DExtProp->DeepCopy(myNormalVProp);
#endif
SetBallSize(aBallElemSize);
+ SetBallScale(aBallElemScale);
Set0DSize(aElem0DSize);
}
}
}
-bool SMESH_ActorDef::GetPointsLabeled() {
+bool SMESH_ActorDef::GetPointsLabeled()
+{
return myNodeActor && myNodeActor->GetPointsLabeled();
}
}
-bool SMESH_ActorDef::GetCellsLabeled() {
+bool SMESH_ActorDef::GetCellsLabeled()
+{
bool result = false;
if(my3DActor)
result = result || my3DActor->GetCellsLabeled();
}
-void
-SMESH_ActorDef::
-SetControlMode(eControl theMode)
+void SMESH_ActorDef::SetControlMode(eControl theMode)
{
SetControlMode(theMode,true);
}
-void
-SMESH_ActorDef::
-SetControlMode(eControl theMode,
- bool theCheckEntityMode)
+void SMESH_ActorDef::SetControlMode( eControl theMode, bool theCheckEntityMode )
{
vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
myControlActor = my2DActor;
break;
}
+ case eNodeConnectivityNb:
+ {
+ myFunctor.reset( new SMESH::Controls::NodeConnectivityNumber() );
+ myControlActor = myNodeActor;
+ break;
+ }
default:
return;
}
vtkUnstructuredGrid* aGrid = myControlActor->GetUnstructuredGrid();
vtkIdType aNbCells = aGrid->GetNumberOfCells();
- if(aNbCells){
+ bool aShowOnlyScalarBarTitle = false;
+ if(aNbCells) {
myControlMode = theMode;
switch(myControlMode){
case eFreeNodes:
case eCoincidentNodes:
myNodeExtActor->SetExtControlMode(myFunctor);
+ aShowOnlyScalarBarTitle = true;
break;
case eFreeEdges:
case eFreeBorders:
case eCoincidentElems1D:
my1DExtActor->SetExtControlMode(myFunctor);
+ aShowOnlyScalarBarTitle = true;
break;
case eFreeFaces:
case eBareBorderFace:
case eOverConstrainedFace:
case eCoincidentElems2D:
my2DExtActor->SetExtControlMode(myFunctor);
+ aShowOnlyScalarBarTitle = true;
break;
case eBareBorderVolume:
case eOverConstrainedVolume:
case eCoincidentElems3D:
my3DExtActor->SetExtControlMode(myFunctor);
+ aShowOnlyScalarBarTitle = true;
break;
case eLength2D:
case eMultiConnection2D:
myControlActor->SetControlMode(myFunctor,myScalarBarActor,myLookupTable);
UpdateDistribution();
}
+ myScalarBarActor->SetTitleOnlyVisibility(aShowOnlyScalarBarTitle);
}
if(theCheckEntityMode) {
+ // if(myControlActor == myNodeActor) {
+ // if ( myControlMode == eNodeConnectivityNb ) {
+ // if (!myIsEntityModeCache){
+ // myEntityModeCache = GetEntityMode();
+ // myIsEntityModeCache=true;
+ // }
+ // SetEntityMode(0);
+ // }
+ // }
if(myControlActor == my1DActor) {
if (!myIsEntityModeCache){
myEntityModeCache = GetEntityMode();
SetEntityMode(eVolumes);
}
}
+ QString aTitle = QString(myScalarBarActor->GetTitle());
+ aTitle.replace(QRegExp("(:\\s).*"),"\\1"+ QString::number(GetNumberControlEntities()));
+ myScalarBarActor->SetTitle(aTitle.toLatin1().constData());
}
else {
Update();
}
+int SMESH_ActorDef::GetNumberControlEntities()
+{
+ SMESH_DeviceActor* anAct = NULL;
+ switch(myControlMode){
+ case eFreeNodes:
+ case eCoincidentNodes:
+ anAct = myNodeExtActor;
+ break;
+ case eFreeEdges:
+ case eFreeBorders:
+ case eCoincidentElems1D:
+ anAct = my1DExtActor;
+ break;
+ case eFreeFaces:
+ case eBareBorderFace:
+ case eOverConstrainedFace:
+ case eCoincidentElems2D:
+ anAct = my2DExtActor;
+ break;
+ case eBareBorderVolume:
+ case eOverConstrainedVolume:
+ case eCoincidentElems3D:
+ anAct = my3DExtActor;
+ break;
+ default:;
+ }
+ return (anAct) ? anAct->GetUnstructuredGrid()->GetNumberOfCells() : -1;
+}
-void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){
-
+void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer)
+{
theRenderer->AddActor(myBaseActor);
theRenderer->AddActor(myNodeExtActor);
theRenderer->AddActor(my1DExtActor);
SALOME_Actor::AddToRender(theRenderer);
}
-void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer){
+void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer)
+{
SALOME_Actor::RemoveFromRender(theRenderer);
theRenderer->RemoveActor(myBaseActor);
bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
- const char* theEntry,
- const char* theName,
- int theIsClear)
+ const char* theEntry,
+ const char* theName,
+ int theIsClear)
{
Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry,"SMESH",theName);
setIO(anIO);
}
-double* SMESH_ActorDef::GetBounds(){
+double* SMESH_ActorDef::GetBounds()
+{
return myNodeActor->GetBounds();
}
-vtkDataSet* SMESH_ActorDef::GetInput(){
+vtkDataSet* SMESH_ActorDef::GetInput()
+{
return GetUnstructuredGrid();
}
-void SMESH_ActorDef::SetTransform(VTKViewer_Transform* theTransform){
+void SMESH_ActorDef::SetTransform(VTKViewer_Transform* theTransform)
+{
Superclass::SetTransform(theTransform);
myNodeActor->SetTransform(theTransform);
}
-void SMESH_ActorDef::SetMapper(vtkMapper* theMapper){
+void SMESH_ActorDef::SetMapper(vtkMapper* theMapper)
+{
vtkLODActor::SetMapper(theMapper);
}
-void SMESH_ActorDef::ShallowCopy(vtkProp *prop){
+void SMESH_ActorDef::ShallowCopy(vtkProp *prop)
+{
SALOME_Actor::ShallowCopy(prop);
}
-vtkMapper* SMESH_ActorDef::GetMapper(){
+vtkMapper* SMESH_ActorDef::GetMapper()
+{
return myPickableActor->GetMapper();
}
-vtkUnstructuredGrid* SMESH_ActorDef::GetUnstructuredGrid(){
+vtkUnstructuredGrid* SMESH_ActorDef::GetUnstructuredGrid()
+{
return myVisualObj->GetUnstructuredGrid();
}
-bool SMESH_ActorDef::IsInfinitive(){
+bool SMESH_ActorDef::IsInfinitive()
+{
vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid();
myIsInfinite = aDataSet->GetNumberOfCells() == 0 ||
( aDataSet->GetNumberOfCells() == 1 &&
}
-void SMESH_ActorDef::SetIsShrunkable(bool theShrunkable){
+void SMESH_ActorDef::SetIsShrunkable(bool theShrunkable)
+{
if ( myIsShrinkable == theShrunkable )
return;
myIsShrinkable = theShrunkable;
Modified();
}
-double SMESH_ActorDef::GetShrinkFactor(){
+double SMESH_ActorDef::GetShrinkFactor()
+{
return myBaseActor->GetShrinkFactor();
}
-void SMESH_ActorDef::SetShrinkFactor(double theValue){
+void SMESH_ActorDef::SetShrinkFactor(double theValue)
+{
myBaseActor->SetShrinkFactor(theValue);
my1DActor->SetShrinkFactor(theValue);
Modified();
}
-void SMESH_ActorDef::SetShrink() {
+void SMESH_ActorDef::SetShrink()
+{
if(!myIsShrinkable) return;
myBaseActor->SetShrink();
Modified();
}
-void SMESH_ActorDef::UnShrink(){
+void SMESH_ActorDef::UnShrink()
+{
if(!myIsShrunk) return;
myBaseActor->UnShrink();
}
-int SMESH_ActorDef::GetNodeObjId(int theVtkID){
+int SMESH_ActorDef::GetNodeObjId(int theVtkID)
+{
return myPickableActor->GetNodeObjId(theVtkID);
}
-double* SMESH_ActorDef::GetNodeCoord(int theObjID){
+double* SMESH_ActorDef::GetNodeCoord(int theObjID)
+{
return myPickableActor->GetNodeCoord(theObjID);
}
-int SMESH_ActorDef::GetElemObjId(int theVtkID){
+int SMESH_ActorDef::GetElemObjId(int theVtkID)
+{
return myPickableActor->GetElemObjId(theVtkID);
}
-vtkCell* SMESH_ActorDef::GetElemCell(int theObjID){
+vtkCell* SMESH_ActorDef::GetElemCell(int theObjID)
+{
return myPickableActor->GetElemCell(theObjID);
}
-void SMESH_ActorDef::SetVisibility(int theMode){
+void SMESH_ActorDef::SetVisibility(int theMode)
+{
SetVisibility(theMode,true);
}
-void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){
+void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation)
+{
SALOME_Actor::SetVisibility(theMode);
myNodeActor->VisibilityOff();
if(theIsUpdateRepersentation)
SetRepresentation(GetRepresentation());
- if(myControlMode != eNone){
- switch(myControlMode){
+ if(myControlMode != eNone) {
+ switch(myControlMode) {
case eFreeNodes:
case eCoincidentNodes:
myNodeExtActor->VisibilityOn();
case eLength2D:
case eMultiConnection2D:
my1DExtActor->VisibilityOn();
- default:
- if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells())
- myScalarBarActor->VisibilityOn();
+ break;
+ default:;
}
+ if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells())
+ myScalarBarActor->VisibilityOn();
}
if(myRepresentation != ePoint)
if (myEntityMode & eFaces) {
if (MYDEBUG) MESSAGE("FACES");
aFilter->RegisterCellsWithType(VTK_TRIANGLE);
- aFilter->RegisterCellsWithType(VTK_POLYGON);
aFilter->RegisterCellsWithType(VTK_QUAD);
+ aFilter->RegisterCellsWithType(VTK_POLYGON);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
+ aFilter->RegisterCellsWithType(VTK_QUADRATIC_POLYGON);
aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_TRIANGLE);
aHightFilter->RegisterCellsWithType(VTK_TRIANGLE);
- aHightFilter->RegisterCellsWithType(VTK_POLYGON);
aHightFilter->RegisterCellsWithType(VTK_QUAD);
+ aHightFilter->RegisterCellsWithType(VTK_POLYGON);
aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
+ aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_POLYGON);
aHightFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
aHightFilter->RegisterCellsWithType(VTK_BIQUADRATIC_TRIANGLE);
}
aFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
-//#ifdef VTK_HAVE_POLYHEDRON
aFilter->RegisterCellsWithType(VTK_POLYHEDRON);
-//#endif
aHightFilter->RegisterCellsWithType(VTK_TETRA);
aHightFilter->RegisterCellsWithType(VTK_VOXEL);
aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_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());
my0DActor->SetRepresentation(aReperesent);
myBallActor->SetRepresentation(aReperesent);
- switch(myControlMode){
+ switch ( myControlMode ) {
case eLength:
case eMultiConnection:
aProp = aBackProp = my1DProp;
if(myRepresentation != ePoint)
aReperesent = SMESH_DeviceActor::eInsideframe;
break;
+ default:;
}
if(aQuadraticMode == SMESH_Actor::eLines)
}
-void SMESH_ActorDef::SetPointRepresentation(bool theIsPointsVisible){
+void SMESH_ActorDef::SetPointRepresentation(bool theIsPointsVisible)
+{
if ( myIsPointsVisible == theIsPointsVisible )
return;
myIsPointsVisible = theIsPointsVisible;
SetRepresentation(GetRepresentation());
}
-bool SMESH_ActorDef::GetPointRepresentation(){
+bool SMESH_ActorDef::GetPointRepresentation()
+{
return myIsPointsVisible || myNodeActor->GetPointsLabeled();
}
-void SMESH_ActorDef::UpdateHighlight(){
+void SMESH_ActorDef::UpdateHighlight()
+{
myHighlitableActor->SetHighlited(false);
myHighlitableActor->SetVisibility(false);
bool anIsVisible = GetVisibility();
}
-void SMESH_ActorDef::highlight(bool theHighlight){
+void SMESH_ActorDef::highlight(bool theHighlight)
+{
if ( myIsHighlighted == theHighlight )
return;
myIsHighlighted = theHighlight;
}
-void SMESH_ActorDef::SetPreSelected(bool thePreselect){
+void SMESH_ActorDef::SetPreSelected(bool thePreselect)
+{
if ( myIsPreselected == thePreselect )
return;
myIsPreselected = thePreselect;
}
-void SMESH_ActorDef::Render(vtkRenderer *ren){
+void SMESH_ActorDef::Render(vtkRenderer *ren)
+{
unsigned long aTime = myTimeStamp->GetMTime();
unsigned long anObjTime = myVisualObj->GetUnstructuredGrid()->GetMTime();
unsigned long aClippingTime = myImplicitBoolean->GetMTime();
}
-void SMESH_ActorDef::Update(){
+void SMESH_ActorDef::Update()
+{
if(MYDEBUG) MESSAGE("SMESH_ActorDef::Update");
if(GetControlMode() != eNone) {
}
-void SMESH_ActorDef::ReleaseGraphicsResources(vtkWindow *renWin){
+void SMESH_ActorDef::ReleaseGraphicsResources(vtkWindow *renWin)
+{
SALOME_Actor::ReleaseGraphicsResources(renWin);
myPickableActor->ReleaseGraphicsResources(renWin);
}
-static void GetColor(vtkProperty *theProperty, double& r,double& g,double& b){
+static void GetColor(vtkProperty *theProperty, double& r,double& g,double& b)
+{
double* aColor = theProperty->GetColor();
r = aColor[0];
g = aColor[1];
}
-void SMESH_ActorDef::SetOpacity(double theValue){
+void SMESH_ActorDef::SetOpacity(double theValue)
+{
mySurfaceProp->SetOpacity(theValue);
myBackSurfaceProp->SetOpacity(theValue);
myNormalVProp->SetOpacity(theValue);
}
-double SMESH_ActorDef::GetOpacity(){
+double SMESH_ActorDef::GetOpacity()
+{
return mySurfaceProp->GetOpacity();
}
-void SMESH_ActorDef::SetSufaceColor(double r,double g,double b, int delta){
+void SMESH_ActorDef::SetSufaceColor(double r,double g,double b, int delta)
+{
mySurfaceProp->SetColor(r,g,b);
my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
Modified();
}
-void SMESH_ActorDef::GetSufaceColor(double& r,double& g,double& b, int& delta){
+void SMESH_ActorDef::GetSufaceColor(double& r,double& g,double& b, int& delta)
+{
::GetColor(mySurfaceProp,r,g,b);
delta = myDeltaBrightness;
}
-void SMESH_ActorDef::SetVolumeColor(double r,double g,double b, int delta){
+void SMESH_ActorDef::SetVolumeColor(double r,double g,double b, int delta)
+{
myNormalVProp->SetColor(r,g,b);
my3DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
Modified();
}
-void SMESH_ActorDef::GetVolumeColor(double& r,double& g,double& b, int& delta){
+void SMESH_ActorDef::GetVolumeColor(double& r,double& g,double& b, int& delta)
+{
::GetColor(myNormalVProp,r,g,b);
delta = myDeltaVBrightness;
}
-void SMESH_ActorDef::SetEdgeColor(double r,double g,double b){
+void SMESH_ActorDef::SetEdgeColor(double r,double g,double b)
+{
myEdgeProp->SetColor(r,g,b);
my1DProp->SetColor(r,g,b);
my1DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
Modified();
}
-void SMESH_ActorDef::GetEdgeColor(double& r,double& g,double& b){
+void SMESH_ActorDef::GetEdgeColor(double& r,double& g,double& b)
+{
::GetColor(myEdgeProp,r,g,b);
}
-void SMESH_ActorDef::SetOutlineColor(double r,double g,double b){
+void SMESH_ActorDef::SetOutlineColor(double r,double g,double b)
+{
myOutLineProp->SetColor(r,g,b);
Modified();
}
-void SMESH_ActorDef::GetOutlineColor(double& r,double& g,double& b){
+void SMESH_ActorDef::GetOutlineColor(double& r,double& g,double& b)
+{
::GetColor(myOutLineProp,r,g,b);
}
-void SMESH_ActorDef::SetNodeColor(double r,double g,double b){
+void SMESH_ActorDef::SetNodeColor(double r,double g,double b)
+{
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() ) )
Modified();
}
-void SMESH_ActorDef::GetNodeColor(double& r,double& g,double& b){
+void SMESH_ActorDef::GetNodeColor(double& r,double& g,double& b)
+{
::GetColor(myNodeProp,r,g,b);
}
-void SMESH_ActorDef::Set0DColor(double r,double g,double b){
+void SMESH_ActorDef::Set0DColor(double r,double g,double b)
+{
my0DProp->SetColor(r,g,b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_0DElement )
Modified();
}
-void SMESH_ActorDef::Get0DColor(double& r,double& g,double& b){
+void SMESH_ActorDef::Get0DColor(double& r,double& g,double& b)
+{
::GetColor(my0DProp,r,g,b);
}
-void SMESH_ActorDef::SetBallColor(double r,double g,double b){
+void SMESH_ActorDef::SetBallColor(double r,double g,double b)
+{
myBallProp->SetColor(r,g,b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_Ball )
Modified();
}
-void SMESH_ActorDef::GetBallColor(double& r,double& g,double& b){
+void SMESH_ActorDef::GetBallColor(double& r,double& g,double& b)
+{
::GetColor(myBallProp,r,g,b);
}
-void SMESH_ActorDef::SetHighlightColor(double r,double g,double b){
+void SMESH_ActorDef::SetHighlightColor(double r,double g,double b)
+{
myHighlightProp->SetColor(r,g,b);
Modified();
}
-void SMESH_ActorDef::GetHighlightColor(double& r,double& g,double& b){
+void SMESH_ActorDef::GetHighlightColor(double& r,double& g,double& b)
+{
::GetColor(myHighlightProp,r,g,b);
}
-void SMESH_ActorDef::SetPreHighlightColor(double r,double g,double b){
+void SMESH_ActorDef::SetPreHighlightColor(double r,double g,double b)
+{
myPreselectProp->SetColor(r,g,b);
Modified();
}
-void SMESH_ActorDef::GetPreHighlightColor(double& r,double& g,double& b){
+void SMESH_ActorDef::GetPreHighlightColor(double& r,double& g,double& b)
+{
::GetColor(myPreselectProp,r,g,b);
}
-double SMESH_ActorDef::GetLineWidth(){
+double SMESH_ActorDef::GetLineWidth()
+{
return myEdgeProp->GetLineWidth();
}
-void SMESH_ActorDef::SetLineWidth(double theVal){
+void SMESH_ActorDef::SetLineWidth(double theVal)
+{
myEdgeProp->SetLineWidth(theVal);
my1DProp->SetLineWidth(theVal + aLineWidthInc);
Modified();
}
-void SMESH_ActorDef::Set0DSize(double theVal){
+void SMESH_ActorDef::Set0DSize(double theVal)
+{
my0DProp->SetPointSize(theVal);
myHighlightProp->SetPointSize(theVal);
myPreselectProp->SetPointSize(theVal);
Modified();
}
-double SMESH_ActorDef::Get0DSize(){
+double SMESH_ActorDef::Get0DSize()
+{
return my0DProp->GetPointSize();
}
-void SMESH_ActorDef::SetBallSize(double theVal){
+void SMESH_ActorDef::SetBallSize(double theVal)
+{
myBallProp->SetPointSize(theVal);
if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myHighlightActor )) {
Modified();
}
-double SMESH_ActorDef::GetBallSize(){
+double SMESH_ActorDef::GetBallSize()
+{
return myBallProp->GetPointSize();
}
+double SMESH_ActorDef::GetBallScale()
+{
+ return myBallActor->GetBallScale();
+}
+
+void SMESH_ActorDef::SetBallScale( double theVal )
+{
+ myBallActor->SetBallScale( theVal );
+ if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myHighlightActor )) {
+ aCustom->SetBallScale(theVal);
+ }
+ if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myPreHighlightActor )) {
+ aCustom->SetBallScale(theVal);
+ }
+
+ Modified();
+}
+
int SMESH_ActorDef::GetObjDimension( const int theObjId )
{
return myVisualObj->GetElemDimension( theObjId );
}
-bool
-SMESH_ActorDef::
-IsImplicitFunctionUsed() const
+bool SMESH_ActorDef::IsImplicitFunctionUsed() const
{
return myBaseActor->IsImplicitFunctionUsed();
}
-void
-SMESH_ActorDef::SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed)
+void SMESH_ActorDef::SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed)
{
myNodeActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
myBaseActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
my3DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
}
-vtkIdType
-SMESH_ActorDef::AddClippingPlane(vtkPlane* thePlane)
+vtkIdType SMESH_ActorDef::AddClippingPlane(vtkPlane* thePlane)
{
if(thePlane){
myImplicitBoolean->GetFunction()->AddItem(thePlane);
return myCippingPlaneCont.size();
}
-void
-SMESH_ActorDef::AddOpenGLClippingPlane(vtkPlane* thePlane)
+void SMESH_ActorDef::AddOpenGLClippingPlane(vtkPlane* thePlane)
{
if(thePlane)
myPlaneCollection->AddItem( thePlane );
}
-void
-SMESH_ActorDef::SetOpenGLClippingPlane()
+void SMESH_ActorDef::SetOpenGLClippingPlane()
{
// before use this method you must add clipping planes using method
// SMESH_ActorDef::AddOpenGLClippingPlane(vtkPlane* thePlane)
Modified();
}
-void
-SMESH_ActorDef::
-RemoveAllClippingPlanes()
+void SMESH_ActorDef::RemoveAllClippingPlanes()
{
myPlaneCollection->RemoveAllItems();
myImplicitBoolean->GetFunction()->RemoveAllItems();
myNodeActor->UpdateLabels();
}
-vtkIdType
-SMESH_ActorDef::
-GetNumberOfClippingPlanes()
+vtkIdType SMESH_ActorDef::GetNumberOfClippingPlanes()
{
return myCippingPlaneCont.size();
}
-vtkPlane*
-SMESH_ActorDef::
-GetClippingPlane(vtkIdType theID)
+vtkPlane* SMESH_ActorDef::GetClippingPlane(vtkIdType theID)
{
- if(theID >= myCippingPlaneCont.size())
+ if ( theID >= (vtkIdType)myCippingPlaneCont.size() )
return NULL;
return myCippingPlaneCont[theID].Get();
}
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;
+ std::vector<int> elemIds; elemIds.reserve( elems.size() );
for ( SMESH_VisualObjDef::TEntityList::iterator e = elems.begin(); e != elems.end(); ++e)
elemIds.push_back( (*e)->GetID());
vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
}
#ifndef DISABLE_PLOT2DVIEWER
-SPlot2d_Histogram* SMESH_ActorDef::UpdatePlot2Histogram() {
-
+SPlot2d_Histogram* SMESH_ActorDef::UpdatePlot2Histogram()
+{
if(my2dHistogram)
my2dHistogram->clearAllPoints();
bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
fun->GetHistogram(nbIntervals, nbEvents, funValues, elemIds, range, isLogarithmic);
- for ( int i = 0; i < std::min( nbEvents.size(), funValues.size() -1 ); i++ )
+ for ( size_t 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)
