void MyDisplay::camera_negatif()
{
capture = cvCreateCameraCapture(CV_CAP_ANY);
while (1){
frame = cvQueryFrame(capture);
img_nvg = cvCreateImage(cvGetSize(frame), frame->depth, 1);
//conversion en niveau de gris
cvConvertImage(frame, img_nvg, 0);
stretch_histogram_NVG(img_nvg);
negatif(img_nvg);
//frame = negatif(frame);
cvShowImage("test", img_nvg);
int key = cvWaitKey(1);
if (key == 'q')
{
break;
}
else {
//nothing to do
}
}
cvReleaseCapture(&capture);
}
IplImage* MyDisplay::image_camera_negatif(CvCapture* capture)
{
frame = cvQueryFrame(capture);
img_nvg = cvCreateImage(cvGetSize(frame), frame->depth, 1);
//conversion en niveau de gris
cvConvertImage(frame, img_nvg, 0);
stretch_histogram_NVG(img_nvg);
negatif(img_nvg);
return img_nvg;
}
/* Donne dans le tp. Par la suite, on n'utilise plus cette fonction */
int copier_bmp(int de, int vers){
unsigned char *pixels;
entete_bmp entete;
/* lecture du fichier source */
lire_entete(de, &entete);
pixels = allouer_pixels(&entete);
lire_pixels(de, &entete, pixels);
/* écriture du fichier destination */
rouge(&entete, pixels);
negatif(&entete, pixels);
moitie(&entete, pixels,1);
sepia(&entete, pixels);
noir_et_blanc(&entete, pixels);
ecrire_entete(vers, &entete);
ecrire_pixels(vers, &entete, pixels);
/* on libère les pixels */
free(pixels);
return 1; /* on a réussi */
}
int main()
{
int largeur = 300;
int hauteur = 300;
t_image img;
//img.pixels = LireImagePGM("guadalest.pgm", &largeur, &hauteur);
img.hauteur = hauteur;
img.largeur = largeur;
img.pixels = creerImage(largeur, hauteur);
degrade(img);
negatif(img);
//miroir(img, 1);
ecrireImagePGM("truc.pgm", img);
afficherImage("truc.pgm");
free(img.pixels);
return(0);
}
int main(int argc, char **argv)
{
/* Pas d'argument */
if (argc == 1)
usage(argv[0]);
/* Initialisation */
int c;
char *nom = NULL;
int de = open("lena.bmp", O_RDONLY);
entete_bmp entete;
unsigned char *pixels;
if (de < 0){
printf("erreur fichier entree\n");
exit(EXIT_FAILURE);
}else{
/* Lecture du fichier source */
lire_entete(de, &entete);
pixels = allouer_pixels(&entete);
lire_pixels(de, &entete, pixels);
}
while ((c = getopt(argc, argv, "rnbmia")) != -1) {
switch (c) {
case 'r':
rouge(&entete, pixels);
break;
case 'n':
negatif(&entete, pixels);
break;
case 'b':
noir_et_blanc(&entete, pixels);
break;
case 'm':
moitie(&entete, pixels, 1);
break;
case 'i':
moitie(&entete, pixels, 0);
break;
case 'a':
sepia(&entete, pixels);
break;
default :
tuto(argv[0]);
break;
}
}
/* Lecture de l'option facultative (nom fichier) */
int index;
for (index = optind; index < argc; index++) {
if (nom == NULL)
nom = argv[index];
else
printf ("L'option %s a été ignoré.\n", argv[index]);
}
/* On écrit dans le fichier de destination */
int vers;
if (nom == NULL)
vers = open("lena_out.bmp", O_WRONLY | O_CREAT, 0644);
else
vers = open(nom, O_WRONLY | O_CREAT, 0644);
if (vers < 0){
printf("erreur fichier sortie\n");
exit(EXIT_FAILURE);
}else{
/* Écriture du fichier destination */
ecrire_entete(vers, &entete);
ecrire_pixels(vers, &entete, pixels);
}
/* On libère les pixels */
free(pixels);
return EXIT_SUCCESS;
}
void PixEditor::addMenu()
{
//Fichier
precedent_action=new QAction(tr("&Precedent"),this);
precedent_action->setIcon(QIcon("./icones/precedent.jpg"));
precedent_action->setStatusTip(tr("Precedent"));
QObject::connect(precedent_action,SIGNAL(triggered()),&widgetcentral,SLOT(precedent()));
//
nouveau_action = new QAction(tr("&Nouveau"), this);
nouveau_action->setIcon(QIcon("./icones/window-new-3.png"));
nouveau_action->setShortcut(tr("Ctrl+N"));
nouveau_action->setStatusTip(tr("Nouvelle image"));
QObject::connect(nouveau_action, SIGNAL(triggered()), &widgetcentral, SLOT(nouveau()));
ouvrir_action = new QAction(tr("&Ouvrir"), this);
ouvrir_action->setShortcut(tr("Ctrl+O"));
ouvrir_action->setIcon(QIcon("./icones/OpenButton.png"));
ouvrir_action->setStatusTip(tr("Charger une image"));
QObject::connect(ouvrir_action, SIGNAL(triggered()), &widgetcentral, SLOT(ouvrir()));
sauver_action = new QAction(tr("&Sauvegarder"), this);
sauver_action->setShortcut(tr("Ctrl+S"));
sauver_action->setIcon(QIcon("./icones/enregistrer.png"));
sauver_action->setStatusTip(tr("Sauvegarder l'image"));
QObject::connect(sauver_action, SIGNAL(triggered()), &widgetcentral, SLOT(sauvegarder()));
sauversous_action = new QAction(tr("S&auvegarder sous..."), this);
sauversous_action->setShortcut(tr("Ctrl+Shift+S"));
sauversous_action->setIcon(QIcon("./icones/enregistrer-sous.png"));
sauversous_action->setStatusTip(tr("Sauvegarder l'image sous..."));
connect(sauversous_action, SIGNAL(triggered()), &widgetcentral, SLOT(sauvegarderSous()));
quitter_action = new QAction(tr("&Quitter"), this);
quitter_action->setStatusTip(tr("Quitter le programme"));
quitter_action->setIcon(QIcon("./icones/icone-infos.png"));
QObject::connect(quitter_action, SIGNAL(triggered()), &widgetcentral, SLOT(quitter()));
menu_fichier = new QMenu(tr("&Fichier"), this);
menu_fichier->addAction(precedent_action);
menu_fichier->addAction(nouveau_action);
menu_fichier->addAction(ouvrir_action);
menu_fichier->addAction(sauver_action);
menu_fichier->addAction(sauversous_action);
menu_fichier->addAction(quitter_action);
// Filtre
flou_action = new QAction(tr("&F&lou"), this);
flou_action->setStatusTip(tr("Appliquer un flou l'image"));
flou_action->setIcon(QIcon("./icones/flou.gif"));
QObject::connect(flou_action, SIGNAL(triggered()), &widgetcentral, SLOT(loadflou()));
fusion_action = new QAction(tr("&F&usion"), this);
fusion_action->setStatusTip(tr("Fusionner l'image avec une autre"));
QObject::connect(fusion_action, SIGNAL(triggered()), &widgetcentral, SLOT(loadfusion()));
gris_action = new QAction(tr("&Gris"),this);
gris_action->setStatusTip("Appliquer un gris l'image");
QObject::connect(gris_action,SIGNAL(triggered()),&widgetcentral,SLOT(gris()));
rehaussement_action = new QAction(tr("&Rehaussement de contraste"),this);
rehaussement_action->setStatusTip("Rehausser le contraste");
QObject::connect(rehaussement_action,SIGNAL(triggered()),&widgetcentral,SLOT(loadrehausseur()));
detection_action = new QAction(tr("&Detecter les contours"),this);
detection_action->setStatusTip("Detection de contour");
QObject::connect(detection_action,SIGNAL(triggered()),&widgetcentral,SLOT(loaddetection()));
gradient_action = new QAction(tr("&Gradient"),this);
gradient_action->setStatusTip("Gradient");
QObject::connect(gradient_action,SIGNAL(triggered()),&widgetcentral,SLOT(loadgradient()));
perso_action = new QAction(tr("&Personnaliser"),this);
perso_action->setStatusTip("Personnaliser le filtre");
QObject::connect(perso_action,SIGNAL(triggered()),&widgetcentral,SLOT(loadperso()));
accent_action = new QAction(tr("&Accentuer"),this);
accent_action->setStatusTip("Accentuer l'image");
QObject::connect(accent_action,SIGNAL(triggered()),&widgetcentral,SLOT(loadaccentuer()));
menu_outils = new QMenu(tr("&F&iltre"), this);
menu_outils->addAction(flou_action);
menu_outils->addAction(fusion_action);
menu_outils->addAction(gris_action);
menu_outils->addAction(rehaussement_action);
menu_outils->addAction(detection_action);
menu_outils->addAction(gradient_action);
menu_outils->addAction(perso_action);
menu_outils->addAction(accent_action);
//histogramme
histo_menu=new QMenu(tr("&Histogramme"),this);
histoRGB_action = new QAction(tr("&RGB"),this);
QObject::connect(histoRGB_action, SIGNAL(triggered()), &widgetcentral, SLOT(histogrammeRGB()));
histo_menu->addAction(histoRGB_action);
histoHSV_action = new QAction(tr("&HSV"),this);
QObject::connect(histoHSV_action, SIGNAL(triggered()), &widgetcentral, SLOT(histogrammeHSV()));
histo_menu->addAction(histoHSV_action);
egalise_action = new QAction(tr("&Egaliser"),this);
QObject::connect(egalise_action, SIGNAL(triggered()), &widgetcentral, SLOT(egalisation()));
histo_menu->addAction(egalise_action);
linearise_action = new QAction(tr("&Lineariser"),this);
QObject::connect(linearise_action, SIGNAL(triggered()), &widgetcentral, SLOT(linearisation()));
histo_menu->addAction(linearise_action);
negatif_action = new QAction(tr("&Negatif"),this);
QObject::connect(negatif_action, SIGNAL(triggered()), &widgetcentral, SLOT(negatif()));
histo_menu->addAction(negatif_action);
seuillage_action = new QAction(tr("&Seuillage"),this);
QObject::connect(seuillage_action, SIGNAL(triggered()), &widgetcentral, SLOT(seuillage()));
histo_menu->addAction(seuillage_action);
//color_picker
picker_action = new QAction(tr("&P&i&xelColor"),this);
picker_action->setStatusTip("Pixel valeur");
picker_action->setIcon(QIcon("./icones/icones/pixelcolor.jpg"));
QObject::connect(picker_action, SIGNAL(triggered()), widgetcentral.affichage, SLOT(pixelColor()));
color_picker = new QMenu(tr("&Picolor"),this);
color_picker->addAction(picker_action);
//Selection
menu_selection = new QMenu(tr("&Se&lection"),this);
selection_action=new QAction(tr("&selection"),this);
QObject::connect(selection_action, SIGNAL(triggered()), widgetcentral.affichage, SLOT(selection()));
menu_selection->addAction(selection_action);
//redimension
redim_action = new QAction(tr("&R&edimension"),this);
redim_action->setStatusTip("Appliquer le redimensionnement l'image");
QObject::connect(redim_action,SIGNAL(triggered()),&widgetcentral,SLOT(redimension()));
seam_action = new QAction(tr("&Seam Carving"),this);
seam_action->setStatusTip("Redimensionnement intelligent");
QObject::connect(seam_action,SIGNAL(triggered()),&widgetcentral,SLOT(loadseam()));
menu_redimension = new QMenu (tr ("&R&e&dimension"), this);
menu_redimension->addAction(redim_action);
menu_redimension->addAction(seam_action);
barre_menu = new QMenuBar(this);
barre_menu->addMenu(menu_fichier);
barre_menu->addMenu(menu_outils);
barre_menu->addMenu(histo_menu);
barre_menu->addMenu(color_picker);
barre_menu->addMenu(menu_selection);
barre_menu->addMenu(menu_redimension);
setMenuBar(barre_menu);
}
/* Fais appel à toutes les fonctions de base contenues dans gestionImg.c, dans affichage.c et dans lecture.c */
void testFonctionsDeBase()
{
image img1 = NULL, img2 = NULL, img3 = NULL, img4 = NULL, img5 = NULL;
/* L'image 1 est lue au clavier */
img1 = lireClavier();
printf("\n");
/* L'image 2 est copiée est mis en négatif */
img2 = copie(img1);
negatif(&img2);
/* L'image 3 est un négatif de la 2 est doit donc être identique à la 1*/
img3 = copie(img2);
negatif(&img3);
/* On regarde la différence entre la 1 et la 2 */
img4 = difference(img1 , img2);
/* On regarde la différence entre la 1 et la 3 */
img5 = difference(img1 , img3);
/* Affichage des résultats */
printf("Voici votre image 1 :\n");
affichageNormal(img1); printf("\n");
affichageProfondeur(img1); printf("\n");
printf("Voici votre image 2 (negatif de la 1) :\n");
affichageNormal(img2); printf("\n");
affichageProfondeur(img2); printf("\n");
printf("Voici votre image 3 (negatif de la 2) :\n");
affichageNormal(img3); printf("\n");
affichageProfondeur(img3); printf("\n");
printf("Voici votre image 4 (différence entre 1 et 2) :\n");
affichageNormal(img4); printf("\n");
affichageProfondeur(img4); printf("\n");
printf("Voici votre image 5 (différence entre 1 et 3) :\n");
affichageNormal(img5); printf("\n");
affichageProfondeur(img5); printf("\n");
printf("\n");
/* Test memeImage() */
memeImage(img1, img3) ? printf("La 1 et la 3 sont identiques.\n") : printf("ERREUR : La 1 et la 3 sont differentes.\n");
(!memeImage(img1, img2)) ? printf("La 1 et la 2 sont differentes.\n") : printf("ERREUR : La 1 et la 2 sont identiques.\n");
printf("\n");
/* Test memeDessin() */
memeDessin(img1, img3) ? printf("La 1 et la 3 ont le meme dessin.\n") : printf("ERREUR : La 1 et la 3 n'ont pas le meme dessin.\n");
memeDessin(img1, img2) ? printf("La 1 et la 2 ont le meme dessin.\n") : printf("ERREUR : La 1 et la 2 n'ont pas le meme dessin.\n");
(!memeDessin(img1, img4)) ? printf("La 1 et la 4 n'ont pas le meme dessin.\n") : printf("WARNING : La 1 et la 4 ont le meme dessin.\n");
printf("\n");
/* Test estBlanche() et estNoire() */
(estNoire(img4) == true) ? printf("La 4 est noire.\n") : printf("ERREUR : La 4 n'est pas noire.\n");
(estBlanche(img5) == true) ? printf("La 5 est blanche.\n") : printf("ERREUR : La 5 n'est pas blanche.\n");
printf("\n");
/* Test aireNoire() */
printf("Aire en noire image 1 : %f\n", aireNoire(img1));
printf("Aire en noire image 2 : %f\n", aireNoire(img2));
printf("Aire en noire image 3 : %f\n", aireNoire(img3));
printf("Aire en noire image 4 : %f\n", aireNoire(img4));
printf("Aire en noire image 5 : %f\n", aireNoire(img5));
printf("\n");
/*Affichage en mode 2k*/
printf("Affichage en mode 2k\n");
printf("Voici votre image 1 (Profondeur : 0) :\n");
affichage2k(img1, 0); printf("\n");
printf("Voici votre image 1 (Profondeur : 1) :\n");
affichage2k(img1, 1); printf("\n");
printf("Voici votre image 1 (Profondeur : 2) :\n");
affichage2k(img1, 2); printf("\n");
printf("Voici votre image 1 (Profondeur : 3) :\n");
affichage2k(img1, 3); printf("\n");
printf("Voici votre image 1 (Profondeur : 4) :\n");
affichage2k(img1, 4); printf("\n");
printf("Voici votre image 1 (Profondeur : 5) :\n");
affichage2k(img1, 5); printf("\n");
printf("Voici votre image 1 (Profondeur : 6) :\n");
affichage2k(img1, 6); printf("\n");
if(img1 != NULL)
rendMemoire(img1);
if(img2 != NULL)
rendMemoire(img2);
if(img3 != NULL)
rendMemoire(img3);
if(img4 != NULL)
rendMemoire(img4);
if(img5 != NULL)
rendMemoire(img5);
}
int main(int argc, char const *argv[])
{
//Pour effacer l'ecran
effacer_ecran();
ligne_separation('=');
char nomImage[255] = "";
char transformation[255] = "";
// On ouvre le fichier de l'image
FILE* file_image = ouverture_lecture_fichier_image(&argc,argv,nomImage,transformation);
if(file_image == NULL)
return 1;
IMAGE tab_pixels;
if(lecture_fichier(file_image, &tab_pixels, nomImage)){
printf("\tNombre de Colonnes:\t%d\n\tNombre de Lignes:\t%d\n\tValeur Maximal:\t\t%d\n",tab_pixels.nb_col,tab_pixels.nb_lig,tab_pixels.max_val);
printf("[O]\tLecture complete du fichier image reussie\n");
}
else{
printf("[X]\tProbleme de lecture du fichier image\n");
return 1;
}
file_image = NULL;
// ###########################################
// Travail des fonctions des transformations
// ###########################################
// Raccourcis pour que l'utilisateur rentre la transformation lors de l'execution en ligne de commande
int transfoOk = 1;
if(strcmp(transformation, "niveauGris") == 0)
niveauGris(&tab_pixels);
else if(strcmp(transformation, "binarisation") == 0)
binarisation(&tab_pixels);
else if(strcmp(transformation, "symetrieH") == 0)
symetrie_horizontale(&tab_pixels);
else if(strcmp(transformation, "symetrieV") == 0)
symetrie_verticale(&tab_pixels);
else if(strcmp(transformation, "negatif") == 0)
negatif(&tab_pixels);
else if(strcmp(transformation, "redimensionnement") == 0)
redimensionnement(&tab_pixels, argc, argv);
else if(strcmp(transformation, "ameliorationContraste") == 0)
amelioration_du_contraste(&tab_pixels);
else if(strcmp(transformation, "lissage") == 0)
lissage(&tab_pixels);
else if(strcmp(transformation, "laplacien") == 0)
laplacien(&tab_pixels);
else if(strcmp(transformation, "gradientSimple") == 0)
gradient(&tab_pixels, transformation);
else if(strcmp(transformation, "gradientSobel") == 0)
gradient(&tab_pixels, transformation);
else if(strcmp(transformation, "detectionContoursSobel") == 0)
detectionContoursSobel(&tab_pixels);
else if(strcmp(transformation, "detectionContoursLaplacien") == 0)
detectionContoursLaplacien(&tab_pixels);
else if(strcmp(transformation, "reductionBruit") == 0)
reductionBruit(&tab_pixels);
else if(strcmp(transformation, "masqueCustom") == 0)
masqueCustom(&tab_pixels, argc, argv);
else if(strcmp(transformation, "base") != 0){
printf("[X]\tTransformation inexistante\n");
transfoOk = 0;
}
// ###########################################
if(transfoOk){
file_image = ouverture_ecriture_fichier_image(&(tab_pixels.type),nomImage,transformation);
if(file_image == NULL)
return 1;
if(ecriture_fichier(file_image,&tab_pixels,nomImage,transformation))
printf("[O]\tEcriture du fichier reussie, transformation sauvegardee\n");
else
printf("[X]\tEcriture du fichier rate, transformation non sauvegardee\n");
}
// On libère le tableau de pixels
vider_tab_pixels(&tab_pixels);
ligne_separation('=');
return 0;
}
void OnNegatif(GtkWidget* widget, gpointer data) {
(void) widget;
(void) data;
pile_new_image(negatif(cur_image));
}
