src/aclvis/Tool.cpp

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 * This program was prepared by PSI. 
 * All rights in the program are reserved by PSI.
 * Neither PSI nor the author(s)
 * makes any warranty, express or implied, or assumes any liability or
 * responsibility for the use of this software
 *
 * Visit http://www.acl.lanl.gov/POOMS for more details
 *
 ***************************************************************************/

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 *
 * Visit http://people.web.psi.ch/adelmann/ for more details
 *
 ***************************************************************************/

#include "aclvis/Tool.h"
#include "Profile/Profiler.h"

// Tool

Tool::Tool() {
  TAU_PROFILE("Tool::Tool()", "void ()", TAU_VIZ);
  SetUpdatePolicy(Once);
}

Tool::~Tool()
{
}

void 
Tool::SetUpdatePolicy(UpdatePolicyType param_update_policy) {
  TAU_PROFILE("Tool::SetUpdatePolicy()", "void (UpdatePolicyType)", TAU_VIZ);
  updatePolicy = param_update_policy;
  switch (updatePolicy) {
  case Zero:
    updateCount=1;
    break;
  case Once:
    updateCount=0;
    break;
  case Al:
    updateCount=0;
  default:
    break;
  }
}

UpdatePolicyType Tool::GetUpdatePolicy() {
  TAU_PROFILE("Tool::GetUpdatePolicy()", "UpdatePolicyType ()", TAU_VIZ);
  return updatePolicy;
}

int Tool::UpdateTestAndSet() {
  TAU_PROFILE("Tool::UpdateTestAndSet()", "int ()", TAU_VIZ);
  int updateTest;

  updateTest = False;
  switch (updatePolicy) {
  case Zero:
  case Once:
    updateTest = (updateCount < 1);
    // cerr << "UpdateT&S: " << updateTest << " " << updateCount << "\n";
    updateCount++;
    break;
  case Al:
    updateTest = 1;
    // cerr << "UpdateT&S: " << updateTest << " " << updateCount << "\n";
    updateCount++;
    break;
  default:
    break;
  }
  return updateTest;
}

void 
Tool::SetLocalDimensions(int *param_dims) {
  TAU_PROFILE("Tool::SetLocalDimensions()", "void (int *)", TAU_VIZ);
  dims[0] = param_dims[0]; dims[1] = param_dims[1]; dims[2] = param_dims[2];
  //  cerr << "Set Dim: " << dims[0] << "," << dims[1] << "," << dims[2] << "\n";
}

void 
Tool::GetLocalDimensions(int *param_dims) {
  TAU_PROFILE("Tool::GetLocalDimensions()", "void (int *)", TAU_VIZ);
  param_dims[0] = dims[0]; param_dims[1] = dims[1]; param_dims[2] = dims[2];
  //  cerr << "Get Dim: " << dims[0] << "," << dims[1] << "," << dims[2] << "\n";
}

void 
Tool::SetLocalOrigin(float *param_origin){
  TAU_PROFILE("Tool::SetLocalOrigin()", "void (float *)", TAU_VIZ);
  origin[0] = param_origin[0]; origin[1] = param_origin[1]; origin[2] = param_origin[2];
  //  cerr << "Set Origin: " << origin[0] << "," << origin[1] << "," << origin[2] << "\n";
}

void 
Tool::GetLocalOrigin(float *param_origin) {
  TAU_PROFILE("Tool::GetLocalOrigin()", "void (float *)", TAU_VIZ);
  param_origin[0] = origin[0]; param_origin[1] = origin[1]; param_origin[2] = origin[2];
  //  cerr << "Get Origin: " << origin[0] << "," << origin[1] << "," << origin[2] << "\n";
}

void 
Tool::SetLocalAspectRatio(float *param_aspect){
  TAU_PROFILE("Tool::SetLocalAspectRatio()", "void (float *)", TAU_VIZ);
  aspect[0] = param_aspect[0]; aspect[1] = param_aspect[1]; aspect[2] = param_aspect[2];
  //  cerr << "Set Aspect: " << aspect[0] << "," << aspect[1] << "," << aspect[2] << "\n";
}

void 
Tool::GetLocalAspectRatio(float *param_aspect) {
  TAU_PROFILE("Tool::GetLocalAspectRatio()", "void (float *)", TAU_VIZ);
  param_aspect[0] = aspect[0]; param_aspect[1] = aspect[1]; param_aspect[2] = aspect[2];
  //  cerr << "Get Aspect: " << aspect[0] << "," << aspect[1] << "," << aspect[2] << "\n";
}

void 
Tool::SetRange(float *param_range) {
  TAU_PROFILE("Tool::SetRange()", "void (float *)", TAU_VIZ);
  range[0] = param_range[0]; range[1] = param_range[1];
  //  cerr << "Set Range: " << range[0] << " " << range[1] << "\n";
}

void 
Tool::GetRange(float *param_range) {
  TAU_PROFILE("Tool::GetRange()", "void (float *)", TAU_VIZ);
  param_range[0] = range[0]; param_range[1] = range[1];
  //  cerr << "Get Range: " << range[0] << " " << range[1] << "\n";
}

void 
Tool::GetAllValues(int *param_dims, float *param_origin, float *param_aspect, float *param_range) {
  TAU_PROFILE("Tool::GetAllValues()", "void (int *, float *, float *, float *)",
    TAU_VIZ);
  GetLocalDimensions(param_dims);
  GetLocalOrigin(param_origin);
  GetLocalAspectRatio(param_aspect);
  GetRange(param_range);
}

void 
Tool::SetAllValues(int *param_dims, float *param_origin, float *param_aspect, float *param_range) {
  TAU_PROFILE("Tool::SetAllValues()", "void (int *, float *, float *, float *)",
    TAU_VIZ);
  SetLocalDimensions(param_dims);
  SetLocalOrigin(param_origin);
  SetLocalAspectRatio(param_aspect);
  SetRange(param_range);
}



ReadFieldTool::ReadFieldTool() {
  TAU_PROFILE("ReadFieldTool::ReadFieldTool()", "void ()", TAU_VIZ);

  // cerr << "Create: Read Field " << GetOutput() <<"\n";
  UpdateAllValues();
  GetOutput()->DebugOff();
  vizData = new vizStructuredFieldDataType;
}    

ReadFieldTool::~ReadFieldTool()
{
  delete vizData;
}

void 
ReadFieldTool::Execute() {
  TAU_PROFILE("ReadFieldTool::Execute()", "void ()", TAU_VIZ);
  //gather_data;
  //cerr << "Execute:" << Output<< "\n";
}    

void 
ReadFieldTool::UpdateDimensions() {
  TAU_PROFILE("ReadFieldTool::UpdateDimensions()", "void ()", TAU_VIZ);
  int dims[3];

  GetOutput()->GetDimensions(dims); SetLocalDimensions(dims);
  GetOutput()->DebugOff();
}

void 
ReadFieldTool::UpdateOrigin() {
  TAU_PROFILE("ReadFieldTool::UpdateOrigin()", "void ()", TAU_VIZ);
  float origin[3];

  GetOutput()->GetOrigin(origin); SetLocalOrigin(origin);
  GetOutput()->DebugOff();
}

void 
ReadFieldTool::UpdateAspect() {
  TAU_PROFILE("ReadFieldTool::UpdateAspect()", "void ()", TAU_VIZ);
  float aspect[3];

  GetOutput()->GetAspectRatio(aspect); SetLocalAspectRatio(aspect);
  GetOutput()->DebugOff();
}

void 
ReadFieldTool::SetDimensions(int dims[3])
{
  this->GetOutput()->SetDimensions(dims);
  SetLocalDimensions(dims);
}

void 
ReadFieldTool::SetAspectRatio(float aspr[3])
{
  this->GetOutput()->SetAspectRatio(aspr);
  SetLocalAspectRatio(aspr);
}

void 
ReadFieldTool::SetOrigin(float orig[3])
{
  this->GetOutput()->SetOrigin(orig);
  SetLocalOrigin(orig);
}

vizStructuredFieldDataType *
ReadFieldTool::GetVizData() 
{
  return vizData;
}

void 
ReadFieldTool::UpdateRange() {
  TAU_PROFILE("ReadFieldTool::UpdateRange()", "void ()", TAU_VIZ);
  float range[3];

  if ( Output->GetPointData()->GetScalars() ) {
      Output->GetPointData()->GetScalars()->GetRange(range);
  } else  {
    range[0] = 0.0; range[1] = 1.0;
  } 
  SetRange(range);
  //  cerr << "Set Range: " << range[0] << "..." << range[1] << "\n";
}

void 
ReadFieldTool::UpdateAllValues() {
  TAU_PROFILE("ReadFieldTool::UpdateAllValues()", "void ()", TAU_VIZ);
  UpdateDimensions();  UpdateOrigin();  UpdateAspect();  UpdateRange();
}

int
ReadFieldTool::PrepareFinishedData()
{
  return vizData->InsertFieldData(this->GetOutput());
}



ReadParticleTool::ReadParticleTool() {
  TAU_PROFILE("ReadFieldTool::ReadParticleTool()", "void ()", TAU_VIZ);

  // cerr << "Create Read Particle: " << GetOutput() <<"\n";
  //  DebugOn();
  vtkIndent indent;
  vizData = new vizParticleDataType;
  //PrintSelf(cerr, indent);
}    

ReadParticleTool::~ReadParticleTool()
{
  delete vizData;
}

void 
ReadParticleTool::Execute() {
  TAU_PROFILE("ReadFieldTool::Execute()", "void ()", TAU_VIZ);
  //gather_data;
  //  cerr << "Execute:" << Output<< "\n";
}    

void 
ReadParticleTool::UpdateRange() {
  TAU_PROFILE("ReadFieldTool::UpdateRange()", "void ()", TAU_VIZ);
  float range[3];

  if ( Output->GetPointData()->GetScalars() ) {
      Output->GetPointData()->GetScalars()->GetRange(range);
  } else  {
    range[0] = 0.0; range[1] = 1.0;
  } 
  SetRange(range);
  //  cerr << "Set Range: " << range[0] << "..." << range[1] << "\n";
}

int
ReadParticleTool::PrepareFinishedData()
{
  vizData->InsertParticleData(this->GetOutput());
  this->Update();
  return 1;
}

vizParticleDataType *
ReadParticleTool::GetVizData() 
{
  return vizData;
}


// Class: Filter Tool
FilterTool::FilterTool() {
  TAU_PROFILE("FilTerTool::FilterTool()", "void ()", TAU_VIZ);
  actor = new vtkActor;
  polyMapper = new vtkPolyMapper;
  actor->GetProperty()->SetAmbient(0.1);
}

FilterTool::~FilterTool() {
  TAU_PROFILE("FilterTool::~FilterTool()", "void ()", TAU_VIZ);
  RenderTool *rendertool;
  vtkActor *vtk_actor;

  rendertool = GetRenderTool();

  // cerr << "Filter Tool Delete\n";
  vtk_actor = GetActor();
  rendertool->RemoveActors(vtk_actor);
  rendertool->Render();

  delete vtk_actor;
  delete polyMapper;
}

vtkActor* 
FilterTool::GetActor() {
  TAU_PROFILE("FilterTool::GetActor()", "vtkActor * ()", TAU_VIZ);
  return actor;
}

vtkPolyMapper*
FilterTool::GetPolyMapper() {
  TAU_PROFILE("FilterTool::GetPolyMapper()", "vtkPolyMapper * ()", TAU_VIZ);
  return polyMapper;
}

void 
FilterTool::SetReadTool(void *param_readtool) {
  TAU_PROFILE("FilterTool::SetReadTool()", "void (void *)", TAU_VIZ);
  readtool = param_readtool;
}

void*
FilterTool::GetReadTool() {
  TAU_PROFILE("FilterTool::GetReadTool()", "void ()", TAU_VIZ);
  return readtool;
}

void 
FilterTool::SetRenderTool(RenderTool *param_rendertool) {
  TAU_PROFILE("FilterTool::SetRenderTool()", "void (RenderTool *)", TAU_VIZ);
  rendertool = param_rendertool;
}

RenderTool*
FilterTool::GetRenderTool() {
  TAU_PROFILE("FilterTool::GetRenderTool()", "RenderTool* ()", TAU_VIZ);
  return rendertool;
}


void 
FilterTool::FilterToolInit(void *param_readtool, RenderTool *param_rendertool) {
  TAU_PROFILE("FilterTool::FilterToolInit()", "void (void *, RenderTool *)", 
    TAU_VIZ);
  SetReadTool(param_readtool);
  SetRenderTool(param_rendertool);
}


SliceTool::SliceTool(void *param_readtool, RenderTool *param_rendertool) {
  TAU_PROFILE("SliceTool::SliceTool()", "void (void *, RenderTool *)", TAU_VIZ);

  RenderTool *rendertool;
  vtkActor *vtk_actor;
  vtkPolyMapper *p1Mapper;

  int dims[3];
  float origin[3], aspect[3];
  float range[2];


  FilterToolInit(param_readtool, param_rendertool);
  rendertool = GetRenderTool();

  //  cerr << "Slice Tool\n";
  ReadFieldTool *readFieldTool;
  readFieldTool = (ReadFieldTool *)GetReadTool();
  
  readFieldTool->GetAllValues(dims,origin,aspect,range);
  SetAllValues(dims,origin,aspect,range);
  
  p1 = new vtkStructuredPointsGeometryFilter;
  p1Mapper = GetPolyMapper();
  
  //  cerr << "Slice color range: " << range[0] << " " << range[1] << "\n";
  
  p1->SetInput(readFieldTool->GetOutput());
  p1Mapper->SetInput(p1->GetOutput());
  vtk_actor = GetActor();
  vtk_actor->SetMapper(p1Mapper);
  SetSliceType(XY);
  SetSliceValue(origin[sliceType]);
  SetExtent();
  p1Mapper->SetScalarRange(range);
  rendertool->AddActors(vtk_actor);
  rendertool->Render();
}

SliceTool::~SliceTool() {
  TAU_PROFILE("SliceTool::~SliceTool()", "void ()", TAU_VIZ);
  delete p1;
}

vtkStructuredPointsGeometryFilter*
SliceTool::GetStructuredPointsGeometryFilter() {
  TAU_PROFILE("SliceTool::GetStructuredPointsGeometryFilter()", "void ()", 
    TAU_VIZ);
  return p1;
}

int 
SliceTool::GetSliceType() {
  TAU_PROFILE("SliceTool::GetSliceType()", "void ()", TAU_VIZ);
  return sliceType;
}

void 
SliceTool::SetSliceType(int param_sliceType) {
  TAU_PROFILE("SliceTool::SetSliceType()", "void ()", TAU_VIZ);
  sliceType = param_sliceType;
}

float 
SliceTool::GetSliceValue() {
  TAU_PROFILE("SliceTool::GetSliceValue()", "void ()", TAU_VIZ);
  int dims[3];
  float aspect[3], origin[3];
  float range[2];

  GetAllValues(dims, origin, aspect,range);
  return sliceValue*aspect[sliceType]+origin[sliceType];
}

void 
SliceTool::SetSliceValue(float param_sliceValue) {
  TAU_PROFILE("SliceTool::SetSliceValue()", "void (float )", TAU_VIZ);
  int dims[3];
  float aspect[3], origin[3];
  float range[2];

  GetAllValues(dims, origin, aspect,range);
  sliceValue = int((param_sliceValue - origin[sliceType])/aspect[sliceType]);
}

float 
SliceTool::GetLowerBound() {
  TAU_PROFILE("SliceTool::GetLowerBound()", "float ()", TAU_VIZ);
  int dims[3];
  float aspect[3], origin[3];
  float range[2];

  GetAllValues(dims, origin, aspect,range);
  return origin[sliceType];
}

float 
SliceTool::GetUpperBound() {
  TAU_PROFILE("SliceTool::GetUpperBound()", "float ()", TAU_VIZ);
  int dims[3];
  float aspect[3], origin[3];
  float range[2];
  
  GetAllValues(dims, origin, aspect,range);
  return dims[sliceType] * aspect[sliceType] + origin[sliceType];
}

float 
SliceTool::GetValueRange() {
  TAU_PROFILE("SliceTool::GetValueRange()", "float ()", TAU_VIZ);
  return GetUpperBound() - GetLowerBound();
}

void SliceTool::SetExtent() {
  TAU_PROFILE("SliceTool::SetExtent()", "void ()", TAU_VIZ);
  int dims[3];

  GetLocalDimensions(dims);

  switch (sliceType) {
  case XY:
    p1->SetExtent(0,dims[0], 0,dims[1], sliceValue, sliceValue);
    break;
  case YZ:
    p1->SetExtent(sliceValue, sliceValue, 0, dims[1], 0, dims[2]);
    break;
  case XZ:
    p1->SetExtent(0,dims[0], sliceValue, sliceValue, 0, dims[2]);
    break;
  default:
    break;
  }
}



IsoSurfaceTool::IsoSurfaceTool(void *param_readtool, RenderTool *param_rendertool) {
  TAU_PROFILE("IsoSurfaceTool::IsoSurfaceTool()", "void (void *, RenderTool * )", TAU_VIZ);
  RenderTool *rendertool;
  ReadFieldTool *readFieldTool;
  vtkActor *vtk_actor;
  vtkPolyMapper *isoMapper;
  int dims[3];
  float origin[3], aspect[3];
  float range[2];  float subrange[2];
  float cvalue;

  FilterToolInit(param_readtool, param_rendertool);
  rendertool = GetRenderTool();
  readFieldTool = (ReadFieldTool *)GetReadTool();
  readFieldTool->GetAllValues(dims,origin,aspect,range);
  SetAllValues(dims,origin,aspect,range);
  
  isoF = new vtkContourFilter;
  isoMapper = GetPolyMapper();
  
  isoF->SetInput(readFieldTool->GetOutput());
  isoMapper->SetInput(isoF->GetOutput());
  vtk_actor = GetActor();
  vtk_actor->SetMapper(isoMapper); 
  
  isoMapper->SetScalarRange(range);
  
  cvalue = (range[0]+range[1])/2.0;
  isoF->SetValue(0,cvalue);
  subrange[0] = cvalue; subrange[1] = cvalue;
  SetContourSubRange(subrange);
  SetNumContours(1);
  
  //isoMapper->ScalarsVisibleOff();
  //  vtk_actor->GetProperty()->SetColor(1.0,1.0,1.0);
  
  rendertool->AddActors(vtk_actor);
  rendertool->Render();
}

IsoSurfaceTool::~IsoSurfaceTool() {
  TAU_PROFILE("IsoSurfaceTool::~IsoSurfaceTool()", "void ()", TAU_VIZ);
  //  cerr << "IsoSurfaceTool delete \n";
  delete isoF;
}

vtkContourFilter*
IsoSurfaceTool::GetContourFilter() {
  TAU_PROFILE("IsoSurfaceTool::GetContourFilter()", "vtkContourFilter* ()", TAU_VIZ);
  return isoF;
}

void 
IsoSurfaceTool::SetNumContours(int param_numContours) {
  TAU_PROFILE("IsoSurfaceTool::SetNumContours()", "void (int)", TAU_VIZ);
  numContours = param_numContours;
}

int 
IsoSurfaceTool::GetNumContours() {
  TAU_PROFILE("IsoSurfaceTool::GetNumContours()", "int ()", TAU_VIZ);
  return numContours;
}

void 
IsoSurfaceTool::SetContourSubRange(float *param_srange) {
  TAU_PROFILE("IsoSurfaceTool::SetContourSubRange()", "void (float *)", TAU_VIZ);
  srange[0] = param_srange[0];
  srange[1] = param_srange[1];
}

void 
IsoSurfaceTool::GetContourSubRange(float *param_srange) {
  TAU_PROFILE("IsoSurfaceTool::GetContourSubRange()", "void (float * )", TAU_VIZ);
  param_srange[0] = srange[0];
  param_srange[1] = srange[1];
}



void RenderTool::SetRenderer(vtkRenderer *ren1) {
  TAU_PROFILE("RenderTool::SetRenderer()", "void (vtkRenderer * )", TAU_VIZ);
    renderer = ren1;
}

void RenderTool::SetRenderWindow(vtkXRenderWindow *renWin) {
  TAU_PROFILE("RenderTool::SetRenderWindow()", "void (vtkXRenderWindow * )", 
    TAU_VIZ);
    render_window = renWin;
}

vtkRenderer *RenderTool::GetRenderer() {
  TAU_PROFILE("RenderTool::GetRenderer()", "vtkRenderer * ()", TAU_VIZ);
  return renderer;
}

//vtkXRenderWindow *RenderTool::GetRenderWindow() {
//  return render_window;
//}

vtkRenderWindow *RenderTool::GetRenderWindow() {
  TAU_PROFILE("RenderTool::GetRenderWindow()", "vtkRenderWindow *()", TAU_VIZ);
  return render_window;
}

RenderTool::RenderTool() {
  TAU_PROFILE("RenderTool::RenderTool()", "void ()", TAU_VIZ);
number_of_actors = 0;
}

void RenderTool::ResetCamera(){
  TAU_PROFILE("RenderTool::ResetCamera()", "void ()", TAU_VIZ);
  renderer->ResetCamera();
  render_window->Render();
}

void RenderTool::AddActors(vtkActor *actor){
  TAU_PROFILE("RenderTool::AddActors()", "void (vtkActor * )", TAU_VIZ);
  number_of_actors++;
  renderer->AddActors(actor);
  if (number_of_actors == 1) {
    ResetCamera();
  }
}

void RenderTool::RemoveActors(vtkActor *actor){
  TAU_PROFILE("RenderTool::RemoveActors()", "void (vtkActor * )", TAU_VIZ);
  number_of_actors--;
  renderer->RemoveActors(actor);
}


void RenderTool::Render(){
  TAU_PROFILE("RenderTool::Render()", "void ()", TAU_VIZ);
  render_window->Render();
}



PointTool::PointTool(void *param_readtool, RenderTool *param_rendertool) {
  TAU_PROFILE("PointTool::PointTool()", "void (void *, RenderTool * )", TAU_VIZ);

  RenderTool *rendertool;
  vtkActor *vtk_actor;
  vtkPolyMapper *polyMapper;
  int dims[3];
  float origin[3], aspect[3];
  float range[2];
  
  FilterToolInit(param_readtool, param_rendertool);
  rendertool = GetRenderTool();

  ReadParticleTool *readParticleTool;
  readParticleTool = (ReadParticleTool *)GetReadTool();
  
  readParticleTool->GetAllValues(dims,origin,aspect,range);
  SetAllValues(dims,origin,aspect,range);

  polyMapper = GetPolyMapper();
  
  polyMapper->SetInput(readParticleTool->GetOutput());
  polyMapper->SetScalarRange(range);
  vtk_actor = GetActor();
  vtk_actor->SetMapper(polyMapper); 
  vtk_actor->GetProperty()->SetAmbient(1.0);
  vtk_actor->GetProperty()->SetSpecular(1.0);
  rendertool->AddActors(vtk_actor);
  rendertool->Render();
}


PointTool::~PointTool() {
  TAU_PROFILE("PointTool::~PointTool()", "void ()", TAU_VIZ);
}




vizTraceTool::vizTraceTool()
{
  TAU_PROFILE("vizTraceTool::vizTraceTool()", "void ()", TAU_VIZ);
  traceCollection = new vtkCollection;
  apd = new vtkAppendPolyData;

  traceNumber = 1;
  traceIter = 0;
}

vizTraceTool::~vizTraceTool() 
{
  TAU_PROFILE("vizTraceTool::~vizTraceTool()", "void ()", TAU_VIZ);
  delete traceCollection;
  delete apd;
}

int
vizTraceTool::AppendPolyData(vtkPolyData *newPolyData)
{
  TAU_PROFILE("vizTraceTool::AppendPolyData()", "int (ReadParticleTool * )", TAU_VIZ);
  vtkPolyData *pt;
  vtkPolyData *stalePolyData;

  if ((traceNumber >= 1)) {
    // if trace stack is filled, remove oldest data
    if (traceIter == traceNumber) {
      traceCollection->InitTraversal();
      stalePolyData = (vtkPolyData*)(traceCollection->GetNextItemAsObject());
      apd->RemoveInput(stalePolyData);
      traceCollection->RemoveItem(stalePolyData);
      IterateTraceIter(-1);
      // if trace stack is exceeded, remove old data until trace stack has one
      // less than the stack capacity (traceNumber)
    } else if (traceIter > traceNumber) {
      CullStalePolyData();
    }
    // add the next set of data to end of stack
    pt = new vtkPolyData(*newPolyData);
    apd->AddInput(pt);
    traceCollection->AddItem(pt);
    IterateTraceIter();
  }    
  return 1;
}

int
vizTraceTool::CullStalePolyData(int fromSetFlag) 
{
  TAU_PROFILE("vizTraceTool::CullStalePolyData()", "int (int )", TAU_VIZ);
  int          i;
  int          diff;
  vtkPolyData *stalePolyData;

  diff = traceIter-traceNumber;
  if (diff > 0) {
    if (fromSetFlag) {
      diff--;
      for (i=0; i <= diff; i++) {
        traceCollection->InitTraversal();
        stalePolyData = (vtkPolyData*)(traceCollection->GetNextItemAsObject());
        apd->RemoveInput(stalePolyData);
        traceCollection->RemoveItem(stalePolyData);
        IterateTraceIter(-1);
      }
    }
  }
  return 1;
}

int
vizTraceTool::SetTraceNumber(int num) 
{
  TAU_PROFILE("vizTraceTool::SetTraceNumber()", "int (int )", TAU_VIZ);
  if (num > 0) {
    traceNumber = num;
  }

  if (traceNumber < traceIter) {
    CullStalePolyData(1);
  }
  return traceNumber;
}

int
vizTraceTool::SetTraceIter(int iter) 
{
  TAU_PROFILE("vizTraceTool::SetTraceIter()", "int (int )", TAU_VIZ);
  if (iter > 0) {
    traceIter = iter;
  } 
  return traceIter;
}

vtkCollection*
vizTraceTool::GetTraceCollection() 
{
  TAU_PROFILE("vizTraceTool::GetTraceCollection()", "vtkCollection * ()", TAU_VIZ);
  return traceCollection;
}

int
vizTraceTool::GetTraceNumber() const 
{
  TAU_PROFILE("vizTraceTool::GetTraceNumber()", "int ()", TAU_VIZ);
  return traceNumber;
}

int
vizTraceTool::GetTraceIter() const 
{
  TAU_PROFILE("vizTraceTool::GetTraceIter()", "int ()", TAU_VIZ);
  return traceIter;
}

vtkAppendPolyData*
vizTraceTool::Getapd() 
{
  TAU_PROFILE("vizTraceTool::Getapd()", "vtkAppendPolyData * ()", TAU_VIZ);
  return apd;
}

int 
vizTraceTool::IterateTraceIter(int amt) 
{
  TAU_PROFILE("vizTraceTool::IterateTraceIter()", "int (int )", TAU_VIZ);
  if (amt == 1) {
    traceIter++;
  } else {
    traceIter = traceIter + amt;
  }

  return traceIter;
}



SphereTool::SphereTool(void *param_readtool, RenderTool *param_rendertool) {
  TAU_PROFILE("SphereTool::SphereTool()", "void (void *, RenderTool * )", 
    TAU_VIZ);

  RenderTool *rendertool;
  int dims[3];
  float origin[3], aspect[3];
  float range[2];

  vtkPolyMapper *glyphMapper;
  vtkActor *vtk_actor;
  vtkPolyData *pt;

  traceCollection = new vtkCollection();

  SetUpdatePolicy(Al);
  FilterToolInit(param_readtool, param_rendertool);
  rendertool = GetRenderTool();

  ReadParticleTool *readParticleTool;
  readParticleTool = (ReadParticleTool *)GetReadTool();
  
  readParticleTool->GetAllValues(dims,origin,aspect,range);
  SetAllValues(dims,origin,aspect,range);

  sphere = new vtkSphereSource;
  sphere->SetRadius(1.0);
  sphere->SetThetaResolution(1.0);
  sphere->SetPhiResolution(1.0);

  if (traceNumber >= 1) {
    apd = new vtkAppendPolyData;

    pt = new vtkPolyData(*readParticleTool->GetOutput());
    apd->AddInput(pt);
    traceCollection->AddItem(pt);

    glyph = new vtkGlyph3D;
    glyph->SetSource(sphere->GetOutput());
    glyph->SetInput(apd->GetOutput());
    
    IterateTraceIter();
    //cout << "traceIter = " << traceIter << endl;
   } 
  
  glyph->ScalingOff();

  // Now map glyphs
  glyphMapper = GetPolyMapper();
    glyphMapper->SetScalarRange(range);
    glyphMapper->SetInput(glyph->GetOutput());

  vtk_actor = GetActor();
    vtk_actor->SetMapper(glyphMapper);

  rendertool->AddActors(vtk_actor);
  rendertool->Render();
}

SphereTool::~SphereTool() {
  TAU_PROFILE("SphereTool::~SphereTool()", "void ()", TAU_VIZ);
  delete glyph;
  delete sphere;
}

vtkSphereSource*
SphereTool::GetSphereSource() {
  TAU_PROFILE("SphereTool::GetSphereSource()", "vtkSphereSource * ()", TAU_VIZ);
  return sphere;
}



vizVectorTool::vizVectorTool()
{
  tubeArrow = 0;// set to 1 to make arrows out of tubes
  
  if (!(vectorRepPolyData = new vtkPolyData))
    cerr << "Problem allocating vectorRepPolyData" << endl;

  vectGlyph = NULL;
  arrowTubeRadius = 0.05;
  numTubeFacets = 3;
}

vizVectorTool::~vizVectorTool()
{
  delete vectorRepPolyData;
  if (vectGlyph)
    delete vectGlyph;
}

void 
vizVectorTool::SetScaleFactor(float scaleFact) 
{
  TAU_PROFILE("vizVectorTool::SetScaleFactor()", "void (float )", TAU_VIZ);
  if (scaleFact>=0) {
    scaleFactor = scaleFact;
    vectGlyph->SetScaleFactor(scaleFactor);
  } else {
    cerr << "Scale Factor must be greater than zero" << endl;
  }
}

void 
vizVectorTool::SetScaleByValue(int scaleByVal) 
{
  TAU_PROFILE("vizVectorTool::SetScaleByValue()", "void (int )", TAU_VIZ);

  if (scaleByVal==0 || scaleByVal==1) {
    scaleByValue = scaleByVal;
    vectGlyph->SetScaleMode(scaleByValue);
  } else {
    cerr << "scale By Value must be either 0 (scale) or 1 (vector)" << endl;
  }
}

void
vizVectorTool::FlipTubeArrowFlag() 
{

  tubeArrow = (tubeArrow == 1 ? 0:1);
//   if (tubeArrow==1) {
//     tubeArrow = 0;
//   } else if (tubeArrow==0) {
//     tubeArrow = 1;
//   }
  
  delete vectorRepPolyData;
  MakeUnitArrowPolyData(vectorRepPolyData);
  vectGlyph->SetSource(vectorRepPolyData);
  vectGlyph->Update();
}

void
vizVectorTool::SetArrowTubeRadius(float rad)
{
  if (rad>=0) {
    arrowTubeRadius = rad;
  }

  delete vectorRepPolyData;
  MakeUnitArrowPolyData(vectorRepPolyData);
  vectGlyph->SetSource(vectorRepPolyData);
  vectGlyph->Update();
}

void
vizVectorTool::SetNumberOfTubeFacets(int facets)
{
  if (facets >= 3)
    numTubeFacets = facets;

  delete vectorRepPolyData;
  MakeUnitArrowPolyData(vectorRepPolyData);
  vectGlyph->SetSource(vectorRepPolyData);
  vectGlyph->Update();
}

float
vizVectorTool::GetScaleFactor() const 
{
  TAU_PROFILE("vizVectorTool::GetScaleFactor()", "float ()", TAU_VIZ);
  return scaleFactor;
}

int 
vizVectorTool::GetScaleByValue() const 
{
  TAU_PROFILE("vizVectorTool::GetScaleByValue()", "int ()", TAU_VIZ);
  return scaleByValue;
}

int 
vizVectorTool::GetTubeArrowFlag() const
{
  return tubeArrow;
}

float
vizVectorTool::GetArrowTubeRadius() const
{
  return arrowTubeRadius;
}

int
vizVectorTool::GetNumberOfTubeFacets() const
{
  return numTubeFacets;
}

void 
vizVectorTool::MakeUnitArrowPolyData(vtkPolyData *&arrowPolyData)
{
  TAU_PROFILE("vizVectorTool::MakeUnitArrowPolyData()", "void (vtkPolyData * )",
    TAU_VIZ);
  // vtkPolyData requires points and 
  // connectivity information. The points
  // are provided by vtFloatPoints and 
  // the connectivity is provided by a vtkCellArray
  vtkCellArray   *lines;
  vtkFloatPoints *points;
  vtkPolyData    *arrowLinePolyData;
  vtkTubeFilter  *arrowTubeFilter;

  int i;
  // Create the arrays that define the end points of the
  // lines that make the arrow, and create the connectivity that
  // produces an arrow using those points
  static float x[6][3]={{0,0,0}, 
                        {1,0,0}, 
                        {0.8,0.15,0.0}, 
                        {0.8,-0.075, 0.13}, 
                        {0.8,-0.075,-0.13}  };

  static int pts[4][2]={0,1, 1,2, 1,3, 1,4};

  points           = new vtkFloatPoints(4);
  lines            = new vtkCellArray;

  for (i=0; i<5; i++) points->InsertPoint( i, x[i]);
  for (i=0; i<4; i++) lines->InsertNextCell( 2, pts[i]);

  arrowLinePolyData = new vtkPolyData;
    arrowLinePolyData->SetPoints(points);
    points->Delete();
    arrowLinePolyData->SetLines(lines);
    lines->Delete();

  if (tubeArrow) {
    arrowTubeFilter = new vtkTubeFilter;
      arrowTubeFilter->SetInput(arrowLinePolyData);
      arrowTubeFilter->SetRadius(arrowTubeRadius);
      arrowTubeFilter->SetVaryRadius(VTK_VARY_RADIUS_OFF);
      arrowTubeFilter->SetNumberOfSides(numTubeFacets);
    
      arrowTubeFilter->Update();
      arrowPolyData = new vtkPolyData(*arrowTubeFilter->GetOutput());
      vectorRepPolyData->Update();
      arrowTubeFilter->Delete();
      arrowLinePolyData->Delete();

  } else {
    vectorRepPolyData = arrowLinePolyData;
  }

  arrowPolyData->BuildCells();
}


vizVectorFieldTool::vizVectorFieldTool() 
{
  TAU_PROFILE("vizVectorFieldTool::vizVectorFieldTool()", "void ()", TAU_VIZ);

};

vizVectorFieldTool::vizVectorFieldTool(void *param_readtool, RenderTool *param_rendertool) {
  TAU_PROFILE("vizVectorFieldTool::vizVectorFieldTool()", 
    "void (void *, RenderTool *)", TAU_VIZ);

  RenderTool       *rendertool;
  ReadFieldTool    *readFieldTool; // reader of vtkStructuredPointData
  vtkPolyMapper    *vectFieldMapper;
  vtkActor         *vectFieldActor;

  FilterToolInit(param_readtool, param_rendertool);
  rendertool = GetRenderTool();
  readFieldTool = (ReadFieldTool *)GetReadTool();

  scaleFactor = 1.0;
  // Check the FieldTool data to see if it contains 
  // vector information. If yes, create the vector
  // field glyph; if not, report an error
  if (readFieldTool->GetOutput()->GetPointData()->GetVectors()) {

    //    vectorRepPolyData = new vtkPolyData;

    // make vtkPolyData that defines the shape of a
    // unit arrow, to use as the glyph source
    MakeUnitArrowPolyData(vectorRepPolyData);

    // make vectorField glyph
    vectGlyph = new vtkGlyph3D;
     vectGlyph->SetInput(readFieldTool->GetOutput());
     vectGlyph->SetSource(vectorRepPolyData);
     vectGlyph->OrientOn();
     vectGlyph->UseVector();
     vectGlyph->ScaleByVector();
     vectGlyph->SetScaleFactor(scaleFactor);
     // Set vtkPolyMapper to the vtkPolyMapper allocated
     // for this FilterTool, and give it the field glyph data
    vectFieldMapper = GetPolyMapper();
     vectFieldMapper->SetInput(vectGlyph->GetOutput());
     // Set actor to point to the actor allocated
     // for this FilterTool
    vectFieldActor = GetActor();
     vectFieldActor->SetMapper(vectFieldMapper);

     rendertool->AddActors(vectFieldActor);
     rendertool->Render();
  } else {
    cerr << "vtkStructuredPointData contains no vtkVector data" << endl;
  }
}

vizVectorFieldTool::~vizVectorFieldTool()
{
  TAU_PROFILE("vizVectorFieldTool::~vizVectorFieldTool()", "void ()", TAU_VIZ);
}



vizVectorParticleTool::vizVectorParticleTool() 
{
  TAU_PROFILE("vizVectorParticleTool::vizVectorParticleTool()", "void ()", 
    TAU_VIZ);
};

vizVectorParticleTool::vizVectorParticleTool(void *param_readtool, RenderTool *param_rendertool) {
  TAU_PROFILE("vizVectorParticleTool::vizVectorParticleTool()", 
    "void (void *, RenderTool *)", TAU_VIZ);

  RenderTool          *rendertool;
  ReadParticleTool    *readParticleTool; // reader of vtkPolyData
  vtkPolyMapper       *vectParticleMapper;
  vtkActor            *vectParticleActor;

  SetUpdatePolicy(Al);
  FilterToolInit(param_readtool, param_rendertool);
  rendertool = GetRenderTool();
  readParticleTool = (ReadParticleTool *)GetReadTool();

  scaleFactor = 1.0;
  // Check the ParticleTool data to see if it contains 
  // vector information. If yes, create the vector
  // field glyph; if not, report an error
  if (readParticleTool->GetOutput()->GetPointData()->GetVectors()) {

    //    vectorRepPolyData = new vtkPolyData;
    // make vtkPolyData that defines the shape of a
    // unit arrow, to use as the glyph source

    MakeUnitArrowPolyData(vectorRepPolyData);

    // make vector glyph
    if (traceNumber >= 1) {
      vtkPolyData *pt;
      apd = new vtkAppendPolyData;

      pt = new vtkPolyData(*readParticleTool->GetOutput());
      apd->AddInput(pt);
      traceCollection->AddItem(pt);

      vectGlyph = new vtkGlyph3D;
        vectGlyph->SetInput(apd->GetOutput());
        vectGlyph->SetSource(vectorRepPolyData);
        vectGlyph->OrientOn();
        vectGlyph->UseVector();
        vectGlyph->ScaleByVector();
        vectGlyph->SetScaleFactor(scaleFactor);
        IterateTraceIter();
    }

     // Set vtkPolyMapper to the vtkPolyMapper allocated
     // for this FilterTool, and give it the field glyph data
    vectParticleMapper = GetPolyMapper();
     vectParticleMapper->SetInput(vectGlyph->GetOutput());
     vectParticleMapper->ScalarsVisibleOff(); // So that the color can be set in the actor
     // Set actor to point to the actor allocated
     // for this FilterTool
    vectParticleActor = GetActor();
     vectParticleActor->SetMapper(vectParticleMapper);
     vectParticleActor->GetProperty()->SetColor(1.0, 0.0, 0.0);

     rendertool->AddActors(vectParticleActor);
     rendertool->Render();
  } else {
    cerr << "vtkStructuredPointData contains no vtkVector data" << endl;
  }
}

vizVectorParticleTool::~vizVectorParticleTool()
{
  TAU_PROFILE("vizVectorParticleTool::~vizVectorParticleTool()", "void ()", 
    TAU_VIZ);
}



vizAxesTool::vizAxesTool() 
{
  TAU_PROFILE("vizAxesTool::vizAxesTool()", "void ()", TAU_VIZ);
}

vizAxesTool::vizAxesTool(void *param_readtool, RenderTool *param_rendertool) {
  TAU_PROFILE("vizAxesTool::vizAxesTool()", "void (void *, RenderTool * )", 
    TAU_VIZ);

  RenderTool     *renderTool;

  vtkPolyMapper  *axesMapper;
  vtkActor       *axesActor;

  FilterToolInit(param_readtool, param_rendertool);
  renderTool = GetRenderTool();

  if (!GetMaxSideLenOfGlobalBoundingBox(renderTool, scaleFactor)) {
    scaleFactor = 1;
  }

  axes = new vtkAxes;
    axes->SetScaleFactor(scaleFactor);               // SCALE
  axesMapper = GetPolyMapper();
    axesMapper->SetInput(axes->GetOutput());
  axesActor = GetActor();
    axesActor->SetMapper(axesMapper);
    axesActor->GetProperty()->SetColor(1, 0, 0);
    axesActor->GetProperty()->SetAmbient(0.5);
    axesActor->GetProperty()->SetDiffuse(0.1);
    axesActor->GetProperty()->SetSpecular(0.1);
    axesActor->SetScale(1,1,1);

  renderTool->AddActors(axesActor);
}

vizAxesTool::~vizAxesTool() 
{
  TAU_PROFILE("vizAxesTool::~vizAxesTool()", "void ()", TAU_VIZ);
  delete axes;
}

int 
vizAxesTool::SetScaleFactor(float scaleFact) 
{
  TAU_PROFILE("vizAxesTool::SetScaleFactor()", "int (float )", TAU_VIZ);
  scaleFactor = scaleFact;
  axes->SetScaleFactor(scaleFactor);               // SCALE
  return 1;
}

float
vizAxesTool::GetScaleFactor() const
{
  TAU_PROFILE("vizAxesTool::GetScaleFactor()", "float ()", TAU_VIZ);
  return scaleFactor;
}

int
vizAxesTool::GetMaxSideLenOfGlobalBoundingBox(RenderTool *ren, float& maxSide)
{
  TAU_PROFILE("vizAxesTool::GetMaxSideLenOfGlobalBoundingBox()", 
    "int (RenderTool *, float )", TAU_VIZ);
  float    bounds[6];
  float    side[3];
  int      success = 0;
  
  if (GetGlobalBoundingBox(ren, bounds)) {
    // get the lengths of the bounding box sides
    side[0] = bounds[1] - bounds[0];
    side[1] = bounds[3] - bounds[2];
    side[2] = bounds[5] - bounds[4];

    // find the maximum extent (side) of the 
    // bounding box (i.e. the length of the 
    // longest side of the bounding box
    if (side[0] > side[1]) {
      maxSide = side[0];
    } else {
      maxSide = side[1];
    }
    if (side[2] > maxSide) {
      maxSide = side[2];
    }
    success = 1;
  }
  return success;
}

int
vizAxesTool::GetGlobalBoundingBox(RenderTool *ren, float allBounds[6])
{
  TAU_PROFILE("vizAxesTool::GetGlobalBoundingBox()", 
    "int (RenderTool *, float )", TAU_VIZ);
  vtkVolume          *aVolume;
  vtkActor           *anActor;
  float              *bounds;
  int                 nothingVisible = 1;
  vtkActorCollection *Actors;
  vtkVolumeRenderer  *VolumeRenderer;
  int                 success = 0;

  allBounds[0] = allBounds[2] = allBounds[4] = VTK_LARGE_FLOAT;
  allBounds[1] = allBounds[3] = allBounds[5] = -VTK_LARGE_FLOAT;

  // get pointer to actors assigned to the vtkRenderer (ren)
  Actors = ren->GetRenderer()->GetActors();

  // loop through actors (and their parts)
  for ( Actors->InitTraversal(); (anActor = Actors->GetNextItem()); )
    {
    // if it's invisible, or has no geometry, we can skip the rest 
      if ( anActor->GetVisibility() ) { nothingVisible = 0;
        bounds = anActor->GetBounds();

        if (bounds[0] < allBounds[0]) allBounds[0] = bounds[0]; 
        if (bounds[1] > allBounds[1]) allBounds[1] = bounds[1]; 
        if (bounds[2] < allBounds[2]) allBounds[2] = bounds[2]; 
        if (bounds[3] > allBounds[3]) allBounds[3] = bounds[3]; 
        if (bounds[4] < allBounds[4]) allBounds[4] = bounds[4]; 
        if (bounds[5] > allBounds[5]) allBounds[5] = bounds[5]; 
      }
    }

  // loop through volumes if any
  if (ren->GetRenderer()->GetVolumeRenderer())
    {
      // Get pointer to volumes being rendered by render
      VolumeRenderer = ren->GetRenderer()->GetVolumeRenderer();
      for (VolumeRenderer->GetVolumes()->InitTraversal(); 
         (aVolume = VolumeRenderer->GetVolumes()->GetNextItem()); )
      {
      // if it's invisible, we can skip the rest 
      if ( aVolume->GetVisibility() )
        {
        nothingVisible = 0;
        bounds = aVolume->GetBounds();
        
        if (bounds[0] < allBounds[0]) allBounds[0] = bounds[0]; 
        if (bounds[1] > allBounds[1]) allBounds[1] = bounds[1]; 
        if (bounds[2] < allBounds[2]) allBounds[2] = bounds[2]; 
        if (bounds[3] > allBounds[3]) allBounds[3] = bounds[3]; 
        if (bounds[4] < allBounds[4]) allBounds[4] = bounds[4]; 
        if (bounds[5] > allBounds[5]) allBounds[5] = bounds[5]; 
        }
      }
    }

  //  if ( ren->NewVolumeRenderer )
  //    {
    // Add bounds code!!!

  //    }

  if ( nothingVisible )
    {
      cout << "No Actors to bound" << endl;
    } else {
      success = 1;
    }

  return success;
}



vizParticleLineTraceTool::vizParticleLineTraceTool(void *param_readtool, 
                                                   RenderTool *param_rendertool) {
  TAU_PROFILE("SphereTool::SphereTool()", "void (void *, RenderTool * )", 
    TAU_VIZ);

  RenderTool      *rendertool;
  int              dims[3];
  float origin[3], aspect[3];
  float            range[2];
  vtkPolyMapper   *linesTraceMapper;
  vtkActor        *linesActor;

  traceNumber = 10;
  tubeLines = 0;
  SetUpdatePolicy(Al);
  FilterToolInit(param_readtool, param_rendertool);
  rendertool = GetRenderTool();

  ReadParticleTool *readParticleTool;
  readParticleTool = (ReadParticleTool *)GetReadTool();
  
  readParticleTool->GetAllValues(dims,origin,aspect,range);
  SetAllValues(dims,origin,aspect,range);

  // Set the newPolyData to the incoming PolyData when
  // first constructed. Since no data for currentPolyData
  // set initially to NULL

  if (!(tubeFilter = new vtkTubeFilter))
    cerr << "Problem allocating tubeFilter" << endl;

  newPolyData = new vtkPolyData(*readParticleTool->GetOutput());
  currentPolyData = NULL;

  linesTraceMapper = GetPolyMapper();
    linesTraceMapper->SetInput(apd->GetOutput());

  linesActor = GetActor();
    linesActor->SetMapper(linesTraceMapper);

  rendertool->AddActors(linesActor);
  rendertool->Render();
}

vizParticleLineTraceTool::~vizParticleLineTraceTool()
{
  currentPolyData->Delete();
  newPolyData->Delete();
}

void     
vizParticleLineTraceTool::MakeAndAppendNewLines(vtkPolyData *newPD)
{
  int               i;
  int               newNumCells;
  vtkPoints        *currentPDPoints;
  vtkPoints        *newPDPoints;
  float            *currentFloat;
  float            *newFloat;
  vtkFloatPoints   *linePoints        = new vtkFloatPoints(2);
  vtkCellArray     *lineArray         = new vtkCellArray;
  int               pointId           = 0;
  int               connection[2];
  vtkPolyData      *newLinesPolyData  = new vtkPolyData;

  // Two sets of PolyData are required to make a set of lines.
  // The the currentPolyData is the polyData from the previous
  // time step and newPolyData is the polyData from the new
  // time step being added 

  // If this is the first time that this function is called, the
  // current PolyData should not be deleted. 
  // It should be deleted there after.
  if (currentPolyData != NULL) {
    currentPolyData->Delete();
    currentPolyData = newPolyData;
    newPolyData = new vtkPolyData;
    newPolyData->CopyStructure(newPD);

  } else {
    currentPolyData = newPolyData;
    newPolyData = new vtkPolyData;
    newPolyData->CopyStructure(newPD);
  }

  newPolyData->Update();
  currentPolyData->Update();
  newPolyData->BuildCells();

  // Get the points from each PolyData set
  currentPDPoints = currentPolyData->GetPoints(); // polyData's points
  newPDPoints     = newPolyData->GetPoints();
  newNumCells     = newPDPoints->GetNumberOfPoints();  // number of cells

  // Get the idInfo from the newPD that tells which index
  // of the currentPolyData has the data corresponding to 
  // the same particle in the new step
  vizPointData          *newIdInfo;
  newIdInfo = (vizPointData*)(newPD->GetPointData()->GetUserDefined());
  vtkIntScalars *ids = newIdInfo->GetIds();
  int currentId = 0;

  // Extract point pairs from (one from current and one form new) 
  // point sets and form lines for each point id that exists in
  // both point sets
  for (i=0; i<newNumCells; i++) {
    currentId = static_cast<int>( ids->GetScalar(i) );
                                   // get the id of in currentPDPoints
                                   // that contains the data cooresponding
                                   // to the i'th point in the new data

    if (currentId != -1) { // Check if the particle in newPD is
                           // new and therefore does not have a 
                           // corresponding currentPD point value

      // Get pointers to the float positions where the particle
      // was on the last time step (currentFloat), and where the 
      // particle will be on the new time step
      currentFloat = currentPDPoints->GetPoint(currentId);
      newFloat = newPDPoints->GetPoint(i);
        
      // Add the currentFloat and newFlaot to the
      // linePoints and add the point ids to the 
      // lineArray to designate the two points as connected
      connection[0] = pointId;
      linePoints->InsertPoint(pointId++, currentFloat);

      connection[1] = pointId;
      linePoints->InsertPoint(pointId++, newFloat);

      lineArray->InsertNextCell( 2, connection);
    }
  }
  
  newLinesPolyData->SetPoints(linePoints);
  linePoints->Delete();
  newLinesPolyData->SetLines(lineArray);
  lineArray->Delete();

  if (tubeLines) {
    //    TubeIt(newLinesPolyData);
    tubeFilter->SetInput(newLinesPolyData);
    tubeFilter->SetRadius(0.05);
    tubeFilter->SetVaryRadius(VTK_VARY_RADIUS_OFF);
    tubeFilter->SetNumberOfSides(3);
    tubeFilter->Update();

    AppendPolyData(tubeFilter->GetOutput());
    //    tubeFilter->Delete();
  } else {
      AppendPolyData(newLinesPolyData);
  }
}

void
vizParticleLineTraceTool::TubeIt(vtkPolyData *polyLines)
{
  tubeFilter->SetInput(polyLines);
  tubeFilter->SetRadius(0.05);
  tubeFilter->SetVaryRadius(VTK_VARY_RADIUS_OFF);
  tubeFilter->SetNumberOfSides(3);
  tubeFilter->Update();
}

void
vizParticleLineTraceTool::FlipTubeLinesFlag() 
{
  tubeLines = (tubeLines == 1 ? 0:1);
}


vizPointData::vizPointData()
{
  ids = new vtkIntScalars;
}

vizPointData::~vizPointData()
{
  delete ids;
}

vtkIntScalars*
vizPointData::GetIds()
{
  return ids;
}



vizStructuredFieldDataType::vizStructuredFieldDataType() : type(ACLVIS_UNKNOWN),
                             numPoints(0)
{
}

vizStructuredFieldDataType::vizStructuredFieldDataType(unsigned numPts, int ptDataType)
{
  InitData(numPts, ptDataType);
}

vizStructuredFieldDataType::~vizStructuredFieldDataType() 
{
}

int       // See Tool.h for explanation
vizStructuredFieldDataType::InitData(unsigned numPts, int ptDataType) {

   if (numPts > 0) {
     numPoints  = numPts;
   } else {
     cerr << "numPts must be greater than zero" << endl;
     numPoints = 0;
     //     return 0;
   }


  // if ptDataType is a leagal value != 0 (ACLVIS_UNKNOWN),
  // initialize the point data and allocate memory for
  // the data
  if (ptDataType <= 3 && ptDataType > 0) {
    InitPointDataType(ptDataType);
  }

  return 1;
}

int
vizStructuredFieldDataType::InitPointDataType(int ptDataType)
{
  int success = 0;
  if ((ptDataType <= 3) && (ptDataType >= 0)) {
   type = ptDataType;
  }

  //  if (numPoints > 0) {
    switch (type) {
    case ACLVIS_SCALAR:
      scalars = new vtkFloatScalars;
      scalars->Allocate(numPoints);
      success = 1;
      break;
    case ACLVIS_VECTOR:
      vectors = new vtkFloatVectors;
      vectors->Allocate(numPoints);
      success = 1;
      break;
    case ACLVIS_TENSOR:
      tensors = new vtkFloatTensors;
      //tensors->Allocate(numPts);
      success = 1;
      break;
    }
    if (success) {
      isPointData = 1;
    }
    //  }
  // cout << "InitPointDataType()" << endl;
  return success;
}

int 
vizStructuredFieldDataType::SetPointData(vtkDataSet *dataSet) 
{
  int success = 0;

  if (isPointData) {
    switch (type) {
    case ACLVIS_SCALAR:
      scalars->WrotePtr();
      if (dataSet != 0)
        dataSet->GetPointData()->SetScalars(scalars);
      scalars->Delete();
      success = 1;
      break;
    case ACLVIS_VECTOR:
      vectors->WrotePtr();
      if (dataSet != 0)
        dataSet->GetPointData()->SetVectors(vectors);
      vectors->Delete();
      success = 1;
      break;
    case ACLVIS_TENSOR:
      tensors->WrotePtr();
      if (dataSet != 0)
        dataSet->GetPointData()->SetTensors(tensors);
      tensors->Delete();
      success = 1;
      break;
    }
  }
  return success;
}

int
vizStructuredFieldDataType::GetPointDataType() const
{
   return type;
}

int
vizStructuredFieldDataType::AddScalar(float sc)
{
  int success = 0;
  if (type == ACLVIS_SCALAR) {
    scalars->InsertNextScalar(sc);
    success = 1;
  } else {
    cerr << "PointDataType is not scalar";
  }
  return success;
}


int   // no bounds checking (fast), but be careful
vizStructuredFieldDataType::AddScalar(int index, float sc)
{
  int success = 0;
  if (type == ACLVIS_SCALAR) {
    scalars->SetScalar(index, sc);
    success = 1;
  } else {
    cerr << "PointDataType is not scalar";
  }
  return success;
}

int
vizStructuredFieldDataType::AddVector(float vect[3])
{
  int success = 0;
  if (type == ACLVIS_VECTOR) {
    vectors->InsertNextVector(vect);
    success = 1;
  } else {
    cerr << "PointDataType is not vector";
  }
  return success;
}

int      // no bounds checking (fast), but be careful
vizStructuredFieldDataType::AddVector(int index, float vect[3])
{
  int success = 0;
  if (type == ACLVIS_VECTOR) {
    vectors->SetVector(index, vect);
    success = 1;
  } else {
    cerr << "PointDataType is not vector";
  }
  return success;
}

void*
vizStructuredFieldDataType::GetPointData()
{
  int success = 0;

  if (isPointData) {
    switch (type) {
    case ACLVIS_SCALAR:
      return scalars;
    case ACLVIS_VECTOR:
      return vectors;
    case ACLVIS_TENSOR:
      return tensors;
    }
  }
  return &success;
}

int
vizStructuredFieldDataType::InsertFieldData(vtkDataSet *dataSet)
{
  int success = 0;

  if (isPointData) {
    SetPointData(dataSet);
  }

  return success;
}


vizParticleDataType::vizParticleDataType() :  points(0),
                                              cellArray(0),
                                              isIdInfo(0)
{
}



vizParticleDataType::vizParticleDataType(unsigned numPts, 
                                         int ptDataType, 
                                         int isIds)
{
  // cout << "vizParticleDataType Constructor" << endl;
  InitData(numPts, ptDataType, isIds);
}

vizParticleDataType::~vizParticleDataType() 
{
}

int       // See Tool.h for explanation
vizParticleDataType::InitData(unsigned numPts, int ptDataType, int isIds) {

  if (numPts > 0) {
    numPoints  = numPts;
  } else {
    cerr << "numPts must be greater than 0";
    return 0;
  }

  // Initialize allocation for vtkPoints "points"
  points     = new vtkFloatPoints;
   points->Allocate(numPoints);
  cellArray  = new vtkCellArray;
   cellArray->Allocate(numPoints);

  // if ptDataType is a leagal value != 0 (ACLVIS_UNKNOWN),
  // initialize the point data and allocate memory for
  // the data
  if (ptDataType <= 3 && ptDataType > 0) {
    InitPointDataType(ptDataType);
  }


  // If there is idInfo initialize space for it
  if (isIds) {
    isIdInfo = 1;
    InitIdInfo();
  }
    
   // Pre set cellArray since they are only points
   // The cellArray is tells the vtkPolyData structure
   // the connectivity among the vtkPoints. 
   // Since I only want individual points, this
   // connectivity is just a bunch of single points
  cellArray->InsertNextCell(numPoints);
  for (int i=0; i < numPoints; ++i)
    cellArray->InsertCellPoint(i);
  
  // cout << "Data Initialized" << endl;
  return 1;
}

int 
vizParticleDataType::InitIdInfo()
{
  int success = 0;

  idInfo = new vizPointData;
  if (numPoints > 0) {
    idInfo->GetIds()->Allocate(numPoints);

    isIdInfo = 1;
    success = 1;
  }
  // cout << "InitIdInfo()" << endl;
  return success;
}

int
vizParticleDataType::AddPoint(float pt[3])
{
  points->InsertNextPoint(pt);
  return 1;
}

int     // no bounds checking (fast), but be careful
vizParticleDataType::AddPoint(int index, float pt[3])
{
  points->SetPoint(index,pt);
  return 1;
}

int
vizParticleDataType::AddIdInfoVal(int idInf)
{
  int success = 0;
  
  if (isIdInfo) {
    idInfo->GetIds()->InsertNextScalar(idInf);
    success = 1;
  } else {
    cerr << "no IdInfo Allocated";
  }
  return success;
}

int     // no bounds checking (fast), but be careful
vizParticleDataType::AddIdInfoVal(int index, int idInf)
{
  int success = 0;
  
  if (isIdInfo) {
    idInfo->GetIds()->SetScalar(index, idInf);
    success = 1;
  } else {
    cerr << "no IdInfo Allocated";
  }
  return success;
}

int
vizParticleDataType::SetIdInfo(vtkDataSet *dataSet)
{
  int success = 0;
  if (isIdInfo) {
    if (idInfo->GetIds() != NULL) {
      dataSet->GetPointData()->SetUserDefined(idInfo);
      success = 1;
    }
  }
  return success;
}

int 
vizParticleDataType::SetPoints(vtkPolyData *polyData) {
  int success = 0;
  if (polyData != 0) {
    polyData->SetPoints(points);
    polyData->SetVerts(cellArray);
    polyData->BuildCells();
    success = 1;
  }
  points->Delete();
  cellArray->Delete();
  return success;
}

int
vizParticleDataType::GetIsIdInfoFlag() const
{
  return isIdInfo;
}

int
vizParticleDataType::InsertParticleData(vtkPolyData *polyData)
{
  int success = 0;

  if (points && cellArray) {
    SetPoints(polyData);
    success = 1;
  }
  if (isPointData) {
    SetPointData(polyData);
  }
  if (isIdInfo) {
    SetIdInfo(polyData);
  }

  return success;
}

/***************************************************************************
 * $RCSfile: Tool.cpp,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:34 $
 * IPPL_VERSION_ID: $Id: Tool.cpp,v 1.1.1.1 2003/01/23 07:40:34 adelmann Exp $ 
 ***************************************************************************/

---