Discussion :

[jp_developpeur]

Bonjour,

J'aurais besoin d'un algorithme (voire code) me permettant de redresser une image. Au lieu de la voir une route en perspective par exemple, je la verrai vu d'avion. Je code sous matlab. Je connais quelques principes comme le fait de prendre des points fixes sur l'image en perspective et de dire qu'ils sont à l'infinis sur l'iamge reel (vu d'avion) mais je n'y arrive pas.
Ce qu'il me faudrai c'est la matrice de passage entre ces deux images.

Merci d'avance,

JP

[ArgusAzure]

Je chercherais du coté de l'homographie si j'ai quelque points en correspondance entre les 2 images.

[jp_developpeur]

Je chercherais du coté de l'homographie si j'ai quelque points en correspondance entre les 2 images.

OK pour l'info mais je trouve pas grd chose. Je sais que c'est cela que je dois faire (prendre quelques points de l'image en perspective) et retrouver les "vraies" coordonnées dans l'image redressée. Seulement ma question est comment déterminer cette matrice de passage ente les 2 images?

merci

JP

[ToTo13]

Bonjour,

mmm... il me semble (à confirmer) que le package imagescience(s).jar utilisé dans certains plugins de ImageJ fait ce genre de chose.

Sinon est ce qu'un petite lancé de rayon de pourrait pas suffire pour ton problème ?

[jp_developpeur]

Bonjour,

mmm... il me semble (à confirmer) que le package imagescience(s).jar utilisé dans certains plugins de ImageJ fait ce genre de chose.

Sinon est ce qu'un petite lancé de rayon de pourrait pas suffire pour ton problème ?

Pour le moment je n'ai encore rien codé sur cela.
J'ai commencé par travailler sur papier mais j'arrivais à des resolution de systemes impossibles.. Je n'arrive pas à voir où sont la ou les erreurs. C'est pour cela que j'ai besoin d'aide!!!!

Je travaille sous Matlab.

Merci de m'aider


JP

[ArgusAzure]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
On cherche la fonction h : (u,v) -> (x,y)
 
    |a b c|	
h=  |d e f|
    |g h i|
 
          |x|    |u|
lambda *  |y|= H |v|
          |1|    |1|
 
cela revient à chercher 
 
  Dh=C
  avec i=1 (on a 8 degrès de liberté et 9 inconnues)
avec   trans (h') =  |a b c d e f g h|
 
Pour chaque correspondant, on a 2 lignes de les matrices C et D
Pour le correspondant n :
Dn  = |x y   1  0  0  0 -u*x -u*y |
      |0  0  0  u' v'  1 -v*x -v*y |
 
Cn= |u|
    |v|
 
 
Avec la méthode de la pseudo inverse pour résoudre le système : 
h' estimé =  inv( trans(D)*D ) * trans(D)*C

C'est du tout cuit pour matlab.

[jp_developpeur]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
On cherche la fonction h : (u,v) -> (x,y)
 
    |a b c|	
h=  |d e f|
    |g h i|
 
          |x|    |u|
lambda *  |y|= H |v|
          |1|    |1|
 
cela revient à chercher 
 
  Dh=C
  avec i=1 (on a 8 degrès de liberté et 9 inconnues)
avec   trans (h') =  |a b c d e f g h|
 
Pour chaque correspondant, on a 2 lignes de les matrices C et D
Pour le correspondant n :
Dn  = |x y   1  0  0  0 -u*x -u*y |
      |0  0  0  u' v'  1 -v*x -v*y |
 
Cn= |u|
    |v|
 
 
Avec la méthode de la pseudo inverse pour résoudre le système : 
h' estimé =  inv( trans(D)*D ) * trans(D)*C

C'est du tout cuit pour matlab.

Merci ArgusAzure!!!!!!!!!!!!!!!!!!!!!!!!!!
je teste ça et je te redis si ça fonctionne!!!

a+

JP

[ArgusAzure]

Petite rectification

Code :

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

1
2
3
 
Dn  = |x  y  1  0  0  0 -u*x -u*y |
      |0  0  0  x  y  1 -v*x -v*y |

Alors, ça march' ti ?

[pseudocode]

Pour info: Projective Mappings for Image Warping

ArgusAzure

[jp_developpeur]

J'ai fait un mixte de tous ce que g trouvé sur internet mais je n'arrive pas à obtenir l'image redressé (vue d'avion). Il y a mon code en piece jointe. Il s'agit de la dernière boucle: au lieu de m'afficher tous les pixels, j'observe qu'une valeur de pixel. Comment resoudre ce pb mais egalement est ce que mon pgm fonctionnera. J'utilise 2 pts de fuite avc une origine. Pour le moment, je me moque du faccteur entre les deux images.

Merci de m'aider, c'est assez urgent.

JP

PS:Le pgm est un peu long (si vs trouvez un moyen pour l'alléger en tps de calcul).

[pseudocode]

Je peux le faire en Java, mais en Matlab: non.

Le programme principal:

Code java :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
public static void main(String[] args) {
	Image source = new Image(new File("droit.jpg"));
 
	// 4 points qui definissent un carré/rectangle dans l'image 
	// (ici les 4 coins de la route)
	Point P1 = new Point(10,71);
	Point P2 = new Point(134,71);
	Point P3 = new Point(71,24);
	Point P4 = new Point(62,24);
 
	// resolution du systeme
	double[] system = getSystem(P1,P2,P3,P4);
	System.out.println(Arrays.toString(system));
 
	// creation de l'image corrigée (ici avec un ratio 1/8)
	int W=100,H=800;
	Image target = new Image(W,H);
 
	// pour chaque pixel (x,y) de l'image corrigée
	for(int y=0;y<H;y++) {
		for(int x=0;x<W;x++) {
 
			// conversion dans le repère orthonormé (u,v) [0,1]x[0,1]
			double u = (double)x/W;
			double v = (double)y/H;
 
			// passage dans le repère perspective
			double[] P = invert(u, v, system);
 
 
			// copie du pixel (px,py) correspondant de l'image source 
			// TODO: faire une interpolation
			int px=(int)Math.round(P[0]);
			int py=(int)Math.round(P[1]);
			target.setrgb(x, y, source.getrgb(px, py) );
		}
	}
}

Et les algos de calcul issus du PDF dont j'ai donné le lien ci-avant

Code java :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
public static double[] getSystem(Point... P) {
	double[] system = new double[8];
	double sx = (P[0].x-P[1].x)+(P[2].x-P[3].x);
	double sy = (P[0].y-P[1].y)+(P[2].y-P[3].y);
	double dx1 = P[1].x-P[2].x;
	double dx2 = P[3].x-P[2].x;
	double dy1 = P[1].y-P[2].y;
	double dy2 = P[3].y-P[2].y;
 
	double z = (dx1*dy2)-(dy1*dx2);
	double g = ((sx*dy2)-(sy*dx2))/z;
	double h = ((sy*dx1)-(sx*dy1))/z;
 
	system[0]=P[1].x-P[0].x+g*P[1].x;
	system[1]=P[3].x-P[0].x+h*P[3].x;
	system[2]=P[0].x;
	system[3]=P[1].y-P[0].y+g*P[1].y;
	system[4]=P[3].y-P[0].y+h*P[3].y;
	system[5]=P[0].y;
	system[6]=g;
	system[7]=h;
 
	return system;
}
 
public static double[] invert(double u, double v, double[] system) {
	double x = (system[0]*u+system[1]*v+system[2])/(system[6]*u+system[7]*v+1); 
	double y = (system[3]*u+system[4]*v+system[5])/(system[6]*u+system[7]*v+1);
	return new double[]{x,y};
}

[jp_developpeur]

Merci pseudocode, c'est genial!!!!

[jokoss]

merci à pseudocode et ArgusAzure, je me suis également inspiré de vos posts pour implémenter une solution par cette technique. J'étais justement en train de me tourner vers cette méthode mais dans les articles que j'avais, ils ne parlaient pas du raccourci de la résolution du système.

J'aurai tout de même une question, es-t-il possible , grâce aux points de fuite ou autre, de retrouver le rapport largeur sur longueur du rectangle initial, car cette technique demande la largeur et longueur de sortie du rectangle.

Ca doit surement être relativement simple mais ce n'est pas évident de faire des recherches sur ce sujet.

Merci à vous.

[ArgusAzure]

La technique que j'exposais nécessite 4 correspondants, le plus éloignés possible pour réduite les erreurs et non alignés. Mais ils ne sont pas forcément les coins d'un rectangle dans l'image "redressée" même si dans la pratique, c'est souvent le cas.

[jokoss]

oui je sais que ca ne correspond pas forcément à un rectangle mais dans mon cas c'est le cas.

J'aimerai juste pouvoir connaître les réelles proportions du rectangle de départ (pas forcément les tailles mais au moins les proportions. Même si connaître les tailles serai encore mieux.

merci.

[pseudocode]

La technique que j'exposais nécessite 4 correspondants, le plus éloignés possible pour réduite les erreurs et non alignés.

Ta technique est bien plus genérale que celle que j'ai exposé. D'un autre coté, le fait de se limiter a un rectangle permet de simplifier la résolution du système.

J'aimerai juste pouvoir connaître les réelles proportions du rectangle de départ (pas forcément les tailles mais au moins les proportions. Même si connaître les tailles serai encore mieux.

Hum... je ne suis pas sur que ce soit possible. Si quelqu'un à des infos...

[ArgusAzure]

J'aimerai juste pouvoir connaître les réelles proportions du rectangle de départ (pas forcément les tailles mais au moins les proportions. Même si connaître les tailles serai encore mieux.

La taille en quoi en mètres? En pixels, je ne vois pas ce que ça veut dire.

[jokoss]

Non certainement pas la taille en mètre. Soit une taille en pixel. Par exemple imaginons que l'on prenne en photo un rectangle en perspective, peut-on connaître la taille (en pixel) de la même image si elle avait été prise de face.

A défaut d'une taille , une proportion longueur-largeur serai intérressante aussi.

[ArgusAzure]

Non certainement pas la taille en mètre. Soit une taille en pixel. Par exemple imaginons que l'on prenne en photo un rectangle en perspective, peut-on connaître la taille (en pixel) de la même image si elle avait été prise de face.

Il faudrait au moins connaitre la distance à laquelle tu te mets pour prendre cette fameuse photo et la définition de ton capteur.

[jokoss]

Oui je reconnais que trouver une taille n'a pas de sens car on peut le redresser de différente manière et selon cette manière le rectangle se trouverai plus ou moins loin.

Par contre trouver des proportions devrai être possible logiquement.

Imaginons une forme en trapèze (2 coté parallèles et les 2 autres se coupant quelque part en un point de fuite), si on prend comme largeur du rectangle redressé la longueur du plus grand des 2 cotés parallèles, on devrai pouvoir en déduire la taille de la longueur du rectangle. Par exemple on peut dire que plus le point de fuite des 2 cotés non parallèles est près, plus la longueur réelle du rectangle est grande et inversément si le point de fuite est très éloigné, le rectangle n'est quasiment pas déformé et donc la longueur apparente est presque correcte.