Coordonnées des pixels de type double

[sigga]

bonjours à tous
comment faire pour représenter des images avec des coordonnées de pixel de type double?
c'est à dire une image construite à partir des points comme
java.awt.geom.Point2D a = new Point2D.Double(13.1258,85.36985);
en effet j'ai deux tableaux de données
le premier tableau de type int, et contient les valeurs de pixels RGB
j'ai un autre tableau de type double et contient les coordonnées des pixels de l'image originale après l'application d'une interpolation
maintenant je dois construire et afficher une image resultat de l'interpolation
merciiii

[wax78]

Envoyé par sigga

comment faire pour représenter des images avec des coordonnées de pixel de type double?

Un pixel sur l'écran est un pixel, il se calcul en entier, et non en double ou autres.
Pour faire simple, Il faut donc arrondir, ou tronquer tes coordonnées ou interpoler tout les points se trouvant dans le pixel de destination.

[sigga]

je vous remercie wax78 pour votre réponse..
mais en effet j'ai deux tableaux de données
le premier tableau de type int, et contient les valeurs de pixels RGB

Code :

int[] pixels = image.getRGB(0,0, image.getWidth(), image.getHeight(), null, 0, image.getWidth());

j'ai un autre tableau de type double et contient les coordonnées des pixels de l'image originale après l'application d'une interpolation

Code :

1
2
3
4
5
6
7
8
9
10
11
12
gridValues = new Double[(xNumCells) * (yNumCells)];
 
        for (int i = 0; i < yNumCells; i++) {
            for (int j = 0; j < xNumCells; j++) {
// les points dp sont les points de l'image originale avec des coordonnées de type int (j,i)
// getValue() est la fonction d'interpolation
            	Point dp = new Point(j,i);
            	int index = (i * xNumCells) + j;
            	double value =  getValue(dp);
                gridValues[index] = value;
            }
        }

maintenant je dois construire et afficher une image resultat de l'interpolation, avec les coordonnées:

Code :

java.awt.geom.Point2D a = new Point2D.Double(j+gridValues[j],i+gridValues[j])

et le cast peut provoquer une perte de précision
tableau des pixels: 255 189 200 120
tab des coordonnées après interpolation: 25.6236 25.856 23.658 21.548

avec un cast on obtient les valeurs suivants

tableau des pixels: 255 189 200 120
tab des coordonnées après interpolation: 25 25 23 21

la position 25 dans le tab des coordonnées peut avoir deux valeurs 255 et 189
comment faire pour résoudre ce problème??

[plegat]

Salut

Envoyé par sigga

comment faire pour résoudre ce problème??

Prendre le problème à l'envers!

Là, tu as interpolé les pixels de l'image de départ pour tenter de les positionner sur l'image d'arrivée. Pourquoi ne pas plutôt faire l'inverse? Tu prends les pixels de l'image d'arrivée, et tu vas chercher à quel pixel de l'image de départ ça correspond. Et si ça tombe entre deux pixels, tu interpoles... mais sur l'image de départ!

[dinobogan]

Pour ta valeur en double 25.6236, tu prends 62% (valeur après virgule) de la case 26 et 38% (1 - valeur_apres_virgule) de la case 25 sur toutes tes composantes RGB.

Il faut voir la valeur double comme une valeur intermédiaire entre deux cases. Pour 0.5, se sera la moyenne entre les deux cases (la moitié de la première et la moitié de la seconde).

[sigga]

Envoyé par plegat

Salut



Prendre le problème à l'envers!

Là, tu as interpolé les pixels de l'image de départ pour tenter de les positionner sur l'image d'arrivée. Pourquoi ne pas plutôt faire l'inverse? Tu prends les pixels de l'image d'arrivée, et tu vas chercher à quel pixel de l'image de départ ça correspond. Et si ça tombe entre deux pixels, tu interpoles... mais sur l'image de départ!

je vous remercie plegat pour votre réponse mais je n'ai pas bien compris ce que vous vouliez dire, comment inverser le problème?
peut être mon problème n'été pas bien expliqué au debut
Voici mon problème complet
j'ai une image I0, et je doit la déformer avec la méthode d'interpolation thin plate spline (spline plaque mince)
thin plate spline permet de déformer l'image en définissant un ensemble des points de contrôle et leurs positions de destination, puis les points de contrôle sont déplacés vers les positions souhaitées.
X = x+dx
Y = y+dy
(x,y): les coordonnées de l'image source(I0)
(X,Y): les coordonnées de l'image resultat(I1) après déformation



Le gros avantage de cet algorithme est que l'image après transformation semble très naturel, une explication simple sur la méthode thin plate spline peut être vu icithin plate spline

maintenant le problème
le résultat de l'interpolation est un tableau de double, il contient les valeurs dx dans le cas d'une interpolation selon l'axe des x ou bien les valeurs dy dans le cas d'une interpolation selon l'axe des y
alors, les coordonnées de l'image résultat I1(X,Y) seront aussi de type double :
X = x+dx (int + double = double)
Y = y+dy

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
gridValues = new Double[(xNumCells) * (yNumCells)];
 
        for (int i = 0; i < yNumCells; i++) {
            for (int j = 0; j < xNumCells; j++) {
// les points dp sont les points de l'image originale avec des coordonnées de type int (j,i)
 
            	Point dp = new Point(j,i);
            	int index = (i * (1 + xNumCells)) + j;
// getValue() est la fonction d'interpolation
            	double value =  getValue(dp);
// gridValuesX est le tableau qui contient le résultat de l'interpolation selon l'axe des X
                gridValuesX[index] = value;
            }
        }

les coordonnées de l'image résultat sont comme suite

Code :

java.awt.geom.Point2D a = new Point2D.Double(j+gridValuesX[j],i+gridValuesY[j])

comment faire pour afficher cette image?
wax78 me propose de faire un cast de double à int, dans ce cas nous seront confronté à un autre problème,
dans une image chaque pixel(x,y) doit avoir une seule valeurs RGB comme suite


mais avec le cast un pixel(x,y) peut avoir plus q'une seule valeur RGB comme le pixel 25 ici



comment résoudre ce problème?
j'espère que le problème est bien expliqué maintenant

[wax78]

Une sorte warping que tu voulais faire, maintenant je comprends mieux, oublie ce que j'ai dit

[dinobogan]

As-tu testé ma technique ?
Ce n'est pas un "simple" déplacement de pixel. Chaque couleur doit être entièrement recalculée.

[sigga]

Envoyé par dinobogan

As-tu testé ma technique ?
Ce n'est pas un "simple" déplacement de pixel. Chaque couleur doit être entièrement recalculée.

je vous remercie dinobogan pour votre réponse, mais j'ai pas compris ce que vous voulez dire par on prends 62% (valeur après virgule) de la case 26 et 38% (1 - valeur_apres_virgule) de la case 25 sur toutes tes composantes RGB. et
Chaque couleur doit être entièrement recalculée

[tchize_]

D'abord, tu ne dois pas regarder à quel pixel de l'image d'arrivée correspond un pixel de l'image de départ, mais l'inverse. Sinon, dans ton calcul, tu aura inévitablement des trous.

Imagine que 4;4 au départ corresponde à 3.2;4 à l'arrivée et que 5;4 corresponde 6.5;4, que mettre en 4;4 et 5;4 sur l'image d'arrivée? Ces points ne sont jamais calculés.
Donc ton algorithme doit être l'inverse, puisque le but est de construire chaque pixel de l'image d'arrivée.

pour chaque pixel de l'image d'arrivée

• calculer la paire de double qui correspond à l'image de départ:
• calculer la valeur de la couleur de cette position en interpolant à partir des pixels entourant ce point (il est à une certaine distance des 4 pixels l'entourant, pondérer en fonction des distance)
• appliquer cette couleur à l'image d'arrivée.

[plegat]

Envoyé par tchize_

Donc ton algorithme doit être l'inverse, puisque le but est de construire chaque pixel de l'image d'arrivée.

pour chaque pixel de l'image d'arrivée

• calculer la paire de double qui correspond à l'image de départ:
• calculer la valeur de la couleur de cette position en interpolant à partir des pixels entourant ce point (il est à une certaine distance des 4 pixels l'entourant, pondérer en fonction des distance)
• appliquer cette couleur à l'image d'arrivée.

Voila, c'est ça que je voulais dire... mais _tchize l'a dit mieux que moi!

[sigga]

Envoyé par tchize_

D'abord, tu ne dois pas regarder à quel pixel de l'image d'arrivée correspond un pixel de l'image de départ, mais l'inverse. Sinon, dans ton calcul, tu aura inévitablement des trous.

Imagine que 4;4 au départ corresponde à 3.2;4 à l'arrivée et que 5;4 corresponde 6.5;4, que mettre en 4;4 et 5;4 sur l'image d'arrivée? Ces points ne sont jamais calculés.
Donc ton algorithme doit être l'inverse, puisque le but est de construire chaque pixel de l'image d'arrivée.

pour chaque pixel de l'image d'arrivée

• calculer la paire de double qui correspond à l'image de départ:
• calculer la valeur de la couleur de cette position en interpolant à partir des pixels entourant ce point (il est à une certaine distance des 4 pixels l'entourant, pondérer en fonction des distance)
• appliquer cette couleur à l'image d'arrivée.

Je vous remercie tchize pour votre réponse; mais si vous me donnez un petit exemple illustratif pour bien comprendre je vous serais très reconnaissante

[tchize_]

prenons un exemple simple, un zoom x3.


4;4 sur l'image d'arrivée correspond à 1.333;1.333 (4/3;4/3) sur l'image de départ.

Ce qui donne ça à peu près

Code :

1
2
3
4
A     B
  X
 
C     D

Reste à calculer la couleur de X, qui sera une valeur pondérée de A,B,C et D.
Pour l'interpolation, tu as une chiée d'algorithmes, à toi de prendre celui qui te convient.

Le plus naif, le "nearest point", X = A
Après tu as les interpolations Bilinéaire
X = (A*2/3+B*1/3) *2/3 + (C*2/3+D*1/3)*1/3
les bicubiques, etc