Commit 38e8f2e3 authored by brugger's avatar brugger

I modified all the vtk classes that inherit from vtkPolyDataToPolyDataFilter

to inherit from vtkPolyDataAlgorithm, since vtkPolyDataToPolyDataFilter
is deprecated and isn't in VTK6.



git-svn-id: http://visit.ilight.com/svn/visit/trunk/src@19965 18c085ea-50e0-402c-830e-de6fd14e8384
parent ec250509
......@@ -54,6 +54,9 @@
#include <vtkDataSet.h>
#include <vtkDataSetWriter.h>
#include <vtkDataSetWriter.h>
#include <vtkExecutive.h>
#include <vtkInformation.h>
#include <vtkInformationVector.h>
#include <vtkMatrix4x4.h>
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
......@@ -94,8 +97,10 @@ vtkStandardNewMacro(vtkParallelImageSpaceRedistributor);
// Creation: September 1, 2004
//
// ****************************************************************************
static void AreaOwned(int rank, int size, int w, int h,
int &x1,int &y1, int &x2,int &y2)
static void
AreaOwned(int rank, int size, int w, int h,
int &x1,int &y1, int &x2,int &y2)
{
x1 = 0;
x2 = w-1;
......@@ -116,10 +121,14 @@ static void AreaOwned(int rank, int size, int w, int h,
// Brad Whitlock, Fri Jan 23 15:09:07 PST 2009
// Initialize the communicator.
//
// Eric Brugger, Wed Jan 9 10:37:37 PST 2013
// Modified to inherit from vtkPolyDataAlgorithm.
//
// ****************************************************************************
vtkParallelImageSpaceRedistributor::vtkParallelImageSpaceRedistributor()
{
SetNumberOfOutputs(1);
SetNumberOfOutputPorts(1);
rank = 0;
size = 1;
x1 = x2 = y1 = y2 = 0;
......@@ -135,6 +144,7 @@ vtkParallelImageSpaceRedistributor::vtkParallelImageSpaceRedistributor()
// Creation: October 21, 2004
//
// ****************************************************************************
vtkParallelImageSpaceRedistributor::~vtkParallelImageSpaceRedistributor()
{
delete[] x1;
......@@ -200,16 +210,22 @@ vtkParallelImageSpaceRedistributor::SetRankAndSize(int r, int s)
// Method: vtkParallelImageSpaceRedistributor::GetOutput()
//
// Purpose:
// retrieves output from this filter
// retrieves output from this filter
//
// Programmer: Chris Wojtan
// Creation: July 7, 2004
//
// Modifications:
// Eric Brugger, Wed Jan 9 10:37:37 PST 2013
// Modified to inherit from vtkPolyDataAlgorithm.
//
// ****************************************************************************
vtkPolyData *
vtkParallelImageSpaceRedistributor::GetOutput()
{
return (vtkPolyData *) vtkSource::GetOutput(0);
return vtkPolyData::SafeDownCast(
this->GetExecutive()->GetOutputData(0));
}
......@@ -217,7 +233,7 @@ vtkParallelImageSpaceRedistributor::GetOutput()
// Method: vtkParallelImageSpaceRedistributor::GetOutput()
//
// Purpose:
// executes the actual filtering of the polydata
// Executes the actual filtering of the polydata
//
// Programmer: Chris Wojtan
// Creation: July 7, 2004
......@@ -246,11 +262,30 @@ vtkParallelImageSpaceRedistributor::GetOutput()
// Kathleen Biagas, Wed Aug 29 09:15:07 MST 2012
// Preserve input coordinate type.
//
// Eric Brugger, Wed Jan 9 10:37:37 PST 2013
// Modified to inherit from vtkPolyDataAlgorithm.
//
// ****************************************************************************
void
vtkParallelImageSpaceRedistributor::Execute(void)
int
vtkParallelImageSpaceRedistributor::RequestData(
vtkInformation *vtkNotUsed(request),
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
#ifdef PARALLEL
// get the info objects
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
//
// Initialize some frequently used values.
//
vtkPolyData *input = vtkPolyData::SafeDownCast(
inInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkPolyData *output = vtkPolyData::SafeDownCast(
outInfo->Get(vtkDataObject::DATA_OBJECT()));
//
// Do some basic setup -- collect some important data
//
......@@ -271,7 +306,6 @@ vtkParallelImageSpaceRedistributor::Execute(void)
int i, j;
vtkPolyData *input = GetInput();
vtkPoints *inPts = input->GetPoints();
vtkPointData *inPD = input->GetPointData();
vtkCellData *inCD = input->GetCellData();
......@@ -623,7 +657,7 @@ vtkParallelImageSpaceRedistributor::Execute(void)
delete[] big_recv_buffer;
appender->Update();
GetOutput()->ShallowCopy(appender->GetOutput());
output->ShallowCopy(appender->GetOutput());
visitTimer->StopTimer(TH_appending, "appending");
//
......@@ -639,6 +673,8 @@ vtkParallelImageSpaceRedistributor::Execute(void)
visitTimer->StopTimer(TH_total, "vtkParallelImageSpaceRedistributor");
visitTimer->DumpTimings();
#endif
return 1;
}
......@@ -646,9 +682,9 @@ vtkParallelImageSpaceRedistributor::Execute(void)
// Method: vtkParallelImageSpaceRedistributor::GetDataVTK()
//
// Purpose:
// Takes a string as input, and converts it to vtkPolyData so we
// can retreive data from other processors and convert it into a
// usable form. This was copied from avtDataRepresentation.C.
// Takes a string as input, and converts it to vtkPolyData so we
// can retreive data from other processors and convert it into a
// usable form. This was copied from avtDataRepresentation.C.
//
// Programmer: Chris Wojtan
// Creation: Mon Jul 12 11:24:32 PDT 2004
......@@ -665,7 +701,7 @@ vtkParallelImageSpaceRedistributor::Execute(void)
vtkPolyData *
vtkParallelImageSpaceRedistributor::GetDataVTK(unsigned char *asChar,
unsigned int asCharLength)
unsigned int asCharLength)
{
vtkPolyDataReader *reader = vtkPolyDataReader::New();
......@@ -686,13 +722,14 @@ vtkParallelImageSpaceRedistributor::GetDataVTK(unsigned char *asChar,
return asVTK;
}
// ***************************************************************************
// Method: vtkParallelImageSpaceRedistributor::GetDataString()
//
// Purpose:
// Takes vtkPolyData as input, and converts it to a string so we
// can send it to other processors. This was copied from
// avtDataRepresentation.C
// Takes vtkPolyData as input, and converts it to a string so we
// can send it to other processors. This was copied from
// avtDataRepresentation.C
//
// Programmer: Chris Wojtan
// Creation: Mon Jul 12 11:23:23 PDT 2004
......@@ -749,11 +786,11 @@ vtkParallelImageSpaceRedistributor::GetDataString(int &length,
// Method: vtkParallelImageSpaceRedistributor::WhichProcessorsForCell()
//
// Purpose:
// Given a piece of vtkPolyData, the processor that we should use
// to draw it will depend on where the data lies in image-space.
// This function analyzes the data and returns a vector of
// integers. Each returned integer will represent a processor
// that should draw this data.
// Given a piece of vtkPolyData, the processor that we should use
// to draw it will depend on where the data lies in image-space.
// This function analyzes the data and returns a vector of
// integers. Each returned integer will represent a processor
// that should draw this data.
//
// Note: Currently assumes a horizontal banding!
// See below for comments on the return values.
......@@ -778,9 +815,7 @@ vtkParallelImageSpaceRedistributor::GetDataString(int &length,
int
vtkParallelImageSpaceRedistributor::WhichProcessorsForCell(double *pts,
vtkIdType npts,
vtkIdType *cellPts,
vector<int> &procs)
vtkIdType npts, vtkIdType *cellPts, vector<int> &procs)
{
// dest has some special values: If it is -2, then no processor
// contained this cell. If it is -1, then the client should walk
......@@ -835,12 +870,13 @@ vtkParallelImageSpaceRedistributor::WhichProcessorsForCell(double *pts,
return dest;
}
// ****************************************************************************
// Method: vtkParallelImageSpaceRedistributor::IncrementOutgoingCellCounts()
//
// Purpose:
// Almost identical to WhichProcessorsForCell, except that instead of
// returning a list of outgoing processors, it
// Almost identical to WhichProcessorsForCell, except that instead of
// returning a list of outgoing processors, it
//
// Note: Currently assumes a horizontal banding!
//
......@@ -854,7 +890,6 @@ vtkParallelImageSpaceRedistributor::WhichProcessorsForCell(double *pts,
// Creation: October 26, 2004
//
// Modifications:
//
// Hank Childs, Sun May 23 16:12:11 CDT 2010
// Calculate the number of VTK points in the cells as well.
//
......@@ -862,10 +897,8 @@ vtkParallelImageSpaceRedistributor::WhichProcessorsForCell(double *pts,
void
vtkParallelImageSpaceRedistributor::IncrementOutgoingCellCounts(double *pts,
vtkIdType npts,
vtkIdType *cellPts,
vector<int> &outgoingCellCount,
vector<int> &outgoingPointCount)
vtkIdType npts, vtkIdType *cellPts, vector<int> &outgoingCellCount,
vector<int> &outgoingPointCount)
{
//
// See WhichProcessorsForCell for more notes
......@@ -901,6 +934,7 @@ vtkParallelImageSpaceRedistributor::IncrementOutgoingCellCounts(double *pts,
}
}
// ****************************************************************************
// Method: vtkParallelImageSpaceRedistributor::CreateWorldToDisplayMatrix()
//
......@@ -945,4 +979,3 @@ vtkParallelImageSpaceRedistributor::CreateWorldToDisplayMatrix()
return M3;
}
......@@ -43,10 +43,13 @@
#ifndef __vtkParallelImageSpaceRedistributor_h
#define __vtkParallelImageSpaceRedistributor_h
#include <plotter_exports.h>
#include <vtkRenderer.h>
#include <vector>
#include <vtkPolyDataToPolyDataFilter.h>
#include <vtkCell.h>
#include <vtkPolyDataAlgorithm.h>
#include <vtkRenderer.h>
#ifdef PARALLEL
#include <mpi.h>
#endif
......@@ -55,10 +58,10 @@
// Class: vtkParallelImageSpaceRedistributor
//
// Purpose:
// This will redistribute data into spatially disparate regions
// by processor. The idea is to sort the data front to back for
// transparency calculations in image space, not in the data's
// coordinate space, in order to avoid transparency errors.
// This will redistribute data into spatially disparate regions
// by processor. The idea is to sort the data front to back for
// transparency calculations in image space, not in the data's
// coordinate space, in order to avoid transparency errors.
//
// Programmer: Chris Wojtan
// Creation: July 6, 2004
......@@ -82,15 +85,18 @@
// Hank Childs, Sun May 23 16:12:11 CDT 2010
// Add argument to IncrementOutgoingCellTypes.
//
// Eric Brugger, Wed Jan 9 10:32:26 PST 2013
// Modified to inherit from vtkPolyDataAlgorithm.
//
// ****************************************************************************
class PLOTTER_API vtkParallelImageSpaceRedistributor :
public vtkPolyDataToPolyDataFilter
public vtkPolyDataAlgorithm
{
public:
static vtkParallelImageSpaceRedistributor *New();
vtkPolyData *GetOutput();
vtkPolyData *GetOutput();
void SetRenderer(vtkRenderer *renderer) {ren = renderer;};
void SetRankAndSize(int r, int s);
#ifdef PARALLEL
......@@ -100,11 +106,13 @@ class PLOTTER_API vtkParallelImageSpaceRedistributor :
vtkParallelImageSpaceRedistributor();
virtual ~vtkParallelImageSpaceRedistributor();
virtual void Execute(void);
virtual int RequestData(vtkInformation *, vtkInformationVector **,
vtkInformationVector *);
private:
vtkParallelImageSpaceRedistributor(
const vtkParallelImageSpaceRedistributor &);
const vtkParallelImageSpaceRedistributor &);
void operator=(const vtkParallelImageSpaceRedistributor &);
vtkRenderer *ren;
......
......@@ -192,6 +192,9 @@ avtTubeFilter::Equivalent(const AttributeGroup *a)
// Kathleen Biagas, Tue Aug 7 10:52:13 PDT 2012
// Send the scale variable to the vtk tube filter when needed.
//
// Eric Brugger, Wed Jan 9 13:17:11 PST 2013
// Modified to inherit from vtkPolyDataAlgorithm.
//
// ****************************************************************************
vtkDataSet *
......@@ -245,7 +248,7 @@ avtTubeFilter::ExecuteData(vtkDataSet *in_ds, int, std::string)
// Note -- if we're scaling by a variable, our vtkConnectedTubeFilter
// doesn't yet support this, so fall back to the old VTK one.
if (atts.GetScaleByVarFlag()==false &&
tube->BuildConnectivityArrays())
tube->BuildConnectivityArrays((vtkPolyData*)in_ds))
{
tube->SetRadius(scaleFactor);
tube->CreateNormalsOn();
......
......@@ -45,7 +45,10 @@
#include <stdlib.h>
#include <vtkCellData.h>
#include <vtkExecutive.h>
#include <vtkGenericCell.h>
#include <vtkInformation.h>
#include <vtkInformationVector.h>
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
#include <vtkPolyData.h>
......@@ -60,38 +63,39 @@ typedef struct
vtkStandardNewMacro(vtkAxisDepthSort);
// ****************************************************************************
// Modifications:
//
// Hank Childs, Fri Mar 11 08:26:34 PST 2005
// Fix memory leak.
//
// Eric Brugger, Wed Jan 9 11:20:53 PST 2013
// Modified to inherit from vtkPolyDataAlgorithm.
//
// ****************************************************************************
vtkAxisDepthSort::vtkAxisDepthSort()
{
SetNumberOfOutputs(6);
SetNumberOfOutputPorts(6);
// Base class does 0.
vtkPolyData *p = vtkPolyData::New();
vtkSource::SetNthOutput(1, p);
this->GetExecutive()->SetOutputData(1, p);
p->Delete();
p = vtkPolyData::New();
vtkSource::SetNthOutput(2, p);
this->GetExecutive()->SetOutputData(2, p);
p->Delete();
p = vtkPolyData::New();
vtkSource::SetNthOutput(3, p);
this->GetExecutive()->SetOutputData(3, p);
p->Delete();
p = vtkPolyData::New();
vtkSource::SetNthOutput(4, p);
this->GetExecutive()->SetOutputData(4, p);
p->Delete();
p = vtkPolyData::New();
vtkSource::SetNthOutput(5, p);
this->GetExecutive()->SetOutputData(5, p);
p->Delete();
}
......@@ -99,51 +103,75 @@ vtkAxisDepthSort::vtkAxisDepthSort()
vtkPolyData *
vtkAxisDepthSort::GetPlusXOutput(void)
{
return (vtkPolyData *) vtkSource::GetOutput(0);
return vtkPolyData::SafeDownCast(
this->GetExecutive()->GetOutputData(0));
}
vtkPolyData *
vtkAxisDepthSort::GetMinusXOutput(void)
{
return (vtkPolyData *) vtkSource::GetOutput(1);
return vtkPolyData::SafeDownCast(
this->GetExecutive()->GetOutputData(1));
}
vtkPolyData *
vtkAxisDepthSort::GetPlusYOutput(void)
{
return (vtkPolyData *) vtkSource::GetOutput(2);
return vtkPolyData::SafeDownCast(
this->GetExecutive()->GetOutputData(2));
}
vtkPolyData *
vtkAxisDepthSort::GetMinusYOutput(void)
{
return (vtkPolyData *) vtkSource::GetOutput(3);
return vtkPolyData::SafeDownCast(
this->GetExecutive()->GetOutputData(3));
}
vtkPolyData *
vtkAxisDepthSort::GetPlusZOutput(void)
{
return (vtkPolyData *) vtkSource::GetOutput(4);
return vtkPolyData::SafeDownCast(
this->GetExecutive()->GetOutputData(4));
}
vtkPolyData *
vtkAxisDepthSort::GetMinusZOutput(void)
{
return (vtkPolyData *) vtkSource::GetOutput(5);
return vtkPolyData::SafeDownCast(
this->GetExecutive()->GetOutputData(5));
}
void
vtkAxisDepthSort::Execute(void)
// ****************************************************************************
// Modifications:
// Eric Brugger, Wed Jan 9 11:20:53 PST 2013
// Modified to inherit from vtkPolyDataAlgorithm.
//
// ****************************************************************************
int
vtkAxisDepthSort::RequestData(
vtkInformation *vtkNotUsed(request),
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
// get the info objects
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
//
// Initialize some frequently used values.
//
vtkPolyData *input = vtkPolyData::SafeDownCast(
inInfo->Get(vtkDataObject::DATA_OBJECT()));
int i;
vtkPolyData *input = GetInput();
int ncells = input->GetNumberOfCells();
coord_cell_id_pair *pairs = new coord_cell_id_pair[ncells];
......@@ -323,6 +351,8 @@ vtkAxisDepthSort::Execute(void)
//
delete [] loc;
delete [] pairs;
return 1;
}
......@@ -343,5 +373,3 @@ CoordSorter(const void *arg1, const void *arg2)
return 0;
}
......@@ -43,14 +43,14 @@
#ifndef __vtkAxisDepthSort_h
#define __vtkAxisDepthSort_h
#include <visit_vtk_exports.h>
#include <vtkPolyDataToPolyDataFilter.h>
#include <vtkPolyDataAlgorithm.h>
// ****************************************************************************
// Class: vtkAxisDepthSort
//
// Purpose:
// This will sort poly data along all six axes (+x, -x, +y, -y, +z, -z).
// This will sort poly data along all six axes (+x, -x, +y, -y, +z, -z).
//
// Programmer: Hank Childs
// Creation: July 13, 2002
......@@ -59,9 +59,12 @@
// Brad Whitlock, Mon Jul 15 15:43:22 PST 2002
// Added API.
//
// Eric Brugger, Wed Jan 9 10:54:24 PST 2013
// Modified to inherit from vtkPolyDataAlgorithm.
//
// ****************************************************************************
class VISIT_VTK_API vtkAxisDepthSort : public vtkPolyDataToPolyDataFilter
class VISIT_VTK_API vtkAxisDepthSort : public vtkPolyDataAlgorithm
{
public:
static vtkAxisDepthSort *New();
......@@ -77,7 +80,9 @@ class VISIT_VTK_API vtkAxisDepthSort : public vtkPolyDataToPolyDataFilter
vtkAxisDepthSort();
virtual ~vtkAxisDepthSort() {;};
virtual void Execute(void);
virtual int RequestData(vtkInformation *,
vtkInformationVector **,
vtkInformationVector *);
private:
vtkAxisDepthSort(const vtkAxisDepthSort &);
......@@ -86,5 +91,3 @@ class VISIT_VTK_API vtkAxisDepthSort : public vtkPolyDataToPolyDataFilter
#endif
......@@ -42,6 +42,8 @@
#include <vtkCellData.h>
#include <vtkCleanPolyData.h>
#include <vtkFloatArray.h>
#include <vtkInformation.h>
#include <vtkInformationVector.h>
#include <vtkMath.h>
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
......@@ -95,7 +97,6 @@ vtkConnectedTubeFilter::PointSequence::~PointSequence()
// Creation: November 1, 2002
//
// Modifications:
//
// Hank Childs (for Jeremy Meredith), Mon Apr 7 11:46:51 PDT 2003
// Increased size of cellindex.
//
......@@ -144,7 +145,6 @@ vtkConnectedTubeFilter::PointSequence::Add(int i, int ci)
// Creation: November 1, 2002
//
// Modifications:
//
// Rich Cook and Hank Childs, Thu Oct 2 16:32:55 PDT 2008
// Initialized data member used for supporting loops.
//
......@@ -255,7 +255,6 @@ vtkConnectedTubeFilter::PointSequenceList::Build(vtkPoints *points,
// Creation: November 1, 2002
//
// Modifications:
//
// Rich Cook and Hank Childs, Thu Oct 2 16:32:55 PDT 2008
// Initialized data member used for supporting loops.
//
......@@ -416,10 +415,13 @@ vtkConnectedTubeFilter::~vtkConnectedTubeFilter()
// Programmer: Jeremy Meredith
// Creation: November 1, 2002
//
// Modifications:
// Eric Brugger, Wed Jan 9 11:31:17 PST 2013
// Modified to inherit from vtkPolyDataAlgorithm.
//
// ****************************************************************************
bool vtkConnectedTubeFilter::BuildConnectivityArrays()
bool vtkConnectedTubeFilter::BuildConnectivityArrays(vtkPolyData *input)
{
vtkPolyData *input = this->GetInput();
vtkPoints *inPts = NULL;
vtkCellArray *inLines = NULL;
int numPts;
......@@ -450,7 +452,7 @@ bool vtkConnectedTubeFilter::BuildConnectivityArrays()
}
// ****************************************************************************
// Method: vtkConnectedTubeFilter::Execute
// Method: vtkConnectedTubeFilter::RequestData
//
// Purpose:
// Normal vtk filter execution.
......@@ -459,7 +461,6 @@ bool vtkConnectedTubeFilter::BuildConnectivityArrays()
// Creation: November 1, 2002
//
// Modifications:
//
// Hank Childs, Mon Apr 7 10:02:31 PDT 2003
// Allocate memory for points, because VTK does not do that for you.
//
......@@ -471,11 +472,28 @@ bool vtkConnectedTubeFilter::BuildConnectivityArrays()
// Kathleen Biagas, Thu Sep 6 11:15:29 MST 2012
// Preserve coordinate data type.
//
// Eric Brugger, Wed Jan 9 11:31:17 PST 2013
// Modified to inherit from vtkPolyDataAlgorithm.
//
// ****************************************************************************
void vtkConnectedTubeFilter::Execute()
int vtkConnectedTubeFilter::RequestData(
vtkInformation *vtkNotUsed(request),
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
// get the info objects
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
//
// Initialize some frequently used values.
//
vtkPolyData *input = vtkPolyData::SafeDownCast(
inInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkPolyData *output = vtkPolyData::SafeDownCast(
outInfo->Get(vtkDataObject::DATA_OBJECT()));
// Get all the appropriate input arrays
vtkPolyData *input = this->GetInput();
vtkPoints *inPts = NULL;
vtkCellArray *inLines = NULL;
vtkCellData *inCD = input->GetCellData();
......@@ -489,7 +507,7 @@ void vtkConnectedTubeFilter::Execute()
{
vtkErrorMacro(<< ": Connectivity was not built yet; need to call "
"vtkConnectedTubeFilter::BuildConnectivityArrays()\n");
return;
return 1;
}
if (!(inPts=input->GetPoints()) ||
......@@ -498,13 +516,12 @@ void vtkConnectedTubeFilter::Execute()
(numCells = inLines->GetNumberOfCells()) < 1)
{
vtkDebugMacro(<< ": No input data!\n");
return;
return 1;
}
// Set up the output arrays
int maxNewCells = numCells * (NumberOfSides + 2);
int maxNewPoints = numCells * NumberOfSides * 2;
vtkPolyData *output = this->GetOutput();
vtkPoints *newPts = vtkPoints::New(inPts->GetDataType());
newPts->Allocate(maxNewPoints);
vtkCellArray *newCells = vtkCellArray::New();
......@@ -638,6 +655,8 @@ void vtkConnectedTubeFilter::Execute()
// don't forget the sequence list; we're done with it
delete pseqlist;
pseqlist = NULL;
return 1;
}
// ****************************************************************************
......
......@@ -40,7 +40,7 @@
#define __vtkConnectedTubeFilter_h
#include <visit_vtk_exports.h>
#include "vtkPolyDataToPolyDataFilter.h"
#include "vtkPolyDataAlgorithm.h"
class vtkCellArray;
class vtkPoints;
......@@ -55,14 +55,17 @@ class vtkPoints;
// Programmer: Jeremy Meredith
// Creation: November 1, 2002
//
// Modifications:
// Eric Brugger, Wed Jan 9 11:29:49 PST 2013
// Modified to inherit from vtkPolyDataAlgorithm.
//
// ****************************************************************************
class VISIT_VTK_API vtkConnectedTubeFilter :
public vtkPolyDataToPolyDataFilter
class VISIT_VTK_API vtkConnectedTubeFilter : public vtkPolyDataAlgorithm
{
public:
vtkTypeMacro(vtkConnectedTubeFilter,vtkPolyDataToPolyDataFilter);
vtkTypeMacro(vtkConnectedTubeFilter,vtkPolyDataAlgorithm);
void PrintSelf(ostream& os, vtkIndent indent);
bool BuildConnectivityArrays();
bool BuildConnectivityArrays(vtkPolyData *);
// Description:
// Construct object with radius 0.5, radius variation turned off, the number
......@@ -119,7 +122,6 @@ class VISIT_VTK_API vtkConnectedTubeFilter :
// Encapsulates a list of separate point sequences.
//
// Modifications:
//
// Rich Cook and Hank Childs, Thu Oct 2 16:31:45 PDT 2008
// Added data member to support tubing over loops.
//
......@@ -150,8 +152,9 @@ class VISIT_VTK_API vtkConnectedTubeFilter :
vtkConnectedTubeFilter();
~vtkConnectedTubeFilter();
// Usual data generation method
void Execute();
virtual int RequestData(vtkInformation *,
vtkInformationVector **,
vtkInformationVector *);
float Radius; // minimum radius of tube
int NumberOfSides; // number of sides to create tube
......
......@@ -42,6 +42,8 @@
#include <vtkCellData.h>
#include <vtkEdgeTable.h>
#include <vtkExtractEdges.h>
#include <vtkInformation.h>
#include <vtkInformationVector.h>
#include <vtkMergePoints.h>
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
......@@ -49,7 +51,6 @@
#include <vtkPolyData.h>
#include <vtkUnsignedIntArray.h>
//------------------------------------------------------------------------------
// Modifications:
// Kathleen Bonnell, Wed Mar 6 15:14:29 PST 2002
......@@ -76,7 +77,6 @@ vtkLinesFromOriginalCells::~vtkLinesFromOriginalCells()
// Generate feature edges for mesh
//
// Modifications:
//
// Kathleen Bonnell, Mon Oct 29 13:22:36 PST 2001
// Make pts of type vtkIdType to match VTK 4.0 API.
//
......@@ -104,13 +104,28 @@ vtkLinesFromOriginalCells::~vtkLinesFromOriginalCells()
// Hank Childs, Thu Mar 10 09:48:47 PST 2005
// Fix memory leak.
//
// Eric Brugger, Wed Jan 9 11:44:42 PST 2013
// Modified to inherit from vtkPolyDataAlgorithm.
//