Function TEST

source/MRTest/MRPointToPlaneAligningTransformTests.cpp:11–139

{

TEST( MRMesh, PointToPlaneAligningTransform1 )
{
    std::vector<Vector3d> pInit, n, n2;
    pInit.resize( 10 );
    n.resize( 10 );
    n2.resize( 3 );

    pInit[0]  = {   1.0,   1.0, -5.0 }; n[0] = {  0.0,  0.0, -1.0 }; n2[0] = { 0.1, -0.1,  0.0 };
    pInit[1]  = {  14.0,   1.0,  1.0 }; n[1] = {  1.0,  0.1,  1.0 }; n2[1] = { 0.3,  0.0, -0.3 };
    pInit[2]  = {   1.0,  14.0,  2.0 }; n[2] = {  0.1,  1.0,  1.2 }; n2[2] = { 0.0, -0.6,  0.5 };
    pInit[3]  = { -11.0,   2.0,  3.0 }; n[3] = { -1.0,  0.1,  1.0 };
    pInit[4]  = {   1.0, -11.0,  4.0 }; n[4] = {  0.1, -1.1,  1.1 };
    pInit[5]  = {   1.0,   2.0,  8.0 }; n[5] = {  0.1,  0.1,  1.0 };
    pInit[6]  = {   2.0,   1.0, -5.0 }; n[6] = {  0.1,  0.0, -1.0 };
    pInit[7]  = {  15.0,   1.5,  1.0 }; n[7] = {  1.1,  0.1,  1.0 };
    pInit[8]  = {   1.5,  15.0,  2.0 }; n[8] = {  0.1,  1.0,  1.2 };
    pInit[9]  = { -11.0,   2.5,  3.1 }; n[9] = { -1.1,  0.1,  1.1 };

    auto preparePt2Pl = [&]( const AffineXf3d & xf )
    {
        std::vector<Vector3d> pTransformed( 10 );

        for( int i = 0; i < 10; i++ )
            pTransformed[i] = xf( pInit[i] );
        for( int i = 0; i < 3; i++ )
            pTransformed[i] += n2[i];

        PointToPlaneAligningTransform p2pl;
        for( int i = 0; i < 10; i++ )
            p2pl.add( pInit[i], pTransformed[i], n[i] );
        p2pl.prepare();
        return p2pl;
    };

    double alpha = 0.15, beta = 0.23, gamma = -0.17;
    const Vector3d eulerAngles{ alpha, beta, gamma };
    const auto [e1, e2] = eulerAngles.perpendicular();
    Matrix3d rotationMatrix = Matrix3d::approximateLinearRotationMatrixFromEuler( eulerAngles );
    const Vector3d b( 2., 3., -1. );
    AffineXf3d xf1( rotationMatrix, b );

    const auto ptp1 = preparePt2Pl( xf1 );
    constexpr double eps = 3e-13;

    {
        const auto ammendment = ptp1.calculateAmendment();
        EXPECT_EQ( ammendment.s, 1 );
        auto xf2 = ammendment.linearXf();
        EXPECT_NEAR( ( xf1.A - xf2.A ).norm(), 0., eps );
        EXPECT_NEAR( ( xf1.b - xf2.b ).length(), 0., eps );
        auto shift = ptp1.findBestTranslation( ammendment.a, ammendment.s );
        EXPECT_NEAR( ( xf1.b - shift ).length(), 0., eps );
    }

    {
        const auto ammendment = ptp1.calculateAmendmentWithScale();
        EXPECT_NEAR( ammendment.s, 1., 1e-13 );
        auto xf2 = ammendment.linearXf();