ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-28 18:30:35 +05:00
Code Issues Packages Projects Releases Wiki Activity

Porting to VTK 6.

Browse Source 
Compilation with ParaView built without option "-DVTK_LEGACY_REMOVE:BOOL=OFF".
This commit is contained in:
ouv 2013-01-30 12:32:34 +00:00
parent 6868039740
commit 786bd93631
28 changed files with 277 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
src/OBJECT/SMESH_Actor.cxx
View File

@ -147,10 +147,10 @@ SMESH_ActorDef::SMESH_ActorDef()
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;
@ -167,7 +167,7 @@ SMESH_ActorDef::SMESH_ActorDef()
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;
@ -185,7 +185,7 @@ SMESH_ActorDef::SMESH_ActorDef()
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();
@ -193,7 +193,7 @@ SMESH_ActorDef::SMESH_ActorDef()
//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;
@ -666,7 +666,7 @@ void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled )
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 );
@ -677,7 +677,7 @@ void SMESH_ActorDef::SetPointsFontProperties( SMESH::LabelFont theFamily, int th
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 );
@ -767,24 +767,24 @@ bool SMESH_ActorDef::GetFacesOriented()
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();
}
@ -1180,7 +1180,7 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
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);
@ -1223,7 +1223,7 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
}
vtkFloatingPointType* SMESH_ActorDef::GetBounds(){
double* SMESH_ActorDef::GetBounds(){
return myNodeActor->GetBounds();
}
@ -1296,11 +1296,11 @@ void SMESH_ActorDef::SetIsShrunkable(bool theShrunkable){
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);
@ -1357,7 +1357,7 @@ int SMESH_ActorDef::GetNodeObjId(int theVtkID){
return myPickableActor->GetNodeObjId(theVtkID);
}
vtkFloatingPointType* SMESH_ActorDef::GetNodeCoord(int theObjID){
double* SMESH_ActorDef::GetNodeCoord(int theObjID){
return myPickableActor->GetNodeCoord(theObjID);
}
@ -1906,15 +1906,15 @@ void SMESH_ActorDef::ReleaseGraphicsResources(vtkWindow *renWin){
}
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);
@ -1929,12 +1929,12 @@ void SMESH_ActorDef::SetOpacity(vtkFloatingPointType 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() ) )
@ -1947,12 +1947,12 @@ void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType
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() ) )
@ -1965,12 +1965,12 @@ void SMESH_ActorDef::SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType
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);
@ -1980,21 +1980,21 @@ void SMESH_ActorDef::SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,
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() ) )
@ -2003,11 +2003,11 @@ void SMESH_ActorDef::SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,
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 )
@ -2015,11 +2015,11 @@ void SMESH_ActorDef::Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vt
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 )
@ -2027,37 +2027,37 @@ void SMESH_ActorDef::SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,
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);
@ -2070,18 +2070,18 @@ void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){
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);
@ -2096,11 +2096,11 @@ void SMESH_ActorDef::Set0DSize(vtkFloatingPointType 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);
@ -2114,7 +2114,7 @@ void SMESH_ActorDef::SetBallSize(vtkFloatingPointType theVal){
Modified();
}
vtkFloatingPointType SMESH_ActorDef::GetBallSize(){
double SMESH_ActorDef::GetBallSize(){
return myBallProp->GetPointSize();
}
@ -2278,21 +2278,21 @@ void SMESH_ActorDef::UpdateScalarBar()
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 );

66
src/OBJECT/SMESH_Actor.h
View File

@ -62,44 +62,44 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
const char* theName,
int theIsClear);
virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta ) = 0;
virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta ) = 0;
virtual void SetSufaceColor(double r,double g,double b, int delta ) = 0;
virtual void GetSufaceColor(double& r,double& g,double& b, int& delta ) = 0;
virtual void SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta ) = 0;
virtual void GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta) = 0;
virtual void SetVolumeColor(double r,double g,double b, int delta ) = 0;
virtual void GetVolumeColor(double& r,double& g,double& b, int& delta) = 0;
virtual void SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetEdgeColor(double r,double g,double b) = 0;
virtual void GetEdgeColor(double& r,double& g,double& b) = 0;
virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetNodeColor(double r,double g,double b) = 0;
virtual void GetNodeColor(double& r,double& g,double& b) = 0;
virtual void SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetOutlineColor(double r,double g,double b) = 0;
virtual void GetOutlineColor(double& r,double& g,double& b) = 0;
virtual void Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void Set0DColor(double r,double g,double b) = 0;
virtual void Get0DColor(double& r,double& g,double& b) = 0;
virtual void SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetBallColor(double r,double g,double b) = 0;
virtual void GetBallColor(double& r,double& g,double& b) = 0;
virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetHighlightColor(double r,double g,double b) = 0;
virtual void GetHighlightColor(double& r,double& g,double& b) = 0;
virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetPreHighlightColor(double r,double g,double b) = 0;
virtual void GetPreHighlightColor(double& r,double& g,double& b) = 0;
virtual vtkFloatingPointType GetLineWidth() = 0;
virtual void SetLineWidth(vtkFloatingPointType theVal) = 0;
virtual double GetLineWidth() = 0;
virtual void SetLineWidth(double theVal) = 0;
virtual vtkFloatingPointType GetOutlineWidth() = 0;
virtual void SetOutlineWidth(vtkFloatingPointType theVal) = 0;
virtual double GetOutlineWidth() = 0;
virtual void SetOutlineWidth(double theVal) = 0;
virtual void Set0DSize(vtkFloatingPointType size) = 0;
virtual vtkFloatingPointType Get0DSize() = 0;
virtual void Set0DSize(double size) = 0;
virtual double Get0DSize() = 0;
virtual void SetBallSize(vtkFloatingPointType size) = 0;
virtual vtkFloatingPointType GetBallSize() = 0;
virtual void SetBallSize(double size) = 0;
virtual double GetBallSize() = 0;
enum EReperesent { ePoint, eEdge, eSurface};
@ -118,7 +118,7 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0;
virtual void SetShrinkFactor(vtkFloatingPointType theValue) = 0;
virtual void SetShrinkFactor(double theValue) = 0;
virtual void SetPointsLabeled(bool theIsPointsLabeled) = 0;
virtual bool GetPointsLabeled() = 0;
@ -129,11 +129,11 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
virtual void SetFacesOriented(bool theIsFacesOriented) = 0;
virtual bool GetFacesOriented() = 0;
virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetFacesOrientationColor(double r,double g,double b) = 0;
virtual void GetFacesOrientationColor(double& r,double& g,double& b) = 0;
virtual void SetFacesOrientationScale(vtkFloatingPointType theScale) = 0;
virtual vtkFloatingPointType GetFacesOrientationScale() = 0;
virtual void SetFacesOrientationScale(double theScale) = 0;
virtual double GetFacesOrientationScale() = 0;
virtual void SetFacesOrientation3DVectors(bool theState) = 0;
virtual bool GetFacesOrientation3DVectors() = 0;
@ -165,10 +165,10 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
virtual void SetPointsFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) = 0;
double r, double g, double b ) = 0;
virtual void SetCellsFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) = 0;
double r, double g, double b ) = 0;
#ifndef DISABLE_PLOT2DVIEWER
virtual SPlot2d_Histogram* GetPlot2Histogram() = 0;

76
src/OBJECT/SMESH_ActorDef.h
View File

@ -100,51 +100,51 @@ class SMESH_ActorDef : public SMESH_Actor
virtual bool IsInfinitive();
virtual void SetOpacity(vtkFloatingPointType theValue);
virtual vtkFloatingPointType GetOpacity();
virtual void SetOpacity(double theValue);
virtual double GetOpacity();
virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta );
virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta);
virtual void SetSufaceColor(double r,double g,double b, int delta );
virtual void GetSufaceColor(double& r,double& g,double& b, int& delta);
virtual void SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta );
virtual void GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta);
virtual void SetVolumeColor(double r,double g,double b, int delta );
virtual void GetVolumeColor(double& r,double& g,double& b, int& delta);
virtual void SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetEdgeColor(double r,double g,double b);
virtual void GetEdgeColor(double& r,double& g,double& b);
virtual void SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetOutlineColor(double r,double g,double b);
virtual void GetOutlineColor(double& r,double& g,double& b);
virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetNodeColor(double r,double g,double b);
virtual void GetNodeColor(double& r,double& g,double& b);
virtual void Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void Set0DColor(double r,double g,double b);
virtual void Get0DColor(double& r,double& g,double& b);
virtual void SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetBallColor(double r,double g,double b);
virtual void GetBallColor(double& r,double& g,double& b);
virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetHighlightColor(double r,double g,double b);
virtual void GetHighlightColor(double& r,double& g,double& b);
virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetPreHighlightColor(double r,double g,double b);
virtual void GetPreHighlightColor(double& r,double& g,double& b);
virtual vtkFloatingPointType GetLineWidth();
virtual void SetLineWidth(vtkFloatingPointType theVal);
virtual double GetLineWidth();
virtual void SetLineWidth(double theVal);
virtual vtkFloatingPointType GetOutlineWidth();
virtual void SetOutlineWidth(vtkFloatingPointType theVal);
virtual double GetOutlineWidth();
virtual void SetOutlineWidth(double theVal);
virtual void Set0DSize(vtkFloatingPointType size);
virtual vtkFloatingPointType Get0DSize();
virtual void Set0DSize(double size);
virtual double Get0DSize();
virtual void SetBallSize(vtkFloatingPointType size);
virtual vtkFloatingPointType GetBallSize();
virtual void SetBallSize(double size);
virtual double GetBallSize();
virtual int GetNodeObjId(int theVtkID);
virtual vtkFloatingPointType* GetNodeCoord(int theObjID);
virtual double* GetNodeCoord(int theObjID);
virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID);
@ -162,15 +162,15 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetPointRepresentation(bool theIsPointsVisible);
virtual bool GetPointRepresentation();
virtual vtkFloatingPointType* GetBounds();
virtual double* 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 double GetShrinkFactor();
virtual void SetShrinkFactor(double theValue);
virtual bool IsShrunkable() { return myIsShrinkable;}
virtual bool IsShrunk() { return myIsShrunk;}
@ -182,10 +182,10 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetPointsFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b );
double r, double g, double b );
virtual void SetCellsFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b );
double r, double g, double b );
virtual void SetCellsLabeled(bool theIsCellsLabeled);
virtual bool GetCellsLabeled();
@ -193,11 +193,11 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetFacesOriented(bool theIsFacesOriented);
virtual bool GetFacesOriented();
virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetFacesOrientationColor(double r,double g,double b);
virtual void GetFacesOrientationColor(double& r,double& g,double& b);
virtual void SetFacesOrientationScale(vtkFloatingPointType theScale);
virtual vtkFloatingPointType GetFacesOrientationScale();
virtual void SetFacesOrientationScale(double theScale);
virtual double GetFacesOrientationScale();
virtual void SetFacesOrientation3DVectors(bool theState);
virtual bool GetFacesOrientation3DVectors();

20
src/OBJECT/SMESH_ActorUtils.cxx
View File

@ -55,12 +55,12 @@
namespace SMESH
{
vtkFloatingPointType
double
GetFloat( const QString& theValue,
vtkFloatingPointType theDefault )
double theDefault )
{
int pos = theValue.indexOf( ":" );
vtkFloatingPointType val = theDefault;
double val = theDefault;
if( pos>=0 )
{
QString name = theValue.right( theValue.length()-pos-1 ),
@ -71,15 +71,15 @@ namespace SMESH
return val;
}
vtkFloatingPointType
double
GetFloat( const QString& theValue,
const QString& theSection,
vtkFloatingPointType theDefault )
double theDefault )
{
vtkFloatingPointType val = theDefault;
double val = theDefault;
SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
if( mgr )
val = (vtkFloatingPointType) mgr->doubleValue( theSection, theValue, theDefault );
val = (double) mgr->doubleValue( theSection, theValue, theDefault );
return val;
}
@ -129,9 +129,9 @@ namespace SMESH
void
GetColor( const QString& theSect,
const QString& theName,
vtkFloatingPointType& r,
vtkFloatingPointType& g,
vtkFloatingPointType& b,
double& r,
double& g,
double& b,
const QColor& def )
{
int ir( 0 ), ig( 0 ), ib( 0 );

14
src/OBJECT/SMESH_ActorUtils.h
View File

@ -41,15 +41,15 @@ namespace SMESH
};
SMESHOBJECT_EXPORT
vtkFloatingPointType
double
GetFloat( const QString& theValue,
vtkFloatingPointType theDefault = 0 );
double theDefault = 0 );
SMESHOBJECT_EXPORT
vtkFloatingPointType
double
GetFloat( const QString& theName,
const QString& theSection,
vtkFloatingPointType theDefault = 0 );
double theDefault = 0 );
SMESHOBJECT_EXPORT
QColor
@ -70,9 +70,9 @@ SMESHOBJECT_EXPORT
void
GetColor( const QString& theSect,
const QString& theName,
vtkFloatingPointType&,
vtkFloatingPointType&,
vtkFloatingPointType&,
double&,
double&,
double&,
const QColor& = QColor() );
SMESHOBJECT_EXPORT

2
src/OBJECT/SMESH_CellLabelActor.cxx
View File

@ -120,7 +120,7 @@ SMESH_CellLabelActor::~SMESH_CellLabelActor() {
void SMESH_CellLabelActor::SetFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b )
double r, double g, double b )
{
switch ( family ) {
case SMESH::FntArial:

2
src/OBJECT/SMESH_CellLabelActor.h
View File

@ -62,7 +62,7 @@ public:
virtual void SetFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b );
double r, double g, double b );
void UpdateLabels();

32
src/OBJECT/SMESH_DeviceActor.cxx
View File

@ -119,7 +119,7 @@ SMESH_DeviceActor
// Orientation of faces
myIsFacesOriented = false;
vtkFloatingPointType anRGB[3] = { 1, 1, 1 };
double anRGB[3] = { 1, 1, 1 };
SMESH::GetColor( "SMESH", "orientation_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 255, 255 ) );
myFaceOrientationFilter = SMESH_FaceOrientationFilter::New();
@ -639,26 +639,26 @@ SMESH_DeviceActor
void
SMESH_DeviceActor
::SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b)
::SetFacesOrientationColor(double r,double g,double b)
{
myFaceOrientation->GetProperty()->SetColor( r, g, b );
}
void
SMESH_DeviceActor
::GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b)
::GetFacesOrientationColor(double& r,double& g,double& b)
{
myFaceOrientation->GetProperty()->GetColor( r, g, b );
}
void
SMESH_DeviceActor
::SetFacesOrientationScale(vtkFloatingPointType theScale)
::SetFacesOrientationScale(double theScale)
{
myFaceOrientationFilter->SetOrientationScale( theScale );
}
vtkFloatingPointType
double
SMESH_DeviceActor
::GetFacesOrientationScale()
{
@ -781,13 +781,13 @@ SMESH_DeviceActor
return aRetID;
}
vtkFloatingPointType*
double*
SMESH_DeviceActor
::GetNodeCoord(int theObjID)
{
vtkDataSet* aDataSet = myMergeFilter->GetOutput();
vtkIdType anID = myVisualObj->GetNodeVTKId(theObjID);
vtkFloatingPointType* aCoord = (anID >=0) ? aDataSet->GetPoint(anID) : NULL;
double* aCoord = (anID >=0) ? aDataSet->GetPoint(anID) : NULL;
if(MYDEBUG) MESSAGE("GetNodeCoord - theObjID = "<<theObjID<<"; anID = "<<anID);
return aCoord;
}
@ -830,7 +830,7 @@ SMESH_DeviceActor
}
vtkFloatingPointType
double
SMESH_DeviceActor
::GetShrinkFactor()
{
@ -839,7 +839,7 @@ SMESH_DeviceActor
void
SMESH_DeviceActor
::SetShrinkFactor(vtkFloatingPointType theValue)
::SetShrinkFactor(double theValue)
{
theValue = theValue > 0.1? theValue: 0.8;
myShrinkFilter->SetShrinkFactor(theValue);
@ -862,13 +862,13 @@ SMESH_DeviceActor
::Render(vtkRenderer *ren, vtkMapper* m)
{
int aResolveCoincidentTopology = vtkMapper::GetResolveCoincidentTopology();
vtkFloatingPointType aStoredFactor, aStoredUnit;
double aStoredFactor, aStoredUnit;
vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(aStoredFactor,aStoredUnit);
vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
vtkFloatingPointType aFactor = myPolygonOffsetFactor, aUnits = myPolygonOffsetUnits;
double aFactor = myPolygonOffsetFactor, aUnits = myPolygonOffsetUnits;
if(myIsHighlited){
static vtkFloatingPointType EPS = .01;
static double EPS = .01;
aUnits *= (1.0-EPS);
}
vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnits);
@ -881,8 +881,8 @@ SMESH_DeviceActor
void
SMESH_DeviceActor
::SetPolygonOffsetParameters(vtkFloatingPointType factor,
vtkFloatingPointType units)
::SetPolygonOffsetParameters(double factor,
double units)
{
myPolygonOffsetFactor = factor;
myPolygonOffsetUnits = units;
@ -904,14 +904,14 @@ bool SMESH_DeviceActor::GetQuadraticArcMode(){
/*!
* Set Max angle for representation 2D quadratic element as arked polygon
*/
void SMESH_DeviceActor::SetQuadraticArcAngle(vtkFloatingPointType theMaxAngle){
void SMESH_DeviceActor::SetQuadraticArcAngle(double theMaxAngle){
myGeomFilter->SetQuadraticArcAngle(theMaxAngle);
}
/*!
* Return Max angle of the representation 2D quadratic element as arked polygon
*/
vtkFloatingPointType SMESH_DeviceActor::GetQuadraticArcAngle(){
double SMESH_DeviceActor::GetQuadraticArcAngle(){
return myGeomFilter->GetQuadraticArcAngle();
}

30
src/OBJECT/SMESH_DeviceActor.h
View File

@ -68,7 +68,7 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
void SetStoreIDMapping(bool theStoreMapping);
virtual int GetNodeObjId(int theVtkID);
virtual vtkFloatingPointType* GetNodeCoord(int theObjID);
virtual double* GetNodeCoord(int theObjID);
virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID);
@ -79,11 +79,11 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
virtual void SetFacesOriented(bool theIsFacesOriented);
virtual bool GetFacesOriented() { return myIsFacesOriented; }
virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetFacesOrientationColor(double r,double g,double b);
virtual void GetFacesOrientationColor(double& r,double& g,double& b);
virtual void SetFacesOrientationScale(vtkFloatingPointType theScale);
virtual vtkFloatingPointType GetFacesOrientationScale();
virtual void SetFacesOrientationScale(double theScale);
virtual double GetFacesOrientationScale();
virtual void SetFacesOrientation3DVectors(bool theState);
virtual bool GetFacesOrientation3DVectors();
@ -93,13 +93,13 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
virtual void SetQuadraticArcMode(bool theFlag);
virtual bool GetQuadraticArcMode();
virtual void SetQuadraticArcAngle(vtkFloatingPointType theMaxAngle);
virtual vtkFloatingPointType GetQuadraticArcAngle();
virtual void SetQuadraticArcAngle(double theMaxAngle);
virtual double GetQuadraticArcAngle();
void UpdateFaceOrientation();
vtkFloatingPointType GetShrinkFactor();
void SetShrinkFactor(vtkFloatingPointType value);
double GetShrinkFactor();
void SetShrinkFactor(double value);
bool IsShrunkable() { return myIsShrinkable;}
bool IsShrunk() { return myIsShrunk;}
@ -182,16 +182,16 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
bool myIsHighlited;
vtkFloatingPointType myPolygonOffsetFactor;
vtkFloatingPointType myPolygonOffsetUnits;
double myPolygonOffsetFactor;
double myPolygonOffsetUnits;
void
SetPolygonOffsetParameters(vtkFloatingPointType factor,
vtkFloatingPointType units);
SetPolygonOffsetParameters(double factor,
double units);
void
GetPolygonOffsetParameters(vtkFloatingPointType& factor,
vtkFloatingPointType& units)
GetPolygonOffsetParameters(double& factor,
double& units)
{
factor = myPolygonOffsetFactor;
units = myPolygonOffsetUnits;

6
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

@ -89,8 +89,8 @@ int SMESH_ExtractGeometry::RequestData(
vtkIdList *cellPts;
vtkCell *cell;
int numCellPts;
vtkFloatingPointType *x;
vtkFloatingPointType multiplier;
double *x;
double multiplier;
vtkPoints *newPts;
vtkIdList *newCellPts;
vtkPointData *pd = input->GetPointData();
@ -163,7 +163,7 @@ int SMESH_ExtractGeometry::RequestData(
// To extract boundary cells, we have to create supplemental information
if ( this->ExtractBoundaryCells )
{
vtkFloatingPointType val;
double val;
newScalars = vtkFloatArray::New();
newScalars->SetNumberOfValues(numPts);

3
src/OBJECT/SMESH_FaceOrientationFilter.cxx
View File

@ -42,7 +42,6 @@
#define PI 3.14159265359
vtkCxxRevisionMacro(SMESH_FaceOrientationFilter, "$Revision$");
vtkStandardNewMacro(SMESH_FaceOrientationFilter);
/*!
@ -93,7 +92,7 @@ SMESH_FaceOrientationFilter::~SMESH_FaceOrientationFilter()
myBaseGlyph->Delete();
}
void SMESH_FaceOrientationFilter::SetOrientationScale( vtkFloatingPointType theScale )
void SMESH_FaceOrientationFilter::SetOrientationScale( double theScale )
{
myOrientationScale = theScale;
Modified();

8
src/OBJECT/SMESH_FaceOrientationFilter.h
View File

@ -33,13 +33,13 @@ class VTKViewer_CellCenters;
class SMESHOBJECT_EXPORT SMESH_FaceOrientationFilter : public vtkPolyDataAlgorithm
{
public:
vtkTypeRevisionMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm );
vtkTypeMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm );
/*!Create a new SMESH_FaceOrientationFilter.*/
static SMESH_FaceOrientationFilter *New();
void SetOrientationScale( vtkFloatingPointType );
vtkFloatingPointType GetOrientationScale() const { return myOrientationScale; }
void SetOrientationScale( double );
double GetOrientationScale() const { return myOrientationScale; }
void Set3dVectors( bool );
bool Get3dVectors() const { return my3dVectors; }
@ -61,7 +61,7 @@ private:
private:
bool my3dVectors;
vtkFloatingPointType myOrientationScale;
double myOrientationScale;
vtkPolyData* myArrowPolyData;
vtkPolyData* myFacePolyData;
VTKViewer_CellCenters* myFaceCenters;

2
src/OBJECT/SMESH_NodeLabelActor.cxx
View File

@ -112,7 +112,7 @@ SMESH_NodeLabelActor::~SMESH_NodeLabelActor() {
void SMESH_NodeLabelActor::SetFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b )
double r, double g, double b )
{
switch ( family ) {
case SMESH::FntArial:

2
src/OBJECT/SMESH_NodeLabelActor.h
View File

@ -59,7 +59,7 @@ public:
virtual void SetFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b );
double r, double g, double b );
void UpdateLabels();

14
src/SMESHGUI/SMESHGUI.cxx
View File

@ -1257,7 +1257,7 @@
return;
}
case 1132: {
vtkFloatingPointType color[3];
double color[3];
QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
QColor orientationColor, outlineColor, volumeColor;
int deltaF = 0, deltaV = 0;
@ -1265,8 +1265,8 @@
int ballSize = 1;
int edgeWidth = 1;
int outlineWidth = 1;
vtkFloatingPointType shrinkCoef = 0.0;
vtkFloatingPointType orientationScale = 0.0;
double shrinkCoef = 0.0;
double orientationScale = 0.0;
bool orientation3d = false;
VTK::MarkerType markerType = VTK::MT_NONE;
VTK::MarkerScale markerScale = VTK::MS_NONE;
@ -5457,7 +5457,7 @@ void SMESHGUI::storeVisualParameters (int savePoint)
ip->setParameter(entry, param, modeStr.toLatin1().data());
// Colors
vtkFloatingPointType r, g, b;
double r, g, b;
int delta;
aSmeshActor->GetSufaceColor(r, g, b, delta);
@ -5596,8 +5596,8 @@ void SMESHGUI::storeVisualParameters (int savePoint)
typedef struct {
int Id;
vtkIdType Orientation;
vtkFloatingPointType Distance;
vtkFloatingPointType Angle[2];
double Distance;
double Angle[2];
} TPlaneData;
typedef std::list<TPlaneData> TPlaneDataList;
typedef std::map<int, TPlaneDataList> TPlaneDataMap;
@ -6172,7 +6172,7 @@ void SMESHGUI::restoreVisualParameters (int savePoint)
if (val != "Off") {
SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
double aDistance = vals[1].toFloat();
vtkFloatingPointType anAngle[2];
double anAngle[2];
anAngle[0] = vals[2].toFloat();
anAngle[1] = vals[3].toFloat();

2
src/SMESHGUI/SMESHGUI.h
View File

@ -221,7 +221,7 @@ private :
SMESHGUI_ClippingPlaneInfoMap myClippingPlaneInfoMap;
vtkSmartPointer<vtkCallbackCommand> myEventCallbackCommand;
vtkFloatingPointType myPriority;
double myPriority;
};
#endif // SMESHGUI_H

2
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
View File

@ -120,7 +120,7 @@ namespace SMESH
myPreviewActor->VisibilityOff();
myPreviewActor->SetMapper(myMapper);
vtkFloatingPointType anRGB[3];
double anRGB[3];
vtkProperty* aProp = vtkProperty::New();
GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
aProp->SetColor( anRGB[0], anRGB[1], anRGB[2] );

4
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

@ -121,7 +121,7 @@ namespace SMESH
vtkUnstructuredGrid* myGrid;
//vtkProperty* myBackProp, *myProp;
//vtkFloatingPointType myRGB[3], myBackRGB[3];
//double myRGB[3], myBackRGB[3];
SALOME_Actor* myFaceOrientation;
vtkPolyDataMapper* myFaceOrientationDataMapper;
@ -148,7 +148,7 @@ namespace SMESH
myPreviewActor->SetMapper(myMapper);
vtkProperty* myProp = vtkProperty::New();
vtkFloatingPointType aRGB[3], aBackRGB[3];
double aRGB[3], aBackRGB[3];
GetColor( "SMESH", "fill_color", aRGB[0], aRGB[1], aRGB[2], QColor( 0, 170, 255 ) );
myProp->SetColor( aRGB[0], aRGB[1], aRGB[2] );
myPreviewActor->SetProperty( myProp );

74
src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
View File

@ -140,7 +140,7 @@ void SMESH::OrientedPlane::Init()
myActor->SetInfinitive(true);
myActor->SetMapper(myMapper);
vtkFloatingPointType anRGB[3];
double anRGB[3];
vtkProperty* aProp = vtkProperty::New();
SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
@ -208,7 +208,7 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
SVTK_ViewWindow* theViewWindow,
SMESH::Orientation theOrientation,
double theDistance,
const vtkFloatingPointType theAngle[2])
const double theAngle[2])
{
SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New(theViewWindow);
@ -218,13 +218,13 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
aPlane->SetOrientation(theOrientation);
aPlane->SetDistance(theDistance);
vtkFloatingPointType aNormal[3];
vtkFloatingPointType aDir[2][3] = {{0, 0, 0}, {0, 0, 0}};
double aNormal[3];
double aDir[2][3] = {{0, 0, 0}, {0, 0, 0}};
{
static double aCoeff = vtkMath::Pi()/180.0;
vtkFloatingPointType anU[2] = {cos(aCoeff * theAngle[0]), cos(aCoeff * theAngle[1])};
vtkFloatingPointType aV[2] = {sqrt(1.0 - anU[0]*anU[0]), sqrt(1.0 - anU[1]*anU[1])};
double anU[2] = {cos(aCoeff * theAngle[0]), cos(aCoeff * theAngle[1])};
double aV[2] = {sqrt(1.0 - anU[0]*anU[0]), sqrt(1.0 - anU[1]*anU[1])};
aV[0] = theAngle[0] > 0? aV[0]: -aV[0];
aV[1] = theAngle[1] > 0? aV[1]: -aV[1];
@ -260,8 +260,8 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
vtkMath::Cross(aNormal,aDir[1],aDir[0]);
}
vtkFloatingPointType aBounds[6];
vtkFloatingPointType anOrigin[3];
double aBounds[6];
double anOrigin[3];
bool anIsOk = false;
if( theActorList.empty() ) {
@ -284,38 +284,38 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
aPlane->SetNormal( aNormal );
aPlane->SetOrigin( anOrigin );
vtkFloatingPointType aPnt[3] = { ( aBounds[0] + aBounds[1] ) / 2.,
double aPnt[3] = { ( aBounds[0] + aBounds[1] ) / 2.,
( aBounds[2] + aBounds[3] ) / 2.,
( aBounds[4] + aBounds[5] ) / 2. };
vtkFloatingPointType aDel = pow( pow( aBounds[1] - aBounds[0], 2 ) +
double aDel = pow( pow( aBounds[1] - aBounds[0], 2 ) +
pow( aBounds[3] - aBounds[2], 2 ) +
pow( aBounds[5] - aBounds[4], 2 ), 0.5 );
vtkFloatingPointType aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
double aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
{aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}};
vtkFloatingPointType aParam, aPnt0[3], aPnt1[3], aPnt2[3];
double aParam, aPnt0[3], aPnt1[3], aPnt2[3];
vtkFloatingPointType aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
double aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
aPnt[1] - aDelta[0][1] - aDelta[1][1],
aPnt[2] - aDelta[0][2] - aDelta[1][2]};
vtkFloatingPointType aPnt02[3] = {aPnt01[0] + aNormal[0],
double aPnt02[3] = {aPnt01[0] + aNormal[0],
aPnt01[1] + aNormal[1],
aPnt01[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0);
vtkFloatingPointType aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
double aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
aPnt[1] - aDelta[0][1] + aDelta[1][1],
aPnt[2] - aDelta[0][2] + aDelta[1][2]};
vtkFloatingPointType aPnt12[3] = {aPnt11[0] + aNormal[0],
double aPnt12[3] = {aPnt11[0] + aNormal[0],
aPnt11[1] + aNormal[1],
aPnt11[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1);
vtkFloatingPointType aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
double aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
aPnt[1] + aDelta[0][1] - aDelta[1][1],
aPnt[2] + aDelta[0][2] - aDelta[1][2]};
vtkFloatingPointType aPnt22[3] = {aPnt21[0] + aNormal[0],
double aPnt22[3] = {aPnt21[0] + aNormal[0],
aPnt21[1] + aNormal[1],
aPnt21[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2);
@ -897,18 +897,18 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
SMESH::TPlaneData aPlaneData = myPlanes[aCurPlaneIndex];
SMESH::OrientedPlane* aPlane = aPlaneData.Plane.GetPointer();
vtkFloatingPointType aNormal[3];
double aNormal[3];
SMESH::Orientation anOrientation;
vtkFloatingPointType aDir[3][3] = {{0, 0, 0}, {0, 0, 0}};
double aDir[3][3] = {{0, 0, 0}, {0, 0, 0}};
{
static double aCoeff = vtkMath::Pi()/180.0;
vtkFloatingPointType aRot[2] = {getRotation1(), getRotation2()};
double aRot[2] = {getRotation1(), getRotation2()};
aPlane->myAngle[0] = aRot[0];
aPlane->myAngle[1] = aRot[1];
vtkFloatingPointType anU[2] = {cos(aCoeff*aRot[0]), cos(aCoeff*aRot[1])};
vtkFloatingPointType aV[2] = {sqrt(1.0-anU[0]*anU[0]), sqrt(1.0-anU[1]*anU[1])};
double anU[2] = {cos(aCoeff*aRot[0]), cos(aCoeff*aRot[1])};
double aV[2] = {sqrt(1.0-anU[0]*anU[0]), sqrt(1.0-anU[1]*anU[1])};
aV[0] = aRot[0] > 0? aV[0]: -aV[0];
aV[1] = aRot[1] > 0? aV[1]: -aV[1];
@ -955,8 +955,8 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
SMESH::TActorList anActorList = aPlaneData.ActorList;
vtkFloatingPointType aBounds[6];
vtkFloatingPointType anOrigin[3];
double aBounds[6];
double anOrigin[3];
bool anIsOk = SMESH::ComputeClippingPlaneParameters( anActorList,
aNormal,
getDistance(),
@ -969,38 +969,38 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
aPlane->SetNormal( aNormal );
aPlane->SetOrigin( anOrigin );
vtkFloatingPointType aPnt[3] = { ( aBounds[0] + aBounds[1] ) / 2.,
double aPnt[3] = { ( aBounds[0] + aBounds[1] ) / 2.,
( aBounds[2] + aBounds[3] ) / 2.,
( aBounds[4] + aBounds[5] ) / 2. };
vtkFloatingPointType aDel = pow( pow( aBounds[1] - aBounds[0], 2 ) +
double aDel = pow( pow( aBounds[1] - aBounds[0], 2 ) +
pow( aBounds[3] - aBounds[2], 2 ) +
pow( aBounds[5] - aBounds[4], 2 ), 0.5 );
vtkFloatingPointType aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
double aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
{aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}};
vtkFloatingPointType aParam, aPnt0[3], aPnt1[3], aPnt2[3];
double aParam, aPnt0[3], aPnt1[3], aPnt2[3];
vtkFloatingPointType aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
double aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
aPnt[1] - aDelta[0][1] - aDelta[1][1],
aPnt[2] - aDelta[0][2] - aDelta[1][2]};
vtkFloatingPointType aPnt02[3] = {aPnt01[0] + aNormal[0],
double aPnt02[3] = {aPnt01[0] + aNormal[0],
aPnt01[1] + aNormal[1],
aPnt01[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0);
vtkFloatingPointType aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
double aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
aPnt[1] - aDelta[0][1] + aDelta[1][1],
aPnt[2] - aDelta[0][2] + aDelta[1][2]};
vtkFloatingPointType aPnt12[3] = {aPnt11[0] + aNormal[0],
double aPnt12[3] = {aPnt11[0] + aNormal[0],
aPnt11[1] + aNormal[1],
aPnt11[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1);
vtkFloatingPointType aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
double aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
aPnt[1] + aDelta[0][1] - aDelta[1][1],
aPnt[2] + aDelta[0][2] - aDelta[1][2]};
vtkFloatingPointType aPnt22[3] = {aPnt21[0] + aNormal[0],
double aPnt22[3] = {aPnt21[0] + aNormal[0],
aPnt21[1] + aNormal[1],
aPnt21[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2);
@ -1147,8 +1147,8 @@ void SMESHGUI_ClippingDlg::dumpPlaneData() const
for ( ; anIter1 != myPlanes.end(); anIter1++, anId++ ) {
SMESH::TPlaneData aPlaneData = *anIter1;
SMESH::TPlane aPlane = aPlaneData.Plane;
vtkFloatingPointType* aNormal = aPlane->GetNormal();
vtkFloatingPointType* anOrigin = aPlane->GetOrigin();
double* aNormal = aPlane->GetNormal();
double* anOrigin = aPlane->GetOrigin();
printf( "Plane N%d:\n", anId );
printf( " Normal = ( %f, %f, %f )\n", aNormal[0], aNormal[1], aNormal[2] );
printf( " Origin = ( %f, %f, %f )\n", anOrigin[0], anOrigin[1], anOrigin[2] );

2
src/SMESHGUI/SMESHGUI_ClippingDlg.h
View File

@ -145,7 +145,7 @@ public:
SVTK_ViewWindow* theViewWindow,
SMESH::Orientation theOrientation,
double theDistance,
const vtkFloatingPointType theAngle[2]);
const double theAngle[2]);
protected:
void keyPressEvent( QKeyEvent* );

4
src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
View File

@ -1180,8 +1180,8 @@ void SMESHGUI_BaseComputeOp::onShowBadMesh()
if ( myBadMeshDisplayer ) delete myBadMeshDisplayer;
myBadMeshDisplayer = new SMESHGUI_MeshEditPreview( view );
SMESH::MeshPreviewStruct_var aMeshData = gen->GetBadInputElements(myMesh,curSub);
vtkFloatingPointType aPointSize = SMESH::GetFloat("SMESH:node_size",3);
vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
double aPointSize = SMESH::GetFloat("SMESH:node_size",3);
double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
vtkProperty* prop = vtkProperty::New();
prop->SetLineWidth( aLineWidth * 3 );
prop->SetPointSize( aPointSize * 3 );

4
src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
View File

@ -260,8 +260,8 @@ bool SMESHGUI_ConvToQuadOp::onApply()
if ( myBadElemsPreview ) delete myBadElemsPreview; // viewWindow may change
myBadElemsPreview = new SMESHGUI_MeshEditPreview( viewWindow() );
vtkFloatingPointType aPointSize = SMESH::GetFloat("SMESH:node_size",3);
vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
double aPointSize = SMESH::GetFloat("SMESH:node_size",3);
double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
vtkProperty* prop = vtkProperty::New();
prop->SetLineWidth( aLineWidth * 3 );
prop->SetPointSize( aPointSize * 3 );

4
src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
View File

@ -114,12 +114,12 @@ namespace SMESH
myPreviewActor->SetMapper( myMapper );
myPreviewActor->SetRepresentation( 3 );
vtkFloatingPointType anRGB[3];
double anRGB[3];
vtkProperty* aProp = vtkProperty::New();
GetColor( "SMESH", "selection_element_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
myPreviewActor->SetProperty( aProp );
vtkFloatingPointType aFactor,aUnits;
double aFactor,aUnits;
myPreviewActor->SetResolveCoincidentTopology(true);
myPreviewActor->GetPolygonOffsetParameters(aFactor,aUnits);
myPreviewActor->SetPolygonOffsetParameters(aFactor,0.2*aUnits);

4
src/SMESHGUI/SMESHGUI_MeshEditPreview.cxx
View File

@ -73,12 +73,12 @@ SMESHGUI_MeshEditPreview::SMESHGUI_MeshEditPreview(SVTK_ViewWindow* theViewWindo
myPreviewActor->VisibilityOn();
myPreviewActor->PickableOff();
vtkFloatingPointType aFactor,aUnits;
double aFactor,aUnits;
myPreviewActor->SetResolveCoincidentTopology(true);
myPreviewActor->GetPolygonOffsetParameters(aFactor,aUnits);
myPreviewActor->SetPolygonOffsetParameters(aFactor,0.2*aUnits);
vtkFloatingPointType anRGB[3];
double anRGB[3];
SMESH::GetColor( "SMESH", "selection_element_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
SetColor( anRGB[0], anRGB[1], anRGB[2] );

4
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
View File

@ -185,11 +185,11 @@ namespace SMESH
vtkProperty* aProp = vtkProperty::New();
aProp->SetRepresentationToPoints();
vtkFloatingPointType anRGB[3];
double anRGB[3];
GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 0 ) );
aProp->SetColor( anRGB[0], anRGB[1], anRGB[2] );
vtkFloatingPointType aPointSize = GetFloat( "SMESH:node_size", 3 );
double aPointSize = GetFloat( "SMESH:node_size", 3 );
aProp->SetPointSize( aPointSize );
myPreviewActor->SetProperty( aProp );

6
src/SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.cxx
View File

@ -639,13 +639,13 @@ void SMESHGUI_Preferences_ScalarBarDlg::onSelectionChanged()
SMESH_ScalarBarActor* myScalarBarActor = myActor->GetScalarBarActor();
if ( myScalarBarActor->GetLookupTable() ) {
vtkFloatingPointType *range = myScalarBarActor->GetLookupTable()->GetRange();
double *range = myScalarBarActor->GetLookupTable()->GetRange();
myMinEdit->setText( QString::number( range[0],'g',12 ) );
myMaxEdit->setText( QString::number( range[1],'g',12 ) );
}
vtkTextProperty* aTitleTextPrp = myScalarBarActor->GetTitleTextProperty();
vtkFloatingPointType aTColor[3];
double aTColor[3];
aTitleTextPrp->GetColor( aTColor );
myTitleColorBtn->setColor( QColor( (int)( aTColor[0]*255 ), (int)( aTColor[1]*255 ), (int)( aTColor[2]*255 ) ) );
myTitleFontCombo->setCurrentIndex( aTitleTextPrp->GetFontFamily() );
@ -654,7 +654,7 @@ void SMESHGUI_Preferences_ScalarBarDlg::onSelectionChanged()
myTitleShadowCheck->setChecked( aTitleTextPrp->GetShadow() );
vtkTextProperty* aLabelsTextPrp = myScalarBarActor->GetLabelTextProperty();
vtkFloatingPointType aLColor[3];
double aLColor[3];
aLabelsTextPrp->GetColor( aLColor );
myLabelsColorBtn->setColor( QColor( (int)( aLColor[0]*255 ), (int)( aLColor[1]*255 ), (int)( aLColor[2]*255 ) ) );
myLabelsFontCombo->setCurrentIndex( aLabelsTextPrp->GetFontFamily() );

56
src/SMESHGUI/SMESHGUI_VTKUtils.cxx
View File

@ -961,7 +961,7 @@ namespace SMESH
SUIT_ResourceMgr* mgr = SMESH::GetResourceMgr( theModule );
if ( !mgr ) return;
//
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 ) );
int aSizeNd = 10;
SMESH::LabelFont aFamilyNd = SMESH::FntTimes;
@ -980,7 +980,7 @@ namespace SMESH
aSizeNd = 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 ) );
int aSizeEl = 12;
SMESH::LabelFont aFamilyEl = SMESH::FntTimes;
@ -1323,21 +1323,21 @@ namespace SMESH
//----------------------------------------------------------------------------
// internal function
void ComputeBoundsParam( vtkFloatingPointType theBounds[6],
vtkFloatingPointType theDirection[3],
vtkFloatingPointType theMinPnt[3],
vtkFloatingPointType& theMaxBoundPrj,
vtkFloatingPointType& theMinBoundPrj )
void ComputeBoundsParam( double theBounds[6],
double theDirection[3],
double theMinPnt[3],
double& theMaxBoundPrj,
double& theMinBoundPrj )
{
//Enlarge bounds in order to avoid conflicts of precision
for(int i = 0; i < 6; i += 2){
static double EPS = 1.0E-3;
vtkFloatingPointType aDelta = (theBounds[i+1] - theBounds[i])*EPS;
double aDelta = (theBounds[i+1] - theBounds[i])*EPS;
theBounds[i] -= aDelta;
theBounds[i+1] += aDelta;
}
vtkFloatingPointType aBoundPoints[8][3] = { {theBounds[0],theBounds[2],theBounds[4]},
double aBoundPoints[8][3] = { {theBounds[0],theBounds[2],theBounds[4]},
{theBounds[1],theBounds[2],theBounds[4]},
{theBounds[0],theBounds[3],theBounds[4]},
{theBounds[1],theBounds[3],theBounds[4]},
@ -1350,7 +1350,7 @@ namespace SMESH
theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]);
theMinBoundPrj = theMaxBoundPrj;
for(int i = 1; i < 8; i++){
vtkFloatingPointType aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]);
double aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]);
if(theMaxBoundPrj < aTmp){
theMaxBoundPrj = aTmp;
aMaxId = i;
@ -1359,43 +1359,43 @@ namespace SMESH
theMinBoundPrj = aTmp;
}
}
vtkFloatingPointType *aMinPnt = aBoundPoints[aMaxId];
double *aMinPnt = aBoundPoints[aMaxId];
theMinPnt[0] = aMinPnt[0];
theMinPnt[1] = aMinPnt[1];
theMinPnt[2] = aMinPnt[2];
}
// internal function
void DistanceToPosition( vtkFloatingPointType theBounds[6],
vtkFloatingPointType theDirection[3],
vtkFloatingPointType theDist,
vtkFloatingPointType thePos[3] )
void DistanceToPosition( double theBounds[6],
double theDirection[3],
double theDist,
double thePos[3] )
{
vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
double aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
ComputeBoundsParam(theBounds,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
vtkFloatingPointType aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist;
double aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist;
thePos[0] = aMinPnt[0]-theDirection[0]*aLength;
thePos[1] = aMinPnt[1]-theDirection[1]*aLength;
thePos[2] = aMinPnt[2]-theDirection[2]*aLength;
}
// internal function (currently unused, left just in case)
void PositionToDistance( vtkFloatingPointType theBounds[6],
vtkFloatingPointType theDirection[3],
vtkFloatingPointType thePos[3],
vtkFloatingPointType& theDist )
void PositionToDistance( double theBounds[6],
double theDirection[3],
double thePos[3],
double& theDist )
{
vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
double aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
ComputeBoundsParam(theBounds,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
vtkFloatingPointType aPrj = vtkMath::Dot(theDirection,thePos);
double aPrj = vtkMath::Dot(theDirection,thePos);
theDist = (aPrj-aMinBoundPrj)/(aMaxBoundPrj-aMinBoundPrj);
}
bool ComputeClippingPlaneParameters( std::list<vtkActor*> theActorList,
vtkFloatingPointType theNormal[3],
vtkFloatingPointType theDist,
vtkFloatingPointType theBounds[6],
vtkFloatingPointType theOrigin[3] )
double theNormal[3],
double theDist,
double theBounds[6],
double theOrigin[3] )
{
bool anIsOk = false;
theBounds[0] = theBounds[2] = theBounds[4] = VTK_DOUBLE_MAX;
@ -1404,7 +1404,7 @@ namespace SMESH
for( ; anIter != theActorList.end(); anIter++ ) {
if( vtkActor* aVTKActor = *anIter ) {
if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) ) {
vtkFloatingPointType aBounds[6];
double aBounds[6];
anActor->GetUnstructuredGrid()->GetBounds( aBounds );
theBounds[0] = std::min( theBounds[0], aBounds[0] );
theBounds[1] = std::max( theBounds[1], aBounds[1] );

8
src/SMESHGUI/SMESHGUI_VTKUtils.h
View File

@ -202,10 +202,10 @@ SMESHGUI_EXPORT
//----------------------------------------------------------------------------
SMESHGUI_EXPORT
bool ComputeClippingPlaneParameters( std::list<vtkActor*> theActorList,
vtkFloatingPointType theNormal[3],
vtkFloatingPointType theDist,
vtkFloatingPointType theBounds[6],
vtkFloatingPointType theOrigin[3] );
double theNormal[3],
double theDist,
double theBounds[6],
double theOrigin[3] );
SMESHGUI_EXPORT
void RemoveVisualObjectWithActors( const char* theEntry, bool fromAllViews = false );
};