transparents du cours en PDF - IUT d'Arles

Imagerie Numérique
Représentation et codage des images
2. Implémentation d’une
classe Image en C++
E. Remy
IUT de Provence
7/01/2003

19/10/2003 2
ATTENTION
CE COURS NECESSITE UNE REECRITURE
COMPLETE POUR ETRE EN
SYNCHRONISATION AVEC LE
PROGRAMME UTILISE EN TRAVAUX
PRATIQUES.
ETANT ENCORE UTILE TEL QUEL, IL EST
DONNE A TITRE INDICATIF…

19/10/2003 3
Préliminaires
• 3 façons classiques de coder une image :
• Une image « directe » dont chaque pixel contient un
vecteur de couleur, par exemple (R,V,B) ;
• Un vecteur d’images « directes » dont les pixels
contiennent une et une seule composante parmi R, V
et B. Il faut donc avoir les 3 images pour pouvoir
interpréter le codage.
• Une palette plus une image contenant les indices de
couleurs utilisés dans la palette.

19/10/2003 4
Cahier des charges
• Coder toutes les formes d’images bitmap 2D (codage
direct ou codage avec palette, noir et blanc, gris,
couleur, etc).
• Capacité de modifier le contenu de l’image.
• Opérations de conversion faciles d’un type d’image à
un autre.
• Lecture et écriture de l’image dans un fichier sur le
disque dur dans plusieurs choix de formats.

19/10/2003 5
Attributs de la classe
Des dimensions :
• Largeur et hauteur
• entières et strictement positives.
Le tableau de pixel :
• Type de pixel variable : pixel_type
• Taille du tableau varie d’une instance à
l’autre, donc allocation dynamique.
• Tableau « à plat » (schéma).
Pour des raisons de performance, on veut que
les classes héritant de Image puissent avoir
accès directement aux données :
• Droit d’accès « protected ».
template
class Image {
protected:
unsigned int dimx,dimy
dimy;
pixel_type *array;
};

19/10/2003 6
Méthodes primitives
Consultation de la largeur et de
la hauteur :
• Obtenir la valeur, mais…
• Ne pas pouvoir la changer !
Modification de la largeur et de
la hauteur :
• Pouvoir changer la taille de
l’image ;
• Réallouer le tableau de pixels,
sans préservation de l’image
qui est dedans.
• On suppose que le tableau est
déjà alloué avant, ou qu’il est
bien indiqué comme étant à
l’adresse NULL.
inline unsigned int GetDimX(void
void) const
{ return dimx; ; }
inline unsigned int GetDimY(void
void) const
{ return dimy; ; }
void SetSize(const
unsigned int dimx,
const unsigned int _dimy)
{
delete [] array;
dimx = _dimx;
dimy = _dimy;
array = new pixel_type[dimx
dimx*dimy];
}

19/10/2003 7
Modification d’un pixel
Vérification des
paramètres ;
Gestion d’erreur
avec des
exceptions ;
Adressage d’un
pixel dans le
tableau linéaire ;
Modification du
pixel si les
paramètres sont
valides.
void SetPixel(const
unsigned int x, const unsigned int y,
const pixel_type pixel_value)
{
if(x >= dimx)
{
std::
::ostringstream
s;
s

19/10/2003 8
Consultation d’un pixel
Méthode constante :
on ne modifie pas
l’image en la
consultant.
Vérification des
paramètres ;
Gestion d’erreur
avec des exceptions ;
Adressage d’un pixel
dans le tableau
linéaire ;
Renvoi d’une
référence constante
sur le pixel dans le
tableau afin d’éviter
une construction par
copie.
const pixel_type& GetPixel(const
unsigned int x,
const unsigned int y) const
{
if(x >= dimx)
{
std::
::ostringstream
s;
s

19/10/2003 9
void Copy(const
Image& source)
{
Copie d’une image
SetSize(source.dimx
source.dimx,source.dimy);
for(unsigned
long tmax = dimx*dimy
dimy,t=0; t

19/10/2003 10
Constructeurs
Image(const
unsigned int _dimx=0,
const unsigned int _dimy=0)
: dimx(0),
(0),dimy(0),array(NULL)
{ SetSize(_dim
_dimx, x,_dimy); }
• Valeurs des paramètres par défaut : correspond à une image de taille nulle.
• Par sécurité, on utilise la liste d’initialisation pour mettre des d
valeurs
signifiant que l’image est vide, et on utilise uniquement la méthode
SetSize()
() pour effectuer l’allocation du tableau.
Image(const Image& i)
: dimx(0),dimy(0),array(NULL)
{ Copy(i); }
• Utilise la méthode Copy()
• Ne pas abuser du constructeur de copie puisqu’il nécessite la coûteuse
recopie pixel par pixel de l’image source.

19/10/2003 11
Destructeur
~Image()
{ delete [] array; ; }
• Le destructeur est trivial.
• Son seul rôle est de libérer la mémoire prise par le tableau.
• On aurait pu utiliser SetSize(0,0)
qui aurait eu un effet sensiblement
équivalent, mais il était inutile de placer les largeurs et hauteur à zéro pour
ensuite de toutes façons détruire l’instance…
Opérateur d’affectation
inline void operator=(const Image&
src)
{ Copy(src); }
• Très semblable au constructeur de copie ;
• Même coût de recopie.

19/10/2003 12
Conversion implicite
template
void Convert(const
Image& source)
{
SetSize(source.GetDimX
source.GetDimX(), (),source.GetDimY());
for(unsigned
int y=0;y

19/10/2003 13
Conversion explicite
template
void Convert(const
Image& source,
pixel_type (*conversion)(const
const any_type))
{
SetSize(source.GetDimX
source.GetDimX(), (),source.GetDimY());
for(unsigned
int y=0;y

19/10/2003 14
Constructeur (suite)
template
Image(const
Image& i,
pixel_type (*conversion)(const
const any_type))
: dimx(0),
(0),dimy(0),array(NULL)
{ Convert(i,
i,conversion); ; }
• On rajoute un constructeur supplémentaire reposant sur la conversion
explicite.
• Il permet de créer directement une instance d’une image en effectuant la
conversion explicite avec une fonction de conversion.

19/10/2003 15
Type byte
typedef unsigned char byte;
const byte byte_MIN(0);
const byte byte_MAX(UCHAR_MAX);
• On définit un type byte correspondant à un entier positif codé sur une
taille de 8 bits (1 octet).
• On définit aussi deux constantes qui sont les bornes supérieures et
inférieures de l’intervalle de définition de ce type byte.
• Ces définitions sont reposent sur la définition de l’unsigned
char dans la
norme C++ 98. Idem pour UCHAR_MAX dont la définition est incorporées
en faisant #include
.

19/10/2003 16
Type Gray
typedef byte Gray;
const Gray Gray_MIN(0);
const Gray Gray_MAX(byte_MAX);
• En se servant de byte, , on définit maintenant un type Gray permettant de
mémoriser un niveau de gris compris entre 0 (Gray_MIN(
Gray_MIN) ) et 255
(Gray_MAX).
• La définition du type byte était attachée à l’idée de taille 1 octet.
• La définition de ce type Gray est liée au concept de niveau de gris.
• On a vu précédemment que 255 niveaux de gris étaient bien plus que q
ce
que le système visuel humain est capable de percevoir. Notre codage sera
donc probablement suffisant dans tous les cas.

Classe Color (1/2)
class Color {
byte red,green,blue;
public:
Color(byte r=0,byte g=0,byte b=0) : red(r),green(g),blue(b) ) {}
Color(Gray g): red(g),green(g),blue(g) ) {}
inline byte GetRed(void) ) const { return red; }
inline byte GetGreen(void) ) const { return green; }
inline byte GetBlue(void) ) const { return blue; }
…
};
• Toujours en se servant de byte, , on définit maintenant une classe Color
permettant de mémoriser un vecteur couleur dans l’espace RGB.
• Chaque composante du vecteur de couleur est codé par un byte, , et est
donc compris entre 0 (byte_MIN(
byte_MIN) ) et 255 (byte_MAX(
byte_MAX).
• Le constructeur permet de faire par défaut une couleur noire (0,0,0).
0,0).
• 3 accesseurs permettent d’obtenir les valeurs de chaque composante, mais
pas de les modifier. Pour modifier une couleur, en fait il faut en déclarer
une autre, et se servir des paramètres du constructeur.
19/10/2003 17

19/10/2003 18
Classe Color (2/2)
class Color {
…
friend inline bool operator==(const Color& c1,const Color& c2)
{ return c1.red==c2.red && c1.green==c2.green && c1.blue==c2.blue; ue; }
friend inline bool operator!=(const Color& c1,const Color& c2)
{ return c1.red!=c2.red || c1.green!=c2.green || c1.blue!=c2.blue; ue; }
inline Color& operator=(const Color& c)
{ red=c.red
c.red; ; green=c.green
c.green; ; blue=c.blue
c.blue; ; return *this; }
friend std::ostream& & operator

19/10/2003 19
Classe GrayImage
class GrayImage : public Image {
public:
GrayImage(const unsigned int dimx=0,const unsigned int dimy=0)
: Image(dimx,dimy
dimx,dimy)
{}
template
GrayImage(const Image& source)
: Image(0,0)
{ Convert(source); }
…
};
• On la fait hériter de Image afin de bénéficier de tout ce qui est déjà
défini pour une template > Image.
• On rajoutera au niveau de cette classe des méthodes spécifiques à une
image en niveau de gris (en particulier, des méthodes de lecture et
d’écriture d’image en niveau de gris).

19/10/2003 20
Classe ColorImage
class ColorImage : public Image {
public:
ColorImage(const unsigned int dimx=0,const unsigned int dimy=0)
: Image(dimx,dimy
dimx,dimy)
{}
template
ColorImage(const Image& source)
: Image(0,0)
{ Convert(source); }
…
};
• Exactement le même principe, mais avec Image.
• Ici aussi, on rajoutera des méthodes spécifiques aux images en couleurs. c

19/10/2003 21
Classe PaletteImage
template
class PaletteImage : public Image
{
protected:
unsigned int palette_count,palette_max;
pixel_type *palette;
…
};
• Images définies avec une palette ;
• Rester indépendant du type des « couleurs » utilisées comme pour
Image.
• On hérite de Image car l’image contient des numéros de
position des couleurs dans le tableau palette. (schéma)
• On utilise un template pour ne pas verrouiller le type des éléments du tableau
palette.

19/10/2003 22
Constructeur et destructeur de la
classe PaletteImage
PaletteImage(const unsigned int dimx=0,const unsigned int dimy=0,
const unsigned int _palette_max=0)
: Image(dimx,dimy),palette_count(0),
palette_max(_palette_max),palette(NULL)
{ palette = new pixel_type[_palette_max]; }
~PaletteImage()
{ delete [] palette; }
• On décide de contraindre l’utilisateur a donner en paramètre du
constructeur la borne supérieure du nombre de couleurs pouvant être ê
mémorisées dans la palette.
• Ce nombre permet d’allouer la palette au moment de la création de d
l’image.
• Contre partie : la palette est pour l’instant de taille fixe.

19/10/2003 23
Copie d’une PaletteImage
void Copy(const PaletteImage& source)
{
palette_count = source.palette_count;
palette_max
= source.palette_max;
delete [] palette;
palette = new pixel_type[palette_max];
for(unsigned int i=0;i::Copy(source);
}
• Copier une PaletteImage c’est copier la palette…
• Puis copier le tableau d’index.
Consultation d’un pixel
const pixel_type& GetPixel(unsigned int x,unsigned int y) const
{ return palette[Image::
>::GetPixel(x,y)]; }

19/10/2003 24
Modification d’un pixel (1/2)
Pour écrire un pixel avec une couleur donnée, il faut :
1. Trouver si cette couleur est présente dans la palette actuelle, et
noter son numéro.
2. Si oui, utiliser ce numéro dans le tableau de points.
3. Si non, utiliser une entrée libre de la palette pour stocker la
couleur, noter son numéro, et l’utiliser dans le tableau de
points.
4. Si la palette est pleine, il y a échec de l’opération.
On introduit donc deux opérations avant d’écrire PutPixel()
:
• FindPaletteIndex()
et
• AllocatePaletteEntry()
().

19/10/2003 25
Recherche d’une couleur dans la palette
unsigned int FindPaletteIndex(const pixel_type pixel)
{
unsigned int i;
for(i=0;i<
=0;i

19/10/2003 26
Allocation d’une (nouvelle) couleur dans
la palette
unsigned int AllocatePaletteEntry(const pixel_type pixel)
{
}
if(palette_count>=
>=palette_max)
{
std::ostringstream os;
os

19/10/2003 27
Modification d’un pixel (2/2)
void SetPixel(const unsigned int x,const unsigned int y,const pixel_type pixel)
{
}
try { Image::
>::SetPixel(x,y,FindPaletteIndex(pixel)); }
catch(std::string s)
{
}
try { Image::
>::SetPixel(x,y,AllocatePaletteEntry(pixel)); }
catch(std::string s2)
{
std::ostringstream os;
os

19/10/2003 28
Des questions ?