fi
LOCAL_INCLUDES="$OGL_INCLUDES"
-LOCAL_LIBS="-lvtkCommon -lvtkGraphics -lvtkImaging -lvtkFiltering -lvtkIO -lvtkRendering -lvtkHybrid $OGL_LIBS $LXLIB -lX11 -lXt"
+LOCAL_LIBS="-lvtkCommon -lvtkGraphics -lvtkImaging -lvtkFiltering -lvtkIO -lvtkRendering -lvtkHybrid -lvtkParallel -lvtkWidgets $OGL_LIBS $LXLIB -lX11 -lXt"
TRY_LINK_LIBS="-lvtkCommon $OGL_LIBS $LXLIB -lX11 -lXt"
if test -z $VTKHOME
rm salome_adm/unix/config_files/${deprecated}
done
+# remove KERNEL CVS directories in subdirectory salome_adm
+for deprecated in CVS unix/CVS unix/config_files/CVS
+do
+ rm -rf salome_adm/${deprecated}
+done
+
cp -f ${KERNEL_ROOT_DIR}/salome_adm/unix/SALOMEconfig.h.in salome_adm/unix
# ____________________________________________________________________
OCCViewer_ViewWindow.h \
OCCViewer_VService.h \
OCCViewer_CreateRestoreViewDlg.h \
- OCCViewer_SetRotationPointDlg.h \
- OCCViewer.h
+ OCCViewer.h \
+ OCCViewer_ClippingDlg.h \
+ OCCViewer_SetRotationPointDlg.h
dist_libOCCViewer_la_SOURCES= \
OCCViewer_AISSelector.cxx \
-I$(top_builddir)/salome_adm/unix @CORBA_CXXFLAGS@ @CORBA_INCLUDES@
libSalomePy_la_LDFLAGS=$(PYTHON_LIBS) $(QT_MT_LIBS) $(VTK_LIBS) $(OGL_LIBS) \
../SalomeApp/libSalomeApp.la \
- -lvtkCommonPython -lvtkGraphicsPython -lvtkImagingPython
+ -lvtkCommonPythonD -lvtkGraphicsPythonD -lvtkImagingPythonD
#include "VTKViewer_Transform.h"
#include "VTKViewer_TransformFilter.h"
-#include "VTKViewer_PassThroughFilter.h"
#include "VTKViewer_GeometryFilter.h"
#include "SVTK_RectPicker.h"
#include <vtkInteractorStyle.h>
#include <vtkRenderWindowInteractor.h>
+#include <vtkPassThroughFilter.h>
#include <TColStd_MapOfInteger.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
#include "VTKViewer_Transform.h"
#include "VTKViewer_TransformFilter.h"
-#include "VTKViewer_PassThroughFilter.h"
#include "VTKViewer_GeometryFilter.h"
// VTK Includes
#include <vtkPolyDataMapper.h>
#include <vtkDataSetMapper.h>
+#include <vtkPassThroughFilter.h>
+
using namespace std;
vtkStandardNewMacro(SVTK_DeviceActor);
myTransformFilter = VTKViewer_TransformFilter::New();
for(int i = 0; i < 6; i++)
- myPassFilter.push_back(VTKViewer_PassThroughFilter::New());
+ myPassFilter.push_back(vtkPassThroughFilter::New());
}
/*!
}else if(vtkPolyDataMapper* aMapper = dynamic_cast<vtkPolyDataMapper*>(theMapper)){
aMapper->SetInput(myPassFilter[anId]->GetPolyDataOutput());
}
- }else
- myPassFilter[ 0 ]->SetInput( NULL );
+ }
Superclass::SetMapper(theMapper);
}
class VTKViewer_Transform;
class VTKViewer_TransformFilter;
-class VTKViewer_PassThroughFilter;
class VTKViewer_GeometryFilter;
class vtkCell;
class vtkDataSet;
class vtkShrinkFilter;
class vtkDataSetMapper;
+class vtkPassThroughFilter;
namespace SVTK
{
VTKViewer_GeometryFilter *myGeomFilter;
VTKViewer_TransformFilter *myTransformFilter;
- std::vector<VTKViewer_PassThroughFilter*> myPassFilter;
+ std::vector<vtkPassThroughFilter*> myPassFilter;
vtkShrinkFilter* myShrinkFilter;
vtkDataSetMapper* myMapper;
myEventCallbackCommand->Delete();
myTrihedron->AddToRender(GetDevice());
- GetDevice()->AddProp(GetCubeAxes());
+ GetDevice()->AddViewProp(GetCubeAxes());
myBndBox[0] = myBndBox[2] = myBndBox[4] = 0;
myBndBox[1] = myBndBox[3] = myBndBox[5] = myTrihedron->GetSize();
VTKViewer_AppendFilter.h \
VTKViewer_Algorithm.h \
VTKViewer_InteractorStyle.h \
- VTKViewer_PassThroughFilter.h \
VTKViewer_RenderWindow.h \
VTKViewer_RenderWindowInteractor.h \
VTKViewer_ShrinkFilter.h \
VTKViewer_Transform.h \
VTKViewer_Trihedron.h \
VTKViewer_Utilities.h \
- VTKViewer_VectorText.h \
VTKViewer_ViewManager.h \
VTKViewer_ViewModel.h \
VTKViewer_ViewWindow.h \
VTKViewer_GeometryFilter.cxx \
VTKViewer_AppendFilter.cxx \
VTKViewer_InteractorStyle.cxx \
- VTKViewer_PassThroughFilter.cxx \
VTKViewer_RenderWindow.cxx \
VTKViewer_RenderWindowInteractor.cxx \
VTKViewer_ShrinkFilter.cxx \
VTKViewer_TransformFilter.cxx \
VTKViewer_Trihedron.cxx \
VTKViewer_Utilities.cxx \
- VTKViewer_VectorText.cxx \
VTKViewer_ViewManager.cxx \
VTKViewer_ViewModel.cxx \
VTKViewer_ConvexTool.cxx \
#include "VTKViewer_AppendFilter.h"
#include "VTKViewer_Algorithm.h"
#include "VTKViewer_InteractorStyle.h"
-#include "VTKViewer_PassThroughFilter.h"
#include "VTKViewer_RenderWindow.h"
#include "VTKViewer_RenderWindowInteractor.h"
#include "VTKViewer_ShrinkFilter.h"
#include "VTKViewer_Transform.h"
#include "VTKViewer_Trihedron.h"
#include "VTKViewer_Utilities.h"
-#include "VTKViewer_VectorText.h"
#include "VTKViewer_ViewManager.h"
#include "VTKViewer_ViewModel.h"
#include "VTKViewer_ViewWindow.h"
#include "VTKViewer_Transform.h"
#include "VTKViewer_TransformFilter.h"
-#include "VTKViewer_PassThroughFilter.h"
#include "VTKViewer_GeometryFilter.h"
// VTK Includes
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
+#include <vtkPassThroughFilter.h>
using namespace std;
myPolygonOffsetUnits);
for(int i = 0; i < 6; i++)
- myPassFilter.push_back(VTKViewer_PassThroughFilter::New());
+ myPassFilter.push_back(vtkPassThroughFilter::New());
}
/*!
unsigned long mTime = this->Superclass::GetMTime();
unsigned long time = myTransformFilter->GetMTime();
mTime = ( time > mTime ? time : mTime );
- if(vtkDataSet *aDataSet = myPassFilter[0]->GetInput()){
+ if(vtkDataSet *aDataSet = dynamic_cast<vtkDataSet*>(myPassFilter[0]->GetInput())){ // bad usage of GetInput
time = aDataSet->GetMTime();
mTime = ( time > mTime ? time : mTime );
}
class vtkCamera;
class vtkProperty;
class vtkRenderer;
+class vtkPassThroughFilter;
class VTKViewer_Transform;
class VTKViewer_GeometryFilter;
class VTKViewer_TransformFilter;
-class VTKViewer_PassThroughFilter;
extern int VTKViewer_POINT_SIZE;
extern int VTKViewer_LINE_WIDTH;
bool myStoreMapping;
VTKViewer_GeometryFilter *myGeomFilter;
VTKViewer_TransformFilter *myTransformFilter;
- std::vector<VTKViewer_PassThroughFilter*> myPassFilter;
+ std::vector<vtkPassThroughFilter*> myPassFilter;
int myRepresentation;
vtkProperty *myProperty;
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
#include <vtkUnstructuredGrid.h>
+#include <vtkInformation.h>
+#include <vtkInformationVector.h>
#include <vtkPoints.h>
return myPoints.GetPointer();
}
-void
+int
VTKViewer_AppendFilter
-::Execute()
+::RequestData(
+ vtkInformation *request,
+ vtkInformationVector **inputVector,
+ vtkInformationVector *outputVector)
{
+ int aRet = 0;
if(myPoints.GetPointer())
- MakeOutput();
+ aRet = MakeOutput(request,inputVector,outputVector);
else
- Superclass::Execute();
+ aRet = Superclass::RequestData(request,inputVector,outputVector);
if(myDoMappingFlag)
DoMapping();
+
+ return aRet;
}
vtkIdType aPntStartId = 0;
vtkIdType aCellStartId = 0;
- for(vtkIdType aDataSetId = 0; aDataSetId < this->NumberOfInputs; ++aDataSetId){
- vtkDataSet* aDataSet = (vtkDataSet *)(this->Inputs[aDataSetId]);
+ for(vtkIdType aDataSetId = 0; aDataSetId < this->GetNumberOfInputPorts(); ++aDataSetId){
+ vtkDataSet* aDataSet = (vtkDataSet *)(this->GetInput(aDataSetId));
// Do mapping of the nodes
if(!myPoints.GetPointer()){
vtkIdType aNbPnts = aDataSet->GetNumberOfPoints();
}
-void
+int
VTKViewer_AppendFilter
-::MakeOutput()
+::MakeOutput(
+ vtkInformation *vtkNotUsed(request),
+ vtkInformationVector **inputVector,
+ vtkInformationVector *outputVector)
{
int idx;
vtkIdType numPts, numCells, newCellId, cellId;
vtkCellData *cd;
vtkIdList *ptIds;
vtkDataSet *ds;
- vtkUnstructuredGrid *output = this->GetOutput();
+ int numInputs = this->GetNumberOfInputConnections(0);
+
+ // get the output info object
+ vtkInformation *outInfo = outputVector->GetInformationObject(0);
+
+ // get the ouptut
+ vtkUnstructuredGrid *output = vtkUnstructuredGrid::SafeDownCast(
+ outInfo->Get(vtkDataObject::DATA_OBJECT()));
//
numPts = myPoints->GetNumberOfPoints();
if (numPts < 1) {
- return;
+ return 0;
}
//
numCells = 0;
- for (idx = 0; idx < this->NumberOfInputs; ++idx) {
- ds = (vtkDataSet *)(this->Inputs[idx]);
+ vtkInformation *inInfo = 0;
+ for (idx = 0; idx < numInputs;++idx) {
+ inInfo = inputVector[0]->GetInformationObject(idx);
+ ds = 0;
+ if (inInfo)
+ {
+ ds = vtkDataSet::SafeDownCast(inInfo->Get(vtkDataObject::DATA_OBJECT()));
+ }
if (ds != NULL) {
if ( ds->GetNumberOfPoints() <= 0 && ds->GetNumberOfCells() <= 0 ) {
continue; //no input, just skip
}//if non-empty dataset
}//for all inputs
if (numCells < 1) {
- return;
+ return 0;
}
//
// Now can allocate memory
// 1.points
output->SetPoints(myPoints.GetPointer());
// 2.cells
- for (idx = 0; idx < this->NumberOfInputs; ++idx) {
- ds = (vtkDataSet *)(this->Inputs[idx]);
+ for (idx = 0; idx < numInputs; ++idx) {
+ inInfo = inputVector[0]->GetInformationObject(idx);
+ ds = 0;
+ if (inInfo)
+ {
+ ds = vtkDataSet::SafeDownCast(inInfo->Get(vtkDataObject::DATA_OBJECT()));
+ }
if (ds != NULL) {
+
numCells = ds->GetNumberOfCells();
cd = ds->GetCellData();
// copy cell and cell data
}
//
ptIds->Delete();
+ return 1;
}
+int VTKViewer_AppendFilter::FillInputPortInformation(int, vtkInformation *info)
+{
+ info->Set(vtkAlgorithm::INPUT_REQUIRED_DATA_TYPE(), "vtkDataSet");
+ info->Set(vtkAlgorithm::INPUT_IS_REPEATABLE(), 1);
+ return 1;
+}
* \brief Destructor.
*/
~VTKViewer_AppendFilter();
- /*! \fn void Execute();
- * \brief Filter culculation method.
- */
- virtual void Execute();
- //
+
+ // Usual data generation method
+ virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
+
+ virtual int FillInputPortInformation(int port, vtkInformation *info);
+
void DoMapping();
void Reset();
- void MakeOutput();
+ int MakeOutput(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
bool myDoMappingFlag;
TVectorIds myNodeRanges;
#include "VTKViewer.h"
-#if (VTK_MAJOR_VERSION >= 4) && (VTK_MINOR_VERSION >= 4)
+#if ((VTK_MAJOR_VERSION == 4) && (VTK_MINOR_VERSION >= 4)) || (VTK_MAJOR_VERSION > 4)
# include <vtkIdTypeArray.h>
# define TCellLocationsArray vtkIdTypeArray
#else
#include <vtkCellArray.h>
#include <vtkIdList.h>
#include <vtkCell.h>
+#include <vtkInformation.h>
+#include <vtkInformationVector.h>
using namespace std;
}
}
-void VTKViewer_ExtractUnstructuredGrid::Execute(){
+
+// int VTKViewer_ExtractUnstructuredGrid::RequestData(
+// vtkInformation *vtkNotUsed(request),
+// vtkInformationVector **inputVector,
+// vtkInformationVector *outputVector)
+void VTKViewer_ExtractUnstructuredGrid::Execute()
+{
+ /*
+ not ported yet to the new executive-based pipeline architecture.
+
+ // get the info objects
+ vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
+ vtkInformation *outInfo = outputVector->GetInformationObject(0);
+
+ // get the input and ouptut
+ vtkUnstructuredGrid *anInput = vtkUnstructuredGrid::SafeDownCast(
+ inInfo->Get(vtkDataObject::DATA_OBJECT()));
+ vtkUnstructuredGrid *anOutput = vtkUnstructuredGrid::SafeDownCast(
+ outInfo->Get(vtkDataObject::DATA_OBJECT()));
+ */
vtkUnstructuredGrid *anInput = this->GetInput();
vtkUnstructuredGrid *anOutput = this->GetOutput();
+
myOut2InId.clear(); myIn2OutId.clear();
/* if(MYDEBUG){
MESSAGE("Execute - myIn2OutId.size() = "<<myIn2OutId.size());
}
}*/
+// return 1;
}
~VTKViewer_ExtractUnstructuredGrid();
//! Main method, which calculate output
- void Execute();
+ // not ported yet to the new executive-based pipeline architecture.
+ // see http://www.vtk.org/cgi-bin/viewcvs.cgi/Filtering/vtkUnstructuredGridToUnstructuredGridFilter.h?rev=1.19&view=log
+ // virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
+ virtual void Execute();
EExtraction myExtractionMode;
#include <vtkUnstructuredGrid.h>
#include <vtkVoxel.h>
#include <vtkWedge.h>
+#include <vtkInformationVector.h>
+#include <vtkInformation.h>
#include <algorithm>
#include <iterator>
{}
-void
+int
VTKViewer_GeometryFilter
-::Execute()
+::RequestData(
+ vtkInformation *request,
+ vtkInformationVector **inputVector,
+ vtkInformationVector *outputVector)
{
- vtkDataSet *input= this->GetInput();
+ // get the info objects
+ vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
+ vtkInformation *outInfo = outputVector->GetInformationObject(0);
+
+ // get the input and ouptut
+ vtkDataSet *input = vtkDataSet::SafeDownCast(
+ inInfo->Get(vtkDataObject::DATA_OBJECT()));
+ vtkPolyData *output = vtkPolyData::SafeDownCast(
+ outInfo->Get(vtkDataObject::DATA_OBJECT()));
+
vtkIdType numCells=input->GetNumberOfCells();
if (numCells == 0)
{
- return;
+ return 0;
}
if (input->GetDataObjectType() == VTK_UNSTRUCTURED_GRID){
- this->UnstructuredGridExecute();
- return;
+ return this->UnstructuredGridExecute(input, output, outInfo);
}else
- vtkGeometryFilter::Execute();
+ return Superclass::RequestData(request,inputVector,outputVector);
+
+ return 1;
}
-void
+int
VTKViewer_GeometryFilter
-::UnstructuredGridExecute()
+::UnstructuredGridExecute(
+ vtkDataSet *dataSetInput,
+ vtkPolyData *output,
+ vtkInformation *outInfo)
{
- vtkUnstructuredGrid *input= (vtkUnstructuredGrid *)this->GetInput();
+
+ vtkUnstructuredGrid *input= (vtkUnstructuredGrid *)dataSetInput;
vtkCellArray *Connectivity = input->GetCells();
// Check input
if ( Connectivity == NULL )
{
vtkDebugMacro(<<"Nothing to extract");
- return;
+ return 0;
}
vtkIdType cellId;
vtkIdType numCells=input->GetNumberOfCells();
vtkPointData *pd = input->GetPointData();
vtkCellData *cd = input->GetCellData();
- vtkPolyData *output = this->GetOutput();
vtkPointData *outputPD = output->GetPointData();
VTKViewer_OrderedTriangulator anOrderedTriangulator;
* \brief Destructor.
*/
~VTKViewer_GeometryFilter();
- /*! \fn void Execute();
- * \brief Filter culculation method.
- */
- void Execute();
+
+ virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
+
+ //special cases for performance
+
/*! \fn void UnstructuredGridExecute();
* \brief Filter culculation method for data object type is VTK_UNSTRUCTURED_GRID.
*/
- void UnstructuredGridExecute();
+ int UnstructuredGridExecute (vtkDataSet *, vtkPolyData *, vtkInformation *);
private:
typedef std::vector<vtkIdType> TVectorId;
#include <vtkDataSet.h>
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
+#include <vtkInformation.h>
+#include <vtkInformationVector.h>
vtkCxxRevisionMacro(VTKViewer_PassThroughFilter, "$Revision$");
vtkStandardNewMacro(VTKViewer_PassThroughFilter);
*/
/*!Execute method.Output calculation.*/
-void VTKViewer_PassThroughFilter::Execute()
+int VTKViewer_PassThroughFilter::RequestData(
+ vtkInformation *,
+ vtkInformationVector **inputVector,
+ vtkInformationVector *outputVector)
{
- vtkDataSet *input = static_cast<vtkDataSet*>(this->GetInput());
- vtkDataSet *output = static_cast<vtkDataSet*>(this->GetOutput());
+ // get the info objects
+ vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
+ vtkInformation *outInfo = outputVector->GetInformationObject(0);
+
+ // get the input and ouptut
+ vtkDataSet *input = vtkDataSet::SafeDownCast(
+ inInfo->Get(vtkDataObject::DATA_OBJECT()));
+ vtkDataSet *output = vtkDataSet::SafeDownCast(
+ outInfo->Get(vtkDataObject::DATA_OBJECT()));
// This has to be here because it initialized all field datas.
output->CopyStructure( input );
output->GetPointData()->PassData( input->GetPointData() );
output->GetCellData()->PassData( input->GetCellData() );
+ return 1;
}
/*!Methods invoked by print to print information about the object including superclasses.\n
VTKViewer_PassThroughFilter() {};//!< Null body.
virtual ~VTKViewer_PassThroughFilter() {};//!< Null body.
- void Execute();
+ virtual int RequestData(vtkInformation *, vtkInformationVector **,
+ vtkInformationVector *); //generate output data
private:
VTKViewer_PassThroughFilter( const VTKViewer_PassThroughFilter& ); //!< Not implemented.
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
#include <vtkUnstructuredGrid.h>
+#include <vtkInformation.h>
+#include <vtkInformationVector.h>
vtkCxxRevisionMacro(VTKViewer_ShrinkFilter, "$Revision$");
vtkStandardNewMacro(VTKViewer_ShrinkFilter);
/*!Execute method. Calculate output.*/
-void VTKViewer_ShrinkFilter::Execute()
+int VTKViewer_ShrinkFilter::RequestData(
+ vtkInformation *vtkNotUsed(request),
+ vtkInformationVector **inputVector,
+ vtkInformationVector *outputVector)
{
+ // get the info objects
+ vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
+ vtkInformation *outInfo = outputVector->GetInformationObject(0);
+
+ // get the input and ouptut
+ vtkDataSet *input = vtkDataSet::SafeDownCast(
+ inInfo->Get(vtkDataObject::DATA_OBJECT()));
+ vtkUnstructuredGrid *output = vtkUnstructuredGrid::SafeDownCast(
+ outInfo->Get(vtkDataObject::DATA_OBJECT()));
+
vtkPoints *newPts;
int i, j, numIds, abort=0;
vtkIdType cellId, numCells, numPts;
vtkFloatingPointType center[3], *p, pt[3];
vtkPointData *pd, *outPD;;
vtkIdList *ptIds, *newPtIds;
- vtkDataSet *input= this->GetInput();
- vtkUnstructuredGrid *output = this->GetOutput();
vtkIdType tenth;
vtkFloatingPointType decimal;
if (numCells < 1 || numPts < 1)
{
vtkErrorMacro(<<"No data to shrink!");
- return;
+ return 0;
}
ptIds = vtkIdList::New();
ptIds->Delete();
newPtIds->Delete();
newPts->Delete();
+
+ return 1;
}
/*!Sets store mapping.*/
VTKViewer_ShrinkFilter();
~VTKViewer_ShrinkFilter();
- void Execute();
+ virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
/*!Not implemented.*/
void UnstructuredGridExecute();
#include <vtkPointData.h>
#include <vtkCellData.h>
#include <vtkPoints.h>
-
+#include <vtkInformation.h>
+#include <vtkInformationVector.h>
vtkStandardNewMacro(VTKViewer_TransformFilter);
/*!Execution method. Calculate output.*/
-void VTKViewer_TransformFilter::Execute(){
+int VTKViewer_TransformFilter::RequestData(
+ vtkInformation *vtkNotUsed(request),
+ vtkInformationVector **inputVector,
+ vtkInformationVector *outputVector)
+{
+ // get the info objects
+ vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
+ vtkInformation *outInfo = outputVector->GetInformationObject(0);
+
+ // get the input and ouptut
+ vtkPointSet *input = vtkPointSet::SafeDownCast(
+ inInfo->Get(vtkDataObject::DATA_OBJECT()));
+ vtkPointSet *output = vtkPointSet::SafeDownCast(
+ outInfo->Get(vtkDataObject::DATA_OBJECT()));
+
vtkPoints *inPts;
vtkPoints *newPts;
int numPts, numCells;
- vtkPointSet *input = this->GetInput();
- vtkPointSet *output = this->GetOutput();
vtkPointData *pd=input->GetPointData(), *outPD=output->GetPointData();
vtkCellData *cd=input->GetCellData(), *outCD=output->GetCellData();
output->CopyStructure( input );
}
outPD->PassData(pd);
outCD->PassData(cd);
+
+ return 1;
}
VTKViewer_TransformFilter(const VTKViewer_TransformFilter&) {/*!Do nothing*/}
/*!Operator = */
void operator=(const VTKViewer_TransformFilter&) {/*!Do nothing*/}
- void Execute();
+
+ int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
};
#endif
#include <vtkLineSource.h>
#include <vtkConeSource.h>
#include <vtkPolyDataMapper.h>
-
-#include "VTKViewer_VectorText.h"
+#include <vtkVectorText.h>
vtkStandardNewMacro(VTKViewer_UnScaledActor);
myLineActor->SetArrowActor(myArrowActor);
/*! \li Initialize the Label pipe-line representation */
- myVectorText = VTKViewer_VectorText::New();
+ myVectorText = vtkVectorText::New();
myMapper[2] = vtkPolyDataMapper::New();
myMapper[2]->SetInput(myVectorText->GetOutput());
class vtkPolyDataMapper;
class vtkLineSource;
class vtkConeSource;
+class vtkVectorText;
class VTKViewer_Axis;
-class VTKViewer_VectorText;
/*! \class vtkFollower
* See <a href="http://www.vtk.org/">vtk documentation</a>
/*! VTKViewer_VectorText pointer (Label)
*/
- VTKViewer_VectorText* myVectorText;
+ vtkVectorText* myVectorText;
};
#endif
VTKViewer_VectorText();
~VTKViewer_VectorText();
- void Execute();
+ //! Main method, which calculate output
+ virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
+
char *Text;
char *Letters[127];
myRWInteractor->Delete();
//m_RW->Delete() ;
- myRenderer->RemoveAllProps();
+ myRenderer->RemoveAllViewProps();
//m_Renderer->Delete() ;
myTrihedron->Delete();
}
