creaMaracasVisu_lib: AutoControlPoints Class Reference

AutoControlPoints::AutoControlPoints ( )

Definition at line 6 of file AutoControlPoints.cxx.

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

AutoControlPoints::~AutoControlPoints ( )

Definition at line 12 of file AutoControlPoints.cxx.

00013 {
00014 }

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:

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::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::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::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::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:

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::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::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::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::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::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::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::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::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::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::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:

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:

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:

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::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::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::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:

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:

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::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().

00847 {
00848         if(_errorpos != -1)
00849         {
00850                 double xmax = _interpointsX[(int)_errorpos];
00851                 double ymax = _interpointsY[(int)_errorpos];
00852                 double xx       = _intervectorX[(int)_errorpos].get_var();
00853                 double yy       = _intervectorY[(int)_errorpos].get_var();
00854 printf("\n XMAX = %f, YMAX = %f, XX = %f, YY = %f",xmax,ymax,xx,yy);
00855 
00856                 int i,ii,j,posA=-1,posB=-1;
00857                 bool findA=false, findB=false;
00858                 //CASE A
00859                 for(i=(int)_errorpos; findA!=true; i++)
00860                 {
00861                         ii = i%_errorvector.size();
00862                         for(j=0; j<(int)(_controlpointsX.size()); j++)
00863                         {
00864                                 if( ((float)_controlpointsX[j]-1.5<=(float)_intervectorX[ii].get_var()) && ((float)_intervectorX[ii].get_var()<=(float)_controlpointsX[j]+1.5) &&
00865                                         ((float)_controlpointsY[j]-1.5<=(float)_intervectorY[ii].get_var()) && ((float)_intervectorY[ii].get_var()<=(float)_controlpointsY[j]+1.5) )
00866                                 {
00867                                         findA = true;
00868                                         posA = j;
00869                                 }
00870                         }
00871                 }
00872                 //CASE B
00873                 for(i=(int)_errorpos; findB!=true; i--)
00874                 {
00875                         if(_errorpos==-1)
00876                         {
00877                                 i = _errorvector.size();
00878                         }
00879                         for(j=0; j<(int)(_controlpointsX.size()); j++)
00880                         {
00881                                 if( ((float)_controlpointsX[j]-1.5<=(float)_intervectorX[i].get_var()) && ((float)_intervectorX[i].get_var()<=(float)_controlpointsX[j]+1.5) &&
00882                                         ((float)_controlpointsY[j]-1.5<=(float)_intervectorY[i].get_var()) && ((float)_intervectorY[i].get_var()<=(float)_controlpointsY[j]+1.5) )
00883                                 {
00884                                         findB = true;
00885                                         posB = j;
00886                                 }
00887                         }
00888                 }
00889                 if(posA == posB)
00890                 {
00891                         posB = posA-1;
00892                 }
00893                 if(posA<posB)
00894                 {
00895                         posA = posB+1;
00896                         if(posB = _controlpointsX.size()-1)  // ?!? // JPRx     // ?!? EED
00897                         {
00898                                 posA = 0;
00899                         }
00900                 }
00901 printf("\n POSA = %d, X = %f, Y = %f",posA,_controlpointsX[posA],_controlpointsY[posA]);
00902 printf("\n POSB = %d, X = %f, Y = %f",posB,_controlpointsX[posB],_controlpointsY[posB]);
00903                 _posA = posA;
00904                 _posB = posB;
00905                 int id = -1;
00906                 if(((posA!=-1)&&(posB!=-1)))
00907                 {
00908                         id = posA;
00909                 }
00910 printf("\n ID = %d",id);
00911                 if(id != -1)
00912                 {
00913                         std::vector<double> tempX;
00914                         std::vector<double> tempY;
00915                         std::vector<double> tempZ;
00916                         for(i=0; i<(int)(_controlpointsX.size()); i++)
00917                         {
00918                                 if(i == id)
00919                                 {
00920                                         tempX.push_back(xmax);
00921                                         tempY.push_back(ymax);
00922                                         tempZ.push_back(_controlpointsZ[0]);
00923                                 }
00924                                 tempX.push_back(_controlpointsX[i]);
00925                                 tempY.push_back(_controlpointsY[i]);
00926                                 tempZ.push_back(_controlpointsZ[i]);
00927                         }
00928                 
00929                         if(activate == true)
00930                         {
00931                                 vectorFunctions *vf = new vectorFunctions();
00932                                 vf->copyVector(&tempX,&_controlpointsX);
00933                                 vf->copyVector(&tempY,&_controlpointsY);
00934                                 vf->copyVector(&tempZ,&_controlpointsZ);
00935                                 delete vf;
00936                         }
00937                 
00938                 }
00939         }//IF-(principal)
00940 }

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::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::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 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 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:

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:

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::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::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:

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 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_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:

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_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:

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:

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 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::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 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:

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 }

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 }

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 }

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 }

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 }

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 Vector::get_plane ( ) [inherited]

Definition at line 106 of file Propagation.cxx.

References Vector::_plane.

00107 {
00108         return _plane;
00109 }

void Vector::resetVec ( ) [inherited]

Definition at line 170 of file Propagation.cxx.

References Vector::_vec.

00171 {
00172         _vec.clear();
00173 }

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

Definition at line 165 of file Propagation.cxx.

References Vector::_vec.

00166 {
00167         return _vec;
00168 }

int AutoControlPoints::_SizeVectorIn [private]

Definition at line 59 of file AutoControlPoints.h.

Referenced by GetSizeVector(), and PointLow().

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().

manualContourModel* AutoControlPoints::_mContourModel [private]

Definition at line 64 of file AutoControlPoints.h.

Referenced by ChargeSpline().

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().

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<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<double> AutoControlPoints::_intercircleDist [private]

Definition at line 76 of file AutoControlPoints.h.

Referenced by InterCircle(), and maxminLocal().

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::_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<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<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().

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().

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

Definition at line 90 of file AutoControlPoints.h.

Referenced by maxminLocal().

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<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().

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().

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<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<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().

int AutoControlPoints::_posn [private]

Definition at line 107 of file AutoControlPoints.h.

Referenced by MoveControlPointInContour(), and NearMaxError2Control().

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

Definition at line 108 of file AutoControlPoints.h.

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

AutoControlPoints Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


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