Bonjour,
Je rencontre un problème de math durant le développement d'une application en Javascript.
J'espère ce na contrevenir aux règles du forum en postant un message hybride math/développement.

contexte:
Je fais de la reconnaissance d'image à partir d'un flux vidéo. si l'image courante contient X critères, j'extrait l'image, je l'envoie au serveur qui détecte de quelle image il s'agit en fonction d'une base de donnée contenant les descripteurs ORB (openCV) d'images de bases.
La serveur me retourne ensuite l'image de base, et une matrice homographique de déformation.

Exemple de matrice retournée:
homography: Array[9]
0: 0.4959908472627171
1: -0.009783332296505506
2: 0.00002373519156751816
3: 0.06435791105292753
4: 0.523665780525115
5: 0.0001297924400678731
6: 166.7081468568362
7: 21.89641913555732
8: 1
length: 9


Problème:

Je souhaite ensuite superposer l'image trouvée a la scène courante en la déformant avec la matrice.

J'ai trouvé un script en JS qui me permet de passer une imageData et d'appliquer la matrice dessus;

/**
* homographyTransform
*
* @param {ImageData} src
* @param {Number} dstWidth
* @param {Number} dstHeight
* @param {Point} p0
* @param {Point} p1
* @param {Point} p2
* @param {Point} p3
* @return ImageData
*/
function homographyTransform(src, dstWidth, dstHeight, p0, p1, p2, p3) {
var sx, sy, dx1, dy1, dx2, dy2,
z, g, h,
m0, m1, m2, m3, m4, m5, m6, m7,
srcWidth, srcHeight, srcPixels,
dst, dstPixels,
x, y, yi, u, v, t, dx, dy, i, j;

sx = p0.x - p1.x + p2.x - p3.x;
sy = p0.y - p1.y + p2.y - p3.y;
dx1 = p1.x - p2.x;
dy1 = p1.y - p2.y;
dx2 = p3.x - p2.x;
dy2 = p3.y - p2.y;

z = dx1 * dy2 - dy1 * dx2;
g = (sx * dy2 - sy * dx2) / z;
h = (sy * dx1 - sx * dy1) / z;

m0 = p1.x - p0.x + g * p1.x;
m1 = p3.x - p0.x + h * p3.x;
m2 = p0.x;
m3 = p1.y - p0.y + g * p1.y;
m4 = p3.y - p0.y + h * p3.y;
m5 = p0.y;
m6 = g;
m7 = h;

srcWidth  = src.width;
srcHeight = src.height;
srcPixels = src.data;

dst = ctx.createImageData(dstWidth, dstHeight);
dstPixels = dst.data;

for (y = 0; y < dstHeight; y++) {
yi = y * dstWidth;
for (x = 0; x < dstWidth; x++) {
i = (yi + x) << 2;
u = x / dstWidth;
v = y / dstHeight;
t = m6 * u + m7 * v + 1;
dx = (m0 * u + m1 * v + m2) / t;
dy = (m3 * u + m4 * v + m5) / t;
if (dx >= 0 && dx < srcWidth && dy >= 0 && dy < srcHeight) {
j = ((dy | 0) * srcWidth + (dx | 0)) << 2;
dstPixels[i]     = srcPixels[j];
dstPixels[i + 1] = srcPixels[j + 1];
dstPixels[i + 2] = srcPixels[j + 2];
}
dstPixels[i + 3] = 255;
}
}

return dst;
}


Cette fonction prend en paramètre 4 points (j'imagine qu'il s'agit des 4 coins de l'image).


Je souhaiterais savoir comment calculer ces 4 points à partir de la matrice.

J'espère que quelqu'un saura m'aider, je suis en galère totale

Merci d'avance !