AutoControlPoints Class Reference

#include <AutoControlPoints.h>

Inheritance diagram for AutoControlPoints:

Collaboration diagram for AutoControlPoints:

Public Member Functions
	AutoControlPoints ()
	~AutoControlPoints ()
int	GetSizeVector (std::vector< double > *Vector)
void	PointLeft (std::vector< double > IndX, std::vector< double > InY, std::vector< double > InZ, double lex, double ley, double lez)
void	PointRight (std::vector< double > IndX, std::vector< double > InY, std::vector< double > InZ, double rix, double riy, double riz)
void	PointHigh (std::vector< double > IndX, std::vector< double > InY, std::vector< double > InZ, double hix, double hiy, double hiz)
void	PointLow (std::vector< double > IndX, std::vector< double > InY, std::vector< double > InZ, double lox, double loy, double loz)
void	TwoPoints (std::vector< double > InX, std::vector< double > InY, std::vector< double > *InZ)
void	Intersection (double x01, double y01, double x02, double y02, double mn, double m2, double x, double y)
void	InterBetweenContours (std::vector< double > InX, std::vector< double > InY, std::vector< double > *InZ)
void	GetInterBetweenContours (std::vector< Vector > interVX, std::vector< Vector > interVY)
void	IntersectionPoints ()
void	GetIntersectionPoints (std::vector< Vector > interVX, std::vector< Vector > interVY)
void	GetErrorBetweenContours (std::vector< double > *vec)
void	CalculeControlPoints (std::vector< double > InX, std::vector< double > InY, std::vector< double > *InZ)
void	GetControlPoints (std::vector< double > OutX, std::vector< double > OutY, std::vector< double > *OutZ)
void	CalculeInitialControlPoints (std::vector< double > InX, std::vector< double > InY, std::vector< double > *InZ)
void	GetInitialControlPoints (std::vector< double > OutX, std::vector< double > OutY, std::vector< double > *OutZ)
void	SetNumSplineInterpolation (int num)
Private Member Functions
void	ChargeSpline ()
double	Slope (double x0, double y0, double x1, double y1)
double	Normal (double x0, double y0, double *m, double xi)
void	CircleCenter (std::vector< double > InX, std::vector< double > InY, std::vector< double > InZ, double cx, double cy, double r)
void	CirclePoints (double cx, double cy, double r, double grad, double x, double y)
void	InterCircle (std::vector< double > InX, std::vector< double > InY, std::vector< double > *InZ)
void	maxminLocal ()
void	fixBetweenPoints (double val)
void	ErrorBetweenContours ()
void	AddControlPoint (bool activate)
void	InterBetweenControl ()
void	fixBetweenControl ()
void	PossibleIntersections (std::vector< double > InX, std::vector< double > InY, std::vector< double > *InZ)
void	ControlInContour (std::vector< double > InX, std::vector< double > InY, std::vector< double > *InZ)
void	NearMaxError2Control ()
void	MoveControlPointInContour (std::vector< double > InX, std::vector< double > InY, std::vector< double > *InZ)
double	MoveAndAverage (int dir, std::vector< double > InX, std::vector< double > InY, std::vector< double > *InZ)
void	MoveControlPoints (std::vector< double > InX, std::vector< double > InY, std::vector< double > *InZ)
void	GetNewPoints (std::vector< double > InX, std::vector< double > InY, std::vector< double > *InZ)
void	GetInitialNewPoints (std::vector< double > InX, std::vector< double > InY, std::vector< double > *InZ)
void	set_vec (double val)
void	set_var (double val)
double	get_vec (int id)
double	get_var ()
int	getsize_vec ()
void	copyVector (std::vector< Vector > vec1, std::vector< Vector > vec2)
void	printVector (std::vector< Vector > *vec1)
void	set_x (double val)
void	set_y (double val)
void	set_z (double val)
void	set_plane (int val)
double	get_x (int id)
int	getsize_x ()
double	get_y (int id)
int	getsize_y ()
double	get_z (int id)
int	getsize_z ()
int	get_plane ()
void	resetVec ()
std::vector< double >	getVec ()
Private Attributes
int	_SizeVectorIn
std::vector< double >	_controlpointsX
std::vector< double >	_controlpointsY
std::vector< double >	_controlpointsZ
manualContourModel *	_mContourModel
int	_numspline
double	_pathsize
std::vector< double >	_chargecontrolpointsX
std::vector< double >	_chargecontrolpointsY
std::vector< double >	_chargecontrolpointsZ
std::vector< double >	_circleX
std::vector< double >	_circleY
std::vector< double >	_intercircleX
std::vector< double >	_intercircleY
std::vector< double >	_intercircleDist
std::vector< double >	_interbewteencircleX
std::vector< double >	_interbewteencircleY
std::vector< double >	_interbewteencircleDist
std::vector< int >	_interbewteencirclePos
std::vector< int >	_posmaxlocal
std::vector< int >	_posminlocal
std::vector< double >	_maxlocalX
std::vector< double >	_maxlocalY
std::vector< double >	_minlocalX
std::vector< double >	_minlocalY
std::vector< double >	_minmaxlocalX
std::vector< double >	_minmaxlocalY
std::vector< int >	_posminmaxlocal
std::vector< Vector >	_intervectorX
std::vector< Vector >	_intervectorY
std::vector< double >	_interpointsX
std::vector< double >	_interpointsY
int	_posA
int	_posB
double	_errorpos
std::vector< double >	_errorvector
std::vector< Vector >	_intervecXX
std::vector< Vector >	_intervecYY
std::vector< Vector >	_interitselfX
std::vector< Vector >	_interitselfY
int	_posn
std::vector< int >	_contIncontpos

Detailed Description

Definition at line 8 of file AutoControlPoints.h.

Constructor & Destructor Documentation

AutoControlPoints::AutoControlPoints ( )

Definition at line 6 of file AutoControlPoints.cxx.

References _numspline, and _pathsize.

00007 {
00008          _pathsize = 0;
00009          _numspline = 100;
00010 }

AutoControlPoints::~AutoControlPoints ( )

Definition at line 12 of file AutoControlPoints.cxx.

00013 {
00014 }

Member Function Documentation

void AutoControlPoints::AddControlPoint ( bool activate ) [private]

Definition at line 846 of file AutoControlPoints.cxx.

References _controlpointsX, _controlpointsY, _controlpointsZ, _errorpos, _errorvector, _interpointsX, _interpointsY, _intervectorX, _intervectorY, _posA, _posB, vectorFunctions::copyVector(), and Vector::get_var().

Referenced by GetInitialNewPoints(), GetNewPoints(), and NearMaxError2Control().

00848 00849         { 00850 00851 00852 00853 00854 00855 00856 00857 00858 00859 00860 00861 00862 00863 00864 00865 00866 00867 00868 00869 00870 00871 00872 00873 00874 00875 00876 00877 00878 00879 00880 00881 00882 00883 00884 00885 00886 00887 00888 00889 00890 00891 00892 00893 00894 00895 00896 00897 00898 00899 00900 00901 00902 00903 00904 00905 00906 00907 00908 00909 00910 00911 00912 00913 00914 00915 00916 00917 00918 00919 00920 00921 00922 00923 00924 00925 00926 00927 00928 00929 00930 00931 00932 00933 00934 00935 00936 00937 00938 00939 00940 }

class="fragment">00847 { if(_errorpos != -1) double xmax = _interpointsX[(int)_errorpos]; double ymax = _interpointsY[(int)_errorpos]; double xx = _intervectorX[(int)_errorpos].get_var(); double yy = _intervectorY[(int)_errorpos].get_var(); printf("\n XMAX = %f, YMAX = %f, XX = %f, YY = %f",xmax,ymax,xx,yy); int i,ii,j,posA=-1,posB=-1; bool findA=false, findB=false; //CASE A for(i=(int)_errorpos; findA!=true; i++) { ii = i%_errorvector.size(); for(j=0; j<(int)(_controlpointsX.size()); j++) { if( ((float)_controlpointsX[j]-1.5<=(float)_intervectorX[ii].get_var()) && ((float)_intervectorX[ii].get_var()<=(float)_controlpointsX[j]+1.5) && ((float)_controlpointsY[j]-1.5<=(float)_intervectorY[ii].get_var()) && ((float)_intervectorY[ii].get_var()<=(float)_controlpointsY[j]+1.5) ) { findA = true; posA = j; } } } //CASE B for(i=(int)_errorpos; findB!=true; i--) { if(_errorpos==-1) { i = _errorvector.size(); } for(j=0; j<(int)(_controlpointsX.size()); j++) { if( ((float)_controlpointsX[j]-1.5<=(float)_intervectorX[i].get_var()) && ((float)_intervectorX[i].get_var()<=(float)_controlpointsX[j]+1.5) && ((float)_controlpointsY[j]-1.5<=(float)_intervectorY[i].get_var()) && ((float)_intervectorY[i].get_var()<=(float)_controlpointsY[j]+1.5) ) { findB = true; posB = j; } } } if(posA == posB) { posB = posA-1; } if(posA<posB) { posA = posB+1; if(posB = _controlpointsX.size()-1) // ?!? // JPRx // ?!? EED { posA = 0; } } printf("\n POSA = %d, X = %f, Y = %f",posA,_controlpointsX[posA],_controlpointsY[posA]); printf("\n POSB = %d, X = %f, Y = %f",posB,_controlpointsX[posB],_controlpointsY[posB]); _posA = posA; _posB = posB; int id = -1; if(((posA!=-1)&&(posB!=-1))) { id = posA; } printf("\n ID = %d",id); if(id != -1) { std::vector<double> tempX; std::vector<double> tempY; std::vector<double> tempZ; for(i=0; i<(int)(_controlpointsX.size()); i++) { if(i == id) { tempX.push_back(xmax); tempY.push_back(ymax); tempZ.push_back(_controlpointsZ[0]); } tempX.push_back(_controlpointsX[i]); tempY.push_back(_controlpointsY[i]); tempZ.push_back(_controlpointsZ[i]); } if(activate == true) { vectorFunctions *vf = new vectorFunctions(); vf->copyVector(&tempX,&_controlpointsX); vf->copyVector(&tempY,&_controlpointsY); vf->copyVector(&tempZ,&_controlpointsZ); delete vf; } } }//IF-(principal)

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::CalculeControlPoints	(	std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ
	)

Definition at line 1672 of file AutoControlPoints.cxx.

References _controlpointsX, _controlpointsY, _controlpointsZ, and GetNewPoints().

Referenced by ExtractControlPoints2D::GetControlPoints().

01673 {
01674 
01675         _controlpointsX.clear();
01676         _controlpointsY.clear();
01677         _controlpointsZ.clear();
01678         _controlpointsZ.push_back((*InZ)[0]);
01679         GetNewPoints( InX,InY,InZ );
01680 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::CalculeInitialControlPoints	(	std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ
	)

Definition at line 1682 of file AutoControlPoints.cxx.

References _controlpointsX, _controlpointsY, _controlpointsZ, and GetInitialNewPoints().

Referenced by ExtractControlPoints2D::GetInitialControlPoints().

01683 {
01684 
01685         _controlpointsX.clear();
01686         _controlpointsY.clear();
01687         _controlpointsZ.clear();
01688         _controlpointsZ.push_back((*InZ)[0]);
01689         GetInitialNewPoints( InX,InY,InZ );
01690 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::ChargeSpline ( ) [private]

Definition at line 203 of file AutoControlPoints.cxx.

References _chargecontrolpointsX, _chargecontrolpointsY, _chargecontrolpointsZ, _controlpointsX, _controlpointsY, _controlpointsZ, _mContourModel, _numspline, _pathsize, manualContourModel::AddPoint(), manualContourModel::DeleteAllPoints(), manualContourModel::GetNumberOfPointsSpline(), manualContourModel::GetPathSize(), manualContourModel::GetSpline_i_Point(), manualContourModel::SetCloseContour(), manualContourModel::SetNumberOfPointsSpline(), and manualContourModel::UpdateSpline().

Referenced by InterBetweenContours().

00204  {
00205          int size = _controlpointsX.size();
00206          if(size != 0)
00207          {
00208                 _mContourModel = new manualContourModel();
00209                 if( _controlpointsX.size() == 2 )
00210                 {
00211                         _mContourModel->SetCloseContour(false);
00212                 }
00213                 if( _controlpointsX.size() > 2 )
00214                 {
00215                         _mContourModel->SetCloseContour(true);
00216                 }
00217 
00218                 _mContourModel->DeleteAllPoints();
00219                 _mContourModel->SetNumberOfPointsSpline(_numspline);
00220                 for(int i=0; i<size; i++)
00221                 {
00222                         _mContourModel->AddPoint(_controlpointsX[i],_controlpointsY[i],_controlpointsZ[i]);
00223                 }
00224                 _mContourModel->UpdateSpline();
00225                 int numspline = _mContourModel->GetNumberOfPointsSpline();
00226                 double x,y,z;
00227                 _chargecontrolpointsX.clear();
00228                 _chargecontrolpointsY.clear();
00229                 _chargecontrolpointsZ.clear();
00230                 for(int j=0; j<numspline; j++)
00231                 {
00232                         _mContourModel->GetSpline_i_Point(j,&x,&y,&z);
00233                         _chargecontrolpointsX.push_back(x);
00234                         _chargecontrolpointsY.push_back(y);
00235                         _chargecontrolpointsZ.push_back(z);
00236                 }
00237                 _pathsize = _mContourModel->GetPathSize();
00238 //printf("\nPATH SIZE = %f",_pathsize);
00239 
00240                  std::ofstream file1;
00241                 file1.open( "4_SplinePoints.txt" );
00242 
00243                 for(int i = 0; i < numspline; i++){
00244                         file1<<"X= "<<_chargecontrolpointsX[i] << "\tY= "<<_chargecontrolpointsY[i] << "\tZ= "<<_chargecontrolpointsZ[i]<<std::endl;
00245                 }
00246                 file1.close();
00247          }
00248         
00249  }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::CircleCenter	(	std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ,
		double *	cx,
		double *	cy,
		double *	r
	)			`[private]`

Definition at line 176 of file AutoControlPoints.cxx.

References PointHigh(), PointLeft(), PointLow(), and PointRight().

Referenced by InterCircle().

00177 {
00178         double hiX=0,hiY=0,hiZ=0;
00179         PointHigh ( InX,InY,InZ,&hiX,&hiY,&hiZ );
00180 
00181         double leX=0,leY=0,leZ=0;
00182         PointLeft ( InX,InY,InZ,&leX,&leY,&leZ );
00183                 
00184         double loX=0,loY=0,loZ=0;
00185         PointLow  ( InX,InY,InZ,&loX,&loY,&loZ );
00186 
00187         double riX=0,riY=0,riZ=0;
00188         PointRight( InX,InY,InZ,&riX,&riY,&riZ );
00189 
00190         *cx = (riX+leX)/2;
00191         *cy = (hiY+loY)/2;
00192         *r = sqrt(pow(leX-*cx,2)+pow(hiY-*cy,2)) + 7;
00193 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::CirclePoints	(	double	cx,
		double	cy,
		double	r,
		double	grad,
		double *	x,
		double *	y
	)			`[private]`

Definition at line 195 of file AutoControlPoints.cxx.

Referenced by InterCircle().

00196 {
00197         double alpha = (2*3.14159265*grad)/360;
00198 
00199         *x = cx + (r*cos(alpha));
00200         *y = cy + (r*sin(alpha));
00201 }

Here is the caller graph for this function:

void AutoControlPoints::ControlInContour	(	std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ
	)			`[private]`

Definition at line 1244 of file AutoControlPoints.cxx.

References _contIncontpos, _controlpointsX, and _controlpointsY.

Referenced by MoveControlPoints().

01245 {
01246         int i,j;
01247         _contIncontpos.clear(); 
01248         bool find = false;
01249         double range = 2;
01250         for(i=0; i<(int)(_controlpointsX.size()); i++)
01251         {
01252                 find = false;
01253                 for(j=0; (j<(int)(InX->size())) && (find!=true); j++)
01254                 {
01255                         if( ((*InX)[j]-range<=_controlpointsX[i]) && (_controlpointsX[i]<=(*InX)[j]+range) && ((*InY)[j]-range<=_controlpointsY[i]) && (_controlpointsY[i]<=(*InY)[j]+range) )
01256                         {
01257                                 _contIncontpos.push_back(j);
01258                                 find = true;
01259                         }
01260                 }
01261         }
01262 }

Here is the caller graph for this function:

void Vector::copyVector	(	std::vector< Vector > *	vec1,
		std::vector< Vector > *	vec2
	)			`[inherited]`

Definition at line 51 of file Propagation.cxx.

References Vector::get_var(), Vector::get_vec(), Vector::set_var(), Vector::set_vec(), and Vector::Vector().

00052 {
00053         int i,j;
00054         if( vec1->size() != 0 )
00055         {
00056                 vec2->clear();
00057                 for(i=0; i<(int)(vec1->size()); i++)
00058                 {
00059                         Vector *temp = new Vector();
00060                         temp->set_var( (*vec1)[i].get_var() );
00061                         for(j=0; j<(*vec1)[i].getsize_vec(); j++)
00062                         {
00063                                 temp->set_vec( (*vec1)[i].get_vec(j) );
00064                         }
00065                         vec2->push_back(*temp);
00066                         delete temp;
00067                 }
00068         }
00069 }

Here is the call graph for this function:

void AutoControlPoints::ErrorBetweenContours ( ) [private]

Definition at line 806 of file AutoControlPoints.cxx.

References _errorpos, _errorvector, _interpointsX, _interpointsY, _intervectorX, _intervectorY, _pathsize, and Vector::get_var().

Referenced by GetInitialNewPoints(), GetNewPoints(), MoveAndAverage(), and MoveControlPointInContour().

00807 {
00808         _errorpos = -1;
00809         if(_interpointsX.size() != 0)
00810         {
00811                 _errorvector.clear();
00812                 int i;
00813 //EED 22 Sep 2008
00814 
00815 //              FILE *fd;
00816 //              fd = fopen("C:/bbtk_JS/data/interErrorData.txt","w");
00817                 for(i=0; i<(int)(_interpointsX.size()); i++)
00818                 {
00819                         _errorvector.push_back( (sqrt( pow( _interpointsX[i]-_intervectorX[i].get_var(),2 ) + pow( _interpointsY[i]-_intervectorY[i].get_var(),2 ) )/_pathsize)*100 );
00820 //                      fprintf(fd,"\n%d        %f",i,_errorvector[i]);
00821                 }
00822 //              fclose(fd);
00823                 double max = -1;
00824                 for(i=0; i<(int)(_errorvector.size()); i++)
00825                 {
00826                         if(_interpointsX[i] != -1)
00827                         {
00828                                 if(_errorvector[i]>max)
00829                                 {
00830                                         max = _errorvector[i];
00831                                         _errorpos = i;
00832                                 }
00833                         }
00834                 }
00835         }
00836 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::fixBetweenControl ( ) [private]

Definition at line 1016 of file AutoControlPoints.cxx.

References _interitselfX, _interitselfY, _intervecXX, _intervecYY, Vector::get_var(), Vector::set_var(), Vector::set_vec(), and Vector::Vector().

01017 {
01018         _interitselfX.clear();
01019         _interitselfY.clear();
01020         int i,j;
01021         float vecx,vecy,varx,vary;
01022 //      FILE *fd;
01023 //      fd = fopen("C:/bbtk_JS/data/InterBetweenControlFix.txt","w");
01024         for(i=0; i<(int)(_intervecXX.size()); i++)
01025         {
01026                 Vector *vx = new Vector();
01027                 Vector *vy = new Vector();
01028                 vx->set_var(_intervecXX[i].get_var());
01029                 vy->set_var(_intervecYY[i].get_var());
01030 //              fprintf(fd,"\n Para X = %f, Y = %f",_intervecXX[i].get_var(),_intervecYY[i].get_var());
01031                 for(j=0; j<_intervecXX[i].getsize_vec(); j++)
01032                 {
01033                         vecx = _intervecXX[i].get_vec(j);
01034                         varx = _intervecXX[i].get_var();
01035                         vecy = _intervecYY[i].get_vec(j);
01036                         vary = _intervecYY[i].get_var();
01037                         if(  (vecx == varx) && (vecy == vary) )
01038                         {
01039                         }
01040                         else
01041                         {
01042                                 vx->set_vec((double)vecx);
01043                                 vy->set_vec((double)vecy);
01044 //                              fprintf(fd,"\n => x_int = %f, y_int = %f",vecx,vecy);
01045                         }
01046                 }
01047                 _interitselfX.push_back(*vx);
01048                 _interitselfY.push_back(*vy);
01049                 delete vx;
01050                 delete vy;
01051         }
01052 //      fclose(fd);
01053 }

Here is the call graph for this function:

void AutoControlPoints::fixBetweenPoints ( double val ) [private]

Definition at line 551 of file AutoControlPoints.cxx.

References _controlpointsX, _controlpointsY, _controlpointsZ, and vectorFunctions::copyVector().

Referenced by GetInitialNewPoints(), GetNewPoints(), MoveAndAverage(), and MoveControlPointInContour().

00552 {
00553         int size = _controlpointsX.size();
00554         double dist;
00555         if(size != 0)
00556         {
00557                 std::vector<double> tempX;
00558                 std::vector<double> tempY;
00559                 std::vector<double>     tempZ;
00560                 tempX.clear();
00561                 tempY.clear();
00562                 tempZ.clear();
00563 
00564                 int ii;
00565                 vectorFunctions *vecf = new vectorFunctions();
00566                 for(int i=0; i<size; i++)
00567                 {
00568                         ii = (i+1)%size;
00569                         dist = sqrt(pow(_controlpointsX[i]-_controlpointsX[ii],2)+pow(_controlpointsY[i]-_controlpointsY[ii],2));
00570                         if(dist>val)
00571                         {
00572                                 tempX.push_back(_controlpointsX[i]);
00573                                 tempY.push_back(_controlpointsY[i]);
00574                                 tempZ.push_back(_controlpointsZ[i]);
00575                         }
00576                 }
00577                 _controlpointsX.clear();
00578                 _controlpointsY.clear();
00579                 _controlpointsZ.clear();
00580 
00581                 vecf->copyVector(&tempX,&_controlpointsX);
00582                 vecf->copyVector(&tempY,&_controlpointsY);
00583                 vecf->copyVector(&tempZ,&_controlpointsZ);
00584 
00585                 std::ofstream file1;
00586                 file1.open( "3_PointsFixed.txt" );
00587 
00588                 for(int i = 0; i < (int)(_controlpointsX.size()); i++){
00589                         file1<<"X= "<<_controlpointsX[i] << "\tY= "<<_controlpointsY[i] << "\tZ= "<<_controlpointsZ[i]<<std::endl;
00590                 }
00591                 file1.close();
00592 
00593                 delete vecf;
00594         }
00595 }

Here is the call graph for this function:

Here is the caller graph for this function:

int Vector::get_plane ( ) [inherited]

Definition at line 106 of file Propagation.cxx.

References Vector::_plane.

00107 {
00108         return _plane;
00109 }

double Vector::get_var ( ) [inherited]

Definition at line 41 of file Propagation.cxx.

References Vector::_var.

Referenced by AddControlPoint(), Vector::copyVector(), ErrorBetweenContours(), fixBetweenControl(), IntersectionPoints(), PossibleIntersections(), and Vector::printVector().

00042 {
00043         return _var;
00044 }

Here is the caller graph for this function:

double Vector::get_vec ( int id ) [inherited]

Definition at line 32 of file Propagation.cxx.

References Vector::_vec.

Referenced by Vector::copyVector(), IntersectionPoints(), PossibleIntersections(), and Vector::printVector().

00033 {
00034         if(_vec.size() != 0)
00035         {
00036                 return _vec[id];
00037         }
00038         return -1;
00039 }

Here is the caller graph for this function:

double Vector::get_x ( int id ) [inherited]

Definition at line 111 of file Propagation.cxx.

References Vector::_vecX.

00112 {
00113         if( (-1<id) && (id<(int)(_vecX.size())  ) )
00114         {
00115                 return _vecX[id];
00116         }
00117         return -1;
00118 }

double Vector::get_y ( int id ) [inherited]

Definition at line 129 of file Propagation.cxx.

References Vector::_vecY.

00130 {
00131         if( (-1<id) && (id<(int)(_vecY.size())) )
00132         {
00133                 return _vecY[id];
00134         }
00135         return -1;
00136 }

double Vector::get_z ( int id ) [inherited]

Definition at line 156 of file Propagation.cxx.

References Vector::_vecZ.

00157 {
00158         if( (-1<id) && (id<(int)(_vecZ.size())) )
00159         {
00160                 return _vecZ[id];
00161         }
00162         return -1;
00163 }

void AutoControlPoints::GetControlPoints	(	std::vector< double > *	OutX,
		std::vector< double > *	OutY,
		std::vector< double > *	OutZ
	)

Definition at line 1692 of file AutoControlPoints.cxx.

References _controlpointsX, _controlpointsY, _controlpointsZ, and vectorFunctions::copyVector().

Referenced by ExtractControlPoints2D::GetControlPoints().

01693 {
01694         vectorFunctions *vf = new vectorFunctions();
01695         OutX->clear();
01696         OutY->clear();
01697         OutZ->clear();
01698         vf->copyVector(&_controlpointsX,OutX);
01699         vf->copyVector(&_controlpointsY,OutY);
01700         vf->copyVector(&_controlpointsZ,OutZ);
01701         delete vf;
01702 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::GetErrorBetweenContours ( std::vector< double > * vec )

Definition at line 838 of file AutoControlPoints.cxx.

References _errorvector, and vectorFunctions::copyVector().

00839 {
00840         vec->clear();
00841         vectorFunctions *vf = new vectorFunctions();
00842         vf->copyVector(&_errorvector,vec);
00843         delete vf;
00844 }

Here is the call graph for this function:

void AutoControlPoints::GetInitialControlPoints	(	std::vector< double > *	OutX,
		std::vector< double > *	OutY,
		std::vector< double > *	OutZ
	)

Definition at line 1704 of file AutoControlPoints.cxx.

References _controlpointsX, _controlpointsY, _controlpointsZ, and vectorFunctions::copyVector().

Referenced by ExtractControlPoints2D::GetInitialControlPoints().

01705 {
01706         vectorFunctions *vf = new vectorFunctions();
01707         OutX->clear();
01708         OutY->clear();
01709         OutZ->clear();
01710         vf->copyVector(&_controlpointsX,OutX);
01711         vf->copyVector(&_controlpointsY,OutY);
01712         vf->copyVector(&_controlpointsZ,OutZ);
01713         delete vf;
01714 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::GetInitialNewPoints	(	std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ
	)			`[private]`

Definition at line 1603 of file AutoControlPoints.cxx.

References _controlpointsX, _controlpointsY, _controlpointsZ, _errorvector, _minmaxlocalX, _minmaxlocalY, AddControlPoint(), vectorFunctions::copyVector(), ErrorBetweenContours(), fixBetweenPoints(), InterCircle(), IntersectionPoints(), maxminLocal(), vectorFunctions::maxVector(), PossibleIntersections(), and vectorFunctions::promVector().

Referenced by CalculeInitialControlPoints().

01604 {
01605         vectorFunctions *vf = new vectorFunctions();
01606         double prom,maxerror;
01607         
01608         InterCircle(InX,InY,InZ);
01609         maxminLocal();
01610         fixBetweenPoints(5.0);
01611         PossibleIntersections(InX,InY,InZ);
01612         IntersectionPoints();
01613         ErrorBetweenContours();
01614         prom = vf->promVector(&_errorvector,false);
01615         vf->maxVector(&_errorvector,&maxerror);
01616         
01617         if( maxerror>3.0 )
01618         {
01619                 _controlpointsX.clear();
01620                 _controlpointsY.clear();
01621                 _controlpointsZ.clear();
01622                 vf->copyVector(&_minmaxlocalX,&_controlpointsX);
01623                 vf->copyVector(&_minmaxlocalY,&_controlpointsY);
01624                 for(int i=0; i<(int)(_minmaxlocalX.size()); i++)
01625                 {
01626                         _controlpointsZ.push_back( (*InZ)[0] );
01627                 }
01628                 fixBetweenPoints(5.0);
01629                 PossibleIntersections(InX,InY,InZ);
01630                 IntersectionPoints();
01631                 ErrorBetweenContours();
01632                 prom = vf->promVector(&_errorvector,false);
01633                 vf->maxVector(&_errorvector,&maxerror);
01634         }
01635 
01636         std::vector<double> cpX;
01637         std::vector<double> cpY;
01638         std::vector<double> cpZ;
01639         cpX.clear();
01640         cpY.clear();
01641         cpZ.clear();
01642         vf->copyVector(&_controlpointsX,&cpX);
01643         vf->copyVector(&_controlpointsY,&cpY);
01644         vf->copyVector(&_controlpointsZ,&cpZ);
01645 
01646         double promini = prom; 
01647 
01648         int i;
01649         for(i=0; (i<10)&&(maxerror>0.5)&&(prom>0.15); i++ )
01650         {
01651                 AddControlPoint(true);
01652                 fixBetweenPoints(5.0);
01653                 PossibleIntersections(InX,InY,InZ);
01654                 IntersectionPoints();
01655                 ErrorBetweenContours();
01656                 prom = vf->promVector(&_errorvector,false);
01657                 vf->maxVector(&_errorvector,&maxerror);
01658         }
01659 
01660         if( i==10 || prom > promini)
01661         {
01662                 _controlpointsX.clear();
01663                 _controlpointsY.clear();
01664                 _controlpointsZ.clear();
01665                 vf->copyVector(&cpX,&_controlpointsX);
01666                 vf->copyVector(&cpY,&_controlpointsY);
01667                 vf->copyVector(&cpZ,&_controlpointsZ);
01668         }
01669         delete vf;
01670 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::GetInterBetweenContours	(	std::vector< Vector > *	interVX,
		std::vector< Vector > *	interVY
	)

Definition at line 686 of file AutoControlPoints.cxx.

References _intervectorX, and _intervectorY.

00687 {
00688         interVX->clear();
00689         interVY->clear();
00690         int size = _intervectorX.size();
00691         int i;
00692         if(size != 0)
00693         {
00694                 for(i=0; i<size; i++)
00695                 {
00696                         interVX->push_back(_intervectorX[i]);
00697                         interVY->push_back(_intervectorY[i]);
00698                 }
00699         }
00700 }

void AutoControlPoints::GetIntersectionPoints	(	std::vector< Vector > *	interVX,
		std::vector< Vector > *	interVY
	)

Definition at line 781 of file AutoControlPoints.cxx.

References _controlpointsZ, _interpointsX, _interpointsY, Vector::set_var(), Vector::set_vec(), and Vector::Vector().

00782 {
00783         int size = _interpointsX.size();
00784         int i;
00785         if(size != 0)
00786         {
00787                 Vector *vecX = new Vector();
00788                 Vector *vecY = new Vector();
00789                 interVX->clear();
00790                 interVY->clear();
00791                 for(i=0; i<size; i++)
00792                 {
00793                         vecX->set_var(_controlpointsZ[0]);
00794                         vecX->set_vec(_interpointsX[i]);
00795                         vecY->set_var(_controlpointsZ[0]);
00796                         vecY->set_vec(_interpointsY[i]);
00797                         interVX->push_back(*vecX);
00798                         interVY->push_back(*vecY);
00799                 }
00800                 delete vecX;
00801                 delete vecY;
00802         }
00803 }

Here is the call graph for this function:

void AutoControlPoints::GetNewPoints	(	std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ
	)			`[private]`

Definition at line 1485 of file AutoControlPoints.cxx.

References _controlpointsX, _controlpointsY, _controlpointsZ, _errorvector, _minmaxlocalX, _minmaxlocalY, AddControlPoint(), vectorFunctions::copyVector(), ErrorBetweenContours(), fixBetweenPoints(), InterCircle(), IntersectionPoints(), maxminLocal(), vectorFunctions::maxVector(), PossibleIntersections(), and vectorFunctions::promVector().

Referenced by CalculeControlPoints().

01486 {
01487         vectorFunctions *vf = new vectorFunctions();
01488         double prom,maxerror;
01489         
01490         InterCircle(InX,InY,InZ);
01491         maxminLocal();
01492         fixBetweenPoints(5.0);
01493         PossibleIntersections(InX,InY,InZ);
01494         IntersectionPoints();
01495         ErrorBetweenContours();
01496         prom = vf->promVector(&_errorvector,false);
01497         vf->maxVector(&_errorvector,&maxerror);
01498 printf("\n");
01499         if( maxerror>3.0 )
01500         {
01501                 _controlpointsX.clear();
01502                 _controlpointsY.clear();
01503                 _controlpointsZ.clear();
01504                 vf->copyVector(&_minmaxlocalX,&_controlpointsX);
01505                 vf->copyVector(&_minmaxlocalY,&_controlpointsY);
01506                 for(int i=0; i<(int)(_minmaxlocalX.size()); i++)
01507                 {
01508                         _controlpointsZ.push_back( (*InZ)[0] );
01509                 }
01510                 fixBetweenPoints(5.0);
01511                 PossibleIntersections(InX,InY,InZ);
01512                 IntersectionPoints();
01513                 ErrorBetweenContours();
01514                 prom = vf->promVector(&_errorvector,false);
01515                 vf->maxVector(&_errorvector,&maxerror);
01516 printf("\n");
01517         }
01518 
01519         std::vector<double> cpX;
01520         std::vector<double> cpY;
01521         std::vector<double> cpZ;
01522         cpX.clear();
01523         cpY.clear();
01524         cpZ.clear();
01525         vf->copyVector(&_controlpointsX,&cpX);
01526         vf->copyVector(&_controlpointsY,&cpY);
01527         vf->copyVector(&_controlpointsZ,&cpZ);
01528         int i;
01529 
01530         for(i=0; (i<10)&&(maxerror>0.5)&&(prom>0.15); i++ )
01531         {
01532                 AddControlPoint(true);
01533                 fixBetweenPoints(5.0);
01534                 PossibleIntersections(InX,InY,InZ);
01535                 IntersectionPoints();
01536                 ErrorBetweenContours();
01537                 prom = vf->promVector(&_errorvector,false);
01538                 vf->maxVector(&_errorvector,&maxerror);
01539                 printf("\n %d ",i);
01540         }
01541 
01542         if(i == 10)
01543         {
01544                 _controlpointsX.clear();
01545                 _controlpointsY.clear();
01546                 _controlpointsZ.clear();
01547                 int inicontrolpoints = cpX.size();
01548                 double inipercentage = (inicontrolpoints*100)/InX->size();
01549                 int h=0;
01550                 if(inicontrolpoints<10)
01551                 {
01552                         int points = (int)((inipercentage*3*InX->size())/100);
01553                         for (int i=0; i<(int)(InX->size()); i++, h++)
01554                         {
01555                                 if( h == points )
01556                                 {
01557                                         _controlpointsX.push_back( (*InX)[i] );
01558                                         _controlpointsY.push_back( (*InY)[i] );
01559                                         _controlpointsZ.push_back( (*InZ)[i] );
01560                                         h = 0;
01561                                 }
01562                         }
01563                 }
01564                 if(inicontrolpoints>=10)
01565                 {
01566                         int points = (int)((inipercentage*2*InX->size())/100);
01567                         for (int i=0; i<(int)(InX->size()); i++, h++)
01568                         {
01569                                 if( h == points )
01570                                 {
01571                                         _controlpointsX.push_back( (*InX)[i] );
01572                                         _controlpointsY.push_back( (*InY)[i] );
01573                                         _controlpointsZ.push_back( (*InZ)[i] );
01574                                         h = 0;
01575                                 }
01576                         }
01577                 }
01578         }
01579 /*
01580         fixBetweenPoints(5.0);
01581         PossibleIntersections(InX,InY,InZ);
01582         IntersectionPoints();
01583         ErrorBetweenContours();
01584         prom = vf->promVector(&_errorvector,false);
01585         vf->maxVector(&_errorvector,&maxerror);
01586 
01587 
01588 printf("\n Error Average  = %f",prom);
01589 printf("\n Error Max  = %f",maxerror);
01590         AddControlPoint(false);
01591 */
01592 /*
01593         //if( (prom>1) || (maxerror>2))
01594         if( prom>0.2 )
01595         {
01596 printf("\n Error Average is grater than 1 !!");
01597                 MoveControlPoints(InX,InY,InZ);
01598         }
01599 */
01600         delete vf;
01601 }

Here is the call graph for this function:

Here is the caller graph for this function:

int Vector::getsize_vec ( ) [inherited]

Definition at line 46 of file Propagation.cxx.

References Vector::_vec.

Referenced by PossibleIntersections().

00047 {
00048         return _vec.size();
00049 }

Here is the caller graph for this function:

int Vector::getsize_x ( ) [inherited]

Definition at line 120 of file Propagation.cxx.

References Vector::_vecX.

00121 {
00122         if(_vecX.size() != 0)
00123         {
00124                 return _vecX.size();
00125         }
00126         return -1;
00127 }

int Vector::getsize_y ( ) [inherited]

Definition at line 138 of file Propagation.cxx.

References Vector::_vecY.

00139 {
00140         if(_vecY.size() != 0)
00141         {
00142                 return _vecY.size();
00143         }
00144         return -1;
00145 }

int Vector::getsize_z ( ) [inherited]

Definition at line 147 of file Propagation.cxx.

References Vector::_vecZ.

00148 {
00149         if(_vecZ.size() != 0)
00150         {
00151                 return _vecZ.size();
00152         }
00153         return -1;
00154 }

int AutoControlPoints::GetSizeVector ( std::vector< double > * Vector )

Definition at line 16 of file AutoControlPoints.cxx.

References _SizeVectorIn.

Referenced by PointLeft(), PointLow(), and PointRight().

00017    {
00018            if(Vector != NULL)
00019            {
00020                         return _SizeVectorIn = Vector->size();
00021            }
00022            else
00023            {
00024                         return _SizeVectorIn = -1;
00025            }
00026    }

Here is the caller graph for this function:

std::vector< double > Vector::getVec ( ) [inherited]

Definition at line 165 of file Propagation.cxx.

References Vector::_vec.

00166 {
00167         return _vec;
00168 }

void AutoControlPoints::InterBetweenContours	(	std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ
	)

Definition at line 598 of file AutoControlPoints.cxx.

References _chargecontrolpointsX, _chargecontrolpointsY, _intervectorX, _intervectorY, ChargeSpline(), Intersection(), Normal(), Vector::set_var(), Vector::set_vec(), Slope(), and Vector::Vector().

Referenced by PossibleIntersections().

00599 {
00600         _intervectorX.clear();
00601         _intervectorY.clear();
00602         ChargeSpline();
00603 
00604         int i,ii,j,jj;
00605         double m1,mn,m2,xinter,yinter;
00606         if(_chargecontrolpointsX.size() > 1) //These condition exists because there is a method for find the initial control points 
00607         {
00608 //EED 22 Sep 2008
00609 //              FILE *fd;
00610 //              fd = fopen("C:/bbtk_JS/data/interBetweenContours.txt","w");
00611                 for(i=0; i<(int)(_chargecontrolpointsX.size()); i++)
00612                 {
00613                         ii = (i+1)%(_chargecontrolpointsX.size());
00614 
00615                         m1 = Slope(_chargecontrolpointsX[i],_chargecontrolpointsY[i],_chargecontrolpointsX[ii],_chargecontrolpointsY[ii]);
00616                         mn = m1;
00617                         Normal(_chargecontrolpointsX[i],_chargecontrolpointsY[i],&mn,_chargecontrolpointsX[i]+1);
00618 //                      fprintf(fd,"\n Para X = %f, Y = %f",_chargecontrolpointsX[i],_chargecontrolpointsY[i]);
00619 
00620                         Vector *vecX = new Vector();
00621                         Vector *vecY = new Vector();
00622                         vecX->set_var(_chargecontrolpointsX[i]);
00623                         vecY->set_var(_chargecontrolpointsY[i]);
00624 
00625                         for(j=0; j<(int)(InX->size()); j++)
00626                         {
00627                                 jj = (j+1)%(InX->size());
00628                                 m2 = Slope((*InX)[j],(*InY)[j],(*InX)[jj],(*InY)[jj]);
00629                                 Intersection(_chargecontrolpointsX[i],_chargecontrolpointsY[i],(*InX)[j],(*InY)[j],mn,m2,&xinter,&yinter);
00630 
00631                                 if(((*InX)[j] <= xinter && xinter <= (*InX)[jj]) || (xinter<=(*InX)[j] && xinter>=(*InX)[jj])){
00632                                         vecX->set_vec(xinter);
00633                                         vecY->set_vec(yinter);
00634                                 }
00635 /*JCP 29-09-08
00636                                 if( (*InX)[j]<=(*InX)[jj] )
00637                                 {
00638                                         if( (xinter>=(*InX)[j]) && (xinter<=(*InX)[jj]) )
00639                                         {
00640                                                 //If the point is a CP, the intersection is itself.
00641                                                 if((xinter==_chargecontrolpointsX[i]) && (yinter==_chargecontrolpointsY[i]))
00642                                                 {
00643                                                         vecX->set_vec(xinter);
00644                                                         vecY->set_vec(yinter);
00645 //                                                      fprintf(fd,"\n => x_int = %f, y_int = %f",xinter,yinter);
00646                                                 }
00647                                                 else
00648                                                 {
00649                                                         vecX->set_vec(xinter);
00650                                                         vecY->set_vec(yinter);
00651 //                                                      fprintf(fd,"\n => x_int = %f, y_int = %f",xinter,yinter);
00652                                                 }
00653                                         }
00654                                 }
00655                                 if( (*InX)[j]>(*InX)[jj] )
00656                                 {
00657                                         if( (xinter<=(*InX)[j]) && (xinter>=(*InX)[jj]) )
00658                                         {
00659                                                 //If the point is a CP, the intersection is itself.
00660                                                 if((xinter==_chargecontrolpointsX[i]) && (yinter==_chargecontrolpointsY[i]))
00661                                                 {
00662                                                         vecX->set_vec(xinter);
00663                                                         vecY->set_vec(yinter);
00664 //                                                      fprintf(fd,"\n => x_int = %f, y_int = %f",xinter,yinter);
00665                                                 }
00666                                                 else
00667                                                 {
00668                                                         vecX->set_vec(xinter);
00669                                                         vecY->set_vec(yinter);
00670 //                                                      fprintf(fd,"\n => x_int = %f, y_int = %f",xinter,yinter);
00671                                                 }
00672                                         }
00673                                 }
00674 JCP 29-09-08*/
00675                         }//FOR2
00676                         _intervectorX.push_back(*vecX);
00677                         _intervectorY.push_back(*vecY);
00678                         //DELETE!!
00679                         delete vecX;
00680                         delete vecY;
00681                 }//FOR1
00682 //              fclose(fd);
00683         }//IF
00684 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::InterBetweenControl ( ) [private]

Definition at line 942 of file AutoControlPoints.cxx.

References _chargecontrolpointsX, _chargecontrolpointsY, _intervecXX, _intervecYY, Intersection(), Normal(), Vector::set_var(), Vector::set_vec(), Slope(), and Vector::Vector().

00943 {
00944         _intervecXX.clear();
00945         _intervecYY.clear();
00946         
00947         int i,ii,j,jj;
00948         double m1,mn,m2,xinter,yinter;
00949         if(_chargecontrolpointsX.size() > 1) //These condition exists because there is a method for find the initial control points 
00950         {
00951 //EED 22 Sep 2008
00952 
00953 //              FILE *fd;
00954 //              fd = fopen("C:/bbtk_JS/data/InterBetweenControl.txt","w");
00955                 for(i=0; i<(int)(_chargecontrolpointsX.size())-1; i++)
00956                 {
00957                         ii = (i+1)%(_chargecontrolpointsX.size());
00958                         m1 = Slope(_chargecontrolpointsX[i],_chargecontrolpointsY[i],_chargecontrolpointsX[ii],_chargecontrolpointsY[ii]);
00959                         mn = m1;
00960                         Normal(_chargecontrolpointsX[i],_chargecontrolpointsY[i],&mn,_chargecontrolpointsX[i]+1);
00961 //                      fprintf(fd,"\n Para X = %f, Y = %f",_chargecontrolpointsX[i],_chargecontrolpointsY[i]);
00962 
00963                         Vector *vecX = new Vector();
00964                         Vector *vecY = new Vector();
00965                         vecX->set_var(_chargecontrolpointsX[i]);
00966                         vecY->set_var(_chargecontrolpointsY[i]);
00967 
00968                         for(j=0; j<(int)(_chargecontrolpointsX.size()); j++)
00969                         {
00970                                 jj = (j+1)%(_chargecontrolpointsX.size());
00971                                 m2 = Slope(_chargecontrolpointsX[j],_chargecontrolpointsY[j],_chargecontrolpointsX[jj],_chargecontrolpointsY[jj]);
00972                                 Intersection(_chargecontrolpointsX[i],_chargecontrolpointsY[i],_chargecontrolpointsX[j],_chargecontrolpointsY[j],mn,m2,&xinter,&yinter);
00973                                 if( _chargecontrolpointsX[j]<=_chargecontrolpointsX[jj] )
00974                                 {
00975                                         if( (xinter>=_chargecontrolpointsX[j]) && (xinter<=_chargecontrolpointsX[jj]) )
00976                                         {
00977                                                 if(((float)xinter==(float)_chargecontrolpointsX[i]) && ((float)yinter==(float)_chargecontrolpointsY[i]))
00978                                                 {
00979                                                 }
00980                                                 else
00981                                                 {
00982 //                                                      fprintf(fd,"\n => x_int = %f, y_int = %f",xinter,yinter);
00983                                                         vecX->set_vec(xinter);
00984                                                         vecY->set_vec(yinter);
00985                                                 }
00986                                         }
00987                                 }
00988                                 if( _chargecontrolpointsX[j]>_chargecontrolpointsX[jj] )
00989                                 {
00990                                         if( (xinter<=_chargecontrolpointsX[j]) && (xinter>=_chargecontrolpointsX[jj]) )
00991                                         {
00992                                                 if(((float)xinter==(float)_chargecontrolpointsX[i]) && ((float)yinter==(float)_chargecontrolpointsY[i]))
00993                                                 {
00994                                                 }
00995                                                 else
00996                                                 {
00997 //                                                      fprintf(fd,"\n => x_int = %f, y_int = %f",xinter,yinter);
00998                                                         vecX->set_vec(xinter);
00999                                                         vecY->set_vec(yinter);
01000                                                 }
01001                                         }
01002                                 }
01003                         }//FOR2
01004                         _intervecXX.push_back(*vecX);
01005                         _intervecYY.push_back(*vecY);
01006                         
01007                         //DELETE!!
01008                         delete vecX;
01009                         delete vecY;
01010 
01011                 }//FOR1
01012 //              fclose(fd);
01013         }//IF
01014 }

Here is the call graph for this function:

void AutoControlPoints::InterCircle	(	std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ
	)			`[private]`

This methods finds the points where each radius of the circle intersect the contour

Definition at line 275 of file AutoControlPoints.cxx.

References _circleX, _circleY, _interbewteencircleDist, _interbewteencirclePos, _interbewteencircleX, _interbewteencircleY, _intercircleDist, _intercircleX, _intercircleY, CircleCenter(), CirclePoints(), vectorFunctions::copyVector(), Intersection(), min, and Slope().

Referenced by GetInitialNewPoints(), and GetNewPoints().

00276 {
00277         double cx,cy,r;
00278         CircleCenter(InX,InY,InZ,&cx,&cy,&r);
00279 
00280         //GENERATE THE CIRCLE'S POINTS
00281         int i;
00282         double grad,x,y,n;
00283         std::vector<double>tempX;
00284         std::vector<double>tempY;
00285         tempX.clear();
00286         tempY.clear();
00287         n = 1;
00288         grad = 0;
00289         for(i=0; i<360/n; i++)
00290         {
00291                 CirclePoints(cx,cy,r,grad,&x,&y);
00292                 tempX.push_back(x);
00293                 tempY.push_back(y);
00294                 grad = grad + n;
00295         }
00296 
00297         //FIND THE INTERSECTIONS BETWEEN THE CIRCLE AND THE CONTOUR
00298         int j,jj;
00299         bool interRad = false;
00300         double m1, /*mn=0,*/ m2,xinter,yinter,xmin,ymin,min,dist; // JPRx
00301         _intercircleX.clear();
00302         _intercircleY.clear();
00303         _intercircleDist.clear();
00304         _interbewteencircleX.clear();
00305         _interbewteencircleY.clear();
00306         _interbewteencircleDist.clear();
00307         _interbewteencirclePos.clear();
00308 
00309 //EED 22 Sep 2008
00310 //      FILE *fd, *fexp;
00311 //      fd = fopen("C:/bbtk_JS/data/tempCircle.txt","w");
00312 //      fexp = fopen("C:/bbtk_JS/data/InterCircle.txt","w");
00313 //      fprintf(fexp,"\npos     min             xmin    ymin    xcir    ycir");
00314 
00315         //std::ofstream file1;
00316     //file1.open( "Temp.txt" ); 
00317         
00318         for(i=0; i<(int)(tempX.size()); i++)
00319         {
00320 //              fprintf(fd,"\n Para X = %f, Y = %f",tempX[i],tempY[i]);
00321                 _circleX.push_back(tempX[i]);
00322                 _circleY.push_back(tempY[i]);
00323                 m1 = Slope(tempX[i],tempY[i],cx,cy);//slope of the radius
00324                 min = 9999;
00325                 for(j=0; j<(int)(InX->size()); j++)
00326                 {
00327                         jj = (j+1)%(InX->size());
00328                         m2 = Slope((*InX)[j],(*InY)[j],(*InX)[jj],(*InY)[jj]);//Slope of the vector between the adjacent points
00329                         Intersection(tempX[i],tempY[i],(*InX)[j],(*InY)[j],m1,m2,&xinter,&yinter);
00330 
00331 //JCP 26-09-2008
00332                         //If the point of intersection is between two points of the contour
00333                         if( ((xinter>=(*InX)[j]) && (xinter<=(*InX)[jj]))||((xinter<=(*InX)[j]) && (xinter>=(*InX)[jj]) ))
00334                         {
00335                                 dist = sqrt(pow(tempX[i]-xinter,2) + pow(tempY[i]-yinter,2));
00336                                 if(dist<min)
00337                                 {
00338                                         min = dist;
00339                                         xmin = xinter;
00340                                         ymin = yinter;
00341                                 }
00342                         }
00343 //JCP 26-09-2008
00344 /*JCP 26-09-2008
00345                         if((*InX)[j]<=(*InX)[jj])
00346                         {
00347                                 if( (xinter>=(*InX)[j]) && (xinter<=(*InX)[jj]) )               //Intersection entre le cercle et le contour
00348                                 {
00349                                         dist = sqrt(pow(tempX[i]-xinter,2) + pow(tempY[i]-yinter,2));
00350                                         if(dist<min)
00351                                         {
00352                                                 min = dist;
00353                                                 xmin = xinter;
00354                                                 ymin = yinter;
00355                                         }
00356                                 }
00357                         }
00358                         if((*InX)[j]>(*InX)[jj])
00359                         {
00360                                 if( (xinter<=(*InX)[j]) && (xinter>=(*InX)[jj]) )               //Intersection entre le cercle et le contour
00361                                 {
00362                                         dist = sqrt(pow(tempX[i]-xinter,2) + pow(tempY[i]-yinter,2));
00363                                         if(dist<min)
00364                                         {
00365                                                 min = dist;
00366                                                 xmin = xinter;
00367                                                 ymin = yinter;
00368                                         }
00369                                 }
00370                         }
00371 JCP 26-09-2008*/
00372                 }
00373 
00374 
00375 
00376 //              fprintf(fd,"\n => x_int = %f, y_int = %f, dist_int = %f",xmin,ymin,min);
00377 //              fprintf(fexp,"\n%d      %f      %f      %f      %f      %f",i,min,xmin,ymin,tempX[i],tempY[i]);
00378 //JCP 26-09-08 If the distance of the intersection is bigger than the radio we have to invert the segment
00379                 if(min>=r)
00380                 {
00381                         interRad = true;
00382                         _interbewteencirclePos.push_back(i);
00383                         _interbewteencircleX.push_back(xmin);
00384                         _interbewteencircleY.push_back(ymin);
00385                         _interbewteencircleDist.push_back( sqrt(pow(cx-xmin,2)+pow(cy-ymin,2)) );
00386 
00387                         //      file1<<i<<std::endl;
00388                 }else{
00389 //JCP 26-09-08          if(min<r)
00390 //JCP 26-09-08          {
00391                         _intercircleX.push_back(xmin);
00392                         _intercircleY.push_back(ymin);
00393                         _intercircleDist.push_back(min);
00394                 //      file1<<"\t"<<i<<std::endl;
00395                 }
00396         }
00397         //file1.close();
00398 //      fclose(fd);
00399 //      fclose(fexp);
00400 
00401         //WHEN THERE IS RADIAL INTERSECTION
00402         vectorFunctions *vecf = new vectorFunctions();
00403 
00404 //EED 22 Sep 2008
00405 //      FILE *fdata;
00406 //      fdata = fopen("C:/bbtk_JS/data/autoCPdata.txt","w");
00407         if(interRad == true)
00408         {
00409                 std::vector<double> tempXX;
00410                 std::vector<double> tempYY;
00411                 std::vector<double> tempDD;
00412                 tempXX.clear();
00413                 tempYY.clear();
00414                 tempDD.clear();
00415 //Copy of the first points in the array until the first intersection is found           
00416                 for(i=0; i<_interbewteencirclePos[0]; i++)
00417                 {
00418                         tempXX.push_back(_intercircleX[i]);
00419                         tempYY.push_back(_intercircleY[i]);
00420                         tempDD.push_back(_intercircleDist[i]);
00421 //                      fprintf(fdata,"\n%f     %f      %f",_intercircleDist[i],_intercircleX[i],_intercircleY[i]);
00422                 }
00423                 int sizep = _interbewteencirclePos.size();
00424 //Copy all the points where there is an intersection with the center but inverted
00425 //JCP 26-09-08          for(i=_interbewteencirclePos[sizep-1],j=sizep-1; i>=_interbewteencirclePos[0]; i--,j--)
00426                 for(i=sizep-1; i >= 0;i--)
00427                 {
00428 //JCP 26-09-08                  tempXX.push_back(_interbewteencircleX[j]);
00429 //JCP 26-09-08                  tempYY.push_back(_interbewteencircleY[j]);
00430 //JCP 26-09-08                  tempDD.push_back(_interbewteencircleDist[j]);
00431                         tempXX.push_back(_interbewteencircleX[i]);
00432                         tempYY.push_back(_interbewteencircleY[i]);
00433                         tempDD.push_back(_interbewteencircleDist[i]);
00434 //                      fprintf(fdata,"\n%f     %f      %f",_interbewteencircleDist[j],_interbewteencircleX[j],_interbewteencircleY[j]);
00435                 }
00436                 for(i=_interbewteencirclePos[0]; i<(int)(_intercircleX.size()); i++)
00437                 {
00438                         tempXX.push_back(_intercircleX[i]);
00439                         tempYY.push_back(_intercircleY[i]);
00440                         tempDD.push_back(_intercircleDist[i]);
00441 //                      fprintf(fdata,"\n%f     %f      %f",_intercircleDist[i],_intercircleX[i],_intercircleY[i]);
00442                 }
00443                 
00444                 _intercircleX.clear();
00445                 _intercircleY.clear();
00446                 _intercircleDist.clear();
00447                 vecf->copyVector(&tempXX,&_intercircleX);
00448                 vecf->copyVector(&tempYY,&_intercircleY);
00449                 vecf->copyVector(&tempDD,&_intercircleDist);
00450         }       
00451 //      fclose(fdata);
00452 
00453         //DELETE!!
00454 
00455         std::ofstream file1;
00456     file1.open( "1_Intersection.txt" );
00457 
00458         for(int i = 0; i < (int)(_intercircleX.size()); i++){
00459                 file1<<"X= "<<_intercircleX[i] << "\tY= "<<_intercircleY[i] << "\tDist= "<<_intercircleDist[i]<<std::endl;
00460         }
00461         file1.close();
00462                 
00463 
00464         delete vecf;
00465 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::Intersection	(	double	x01,
		double	y01,
		double	x02,
		double	y02,
		double	mn,
		double	m2,
		double *	x,
		double *	y
	)

Definition at line 266 of file AutoControlPoints.cxx.

Referenced by InterBetweenContours(), InterBetweenControl(), and InterCircle().

00267 {
00268         *x = ( y02-y01-(m2*x02)+(mn*x01) )/(mn-m2);
00269         *y = m2*(*x-x02)+y02;
00270 }

Here is the caller graph for this function:

void AutoControlPoints::IntersectionPoints ( )

Definition at line 703 of file AutoControlPoints.cxx.

References _interpointsX, _interpointsY, _intervectorX, _intervectorY, Vector::get_var(), Vector::get_vec(), and min.

Referenced by GetInitialNewPoints(), GetNewPoints(), MoveAndAverage(), and MoveControlPointInContour().

00704 {
00705         if(_intervectorX.size() != 0)
00706         {               
00707                 _interpointsX.clear();
00708                 _interpointsY.clear();
00709 
00710 //EED
00711 //              FILE *fd;
00712 //              fd = fopen("C:/bbtk_JS/data/IntersectionPoints.txt","w");
00713                 double dist,min;
00714                 int i,j,posj;
00715 
00716                 posj = -1;
00717                 min = 9999;
00718 /*JCP 30-08-09 
00719                 for(j=0; j<_intervectorX[0].getsize_vec(); j++)
00720                 {
00721                         dist = sqrt( pow( _intervectorX[0].get_vec(j)-_intervectorX[0].get_var(),2 ) + pow( _intervectorY[0].get_vec(j)-_intervectorY[0].get_var(),2 ) );
00722                         if( dist < min )
00723                         {
00724                                 min = dist;
00725                                 posj = j;
00726                         }
00727                 }
00728                 if(posj != -1)
00729                 {
00730                         _interpointsX.push_back(_intervectorX[0].get_vec(posj));
00731                         _interpointsY.push_back(_intervectorY[0].get_vec(posj));
00732 //                      fprintf(fd,"\n Para X = %f, Y = %f",_intervectorX[0].get_var(),_intervectorY[0].get_var());
00733 //                      fprintf(fd,"\n => x_int = %f, y_int = %f",_interpointsX[0],_interpointsY[0]);
00734                 }
00735                 if(posj == -1)
00736                 {
00737                         printf("\n\n There is an invalid intersection: Must see AutoControlPoints::IntersectionPoints() method");
00738                 }
00739 JCP 30-08-09 */
00740                 for(i=0; i<(int)(_intervectorX.size()); i++){
00741                         min = 9999;
00742                         posj = -1;
00743                         for(j=0; j<_intervectorX[i].getsize_vec(); j++) {
00744                                 dist  = sqrt( pow( _intervectorX[i].get_vec(j)-_intervectorX[i].get_var(),2 ) + pow( _intervectorY[i].get_vec(j)-_intervectorX[i].get_var(),2 ) );
00745                                 if( dist < min ){
00746                                         min = dist;
00747                                         posj = j;
00748                                 }
00749                         }
00750                         _interpointsX.push_back(_intervectorX[i].get_vec(posj));
00751                         _interpointsY.push_back(_intervectorY[i].get_vec(posj));                
00752                 }
00753 /*JCP 30-09-08
00754                 for(i=1; i<_intervectorX.size(); i++)
00755                 {
00756                         min = 9999;
00757                         posj = -1;
00758 //                      fprintf(fd,"\n Para X = %f, Y = %f",_intervectorX[i].get_var(),_intervectorY[i].get_var());
00759                         for(j=0; j<_intervectorX[i].getsize_vec(); j++)
00760                         {
00761                                 //TYPE: LE PLUS PRES VOISIN
00762                                 dist  = sqrt( pow( _intervectorX[i].get_vec(j)-_interpointsX[i-1],2 ) + pow( _intervectorY[i].get_vec(j)-_interpointsY[i-1],2 ) );
00763                                 //TYPE: LE PLUS PRES DANS LA M�ME DROITE
00764                                 //dist = sqrt(pow(_intervectorX[i].get_vec(j)-_intervectorX[i].get_var(),2)+pow(_intervectorY[i].get_vec(j)-_intervectorY[i].get_var(),2));
00765                                 
00766                                 if( dist < min )
00767                                 {
00768                                         min = dist;
00769                                         posj = j;
00770                                 }
00771                         }
00772                         _interpointsX.push_back(_intervectorX[i].get_vec(posj));
00773                         _interpointsY.push_back(_intervectorY[i].get_vec(posj));
00774 //                      fprintf(fd,"\n => x_int = %f, y_int = %f",_interpointsX[i],_interpointsY[i]);
00775                 }
00776 JCP 30-09-08*/
00777 //              fclose(fd);
00778         }
00779 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::maxminLocal ( ) [private]

Definition at line 467 of file AutoControlPoints.cxx.

References _controlpointsX, _controlpointsY, _controlpointsZ, _intercircleDist, _intercircleX, _intercircleY, _maxlocalX, _maxlocalY, _minlocalX, _minlocalY, _minmaxlocalX, _minmaxlocalY, _posmaxlocal, _posminlocal, _posminmaxlocal, and vectorFunctions::copyVector().

Referenced by GetInitialNewPoints(), and GetNewPoints().

00468 {
00469         int i;
00470         _posmaxlocal.clear();
00471         _posminlocal.clear();
00472         _posminmaxlocal.clear();
00473         _maxlocalX.clear();
00474         _maxlocalY.clear();
00475         _minlocalX.clear();
00476         _minlocalY.clear();
00477         _minmaxlocalX.clear();
00478         _minmaxlocalY.clear();
00479         
00480         if(_intercircleDist.size() != 0)
00481         {
00482 //JCP 26 - 09 - 08 This change was du to the posibility of having a maximum or a minimum value in the limits of 
00483 //JCP 26 - 09 - 08 the array
00484                 double lastdist, currentdist, nextdist;
00485                 for(i=0; i < (int)(_intercircleDist.size()); i++)
00486                 {
00487                         //FOR MAXIMUM LOCAL
00488 //JCP 26-09-08
00489                         currentdist = _intercircleDist[i];
00490                         if(i == 0){
00491                                 lastdist = _intercircleDist[_intercircleDist.size()-1];
00492                                 nextdist = _intercircleDist[i+1];
00493                         }else if (i == (int)(_intercircleDist.size())-1){
00494                                 lastdist = _intercircleDist[i-1];
00495                                 nextdist = _intercircleDist[0];
00496                         }else{
00497                                 lastdist = _intercircleDist[i-1];                               
00498                                 nextdist = _intercircleDist[i+1];
00499                         }
00500                         
00501 
00502 //JCP 26-09-08                  if( (_intercircleDist[i-1]<_intercircleDist[i]) && (_intercircleDist[i]>_intercircleDist[i+1]))
00503                         if(lastdist < currentdist && currentdist > nextdist)
00504                         {
00505                                 _posmaxlocal.push_back(i);
00506                                 _maxlocalX.push_back(_intercircleX[i]);
00507                                 _maxlocalY.push_back(_intercircleY[i]);
00508                                 _minmaxlocalX.push_back(_intercircleX[i]);
00509                                 _minmaxlocalY.push_back(_intercircleY[i]);
00510                                 _posminmaxlocal.push_back(i);
00511                         }
00512                         //FOR MINIMUM LOCAL
00513 //JCP 26-09-08                  if( (_intercircleDist[i-1]>_intercircleDist[i]) && (_intercircleDist[i]<_intercircleDist[i+1]))
00514                         if(lastdist > currentdist && currentdist < nextdist)
00515                         {
00516                                 _posminlocal.push_back(i);
00517                                 _minlocalX.push_back(_intercircleX[i]);
00518                                 _minlocalY.push_back(_intercircleY[i]);
00519                                 _minmaxlocalX.push_back(_intercircleX[i]);
00520                                 _minmaxlocalY.push_back(_intercircleY[i]);
00521                                 _posminmaxlocal.push_back(i);
00522                         }
00523                 }
00524         }
00525 
00526         vectorFunctions *vecf   = new vectorFunctions();
00527         std::vector<double> tempZ;
00528         tempZ.clear();
00529         
00530         vecf->copyVector(&_minlocalX,&_controlpointsX); 
00531         vecf->copyVector(&_minlocalY,&_controlpointsY);
00532         for(i=0; i<(int)(_minlocalX.size()); i++)
00533         {
00534                 tempZ.push_back(_controlpointsZ[0]);
00535         }
00536         vecf->copyVector(&tempZ,&_controlpointsZ);
00537 
00538 //JCP 26-09-08  
00539         std::ofstream file1;
00540     file1.open( "2_MaxMin.txt" );
00541 
00542         for(int i = 0; i < (int)(_controlpointsX.size()); i++){
00543                 file1<<"X= "<<_controlpointsX[i] << "\tY= "<<_controlpointsY[i] << "\tZ= "<<_controlpointsZ[i]<<std::endl;
00544         }
00545         file1.close();
00546 //JCP 26-09-08
00547         delete vecf;
00548 }

Here is the call graph for this function:

Here is the caller graph for this function:

double AutoControlPoints::MoveAndAverage	(	int	dir,
		std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ
	)			`[private]`

Definition at line 1397 of file AutoControlPoints.cxx.

References _contIncontpos, _controlpointsX, _controlpointsY, _errorvector, vectorFunctions::copyVector(), ErrorBetweenContours(), fixBetweenPoints(), IntersectionPoints(), PossibleIntersections(), and vectorFunctions::promVector().

Referenced by MoveControlPoints().

01398 {
01399         /*
01400 //PRINTF---------------------------------------------------------------
01401         int i;
01402         printf("\n CONTROL POINTS BEFORE MOVEMENT");
01403         for(i=0; i<_controlpointsX.size(); i++)
01404         {
01405                 printf("\n X = %f, Y = %f",_controlpointsX[i],_controlpointsY[i]);
01406         }
01407         for(i=0; i<_contIncontpos.size(); i++)
01408         {
01409                 printf("\n contIncont pos = %d",_contIncontpos[i]);
01410         }
01411 */
01412 //IMPLEMENTATION-------------------------------------------------------
01413         if( (_contIncontpos.size() != 0) && (_controlpointsX.size() != 0) )
01414         {
01415                 vectorFunctions *vf = new vectorFunctions();
01416                 std::vector<double>::iterator itx;
01417                 std::vector<double>::iterator ity;
01418                 std::vector<double> tempX;
01419                 std::vector<double> tempY;
01420                 tempX.clear();
01421                 tempY.clear();
01422                 vf->copyVector(&_controlpointsX,&tempX);
01423                 vf->copyVector(&_controlpointsY,&tempY);
01424                 int i,j /*,pos = 0*/ ;  // JPRx
01425                 double prom1=0,promactual1=1;
01426                 //double prom2=0,promactual2=1; // JPRx
01427                 int h = 0;
01428                 int hh = 1;
01429                 if(_contIncontpos[h]>_contIncontpos[hh])
01430                 {
01431                         itx = _controlpointsX.begin();
01432                         ity = _controlpointsY.begin();
01433                         for(i=_contIncontpos[h],j=_contIncontpos[h]; (i>_contIncontpos[hh]) && (promactual1>prom1); i--)
01434                         {
01435                                 if(j == (int)(InX->size()))
01436                                 {
01437                                         j = 0;
01438                                 }
01439                                 prom1 = promactual1;
01440                                 *itx = (*InX)[j];
01441                                 *ity = (*InY)[j];
01442                                 printf("\n itx = %f, ity = %f", *itx,*ity);
01443                                 fixBetweenPoints(5.0);
01444                                 PossibleIntersections(InX,InY,InZ);
01445                                 IntersectionPoints();
01446                                 ErrorBetweenContours();
01447                                 promactual1 = vf->promVector(&_errorvector,false);
01448                                 j++;
01449                         }
01450                 }
01451                 if(_contIncontpos[h]<_contIncontpos[hh])
01452                 {
01453                         itx = _controlpointsX.begin();
01454                         ity = _controlpointsY.begin();
01455                         for(i=_contIncontpos[h],j=_contIncontpos[h]; (i<_contIncontpos[hh]) && (promactual1>prom1); i++)
01456                         {
01457                                 if(j == -1)
01458                                 {
01459                                         j = InX->size()-1;
01460                                 }
01461                                 prom1 = promactual1;
01462                                 *itx = (*InX)[j];
01463                                 *ity = (*InY)[j];
01464                                 printf("\n itx = %f, ity = %f", *itx,*ity);
01465                                 fixBetweenPoints(5.0);
01466                                 PossibleIntersections(InX,InY,InZ);
01467                                 IntersectionPoints();
01468                                 ErrorBetweenContours();
01469                                 promactual1 = vf->promVector(&_errorvector,false);
01470                                 j--;
01471                         }
01472                 }
01473                 delete vf;
01474         }
01475         return 99999;
01476 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::MoveControlPointInContour	(	std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ
	)			`[private]`

Definition at line 1287 of file AutoControlPoints.cxx.

References _contIncontpos, _controlpointsX, _controlpointsY, _controlpointsZ, _errorvector, _posn, vectorFunctions::copyVector(), ErrorBetweenContours(), fixBetweenPoints(), IntersectionPoints(), PossibleIntersections(), and vectorFunctions::promVector().

01288 {
01289 int i;
01290 /*
01291 //PRINTF---------------------------------------------------------------
01292 printf("\n CONTROL POINTS BEFORE MOVEMENT");
01293 for(i=0; i<_controlpointsX.size(); i++)
01294 {
01295         printf("\n X = %f, Y = %f",_controlpointsX[i],_controlpointsY[i]);
01296 }
01297 //---------------------------------------------------------------------
01298 */
01299         vectorFunctions *vf = new vectorFunctions();
01300         fixBetweenPoints(5.0);
01301         PossibleIntersections(InX,InY,InZ);
01302         IntersectionPoints();
01303         ErrorBetweenContours();
01304         //double promIn = vf->promVector(&_errorvector,false); // JPRx
01305 
01306         std::vector<double> tempX;
01307         std::vector<double> tempY;
01308         std::vector<double> tempZ;
01309         tempX.clear();
01310         tempY.clear();
01311         tempZ.clear();
01312         
01313         vf->copyVector(&_controlpointsX,&tempX);
01314         vf->copyVector(&_controlpointsY,&tempY);
01315         vf->copyVector(&_controlpointsZ,&tempZ);
01316         _controlpointsX.clear();
01317         _controlpointsY.clear();
01318         _controlpointsZ.clear();
01319 
01320         for(i=0; i<(int)(tempX.size()); i++)
01321         {
01322                 if(i==_posn)
01323                 {
01324                         _controlpointsX.push_back( (*InX)[_contIncontpos[_posn]] );
01325                         _controlpointsY.push_back( (*InY)[_contIncontpos[_posn]] );
01326                         _controlpointsZ.push_back( (*InZ)[_contIncontpos[_posn]] );
01327                 }
01328                 else
01329                 {
01330                         _controlpointsX.push_back( tempX[i] );
01331                         _controlpointsY.push_back( tempY[i] );
01332                         _controlpointsZ.push_back( tempZ[i] );
01333                 }
01334         }
01335 
01336         fixBetweenPoints(5.0);
01337         PossibleIntersections(InX,InY,InZ);
01338         IntersectionPoints();
01339         ErrorBetweenContours();
01340         double promactualIn = vf->promVector(&_errorvector,false);
01341         double prom;
01342         double promactual;
01343         
01344         int posact;
01345         //int pos1; // JPRx
01346         //double prom1final; // JPRx
01347         int pos2;
01348         double prom2final;
01349 
01350         //DIRECTION 1
01351         int direction = 1;
01352         posact = _posn;
01353         prom = -1;
01354         promactual = promactualIn;
01355         _controlpointsX.clear();
01356         _controlpointsY.clear();
01357         _controlpointsZ.clear();
01358         for(i=0; promactual > prom; i++)
01359         {
01360                 prom = promactual;
01361                 for(i=0; i<(int)(tempX.size()); i++)
01362                 {
01363                         if(i==_posn)
01364                         {
01365                                 _controlpointsX.push_back( (*InX)[_contIncontpos[posact]] );
01366                                 _controlpointsY.push_back( (*InY)[_contIncontpos[posact]] );
01367                                 _controlpointsZ.push_back( (*InZ)[_contIncontpos[posact]] );
01368                         }
01369                         else
01370                         {
01371                                 _controlpointsX.push_back( tempX[i] );
01372                                 _controlpointsY.push_back( tempY[i] );
01373                                 _controlpointsZ.push_back( tempZ[i] );
01374                         }
01375                 }
01376                 if(direction == 1)
01377                 {
01378                         posact = posact+1;
01379                 }
01380                 if(direction == -1)
01381                 {
01382                         posact = posact-1;
01383                 }
01384                 fixBetweenPoints(5.0);
01385                 PossibleIntersections(InX,InY,InZ);
01386                 IntersectionPoints();
01387                 ErrorBetweenContours();
01388                 promactual = vf->promVector(&_errorvector,false);
01389 //printf("\n The point in the position %d, has moved %d times",_posn,i);
01390         }
01391         pos2 = posact;
01392         prom2final = promactual;
01393 
01394         delete vf;
01395 }

Here is the call graph for this function:

void AutoControlPoints::MoveControlPoints	(	std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ
	)			`[private]`

Definition at line 1478 of file AutoControlPoints.cxx.

References ControlInContour(), MoveAndAverage(), and NearMaxError2Control().

01479 {
01480         ControlInContour(InX,InY,InZ);
01481         NearMaxError2Control();
01482         MoveAndAverage(1,InX,InY,InZ);
01483 }

Here is the call graph for this function:

void AutoControlPoints::NearMaxError2Control ( ) [private]

Definition at line 1264 of file AutoControlPoints.cxx.

References _controlpointsX, _controlpointsY, _errorpos, _interpointsX, _interpointsY, _posA, _posB, _posn, and AddControlPoint().

Referenced by MoveControlPoints().

01265 {
01266         if(_interpointsX.size() != 0)
01267         {
01268                 AddControlPoint(false);
01269 
01270                 double distA = sqrt( pow(_interpointsX[_errorpos]-_controlpointsX[_posA],2) + pow(_interpointsY[_errorpos]-_controlpointsY[_posA],2) );
01271                 double distB = sqrt( pow(_interpointsX[_errorpos]-_controlpointsX[_posB],2) + pow(_interpointsY[_errorpos]-_controlpointsY[_posB],2) );
01272                 double nearp = -1;
01273                 if(distA<distB)
01274                 {
01275                         nearp = distA;
01276                         _posn = _posA;
01277 
01278                 }
01279                 else
01280                 {
01281                         nearp = distB;
01282                         _posn = _posB;
01283                 }
01284         }
01285 }

Here is the call graph for this function:

Here is the caller graph for this function:

double AutoControlPoints::Normal	(	double	x0,
		double	y0,
		double *	m,
		double	xi
	)			`[private]`

Definition at line 258 of file AutoControlPoints.cxx.

Referenced by InterBetweenContours(), and InterBetweenControl().

00259 {
00260         double y;
00261         *m = -(1/(*m));
00262         y = ((*m)*(xi - x0)) + y0;
00263         return y;
00264 }

Here is the caller graph for this function:

void AutoControlPoints::PointHigh	(	std::vector< double > *	IndX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ,
		double *	hix,
		double *	hiy,
		double *	hiz
	)

Definition at line 72 of file AutoControlPoints.cxx.

Referenced by CircleCenter(), and TwoPoints().

00074 {
00075         double HighY=-1;
00076         int pos = 0;
00077         int size = InX->size();
00078         if(size > 0){
00079                 HighY = (*InY)[0];
00080                 for(int i = 1; i < size; i++){
00081                         if((*InY)[i] < HighY){
00082                                 HighY = (*InY)[i];
00083                                 pos = i;
00084                         }
00085                 }
00086                 *hix = (*InX)[pos];
00087                 *hiy = (*InY)[pos];
00088                 *hiz = (*InZ)[pos];
00089         }
00090         
00091 /*JCP 29-09-08
00092         int size = GetSizeVector(InX);
00093         if(size != -1)
00094         {
00095                 for(int i=0; i< _SizeVectorIn; i++)
00096                 {
00097                         if(  (*InY)[i] < HighY  )
00098                         {
00099                                 HighY = (*InY)[i];
00100                                 pos = i;
00101                         }
00102                 }
00103                 *hix = (*InX)[pos];
00104                 *hiy = (*InY)[pos];
00105                 *hiz = (*InZ)[pos];
00106         }
00107 JCP 29-09-08*/
00108         
00109 }

Here is the caller graph for this function:

void AutoControlPoints::PointLeft	(	std::vector< double > *	IndX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ,
		double *	lex,
		double *	ley,
		double *	lez
	)

Definition at line 28 of file AutoControlPoints.cxx.

References GetSizeVector().

Referenced by CircleCenter(), and TwoPoints().

00030 {
00031         double LeftX = 1000;
00032         int pos = 0;
00033         int size = GetSizeVector(InX);
00034         if(size != -1)
00035         {
00036                 for(int i=0; i< size; i++)
00037                 {
00038                         if(  (*InX)[i] < LeftX  )
00039                         {
00040                                 LeftX = (*InX)[i];
00041                                 pos = i;
00042                         }
00043                 }
00044                 *lex = (*InX)[pos];
00045                 *ley = (*InY)[pos];
00046                 *lez = (*InZ)[pos];
00047         }
00048 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::PointLow	(	std::vector< double > *	IndX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ,
		double *	lox,
		double *	loy,
		double *	loz
	)

Definition at line 112 of file AutoControlPoints.cxx.

References _SizeVectorIn, and GetSizeVector().

Referenced by CircleCenter(), and TwoPoints().

00114 {
00115         double LowY = 0;
00116         int pos = 0;
00117         int size = GetSizeVector(InX);
00118         if(size != 0)
00119         {
00120                 for(int i=0; i< _SizeVectorIn; i++)
00121                 {
00122                         if(  (*InY)[i] > LowY  )
00123                         {
00124                                 LowY = (*InY)[i];
00125                                 pos = i;
00126                         }
00127                 } 
00128                 *lox = (*InX)[pos];
00129                 *loy = (*InY)[pos];
00130                 *loz = (*InZ)[pos];
00131         }
00132 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::PointRight	(	std::vector< double > *	IndX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ,
		double *	rix,
		double *	riy,
		double *	riz
	)

Definition at line 50 of file AutoControlPoints.cxx.

References GetSizeVector().

Referenced by CircleCenter(), and TwoPoints().

00052 {
00053           double RightX = 0;
00054           int pos = 0;
00055           int size = GetSizeVector(InX);
00056           if(size != -1)
00057           {
00058                 for(int i=0; i< size; i++)
00059                 {
00060                   if(  (*InX)[i] > RightX  )
00061                   {
00062                           RightX = (*InX)[i];
00063                           pos = i;      
00064                   }
00065                 }
00066                 *rix = (*InX)[pos];
00067                 *riy = (*InY)[pos];
00068                 *riz = (*InZ)[pos];
00069           }
00070 }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutoControlPoints::PossibleIntersections	(	std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ
	)			`[private]`

Definition at line 1055 of file AutoControlPoints.cxx.

References _intervectorX, _intervectorY, Vector::get_var(), Vector::get_vec(), Vector::getsize_vec(), and InterBetweenContours().

Referenced by GetInitialNewPoints(), GetNewPoints(), MoveAndAverage(), and MoveControlPointInContour().

01056 {
01057         InterBetweenContours(InX,InY,InZ);      //_intervectorX
01058         //InterBetweenControl();                                //_intervecXX
01059         //fixBetweenControl();                          //_interitselfX
01060         
01061         std::vector<Vector> tempX;
01062         std::vector<Vector> tempY;
01063         tempX.clear();
01064         tempY.clear();
01065         int i,j,k;
01066         //double dist1,dist2; // JPRx
01067 //EED 22 Sep 2008
01068 //      FILE *fd;
01069 /*
01070         bool ready;
01071         fd = fopen("C:/bbtk_JS/data/InterPossibleIntersections.txt","w");
01072 
01073 
01074         for(i=0; i<_intervectorX.size(); i++)
01075         {
01076                 fprintf(fd,"\n Para X = %f, Y = %f",_intervectorX[i].get_var(),_intervectorY[i].get_var());
01077                 Vector *vx = new Vector();
01078                 Vector *vy = new Vector();
01079                 vx->set_var(_intervectorX[i].get_var());
01080                 vy->set_var(_intervectorY[i].get_var());
01081                 ready = false;
01082                 for(j=0; j<_intervectorX[i].getsize_vec() ; j++)
01083                 {
01084                         dist1 = sqrt( pow(_intervectorX[i].get_var()-_intervectorX[i].get_vec(j),2) + pow(_intervectorY[i].get_var()-_intervectorY[i].get_vec(j),2) );
01085                         for(k=0; (k<_interitselfX[i].getsize_vec()) && (ready!=true); k++)
01086                         {
01087                                 dist2 = sqrt( pow(_interitselfX[i].get_var()-_interitselfX[i].get_vec(k),2) + pow(_interitselfY[i].get_var()-_interitselfY[i].get_vec(k),2) );
01088                                 if(dist2>dist1)
01089                                 {
01090                                         fprintf(fd,"\n => x_int = %f, y_int = %f",_intervectorX[i].get_vec(j),_intervectorY[i].get_vec(j));
01091                                         vx->set_vec(_intervectorX[i].get_vec(j));
01092                                         vy->set_vec(_intervectorY[i].get_vec(j));
01093                                         ready == true;
01094                                 }
01095                         }
01096                 }
01097                 tempX.push_back(*vx);
01098                 tempY.push_back(*vy);
01099                 delete vx;
01100                 delete vy;
01101         }
01102         fclose(fd);
01103         
01104         _intervectorX.clear();
01105         _intervectorY.clear();
01106         Vector *vv = new Vector();
01107         vv->copyVector(&tempX,&_intervectorX);
01108         vv->copyVector(&tempY,&_intervectorY);
01109         
01110         //vv->printVector(&_intervectorX);
01111 */
01112         std::vector<double> arrX; 
01113         std::vector<double> arrY;
01114         std::vector<double>::iterator itx;
01115         std::vector<double>::iterator ity;
01116         std::vector<double>::iterator itxx;
01117         std::vector<double>::iterator ityy;
01118         double distA, distB;
01119         if(_intervectorX.size() != 0)
01120         {
01121 //              fd = fopen("C:/bbtk_JS/data/InterPossibleIntersections.txt","w");
01122                 for(i=0; i<(int)(_intervectorX.size()); i++)
01123                 {
01124 //                      fprintf(fd,"\n Para X = %f, Y = %f",_intervectorX[i].get_var(),_intervectorY[i].get_var());
01125                         if(_intervectorX[i].getsize_vec() > 1)
01126                         {
01127                                 arrX.clear();
01128                                 arrY.clear();
01129                                 for(j=0; j<_intervectorX[i].getsize_vec(); j++)
01130                                 {
01131                                         arrX.push_back(_intervectorX[i].get_vec(j));
01132                                         arrY.push_back(_intervectorY[i].get_vec(j));
01133                                 }
01134 //printf("\n arrX Size = %d",arrX.size());
01135                                 itx = arrX.begin();
01136                                 ity = arrY.begin();
01137                                 itxx = arrX.begin()+1;
01138                                 ityy = arrY.begin()+1;
01139                                 for(j=0; j<(int)(arrX.size())-1; j++)
01140                                 {
01141                                         // I
01142                                         if( (*itx > _intervectorX[i].get_var())  && (*ity < _intervectorY[i].get_var()) && 
01143                                                 (*itxx > _intervectorX[i].get_var()) && (*ityy < _intervectorY[i].get_var()) )
01144                                         {
01145                                                 distA = sqrt( pow(*itx-_intervectorX[i].get_var(),2) + pow(*ity-_intervectorY[i].get_var(),2) );
01146                                                 distB = sqrt( pow(*itxx-_intervectorX[i].get_var(),2) + pow(*ityy-_intervectorY[i].get_var(),2) );
01147                                                 if(distA<distB)
01148                                                 {
01149                                                         arrX.erase(itxx);
01150                                                         arrY.erase(ityy);
01151                                                 }
01152                                                         if(distA>distB)
01153                                                 {
01154                                                         arrX.erase(itx);
01155                                                         arrY.erase(ity);
01156                                                         itxx++;
01157                                                         ityy++;
01158                                                 }       
01159                                         }
01160                                         // II
01161                                         else if( (*itx < _intervectorX[i].get_var())  && (*ity < _intervectorY[i].get_var()) && 
01162                                                 (*itxx < _intervectorX[i].get_var()) && (*ityy < _intervectorY[i].get_var()) )
01163                                         {
01164                                                 distA = sqrt( pow(*itx-_intervectorX[i].get_var(),2) + pow(*ity-_intervectorY[i].get_var(),2) );
01165                                                 distB = sqrt( pow(*itxx-_intervectorX[i].get_var(),2) + pow(*ityy-_intervectorY[i].get_var(),2) );
01166                                                 if(distA<distB)
01167                                                 {
01168                                                         arrX.erase(itxx);
01169                                                         arrY.erase(ityy);
01170                                                 }
01171                                                 if(distA>distB)
01172                                                 {
01173                                                         arrX.erase(itx);
01174                                                         arrY.erase(ity);
01175                                                         itxx++;
01176                                                         ityy++;
01177                                                 }       
01178                                         }
01179                                         // III
01180                                         else if( (*itx < _intervectorX[i].get_var())  && (*ity > _intervectorY[i].get_var()) && 
01181                                                 (*itxx < _intervectorX[i].get_var()) && (*ityy > _intervectorY[i].get_var()) )
01182                                         {
01183                                                 distA = sqrt( pow(*itx-_intervectorX[i].get_var(),2) + pow(*ity-_intervectorY[i].get_var(),2) );
01184                                                 distB = sqrt( pow(*itxx-_intervectorX[i].get_var(),2) + pow(*ityy-_intervectorY[i].get_var(),2) );
01185                                                 if(distA<distB)
01186                                                 {
01187                                                         arrX.erase(itxx);
01188                                                         arrY.erase(ityy);
01189                                                 }
01190                                                 if(distA>distB)
01191                                                 {
01192                                                         arrX.erase(itx);
01193                                                         arrY.erase(ity);
01194                                                         itxx++;
01195                                                         ityy++;
01196                                                 }       
01197                                         }
01198                                         // IV
01199                                         else if( ((double)*itx > _intervectorX[i].get_var())  && (*ity > _intervectorY[i].get_var()) && 
01200                                                 ((double)*itxx > _intervectorX[i].get_var()) && (*ityy > _intervectorY[i].get_var()) )
01201                                         {
01202                                                 distA = sqrt( pow(*itx-_intervectorX[i].get_var(),2) + pow(*ity-_intervectorY[i].get_var(),2) );
01203                                                 distB = sqrt( pow(*itxx-_intervectorX[i].get_var(),2) + pow(*ityy-_intervectorY[i].get_var(),2) );
01204                                                 if(distA<distB)
01205                                                 {
01206                                                         arrX.erase(itxx);
01207                                                         arrY.erase(ityy);
01208                                                 }
01209                                                 if(distA>distB)
01210                                                 {
01211                                                         arrX.erase(itx);
01212                                                         arrY.erase(ity);
01213                                                         itxx++;
01214                                                         ityy++;
01215                                                 }       
01216                                         }
01217                                         else
01218                                         {
01219                                                 itx++;
01220                                                 ity++;
01221                                                 itxx++;
01222                                                 ityy++;
01223                                         }
01224                                 }
01225                                 _intervectorX[i].resetVec();
01226                                 _intervectorY[i].resetVec();
01227 //printf("\n _intervector(%d) Size = %d",i,_intervectorX[i].getsize_vec());
01228                                 for(k=0; k<(int)(arrX.size()); k++)
01229                                 {
01230 //printf("\n arr(%d) X = %f, Y = %f",k,arrX[k],arrY[k]);
01231 //                                      fprintf(fd,"\n => x_int = %f, y_int = %f",arrX[k],arrY[k]);
01232                                         _intervectorX[i].set_vec(arrX[k]);
01233                                         _intervectorY[i].set_vec(arrY[k]);
01234                                 }
01235                         }
01236                 }
01237         }
01238 
01239         //DELETE!!
01240 //      delete vv;
01241 
01242 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Vector::printVector ( std::vector< Vector > * vec1 ) [inherited]

Definition at line 71 of file Propagation.cxx.

References Vector::get_var(), and Vector::get_vec().

00072 {
00073         int i,j;
00074         for(i=0; i<(int)(vec1->size()); i++)
00075         {
00076                 printf("\n Pos (%d) => var = %f",i,(*vec1)[i].get_var());
00077                 for(j=0; j<(*vec1)[i].getsize_vec(); j++)
00078                 {
00079                         printf("\n vec(%d) = %f",j,(*vec1)[i].get_vec(j));
00080                 }
00081         }
00082 }

Here is the call graph for this function:

void Vector::resetVec ( ) [inherited]

Definition at line 170 of file Propagation.cxx.

References Vector::_vec.

00171 {
00172         _vec.clear();
00173 }

void Vector::set_plane ( int val ) [inherited]

Definition at line 84 of file Propagation.cxx.

References Vector::_plane.

Referenced by PropContour::GetPropagatedContours().

00085 {
00086         _plane = val;
00087 }

Here is the caller graph for this function:

void Vector::set_var ( double val ) [inherited]

Definition at line 27 of file Propagation.cxx.

References Vector::_var.

Referenced by Vector::copyVector(), fixBetweenControl(), GetIntersectionPoints(), InterBetweenContours(), and InterBetweenControl().

00028 {
00029         _var = val;
00030 }

Here is the caller graph for this function:

void Vector::set_vec ( double val ) [inherited]

Definition at line 22 of file Propagation.cxx.

References Vector::_vec.

Referenced by Vector::copyVector(), fixBetweenControl(), GetIntersectionPoints(), InterBetweenContours(), and InterBetweenControl().

00023 {
00024         _vec.push_back(val);
00025 }

Here is the caller graph for this function:

void Vector::set_x ( double val ) [inherited]

Definition at line 89 of file Propagation.cxx.

References Vector::_vecX.

Referenced by PropContour::GetPropagatedContours().

00090 {
00091         _vecX.push_back(val);
00092 }

Here is the caller graph for this function:

void Vector::set_y ( double val ) [inherited]

Definition at line 95 of file Propagation.cxx.

References Vector::_vecY.

Referenced by PropContour::GetPropagatedContours().

00096 {
00097         _vecY.push_back(val);
00098 }

Here is the caller graph for this function:

void Vector::set_z ( double val ) [inherited]

Definition at line 101 of file Propagation.cxx.

References Vector::_vecZ.

Referenced by PropContour::GetPropagatedContours().

00102 {
00103         _vecZ.push_back(val);
00104 }

Here is the caller graph for this function:

void AutoControlPoints::SetNumSplineInterpolation ( int num )

Definition at line 1717 of file AutoControlPoints.cxx.

References _numspline.

Referenced by ExtractControlPoints2D::GetControlPoints(), and ExtractControlPoints2D::GetInitialControlPoints().

01718 {
01719         _numspline = num;
01720 }

Here is the caller graph for this function:

double AutoControlPoints::Slope	(	double	x0,
		double	y0,
		double	x1,
		double	y1
	)			`[private]`

Definition at line 251 of file AutoControlPoints.cxx.

Referenced by InterBetweenContours(), InterBetweenControl(), and InterCircle().

00252 {
00253         double m = (y1-y0)/(x1-x0);
00254         return m;
00255 }

Here is the caller graph for this function:

void AutoControlPoints::TwoPoints	(	std::vector< double > *	InX,
		std::vector< double > *	InY,
		std::vector< double > *	InZ
	)

Definition at line 134 of file AutoControlPoints.cxx.

References _controlpointsX, _controlpointsY, _controlpointsZ, PointHigh(), PointLeft(), PointLow(), and PointRight().

00135 {
00136         double hiX=0,hiY=0,hiZ=0;
00137         PointHigh ( InX,InY,InZ,&hiX,&hiY,&hiZ );
00138         
00139         double leX=0,leY=0,leZ=0;
00140         PointLeft ( InX,InY,InZ,&leX,&leY,&leZ );
00141         
00142         double loX=0,loY=0,loZ=0;
00143         PointLow  ( InX,InY,InZ,&loX,&loY,&loZ );
00144 
00145         double riX=0,riY=0,riZ=0;
00146         PointRight( InX,InY,InZ,&riX,&riY,&riZ );
00147 
00148         double distHiLo = sqrt( pow(hiX-loX,2) + pow(hiY-loY,2) );
00149         double distRiLe = sqrt( pow(riX-leX,2) + pow(riY-leY,2) );
00150                 
00151         _controlpointsX.clear();
00152         _controlpointsY.clear();
00153         _controlpointsZ.clear();
00154         if(distHiLo >= distRiLe)
00155         {
00156                 _controlpointsX.push_back(hiX);
00157                 _controlpointsY.push_back(hiY);
00158                 _controlpointsZ.push_back(hiZ);
00159                         
00160                 _controlpointsX.push_back(loX);
00161                 _controlpointsY.push_back(loY);
00162                 _controlpointsZ.push_back(loZ);
00163         }
00164         else
00165         {
00166                 _controlpointsX.push_back(riX);
00167                 _controlpointsY.push_back(riY);
00168                 _controlpointsZ.push_back(riZ);
00169 
00170                 _controlpointsX.push_back(leX);
00171                 _controlpointsY.push_back(leY);
00172                 _controlpointsZ.push_back(leZ);
00173         }
00174 }

Here is the call graph for this function:

Member Data Documentation

std::vector<double> AutoControlPoints::_chargecontrolpointsX [private]

Definition at line 68 of file AutoControlPoints.h.

Referenced by ChargeSpline(), InterBetweenContours(), and InterBetweenControl().

std::vector<double> AutoControlPoints::_chargecontrolpointsY [private]

Definition at line 69 of file AutoControlPoints.h.

Referenced by ChargeSpline(), InterBetweenContours(), and InterBetweenControl().

std::vector<double> AutoControlPoints::_chargecontrolpointsZ [private]

Definition at line 70 of file AutoControlPoints.h.

Referenced by ChargeSpline().

std::vector<double> AutoControlPoints::_circleX [private]

Definition at line 72 of file AutoControlPoints.h.

Referenced by InterCircle().

std::vector<double> AutoControlPoints::_circleY [private]

Definition at line 73 of file AutoControlPoints.h.

Referenced by InterCircle().

std::vector<int> AutoControlPoints::_contIncontpos [private]

Definition at line 108 of file AutoControlPoints.h.

Referenced by ControlInContour(), MoveAndAverage(), and MoveControlPointInContour().

std::vector<double> AutoControlPoints::_controlpointsX [private]

Definition at line 60 of file AutoControlPoints.h.

Referenced by AddControlPoint(), CalculeControlPoints(), CalculeInitialControlPoints(), ChargeSpline(), ControlInContour(), fixBetweenPoints(), GetControlPoints(), GetInitialControlPoints(), GetInitialNewPoints(), GetNewPoints(), maxminLocal(), MoveAndAverage(), MoveControlPointInContour(), NearMaxError2Control(), and TwoPoints().

std::vector<double> AutoControlPoints::_controlpointsY [private]

Definition at line 61 of file AutoControlPoints.h.

Referenced by AddControlPoint(), CalculeControlPoints(), CalculeInitialControlPoints(), ChargeSpline(), ControlInContour(), fixBetweenPoints(), GetControlPoints(), GetInitialControlPoints(), GetInitialNewPoints(), GetNewPoints(), maxminLocal(), MoveAndAverage(), MoveControlPointInContour(), NearMaxError2Control(), and TwoPoints().

std::vector<double> AutoControlPoints::_controlpointsZ [private]

Definition at line 62 of file AutoControlPoints.h.

Referenced by AddControlPoint(), CalculeControlPoints(), CalculeInitialControlPoints(), ChargeSpline(), fixBetweenPoints(), GetControlPoints(), GetInitialControlPoints(), GetInitialNewPoints(), GetIntersectionPoints(), GetNewPoints(), maxminLocal(), MoveControlPointInContour(), and TwoPoints().

double AutoControlPoints::_errorpos [private]

Definition at line 99 of file AutoControlPoints.h.

Referenced by AddControlPoint(), ErrorBetweenContours(), and NearMaxError2Control().

std::vector<double> AutoControlPoints::_errorvector [private]

Definition at line 100 of file AutoControlPoints.h.

Referenced by AddControlPoint(), ErrorBetweenContours(), GetErrorBetweenContours(), GetInitialNewPoints(), GetNewPoints(), MoveAndAverage(), and MoveControlPointInContour().

std::vector<double> AutoControlPoints::_interbewteencircleDist [private]

Definition at line 79 of file AutoControlPoints.h.

Referenced by InterCircle().

std::vector<int> AutoControlPoints::_interbewteencirclePos [private]

Definition at line 80 of file AutoControlPoints.h.

Referenced by InterCircle().

std::vector<double> AutoControlPoints::_interbewteencircleX [private]

Definition at line 77 of file AutoControlPoints.h.

Referenced by InterCircle().

std::vector<double> AutoControlPoints::_interbewteencircleY [private]

Definition at line 78 of file AutoControlPoints.h.

Referenced by InterCircle().

std::vector<double> AutoControlPoints::_intercircleDist [private]

Definition at line 76 of file AutoControlPoints.h.

Referenced by InterCircle(), and maxminLocal().

std::vector<double> AutoControlPoints::_intercircleX [private]

Definition at line 74 of file AutoControlPoints.h.

Referenced by InterCircle(), and maxminLocal().

std::vector<double> AutoControlPoints::_intercircleY [private]

Definition at line 75 of file AutoControlPoints.h.

Referenced by InterCircle(), and maxminLocal().

std::vector<Vector> AutoControlPoints::_interitselfX [private]

Definition at line 104 of file AutoControlPoints.h.

Referenced by fixBetweenControl().

std::vector<Vector> AutoControlPoints::_interitselfY [private]

Definition at line 105 of file AutoControlPoints.h.

Referenced by fixBetweenControl().

std::vector<double> AutoControlPoints::_interpointsX [private]

Definition at line 94 of file AutoControlPoints.h.

Referenced by AddControlPoint(), ErrorBetweenContours(), GetIntersectionPoints(), IntersectionPoints(), and NearMaxError2Control().

std::vector<double> AutoControlPoints::_interpointsY [private]

Definition at line 95 of file AutoControlPoints.h.

Referenced by AddControlPoint(), ErrorBetweenContours(), GetIntersectionPoints(), IntersectionPoints(), and NearMaxError2Control().

std::vector<Vector> AutoControlPoints::_intervectorX [private]

Definition at line 92 of file AutoControlPoints.h.

Referenced by AddControlPoint(), ErrorBetweenContours(), GetInterBetweenContours(), InterBetweenContours(), IntersectionPoints(), and PossibleIntersections().

std::vector<Vector> AutoControlPoints::_intervectorY [private]

Definition at line 93 of file AutoControlPoints.h.

Referenced by AddControlPoint(), ErrorBetweenContours(), GetInterBetweenContours(), InterBetweenContours(), IntersectionPoints(), and PossibleIntersections().

std::vector<Vector> AutoControlPoints::_intervecXX [private]

Definition at line 102 of file AutoControlPoints.h.

Referenced by fixBetweenControl(), and InterBetweenControl().

std::vector<Vector> AutoControlPoints::_intervecYY [private]

Definition at line 103 of file AutoControlPoints.h.

Referenced by fixBetweenControl(), and InterBetweenControl().

std::vector<double> AutoControlPoints::_maxlocalX [private]

Definition at line 84 of file AutoControlPoints.h.

Referenced by maxminLocal().

std::vector<double> AutoControlPoints::_maxlocalY [private]

Definition at line 85 of file AutoControlPoints.h.

Referenced by maxminLocal().

manualContourModel* AutoControlPoints::_mContourModel [private]

Definition at line 64 of file AutoControlPoints.h.

Referenced by ChargeSpline().

std::vector<double> AutoControlPoints::_minlocalX [private]

Definition at line 86 of file AutoControlPoints.h.

Referenced by maxminLocal().

std::vector<double> AutoControlPoints::_minlocalY [private]

Definition at line 87 of file AutoControlPoints.h.

Referenced by maxminLocal().

std::vector<double> AutoControlPoints::_minmaxlocalX [private]

Definition at line 88 of file AutoControlPoints.h.

Referenced by GetInitialNewPoints(), GetNewPoints(), and maxminLocal().

std::vector<double> AutoControlPoints::_minmaxlocalY [private]

Definition at line 89 of file AutoControlPoints.h.

Referenced by GetInitialNewPoints(), GetNewPoints(), and maxminLocal().

int AutoControlPoints::_numspline [private]

Definition at line 65 of file AutoControlPoints.h.

Referenced by AutoControlPoints(), ChargeSpline(), and SetNumSplineInterpolation().

double AutoControlPoints::_pathsize [private]

Definition at line 66 of file AutoControlPoints.h.

Referenced by AutoControlPoints(), ChargeSpline(), and ErrorBetweenContours().

int AutoControlPoints::_posA [private]

Definition at line 96 of file AutoControlPoints.h.

Referenced by AddControlPoint(), and NearMaxError2Control().

int AutoControlPoints::_posB [private]

Definition at line 97 of file AutoControlPoints.h.

Referenced by AddControlPoint(), and NearMaxError2Control().

std::vector<int> AutoControlPoints::_posmaxlocal [private]

Definition at line 82 of file AutoControlPoints.h.

Referenced by maxminLocal().

std::vector<int> AutoControlPoints::_posminlocal [private]

Definition at line 83 of file AutoControlPoints.h.

Referenced by maxminLocal().

std::vector<int> AutoControlPoints::_posminmaxlocal [private]

Definition at line 90 of file AutoControlPoints.h.

Referenced by maxminLocal().

int AutoControlPoints::_posn [private]

Definition at line 107 of file AutoControlPoints.h.

Referenced by MoveControlPointInContour(), and NearMaxError2Control().

int AutoControlPoints::_SizeVectorIn [private]

Definition at line 59 of file AutoControlPoints.h.

Referenced by GetSizeVector(), and PointLow().

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

/home/davila/Creatis/creaMaracasVisu/lib/maracasVisuLib/src/interface/wxWindows/Contour/AutoControlPoints.h
/home/davila/Creatis/creaMaracasVisu/lib/maracasVisuLib/src/interface/wxWindows/Contour/AutoControlPoints.cxx

AutoControlPoints Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation