void TestGPURayCaster::testSetImages()
{
	vtkImageDataPtr data = vtkImageData::New();
	cx::ImagePtr image1(new cx::Image("i1", data));
	cx::ImagePtr image2(new cx::Image("i2", data));
	cx::ImagePtr image3(new cx::Image("i3", data));
	cx::ImagePtr image4(new cx::Image("i4", data));
	cx::ImagePtr image5(new cx::Image("i5", data));
	std::vector<cx::ImagePtr> images;
	uint64_t mTime = mRep->mActor->GetMTime();
	images.push_back(image1);
	CPPUNIT_ASSERT_EQUAL((size_t)0, mRep->getImages().size());
	mRep->setImages(images);
	CPPUNIT_ASSERT_EQUAL((size_t)1, mRep->getImages().size());
	CPPUNIT_ASSERT_EQUAL(QString("i1"), mRep->getImages()[0]->getUid());
	CPPUNIT_ASSERT(mRep->mActor->GetMTime() > mTime);
	mTime = mRep->mActor->GetMTime();
	mRep->setImages(images);
	uint64_t mNewTime = mRep->mActor->GetMTime();
	CPPUNIT_ASSERT_EQUAL(mTime, mNewTime);
	
	images.push_back(image2);
	images.push_back(image3);
	images.push_back(image4);
	images.push_back(image5);
	mRep->setImages(images);
	CPPUNIT_ASSERT_EQUAL((size_t)4, mRep->getImages().size());
	CPPUNIT_ASSERT_EQUAL(QString("i1"), mRep->getImages()[0]->getUid());
	CPPUNIT_ASSERT_EQUAL(QString("i2"), mRep->getImages()[1]->getUid());
	CPPUNIT_ASSERT_EQUAL(QString("i3"), mRep->getImages()[2]->getUid());
	CPPUNIT_ASSERT_EQUAL(QString("i4"), mRep->getImages()[3]->getUid());
}
示例#2
0
int Product::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    
#ifndef QT_NO_PROPERTIES
     if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QString*>(_v) = id(); break;
        case 1: *reinterpret_cast< QString*>(_v) = description(); break;
        case 2: *reinterpret_cast< QString*>(_v) = longdescription(); break;
        case 3: *reinterpret_cast< QString*>(_v) = longtext(); break;
        case 4: *reinterpret_cast< QString*>(_v) = image1(); break;
        case 5: *reinterpret_cast< QString*>(_v) = image2(); break;
        case 6: *reinterpret_cast< QString*>(_v) = image3(); break;
        case 7: *reinterpret_cast< QString*>(_v) = catid(); break;
        case 8: *reinterpret_cast< QString*>(_v) = subcatid(); break;
        }
        _id -= 9;
    } else if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: setId(*reinterpret_cast< QString*>(_v)); break;
        case 1: setDescription(*reinterpret_cast< QString*>(_v)); break;
        case 2: setLongDescription(*reinterpret_cast< QString*>(_v)); break;
        case 3: setLongText(*reinterpret_cast< QString*>(_v)); break;
        case 4: setImage1(*reinterpret_cast< QString*>(_v)); break;
        case 5: setImage2(*reinterpret_cast< QString*>(_v)); break;
        case 6: setImage2(*reinterpret_cast< QString*>(_v)); break;
        case 7: setCatId(*reinterpret_cast< QString*>(_v)); break;
        case 8: setSubCatId(*reinterpret_cast< QString*>(_v)); break;
        }
        _id -= 9;
    } else if (_c == QMetaObject::ResetProperty) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 9;
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
        if (_id < 9)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 9;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
void	ImageTest::testShortImage() {
	debug(LOG_DEBUG, DEBUG_LOG, 0, "testShortImage() begin");
	Image<unsigned short>	image2(640, 480);
	convertImage(image2, *image);
	CPPUNIT_ASSERT(image2.pixel(13, 15) == ((13 + 15 * 640) % 160) * 256);
	Image<unsigned char>	image3(640,480);
	convertImage(image3, image2);
	CPPUNIT_ASSERT(image3 == *image);
	image3.pixel(14, 15) = 1;
	CPPUNIT_ASSERT(!(image3 == *image));
	debug(LOG_DEBUG, DEBUG_LOG, 0, "testShortImage() end");
}
    void MultiVolumeRaycaster::updateResult(DataContainer& dataContainer) {
        ImageRepresentationGL::ScopedRepresentation image1(dataContainer, p_sourceImage1.getValue());
        ImageRepresentationGL::ScopedRepresentation image2(dataContainer, p_sourceImage2.getValue());
        ImageRepresentationGL::ScopedRepresentation image3(dataContainer, p_sourceImage3.getValue());
        ScopedTypedData<CameraData> camera(dataContainer, p_camera.getValue());
        ScopedTypedData<RenderData> geometryImage(dataContainer, p_geometryImageId.getValue(), true);
        ScopedTypedData<LightSourceData> light(dataContainer, p_lightId.getValue());

        std::vector<const ImageRepresentationGL*> images;
        if (image1) {
            images.push_back(image1);

            if (getInvalidationLevel() & INVALID_VOXEL_HIERARCHY1){
                _vhm1->createHierarchy(image1, p_transferFunction1.getTF());
                validate(INVALID_VOXEL_HIERARCHY1);
            }
        }
        if (image2) {
            images.push_back(image2);

            if (getInvalidationLevel() & INVALID_VOXEL_HIERARCHY2){
                _vhm2->createHierarchy(image2, p_transferFunction2.getTF());
                validate(INVALID_VOXEL_HIERARCHY2);
            }
        }
        if (image3) {
            images.push_back(image3);

            if (getInvalidationLevel() & INVALID_VOXEL_HIERARCHY3){
                _vhm3->createHierarchy(image3, p_transferFunction3.getTF());
                validate(INVALID_VOXEL_HIERARCHY3);
            }
        }
        

        if (images.size() >= 3 && camera != nullptr) {
            auto eepp = computeEntryExitPoints(images, camera, geometryImage);
            dataContainer.addData(p_outputImageId.getValue() + ".entrypoints", eepp.first);
            dataContainer.addData(p_outputImageId.getValue() + ".exitpoints", eepp.second);

            auto rc = performRaycasting(dataContainer, images, camera, eepp.first, eepp.second, light);
            dataContainer.addData(p_outputImageId.getValue(), rc);
        }
        else {
            LDEBUG("No suitable input data found!");
        }
    }
    void MultiVolumeRaycaster::updateProperties(DataContainer& dataContainer) {
        ImageRepresentationGL::ScopedRepresentation image1(dataContainer, p_sourceImage1.getValue());
        ImageRepresentationGL::ScopedRepresentation image2(dataContainer, p_sourceImage2.getValue());
        ImageRepresentationGL::ScopedRepresentation image3(dataContainer, p_sourceImage3.getValue());

        if (image1)
            p_transferFunction1.setImageHandle(image1.getDataHandle());
        else
            p_transferFunction1.setImageHandle(DataHandle(nullptr));

        if (image2)
            p_transferFunction2.setImageHandle(image2.getDataHandle());
        else
            p_transferFunction2.setImageHandle(DataHandle(nullptr));

        if (image3)
            p_transferFunction3.setImageHandle(image3.getDataHandle());
        else
            p_transferFunction3.setImageHandle(DataHandle(nullptr));
    }
void	ImageTest::testYUYVImage() {
	debug(LOG_DEBUG, DEBUG_LOG, 0, "testYUYVImage() begin");
	// test the conversion of an individual pixel
	YUYV<unsigned char>	p((unsigned char)47, 11);
	unsigned char	v;
	convertPixel(v, p);
	CPPUNIT_ASSERT(47 == v);

	// convert a complete image
	Image<YUYV<unsigned char> >	image2(640, 480);
	convertImage(image2, *image);
	CPPUNIT_ASSERT(image2.pixel(13, 15).y == (13 + 15 * 640) % 160);

	// convert to an unsigned short image
	Image<unsigned char>	image3(640, 480);
	convertImage(image3, image2);
	CPPUNIT_ASSERT(image3 == *image);
	image3.pixel(14,15) = 1;
	CPPUNIT_ASSERT(!(image3 == *image));
	debug(LOG_DEBUG, DEBUG_LOG, 0, "testYUYVImage() end");
}
示例#7
0
    void TerrainWeightEditor::DecomposeImageToCanvases(const QImage& image)
    {
        QLabel *canvas1 = editor_widget_->findChild<QLabel *>("canvas_1");
        QLabel *canvas2 = editor_widget_->findChild<QLabel *>("canvas_2");
        QLabel *canvas3 = editor_widget_->findChild<QLabel *>("canvas_3");
        QLabel *canvas4 = editor_widget_->findChild<QLabel *>("canvas_4");
        assert(canvas1 && canvas2 && canvas3 && canvas4);

        int width = image.width();
        int height = image.height();
        QImage::Format format = image.format();

        QImage image1(width,height,format);
        QImage image2(width,height,format);
        QImage image3(width,height,format);
        QImage image4(width,height,format);

        for(int i=0;i<width;i++)
        {
            for(int j=0; j<height;j++)
            {
                QRgb color = image.pixel(i,j);
                int alpha = qAlpha(color);
                int red = qRed(color);
                int green = qGreen(color);
                int blue = qBlue(color);

                image1.setPixel(i,j, QColor(red,red,red).rgba());
                image2.setPixel(i,j, QColor(green,green,green).rgba());
                image3.setPixel(i,j, QColor(blue,blue,blue).rgba());
                image4.setPixel(i,j, QColor(alpha,alpha,alpha).rgba());
            }
        }

        canvas1->setPixmap(QPixmap::fromImage(image1));
        canvas2->setPixmap(QPixmap::fromImage(image2));
        canvas3->setPixmap(QPixmap::fromImage(image3));
        canvas4->setPixmap(QPixmap::fromImage(image4));
    }
示例#8
0
文件: testcube.cpp 项目: nordewal/sfm
void TestCube::setPairs(vector<shared_ptr<ImagePair>> &pairs) {
  shared_ptr<Image> image1(new Image());
  shared_ptr<Image> image2(new Image());
  shared_ptr<Image> image3(new Image());
  shared_ptr<ImagePair> pair1(new ImagePair());
  shared_ptr<ImagePair> pair2(new ImagePair());

  pair1->image1 = image1;
  pair1->image2 = image2;
  pair2->image1 = image2;
  pair2->image2 = image3;

  TestCube::setKeypointsImg1(image1->keypoints_);
  TestCube::setKeypointsImg2(image2->keypoints_);
  TestCube::setKeypointsImg3(image3->keypoints_);

  TestCube::setMatches(8, pair1->matches);
  TestCube::setMatches(9, pair2->matches);

  pairs.push_back(pair1);
  pairs.push_back(pair2);
}
示例#9
0
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);
}
示例#10
0
void WindowTexture::generateWindowTexture()  //randomly generate windows texture for buildings
{
    CBitmap image0("building/texture/1.bmp");    

    glBindTexture(GL_TEXTURE_2D, m_nTextureId[0]);    //bind this texture to be active
    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,image0.GetWidth(),image0.GetHeight(),0,GL_RGBA,GL_UNSIGNED_BYTE,image0.GetBits()); //load data into texture
        
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); //specify minificaton filtering
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); //specify magnificaton filtering

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);    //specify texture coordinate treatment
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);    //specify texture coordinate treatment

    glEnable(GL_TEXTURE_2D);

    CBitmap image1("building/texture/2.bmp");    

    glBindTexture(GL_TEXTURE_2D, m_nTextureId[1]);    //bind this texture to be active
    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,image1.GetWidth(),image1.GetHeight(),0,GL_RGBA,GL_UNSIGNED_BYTE,image1.GetBits()); //load data into texture
        
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); //specify minificaton filtering
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); //specify magnificaton filtering

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);    //specify texture coordinate treatment
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);    //specify texture coordinate treatment

    glEnable(GL_TEXTURE_2D);

    CBitmap image2("building/texture/3.bmp");    

    glBindTexture(GL_TEXTURE_2D, m_nTextureId[2]);    //bind this texture to be active
    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,image2.GetWidth(),image2.GetHeight(),0,GL_RGBA,GL_UNSIGNED_BYTE,image2.GetBits()); //load data into texture
        
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); //specify minificaton filtering
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); //specify magnificaton filtering

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);    //specify texture coordinate treatment
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);    //specify texture coordinate treatment

    glEnable(GL_TEXTURE_2D);

    CBitmap image3("building/texture/4.bmp");    

    glBindTexture(GL_TEXTURE_2D, m_nTextureId[3]);    //bind this texture to be active
    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,image3.GetWidth(),image3.GetHeight(),0,GL_RGBA,GL_UNSIGNED_BYTE,image3.GetBits()); //load data into texture
        
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); //specify minificaton filtering
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); //specify magnificaton filtering

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);    //specify texture coordinate treatment
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);    //specify texture coordinate treatment

    glEnable(GL_TEXTURE_2D);

    CBitmap image4("building/texture/5.bmp");    

    glBindTexture(GL_TEXTURE_2D, m_nTextureId[4]);    //bind this texture to be active
    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,image4.GetWidth(),image4.GetHeight(),0,GL_RGBA,GL_UNSIGNED_BYTE,image4.GetBits()); //load data into texture
        
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); //specify minificaton filtering
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); //specify magnificaton filtering

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);    //specify texture coordinate treatment
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);    //specify texture coordinate treatment

    glEnable(GL_TEXTURE_2D);

    CBitmap image100("building/texture/mailbox_asdf.bmp");

    glBindTexture(GL_TEXTURE_2D, m_nTextureId[numTex]);    //bind this texture to be active
    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,image100.GetWidth(),image100.GetHeight(),0,GL_RGBA,GL_UNSIGNED_BYTE,image100.GetBits()); //load data into texture
        
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); //specify minificaton filtering
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); //specify magnificaton filtering

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);    //specify texture coordinate treatment
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);    //specify texture coordinate treatment

    glEnable(GL_TEXTURE_2D);

    textureBounded = true;
}
示例#11
0
/* 
 *  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()) );

}
示例#12
0
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;
}
示例#13
0
void StatusBar::drawOn(Surface & surface)
{
	
	switch (lives)
	{
		case 3: 
		{
			Image image("images/galaxian/GalaxianGalaxip.gif");
		    Rect rect = image.getRect();
		    rect.x = W-32;
		    rect.y = H-32;

		    surface.put_image(image, rect);

		    Image image2("images/galaxian/GalaxianGalaxip.gif");
		    Rect rect2 = image2.getRect();
		    rect2.x = W-64;
		    rect2.y = H-32;

		    surface.put_image(image2, rect2);

		    Image image3("images/galaxian/GalaxianGalaxip.gif");
		    Rect rect3 = image3.getRect();
		    rect3.x = W-96;
		    rect3.y = H-32;

		    surface.put_image(image3, rect3);
		    break;
		}
		case 2:
		{
			Image image("images/galaxian/GalaxianGalaxip.gif");
		    Rect rect = image.getRect();
		    rect.x = W-32;
		    rect.y = H-32;

		    surface.put_image(image, rect);

		    Image image2("images/galaxian/GalaxianGalaxip.gif");
		    Rect rect2 = image2.getRect();
		    rect2.x = W-64;
		    rect2.y = H-32;

		    surface.put_image(image2, rect2);
		    break;
		}
		case 1:
		{
			Image image("images/galaxian/GalaxianGalaxip.gif");
		    Rect rect = image.getRect();
		    rect.x = W-32;
		    rect.y = H-32;

		    surface.put_image(image, rect);
		    break;
		}
		default:
		break;
	}

	//printing score
	Font font("fonts/FreeSans.ttf", 32);
	Color c = {0,255,0};
	Color b = {225,255, 0};

	Image imagescoretext(font.render("Score:",c));
	Rect rectscoretext = imagescoretext.getRect();
	rectscoretext.x = 5;
	rectscoretext.y = H- 42;

	surface.put_image(imagescoretext, rectscoretext);

	//converting int to string
	std::stringstream strmsc;
	strmsc << score;

	Image imagescore(font.render(strmsc.str().c_str(), b));
	Rect rectscore = imagescore.getRect();
	rectscore.x = 170;
	rectscore.y = H-42;

	surface.put_image(imagescore, rectscore);

	Image imagehittext(font.render("Kills:",c));
	Rect recthittext = imagehittext.getRect();
	recthittext.x = 300;
	recthittext.y = H- 42;

	surface.put_image(imagehittext, recthittext);


	std::stringstream strmki;
	strmki << kills;

	Image imagekills(font.render(strmki.str().c_str(), b));
	Rect rectkills = imagekills.getRect();
	rectkills.x = 430;
	rectkills.y = H-42;

	surface.put_image(imagekills, rectkills);
}