Hi,

Someone can point me to a D implementation of the classical OpenCV find homography matrix?

Thank you,
Paolo

On Sunday, 21 April 2024 at 14:57:33 UTC, Paolo Invernizzi wrote:

Kinda some work but it should be doable using DCV and mir.lubeck in theory

DCV can compute, not sift or surf b, but similar features https://github.com/libmir/dcv/blob/master/examples/features/source/app.d

Lubeck computes singular value decomposition
https://github.com/kaleidicassociates/lubeck

And this method but with mir ndslices

https://medium.com/all-things-about-robotics-and-computer-vision/homography-and-how-to-calculate-it-8abf3a13ddc5

On Sunday, 21 April 2024 at 14:57:33 UTC, Paolo Invernizzi wrote:

Just for future records in the forum.

// https://math.stackexchange.com/questions/3509039/calculate-homography-with-and-without-svd

/+dub.sdl:
dependency "lubeck" version="~>1.5.4"
+/
import std;
import mir.ndslice;
import kaleidic.lubeck;

void main()
{
    double[2] x_1 = [93,-7];
    double[2] y_1 = [63,0];
    double[2] x_2 = [293,3];
    double[2] y_2 = [868,-6];
    double[2] x_3 = [1207,7];
    double[2] y_3 = [998,-4];
    double[2] x_4 = [1218,3];
    double[2] y_4 = [309,2];

    auto A = [
        -x_1[0], -y_1[0], -1, 0, 0, 0, x_1[0]*x_1[1], y_1[0]*x_1[1], x_1[1],
        0, 0, 0, -x_1[0], -y_1[0], -1, x_1[0]*y_1[1], y_1[0]*y_1[1], y_1[1],
        -x_2[0], -y_2[0], -1, 0, 0, 0, x_2[0]*x_2[1], y_2[0]*x_2[1], x_2[1],
        0, 0, 0, -x_2[0], -y_2[0], -1, x_2[0]*y_2[1], y_2[0]*y_2[1], y_2[1],
        -x_3[0], -y_3[0], -1, 0, 0, 0, x_3[0]*x_3[1], y_3[0]*x_3[1], x_3[1],
        0, 0, 0, -x_3[0], -y_3[0], -1, x_3[0]*y_3[1], y_3[0]*y_3[1], y_3[1],
        -x_4[0], -y_4[0], -1, 0, 0, 0, x_4[0]*x_4[1], y_4[0]*x_4[1], x_4[1],
        0, 0, 0, -x_4[0], -y_4[0], -1, x_4[0]*y_4[1], y_4[0]*y_4[1], y_4[1]
    ].sliced(8, 9);

    auto svdResult = svd(A);

    auto homography = svdResult.vt[$-1].sliced(3, 3);
	auto transformedPoint = homography.mtimes([1679,  128, 1].sliced.as!double.slice);
    transformedPoint[] /= transformedPoint[2];

    writeln(transformedPoint); //[4, 7, 1]
}

On Sunday, 21 April 2024 at 14:57:33 UTC, Paolo Invernizzi wrote:

Something I wrote awhile ago...

import kaleidic.lubeck : svd;
import gfm.math;
import mir.ndslice : sliced;

auto generateTransformationArray(int[] p) {
    return generateTransformationArray(p[0],p[1],p[2],p[3]);
}

auto generateTransformationArray(int x, int y, int x_, int y_) {
    return [-x, -y, -1, 0, 0, 0, x*x_, y*x_, x_,
            0, 0, 0, -x, -y, -1, x*y_, y*y_, y_];
}

auto transformCoor (mat3d mat, vec3d vec) {
    auto res = mat * vec;
    return res / res[2];
}

auto findHomography (int[][] correspondances) {
    auto a = correspondances
                .map!(a => a.generateTransformationArray)
                .joiner
                .array
                .sliced(8,9);

    auto r = a.svd;
    auto homog = r.vt.back;
    return mat3d(homog.map!(a => a/homog.back).array);
}