Discussion :

[FidoDido®]

Bonjour,

je travaille actuellement sur un principe de "boîtes à images", développement en C de boîtes noires d'application de différents traitements à des images.
Je travaille donc sur une structure de tableaux de pixels (autant de tableaux qu'il y a de couches (R,G,B,transparence...))
Ces tableaux sont donc de taille "longueur*largeur"

J'ai un problème en ce qui concerne l'algorithme de rotation d'une image. Je compte l'implémenter avec une rotation de centre le centre de l'image, avec pour argument un angle flottant.
Il semble alors obligatoire de passer par les coordonnées polaires des pixels, mais cela me paraît tendu. Et je ne trouve rien de très probant.

Pourriez-vous m'indiquer, si vous en connaissez, des algorithmes appropriés ?

Merci

[ToTo13]

Bonsoir,

ton problème est quelque chose de bien connu en imagerie, mais n'a pas forcément de solution.
En effet, la rotation d'un espace discret dans un autre n'est absolument pas une application bijective.
Seule les rotations de +-Pi/4, +-Pi/2, +-Pi ont une solution évidente.
Pour toute les autre rotations, il te faudrait faire une approximation de où mettre le pixel.

[FidoDido®]

Ok, merci, bon donc ca parait assez compliqué, pcq l'approximation va avoir pour effet de dénaturer l'image, non ?
Bon en tout cas, avant toute chose, je vais m'occuper des rotations 'simples' et je verrai les autres après.

Bonne soirée

[Pegasus32]

Moi je partirai de chaque pixel d'arrivée, et par une rotation inverse je regarde quels sont les pixels de départ qui lui correspondent, et je fait une moyenne pondérée des composantes RGBA de ces pixels

(par exemple : pour un pixel d'arrivée, tu arrives à la coordonnée X de départ 5.78. Donc tu pondère par 0.78 du pixel 6 et 0.22 du pixel 5)

Evidemment faut rajouter la composante Y dans l'equation.

Voila, une idée à l'arrache donc je sais pas ce que ca donne

[Flo.]

Salut,

non non c'est loin d'être "idiot" ...

Ce dont tu parles c'est d'une interpolation bi-linéaire (ordre 1).

En outre, c'est ainsi que l'on fait la rotation d'une image, en calculant pour chaque pixel de l'image d'arrivée les coordonnées correspondantes du pixel de l'image de départ. Dans l'autre sens on se retrouve avec des "trous" dans l'image d'arrivée.

Donc soit tu peux faire une rotation bête et méchante sans interpolation (ça marche quand même et ça reste propre) (donc la coordonée x=5.78 deviendra x=6), soit tu peux faire avec interpolation bi-linéaire :

Tu veux calculer le niveau de gris du couple d'entier (x2;y2) de l'image d'arrivée, en faisant la rotation inverse tu te retrouves avec le couple de floattants (x1;y1) de l'image de départ auquel tu peux adjoindre 4 couples d'entiers :

- le couple C1 (x11; y11) avec un niveau de gris G1
- le couple C2 (x11+1; y11) avec un niveau de gris G2
- le couple C3 (x11; y11+1) avec un niveau de gris G3
- le couple C4 (x11+1; y11+1) avec un niveau de gris G4

avec :

x11 = partie entiere de x1
y11 = partie entière de y1

on calcule la distance sur chaque axe entre C1 et (x2; y2) (le 0.78 de Pegasus32) :

Code :

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

1
2
dx = x1 - x11
dy = y1 - y11

pour calculer le niveau de gris de (x2; y2)

Code :

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

1
2
3
4
G = (1-dx) * (1-dy) * G1 +
    (  dx) * (1-dy) * G2 +
    (1-dx) * (  dy) * G3 +
    (  dx) * (  dy) * G4

En gros plus on est pres d'un des 4 coins/pixels qui englobe le pixel floattant, plus on est influencé par sa couleur.

Voila

A+

Flo.

[Matthieu Brucher]

C'est en gros ce qui est fait dans les logiciels de dessin, pour une rotation, translation, dilatation, contraction.
Il y a l'algorithme des plus proches voisins, ce que Flo a proposé, ce que Pegasus propose, c'est une interpolation bilinéaire - bi parce que 2 interpolations linéaires, l'une sur les absisses, l'autre les ordonnées -, ensuite, on peut prendre plus de voisins, des fonctions non linéaires, ...
Mais quoiqu'il arrive, on part de l'espace d'arrivée : d'om vient le point qu'on considère. Dans le cas contraire, on peut avoir des trous pour certains déformations.

[Flo.]

Oui enfin, ce que je détaille c'est bien l'interpolation bi-linéaire (interpolation d'ordre 1). Le cas des plus proches voisins je ne fais que l'évoquer .

Sinon effectivement on peut faire une interpolation d'ordre 2 (avec 9 pixels voisins), d'ordre 3 (avec 16 pixels voisins), en utilisant des splines.

Moi je pense que l'ordre 1 est un bon compromis pour quelqu'un qui veut s'essayer à la rotation d'images.

A+.

Flo.

[FidoDido®]

Merci pour vos réponses nombreuses, je vais me tenter sur une approximation à l'ordre 1 pour commencer. Si j'ai le temps (et/ou le courage) je tenterai des approximations plus fines.

FidoDido

[FidoDido®]

Re kikoo tout le monde.

Bon, l'interpolation bilinéaire est codée et les resultats sont carrément satisfaisants pour ce qui est de la rotation d'une image.
Maintenant, j'aimerais tester l'interpolation bicubique, mais je ne trouve nulle part un algorithme.
Pouvez-vous m'éclairer ?

Merci
FidoDido

[mathieu_t]

Ici !

Précisons que tes temps de calculs vont bien sûr exploser, on n'a pas une meilleure précision sans contrepartie !
A++

[FidoDido®]

Merci beaucoup...

[mitmal]

Bonjour tout le monde,

Je viens de lire avec beaucoup d'interet votre conversation.
Dans mon cas je suis en C++ et j'ai des images DICOM, traitant de zones anatomiques de patients.

J'aimerai appliquer une rotation sur ses images (que je stoque dans des short*)
J'aimerai savoir si quelqu'un peut me donner le code C++ pour faire ce genre de chose.
Merci beaucoup

[souviron34]

J'aimerai savoir si quelqu'un peut me donner le code C++ pour faire ce genre de chose.

Bonjour

ici on ne fait pas les choses à la place des gens...

Cependant le codage est ultra-simple...

Comment s'exprime une rotation d'un point (x,y) ?

Tu pars de l'image d'arrivée, tu explores chaque pixel, et tu calcules sa rotation inverse, et tu lui affectes la valeur de ce pixel dans l'image de départ...