ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-13 02:00:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

Merge from BR_PORTING_VTK6 01/03/2013

Browse Source
This commit is contained in:
vsr 2013-03-01 13:13:25 +00:00
parent 88b3dbe23b
commit ae29d46509
35 changed files with 355 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
src/OBJECT/SMESH_Actor.cxx
View 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 );

66
src/OBJECT/SMESH_Actor.h
View File

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

76
src/OBJECT/SMESH_ActorDef.h
View File

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

22
src/OBJECT/SMESH_ActorUtils.cxx
View File

@ -55,12 +55,12 @@
namespace SMESH
{
vtkFloatingPointType
double
GetFloat( const QString& theValue,
vtkFloatingPointType theDefault )
double theDefault )
{
int pos = theValue.indexOf( ":" );
vtkFloatingPointType val = theDefault;
double val = theDefault;
if( pos>=0 )
{
QString name = theValue.right( theValue.length()-pos-1 ),
@ -71,15 +71,15 @@ namespace SMESH
return val;
}
vtkFloatingPointType
double
GetFloat( const QString& theValue,
const QString& theSection,
vtkFloatingPointType theDefault )
double theDefault )
{
vtkFloatingPointType val = theDefault;
double val = theDefault;
SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
if( mgr )
val = (vtkFloatingPointType) mgr->doubleValue( theSection, theValue, theDefault );
val = (double) mgr->doubleValue( theSection, theValue, theDefault );
return val;
}
@ -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 );

14
src/OBJECT/SMESH_ActorUtils.h
View File

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

12
src/OBJECT/SMESH_CellLabelActor.cxx
View 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);

2
src/OBJECT/SMESH_CellLabelActor.h
View File

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

80
src/OBJECT/SMESH_DeviceActor.cxx
View 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
}
vtkFloatingPointType
double
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();
}

30
src/OBJECT/SMESH_DeviceActor.h
View File

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

6
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

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

19
src/OBJECT/SMESH_FaceOrientationFilter.cxx
View 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();
}

8
src/OBJECT/SMESH_FaceOrientationFilter.h
View File

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

10
src/OBJECT/SMESH_NodeLabelActor.cxx
View 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();
}

2
src/OBJECT/SMESH_NodeLabelActor.h
View File

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

4
src/OBJECT/SMESH_ScalarBarActor.cxx
View 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);

5
src/SMDS/SMDS_UnstructuredGrid.cxx
View 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

5
src/SMDS/SMDS_UnstructuredGrid.hxx
View 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

14
src/SMESHGUI/SMESHGUI.cxx
View File

@ -1256,7 +1256,7 @@
return;
}
case 1132: {
vtkFloatingPointType color[3];
double color[3];
QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
QColor orientationColor, outlineColor, volumeColor;
int deltaF = 0, deltaV = 0;
@ -1264,8 +1264,8 @@
int ballSize = 1;
int edgeWidth = 1;
int outlineWidth = 1;
vtkFloatingPointType shrinkCoef = 0.0;
vtkFloatingPointType orientationScale = 0.0;
double shrinkCoef = 0.0;
double orientationScale = 0.0;
bool orientation3d = false;
VTK::MarkerType markerType = VTK::MT_NONE;
VTK::MarkerScale markerScale = VTK::MS_NONE;
@ -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();

2
src/SMESHGUI/SMESHGUI.h
View File

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

8
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
View 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();

10
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

@ -121,7 +121,7 @@ namespace SMESH
vtkUnstructuredGrid* myGrid;
//vtkProperty* myBackProp, *myProp;
//vtkFloatingPointType myRGB[3], myBackRGB[3];
//double myRGB[3], myBackRGB[3];
SALOME_Actor* myFaceOrientation;
vtkPolyDataMapper* myFaceOrientationDataMapper;
@ -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();

79
src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
View 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] );

2
src/SMESHGUI/SMESHGUI_ClippingDlg.h
View File

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

4
src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
View File

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

4
src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
View File

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

6
src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
View 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);

4
src/SMESHGUI/SMESHGUI_Measurements.cxx
View 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();

10
src/SMESHGUI/SMESHGUI_MergeDlg.cxx
View 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 {

6
src/SMESHGUI/SMESHGUI_MeshEditPreview.cxx
View 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] );

2
src/SMESHGUI/SMESHGUI_MeshPatternDlg.cxx
View File

@ -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();

2
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
View File

@ -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();

6
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
View 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 );

6
src/SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.cxx
View 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() );

56
src/SMESHGUI/SMESHGUI_VTKUtils.cxx
View File

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

8
src/SMESHGUI/SMESHGUI_VTKUtils.h
View File

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