precision_test.cpp File Reference

#include "homog2d.hpp"
#include <random>

Include dependency graph for precision_test.cpp:

Macros
#define	NUMTYPE   double

Enumerations
enum	Order {   Order::RST, Order::RTS, Order::TSR, Order::TRS,   Order::STR, Order::SRT, Order::Dummy, Order::RST,   Order::RTS, Order::TSR, Order::TRS, Order::STR,   Order::SRT, Order::Dummy }
	Order of transformations. More...

Functions
const char *	getString (Order order)
int	main (int argc, const char **argv)

Macro Definition Documentation

NUMTYPE

#define NUMTYPE   double

Enumeration Type Documentation

Order

enum Order

strong

Order of transformations.

Enumerator
RST
RTS
TSR
TRS
STR
SRT
Dummy
RST
RTS
TSR
TRS
STR
SRT
Dummy

{
    RST,RTS,TSR,TRS,STR,SRT, Dummy
};

Function Documentation

getString()

const char* getString

(

Order

order

)

{
    switch (order )
    {
        case Order::RST: return "RST";
        case Order::RTS: return "RTS";
        case Order::TSR: return "TSR";
        case Order::TRS: return "TRS";
        case Order::STR: return "STR";
        case Order::SRT: return "SRT";
        default: assert(0);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		const char **	argv
	)

{
    RandomData rd;

    int nbTransfo = 5;
    int nbPts = 20;

/*  for( int i=0; i<30; i++ )
        std::cout << rd.getRandom() << "\n";
    return 0;*/

    for( int i=0; i<nbTransfo; i++ )
    {
        auto angle = rd.getRandomAngle();
        auto tx = rd.getRandomTranslation();
        auto ty = rd.getRandomTranslation();
        auto sx = rd.getRandomScale();
        auto sy = rd.getRandomScale();
        std::cout << std::scientific << i << ": angle=" << angle
            << " tx=" << tx << " ty=" << ty
            << " sx=" << sx << " sy=" << sy
            << '\n';

        for( int order=0; order<6; order++ )
        {
            Hmatrix_<type::IsHomogr,NUMTYPE> H;

            auto str = getString( static_cast<Order>(order) );
            std::cout << "order = " << str << '\n';
            for( int c=0; c<3; c++ )
                switch( str[c] )
                {
                    case 'R': H.addRotation( angle*M_PI/180. ); break;
                    case 'T': H.addTranslation( tx, ty );
                    case 'S': H.addScale( sx, sy );
                }
//          std::cout << H << '\n';
            Hmatrix_<type::IsHomogr,NUMTYPE> HMT = H;
            HMT.inverse().transpose();
            double dmin = 999.;
            double dmax = 0.;
            for( int j=0; j<nbPts; j++ )
            {
                auto pt1 = rd.getRandomPt();
                auto pt2 = rd.getRandomPt();
                auto lA = pt1 * pt2;
                auto pt = H * pt1;    // project point with H
                auto lB = HMT * lA;   // project line with H^-T
                auto d = pt.distTo( lB );
                auto dlog = d;
//              if( d != 0. )
//                  dlog = std::log10(d);
#if 0
                std::cout << j
//                  << std::fixed
                    << std::scientific
                    << std::setprecision(2)
                    << ": pt1=" << pt1
                    << ", pt2=" << pt2
                    << " dist pts=" << pt1.distTo(pt2)
                    << "=> dH=" << dlog
                    << " ratio=" << pt1.distTo(pt2) / dlog
                    << '\n';
#endif
                if( d != 0. )
                {
                    dmax = std::max( d, dmax );
                    dmin = std::min( d, dmin );
                }

            }
            std::cout << "dist: min=" << dmin <<  " max=" << dmax << '\n';
        }
    }
}

Here is the call graph for this function: