Commit c6c7ae2c authored by Xavier CORBILLON's avatar Xavier CORBILLON

Ajout du code de traitement d'image pour l'overo

parent 329b5417
*.o
*.jpg
*.JPG
*.bin
bin/
#include "cv.h"
#include "highgui.h"
#include <cmath>
#include <iostream>
#define PI 3.14159265
using namespace cv;
using namespace std;
int main(int argc, char** argv) {
int alpha_=90., beta_=90., gamma_=90.;
int f_ = 500, dist_ = 500;
bool video = false;
Mat source, destination;
VideoCapture capture(0);
if (argc >= 2) {
// Si au moins un argument est précisé, on essaye de charger l'image
cout << "Lecture de " << argv[1] << endl;
source = imread(argv[1]);
} else {
// Sinon on essaye d'ouvrir une capture de vidéo (webcam)
cout << "Ouverture du flux vidéo..." << endl;
if(!capture.isOpened()) {
cout << "... échec :(" << endl;
return -1;
}
cout << "... ça marche :)" << endl;
video = true;
}
string wndname1 = "Source";
string wndname2 = "Warp Perspective";
string tbarname1 = "Alpha";
string tbarname2 = "Beta";
string tbarname3 = "Gamma";
string tbarname4 = "f";
string tbarname5 = "Distance";
namedWindow(wndname1, 1);
namedWindow(wndname2, 1);
createTrackbar(tbarname1, wndname2, &alpha_, 180);
createTrackbar(tbarname2, wndname2, &beta_, 180);
createTrackbar(tbarname3, wndname2, &gamma_, 180);
createTrackbar(tbarname4, wndname2, &f_, 2000);
createTrackbar(tbarname5, wndname2, &dist_, 2000);
while(true) {
// Les trackbar d'opencv ne donnent que des valeurs entières entre 0
// et le max (dernier paramètre de createTrackbar)
// Il faut donc adapter les paramètres
double f, dist;
double alpha, beta, gamma;
alpha = ((double)alpha_ - 90.)*PI/180;
beta = ((double)beta_ - 90.)*PI/180;
gamma = ((double)gamma_ - 90.)*PI/180;
f = (double) f_;
dist = (double) dist_;
if (video) {
// Capture l'image de la caméra
capture >> source;
}
// Affiche l'image
imshow(wndname1, source);
Size taille = source.size();
double w = (double)taille.width, h = (double)taille.height;
// Cette matrice projette l'image de la caméra (2D) dans l'espace (3D)
// et la centre
Mat A1 = (Mat_<double>(4,3) <<
1, 0, -w/2,
0, 1, -h/2,
0, 0, 0,
0, 0, 1);
// On définit les 3 matrices de rotation (une par axe)
Mat RX = (Mat_<double>(4, 4) <<
1, 0, 0, 0,
0, cos(alpha), -sin(alpha), 0,
0, sin(alpha), cos(alpha), 0,
0, 0, 0, 1);
Mat RY = (Mat_<double>(4, 4) <<
cos(beta), 0, -sin(beta), 0,
0, 1, 0, 0,
sin(beta), 0, cos(beta), 0,
0, 0, 0, 1);
Mat RZ = (Mat_<double>(4, 4) <<
cos(gamma), -sin(gamma), 0, 0,
sin(gamma), cos(gamma), 0, 0,
0, 0, 1, 0,
0, 0, 0, 1);
// La matrice de rotation finale
Mat R = RX * RY * RZ;
// Matrice de translation : on place le plan à la distance "dist" de
// la caméra
Mat T = (Mat_<double>(4, 4) <<
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, dist,
0, 0, 0, 1);
// Matrice de la caméra : projette l'image en 2D et la centre
Mat A2 = (Mat_<double>(3,4) <<
f, 0, w/2, 0,
0, f, h/2, 0,
0, 0, 1, 0);
// La matrice de transformation est tout simplement le produit des
// matrices
Mat transfo = A2 * (T * (R * A1));
// Applique la transformation
warpPerspective(source, destination, transfo, taille, INTER_CUBIC | WARP_INVERSE_MAP);
// Affiche le résultat
imshow(wndname2, destination);
if (video) {
// Quitte lorsqu'une touche est pressée
if(waitKey(10) >= 0)
break;
} else {
// Quitte lorsque la touche echap est pressée
if(waitKey(0) == 27)
break;
}
}
return 0;
}
CC=g++
CFLAGS=-c -Wall -g -O0 `pkg-config opencv --cflags`
LDFLAGS=`pkg-config opencv --libs`
SOURCES=applatir.cpp
OBJECTS=$(SOURCES:.cpp=.o)
EXECUTABLE=applatir.bin
all: $(SOURCES) $(EXECUTABLE)
$(EXECUTABLE): $(OBJECTS)
$(CC) $(LDFLAGS) $(OBJECTS) -o $@
.cpp.o:
$(CC) $(CFLAGS) $< -o $@
clean:
rm *.o
// include standard OpenCV headers, same as before
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <cmath>
#include <iostream>
#include "cv.h"
#include "highgui.h"
// all the new API is put into "cv" namespace. Export its content
using namespace cv;
using namespace std;
// enable/disable use of mixed API in the code below.
#define DEMO_MIXED_API_USE 1
#define CV_EVENT_MOUSEMOVE 0
#define CV_EVENT_LBUTTONDOWN 1
#define CV_EVENT_RBUTTONDOWN 2
#define CV_EVENT_MBUTTONDOWN 3
#define CV_EVENT_LBUTTONUP 4
#define CV_EVENT_RBUTTONUP 5
#define CV_EVENT_MBUTTONUP 6
#define CV_EVENT_LBUTTONDBLCLK 7
#define CV_EVENT_RBUTTONDBLCLK 8
#define CV_EVENT_MBUTTONDBLCLK 9
int h = 0, s = 0, v = 0, tolerance = 40;
IplImage *image;
void my_mouse_callback( int event, int x, int y, int flags, void *param=NULL)
{
CvScalar pixel;
if(event== CV_EVENT_LBUTTONDOWN )
{
pixel=cvGet2D(image,y,x);
printf("\nB=%f, G=%f R=%f",pixel.val[0],pixel.val[1],pixel.val[2]);
h = (int)pixel.val[0];
s = (int)pixel.val[1];
v = (int)pixel.val[2];
}
}
int main( )
{
const char* imagename = "1.jpg";
//const char* imagename = "1.jpg";
IplImage *img = cvLoadImage(imagename);
if(!img)
{
printf("Erreur \n");
return -1;
}
//Largueur image dans pixels
int width = img->width;
//Hauture image dans pixels
int height = img->height;
int step = img->widthStep/sizeof(uchar);
//Nombre canaux image
int channels = img->nChannels;
//Binarisation
int x, y;
CvScalar pixel;
IplImage *img_s,*hsv, *detec,*mask,*hsv_s, *mask_s, *image_new, *image_new2, *gray;
IplConvKernel *kernel;
int sommeX = 0, sommeY = 0;
int nbPixels = 0, nbPixels2 = 0;
// Key for keyboard event
char key=0;
//uchar* data = (uchar *)img->imageData; //cargamos los datos de la imagen en “data”
printf("\nstep=%d height=%d",step, height);
fflush(stdout);
//image = cvCloneImage(img);
cvNamedWindow("original", CV_WINDOW_AUTOSIZE);
cvShowImage("original", img);
image= cvCloneImage(img);
// Set up the callback
//cvSetMouseCallback("original_hsv", my_mouse_callback, (void*) image_hsv); //original_hsv
//FONCTION QUI DETECTE LES COULEURS RGB
cvSetMouseCallback("original", my_mouse_callback, (void*) image); //original
while(1/*key != 'Q' && key != 'q'*/)
{
// We wait 10 ms
key = cvWaitKey(10);
}
cvReleaseImage( &img );
cvDestroyWindow("original");
cvWaitKey(10);
return 0;
}
CC=g++
CFLAGS=-c -Wall -g -O0 `pkg-config opencv --cflags`
LDFLAGS=`pkg-config opencv --libs`
SOURCES=getColor.cpp
OBJECTS=$(SOURCES:.cpp=.o)
EXECUTABLE=Color.bin
all: $(SOURCES) $(EXECUTABLE)
$(EXECUTABLE): $(OBJECTS)
$(CC) $(LDFLAGS) $(OBJECTS) -o $@
.cpp.o:
$(CC) $(CFLAGS) $< -o $@
clean:
rm *.o
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="TestCPP" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/TestCPP" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
</Compiler>
</Target>
<Target title="Release">
<Option output="bin/Release/TestCPP" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Release/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-O2" />
</Compiler>
<Linker>
<Add option="-s" />
</Linker>
</Target>
</Build>
<Compiler>
<Add option="-Wall" />
<Add option="-fexceptions" />
</Compiler>
<Unit filename="main.cpp" />
<Unit filename="math.cpp" />
<Unit filename="math.h" />
<Extensions>
<code_completion />
<debugger />
</Extensions>
</Project>
</CodeBlocks_project_file>
# depslib dependency file v1.0
1302210822 source:/home/mohamed/ProjetS4/TestCPP/main.cpp
<iostream>
<string>
<fstream>
1302191236 source:/home/mohamed/ProjetS4/TestCPP/math.cpp
"math.h"
1302191489 /home/mohamed/ProjetS4/TestCPP/math.h
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_layout_file>
<ActiveTarget name="Debug" />
<File name="main.cpp" open="1" top="1" tabpos="0">
<Cursor position="443" topLine="10" />
</File>
</CodeBlocks_layout_file>
#include <iostream>
# include <string>
#include <ctime>
#include <cstdlib>
using namespace std;
string desordonner(string mot)
{
srand(time(0));
int l(mot.size());
string motDesordonne("");
while (l!=0)
{
int position=rand() % l;
motDesordonne+=mot[position];
mot.erase(position,1);
l=mot.size();
}
return motDesordonne;
}
int main()
{
int *pointeur(0);
pointeur=new int;
cout << "quel est votre age ?"<< endl;
cin >> *pointeur;
cout << "votre age est : " << *pointeur << endl;
delete pointeur;
pointeur=0;
return 0;
}
#include "math.h"
int ajouteDeux(int nombreRecu)
{
int valeur(nombreRecu + 2);
return valeur;
}
#ifndef MATH_H_INCLUDED
#define MATH_H_INCLUDED
int ajouteDeux(int nombreRecu);
#endif // MATH_H_INCLUDED
moi benjelloun mohamed
j'ai 22 ans !
je suis beaugoss. moi benjelloun amine
j'ai 16 ans !
je suis beaugoss.
\ No newline at end of file
This diff is collapsed.
CC=g++
CFLAGS=-c -Wall -g -O0 `pkg-config opencv --cflags`
LDFLAGS=`pkg-config opencv --libs`
SOURCES=Vision.cpp
OBJECTS=$(SOURCES:.cpp=.o)
EXECUTABLE=Vision.bin
all: $(SOURCES) $(EXECUTABLE)
$(EXECUTABLE): $(OBJECTS)
$(CC) $(LDFLAGS) $(OBJECTS) -o $@
.cpp.o:
$(CC) $(CFLAGS) $< -o $@
clean:
rm *.o
#include "cv.h"
#include "highgui.h"
#include <cmath>
#include <iostream>
#include <vector>
#define PI 3.14159265
using namespace cv;
using namespace std;
int main(int argc, char** argv) {
// les paramètres pour applatir l'image reçue de la camèra.
// A regler selon la position de la camera sur le robot !
int alpha_=30., beta_=90., gamma_=90.;
int f_ = 500, dist_ =415;
// indique si on a le flux video ou pas.
bool video = false;
// source est l'image vu par la camèra.
// destination est l'image "vu" par le robot.
// contours1 est l'image obtenue apres detection de contours sur l'image en 3 channals.
// contours2 est l'image obtenue apres detection de contours sur l'image dans le channal G (Green).
// lines1 est un vecteur contenant les coordonnées des extremites des segments detectes
Mat source, destination, contours1, contours2;
vector<Vec4i> lines1,lines2;
VideoCapture capture(0);
// lecture des donnees :
if (argc >= 2) {
// Si au moins un argument est précisé, on essaye de charger l'image
cout << "Lecture de " << argv[1] << endl;
source = imread(argv[1]);
} else {
// Sinon on essaye d'ouvrir une capture de vidéo (webcam)
cout << "Ouverture du flux vidéo..." << endl;
if(!capture.isOpened()) {
cout << "... échec :(" << endl;
return -1;
}
cout << "... ça marche :)" << endl;
video = true;
}
// juste pour les tests sur ordinateur.
string wndname1 = "Source";
string wndname2 = "destination";
string wndname3 = "contours1";
string wndname4 = "contours2";
string wndname5 = "test";
namedWindow(wndname1, 1);
namedWindow(wndname2, 1);
namedWindow(wndname3, 1);
namedWindow(wndname4, 1);
namedWindow(wndname5, 1);
Mat test=Mat_<Scalar>(40,40);
test=Scalar(0.,254.,255.);
cout << test.at<Scalar>(20,20)[1]<< endl;
imshow(wndname5, test);
while(true) {
// on transforme les angles en radians.
double f, dist;
double alpha, beta, gamma;
alpha = ((double)alpha_ - 90.)*PI/180;
beta = ((double)beta_ - 90.)*PI/180;
gamma = ((double)gamma_ - 90.)*PI/180;
f = (double) f_;
dist = (double) dist_;
if (video) {
// Capture l'image de la caméra
capture >> source;
}
// Affiche l'image
imshow(wndname1, source);
Size taille = source.size();
double w = (double)taille.width, h = (double)taille.height;
// Cette matrice projette l'image de la caméra (2D) dans l'espace (3D)
// et la centre
Mat A1 = (Mat_<double>(4,3) <<
1, 0, -w/2,
0, 1, -h/2,
0, 0, 0,
0, 0, 1);
// On définit les 3 matrices de rotation (une par axe)
Mat RX = (Mat_<double>(4, 4) <<
1, 0, 0, 0,
0, cos(alpha), -sin(alpha), 0,
0, sin(alpha), cos(alpha), 0,
0, 0, 0, 1);
Mat RY = (Mat_<double>(4, 4) <<
cos(beta), 0, -sin(beta), 0,
0, 1, 0, 0,
sin(beta), 0, cos(beta), 0,
0, 0, 0, 1);
Mat RZ = (Mat_<double>(4, 4) <<
cos(gamma), -sin(gamma), 0, 0,
sin(gamma), cos(gamma), 0, 0,
0, 0, 1, 0,
0, 0, 0, 1);
// La matrice de rotation finale
Mat R = RX * RY * RZ;
// Matrice de translation : on place le plan à la distance "dist" de
// la caméra
Mat T = (Mat_<double>(4, 4) <<
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, dist,
0, 0, 0, 1);
// Matrice de la caméra : projette l'image en 2D et la centre
Mat A2 = (Mat_<double>(3,4) <<
f, 0, w/2, 0,
0, f, h/2, 0,
0, 0, 1, 0);
// La matrice de transformation est tout simplement le produit des
// matrices
Mat transfo = A2 * (T * (R * A1));
// Applique la transformation
warpPerspective(source, destination, transfo, taille, INTER_CUBIC | WARP_INVERSE_MAP);
// Affiche le résultat
imshow(wndname2, destination);
// le traitement
// on construit contours1, l'image contenant les contours de l'image destination (en 3 channals)
cvtColor(destination, contours1, CV_BGR2GRAY);
Mat gray;
cvtColor(destination, gray, CV_BGR2GRAY);
GaussianBlur(contours1, contours1, Size(5,5), 1.5, 1.5);
Canny(contours1, contours1, 20, 50, 3,false);
// on construit contours2, l'image contenant les contours de l'image destination dans le channal 1 ie Green
vector<Mat> channels;
split(destination, channels);
GaussianBlur(channels[1], contours2, Size(5,5), 1.5, 1.5);
Canny(contours2, contours2, 20, 50, 3,false);
IplImage *tranche,*src;
src= cvLoadImage("d.JPG");
tranche = cvCreateImage(cvGetSize(src),src->depth , 1);
cvInRangeS(src,Scalar(0.,0.,0.),Scalar(0.,255.,0.),tranche);
imshow(wndname5,src);
imshow("test2",tranche);
// les parametres ci-dessous dependent de la resolution de la camera, des parametres pour applatir.
// ils servent a faire le lien entre la distance reelle sur la table et la distance mesure sur l'image.
double dminCentres=40.; // la distance minimale entre les centres des cercles a detecter.
int rayonMin=10; // le rayon minimal des cercles a detecter.
int rayonMax=200; // le rayon maximal des cercles a detecter
// Detection des cercles dans les images contours1 et contours2,
HoughLinesP(contours1,lines1, 1, CV_PI/180,1, 13, 5 );
//HoughLinesP(contours2, lines2, 1, CV_PI/180, 80, 30, 10 );;
// Ces parametres dependent de la qualite de la camera,
// ils donnent les valeurs (en int) possibles des pixelx dont la couleur est celle des pions.
int couleurPionsMax=2000000000;
int couleurPionsMin=0;
// puis on dessine chaque cercle detecte dans contours2 en ne gardant que les pions,
// et on stocke le triplet (x,y,rayon) de ces pions dans le tableau pions.
vector<Vec3f> pions;
for( size_t i = 0; i < lines1.size(); i++ )
{
line( destination, Point(lines1[i][0], lines1[i][1]),
Point(lines1[i][2], lines1[i][3]), Scalar(0,0,255), 3, 8 );
}
for( size_t i = 0; i < lines2.size(); i++ )
{
line( destination, Point(lines2[i][0], lines2[i][1]),
Point(lines2[i][2], lines2[i][3]), Scalar(0,0,255), 3, 8 );
}
imshow(wndname2, destination);
imshow(wndname3,contours1);
imshow(wndname4,contours2);
//cout <<pions.size()<< endl;
// pour fermer les deux fenêtre des test sur ordinateur.
if (video) {
// Quitte lorsqu'une touche est pressée
if(waitKey(10) >= 0)
break;
} else {
// Quitte lorsque la touche echap est pressée
if(waitKey(0) == 27)
break;
}
}
return 0;
}
//Matching avec cvMatchTemplate()
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "cv.h"
#include "cxcore.h"
#include "highgui.h"
#include "iostream"
using namespace std;
using namespace cv;
/*enregistrez une image template en appuyant sur 'espace'
cette image sera recherchée dans la video issue de la webcam
matchtemplate retourne une valeur de corrélation pour chaque pixel de l'image
la valeur la plus grande de corrélation correspond très probablement au template recherché
pour un matching plus précis, il est possible de régler le seuil à partir duquel il y a matching
pour cela, observer dans la console la valeur maximale de corrélation pour chaque frame
puis agir sur la trackbar de seuil*/
int main() {
//définition des images a utiliser
IplImage *src,*hsv,*mask;//=cvCreateImage(cvSize(640,480), 8, 3);
IplImage *templ;// = cvCreateImage(cvSize(200,300), 8, 3);
templ = cvLoadImage("templ2.JPG");
if(!templ)
{
printf("Erreur \n");
return -1;
}
src = cvLoadImage("img3.JPG");
if(!src)
{
printf("Erreur \n");
return -1;
}
mask = cvCreateImage(cvGetSize(src),src->depth , 1);
hsv = cvCloneImage(src);
cvCvtColor(src, hsv, CV_BGR2HSV);
cvInRangeS(hsv, cvScalar(9,80, 0), cvScalar(30,240,255),mask);