ForkMaster/geom
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/geom.git synced 2024-11-12 00:29:18 +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:10:52 +00:00
parent 2488be88d9
commit cb06d0db39
20 changed files with 193 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/OBJECT/GEOM_Actor.cxx
View File

@ -119,7 +119,7 @@ GEOM_Actor::GEOM_Actor():
MESSAGE (this<< " GEOM_Actor::GEOM_Actor");
#endif
myPolyDataMapper->SetInput(myAppendFilter->GetOutput());
myPolyDataMapper->SetInputConnection(myAppendFilter->GetOutputPort());
vtkProperty* aProperty;
myHighlightProp->SetAmbient(0.5);
@ -132,48 +132,48 @@ GEOM_Actor::GEOM_Actor():
myHighlightProp->SetPointSize(SALOME_POINT_SIZE);
myHighlightActor->SetProperty(myHighlightProp.GetPointer());
this->myHighlightActor->SetInput(myAppendFilter->GetOutput(),false);
this->myHighlightActor->SetInput(myAppendFilter->GetOutputPort(),false);
myPreHighlightProp->SetColor(0,1,1);
myPreHighlightProp->SetPointSize(SALOME_POINT_SIZE+2);
myPreHighlightProp->SetLineWidth(SALOME_LINE_WIDTH+1);
myPreHighlightProp->SetRepresentationToWireframe();
myAppendFilter->AddInput(myVertexSource->GetOutput());
myVertexActor->SetInput(myVertexSource->GetOutput(),false);
myAppendFilter->AddInputConnection(myVertexSource->GetOutputPort());
myVertexActor->SetInput(myVertexSource->GetOutputPort(),false);
aProperty = myVertexActor->GetProperty();
aProperty->SetRepresentation(VTK_POINTS);
aProperty->SetPointSize(3);
aProperty->SetColor(1, 1, 0);
myAppendFilter->AddInput(myIsolatedEdgeSource->GetOutput());
myIsolatedEdgeActor->SetInput(myIsolatedEdgeSource->GetOutput(),false);
myAppendFilter->AddInputConnection(myIsolatedEdgeSource->GetOutputPort());
myIsolatedEdgeActor->SetInput(myIsolatedEdgeSource->GetOutputPort(),false);
aProperty = myIsolatedEdgeActor->GetProperty();
aProperty->SetRepresentation(VTK_WIREFRAME);
myIsolatedEdgeColor[0] = 1; myIsolatedEdgeColor[1] = 0; myIsolatedEdgeColor[2] = 0;
aProperty->SetColor(myIsolatedEdgeColor[0], myIsolatedEdgeColor[1], myIsolatedEdgeColor[2]);
myAppendFilter->AddInput(myOneFaceEdgeSource->GetOutput());
myOneFaceEdgeActor->SetInput(myOneFaceEdgeSource->GetOutput(),false);
myAppendFilter->AddInputConnection(myOneFaceEdgeSource->GetOutputPort());
myOneFaceEdgeActor->SetInput(myOneFaceEdgeSource->GetOutputPort(),false);
aProperty = myOneFaceEdgeActor->GetProperty();
aProperty->SetRepresentation(VTK_WIREFRAME);
myOneFaceEdgeColor[0] = 0; myOneFaceEdgeColor[1] = 1; myOneFaceEdgeColor[2] = 0;
aProperty->SetColor(myOneFaceEdgeColor[0], myOneFaceEdgeColor[1], myOneFaceEdgeColor[2]);
myAppendFilter->AddInput(mySharedEdgeSource->GetOutput());
mySharedEdgeActor->SetInput(mySharedEdgeSource->GetOutput(),false);
myAppendFilter->AddInputConnection(mySharedEdgeSource->GetOutputPort());
mySharedEdgeActor->SetInput(mySharedEdgeSource->GetOutputPort(),false);
aProperty = mySharedEdgeActor->GetProperty();
aProperty->SetRepresentation(VTK_WIREFRAME);
mySharedEdgeColor[0] = 1; mySharedEdgeColor[1] = 1; mySharedEdgeColor[2] = 0;
aProperty->SetColor(mySharedEdgeColor[0], mySharedEdgeColor[1], mySharedEdgeColor[2]);
myAppendFilter->AddInput(myWireframeFaceSource->GetOutput());
myWireframeFaceActor->SetInput(myWireframeFaceSource->GetOutput(),false);
myAppendFilter->AddInputConnection(myWireframeFaceSource->GetOutputPort());
myWireframeFaceActor->SetInput(myWireframeFaceSource->GetOutputPort(),false);
aProperty = myWireframeFaceActor->GetProperty();
aProperty->SetRepresentation(VTK_WIREFRAME);
aProperty->SetColor(0.5, 0.5, 0.5);
myShadingFaceActor->SetInput(myShadingFaceSource->GetOutput(),true);
myShadingFaceActor->SetInput(myShadingFaceSource->GetOutputPort(),true);
myShadingFaceProp->SetRepresentation(VTKViewer::Representation::Surface);
myShadingFaceProp->SetInterpolationToGouraud();
@ -219,7 +219,7 @@ New()
void Write(vtkPolyData* theDataSet, const char* theFileName){
vtkPolyDataWriter* aWriter = vtkPolyDataWriter::New();
MESSAGE ("Write - "<<theFileName<<"' : "<<theDataSet->GetNumberOfPoints()<<"; "<<theDataSet->GetNumberOfCells());
aWriter->SetInput(theDataSet);
aWriter->SetInputData(theDataSet);
aWriter->SetFileName(theFileName);
//aWriter->Write();
aWriter->Delete();
@ -601,10 +601,10 @@ void GEOM_Actor::Render(vtkRenderer *ren, vtkMapper *theMapper)
/* if(myShape.ShapeType() == TopAbs_VERTEX) {
if(ren){
//The parameter determine size of vertex actor relate to diagonal of RendererWindow
static vtkFloatingPointType delta = 0.01;
vtkFloatingPointType X1 = -1, Y1 = -1, Z1 = 0;
static double delta = 0.01;
double X1 = -1, Y1 = -1, Z1 = 0;
ren->ViewToWorld(X1,Y1,Z1);
vtkFloatingPointType X2 = +1, Y2 = +1, Z2 = 0;
double X2 = +1, Y2 = +1, Z2 = 0;
ren->ViewToWorld(X2,Y2,Z2);
Z2 = sqrt((X2-X1)*(X2-X1) + (Y2-Y1)*(Y2-Y1) + (Z2-Z1)*(Z2-Z1));
this->SetScale(Z2*delta);
@ -696,7 +696,7 @@ void GEOM_Actor::highlight(bool highlight)
SALOME_Actor::highlight(highlight);
}
void GEOM_Actor::SetOpacity(vtkFloatingPointType opa)
void GEOM_Actor::SetOpacity(double opa)
{
// enk:tested OK
myShadingFaceProp->SetOpacity(opa);
@ -706,13 +706,13 @@ void GEOM_Actor::SetOpacity(vtkFloatingPointType opa)
myVertexActor->GetProperty()->SetOpacity(opa);
}
vtkFloatingPointType GEOM_Actor::GetOpacity()
double GEOM_Actor::GetOpacity()
{
// enk:tested OK
return myShadingFaceProp->GetOpacity();
}
void GEOM_Actor::SetColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b)
void GEOM_Actor::SetColor(double r,double g,double b)
{
// set the same color to all sub-actors:
// - points
@ -728,9 +728,9 @@ void GEOM_Actor::SetColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloat
myShadingBackFaceProp->SetColor(r,g,b); // back face shading color
}
void GEOM_Actor::GetColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b)
void GEOM_Actor::GetColor(double& r,double& g,double& b)
{
vtkFloatingPointType aRGB[3];
double aRGB[3];
myShadingFaceProp->GetColor(aRGB);
r = aRGB[0];
g = aRGB[1];
@ -741,7 +741,7 @@ void GEOM_Actor::GetColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFlo
\brief Set color of points
Points actor is shown in Wireframe mode only, see SetVisibility()
*/
void GEOM_Actor::SetPointColor(vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b)
void GEOM_Actor::SetPointColor(double r, double g, double b)
{
myVertexActor->GetProperty()->SetColor(r, g, b);
}
@ -751,7 +751,7 @@ void GEOM_Actor::SetPointColor(vtkFloatingPointType r, vtkFloatingPointType g,
This actor is shown in all display mode, see SetVisibility()
TODO: check - this color seems to be used not only for standalone edges
*/
void GEOM_Actor::SetIsolatedEdgeColor(vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b)
void GEOM_Actor::SetIsolatedEdgeColor(double r, double g, double b)
{
myIsolatedEdgeColor[0] = r; myIsolatedEdgeColor[1] = g; myIsolatedEdgeColor[2] = b;
if ( myDisplayMode != (int)eShadingWithEdges )
@ -763,7 +763,7 @@ void GEOM_Actor::SetIsolatedEdgeColor(vtkFloatingPointType r, vtkFloatingPointTy
This actor is shown only in wireframe and shading+edges display modes, see SetVisibility()
TODO: check - this seems to be not working currently
*/
void GEOM_Actor::SetSharedEdgeColor(vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b)
void GEOM_Actor::SetSharedEdgeColor(double r, double g, double b)
{
mySharedEdgeColor[0] = r; mySharedEdgeColor[1] = g; mySharedEdgeColor[2] = b;
if ( myDisplayMode != (int)eShadingWithEdges )
@ -775,7 +775,7 @@ void GEOM_Actor::SetSharedEdgeColor(vtkFloatingPointType r, vtkFloatingPointType
This actor is shown only in wireframe and shading+edges display modes, see SetVisibility()
TODO: this color should be used not only for faces
*/
void GEOM_Actor::SetFreeEdgeColor(vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b)
void GEOM_Actor::SetFreeEdgeColor(double r, double g, double b)
{
myOneFaceEdgeColor[0] = r; myOneFaceEdgeColor[1] = g; myOneFaceEdgeColor[2] = b;
if ( myDisplayMode != (int)eShadingWithEdges )
@ -786,7 +786,7 @@ void GEOM_Actor::SetFreeEdgeColor(vtkFloatingPointType r, vtkFloatingPointType g
\brief Set color of iso-lines
This actor is shown only in wireframe display mode, see SetVisibility()
*/
void GEOM_Actor::SetIsosColor(vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b)
void GEOM_Actor::SetIsosColor(double r, double g, double b)
{
myWireframeFaceActor->GetProperty()->SetColor(r, g, b);
}
@ -1072,7 +1072,7 @@ void GEOM_Actor::GetMatrix(vtkCamera* theCam, vtkMatrix4x4 *result)
this->Transform->Pop();
}
void GEOM_Actor::SetEdgesInShadingColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b)
void GEOM_Actor::SetEdgesInShadingColor(double r,double g,double b)
{
myEdgesInShadingColor[0] = r;
myEdgesInShadingColor[1] = g;

30
src/OBJECT/GEOM_Actor.h
View File

@ -121,24 +121,24 @@ public:
void ShallowCopy(vtkProp *prop);
// Opacity
void SetOpacity(vtkFloatingPointType opa);
vtkFloatingPointType GetOpacity();
void SetOpacity(double opa);
double GetOpacity();
// Color (same to all sub-actors/display modes)
void SetColor(vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b);
void GetColor(vtkFloatingPointType& r, vtkFloatingPointType& g, vtkFloatingPointType& b);
void SetColor(double r, double g, double b);
void GetColor(double& r, double& g, double& b);
// Color of points
void SetPointColor(vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b);
void SetPointColor(double r, double g, double b);
// Color of standalone edges, wires, vectors
void SetIsolatedEdgeColor(vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b);
void SetIsolatedEdgeColor(double r, double g, double b);
// Color of shared edges
void SetSharedEdgeColor(vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b);
void SetSharedEdgeColor(double r, double g, double b);
// Color of free edges
void SetFreeEdgeColor(vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b);
void SetFreeEdgeColor(double r, double g, double b);
// Color of edges in shading+edges display mode
void SetEdgesInShadingColor(vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b);
void SetEdgesInShadingColor(double r, double g, double b);
// Color of iso-lines
void SetIsosColor(vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b);
void SetIsosColor(double r, double g, double b);
// Material
@ -263,11 +263,11 @@ private:
GEOM_Actor(const GEOM_Actor&);
void operator=(const GEOM_Actor&);
vtkFloatingPointType myEdgesInWireframeColor[3];
vtkFloatingPointType myEdgesInShadingColor[3];
vtkFloatingPointType myIsolatedEdgeColor[3];
vtkFloatingPointType mySharedEdgeColor[3];
vtkFloatingPointType myOneFaceEdgeColor[3];
double myEdgesInWireframeColor[3];
double myEdgesInShadingColor[3];
double myIsolatedEdgeColor[3];
double mySharedEdgeColor[3];
double myOneFaceEdgeColor[3];
};
#endif //GEOM_ACTOR_H

14
src/OBJECT/GEOM_DeviceActor.cxx
View File

@ -38,8 +38,8 @@ GEOM_DeviceActor::GEOM_DeviceActor():
myPolyDataNormals(vtkPolyDataNormals::New(),true),
myActor(VTKViewer_Actor::New(),true)
{
myStripper->SetInput(myPolyDataNormals->GetOutput());
myPolyDataMapper->SetInput(myStripper->GetOutput());
myStripper->SetInputConnection(myPolyDataNormals->GetOutputPort());
myPolyDataMapper->SetInputConnection(myStripper->GetOutputPort());
myActor->SetMapper(myPolyDataMapper.Get());
myActor->PickableOff();
@ -51,12 +51,16 @@ GEOM_DeviceActor::~GEOM_DeviceActor()
void
GEOM_DeviceActor::
SetInput(vtkPolyData* thePolyData, bool theUseStripper)
SetInput(vtkAlgorithmOutput* thePolyData, bool theUseStripper)
{
if(theUseStripper)
myPolyDataNormals->SetInput(thePolyData);
{
myPolyDataNormals->SetInputConnection(thePolyData);
myStripper->SetInputConnection(myPolyDataNormals->GetOutputPort());
myPolyDataMapper->SetInputConnection(myStripper->GetOutputPort());
}
else
myPolyDataMapper->SetInput(thePolyData);
myPolyDataMapper->SetInputConnection(thePolyData);
}
void

3
src/OBJECT/GEOM_DeviceActor.h
View File

@ -43,6 +43,7 @@ class vtkRenderer;
#include <vtkObject.h>
class vtkAlgorithmOutput;
class VTK_EXPORT GEOM_DeviceActor: public vtkObject
{
@ -59,7 +60,7 @@ public:
void SetVisibility(int theVisibility);
int GetVisibility();
void SetInput(vtkPolyData* thePolyData, bool theUseStripper);
void SetInput(vtkAlgorithmOutput* thePolyData, bool theUseStripper);
void AddToRender(vtkRenderer* theRenderer);
void RemoveFromRender(vtkRenderer* theRenderer);

20
src/OBJECT/GEOM_OCCReader.cxx
View File

@ -33,6 +33,8 @@
#include <vtkObjectFactory.h>
#include <vtkPolyData.h>
#include <vtkInformation.h>
#include <vtkInformationVector.h>
// OpenCASCADE Includes
#include <TopExp_Explorer.hxx>
@ -114,14 +116,18 @@ GEOM_OCCReader::~GEOM_OCCReader()
//=======================================================================
// Function : Execute
// Function : RequestData
// Purpose :
//=======================================================================
int GEOM_OCCReader::RequestData(vtkInformation *vtkNotUsed(request),
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
vtkInformation *outInfo = outputVector->GetInformationObject(0);
vtkPolyData *output = vtkPolyData::SafeDownCast(
outInfo->Get(vtkDataObject::DATA_OBJECT()));
void GEOM_OCCReader::Execute() {
vtkPolyData* output = this->GetOutput();
vtkPoints* Pts = NULL;
vtkCellArray* Cells = NULL;
TopLoc_Location aLoc;
@ -143,7 +149,7 @@ void GEOM_OCCReader::Execute() {
if(aPoly.IsNull()) {
Pts->Delete();
Cells->Delete();
return;
return 0;
}
nbpts = aPoly->NbNodes();
@ -155,7 +161,7 @@ void GEOM_OCCReader::Execute() {
else {
Cells->Delete();
Pts->Delete();
return;
return 0;
}
}
@ -177,7 +183,7 @@ void GEOM_OCCReader::Execute() {
}
Pts->Delete();
Cells->Delete();
return 1;
}
//=======================================================================

7
src/OBJECT/GEOM_OCCReader.h
View File

@ -35,7 +35,7 @@
#include "GEOM_OBJECT_defs.hxx"
#include <vtkPolyDataSource.h>
#include <vtkAlgorithm.h>
class vtkPoints;
class vtkCellArray;
@ -46,7 +46,7 @@ class vtkCellArray;
#include <GeomAbs_IsoType.hxx>
#include <BRepAdaptor_Surface.hxx>
class GEOM_OBJECT_EXPORT GEOM_OCCReader : public vtkPolyDataSource {
class GEOM_OBJECT_EXPORT GEOM_OCCReader : public vtkAlgorithm {
// methods
@ -67,7 +67,8 @@ class GEOM_OBJECT_EXPORT GEOM_OCCReader : public vtkPolyDataSource {
GEOM_OCCReader();
~GEOM_OCCReader();
void Execute();
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
void ComputeShading(vtkPoints* Pts,vtkCellArray* Cells);
void ComputeWireframe(vtkPoints* Pts,vtkCellArray* Cells);

34
src/OBJECT/GEOM_VTKTrihedron.cxx
View File

@ -66,15 +66,15 @@ public:
vtkTypeMacro( GEOM_VTKTrihedronAxis, VTKViewer_Axis );
static GEOM_VTKTrihedronAxis* New();
void SetAxis( const gp_Ax1& theAxis, const int theRot, vtkFloatingPointType theColor[ 3 ] );
void SetAxis( const gp_Ax1& theAxis, const int theRot, double theColor[ 3 ] );
virtual void Render( vtkRenderer* theRenderer );
virtual void SetSize( vtkFloatingPointType theSize );
virtual void SetSize( double theSize );
gp_Pnt GetOri() const;
void SetColor( const vtkFloatingPointType theColor[ 3 ] );
void SetColor( const double theColor[ 3 ] );
private:
vtkFloatingPointType myOri[ 3 ];
double myOri[ 3 ];
vtkMatrix4x4* myMatrix;
vtkTransform* myTrsf;
};
@ -94,9 +94,9 @@ GEOM_VTKTrihedronAxis::~GEOM_VTKTrihedronAxis()
myTrsf->Delete();
}
void GEOM_VTKTrihedronAxis::SetSize( vtkFloatingPointType theSize )
void GEOM_VTKTrihedronAxis::SetSize( double theSize )
{
vtkFloatingPointType aPosition[ 3 ] = { myOri[ 0 ] + myDir[ 0 ] * theSize,
double aPosition[ 3 ] = { myOri[ 0 ] + myDir[ 0 ] * theSize,
myOri[ 1 ] + myDir[ 1 ] * theSize,
myOri[ 2 ] + myDir[ 2 ] * theSize };
@ -154,7 +154,7 @@ gp_Pnt GEOM_VTKTrihedronAxis::GetOri() const
void GEOM_VTKTrihedronAxis::SetAxis( const gp_Ax1& theAxis,
const int theRot,
vtkFloatingPointType theColor[ 3 ] )
double theColor[ 3 ] )
{
gp_Pnt aLoc = theAxis.Location();
gp_Dir aDir = theAxis.Direction();
@ -167,7 +167,7 @@ void GEOM_VTKTrihedronAxis::SetAxis( const gp_Ax1& theAxis,
myDir[ 1 ] = aDir.Y();
myDir[ 2 ] = aDir.Z();
vtkFloatingPointType aColor[ 3 ] = { 0, 0, 0 };
double aColor[ 3 ] = { 0, 0, 0 };
aColor[ theRot ] = 1;
if ( theColor[ 0 ] == -1 )
VTKViewer_Axis::SetColor( aColor[ 0 ], aColor[ 1 ], aColor[ 2 ] );
@ -185,7 +185,7 @@ void GEOM_VTKTrihedronAxis::SetAxis( const gp_Ax1& theAxis,
#endif
}
void GEOM_VTKTrihedronAxis::SetColor( const vtkFloatingPointType theColor[ 3 ] )
void GEOM_VTKTrihedronAxis::SetColor( const double theColor[ 3 ] )
{
VTKViewer_Axis::SetColor( theColor[ 0 ], theColor[ 1 ], theColor[ 2 ] );
}
@ -227,7 +227,7 @@ GEOM_VTKTrihedron::~GEOM_VTKTrihedron()
myMapper->Delete();
}
void GEOM_VTKTrihedron::SetSize( vtkFloatingPointType theSize )
void GEOM_VTKTrihedron::SetSize( double theSize )
{
mySize = theSize;
for ( int i = 0; i < 3; i++ )
@ -254,11 +254,11 @@ void GEOM_VTKTrihedron::SetSize( vtkFloatingPointType theSize )
aSrcZ->SetPoint2( aEndZ.X(), aEndZ.Y(), aEndZ.Z() );
vtkAppendPolyData* aRes = vtkAppendPolyData::New();
aRes->AddInput( aSrcX->GetOutput() );
aRes->AddInput( aSrcY->GetOutput() );
aRes->AddInput( aSrcZ->GetOutput() );
aRes->AddInputConnection( aSrcX->GetOutputPort() );
aRes->AddInputConnection( aSrcY->GetOutputPort() );
aRes->AddInputConnection( aSrcZ->GetOutputPort() );
myMapper->SetInput( aRes->GetOutput() );
myMapper->SetInputConnection( aRes->GetOutputPort() );
SALOME_Actor::SetMapper( myMapper );
aSrcX->Delete();
@ -362,7 +362,7 @@ void GEOM_VTKTrihedron::Render(vtkRenderer* r, vtkMapper *)
( (GEOM_VTKTrihedronAxis*)myAxis[ 2 ] )->Render( r );
}
void GEOM_VTKTrihedron::SetColor( vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b )
void GEOM_VTKTrihedron::SetColor( double r, double g, double b )
{
myColor[ 0 ] = r;
myColor[ 1 ] = g;
@ -373,7 +373,7 @@ void GEOM_VTKTrihedron::SetColor( vtkFloatingPointType r, vtkFloatingPointType g
if ( myAxis[ 2 ] ) ( (GEOM_VTKTrihedronAxis*)myAxis[ 2 ] )->SetColor( myColor );
}
void GEOM_VTKTrihedron::GetColor( vtkFloatingPointType& r, vtkFloatingPointType& g, vtkFloatingPointType& b )
void GEOM_VTKTrihedron::GetColor( double& r, double& g, double& b )
{
r = myColor[ 0 ];
g = myColor[ 1 ];
@ -426,7 +426,7 @@ void GEOM_VTKTrihedron::ResetAxesColors()
SetAxesColors( myDefaultColor, true );
}
void GEOM_VTKTrihedron::SetAxesColors( vtkFloatingPointType theColor[3], bool theIsDiffuse )
void GEOM_VTKTrihedron::SetAxesColors( double theColor[3], bool theIsDiffuse )
{
myAxis[ 0 ]->SetColor( theColor[0], theIsDiffuse ? 0.0 : theColor[1], theIsDiffuse ? 0.0 : theColor[2] );
myAxis[ 1 ]->SetColor( theIsDiffuse ? 0.0 : theColor[0], theColor[1], theIsDiffuse ? 0.0 : theColor[2] );

20
src/OBJECT/GEOM_VTKTrihedron.hxx
View File

@ -55,7 +55,7 @@ public:
vtkTypeMacro( GEOM_VTKTrihedron, SALOME_Actor );
static GEOM_VTKTrihedron* New();
virtual vtkFloatingPointType GetSize() { return mySize;}
virtual double GetSize() { return mySize;}
virtual void SetVisibility( int theVisibility );
virtual void SetVisibility( VTKViewer_Trihedron::TVisibility theVis );
@ -74,11 +74,11 @@ public:
virtual void Render(vtkRenderer *, vtkMapper *);
virtual bool IsSetCamera() const;
virtual bool IsResizable() const;
virtual void SetSize( vtkFloatingPointType );
virtual void SetSize( double );
virtual void SetCamera( vtkCamera* );
void SetColor( vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b );
void GetColor( vtkFloatingPointType& r, vtkFloatingPointType& g, vtkFloatingPointType& b );
void SetColor( double r, double g, double b );
void GetColor( double& r, double& g, double& b );
virtual bool hasHighlight() { return true; }
@ -89,18 +89,18 @@ public:
protected:
virtual void ResetAxesColors();
virtual void SetAxesColors( vtkFloatingPointType theColor[3], bool theIsDiffuse = false );
virtual void SetAxesColors( double theColor[3], bool theIsDiffuse = false );
protected:
VTKViewer_Axis* myAxis[3];
vtkPolyDataMapper* myMapper;
vtkFloatingPointType mySize;
double mySize;
gp_Pnt myLocation;
gp_Dir myDirX, myDirY, myDirZ;
vtkFloatingPointType myColor[ 3 ];
vtkFloatingPointType myDefaultColor[ 3 ];
vtkFloatingPointType myPreHighlightColor[ 3 ];
vtkFloatingPointType myHighlightColor[ 3 ];
double myColor[ 3 ];
double myDefaultColor[ 3 ];
double myPreHighlightColor[ 3 ];
double myHighlightColor[ 3 ];
};
#endif

15
src/OCC2VTK/GEOM_EdgeSource.cxx
View File

@ -34,12 +34,15 @@
#include <vtkStripper.h>
#include <vtkPolyData.h>
#include <vtkInformation.h>
#include <vtkInformationVector.h>
vtkStandardNewMacro(GEOM_EdgeSource);
GEOM_EdgeSource::GEOM_EdgeSource() :
myIsVector(false)
{
this->SetNumberOfInputPorts(0);
}
GEOM_EdgeSource::~GEOM_EdgeSource()
@ -53,11 +56,14 @@ void GEOM_EdgeSource::AddEdge (const TopoDS_Edge& theEdge,
myIsVector = theIsVector;
}
void
GEOM_EdgeSource::
Execute()
int GEOM_EdgeSource::RequestData(vtkInformation *vtkNotUsed(request),
vtkInformationVector **vtkNotUsed(inputVector),
vtkInformationVector *outputVector)
{
vtkPolyData* aPolyData = GetOutput();
vtkInformation *outInfo = outputVector->GetInformationObject(0);
vtkPolyData *aPolyData = vtkPolyData::SafeDownCast(
outInfo->Get(vtkDataObject::DATA_OBJECT()));
aPolyData->Allocate();
vtkPoints* aPts = vtkPoints::New();
aPolyData->SetPoints(aPts);
@ -71,6 +77,7 @@ Execute()
anEdge.Orientation( TopAbs_FORWARD );
OCC2VTK(anEdge,aPolyData,aPts,myIsVector||myIsVectorMode);
}
return 1;
}
void GEOM_EdgeSource::OCC2VTK (const TopoDS_Edge& theEdge,

10
src/OCC2VTK/GEOM_EdgeSource.h
View File

@ -28,12 +28,14 @@
typedef NCollection_Set<TopoDS_Edge> TEdgeSet;
#include <vtkPoints.h>
#include <vtkPolyDataSource.h>
#include <vtkPolyDataAlgorithm.h>
class OCC2VTK_EXPORT GEOM_EdgeSource: public vtkPolyDataSource
class vtkPolyData;
class OCC2VTK_EXPORT GEOM_EdgeSource: public vtkPolyDataAlgorithm
{
public:
vtkTypeMacro(GEOM_EdgeSource,vtkPolyDataSource);
vtkTypeMacro(GEOM_EdgeSource,vtkPolyDataAlgorithm);
static GEOM_EdgeSource* New();
void AddEdge (const TopoDS_Edge& theEdge,
@ -59,7 +61,7 @@ protected:
// representing a vector, can have only one edge.
bool myIsVector, myIsVectorMode;
void Execute();
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
GEOM_EdgeSource();
~GEOM_EdgeSource();

1
src/OCC2VTK/GEOM_FaceSource.cxx
View File

@ -29,6 +29,7 @@
GEOM_FaceSource::GEOM_FaceSource()
{
this->SetNumberOfInputPorts(0);
}
GEOM_FaceSource::~GEOM_FaceSource()

8
src/OCC2VTK/GEOM_FaceSource.h
View File

@ -29,12 +29,14 @@
typedef NCollection_Set<TopoDS_Face> TFaceSet;
#include <vtkPoints.h>
#include <vtkPolyDataSource.h>
#include <vtkPolyDataAlgorithm.h>
class OCC2VTK_EXPORT GEOM_FaceSource: public vtkPolyDataSource
class vtkPolyData;
class OCC2VTK_EXPORT GEOM_FaceSource: public vtkPolyDataAlgorithm
{
public:
vtkTypeMacro(GEOM_FaceSource,vtkPolyDataSource);
vtkTypeMacro(GEOM_FaceSource,vtkPolyDataAlgorithm);
void AddFace(const TopoDS_Face& theFace);
void Clear(){ myFaceSet.Clear();}

15
src/OCC2VTK/GEOM_ShadingFace.cxx
View File

@ -26,6 +26,8 @@
#include <vtkPolyDataMapper.h>
#include <vtkPolyData.h>
#include <vtkInformation.h>
#include <vtkInformationVector.h>
#include <BRep_Tool.hxx>
#include <Poly_Triangulation.hxx>
@ -35,17 +37,21 @@ vtkStandardNewMacro(GEOM_ShadingFace);
GEOM_ShadingFace::GEOM_ShadingFace()
{
this->SetNumberOfInputPorts(0);
}
GEOM_ShadingFace::~GEOM_ShadingFace()
{
}
void
GEOM_ShadingFace::
Execute()
int GEOM_ShadingFace::RequestData(vtkInformation *vtkNotUsed(request),
vtkInformationVector **vtkNotUsed(inputVector),
vtkInformationVector *outputVector)
{
vtkPolyData* aPolyData = GetOutput();
vtkInformation *outInfo = outputVector->GetInformationObject(0);
vtkPolyData *aPolyData = vtkPolyData::SafeDownCast(
outInfo->Get(vtkDataObject::DATA_OBJECT()));
aPolyData->Allocate();
vtkPoints* aPts = vtkPoints::New();
aPolyData->SetPoints(aPts);
@ -56,6 +62,7 @@ Execute()
const TopoDS_Face& aFace = anIter.Value();
OCC2VTK(aFace,aPolyData,aPts);
}
return 1;
}
void

2
src/OCC2VTK/GEOM_ShadingFace.h
View File

@ -35,7 +35,7 @@ public:
vtkPoints* thePts);
protected:
void Execute();
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
GEOM_ShadingFace();
~GEOM_ShadingFace();

15
src/OCC2VTK/GEOM_VertexSource.cxx
View File

@ -25,6 +25,8 @@
#include <vtkCellArray.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkInformation.h>
#include <vtkInformationVector.h>
#include <gp_Pnt.hxx>
#include <BRep_Tool.hxx>
@ -33,6 +35,7 @@ vtkStandardNewMacro(GEOM_VertexSource);
GEOM_VertexSource::GEOM_VertexSource()
{
this->SetNumberOfInputPorts(0);
}
GEOM_VertexSource::~GEOM_VertexSource()
@ -46,11 +49,14 @@ AddVertex(const TopoDS_Vertex& theVertex)
myVertexSet.Add(theVertex);
}
void
GEOM_VertexSource::
Execute()
int GEOM_VertexSource::RequestData(vtkInformation *vtkNotUsed(request),
vtkInformationVector **vtkNotUsed(inputVector),
vtkInformationVector *outputVector)
{
vtkPolyData* aPolyData = GetOutput();
vtkInformation *outInfo = outputVector->GetInformationObject(0);
vtkPolyData *aPolyData = vtkPolyData::SafeDownCast(
outInfo->Get(vtkDataObject::DATA_OBJECT()));
aPolyData->Allocate();
vtkPoints* aPts = vtkPoints::New();
aPolyData->SetPoints(aPts);
@ -61,6 +67,7 @@ Execute()
const TopoDS_Vertex& aVertex = anIter.Value();
OCC2VTK(aVertex,aPolyData,aPts);
}
return 1;
}
void

10
src/OCC2VTK/GEOM_VertexSource.h
View File

@ -28,12 +28,14 @@
typedef NCollection_Set<TopoDS_Vertex> TVertexSet;
#include <vtkPoints.h>
#include <vtkPolyDataSource.h>
#include <vtkPolyDataAlgorithm.h>
class OCC2VTK_EXPORT GEOM_VertexSource: public vtkPolyDataSource
class vtkPolyData;
class OCC2VTK_EXPORT GEOM_VertexSource: public vtkPolyDataAlgorithm
{
public:
vtkTypeMacro(GEOM_VertexSource,vtkPolyDataSource);
vtkTypeMacro(GEOM_VertexSource,vtkPolyDataAlgorithm);
static GEOM_VertexSource* New();
void AddVertex(const TopoDS_Vertex& theVertex);
@ -47,7 +49,7 @@ public:
protected:
TVertexSet myVertexSet;
void Execute();
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
GEOM_VertexSource();
~GEOM_VertexSource();

16
src/OCC2VTK/GEOM_WireframeFace.cxx
View File

@ -26,6 +26,8 @@
#include <vtkPolyDataMapper.h>
#include <vtkPolyData.h>
#include <vtkInformation.h>
#include <vtkInformationVector.h>
#include <Precision.hxx>
#include <BRepTools.hxx>
@ -55,17 +57,22 @@ GEOM_WireframeFace::GEOM_WireframeFace():
{
NbIso[0] = 1;
NbIso[1] = 1;
this->SetNumberOfInputPorts(0);
}
GEOM_WireframeFace::~GEOM_WireframeFace()
{
}
void
GEOM_WireframeFace::
Execute()
int GEOM_WireframeFace::RequestData(vtkInformation *vtkNotUsed(request),
vtkInformationVector **vtkNotUsed(inputVector),
vtkInformationVector *outputVector)
{
vtkPolyData* aPolyData = GetOutput();
vtkInformation *outInfo = outputVector->GetInformationObject(0);
vtkPolyData *aPolyData = vtkPolyData::SafeDownCast(
outInfo->Get(vtkDataObject::DATA_OBJECT()));
aPolyData->Allocate();
vtkPoints* aPts = vtkPoints::New();
aPolyData->SetPoints(aPts);
@ -76,6 +83,7 @@ Execute()
const TopoDS_Face& aFace = anIter.Value();
OCC2VTK(aFace,aPolyData,aPts,NbIso,Discret);
}
return 1;
}
void GEOM_WireframeFace::SetNbIso(const int theNb[2])

4
src/OCC2VTK/GEOM_WireframeFace.h
View File

@ -26,7 +26,7 @@
#include <GeomAbs_IsoType.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <vtkPolyDataSource.h>
class vtkPolyData;
class OCC2VTK_EXPORT GEOM_WireframeFace: public GEOM_FaceSource
{
@ -85,7 +85,7 @@ protected:
vtkPolyData* thePolyData,
vtkPoints* thePts);
void Execute();
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
GEOM_WireframeFace();
~GEOM_WireframeFace();

10
src/OperationGUI/OperationGUI_ClippingDlg.cxx
View File

@ -154,7 +154,7 @@ void OperationGUI_ClippingDlg::Init()
double position[3];
anActiveCamera->GetPosition( position );
vtkFloatingPointType bounds[6];
double bounds[6];
aRenderer->ComputeVisiblePropBounds( bounds );
double center[3];
@ -170,7 +170,7 @@ void OperationGUI_ClippingDlg::Init()
( position[1]-center[1] ) * ( position[1]-center[1] ) +
( position[2]-center[2] ) * ( position[2]-center[2] ) );
vtkFloatingPointType range[2] = { distance - width/2.0, distance + width/2.0 };
double range[2] = { distance - width/2.0, distance + width/2.0 };
SpinBox_Near->setValue( range[0] );
SpinBox_Far->setValue( range[1] );
@ -220,7 +220,7 @@ bool OperationGUI_ClippingDlg::ClickOnApply()
return false;
}
vtkFloatingPointType range[2] = { SpinBox_Near->value(), SpinBox_Far->value() };
double range[2] = { SpinBox_Near->value(), SpinBox_Far->value() };
if ( range[0] < 0.0 ) range[0] = 0.0;
anActiveCamera->SetClippingRange( range );
@ -302,7 +302,7 @@ void OperationGUI_ClippingDlg::onReset()
double position[3];
anActiveCamera->GetPosition( position );
vtkFloatingPointType bounds[6];
double bounds[6];
aRenderer->ComputeVisiblePropBounds( bounds );
double center[3];
@ -318,7 +318,7 @@ void OperationGUI_ClippingDlg::onReset()
( position[1]-center[1] ) * ( position[1]-center[1] ) +
( position[2]-center[2] ) * ( position[2]-center[2] ) );
vtkFloatingPointType range[2] = { distance - width/2.0, distance + width/2.0 };
double range[2] = { distance - width/2.0, distance + width/2.0 };
SpinBox_Near->setValue( range[0] );
SpinBox_Far->setValue( range[1] );

14
src/VTKExport/VTKExport.cxx
View File

@ -81,12 +81,12 @@ extern "C"
GEOM_ShadingFace* myShadingFaceSource = GEOM_ShadingFace::New();
vtkAppendPolyData* myAppendFilter = vtkAppendPolyData::New();
myAppendFilter->AddInput( myVertexSource->GetOutput() );
myAppendFilter->AddInput( myIsolatedEdgeSource->GetOutput() );
myAppendFilter->AddInput( myOneFaceEdgeSource->GetOutput() );
myAppendFilter->AddInput( mySharedEdgeSource->GetOutput() );
//myAppendFilter->AddInput( myWireframeFaceSource->GetOutput() ); // iso-lines are unnecessary
myAppendFilter->AddInput( myShadingFaceSource->GetOutput() );
myAppendFilter->AddInputConnection( myVertexSource->GetOutputPort() );
myAppendFilter->AddInputConnection( myIsolatedEdgeSource->GetOutputPort() );
myAppendFilter->AddInputConnection( myOneFaceEdgeSource->GetOutputPort() );
myAppendFilter->AddInputConnection( mySharedEdgeSource->GetOutputPort() );
//myAppendFilter->AddInputConnection( myWireframeFaceSource->GetOutputPort() ); // iso-lines are unnecessary
myAppendFilter->AddInputConnection( myShadingFaceSource->GetOutputPort() );
float aDeflection = 0.001;
bool anIsVector = false;
@ -131,7 +131,7 @@ extern "C"
Kernel_Utils::Localizer loc;
vtkPolyDataWriter* aWriter = vtkPolyDataWriter::New();
aWriter->SetInput( myAppendFilter->GetOutput() );
aWriter->SetInputConnection( myAppendFilter->GetOutputPort() );
aWriter->SetFileName( theFileName.ToCString() );
aWriter->Write();
aWriter->Delete();