marAxisCT Class Reference

#include <marAxisCT.h>

Inheritance diagram for marAxisCT:

[legend]

Collaboration diagram for marAxisCT:

[legend]

List of all members.

Public Types
enum	AxisStateVectorIndexes {   INDX_X = 0, INDX_Y, INDX_Z, INDX_V1X,   INDX_V1Y, INDX_V1Z, INDX_V2X, INDX_V2Y,   INDX_V2Z, INDX_V3X, INDX_V3Y, INDX_V3Z,   INDX_LAMBDA1, INDX_LAMBDA2, INDX_LAMBDA3, INDX_MASSE,   INDX_RAYON, INDX_INERTIE, INDX_PTAGEMASSE, INDX_PTAGERAYON,   INDX_SIGNALVALUE, INDX_count }
Public Member Functions
	marAxisCT ()
marContour *	getContour (int point, kVolume *vol, int index)
vtkPoints *	get3Dcontour (int point, kVolume *vol, int index)
vtkPolyData *	get2Dcontour (int point, kVolume *vol, int index)
vtkPoints *	get2DDiameterMin (int point, kVolume *vol, int index)
vtkPoints *	get2DDiameterMax (int point, kVolume *vol, int index)
int	getSignal (int point, int index, kVolume *vol)
void	updateLumenPercentage (int point, kVolume *vol)
void	updateCalcPercentage (int point, kVolume *vol)
void	replaceContour2D (int point, int size, double *vx, double *vy, int type)
marContourVO *	searchContour (int type, int point)
int	getNumberOfContours (int point, kVolume *vol)
int	getContourType (int point, int index, kVolume *vol)
void	createEmptyContours ()
void	eraseContours ()
void	eraseContoursPartial (int start)
void	histogram (int point, kVolume *vol)
void	setCalibration (bool calib)
bool	getCalibration ()
int	getStartIndex ()
void	setStartIndex (int start)
int	getPointSize ()
marPoint *	getPoint (int i)
void	markUpLumen (int point, kVolume *vol)
void	generateFile (int point, kVolume *vol)
void	cleanContours (int type, int point)
double	performXOR (int type, int point, std::vector< marIsocontour * > manual, kVolume *vol)
double	performAND (int type, int point, std::vector< marIsocontour * > manual, kVolume *vol)
double	performUnion (int type, int point, std::vector< marIsocontour * > manual, kVolume *vol)
marIsocontour *	loadMarIsocontour (int size, double *vx, double *vy)
std::string &	getDescription ()
void	setDescription (std::string &d)
void	addAxisPoint (double *p)
void	changeAxisResolution ()
void	calculateSignal (kVolume *vol)
int	getActualQuant ()
float	getSignal (uint slice)
double *	getSplinePoint (uint i)
int	getHealthySlice ()
int	getHealthySliceStart ()
int	getHealthySliceEnd ()
void	setActualQuant (int act)
void	setHealthySlice (int hsS, int hs, int hsE)
void	setStartQuant (int sq)
void	setFinishQuant (int fq)
int	getStartQuant ()
int	getFinishQuant ()
void	start ()
void	next ()
void	stop ()
bool	isFinished ()
void	doSpline ()
void	cut (int slice, bool up)
void	sliceVolumeAxis (kVolume *vol, bool forceCnt=true)
double *	getNormal (unsigned int slice)
int	getNumberOfContours ()
int	getNumberOfSplinePoints ()
bool	if3DcontourExist (int i)
void	Save3Dcontour (FILE *ff, int i)
void	SaveExisting3DContours (FILE *ff)
marContour *	getContour (int i, kVolume *vol)
kVolume *	getSlice (int i, kVolume *vol)
vtkProbeFilter *	get3DSlice (int i, kVolume *vol)
vtkPoints *	get3Dcontour (int i, kVolume *vol)
vtkImageData *	getSliceImage (int i, kVolume *vol)
vtkPolyData *	get2Dcontour (int i, kVolume *vol)
vtkPoints *	get2DDiameterMin (int i, kVolume *vol)
vtkPoints *	get2DDiameterMax (int i, kVolume *vol)
void	replaceContour2D (int i, int size, double *vx, double *vy)
void	EraseContour (int i)
void	createEmptyVectors ()
void	clearAllVectors ()
void	eraseContourVectorsContent ()
void	set_points_disc (PPPOINTAXE p)
double	getTotalLength ()
double	getSubAxisLength ()
double	getReferenceArea (kVolume *vol)
double	getReferenceAverDiam (kVolume *vol)
double	getAverageArea (int pIni, int pEnd, kVolume *vol)
void	reset ()
void	copyFrom (const marObject &from)
bool	save (std::ofstream &os)
bool	save (std::string &nw)
bool	load (std::ifstream &is)
bool	load (std::string &nr)
vtkPolyData *	Draw ()
vtkPolyData *	GetAxisData ()
void	Delete ()
double *	getPoints (int i)
void	AddPointToList (double x, double y, double z, int signal)
void	setParameters (marParameters *p)
void	copyParameters (marParameters *p)
void	makeACopyParameters ()
marParameters *	getParameters ()
bool	parametersOwned ()
Protected Attributes
std::vector < marAxisContours * >	quantContours
std::vector< marPoint * >	vesselPoints
std::vector < marIsocontour * >	lumenContour
bool	calibration
Private Member Functions
void	createContours (int point, kVolume *vol)
void	create3Dcontours (int point, kVolume *vol)
void	create2Dcontours (int point, kVolume *vol)
void	create2DDiametersMin (int point, kVolume *vol)
void	create2DDiametersMax (int point, kVolume *vol)
void	createSignals (int point, kVolume *vol)
void	generatePoints (int point, kVolume *vol, std::vector< marIsocontour * > *list)
int	getMaximumGrad (std::vector< marPoint * > list, int iniPos, int limit, double threshold)
int	getMinimumGrad (std::vector< marPoint * > list, int iniPos, int limit, double threshold)
double	interpolate (double x, double y, vtkImageData *imagedata)
void	generateVector (int dir, int *coordBase, double originX, double originY, double *x, double *y)
bool	detectNeighbor (marIsocontour *contour, int dir, int type)
marIsocontour *	addPointToContour (marIsocontour *cont, bool inside, int type, marPoint *point)
void	unifyDividedStructure (std::vector< marIsocontour * > *contList)
double	getStatistics (marIsocontour *contour, double x, double y, vtkImageData *imagedata)
double	getCalcStatistics (marIsocontour *contour, double x, double y, vtkImageData *imagedata, int i)
int	round (double num)
int	getMaxIntensity (int point)
bool	pointInPolygon (marIsocontour *c, double x, double y)
marIsocontour *	parsePolyDataToMarIsocontour (marContourVO *contourVO)
marIsocontour *	filterContour (marIsocontour *contExt, marIsocontour *contInt, double radio)
double	obtainContourArea (marIsocontour *contour)
void	adjustWall (int point, kVolume *vol)
void	adjustCalcification (int point, kVolume *vol)
void	adjustContour (int point, kVolume *vol)
int	maxValue (std::vector< double > list)
int	getDiameter (marContourVO *contourVO, double x, double y, int limInfX, int limInfY, int limSupX, int limSupY)
int	searchData (std::vector< double > vec, double value)
void	extractLumen (vtkImageData *lumenImage, marIsocontour *lumenContour, int point)
Private Attributes
double	avgValue
double	stdValue
int	startIndex
double	maxSignal

---

Detailed Description

Definition at line 30 of file marAxisCT.h.

---

Member Enumeration Documentation

enum marAxis::AxisStateVectorIndexes [inherited]

An enum.

More detailed enum description.

Enumerator:

INDX_X	X coordinate of an axis point.
INDX_Y	Y coordinate of an axis point.
INDX_Z	Z coordinate of an axis point.
INDX_V1X	X coordinate of the first eigen vector.
INDX_V1Y	Y coordinate of the first eigen vector.
INDX_V1Z	Z coordinate of the first eigen vector.
INDX_V2X	X coordinate of the second eigen vector.
INDX_V2Y	Y coordinate of the second eigen vector.
INDX_V2Z	Z coordinate of the second eigen vector.
INDX_V3X	X coordinate of the third eigen vector.
INDX_V3Y	Y coordinate of the third eigen vector.
INDX_V3Z	Z coordinate of the third eigen vector.
INDX_LAMBDA1	Value of the first eigen value.
INDX_LAMBDA2	Value of the second eigen value.
INDX_LAMBDA3	Value of the third eigen value.
INDX_MASSE	Weight of the optimal sphere.
INDX_RAYON	Radius of the optimal sphere.
INDX_INERTIE	Inertia of the optimal sphere.
INDX_PTAGEMASSE	X coordinate of an axis point.
INDX_PTAGERAYON	X coordinate of an axis point.
INDX_SIGNALVALUE	X coordinate of an axis point.
INDX_count	Allow counting of this enum.

Definition at line 52 of file marAxis.h.

{
    INDX_X = 0,       
    INDX_Y,           
    INDX_Z,           
    INDX_V1X,         
    INDX_V1Y,         
    INDX_V1Z,         
    INDX_V2X,         
    INDX_V2Y,         
    INDX_V2Z,         
    INDX_V3X,         
    INDX_V3Y,         
    INDX_V3Z,         
    INDX_LAMBDA1,     
    INDX_LAMBDA2,     
    INDX_LAMBDA3,     
    INDX_MASSE,       
    INDX_RAYON,       
    INDX_INERTIE,     
    INDX_PTAGEMASSE,  
    INDX_PTAGERAYON,  
    INDX_SIGNALVALUE, 
    INDX_count        
    };

---

Constructor & Destructor Documentation

marAxisCT::marAxisCT

(

)

Definition at line 32 of file marAxisCT.cpp.

                       : marAxis(  )                             
{
}

---

Member Function Documentation

marContour * marAxisCT::getContour	(	int	point,
		kVolume *	vol,
		int	index
	)

Definition at line 37 of file marAxisCT.cpp.

References createContours(), and marAxis::quantContours.

Referenced by cleanContours(), create2DDiametersMax(), create2DDiametersMin(), create3Dcontours(), generateFile(), get2Dcontour(), get3Dcontour(), getMaxIntensity(), markUpLumen(), performAND(), performUnion(), performXOR(), and updateCalcPercentage().

                                                                       {
        if (quantContours[point] == NULL || quantContours[point]->getContour(index)->getContour() == NULL)
        {
                createContours(point,vol);
        }

        return quantContours[point]->getContour(index)->getContour();
} 

Here is the call graph for this function:

Here is the caller graph for this function:

vtkPoints * marAxisCT::get3Dcontour	(	int	point,
		kVolume *	vol,
		int	index
	)

Definition at line 47 of file marAxisCT.cpp.

References create3Dcontours(), marContourVO::get3DContour(), marAxisContours::getContour(), getContour(), and marAxis::quantContours.

                                                                        {
        if (quantContours[point] == NULL || quantContours[point]->getContour(index)->get3DContour() == NULL)
        {
                create3Dcontours(point,vol); 
        }

        marAxisContours* cont = quantContours[point];

        return cont->getContour(index)->get3DContour();
}

Here is the call graph for this function:

vtkPolyData * marAxisCT::get2Dcontour	(	int	point,
		kVolume *	vol,
		int	index
	)

Definition at line 59 of file marAxisCT.cpp.

References create2Dcontours(), marContourVO::get2DContour(), marAxisContours::getContour(), getContour(), and marAxis::quantContours.

                                                                          {
        if (quantContours[point] == NULL || quantContours[point]->getContour(index)->get2DContour() == NULL)
        {
                create2Dcontours(point,vol); 
        }

        marAxisContours* cont = quantContours[point];

        

        return cont->getContour(index)->get2DContour();
}

Here is the call graph for this function:

vtkPoints * marAxisCT::get2DDiameterMin	(	int	point,
		kVolume *	vol,
		int	index
	)

Definition at line 73 of file marAxisCT.cpp.

References create2DDiametersMin(), marContourVO::get2DDiameterMin(), marAxisContours::getContour(), and marAxis::quantContours.

                                                                            {
//      if (quantContours[point] == NULL || quantContours[point]->getContour(index)->get2DDiameterMin() == NULL)
//      {
                create2DDiametersMin(point,vol); 
//      }

        marAxisContours* cont = quantContours[point];

        return cont->getContour(index)->get2DDiameterMin();
}

Here is the call graph for this function:

vtkPoints * marAxisCT::get2DDiameterMax	(	int	point,
		kVolume *	vol,
		int	index
	)

Definition at line 85 of file marAxisCT.cpp.

References create2DDiametersMax(), marContourVO::get2DDiameterMax(), marAxisContours::getContour(), and marAxis::quantContours.

                                                                            {
//      if (quantContours[point] == NULL || quantContours[point]->getContour(index)->get2DDiameterMax() == NULL)
//      {
                create2DDiametersMax(point,vol); 
//      }

        marAxisContours* cont = quantContours[point];

        return cont->getContour(index)->get2DDiameterMax();
}

Here is the call graph for this function:

int marAxisCT::getSignal	(	int	point,
		int	index,
		kVolume *	vol
	)

Definition at line 97 of file marAxisCT.cpp.

References createSignals(), and marAxis::quantContours.

                                                           {
        if (quantContours[point] == NULL )
        {
                createSignals(point,vol); 
        }

        return (int) ( quantContours[point]->getContour(index)->getSignal() );
}

Here is the call graph for this function:

void marAxisCT::updateLumenPercentage	(	int	point,
		kVolume *	vol
	)

Definition at line 1061 of file marAxisCT.cpp.

References create2Dcontours(), marContourVO::get2DContour(), marContourVO::getIsocontour(), marObject::getParameters(), marContourVO::getSignal(), marContourVO::getType(), marContourVO::isReplaced(), marAxis::quantContours, searchContour(), and marAxisContours::WALL.

Referenced by adjustWall(), create2Dcontours(), and histogram().

{
        marContourVO* wallCont = searchContour(marAxisContours::WALL,point);
        if (quantContours[point] == NULL || wallCont->get2DContour() == NULL)
        {
                create2Dcontours(point,vol); 
        }

        if (wallCont->getType() == marAxisContours::WALL
                        && wallCont->isReplaced() == false)
        {
                int a = ((marParameters *) getParameters())->getLumenPercentage();
                double oldValue = wallCont->getSignal();
                double lumenPercentage=((marParameters *) getParameters())->getLumenPercentage();
                double poww=pow(10.0,-2.0);
                double newValue = oldValue * lumenPercentage*poww;
                wallCont->getIsocontour()->SetValue(0,newValue);
                wallCont->getIsocontour()->Update();
                wallCont->get2DContour()->Update(); 
        }
        
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::updateCalcPercentage	(	int	point,
		kVolume *	vol
	)

Definition at line 1085 of file marAxisCT.cpp.

References marAxisContours::CALCIFICATION, create2Dcontours(), getContour(), getMaxIntensity(), marObject::getParameters(), and marAxis::quantContours.

Referenced by create2Dcontours().

{
        double oldValue;
        int posMax;

        if (quantContours[point] == NULL)
        {
                create2Dcontours(point,vol); 
        }

        posMax = getMaxIntensity(point);
        
        if (quantContours[point]->getSize() > 1)
        {
                oldValue = quantContours[point]->getContour(posMax)->getSignal();
        }
        
        for (int i = 1; i < quantContours[point]->getSize(); i++)
        {
                
                if (quantContours[point]->getContour(i)->getType() == marAxisContours::CALCIFICATION 
                                && quantContours[point]->getContour(i)->isReplaced() == false)
                {

                        double newValue = oldValue * ((((marParameters *) getParameters())->getCalcPercentage())*pow(10.0,-2.0));
                        quantContours[point]->getContour(i)->getIsocontour()->SetValue(0,newValue);
                        quantContours[point]->getContour(i)->getIsocontour()->Update();
                        quantContours[point]->getContour(i)->get2DContour()->Update();
                }
        
        }
        
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::replaceContour2D	(	int	point,
		int	size,
		double *	vx,
		double *	vy,
		int	type
	)

this->searchContour(type,point);

Definition at line 2156 of file marAxisCT.cpp.

References marAxis::quantContours, marContourVO::set2DContour(), marContourVO::setReplaced(), and marContourVO::setType().

{

        vtkPoints *_pts = vtkPoints::New();
        _pts->SetNumberOfPoints(size);
        int j;

        for (j=0 ; j<size ; j++){
                _pts->SetPoint(j,       vx[j]   , vy[j] , 0 );
        }
//      _pts->SetPoint(0,       vx[0]   , vy[0] , 0 );

        vtkCellArray *lines = vtkCellArray::New();
        lines->InsertNextCell( size );
        for ( j=0 ; j<size+1 ; j++ ){
                lines->InsertCellPoint(j % size );
        }

        vtkPolyData *_pd = vtkPolyData::New();
        _pd->SetPoints( _pts );
        _pd->SetLines( lines );
        lines->Delete();  //do not delete lines ??
        _pts->Delete();  

        marContourVO* vo = new marContourVO();
        vo->setReplaced(true);
        vo->set2DContour(_pd);
        vo->setType(type);
        quantContours[point]->addContour(vo);   //->replaceContour(vo,i);
/*      _2Dcontours[i]=_pd;
        createContour(i,NULL);*/
}

Here is the call graph for this function:

marContourVO * marAxisCT::searchContour	(	int	type,
		int	point
	)

Definition at line 2214 of file marAxisCT.cpp.

References getContourType(), and marAxis::quantContours.

Referenced by adjustContour(), adjustWall(), extractLumen(), histogram(), markUpLumen(), and updateLumenPercentage().

{
        marContourVO* cont = NULL;

        for (int i = 0; i < quantContours[point]->getSize(); i++)
        {
                if (quantContours[point]->getContourType(i) == type)
                {
                        cont = quantContours[point]->getContour(i);
                }
        }

        return cont;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int marAxisCT::getNumberOfContours	(	int	point,
		kVolume *	vol
	)

Definition at line 463 of file marAxisCT.cpp.

References create2Dcontours(), and marAxis::quantContours.

                                                              {
        if (quantContours[point] == NULL )
        {
                create2Dcontours(point,vol);//AQUI
        //      filterSignal(vol);
                
        }

        return quantContours[point]->getSize();
}

Here is the call graph for this function:

int marAxisCT::getContourType	(	int	point,
		int	index,
		kVolume *	vol
	)

Definition at line 475 of file marAxisCT.cpp.

References create2Dcontours(), and marAxis::quantContours.

Referenced by cleanContours(), generateFile(), performAND(), performUnion(), performXOR(), and searchContour().

                                                                    {
        if (quantContours[point] == NULL )
        {
                create2Dcontours(point,vol);
        }
        
        return quantContours[point]->getContourType(index);

}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::createEmptyContours

(

)

Definition at line 1048 of file marAxisCT.cpp.

References marAxis::getNumberOfSplinePoints(), marAxis::lumenContour, and marAxis::quantContours.

                                   {

        int nCnts = ( int ) getNumberOfSplinePoints( );
        

        for (int i = 0; i < nCnts; i++)
        {
                quantContours.push_back( NULL );
                lumenContour.push_back( NULL);
        }
}

Here is the call graph for this function:

void marAxisCT::eraseContours

(

)

Definition at line 1141 of file marAxisCT.cpp.

References marAxis::lumenContour, marAxis::quantContours, and marAxis::vesselPoints.

{

        
                int nCts = quantContours.size();
                vesselPoints.clear();

                int i = 0;

                while (i < nCts)
                {
                        delete quantContours[i];
                        quantContours[i] = NULL;
                        lumenContour[i] = NULL;
                        i++;
                }
                quantContours.clear();
                lumenContour.clear();

        
}

void marAxisCT::eraseContoursPartial

(

int

start

)

Definition at line 1164 of file marAxisCT.cpp.

References marAxis::lumenContour, and marAxis::quantContours.

{

        int nCts = 0;
        int i = start;

        while (i >= nCts)
        {
                delete quantContours[i];
                quantContours[i] = NULL;
                lumenContour[i] = NULL;
                i--;
        }
        quantContours.clear();
        lumenContour.clear();

        //TODO Revisar esto que no me convence
}

void marAxisCT::histogram	(	int	point,
		kVolume *	vol
	)

Definition at line 1649 of file marAxisCT.cpp.

References marObject::getParameters(), marAxis::getSlice(), parsePolyDataToMarIsocontour(), pointInPolygon(), searchContour(), searchData(), updateLumenPercentage(), and marAxisContours::WALL.

{

        vtkImageData* imagedata;
        int limInfX, limInfY, limInfZ;
        int limSupX, limSupY, limSupZ;
        int pos;
        
        
        FILE *archivo;
        char nomArchivo[30],temp[3];
        marContourVO* wallCont = searchContour(marAxisContours::WALL,point);
        
                
//      for (int point = 0; point <  quantContours.size(); point++)
//      {
                imagedata = (vtkImageData*) ((getSlice( point , vol ))->castVtk( ));
                imagedata->GetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);
                ((marParameters *) getParameters())->setLumenPercentage(86);
                updateLumenPercentage(point,vol);
                marIsocontour* contExt = parsePolyDataToMarIsocontour(wallCont);

                std::vector<double> intensity;
                std::vector<int> frecuencies;
            
                for (int i = 0; i < limSupX; i++)
                {
                        for (int j = 0; j < limSupY; j++)
                        {
                                if(pointInPolygon(contExt,i,j))
                                {
                                        
                                        pos = searchData(intensity,imagedata->GetScalarComponentAsDouble(i,j,0,0));
                                        if (pos == -1)
                                        {
                                                intensity.push_back( imagedata->GetScalarComponentAsDouble(i,j,0,0));
                                                frecuencies.push_back(1);
                                        
                                                
                                        }
                                        else
                                        {
                                                frecuencies[pos]++;
                                        }
                                }
                                
                        }
                }
                        
                strcpy(nomArchivo,"./histogram");

// EED 06/06/2007 linux
//              itoa(point,temp,10);
                sprintf(temp,"%d",point);

                strcat(nomArchivo,temp);
                strcat(nomArchivo,".csv");
                
                

                archivo = fopen(nomArchivo,"w");
                for (int k = 0; k < frecuencies.size(); k++)
                {

                        fprintf(archivo,"%f;%d\n",intensity[k],frecuencies[k]);

                }
                fclose(archivo);
                
        
                

                //imagedata->Delete();
                delete contExt;
//      }

}

Here is the call graph for this function:

void marAxisCT::setCalibration

(

bool

calib

)

Definition at line 1746 of file marAxisCT.cpp.

References marAxis::calibration.

{
        calibration = calib;
}

bool marAxisCT::getCalibration

(

)

Definition at line 1752 of file marAxisCT.cpp.

References marAxis::calibration.

{
        return calibration;
}

int marAxisCT::getStartIndex

(

)

Definition at line 1911 of file marAxisCT.cpp.

References startIndex.

{
        return startIndex;
}

void marAxisCT::setStartIndex

(

int

start

)

Definition at line 1917 of file marAxisCT.cpp.

References marObject::getParameters(), maxSignal, marAxis::quantContours, and startIndex.

{
        startIndex = start;

        int per = ((marParameters *) getParameters())->getLumenPercentage();
        double oldValue = quantContours[start]->getContour(0)->getSignal()*per*pow(10.0,-2.0);

        maxSignal = oldValue; // / (per*pow(10.0,-2.0));
}

Here is the call graph for this function:

int marAxisCT::getPointSize

(

)

Definition at line 1928 of file marAxisCT.cpp.

References marAxis::vesselPoints.

{
        return vesselPoints.size();
}

marPoint * marAxisCT::getPoint

(

int

i

)

Definition at line 1934 of file marAxisCT.cpp.

References marAxis::vesselPoints.

{
        return vesselPoints[i];
}

void marAxisCT::markUpLumen	(	int	point,
		kVolume *	vol
	)

Definition at line 1321 of file marAxisCT.cpp.

References marAxisContours::ELUMEN, extractLumen(), getContour(), marPoint::getIntensity(), marAxis::getSlice(), marAxis::lumenContour, maxSignal, parsePolyDataToMarIsocontour(), pointInPolygon(), marAxis::quantContours, searchContour(), marPoint::setIntensity(), and marAxis::vesselPoints.

Referenced by adjustContour().

{
        
        marContourVO* aVO = this->searchContour(marAxisContours::ELUMEN,point);

        if (aVO != NULL)
        {
                return;
        }

        int limInfX,limInfY,limInfZ,limSupX,limSupY,limSupZ;
        vtkImageData* imagedata;
        vtkImageData* erodedata;
        std::vector <marIsocontour* > polygons;
        std::vector <marPoint* > points;
        double average = 0, deviation = 0;
        vtkImageData* image = vtkImageData::New();
        vesselPoints.clear();
        

        imagedata = (vtkImageData*) ((getSlice( point , vol ))->castVtk( ));
        imagedata->GetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);
        image->SetDimensions(limSupX,limSupY,0);
        image->SetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);
        image->SetScalarTypeToUnsignedShort();
        image->AllocateScalars();
        image->Update();
        
        vtkImageThreshold *imageThreshold = vtkImageThreshold::New();
        imageThreshold->SetInput(imagedata);
        imageThreshold->ThresholdByUpper(maxSignal);
        imageThreshold->SetInValue(255);
        imageThreshold->SetOutValue(0.0);
        imageThreshold->Update();

        vtkImageContinuousErode3D *imageErode3D = vtkImageContinuousErode3D::New();
        imageErode3D->SetInput(imageThreshold->GetOutput());
        imageErode3D->SetKernelSize(4,4,1);
        imageErode3D->Update();
        erodedata = imageErode3D->GetOutput();

//      polygons.push_back(contExt);
        for (int i = 0; i < quantContours[point]->getSize(); i++)
        {
                polygons.push_back(parsePolyDataToMarIsocontour(quantContours[point]->getContour(i)));
        }
        
        //7- Wipe image to detect lumen
        
        int x;
        for (x = limInfX + 30; x < (limSupX - 1); x++)
        {
                
                for (int y = limInfY; y < (limSupY - 1) ; y++)
                {
                        bool inWall = false;
                        bool outCalc = true;
                        
                        for (int numConts = 0; numConts < polygons.size(); numConts++)
                        {
                                if (pointInPolygon(polygons[numConts],x,y) && erodedata->GetScalarComponentAsDouble(x,y,0,0) > 0)
                                {
                                        if (numConts == 0)
                                        {
                                                inWall = true;
                                        }
                                
                                        else 
                                        {
                                                outCalc = false;
                                        }
                                        
                                }
                                
                        }

                        if (inWall && outCalc)
                        {
                                marPoint *p = new marPoint(x,y);
                                p->setIntensity(imagedata->GetScalarComponentAsDouble(x,y,0,0));
                                average += p->getIntensity();
                                points.push_back(p);
                        }

                /*      if (cont >= (limSupY - limSupX))
                        {
                                contin = false;
                        }*/
                }
        }
        
        if (points.size() > 0)
        {
                average = average / points.size();
                for (int k = 0; k < points.size(); k++)
                {
                        marPoint *p = points[k];
                        double actualInt = p->getIntensity();
                        double temp = average - actualInt;
                        deviation += pow(temp,2.0);
                }
                deviation = sqrt(deviation / points.size());

        }


        polygons.push_back(lumenContour[point]);


        for (x = limInfX; x < (limSupX - 1); x++)
        {
                for (int y = limInfY; y < (limSupY - 1); y++)
                {
                        bool inWall = false;
                        bool outCalc = true;
                        bool inLumen = false;
                        unsigned short *refValue = (unsigned short *) image->GetScalarPointer(x,y,0);
                        *refValue = 0;

                        for (int numConts = 0; numConts < polygons.size(); numConts++)
                        {
                                bool adentro = pointInPolygon(polygons[numConts],x,y);
                                if (pointInPolygon(polygons[numConts],x,y) && erodedata->GetScalarComponentAsDouble(x,y,0,0) > 0)
                                {
                                        if (numConts == 0)
                                        {
                                                inWall = true;
                                        }
                                        else if (numConts == polygons.size() - 1)
                                        {
                                                inLumen = true;
                                                
                                        }
                                        else
                                        {
                                                outCalc = false;
                                        }
                                }
                        }

                        double intensidad = imagedata->GetScalarComponentAsDouble(x,y,0,0);
                        
                        if (inWall && outCalc && inLumen)
                        {

                                if (imagedata->GetScalarComponentAsDouble(x,y,0,0) > (average - 1.5*deviation)
                                         && imagedata->GetScalarComponentAsDouble(x,y,0,0) < (average + 2.5*deviation))
                                {
                                        *refValue = 255;                
                                }
                        
                        }

                }
        }

        

        extractLumen(image,lumenContour[point],point);
        
//      fclose(archivo);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::generateFile	(	int	point,
		kVolume *	vol
	)

Definition at line 2092 of file marAxisCT.cpp.

References getContour(), getContourType(), marIsocontour::getPoint(), marIsocontour::getSize(), marAxis::getSliceImage(), parsePolyDataToMarIsocontour(), marAxis::quantContours, and marRAW2Files::saveVolume().

{
        FILE *archivo;
        char nomArchivo[30], temp[3];

        strcpy(nomArchivo,"./point");

// EED 06/06/2007 linux
//      itoa(point,temp,10);
        sprintf(temp,"%d",point);

        strcat(nomArchivo,temp);
        strcat(nomArchivo,".txt");
        archivo = fopen(nomArchivo,"w");

        fprintf(archivo, "%d", quantContours[point]->getSize());

        int i;
        for (i = 0; i < quantContours[point]->getSize(); i++)
        {
                marIsocontour* iso =parsePolyDataToMarIsocontour(quantContours[point]->getContour(i));
                fprintf(archivo, " %d",iso->getSize());
                
        }
        fprintf(archivo,"\n");

        for ( i = 0; i < quantContours[point]->getSize(); i++)
        {
                marIsocontour* iso =parsePolyDataToMarIsocontour(quantContours[point]->getContour(i));
                fprintf(archivo,"Tipo: %d\n",quantContours[point]->getContourType(i));
                for (int j = 0; j < iso->getSize(); j++)
                {
                        double tempX, tempY;
                        iso->getPoint(j,&tempX,&tempY); 
                        fprintf(archivo,"%f;%f;%d\n",tempX,tempY,point);
                }
        }

// EED 30 Janvier 2007
        vtkImageData *vtkimagedata = this->getSliceImage(point,vol);

        std::string directory = "./";
        std::string filename  = "xx";
        float rescalaSlope           =  1;
        float rescalaIntercept       =  0;
        int dim[3];
        vtkimagedata->GetDimensions(dim);
        int voi[6];
        voi[0]=0;
        voi[1]=dim[0];
        voi[2]=0;
        voi[3]=dim[1];
        voi[4]=0;
        voi[5]=dim[2];
        marRAW2Files marraw2;
        marraw2.saveVolume(directory,filename,vtkimagedata,voi,rescalaSlope,rescalaIntercept);



        fclose(archivo);

}

Here is the call graph for this function:

void marAxisCT::cleanContours	(	int	type,
		int	point
	)

Definition at line 2190 of file marAxisCT.cpp.

References marAxisContours::addContour(), getContour(), getContourType(), and marAxis::quantContours.

{
        marAxisContours* newContours = new marAxisContours();
        if (quantContours[point] != NULL)
        {
                for (int i = 0; i < quantContours[point]->getSize(); i++)
                {
                        if (quantContours[point]->getContourType(i) != type)
                        {
                                newContours->addContour(quantContours[point]->getContour(i));
                        }
                        else
                        {
                        /*      marContourVO* vo = quantContours[point]->getContour(i);
                                vo->set2DContour(NULL);
                                newContours->replaceContour(vo,i);*/
                        }
                }
        }

        quantContours[point] = newContours;
}

Here is the call graph for this function:

double marAxisCT::performXOR	(	int	type,
		int	point,
		std::vector< marIsocontour * >	manual,
		kVolume *	vol
	)

Definition at line 2230 of file marAxisCT.cpp.

References getContour(), getContourType(), marAxis::getSlice(), parsePolyDataToMarIsocontour(), pointInPolygon(), and marAxis::quantContours.

{
        if (manual.size() == 0)
        {
                return 0;
        }

        int limInfX,limInfY,limInfZ,limSupX,limSupY,limSupZ;
        std::vector <marIsocontour* > polygons;
        vtkImageData* imagedata;

        imagedata = (vtkImageData*) ((getSlice( point , vol ))->castVtk( ));
        imagedata->GetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);
        vtkImageData* imageA = vtkImageData::New();
        imageA->SetDimensions(limSupX,limSupY,0);
        imageA->SetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);
        imageA->SetScalarTypeToUnsignedShort();
        imageA->AllocateScalars();
        imageA->Update();

        vtkImageData* imageM = vtkImageData::New();
        imageM->SetDimensions(limSupX,limSupY,0);
        imageM->SetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);
        imageM->SetScalarTypeToUnsignedShort();
        imageM->AllocateScalars();
        imageM->Update();

        
        for (int i = 0; i < quantContours[point]->getSize(); i++)
        {
                if (quantContours[point]->getContourType(i) == type)
                {
                        polygons.push_back(parsePolyDataToMarIsocontour(quantContours[point]->getContour(i)));
                }
                
        }

        if (polygons.size() == 0)
        {
                return 0;
        }
        int x,y;
        for (x = limInfX; x < (limSupX - 1); x++)
        {
                for (y = limInfY; y < (limSupY - 1); y++)
                {
                        unsigned short *refValueA = (unsigned short *) imageA->GetScalarPointer(x,y,0);
                        unsigned short *refValueM = (unsigned short *) imageM->GetScalarPointer(x,y,0);
                        *refValueA = 0;
                        *refValueM = 0;

                        int numConts;
                        for (numConts = 0; numConts < polygons.size(); numConts++)
                        {
                                if (pointInPolygon(polygons[numConts],x,y))
                                {
                                                *refValueA = 255;
                                }
                        }

                        for (numConts = 0; numConts < manual.size(); numConts++)
                        {
                                if (pointInPolygon(manual[numConts],x,y))
                                {
                                                *refValueM = 255;
                                }
                        }
                }
        }

/*      vtkImageLogic* xor = vtkImageLogic::New();
        xor->SetInput1(imageM);
        xor->SetInput2(imageA);
        xor->SetOutputTrueValue(255);
        xor->SetOperationToXor();

        vtkImageCast* cast = vtkImageCast::New();
        cast->SetInput(xor->GetOutput());
        cast->SetOutputScalarTypeToDouble();
*/
        int coincidencias = 0;
        for (x = limInfX; x < (limSupX - 1); x++)
        {
                for (y = limInfY; y < (limSupY - 1); y++)
                {
                        int compA = (int) imageA->GetScalarComponentAsDouble(x,y,0,0);
                        int compM = (int) imageM->GetScalarComponentAsDouble(x,y,0,0);

                        int xor_ = compA^compM;
                        if (xor_ == 255)
                        {
                                coincidencias++;
                        }
                }
        }

        double resp = (double)coincidencias ;

        return resp;

}

Here is the call graph for this function:

double marAxisCT::performAND	(	int	type,
		int	point,
		std::vector< marIsocontour * >	manual,
		kVolume *	vol
	)

Definition at line 2333 of file marAxisCT.cpp.

References getContour(), getContourType(), marAxis::getSlice(), parsePolyDataToMarIsocontour(), pointInPolygon(), and marAxis::quantContours.

{

        if (manual.size() == 0)
        {
                return 0;
        }

        int limInfX,limInfY,limInfZ,limSupX,limSupY,limSupZ;
        std::vector <marIsocontour* > polygons;
        vtkImageData* imagedata;

        imagedata = (vtkImageData*) ((getSlice( point , vol ))->castVtk( ));
        imagedata->GetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);
        vtkImageData* imageA = vtkImageData::New();
        imageA->SetDimensions(limSupX,limSupY,0);
        imageA->SetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);
        imageA->SetScalarTypeToUnsignedShort();
        imageA->AllocateScalars();
        imageA->Update();

        vtkImageData* imageM = vtkImageData::New();
        imageM->SetDimensions(limSupX,limSupY,0);
        imageM->SetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);
        imageM->SetScalarTypeToUnsignedShort();
        imageM->AllocateScalars();
        imageM->Update();

        for (int i = 0; i < quantContours[point]->getSize(); i++)
        {
                if (quantContours[point]->getContourType(i) == type)
                {
                        polygons.push_back(parsePolyDataToMarIsocontour(quantContours[point]->getContour(i)));
                }
                
        }

        if (polygons.size() == 0)
        {
                return 0;
        }

        int x,y;
        for (x = limInfX; x < (limSupX - 1); x++)
        {
                for (y = limInfY; y < (limSupY - 1); y++)
                {
                        unsigned short *refValueA = (unsigned short *) imageA->GetScalarPointer(x,y,0);
                        unsigned short *refValueM = (unsigned short *) imageM->GetScalarPointer(x,y,0);
                        *refValueA = 0;
                        *refValueM = 0;

                        int numConts;
                        for (numConts = 0; numConts < polygons.size(); numConts++)
                        {
                                if (pointInPolygon(polygons[numConts],x,y))
                                {
                                                *refValueA = 255;
                                }
                        }

                        for (numConts = 0; numConts < manual.size(); numConts++)
                        {
                                if (pointInPolygon(manual[numConts],x,y))
                                {
                                                *refValueM = 255;
                                }
                        }
                }
        }

/*      vtkImageLogic* and = vtkImageLogic::New();
        and->SetInput1(imageM);
        and->SetInput2(imageA);
        and->SetOutputTrueValue(255);
        and->SetOperationToAnd();
*/
        int coincidencias = 0;
        for (x = limInfX; x < (limSupX - 1); x++)
        {
                for (y = limInfY; y < (limSupY - 1); y++)
                {
                        int compA = (int) imageA->GetScalarComponentAsDouble(x,y,0,0);
                        int compM = (int) imageM->GetScalarComponentAsDouble(x,y,0,0);

                        int and_ = compA & compM;
                        if (and_ == 255)
                        {
                                coincidencias++;
                        }
                }
        }

        double resp = (double)coincidencias ;


        return resp;
}

Here is the call graph for this function:

double marAxisCT::performUnion	(	int	type,
		int	point,
		std::vector< marIsocontour * >	manual,
		kVolume *	vol
	)

Definition at line 2446 of file marAxisCT.cpp.

References getContour(), getContourType(), marAxis::getSlice(), parsePolyDataToMarIsocontour(), pointInPolygon(), and marAxis::quantContours.

{
                if (manual.size() == 0)
        {
                return 0;
        }

        int limInfX,limInfY,limInfZ,limSupX,limSupY,limSupZ;
        std::vector <marIsocontour* > polygons;
        vtkImageData* imagedata;

        imagedata = (vtkImageData*) ((getSlice( point , vol ))->castVtk( ));
        imagedata->GetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);
        vtkImageData* imageA = vtkImageData::New();
        imageA->SetDimensions(limSupX,limSupY,0);
        imageA->SetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);
        imageA->SetScalarTypeToUnsignedShort();
        imageA->AllocateScalars();
        imageA->Update();

        vtkImageData* imageM = vtkImageData::New();
        imageM->SetDimensions(limSupX,limSupY,0);
        imageM->SetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);
        imageM->SetScalarTypeToUnsignedShort();
        imageM->AllocateScalars();
        imageM->Update();

        int i;
        for (i = 0; i < quantContours[point]->getSize(); i++)
        {
                if (quantContours[point]->getContourType(i) == type)
                {
                        polygons.push_back(parsePolyDataToMarIsocontour(quantContours[point]->getContour(i)));
                }
                
        }

        if (polygons.size() == 0)
        {
                return 0;
        }

        int x,y;
        for ( x = limInfX; x < (limSupX - 1); x++)
        {
                for ( y = limInfY; y < (limSupY - 1); y++)
                {
                        unsigned short *refValueA = (unsigned short *) imageA->GetScalarPointer(x,y,0);
                        unsigned short *refValueM = (unsigned short *) imageM->GetScalarPointer(x,y,0);
                        *refValueA = 0;
                        *refValueM = 0;
                        int  numConts; 
                        for ( numConts = 0; numConts < polygons.size(); numConts++)
                        {
                                if (pointInPolygon(polygons[numConts],x,y))
                                {
                                                *refValueA = 255;
                                }
                        }

                        for (numConts = 0; numConts < manual.size(); numConts++)
                        {
                                if (pointInPolygon(manual[numConts],x,y))
                                {
                                                *refValueM = 255;
                                }
                        }
                }
        }

/*      vtkImageLogic* and = vtkImageLogic::New();
        and->SetInput1(imageM);
        and->SetInput2(imageA);
        and->SetOutputTrueValue(255);
        and->SetOperationToAnd();
*/
        int coincidencias = 0;
        for (x = limInfX; x < (limSupX - 1); x++)
        {
                for ( y = limInfY; y < (limSupY - 1); y++)
                {
                        int compA = (int) imageA->GetScalarComponentAsDouble(x,y,0,0);
                        int compM = (int) imageM->GetScalarComponentAsDouble(x,y,0,0);

                        int or_ = compA | compM;
                        if (or_ == 255)
                        {
                                coincidencias++;
                        }
                }
        }

        double resp = (double)coincidencias;


        return resp;
}

Here is the call graph for this function:

marIsocontour * marAxisCT::loadMarIsocontour	(	int	size,
		double *	vx,
		double *	vy
	)

Definition at line 2433 of file marAxisCT.cpp.

References marIsocontour::insertPoint().

{
        marIsocontour* cont = new marIsocontour();
                
        for ( int j=0 ; j<size ; j++ )
        {
                cont->insertPoint(vx[j], vy[j]);
        }

        return cont;
}

Here is the call graph for this function:

void marAxisCT::createContours	(	int	point,
		kVolume *	vol
	)			[private]

Definition at line 107 of file marAxisCT.cpp.

References create2Dcontours(), marContourVO::get2DContour(), marContourVO::getContour(), marAxisContours::getContour(), marParameters::getDimIma(), marObject::getParameters(), marAxisContours::getSize(), marParameters::getSizeIma(), marAxis::quantContours, and marContourVO::setContour().

Referenced by create2DDiametersMax(), create2DDiametersMin(), create3Dcontours(), and getContour().

                                                          {

        int j,id;
        int numberOfPoints,numberOfCells;
        vtkCell* cell;
        vtkIdList* pids;
        double p[ 3 ];
        vtkPolyData* vtkPolyData_2DContour;
        double x,y;

        int sizeIma                             =       getParameters( )->getSizeIma( );
        double dimIma                   =       getParameters( )->getDimIma( );

        if (quantContours.size() < point - 1 )
        {
                create2Dcontours(point,vol);
        }

        marAxisContours* axisCont = quantContours[point];
        
        for (int i = 0; i < axisCont->getSize(); i++)
        {
                marContourVO* aContourVO = axisCont->getContour(i);
                aContourVO->setContour(new marContour( point, getParameters( ) ));
                vtkPolyData_2DContour = aContourVO->get2DContour();
                numberOfCells                   =       vtkPolyData_2DContour->GetNumberOfCells( );
                cell                                    =       vtkPolyData_2DContour->GetCell( 0 );
                pids                                    =       cell->GetPointIds( );
                numberOfPoints                  =       pids->GetNumberOfIds( );
                for( j = 0; j < numberOfPoints; j++ ) 
                {
                        id = pids->GetId( j );
                        vtkPolyData_2DContour->GetPoint( id, p);
                        x=p[0]-64.0;
                        y=p[1]-64.0;
                        x=x * dimIma / ( float ) sizeIma;
                        y=y * dimIma / ( float ) sizeIma;
                        aContourVO->getContour()->addContourPoint( x , y );
                }

                aContourVO->getContour()->do_spline();
                aContourVO->getContour()->calculateVariables();
        }
        
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::create3Dcontours	(	int	point,
		kVolume *	vol
	)			[private]

Definition at line 154 of file marAxisCT.cpp.

References createContours(), marContourVO::get3DContour(), marAxisContours::getContour(), getContour(), marAxis::getNormal(), marAxis::getPoints(), marAxisContours::getSize(), marAxis::quantContours, and marContourVO::set3DContour().

Referenced by get3Dcontour().

                                                                 {
        
        if (quantContours[point] == NULL )
        {
                createContours(point,vol);
        }

        marAxisContours* axisCont = quantContours[point];

        for (int i = 0; i < axisCont->getSize(); i++)
        {
                vtkPoints *_vtkPoints;
                double *o;
                double *n;
                vtkMatrix4x4* mat;
                vtkTransform* trans;
                double nn[3];
                double c[3],p1[3],p2[3];
                double nA,nB,nC;

                _vtkPoints                                              = vtkPoints::New();
                o                                                               = getPoints(point); //PENDIENTE  _points[i];
                n                                                               = getNormal( i );
                mat                                                             = vtkMatrix4x4::New();
                trans                                                   = vtkTransform::New();


                nn[0]=n[0];  nn[1]=n[1];  nn[2]=n[2];
                nC=sqrt( nn[0]*nn[0] + nn[1]*nn[1] + nn[2]*nn[2] );
                nn[0]=nn[0]/nC;  nn[1]=nn[1]/nC;  nn[2]=nn[2]/nC;

                vtkPlaneSource* pSource = vtkPlaneSource::New( );
                pSource->SetOrigin( 0, 0        , 0                             );
                pSource->SetPoint1( 1, 0        , 0                             );
                pSource->SetPoint2( 0, 0        , 1.0   );
                pSource->SetCenter( 0,0,0 );
                pSource->SetNormal( nn[ 0 ], nn[ 1 ], nn[ 2 ] );
                pSource->Update( );
                pSource->Update( );
                pSource->GetOrigin(c);
                pSource->GetPoint1(p1);
                pSource->GetPoint2(p2);
                pSource->Delete();
                p1[0]=p1[0]-c[0];  p1[1]=p1[1]-c[1];  p1[2]=p1[2]-c[2];
                p2[0]=p2[0]-c[0];  p2[1]=p2[1]-c[1];  p2[2]=p2[2]-c[2];
                nA=sqrt( p1[0]*p1[0] + p1[1]*p1[1] + p1[2]*p1[2] );
                nB=sqrt( p2[0]*p2[0] + p2[1]*p2[1] + p2[2]*p2[2] );
                p1[0]=p1[0]/nA;  p1[1]=p1[1]/nA;  p1[2]=p1[2]/nA;
                p2[0]=p2[0]/nB;  p2[1]=p2[1]/nB;  p2[2]=p2[2]/nB;

                mat->SetElement (0,0, nn[0]);
                mat->SetElement (1,0, nn[1]);
                mat->SetElement (2,0, nn[2]);
                mat->SetElement (3,0, 0);
                mat->SetElement (0,1, p2[0]);
                mat->SetElement (1,1, p2[1]);
                mat->SetElement (2,1, p2[2]);
                mat->SetElement (3,1, 0);
                mat->SetElement (0,2, p1[0]);
                mat->SetElement (1,2, p1[1]);
                mat->SetElement (2,2, p1[2]);
                mat->SetElement (3,2, 0);
                mat->SetElement (0,3, 0);
                mat->SetElement (1,3, 0);
                mat->SetElement (2,3, 0);
                mat->SetElement (3,3, 1);

                double deter=mat->Determinant(mat);
                trans->Identity();
                trans->SetMatrix(mat);
                float ang;
                ang=-90;
                trans->RotateWXYZ  ( ang,0,1,0); 
                trans->Update();

                vtkMatrix4x4 *m=vtkMatrix4x4::New();
                trans->GetMatrix  (  m  );
    
                int j,numberOfPoints;

                marContour* contour2D   = getContour(point,vol,i);
                marContourVO* aContourVO = axisCont->getContour(i);
                numberOfPoints                  = contour2D->getNumberOfPoints( );
                double fpA[3];
                double pA[3],ppp[3];

                for( j = 0; j <= numberOfPoints; j++ ) {
                        contour2D->getPoint( fpA,j % numberOfPoints);
                        pA[0]=fpA[0];
                        pA[1]=fpA[1];
                        pA[2]=0;

                        ppp[0] = m->GetElement(0,0)*pA[0] + m->GetElement(0,1)*pA[1] + m->GetElement(0,2)*pA[2] + m->GetElement(0,3);
                        ppp[1] = m->GetElement(1,0)*pA[0] + m->GetElement(1,1)*pA[1] + m->GetElement(1,2)*pA[2] + m->GetElement(1,3);
                        ppp[2] = m->GetElement(2,0)*pA[0] + m->GetElement(2,1)*pA[1] + m->GetElement(2,2)*pA[2] + m->GetElement(2,3);

                        ppp[0]=ppp[0]+o[0]-c[0]; ppp[1]=ppp[1]+o[1]-c[1]; ppp[2]=ppp[2]+o[2]-c[2];  
                        _vtkPoints->InsertNextPoint( (float)ppp[0],(float)ppp[1],(float)ppp[2] );

                
                }

        
                m->Delete();
                mat->Delete();
                trans->Delete();

                if (aContourVO->get3DContour()!=NULL){ aContourVO->get3DContour()->Delete(); }
                        aContourVO->set3DContour(_vtkPoints);
        
        }


        
        
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::create2Dcontours	(	int	point,
		kVolume *	vol
	)			[private]

Definition at line 272 of file marAxisCT.cpp.

References marAxisContours::addContour(), adjustContour(), adjustWall(), marAxis::calibration, generatePoints(), marContourVO::get2DContour(), marIsocontour::getCG(), marContourVO::getIsocontour(), marContourVO::getIsocontourCpd(), marContourVO::getIsocontourCpd2(), marContourVO::getIsocontourDcf(), marContourVO::getIsocontourStripped(), marIsocontour::getMaxIntensity(), marAxis::getSlice(), marIsocontour::getType(), marAxisContours::LUMEN, marAxis::quantContours, marContourVO::set2DContour(), marContourVO::setIsocontour(), marContourVO::setIsocontourCpd(), marContourVO::setIsocontourCpd2(), marContourVO::setIsocontourDcf(), marContourVO::setIsocontourStripped(), marContourVO::setSignal(), marContourVO::setType(), startIndex, updateCalcPercentage(), updateLumenPercentage(), and marAxisContours::WALL.

Referenced by adjustContour(), createContours(), createSignals(), get2Dcontour(), getContourType(), getNumberOfContours(), updateCalcPercentage(), and updateLumenPercentage().

                                                                 {
        std::vector <marIsocontour *> contours;

        

        generatePoints(point,vol,&contours);
        
        vtkImageData* imagedata = (vtkImageData*) ((getSlice( point , vol ))->castVtk( ));
        marAxisContours* axisCont = new marAxisContours();

        for (int i = 0; i < contours.size(); i++)
        {
                marContourVO* contourVO = new marContourVO();
                marIsocontour* iso = contours[i];
        
                contourVO->setIsocontour(vtkContourFilter::New());
                contourVO->getIsocontour()->SetInput( imagedata );
                contourVO->getIsocontour()->SetNumberOfContours( 1 );
                contourVO->getIsocontour()->SetValue( 0, iso->getMaxIntensity() );      
                contourVO->getIsocontour()->Update( );
                
                contourVO->setIsocontourCpd(vtkCleanPolyData::New());
                contourVO->getIsocontourCpd()->SetInput( contourVO->getIsocontour()->GetOutput( ) );
                contourVO->getIsocontourCpd()->ConvertLinesToPointsOff( );
                contourVO->getIsocontourCpd()->Update( );

                double cgx, cgy;

                iso->getCG(&cgx,&cgy);
                
                contourVO->setIsocontourDcf(vtkPolyDataConnectivityFilter::New( ));
                contourVO->getIsocontourDcf()->SetInput( contourVO->getIsocontourCpd()->GetOutput( ) );
                
                contourVO->getIsocontourDcf()->SetClosestPoint( cgx, cgy, 0 );
                contourVO->getIsocontourDcf()->SetExtractionModeToClosestPointRegion( );
                contourVO->getIsocontourDcf()->Update( );
                
                contourVO->setIsocontourCpd2(vtkCleanPolyData::New());
                contourVO->getIsocontourCpd2()->SetInput( contourVO->getIsocontourDcf()->GetOutput( ) );
                contourVO->getIsocontourCpd2()->Update();

                contourVO->setIsocontourStripped(vtkStripper::New( ));
                contourVO->getIsocontourStripped()->SetInput( contourVO->getIsocontourCpd2()->GetOutput() );
                contourVO->getIsocontourStripped()->Update();
        
                contourVO->set2DContour(contourVO->getIsocontourStripped()->GetOutput());
                contourVO->get2DContour()->Update();
                contourVO->setSignal(iso->getMaxIntensity());
                
                if (iso->getType() == marAxisContours::LUMEN)
                {
                        contourVO->setType(marAxisContours::WALL);
                }
                else
                {
                        contourVO->setType(iso->getType());
                }
                
                
                
                axisCont->addContour(contourVO);

                
                delete iso;
                contours[i] = NULL;
        }

        

        quantContours[point] = axisCont;
        


        updateLumenPercentage(point,vol);
        
        updateCalcPercentage(point,vol);
//      adjustWall(point,vol);
        if (calibration && point < startIndex)
        {
                this->adjustContour(point,vol); 
        }
        else
        {
                adjustWall(point,vol);
        }
        contours.clear();
        imagedata->Delete();


//      marIsocontour* cont = parsePolyDataToMarIsocontour(quantContours[point]->getContour(0));

        /*FILE *archivo;
        char nomArchivo[30], temp[3];

        strcpy(nomArchivo,"./points");
        itoa(point,temp,10);
        strcat(nomArchivo,temp);
        strcat(nomArchivo,".csv");
        
        archivo = fopen(nomArchivo,"w");
        
        for (int h = 0; h < cont->getSize(); h++)
        {
                double x, y;
                cont->getPoint(h,&x,&y);
                fprintf(archivo,"%f;%f\n",x,y);
        }

        fclose(archivo);*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::create2DDiametersMin	(	int	point,
		kVolume *	vol
	)			[private]

Definition at line 384 of file marAxisCT.cpp.

References createContours(), marContourVO::get2DDiameterMin(), marAxisContours::getContour(), getContour(), marParameters::getDimIma(), marObject::getParameters(), marAxisContours::getSize(), marParameters::getSizeIma(), marAxis::quantContours, and marContourVO::set2DDiameterMin().

Referenced by get2DDiameterMin().

                                                                 {
        
if (quantContours[point] == NULL )
        {
                createContours(point,vol);
        }

        marAxisContours* axisCont = quantContours[point];

        for (int i = 0; i < axisCont->getSize(); i++)
        {
                double p1[2],p2[2];
                marContour *marcontour=getContour(point,vol,i);
                marContourVO* aContourVO = axisCont->getContour(i);

                marcontour->getMinimumLine(p1,p2);
                vtkPoints *_vtkPoints = vtkPoints::New();
                
                int sizeIma = getParameters( )->getSizeIma( );
                double dimIma = getParameters( )->getDimIma( );
                double factor=( float ) sizeIma / dimIma;
                
                p1[0]=p1[0]*factor+sizeIma/2;
                p1[1]=p1[1]*factor+sizeIma/2;
                p2[0]=p2[0]*factor+sizeIma/2;
                p2[1]=p2[1]*factor+sizeIma/2;
                _vtkPoints->InsertNextPoint( p1[0] , p1[1] , 1 );
                _vtkPoints->InsertNextPoint( p2[0] , p2[1] , 1 );

                if ( aContourVO->get2DDiameterMin()!=NULL ) { aContourVO->get2DDiameterMin()->Delete(); }
                        aContourVO->set2DDiameterMin(_vtkPoints);

        }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::create2DDiametersMax	(	int	point,
		kVolume *	vol
	)			[private]

Definition at line 421 of file marAxisCT.cpp.

References createContours(), marContourVO::get2DDiameterMax(), marAxisContours::getContour(), getContour(), marParameters::getDimIma(), marObject::getParameters(), marAxisContours::getSize(), marParameters::getSizeIma(), marAxis::quantContours, and marContourVO::set2DDiameterMax().

Referenced by get2DDiameterMax().

                                                                 {
        if (quantContours[point] == NULL )
        {
                createContours(point,vol);
        }

        marAxisContours* axisCont = quantContours[point];

        for (int i = 0; i < axisCont->getSize(); i++)
        {
                double p1[2],p2[2];
                marContour *marcontour=getContour(point,vol,i);
                marContourVO* aContourVO = axisCont->getContour(i);

                marcontour->getMaximumLine(p1,p2);
                vtkPoints *_vtkPoints = vtkPoints::New();

                int sizeIma = getParameters( )->getSizeIma( );
                double dimIma = getParameters( )->getDimIma( );
                double factor=( float ) sizeIma / dimIma;
                p1[0]=p1[0]*factor+sizeIma/2;
                p1[1]=p1[1]*factor+sizeIma/2;
                p2[0]=p2[0]*factor+sizeIma/2;
                p2[1]=p2[1]*factor+sizeIma/2;
                _vtkPoints->InsertNextPoint( p1[0] , p1[1] , 1 );
                _vtkPoints->InsertNextPoint( p2[0] , p2[1] , 1 );
                
                if ( aContourVO->get2DDiameterMax()!=NULL ) { aContourVO->get2DDiameterMax()->Delete(); }
                        aContourVO->set2DDiameterMax(_vtkPoints);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::createSignals	(	int	point,
		kVolume *	vol
	)			[private]

Definition at line 454 of file marAxisCT.cpp.

References create2Dcontours(), and marAxis::quantContours.

Referenced by getSignal().

                                                      {
        if (quantContours[point] == NULL )
        {
                create2Dcontours(point,vol); //AQUI
        //      filterSignal(vol);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::generatePoints	(	int	point,
		kVolume *	vol,
		std::vector< marIsocontour * > *	list
	)			[private]

Definition at line 486 of file marAxisCT.cpp.

References addPointToContour(), marAxisContours::CALCIFICATION, detectNeighbor(), generateVector(), getCalcStatistics(), getMaximumGrad(), getMaxIntensity(), getMinimumGrad(), marObject::getParameters(), marAxis::getPoints(), marAxis::getSlice(), getStatistics(), interpolate(), marAxisContours::LUMEN, marAxis::lumenContour, marAxis::next(), marUtils::obtainAverage(), marUtils::obtainStandardDeviation(), marPoint::setDirection(), marPoint::setGradient(), marPoint::setIntensity(), and unifyDividedStructure().

Referenced by create2Dcontours().

                                                                                       {

        vtkImageData* imagedata;
        int dirs = 72;
        double aPoint[ 3 ];
        double *nPoint = new double[ 3 ];
        double x, y, prevIntensity, threshold;
        bool found, estStart, estDivided, isNeighbor;
        int actualZone, startZone, coordBase, maxPoint, lumenCount, calcCount;
        std::vector <marPoint  *> gradients;
        std::vector <double> average;
        std::vector <marIsocontour *> contoursLumen;
        std::vector <marIsocontour *> contoursCalc;

        contoursLumen.push_back(NULL);
        contoursCalc.push_back(NULL);
        
        
        
        //1. Check starting zone
        startZone = marAxisContours::LUMEN;
        actualZone = startZone;
        lumenCount = 0;
        calcCount = 0;

        imagedata = (vtkImageData*) ((getSlice( point , vol ))->castVtk( ));

        int limInfX, limInfY, limInfZ;
        int limSupX, limSupY, limSupZ;
        imagedata->GetExtent(limInfX,limSupX,limInfY,limSupY,limInfZ,limSupZ);

        vtkImageCast* cast = vtkImageCast::New();
        cast->SetInput(imagedata);
        cast->SetOutputScalarTypeToDouble();

        vtkImageGaussianSmooth* filter = vtkImageGaussianSmooth::New();
        filter->SetDimensionality(2);
        filter->SetInput(cast->GetOutput());
        filter->SetStandardDeviations((getParameters())->getStandardDeviation(),(getParameters())->getStandardDeviation());
        filter->SetRadiusFactors((getParameters())->getRadius(),(getParameters())->getRadius());
        filter->SetStandardDeviations(3,3);
        filter->SetRadiusFactors(3,3);

        //imagedata = filter->GetOutput();
        
        
        nPoint = getPoints(point);

        aPoint[ 0 ]     =  (limSupX - limInfX) / 2; //nPoint[0]; 
        aPoint[ 1 ]     =  (limSupY - limInfY) / 2; //nPoint[1]; 
        aPoint[ 2 ]     =  (limSupZ - limInfZ) / 2; // nPoint[2]; 
        estDivided = false;
        estStart = false;
        //3. Generate rays over all directions
        for (int dir = 0; dir < dirs; dir++)
        {
                
                x = aPoint[ 0 ];
                y = aPoint[ 1 ];
                coordBase = 1;
                prevIntensity = interpolate(x,y,imagedata);
                generateVector(dir,&coordBase,aPoint[0],aPoint[1],&x,&y);

                //2.1 Evaluate gradient in every position of the ray 
                while ((x > (limInfX+1) && x < (limSupX-1)) && (y > (limInfY+1) && y < (limSupY-1)))
                {
                        
                        //2.1.1 Interpolate
                        double resp = interpolate(x,y,imagedata);
                        //2.1.2 Calcultate gradient
                        marPoint* p = new marPoint(x,y);
                        p->setGradient(prevIntensity - resp);
                        p->setDirection(dir);
                        p->setIntensity(resp);
                        
                        prevIntensity = resp;

                        gradients.push_back(p);

                        //2.1.3 Increase ray for next evaluation
                        generateVector(dir,&coordBase,aPoint[0],aPoint[1],&x,&y);

                }// end while gradient

                int index = 0;
                found = false;
                x = aPoint[ 0 ];
                y = aPoint [ 1 ];
                threshold = ((marParameters *) getParameters())->getContourThresh();
                int mysize = gradients.size();
                
                //2.2 Compare every gradient value with threshold
                while (index < gradients.size() && !found)
                {
                        //2.2.1 Evaluate Lumen
                        if (actualZone == marAxisContours::LUMEN)
                        {
                                average.push_back(gradients[index]->getIntensity());
                                
                                //2.2.1.1 If value > threshold there is a contour
                                if (fabs(gradients[index]->getGradient()) > threshold 
                                        && fabs(gradients[index]->getGradient()) < 4000) {
                                                //|| (calibration && (abs(gradients[index]->getIntensity()) > abs(avgValue - 2.5*stdValue)
                                                //|| abs(gradients[index]->getIntensity()) > abs(avgValue + 2.5*stdValue)))) {

                                        

                                        if(gradients[index]->getGradient() > 0)
                                                maxPoint = getMaximumGrad(gradients,index,gradients.size(),threshold);
                                        else
                                                maxPoint = getMinimumGrad(gradients,index,gradients.size(),threshold);

                                        index = maxPoint;
                                        x = gradients[maxPoint]->getX();
                                        y = gradients[maxPoint]->getY();

                                        //2.2.1.1.1 Assign lumen structure
                                        isNeighbor = detectNeighbor(contoursLumen[lumenCount],dir,marAxisContours::LUMEN);
                                        if (!isNeighbor)
                                        {
                                                lumenCount++;
                                        }
                                        
                                        marIsocontour* cont = addPointToContour(contoursLumen[lumenCount],false,marAxisContours::LUMEN,gradients[maxPoint]);
                                        contoursLumen[lumenCount] = cont;

                                        //2.2.1.1.2 Check step lumen->calcification
                                        double actualInt = interpolate(x,y,imagedata);
                                        double auxX = x;
                                        double auxY = y;
                                        generateVector(dir,&coordBase,aPoint[0],aPoint[1],&auxX,&auxY);
                                    double next = interpolate(auxX,auxY,imagedata);
                                        if (gradients[index]->getGradient() < 0 /*&& actualInt < next */&& (auxX > (limInfX+1) && auxX < (limSupX-1)) && (auxY > (limInfY+1) && auxY < (limSupY-1)))
                                        {
                                                //2.2.1.1.2.1 Assign calcification structure
                                                isNeighbor = detectNeighbor(contoursCalc[calcCount],dir,marAxisContours::CALCIFICATION);
                                                if (!isNeighbor)
                                                {
                                                        calcCount++;
                                                        contoursCalc.push_back(NULL);
                                                }

                                                cont = addPointToContour(contoursCalc[calcCount],true,marAxisContours::CALCIFICATION,gradients[maxPoint]);
                                                
                                                contoursCalc[calcCount] = cont;

                                                actualZone = marAxisContours::CALCIFICATION;
                                                //ASIGNACION varX???

                                                //2.2.1.1.2.3 Verify divided structure
                                                if (dir == 0)
                                                {
                                                        estStart = true;
                                                }

                                                if ((dir == dirs - 1) && estStart)
                                                {
                                                        estDivided = true;
                                                }

                                        }//2.2.1.1.3 Transition lumen->background
                                        else
                                        {
                                                //2.2.1.1.3.1 Asign border structure
                                                //ASIGNAR ESTRUCTURA
                                                
                                                //2.2.1.1.3.2 Generate stop condition
                                                found = true;
                                                actualZone = startZone;
                                                coordBase = 1;
                                                x = aPoint[ 0 ];
                                                y = aPoint[ 1 ];
                                                threshold = ((marParameters *) getParameters())->getContourThresh();
                                        }

                                }
                        }
                        //2.2.2 Evaluate calcification (MODIFIED IF THERE IS HYPODENSE)
                        else
                        {
                                coordBase = 1;
                                int calcIndex;
                                double actualInt = interpolate(x,y,imagedata);
                                generateVector(dir,&coordBase,aPoint[0],aPoint[1],&x,&y);
                                double next = interpolate(x,y,imagedata);

                                //2.2.2.1 If actual intensity is smaller than previous there is a contour
                                if (actualInt < next)
                                {
                                        while (actualInt < interpolate(x,y,imagedata) && (x > (limInfX+1) && x < (limSupX-1)) && (y > (limInfY+1) && y < (limSupY-1)))
                                        {
                                                generateVector(dir,&coordBase,aPoint[0],aPoint[1],&x,&y);
                                                index++;
                                        }

                                }

                                generateVector(dir,&coordBase,aPoint[0],aPoint[1],&x,&y);

                                //2.2.2.2 Assign calcification structure
                                isNeighbor = detectNeighbor(contoursCalc[calcCount],dir,marAxisContours::CALCIFICATION);
                                if (!isNeighbor)
                                {
                                        calcCount++;
                                        contoursCalc.push_back(NULL);
                                }

                                //Adjust index to avoiod crash
                                if (index >= gradients.size())
                                {
                                        calcIndex = gradients.size() - 1;
                                }
                                else
                                {
                                        calcIndex = index;
                                }

                                marIsocontour* cont = addPointToContour(contoursCalc[calcCount],false,marAxisContours::CALCIFICATION,gradients[calcIndex]);
                                contoursCalc[calcCount] = cont;
                                
                                //2.2.2.3 Asign border structure
                                //ASIGNACION BORDE

                                found = true;
                                actualZone = startZone;
                                x = aPoint[ 0 ];
                                y = aPoint[ 1 ];
                                threshold = ((marParameters *) getParameters())->getContourThresh();

                        }//end if zones

                        index++;

                        if (index == gradients.size() && !found)
                        {
                                threshold = threshold - 1;
                                index = 0;
                        }

                }//end while evaluation

                //TODO - SACAR A UTILS
                for (int ind = 0; ind < gradients.size(); ind++)
                {
                        marPoint* p = gradients[ind];
                        gradients[ind] = NULL;
                        delete p;
                        
                }
                gradients.clear();

        }//end for directions

        FILE *archivo;
        char nomArchivo[30]; //, temp[3]

        strcpy(nomArchivo,"./debug");
//      itoa(point,temp,10);
//      strcat(nomArchivo,temp);
        strcat(nomArchivo,".txt");
        archivo = fopen(nomArchivo,"w");
        
  


        
//      lumenContour[point] = contoursLumen[marAxisContours::LUMEN];
        
        double  tempXi, tempYi;
        int polySides = contoursLumen[marAxisContours::LUMEN]->getSize();
        
    
        marIsocontour* alc = new marIsocontour();
        for (int m=0; m<polySides; m++) {
                contoursLumen[marAxisContours::LUMEN]->getPoint(m,&tempXi,&tempYi);          
                alc = addPointToContour(lumenContour[point],false,marAxisContours::LUMEN,new marPoint(tempXi,tempYi));
                lumenContour[point] = alc;
                fprintf(archivo,"X:%f,Y:%f\n",tempXi,tempYi);
        }
        

        
        //4. Verify divided unified structure
        if (estDivided && calcCount > 0)
        {
                unifyDividedStructure(&contoursCalc);
                calcCount--;
        }   
        
        //5. Obtain statistics
        double lumenInt = getStatistics(contoursLumen[marAxisContours::LUMEN],aPoint[ 0 ],aPoint[ 1 ], imagedata);
        contoursLumen[marAxisContours::LUMEN]->setMaxIntensity(lumenInt);

        if (contoursCalc[0] != NULL)
        {
                for (int i = 0; i < contoursCalc.size(); i++)
                {
                        lumenCount++;
                        double maxInt = getCalcStatistics(contoursCalc[i],aPoint[ 0 ],aPoint[1],imagedata,i-1);
                        contoursCalc[i]->setMaxIntensity(maxInt);
                        contoursLumen.push_back(NULL);
                        contoursLumen[lumenCount] = contoursCalc[i];
                }
        }
        
        
        *list = contoursLumen;

        contoursCalc.clear();
    contoursLumen.clear();
        marUtils* util = new marUtils();
        double avg = util->obtainAverage(average);
        //FILE *archivo;
        //archivo = fopen("./debug.txt","w");
        fprintf(archivo,"tamaño: %d umbra: %d",  (*list).size(),((marParameters *) getParameters())->getContourThresh());
        for (int k = 0; k < contoursLumen.size(); k++)
        {
                double cgx, cgy;

                (*list)[k]->getCG(&cgx,&cgy);
                fprintf(archivo,"cx: %f cy:%f Señal: %f Type: %d\n", cgx, cgy, (*list)[k]->getMaxIntensity(), (*list)[k]->getType());
        }

        fprintf(archivo,"PROMEDIO %f - STD: %f\n",avg,util->obtainStandardDeviation(average,avg));
        fprintf(archivo,"%d\n",lumenContour.size());
        fclose(archivo);
        imagedata->Delete();
        
}

Here is the call graph for this function:

Here is the caller graph for this function:

int marAxisCT::getMaximumGrad	(	std::vector< marPoint * >	list,
		int	iniPos,
		int	limit,
		double	threshold
	)			[private]

Definition at line 817 of file marAxisCT.cpp.

Referenced by generatePoints().

                                                                                                  {
        
        double max = list[iniPos]->getGradient();
        int coordMax = iniPos;
        int cont = iniPos + 1;

        while (cont < limit && list[cont]->getGradient()>=threshold){
                if (list[cont]->getGradient() > max){
                        max = list[cont]->getGradient();
                        coordMax = cont;
                }
                cont++;
        }

        return coordMax;
} 

Here is the caller graph for this function:

int marAxisCT::getMinimumGrad	(	std::vector< marPoint * >	list,
		int	iniPos,
		int	limit,
		double	threshold
	)			[private]

Definition at line 835 of file marAxisCT.cpp.

References min.

Referenced by generatePoints().

                                                                                                  {
        
        double min = list[iniPos]->getGradient();
        int coordMin = iniPos;
        int cont = iniPos + 1;

        while (cont < limit && fabs(list[cont]->getGradient())>=threshold){
                if (list[cont]->getGradient() < min){
                        min = list[cont]->getGradient();
                        coordMin = cont;
                }
                cont++;
        }

        return coordMin;
} 

Here is the caller graph for this function:

double marAxisCT::interpolate	(	double	x,
		double	y,
		vtkImageData *	imagedata
	)			[private]

Definition at line 853 of file marAxisCT.cpp.

Referenced by generatePoints(), getCalcStatistics(), and getStatistics().

                                                                         {

        double a,b,c,d;
        double intensity;
        int i,j;

        i = (int)floor(x);
        j = (int)floor(y);

        
        c = imagedata->GetScalarComponentAsDouble(i,j,0,0) + (double) imagedata->GetScalarComponentAsDouble(i+1,j+1,0,0)
                - imagedata->GetScalarComponentAsDouble(i+1,j,0,0) - imagedata->GetScalarComponentAsDouble(i,j+1,0,0);

        b = imagedata->GetScalarComponentAsDouble(i,j+1,0,0) - c*i - imagedata->GetScalarComponentAsDouble(i,j,0,0);

        a = imagedata->GetScalarComponentAsDouble(i+1,j,0,0) - c*j - imagedata->GetScalarComponentAsDouble(i,j,0,0);

        d = imagedata->GetScalarComponentAsDouble(i,j,0,0) - a*i - b*j - c*i*j;

        intensity = a*x + b*y + c*x*y + d;

        return intensity;
}

Here is the caller graph for this function:

void marAxisCT::generateVector	(	int	dir,
		int *	coordBase,
		double	originX,
		double	originY,
		double *	x,
		double *	y
	)			[private]

Definition at line 878 of file marAxisCT.cpp.

Referenced by generatePoints(), getCalcStatistics(), getDiameter(), and getStatistics().

                                                                                                       {

        int dirs = 72;
        int angle = (dir * (360 / dirs));

        *x = 1 * cos(angle *(3.1415/180)) + (*x); 
        *y = 1 * sin(angle *(3.1415/180)) + (*y); 

        (*coordBase)++; 
}

Here is the caller graph for this function:

bool marAxisCT::detectNeighbor	(	marIsocontour *	contour,
		int	dir,
		int	type
	)			[private]

Definition at line 890 of file marAxisCT.cpp.

References marIsocontour::getDir(), marIsocontour::getSize(), and marIsocontour::getType().

Referenced by generatePoints().

                                                                       {
        
        bool isNeighbor = false;

        if (contour == NULL){
                isNeighbor = true; 
        }else{
                for (int i = 0; i < contour->getSize(); i++) {
                        
                        if (((contour->getDir(i) == (dir - 1)) || (contour->getDir(i) == dir)) 
                                    && (contour->getType() == type)){ 
                                isNeighbor = true; 
                        }       
                }
        }

        return isNeighbor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marIsocontour * marAxisCT::addPointToContour	(	marIsocontour *	cont,
		bool	inside,
		int	type,
		marPoint *	point
	)			[private]

Definition at line 910 of file marAxisCT.cpp.

References marPoint::getDirection(), marIsocontour::getSize(), marPoint::getX(), marPoint::getY(), marIsocontour::insertPoint(), marIsocontour::setDir(), marIsocontour::setInside(), and marIsocontour::setType().

Referenced by generatePoints().

                                                                                                      {

        

        if (cont == NULL)
        {
                cont = new marIsocontour();
                cont->setType(type);
        }
        
        cont->insertPoint(point->getX(),point->getY());
        cont->setDir(cont->getSize() - 1,point->getDirection());
        cont->setInside(cont->getSize() - 1,inside);
        
        return cont;
        
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::unifyDividedStructure

(

std::vector< marIsocontour * > *

contList

)

[private]

Definition at line 929 of file marAxisCT.cpp.

References marIsocontour::getDir(), marIsocontour::getInside(), marIsocontour::getPoint(), marIsocontour::getSize(), marIsocontour::insertPoint(), marIsocontour::setDir(), and marIsocontour::setInside().

Referenced by generatePoints().

                                                                         {

        marIsocontour* structOne = (*contList)[contList->size()-1];
        marIsocontour* structTwo = (*contList)[0];
        

        for (int i = 0; i < structOne->getSize(); i++)
        {
                double x;
                double y;
                structOne->getPoint(i,&x,&y);
                structTwo->insertPoint(x,y);
                structTwo->setDir(structTwo->getSize() - 1,structOne->getDir(i));
                structTwo->setInside(structTwo->getSize() - 1,structOne->getInside(i));

        }

        contList->pop_back();
}

Here is the call graph for this function:

Here is the caller graph for this function:

double marAxisCT::getStatistics	(	marIsocontour *	contour,
		double	x,
		double	y,
		vtkImageData *	imagedata
	)			[private]

Definition at line 950 of file marAxisCT.cpp.

References generateVector(), marIsocontour::getDir(), marIsocontour::getPoint(), marIsocontour::getSize(), and interpolate().

Referenced by generatePoints().

                                                                                                   {

        double max, auxX, auxY;
        int basis;
        max = interpolate(x,y,imagedata);

        for (int i = 0; i < contour->getSize(); i++)
        {
                basis = 1;
                auxX = x;
                auxY = y;
                double pointX;
                double pointY;

                contour->getPoint(i,&pointX,&pointY);
                while (auxX != pointX || auxY != pointY)
                {
                        double intensity = interpolate(auxX,auxY,imagedata);
                        if (max < intensity)
                        {
                                max = intensity;
                        }
                        generateVector(contour->getDir(i),&basis,x,y,&auxX,&auxY);

                }
        }
        
        return max;
}

Here is the call graph for this function:

Here is the caller graph for this function:

double marAxisCT::getCalcStatistics	(	marIsocontour *	contour,
		double	x,
		double	y,
		vtkImageData *	imagedata,
		int	i
	)			[private]

Definition at line 982 of file marAxisCT.cpp.

References generateVector(), marIsocontour::getDir(), marIsocontour::getPoint(), marIsocontour::getSize(), and interpolate().

Referenced by generatePoints().

                                                                                                                {

        
        double max, auxX,auxY;
        int basis;
        
        int i;
        FILE *archivo;
        char nomArchivo[30], temp[3];

        strcpy(nomArchivo,"./statistics");

// EED 06/06/2007 linux
//      itoa(dir,temp,10);
        sprintf(temp,"%d",dir);

        strcat(nomArchivo,temp);
        strcat(nomArchivo,".txt");


        archivo = fopen(nomArchivo,"w");
        i = 0; 
        max = 0;
        fprintf(archivo,"TAMAÑO %d\n",contour->getSize());

        while (i < contour->getSize()) 
        {
                basis = 1;
                double pointX, pointY;
                contour->getPoint(i+1,&pointX,&pointY);
                contour->getPoint(i,&auxX,&auxY);
                fprintf(archivo,"final: %f %f inicial %f %f \n",pointX,pointY,auxX,auxY);       
                
                while (auxX != pointX || auxY != pointY)
                {
                        double intensity = interpolate(auxX,auxY,imagedata);
                        if (max < intensity){
                                max = intensity;
                        }
                        generateVector(contour->getDir(i),&basis,auxX,auxY,&auxX,&auxY);
                }
                        
                i +=2;
        }
        fclose(archivo);
        return max;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int marAxisCT::round

(

double

num

)

[private]

Definition at line 1031 of file marAxisCT.cpp.

                              {

        float decimal;
        int resp;
        
        decimal = num - floor(num) * 1.0000;

        if (decimal >= 0.50000)
                resp = (int)ceil(num);
        else
                resp = (int)floor(num);

        return resp;

}

int marAxisCT::getMaxIntensity

(

int

point

)

[private]

Definition at line 1120 of file marAxisCT.cpp.

References marAxisContours::CALCIFICATION, getContour(), and marAxis::quantContours.

Referenced by generatePoints(), and updateCalcPercentage().

{
        int pos = 1; 
        double intMax;
        if (quantContours[point]->getSize() > 2)
        {
                intMax = quantContours[point]->getContour(0)->getSignal();
                for (int i = 0; i < quantContours[point]->getSize(); i++)
                {
                        if (quantContours[point]->getContour(i)->getSignal() > intMax && quantContours[point]->getContour(i)->getType() == marAxisContours::CALCIFICATION)
                        {
                                intMax = quantContours[point]->getContour(i)->getSignal() ;
                                pos = i;
                        }
                }
        }

        return pos;
        
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool marAxisCT::pointInPolygon	(	marIsocontour *	c,
		double	x,
		double	y
	)			[private]

Definition at line 1185 of file marAxisCT.cpp.

References marIsocontour::getPoint(), and marIsocontour::getSize().

Referenced by getDiameter(), histogram(), markUpLumen(), performAND(), performUnion(), and performXOR().

                                                                  {
        int      i, j=0;
        bool  oddNODES=false;
        int polySides = c->getSize();
        double *polyX, *polyY, tempX, tempY;

        polyX = (double *) malloc(polySides*sizeof(double));
        polyY = (double *) malloc(polySides*sizeof(double));

        for (i=0; i<polySides; i++) {
                c->getPoint(i,&tempX,&tempY);          
                polyX[i] = tempX;
                polyY[i] = tempY;
        }

        for (i=0; i<polySides; i++) {
                j++; 
                if (j==polySides) 
                        j=0;
                
                if (polyY[i]<y && polyY[j]>=y
                        ||  polyY[j]<y && polyY[i]>=y) {
                        if (polyX[i]+(y-polyY[i])/(polyY[j]-polyY[i])*(polyX[j]-polyX[i])<x) {
                                oddNODES=!oddNODES; 
                        }
                }
        }

        free(polyX);
        free(polyY);
  return oddNODES; 

}

Here is the call graph for this function:

Here is the caller graph for this function:

marIsocontour * marAxisCT::parsePolyDataToMarIsocontour

(

marContourVO *

contourVO

)

[private]

Definition at line 1220 of file marAxisCT.cpp.

References marContourVO::get2DContour(), marContourVO::getIsocontourStripped(), marIsocontour::insertPoint(), and marContourVO::isReplaced().

Referenced by adjustContour(), adjustWall(), extractLumen(), generateFile(), getDiameter(), histogram(), markUpLumen(), performAND(), performUnion(), and performXOR().

                                                                             {

        vtkPolyData* polyDataCnt;
        vtkIdList* pointsId;
        double* pointPolyDataCnt;
        int numPointsPolyDataCnt, numTemp;
        marIsocontour *cont;

        if (contourVO->isReplaced())
        {
                polyDataCnt = contourVO->get2DContour();
        }
        else
        {
                polyDataCnt =    contourVO->getIsocontourStripped()->GetOutput();
        }
        
        numPointsPolyDataCnt = polyDataCnt->GetNumberOfPoints();
        pointsId = polyDataCnt->GetCell(0)->GetPointIds();
        numTemp = pointsId->GetNumberOfIds();
        
        cont = new marIsocontour();
        
        for (int i = 0; i < (numTemp -1); i++){
                pointPolyDataCnt = polyDataCnt->GetPoint(pointsId->GetId(i));
                cont->insertPoint(pointPolyDataCnt[0], pointPolyDataCnt[1]);
                
        }
                
        return cont;    
}

Here is the call graph for this function:

Here is the caller graph for this function:

marIsocontour * marAxisCT::filterContour	(	marIsocontour *	contExt,
		marIsocontour *	contInt,
		double	radio
	)			[private]

Definition at line 1255 of file marAxisCT.cpp.

References marLine::getA(), marLine::getB(), marLine::getC(), marLine::getIntersect(), marIsocontour::getPoint(), marIsocontour::getSize(), and marIsocontour::insertPoint().

                                                                                                   {
  
        double tmp_eed;
        double x1,y1,x2,y2,xInt,yInt, xAux, yAux;
        std::vector<marLine*> lineas;   
        std::vector<double> dists;
        int count, countAux, ultima;
        bool hayInterseccion;

        marIsocontour* newCont = new marIsocontour();

        for (int i = 0; i < contExt->getSize(); i++){
                contExt->getPoint(i,&x1,&y1);
                contInt->getPoint(i,&x2,&y2);
                lineas.push_back(new marLine(x1,y1,x2,y2));     
                tmp_eed = sqrt(pow((x2-x1),2.0) + pow((y2-y1),2.0)); 
                dists.push_back( tmp_eed );
        }

        count = 0;
        ultima = 0;
        while (count < lineas.size() - 1){
                countAux = 0;

                marLine* l1 = lineas[count];
        
                hayInterseccion = false;
                while (countAux < lineas.size()){
                        marLine *l2 = lineas[countAux];

                        l1->getIntersect(l2->getA(),l2->getB(),l2->getC(),&xInt,&yInt);

                        
                        if (xInt > 0 && yInt > 0){
                                contExt->getPoint(countAux,&xAux,&yAux);
                                if (dists[count] >= sqrt(pow((xInt-xAux),2.0) + pow((yInt-yAux),2.0))){
                                        contExt->getPoint(count,&x1,&y1);
                                        contInt->getPoint(count,&x2,&y2);

                                        //Distancia menor?
                                        if ((dists[count] > sqrt(pow((xInt-x1),2.0) + pow((yInt-y1),2.0))) && 
                                                (dists[count] > sqrt(pow((xInt-x2),2.0) + pow((yInt-y2),2.0))))
                                        {
                                                ultima = countAux;
                                                hayInterseccion = true;
                                        
                                        } 
                                
                                }
                        }
                        countAux++;
                }

        
                if (!hayInterseccion){
                        contInt->getPoint(count,&x2,&y2);
                        newCont->insertPoint(x2,y2);
                } 
                        count++;
                
        }

        return newCont;
}

Here is the call graph for this function:

double marAxisCT::obtainContourArea

(

marIsocontour *

contour

)

[private]

Definition at line 1485 of file marAxisCT.cpp.

References marIsocontour::getPoint(), and marIsocontour::getSize().

Referenced by adjustContour(), adjustWall(), and extractLumen().

{

        double area = 0.0;
        double x1,y1,x2,y2;
        
        for (int i = 0; i < contour->getSize();i++)
        {
                contour->getPoint(i,&x1,&y1);
                if (i < (contour->getSize() - 1)) 
                {
                        contour->getPoint(i+1,&x2,&y2);
                }
                else 
                {
                        contour->getPoint(0,&x2,&y2);
                }

                area += (x1 * y2);
                area -= (y1 * x2);
        }

        area = area / 2;

        if (area < 0)
                area = -area;

        return area;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::adjustWall	(	int	point,
		kVolume *	vol
	)			[private]

Definition at line 1516 of file marAxisCT.cpp.

References marObject::getParameters(), maxValue(), obtainContourArea(), parsePolyDataToMarIsocontour(), searchContour(), updateLumenPercentage(), and marAxisContours::WALL.

Referenced by create2Dcontours().

{
        //int actualPercentage = ((marParameters *) getParameters())->getLumenPercentage();
        marIsocontour* cont;
        double actualArea, previousArea;
        std::vector <double > grad;
        marContourVO* wallCont = searchContour(marAxisContours::WALL,point);

        //Obtain first area
        ((marParameters *) getParameters())->setLumenPercentage(50);
        updateLumenPercentage(point,vol);
        cont = parsePolyDataToMarIsocontour(wallCont);
        previousArea = obtainContourArea(cont);

        for (int eval = 49; eval >= 0; eval--)
        {
                ((marParameters *) getParameters())->setLumenPercentage(eval);
                updateLumenPercentage(point,vol);
                cont = parsePolyDataToMarIsocontour(wallCont);
                actualArea = obtainContourArea(cont);
                grad.push_back(fabs(actualArea - previousArea));
        }

        int newPercentage = 50 - maxValue(grad);
        ((marParameters *) getParameters())->setLumenPercentage(newPercentage);
        updateLumenPercentage(point,vol);

        

}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxisCT::adjustCalcification	(	int	point,
		kVolume *	vol
	)			[private]

Definition at line 1548 of file marAxisCT.cpp.

{
}

void marAxisCT::adjustContour	(	int	point,
		kVolume *	vol
	)			[private]

Definition at line 1758 of file marAxisCT.cpp.

References create2Dcontours(), marContourVO::get2DContour(), marContourVO::getIsocontour(), markUpLumen(), maxSignal, obtainContourArea(), parsePolyDataToMarIsocontour(), marAxis::quantContours, searchContour(), marAxis::stop(), and marAxisContours::WALL.

Referenced by create2Dcontours().

{

        double percentage = 0.05;
        double prevDifference = 0;
        if (quantContours[point + 1] == NULL)
        {
                create2Dcontours(point + 1 ,vol);
        }

        //1. Obtain actual signal 
        double signal = maxSignal;
        marContourVO* wallCont = searchContour(marAxisContours::WALL,point);

        //2. Obtain previous contour
        marIsocontour* prev = parsePolyDataToMarIsocontour(searchContour(marAxisContours::WALL, point + 1));
        
        //3. Adjust actual contour
        double newValue = signal; 
        wallCont->getIsocontour()->SetValue(0,newValue);
        wallCont->getIsocontour()->Update();
        wallCont->get2DContour()->Update();

        //4. Obtain points
        marIsocontour* actual = parsePolyDataToMarIsocontour(wallCont);

        //5. Compare areas
        double prevA = obtainContourArea(prev);
        double actuA = obtainContourArea(actual);

        prevDifference = fabs(prevA - actuA);


        if (prevA - actuA > 0 && prevA - actuA < percentage*prevA) //CASO 1
        {
                bool stop = false;
                while (!stop && newValue > 0)
                {
                        newValue--;
                        
                        wallCont->getIsocontour()->SetValue(0,newValue);
                        wallCont->getIsocontour()->Update();
                        wallCont->get2DContour()->Update();

                        actual = parsePolyDataToMarIsocontour(wallCont);
                        actuA = obtainContourArea(actual);
 
                        if (fabs(prevA - actuA) > percentage*prevA)
                        {
                                newValue++;
                                wallCont->getIsocontour()->SetValue(0,newValue);
                                wallCont->getIsocontour()->Update();
                                wallCont->get2DContour()->Update();
                                stop = true;
                        }
                }
        
        }
        else if (prevA - actuA < 0 && prevA - actuA > -percentage*prevA) //CASO 2
        {

                bool stop = false;
                while (!stop && newValue > 0)
                {
                        newValue--;
                        
                        wallCont->getIsocontour()->SetValue(0,newValue);
                        wallCont->getIsocontour()->Update();
                        wallCont->get2DContour()->Update();

                        actual = parsePolyDataToMarIsocontour(wallCont);
                        actuA = obtainContourArea(actual);
 
                        if (prevA - actuA < -percentage*prevA)
                        {
                                newValue++;
                                wallCont->getIsocontour()->SetValue(0,newValue);
                                wallCont->getIsocontour()->Update();
                                wallCont->get2DContour()->Update();
                                stop = true;
                        }
                }
        }
        else if (prevA - actuA < 0 && prevA - actuA < -percentage*prevA) //CASO 3
        {

                bool stop = false;
                
                while (!stop)
                {
                        newValue++;
                        
                        wallCont->getIsocontour()->SetValue(0,newValue);
                        wallCont->getIsocontour()->Update();
                        wallCont->get2DContour()->Update();

                        actual = parsePolyDataToMarIsocontour(wallCont);
                        
                        actuA = obtainContourArea(actual);
                        if (prevA - actuA > -percentage*prevA)
                        {
                                if (prevDifference < fabs(prevA - actuA))
                                {
                                        newValue--;
                                        wallCont->getIsocontour()->SetValue(0,newValue);
                                        wallCont->getIsocontour()->Update();
                                        wallCont->get2DContour()->Update();
                                }
                                
                                stop = true;
                                
                        }
                        prevDifference = fabs(prevA - actuA);
                }
        }
        else if (prevA - actuA > 0 && prevA - actuA > percentage*prevA) //CASO 4
        {
                bool stop = false;
                while (!stop && newValue > 0)
                {
                        newValue--;
                        
                        wallCont->getIsocontour()->SetValue(0,newValue);
                        wallCont->getIsocontour()->Update();
                        wallCont->get2DContour()->Update();

                        actual = parsePolyDataToMarIsocontour(wallCont);
                        actuA = obtainContourArea(actual);
 
                        if (prevA - actuA < percentage*prevA)
                        {
                                if (prevDifference < fabs(prevA - actuA))
                                {
                                        newValue++;
                                        wallCont->getIsocontour()->SetValue(0,newValue);
                                        wallCont->getIsocontour()->Update();
                                        wallCont->get2DContour()->Update();
                                }
                                
                                stop = true;
                                
                        }
                        prevDifference = fabs(prevA - actuA);
                }
        }

        
        maxSignal = newValue;

        this->markUpLumen(point,vol);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int marAxisCT::maxValue

(

std::vector< double >

list

)

[private]

Definition at line 1553 of file marAxisCT.cpp.

Referenced by adjustWall().

{
        int max = 0;
        double maxVal = list[0];

        for (int i = 0; i < list.size(); i++)
        {
                if (list[i] > maxVal)
                {
                        maxVal = list[i];
                        max = i;
                }
        }

        return max;
}

Here is the caller graph for this function:

int marAxisCT::getDiameter	(	marContourVO *	contourVO,
		double	x,
		double	y,
		int	limInfX,
		int	limInfY,
		int	limSupX,
		int	limSupY
	)			[private]

Definition at line 1572 of file marAxisCT.cpp.

References generateVector(), parsePolyDataToMarIsocontour(), pointInPolygon(), and marAxis::stop().

{
        bool stop = false; 
        double originX = x;
        double originY = y;

        int coordBase = 1, diameterOne = 0, diameterTwo = 0;
        marIsocontour* cont = parsePolyDataToMarIsocontour(contourVO);
        generateVector(1,&coordBase,originX,originY,&x,&y);

        while ((x > (limInfX+1) && x < (limSupX-1)) && (y > (limInfY+1) && y < (limSupY-1)) && !stop)
        {
                generateVector(0,&coordBase,originX,originY,&x,&y);
                if (pointInPolygon(cont,x,y))
                {
                        diameterOne++;
                }
                else
                {
                        stop = true; 
                }
        }

        stop = false; 
        x = originX;
        y = originY; 
        while ((x > (limInfX+1) && x < (limSupX-1)) && (y > (limInfY+1) && y < (limSupY-1)) && !stop)
        {
                generateVector(35,&coordBase,originX,originY,&x,&y);
                if (pointInPolygon(cont,x,y))
                {
                        diameterOne++;
                }
                else
                {
                        stop = true; 
                }
        }

        stop = false; 
        x = originX;
        y = originY; 
        while ((x > (limInfX+1) && x < (limSupX-1)) && (y > (limInfY+1) && y < (limSupY-1)) && !stop)
        {
                generateVector(17,&coordBase,originX,originY,&x,&y);
                if (pointInPolygon(cont,x,y))
                {
                        diameterTwo++;
                }
                else
                {
                        stop = true; 
                }
        }

        stop = false; 
        x = originX;
        y = originY; 
        while ((x > (limInfX+1) && x < (limSupX-1)) && (y > (limInfY+1) && y < (limSupY-1)) && !stop)
        {
                generateVector(107,&coordBase,originX,originY,&x,&y);
                if (pointInPolygon(cont,x,y))
                {
                        diameterTwo++;
                }
                else
                {
                        stop = true; 
                }
        }

        delete cont;

        return (diameterOne + diameterTwo) / 2;
}

Here is the call graph for this function:

int marAxisCT::searchData	(	std::vector< double >	vec,
		double	value
	)			[private]

Definition at line 1728 of file marAxisCT.cpp.

Referenced by histogram().

{
        int resp = -1;
        bool found = false;

        for (int i = 0; i< vec.size() && !found; i++)
        {
                if (vec[i] == value)
                {
                        resp = i;
                        found = true;
                }
        }

        return resp;
}

Here is the caller graph for this function:

void marAxisCT::extractLumen	(	vtkImageData *	lumenImage,
		marIsocontour *	lumenContour,
		int	point
	)			[private]

Definition at line 1940 of file marAxisCT.cpp.

References marAxisContours::addContour(), marAxisContours::ELUMEN, marContourVO::get2DContour(), marIsocontour::getCG(), marAxisContours::getContourType(), marContourVO::getIsocontour(), marContourVO::getIsocontourCpd(), marContourVO::getIsocontourCpd2(), marContourVO::getIsocontourDcf(), marContourVO::getIsocontourStripped(), marObject::getParameters(), marAxisContours::getSize(), marAxisContours::isReplaced(), obtainContourArea(), parsePolyDataToMarIsocontour(), marAxis::quantContours, marAxisContours::replaceContour(), searchContour(), marContourVO::set2DContour(), marContourVO::setIsocontour(), marContourVO::setIsocontourCpd(), marContourVO::setIsocontourCpd2(), marContourVO::setIsocontourDcf(), marContourVO::setIsocontourStripped(), marContourVO::setSignal(), marContourVO::setType(), marAxis::stop(), and marAxisContours::WALL.

Referenced by markUpLumen().

{

        
        vtkImageCast* cast = vtkImageCast::New();
        cast->SetInput(lumenImage);
        cast->SetOutputScalarTypeToDouble();
        
        vtkImageGaussianSmooth* filter = vtkImageGaussianSmooth::New();
        filter->SetDimensionality(2);
        filter->SetInput(cast->GetOutput());
        filter->SetStandardDeviations((getParameters())->getStandardDeviation(),(getParameters())->getStandardDeviation());
        filter->SetRadiusFactors((getParameters())->getRadius(),(getParameters())->getRadius());
        filter->SetStandardDeviations(3,3);
        filter->SetRadiusFactors(3,3);
        


        marAxisContours* axisCont = quantContours[point];

        int pos = -1;
        
        for (int i = 0; i < axisCont->getSize()  && pos == -1; i++)
        {
                if (axisCont->getContourType(i) == marAxisContours::ELUMEN)
                {
                        pos = i;
                }
        }

        bool stop = false;
        if (pos != -1)          //Verify that contour hasn't been replaced
        {
                stop = true;
                if (axisCont->isReplaced(pos))
                {
                        stop = true;
                }
        
        }

        if (!stop)
        {
                marContourVO* contourVO = new marContourVO();
                marIsocontour* iso = lumenContour;
                
                contourVO->setIsocontour(vtkContourFilter::New());
                contourVO->getIsocontour()->SetInput( filter->GetOutput() );
                contourVO->getIsocontour()->SetNumberOfContours( 1 );
                contourVO->getIsocontour()->SetValue( 0, 128 ); 
                contourVO->getIsocontour()->Update( );
                        
                contourVO->setIsocontourCpd(vtkCleanPolyData::New());
                contourVO->getIsocontourCpd()->SetInput( contourVO->getIsocontour()->GetOutput( ) );
                contourVO->getIsocontourCpd()->ConvertLinesToPointsOff( );
                contourVO->getIsocontourCpd()->Update( );

                double cgx, cgy;

                iso->getCG(&cgx,&cgy);
                        
                contourVO->setIsocontourDcf(vtkPolyDataConnectivityFilter::New( ));
                contourVO->getIsocontourDcf()->SetInput( contourVO->getIsocontourCpd()->GetOutput( ) );
                        
                contourVO->getIsocontourDcf()->SetClosestPoint( cgx, cgy, 0 );
                contourVO->getIsocontourDcf()->SetExtractionModeToClosestPointRegion( );
                contourVO->getIsocontourDcf()->Update( );
                        
                contourVO->setIsocontourCpd2(vtkCleanPolyData::New());
                contourVO->getIsocontourCpd2()->SetInput( contourVO->getIsocontourDcf()->GetOutput( ) );
                contourVO->getIsocontourCpd2()->Update();

                contourVO->setIsocontourStripped(vtkStripper::New( ));
                contourVO->getIsocontourStripped()->SetInput( contourVO->getIsocontourCpd2()->GetOutput() );
                contourVO->getIsocontourStripped()->Update();
                
                contourVO->set2DContour(contourVO->getIsocontourStripped()->GetOutput());
                contourVO->get2DContour()->Update();
                contourVO->setSignal(255);
                contourVO->setType(marAxisContours::ELUMEN); 
                
                
                
                marIsocontour* actual = parsePolyDataToMarIsocontour(contourVO);
                marContourVO* aVO = searchContour(marAxisContours::WALL,point);
                double wallArea = 0;
                if (aVO != NULL)
                {
                        wallArea = obtainContourArea(parsePolyDataToMarIsocontour(aVO));
                }
        
                double prevA = obtainContourArea(actual);
                
                int newValue = 128;
                int finalValue = 128;
                double actuA = 1;
                while (newValue > 0 && actuA > 0)
                {
                        
                        newValue--;

                        try
                        {
                                contourVO->getIsocontour()->SetValue(0,newValue);
                                contourVO->getIsocontour()->Update();
                                contourVO->get2DContour()->Update();
                                actual = parsePolyDataToMarIsocontour(contourVO);
                                actuA = obtainContourArea(actual);
                                if ((actuA /1000) < 1 && (prevA / 1000) > 1)
                                {
                                        finalValue = newValue;
                                        prevA = actuA;
                                }
                                else if (actuA > prevA && (prevA / 1000) < 1 && actuA < 0.1*wallArea)
                                {
                                        finalValue = newValue;
                                        prevA = actuA;
                                }
                        }
                        catch (std::exception e)
                        {
                                actuA = 0;
                        }
                        
                }

                contourVO->getIsocontour()->SetValue(0,finalValue);
                contourVO->getIsocontour()->Update();
                contourVO->get2DContour()->Update();



                /*iso->getType()*/

                if (pos != -1)
                {
                        axisCont->replaceContour(contourVO,pos);
                }
                else
                {
                        axisCont->addContour(contourVO);
                }
                //      axisCont->addContour(contourVO);


                quantContours[point] = axisCont;
        }

        
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string& marAxis::getDescription

(

)

[inline, inherited]

Return description as a std::string

Definition at line 93 of file marAxis.h.

{ return( _description ); };

void marAxis::setDescription

(

std::string &

d

)

[inline, inherited]

Set description as a std::string

Definition at line 98 of file marAxis.h.

Referenced by marExperiment::extractVascularTree().

{ _description = d; };

Here is the caller graph for this function:

void marAxis::addAxisPoint

(

double *

p

)

[inherited]

Add a point to the axis

Warning:

no check is done

Definition at line 72 of file marAxis.cpp.

References marAxis::INDX_count, and marAxis::INDX_SIGNALVALUE.

Referenced by marExperiment::extractVascularTree().

{
    double pt[ INDX_count ];

    memcpy( pt, p, sizeof( POINTAXE ) );
    pt[ INDX_SIGNALVALUE ] = 0;
    addControlPoint( pt, pt + 3 );
}

Here is the caller graph for this function:

void marAxis::changeAxisResolution

(

)

[inherited]

Definition at line 107 of file marAxis.cpp.

{/*
   int i;
   int nOut = ( int )ceil(
   getParameters( )->
   getDoubleParam( marParameters::e_axis_discret_step )
   * ( double )( GetNumberOfPoints( ) )
   );

   i = GetNumberOfPoints( );
   double d = getParameters( )->
   getDoubleParam( marParameters::e_axis_discret_step );

   SetResolution( nOut );
   for( i = 0; i < _contours.size( ); i++ )
   delete _contours[ i ];
   _contours.clear( );
   for( i = 0; i < nOut; i++ )
   _contours.push_back( new marContour( getParameters( ) ) );
 */
}

void marAxis::calculateSignal

(

kVolume *

vol

)

[inherited]

PSIGNAL_USHORT <-> unsigned short *

Definition at line 130 of file marAxis.cpp.

References marAxis::_points, marAxis::_points_disc, marAxis::_signal, marParameters::e_mask_size, and marObject::getParameters().

Referenced by marExperiment::extractVascularTree(), and marExperiment::RegenerateSignal().

{
    /* PSIGNAL_FLOAT PutSignalValueFloat(PSIGNAL_FLOAT signal, int pos, float value)
    {
      signal[pos] = value;
      return signal;
    }*/
  ushort maxlocal;
  double *p;

  double rayon;
  unsigned int i, mask_size = getParameters( )-> getIntParam( marParameters::e_mask_size );

  while( _signal.size( ) > 0 ) _signal.pop_back( );
  // Intensity signal

  PSIGNAL_USHORT signal = ( PSIGNAL_USHORT ) IdSigAlloc( _points.size( ), SIG_USHORT );
  for( i = 0; i < _points.size( ); i++ ) {
    p = _points[i];
    rayon = RayonLocal(
                      ( int ) ( p[ 0 ] ),
                      ( int ) ( p[ 1 ] ),
                      ( int ) ( p[ 2 ] ),
                      _points_disc, getNumberOfControlPoints( ));

    maxlocal = vol->GetMaxIntSphere2( p, rayon );
    PutSignalValue( signal, i, maxlocal );
  } // rof

  PSIGNAL_FLOAT mask_signal = ( PSIGNAL_FLOAT )IdSigAlloc( mask_size, SIG_FLOAT );

  for( i = 0; i < mask_size; i++ )
    PutSignalValueFloat( mask_signal, i, 1 );

  PSIGNAL_USHORT signalfilt = ( PSIGNAL_USHORT )IdSigAlloc( _points.size( ), SIG_USHORT );
  signalfilt = MonSigConvolve( signal, mask_signal, signalfilt, 1.0 / ( double )mask_size, 0 );
  for( i = 0; i < _points.size( ); i++ ){
    _signal.push_back( GetSignalValue( signalfilt, i ) );
  }
  IdSigFree( signal );
  IdSigFree( mask_signal );
  IdSigFree( signalfilt );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int marAxis::getActualQuant

(

)

[inline, inherited]

Definition at line 109 of file marAxis.h.

Referenced by marInterfaceCT::getActualQuant(), wxQuantificationWidget::RefreshAxis(), marExperiment::RegenerateAxis(), and wxQuantificationWidget::showVariables().

{ return _actualQuant;                          }

Here is the caller graph for this function:

float marAxis::getSignal

(

uint

slice

)

[inline, inherited]

Definition at line 111 of file marAxis.h.

Referenced by vtk3DSurfaceSTLWidget::ConvertMarAxisToPolyData(), marAxis::create2Dcontour(), marExperiment::extractVascularTree(), and wxEmptyPanelWidget_2::WriteSignals().

{ return( _signal[ slice ] );           };

Here is the caller graph for this function:

double* marAxis::getSplinePoint

(

uint

i

)

[inline, inherited]

Definition at line 113 of file marAxis.h.

Referenced by wxQuantificationWidgetCT::CallBackOnLeftDClick(), wxQuantificationWidget::CallBackOnLeftDClick(), and vtk3DQuantSurfaceWidget::Set3DSliceActor().

{ return ( _points[ i ] );                      };

Here is the caller graph for this function:

int marAxis::getHealthySlice

(

)

[inline, inherited]

Definition at line 115 of file marAxis.h.

Referenced by marInterfaceCT::getHealthySlice(), wxQuantificationWidget::GetHealthySlice(), wxQuantificationWidget::OnHealthySlice_CB(), vtk3DQuantSurfaceWidget::Set3DHealthySliceActor(), and wxQuantificationWidget::showVariables().

{ return( _healthySlice );                      };

Here is the caller graph for this function:

int marAxis::getHealthySliceStart

(

)

[inline, inherited]

Definition at line 116 of file marAxis.h.

Referenced by wxQuantificationWidget::GetHealthySliceRange(), marInterfaceCT::getHealthySliceStart(), and wxQuantificationWidget::showVariables().

{ return( _healthySliceStart );         };

Here is the caller graph for this function:

int marAxis::getHealthySliceEnd

(

)

[inline, inherited]

Definition at line 117 of file marAxis.h.

Referenced by marInterfaceCT::getHealthySliceEnd(), wxQuantificationWidget::GetHealthySliceRange(), and wxQuantificationWidget::showVariables().

{ return( _healthySliceEnd );           };

Here is the caller graph for this function:

void marAxis::setActualQuant

(

int

act

)

[inline, inherited]

Definition at line 119 of file marAxis.h.

Referenced by wxQuantificationWidget::MoveSlider(), marExperiment::RecalculateAxis(), marExperiment::RegenerateAxis(), wxQuantificationWidget::ResetAxis(), marInterfaceCT::setActualQuant(), and wxQuantificationWidget::ShowMARACASData().

{ _actualQuant=act;                                     };

Here is the caller graph for this function:

void marAxis::setHealthySlice	(	int	hsS,
		int	hs,
		int	hsE
	)			[inherited]

Definition at line 1520 of file marAxis.cpp.

References marAxis::_healthySlice, marAxis::_healthySliceEnd, marAxis::_healthySliceStart, marAxis::_referenceArea, and marAxis::_referenceAverDiam.

Referenced by wxQuantificationWidget::ResetAxis(), marInterfaceCT::setHealthySlice(), and wxQuantificationWidget::SetHealthySlice().

                                                       { 
          _healthySliceStart    = hsS;
          _healthySlice                 = hs;   
          _healthySliceEnd              = hsE;
          _referenceArea=-1;
          _referenceAverDiam=-1;
  };

Here is the caller graph for this function:

void marAxis::setStartQuant

(

int

sq

)

[inherited]

Definition at line 1528 of file marAxis.cpp.

References marAxis::_startQuant, and marAxis::_subAxisLenght.

Referenced by vtk3DQuantSurfaceWidget::Set3DStartRegionSliceActor().

                                   {
        _startQuant             =       sq;             
        _subAxisLenght  =       -1;
};

Here is the caller graph for this function:

void marAxis::setFinishQuant

(

int

fq

)

[inherited]

Definition at line 1533 of file marAxis.cpp.

References marAxis::_finishQuant, and marAxis::_subAxisLenght.

Referenced by vtk3DQuantSurfaceWidget::Set3DEndRegionSliceActor().

                                    { 
        _finishQuant    =       fq;             
        _subAxisLenght  =       -1;
};

Here is the caller graph for this function:

int marAxis::getStartQuant

(

)

[inline, inherited]

Definition at line 127 of file marAxis.h.

Referenced by marExperiment::getQuantStart(), and wxQuantificationWidget::showVariables().

{ return _startQuant;                           };

Here is the caller graph for this function:

int marAxis::getFinishQuant

(

)

[inline, inherited]

Definition at line 128 of file marAxis.h.

Referenced by wxQuantificationWidget::showVariables().

{ return _finishQuant;                          };

Here is the caller graph for this function:

void marAxis::start

(

)

[inherited]

Definition at line 178 of file marAxis.cpp.

{
    /* TODO
       int swap, n = GetNumberOfPoints( );

       swap = GSL_MIN( _startQuant, _finishQuant );
       _finishQuant = GSL_MAX( _startQuant, _finishQuant );
       _startQuant = swap;

       _startQuant = ( _startQuant >= 0 )? _startQuant: 0;
       _finishQuant = ( _finishQuant >= n )? _finishQuant: n - 1;
       _actualQuant = _startQuant;
    */
}

void marAxis::next

(

)

[inline, inherited]

Definition at line 132 of file marAxis.h.

Referenced by generatePoints().

{ _actualQuant++; };

Here is the caller graph for this function:

void marAxis::stop

(

)

[inline, inherited]

Definition at line 133 of file marAxis.h.

Referenced by adjustContour(), extractLumen(), and getDiameter().

{ _actualQuant = _finishQuant + 1; };

Here is the caller graph for this function:

bool marAxis::isFinished

(

)

[inline, inherited]

Definition at line 134 of file marAxis.h.

{ return( _actualQuant >= _startQuant && _actualQuant <= _finishQuant ); }

void marAxis::doSpline

(

)

[inherited]

Definition at line 200 of file marAxis.cpp.

References marAxis::_contours, marAxis::_healthySlice, marAxis::_points, marParameters::e_axis_discret_step, marParameters::getDoubleParam(), marObject::getParameters(), marAxis::INDX_count, marAxis::INDX_X, marAxis::INDX_Y, and marAxis::INDX_Z.

Referenced by marExperiment::extractVascularTree(), and marExperiment::RecalculateAxis().

{
  unsigned int i;
  unsigned int nop, nip;
  float length=0, t;
  float p1[ 3 ], p2[ 3 ];
  double p[marAxis::INDX_count];

  vtkKochanekSpline* spX = vtkKochanekSpline::New( );
  vtkKochanekSpline* spY = vtkKochanekSpline::New( );
  vtkKochanekSpline* spZ = vtkKochanekSpline::New( );

  for( i = 0, length = 0.0; i < _controlPoints.size( ); i++ ) {
    getControlPoint(i, p, p+3);
    p2[ 0 ] = (float) p[marAxis::INDX_X];
    p2[ 1 ] = (float) p[marAxis::INDX_Y];
    p2[ 2 ] = (float) p[marAxis::INDX_Z];
    spX->AddPoint( (float) i, p2[ 0 ] );
    spY->AddPoint( (float) i, p2[ 1 ] );
    spZ->AddPoint( (float) i, p2[ 2 ] );
    if( i > 0 )
      length += (float) (sqrt( (p2[0]-p1[0])*(p2[0]-p1[0]) +
                               (p2[1]-p1[1])*(p2[1]-p1[1]) +
                               (p2[2]-p1[2])*(p2[2]-p1[2]) ) );
    p1[ 0 ] = p2[ 0 ]; p1[ 1 ] = p2[ 1 ]; p1[ 2 ] = p2[ 2 ];
  } // rof

  nop = ( unsigned int ) ( getParameters( )->getDoubleParam(
                                           marParameters::e_axis_discret_step ) * length );
  nip = _controlPoints.size( );
  _healthySlice = -1;

  while( _points.size( ) > 0 ) {
    delete _points[ _points.size( ) - 1 ];
    _points.pop_back( );
  } // fwhile

  while( _contours.size( ) > 0 ) {
    delete _contours[ _contours.size( ) - 1 ];
    _contours.pop_back( );
  } // fwhile

  for( i = 0; i < nop; i++ ) {
    t = (float) (( ( double ) nip - 1.0 ) / ( ( double ) nop - 1.0 ) * i);
    double* np = new double[ 3 ];
    np[ 0 ] =  0;
    np[ 1 ] =  0;
    np[ 2 ] =  0;
    np[ 0 ] = (double) (spX->Evaluate( t ));
    np[ 1 ] = (double) (spY->Evaluate( t ));
    np[ 2 ] = (double) (spZ->Evaluate( t ));
    _points.push_back( np );
    _contours.push_back( new marContour( i, getParameters( ) ) );

  } // rof

  spX->Delete( );
  spY->Delete( );
  spZ->Delete( );

}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxis::cut	(	int	slice,
		bool	up
	)			[inherited]

Definition at line 194 of file marAxis.cpp.

{ // TODO
}

void marAxis::sliceVolumeAxis	(	kVolume *	vol,
		bool	forceCnt = true
	)			[inherited]

Definition at line 265 of file marAxis.cpp.

{
/*
  int nCnts = ( int ) getNumberOfSplinePoints( );
  int sizeIma = getParameters( )->getSizeIma( );
  double dimIma = getParameters( )->getDimIma( );
  double voxSize = getParameters( )->getVoxelSize( );

  if( forceCnt )
    for( unsigned int i = 0; i < _contours.size( ); i++ )
      delete _contours[ i ];
    _contours.clear( );

    for( unsigned int i = 0; i < _slices.size( ); i++ ) {
      delete _slices[ i ];
      _3Dslices[ i ]->Delete( );
      _quantificationImages[ i ]->Delete( );
    }

  _slices.clear( );
  _3Dslices.clear( );
  _quantificationImages.clear( );


  // "Cutter" initialization
  vtkStructuredPoints* stPoints = vtkStructuredPoints::New( );
  // Perform "cut"
  double *p, *n;
  for( int k = 0; k < nCnts; k++ ) {
    //s = ( double )k / ( double )( nCnts - 1 );
    p = _points[k];
    n = getNormal( k );
    vtkPlaneSource* pSource = vtkPlaneSource::New( );
    pSource->SetOrigin( p[ 0 ], p[ 1 ], p[ 2 ] );
    pSource->SetPoint1( p[ 0 ] + dimIma - 1.0, p[ 1 ], p[ 2 ] );
    pSource->SetPoint2( p[ 0 ], p[ 1 ], p[ 2 ] + dimIma - 1.0 );
    pSource->SetResolution( sizeIma - 1, sizeIma - 1 );
    pSource->Update( );
    pSource->SetCenter( p[ 0 ], p[ 1 ], p[ 2 ] );
    pSource->SetNormal( n[ 0 ], n[ 1 ], n[ 2 ] );
    pSource->Update( );

    _3Dslices.push_back( vtkProbeFilter::New( ) );
    _3Dslices[ k ]->SetInput( ( vtkDataSet* )pSource->GetOutput( ) );
    _3Dslices[ k ]->SetSource( vol->castVtk( ) );
    _3Dslices[ k ]->Update( );
    pSource->Delete( );

    stPoints->GetPointData( )->
                SetScalars( _3Dslices[ k ]->GetOutput( )->
                GetPointData( )->GetScalars( ) );
    stPoints->SetDimensions( sizeIma, sizeIma, 1 );
    stPoints->SetScalarType( vol->castVtk( )->GetDataObjectType( ) );
    stPoints->Update( );
    if( forceCnt )
      {
                marContour* tmp_marContour = new marContour( k, getParameters( ) ) ;
                tmp_marContour->calculateVariables();
                _contours.push_back( tmp_marContour );
        }
    _slices.push_back( new kVolume( kVolume::UCHAR, 1, 1, 1 ) );

    *( _slices[ k ] ) = ( vtkImageData* )stPoints;  //copy
    _quantificationImages.push_back( (_slices[ k ])->castVtk( ) );
  } // rof

  stPoints->Delete( );
*/
}

double * marAxis::getNormal

(

unsigned int

slice

)

[inherited]

Definition at line 83 of file marAxis.cpp.

References marAxis::_points.

Referenced by marAxis::create3Dcontour(), create3Dcontours(), marAxis::create3DSlice(), marAxis::createSlice(), and vtk3DQuantSurfaceWidget::Set3DSliceActor().

                                               {

    double* ret = new double[ 3 ];

    if ( slice == 0 ) {
      ret[0] = _points[ slice + 1 ][0] - _points[ slice ][0];
      ret[1] = _points[ slice + 1 ][1] - _points[ slice ][1];
      ret[2] = _points[ slice + 1 ][2] - _points[ slice ][2];
    }
    else if ( slice == _points.size( ) - 1 ) {
      ret[0] = _points[ slice - 1 ][0] - _points[ slice ][0];
      ret[1] = _points[ slice - 1 ][1] - _points[ slice ][1];
      ret[2] = _points[ slice - 1 ][2] - _points[ slice ][2];
    }
    else if ( slice > 0 && slice < _points.size( ) - 1 ) {
      ret[0] = _points[ slice - 1 ][0] - _points[ slice + 1 ][0];
      ret[1] = _points[ slice - 1 ][1] - _points[ slice + 1 ][1];
      ret[2] = _points[ slice - 1 ][2] - _points[ slice + 1 ][2];
    }

    return( ret );
}

Here is the caller graph for this function:

int marAxis::getNumberOfContours

(

)

[inherited]

Definition at line 338 of file marAxis.cpp.

References marAxis::_contours.

Referenced by marAxis::save().

{
    return( _contours.size( ) );
}

Here is the caller graph for this function:

int marAxis::getNumberOfSplinePoints

(

)

[inherited]

Definition at line 344 of file marAxis.cpp.

References marAxis::_points.

Referenced by wxQuantificationWidgetCT::CallBackOnLeftDClick(), wxQuantificationWidget::CallBackOnLeftDClick(), createEmptyContours(), marAxis::createEmptyVectors(), and marExperiment::RecalculateAxis().

{
    return( _points.size( ) );
}

Here is the caller graph for this function:

bool marAxis::if3DcontourExist

(

int

i

)

[inherited]

Definition at line 1172 of file marAxis.cpp.

References marAxis::_3Dcontour.

{
        bool result=true;
        if (_3Dcontour[i]==NULL)
        {
                result=false;
        } 
        return result;
}

void marAxis::Save3Dcontour	(	FILE *	ff,
		int	i
	)			[inherited]

Definition at line 1183 of file marAxis.cpp.

References marAxis::_3Dcontour.

Referenced by marAxis::SaveExisting3DContours().

{
        int i,size;
        double point[3];
        if (_3Dcontour[id]!=NULL)
        {
//Ramiro                fprintf(ff,"contour_id: %d \n", id);
                size = _3Dcontour[id]->GetNumberOfPoints();
//Ramiro                fprintf(ff,"numberOfPoints: %d \n", size);
            for ( i=0 ; i<size  ;i++ ){
                _3Dcontour[id]->GetPoint( i , point );
                        fprintf(ff,"%f %f %f %d\n", point[0], point[1],point[2],id);
            }
        }
}

Here is the caller graph for this function:

void marAxis::SaveExisting3DContours

(

FILE *

ff

)

[inherited]

Definition at line 1199 of file marAxis.cpp.

References marAxis::_3Dcontour, and marAxis::Save3Dcontour().

Referenced by wxQuantificationWidget::OnSaveContours3D_BT().

{
        if (ff!=NULL)
        {
                // counting existing 3Dcontours
                int acum=0;
                int i,size=_3Dcontour.size();
                for (i=0; i<size; i++)
                {
                        if (_3Dcontour[i]!=NULL)
                        {
                                acum++;
                        }
                }
//Ramiro                fprintf(ff, "NumberOf3DContours: %d \n", acum);
                // saving existing 3Dcontours
                for (i=0; i<size; i++)
                {
                        Save3Dcontour(ff,i);
                }               
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

marContour * marAxis::getContour	(	int	i,
		kVolume *	vol
	)			[inherited]

Definition at line 1159 of file marAxis.cpp.

References marAxis::_contours, and marAxis::createContour().

Referenced by marAxis::calculateReferenceAverDiam(), marAxis::create2DDiameterMax(), marAxis::create2DDiameterMin(), marAxis::create3Dcontour(), and marAxis::getAverageArea().

{                                                               
        if (_contours[i]==NULL){ createContour(i, vol); }
        return _contours[i];
} 

Here is the call graph for this function:

Here is the caller graph for this function:

kVolume * marAxis::getSlice	(	int	i,
		kVolume *	vol
	)			[inherited]

Definition at line 1165 of file marAxis.cpp.

References marAxis::_slices, and marAxis::createSlice().

Referenced by marAxis::create2Dcontour(), create2Dcontours(), marAxis::createSliceImage(), generatePoints(), histogram(), markUpLumen(), performAND(), performUnion(), and performXOR().

{
        if (_slices[i]==NULL){ createSlice( i , vol ); }
        return _slices[i];
}

Here is the call graph for this function:

Here is the caller graph for this function:

vtkProbeFilter * marAxis::get3DSlice	(	int	i,
		kVolume *	vol
	)			[inherited]

Definition at line 1223 of file marAxis.cpp.

References marAxis::_3Dslices, and marAxis::create3DSlice().

Referenced by marAxis::createSlice().

                                                      {                 // VISUALISATION-VTK 3D
        if (_3Dslices[i]==NULL){ create3DSlice(i,vol); }
        return _3Dslices[i];
}

Here is the call graph for this function:

Here is the caller graph for this function:

vtkPoints * marAxis::get3Dcontour	(	int	i,
		kVolume *	vol
	)			[inherited]

Definition at line 1228 of file marAxis.cpp.

References marAxis::_3Dcontour, and marAxis::create3Dcontour().

                                                   {                            // VISUALISATION-VTK 3D
        if (_3Dcontour[i]==NULL){ create3Dcontour(i, vol); }
        return _3Dcontour[i];
}

Here is the call graph for this function:

vtkImageData * marAxis::getSliceImage	(	int	i,
		kVolume *	vol
	)			[inherited]

Definition at line 1233 of file marAxis.cpp.

References marAxis::_quantificationImages, and marAxis::createSliceImage().

Referenced by generateFile().

                                                       {                        // VISUALISATION-VTK 2D
        if (_quantificationImages[i]==NULL){ createSliceImage(i,vol); }
        return _quantificationImages[i];
}

Here is the call graph for this function:

Here is the caller graph for this function:

vtkPolyData * marAxis::get2Dcontour	(	int	i,
		kVolume *	vol
	)			[inherited]

Definition at line 1238 of file marAxis.cpp.

References marAxis::_2Dcontours, and marAxis::create2Dcontour().

Referenced by marAxis::createContour().

                                                      {                 // VISUALISATION-VTK 2D
        if (_2Dcontours[i]==NULL){ create2Dcontour(i,vol); }
        return _2Dcontours[i];
}

Here is the call graph for this function:

Here is the caller graph for this function:

vtkPoints * marAxis::get2DDiameterMin	(	int	i,
		kVolume *	vol
	)			[inherited]

Definition at line 1243 of file marAxis.cpp.

References marAxis::_2DDiameterMin, and marAxis::create2DDiameterMin().

                                                        {               // VISUALISATION-VTK 2D
        if (_2DDiameterMin[i]==NULL){ create2DDiameterMin(i,vol); }
        return _2DDiameterMin[i];
}

Here is the call graph for this function:

vtkPoints * marAxis::get2DDiameterMax	(	int	i,
		kVolume *	vol
	)			[inherited]

Definition at line 1248 of file marAxis.cpp.

References marAxis::_2DDiameterMax, and marAxis::create2DDiameterMax().

                                                        {               // VISUALISATION-VTK 2D
        if (_2DDiameterMax[i]==NULL){ create2DDiameterMax(i,vol); }
        return _2DDiameterMax[i];
}

Here is the call graph for this function:

void marAxis::replaceContour2D	(	int	i,
		int	size,
		double *	vx,
		double *	vy
	)			[inherited]

Definition at line 642 of file marAxis.cpp.

References marAxis::_2Dcontours, marAxis::createContour(), and marAxis::EraseContour().

Referenced by marInterfaceCT::replaceContour2D(), and wxQuantificationWidget::SetManualContour_ReplaceContour().

                                                                  {

        EraseContour(i);


        vtkPoints *_pts = vtkPoints::New();
        _pts->SetNumberOfPoints(size);
        int j;

        for (j=0 ; j<size ; j++){
                _pts->SetPoint(j,       vx[j]   , vy[j] , 0 );
        }
//      _pts->SetPoint(0,       vx[0]   , vy[0] , 0 );

        vtkCellArray *lines = vtkCellArray::New();
        lines->InsertNextCell( size );
        for ( j=0 ; j<size+1 ; j++ ){
                lines->InsertCellPoint(j % size );
        }

        vtkPolyData *_pd = vtkPolyData::New();
        _pd->SetPoints( _pts );
        _pd->SetLines( lines );
        lines->Delete();  //do not delete lines ??
        _pts->Delete();  

        _2Dcontours[i]=_pd;
        createContour(i,NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxis::EraseContour

(

int

i

)

[inherited]

Definition at line 614 of file marAxis.cpp.

References marAxis::_2Dcontours, marAxis::_2DDiameterMax, marAxis::_2DDiameterMin, marAxis::_3Dcontour, and marAxis::_contours.

Referenced by marInterfaceCT::EraseContour(), marAxis::replaceContour2D(), and wxQuantificationWidget::SetManualContour_AddPoint_2DWorld().

                               {
        if (_3Dcontour[i]!=NULL){
                _3Dcontour[i]->Delete();
                _3Dcontour[i]=NULL;
        }

        if (_2DDiameterMax[i]!=NULL){
                _2DDiameterMax[i]->Delete();
                _2DDiameterMax[i]=NULL;
        }

        if (_2DDiameterMin[i]!=NULL){
                _2DDiameterMin[i]->Delete();
                _2DDiameterMin[i]=NULL;
        }

        if (_2Dcontours[i]!=NULL){
                _2Dcontours[i]->Delete();
                _2Dcontours[i]=NULL;
        }

        if (_contours[i]!=NULL){
                delete _contours[i];
                _contours[i]=NULL;
        }
}

Here is the caller graph for this function:

void marAxis::createEmptyVectors

(

)

[inherited]

Definition at line 1033 of file marAxis.cpp.

References marAxis::_2Dcontours, marAxis::_2DDiameterMax, marAxis::_2DDiameterMin, marAxis::_3Dcontour, marAxis::_3Dslices, marAxis::_contours, marAxis::_quantificationImages, marAxis::_slices, marAxis::clearAllVectors(), and marAxis::getNumberOfSplinePoints().

Referenced by marExperiment::RecalculateAxis(), and marExperiment::RegenerateAxis().

{
        int nCnts = ( int ) getNumberOfSplinePoints( );
        clearAllVectors();
        int i;
//      int xxxx=getNumberOfContours();
        for (i=0;i<nCnts;i++){
                _contours.push_back( NULL );
                _slices.push_back( NULL );
                _3Dslices.push_back( NULL );
                _3Dcontour.push_back( NULL );
                _quantificationImages.push_back( NULL );
                _2Dcontours.push_back( NULL );
                _2DDiameterMin.push_back( NULL );
                _2DDiameterMax.push_back( NULL );
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxis::clearAllVectors

(

)

[inherited]

Definition at line 1051 of file marAxis.cpp.

References marAxis::_2Dcontours, marAxis::_2DDiameterMax, marAxis::_2DDiameterMin, marAxis::_3Dcontour, marAxis::_3Dslices, marAxis::_contours, marAxis::_quantificationImages, and marAxis::_slices.

Referenced by marAxis::createEmptyVectors(), and marAxis::Delete().

{
        unsigned int i;
        
        for (i=0;i<_contours.size();i++){
                if (_contours[i]!=NULL) {                                       //  DATA-MODEL-2D
                        delete _contours[i];
                        _contours[i]=NULL;
                }
        }
        _contours.clear();

        for (i=0;i<_slices.size();i++){                                 //  DATA-MODEL-Voxel XxYx1
                if (_slices[i]!=NULL) {                         
                        delete _slices[i];
                        _slices[i]=NULL;
                }
        }
        _slices.clear();


        for (i=0;i<_3Dslices.size();i++){                                       //  VISUALISATION_VTK 3D
                if (_3Dslices[i]!=NULL) {
                        _3Dslices[i]->Delete();
                        _3Dslices[i]=NULL;
                }
        }
        _3Dslices.clear();

        for (i=0;i<_3Dcontour.size();i++){                              //  VISUALISATION_VTK 3D
                if (_3Dcontour[i]!=NULL) {                              
                        _3Dcontour[i]->Delete();
                        _3Dcontour[i]=NULL;
                }
        }
        _3Dcontour.clear();

        for (i=0;i<_quantificationImages.size();i++){   //  VISUALISATION_VTK 2D
                if (_quantificationImages[i]!=NULL) {                           
//                      _quantificationImages[i]->Delete();
//                      _quantificationImages[i]=NULL;
                }
        }
        _quantificationImages.clear();

        for (i=0;i<_2Dcontours.size();i++){                             //  VISUALISATION_VTK 2D
                if (_2Dcontours[i]!=NULL) {                             
// EED ???  This object was allready erased bye the VTK pipeline
//                      _2Dcontours[i]->Delete();
                        _2Dcontours[i]=NULL;
                }
        }
        _2Dcontours.clear();

        for (i=0;i<_2DDiameterMin.size();i++){                  //  VISUALISATION_VTK 2D
                if (_2DDiameterMin[i]!=NULL) {                          
                        _2DDiameterMin[i]->Delete() ;
                        _2DDiameterMin[i]=NULL;
                }
        }
        _2DDiameterMin.clear();

        for (i=0;i<_2DDiameterMax.size();i++){                  //  VISUALISATION_VTK 2D
                if (_2DDiameterMax[i]!=NULL) {                          
                        _2DDiameterMax[i]->Delete();
                        _2DDiameterMax[i]=NULL;
                }
        }
        _2DDiameterMax.clear();

}

Here is the caller graph for this function:

void marAxis::eraseContourVectorsContent

(

)

[inherited]

Definition at line 1123 of file marAxis.cpp.

References marAxis::_2Dcontours, marAxis::_2DDiameterMax, marAxis::_2DDiameterMin, marAxis::_3Dcontour, and marAxis::_contours.

Referenced by marExperiment::ClearContours(), and marExperiment::RegenerateSignal().

{
        unsigned int i;
        for (i=0;i<_contours.size();i++){
                if (_contours[i]!=NULL) {                                       //  DATA-MODEL-2D
                        delete _contours[i];
                        _contours[i]=NULL;
                }
        }
        for (i=0;i<_2Dcontours.size();i++){                             //  VISUALISATION_VTK 2D
                if (_2Dcontours[i]!=NULL) {                             
                        _2Dcontours[i]->Delete();
                        _2Dcontours[i]=NULL;
                }
        }
        for (i=0;i<_2DDiameterMin.size();i++){                          //  VISUALISATION_VTK 2D
                if (_2DDiameterMin[i]!=NULL) {                          
                        _2DDiameterMin[i]->Delete();
                        _2DDiameterMin[i]=NULL;
                }
        }
        for (i=0;i<_2DDiameterMax.size();i++){                          //  VISUALISATION_VTK 2D
                if (_2DDiameterMax[i]!=NULL) {                          
                        _2DDiameterMax[i]->Delete();
                        _2DDiameterMax[i]=NULL;
                }
        }
        for (i=0;i<_3Dcontour.size();i++){                              //  VISUALISATION_VTK 3D
                if (_3Dcontour[i]!=NULL) {                              
                        _3Dcontour[i]->Delete();
                        _3Dcontour[i]=NULL;
                }
        }
}

Here is the caller graph for this function:

void marAxis::set_points_disc

(

PPPOINTAXE

p

)

[inline, inherited]

Definition at line 182 of file marAxis.h.

Referenced by marExperiment::extractVascularTree().

{ _points_disc = p; };

Here is the caller graph for this function:

double marAxis::getTotalLength

(

)

[inherited]

Definition at line 1280 of file marAxis.cpp.

References marAxis::_totalAxisLenght, and marAxis::calculateTotalAxisLenght().

                              {
        if (_totalAxisLenght==-1){
                calculateTotalAxisLenght();
        }
        return _totalAxisLenght;
}

Here is the call graph for this function:

double marAxis::getSubAxisLength

(

)

[inherited]

Definition at line 1292 of file marAxis.cpp.

References marAxis::_subAxisLenght, and marAxis::calculateSubAxisLength().

                                {
        if (_subAxisLenght==-1){
                calculateSubAxisLength();
        }
        return _subAxisLenght;
}

Here is the call graph for this function:

double marAxis::getReferenceArea

(

kVolume *

vol

)

[inherited]

Definition at line 1317 of file marAxis.cpp.

References marAxis::_referenceArea, and marAxis::calculateReferenceArea().

                                            {
        if (_referenceArea==-1){
                calculateReferenceArea(vol);
        }
        return _referenceArea;
}

Here is the call graph for this function:

double marAxis::getReferenceAverDiam

(

kVolume *

vol

)

[inherited]

Definition at line 1335 of file marAxis.cpp.

References marAxis::_referenceAverDiam, and marAxis::calculateReferenceAverDiam().

                                                {
        if (_referenceAverDiam==-1){
                calculateReferenceAverDiam(vol);
        }
        return _referenceAverDiam;
}

Here is the call graph for this function:

double marAxis::getAverageArea	(	int	pIni,
		int	pEnd,
		kVolume *	vol
	)			[inherited]

Definition at line 1299 of file marAxis.cpp.

References marAxis::_points, and marAxis::getContour().

Referenced by marAxis::calculateReferenceArea().

                                                              {
        marContour      *marcontourHealthy;
        int                     ihealthySlice,itemp;
        double          acumArea        =       0;
        for (ihealthySlice = pIni ; ihealthySlice <= pEnd ; ihealthySlice++ ){
                itemp=ihealthySlice;
                if (itemp<0)                            { itemp=0;                                      }
                if (itemp>=_points.size( ))     { itemp=_points.size( )-1;      }
                marcontourHealthy = getContour( itemp , vol );
                acumArea = acumArea + marcontourHealthy->getArea();
        }
        return acumArea / (pEnd - pIni + 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxis::reset

(

)

[virtual, inherited]

General methods

Implements marObject.

Definition at line 1343 of file marAxis.cpp.

References marAxis::_actualQuant, marAxis::_description, marAxis::_finishQuant, marAxis::_healthySlice, marAxis::_referenceArea, marAxis::_referenceAverDiam, marAxis::_startQuant, marAxis::_subAxisLenght, and marAxis::Delete().

Referenced by marAxis::load(), and marAxis::marAxis().

{
//EED Borrame
//    unsigned int i;
    kCurve::reset( );

    _description                = "";
    _healthySlice               = -1;
    _startQuant                 = -1;
    _finishQuant                = -1;
    _actualQuant                = -1;

        _subAxisLenght          = -1;
        _referenceArea          = -1;
        _referenceAverDiam      = -1;

        Delete( );

// EED Borrame  
/*
    for( i = 0; i < _contours.size( ); i++ )
      delete _contours[ i ];
    _contours.clear( );
    for( i = 0; i < _slices.size( ); i++ )
        delete _slices[ i ];
    _slices.clear( );
*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

void marAxis::copyFrom

(

const marObject &

from

)

[virtual, inherited]

Implements marObject.

Definition at line 1373 of file marAxis.cpp.

{ // TODO
}

bool marAxis::save

(

std::ofstream &

os

)

[virtual, inherited]

Persistence methods

Implements marObject.

Definition at line 1378 of file marAxis.cpp.

References marAxis::_contours, marAxis::_description, marAxis::getNumberOfContours(), and marAxis::INDX_count.

{
    double p[ INDX_count ];
    unsigned int i;

    i = _description.length( );
    os.write( ( const char* )&i, sizeof( int ) );
    os.write( ( char* )_description.c_str( ), i * sizeof( char ) );

    i = getNumberOfControlPoints( );
    os.write( ( const char* )&i, sizeof( int ) );
    for( i = 0; i < getNumberOfControlPoints( ); i++ ) {

        memcpy( p, _controlPoints[ i ], 3 * sizeof( double ) );
        memcpy( p + 3, _controlState[ i ],
                ( INDX_count - 3 ) * sizeof( double ) );
        os.write( ( const char* )p, INDX_count * sizeof( double ) );

    } // rof
    i = getNumberOfContours( );
    os.write( ( const char* )&i, sizeof( int ) );
    for( i = 0; i < getNumberOfContours( ); i++ )
      _contours[ i ]->save( os );

    return( true );
}

Here is the call graph for this function:

bool marObject::save

(

std::string &

nw

)

[inherited]

Persistence methods

Definition at line 51 of file marObject.cpp.

References marObject::save().

{
    std::ofstream os( nw.c_str( ) );

    if( os ) {

        save( os );
        os.close( );
        return( true );

    } // fi

    return( false );
}

Here is the call graph for this function:

bool marAxis::load

(

std::ifstream &

is

)

[virtual, inherited]

Implements marObject.

Definition at line 1406 of file marAxis.cpp.

References marAxis::_contours, marAxis::_description, marObject::getParameters(), marAxis::INDX_count, and marAxis::reset().

Referenced by marExperiment::load().

{
    double p[ INDX_count ];
    int i, n;

    reset( );

    is.read( ( char* )&n, sizeof( int ) );
    _description.resize( n );
    is.read( ( char* )_description.c_str( ), n * sizeof( char ) );

    is.read( ( char* )&n, sizeof( int ) );
    for( i = 0; i < n; i++ ) {

        is.read( ( char* )p, INDX_count * sizeof( double ) );
        addControlPoint( p, p + 3 );

    } // rof
    is.read( ( char* )&n, sizeof( int ) );
    for( i = 0; i < n; i++ ) {

      _contours.push_back( new marContour( 0, getParameters( ) ) );
      _contours[ i ]->load( is );

    } // rof
    return( true );
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool marObject::load

(

std::string &

nr

)

[inherited]

Definition at line 67 of file marObject.cpp.

References marObject::load().

{
    std::ifstream is( nr.c_str( ) );

    if( is ) {

        load( is );
        is.close( );
        return( true );

    } // fi

    return( false );
}

Here is the call graph for this function:

vtkPolyData * marAxis::Draw

(

)

[inherited]

Definition at line 1434 of file marAxis.cpp.

References marAxis::_allData, and marAxis::_points.

Referenced by wxSurfaceWidget::AddAxisActors(), wxQuantificationWidgetCT::AddAxisActors(), wxQuantificationWidget::AddAxisActors(), wxEmptyPanelWidget_2::PaintVascularTree_MH_JFC(), vtk3DSurfaceSTLWidget::ShowMARACASDataAndAxe(), vtk3DQuantSurfaceWidget::ShowMARACASDataAndAxe(), and vtk3DQuantSurfaceWidget::ShowMARACASDataAndAxeCT().

{
  unsigned int i, j;
  double *p;

  vtkPoints* allPoints = vtkPoints::New( );
  vtkCellArray* allTopology = vtkCellArray::New( );

  allTopology->InsertNextCell( _points.size( ) );
  for( i = 0, j=0; i < _points.size( ); i++, j++ ) {
    p = _points[i];
    allPoints->InsertNextPoint( p[ 0 ],  p[ 1 ], p[ 2 ] );
    allTopology->InsertCellPoint( j );
  } // rof

  _allData = vtkPolyData::New( );
  _allData->SetPoints( allPoints );
  _allData->SetLines( allTopology );
  allPoints->Delete();
  allTopology->Delete();

  return ( _allData );
}

Here is the caller graph for this function:

vtkPolyData * marAxis::GetAxisData

(

)

[inherited]

Definition at line 1458 of file marAxis.cpp.

References marAxis::_allData, marAxis::INDX_count, marAxis::INDX_RAYON, marAxis::INDX_X, marAxis::INDX_Y, and marAxis::INDX_Z.

Referenced by TreeExtraction_MH_JFC::Execute(), wxSTLWidget_02::ExtractTree2_JF(), and TreeExtraction_MH_JFC::FindVit().

{
        unsigned int i;
        double point[ 3 ];
        double radio;
        double p[marAxis::INDX_count];


        vtkPoints                       *allPoints              = vtkPoints::New( );
        vtkCellArray            *allTopology    = vtkCellArray::New( );
        vtkDoubleArray          *allRadios              = vtkDoubleArray::New( );
        allRadios->SetName("radio");

        for( i = 0; i < _controlPoints.size( ); i++ ) {
                getControlPoint(i, p, p+3);
                point[ 0 ]      =  p[marAxis::INDX_X];
                point[ 1 ]      =  p[marAxis::INDX_Y];
                point[ 2 ]      =  p[marAxis::INDX_Z];
                radio           =  p[marAxis::INDX_RAYON]*2.0;
                allPoints    -> InsertPoint( i, point[ 0 ] ,  point[ 1 ] , point[ 2 ]  );  //para saber exactamante el indice que se le asigno

                allRadios       -> InsertValue(i,radio);
 
    if(i>0){
       allTopology->InsertNextCell(2);
       allTopology->InsertCellPoint(i);
       allTopology->InsertCellPoint(i-1);
      }

        } // rof

        _allData = vtkPolyData::New( );
        _allData        -> SetPoints( allPoints );
        _allData        -> SetLines( allTopology );
        _allData        -> GetPointData()->SetScalars(allRadios);

        
        return ( _allData );
}

Here is the caller graph for this function:

void marAxis::Delete

(

)

[inherited]

Definition at line 1498 of file marAxis.cpp.

References marAxis::_allData, marAxis::_points, marAxis::_signal, and marAxis::clearAllVectors().

Referenced by marAxis::create2Dcontour(), and marAxis::reset().

                     {
        clearAllVectors();

        int i;
        for (i=0;i<_points.size();i++){         
                if (_points[i]!=NULL) {                         
                        delete _points[i];
                        _points[i]=NULL;
                }
        }
        _points.clear();
        _signal.clear();


        if(_allData) {
                _allData->Delete();
                _allData = NULL;
        }

//  reset();
}

Here is the call graph for this function:

Here is the caller graph for this function:

double* marAxis::getPoints

(

int

i

)

[inline, inherited]

Definition at line 205 of file marAxis.h.

Referenced by create3Dcontours(), generatePoints(), and wxQuantificationWidgetCT::MoveSlider().

{ return _points[i]; }; 

Here is the caller graph for this function:

void marAxis::AddPointToList	(	double	x,
		double	y,
		double	z,
		int	signal
	)			[inherited]

Definition at line 1539 of file marAxis.cpp.

References marAxis::_points, and marAxis::_signal.

Referenced by wxMaracas_ManualTree_MPRDlg::ExportPoints().

{
        double *p;
        p=(double *)malloc(sizeof(double)*3);
        p[0]=x;
        p[1]=y;
        p[2]=z;
        _points.push_back( p );
        _signal.push_back( signal );
}

Here is the caller graph for this function:

void marObject::setParameters

(

marParameters *

p

)

[inherited]

Parameters assignation methods.

You can assign a marParameters object by reference (setParameters) or by value (copyParameters). Besides, if you want to make your actual reference to be by value, call makeACopyParameters.

Definition at line 34 of file marObject.cpp.

References marObject::_parameters, and marObject::_parametersCopied.

{
    if( _parametersCopied && _parameters != NULL ) delete _parameters;
    _parameters = p;
    _parametersCopied = false;
}

void marObject::copyParameters

(

marParameters *

p

)

[inherited]

Definition at line 42 of file marObject.cpp.

References marObject::_parameters, and marObject::_parametersCopied.

{
    if( _parametersCopied && _parameters != NULL ) delete _parameters;
    _parameters = new marParameters( );
    *_parameters = *p;
    _parametersCopied = true;
}

void marObject::makeACopyParameters

(

)

[inline, inherited]

Definition at line 48 of file marObject.h.

    {
            copyParameters( _parameters );
    }

marParameters* marObject::getParameters

(

)

[inline, inherited]

Parameters analizers.

Definition at line 55 of file marObject.h.

Referenced by adjustWall(), marAxis::calculateSignal(), marAxis::create2Dcontour(), marAxis::create2DDiameterMax(), marAxis::create2DDiameterMin(), create2DDiametersMax(), create2DDiametersMin(), marAxis::create3DSlice(), marAxis::createContour(), createContours(), marAxis::createSlice(), marAxis::doSpline(), extractLumen(), marExperiment::extractVascularTree(), generatePoints(), marDynData::getActualVoxel(), histogram(), marExperiment::initExperiment(), marExperiment::load(), marAxis::load(), marRAW2Files::loadActualSerie(), marRAW2AsciiFiles::loadActualSerie(), marRAWFiles::loadActualSerie(), marDynData::loadData(), marSimpleDicom::loadVolumeDXMM(), wxEmptyPanelWidget_2::OnBtnExtractTree_MH_JFC(), wxSurfaceWidget::OnManualAxis(), vtk3DQuantSurfaceWidget::Set3DSliceActor(), vtk3DSurfaceWidget::SetInitialPoint(), setStartIndex(), marExperimentCT::updateCalcPercentage(), updateCalcPercentage(), marExperimentCT::updateDiscontinuityThreshold(), marExperimentCT::updateLumenPercentage(), and updateLumenPercentage().

{ return( _parameters ); };

Here is the caller graph for this function:

bool marObject::parametersOwned

(

)

[inline, inherited]

Definition at line 56 of file marObject.h.

{ return( _parametersCopied ); };

---

Member Data Documentation

double marAxisCT::avgValue [private]

Definition at line 109 of file marAxisCT.h.

double marAxisCT::stdValue [private]

Definition at line 110 of file marAxisCT.h.

int marAxisCT::startIndex [private]

Definition at line 111 of file marAxisCT.h.

Referenced by create2Dcontours(), getStartIndex(), and setStartIndex().

double marAxisCT::maxSignal [private]

Definition at line 112 of file marAxisCT.h.

Referenced by adjustContour(), markUpLumen(), and setStartIndex().

std::vector<marAxisContours* > marAxis::quantContours [protected, inherited]

Definition at line 262 of file marAxis.h.

Referenced by adjustContour(), cleanContours(), create2Dcontours(), create2DDiametersMax(), create2DDiametersMin(), create3Dcontours(), createContours(), createEmptyContours(), createSignals(), eraseContours(), eraseContoursPartial(), extractLumen(), generateFile(), get2Dcontour(), get2DDiameterMax(), get2DDiameterMin(), get3Dcontour(), getContour(), getContourType(), getMaxIntensity(), getNumberOfContours(), getSignal(), markUpLumen(), performAND(), performUnion(), performXOR(), replaceContour2D(), searchContour(), setStartIndex(), updateCalcPercentage(), and updateLumenPercentage().

std::vector<marPoint *> marAxis::vesselPoints [protected, inherited]

Definition at line 263 of file marAxis.h.

Referenced by eraseContours(), getPoint(), getPointSize(), and markUpLumen().

std::vector<marIsocontour *> marAxis::lumenContour [protected, inherited]

Definition at line 264 of file marAxis.h.

Referenced by createEmptyContours(), eraseContours(), eraseContoursPartial(), generatePoints(), and markUpLumen().

bool marAxis::calibration [protected, inherited]

Definition at line 265 of file marAxis.h.

Referenced by create2Dcontours(), getCalibration(), marAxis::marAxis(), and setCalibration().

---

The documentation for this class was generated from the following files:

• C:/Creatis/creaMaracasVisu/lib/maracasVisuLib/src/kernel/include/marAxisCT.h
• C:/Creatis/creaMaracasVisu/lib/maracasVisuLib/src/kernel/include/marAxisCT.cpp

---