if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1);
- vtkFloatingPointType aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
- vtkFloatingPointType aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10);
- vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
- vtkFloatingPointType aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1);
+ double aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
+ double aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10);
+ double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
+ double aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1);
SMESH::LabelFont aFamilyNd = SMESH::FntTimes;
bool aBoldNd = true;
aShadowNd = f.overline();
aSizeNd = f.pointSize();
}
- vtkFloatingPointType anRGBNd[3] = {1,1,1};
+ double anRGBNd[3] = {1,1,1};
SMESH::GetColor( "SMESH", "numbering_node_color", anRGBNd[0], anRGBNd[1], anRGBNd[2], QColor( 255, 255, 255 ) );
SMESH::LabelFont aFamilyEl = SMESH::FntTimes;
aShadowEl = f.overline();
aSizeEl = f.pointSize();
}
- vtkFloatingPointType anRGBEl[3] = {0,1,0};
+ double anRGBEl[3] = {0,1,0};
SMESH::GetColor( "SMESH", "numbering_elem_color", anRGBEl[0], anRGBEl[1], anRGBEl[2], QColor( 0, 255, 0 ) );
vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
//Definition 2D and 3D devices of the actor
//-----------------------------------------
- vtkFloatingPointType anRGB[3] = {1,1,1};
+ double anRGB[3] = {1,1,1};
mySurfaceProp = vtkProperty::New();
QColor ffc, bfc;
int delta;
void SMESH_ActorDef::SetPointsFontProperties( SMESH::LabelFont theFamily, int theSize,
bool theBold, bool theItalic, bool theShadow,
- vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b )
-{
+ double r, double g, double b )
+{
if(myNodeActor) {
myNodeActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b );
SetRepresentation( GetRepresentation() );
void SMESH_ActorDef::SetCellsFontProperties( SMESH::LabelFont theFamily, int theSize,
bool theBold, bool theItalic, bool theShadow,
- vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b )
-{
+ double r, double g, double b )
+{
if(my3DActor) {
my3DActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b );
SetRepresentation( GetRepresentation() );
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();
}
my2DExtActor->GetMapper()->SetLookupTable(myLookupTable);
my3DActor->GetMapper()->SetLookupTable(myLookupTable);
my3DExtActor->GetMapper()->SetLookupTable(myLookupTable);
-
- vtkFloatingPointType aFactor, aUnits;
+
+ double aFactor, aUnits;
my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
my2DExtActor->SetPolygonOffsetParameters(aFactor,aUnits*0.5);
}
-vtkFloatingPointType* SMESH_ActorDef::GetBounds(){
+double* SMESH_ActorDef::GetBounds(){
return myNodeActor->GetBounds();
}
bool SMESH_ActorDef::IsInfinitive(){
vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid();
- aDataSet->Update();
myIsInfinite = aDataSet->GetNumberOfCells() == 0 ||
( aDataSet->GetNumberOfCells() == 1 &&
aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX );
Modified();
}
-vtkFloatingPointType SMESH_ActorDef::GetShrinkFactor(){
+double SMESH_ActorDef::GetShrinkFactor(){
return myBaseActor->GetShrinkFactor();
}
-void SMESH_ActorDef::SetShrinkFactor(vtkFloatingPointType theValue){
+void SMESH_ActorDef::SetShrinkFactor(double theValue){
myBaseActor->SetShrinkFactor(theValue);
my1DActor->SetShrinkFactor(theValue);
return myPickableActor->GetNodeObjId(theVtkID);
}
-vtkFloatingPointType* SMESH_ActorDef::GetNodeCoord(int theObjID){
+double* SMESH_ActorDef::GetNodeCoord(int theObjID){
return myPickableActor->GetNodeCoord(theObjID);
}
}
-static void GetColor(vtkProperty *theProperty, vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
- vtkFloatingPointType* aColor = theProperty->GetColor();
+static void GetColor(vtkProperty *theProperty, double& r,double& g,double& b){
+ double* aColor = theProperty->GetColor();
r = aColor[0];
g = aColor[1];
b = aColor[2];
}
-void SMESH_ActorDef::SetOpacity(vtkFloatingPointType theValue){
+void SMESH_ActorDef::SetOpacity(double theValue){
mySurfaceProp->SetOpacity(theValue);
myBackSurfaceProp->SetOpacity(theValue);
myNormalVProp->SetOpacity(theValue);
}
-vtkFloatingPointType SMESH_ActorDef::GetOpacity(){
+double SMESH_ActorDef::GetOpacity(){
return mySurfaceProp->GetOpacity();
}
-void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta){
+void SMESH_ActorDef::SetSufaceColor(double r,double g,double b, int delta){
mySurfaceProp->SetColor(r,g,b);
my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
Modified();
}
-void SMESH_ActorDef::GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta){
+void SMESH_ActorDef::GetSufaceColor(double& r,double& g,double& b, int& delta){
::GetColor(mySurfaceProp,r,g,b);
delta = myDeltaBrightness;
}
-void SMESH_ActorDef::SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta){
+void SMESH_ActorDef::SetVolumeColor(double r,double g,double b, int delta){
myNormalVProp->SetColor(r,g,b);
my3DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
Modified();
}
-void SMESH_ActorDef::GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta){
+void SMESH_ActorDef::GetVolumeColor(double& r,double& g,double& b, int& delta){
::GetColor(myNormalVProp,r,g,b);
delta = myDeltaVBrightness;
}
-void SMESH_ActorDef::SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+void SMESH_ActorDef::SetEdgeColor(double r,double g,double b){
myEdgeProp->SetColor(r,g,b);
my1DProp->SetColor(r,g,b);
my1DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
Modified();
}
-void SMESH_ActorDef::GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetEdgeColor(double& r,double& g,double& b){
::GetColor(myEdgeProp,r,g,b);
}
-void SMESH_ActorDef::SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+void SMESH_ActorDef::SetOutlineColor(double r,double g,double b){
myOutLineProp->SetColor(r,g,b);
Modified();
}
-void SMESH_ActorDef::GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetOutlineColor(double& r,double& g,double& b){
::GetColor(myOutLineProp,r,g,b);
}
-void SMESH_ActorDef::SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+void SMESH_ActorDef::SetNodeColor(double r,double g,double b){
myNodeProp->SetColor(r,g,b);
myNodeExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
Modified();
}
-void SMESH_ActorDef::GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetNodeColor(double& r,double& g,double& b){
::GetColor(myNodeProp,r,g,b);
}
-void SMESH_ActorDef::Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+void SMESH_ActorDef::Set0DColor(double r,double g,double b){
my0DProp->SetColor(r,g,b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_0DElement )
Modified();
}
-void SMESH_ActorDef::Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::Get0DColor(double& r,double& g,double& b){
::GetColor(my0DProp,r,g,b);
}
-void SMESH_ActorDef::SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+void SMESH_ActorDef::SetBallColor(double r,double g,double b){
myBallProp->SetColor(r,g,b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_Ball )
Modified();
}
-void SMESH_ActorDef::GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetBallColor(double& r,double& g,double& b){
::GetColor(myBallProp,r,g,b);
}
-void SMESH_ActorDef::SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+void SMESH_ActorDef::SetHighlightColor(double r,double g,double b){
myHighlightProp->SetColor(r,g,b);
myBallHighlightProp->SetColor(r,g,b);
Modified();
}
-void SMESH_ActorDef::GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetHighlightColor(double& r,double& g,double& b){
::GetColor(myHighlightProp,r,g,b);
}
-void SMESH_ActorDef::SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){
+void SMESH_ActorDef::SetPreHighlightColor(double r,double g,double b){
myPreselectProp->SetColor(r,g,b);
myBallPreselectProp->SetColor(r,g,b);
Modified();
}
-void SMESH_ActorDef::GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){
+void SMESH_ActorDef::GetPreHighlightColor(double& r,double& g,double& b){
::GetColor(myPreselectProp,r,g,b);
}
-vtkFloatingPointType SMESH_ActorDef::GetLineWidth(){
+double SMESH_ActorDef::GetLineWidth(){
return myEdgeProp->GetLineWidth();
}
-void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){
+void SMESH_ActorDef::SetLineWidth(double theVal){
myEdgeProp->SetLineWidth(theVal);
my1DProp->SetLineWidth(theVal + aLineWidthInc);
Modified();
}
-vtkFloatingPointType SMESH_ActorDef::GetOutlineWidth()
+double SMESH_ActorDef::GetOutlineWidth()
{
return myOutLineProp->GetLineWidth();
}
-void SMESH_ActorDef::SetOutlineWidth(vtkFloatingPointType theVal)
+void SMESH_ActorDef::SetOutlineWidth(double theVal)
{
myOutLineProp->SetLineWidth(theVal);
Modified();
}
-void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){
+void SMESH_ActorDef::Set0DSize(double theVal){
my0DProp->SetPointSize(theVal);
myHighlightProp->SetPointSize(theVal);
myPreselectProp->SetPointSize(theVal);
Modified();
}
-vtkFloatingPointType SMESH_ActorDef::Get0DSize(){
+double SMESH_ActorDef::Get0DSize(){
return my0DProp->GetPointSize();
}
-void SMESH_ActorDef::SetBallSize(vtkFloatingPointType theVal){
+void SMESH_ActorDef::SetBallSize(double theVal){
myBallProp->SetPointSize(theVal);
myBallHighlightProp->SetPointSize(theVal);
myBallPreselectProp->SetPointSize(theVal);
Modified();
}
-vtkFloatingPointType SMESH_ActorDef::GetBallSize(){
+double SMESH_ActorDef::GetBallSize(){
return myBallProp->GetPointSize();
}
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 );
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};
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;
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;
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;
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);
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;}
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();
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();
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 ),
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;
}
{
vtkXMLUnstructuredGridWriter* aWriter = vtkXMLUnstructuredGridWriter::New();
aWriter->SetFileName(theFileName);
- aWriter->SetInput(theGrid);
+ aWriter->SetInputData(theGrid);
aWriter->SetDataModeToAscii();
if(theGrid->GetNumberOfCells()){
aWriter->Write();
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 );
};
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
void
GetColor( const QString& theSect,
const QString& theName,
- vtkFloatingPointType&,
- vtkFloatingPointType&,
- vtkFloatingPointType&,
+ double&,
+ double&,
+ double&,
const QColor& = QColor() );
SMESHOBJECT_EXPORT
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();
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:
anArray->SetValue(anId,aSMDSId);
}
aDataSet->GetCellData()->SetScalars(anArray);
- myCellCenters->SetInput(aDataSet);
+ myCellCenters->SetInputData(aDataSet);
myCellsLabels->SetVisibility(GetVisibility());
}else{
myCellsLabels->SetVisibility(false);
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();
// 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);
{
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);
//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();
theLookupTable->SetNumberOfTableValues(theScalarBarActor->GetMaximumNumberOfColors());
theLookupTable->Build();
- myMergeFilter->SetScalars(aDataSet);
+ myMergeFilter->SetScalarsData(aDataSet);
aDataSet->Delete();
}
GetMapper()->SetScalarVisibility(anIsInitialized);
theLookupTable->SetRange(aScalars->GetRange());
theLookupTable->Build();
- myMergeFilter->SetScalars(aDataSet);
+ myMergeFilter->SetScalarsData(aDataSet);
aDataSet->Delete();
}
else if (MultiConnection2D* aMultiConnection2D = dynamic_cast<MultiConnection2D*>(theFunctor.get())){
theLookupTable->SetRange(aScalars->GetRange());
theLookupTable->Build();
- myMergeFilter->SetScalars(aDataSet);
+ myMergeFilter->SetScalarsData(aDataSet);
aDataSet->Delete();
}
}
::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;
}
}
::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();
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()
{
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;
}
}
-vtkFloatingPointType
+double
SMESH_DeviceActor
::GetShrinkFactor()
{
void
SMESH_DeviceActor
-::SetShrinkFactor(vtkFloatingPointType theValue)
+::SetShrinkFactor(double theValue)
{
theValue = theValue > 0.1? theValue: 0.8;
myShrinkFilter->SetShrinkFactor(theValue);
::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);
void
SMESH_DeviceActor
-::SetPolygonOffsetParameters(vtkFloatingPointType factor,
- vtkFloatingPointType units)
+::SetPolygonOffsetParameters(double factor,
+ double units)
{
myPolygonOffsetFactor = factor;
myPolygonOffsetUnits = units;
/*!
* 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();
}
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);
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();
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;}
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;
vtkIdList *cellPts;
vtkCell *cell;
int numCellPts;
- vtkFloatingPointType *x;
- vtkFloatingPointType multiplier;
+ double *x;
+ double multiplier;
vtkPoints *newPts;
vtkIdList *newCellPts;
vtkPointData *pd = input->GetPointData();
// To extract boundary cells, we have to create supplemental information
if ( this->ExtractBoundaryCells )
{
- vtkFloatingPointType val;
+ double val;
newScalars = vtkFloatArray::New();
newScalars->SetNumberOfValues(numPts);
#define PI 3.14159265359
-vtkCxxRevisionMacro(SMESH_FaceOrientationFilter, "$Revision$");
vtkStandardNewMacro(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();
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()
myBaseGlyph->Delete();
}
-void SMESH_FaceOrientationFilter::SetOrientationScale( vtkFloatingPointType theScale )
+void SMESH_FaceOrientationFilter::SetOrientationScale( double theScale )
{
myOrientationScale = theScale;
Modified();
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();
}
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; }
private:
bool my3dVectors;
- vtkFloatingPointType myOrientationScale;
+ double myOrientationScale;
vtkPolyData* myArrowPolyData;
vtkPolyData* myFacePolyData;
VTKViewer_CellCenters* myFaceCenters;
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();
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:
}
aDataSet->GetPointData()->SetScalars( anArray );
- myPtsMaskPoints->SetInput( aDataSet );
+ myPtsMaskPoints->SetInputData( aDataSet );
myPointLabels->SetVisibility( GetVisibility() );
anArray->Delete();
}
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();
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()->
// 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);
MESSAGE("vtkUnstructuredGrid::GetMTime: " << mtime);
return mtime;
}
-
+// OUV_PORTING_VTK6: seems to be useless
+/*
void SMDS_UnstructuredGrid::Update()
{
MESSAGE("SMDS_UnstructuredGrid::Update");
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
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
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;
ip->setParameter(entry, param, modeStr.toLatin1().data());
// Colors
- vtkFloatingPointType r, g, b;
+ double r, g, b;
int delta;
aSmeshActor->GetSufaceColor(r, g, b, delta);
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;
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();
SMESHGUI_ClippingPlaneInfoMap myClippingPlaneInfoMap;
vtkSmartPointer<vtkCallbackCommand> myEventCallbackCommand;
- vtkFloatingPointType myPriority;
+ double myPriority;
};
#endif // SMESHGUI_H
// 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] );
// 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();
vtkUnstructuredGrid* myGrid;
//vtkProperty* myBackProp, *myProp;
- //vtkFloatingPointType myRGB[3], myBackRGB[3];
+ //double myRGB[3], myBackRGB[3];
SALOME_Actor* myFaceOrientation;
vtkPolyDataMapper* myFaceOrientationDataMapper;
// Create and display actor
myMapper = vtkDataSetMapper::New();
- myMapper->SetInput(myGrid);
+ myMapper->SetInputData(myGrid);
myPreviewActor = SALOME_Actor::New();
myPreviewActor->PickableOff();
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 );
// 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();
myPlaneSource->SetOrigin(theOrientedPlane->myPlaneSource->GetOrigin());
myPlaneSource->SetPoint1(theOrientedPlane->myPlaneSource->GetPoint1());
myPlaneSource->SetPoint2(theOrientedPlane->myPlaneSource->GetPoint2());
+ myPlaneSource->Update();
}
SMESH::OrientedPlane::OrientedPlane(SVTK_ViewWindow* theViewWindow):
// Create and display actor
myMapper = vtkDataSetMapper::New();
- myMapper->SetInput(myPlaneSource->GetOutput());
+ myMapper->SetInputConnection(myPlaneSource->GetOutputPort());
myActor = SALOME_Actor::New();
myActor->VisibilityOff();
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]);
SVTK_ViewWindow* theViewWindow,
SMESH::Orientation theOrientation,
double theDistance,
- const vtkFloatingPointType theAngle[2])
+ const double theAngle[2])
{
SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New(theViewWindow);
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];
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() ) {
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);
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++ )
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];
SMESH::TActorList anActorList = aPlaneData.ActorList;
- vtkFloatingPointType aBounds[6];
- vtkFloatingPointType anOrigin[3];
+ double aBounds[6];
+ double anOrigin[3];
bool anIsOk = SMESH::ComputeClippingPlaneParameters( anActorList,
aNormal,
getDistance(),
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);
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())
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] );
SVTK_ViewWindow* theViewWindow,
SMESH::Orientation theOrientation,
double theDistance,
- const vtkFloatingPointType theAngle[2]);
+ const double theAngle[2]);
protected:
void keyPressEvent( QKeyEvent* );
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 );
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 );
// Create and display actor
myMapper = vtkDataSetMapper::New();
- myMapper->SetInput( myGrid );
+ myMapper->SetInputData( myGrid );
myPreviewActor = SALOME_Actor::New();
myPreviewActor->PickableOff();
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);
aCells->Delete();
// create actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
- aMapper->SetInput( aGrid );
+ aMapper->SetInputData( aGrid );
aGrid->Delete();
myPreview = SALOME_Actor::New();
myPreview->PickableOff();
aCells->Delete();
// create actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
- aMapper->SetInput( aGrid );
+ aMapper->SetInputData( aGrid );
aGrid->Delete();
myPreview = SALOME_Actor::New();
myPreview->PickableOff();
// Create and display actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
- aMapper->SetInput( myIdGrid );
+ aMapper->SetInputData( myIdGrid );
myIdActor = SALOME_Actor::New();
myIdActor->SetInfinitive(true);
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
anArray->SetValue( i, myIDs[i] );
aDataSet->GetPointData()->SetScalars( anArray );
anArray->Delete();
- myPtsMaskPoints->SetInput( aDataSet );
+ myPtsMaskPoints->SetInputData( aDataSet );
myPointLabels->SetVisibility( theIsActorVisible );
}
else {
// 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] );
// Create and display actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
- aMapper->SetInput(aGrid);
+ aMapper->SetInputData(aGrid);
myPreviewActor = SALOME_Actor::New();
myPreviewActor->PickableOff();
// Create and display actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
- aMapper->SetInput(aGrid);
+ aMapper->SetInputData(aGrid);
myPreviewActor = SALOME_Actor::New();
myPreviewActor->PickableOff();
// Create and display actor
myMapper = vtkDataSetMapper::New();
- myMapper->SetInput( aGrid );
+ myMapper->SetInputData( aGrid );
aGrid->Delete();
myPreviewActor = SALOME_Actor::New();
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 );
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);
}
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() );
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() );
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;
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;
//----------------------------------------------------------------------------
// 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]},
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;
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;
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] );
//----------------------------------------------------------------------------
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 );
};
