Salome HOME
Merge from BR_PORTING_VTK6 01/03/2013 V7_1_0b1
authorvsr <vsr@opencascade.com>
Fri, 1 Mar 2013 13:13:25 +0000 (13:13 +0000)
committervsr <vsr@opencascade.com>
Fri, 1 Mar 2013 13:13:25 +0000 (13:13 +0000)
35 files changed:
src/OBJECT/SMESH_Actor.cxx
src/OBJECT/SMESH_Actor.h
src/OBJECT/SMESH_ActorDef.h
src/OBJECT/SMESH_ActorUtils.cxx
src/OBJECT/SMESH_ActorUtils.h
src/OBJECT/SMESH_CellLabelActor.cxx
src/OBJECT/SMESH_CellLabelActor.h
src/OBJECT/SMESH_DeviceActor.cxx
src/OBJECT/SMESH_DeviceActor.h
src/OBJECT/SMESH_ExtractGeometry.cxx
src/OBJECT/SMESH_FaceOrientationFilter.cxx
src/OBJECT/SMESH_FaceOrientationFilter.h
src/OBJECT/SMESH_NodeLabelActor.cxx
src/OBJECT/SMESH_NodeLabelActor.h
src/OBJECT/SMESH_ScalarBarActor.cxx
src/SMDS/SMDS_UnstructuredGrid.cxx
src/SMDS/SMDS_UnstructuredGrid.hxx
src/SMESHGUI/SMESHGUI.cxx
src/SMESHGUI/SMESHGUI.h
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
src/SMESHGUI/SMESHGUI_ClippingDlg.h
src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
src/SMESHGUI/SMESHGUI_Measurements.cxx
src/SMESHGUI/SMESHGUI_MergeDlg.cxx
src/SMESHGUI/SMESHGUI_MeshEditPreview.cxx
src/SMESHGUI/SMESHGUI_MeshPatternDlg.cxx
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
src/SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.cxx
src/SMESHGUI/SMESHGUI_VTKUtils.cxx
src/SMESHGUI/SMESHGUI_VTKUtils.h

index 3ae80f7..65e5c98 100644 (file)
@@ -146,10 +146,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;
@@ -166,7 +166,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;
@@ -184,7 +184,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();
@@ -192,7 +192,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;
@@ -665,8 +665,8 @@ 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 );
     SetRepresentation( GetRepresentation() );
@@ -676,8 +676,8 @@ 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 );
     SetRepresentation( GetRepresentation() );
@@ -766,24 +766,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();
 }
@@ -1189,8 +1189,8 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
   my2DExtActor->GetMapper()->SetLookupTable(myLookupTable);
   my3DActor->GetMapper()->SetLookupTable(myLookupTable);
   my3DExtActor->GetMapper()->SetLookupTable(myLookupTable);
-
-  vtkFloatingPointType aFactor, aUnits;
+    
+  double aFactor, aUnits;
   my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
   my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
   my2DExtActor->SetPolygonOffsetParameters(aFactor,aUnits*0.5);
@@ -1233,7 +1233,7 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
 }
 
 
-vtkFloatingPointType* SMESH_ActorDef::GetBounds(){
+double* SMESH_ActorDef::GetBounds(){
   return myNodeActor->GetBounds();
 }
 
@@ -1291,7 +1291,6 @@ vtkUnstructuredGrid* SMESH_ActorDef::GetUnstructuredGrid(){
 
 bool SMESH_ActorDef::IsInfinitive(){
   vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid();
-  aDataSet->Update();
   myIsInfinite = aDataSet->GetNumberOfCells() == 0 ||
     ( aDataSet->GetNumberOfCells() == 1 &&
     aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX );
@@ -1306,11 +1305,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);
@@ -1367,7 +1366,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);
 }
 
@@ -1916,15 +1915,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);
@@ -1939,12 +1938,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() ) )
@@ -1957,12 +1956,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() ) )
@@ -1975,12 +1974,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);
@@ -1990,21 +1989,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() ) )
@@ -2013,11 +2012,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 )
@@ -2025,11 +2024,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 )
@@ -2037,37 +2036,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);
@@ -2080,18 +2079,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);
@@ -2106,11 +2105,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);
@@ -2124,7 +2123,7 @@ void SMESH_ActorDef::SetBallSize(vtkFloatingPointType theVal){
   Modified();
 }
 
-vtkFloatingPointType SMESH_ActorDef::GetBallSize(){
+double SMESH_ActorDef::GetBallSize(){
   return myBallProp->GetPointSize();
 }
 
@@ -2288,21 +2287,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 );
index bbd7ac9..18fcdcb 100644 (file)
@@ -62,44 +62,44 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
                           const char* theName,
                           int theIsClear);
   
-  virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta ) = 0;
-  virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta ) = 0;
+  virtual void SetSufaceColor(double r,double g,double b, int delta ) = 0;
+  virtual void GetSufaceColor(double& r,double& g,double& b, int& delta ) = 0;
     
-  virtual void SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta ) = 0;
-  virtual void GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta) = 0;
+  virtual void SetVolumeColor(double r,double g,double b, int delta ) = 0;
+  virtual void GetVolumeColor(double& r,double& g,double& b, int& delta) = 0;
 
-  virtual void SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
-  virtual void GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
+  virtual void SetEdgeColor(double r,double g,double b) = 0;
+  virtual void GetEdgeColor(double& r,double& g,double& b) = 0;
 
-  virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
-  virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
+  virtual void SetNodeColor(double r,double g,double b) = 0;
+  virtual void GetNodeColor(double& r,double& g,double& b) = 0;
   
-  virtual void SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
-  virtual void GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;  
+  virtual void SetOutlineColor(double r,double g,double b) = 0;
+  virtual void GetOutlineColor(double& r,double& g,double& b) = 0;  
 
-  virtual void Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
-  virtual void Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
+  virtual void Set0DColor(double r,double g,double b) = 0;
+  virtual void Get0DColor(double& r,double& g,double& b) = 0;
 
-  virtual void SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
-  virtual void GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
+  virtual void SetBallColor(double r,double g,double b) = 0;
+  virtual void GetBallColor(double& r,double& g,double& b) = 0;
 
-  virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
-  virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
+  virtual void SetHighlightColor(double r,double g,double b) = 0;
+  virtual void GetHighlightColor(double& r,double& g,double& b) = 0;
 
-  virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
-  virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
+  virtual void SetPreHighlightColor(double r,double g,double b) = 0;
+  virtual void GetPreHighlightColor(double& r,double& g,double& b) = 0;
  
-  virtual vtkFloatingPointType GetLineWidth() = 0;
-  virtual void SetLineWidth(vtkFloatingPointType theVal) = 0;
+  virtual double GetLineWidth() = 0;
+  virtual void SetLineWidth(double theVal) = 0;
 
-  virtual vtkFloatingPointType GetOutlineWidth() = 0;
-  virtual void SetOutlineWidth(vtkFloatingPointType theVal) = 0;
+  virtual double GetOutlineWidth() = 0;
+  virtual void SetOutlineWidth(double theVal) = 0;
 
-  virtual void Set0DSize(vtkFloatingPointType size) = 0;
-  virtual vtkFloatingPointType Get0DSize() = 0;
+  virtual void Set0DSize(double size) = 0;
+  virtual double Get0DSize() = 0;
 
-  virtual void SetBallSize(vtkFloatingPointType size) = 0;
-  virtual vtkFloatingPointType GetBallSize() = 0;
+  virtual void SetBallSize(double size) = 0;
+  virtual double GetBallSize() = 0;
 
   enum EReperesent { ePoint, eEdge, eSurface};
   
@@ -118,7 +118,7 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
 
   virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0;
 
-  virtual void SetShrinkFactor(vtkFloatingPointType theValue) = 0;
+  virtual void SetShrinkFactor(double theValue) = 0;
 
   virtual void SetPointsLabeled(bool theIsPointsLabeled) = 0;
   virtual bool GetPointsLabeled() = 0;
@@ -129,11 +129,11 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
   virtual void SetFacesOriented(bool theIsFacesOriented) = 0;
   virtual bool GetFacesOriented() = 0;
 
-  virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
-  virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
+  virtual void SetFacesOrientationColor(double r,double g,double b) = 0;
+  virtual void GetFacesOrientationColor(double& r,double& g,double& b) = 0;
 
-  virtual void SetFacesOrientationScale(vtkFloatingPointType theScale) = 0;
-  virtual vtkFloatingPointType GetFacesOrientationScale() = 0;
+  virtual void SetFacesOrientationScale(double theScale) = 0;
+  virtual double GetFacesOrientationScale() = 0;
 
   virtual void SetFacesOrientation3DVectors(bool theState) = 0;
   virtual bool GetFacesOrientation3DVectors() = 0;
@@ -165,10 +165,10 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
 
   virtual void SetPointsFontProperties( SMESH::LabelFont family, int size, 
                                         bool bold, bool italic, bool shadow,
-                                        vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) = 0;
+                                        double r, double g, double b ) = 0;
   virtual void SetCellsFontProperties( SMESH::LabelFont family, int size, 
                                        bool bold, bool italic, bool shadow,
-                                       vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) = 0;
+                                       double r, double g, double b ) = 0;
 
 #ifndef DISABLE_PLOT2DVIEWER
   virtual SPlot2d_Histogram* GetPlot2Histogram() = 0;
index 47dc703..ee71554 100644 (file)
@@ -100,51 +100,51 @@ class SMESH_ActorDef : public SMESH_Actor
 
   virtual bool IsInfinitive();  
 
-  virtual void SetOpacity(vtkFloatingPointType theValue);
-  virtual vtkFloatingPointType GetOpacity();
+  virtual void SetOpacity(double theValue);
+  virtual double GetOpacity();
 
-  virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta );
-  virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta);
+  virtual void SetSufaceColor(double r,double g,double b, int delta );
+  virtual void GetSufaceColor(double& r,double& g,double& b, int& delta);
 
-  virtual void SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta );
-  virtual void GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta);
+  virtual void SetVolumeColor(double r,double g,double b, int delta );
+  virtual void GetVolumeColor(double& r,double& g,double& b, int& delta);
 
-  virtual void SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
-  virtual void GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
+  virtual void SetEdgeColor(double r,double g,double b);
+  virtual void GetEdgeColor(double& r,double& g,double& b);
 
-  virtual void SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
-  virtual void GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
+  virtual void SetOutlineColor(double r,double g,double b);
+  virtual void GetOutlineColor(double& r,double& g,double& b);
 
 
-  virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
-  virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
+  virtual void SetNodeColor(double r,double g,double b);
+  virtual void GetNodeColor(double& r,double& g,double& b);
 
-  virtual void Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
-  virtual void Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
+  virtual void Set0DColor(double r,double g,double b);
+  virtual void Get0DColor(double& r,double& g,double& b);
 
-  virtual void SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
-  virtual void GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
+  virtual void SetBallColor(double r,double g,double b);
+  virtual void GetBallColor(double& r,double& g,double& b);
 
-  virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
-  virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
+  virtual void SetHighlightColor(double r,double g,double b);
+  virtual void GetHighlightColor(double& r,double& g,double& b);
 
-  virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
-  virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
+  virtual void SetPreHighlightColor(double r,double g,double b);
+  virtual void GetPreHighlightColor(double& r,double& g,double& b);
  
-  virtual vtkFloatingPointType GetLineWidth();
-  virtual void SetLineWidth(vtkFloatingPointType theVal);
+  virtual double GetLineWidth();
+  virtual void SetLineWidth(double theVal);
 
-  virtual vtkFloatingPointType GetOutlineWidth();
-  virtual void SetOutlineWidth(vtkFloatingPointType theVal);
+  virtual double GetOutlineWidth();
+  virtual void SetOutlineWidth(double theVal);
 
-  virtual void Set0DSize(vtkFloatingPointType size);
-  virtual vtkFloatingPointType Get0DSize();
+  virtual void Set0DSize(double size);
+  virtual double Get0DSize();
 
-  virtual void SetBallSize(vtkFloatingPointType size);
-  virtual vtkFloatingPointType GetBallSize();
+  virtual void SetBallSize(double size);
+  virtual double GetBallSize();
 
   virtual int GetNodeObjId(int theVtkID);
-  virtual vtkFloatingPointType* GetNodeCoord(int theObjID);
+  virtual double* GetNodeCoord(int theObjID);
 
   virtual int GetElemObjId(int theVtkID);
   virtual vtkCell* GetElemCell(int theObjID);
@@ -162,15 +162,15 @@ class SMESH_ActorDef : public SMESH_Actor
   virtual void SetPointRepresentation(bool theIsPointsVisible);
   virtual bool GetPointRepresentation();
 
-  virtual vtkFloatingPointType* GetBounds();
+  virtual double* GetBounds();
   virtual void SetTransform(VTKViewer_Transform* theTransform); 
 
   virtual vtkUnstructuredGrid* GetUnstructuredGrid();
   virtual vtkDataSet* GetInput();
   virtual vtkMapper* GetMapper();
 
-  virtual vtkFloatingPointType GetShrinkFactor();
-  virtual void SetShrinkFactor(vtkFloatingPointType theValue);
+  virtual double GetShrinkFactor();
+  virtual void SetShrinkFactor(double theValue);
 
   virtual bool IsShrunkable() { return myIsShrinkable;}
   virtual bool IsShrunk() { return myIsShrunk;}
@@ -182,10 +182,10 @@ class SMESH_ActorDef : public SMESH_Actor
 
   virtual void SetPointsFontProperties( SMESH::LabelFont family, int size, 
                                         bool bold, bool italic, bool shadow,
-                                        vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b );
+                                        double r, double g, double b );
   virtual void SetCellsFontProperties( SMESH::LabelFont family, int size, 
                                        bool bold, bool italic, bool shadow,
-                                       vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b );
+                                       double r, double g, double b );
   
   virtual void SetCellsLabeled(bool theIsCellsLabeled);
   virtual bool GetCellsLabeled();
@@ -193,11 +193,11 @@ class SMESH_ActorDef : public SMESH_Actor
   virtual void SetFacesOriented(bool theIsFacesOriented);
   virtual bool GetFacesOriented();
 
-  virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
-  virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
+  virtual void SetFacesOrientationColor(double r,double g,double b);
+  virtual void GetFacesOrientationColor(double& r,double& g,double& b);
 
-  virtual void SetFacesOrientationScale(vtkFloatingPointType theScale);
-  virtual vtkFloatingPointType GetFacesOrientationScale();
+  virtual void SetFacesOrientationScale(double theScale);
+  virtual double GetFacesOrientationScale();
 
   virtual void SetFacesOrientation3DVectors(bool theState);
   virtual bool GetFacesOrientation3DVectors();
index c756156..9ce8b05 100644 (file)
 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;
   }
@@ -90,7 +90,7 @@ namespace SMESH
   {
     vtkXMLUnstructuredGridWriter* aWriter = vtkXMLUnstructuredGridWriter::New();
     aWriter->SetFileName(theFileName);
-    aWriter->SetInput(theGrid);
+    aWriter->SetInputData(theGrid);
     aWriter->SetDataModeToAscii();
     if(theGrid->GetNumberOfCells()){
       aWriter->Write();
@@ -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 );
index ce189fb..9a62009 100644 (file)
@@ -41,15 +41,15 @@ namespace SMESH
   };
 
 SMESHOBJECT_EXPORT  
-  vtkFloatingPointTyp
+  doubl
   GetFloat( const QString& theValue, 
-            vtkFloatingPointType theDefault = 0 );
+            double theDefault = 0 );
 
 SMESHOBJECT_EXPORT
-  vtkFloatingPointTyp
+  doubl
   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
index 297c37d..9b076d5 100644 (file)
@@ -52,19 +52,19 @@ SMESH_CellLabelActor::SMESH_CellLabelActor() {
   myCellsNumDataSet = vtkUnstructuredGrid::New();
 
   myCellCenters = VTKViewer_CellCenters::New();
-  myCellCenters->SetInput(myCellsNumDataSet);
+  myCellCenters->SetInputData(myCellsNumDataSet);
 
   myClsMaskPoints = vtkMaskPoints::New();
-  myClsMaskPoints->SetInput(myCellCenters->GetOutput());
+  myClsMaskPoints->SetInputConnection(myCellCenters->GetOutputPort());
   myClsMaskPoints->SetOnRatio(1);
     
   myClsSelectVisiblePoints = vtkSelectVisiblePoints::New();
-  myClsSelectVisiblePoints->SetInput(myClsMaskPoints->GetOutput());
+  myClsSelectVisiblePoints->SetInputConnection(myClsMaskPoints->GetOutputPort());
   myClsSelectVisiblePoints->SelectInvisibleOff();
   myClsSelectVisiblePoints->SetTolerance(0.1);
     
   myClsLabeledDataMapper = vtkLabeledDataMapper::New();
-  myClsLabeledDataMapper->SetInput(myClsSelectVisiblePoints->GetOutput());
+  myClsLabeledDataMapper->SetInputConnection(myClsSelectVisiblePoints->GetOutputPort());
 
   myClsLabeledDataMapper->SetLabelFormat("%d");
   myClsLabeledDataMapper->SetLabelModeToLabelScalars();
@@ -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:
@@ -156,7 +156,7 @@ void SMESH_CellLabelActor::SetCellsLabeled(bool theIsCellsLabeled) {
       anArray->SetValue(anId,aSMDSId);
     }
     aDataSet->GetCellData()->SetScalars(anArray);
-    myCellCenters->SetInput(aDataSet);
+    myCellCenters->SetInputData(aDataSet);
     myCellsLabels->SetVisibility(GetVisibility());
   }else{
     myCellsLabels->SetVisibility(false);
index f9a6a23..83b8b63 100644 (file)
@@ -62,7 +62,7 @@ public:
   
   virtual void SetFontProperties( SMESH::LabelFont family, int size,
                                   bool bold, bool italic, bool shadow,
-                                  vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b );
+                                  double r, double g, double b );
 
   void UpdateLabels();
   
index c82bbf3..dc87860 100644 (file)
@@ -119,13 +119,13 @@ 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();
 
   myFaceOrientationDataMapper = vtkPolyDataMapper::New();
-  myFaceOrientationDataMapper->SetInput(myFaceOrientationFilter->GetOutput());
+  myFaceOrientationDataMapper->SetInputConnection(myFaceOrientationFilter->GetOutputPort());
 
   myFaceOrientation = vtkActor::New();
   myFaceOrientation->SetMapper(myFaceOrientationDataMapper);
@@ -208,9 +208,9 @@ SMESH_DeviceActor
 {
   int anId = 0;
   if(theIsImplicitFunctionUsed)
-    myPassFilter[ anId ]->SetInput( myExtractGeometry->GetOutput() );
+    myPassFilter[ anId ]->SetInputConnection( myExtractGeometry->GetOutputPort() );
   else
-    myPassFilter[ anId ]->SetInput( myMergeFilter->GetOutput() );
+    myPassFilter[ anId ]->SetInputConnection( myMergeFilter->GetOutputPort() );
     
   myIsImplicitFunctionUsed = theIsImplicitFunctionUsed;
   SetStoreClippingMapping(myStoreClippingMapping);
@@ -225,32 +225,32 @@ SMESH_DeviceActor
     //myIsShrinkable = theGrid->GetNumberOfCells() > 10;
     myIsShrinkable = true;
 
-    myExtractUnstructuredGrid->SetInput(theGrid);
+    myExtractUnstructuredGrid->SetInputData(theGrid);
 
-    myMergeFilter->SetGeometry(myExtractUnstructuredGrid->GetOutput());
+    myMergeFilter->SetGeometryConnection(myExtractUnstructuredGrid->GetOutputPort());
 
-    myExtractGeometry->SetInput(myMergeFilter->GetOutput());
+    myExtractGeometry->SetInputConnection(myMergeFilter->GetOutputPort());
 
     int anId = 0;
     SetImplicitFunctionUsed(myIsImplicitFunctionUsed);
-    myPassFilter[ anId + 1]->SetInput( myPassFilter[ anId ]->GetOutput() );
+    myPassFilter[ anId + 1]->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
     
     anId++; // 1
-    myTransformFilter->SetInput( myPassFilter[ anId ]->GetOutput() );
+    myTransformFilter->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
 
     anId++; // 2
-    myPassFilter[ anId ]->SetInput( myTransformFilter->GetOutput() );
-    myPassFilter[ anId + 1 ]->SetInput( myPassFilter[ anId ]->GetOutput() );
+    myPassFilter[ anId ]->SetInputConnection( myTransformFilter->GetOutputPort() );
+    myPassFilter[ anId + 1 ]->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
 
     anId++; // 3
-    myGeomFilter->SetInput( myPassFilter[ anId ]->GetOutput() );
+    myGeomFilter->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
 
     anId++; // 4
-    myPassFilter[ anId ]->SetInput( myGeomFilter->GetOutput() ); 
-    myPassFilter[ anId + 1 ]->SetInput( myPassFilter[ anId ]->GetOutput() );
+    myPassFilter[ anId ]->SetInputConnection( myGeomFilter->GetOutputPort() ); 
+    myPassFilter[ anId + 1 ]->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
 
     anId++; // 5
-    myMapper->SetInput( myPassFilter[ anId ]->GetPolyDataOutput() );
+    myMapper->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
 
     vtkLODActor::SetMapper( myMapper );
     Modified();
@@ -322,7 +322,7 @@ SMESH_DeviceActor
     theLookupTable->SetNumberOfTableValues(theScalarBarActor->GetMaximumNumberOfColors());
     theLookupTable->Build();
     
-    myMergeFilter->SetScalars(aDataSet);
+    myMergeFilter->SetScalarsData(aDataSet);
     aDataSet->Delete();
   }
   GetMapper()->SetScalarVisibility(anIsInitialized);
@@ -402,7 +402,7 @@ SMESH_DeviceActor
       theLookupTable->SetRange(aScalars->GetRange());
       theLookupTable->Build();
       
-      myMergeFilter->SetScalars(aDataSet);
+      myMergeFilter->SetScalarsData(aDataSet);
       aDataSet->Delete();
     }
     else if (MultiConnection2D* aMultiConnection2D = dynamic_cast<MultiConnection2D*>(theFunctor.get())){
@@ -462,7 +462,7 @@ SMESH_DeviceActor
       theLookupTable->SetRange(aScalars->GetRange());
       theLookupTable->Build();
       
-      myMergeFilter->SetScalars(aDataSet);
+      myMergeFilter->SetScalarsData(aDataSet);
       aDataSet->Delete();
     }
   }
@@ -600,10 +600,10 @@ SMESH_DeviceActor
 ::SetShrink() 
 {
   if ( !myIsShrinkable ) return;
-  if ( vtkDataSet* aDataSet = myPassFilter[ 0 ]->GetOutput() )
+  if ( vtkAlgorithmOutput* aDataSet = myPassFilter[ 0 ]->GetOutputPort() )
   {
-    myShrinkFilter->SetInput( aDataSet );
-    myPassFilter[ 1 ]->SetInput( myShrinkFilter->GetOutput() );
+    myShrinkFilter->SetInputConnection( aDataSet );
+    myPassFilter[ 1 ]->SetInputConnection( myShrinkFilter->GetOutputPort() );
     myIsShrunk = true;
   }
 }
@@ -613,9 +613,9 @@ SMESH_DeviceActor
 ::UnShrink() 
 {
   if ( !myIsShrunk ) return;
-  if ( vtkDataSet* aDataSet = myPassFilter[ 0 ]->GetOutput() )
+  if ( vtkAlgorithmOutput* aDataSet = myPassFilter[ 0 ]->GetOutputPort() )
   {    
-    myPassFilter[ 1 ]->SetInput( aDataSet );
+    myPassFilter[ 1 ]->SetInputConnection( aDataSet );
     myPassFilter[ 1 ]->Modified();
     myIsShrunk = false;
     Modified();
@@ -627,37 +627,37 @@ void
 SMESH_DeviceActor
 ::SetFacesOriented(bool theIsFacesOriented) 
 {
-  if ( vtkDataSet* aDataSet = myTransformFilter->GetOutput() )
+  if ( vtkAlgorithmOutput* aDataSet = myTransformFilter->GetOutputPort() )
   {
     myIsFacesOriented = theIsFacesOriented;
     if( theIsFacesOriented )
-      myFaceOrientationFilter->SetInput( aDataSet );
+      myFaceOrientationFilter->SetInputConnection( aDataSet );
     UpdateFaceOrientation();
   }
 }
 
 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()
 {
@@ -780,13 +780,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;
 }
@@ -829,7 +829,7 @@ SMESH_DeviceActor
 }
 
 
-vtkFloatingPointTyp
+doubl
 SMESH_DeviceActor
 ::GetShrinkFactor()
 {
@@ -838,7 +838,7 @@ SMESH_DeviceActor
 
 void
 SMESH_DeviceActor
-::SetShrinkFactor(vtkFloatingPointType theValue)
+::SetShrinkFactor(double theValue)
 {
   theValue = theValue > 0.1? theValue: 0.8;
   myShrinkFilter->SetShrinkFactor(theValue);
@@ -861,13 +861,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);
@@ -880,8 +880,8 @@ SMESH_DeviceActor
 
 void
 SMESH_DeviceActor
-::SetPolygonOffsetParameters(vtkFloatingPointType factor, 
-                             vtkFloatingPointType units)
+::SetPolygonOffsetParameters(double factor, 
+                             double units)
 {
   myPolygonOffsetFactor = factor;
   myPolygonOffsetUnits = units;
@@ -903,14 +903,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();
 }
 
index 554af35..40bfced 100644 (file)
@@ -68,7 +68,7 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
   void SetStoreIDMapping(bool theStoreMapping);
 
   virtual int GetNodeObjId(int theVtkID);
-  virtual vtkFloatingPointType* GetNodeCoord(int theObjID);
+  virtual double* GetNodeCoord(int theObjID);
 
   virtual int GetElemObjId(int theVtkID);
   virtual vtkCell* GetElemCell(int theObjID);
@@ -79,11 +79,11 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
   virtual void SetFacesOriented(bool theIsFacesOriented);
   virtual bool GetFacesOriented() { return myIsFacesOriented; }
 
-  virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
-  virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
+  virtual void SetFacesOrientationColor(double r,double g,double b);
+  virtual void GetFacesOrientationColor(double& r,double& g,double& b);
 
-  virtual void SetFacesOrientationScale(vtkFloatingPointType theScale);
-  virtual vtkFloatingPointType GetFacesOrientationScale();
+  virtual void SetFacesOrientationScale(double theScale);
+  virtual double GetFacesOrientationScale();
 
   virtual void SetFacesOrientation3DVectors(bool theState);
   virtual bool GetFacesOrientation3DVectors();
@@ -93,13 +93,13 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
   virtual void SetQuadraticArcMode(bool theFlag);
   virtual bool GetQuadraticArcMode();
   
-  virtual void SetQuadraticArcAngle(vtkFloatingPointType theMaxAngle);
-  virtual vtkFloatingPointType GetQuadraticArcAngle();
+  virtual void SetQuadraticArcAngle(double theMaxAngle);
+  virtual double GetQuadraticArcAngle();
   
   void UpdateFaceOrientation();
 
-  vtkFloatingPointType GetShrinkFactor();
-  void  SetShrinkFactor(vtkFloatingPointType value);
+  double GetShrinkFactor();
+  void  SetShrinkFactor(double value);
 
   bool IsShrunkable() { return myIsShrinkable;}
   bool IsShrunk() { return myIsShrunk;}
@@ -182,16 +182,16 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
   
   bool myIsHighlited;
 
-  vtkFloatingPointType myPolygonOffsetFactor;
-  vtkFloatingPointType myPolygonOffsetUnits;
+  double myPolygonOffsetFactor;
+  double myPolygonOffsetUnits;
 
   void
-  SetPolygonOffsetParameters(vtkFloatingPointType factor, 
-                             vtkFloatingPointType units);
+  SetPolygonOffsetParameters(double factor, 
+                             double units);
 
   void
-  GetPolygonOffsetParameters(vtkFloatingPointType& factor, 
-                             vtkFloatingPointType& units)
+  GetPolygonOffsetParameters(double& factor, 
+                             double& units)
   {
     factor = myPolygonOffsetFactor;
     units = myPolygonOffsetUnits;
index aad9a64..70c226c 100644 (file)
@@ -89,8 +89,8 @@ int SMESH_ExtractGeometry::RequestData(
   vtkIdList *cellPts;
   vtkCell *cell;
   int numCellPts;
-  vtkFloatingPointType *x;
-  vtkFloatingPointType multiplier;
+  double *x;
+  double multiplier;
   vtkPoints *newPts;
   vtkIdList *newCellPts;
   vtkPointData *pd = input->GetPointData();
@@ -163,7 +163,7 @@ int SMESH_ExtractGeometry::RequestData(
     // To extract boundary cells, we have to create supplemental information
     if ( this->ExtractBoundaryCells )
       {
-      vtkFloatingPointType val;
+      double val;
       newScalars = vtkFloatArray::New();
       newScalars->SetNumberOfValues(numPts);
 
index da38ecf..46a6469 100644 (file)
@@ -42,7 +42,6 @@
 
 #define PI   3.14159265359
 
-vtkCxxRevisionMacro(SMESH_FaceOrientationFilter, "$Revision$");
 vtkStandardNewMacro(SMESH_FaceOrientationFilter);
 
 /*!
@@ -61,10 +60,10 @@ SMESH_FaceOrientationFilter::SMESH_FaceOrientationFilter()
   myFacePolyData = vtkPolyData::New();
 
   myFaceCenters = VTKViewer_CellCenters::New();
-  myFaceCenters->SetInput(myFacePolyData);
+  myFaceCenters->SetInputData(myFacePolyData);
 
   myFaceMaskPoints = vtkMaskPoints::New();
-  myFaceMaskPoints->SetInput(myFaceCenters->GetOutput());
+  myFaceMaskPoints->SetInputConnection(myFaceCenters->GetOutputPort());
   myFaceMaskPoints->SetOnRatio(1);
 
   myGlyphSource = vtkGlyphSource2D::New();
@@ -73,11 +72,14 @@ SMESH_FaceOrientationFilter::SMESH_FaceOrientationFilter()
   myGlyphSource->SetCenter(0.5, 0.0, 0.0);
 
   myBaseGlyph = vtkGlyph3D::New();
-  myBaseGlyph->SetInput(myFaceMaskPoints->GetOutput());
+  myBaseGlyph->SetInputConnection(myFaceMaskPoints->GetOutputPort());
   myBaseGlyph->SetVectorModeToUseVector();
   myBaseGlyph->SetScaleModeToDataScalingOff();
   myBaseGlyph->SetColorModeToColorByScalar();
-  myBaseGlyph->SetSource(my3dVectors ? myArrowPolyData : myGlyphSource->GetOutput());
+  if( my3dVectors )
+    myBaseGlyph->SetSourceData(myArrowPolyData);
+  else
+    myBaseGlyph->SetSourceConnection(myGlyphSource->GetOutputPort());
 }
 
 SMESH_FaceOrientationFilter::~SMESH_FaceOrientationFilter()
@@ -90,7 +92,7 @@ SMESH_FaceOrientationFilter::~SMESH_FaceOrientationFilter()
   myBaseGlyph->Delete();
 }
 
-void SMESH_FaceOrientationFilter::SetOrientationScale( vtkFloatingPointType theScale )
+void SMESH_FaceOrientationFilter::SetOrientationScale( double theScale )
 {
   myOrientationScale = theScale;
   Modified();
@@ -99,7 +101,10 @@ void SMESH_FaceOrientationFilter::SetOrientationScale( vtkFloatingPointType theS
 void SMESH_FaceOrientationFilter::Set3dVectors( bool theState )
 {
   my3dVectors = theState;
-  myBaseGlyph->SetSource(my3dVectors ? myArrowPolyData : myGlyphSource->GetOutput());
+  if( my3dVectors )
+    myBaseGlyph->SetSourceData(myArrowPolyData);
+  else
+    myBaseGlyph->SetSourceConnection(myGlyphSource->GetOutputPort());
   Modified();
 }
 
index dcd4c33..aed9866 100644 (file)
@@ -33,13 +33,13 @@ class VTKViewer_CellCenters;
 class SMESHOBJECT_EXPORT SMESH_FaceOrientationFilter : public vtkPolyDataAlgorithm
 {
 public:
-  vtkTypeRevisionMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm );
+  vtkTypeMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm );
 
   /*!Create a new SMESH_FaceOrientationFilter.*/
   static SMESH_FaceOrientationFilter *New();
 
-  void SetOrientationScale( vtkFloatingPointType );
-  vtkFloatingPointType GetOrientationScale() const { return myOrientationScale; }
+  void SetOrientationScale( double );
+  double GetOrientationScale() const { return myOrientationScale; }
 
   void Set3dVectors( bool );
   bool Get3dVectors() const { return my3dVectors; }
@@ -61,7 +61,7 @@ private:
 
 private:
   bool my3dVectors;
-  vtkFloatingPointType myOrientationScale;
+  double myOrientationScale;
   vtkPolyData* myArrowPolyData;
   vtkPolyData* myFacePolyData;
   VTKViewer_CellCenters* myFaceCenters;
index b3a8d3d..039456b 100644 (file)
@@ -50,16 +50,16 @@ SMESH_NodeLabelActor::SMESH_NodeLabelActor() {
   myPointsNumDataSet = vtkUnstructuredGrid::New();
 
   myPtsMaskPoints = vtkMaskPoints::New();
-  myPtsMaskPoints->SetInput(myPointsNumDataSet);
+  myPtsMaskPoints->SetInputData(myPointsNumDataSet);
   myPtsMaskPoints->SetOnRatio(1);
 
   myPtsSelectVisiblePoints = vtkSelectVisiblePoints::New();
-  myPtsSelectVisiblePoints->SetInput(myPtsMaskPoints->GetOutput());
+  myPtsSelectVisiblePoints->SetInputConnection(myPtsMaskPoints->GetOutputPort());
   myPtsSelectVisiblePoints->SelectInvisibleOff();
   myPtsSelectVisiblePoints->SetTolerance(0.1);
     
   myPtsLabeledDataMapper = vtkLabeledDataMapper::New();
-  myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput());
+  myPtsLabeledDataMapper->SetInputConnection(myPtsSelectVisiblePoints->GetOutputPort());
   myPtsLabeledDataMapper->SetLabelFormat("%d");
   myPtsLabeledDataMapper->SetLabelModeToLabelScalars();
     
@@ -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:
@@ -156,7 +156,7 @@ void SMESH_NodeLabelActor::SetPointsLabeled(bool theIsPointsLabeled) {
     }
     
     aDataSet->GetPointData()->SetScalars( anArray );
-    myPtsMaskPoints->SetInput( aDataSet );
+    myPtsMaskPoints->SetInputData( aDataSet );
     myPointLabels->SetVisibility( GetVisibility() );
     anArray->Delete();
   }
index 03de78f..601abb0 100644 (file)
@@ -59,7 +59,7 @@ public:
   
   virtual void SetFontProperties( SMESH::LabelFont family, int size,
                                   bool bold, bool italic, bool shadow,
-                                  vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b );
+                                  double r, double g, double b );
 
   void UpdateLabels();
   
index a305712..19d4689 100644 (file)
@@ -88,7 +88,7 @@ SMESH_ScalarBarActor::SMESH_ScalarBarActor() {
 
   this->ScalarBar = vtkPolyData::New();
   this->ScalarBarMapper = vtkPolyDataMapper2D::New();
-  this->ScalarBarMapper->SetInput(this->ScalarBar);
+  this->ScalarBarMapper->SetInputData(this->ScalarBar);
   this->ScalarBarActor = vtkActor2D::New();
   this->ScalarBarActor->SetMapper(this->ScalarBarMapper);
   this->ScalarBarActor->GetPositionCoordinate()->
@@ -103,7 +103,7 @@ SMESH_ScalarBarActor::SMESH_ScalarBarActor() {
   // Customization of the vtkScalarBarActor to show distribution histogram.
   myDistribution = vtkPolyData::New();
   myDistributionMapper = vtkPolyDataMapper2D::New();
-  myDistributionMapper->SetInput(this->myDistribution);
+  myDistributionMapper->SetInputData(this->myDistribution);
   
   myDistributionActor = vtkActor2D::New();
   myDistributionActor->SetMapper(this->myDistributionMapper);
index 5a05789..d3ea0b6 100644 (file)
@@ -87,7 +87,8 @@ unsigned long SMDS_UnstructuredGrid::GetMTime()
   MESSAGE("vtkUnstructuredGrid::GetMTime: " << mtime);
   return mtime;
 }
-
+// OUV_PORTING_VTK6: seems to be useless
+/*
 void SMDS_UnstructuredGrid::Update()
 {
   MESSAGE("SMDS_UnstructuredGrid::Update");
@@ -99,7 +100,7 @@ void SMDS_UnstructuredGrid::UpdateInformation()
   MESSAGE("SMDS_UnstructuredGrid::UpdateInformation");
   return vtkUnstructuredGrid::UpdateInformation();
 }
-
+*/
 vtkPoints* SMDS_UnstructuredGrid::GetPoints()
 {
   // TODO erreur incomprehensible de la macro vtk GetPoints apparue avec la version paraview de fin aout 2010
index 4cd1dae..4292dfd 100644 (file)
@@ -70,8 +70,9 @@ public:
                    std::vector<int>& idCellsOldToNew,
                    int               newCellSize);
   virtual unsigned long GetMTime();
-  virtual void Update();
-  virtual void UpdateInformation();
+  // OUV_PORTING_VTK6: seems to be useless
+  //virtual void Update();
+  //virtual void UpdateInformation();
   virtual vtkPoints *GetPoints();
 
   //#ifdef VTK_HAVE_POLYHEDRON
index 47f42b9..8261007 100644 (file)
         return;
       }
       case 1132: {
-        vtkFloatingPointType color[3];
+        double color[3];
         QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
         QColor orientationColor, outlineColor, volumeColor;
         int deltaF = 0, deltaV = 0;
         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;
@@ -5456,7 +5456,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);
@@ -5595,8 +5595,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;
@@ -6171,7 +6171,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();
 
index f45cfbf..bd4b170 100644 (file)
@@ -221,7 +221,7 @@ private :
   SMESHGUI_ClippingPlaneInfoMap   myClippingPlaneInfoMap;
 
   vtkSmartPointer<vtkCallbackCommand> myEventCallbackCommand;
-  vtkFloatingPointType            myPriority;
+  double            myPriority;
 };
 
 #endif // SMESHGUI_H
index ce220e2..87ff73c 100644 (file)
@@ -113,14 +113,14 @@ namespace SMESH
 
       // Create and display actor
       myMapper = vtkDataSetMapper::New();
-      myMapper->SetInput(myGrid);
+      myMapper->SetInputData(myGrid);
 
       myPreviewActor = SALOME_Actor::New();
       myPreviewActor->PickableOff();
       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] );
@@ -137,10 +137,10 @@ namespace SMESH
 
       // Orientation of faces
       myFaceOrientationFilter = SMESH_FaceOrientationFilter::New();
-      myFaceOrientationFilter->SetInput(myGrid);
+      myFaceOrientationFilter->SetInputData(myGrid);
 
       myFaceOrientationDataMapper = vtkPolyDataMapper::New();
-      myFaceOrientationDataMapper->SetInput(myFaceOrientationFilter->GetOutput());
+      myFaceOrientationDataMapper->SetInputConnection(myFaceOrientationFilter->GetOutputPort());
 
       myFaceOrientation = SALOME_Actor::New();
       myFaceOrientation->PickableOff();
index 3a72de1..2f7459e 100644 (file)
@@ -121,7 +121,7 @@ namespace SMESH
     vtkUnstructuredGrid* myGrid;
     //vtkProperty* myBackProp, *myProp;
 
-    //vtkFloatingPointType myRGB[3], myBackRGB[3];
+    //double myRGB[3], myBackRGB[3];
 
     SALOME_Actor* myFaceOrientation;
     vtkPolyDataMapper* myFaceOrientationDataMapper;
@@ -140,7 +140,7 @@ namespace SMESH
 
       // Create and display actor
       myMapper = vtkDataSetMapper::New();
-      myMapper->SetInput(myGrid);
+      myMapper->SetInputData(myGrid);
 
       myPreviewActor = SALOME_Actor::New();
       myPreviewActor->PickableOff();
@@ -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 );
@@ -164,10 +164,10 @@ namespace SMESH
 
       // Orientation of faces
       myFaceOrientationFilter = SMESH_FaceOrientationFilter::New();
-      myFaceOrientationFilter->SetInput(myGrid);
+      myFaceOrientationFilter->SetInputData(myGrid);
 
       myFaceOrientationDataMapper = vtkPolyDataMapper::New();
-      myFaceOrientationDataMapper->SetInput(myFaceOrientationFilter->GetOutput());
+      myFaceOrientationDataMapper->SetInputConnection(myFaceOrientationFilter->GetOutputPort());
 
       myFaceOrientation = SALOME_Actor::New();
       myFaceOrientation->PickableOff();
index c359f18..bc097f2 100644 (file)
@@ -105,6 +105,7 @@ void SMESH::OrientedPlane::ShallowCopy(SMESH::OrientedPlane* theOrientedPlane)
   myPlaneSource->SetOrigin(theOrientedPlane->myPlaneSource->GetOrigin());
   myPlaneSource->SetPoint1(theOrientedPlane->myPlaneSource->GetPoint1());
   myPlaneSource->SetPoint2(theOrientedPlane->myPlaneSource->GetPoint2());
+  myPlaneSource->Update();
 }
 
 SMESH::OrientedPlane::OrientedPlane(SVTK_ViewWindow* theViewWindow):
@@ -132,7 +133,7 @@ void SMESH::OrientedPlane::Init()
 
   // Create and display actor
   myMapper = vtkDataSetMapper::New();
-  myMapper->SetInput(myPlaneSource->GetOutput());
+  myMapper->SetInputConnection(myPlaneSource->GetOutputPort());
 
   myActor = SALOME_Actor::New();
   myActor->VisibilityOff();
@@ -140,7 +141,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 +209,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 +219,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 +261,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 +285,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);
@@ -325,6 +326,7 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
   aPlaneSource->SetOrigin(aPnt0[0],aPnt0[1],aPnt0[2]);
   aPlaneSource->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]);
   aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]);
+  aPlaneSource->Update();
 
   SMESH::TActorList::iterator anIter = theActorList.begin();
   for ( ; anIter != theActorList.end(); anIter++ )
@@ -898,18 +900,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];
 
@@ -956,8 +958,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(),
@@ -970,38 +972,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);
@@ -1011,6 +1013,7 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
     aPlaneSource->SetOrigin(aPnt0[0],aPnt0[1],aPnt0[2]);
     aPlaneSource->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]);
     aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]);
+    aPlaneSource->Update();
   }
 
   if(AutoApplyCheckBox->isChecked())
@@ -1148,8 +1151,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] );
index 3ade2c9..2978394 100644 (file)
@@ -145,7 +145,7 @@ public:
                                          SVTK_ViewWindow*           theViewWindow,
                                          SMESH::Orientation         theOrientation,
                                          double                     theDistance,
-                                         const vtkFloatingPointType theAngle[2]);
+                                         const double theAngle[2]);
 
 protected:  
   void                    keyPressEvent( QKeyEvent* );
index 1d5555e..c0c2960 100644 (file)
@@ -1180,8 +1180,8 @@ void SMESHGUI_BaseComputeOp::onShowBadMesh()
       if ( myBadMeshDisplayer ) delete myBadMeshDisplayer;
       myBadMeshDisplayer = new SMESHGUI_MeshEditPreview( view );
       SMESH::MeshPreviewStruct_var aMeshData = gen->GetBadInputElements(myMesh,curSub);
-      vtkFloatingPointType aPointSize = SMESH::GetFloat("SMESH:node_size",3);
-      vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
+      double aPointSize = SMESH::GetFloat("SMESH:node_size",3);
+      double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
       vtkProperty* prop = vtkProperty::New();
       prop->SetLineWidth( aLineWidth * 3 );
       prop->SetPointSize( aPointSize * 3 );
index eac1ae8..ff21b39 100644 (file)
@@ -260,8 +260,8 @@ bool SMESHGUI_ConvToQuadOp::onApply()
           if ( myBadElemsPreview ) delete myBadElemsPreview; // viewWindow may change
           myBadElemsPreview = new SMESHGUI_MeshEditPreview( viewWindow() );
           
-          vtkFloatingPointType aPointSize = SMESH::GetFloat("SMESH:node_size",3);
-          vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
+          double aPointSize = SMESH::GetFloat("SMESH:node_size",3);
+          double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
           vtkProperty* prop = vtkProperty::New();
           prop->SetLineWidth( aLineWidth * 3 );
           prop->SetPointSize( aPointSize * 3 );
index 8fdd03e..4d0a497 100644 (file)
@@ -106,7 +106,7 @@ namespace SMESH
   
       // Create and display actor
       myMapper = vtkDataSetMapper::New();
-      myMapper->SetInput( myGrid );
+      myMapper->SetInputData( myGrid );
 
       myPreviewActor = SALOME_Actor::New();
       myPreviewActor->PickableOff();
@@ -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);
index ff93944..13a2092 100644 (file)
@@ -362,7 +362,7 @@ void SMESHGUI_MinDistance::createPreview( double x1, double y1, double z1, doubl
   aCells->Delete();
   // create actor
   vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
-  aMapper->SetInput( aGrid );
+  aMapper->SetInputData( aGrid );
   aGrid->Delete();
   myPreview = SALOME_Actor::New();
   myPreview->PickableOff();
@@ -879,7 +879,7 @@ void SMESHGUI_BoundingBox::createPreview( double minX, double maxX, double minY,
   aCells->Delete();
   // create actor
   vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
-  aMapper->SetInput( aGrid );
+  aMapper->SetInputData( aGrid );
   aGrid->Delete();
   myPreview = SALOME_Actor::New();
   myPreview->PickableOff();
index 8288470..8a615d3 100644 (file)
@@ -124,7 +124,7 @@ namespace SMESH
 
       // Create and display actor
       vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
-      aMapper->SetInput( myIdGrid );
+      aMapper->SetInputData( myIdGrid );
 
       myIdActor = SALOME_Actor::New();
       myIdActor->SetInfinitive(true);
@@ -140,16 +140,16 @@ namespace SMESH
       myPointsNumDataSet = vtkUnstructuredGrid::New();
 
       myPtsMaskPoints = vtkMaskPoints::New();
-      myPtsMaskPoints->SetInput(myPointsNumDataSet);
+      myPtsMaskPoints->SetInputData(myPointsNumDataSet);
       myPtsMaskPoints->SetOnRatio(1);
 
       myPtsSelectVisiblePoints = vtkSelectVisiblePoints::New();
-      myPtsSelectVisiblePoints->SetInput(myPtsMaskPoints->GetOutput());
+      myPtsSelectVisiblePoints->SetInputConnection(myPtsMaskPoints->GetOutputPort());
       myPtsSelectVisiblePoints->SelectInvisibleOff();
       myPtsSelectVisiblePoints->SetTolerance(0.1);
     
       myPtsLabeledDataMapper = vtkLabeledDataMapper::New();
-      myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput());
+      myPtsLabeledDataMapper->SetInputConnection(myPtsSelectVisiblePoints->GetOutputPort());
 #if (VTK_XVERSION < 0x050200)
       myPtsLabeledDataMapper->SetLabelFormat("%g");
 #endif
@@ -250,7 +250,7 @@ namespace SMESH
           anArray->SetValue( i, myIDs[i] );
         aDataSet->GetPointData()->SetScalars( anArray );
         anArray->Delete();
-        myPtsMaskPoints->SetInput( aDataSet );
+        myPtsMaskPoints->SetInputData( aDataSet );
         myPointLabels->SetVisibility( theIsActorVisible );
       }
       else {
index ac71ddb..25cae2f 100644 (file)
@@ -66,19 +66,19 @@ SMESHGUI_MeshEditPreview::SMESHGUI_MeshEditPreview(SVTK_ViewWindow* theViewWindo
 
   // Create and display actor
   vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
-  aMapper->SetInput( myGrid );
+  aMapper->SetInputData( myGrid );
 
   myPreviewActor = SALOME_Actor::New();
   myPreviewActor->SetInfinitive(true);
   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] );
 
index 48b0a82..a611756 100755 (executable)
@@ -948,7 +948,7 @@ void SMESHGUI_MeshPatternDlg::displayPreview()
 
     // Create and display actor
     vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
-    aMapper->SetInput(aGrid);
+    aMapper->SetInputData(aGrid);
 
     myPreviewActor = SALOME_Actor::New();
     myPreviewActor->PickableOff();
index 1d3a35f..c4fabd9 100755 (executable)
@@ -1433,7 +1433,7 @@ void SMESHGUI_CuttingOfQuadsDlg::displayPreview()
 
   // Create and display actor
   vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
-  aMapper->SetInput(aGrid);
+  aMapper->SetInputData(aGrid);
 
   myPreviewActor = SALOME_Actor::New();
   myPreviewActor->PickableOff();
index e4010b8..2f9c038 100644 (file)
@@ -173,7 +173,7 @@ namespace SMESH
 
       // Create and display actor
       myMapper = vtkDataSetMapper::New();
-      myMapper->SetInput( aGrid );
+      myMapper->SetInputData( aGrid );
       aGrid->Delete();
 
       myPreviewActor = SALOME_Actor::New();
@@ -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 );
index bdb954b..056b895 100644 (file)
@@ -649,7 +649,7 @@ void SMESHGUI_Preferences_ScalarBarDlg::onSelectionChanged()
         if ( myScalarBarActor->GetLookupTable() ) {
           vtkLookupTable* aLookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
 
-          vtkFloatingPointType *range = aLookupTable->GetRange();
+          double *range = aLookupTable->GetRange();
           myMinEdit->setText( QString::number( range[0],'g',12 ) );
           myMaxEdit->setText( QString::number( range[1],'g',12 ) );
           myLogarithmicCheck->setChecked(aLookupTable->GetScale() == VTK_SCALE_LOG10);
@@ -657,7 +657,7 @@ void SMESHGUI_Preferences_ScalarBarDlg::onSelectionChanged()
         }
 
         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() );
@@ -666,7 +666,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() );
index 229d7f8..1bd966e 100644 (file)
@@ -961,7 +961,7 @@ namespace SMESH
     SUIT_ResourceMgr* mgr = SMESH::GetResourceMgr( theModule );
     if ( !mgr ) return;
     //
-    vtkFloatingPointType anRGBNd[3] = {1,1,1};
+    double anRGBNd[3] = {1,1,1};
     SMESH::GetColor( "SMESH", "numbering_node_color", anRGBNd[0], anRGBNd[1], anRGBNd[2], QColor( 255, 255, 255 ) );
     int aSizeNd = 10;
     SMESH::LabelFont aFamilyNd = SMESH::FntTimes;
@@ -980,7 +980,7 @@ namespace SMESH
       aSizeNd    = f.pointSize();
     }
     //
-    vtkFloatingPointType anRGBEl[3] = {0,1,0};
+    double anRGBEl[3] = {0,1,0};
     SMESH::GetColor( "SMESH", "numbering_elem_color", anRGBEl[0], anRGBEl[1], anRGBEl[2], QColor( 0, 255, 0 ) );
     int aSizeEl = 12;
     SMESH::LabelFont aFamilyEl = SMESH::FntTimes;
@@ -1323,21 +1323,21 @@ namespace SMESH
 
   //----------------------------------------------------------------------------
   // internal function
-  void ComputeBoundsParam( vtkFloatingPointType theBounds[6],
-                           vtkFloatingPointType theDirection[3],
-                           vtkFloatingPointType theMinPnt[3],
-                           vtkFloatingPointType& theMaxBoundPrj,
-                           vtkFloatingPointType& theMinBoundPrj )
+  void ComputeBoundsParam( double theBounds[6],
+                           double theDirection[3],
+                           double theMinPnt[3],
+                           double& theMaxBoundPrj,
+                           double& theMinBoundPrj )
   {
     //Enlarge bounds in order to avoid conflicts of precision
     for(int i = 0; i < 6; i += 2){
       static double EPS = 1.0E-3;
-      vtkFloatingPointType aDelta = (theBounds[i+1] - theBounds[i])*EPS;
+      double aDelta = (theBounds[i+1] - theBounds[i])*EPS;
       theBounds[i] -= aDelta;
       theBounds[i+1] += aDelta;
     }
 
-    vtkFloatingPointType aBoundPoints[8][3] = { {theBounds[0],theBounds[2],theBounds[4]},
+    double aBoundPoints[8][3] = { {theBounds[0],theBounds[2],theBounds[4]},
                                                 {theBounds[1],theBounds[2],theBounds[4]},
                                                 {theBounds[0],theBounds[3],theBounds[4]},
                                                 {theBounds[1],theBounds[3],theBounds[4]},
@@ -1350,7 +1350,7 @@ namespace SMESH
     theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]);
     theMinBoundPrj = theMaxBoundPrj;
     for(int i = 1; i < 8; i++){
-      vtkFloatingPointType aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]);
+      double aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]);
       if(theMaxBoundPrj < aTmp){
         theMaxBoundPrj = aTmp;
         aMaxId = i;
@@ -1359,43 +1359,43 @@ namespace SMESH
         theMinBoundPrj = aTmp;
       }
     }
-    vtkFloatingPointType *aMinPnt = aBoundPoints[aMaxId];
+    double *aMinPnt = aBoundPoints[aMaxId];
     theMinPnt[0] = aMinPnt[0];
     theMinPnt[1] = aMinPnt[1];
     theMinPnt[2] = aMinPnt[2];
   }
 
   // internal function
-  void DistanceToPosition( vtkFloatingPointType theBounds[6],
-                           vtkFloatingPointType theDirection[3],
-                           vtkFloatingPointType theDist,
-                           vtkFloatingPointType thePos[3] )
+  void DistanceToPosition( double theBounds[6],
+                           double theDirection[3],
+                           double theDist,
+                           double thePos[3] )
   {
-    vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
+    double aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
     ComputeBoundsParam(theBounds,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
-    vtkFloatingPointType aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist;
+    double aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist;
     thePos[0] = aMinPnt[0]-theDirection[0]*aLength;
     thePos[1] = aMinPnt[1]-theDirection[1]*aLength;
     thePos[2] = aMinPnt[2]-theDirection[2]*aLength;
   }
 
   // internal function (currently unused, left just in case)
-  void PositionToDistance( vtkFloatingPointType theBounds[6],
-                           vtkFloatingPointType theDirection[3],
-                           vtkFloatingPointType thePos[3],
-                           vtkFloatingPointType& theDist )
+  void PositionToDistance( double theBounds[6],
+                           double theDirection[3],
+                           double thePos[3],
+                           double& theDist )
   {
-    vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
+    double aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
     ComputeBoundsParam(theBounds,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
-    vtkFloatingPointType aPrj = vtkMath::Dot(theDirection,thePos);
+    double aPrj = vtkMath::Dot(theDirection,thePos);
     theDist = (aPrj-aMinBoundPrj)/(aMaxBoundPrj-aMinBoundPrj);
   }
 
   bool ComputeClippingPlaneParameters( std::list<vtkActor*> theActorList,
-                                       vtkFloatingPointType theNormal[3],
-                                       vtkFloatingPointType theDist,
-                                       vtkFloatingPointType theBounds[6],
-                                       vtkFloatingPointType theOrigin[3] )
+                                       double theNormal[3],
+                                       double theDist,
+                                       double theBounds[6],
+                                       double theOrigin[3] )
   {
     bool anIsOk = false;
     theBounds[0] = theBounds[2] = theBounds[4] = VTK_DOUBLE_MAX;
@@ -1404,7 +1404,7 @@ namespace SMESH
     for( ; anIter != theActorList.end(); anIter++ ) {
       if( vtkActor* aVTKActor = *anIter ) {
         if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) ) {
-          vtkFloatingPointType aBounds[6];
+          double aBounds[6];
           anActor->GetUnstructuredGrid()->GetBounds( aBounds );
           theBounds[0] = std::min( theBounds[0], aBounds[0] );
           theBounds[1] = std::max( theBounds[1], aBounds[1] );
index b226f77..e571f30 100644 (file)
@@ -202,10 +202,10 @@ SMESHGUI_EXPORT
   //----------------------------------------------------------------------------
 SMESHGUI_EXPORT
   bool ComputeClippingPlaneParameters( std::list<vtkActor*> theActorList,
-                                       vtkFloatingPointType theNormal[3],
-                                       vtkFloatingPointType theDist,
-                                       vtkFloatingPointType theBounds[6],
-                                       vtkFloatingPointType theOrigin[3] );
+                                       double theNormal[3],
+                                       double theDist,
+                                       double theBounds[6],
+                                       double theOrigin[3] );
  SMESHGUI_EXPORT
    void RemoveVisualObjectWithActors( const char* theEntry, bool fromAllViews = false );
 };