Discussion :

[parano]

Bonjour,

j'aimerai avoir une aide pour démarrer cet exo qui consiste à faire des transformations géométriques sur une image.
Pour ce qui est des classes Pixel et Couleur, je n'ai pas de soucis mais c'est pour les autres : Matrice, Image et Image2D.

Les classes
Dans le cadre de cet exercice, vous êtes amenés à manipuler des instances d'objet des classes

* Couleur (les couleurs sont codées sur 24 bits)
* Pixel qui est une classe dérivée de la classe Couleur
* Image

Conceptuellement, la classe Image devra hériter de la classe Image2D et de la classe générique Matrice (dont le paramètre de généricité sera la classe Pixel). La classe Image2D devra contenir les données et les méthodes qui ne concernent que les images en 2D. Idem pour les classes Matrice ou Pixel.

Dans l'énoncé, je ne comprends pas cette phrase :

la classe générique Matrice (dont le paramètre de généricité sera la classe Pixel).

Cette classe est censée être générique le paramètre générique est connu d'avance.
Du coup, je ne sais pas trop comment faire.
Dans cette classe Matrice, il me semblait que les méthodes permettant la rotation, translations avaient leurs places dans cette classe mais l'énoncé nous dit que c'est la classe Image2D qui doit se charger de ça.
De plus je ne comprends pas très bien l'intéret d'avoir une classe Image et une autre Image2D.

Quelqu'un pourrait-il m'indiquer comment il s'y prendrait pour les différentes classes qui me posent problème.

Merci

[millie]

Dans l'énoncé, je ne comprends pas cette phrase :
...
Cette classe est censée être générique le paramètre générique est connu d'avance.

Cela signifie que ta matrice sera à valeur dans l'ensemble des Pixels (donc il faut utiliser des templates).

Tu pourras aussi définir une image avec des Pixels définis comme des float (noir et blanc), ou en couleur RGB (donc un triplé). Il te faudra bien penser pour par exemple les pixels sous format RGB à définir les opérateurs +, = ... (afin que cela fonctionne aussi bien avec float qu'avec les couleurs RGB).

Et normalement, tu pourras écrire de manière générique des opérateurs sur ta classe image (tel la rotation)

[parano]

Bonjour,

je fais un récapitulatif pour voir si j'ai bien tout compris.
Pixel :
attribut double x,y;
méthode : getteur pour récupérer les coordonnées

Couleur hérite de Pixel
attribut int red, green, blue;
méthode : getteur pour récupérer les couleurs

Matrice classe génerique qui est une représensentation de l'image.
Cette matrice doit donc être de taille : largeur_image * hauteur_image
attribut : T**contenu
int largeur_image, hauteur_image
méthode : getteur et setteur

Image2D : classe abstraite définissant toutes les méthodes que devra implémenter la classe qui en héritera -> ici la classe Image.
Toutes les méthodes modifiant l'image initiale seront déclarées ici
attribut : aucun
méthode : rotation, translation, ...

Image : classe qui hérite de Image2D et de Matrice(je ne comprends pas trop pourquoi cette classe doit être héritée et non en attribut de la classe Image)
attribut : aucun sauf si Matrice est en attribut et non en héritage
méthode : implémente toutes les méthodes qui ont été déclarées dans Image2D + ajouter le constructeur pour le chargement de l'image et une méthode pour la sauvegarde.
Le constructeur se chargera de parcourir l'image (largeur * hauteur) et de remplir la matrice.

Est-ce que tu pourrais m'indiquer si ma représentation est correcte, s'il y a des points à modifier.

Merci

[millie]

En fait, je ne comprend pas pourquoi il met :

Pixel qui est une classe dérivée de la classe Couleur

Pour moi, ce serait plutôt Couleur qui hérite de Pixel.

En fait, je vois pas trop à quoi sert Image2D, pour rendre les méthodes abstraites. Personnellement, j'aurais plutôt vu que Image2D hérite de Matrice et contiennen les méthodes concernant les transformations géométriques (comme rotation, scale), et que Image contienne d'autres transformations (comme la convolution).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
template <typename T> 
class Matrice {
  T* _tab:
  unsigned int _taillex;
  unsigned int _tailley;
 public:
  Matrice(unsigned int taillex, unsigned int taille y);
  virtual T& operator()(unsigned int i, unsigned int j);
  virtual T operator() (unsigned int x, unsigned int y) const;
};

Ensuite :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
class Pixel {
 public:
  virtual Pixel operator=(const Pixel &);
};

Puis :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
class Couleur : public Pixel {
 private:
  float _r; // ou short si il veut du 24 bits
  float _g;
  float _b
 public:
  Couleur operator=(const Couleur &);
  friend Couleur operator+(const Couleur&, const Couleur &); //si il n'y a que des transformations géométriques, l'opérateur là est inutile. Ca sert pour les convolutions.
 
  //+d'autres si tu veux
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class Image2D {
 public: 
  virtual rotation(float angle);
  //...
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
template <typename T> 
class Image : public Image2D, public Matrice<T>
{
 
};

Enfin, je vois pas trop à quoi sert la classe Pixel dans le coup là.

classe qui hérite de Image2D et de Matrice(je ne comprends pas trop pourquoi cette classe doit être héritée et non en attribut de la classe Image)

Si comme ça, tu pourras toujours utiliser l'opérateur ().




Personnellement, je trouve la représentation un peu pas terrible. Je ne vois pas pourquoi Image doit hériter d'Image2D et de Matrice. Alors que logiquement, Image devrait hériter de Matrice... Et Image2D devrait hériter d'Image (en ajoutant par exemple, les méthodes de chargement de fichier). Mais que Image doivent implémenter les opérations géométrique (rotation).

[Luc Hermitte]

@Millie. Héritage et opérateurs sont difficilement compatibles.
Un pixel n'est pas une couleur. Il va en avoir une par contre.

De même, une image n'est pas vraiment une matrice.
Cf les articles sur object mentor pour en revenir aux bases. Un chapitre du bouquin de B.Meyer traite de cela - dispo en ligne.

[millie]

@Millie. Héritage et opérateurs sont difficilement compatibles.

Merci. Je me disais bien que quelque chose ne collait pas.

Un pixel n'est pas une couleur. Il va en avoir une par contre.

En fait, qu'est ce qu'un pixel a en plus par rapport à une couleur. J'avais confondu les deux notions en une seule car je ne voyais pas l'interêt de les séparer.

J'avais déjà voulu regarder un peu la manière dont était écrit la bibliothèque JAI (Java Advanced Imaging), mais je me suis vite perdu dans les classes

De même, une image n'est pas vraiment une matrice.

Là, on est d'accord

[Luc Hermitte]

Si tu veux voir un design intéressant et très C++, jette plutôt un coup d'oeil à GIL d'adobe -- prochainement dans boost.