Correction de perspective en C

**CreativeC** · 27/11/2020, 20h21

Bonjour,
je m'efforce de suivre ce tutoriel afin de corriger la perspective d'une image, seulement, après avoir galéré 6 heures, et avoir une inversion et une multiplication de matrices fonctionnelles (l84 à 131), je fais la dernière étape de l'algorithme (trouver chaque pixel (X,Y) dans ma nouvelle matrice à l'aide des coefficient trouvés grace à la multiplication de matrice (dans le lien ils écrivent 3 matrices en disant: AB = C, et je retrouve B en disant B = A^-1*C)

Seulement, après avoir sauvegardé mon image, cela donne le résultat incroyable en annexe...

Je vous avoue que je suis un peut à bout, j'ai tout revérifié, j'envoie les bons coordonnées en entier, mes fonctions de création de la matrice de 8*8, d'inversion de matrice et de multiplications de matrices fonctionnent, car je les ai testées, et elles renvoient les même résultats que les inverseurs de matrice en ligne (j'ai effectué 4 tests)...

Je vous implore à l'aide car je dois terminer ceci d'ici 3 jours (on se laisse avec mon groupe 2 semaines et demie de marge pour l'assemblage et les corrections, au cas où il y aurait des problèmes, ou que la fin de semestre serait chargée...)
Merci d'avance.
PS: je sais que tout mon code est dans mon main, et que je ne peux pas l'appeler avec des arguments, pour l'instant je m'occupe de faire un code fonctionnel.

Code C :

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <unistd.h>
#include <SDL2/SDL.h>
#include <string.h>
 
//#include "tools/bin/resize.h"
//#include "separator/separator.h"
#include "binarization/binarize.h"
#include "SDL_Manager/import-export.h"
#include "skew/skew.h"
 
//Safety test env
#ifndef ENV_TEST
 
double abse(double x){
  if (x < 0)
    return -x;
  return x;
}
double lemax(double x, double y){
  if (x > y)
    return x;
  else
    return y;
}
double lemin(double x, double y){
  if (x < y)
    return x;
  else
    return y;
}
 
int main(int argc, char ** argv)
{
  double * ptdr = NULL;
  ptdr = malloc(8*sizeof(double));
  ptdr[0] = 37;
  ptdr[1] = 381;
  ptdr[2] = 647;
  ptdr[3] = 441;
  ptdr[4] = 115;
  ptdr[5] = 1219;
  ptdr[6] = 787;
  ptdr[7] = 1200;
 
  int l = 8;
  double * boardg = NULL;
  boardg = malloc(l * l * sizeof(double));
  double * inv = NULL;
  inv = malloc(l * l * sizeof(double));
  for(int i = 0;i<l*l;i++){
    if (i%(l+1) == 0)
      inv[i] = 1;
    else
      inv[i] = 0;
  }
  for(int i = 0;i<l*l;i++)
    boardg[i] = 0;
 
  for(int i = 0;i<4;i++){
    boardg[l*i] = boardg[l*(i+4)+3] = boardg[l*i+6] = boardg[l*(i+4)+6] = ptdr[2*i];
    boardg[l*i+1] = boardg[l*(i+4)+4] = boardg[l*i+7] = boardg[l*(i+4)+7] = ptdr[2*i+1];
    boardg[l*i+2] = boardg[l*(i+4)+5] = 1;
  }//*/
  ptdr[0] = ptdr[4] = lemin(ptdr[0],ptdr[4]);
  ptdr[1] = ptdr[3] = lemin(ptdr[1],ptdr[3]);
  ptdr[2] = ptdr[6] = lemax(ptdr[2],ptdr[6]);
  ptdr[7] = ptdr[5] = lemax(ptdr[7],ptdr[5]);
  for(int i = 0;i<4;i++){
    boardg[l*i+6] *= -1 * ptdr[2*i];
    boardg[l*i+7] *= -1 * ptdr[2*i];
    boardg[l*(i+4)+6] *= -1 * ptdr[2*i+1];
    boardg[l*(i+4)+7] *= -1 * ptdr[2*i+1];
  }
  /*
  for(int i = 0; i < l*l;i++){
    if (i %l == 0)
      printf("\n");
    printf(" %f ,",boardg[i]);
  } //*/
 
  //Calcul inverse
  int r = -1;
  for (int j = 0; j < l;j++){
    int k = r+1;
    for(int i = k;i< l;i++){
      if (abse(boardg[l*i + j]) > abse(boardg[l*k + j]))
        k = i;
    }
    if (boardg[l*k+j] != 0){
      r += 1;
      double divisor = boardg[k*l+j];
      for(int i = 0; i < l;i++){
        boardg[k*l+i] /= divisor;
        inv[k*l+i] /= divisor;
      }
      if (k != r){
        for(int i = 0; i < l;i++){
          double tmp = boardg[r*l+i];
          boardg[r*l+i] = boardg[k*l+i];
          boardg[k*l+i] = tmp;
          double tmp2 = inv[r*l+i];
          inv[r*l+i] = inv[k*l+i];
          inv[k*l+i] = tmp2;
        }
      }
      for (int i = 0; i < l;i++){
        if (i != r){
          double tmp = boardg[i*l+j];
          for (int wow = 0; wow < l;wow++){
            boardg[i*l+wow] -= boardg[r*l+wow] * tmp;
            inv[i*l+wow] -= inv[r*l+wow] * tmp;
          }
        }
      }
    }
  } //*/
 
  //Multiplication matrice
  double res[l];
  for (int i=0;i<l;i++){
    res[i] = 0;
    for(int j = 0;j<l;j++){
      res[i] += inv[l*i+j] * ptdr[j];
    }
    //printf("%f\n",ptdr[i]);
    printf("%f\n",res[i]);
  }
 
  //Initialisation SDL
  printf("\nui\n");
  int x;
  int * px = &x;
  int y;
  int * py = &y;
  SDL_Surface * image = load_image("ANT.BMP", px, py);
  Uint8 * board3 = NULL;
  board3 = malloc(x * y * sizeof(Uint8));
  gray(image,board3);
  Uint8 * board2 = NULL;
  board2 = malloc(x * y * sizeof(Uint8));
  //Application nouvelles coordonnées
   for(Uint16 i = 0; i < x;i++){
     for(Uint16 j = 0; j < y;j++){
      int ppx = (int) ((res[0]*i+res[1]*j+res[2])/(res[6]*i+res[7]*j+1));
      int ppy = (int) ((res[3]*i+res[4]*j+res[5])/(res[6]*i+res[7]*j+1));
      if (ppy>0 && ppy < y && ppx >0 && ppx < x)
        board2[j*x + i] = board3[ppy*x+ppx];
    }
  }
 
  save(board2,x,y,"/home/user/Bureau/ocr/src/main/c/oui.bmp");
  printf("\nChaussette\n\n");
  free(board3);
  free(board2);
  free(boardg);
  free(ptdr);
  return 0;
}
 
#endif

Entrée:

Résultat:

**CreativeC** · 28/11/2020, 10h07

J'ai eu une révélation pendant la nuit: ma multiplication était foireuse, puis ce que dans ma multiplication, je considérais que l'array ptdr[] était agencé comme ceci : (X1,X2,X3,X4,Y1,Y2,Y3,Y4) alors qu'il l'est comme ça: (X1,Y1,X2,Y2,X3,Y3,X4,Y4).
J'ai donc l'agencement ptdr[], car vu comment je l'utilise, (X1,X2,X3,X4,Y1,Y2,Y3,Y4) est plus pratique à manier.

Voici mon code modifié

Code C :

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <unistd.h>
#include <SDL2/SDL.h>
#include <string.h>
 
//#include "tools/bin/resize.h"
//#include "separator/separator.h"
#include "binarization/binarize.h"
#include "SDL_Manager/import-export.h"
#include "skew/skew.h"
 
//Safety test env
#ifndef ENV_TEST
 
double abse(double x){
  if (x < 0)
    return -x;
  return x;
}
double lemax(double x, double y){
  if (x > y)
    return x;
  else
    return y;
}
double lemin(double x, double y){
  if (x < y)
    return x;
  else
    return y;
}
 
int main(int argc, char ** argv)
{
  int x;
  int * px = &x;
  int y;
  int * py = &y;
  SDL_Surface * image = load_image("ANT.BMP", px, py);
 
  double * ptdr = NULL;
  ptdr = malloc(8*sizeof(double));
  //x1,y1,...
  ptdr[0] = 37;
  ptdr[4] = 381;
  ptdr[1] = 647;
  ptdr[5] = 441;
  ptdr[2] = 115;
  ptdr[6] = 1219;
  ptdr[3] = 787;
  ptdr[7] = 1200;
 
  int l = 8;
  double * boardg = NULL;
  boardg = malloc(l * l * sizeof(double));
  double * inv = NULL;
  inv = malloc(l * l * sizeof(double));
  for(int i = 0;i<l*l;i++){
    if (i%(l+1) == 0)
      inv[i] = 1;
    else
      inv[i] = 0;
  }
  for(int i = 0;i<l*l;i++)
    boardg[i] = 0;
  for(int i = 0;i<4;i++){
    boardg[l*i] = boardg[l*(i+4)+3] = boardg[l*i+6] = boardg[l*(i+4)+6] = ptdr[i];
    boardg[l*i+1] = boardg[l*(i+4)+4] = boardg[l*i+7] = boardg[l*(i+4)+7] = ptdr[i+4];
    boardg[l*i+2] = boardg[l*(i+4)+5] = 1;
  }//*/
 
  //Transformation de x,y en X,Y
 
  ptdr[0] = ptdr[2] = lemin(ptdr[0],ptdr[2]);
  ptdr[4] = ptdr[5] = lemin(ptdr[4],ptdr[5]);
  ptdr[1] = ptdr[3] = lemax(ptdr[1],ptdr[3]);
  ptdr[7] = ptdr[6] = lemax(ptdr[7],ptdr[6]);
  /*
  ptdr[0] = ptdr[2] = 10;
  ptdr[4] = ptdr[5] = 10;
  ptdr[1] = ptdr[3] = x-10;
  ptdr[7] = ptdr[6] = y-10; */
 
 
  for(int i = 0;i<4;i++){
    boardg[l*i+6] *= -1 * ptdr[i];
    boardg[l*i+7] *= -1 * ptdr[i];
    boardg[l*(i+4)+6] *= -1 * ptdr[i+4];
    boardg[l*(i+4)+7] *= -1 * ptdr[i+4];
  }
  /*
  for(int i = 0; i < l*l;i++){
    if (i %l == 0)
      printf("\n");
    printf(" %f ,",boardg[i]);
  } //*/
 
  //Calcul inverse
  int r = -1;
  for (int j = 0; j < l;j++){
    int k = r+1;
    for(int i = k;i< l;i++){
      if (abse(boardg[l*i + j]) > abse(boardg[l*k + j]))
        k = i;
    }
    if (boardg[l*k+j] != 0){
      r += 1;
      double divisor = boardg[k*l+j];
      for(int i = 0; i < l;i++){
        boardg[k*l+i] /= divisor;
        inv[k*l+i] /= divisor;
      }
      if (k != r){
        for(int i = 0; i < l;i++){
          double tmp = boardg[r*l+i];
          boardg[r*l+i] = boardg[k*l+i];
          boardg[k*l+i] = tmp;
          double tmp2 = inv[r*l+i];
          inv[r*l+i] = inv[k*l+i];
          inv[k*l+i] = tmp2;
        }
      }
      for (int i = 0; i < l;i++){
        if (i != r){
          double tmp = boardg[i*l+j];
          for (int wow = 0; wow < l;wow++){
            boardg[i*l+wow] -= boardg[r*l+wow] * tmp;
            inv[i*l+wow] -= inv[r*l+wow] * tmp;
          }
        }
      }
    }
  } //*/
 
  //Multiplication matrice
  double res[l];
  for (int i=0;i<l;i++){
    res[i] = 0;
    for(int j = 0;j<l;j++)
      res[i] += inv[l*i+j] * ptdr[j];
    //printf("%f\n",ptdr[i]);
    printf("%f\n",res[i]);
  }
 
  //Initialisation SDL
  printf("\nui\n");
  Uint8 * board3 = NULL;
  board3 = malloc(x * y * sizeof(Uint8));
  gray(image,board3);
  Uint8 * board2 = NULL;
  board2 = malloc(x * y * sizeof(Uint8));
  //Application nouvelles coordonnées
  for(Uint16 i = 0; i < x;i++){
    for(Uint16 j = 0; j < y;j++){
      int ppx = (int) ((res[0]*i+res[1]*j+res[2])/(res[6]*i+res[7]*j+1));
      int ppy = (int) ((res[3]*i+res[4]*j+res[5])/(res[6]*i+res[7]*j+1));
      if (ppy>0 && ppy < y && ppx >0 && ppx < x)
        board2[j*x + i] = board3[ppy*x+ppx];
    }
  }
 
  save(board2,x,y,"/home/user/Bureau/ocr/src/main/c/oui.bmp");
  printf("\nChaussette\n\n");
  free(board3);
  free(board2);
  free(boardg);
  free(ptdr);
  return 0;
}
 
#endif

Et voici le résultat

D'ailleurs, quand je décommente les lignes 81 à 84, j'obtiens ce résultat (?!!)

**CreativeC** · 28/11/2020, 12h36

En remplaçant la ligne

Code :

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

board2[j*x + i] = board3[ppy*x+ppx];

par

Code :

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

board2[ppy*x+ppx] = board3[j*x + i];

cela marche...

Il reste encore des trous, mais ceci est inévitable

**Guesset** · 17/05/2021, 18h57

Bonjour,

Envoyé par CreativeC

Il reste encore des trous, mais ceci est inévitable

Que nenni !

Si on calcule une image résultante comme une fonction d'une image source, il y a des trous. En revanche, si on part de l'image résultante pour aller chercher les points dans l'image source, il ne peut plus y avoir de trous. Toutes les difficultés ne sont pas résolues, un travail d'interpolation est souvent nécessaire.

Salutations

**CreativeC** · 17/05/2021, 19h58

Envoyé par Guesset

Bonjour,

Que nenni !

Si on calcule une image résultante comme une fonction d'une image source, il y a des trous. En revanche, si on part de l'image résultante pour aller chercher les points dans l'image source, il ne peut plus y avoir de trous. Toutes les difficultés ne sont pas résolues, un travail d'interpolation est souvent nécessaire.

Salutations

Bonjour,
merci beaucoup de votre conseil ! J'ai en effet eu la même conclusion que vous, et je l'ai implémenté sans l'écrire sur le forum, mais j'ai isolé x et y dans l'équation initiale:
Nom : Capture.PNG
Affichages : 155
Taille : 15,6 Ko

Nom : Capture.PNG
Affichages : 155
Taille : 15,6 Ko

Et voici le résultat:
Nom : Capture.PNG
Affichages : 161
Taille : 579,4 Ko

**Guesset** · 18/05/2021, 15h21

Bonjour,

C'est nettement mieux

.

Plus dur, sans les mains

Enfin sans multiplication ni division. Le principe est de travailler avec des couples de triangles et de parcourir ligne par ligne chaque triangle de réception - il y a bien sûr deux triangles pour faire un rectangle - et d'y associer les lignes correspondantes dans la source. Qui dit ligne dit tracé incrémental (Bresenham, demi point...) donc avec seulement des aditions et des soustractions d'entiers. J'exagère un peu, il y a bien un calcul initial un peu plus lourd mais pour les seuls 4 points des angles de la sources qui correspondent aux 4 coins de la destination.

Pourquoi faire compliqué quand on peut faire simple ? Parce que c'est beaucoup (beaucoup) plus rapide en traitement.

Salutations

Correction de perspective en C

Traitement d'images

Discussions similaires

Partager

Partager