Porting to VTK 6.

Compilation with ParaView built without option "-DVTK_LEGACY_REMOVE:BOOL=OFF".

diff --git a/src/OBJECT/SMESH_Actor.cxx b/src/OBJECT/SMESH_Actor.cxx
index 8533a7a2a9b67d2afbd2d7d76ed1f69bd8fee281..5b4d9b3758fa3f0609ee28d8079800dc8ac4f1f1 100644 (file)
--- a/src/OBJECT/SMESH_Actor.cxx
+++ b/src/OBJECT/SMESH_Actor.cxx
@@ -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 );

diff --git a/src/OBJECT/SMESH_Actor.h b/src/OBJECT/SMESH_Actor.h
index bbd7ac9655e5ea7d49f94fb8750222722cfc3401..18fcdcb446d438e9090d8ac70ace36c134e1c56c 100644 (file)
--- a/src/OBJECT/SMESH_Actor.h
+++ b/src/OBJECT/SMESH_Actor.h
@@ -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;

diff --git a/src/OBJECT/SMESH_ActorDef.h b/src/OBJECT/SMESH_ActorDef.h
index 47dc703a0ff8bbc74c322385fb7259031d17aa85..ee715548c2e45f036177d2004deba8bc6c219044 100644 (file)
--- a/src/OBJECT/SMESH_ActorDef.h
+++ b/src/OBJECT/SMESH_ActorDef.h
@@ -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();

diff --git a/src/OBJECT/SMESH_ActorUtils.cxx b/src/OBJECT/SMESH_ActorUtils.cxx
index f1432159e6b5c1ac765e46555bbba827e9704724..9ce8b05672ae932002c0182a3d2da8b77a264c17 100644 (file)
--- a/src/OBJECT/SMESH_ActorUtils.cxx
+++ b/src/OBJECT/SMESH_ActorUtils.cxx
@@ -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 );

diff --git a/src/OBJECT/SMESH_ActorUtils.h b/src/OBJECT/SMESH_ActorUtils.h
index ce189fbe8dcb88a6304e514733ced33702a8294d..9a6200906f35e60d75ca19b8aacefa132d4cbde2 100644 (file)
--- a/src/OBJECT/SMESH_ActorUtils.h
+++ b/src/OBJECT/SMESH_ActorUtils.h
@@ -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

diff --git a/src/OBJECT/SMESH_CellLabelActor.cxx b/src/OBJECT/SMESH_CellLabelActor.cxx
index 35a87e6413737f7b1caa4291274f5af58147a300..9b076d54d077984ee6f97c3908da8b27598d0b7c 100644 (file)
--- a/src/OBJECT/SMESH_CellLabelActor.cxx
+++ b/src/OBJECT/SMESH_CellLabelActor.cxx
@@ -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:

diff --git a/src/OBJECT/SMESH_CellLabelActor.h b/src/OBJECT/SMESH_CellLabelActor.h
index f9a6a239de7abac3cee52e960b7bb44c4e5c2861..83b8b6386b3baffc004698712922fd054f3c8bb3 100644 (file)
--- a/src/OBJECT/SMESH_CellLabelActor.h
+++ b/src/OBJECT/SMESH_CellLabelActor.h
@@ -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();
   

diff --git a/src/OBJECT/SMESH_DeviceActor.cxx b/src/OBJECT/SMESH_DeviceActor.cxx
index a9aec176f64544f65492cf1c9e78d9d28d5093b8..e04be9967a4cd699271e3130e247331a4a25e0d0 100644 (file)
--- a/src/OBJECT/SMESH_DeviceActor.cxx
+++ b/src/OBJECT/SMESH_DeviceActor.cxx
@@ -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();
 }
 

diff --git a/src/OBJECT/SMESH_DeviceActor.h b/src/OBJECT/SMESH_DeviceActor.h
index 554af35d9462d64691e611ec5de367a04f561bea..40bfced14ee940d7b7cb87dfd060128f26bcb25e 100644 (file)
--- a/src/OBJECT/SMESH_DeviceActor.h
+++ b/src/OBJECT/SMESH_DeviceActor.h
@@ -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;

diff --git a/src/OBJECT/SMESH_ExtractGeometry.cxx b/src/OBJECT/SMESH_ExtractGeometry.cxx
index aad9a64474a7110208f147593c3105f36eea43ae..70c226c9cb04485974651cf0b0385dd8b54a5423 100644 (file)
--- a/src/OBJECT/SMESH_ExtractGeometry.cxx
+++ b/src/OBJECT/SMESH_ExtractGeometry.cxx
@@ -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);
 

diff --git a/src/OBJECT/SMESH_FaceOrientationFilter.cxx b/src/OBJECT/SMESH_FaceOrientationFilter.cxx
index f0abd890a6196e4d3d9f74e6aef5565a67656499..46a646912f6e94c10495d8ca831e7c323fb67b4d 100644 (file)
--- a/src/OBJECT/SMESH_FaceOrientationFilter.cxx
+++ b/src/OBJECT/SMESH_FaceOrientationFilter.cxx
@@ -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();

diff --git a/src/OBJECT/SMESH_FaceOrientationFilter.h b/src/OBJECT/SMESH_FaceOrientationFilter.h
index dcd4c33d596cfa6e09bc2f08883c8f2f5aa99672..aed9866ae39f0300d5bd4fd4656136f8b93e7c1b 100644 (file)
--- a/src/OBJECT/SMESH_FaceOrientationFilter.h
+++ b/src/OBJECT/SMESH_FaceOrientationFilter.h
@@ -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;

diff --git a/src/OBJECT/SMESH_NodeLabelActor.cxx b/src/OBJECT/SMESH_NodeLabelActor.cxx
index 40f61a0f4a6709e1f6bc04b0174a2458154134ca..039456b0108aad0d87367f112e5c20b3999276a7 100644 (file)
--- a/src/OBJECT/SMESH_NodeLabelActor.cxx
+++ b/src/OBJECT/SMESH_NodeLabelActor.cxx
@@ -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:

diff --git a/src/OBJECT/SMESH_NodeLabelActor.h b/src/OBJECT/SMESH_NodeLabelActor.h
index 03de78f3ad7117b9ad09ab821dd80ff042a091e0..601abb0e7c4d9f1253aec8ae628af6ae784637b2 100644 (file)
--- a/src/OBJECT/SMESH_NodeLabelActor.h
+++ b/src/OBJECT/SMESH_NodeLabelActor.h
@@ -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();
   

diff --git a/src/SMESHGUI/SMESHGUI.cxx b/src/SMESHGUI/SMESHGUI.cxx
index b509f6ac1a62c6782602a4d9519038adc8d874cf..c7e63cbe0a1d6aed66959934162a65a8b27b1267 100644 (file)
--- a/src/SMESHGUI/SMESHGUI.cxx
+++ b/src/SMESHGUI/SMESHGUI.cxx
@@ -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();
 

diff --git a/src/SMESHGUI/SMESHGUI.h b/src/SMESHGUI/SMESHGUI.h
index f45cfbfb531c468cef2c3369a534abdeee1eb126..bd4b1706a3bb1b579cbc74ae9996fc00524e7985 100644 (file)
--- a/src/SMESHGUI/SMESHGUI.h
+++ b/src/SMESHGUI/SMESHGUI.h
@@ -221,7 +221,7 @@ private :
   SMESHGUI_ClippingPlaneInfoMap   myClippingPlaneInfoMap;
 
   vtkSmartPointer<vtkCallbackCommand> myEventCallbackCommand;
-  vtkFloatingPointType            myPriority;
+  double            myPriority;
 };
 
 #endif // SMESHGUI_H

diff --git a/src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx b/src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
index 0f5ddb3062d3feb1381f880441339299a135d644..a66da49b5e1c969108371607c4677991ddd347a0 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
+++ b/src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
@@ -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] );

diff --git a/src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx b/src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
index 75ce1e599c735cb43c2380d328fb09c1c4e5b045..538524cb4afb20367f81befc184b68d240145802 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
+++ b/src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
@@ -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 );

diff --git a/src/SMESHGUI/SMESHGUI_ClippingDlg.cxx b/src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
index 6b846cea45ecec43ef54d7c2b4d5c9917b639008..20a05e471bf2231b99fb108307dc29cf523594a0 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
+++ b/src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
@@ -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] );

diff --git a/src/SMESHGUI/SMESHGUI_ClippingDlg.h b/src/SMESHGUI/SMESHGUI_ClippingDlg.h
index e8cb095f89fa7f8293ed2a402ad851333e15f2bf..6d495cba58efd56abbd55ff9e439877022ee4787 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_ClippingDlg.h
+++ b/src/SMESHGUI/SMESHGUI_ClippingDlg.h
@@ -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* );

diff --git a/src/SMESHGUI/SMESHGUI_ComputeDlg.cxx b/src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
index 1d5555e7eb71f13c1274e12da6315e3efa7c1252..c0c296010c16c881b3f85b13eb439509fce5bf4d 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
+++ b/src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
@@ -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 );

diff --git a/src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx b/src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
index eac1ae86cf4903fd1670db4b1109c56fbca87ca4..ff21b39e687efc1973b5af2b122e12e81e875ed4 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
+++ b/src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
@@ -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 );

diff --git a/src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx b/src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
index 5bc16f58e5e107f8f8487e59fb4a7ab678391941..ec50612b431b033b856963eaa8e2e093d19d709c 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
+++ b/src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
@@ -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);

diff --git a/src/SMESHGUI/SMESHGUI_MeshEditPreview.cxx b/src/SMESHGUI/SMESHGUI_MeshEditPreview.cxx
index fdf0868ae3fb06b820f73dea6f2300f19f476a88..25cae2f0da93e38a5cc5340a2cb15538c7785c63 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_MeshEditPreview.cxx
+++ b/src/SMESHGUI/SMESHGUI_MeshEditPreview.cxx
@@ -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] );
 

diff --git a/src/SMESHGUI/SMESHGUI_NodesDlg.cxx b/src/SMESHGUI/SMESHGUI_NodesDlg.cxx
index af34e8de440e102de3db30ca3764adb0d1655394..d80e2bcdc27316467b7e7e866925b3a3f0cf0a35 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_NodesDlg.cxx
+++ b/src/SMESHGUI/SMESHGUI_NodesDlg.cxx
@@ -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 );

diff --git a/src/SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.cxx b/src/SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.cxx
index 7f0a861ae9f1f1e9bfdeba20d8d2d196c889c04d..ba878f6b2993fe977d4f14d0b5f1915d8aeb1817 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.cxx
+++ b/src/SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.cxx
@@ -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() );

diff --git a/src/SMESHGUI/SMESHGUI_VTKUtils.cxx b/src/SMESHGUI/SMESHGUI_VTKUtils.cxx
index 229d7f809518fb67cbb493a59ff6cddc8be115f5..1bd966e379715c7a5661d8c764816e1c6d76be0b 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_VTKUtils.cxx
+++ b/src/SMESHGUI/SMESHGUI_VTKUtils.cxx
@@ -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] );

diff --git a/src/SMESHGUI/SMESHGUI_VTKUtils.h b/src/SMESHGUI/SMESHGUI_VTKUtils.h
index b226f7767263878de40db1ebad4ba33837ee60ad..e571f30bb2aedff2f215cf6b0f879264ef851647 100644 (file)
--- a/src/SMESHGUI/SMESHGUI_VTKUtils.h
+++ b/src/SMESHGUI/SMESHGUI_VTKUtils.h
@@ -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 );
 };