Download the code. (Splines, TubeFilter)(.cpp)
//Maysa Macedo maysa@ime.usp.br
//You can visualize sequence of points with respective diameter
//---------------------------------------------------------------------------
//to execute:$>./name_executable name_inputFile
/*-----------inputfile model------------
number of points for each tubular segment
number of segments
x1 y1 z1 x2 y2 z2 diameter
...
-------------------------------------------*/
//if windows
//#pragma hdrstop
#include
//if windows
//#include
#include
#include "vtkMath.h"
#include "vtkActor.h"
#include "vtkCamera.h"
#include "vtkCellArray.h"
#include "vtkPoints.h"
#include "vtkPointData.h"
#include "vtkPolyData.h"
#include "vtkPolyDataMapper.h"
#include "vtkPropAssembly.h"
#include "vtkPropCollection.h"
#include "vtkProperty.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkTubeFilter.h"
#include "vtkCardinalSpline.h"
#include "vtkSphereSource.h"
#include "vtkGlyph3D.h"
#include "vtkCallbackCommand.h"
#include "vtkOutlineFilter.h"
#include "vtkSplineFilter.h"
#include "vtkCubeSource.h"
#include "vtkFloatArray.h"
//if windows
//#pragma argsused
//---------------------------------------------------------------------------
//CLASSES
//static void handle_double_click(vtkObject* obj, unsigned long,void*, void*);
class Interactor{
private:
vtkRenderer *renderer ;
vtkRenderWindow *renWin;
vtkRenderWindowInteractor *wInteractor;
public:
Interactor();
~Interactor();
void update();
// vtkRenderer GetRenderer();
// vtkRendererWindow GetWindow();
};
class Vasculature{
private:
class Vessel{
private:
Vasculature *vasculature;
vtkPoints *points;
vtkCellArray *line;
vtkPolyData *vesselData ;
vtkFloatArray *scalars ;
vtkPolyDataMapper *vesselMapper ;
vtkTubeFilter *vesselTubes ;
vtkActor *vesselActor;
vtkSplineFilter *splineFilter;
vtkSphereSource *balls;
vtkGlyph3D *glyphPoints;
vtkPolyDataMapper *glyphMapper;
vtkActor *actorglyph;
vtkPolyData *glyphData;
int pontoesf;
public:
Vessel(Vasculature *vasculature, vtkPoints *points1,vtkCellArray *line1, vtkFloatArray *scalars1,vtkPoints *pointsBall, int pontoesfer);
~Vessel();
void InsertPoint(int j, int x,int y, int z);
void InsertCell(int i);
void update(double lengthSpline, int nSideTube, double radius, double *color, double specular, double power);
void addTo(vtkRenderer *renderer);
vtkTubeFilter getTube();
};
int n_vessel;
double max_x, max_y, max_z, min_x, min_y, min_z;
Vessel **vessel;
vtkOutlineFilter *outlineData ;
vtkActor *outlineActor ;
vtkPolyDataMapper *mapOutline;
vtkCubeSource *cube;
public:
Vasculature();
~Vasculature();
void createVasculature(char filename[], int *n_point, int *n_vessel, int pontoesf );
void update();
void addTo(vtkRenderer *renderer);
void createOutline();
void addOutline(vtkRenderer *renderer);
};
//----------------------------------------------------------------------------
//METODOS
Vasculature::Vasculature(){
outlineData = vtkOutlineFilter::New();
outlineActor = vtkActor::New();
mapOutline = vtkPolyDataMapper::New();
cube = vtkCubeSource::New();
}
Vasculature::~Vasculature(){
// for(int f = 0; f < n_vessel; f++)
// delete vessel[f];
delete vessel[0];
delete[] vessel;
outlineData->Delete();
outlineActor->Delete();
cube->Delete();
mapOutline->Delete();
}
//set the interactor pattern of VTK
Interactor::Interactor(){
renderer = vtkRenderer::New();
renWin = vtkRenderWindow::New();
wInteractor = vtkRenderWindowInteractor::New();
}
Interactor::~Interactor(){
renderer->Delete();
renWin->Delete();
wInteractor->Delete();
}
//insert points and the diameter's list in a polydata
Vasculature::Vessel::Vessel(Vasculature *vasculature, vtkPoints *points1,vtkCellArray *line1, vtkFloatArray *scalars1,vtkPoints *pointsBall, int pontoesfer){
this->vasculature = vasculature;
this->pontoesf = pontoesfer ;
vesselData = vtkPolyData::New();
vesselMapper = vtkPolyDataMapper::New();
vesselTubes = vtkTubeFilter::New();
splineFilter = vtkSplineFilter::New();
vesselActor = vtkActor::New();
scalars = vtkFloatArray::New();
balls = vtkSphereSource::New();
glyphPoints = vtkGlyph3D::New();
glyphMapper = vtkPolyDataMapper::New();
actorglyph = vtkActor::New();
glyphData = vtkPolyData::New();
points = points1;
line = line1;
scalars = scalars1;
//set the coordinates point
vesselData->SetPoints(points);
//set diameters
vesselData->GetPointData()->SetScalars(scalars);
vesselData->SetLines(line);
//put the polyData in a spline
splineFilter->SetInput(vesselData);
//it indicates the final and initial point as a sphere
if (this->pontoesf ==1){
balls->SetRadius(5);
balls->SetPhiResolution(10);
balls->SetThetaResolution(10);
glyphData->SetPoints(pointsBall);
}
}
//read the data file and put in data structure like points and CellArray
void Vasculature::createVasculature(char filename[], int *n_point, int *n_vessel,int pontoesfer){
FILE *arquivo;
int i,j,y,t,x1,y1,z1,x2,y2,z2,nSideTube,k;
float diametro,diamet,xf1,yf1,zf1,xf2,yf2,zf2; double lengthSpline, radius, specular, color[3], power,pointTest[3];
//set appearance
lengthSpline =0.008;
radius = 0.8;
specular = 0.3;
color[0]=1.0 ; color[1]=1.0 ; color[2]=0.6;
power=30.0;
nSideTube=10;
arquivo = fopen(filename, "r");
fscanf(arquivo,"%d",n_point);
fscanf(arquivo,"%d",n_vessel);
this->n_vessel = *n_vessel;
//vessel = new Vessel*[*n_vessel];
vessel = new Vessel*[1];
max_x=0;max_y=0;max_z=0;min_x=0;min_y=0;min_z=0;
vtkPoints *points = vtkPoints::New(VTK_DOUBLE);
vtkCellArray *line = vtkCellArray::New();
vtkFloatArray * scalars = vtkFloatArray::New();
vtkPoints *pointsBall = vtkPoints::New(VTK_DOUBLE);
line->SetNumberOfCells(*n_vessel);
scalars->SetNumberOfComponents(1);
scalars->SetNumberOfTuples(*n_point*2*(*n_vessel));
k=0; j=0;
for(y=0;y<*n_vessel; y++){
t=0;
line->InsertNextCell(*n_point*2);
for (i=0;i<*n_point;i++){
fscanf(arquivo,"%d\t%d\t%d\t%d\t%d\t%d\t%f",&x1,&y1,&z1,&x2,&y2,&z2,&diametro);
//its not acceptable point out of the cube
if (max_x
if (max_y
if (max_z
if (min_x>x1) min_x=x1;
if (min_y>y1) min_y=y1;
if (min_z>z1) min_z=z1;
if (max_x
if (max_y
if (max_z
if (min_x>x1) min_x=x2;
if (min_y>y1) min_y=y2;
if (min_z>z1) min_z=z2;
//inserting points in pairs
//insert the initial point of a cellArray
points->InsertPoint(j, x1,y1,z1);
points->GetPoint(j,pointTest);
//insert the final point of a cellArray
points->InsertPoint(j+1, x2,y2,z2);
points->GetPoint(j+1,pointTest);
line->InsertCellPoint(j);
line->InsertCellPoint(j+1);
//for each pair of points, we have to insert the respective diameter
scalars->InsertTuple1(j,diametro);
scalars->InsertTuple1(j+1,diametro);
j=j+2;
t=t+2;
}
//fflush();
//if the user wants to show initial and final point as spheres
if (pontoesfer==1) {
fscanf(arquivo,"%d\t%d\t%d\t%d\t%d\t%d\t%f",&x1,&y1,&z1,&x2,&y2,&z2,&diametro);
//printf(">> %d %d %d - %d %d %d\n",x1,y1,z1,x2,y2,z2);
pointsBall->InsertPoint(k, x1,y1,z1);
pointsBall->GetPoint(k,pointTest);
//printf("! %f %f %f\n",pointTest[0],pointTest[1],pointTest[2]);
pointsBall->InsertPoint(k+1, x2,y2,z2);
pointsBall->GetPoint(k+1,pointTest);
//printf("!! %f %f %f\n",pointTest[0],pointTest[1],pointTest[2]);
}
k=k+2;
}
vessel[0] = new Vessel(this, points, line, scalars,pointsBall,pontoesfer);
vessel[0]->update(lengthSpline, nSideTube, radius, color, specular, power);
points->Delete();
line->Delete();
scalars->Delete();
pointsBall->Delete();
fclose(arquivo);
}
Vasculature::Vessel::~Vessel(){
vesselActor->Delete();
splineFilter->Delete();
vesselTubes->Delete();
vesselMapper->Delete();
vesselData->Delete();
balls ->Delete();
glyphPoints ->Delete();
glyphMapper ->Delete();
actorglyph ->Delete();
glyphData ->Delete();
}
//create cube envolving the vessel
void Vasculature::createOutline(){
cube->SetBounds (min_x, max_x, min_y, max_y, min_z, max_z);
outlineData->SetInputConnection(cube->GetOutputPort());
mapOutline->SetInputConnection(outlineData->GetOutputPort());
outlineActor->SetMapper(mapOutline);
outlineActor->GetProperty()->SetColor(1,1,1);
outlineActor->SetPosition(0,0,0);
}
void Vasculature::Vessel::InsertPoint(int j, int x,int y, int z){
this->points->InsertPoint(j, (double)x,(double)y,(double)z);
}
void Vasculature::Vessel::InsertCell(int i){
this->line->InsertCellPoint(i);
}
//insert the spline in a tube
void Vasculature::Vessel::update(double lengthSpline, int nSideTube, double radius, double *color, double specular, double power){
splineFilter->SetSubdivideToLength();
splineFilter->SetLength(lengthSpline);
//number of tube sides, more sides more continuos
vesselTubes->SetNumberOfSides(nSideTube);
//insert the spline in the tube
vesselTubes->SetInputConnection(splineFilter->GetOutputPort());
//show the diameter variation
vesselTubes->SetVaryRadiusToVaryRadiusByScalar();
vesselMapper->SetInputConnection(vesselTubes->GetOutputPort());
vesselMapper->UseLookupTableScalarRangeOff();
vesselActor->SetMapper(vesselMapper);
vesselActor->GetProperty()->SetDiffuseColor(color);
vesselActor->GetProperty()->SetSpecular(specular);
vesselActor->GetProperty()->SetSpecularPower(power);
//if the user wants to show initial and final point as a sphere
if (this->pontoesf==1){
glyphPoints->SetInput(glyphData);
glyphPoints->SetSource(balls->GetOutput());
glyphMapper->SetInputConnection(glyphPoints->GetOutputPort());
actorglyph->SetMapper(glyphMapper);
actorglyph->GetProperty()->SetDiffuseColor( 1, 1, 1);
actorglyph->GetProperty()->SetSpecular(.3);
actorglyph->GetProperty()->SetSpecularPower(30);
}
}
void Vasculature::Vessel::addTo(vtkRenderer *renderer){
renderer->AddActor(vesselActor);
//renderer->AddActor(actorglyph);}
//printf("scalars%f\n",this->vesselTubes->GetRadiusMinValue());
//printf("scalars%f\n",this->vesselTubes->GetRadiusMaxValue());
}
void Vasculature::addTo(vtkRenderer *renderer){
// for(int f = 0; f < n_vessel; f++){
// vessel[f]->addTo(renderer);
//}
vessel[0]->addTo(renderer);
createOutline();
addOutline(renderer);
}
void Vasculature::addOutline(vtkRenderer *renderer){
renderer->AddActor(outlineActor);
}
void Vasculature::update(){
}
int main(int argc, char* argv[])
{ //to execute:$>./name_executable name_inputFile
int n_vessel, n_point,pontoesf;
int j=0,i,cd,t,n_saida;
float diametro,offset;
int x1,y1,z1,x2,y2,z2;
double pointTest[6];
char *filename;
printf("*******************Visualizador de vasos sanguineos*********************\n");
if (argc < 2){
printf("Erro! Insira o arquivo de entrada.\n");
exit(1);
}
filename = argv[1];
printf("Exibir pontos de subramo? (1-Sim,2-Nao)\n") ;
scanf("%d",&pontoesf);
Vasculature *vasculature = new Vasculature();
vasculature->createVasculature(filename, &n_point, &n_vessel, pontoesf);
//set the render
vtkRenderer *renderer = vtkRenderer::New();
vasculature->addTo(renderer);
vtkRenderWindow *renWin = vtkRenderWindow::New();
renWin->AddRenderer(renderer);
vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
iren->SetRenderWindow(renWin);
//set the camera and other settings for the window
renderer->SetBackground(0.0, 0.0, 0.0);
renWin->SetSize(600, 600);
renderer->ResetCamera();
renderer->GetActiveCamera()->Zoom(1.5);
renWin->Render();
iren->Start();
delete vasculature;
renderer->Delete();
renWin->Delete();
iren->Delete();
return 0;
}
|
maysa (a t) ime.usp.br
|
|
