static int test_jprobes(void)
{
int ret;
struct jprobe *jps[2] = {&jp, &jp2};
/* */
jp.kp.addr = NULL;
jp.kp.flags = 0;
ret = register_jprobes(jps, 2);
if (ret < 0) {
printk(KERN_ERR "Kprobe smoke test failed: "
"register_jprobes returned %d\n", ret);
return ret;
}
jph_val = 0;
ret = target(rand1);
if (jph_val == 0) {
printk(KERN_ERR "Kprobe smoke test failed: "
"jprobe handler not called\n");
handler_errors++;
}
jph_val = 0;
ret = target2(rand1);
if (jph_val == 0) {
printk(KERN_ERR "Kprobe smoke test failed: "
"jprobe handler2 not called\n");
handler_errors++;
}
unregister_jprobes(jps, 2);
return 0;
}
static int test_kretprobes(void)
{
int ret;
struct kretprobe *rps[2] = {&rp, &rp2};
/* */
rp.kp.addr = NULL;
rp.kp.flags = 0;
ret = register_kretprobes(rps, 2);
if (ret < 0) {
printk(KERN_ERR "Kprobe smoke test failed: "
"register_kretprobe returned %d\n", ret);
return ret;
}
krph_val = 0;
ret = target(rand1);
if (krph_val != rand1) {
printk(KERN_ERR "Kprobe smoke test failed: "
"kretprobe handler not called\n");
handler_errors++;
}
krph_val = 0;
ret = target2(rand1);
if (krph_val != rand1) {
printk(KERN_ERR "Kprobe smoke test failed: "
"kretprobe handler2 not called\n");
handler_errors++;
}
unregister_kretprobes(rps, 2);
return 0;
}
static int test_kprobes(void)
{
int ret;
struct kprobe *kps[2] = {&kp, &kp2};
/* */
kp.addr = NULL;
kp.flags = 0;
ret = register_kprobes(kps, 2);
if (ret < 0) {
printk(KERN_ERR "Kprobe smoke test failed: "
"register_kprobes returned %d\n", ret);
return ret;
}
preh_val = 0;
posth_val = 0;
ret = target(rand1);
if (preh_val == 0) {
printk(KERN_ERR "Kprobe smoke test failed: "
"kprobe pre_handler not called\n");
handler_errors++;
}
if (posth_val == 0) {
printk(KERN_ERR "Kprobe smoke test failed: "
"kprobe post_handler not called\n");
handler_errors++;
}
preh_val = 0;
posth_val = 0;
ret = target2(rand1);
if (preh_val == 0) {
printk(KERN_ERR "Kprobe smoke test failed: "
"kprobe pre_handler2 not called\n");
handler_errors++;
}
if (posth_val == 0) {
printk(KERN_ERR "Kprobe smoke test failed: "
"kprobe post_handler2 not called\n");
handler_errors++;
}
unregister_kprobes(kps, 2);
return 0;
}
JNIEXPORT void JNICALL
Java_org_apache_subversion_javahl_SVNClient_diff__Ljava_lang_String_2Lorg_apache_subversion_javahl_types_Revision_2Ljava_lang_String_2Lorg_apache_subversion_javahl_types_Revision_2Ljava_lang_String_2Ljava_io_OutputStream_2Lorg_apache_subversion_javahl_types_Depth_2Ljava_util_Collection_2ZZZZZ
(JNIEnv *env, jobject jthis, jstring jtarget1, jobject jrevision1,
jstring jtarget2, jobject jrevision2, jstring jrelativeToDir,
jobject jstream, jobject jdepth, jobject jchangelists,
jboolean jignoreAncestry, jboolean jnoDiffDeleted, jboolean jforce,
jboolean jcopiesAsAdds, jboolean jignoreProps)
{
JNIEntry(SVNClient, diff);
SVNClient *cl = SVNClient::getCppObject(jthis);
if (cl == NULL)
{
JNIUtil::throwError(_("bad C++ this"));
return;
}
JNIStringHolder target1(jtarget1);
if (JNIUtil::isExceptionThrown())
return;
Revision revision1(jrevision1);
if (JNIUtil::isExceptionThrown())
return;
JNIStringHolder target2(jtarget2);
if (JNIUtil::isExceptionThrown())
return;
Revision revision2(jrevision2);
if (JNIUtil::isExceptionThrown())
return;
JNIStringHolder relativeToDir(jrelativeToDir);
if (JNIUtil::isExceptionThrown())
return;
OutputStream dataOut(jstream);
if (JNIUtil::isExceptionThrown())
return;
StringArray changelists(jchangelists);
if (JNIUtil::isExceptionThrown())
return;
cl->diff(target1, revision1, target2, revision2, relativeToDir, dataOut,
EnumMapper::toDepth(jdepth), changelists,
jignoreAncestry ? true:false,
jnoDiffDeleted ? true:false, jforce ? true:false,
jcopiesAsAdds ? true:false, jignoreProps ? true:false);
}
JNIEXPORT void JNICALL
Java_org_apache_subversion_javahl_SVNClient_diffSummarize__Ljava_lang_String_2Lorg_apache_subversion_javahl_types_Revision_2Ljava_lang_String_2Lorg_apache_subversion_javahl_types_Revision_2Lorg_apache_subversion_javahl_types_Depth_2Ljava_util_Collection_2ZLorg_apache_subversion_javahl_callback_DiffSummaryCallback_2
(JNIEnv *env, jobject jthis, jstring jtarget1, jobject jrevision1,
jstring jtarget2, jobject jrevision2, jobject jdepth, jobject jchangelists,
jboolean jignoreAncestry, jobject jdiffSummaryReceiver)
{
JNIEntry(SVNClient, diffSummarize);
SVNClient *cl = SVNClient::getCppObject(jthis);
if (cl == NULL)
{
JNIUtil::throwError(_("bad C++ this"));
return;
}
JNIStringHolder target1(jtarget1);
if (JNIUtil::isExceptionThrown())
return;
Revision revision1(jrevision1);
if (JNIUtil::isExceptionThrown())
return;
JNIStringHolder target2(jtarget2);
if (JNIUtil::isExceptionThrown())
return;
Revision revision2(jrevision2);
if (JNIUtil::isExceptionThrown())
return;
DiffSummaryReceiver receiver(jdiffSummaryReceiver);
if (JNIUtil::isExceptionThrown())
return;
StringArray changelists(jchangelists);
if (JNIUtil::isExceptionThrown())
return;
cl->diffSummarize(target1, revision1, target2, revision2,
EnumMapper::toDepth(jdepth), changelists,
jignoreAncestry ? true: false, receiver);
}
void julianOperatorTest()
{
JulianDate target1(2006, 3, 6);
JulianDate target2(2006, 3, 7);
JulianDate target1_(2006, 3, 6);
CPPUNIT_ASSERT(!(target1 == target2));
CPPUNIT_ASSERT(target1 == target1_);
CPPUNIT_ASSERT(target1 != target2);
CPPUNIT_ASSERT(!(target1 != target1_));
CPPUNIT_ASSERT(target1 < target2);
CPPUNIT_ASSERT(!(target1 < target1_));
CPPUNIT_ASSERT(target1 <= target1_);
CPPUNIT_ASSERT(target1 <= target2);
CPPUNIT_ASSERT(!(target2 <= target1));
CPPUNIT_ASSERT(target2 > target1);
CPPUNIT_ASSERT(!(target1 > target2));
CPPUNIT_ASSERT(target1 >= target1_);
CPPUNIT_ASSERT(target2 >= target1_);
CPPUNIT_ASSERT(!(target1 >= target2));
}
void main()
{
bool patternfound = false;
bool resetAuto = false;
int nbImages = 0;
double moyFinale = 0;
bool detectionVisage = false;
int nbrLoopSinceLastDetection = 0;
int criticalValueOfLoopWithoutDetection = 15;
std::cout << "initialisation de Chehra..." << std::endl;
Chehra chehra;
std::cout << "done" << std::endl;
cv::Mat cameraMatrix, distCoeffs;
cv::Mat rvecs, tvecs;
std::vector<cv::Point2f> imagePoints;
std::vector<cv::Point2f> pointsVisage2D;
std::vector<cv::Point2f> moyPointsVisage2D;
std::vector<cv::Point3f> pointsVisage3D;
std::vector<cv::Point3f> visage;
std::vector<double> distances;
double moyDistances;
std::vector<std::vector<cv::Point2f>> images;
std::vector<cv::Mat> frames;
double s = 10.0f;
osg::Matrixd matrixS; // scale
matrixS.set(
s, 0, 0, 0,
0, s, 0, 0,
0, 0, s, 0,
0, 0, 0, 1);
pointsVisage3D.push_back(cv::Point3f(90,0,-80));
pointsVisage3D.push_back(cv::Point3f(-90,0,-80));
pointsVisage3D.push_back(cv::Point3f(0,0,0));
pointsVisage3D.push_back(cv::Point3f(600,0,600));
pointsVisage3D.push_back(cv::Point3f(0,0,600));
pointsVisage3D.push_back(cv::Point3f(-600,0,600));
/*
pointsVisage3D.push_back(cv::Point3f(13.1, -98.1,108.3)); // exterieur narine gauche
pointsVisage3D.push_back(cv::Point3f(-13.1, -98.1,108.3)); // exterieur narine droite
pointsVisage3D.push_back(cv::Point3f(0, -87.2, 124.2)); // bout du nez
pointsVisage3D.push_back(cv::Point3f(44.4, -57.9, 83.7)); // exterieur oeil gauche
pointsVisage3D.push_back(cv::Point3f(0, 55.4, 101.4)); // haut du nez, centre des yeux
pointsVisage3D.push_back(cv::Point3f(-44.4, -57.9, 83.7)); // exterieur oeil droit
*/
cv::FileStorage fs("../rsc/intrinsicMatrix.yml", cv::FileStorage::READ);
fs["cameraMatrix"] >> cameraMatrix;
fs["distCoeffs"] >> distCoeffs;
double f = (cameraMatrix.at<double>(0, 0) + cameraMatrix.at<double>(1, 1)) / 2; // NEAR = distance focale ; si pixels carrés, fx = fy -> np
//mais est généralement différent de fy donc on prend (pour l'instant) par défaut la valeur médiane
double g = 2000 * f; // je sais pas pourquoi. au pif.
fs.release();
cv::VideoCapture vcap(0);
if(!vcap.isOpened())
{
std::cout << "FAIL!" << std::endl;
return;
}
cv::Mat *frame = new cv::Mat(cv::Mat::zeros(vcap.get(CV_CAP_PROP_FRAME_HEIGHT), vcap.get(CV_CAP_PROP_FRAME_WIDTH), CV_8UC3));
do
{
vcap >> *frame;
}while(frame->empty());
osg::ref_ptr<osg::Image> backgroundImage = new osg::Image;
backgroundImage->setImage(frame->cols, frame->rows, 3,
GL_RGB, GL_BGR, GL_UNSIGNED_BYTE,
(uchar*)(frame->data),
osg::Image::AllocationMode::NO_DELETE, 1);
// read the scene from the list of file specified commandline args.
osg::ref_ptr<osg::Group> group = new osg::Group;
osg::ref_ptr<osg::Geode> cam = createHUD(backgroundImage, vcap.get(CV_CAP_PROP_FRAME_WIDTH), vcap.get(CV_CAP_PROP_FRAME_HEIGHT), cameraMatrix.at<double>(0, 2), cameraMatrix.at<double>(1, 2), f);
std::cout << "initialisation de l'objet 3D..." << std::endl;
osg::ref_ptr<osg::Node> objet3D = osgDB::readNodeFile("../rsc/objets3D/brain.obj");
//osg::ref_ptr<osg::Node> objet3D = osgDB::readNodeFile("../rsc/objets3D/dumptruck.osgt");
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
osg::Sphere* unitSphere = new osg::Sphere(osg::Vec3(0, -1000, 1000), 100.0);
osg::ShapeDrawable* unitSphereDrawable = new osg::ShapeDrawable(unitSphere);
osg::Geode* objet3D = new osg::Geode();
objet3D->addDrawable(unitSphereDrawable);
*/
//osg::StateSet* sphereStateset = unitSphereDrawable->getOrCreateStateSet();
//sphereStateset->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
//sphereStateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
std::cout << "done" << std::endl;
osg::StateSet* obectStateset = objet3D->getOrCreateStateSet();
obectStateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
obectStateset->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
osg::ref_ptr<osg::MatrixTransform> mat = new osg::MatrixTransform();
// construct the viewer.
osgViewer::CompositeViewer compositeViewer;
osgViewer::View* viewer = new osgViewer::View;
osgViewer::View* viewer2 = new osgViewer::View;
// add the HUD subgraph.
group->addChild(cam);
mat->addChild(objet3D);
group->addChild(mat);
osg::Matrixd projectionMatrix;
projectionMatrix.makeFrustum(
-cameraMatrix.at<double>(0, 2), vcap.get(CV_CAP_PROP_FRAME_WIDTH) - cameraMatrix.at<double>(0, 2),
-cameraMatrix.at<double>(1, 2), vcap.get(CV_CAP_PROP_FRAME_HEIGHT) - cameraMatrix.at<double>(1, 2),
f, g);
osg::Vec3d eye(0.0f, 0.0f, 0.0f), target(0.0f, g, 0.0f), normal(0.0f, 0.0f, 1.0f);
// set the scene to render
viewer->setSceneData(group.get());
viewer->setUpViewInWindow(0, 0, 1920 / 2, 1080 / 2);
viewer->getCamera()->setProjectionMatrix(projectionMatrix);
viewer->getCamera()->setViewMatrixAsLookAt(eye, target, normal);
viewer2->setSceneData(group.get());
viewer2->setUpViewInWindow(1920 / 2, 0, 1920 / 2, 1080 / 2);
viewer2->getCamera()->setProjectionMatrix(projectionMatrix);
osg::Vec3d eye2(4 * f, 3 * f / 2, 0.0f), target2(0.0f, f, 0.0f), normal2(0.0f, 0.0f, 1.0f);
viewer2->getCamera()->setViewMatrixAsLookAt(eye2, target2, normal2);
compositeViewer.addView(viewer2);
compositeViewer.addView(viewer);
compositeViewer.realize(); // set up windows and associated threads.
do
{
patternfound = false;
resetAuto = false;
detectionVisage = false;
moyPointsVisage2D.clear();
pointsVisage2D.clear();
visage.clear();
moyDistances = 0;
distances.clear();
std::cout << "recherche de pattern" << std::endl
<< "nbr images sauvegardees : " << images.size() << std::endl;
vcap >> *frame;
frames.push_back(*frame);
detectionVisage = detecterVisage(frame, &chehra, &pointsVisage2D, &visage);
if(detectionVisage)
{
images.push_back(pointsVisage2D);
nbrLoopSinceLastDetection = 0;
group->addChild(mat);
}
else
nbrLoopSinceLastDetection++;
if((images.size() > NBRSAVEDIMAGES || nbrLoopSinceLastDetection > criticalValueOfLoopWithoutDetection) && !images.empty())
images.erase(images.begin());
if(images.empty())
group->removeChild(mat);
else
{
//cv::cornerSubPix(*frame, pointsVisage2D, cv::Size(5, 5), cv::Size(-1, -1), cv::TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
for(int i = 0; i < NBRFACEPOINTSDETECTED; i++)
{
cv::Point2f coordonee(0.0f, 0.0f);
for(int j = 0; j < images.size(); j++)
{
coordonee.x += images[j][i].x;
coordonee.y += images[j][i].y;
}
coordonee.x /= images.size();
coordonee.y /= images.size();
moyPointsVisage2D.push_back(coordonee);
}
cv::solvePnP(pointsVisage3D, moyPointsVisage2D, cameraMatrix, distCoeffs, rvecs, tvecs);
cv::Mat rotVec(3, 3, CV_64F);
cv::Rodrigues(rvecs, rotVec);
imagePoints = dessinerPoints(frame, pointsVisage3D, rotVec, tvecs, cameraMatrix, distCoeffs);
double t3 = tvecs.at<double>(2, 0);
double t1 = tvecs.at<double>(0, 0);
double t2 = tvecs.at<double>(1, 0) + t3 / 27.5; // and now, magic !
double r11 = rotVec.at<double>(0, 0);
double r12 = rotVec.at<double>(0, 1);
double r13 = rotVec.at<double>(0, 2);
double r21 = rotVec.at<double>(1, 0);
double r22 = rotVec.at<double>(1, 1);
double r23 = rotVec.at<double>(1, 2);
double r31 = rotVec.at<double>(2, 0);
double r32 = rotVec.at<double>(2, 1);
double r33 = rotVec.at<double>(2, 2);
osg::Matrixd matrixR; // rotation (transposee de rotVec)
matrixR.set(
r11, r21, r31, 0,
r12, r22, r32, 0,
r13, r23, r33, 0,
0, 0, 0, 1);
osg::Matrixd matrixT; // translation
matrixT.makeTranslate(t1, t2, t3);
osg::Matrixd matrix90; // rotation de repere entre opencv et osg
matrix90.makeRotate(osg::Quat(osg::DegreesToRadians(-90.0f), osg::Vec3d(1.0, 0.0, 0.0)));
mat->setMatrix(matrixS * matrixR * matrixT * matrix90);
// Calcul d'erreur de reprojection
double moy = 0;
for(int i = 0; i < pointsVisage2D.size(); i++)
{
double d = sqrt(pow(pointsVisage2D[i].y - imagePoints[i].y, 2) + pow(pointsVisage2D[i].x - imagePoints[i].x, 2));
distances.push_back(d);
moy += d;
}
moyDistances = moy / pointsVisage2D.size();
if(moyDistances > 2) // si l'ecart de reproj est trop grand, reset
resetAuto = true;
}
backgroundImage->dirty();
compositeViewer.frame();
}while(!compositeViewer.done());
}
bool Setup()
{
D3DXVECTOR3 lightDirection(0.0f, 1.0f, 0.0f);
TheTerrain = new Terrain(Device, "Faces.raw", 734,1024,20,1.0f);
TheTerrain->genTexture(&lightDirection);
TheTerrain->loadTexture("Faces.jpg");
D3DXCreateFont(Device, 20, 0, FW_BOLD, 0, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, TEXT("Arial"), &m_font );
//
// Lights.
//
Barrels.init(Device, "barells/barrels.x");
Dalek.init(Device, "dalek/dalek.x");
tank.init(Device, "Oiltank/tank.x");
Table.init(Device, "table/table.x");
Ton.init(Device, "ton/ton3.x");
Tree.init(Device, "trees/palm_tree_3.x");
numbertrees = rand() % 100 - 1;
for(int i = 0; i < 10; i++)
BoolTrash[i] = true;
D3DXCreateSprite(Device, &spriteMap);
D3DXCreateSprite(Device, &spritePlayer);
for(int i = 0; i < 10; i++)
{
D3DXCreateSprite(Device, &spriteTrash[i]);
}
D3DXCreateTextureFromFile(Device, "Map.png", &texMap);
srand(GetTickCount());
TrashPositions[0].x = rand() % 360 - 180;
TrashPositions[0].z = rand() % 360 - 180;
float height = TheTerrain->getHeight(TrashPositions[0].x, TrashPositions[0].z);
TrashPositions[0].y = height;
TrashPositions[1].x = rand() % 360 - 180;
TrashPositions[1].z = rand() % 360 - 180;
height = TheTerrain->getHeight(TrashPositions[1].x, TrashPositions[1].z);
TrashPositions[1].y = height;
TrashPositions[2].x = rand() % 360 - 180;
TrashPositions[2].z = rand() % 360 - 180;
height = TheTerrain->getHeight(TrashPositions[2].x, TrashPositions[2].z);
TrashPositions[2].y = height;
TrashPositions[3].x = rand() % 360 - 180;
TrashPositions[3].z = rand() % 360 - 180;
height = TheTerrain->getHeight(TrashPositions[3].x, TrashPositions[3].z);
TrashPositions[3].y = height;
TrashPositions[4].x = rand() % 360 - 180;
TrashPositions[4].z = rand() % 360 - 180;
height = TheTerrain->getHeight(TrashPositions[4].x, TrashPositions[4].z);
TrashPositions[4].y = height;
TrashPositions[5].x = rand() % 360 - 180;
TrashPositions[5].z = rand() % 360 - 180;
height = TheTerrain->getHeight(TrashPositions[5].x, TrashPositions[5].z);
TrashPositions[5].y = height;
TrashPositions[6].x = rand() % 360 - 180;
TrashPositions[6].z = rand() % 360 - 180;
height = TheTerrain->getHeight(TrashPositions[6].x, TrashPositions[6].z);
TrashPositions[6].y = height;
TrashPositions[7].x = rand() % 360 - 180;
TrashPositions[7].z = rand() % 360 - 180;
height = TheTerrain->getHeight(TrashPositions[7].x, TrashPositions[7].z);
TrashPositions[7].y = height;
TrashPositions[8].x = rand() % 360 - 180;
TrashPositions[8].z = rand() % 360 - 180;
height = TheTerrain->getHeight(TrashPositions[8].x, TrashPositions[8].z);
TrashPositions[8].y = height;
TrashPositions[9].x = rand() % 360 - 180;
TrashPositions[9].z = rand() % 360 - 180;
height = TheTerrain->getHeight(TrashPositions[9].x, TrashPositions[9].z);
TrashPositions[9].y = height;
for(int i = 0; i < numbertrees; i++)
{
TreePositions[i].x = rand() % 360 - 180;
TreePositions[i].z = rand() % 360 - 180;
height = TheTerrain->getHeight(TreePositions[i].x, TreePositions[i].z);
TreePositions[i].y = height;
}
D3DXVECTOR3 lightDir(0.707f, -0.707f, 0.707f);
D3DXCOLOR color(1.0f, 1.0f, 1.0f, 1.0f);
D3DLIGHT9 light = d3d::InitDirectionalLight(&lightDir, &color);
Device->SetLight(0, &light);
Device->LightEnable(0, true);
Device->SetRenderState(D3DRS_NORMALIZENORMALS, true);
Device->SetRenderState(D3DRS_SPECULARENABLE, true);
//build skybox
BuildSkybox(Device);
//
// Set Camera.
//
D3DXVECTOR3 pos(-0.0f, -197.0f, -0.0f);
D3DXVECTOR3 target(0.0, 0.0f, 0.0f);
D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
D3DXMATRIX V;
D3DXMatrixLookAtLH(&V, &pos, &target, &up);
Device->SetTransform(D3DTS_VIEW, &V);
D3DXVECTOR3 pos2(-0.0f, -10.0f, 0.0f);
D3DXVECTOR3 target2(0.0, 0.0f, 0.0f);
D3DXVECTOR3 up2(0.0f, 1.0f, 0.0f);
// D3DXMATRIX V;
D3DXMatrixLookAtLH(&mview, &pos2, &target2, &up2);
//Device->SetTransform(D3DTS_VIEW, &mview);
//
// Set projection matrix.
//
D3DXMATRIX proj;
D3DXMatrixPerspectiveFovLH(
&proj,
D3DX_PI / 4.0f, // 45 - degree
(float)Width / (float)Height,
1.0f,
20001.0f);
Device->SetTransform(D3DTS_PROJECTION, &proj);
D3DXMatrixPerspectiveFovLH(&mprojection, D3DX_PI / 4.0f, (float)Width / (float)Height, 1.0f, 20001.0f);
//Device->SetTransform(D3DTS_PROJECTION, &mprojection);
return true;
}
/** \brief Create progessive icon
Do QIcon with top and bottom image mixed and percent writed on it.
The icon it be search in the style path.
Do by mongaulois, remake by alpha_one_x86.
\param percent indique how many percent need be showed, sould be between 0 and 100
\param text The showed text if needed (optionnal)
\return QIcon of the final image
\note Can be used as it: dynaIcon(75,"...")
*/
QIcon Themes::dynaIcon(int percent,QString text) const
{
#ifdef ULTRACOPIER_PLUGIN_DEBUG
if(pixmapTop.isNull() || pixmapBottom.isNull())
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"Error loading the icons");
#endif
if(percent==-1)
percent=getOldProgression;
if(percent<0)
percent=0;
if(percent>100)
percent=100;
//pixmap avec un fond transparent
#ifdef Q_OS_WIN32
quint8 imageSize=16;
#else
quint8 imageSize=22;
#endif
QPixmap resultImage(imageSize,imageSize);
resultImage.fill(Qt::transparent);
{
QPainter painter(&resultImage);
#ifndef Q_OS_WIN32
QFont font(QStringLiteral("Courier New"),9);
font.setBold(true);
font.setKerning(true);
painter.setFont(font);
#endif
#ifdef Q_OS_WIN32
QFont font(QStringLiteral("Courier New"),8);
font.setBold(true);
font.setKerning(true);
painter.setFont(font);
#endif
//preprocessing the calcul
quint8 bottomPixel=(percent*imageSize)/100;
quint8 topPixel=imageSize-bottomPixel;
//top image
if(topPixel>0)
{
QRect target(0, 0, imageSize, topPixel);
QRect source(0, 0, imageSize, topPixel);
painter.drawPixmap(target, pixmapTop, source);
}
//bottom image
if(bottomPixel>0)
{
QRect target2(0, topPixel, imageSize, bottomPixel);
QRect source2(0, topPixel, imageSize, bottomPixel);
painter.drawPixmap(target2, pixmapBottom, source2);
}
qint8 textxOffset=0;
qint8 textyOffset=0;
if(text.isEmpty())
{
if(percent!=100)
text=QString::number(percent);
else
{
text=QStringLiteral(":)");
#ifdef Q_OS_WIN32
textyOffset-=2;
#else
textyOffset-=1;
#endif
}
}
if(text.size()==1)
{
textxOffset+=3;
#ifdef Q_OS_WIN32
textxOffset-=1;
#endif
}
else
{
#ifdef Q_OS_WIN32
textxOffset-=1;
#endif
}
#ifndef Q_OS_WIN32
textxOffset+=2;
textyOffset+=3;
#endif
painter.setPen(QPen(Qt::black));
painter.drawText(3+textxOffset,13+textyOffset,text);
painter.setPen(QPen(Qt::white));
painter.drawText(2+textxOffset,12+textyOffset,text);
}
return QIcon(resultImage);
}
void main()
{
bool patternfound = false;
bool reset = false;
bool resetAuto = false;
int nbImages = 0;
double moyFinale = 0;
char key = 0;
bool detectionMire = false;
bool detectionVisage = false;
int cpt = 0, moyCpt = 0, i = 0;
std::cout << "initialisation de Chehra..." << std::endl;
Chehra chehra;
std::cout << "done" << std::endl;
cv::TermCriteria termcrit(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03);
cv::Size winSize(31, 31);
cv::Mat cameraMatrix, distCoeffs;
cv::Mat imCalib;
cv::Mat imCalibColor;
cv::Mat imCalibNext;
cv::Mat rvecs, tvecs;
cv::Mat Rc, C = cv::Mat(3, 1, CV_64F), rotVecInv;
std::vector<cv::Point2f> imagePoints;
std::vector<cv::Point3f> objectPoints;
std::vector<cv::Point3f> cubeObjectPoints;
std::vector<cv::Point3f> dessinPointsVisage;
std::vector<std::vector<cv::Point2f>> chessCornersInit(2);
std::vector<std::vector<cv::Point2f>> pointsVisageInit(2);
std::vector<cv::Point3f> chessCorners3D;
std::vector<cv::Point3f> pointsVisage3D;
std::vector<cv::Point3f> visage;
std::vector<double> distances;
double moyDistances;
// Creation des coins de la mire
for(int x = 0; x < COLCHESSBOARD; x++)
for(int y = 0; y < ROWCHESSBOARD; y++)
chessCorners3D.push_back(cv::Point3f(x * SIZEMIRE, y * SIZEMIRE, 0.0f));
// Creation des points a projeter
for(int x = 0; x < COLCHESSBOARD; x++)
for(int y = 0; y < ROWCHESSBOARD; y++)
objectPoints.push_back(cv::Point3f(x * SIZEMIRE, y * SIZEMIRE, 0.0f));
cv::FileStorage fs("../rsc/intrinsicMatrix.yml", cv::FileStorage::READ);
fs["cameraMatrix"] >> cameraMatrix;
fs["distCoeffs"] >> distCoeffs;
double f = (cameraMatrix.at<double>(0, 0) + cameraMatrix.at<double>(1, 1)) / 2; // NEAR = distance focale ; si pixels carrés, fx = fy -> np
//mais est généralement différent de fy donc on prend (pour l'instant) par défaut la valeur médiane
double g = 2000 * f; // je sais pas pourquoi. au pif.
fs.release();
cv::VideoCapture vcap(0);
if(!vcap.isOpened()){
std::cout << "FAIL!" << std::endl;
return;
}
cv::Mat *frame = new cv::Mat(cv::Mat::zeros(vcap.get(CV_CAP_PROP_FRAME_HEIGHT), vcap.get(CV_CAP_PROP_FRAME_WIDTH), CV_8UC3));
do
{
vcap >> *frame;
}while(frame->empty());
osg::ref_ptr<osg::Image> backgroundImage = new osg::Image;
backgroundImage->setImage(frame->cols, frame->rows, 3,
GL_RGB, GL_BGR, GL_UNSIGNED_BYTE,
(uchar*)(frame->data),
osg::Image::AllocationMode::NO_DELETE, 1);
// read the scene from the list of file specified commandline args.
osg::ref_ptr<osg::Group> group = new osg::Group;
osg::ref_ptr<osg::Geode> cam = createHUD(backgroundImage, vcap.get(CV_CAP_PROP_FRAME_WIDTH), vcap.get(CV_CAP_PROP_FRAME_HEIGHT), cameraMatrix.at<double>(0, 2), cameraMatrix.at<double>(1, 2), f);
std::cout << "initialisation de l'objet 3D..." << std::endl;
osg::ref_ptr<osg::Node> objet3D = osgDB::readNodeFile("../rsc/objets3D/Creature.obj");
std::cout << "done" << std::endl;
osg::StateSet* obectStateset = objet3D->getOrCreateStateSet();
obectStateset->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
osg::ref_ptr<osg::MatrixTransform> mat = new osg::MatrixTransform();
osg::ref_ptr<osg::PositionAttitudeTransform> pat = new osg::PositionAttitudeTransform();
// construct the viewer.
osgViewer::CompositeViewer compositeViewer;
osgViewer::View* viewer = new osgViewer::View;
osgViewer::View* viewer2 = new osgViewer::View;
// add the HUD subgraph.
group->addChild(cam);
mat->addChild(objet3D);
pat->addChild(mat);
group->addChild(pat);
pat->setScale(osg::Vec3d(3, 3, 3));
osg::Matrixd projectionMatrix;
projectionMatrix.makeFrustum(
-cameraMatrix.at<double>(0, 2), vcap.get(CV_CAP_PROP_FRAME_WIDTH) - cameraMatrix.at<double>(0, 2),
-cameraMatrix.at<double>(1, 2), vcap.get(CV_CAP_PROP_FRAME_HEIGHT) - cameraMatrix.at<double>(1, 2),
f, g);
osg::Vec3d eye(0.0f, 0.0f, 0.0f), target(0.0f, g, 0.0f), normal(0.0f, 0.0f, 1.0f);
// set the scene to render
viewer->setSceneData(group.get());
viewer->setUpViewInWindow(0, 0, 1920 / 2, 1080 / 2);
viewer->getCamera()->setProjectionMatrix(projectionMatrix);
viewer->getCamera()->setViewMatrixAsLookAt(eye, target, normal);
viewer2->setSceneData(group.get());
viewer2->setUpViewInWindow(1920 / 2, 0, 1920 / 2, 1080 / 2);
viewer2->getCamera()->setProjectionMatrix(projectionMatrix);
osg::Vec3d eye2(4 * f, 3 * f / 2, 0.0f), target2(0.0f, f, 0.0f), normal2(0.0f, 0.0f, 1.0f);
viewer2->getCamera()->setViewMatrixAsLookAt(eye2, target2, normal2);
compositeViewer.addView(viewer);
compositeViewer.addView(viewer2);
compositeViewer.realize(); // set up windows and associated threads.
do
{
group->removeChild(pat);
patternfound = false;
resetAuto = false;
detectionMire = false;
detectionVisage = false;
imagePoints.clear();
chessCornersInit[0].clear();
chessCornersInit[1].clear();
pointsVisageInit[0].clear();
pointsVisageInit[1].clear();
pointsVisage3D.clear();
dessinPointsVisage.clear();
visage.clear();
moyDistances = 0;
distances.clear();
imCalibNext.release();
std::cout << "recherche de pattern" << std::endl;
time_t start = clock();
double timer = 0;
do
{
start = clock();
vcap >> *frame;
backgroundImage->dirty();
//detectionMire = detecterMire(frame, &chessCornersInit[1], &imCalibNext);
detectionVisage = detecterVisage(frame, &chehra, &pointsVisageInit[1], &visage, &pointsVisage3D, &imCalibNext);
cpt++;
double duree = (clock() - start)/(double) CLOCKS_PER_SEC;
timer += duree;
if(timer >= 1){
std::cout << cpt << " fps" << std::endl;
moyCpt += cpt;
timer = 0;
duree = 0;
i++;
cpt = 0;
start = clock();
}
compositeViewer.frame();
}while(!detectionMire && !detectionVisage && !compositeViewer.done());
if(compositeViewer.done())
break;
std::cout << "pattern detectee" << std::endl << std::endl;
group->addChild(pat);
do
{
start = clock();
vcap >> *frame;
cv::Mat rotVec = trackingMire(frame, &imCalibNext, &pointsVisageInit, &pointsVisage3D, &cameraMatrix, &distCoeffs, &tvecs);
//cv::Mat rotVec = trackingMire(frame, &imCalibNext, &chessCornersInit, &chessCorners3D, &cameraMatrix, &distCoeffs, &tvecs);
//imagePoints = dessinerPoints(frame, objectPoints, rotVec, tvecs, cameraMatrix, distCoeffs);
imagePoints = dessinerPoints(frame, pointsVisage3D, rotVec, tvecs, cameraMatrix, distCoeffs);
double r11 = rotVec.at<double>(0, 0);
double r21 = rotVec.at<double>(1, 0);
double r31 = rotVec.at<double>(2, 0);
double r32 = rotVec.at<double>(2, 1);
double r33 = rotVec.at<double>(2, 2);
osg::Matrixd matrixR;
matrixR.makeRotate(
atan2(r32, r33), osg::Vec3d(1.0, 0.0, 0.0),
-atan2(-r31, sqrt((r32 * r32) + (r33 * r33))), osg::Vec3d(0.0, 0.0, 1.0),
atan2(r21, r11), osg::Vec3d(0.0, 1.0, 0.0));
mat->setMatrix(matrixR);
pat->setPosition(osg::Vec3d(tvecs.at<double>(0, 0), tvecs.at<double>(2, 0), -tvecs.at<double>(1, 0)));
//std::cout << "x = " << tvecs.at<double>(0, 0) << " - y = " << tvecs.at<double>(1, 0) << " - z = " << tvecs.at<double>(2, 0) << std::endl;
// Calcul d'erreur de reprojection
double moy = 0;
for(int j = 0; j < pointsVisageInit[1].size() ; j++)
{
double d = sqrt(pow(pointsVisageInit[0][j].y - imagePoints[j].y, 2) + pow(pointsVisageInit[0][j].x - imagePoints[j].x, 2));
distances.push_back(d);
moy += d;
}
moyDistances = moy / pointsVisageInit[1].size();
if(moyDistances > 1) // si l'ecart de reproj est trop grand, reset
resetAuto = true;
double duree = (clock() - start)/(double) CLOCKS_PER_SEC;
std::cout << (int)(1/duree) << " fps" << std::endl;
moyCpt += (int)(1/duree);
duree = 0;
i++;
backgroundImage->dirty();
compositeViewer.frame();
}while(!compositeViewer.done() && !resetAuto);
}while(!compositeViewer.done());
std::cout << std::endl << "Moyenne des fps : " << moyCpt/i << std::endl;
std::system("PAUSE");
}
size_t BVH4MB::rotate(Base* nodeID, size_t depth)
{
/*! nothing to rotate if we reached a leaf node. */
if (nodeID->isLeaf()) return 0;
Node* parent = nodeID->node();
/*! rotate all children first */
ssei cdepth;
for (size_t c=0; c<4; c++)
cdepth[c] = (int)rotate(parent->child[c],depth+1);
/* compute current area of all children */
ssef sizeX = parent->upper_x-parent->lower_x;
ssef sizeY = parent->upper_y-parent->lower_y;
ssef sizeZ = parent->upper_z-parent->lower_z;
ssef childArea = sizeX*(sizeY + sizeZ) + sizeY*sizeZ;
/*! transpose node bounds */
ssef plower0,plower1,plower2,plower3; transpose(parent->lower_x,parent->lower_y,parent->lower_z,ssef(zero),plower0,plower1,plower2,plower3);
ssef pupper0,pupper1,pupper2,pupper3; transpose(parent->upper_x,parent->upper_y,parent->upper_z,ssef(zero),pupper0,pupper1,pupper2,pupper3);
BBox<ssef> other0(plower0,pupper0), other1(plower1,pupper1), other2(plower2,pupper2), other3(plower3,pupper3);
/*! Find best rotation. We pick a target child of a first child,
and swap this with an other child. We perform the best such
swap. */
float bestCost = pos_inf;
int bestChild = -1, bestTarget = -1, bestOther = -1;
for (size_t c=0; c<4; c++)
{
/*! ignore leaf nodes as we cannot descent into */
if (parent->child[c]->isLeaf()) continue;
Node* child = parent->child[c]->node();
/*! transpose child bounds */
ssef clower0,clower1,clower2,clower3; transpose(child->lower_x,child->lower_y,child->lower_z,ssef(zero),clower0,clower1,clower2,clower3);
ssef cupper0,cupper1,cupper2,cupper3; transpose(child->upper_x,child->upper_y,child->upper_z,ssef(zero),cupper0,cupper1,cupper2,cupper3);
BBox<ssef> target0(clower0,cupper0), target1(clower1,cupper1), target2(clower2,cupper2), target3(clower3,cupper3);
/*! put other0 at each target position */
float cost00 = halfArea3f(merge(other0 ,target1,target2,target3));
float cost01 = halfArea3f(merge(target0,other0 ,target2,target3));
float cost02 = halfArea3f(merge(target0,target1,other0 ,target3));
float cost03 = halfArea3f(merge(target0,target1,target2,other0 ));
ssef cost0 = ssef(cost00,cost01,cost02,cost03);
ssef min0 = vreduce_min(cost0);
int pos0 = (int)__bsf(movemask(min0 == cost0));
/*! put other1 at each target position */
float cost10 = halfArea3f(merge(other1 ,target1,target2,target3));
float cost11 = halfArea3f(merge(target0,other1 ,target2,target3));
float cost12 = halfArea3f(merge(target0,target1,other1 ,target3));
float cost13 = halfArea3f(merge(target0,target1,target2,other1 ));
ssef cost1 = ssef(cost10,cost11,cost12,cost13);
ssef min1 = vreduce_min(cost1);
int pos1 = (int)__bsf(movemask(min1 == cost1));
/*! put other2 at each target position */
float cost20 = halfArea3f(merge(other2 ,target1,target2,target3));
float cost21 = halfArea3f(merge(target0,other2 ,target2,target3));
float cost22 = halfArea3f(merge(target0,target1,other2 ,target3));
float cost23 = halfArea3f(merge(target0,target1,target2,other2 ));
ssef cost2 = ssef(cost20,cost21,cost22,cost23);
ssef min2 = vreduce_min(cost2);
int pos2 = (int)__bsf(movemask(min2 == cost2));
/*! put other3 at each target position */
float cost30 = halfArea3f(merge(other3 ,target1,target2,target3));
float cost31 = halfArea3f(merge(target0,other3 ,target2,target3));
float cost32 = halfArea3f(merge(target0,target1,other3 ,target3));
float cost33 = halfArea3f(merge(target0,target1,target2,other3 ));
ssef cost3 = ssef(cost30,cost31,cost32,cost33);
ssef min3 = vreduce_min(cost3);
int pos3 = (int)__bsf(movemask(min3 == cost3));
/*! find best other child */
ssef otherCost = ssef(extract<0>(min0),extract<0>(min1),extract<0>(min2),extract<0>(min3));
int pos[4] = { pos0,pos1,pos2,pos3 };
sseb valid = ssei(int(depth+1))+cdepth <= ssei(maxDepth); // only select swaps that fulfill depth constraints
if (none(valid)) continue;
size_t n = select_min(valid,otherCost);
float cost = otherCost[n]-childArea[c]; //< increasing the original child bound is bad, decreasing good
/*! accept a swap when it reduces cost and is not swapping a node with itself */
if (cost < bestCost && n != c) {
bestCost = cost;
bestChild = (int)c;
bestOther = (int)n;
bestTarget = pos[n];
}
}
/*! if we did not find a swap that improves the SAH then do nothing */
if (bestCost >= 0) return 1+reduce_max(cdepth);
/*! perform the best found tree rotation */
Node* child = parent->child[bestChild]->node();
swap(parent,bestOther,child,bestTarget);
parent->lower_x[bestChild] = reduce_min(child->lower_x);
parent->lower_y[bestChild] = reduce_min(child->lower_y);
parent->lower_z[bestChild] = reduce_min(child->lower_z);
parent->upper_x[bestChild] = reduce_max(child->upper_x);
parent->upper_y[bestChild] = reduce_max(child->upper_y);
parent->upper_z[bestChild] = reduce_max(child->upper_z);
parent->lower_dx[bestChild] = reduce_min(child->lower_dx);
parent->lower_dy[bestChild] = reduce_min(child->lower_dy);
parent->lower_dz[bestChild] = reduce_min(child->lower_dz);
parent->upper_dx[bestChild] = reduce_max(child->upper_dx);
parent->upper_dy[bestChild] = reduce_max(child->upper_dy);
parent->upper_dz[bestChild] = reduce_max(child->upper_dz);
/*! This returned depth is conservative as the child that was
* pulled up in the tree could have been on the critical path. */
cdepth[bestOther]++; // bestOther was pushed down one level
return 1+reduce_max(cdepth);
}
static int recurse_dir(astring &srcdir)
{
int result = 0;
// iterate through each file
for (librarylist_entry *lib = librarylist; lib != NULL; lib = lib->next)
{
for (list_entry *src = lib->sourcefiles; src != NULL; src = src->next)
{
astring srcfile;
// build the source filename
srcfile.printf("%s%s.c", srcdir.cstr(), src->name.cstr());
dependency_map depend_map;
// find dependencies
file_entry &file = compute_dependencies(srcfile);
recurse_dependencies(file, depend_map);
for (dependency_map::entry_t *entry = depend_map.first(); entry != NULL; entry = depend_map.next(entry))
{
astring t(entry->tag());
if (core_filename_ends_with(t, ".h"))
{
char *foundfile = include_map.find(t);
if (foundfile != NULL) {
printf("%s\n", foundfile);
// we add things just once when needed
include_map.remove(t);
}
}
}
}
}
// iterate through each file
for (librarylist_entry *lib = librarylist; lib != NULL; lib = lib->next)
{
// convert the target from source to object (makes assumptions about rules)
astring target("$(OBJ)/target/",lib->name.cstr());
target.cat(".a");
printf("\n%s : \\\n", target.cstr());
for (list_entry *src = lib->sourcefiles; src != NULL; src = src->next)
{
astring srcfile;
// build the source filename
srcfile.printf("%s%s.c", srcdir.cstr(), src->name.cstr());
dependency_map depend_map;
// find dependencies
file_entry &file = compute_dependencies(srcfile);
recurse_dependencies(file, depend_map);
// iterate over the hashed dependencies and output them as well
for (dependency_map::entry_t *entry = depend_map.first(); entry != NULL; entry = depend_map.next(entry))
{
astring t(entry->tag());
t.replace(0, "src/", "$(OBJ)/");
t.replace(0, ".c", ".o");
if (core_filename_ends_with(t, ".o"))
{
printf("\t%s \\\n", t.cstr());
}
}
}
printf("\n");
for (list_entry *src = lib->sourcefiles; src != NULL; src = src->next)
{
astring srcfile;
// build the source filename
srcfile.printf("%s%s.c", srcdir.cstr(), src->name.cstr());
dependency_map depend_map;
// find dependencies
file_entry &file = compute_dependencies(srcfile);
recurse_dependencies(file, depend_map);
for (dependency_map::entry_t *entry = depend_map.first(); entry != NULL; entry = depend_map.next(entry))
{
astring t(entry->tag());
if (core_filename_ends_with(t, ".lay"))
{
astring target2(file.name);
target2.replace(0, "src/", "$(OBJ)/");
target2.replace(0, ".c", ".o");
t.replace(0, "src/", "$(OBJ)/");
t.replace(0, ".lay", ".lh");
printf("%s: %s\n", target2.cstr(), t.cstr());
}
if (core_filename_ends_with(t, ".inc"))
{
astring target2(file.name);
target2.replace(0, "src/", "$(OBJ)/");
target2.replace(0, ".c", ".o");
printf("%s: %s\n", target2.cstr(), t.cstr());
}
}
}
}
return result;
}
