-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2014 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
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
// SMESH OBJECT : interactive object for SMESH visualization
// File : SMESH_Actor.cxx
#include <vtkMath.h>
#include <vtkPlane.h>
+#include <vtkPlaneCollection.h>
#include <vtkImplicitBoolean.h>
#include <vtkImplicitFunctionCollection.h>
-#include <vtkConfigure.h>
-#if !defined(VTK_XVERSION)
-#define VTK_XVERSION (VTK_MAJOR_VERSION<<16)+(VTK_MINOR_VERSION<<8)+(VTK_BUILD_VERSION)
-#endif
-
#include "utilities.h"
#ifdef _DEBUG_
if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1);
- vtkFloatingPointType aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
- vtkFloatingPointType aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10);
- vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
- vtkFloatingPointType aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1);
+ 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);
SMESH::LabelFont aFamilyNd = SMESH::FntTimes;
bool aBoldNd = true;
aShadowNd = f.overline();
aSizeNd = f.pointSize();
}
- vtkFloatingPointType anRGBNd[3] = {1,1,1};
+ double anRGBNd[3] = {1,1,1};
SMESH::GetColor( "SMESH", "numbering_node_color", anRGBNd[0], anRGBNd[1], anRGBNd[2], QColor( 255, 255, 255 ) );
SMESH::LabelFont aFamilyEl = SMESH::FntTimes;
aShadowEl = f.overline();
aSizeEl = f.pointSize();
}
- vtkFloatingPointType anRGBEl[3] = {0,1,0};
+ double anRGBEl[3] = {0,1,0};
SMESH::GetColor( "SMESH", "numbering_elem_color", anRGBEl[0], anRGBEl[1], anRGBEl[2], QColor( 0, 255, 0 ) );
vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
//Definition 2D and 3D devices of the actor
//-----------------------------------------
- vtkFloatingPointType anRGB[3] = {1,1,1};
+ double anRGB[3] = {1,1,1};
mySurfaceProp = vtkProperty::New();
QColor ffc, bfc;
int delta;
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
+ aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_TRIANGLE);
my2DExtProp = vtkProperty::New();
my2DExtProp->DeepCopy(mySurfaceProp);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
+ aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_TRIANGLE);
my3DActor = SMESH_CellLabelActor::New();
my3DActor->SetStoreGemetryMapping(true);
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);
myBallActor->SetVisibility(false);
myBallActor->SetProperty(myBallProp);
myBallActor->SetRepresentation(SMESH_DeviceActor::eSurface);
+ myBallActor->SetBallEnabled(true);
aFilter = myBallActor->GetExtractUnstructuredGrid();
aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
aFilter->RegisterCellsWithType(VTK_POLY_VERTEX);
myHighlightProp->SetLineWidth(aLineWidth);
myHighlightProp->SetRepresentation(1);
- myBallHighlightProp = vtkProperty::New();
- myBallHighlightProp->DeepCopy(myHighlightProp);
- myBallHighlightProp->SetPointSize(aBallElemSize);
-
-
myOutLineProp = vtkProperty::New();
myOutLineProp->SetAmbient(1.0);
myOutLineProp->SetDiffuse(0.0);
myPreselectProp->SetLineWidth(aLineWidth);
myPreselectProp->SetRepresentation(1);
- myBallPreselectProp = vtkProperty::New();
- myBallPreselectProp->DeepCopy(myPreselectProp);
- myBallPreselectProp->SetPointSize(aBallElemSize);
-
myHighlitableActor = SMESH_DeviceActor::New();
myHighlitableActor->SetUserMatrix(aMatrix);
myHighlitableActor->PickableOff();
myImplicitBoolean = vtkImplicitBoolean::New();
myImplicitBoolean->SetOperationTypeToIntersection();
+ myPlaneCollection = vtkPlaneCollection::New();
+
//Quadratic 2D elements representation
//-----------------------------------------------------------------------------
int aQuadratic2DMode = mgr->integerValue( "SMESH", "quadratic_mode", 0);
myOutLineProp->Delete();
myPreselectProp->Delete();
- myBallHighlightProp->Delete();
- myBallPreselectProp->Delete();
-
myHighlitableActor->Delete();
my2DExtProp->Delete();
//my0DExtActor->Delete();
myImplicitBoolean->Delete();
+ myPlaneCollection->Delete();
#ifndef DISABLE_PLOT2DVIEWER
if(my2dHistogram) {
void SMESH_ActorDef::SetPointsFontProperties( SMESH::LabelFont theFamily, int theSize,
bool theBold, bool theItalic, bool theShadow,
- vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b )
-{
+ double r, double g, double b )
+{
if(myNodeActor) {
myNodeActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b );
SetRepresentation( GetRepresentation() );
void SMESH_ActorDef::SetCellsFontProperties( SMESH::LabelFont theFamily, int theSize,
bool theBold, bool theItalic, bool theShadow,
- vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b )
-{
+ double r, double g, double b )
+{
if(my3DActor) {
my3DActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b );
- SetRepresentation( GetRepresentation() );
- myTimeStamp->Modified();
}
if(my2DActor) {
my2DActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b );
return myIsFacesOriented;
}
-void SMESH_ActorDef::SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b)
+void SMESH_ActorDef::SetFacesOrientationColor(double r,double g,double b)
{
my2DActor->SetFacesOrientationColor( r, g, b );
my3DActor->SetFacesOrientationColor( r, g, b );
}
-void SMESH_ActorDef::GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b)
+void SMESH_ActorDef::GetFacesOrientationColor(double& r,double& g,double& b)
{
my3DActor->GetFacesOrientationColor( r, g, b );
}
-void SMESH_ActorDef::SetFacesOrientationScale(vtkFloatingPointType theScale)
+void SMESH_ActorDef::SetFacesOrientationScale(double theScale)
{
my2DActor->SetFacesOrientationScale( theScale );
my3DActor->SetFacesOrientationScale( theScale );
}
-vtkFloatingPointType SMESH_ActorDef::GetFacesOrientationScale()
+double SMESH_ActorDef::GetFacesOrientationScale()
{
return my3DActor->GetFacesOrientationScale();
}
void SMESH_ActorDef::AddToRender(vtkRenderer* theRenderer){
- //myHighlightActor->AddToRender(theRenderer);
-
theRenderer->AddActor(myBaseActor);
theRenderer->AddActor(myNodeExtActor);
theRenderer->AddActor(my1DExtActor);
my1DActor ->AddToRender(theRenderer);
my0DActor ->AddToRender(theRenderer);
myBallActor ->AddToRender(theRenderer);
- //theRenderer->AddActor(my0DExtActor);
theRenderer->AddActor(myHighlitableActor);
myVisualObj = theVisualObj;
myVisualObj->Update(theIsClear);
+ SMESH_SVTKActor::SafeDownCast(myHighlightActor)->SetVisualObject(myVisualObj);
+ SMESH_SVTKActor::SafeDownCast(myPreHighlightActor)->SetVisualObject(myVisualObj);
+
myNodeActor->Init(myVisualObj,myImplicitBoolean);
myBaseActor->Init(myVisualObj,myImplicitBoolean);
my2DExtActor->GetMapper()->SetLookupTable(myLookupTable);
my3DActor->GetMapper()->SetLookupTable(myLookupTable);
my3DExtActor->GetMapper()->SetLookupTable(myLookupTable);
-
- vtkFloatingPointType aFactor, aUnits;
+
+ double aFactor, aUnits;
my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
my2DExtActor->SetPolygonOffsetParameters(aFactor,aUnits*0.5);
}
-vtkFloatingPointType* SMESH_ActorDef::GetBounds(){
+double* SMESH_ActorDef::GetBounds(){
return myNodeActor->GetBounds();
}
bool SMESH_ActorDef::IsInfinitive(){
vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid();
- aDataSet->Update();
myIsInfinite = aDataSet->GetNumberOfCells() == 0 ||
( aDataSet->GetNumberOfCells() == 1 &&
aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX );
Modified();
}
-vtkFloatingPointType SMESH_ActorDef::GetShrinkFactor(){
+double SMESH_ActorDef::GetShrinkFactor(){
return myBaseActor->GetShrinkFactor();
}
-void SMESH_ActorDef::SetShrinkFactor(vtkFloatingPointType 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();
return myPickableActor->GetNodeObjId(theVtkID);
}
-vtkFloatingPointType* SMESH_ActorDef::GetNodeCoord(int theObjID){
+double* SMESH_ActorDef::GetNodeCoord(int theObjID){
return myPickableActor->GetNodeCoord(theObjID);
}
if (myEntityMode & eBallElem) {
aFilter->RegisterCellsWithType(VTK_POLY_VERTEX);
- aHightFilter->RegisterCellsWithType(VTK_POLY_VERTEX);
}
if (myEntityMode & eEdges) {
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
+ aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_TRIANGLE);
aHightFilter->RegisterCellsWithType(VTK_TRIANGLE);
aHightFilter->RegisterCellsWithType(VTK_POLYGON);
aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
aHightFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
+ aHightFilter->RegisterCellsWithType(VTK_BIQUADRATIC_TRIANGLE);
}
if (myEntityMode & eVolumes) {
aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
aFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
+ aFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID);
aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
//#ifdef VTK_HAVE_POLYHEDRON
if (theMode < 0) {
myRepresentation = eSurface;
- if (!aNbFaces && !aNbVolumes && aNbEdges) {
+ if (!aNbFaces && !aNbVolumes && !aNbBalls && aNbEdges) {
myRepresentation = eEdge;
- } else if (!aNbFaces && !aNbVolumes && !aNbEdges) {
+ } else if (!aNbFaces && !aNbVolumes && !aNbEdges && !aNbBalls) {
myRepresentation = ePoint;
}
} else {
my3DActor->SetBackfaceProperty(aPropVR);
my3DActor->SetRepresentation(aReperesent);
- //my0DExtActor->SetVisibility(false);
+
my1DExtActor->SetVisibility(false);
my2DExtActor->SetVisibility(false);
my3DExtActor->SetVisibility(false);
- // ???
- //my0DActor->SetProperty(aProp);
- //my0DActor->SetBackfaceProperty(aBackProp);
my0DActor->SetRepresentation(aReperesent);
myBallActor->SetRepresentation(aReperesent);
- //my0DExtActor->SetRepresentation(aReperesent);
switch(myControlMode){
case eLength:
void SMESH_ActorDef::UpdateHighlight(){
myHighlitableActor->SetHighlited(false);
myHighlitableActor->SetVisibility(false);
-
bool anIsVisible = GetVisibility();
switch(myRepresentation){
{
if(myIsHighlighted) {
myHighlitableActor->SetProperty(myHighlightProp);
- myBallActor->SetProperty(myBallHighlightProp);
}else if(myIsPreselected){
myHighlitableActor->SetProperty(myPreselectProp);
- myBallActor->SetProperty(myBallPreselectProp);
} else if(anIsVisible){
- myBallActor->SetProperty(myBallProp);
(myRepresentation == eSurface) ?
myHighlitableActor->SetProperty(myOutLineProp) : myHighlitableActor->SetProperty(myEdgeProp);
}
}
-static void GetColor(vtkProperty *theProperty, vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
- vtkFloatingPointType* aColor = theProperty->GetColor();
+static void GetColor(vtkProperty *theProperty, double& r,double& g,double& b){
+ double* aColor = theProperty->GetColor();
r = aColor[0];
g = aColor[1];
b = aColor[2];
}
-void SMESH_ActorDef::SetOpacity(vtkFloatingPointType theValue){
+void SMESH_ActorDef::SetOpacity(double theValue){
mySurfaceProp->SetOpacity(theValue);
myBackSurfaceProp->SetOpacity(theValue);
myNormalVProp->SetOpacity(theValue);
}
-vtkFloatingPointType SMESH_ActorDef::GetOpacity(){
+double SMESH_ActorDef::GetOpacity(){
return mySurfaceProp->GetOpacity();
}
-void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType 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(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& 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(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType 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(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& 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(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType 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(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetEdgeColor(double& r,double& g,double& b){
::GetColor(myEdgeProp,r,g,b);
}
-void SMESH_ActorDef::SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+void SMESH_ActorDef::SetOutlineColor(double r,double g,double b){
myOutLineProp->SetColor(r,g,b);
Modified();
}
-void SMESH_ActorDef::GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetOutlineColor(double& r,double& g,double& b){
::GetColor(myOutLineProp,r,g,b);
}
-void SMESH_ActorDef::SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType 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(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetNodeColor(double& r,double& g,double& b){
::GetColor(myNodeProp,r,g,b);
}
-void SMESH_ActorDef::Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType 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(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::Get0DColor(double& r,double& g,double& b){
::GetColor(my0DProp,r,g,b);
}
-void SMESH_ActorDef::SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType 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(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetBallColor(double& r,double& g,double& b){
::GetColor(myBallProp,r,g,b);
}
-void SMESH_ActorDef::SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+void SMESH_ActorDef::SetHighlightColor(double r,double g,double b){
myHighlightProp->SetColor(r,g,b);
- myBallHighlightProp->SetColor(r,g,b);
Modified();
}
-void SMESH_ActorDef::GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetHighlightColor(double& r,double& g,double& b){
::GetColor(myHighlightProp,r,g,b);
}
-void SMESH_ActorDef::SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+void SMESH_ActorDef::SetPreHighlightColor(double r,double g,double b){
myPreselectProp->SetColor(r,g,b);
- myBallPreselectProp->SetColor(r,g,b);
Modified();
}
-void SMESH_ActorDef::GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetPreHighlightColor(double& r,double& g,double& b){
::GetColor(myPreselectProp,r,g,b);
}
-vtkFloatingPointType SMESH_ActorDef::GetLineWidth(){
+double SMESH_ActorDef::GetLineWidth(){
return myEdgeProp->GetLineWidth();
}
-void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){
+void SMESH_ActorDef::SetLineWidth(double theVal){
myEdgeProp->SetLineWidth(theVal);
my1DProp->SetLineWidth(theVal + aLineWidthInc);
Modified();
}
-vtkFloatingPointType SMESH_ActorDef::GetOutlineWidth()
+double SMESH_ActorDef::GetOutlineWidth()
{
return myOutLineProp->GetLineWidth();
}
-void SMESH_ActorDef::SetOutlineWidth(vtkFloatingPointType theVal)
+void SMESH_ActorDef::SetOutlineWidth(double theVal)
{
myOutLineProp->SetLineWidth(theVal);
Modified();
}
-void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){
+void SMESH_ActorDef::Set0DSize(double theVal){
my0DProp->SetPointSize(theVal);
myHighlightProp->SetPointSize(theVal);
myPreselectProp->SetPointSize(theVal);
Modified();
}
-vtkFloatingPointType SMESH_ActorDef::Get0DSize(){
+double SMESH_ActorDef::Get0DSize(){
return my0DProp->GetPointSize();
}
-void SMESH_ActorDef::SetBallSize(vtkFloatingPointType theVal){
+void SMESH_ActorDef::SetBallSize(double theVal){
myBallProp->SetPointSize(theVal);
- myBallHighlightProp->SetPointSize(theVal);
- myBallPreselectProp->SetPointSize(theVal);
+
if(SMESH_SVTKActor* aCustom = SMESH_SVTKActor::SafeDownCast( myHighlightActor )) {
aCustom->SetBallSize(theVal);
}
Modified();
}
-vtkFloatingPointType SMESH_ActorDef::GetBallSize(){
+double SMESH_ActorDef::GetBallSize(){
return myBallProp->GetPointSize();
}
return myCippingPlaneCont.size();
}
+void
+SMESH_ActorDef::AddOpenGLClippingPlane(vtkPlane* thePlane)
+{
+ if(thePlane)
+ myPlaneCollection->AddItem( thePlane );
+}
+
+void
+SMESH_ActorDef::SetOpenGLClippingPlane()
+{
+ // before use this method you must add clipping planes using method
+ // SMESH_ActorDef::AddOpenGLClippingPlane(vtkPlane* thePlane)
+ if( !myPlaneCollection->GetNumberOfItems() )
+ return;
+
+ // It is necessary to set plane collection for each mapper of actor
+ // and update current inputs of mapper
+ myNodeActor->SetPlaneCollection( myPlaneCollection );
+ myNodeActor->SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
+
+ myBaseActor->SetPlaneCollection( myPlaneCollection );
+ myBaseActor->SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
+
+ myHighlitableActor->SetPlaneCollection( myPlaneCollection );
+ myHighlitableActor->SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
+
+ my1DActor->SetPlaneCollection( myPlaneCollection );
+ my1DActor->SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
+
+ my2DActor->SetPlaneCollection( myPlaneCollection );
+ my2DActor->SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
+
+ myNodeExtActor->SetPlaneCollection( myPlaneCollection );
+ myNodeExtActor->SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
+
+ my0DActor->SetPlaneCollection( myPlaneCollection );
+ my0DActor->SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
+
+ myBallActor->SetPlaneCollection( myPlaneCollection );
+ myBallActor->SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
+
+ my1DExtActor->SetPlaneCollection( myPlaneCollection );
+ my1DExtActor->SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
+
+ my2DExtActor->SetPlaneCollection( myPlaneCollection );
+ my2DExtActor->SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
+
+ my3DActor->SetPlaneCollection( myPlaneCollection );
+ my3DActor->SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
+
+ my3DExtActor->SetPlaneCollection( myPlaneCollection );
+ my3DExtActor->SetUnstructuredGrid(myVisualObj->GetUnstructuredGrid());
+
+ if(IsShrunk())
+ SetShrink();
+ else
+ Modified();
+}
+
void
SMESH_ActorDef::
RemoveAllClippingPlanes()
{
+ myPlaneCollection->RemoveAllItems();
myImplicitBoolean->GetFunction()->RemoveAllItems();
myImplicitBoolean->GetFunction()->Modified(); // VTK bug
myCippingPlaneCont.clear();
myScalarBarActor->SetOrientationToVertical();
- vtkFloatingPointType aXVal = horiz ? 0.20 : 0.01;
+ double 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;
+ double 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;
+ double 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;
+ double aHVal = horiz ? 0.12 : 0.80;
if( mgr->hasValue( "SMESH", name + "height" ) )
aHVal = mgr->doubleValue( "SMESH", name + "height", aHVal );
myScalarBarActor->SetHeight( aHVal );
