/*
* Constructs a Smilies which is a child of 'parent', with the
* name 'name' and widget flags set to 'f'
*/
Smilies::Smilies( QWidget* parent, const char* name, WFlags fl )
: QWidget( parent, name, fl )
{
QPixmap image0( SmallIcon("face_smile") );
QPixmap image1( SmallIcon("face_angel") );
QPixmap image2( SmallIcon("face_embarrassed") );
QPixmap image3( SmallIcon("face_yell") );
QPixmap image4( SmallIcon("face_wink") );
QPixmap image5( SmallIcon("face_glasses") );
QPixmap image6( SmallIcon("face_moneymouth") );
QPixmap image7( SmallIcon("face_crossedlips") );
QPixmap image8( SmallIcon("face_sad") );
QPixmap image9( SmallIcon("face_scream") );
QPixmap image10( SmallIcon("face_cry") );
QPixmap image11( SmallIcon("face_burp") );
QPixmap image12( SmallIcon("face_kiss") );
QPixmap image13( SmallIcon("face_think") );
QPixmap image14( SmallIcon("face_tongue") );
QPixmap image15( SmallIcon("face_luke") );
QPixmap image16( SmallIcon("face_bigsmile") );
QPixmap image17( SmallIcon("face_oneeye") );
if ( !name )
setName( "Smilies" );
resize( 124, 139 );
setCaption( tr( "kaim-smiles" ) );
SmiliesLayout = new QGridLayout( this );
SmiliesLayout->setSpacing( 0 );
SmiliesLayout->setMargin( 0 );
smile = new QToolButton( this, "smile" );
smile->setText( tr( " " ) );
smile->setPixmap( image0 );
SmiliesLayout->addWidget( smile, 0, 0 );
angel = new QToolButton( this, "angel" );
angel->setText( tr( " " ) );
angel->setPixmap( image1 );
SmiliesLayout->addWidget( angel, 2, 3 );
embarrassed = new QToolButton( this, "embarrassed" );
embarrassed->setText( tr( " " ) );
embarrassed->setPixmap( image2 );
SmiliesLayout->addWidget( embarrassed, 2, 2 );
yell = new QToolButton( this, "yell" );
yell->setText( tr( " " ) );
yell->setPixmap( image3 );
SmiliesLayout->addWidget( yell, 1, 2 );
wink = new QToolButton( this, "wink" );
wink->setText( tr( " " ) );
wink->setPixmap( image4 );
SmiliesLayout->addWidget( wink, 0, 3 );
glasses = new QToolButton( this, "glasses" );
glasses->setText( tr( " " ) );
glasses->setPixmap( image5 );
SmiliesLayout->addWidget( glasses, 2, 0 );
moneymouth = new QToolButton( this, "moneymouth" );
moneymouth->setText( tr( " " ) );
moneymouth->setPixmap( image6 );
SmiliesLayout->addWidget( moneymouth, 3, 3 );
crossedlips = new QToolButton( this, "crossedlips" );
crossedlips->setText( tr( " " ) );
crossedlips->setPixmap( image7 );
SmiliesLayout->addWidget( crossedlips, 3, 2 );
sad = new QToolButton( this, "sad" );
sad->setText( tr( " " ) );
sad->setPixmap( image8 );
SmiliesLayout->addWidget( sad, 0, 2 );
scream = new QToolButton( this, "scream" );
scream->setText( tr( " " ) );
scream->setPixmap( image9 );
SmiliesLayout->addWidget( scream, 1, 1 );
cry = new QToolButton( this, "cry" );
cry->setText( tr( " " ) );
cry->setPixmap( image10 );
SmiliesLayout->addWidget( cry, 3, 1 );
burp = new QToolButton( this, "burp" );
burp->setText( tr( " " ) );
burp->setPixmap( image11 );
SmiliesLayout->addWidget( burp, 2, 1 );
kiss = new QToolButton( this, "kiss" );
kiss->setText( tr( " " ) );
kiss->setPixmap( image12 );
SmiliesLayout->addWidget( kiss, 1, 3 );
think = new QToolButton( this, "think" );
think->setText( tr( " " ) );
think->setPixmap( image13 );
SmiliesLayout->addWidget( think, 3, 0 );
tongue = new QToolButton( this, "tongue" );
tongue->setText( tr( " " ) );
tongue->setPixmap( image14 );
SmiliesLayout->addWidget( tongue, 1, 0 );
luke = new QToolButton( this, "luke" );
luke->setText( tr( " " ) );
luke->setPixmap( image15 );
SmiliesLayout->addWidget( luke, 4, 2 );
bigsmile = new QToolButton( this, "bigsmile" );
bigsmile->setText( tr( " " ) );
bigsmile->setPixmap( image16 );
SmiliesLayout->addWidget( bigsmile, 0, 1 );
oneeye = new QToolButton( this, "oneeye" );
oneeye->setText( tr( " " ) );
oneeye->setPixmap( image17 );
SmiliesLayout->addWidget( oneeye, 4, 1 );
QObject::connect( smile, SIGNAL(clicked()), SLOT(smileClicked()) );
QObject::connect( angel, SIGNAL(clicked()), SLOT(angelClicked()) );
QObject::connect( embarrassed, SIGNAL(clicked()), SLOT(embarrassedClicked()) );
QObject::connect( yell, SIGNAL(clicked()), SLOT(yellClicked()) );
QObject::connect( wink, SIGNAL(clicked()), SLOT(winkClicked()) );
QObject::connect( glasses, SIGNAL(clicked()), SLOT(glassesClicked()) );
QObject::connect( moneymouth, SIGNAL(clicked()), SLOT(moneymouthClicked()) );
QObject::connect( crossedlips, SIGNAL(clicked()), SLOT(crossedlipsClicked()) );
QObject::connect( sad, SIGNAL(clicked()), SLOT(sadClicked()) );
QObject::connect( scream, SIGNAL(clicked()), SLOT(screamClicked()) );
QObject::connect( cry, SIGNAL(clicked()), SLOT(cryClicked()) );
QObject::connect( burp, SIGNAL(clicked()), SLOT(burpClicked()) );
QObject::connect( kiss, SIGNAL(clicked()), SLOT(kissClicked()) );
QObject::connect( think, SIGNAL(clicked()), SLOT(thinkClicked()) );
QObject::connect( tongue, SIGNAL(clicked()), SLOT(tongueClicked()) );
QObject::connect( luke, SIGNAL(clicked()), SLOT(lukeClicked()) );
QObject::connect( bigsmile, SIGNAL(clicked()), SLOT(bigsmileClicked()) );
QObject::connect( oneeye, SIGNAL(clicked()), SLOT(oneeyeClicked()) );
}
void prob3b(){
// filenames
std::string train1 = "Data_Prog2/Training_1.ppm";
std::string ref1 = "Data_Prog2/ref1.ppm";
// variable declarations
int M, N, Q;
bool type;
// make image objects
readImageHeader(train1.c_str(), N, M, Q, type);
ImageType image1(N, M, Q);
ImageType refimage1(N, M, Q);
readImage(train1.c_str(),image1);
readImage(ref1.c_str(),refimage1);
// make skin colors
Matrix skin_colors, non_skin_colors;
makeColorMatrices(image1, refimage1, skin_colors, non_skin_colors, true);
// estimate parameters for skin-color class
std::vector<double> mean1 = getSampleMean(skin_colors);
std::cout << "sample_mean1 = ";
print_vec(mean1);
Matrix cov1 = getSampleVar(skin_colors, mean1);
std::cout << "sample_cov1 = ";
print_matrix(cov1);
// set up parameters for non-skin-color class
std::vector<double> mean2 = getSampleMean(non_skin_colors);
Matrix cov2 = getSampleVar(non_skin_colors, mean2);
std::cout << "sample_mean2 = ";
print_vec(mean2);
std::cout << "sample_cov2 = ";
print_matrix(cov2);
// make classifier
QuadraticDiscriminant classifier(mean1, mean2, cov1, cov2, 0.08, 0.92);
std::string out1 = "Data_Prog2/out1b.ppm";
testSkinRecognition(classifier, image1, refimage1, out1, true);
std::string train3 = "Data_Prog2/Training_3.ppm";
std::string ref3 = "Data_Prog2/ref3.ppm";
readImageHeader(train3.c_str(), N, M, Q, type);
ImageType image3(N, M, Q);
ImageType refimage3(N, M, Q);
readImage(train3.c_str(),image3);
readImage(ref3.c_str(),refimage3);
std::string out3 = "Data_Prog2/out3b.ppm";
testSkinRecognition(classifier, image3, refimage3, out3, true);
std::string train6 = "Data_Prog2/Training_6.ppm";
std::string ref6 = "Data_Prog2/ref6.ppm";
readImageHeader(train6.c_str(), N, M, Q, type);
ImageType image6(N, M, Q);
ImageType refimage6(N, M, Q);
readImage(train6.c_str(),image6);
readImage(ref6.c_str(),refimage6);
std::string out6 = "Data_Prog2/out6b.ppm";
testSkinRecognition(classifier, image6, refimage6, out6, true);
}
int main(int, char *[])
{
double testrad = 5.5, testx = 127.25, testy = 127.75; //< Actual location of spot
double seedrad = 6, seedx = 120, seedy = 118; //< Start location for tracking
int avgcount; //< How many samples to average over
double pixacc; //< Pixel accuracy desired
double err, minerr, maxerr, sumerr;
double raderr, minraderr, maxraderr, sumraderr;
double biasx, biasy;
printf("Generating default test image with radius %lg disk at %lg, %lg\n", testrad, testx, testy);
disc_image image(0,255, 0,255, 127, 5, testx, testy, testrad, 250);
printf("-----------------------------------------------------------------\n");
printf("Generating default spot tracker\n");
disk_spot_tracker tracker(seedrad);
printf("Looking for best fit within the image\n");
tracker.locate_good_fit_in_image(image, 0, seedx, seedy);
printf("Optimization, starting at found location %lg, %lg, rad %lg\n", seedx, seedy, seedrad);
int i;
double x,y, rad, fit;
tracker.take_single_optimization_step(image, 0, x,y, seedx, seedy);
for (i = 0; i < 5; i++) {
tracker.take_single_optimization_step(image, 0, x, y, true, true, true);
rad = tracker.get_radius();
fit = tracker.get_fitness();
printf("Next step: X = %8.3lg, Y = %8.3lg, rad = %8.3lg, fit = %12.5lg\n", x,y,rad, fit);
}
printf("Chasing around a slightly noisy spot using full optimization\n");
testrad = 5.5, testx = 127.25, testy = 127.75; //< Actual location of spot
seedrad = 6, seedx = 120, seedy = 118; //< Start location for tracking
avgcount = 50;
minerr = 1000; maxerr = 0; sumerr = 0;
minraderr = 1000; maxraderr = 0; sumraderr = 0;
biasx = 0; biasy = 0;
for (i = 0; i < avgcount; i++) {
testrad += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * 1;
if (testrad < 3) { testrad = 3; }
testx += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2);
testy += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2);
{
disc_image image2(0,255, 0,255, 127, 5, testx, testy, testrad, 250);
tracker.optimize(image2, 0, x, y);
rad = tracker.get_radius();
fit = tracker.get_fitness();
err = sqrt( (x-testx)*(x-testx) + (y-testy)*(y-testy) );
if (err < minerr) { minerr = err; }
if (err > maxerr) { maxerr = err; }
sumerr += err;
raderr = fabs(rad-testrad);
if (raderr < minraderr) { minraderr = raderr; }
if (raderr > maxraderr) { maxraderr = raderr; }
sumraderr += raderr;
biasx += x - testx;
biasy += y - testy;
if (i == 0) {
printf("First opt: real coords (%g,%g), found coords (%g,%g)\n", testx,testy, x,y);
}
}
}
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
printf("Rad err: min=%g, max=%g, mean=%g\n", minraderr, maxraderr, sumraderr/avgcount);
testrad = 5.5;
pixacc = 0.05;
avgcount = 50;
x = 120.5; y = 120;
printf("Chasing around a slightly noisy disk of known radius %g to %g pixel\n", testrad, pixacc);
compute_disk_chase_statistics(tracker, testrad, pixacc, avgcount, minerr, maxerr, sumerr, biasx, biasy, x,y);
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
x = 120.5; y = 120;
printf("Chasing around a slightly noisy cone of known radius %g to %g pixel\n", testrad, pixacc);
compute_cone_chase_statistics(tracker, testrad, pixacc, avgcount, minerr, maxerr, sumerr, biasx, biasy, x,y);
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
pixacc = 0.05;
testrad = 5.5;
tracker.set_pixel_accuracy(pixacc);
printf("Timing how long it takes to optimize pos to %g pixels from a nearby position on average\n", pixacc);
avgcount = 1000;
struct timeval start, end;
tracker.optimize(image, 0, x,y); // Get back to the correct starting location
gettimeofday(&start, NULL);
for (i = 0; i < avgcount; i++) {
tracker.optimize_xy(image, 0, x, y,
x + ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2),
y + ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2));
}
gettimeofday(&end, NULL);
printf(" Time: %lg seconds per optimization\n", duration(end, start)/avgcount);
printf("-----------------------------------------------------------------\n");
printf("Generating interpolating spot tracker\n");
disk_spot_tracker_interp interptracker(seedrad);
printf("Looking for best fit within the image\n");
interptracker.locate_good_fit_in_image(image, 0, seedx, seedy);
printf("Optimization, starting at found location %lg, %lg, rad %lg\n", seedx, seedy, seedrad);
interptracker.take_single_optimization_step(image, 0, x,y, seedx, seedy);
for (i = 0; i < 5; i++) {
interptracker.take_single_optimization_step(image, 0, x, y, true, true, true);
rad = interptracker.get_radius();
fit = interptracker.get_fitness();
printf("Next step: X = %8.3lg, Y = %8.3lg, rad = %8.3lg, fit = %12.5lg\n", x,y,rad, fit);
}
printf("Chasing around a slightly noisy spot using full optimization\n");
testrad = 5.5, testx = 127.25, testy = 127.75; //< Actual location of spot
seedrad = 6, seedx = 120, seedy = 118; //< Start location for tracking
avgcount = 50;
minerr = 1000; maxerr = 0; sumerr = 0;
minraderr = 1000; maxraderr = 0; sumraderr = 0;
biasx = 0; biasy = 0;
for (i = 0; i < avgcount; i++) {
testrad += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * 1;
if (testrad < 3) { testrad = 3; }
testx += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2);
testy += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2);
{
disc_image image2(0,255, 0,255, 127, 5, testx, testy, testrad, 250);
interptracker.optimize(image2, 0, x, y);
rad = interptracker.get_radius();
fit = interptracker.get_fitness();
err = sqrt( (x-testx)*(x-testx) + (y-testy)*(y-testy) );
if (err < minerr) { minerr = err; }
if (err > maxerr) { maxerr = err; }
sumerr += err;
raderr = fabs(rad-testrad);
if (raderr < minraderr) { minraderr = raderr; }
if (raderr > maxraderr) { maxraderr = raderr; }
sumraderr += raderr;
biasx += x - testx;
biasy += y - testy;
if (i == 0) {
printf("First opt: real coords (%g,%g), found coords (%g,%g)\n", testx,testy, x,y);
}
}
}
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
printf("Rad err: min=%g, max=%g, mean=%g\n", minraderr, maxraderr, sumraderr/avgcount);
testrad = 5.5;
pixacc = 0.05;
avgcount = 50;
x = 120.5; y = 120;
printf("Chasing around a slightly noisy disk of known radius %g to %g pixel\n", testrad, pixacc);
compute_disk_chase_statistics(interptracker, testrad, pixacc, avgcount, minerr, maxerr, sumerr, biasx,biasy, x,y);
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
x = 120.5; y = 120;
printf("Chasing around a slightly noisy cone of known radius %g to %g pixel\n", testrad, pixacc);
compute_cone_chase_statistics(interptracker, testrad, pixacc, avgcount, minerr, maxerr, sumerr, biasx,biasy, x,y);
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
testrad = 5.5;
pixacc = 0.05;
x = 120.5; y = 120;
disc_image image3(0,255,0,255,127,0,x,y,testrad, 250);
printf("Optimizing a slightly noisy disk of known radius %g at %g,%g\n", testrad, x,y);
interptracker.optimize_xy(image3, 0, x, y, floor(x), ceil(y));
printf(" Found a spot of radius %g at %g,%g\n", interptracker.get_radius(), interptracker.get_x(), interptracker.get_y());
pixacc = 0.05;
testrad = 5.5;
interptracker.set_pixel_accuracy(pixacc);
printf("Timing how long it takes to optimize pos to %g pixels from a nearby position on average\n", pixacc);
avgcount = 100;
interptracker.optimize(image, 0, x,y); // Get back to the correct starting location
gettimeofday(&start, NULL);
for (i = 0; i < avgcount; i++) {
interptracker.optimize_xy(image, 0, x, y,
x + ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2),
y + ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2));
}
gettimeofday(&end, NULL);
printf(" Time: %lg seconds per optimization\n", duration(end, start)/avgcount);
printf("-----------------------------------------------------------------\n");
printf("Generating interpolating cone spot tracker\n");
cone_spot_tracker_interp conetracker(seedrad);
printf("Looking for best fit within the image\n");
conetracker.locate_good_fit_in_image(image, 0, seedx, seedy);
printf("Optimization, starting at found location %lg, %lg, rad %lg\n", seedx, seedy, seedrad);
conetracker.take_single_optimization_step(image, 0, x,y, seedx, seedy);
for (i = 0; i < 5; i++) {
conetracker.take_single_optimization_step(image, 0, x, y, true, true, true);
rad = conetracker.get_radius();
fit = conetracker.get_fitness();
printf("Next step: X = %8.3lg, Y = %8.3lg, rad = %8.3lg, fit = %12.5lg\n", x,y,rad, fit);
}
printf("Chasing around a slightly noisy spot using full optimization\n");
testrad = 5.5, testx = 127.25, testy = 127.75; //< Actual location of spot
seedrad = 6, seedx = 120, seedy = 118; //< Start location for tracking
avgcount = 50;
minerr = 1000; maxerr = 0; sumerr = 0;
minraderr = 1000; maxraderr = 0; sumraderr = 0;
biasx = 0; biasy = 0;
for (i = 0; i < avgcount; i++) {
testrad += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * 1;
if (testrad < 3) { testrad = 3; }
testx += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2);
testy += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2);
{
disc_image image2(0,255, 0,255, 127, 5, testx, testy, testrad, 250);
conetracker.optimize(image2, 0, x, y);
rad = conetracker.get_radius();
fit = conetracker.get_fitness();
err = sqrt( (x-testx)*(x-testx) + (y-testy)*(y-testy) );
if (err < minerr) { minerr = err; }
if (err > maxerr) { maxerr = err; }
sumerr += err;
raderr = fabs(rad-testrad);
if (raderr < minraderr) { minraderr = raderr; }
if (raderr > maxraderr) { maxraderr = raderr; }
sumraderr += raderr;
biasx += x - testx;
biasy += y - testy;
if (i == 0) {
printf("First opt: real coords (%g,%g), found coords (%g,%g)\n", testx,testy, x,y);
}
}
}
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
printf("Rad err: min=%g, max=%g, mean=%g\n", minraderr, maxraderr, sumraderr/avgcount);
testrad = 5.5;
pixacc = 0.05;
avgcount = 50;
x = 120.5; y = 120;
printf("Chasing around a slightly noisy disk of known radius %g to %g pixel\n", testrad, pixacc);
// Make the radius slightly larger than the radius of the spot.
compute_disk_chase_statistics(conetracker, 1.3*testrad, pixacc, avgcount, minerr, maxerr, sumerr, biasx,biasy, x,y);
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
x = 120.5; y = 120;
printf("Chasing around a slightly noisy cone of known radius %g to %g pixel\n", testrad, pixacc);
// Make the radius slightly larger than the radius of the spot.
compute_cone_chase_statistics(conetracker, 1.3*testrad, pixacc, avgcount, minerr, maxerr, sumerr, biasx,biasy, x,y);
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
testrad = 5.5;
pixacc = 0.05;
x = 120.5; y = 120;
disc_image image4(0,255,0,255,127,0,x,y,testrad, 250);
printf("Optimizing a slightly noisy disk of known radius %g at %g,%g\n", testrad, x,y);
conetracker.optimize_xy(image4, 0, x, y, floor(x), ceil(y));
printf(" Found a spot of radius %g at %g,%g\n", conetracker.get_radius(), conetracker.get_x(), conetracker.get_y());
pixacc = 0.05;
testrad = 5.5;
conetracker.set_pixel_accuracy(pixacc);
printf("Timing how long it takes to optimize pos to %g pixels from a nearby position on average\n", pixacc);
avgcount = 100;
conetracker.optimize(image, 0, x,y); // Get back to the correct starting location
gettimeofday(&start, NULL);
for (i = 0; i < avgcount; i++) {
conetracker.optimize_xy(image, 0, x, y,
x + ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2),
y + ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2));
}
gettimeofday(&end, NULL);
printf(" Time: %lg seconds per optimization\n", duration(end, start)/avgcount);
printf("-----------------------------------------------------------------\n");
printf("Generating interpolating symmetric spot tracker\n");
symmetric_spot_tracker_interp symmetrictracker(seedrad);
printf("Looking for best fit within the image\n");
symmetrictracker.locate_good_fit_in_image(image, 0, seedx, seedy);
printf("Optimization, starting at found location %lg, %lg, rad %lg\n", seedx, seedy, seedrad);
symmetrictracker.take_single_optimization_step(image, 0, x,y, seedx, seedy);
for (i = 0; i < 5; i++) {
symmetrictracker.take_single_optimization_step(image, 0, x, y, true, true, true);
rad = symmetrictracker.get_radius();
fit = symmetrictracker.get_fitness();
printf("Next step: X = %8.3lg, Y = %8.3lg, rad = %8.3lg, fit = %12.5lg\n", x,y,rad, fit);
}
printf("Chasing around a slightly noisy spot using full optimization\n");
testrad = 5.5, testx = 127.25, testy = 127.75; //< Actual location of spot
seedrad = 6, seedx = 120, seedy = 118; //< Start location for tracking
avgcount = 50;
minerr = 1000; maxerr = 0; sumerr = 0;
minraderr = 1000; maxraderr = 0; sumraderr = 0;
biasx = 0; biasy = 0;
for (i = 0; i < avgcount; i++) {
testrad += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * 1;
if (testrad < 3) { testrad = 3; }
testx += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2);
testy += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2);
{
disc_image image2(0,255, 0,255, 127, 5, testx, testy, testrad, 250);
symmetrictracker.optimize(image2, 0, x, y);
rad = symmetrictracker.get_radius();
fit = symmetrictracker.get_fitness();
err = sqrt( (x-testx)*(x-testx) + (y-testy)*(y-testy) );
if (err < minerr) { minerr = err; }
if (err > maxerr) { maxerr = err; }
sumerr += err;
raderr = fabs(rad-testrad);
if (raderr < minraderr) { minraderr = raderr; }
if (raderr > maxraderr) { maxraderr = raderr; }
sumraderr += raderr;
biasx += x - testx;
biasy += y - testy;
if (i == 0) {
printf("First opt: real coords (%g,%g), found coords (%g,%g)\n", testx,testy, x,y);
}
}
}
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
printf("Rad err: min=%g, max=%g, mean=%g\n", minraderr, maxraderr, sumraderr/avgcount);
testrad = 5.5;
pixacc = 0.01;
avgcount = 50;
x = 120.5; y = 120;
printf("Chasing around a slightly noisy disk of known radius %g to %g pixel\n", testrad, pixacc);
// Make the radius slightly larger than the radius of the spot.
compute_disk_chase_statistics(symmetrictracker, 1.3*testrad, pixacc, avgcount, minerr, maxerr, sumerr, biasx,biasy, x,y);
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
x = 120.5; y = 120;
printf("Chasing around a slightly noisy cone of known radius %g to %g pixel\n", testrad, pixacc);
// Make the radius slightly larger than the radius of the spot.
compute_disk_chase_statistics(symmetrictracker, 1.3*testrad, pixacc, avgcount, minerr, maxerr, sumerr, biasx,biasy, x,y);
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
testrad = 5.5;
pixacc = 0.05;
x = 120.5; y = 120;
disc_image image5(0,255,0,255,127,0,x,y,testrad, 250);
printf("Optimizing a slightly noisy disk of known radius %g at %g,%g\n", testrad, x,y);
symmetrictracker.optimize_xy(image5, 0, x, y, floor(x), ceil(y));
printf(" Found a spot of radius %g at %g,%g\n", symmetrictracker.get_radius(), symmetrictracker.get_x(), symmetrictracker.get_y());
pixacc = 0.05;
testrad = 5.5;
symmetrictracker.set_pixel_accuracy(pixacc);
printf("Timing how long it takes to optimize pos to %g pixels from a nearby position on average\n", pixacc);
avgcount = 100;
symmetrictracker.optimize(image, 0, x,y); // Get back to the correct starting location
gettimeofday(&start, NULL);
for (i = 0; i < avgcount; i++) {
symmetrictracker.optimize_xy(image, 0, x, y,
x + ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2),
y + ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2));
}
gettimeofday(&end, NULL);
printf(" Time: %lg seconds per optimization\n", duration(end, start)/avgcount);
printf("-----------------------------------------------------------------\n");
printf("Generating Gaussian spot tracker\n");
testrad = 5.5, testx = 127.25, testy = 127.75; //< Actual location of spot
seedrad = 6, seedx = 120, seedy = 118; //< Start location for tracking
Gaussian_spot_tracker Gaussiantracker(seedrad, false, 0.25, 0.25, 1.0, 127, 11689);
printf("Looking for best fit within the image\n");
Gaussiantracker.locate_good_fit_in_image(image, 0, seedx, seedy);
printf("Optimization, starting at found location %lg, %lg, rad %lg\n", seedx, seedy, seedrad);
Gaussiantracker.take_single_optimization_step(image, 0, x,y, seedx, seedy);
for (i = 0; i < 5; i++) {
Gaussiantracker.take_single_optimization_step(image, 0, x, y, true, true, true);
rad = Gaussiantracker.get_radius();
fit = Gaussiantracker.get_fitness();
printf("Next step: X = %8.3lg, Y = %8.3lg, rad = %8.3lg, fit = %12.5lg\n", x,y,rad, fit);
}
printf("Chasing around a slightly noisy spot using full optimization\n");
avgcount = 50;
minerr = 1000; maxerr = 0; sumerr = 0;
minraderr = 1000; maxraderr = 0; sumraderr = 0;
biasx = 0; biasy = 0;
for (i = 0; i < avgcount; i++) {
testrad += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * 1;
if (testrad < 3) { testrad = 3; }
testx += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2);
testy += ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2);
{
disc_image image2(0,255, 0,255, 127, 5, testx, testy, testrad, 250);
Gaussiantracker.optimize(image2, 0, x, y);
rad = Gaussiantracker.get_radius();
fit = Gaussiantracker.get_fitness();
err = sqrt( (x-testx)*(x-testx) + (y-testy)*(y-testy) );
if (err < minerr) { minerr = err; }
if (err > maxerr) { maxerr = err; }
sumerr += err;
raderr = fabs(rad-testrad);
if (raderr < minraderr) { minraderr = raderr; }
if (raderr > maxraderr) { maxraderr = raderr; }
sumraderr += raderr;
biasx += x - testx;
biasy += y - testy;
if (i == 0) {
printf("First opt: real coords (%g,%g), found coords (%g,%g)\n", testx,testy, x,y);
}
}
}
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
// XXX Radius error meaningless here because radius not optimized.
//printf("Rad err: min=%g, max=%g, mean=%g\n", minraderr, maxraderr, sumraderr/avgcount);
testrad = 5.5;
pixacc = 0.01;
avgcount = 50;
x = 120.5; y = 120;
printf("Chasing around a slightly noisy disk of known radius %g to %g pixel\n", testrad, pixacc);
// Make the radius slightly larger than the radius of the spot.
compute_disk_chase_statistics(Gaussiantracker, 1.3*testrad, pixacc, avgcount, minerr, maxerr, sumerr, biasx,biasy, x,y);
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
x = 120.5; y = 120;
printf("Chasing around a slightly noisy cone of known radius %g to %g pixel\n", testrad, pixacc);
// Make the radius slightly larger than the radius of the spot.
compute_disk_chase_statistics(Gaussiantracker, 1.3*testrad, pixacc, avgcount, minerr, maxerr, sumerr, biasx,biasy, x,y);
printf("Pos err: min=%g, max=%g, mean=%g, xbias = %g, ybias = %g\n", minerr, maxerr, sumerr/avgcount, biasx/avgcount, biasy/avgcount);
testrad = 5.5;
pixacc = 0.05;
x = 120.5; y = 120;
disc_image image6(0,255,0,255,127,0,x,y,testrad, 250);
printf("Optimizing a slightly noisy disk of known radius %g at %g,%g\n", testrad, x,y);
Gaussiantracker.optimize(image6, 0, x, y, floor(x), ceil(y));
printf(" Found a spot of radius %g at %g,%g\n", Gaussiantracker.get_radius(), Gaussiantracker.get_x(), Gaussiantracker.get_y());
pixacc = 0.05;
testrad = 5.5;
Gaussiantracker.set_pixel_accuracy(pixacc);
printf("Timing how long it takes to optimize pos to %g pixels from a nearby position on average\n", pixacc);
avgcount = 10;
Gaussiantracker.optimize(image, 0, x,y); // Get back to the correct starting location
gettimeofday(&start, NULL);
for (i = 0; i < avgcount; i++) {
Gaussiantracker.optimize_xy(image, 0, x, y,
x + ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2),
y + ( (rand()/(double)(RAND_MAX)) - 0.5) * 2 * (testrad/2));
}
gettimeofday(&end, NULL);
printf(" Time: %lg seconds per optimization\n", duration(end, start)/avgcount);
//-----------------------------------------------------------------------------------------------
// Testing the Z-tracking classes.
printf("-----------------------------------------------------------------\n");
// Construct a PSF kernel by making a number of disc images and sticking them into it.
disc_image *discs[10];
PSF_File *psf = new PSF_File("deleteme.tif", 25, false);
for (i = 0; i < 10; i++) {
discs[i] = new disc_image(0,128, 0,128, 0, 0.0, 64,64, i+10, 255, 4);
psf->append_line(*discs[i], 64, 64);
}
delete psf;
// Test the best-fit-finding code
radial_average_tracker_Z Ztrack("deleteme.tif");
double z = 0.0;
Ztrack.locate_best_fit_in_depth(*discs[5], 0, 64, 64, z);
printf("Z best fit should be 5, found at %lf\n", z);
// Test the optimization code
Ztrack.optimize(*discs[7], 0, 64, 64, z);
printf("Z optimum should be 7, found at %lf\n", z);
// Test on a novel image
disc_image test_disc(0,128, 0,128, 0, 0.0, 64,64, 5.5+10, 255, 4);
Ztrack.optimize(test_disc, 0, 64, 64, z);
printf("Z optimum should be 5.5, found at %lf\n", z);
// Delete the PSF file
unlink("deleteme.tif");
return 0;
}
