ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-30 19: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 ) ) if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1); myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1);
vtkFloatingPointType aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5); double aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
vtkFloatingPointType aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10); double aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10);
vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1); double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
vtkFloatingPointType aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1); double aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1);
SMESH::LabelFont aFamilyNd = SMESH::FntTimes; SMESH::LabelFont aFamilyNd = SMESH::FntTimes;
bool aBoldNd = true; bool aBoldNd = true;
@ -167,7 +167,7 @@ SMESH_ActorDef::SMESH_ActorDef()
aShadowNd = f.overline(); aShadowNd = f.overline();
aSizeNd = f.pointSize(); 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::GetColor( "SMESH", "numbering_node_color", anRGBNd[0], anRGBNd[1], anRGBNd[2], QColor( 255, 255, 255 ) );
SMESH::LabelFont aFamilyEl = SMESH::FntTimes; SMESH::LabelFont aFamilyEl = SMESH::FntTimes;
@ -185,7 +185,7 @@ SMESH_ActorDef::SMESH_ActorDef()
aShadowEl = f.overline(); aShadowEl = f.overline();
aSizeEl = f.pointSize(); 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 ) ); SMESH::GetColor( "SMESH", "numbering_elem_color", anRGBEl[0], anRGBEl[1], anRGBEl[2], QColor( 0, 255, 0 ) );
vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New(); vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
@ -193,7 +193,7 @@ SMESH_ActorDef::SMESH_ActorDef()
//Definition 2D and 3D devices of the actor //Definition 2D and 3D devices of the actor
//----------------------------------------- //-----------------------------------------
vtkFloatingPointType anRGB[3] = {1,1,1}; double anRGB[3] = {1,1,1};
mySurfaceProp = vtkProperty::New(); mySurfaceProp = vtkProperty::New();
QColor ffc, bfc; QColor ffc, bfc;
int delta; int delta;
@ -666,7 +666,7 @@ void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled )
void SMESH_ActorDef::SetPointsFontProperties( SMESH::LabelFont theFamily, int theSize, void SMESH_ActorDef::SetPointsFontProperties( SMESH::LabelFont theFamily, int theSize,
bool theBold, bool theItalic, bool theShadow, bool theBold, bool theItalic, bool theShadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) double r, double g, double b )
{ {
if(myNodeActor) { if(myNodeActor) {
myNodeActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b ); 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, void SMESH_ActorDef::SetCellsFontProperties( SMESH::LabelFont theFamily, int theSize,
bool theBold, bool theItalic, bool theShadow, bool theBold, bool theItalic, bool theShadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) double r, double g, double b )
{ {
if(my3DActor) { if(my3DActor) {
my3DActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b ); my3DActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b );
@ -767,24 +767,24 @@ bool SMESH_ActorDef::GetFacesOriented()
return myIsFacesOriented; 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 ); my2DActor->SetFacesOrientationColor( r, g, b );
my3DActor->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 ); my3DActor->GetFacesOrientationColor( r, g, b );
} }
void SMESH_ActorDef::SetFacesOrientationScale(vtkFloatingPointType theScale) void SMESH_ActorDef::SetFacesOrientationScale(double theScale)
{ {
my2DActor->SetFacesOrientationScale( theScale ); my2DActor->SetFacesOrientationScale( theScale );
my3DActor->SetFacesOrientationScale( theScale ); my3DActor->SetFacesOrientationScale( theScale );
} }
vtkFloatingPointType SMESH_ActorDef::GetFacesOrientationScale() double SMESH_ActorDef::GetFacesOrientationScale()
{ {
return my3DActor->GetFacesOrientationScale(); return my3DActor->GetFacesOrientationScale();
} }
@ -1180,7 +1180,7 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
my3DActor->GetMapper()->SetLookupTable(myLookupTable); my3DActor->GetMapper()->SetLookupTable(myLookupTable);
my3DExtActor->GetMapper()->SetLookupTable(myLookupTable); my3DExtActor->GetMapper()->SetLookupTable(myLookupTable);
vtkFloatingPointType aFactor, aUnits; double aFactor, aUnits;
my2DActor->GetPolygonOffsetParameters(aFactor,aUnits); my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75); my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
my2DExtActor->SetPolygonOffsetParameters(aFactor,aUnits*0.5); 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(); return myNodeActor->GetBounds();
} }
@ -1296,11 +1296,11 @@ void SMESH_ActorDef::SetIsShrunkable(bool theShrunkable){
Modified(); Modified();
} }
vtkFloatingPointType SMESH_ActorDef::GetShrinkFactor(){ double SMESH_ActorDef::GetShrinkFactor(){
return myBaseActor->GetShrinkFactor(); return myBaseActor->GetShrinkFactor();
} }
void SMESH_ActorDef::SetShrinkFactor(vtkFloatingPointType theValue){ void SMESH_ActorDef::SetShrinkFactor(double theValue){
myBaseActor->SetShrinkFactor(theValue); myBaseActor->SetShrinkFactor(theValue);
my1DActor->SetShrinkFactor(theValue); my1DActor->SetShrinkFactor(theValue);
@ -1357,7 +1357,7 @@ int SMESH_ActorDef::GetNodeObjId(int theVtkID){
return myPickableActor->GetNodeObjId(theVtkID); return myPickableActor->GetNodeObjId(theVtkID);
} }
vtkFloatingPointType* SMESH_ActorDef::GetNodeCoord(int theObjID){ double* SMESH_ActorDef::GetNodeCoord(int theObjID){
return myPickableActor->GetNodeCoord(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){ static void GetColor(vtkProperty *theProperty, double& r,double& g,double& b){
vtkFloatingPointType* aColor = theProperty->GetColor(); double* aColor = theProperty->GetColor();
r = aColor[0]; r = aColor[0];
g = aColor[1]; g = aColor[1];
b = aColor[2]; b = aColor[2];
} }
void SMESH_ActorDef::SetOpacity(vtkFloatingPointType theValue){ void SMESH_ActorDef::SetOpacity(double theValue){
mySurfaceProp->SetOpacity(theValue); mySurfaceProp->SetOpacity(theValue);
myBackSurfaceProp->SetOpacity(theValue); myBackSurfaceProp->SetOpacity(theValue);
myNormalVProp->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(); 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); mySurfaceProp->SetColor(r,g,b);
my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b); my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) ) if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
@ -1947,12 +1947,12 @@ void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType
Modified(); 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); ::GetColor(mySurfaceProp,r,g,b);
delta = myDeltaBrightness; 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); myNormalVProp->SetColor(r,g,b);
my3DExtProp->SetColor(1.0-r,1.0-g,1.0-b); my3DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) ) if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
@ -1965,12 +1965,12 @@ void SMESH_ActorDef::SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType
Modified(); 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); ::GetColor(myNormalVProp,r,g,b);
delta = myDeltaVBrightness; 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); myEdgeProp->SetColor(r,g,b);
my1DProp->SetColor(r,g,b); my1DProp->SetColor(r,g,b);
my1DExtProp->SetColor(1.0-r,1.0-g,1.0-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(); 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); ::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); myOutLineProp->SetColor(r,g,b);
Modified(); 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); ::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); myNodeProp->SetColor(r,g,b);
myNodeExtProp->SetColor(1.0-r,1.0-g,1.0-b); myNodeExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) ) if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
@ -2003,11 +2003,11 @@ void SMESH_ActorDef::SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,
Modified(); 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); ::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); my0DProp->SetColor(r,g,b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) ) if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_0DElement ) if( aGroupObj->GetElementType() == SMDSAbs_0DElement )
@ -2015,11 +2015,11 @@ void SMESH_ActorDef::Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vt
Modified(); 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); ::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); myBallProp->SetColor(r,g,b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) ) if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_Ball ) if( aGroupObj->GetElementType() == SMDSAbs_Ball )
@ -2027,37 +2027,37 @@ void SMESH_ActorDef::SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,
Modified(); 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); ::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); myHighlightProp->SetColor(r,g,b);
myBallHighlightProp->SetColor(r,g,b); myBallHighlightProp->SetColor(r,g,b);
Modified(); 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); ::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); myPreselectProp->SetColor(r,g,b);
myBallPreselectProp->SetColor(r,g,b); myBallPreselectProp->SetColor(r,g,b);
Modified(); 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); ::GetColor(myPreselectProp,r,g,b);
} }
vtkFloatingPointType SMESH_ActorDef::GetLineWidth(){ double SMESH_ActorDef::GetLineWidth(){
return myEdgeProp->GetLineWidth(); return myEdgeProp->GetLineWidth();
} }
void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){ void SMESH_ActorDef::SetLineWidth(double theVal){
myEdgeProp->SetLineWidth(theVal); myEdgeProp->SetLineWidth(theVal);
my1DProp->SetLineWidth(theVal + aLineWidthInc); my1DProp->SetLineWidth(theVal + aLineWidthInc);
@ -2070,18 +2070,18 @@ void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){
Modified(); Modified();
} }
vtkFloatingPointType SMESH_ActorDef::GetOutlineWidth() double SMESH_ActorDef::GetOutlineWidth()
{ {
return myOutLineProp->GetLineWidth(); return myOutLineProp->GetLineWidth();
} }
void SMESH_ActorDef::SetOutlineWidth(vtkFloatingPointType theVal) void SMESH_ActorDef::SetOutlineWidth(double theVal)
{ {
myOutLineProp->SetLineWidth(theVal); myOutLineProp->SetLineWidth(theVal);
Modified(); Modified();
} }
void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){ void SMESH_ActorDef::Set0DSize(double theVal){
my0DProp->SetPointSize(theVal); my0DProp->SetPointSize(theVal);
myHighlightProp->SetPointSize(theVal); myHighlightProp->SetPointSize(theVal);
myPreselectProp->SetPointSize(theVal); myPreselectProp->SetPointSize(theVal);
@ -2096,11 +2096,11 @@ void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){
Modified(); Modified();
} }
vtkFloatingPointType SMESH_ActorDef::Get0DSize(){ double SMESH_ActorDef::Get0DSize(){
return my0DProp->GetPointSize(); return my0DProp->GetPointSize();
} }
void SMESH_ActorDef::SetBallSize(vtkFloatingPointType theVal){ void SMESH_ActorDef::SetBallSize(double theVal){
myBallProp->SetPointSize(theVal); myBallProp->SetPointSize(theVal);
myBallHighlightProp->SetPointSize(theVal); myBallHighlightProp->SetPointSize(theVal);
myBallPreselectProp->SetPointSize(theVal); myBallPreselectProp->SetPointSize(theVal);
@ -2114,7 +2114,7 @@ void SMESH_ActorDef::SetBallSize(vtkFloatingPointType theVal){
Modified(); Modified();
} }
vtkFloatingPointType SMESH_ActorDef::GetBallSize(){ double SMESH_ActorDef::GetBallSize(){
return myBallProp->GetPointSize(); return myBallProp->GetPointSize();
} }
@ -2278,21 +2278,21 @@ void SMESH_ActorDef::UpdateScalarBar()
myScalarBarActor->SetOrientationToVertical(); myScalarBarActor->SetOrientationToVertical();
vtkFloatingPointType aXVal = horiz ? 0.20 : 0.01; double aXVal = horiz ? 0.20 : 0.01;
if( mgr->hasValue( "SMESH", name + "x" ) ) if( mgr->hasValue( "SMESH", name + "x" ) )
aXVal = mgr->doubleValue( "SMESH", name + "x", aXVal ); 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" ) ) if( mgr->hasValue( "SMESH", name + "y" ) )
aYVal = mgr->doubleValue( "SMESH", name + "y", aYVal ); aYVal = mgr->doubleValue( "SMESH", name + "y", aYVal );
myScalarBarActor->SetPosition( aXVal, 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" ) ) if( mgr->hasValue( "SMESH", name + "width" ) )
aWVal = mgr->doubleValue( "SMESH", name + "width", aWVal ); aWVal = mgr->doubleValue( "SMESH", name + "width", aWVal );
myScalarBarActor->SetWidth( aWVal ); myScalarBarActor->SetWidth( aWVal );
vtkFloatingPointType aHVal = horiz ? 0.12 : 0.80; double aHVal = horiz ? 0.12 : 0.80;
if( mgr->hasValue( "SMESH", name + "height" ) ) if( mgr->hasValue( "SMESH", name + "height" ) )
aHVal = mgr->doubleValue( "SMESH", name + "height", aHVal ); aHVal = mgr->doubleValue( "SMESH", name + "height", aHVal );
myScalarBarActor->SetHeight( 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, const char* theName,
int theIsClear); int theIsClear);
virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta ) = 0; virtual void SetSufaceColor(double r,double g,double b, int delta ) = 0;
virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& 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 SetVolumeColor(double r,double g,double b, int delta ) = 0;
virtual void GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& 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 SetEdgeColor(double r,double g,double b) = 0;
virtual void GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetEdgeColor(double& r,double& g,double& b) = 0;
virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetNodeColor(double r,double g,double b) = 0;
virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetNodeColor(double& r,double& g,double& b) = 0;
virtual void SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetOutlineColor(double r,double g,double b) = 0;
virtual void GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetOutlineColor(double& r,double& g,double& b) = 0;
virtual void Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void Set0DColor(double r,double g,double b) = 0;
virtual void Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void Get0DColor(double& r,double& g,double& b) = 0;
virtual void SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetBallColor(double r,double g,double b) = 0;
virtual void GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetBallColor(double& r,double& g,double& b) = 0;
virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetHighlightColor(double r,double g,double b) = 0;
virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetHighlightColor(double& r,double& g,double& b) = 0;
virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetPreHighlightColor(double r,double g,double b) = 0;
virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetPreHighlightColor(double& r,double& g,double& b) = 0;
virtual vtkFloatingPointType GetLineWidth() = 0; virtual double GetLineWidth() = 0;
virtual void SetLineWidth(vtkFloatingPointType theVal) = 0; virtual void SetLineWidth(double theVal) = 0;
virtual vtkFloatingPointType GetOutlineWidth() = 0; virtual double GetOutlineWidth() = 0;
virtual void SetOutlineWidth(vtkFloatingPointType theVal) = 0; virtual void SetOutlineWidth(double theVal) = 0;
virtual void Set0DSize(vtkFloatingPointType size) = 0; virtual void Set0DSize(double size) = 0;
virtual vtkFloatingPointType Get0DSize() = 0; virtual double Get0DSize() = 0;
virtual void SetBallSize(vtkFloatingPointType size) = 0; virtual void SetBallSize(double size) = 0;
virtual vtkFloatingPointType GetBallSize() = 0; virtual double GetBallSize() = 0;
enum EReperesent { ePoint, eEdge, eSurface}; enum EReperesent { ePoint, eEdge, eSurface};
@ -118,7 +118,7 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0; virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0;
virtual void SetShrinkFactor(vtkFloatingPointType theValue) = 0; virtual void SetShrinkFactor(double theValue) = 0;
virtual void SetPointsLabeled(bool theIsPointsLabeled) = 0; virtual void SetPointsLabeled(bool theIsPointsLabeled) = 0;
virtual bool GetPointsLabeled() = 0; virtual bool GetPointsLabeled() = 0;
@ -129,11 +129,11 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
virtual void SetFacesOriented(bool theIsFacesOriented) = 0; virtual void SetFacesOriented(bool theIsFacesOriented) = 0;
virtual bool GetFacesOriented() = 0; virtual bool GetFacesOriented() = 0;
virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetFacesOrientationColor(double r,double g,double b) = 0;
virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetFacesOrientationColor(double& r,double& g,double& b) = 0;
virtual void SetFacesOrientationScale(vtkFloatingPointType theScale) = 0; virtual void SetFacesOrientationScale(double theScale) = 0;
virtual vtkFloatingPointType GetFacesOrientationScale() = 0; virtual double GetFacesOrientationScale() = 0;
virtual void SetFacesOrientation3DVectors(bool theState) = 0; virtual void SetFacesOrientation3DVectors(bool theState) = 0;
virtual bool GetFacesOrientation3DVectors() = 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, virtual void SetPointsFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, 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, virtual void SetCellsFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) = 0; double r, double g, double b ) = 0;
#ifndef DISABLE_PLOT2DVIEWER #ifndef DISABLE_PLOT2DVIEWER
virtual SPlot2d_Histogram* GetPlot2Histogram() = 0; 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 bool IsInfinitive();
virtual void SetOpacity(vtkFloatingPointType theValue); virtual void SetOpacity(double theValue);
virtual vtkFloatingPointType GetOpacity(); virtual double GetOpacity();
virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta ); virtual void SetSufaceColor(double r,double g,double b, int delta );
virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& 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 SetVolumeColor(double r,double g,double b, int delta );
virtual void GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& 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 SetEdgeColor(double r,double g,double b);
virtual void GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetEdgeColor(double& r,double& g,double& b);
virtual void SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetOutlineColor(double r,double g,double b);
virtual void GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetOutlineColor(double& r,double& g,double& b);
virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetNodeColor(double r,double g,double b);
virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetNodeColor(double& r,double& g,double& b);
virtual void Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void Set0DColor(double r,double g,double b);
virtual void Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void Get0DColor(double& r,double& g,double& b);
virtual void SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetBallColor(double r,double g,double b);
virtual void GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetBallColor(double& r,double& g,double& b);
virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetHighlightColor(double r,double g,double b);
virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetHighlightColor(double& r,double& g,double& b);
virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetPreHighlightColor(double r,double g,double b);
virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetPreHighlightColor(double& r,double& g,double& b);
virtual vtkFloatingPointType GetLineWidth(); virtual double GetLineWidth();
virtual void SetLineWidth(vtkFloatingPointType theVal); virtual void SetLineWidth(double theVal);
virtual vtkFloatingPointType GetOutlineWidth(); virtual double GetOutlineWidth();
virtual void SetOutlineWidth(vtkFloatingPointType theVal); virtual void SetOutlineWidth(double theVal);
virtual void Set0DSize(vtkFloatingPointType size); virtual void Set0DSize(double size);
virtual vtkFloatingPointType Get0DSize(); virtual double Get0DSize();
virtual void SetBallSize(vtkFloatingPointType size); virtual void SetBallSize(double size);
virtual vtkFloatingPointType GetBallSize(); virtual double GetBallSize();
virtual int GetNodeObjId(int theVtkID); virtual int GetNodeObjId(int theVtkID);
virtual vtkFloatingPointType* GetNodeCoord(int theObjID); virtual double* GetNodeCoord(int theObjID);
virtual int GetElemObjId(int theVtkID); virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID); virtual vtkCell* GetElemCell(int theObjID);
@ -162,15 +162,15 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetPointRepresentation(bool theIsPointsVisible); virtual void SetPointRepresentation(bool theIsPointsVisible);
virtual bool GetPointRepresentation(); virtual bool GetPointRepresentation();
virtual vtkFloatingPointType* GetBounds(); virtual double* GetBounds();
virtual void SetTransform(VTKViewer_Transform* theTransform); virtual void SetTransform(VTKViewer_Transform* theTransform);
virtual vtkUnstructuredGrid* GetUnstructuredGrid(); virtual vtkUnstructuredGrid* GetUnstructuredGrid();
virtual vtkDataSet* GetInput(); virtual vtkDataSet* GetInput();
virtual vtkMapper* GetMapper(); virtual vtkMapper* GetMapper();
virtual vtkFloatingPointType GetShrinkFactor(); virtual double GetShrinkFactor();
virtual void SetShrinkFactor(vtkFloatingPointType theValue); virtual void SetShrinkFactor(double theValue);
virtual bool IsShrunkable() { return myIsShrinkable;} virtual bool IsShrunkable() { return myIsShrinkable;}
virtual bool IsShrunk() { return myIsShrunk;} virtual bool IsShrunk() { return myIsShrunk;}
@ -182,10 +182,10 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetPointsFontProperties( SMESH::LabelFont family, int size, virtual void SetPointsFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, 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, virtual void SetCellsFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ); double r, double g, double b );
virtual void SetCellsLabeled(bool theIsCellsLabeled); virtual void SetCellsLabeled(bool theIsCellsLabeled);
virtual bool GetCellsLabeled(); virtual bool GetCellsLabeled();
@ -193,11 +193,11 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetFacesOriented(bool theIsFacesOriented); virtual void SetFacesOriented(bool theIsFacesOriented);
virtual bool GetFacesOriented(); virtual bool GetFacesOriented();
virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetFacesOrientationColor(double r,double g,double b);
virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetFacesOrientationColor(double& r,double& g,double& b);
virtual void SetFacesOrientationScale(vtkFloatingPointType theScale); virtual void SetFacesOrientationScale(double theScale);
virtual vtkFloatingPointType GetFacesOrientationScale(); virtual double GetFacesOrientationScale();
virtual void SetFacesOrientation3DVectors(bool theState); virtual void SetFacesOrientation3DVectors(bool theState);
virtual bool GetFacesOrientation3DVectors(); virtual bool GetFacesOrientation3DVectors();

20
src/OBJECT/SMESH_ActorUtils.cxx
View File

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

14
src/OBJECT/SMESH_ActorUtils.h
View File

@ -41,15 +41,15 @@ namespace SMESH
}; };
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT
vtkFloatingPointType double
GetFloat( const QString& theValue, GetFloat( const QString& theValue,
vtkFloatingPointType theDefault = 0 ); double theDefault = 0 );
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT
vtkFloatingPointType double
GetFloat( const QString& theName, GetFloat( const QString& theName,
const QString& theSection, const QString& theSection,
vtkFloatingPointType theDefault = 0 ); double theDefault = 0 );
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT
QColor QColor
@ -70,9 +70,9 @@ SMESHOBJECT_EXPORT
void void
GetColor( const QString& theSect, GetColor( const QString& theSect,
const QString& theName, const QString& theName,
vtkFloatingPointType&, double&,
vtkFloatingPointType&, double&,
vtkFloatingPointType&, double&,
const QColor& = QColor() ); const QColor& = QColor() );
SMESHOBJECT_EXPORT 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, void SMESH_CellLabelActor::SetFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) double r, double g, double b )
{ {
switch ( family ) { switch ( family ) {
case SMESH::FntArial: case SMESH::FntArial:

2
src/OBJECT/SMESH_CellLabelActor.h
View File

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

32
src/OBJECT/SMESH_DeviceActor.cxx
View File

@ -119,7 +119,7 @@ SMESH_DeviceActor
// Orientation of faces // Orientation of faces
myIsFacesOriented = false; 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 ) ); SMESH::GetColor( "SMESH", "orientation_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 255, 255 ) );
myFaceOrientationFilter = SMESH_FaceOrientationFilter::New(); myFaceOrientationFilter = SMESH_FaceOrientationFilter::New();
@ -639,26 +639,26 @@ SMESH_DeviceActor
void void
SMESH_DeviceActor SMESH_DeviceActor
::SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) ::SetFacesOrientationColor(double r,double g,double b)
{ {
myFaceOrientation->GetProperty()->SetColor( r, g, b ); myFaceOrientation->GetProperty()->SetColor( r, g, b );
} }
void void
SMESH_DeviceActor SMESH_DeviceActor
::GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) ::GetFacesOrientationColor(double& r,double& g,double& b)
{ {
myFaceOrientation->GetProperty()->GetColor( r, g, b ); myFaceOrientation->GetProperty()->GetColor( r, g, b );
} }
void void
SMESH_DeviceActor SMESH_DeviceActor
::SetFacesOrientationScale(vtkFloatingPointType theScale) ::SetFacesOrientationScale(double theScale)
{ {
myFaceOrientationFilter->SetOrientationScale( theScale ); myFaceOrientationFilter->SetOrientationScale( theScale );
} }
vtkFloatingPointType double
SMESH_DeviceActor SMESH_DeviceActor
::GetFacesOrientationScale() ::GetFacesOrientationScale()
{ {
@ -781,13 +781,13 @@ SMESH_DeviceActor
return aRetID; return aRetID;
} }
vtkFloatingPointType* double*
SMESH_DeviceActor SMESH_DeviceActor
::GetNodeCoord(int theObjID) ::GetNodeCoord(int theObjID)
{ {
vtkDataSet* aDataSet = myMergeFilter->GetOutput(); vtkDataSet* aDataSet = myMergeFilter->GetOutput();
vtkIdType anID = myVisualObj->GetNodeVTKId(theObjID); 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); if(MYDEBUG) MESSAGE("GetNodeCoord - theObjID = "<<theObjID<<"; anID = "<<anID);
return aCoord; return aCoord;
} }
@ -830,7 +830,7 @@ SMESH_DeviceActor
} }
vtkFloatingPointType double
SMESH_DeviceActor SMESH_DeviceActor
::GetShrinkFactor() ::GetShrinkFactor()
{ {
@ -839,7 +839,7 @@ SMESH_DeviceActor
void void
SMESH_DeviceActor SMESH_DeviceActor
::SetShrinkFactor(vtkFloatingPointType theValue) ::SetShrinkFactor(double theValue)
{ {
theValue = theValue > 0.1? theValue: 0.8; theValue = theValue > 0.1? theValue: 0.8;
myShrinkFilter->SetShrinkFactor(theValue); myShrinkFilter->SetShrinkFactor(theValue);
@ -862,13 +862,13 @@ SMESH_DeviceActor
::Render(vtkRenderer *ren, vtkMapper* m) ::Render(vtkRenderer *ren, vtkMapper* m)
{ {
int aResolveCoincidentTopology = vtkMapper::GetResolveCoincidentTopology(); int aResolveCoincidentTopology = vtkMapper::GetResolveCoincidentTopology();
vtkFloatingPointType aStoredFactor, aStoredUnit; double aStoredFactor, aStoredUnit;
vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(aStoredFactor,aStoredUnit); vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(aStoredFactor,aStoredUnit);
vtkMapper::SetResolveCoincidentTopologyToPolygonOffset(); vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
vtkFloatingPointType aFactor = myPolygonOffsetFactor, aUnits = myPolygonOffsetUnits; double aFactor = myPolygonOffsetFactor, aUnits = myPolygonOffsetUnits;
if(myIsHighlited){ if(myIsHighlited){
static vtkFloatingPointType EPS = .01; static double EPS = .01;
aUnits *= (1.0-EPS); aUnits *= (1.0-EPS);
} }
vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnits); vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnits);
@ -881,8 +881,8 @@ SMESH_DeviceActor
void void
SMESH_DeviceActor SMESH_DeviceActor
::SetPolygonOffsetParameters(vtkFloatingPointType factor, ::SetPolygonOffsetParameters(double factor,
vtkFloatingPointType units) double units)
{ {
myPolygonOffsetFactor = factor; myPolygonOffsetFactor = factor;
myPolygonOffsetUnits = units; myPolygonOffsetUnits = units;
@ -904,14 +904,14 @@ bool SMESH_DeviceActor::GetQuadraticArcMode(){
/*! /*!
* Set Max angle for representation 2D quadratic element as arked polygon * 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); myGeomFilter->SetQuadraticArcAngle(theMaxAngle);
} }
/*! /*!
* Return Max angle of the representation 2D quadratic element as arked polygon * Return Max angle of the representation 2D quadratic element as arked polygon
*/ */
vtkFloatingPointType SMESH_DeviceActor::GetQuadraticArcAngle(){ double SMESH_DeviceActor::GetQuadraticArcAngle(){
return myGeomFilter->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); void SetStoreIDMapping(bool theStoreMapping);
virtual int GetNodeObjId(int theVtkID); virtual int GetNodeObjId(int theVtkID);
virtual vtkFloatingPointType* GetNodeCoord(int theObjID); virtual double* GetNodeCoord(int theObjID);
virtual int GetElemObjId(int theVtkID); virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID); virtual vtkCell* GetElemCell(int theObjID);
@ -79,11 +79,11 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
virtual void SetFacesOriented(bool theIsFacesOriented); virtual void SetFacesOriented(bool theIsFacesOriented);
virtual bool GetFacesOriented() { return myIsFacesOriented; } virtual bool GetFacesOriented() { return myIsFacesOriented; }
virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetFacesOrientationColor(double r,double g,double b);
virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetFacesOrientationColor(double& r,double& g,double& b);
virtual void SetFacesOrientationScale(vtkFloatingPointType theScale); virtual void SetFacesOrientationScale(double theScale);
virtual vtkFloatingPointType GetFacesOrientationScale(); virtual double GetFacesOrientationScale();
virtual void SetFacesOrientation3DVectors(bool theState); virtual void SetFacesOrientation3DVectors(bool theState);
virtual bool GetFacesOrientation3DVectors(); virtual bool GetFacesOrientation3DVectors();
@ -93,13 +93,13 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
virtual void SetQuadraticArcMode(bool theFlag); virtual void SetQuadraticArcMode(bool theFlag);
virtual bool GetQuadraticArcMode(); virtual bool GetQuadraticArcMode();
virtual void SetQuadraticArcAngle(vtkFloatingPointType theMaxAngle); virtual void SetQuadraticArcAngle(double theMaxAngle);
virtual vtkFloatingPointType GetQuadraticArcAngle(); virtual double GetQuadraticArcAngle();
void UpdateFaceOrientation(); void UpdateFaceOrientation();
vtkFloatingPointType GetShrinkFactor(); double GetShrinkFactor();
void SetShrinkFactor(vtkFloatingPointType value); void SetShrinkFactor(double value);
bool IsShrunkable() { return myIsShrinkable;} bool IsShrunkable() { return myIsShrinkable;}
bool IsShrunk() { return myIsShrunk;} bool IsShrunk() { return myIsShrunk;}
@ -182,16 +182,16 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
bool myIsHighlited; bool myIsHighlited;
vtkFloatingPointType myPolygonOffsetFactor; double myPolygonOffsetFactor;
vtkFloatingPointType myPolygonOffsetUnits; double myPolygonOffsetUnits;
void void
SetPolygonOffsetParameters(vtkFloatingPointType factor, SetPolygonOffsetParameters(double factor,
vtkFloatingPointType units); double units);
void void
GetPolygonOffsetParameters(vtkFloatingPointType& factor, GetPolygonOffsetParameters(double& factor,
vtkFloatingPointType& units) double& units)
{ {
factor = myPolygonOffsetFactor; factor = myPolygonOffsetFactor;
units = myPolygonOffsetUnits; units = myPolygonOffsetUnits;

6
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

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

3
src/OBJECT/SMESH_FaceOrientationFilter.cxx
View File

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

8
src/OBJECT/SMESH_FaceOrientationFilter.h
View File

@ -33,13 +33,13 @@ class VTKViewer_CellCenters;
class SMESHOBJECT_EXPORT SMESH_FaceOrientationFilter : public vtkPolyDataAlgorithm class SMESHOBJECT_EXPORT SMESH_FaceOrientationFilter : public vtkPolyDataAlgorithm
{ {
public: public:
vtkTypeRevisionMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm ); vtkTypeMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm );
/*!Create a new SMESH_FaceOrientationFilter.*/ /*!Create a new SMESH_FaceOrientationFilter.*/
static SMESH_FaceOrientationFilter *New(); static SMESH_FaceOrientationFilter *New();
void SetOrientationScale( vtkFloatingPointType ); void SetOrientationScale( double );
vtkFloatingPointType GetOrientationScale() const { return myOrientationScale; } double GetOrientationScale() const { return myOrientationScale; }
void Set3dVectors( bool ); void Set3dVectors( bool );
bool Get3dVectors() const { return my3dVectors; } bool Get3dVectors() const { return my3dVectors; }
@ -61,7 +61,7 @@ private:
private: private:
bool my3dVectors; bool my3dVectors;
vtkFloatingPointType myOrientationScale; double myOrientationScale;
vtkPolyData* myArrowPolyData; vtkPolyData* myArrowPolyData;
vtkPolyData* myFacePolyData; vtkPolyData* myFacePolyData;
VTKViewer_CellCenters* myFaceCenters; 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, void SMESH_NodeLabelActor::SetFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) double r, double g, double b )
{ {
switch ( family ) { switch ( family ) {
case SMESH::FntArial: case SMESH::FntArial:

2
src/OBJECT/SMESH_NodeLabelActor.h
View File

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

14
src/SMESHGUI/SMESHGUI.cxx
View File

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

2
src/SMESHGUI/SMESHGUI.h
View File

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

2
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
View File

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

4
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

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

74
src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
View File

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

4
src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
View File

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

4
src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
View File

@ -114,12 +114,12 @@ namespace SMESH
myPreviewActor->SetMapper( myMapper ); myPreviewActor->SetMapper( myMapper );
myPreviewActor->SetRepresentation( 3 ); myPreviewActor->SetRepresentation( 3 );
vtkFloatingPointType anRGB[3]; double anRGB[3];
vtkProperty* aProp = vtkProperty::New(); vtkProperty* aProp = vtkProperty::New();
GetColor( "SMESH", "selection_element_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); GetColor( "SMESH", "selection_element_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
myPreviewActor->SetProperty( aProp ); myPreviewActor->SetProperty( aProp );
vtkFloatingPointType aFactor,aUnits; double aFactor,aUnits;
myPreviewActor->SetResolveCoincidentTopology(true); myPreviewActor->SetResolveCoincidentTopology(true);
myPreviewActor->GetPolygonOffsetParameters(aFactor,aUnits); myPreviewActor->GetPolygonOffsetParameters(aFactor,aUnits);
myPreviewActor->SetPolygonOffsetParameters(aFactor,0.2*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->VisibilityOn();
myPreviewActor->PickableOff(); myPreviewActor->PickableOff();
vtkFloatingPointType aFactor,aUnits; double aFactor,aUnits;
myPreviewActor->SetResolveCoincidentTopology(true); myPreviewActor->SetResolveCoincidentTopology(true);
myPreviewActor->GetPolygonOffsetParameters(aFactor,aUnits); myPreviewActor->GetPolygonOffsetParameters(aFactor,aUnits);
myPreviewActor->SetPolygonOffsetParameters(aFactor,0.2*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 ) ); SMESH::GetColor( "SMESH", "selection_element_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
SetColor( anRGB[0], anRGB[1], anRGB[2] ); 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(); vtkProperty* aProp = vtkProperty::New();
aProp->SetRepresentationToPoints(); aProp->SetRepresentationToPoints();
vtkFloatingPointType anRGB[3]; double anRGB[3];
GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 0 ) ); GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 0 ) );
aProp->SetColor( anRGB[0], anRGB[1], anRGB[2] ); 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 ); aProp->SetPointSize( aPointSize );
myPreviewActor->SetProperty( aProp ); 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(); SMESH_ScalarBarActor* myScalarBarActor = myActor->GetScalarBarActor();
if ( myScalarBarActor->GetLookupTable() ) { if ( myScalarBarActor->GetLookupTable() ) {
vtkFloatingPointType *range = myScalarBarActor->GetLookupTable()->GetRange(); double *range = myScalarBarActor->GetLookupTable()->GetRange();
myMinEdit->setText( QString::number( range[0],'g',12 ) ); myMinEdit->setText( QString::number( range[0],'g',12 ) );
myMaxEdit->setText( QString::number( range[1],'g',12 ) ); myMaxEdit->setText( QString::number( range[1],'g',12 ) );
} }
vtkTextProperty* aTitleTextPrp = myScalarBarActor->GetTitleTextProperty(); vtkTextProperty* aTitleTextPrp = myScalarBarActor->GetTitleTextProperty();
vtkFloatingPointType aTColor[3]; double aTColor[3];
aTitleTextPrp->GetColor( aTColor ); aTitleTextPrp->GetColor( aTColor );
myTitleColorBtn->setColor( QColor( (int)( aTColor[0]*255 ), (int)( aTColor[1]*255 ), (int)( aTColor[2]*255 ) ) ); myTitleColorBtn->setColor( QColor( (int)( aTColor[0]*255 ), (int)( aTColor[1]*255 ), (int)( aTColor[2]*255 ) ) );
myTitleFontCombo->setCurrentIndex( aTitleTextPrp->GetFontFamily() ); myTitleFontCombo->setCurrentIndex( aTitleTextPrp->GetFontFamily() );
@ -654,7 +654,7 @@ void SMESHGUI_Preferences_ScalarBarDlg::onSelectionChanged()
myTitleShadowCheck->setChecked( aTitleTextPrp->GetShadow() ); myTitleShadowCheck->setChecked( aTitleTextPrp->GetShadow() );
vtkTextProperty* aLabelsTextPrp = myScalarBarActor->GetLabelTextProperty(); vtkTextProperty* aLabelsTextPrp = myScalarBarActor->GetLabelTextProperty();
vtkFloatingPointType aLColor[3]; double aLColor[3];
aLabelsTextPrp->GetColor( aLColor ); aLabelsTextPrp->GetColor( aLColor );
myLabelsColorBtn->setColor( QColor( (int)( aLColor[0]*255 ), (int)( aLColor[1]*255 ), (int)( aLColor[2]*255 ) ) ); myLabelsColorBtn->setColor( QColor( (int)( aLColor[0]*255 ), (int)( aLColor[1]*255 ), (int)( aLColor[2]*255 ) ) );
myLabelsFontCombo->setCurrentIndex( aLabelsTextPrp->GetFontFamily() ); myLabelsFontCombo->setCurrentIndex( aLabelsTextPrp->GetFontFamily() );

56
src/SMESHGUI/SMESHGUI_VTKUtils.cxx
View File

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

8
src/SMESHGUI/SMESHGUI_VTKUtils.h
View File

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