C++

à laide svp!!! exo sur C++

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : à laide svp!!! exo sur C++

sadrine_guillerme

bonjour
je voulais savoir s'il y aurait quelqu'un qui pourrais m'aider a faire un petit programme de remplissage d'une région avec C++
Je souhaite donc écrire un programme permettant de remplir une région délimitée.
Pour manipuler les images, vous utiliserez le module image composé des fichiers image.h et image.cpp

Le programme doit :
Ouvrir limage de départ
Demander à lutilisateur de saisir les coordonnées (x,y) du point de départ
Appliquer la procédure qui colore en gris les pixels à partir du point de départ
Enregistrer limage obtenue

y aura donc t il quelqu'un pour m'aider svp ???
Je poste image.h et image.cpp ainsi que l'image de départ à votre demande;
Merci d'avance !

Publicité

nargy

Voici un code, pourri et rafistolé, au passage, mais qui fonctionne:

Code :

void Image24::region_h_rec(unsigned int x0,
unsigned int y0,
UInt8 threshold,
RGB24 c0,
Image32& res) const
{
unsigned int _xmin; // position horizontale minimum
unsigned int xmax; // position horizontale max
// parcourrir les pixels à droite
for(xmax=x0+1; xmax<dx; xmax++)
{
RGB24 c=data[xmax+y0*dx];
if(c.delta(c0)>threshold) { xmax--; break; } // arrêter le parcours quand delta>threshold
RGBA32& r=res(xmax, y0); // lire le pixel de l'image résultat
if(r.a()!=0) { xmax--; break; } // si le pixel n'est pas transparent arrêter le parcours
r=c; // ranger le pixel (non transparent) dans l'image résultat
}
int xmin=0; // cas où il n'y a pas de pixels à gauche
if(x0>0) // s'il y a des pixels à gauche de celui de départ
{ // parcourrir de la même manière à gauche
for(xmin=x0-1; xmin>=0; xmin--)
{
RGB24 c=data[xmin+dx*y0];
if(c.delta(c0)>threshold) break;
RGBA32& r=res(xmin,y0);
if(r.a()!=0) break;
r=c;
}
xmin++;
}
_xmin=xmin; // garder la coordonnée la plus à gauche
if(_xmin!=xmax) // si on a trouvé des pixels sur la bande horizontale
{ // pour chacun des pixels de couleur proche trouvé, faire un parcours vertical
for(unsigned int x0=_xmin;x0<xmax;x0++)
{
region_v_rec(x0,
y0,
threshold,
c0,
res);
}
}
}
// le parcours vertical est symétrique au parcours horizontal
void Image24::region_v_rec(unsigned int x0,
unsigned int y0,
UInt8 threshold,
RGB24 c0,
Image32& res) const
{
unsigned int _ymin;
unsigned int ymax;
for(ymax=y0+1; ymax<dy; ymax++)
{
RGB24 c=data[ymax*dx+x0];
if(c.delta(c0)>threshold) { ymax--; break; }
RGBA32& r=res(x0,ymax);
if(r.a()!=0) { ymax--; break; }
r=c;
}
int ymin=0;
if(y0>0)
{
for(ymin=y0-1; ymin>=0; ymin--)
{
RGB24 c=data[ymin*dx+x0];
if(c.delta(c0)>threshold) break;
RGBA32& r=res(x0,ymin);
if(r.a()!=0) break;
r=c;
}
ymin++;
}
_ymin=ymin;
if(_ymin!=ymax)
{
for(unsigned int y0=_ymin;y0<ymax;y0++)
{
region_h_rec(x0,
y0,
threshold,
c0,
res);
}
}
}
Image32* Image24::region(unsigned int x0,
unsigned int y0,
UInt8 threshold) const
{
// une nouvelle image résultat
Image32& res=*new Image32(dx, dy);
res.clear(0); // effacer l'image
RGB24 c0=data[y0*dx+x0]; // prendre la couleur au point x0, y0
// parcours récursif
region_h_rec(x0, y0, // à partir de cette position
threshold, // avec un delta maximum
c0, // par rapport à la couleur de départ
res); // et copier le résultat dans res
return &res;
}

Le fonctionnement est simple: region fait appel récursivement et alternativement à region_horizontal et region_vertical. Ça ne fonctionne pas sur 1 seul pixel (car je nen avais pas besoin) donc il faut ajouter ce cas à la fonction region.

Il faut que tu ladapte puisque il prend en entrée une ImageRGB24 et renvoie une ImageRGBA32. La structure est la même dans les deux cas: data contient les pixels de gauche à droite et de haut en bas, et dx et dy sont les largeurs et hauteurs des images.

La fonction delta sur les couleurs RGB:

Code :

inline UInt8 delta(const RGB24 other) const
{
Int16 d=_b-other._b; if(d<0) d=-d;
Int16 dmax=_g-other._g; if(dmax<0) dmax=-dmax;
if(d<dmax) d=dmax;
dmax=_r-other._r; if(dmax<0) dmax=-dmax;
if(d<dmax) d=dmax;
return (UInt8)d;
}

Avec Int8=char, Int16=short, Int32=int, UInt8=unsigned char, etc..
La fonction delta calcule: max(abs(r1-r2),abs(g1-g2),abs(b1-b2))
La fonction region copie dans une ImageRGBA32 les pixels adjacents dont le delta est inférieur au paramètre threshold.

Edit: jai honte de poster un code aussi crade, mais bon, si ça peut aider au moins sur le principe.

Message édité par nargy le 10-09-2006 à 21:59:17

sadrine_guillerme

Merci beaucoup pour votre réponse déja je suis désolé paske je viens de voir votre message j'etais pas la donc je sais pas si t encore la j'ai besoin que tu m'explique encore plus stp? Merci beaucoup d'avance

nargy

C'est à dire?

nargy

J'ai commenté le code et corrigé un bug sur les pixels les plus à droite et les plus en bas.

sadrine_guillerme

je te montre déjà le fichier image.h et image.cpp que j'ai comme données et je veux bien poster l'image de départ mais je n sais pas comment faire pour attacher un fichier sur ce forum
Bien merci

sadrine_guillerme

image.h
#ifndef IMAGE_H
#define IMAGE_H

#define COTE_MAX 1000
#define NIVEAU_GRIS_MAX 2

#define NOIR 0
#define GRIS 1
#define BLANC 2

/* Module de manipulation des images de labyrinthes
- Les pixels de l'image sont des entiers correspondant a des
niveaux de gris (voir definitions ci-dessus)
- on accede a un pixel par image->mat[colonne][ligne]
avec colonne compris entre 0 et (image->largeur - 1)
et ligne compris entre 0 et (image->hauteur - 1)
- Le pixel [0][0] est le pixel en haut a gauche
- Exemple d'utilisation :
image im;
imageOuvrir(im, "maze.pgm" );
im->mat[colonne][ligne] = BLANC;
imageEnregistrerSous(im, "copiemaze.pgm" );
*/

struct Image {
int mat[COTE_MAX][COTE_MAX];
int hauteur, largeur;
};
typedef struct Image *image;

/* Opérations */
void imageOuvrir (image &, char *nom);
void imageEnregistrerSous (image, char *);
void imageCopier (image, image & );

#endif

sadrine_guillerme

image.cpp
#include <cstdio>
#include <cassert>

#include "image.h"

void imageOuvrir (image &im, char *nom)
{
FILE *pgm;
int dummy, i, j;

im = new Image;
assert(im);
pgm = fopen(nom, "r" );
assert(pgm);

// Lecture de 'P2'
fscanf(pgm, "%c", &dummy);
fscanf(pgm, "%c", &dummy);

// Lecture de largeur, hauteur, et niveau gris max
fscanf(pgm, "%d", &(im->largeur));
assert((im->largeur>0)&&(im->largeur<=COTE_MAX));
fscanf(pgm, "%d", &(im->hauteur));
assert((im->hauteur>0)&&(im->largeur<=COTE_MAX));
fscanf(pgm, "%d", &dummy);

// Stockage dans la matrice
for (j = 0; j < im->hauteur; j++)
for (i = 0; i < im->largeur; i++)
fscanf(pgm, "%d", &(im->mat[i][j]));

fclose(pgm);
}

void imageEnregistrerSous (image im, char *nom)
{
FILE *pgm;
int i, j;

pgm = fopen(nom, "w" );
assert(pgm);

fprintf(pgm, "P2\n" );
fprintf(pgm, "%d %d\n", im->largeur, im->hauteur);
fprintf(pgm, "%d\n", NIVEAU_GRIS_MAX);

for (j = 0; j < im->hauteur; j++) {
for (i = 0; i < im->largeur; i++)
fprintf(pgm, "%d ", im->mat[i][j]);
fprintf(pgm, "\n" );
}

fclose(pgm);
}

void imageCopier(image im, image &copie) {
int i, j;

copie = new Image;
copie->hauteur = im->hauteur;
copie->largeur = im->largeur;
for (j = 0; j < im->hauteur; j++)
for (i = 0; i < im->largeur; i++)
copie->mat[i][j] = im->mat[i][j];
}

/*
int main() {
image im, im2;
imageOuvrir(im, "maze8.pgm" );
imageCopier(im, im2);
imageEnregistrerSous(im2, "copiemaze.pgm" );
}
*/

nargy

mouais...
L'image de départ n'a pas d'importance. Essaye de comprendre comment le code que j'ai posté fonctionne.
Tu peut le réutiliser en simplifiant puisque tu n'a pas besoin de détection de couleur complexe mais uniquement de vérifier si les pixels sont exactement de même couleur.
Puis poste ton code si tu as des problèmes.

sadrine_guillerme

pourriez vous m'expliquer la 1ere ligne pourquoi vous avez mis unsigned?

Publicité

nargy

olala ça va être dur...
unsigned int: un entier non signé, soit positif ou nul
celà représente une coordonnée dans l'image.

nargy

commence par regarder la dernière fonction region().

sadrine_guillerme

Ah bon d'accord!
c ok
mais pour inline ? elle signifie quoi? on doit vraiment le dire (je suis débutante :$)

nargy

laisse tomber inline. c'est pas important pour les trois fonctions region.., et la fonction delta ne te servira pas (c'est pour la couleur).

Message édité par nargy le 10-09-2006 à 23:21:20

sadrine_guillerme

le truc c ke je trouve des delats partout tu pourrais me donner la version finale stp?

nargy

En deuxième, regarde la fonction region_h_rec, elle est commentée. remplace couleur1.delta(couleur0)>threshold par mat[x][y]!=c0. Au lieu d'utiliser la transparence pour marquer les pixels déjà parcourrus, utilise la couleur GRIS.

Message édité par nargy le 10-09-2006 à 23:46:43

el muchacho

Comfortably Numb

La résolution d"exercices est prohibée.

---------------
Les aéroports où il fait bon attendre, voila un topic qu'il est bien

apprentitux

clair !
Elle abuse trop sardine !

nargy

L'algorithme commence au point indiqué x0,y0.
Puis, il parcours horizontalement, à gauche puis à droite, à la recherche d'un pixel de couleur différent de celui de départ. Il note les coordonnées horizontales xmin et xmax, la ligne de pixel horizontale entre ces coordonnées ont la même couleur.
Pour chacun de ces nouveaux pixels, il parcours verticalement suivant le même principe, etc.. tant qu'une ligne horizontale n'est pas vide (xmin!=xmax), ou qu'une ligne verticale n'est pas vide il continue alternativement horizontalement puis verticalement. Enfin, il colorie tous les pixels trouvés en GRIS.

nargy

ouais, de toutes façon ell va devoir se débrouiller parceque je vais y aller.

sadrine_guillerme

bom bah merci bcp pour ton aide nargy c très gentil de ta part g du temps devant moi pour mieux affiner ma recherche bonne nuit!

Publicité

FORUM HardWare.fr

Programmation

C++

à laide svp!!! exo sur C++

Sujets relatifs
implementation de files a laide de pile	[php/SQL] ajouter des enregistrement a laide d'une textarea
laide je cherche le crack de billpro 5.31
Plus de sujets relatifs à : à laide svp!!! exo sur C++

Page générée en 0.089 secondes