demo_opencv.cpp File Reference

demo of interfacing with Opencv. Try it with $ make demo. More...

#include "homog2d.hpp"
#include "opencv2/highgui.hpp"

Include dependency graph for demo_opencv.cpp:

Macros
#define	HOMOG2D_ENABLE_VRTP
#define	HOMOG2D_USE_OPENCV

Functions
void	action_1 (void *param)
void	action_6 (void *param)
void	action_BB (void *param)
void	action_C (void *param)
void	action_CH (void *param)
void	action_CIR (void *param)
void	action_ELL (void *param)
	action for Ellipse demo (run on keyboard hit) More...
void	action_H (void *param)
void	action_NFP (void *param)
void	action_ORS (void *param)
void	action_OSegAngle (void *param)
void	action_PL (void *param)
void	action_PO (void *param)
	Polygon Offset demo action. More...
void	action_polRot (void *param)
void	action_RCP (void *param)
void	action_RI (void *param)
void	action_SEG (void *param)
void	action_SI (void *param)
double	action_SI_drawDist (const Segment &seg, void *param)
void	demo_1 (int demidx)
void	demo_6 (int demidx)
void	demo_B (int demidx)
	Build H from R,T,S (no mouse) More...
void	demo_BB (int demidx)
void	demo_C (int demidx)
void	demo_CH (int demidx)
void	demo_CIR (int demidx)
void	demo_ELL (int demidx)
	Ellipse demo. More...
void	demo_H (int demidx)
	Demo of computing a homography from two sets of 4 points. More...
void	demo_NFP (int demidx)
void	demo_orthSeg (int demidx)
void	demo_OSegAngle (int demidx)
void	demo_PL (int demidx)
void	demo_PO (int demidx)
	Polygon Offset demo start. More...
void	demo_polRot (int demidx)
void	demo_RCP (int demidx)
void	demo_RI (int demidx)
void	demo_SEG (int demidx)
void	demo_SI (int demidx)
	Segment intersection demo. More...
int	main (int argc, const char **argv)
	Demo program, using Opencv. More...
void	myMouseCB (int event, int x, int y, int, void *param)
	Mouse callback functions, checks if one of the points is selected. More...
template<typename IM , typename POL >
void	process_PO (IM &im, const POL &pol, Param_PO &data)
std::vector< Point2d >	removeDupes (const std::vector< Point2d > &vec)
	Helper function. Only removes duplicates if there are consecutive. More...
void	toggle (bool &b, std::string msg)

Detailed Description

demo of interfacing with Opencv. Try it with $ make demo.

precision evaluation, using Opencv

precision evaluation

(requires OpenCv)

To run a specific demo, give its number as first argument, i.e.:

$ BUILD/demo_opencv 4.

Each demo is defined by three code blocks:

• a class definition, that inherits from class Data (usually named Params_something), and that may hold some specific data for the demo.
• a function demo_something( int ), that will be run by this program, it must be added in the v_demo vector in main() function.
• a callback function action_something( void* ), that may/will be called either by the mouse callback, either after each (valid) keyboard hit. Its argument will be

To enable the mouse callback, the function demo_something( int ) must first instanciate the Params_something class then assign the action_something() function to the mouse callback:

void demo_something( int demo_index)
{
    Param_something data( demo_index, "what-is-this-about" );
    action_something( &data );                      // initial call of the "action" stuff
    data.setMouseCB( action_something )             // assign to mouse callback
    ...
}

Computation of the line passed through H^{-T} and computation of the distance between the resulting line and the transformed point. Should be 0, always.

We do this for multiple random transformation, in random order, and with multiple random points

Macro Definition Documentation

HOMOG2D_ENABLE_VRTP

#define HOMOG2D_ENABLE_VRTP

HOMOG2D_USE_OPENCV

#define HOMOG2D_USE_OPENCV

Function Documentation

action_1()

void action_1

(

void *

param

)

{
    auto& data = *reinterpret_cast<Data*>(param);
    data.drawLines();

    Line2d l_mouse  = data._pt_mouse * Point2d();
    auto p_lines = l_mouse.getParallelLines( 30 );

    auto ppts = l_mouse.getPoints( Point2d(), 200 );
    Line2d l_mouse_o = l_mouse.getOrthogLine( ppts.second );
    l_mouse.draw( data.img );
    l_mouse_o.draw( data.img );

    auto p_lines_o = l_mouse_o.getParallelLines( 10 );


    img::DrawParams dp;
    dp.setColor(100,250,100);
    p_lines.first.draw(  data.img, dp );
    p_lines.second.draw( data.img, dp );

    p_lines_o.first.draw(  data.img, dp );
    p_lines_o.second.draw( data.img, dp );
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_6()

void action_6

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_6*>(param);

    data.clearImage();
    double K = M_PI / 180.;
    auto tx = data._pt_mouse.getX();
    auto ty = data._pt_mouse.getY();

    auto mouse_pos = std::make_pair(
        Line2d( LineDir::H, ty ),
        Line2d( LineDir::V, tx )
    );
    draw( data.img, mouse_pos, img::DrawParams().setColor( 200,200,200) );

/*  auto org = std::make_pair(
        Line2d( LineDir::H, ty ),
        Line2d( LineDir::V, tx )
    );
    draw( data.img, org );
*/
    Homogr H = Homogr().addTranslation(-tx,-ty).addRotation( data.angle * K ).addTranslation(tx,ty);

    draw( data.img, data.vpt[0] );
    draw( data.img, data.vpt[1] );
    Line2d l1( data.vpt[0], data.vpt[1] );
    Line2d l2 = l1.getRotatedLine( data.vpt[0], data.angle * K );

    auto dpar = img::DrawParams();
    l1.draw( data.img, dpar.setColor( 250,0,0) );
    l2.draw( data.img, dpar.setColor( 0,250,0) );

    Segment s1( data.vpt[2], data.vpt[3] );
    Segment s2 = H*s1;
    s1.draw( data.img, dpar.setColor( 250,0,0) );
    s2.draw( data.img, dpar.setColor( 0,0,250) );
    s1.getPts().first.draw( data.img, dpar.selectPoint() );
    s1.getPts().second.draw( data.img, dpar.selectPoint() );
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_BB()

void action_BB

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_BB*>(param);
    data.clearImage();
    auto style = img::DrawParams().setPointStyle( img::PtStyle::Dot ).showPoints();
    auto style0 = style.setColor(0,250,0);
    auto style1 = style.setColor(250,0,0);
    auto style2 = style.setColor(0,0,250);

    data.initElemsAll();                              // first initialize objects

    fct::DrawFunct vde1( data.img, style1 );        // then draw the current ones
    fct::DrawFunct vde2( data.img, style2 );
    const auto& curr1 = data.getCurrent(0);
    const auto& curr2 = data.getCurrent(1);
    std::visit( vde1, curr1 );
    std::visit( vde2, curr2 );

    auto pp1 = std::visit( fct::PtPairFunct{}, curr1 );      // get their "pseudo" bounding box (as pair of points)
    auto pp2 = std::visit( fct::PtPairFunct{}, curr2 );

    try {
        getBB( pp1, pp2 ).draw( data.img, style0 );
    }
    catch( std::runtime_error& err )
    {
        std::cout << "Unable: " << err.what() << '\n';
    }

    data._pt_mouse.draw( data.img );

    int y0=30;
    int dy=30;

    auto l1 = length(curr1);
    auto l2 = length(curr2);
    auto a1 = area(curr1);
    auto a2 = area(curr2);
    data.img.drawText( "[w]->red: "  + data._name[0], Point2d( 20,y0),    style1 );
    data.img.drawText( " length=" + std::to_string(l1) + " area=" + std::to_string(a1), Point2d( 20,y0+dy),  style1 );
    data.img.drawText( "[x]->blue: " + data._name[1], Point2d( 20,y0+2*dy), style2 );
    data.img.drawText( " length=" + std::to_string(l2) + " area=" + std::to_string(a2), Point2d( 20,y0+3*dy),  style2 );

    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_C()

void action_C

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_C*>(param);
    data.clearImage();
    data.drawLines();

    Circle c1( data.vpt[0], data.radius );
    Circle c2( data.vpt[1], 100 );

    img::DrawParams dpc2;
    dpc2.setColor(150,0,150);
    if( c2.isInside( c1 ) )
        dpc2.setColor(250,100,0);
    c2.draw( data.img, dpc2 );

    img::DrawParams dp;
    dp.setColor(150,0,150);
    if( data.rect.isInside( c1 ) )
        dp.setColor(250,100,0);
    data.rect.draw( data.img, dp );

    img::DrawParams dpc1;
    dpc1.setColor(0,250,0);
    if( c1.isInside( data.rect ) )
        dpc1.setColor(250,100,0);
    if( c1.isInside( c2 ) )
        dpc1.setColor(250,100,0);
    c1.draw( data.img, dpc1 );

    data._pt_mouse.draw( data.img, img::DrawParams().setColor(250,50,20) );

// circle - circle intersections
    auto cci = c1.intersects( c2 );
    if( cci() )
        draw( data.img, cci.get(), img::DrawParams().setColor(0,150,0).setPointStyle(img::PtStyle::Diam) );


// circle - rectangle intersections
    auto cr1 = c1.intersects( data.rect );
    auto cr2 = c2.intersects( data.rect );
    if( cr1() )
        draw( data.img, cr1.get(), img::DrawParams().setColor(0,20,220).setPointStyle(img::PtStyle::Diam) );
    if( cr2() )
        draw( data.img, cr2.get(), img::DrawParams().setColor(0,20,220).setPointStyle(img::PtStyle::Diam) );

// circle - lines intersections
    for( size_t i=0; i<data.li.size(); i++ )
    {
        auto ri = data.li[i].intersects( c1 );
        if( ri() )
        {
            auto inter = ri.get();
            inter.first.draw(  data.img, img::DrawParams().setColor(250, 0, 0) );
            inter.second.draw( data.img, img::DrawParams().setColor(250, 0, 0) );
        }
    }

    auto seg = getSegment( c1, c2 );
    seg.draw( data.img, img::DrawParams().setColor(250, 0, 0) );

    auto pseg = getTanSegs( c1, c2 );
    pseg.first.draw(  data.img, img::DrawParams().setColor(250, 250, 0) );
    pseg.second.draw( data.img, img::DrawParams().setColor(0, 250, 250) );
    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_CH()

void action_CH

(

void *

param

)

{
    static size_t old_size = 0;
    auto& data = *reinterpret_cast<Param_CH*>(param);

    data.clearImage();
    draw( data.img, data.vpt, img::DrawParams().showIndex() );

    data._cpoly = convexHull( data.vpt );
    Circle cir;
    cir.set( data.vpt );

    auto vlines = getLines( data._cpoly.getSegs() );
    if( old_size != vlines.size() )
    {
        data.vcol = img::genRandomColors( vlines.size() );
        old_size = vlines.size();
    }

    auto func = [&](int i)   // lambda, needed to fetch color from index
        {
            return img::DrawParams().setColor(data.vcol[i]);
        };
    std::function<img::DrawParams(int)> f(func);

    if( data._mode )
        draw( data.img, vlines, f );
    if( !data._mode )
        data._cpoly.draw( data.img, img::DrawParams().setColor(250,0,0) );
    cir.draw( data.img, img::DrawParams().setColor(0,0,250) );

    auto dp = img::DrawParams().setColor(0,0,0).setPointStyle( img::PtStyle::Dot ).setPointSize(5).setThickness(2);
    data._cpoly.getLmPoint().draw( data.img, dp );
    data._cpoly.getRmPoint().draw( data.img, dp );
    data._cpoly.getTmPoint().draw( data.img, dp );
    data._cpoly.getBmPoint().draw( data.img, dp );
    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_CIR()

void action_CIR

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_CIR*>(param);
    data.clearImage();
    data.setAndDraw();
    data.showImage();
}

Here is the caller graph for this function:

action_ELL()

void action_ELL

(

void *

param

)

action for Ellipse demo (run on keyboard hit)

{
    auto& data = *reinterpret_cast<Param_ELL*>(param);
    data.H.init();
    data.H.addTranslation(-data.x0, -data.y0).addRotation( data.angle * M_PI/180.).addTranslation(data.x0+data.tx, data.y0+data.ty);
    data.draw();
}

Here is the caller graph for this function:

action_H()

void action_H

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_H*>(param);

    data.clearImage();

    std::vector<Point2d> v1(4);
    std::vector<Point2d> v2(4);
    std::copy( data.vpt.begin(),   data.vpt.begin()+4, v1.begin() );
    std::copy( data.vpt.begin()+4, data.vpt.end(),     v2.begin() );
    for( int i=0; i<4; i++ )
    {
        Segment s1( v1[i], v1[i==3?0:i+1] );
        Segment s2( v2[i], v2[i==3?0:i+1] );
        s1.draw( data.img, img::DrawParams().setColor( 0,0,250) );
        s2.draw( data.img, img::DrawParams().setColor( 250,0,0) );

        s1.draw( data.img2, img::DrawParams().setColor( 0,0,250) );

        Segment( v1[i], v2[i] ).draw( data.img );

        v1[i].draw( data.img );
        v2[i].draw( data.img );
    }

    std::vector<Point2d> vseg;
    auto center_x = 160;
    auto center_y = 220;
    auto size_v = 40;
    auto size_h = 60;
    vseg.emplace_back( Point2d(center_x+size_h, center_y) );
    vseg.emplace_back( Point2d(center_x-size_h, center_y) );
    vseg.emplace_back( Point2d(center_x,        center_y+size_v) );
    vseg.emplace_back( Point2d(center_x,        center_y-size_v) );

    Segment sa1( vseg[0], vseg[1] );
    Segment sb1( vseg[2], vseg[3] );

    sa1.draw( data.img, img::DrawParams().setColor( 0,100,100) );
    sb1.draw( data.img, img::DrawParams().setColor( 0,100,100) );

    cv::putText( data.img.getReal(), "source points", cv::Point2i( v1[0].getX(), v1[0].getY() ), 0, 0.8, cv::Scalar( 250,0,0 ), 2 );
    cv::putText( data.img.getReal(), "dest points",   cv::Point2i( v2[0].getX(), v2[0].getY() ), 0, 0.8, cv::Scalar( 0,0,250 ), 2 );

    Homogr H;
    H.buildFrom4Points( v1, v2, data.hmethod );
    std::cout << "Computed Homography:\n" << H << '\n';

    std::vector<Point2d> vpt3;
    for( int i=0; i<4; i++ )
        vpt3.push_back( H * data.vpt[i] );

    for( int i=0; i<4; i++ )
    {
        Segment s1( vpt3[i], vpt3[i==3?0:i+1] );
        s1.draw( data.img2, img::DrawParams().setColor( 0,250,0) );
    }

    auto vsegH  = H * vseg;
    Segment sa2( vsegH[0], vsegH[1] );
    Segment sb2( vsegH[2], vsegH[3] );

    sa2.draw( data.img2, img::DrawParams().setColor( 0,100,100) );
    sb2.draw( data.img2, img::DrawParams().setColor( 0,100,100) );


    FRect rect( Point2d(200,160), Point2d(330,250));
    rect.draw( data.img );
    auto rect2 = H * rect;
    rect2.draw( data.img2 );

    auto e_x = 320.;
    auto e_y = 360.;
    auto e_h = 70.;

    Circle c_ell( e_x, e_y, e_h );
    c_ell.draw( data.img );
    auto ell = H * c_ell;
    ell.draw( data.img2 );
    auto ecenter = ell.getCenter();
    ecenter.draw( data.img2 );

    auto ell_bb = ell.getBB();
    ell_bb.draw( data.img2 );

    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_NFP()

void action_NFP

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_NFP*>(param);
    data.clearImage();
    draw( data.img, data.vpt );
    data._pt_mouse.draw( data.img, img::DrawParams().setColor( 250,0,0) );
    switch( data._mode )
    {
        case 0:
        {
            auto idx = findNearestPoint( data._pt_mouse, data.vpt );
            Segment(data.vpt[idx], data._pt_mouse).draw( data.img, img::DrawParams().setColor( 250,0,0) );
        }
        break;
        case 1:
        {
            auto idx = findFarthestPoint( data._pt_mouse, data.vpt );
            Segment(data.vpt[idx], data._pt_mouse).draw( data.img, img::DrawParams().setColor( 0,250,0) );
        }
        break;
        case 2:
        {
            auto pidx = findNearestFarthestPoint( data._pt_mouse, data.vpt );
            Segment(data.vpt[pidx.first], data._pt_mouse).draw( data.img, img::DrawParams().setColor( 250,0,0) );
            Segment(data.vpt[pidx.second], data._pt_mouse).draw( data.img, img::DrawParams().setColor( 0,250,0) );
        }
        break;
        default: assert(0);
    }

    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_ORS()

void action_ORS

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_ORS*>(param);
    data.clearImage();

    auto fl = [&](int i)   // lambda
    {
        return img::DrawParams().setPointStyle(img::PtStyle::Dot).setColor( data._vcol[i] );
    };
    std::function<img::DrawParams(int)> style(fl);

    Segment seg( data.vpt[0], data.vpt[1] );
    seg.draw( data.img, img::DrawParams().setColor( 250,0,0) );
    if( data._ptsOrSegs )
        draw( data.img, seg.getOrthogSegs(), style );
    else
    {
        auto opts = seg.getOrthogPts();
        draw( data.img, opts, style );
        if( data._drawPolyg )
            CPolyline( opts ).draw( data.img, img::DrawParams().setColor( 125,125,0) );
    }
    data._pt_mouse.draw( data.img, img::DrawParams().setColor( 250,0,0) );
    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_OSegAngle()

void action_OSegAngle

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_OSegAngle*>(param);
    data.clearImage();
    drawText( data.img, "Warning: flipped image on x axis: Left/Right reversed!", Point2d( 170, 20 ) );
    OSegment s1( data.vpt[0], data.vpt[1] );
    OSegment s2( data.vpt[1], data.vpt[2] );

    if( data._reverseS2 )
        s2 = -s2;
    if( data._reverseS1 )
        s1 = -s1;
    auto col1 = img::DrawParams().setColor(200,0,0);
    auto col2 = img::DrawParams().setColor(0,0,200);

    data.img.draw( s1, col1 );
    data.img.draw( s2, col2 );
    draw( data.img, data.vpt, img::DrawParams().setColor(0,200,0).setPointStyle(img::PtStyle::Dot) );

    if( data._showParallel )
    {
        auto psegs = s1.getParallelSegs( 25 );
        draw( data.img, psegs.first,  img::DrawParams().setColor(250,100,0) );
        draw( data.img, psegs.second, img::DrawParams().setColor(250,0,100) );
        drawText( data.img, "L", psegs.first.getCenter()  );
        drawText( data.img, "R", psegs.second.getCenter() );
    }

    auto angle = getAngle( s1, s2 );
    drawText( data.img, std::to_string(angle*180./M_PI), data.vpt[1] );

    drawText( data.img, "S1", s1.getCenter() );
    drawText( data.img, "S2", s2.getCenter() );

    draw( data.img, data._pt_mouse, img::DrawParams().setColor(150,150,0).setPointSize(7) );
    drawText(
        data.img,
        std::string("S1:") + getString( s1.getPointSide(data._pt_mouse) )
        + " S2:"           + getString( s2.getPointSide(data._pt_mouse) ),
        data._pt_mouse
    );

    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_PL()

void action_PL

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_PL*>(param);

    data.clearImage();
    data.polyline_o.set( data.vpt );
    data.polyline_c.set( data.vpt );

    auto color = img::DrawParams().setColor( 0,10,200);
    if( data.polyline_c.isSimple() )
        color = img::DrawParams().setColor( 250,10,20);

    auto len = data.showClosedPoly ? data.polyline_c.length() : data.polyline_o.length();
    if( data.showClosedPoly )
        data.polyline_c.draw( data.img, color );
    else
        data.polyline_o.draw( data.img, color );

    auto col_green = img::DrawParams().setColor(10,250,10);
    Line2d li( Point2d( 10,60), Point2d( 400,270) );
    li.draw( data.img, col_green );

    data.putTextLine( std::string("Nb pts=") + std::to_string( data.polyline_c.size() ), 0 );
    data.putTextLine( std::string("length=") + std::to_string(len)                         );

    auto intersPts_o = li.intersects(data.polyline_o).get();
    auto intersPts_c = li.intersects(data.polyline_c).get();;

    auto intersPts = ( data.showClosedPoly ? intersPts_c : intersPts_o );
    for( const auto& pt: intersPts )
        pt.draw( data.img  );

    Circle cir( 350,180,85);
    cir.draw( data.img, col_green );
    auto i_cir_o = cir.intersects( data.polyline_o );
    auto i_cir_c = cir.intersects( data.polyline_c );

    FRect rect( 90,160,205,245);
    rect.draw( data.img, col_green );
    auto i_rect_o = rect.intersects( data.polyline_o );
    auto i_rect_c = rect.intersects( data.polyline_c );

    std::string str_ispoly{"Polygon: N"};
    if( data.showClosedPoly )
    {
        draw( data.img, i_cir_c.get() );
        draw( data.img, i_rect_c.get() );
        if( data.polyline_c.isSimple() )
            str_ispoly = "Polygon: Y";
    }
    else
    {
        draw( data.img, i_cir_o.get() );
        draw( data.img, i_rect_o.get() );
    }
    data.putTextLine( str_ispoly );
    auto bb = data.polyline_c.getBB();
    bb.draw( data.img );

    if( data.showClosedPoly && data.polyline_c.isSimple() )
    {
        auto centroid = data.polyline_c.centroid();
        centroid.draw( data.img, img::DrawParams().setColor(40,20,250) );
        cv::putText(
            data.img.getReal(),
            "centroid",
            centroid.getCvPti(),
            0, 0.6,
            cv::Scalar( 250,0,0 )
        );

        data.putTextLine( std::string("area=") + std::to_string(data.polyline_c.area()) );

        auto isC = "Convex: Y";
        if( !data.polyline_c.isConvex() )
            isC = "Convex: N";
        data.putTextLine( isC );

        auto isInside = data._pt_mouse.isInside(data.polyline_c);
        data.putTextLine( std::string("IsInside=") + std::string( isInside?"Y":"N" ) );
        if( isInside )
            drawText( data.img, "Inside", data._pt_mouse );
        else
            drawText( data.img, "Outside", data._pt_mouse );
    }
    data._pt_mouse.draw( data.img, img::DrawParams().setPointStyle( img::PtStyle::Dot ).setColor(0,220,0) );
    data.showImage();
    data._cpoly = data.polyline_c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_PO()

void action_PO

(

void *

param

)

Polygon Offset demo action.

{
    auto& data = *reinterpret_cast<Param_PO*>(param);
    data.clearImage();

    auto withoutDupes = removeDupes( data.vpt );
    data._cpoly = CPolyline( withoutDupes );
    data._cpol = CPolyline( withoutDupes );
    data._opol = OPolyline( withoutDupes );

    if( data._closedPol )
        process_PO( data.img, data._cpol, data );
    else
        process_PO( data.img, data._opol, data );

/*  data.img.draw( debug.pt1, img::DrawParams().setColor(0,250,0).setPointSize(7) );
    data.img.draw( debug.ptnew, img::DrawParams().setColor(0,250,0).setPointSize(7) );
    data.img.draw( debug.plines, img::DrawParams().setColor(0,250,0) );
    data.img.draw( debug.seg, img::DrawParams().setColor(0,250,0) );
*/
    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_polRot()

void action_polRot

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_polRot*>(param);
    data.clearImage();

    if( data._doIt )
    {
        if( data._item )
            data._cpoly.rotate( data._rotateType, data._cpoly.getPoint( data._refPt_p ) );
        else
            data._rect.rotate( data._rotateType, data._pt_mouse );
         data._doIt = false;
    }

    if( data._item )
    {
        data._cpoly.draw( data.img, img::DrawParams().setColor(250,0,0).showPoints() );
        data._cpoly.getPoint( data._refPt_p ).draw( data.img, img::DrawParams().setColor(0,0,250).setPointStyle(img::PtStyle::Dot) );
    }
    else
    {
        data._rect.draw( data.img, img::DrawParams().setColor(0,0,250).showPoints() );
        draw( data.img, data._pt_mouse, img::DrawParams().setColor(250,0,0).setPointStyle(img::PtStyle::Dot) );
    }
    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_RCP()

void action_RCP

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_RCP*>(param);
    data.clearImage();

    Point2d ptCenter( data._trans_x, data._trans_y );
    Line2d lih( Point2d(data._imWidth,data._trans_y), Point2d(0,data._trans_y) );
    Line2d liv( Point2d(data._trans_x,data._imHeight), Point2d(data._trans_x,0) );
    lih.draw( data.img, img::DrawParams().setColor(220,220,220) );
    liv.draw( data.img, img::DrawParams().setColor(220,220,220) );

    Point2d(data._trans_x,data._trans_y).draw( data.img, img::DrawParams().setColor(100,0,100) );
    auto values = data._cpoly.set( data._radius, data._nbPts );
    std::cout << " -Building Regular Convex Polygon with " << data._nbPts << " points\n";

    data._cpoly.moveTo( Point2d(data._trans_x+data._radius,data._trans_y) );
    data._cpoly.draw( data.img );
    {
        Segment s1( ptCenter, data._cpoly.getPts().front() );
        s1.draw( data.img ) ;
        drawText( data.img, std::to_string(int(data._radius)), s1.getCenter() );
    }
    {
        auto s1 = data._cpoly.getSegs().at(0);
        auto spara1 = s1.getParallelSegs(20).second;
        std::ostringstream oss1;
        oss1 << std::fixed << std::setprecision(1) << values.first;
        drawText( data.img, oss1.str(), spara1.getCenter() );
    }
    {
        Segment s1( ptCenter, data._cpoly.getPts().back() );
        Circle c1( ptCenter, values.second );
        auto it1 = c1.intersects(s1);

        Segment ss1( ptCenter, it1.get()[0] );
        ss1.draw( data.img ) ;

        std::ostringstream oss1;
        oss1 << std::fixed << std::setprecision(1) << values.second;
        drawText( data.img, oss1.str(), ss1.getCenter() );
    }
    data.putTextLine( "NbPts="         + std::to_string(data._nbPts)    );
    data.putTextLine( "segment dist="  + std::to_string(values.first)  );
    data.putTextLine( "red circle radius=" + std::to_string(values.second) );

    Circle c1( data._trans_x,data._trans_y,data._radius);
    Circle c2( data._trans_x,data._trans_y,values.second);
    c1.draw( data.img, img::DrawParams().setColor(0,0,250) );
    c2.draw( data.img, img::DrawParams().setColor(250,0,0) );
    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_RI()

void action_RI

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_RI*>(param);

    data.clearImage();
    draw( data.img, data.vpt );
    try
    {
        FRect r1( data.vpt[0], data.vpt[1] );
        FRect r2( data.vpt[2], data.vpt[3] );
        r1.draw( data.img, img::DrawParams().setColor(250,0,0) );
        r2.draw( data.img, img::DrawParams().setColor(0,250,0) );
        auto c1a = r1.getBoundingCircle();
        auto c1b = r1.getInscribedCircle();
        c1a.draw( data.img );
        c1b.draw( data.img );
        if( data.doUnion )
        {
            auto res = r1 & r2;
            if( res() )
                res.get().draw( data.img, img::DrawParams().setColor(0,0,250) );
        }
        else
        {
            auto res = r1 | r2;
            res.draw( data.img, img::DrawParams().setColor(0,0,250) );
        }
    }
    catch( std::exception& err )
    {
        std::cout << "Unable, points do not define a rectangle\n";
    }
    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_SEG()

void action_SEG

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_SEG*>(param);

    data.clearImage();
    if( data.regen )
        data.generateSegments();

    auto func = [&](int i)   // lambda, needed to fetch color from index
        {
            return img::DrawParams().showIndex(data.showIndexes).setColor(data.vcol[i]);
        };
    std::function<img::DrawParams(int)> f(func);
    draw( data.img, data.vseg, f );

    if( data.showIntersection )
    {
        size_t c_intersect = 0;
        for( size_t i=0; i<data.vseg.size()-1; i++ )
        {
            auto s1 = data.vseg[i];
            for( size_t j=i+1; j<data.vseg.size(); j++ )
            {
                auto s2 = data.vseg[j];
                auto pi = s1.intersects( s2 );
                if( pi() )
                {
                    draw( data.img, pi.get(), img::DrawParams().setColor( 250,0,0) );
                    c_intersect++;
                }
            }
        }
        std::cout << "- # intersection points=" << c_intersect << '\n';
    }
    if( data.showMiddlePoint )
    {
        for( const auto& seg: data.vseg )
            seg.getCenter().draw( data.img, img::DrawParams().setColor( 0,0,250) );
    }
    if( data.showBisector )
    {
        std::vector<Line2d> v_bisect( data.vseg.size() );
        std::transform(                               // To draw bisector lines with the same
            data.vseg.begin(),                        //  color as the segments,
            data.vseg.end(),                          //  we need to store them in a vector.
            v_bisect.begin(),
            [](const Segment& s){ return s.getBisector(); }
        );
        draw( data.img, v_bisect, f );
    }
    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_SI()

void action_SI

(

void *

param

)

{
    auto& data = *reinterpret_cast<Param_SI*>(param);

    data.clearImage();
    data.seg1.set( data.vpt[0], data.vpt[1] );
    data.seg2.set( data.vpt[2], data.vpt[3] );

    data.seg1.draw( data.img, img::DrawParams().setColor( 0,0,250).setThickness(2) );
    data.seg2.draw( data.img, img::DrawParams().setColor( 250,0,0).setThickness(2) );
    data.seg1.getLine().draw( data.img, img::DrawParams().setColor( 200,200,200) );
    data.seg2.getLine().draw( data.img, img::DrawParams().setColor( 200,200,200) );
    draw( data.img, data.vpt );

    auto psegs = data.seg1.getParallelSegs( 40 );
    draw( data.img, psegs.first,  img::DrawParams().setColor( 0,250,200) );
    draw( data.img, psegs.second, img::DrawParams().setColor( 200,0,250) );


    if( data._selected != -1 )
        data.vpt[data._selected].draw( data.img, img::DrawParams().selectPoint() );

    auto inters = data.seg1.intersects( data.seg2 );
    if( inters() )
    {
        auto pti = inters.get();
        pti.draw( data.img );
        Line2d l1 = data.seg1.getLine().getOrthogLine( pti );
        l1.draw( data.img, img::DrawParams().setColor( 0,0,100) );

        Line2d l2 = data.seg2.getLine().getOrthogLine( pti );
        l2.draw( data.img, img::DrawParams().setColor( 100,0,0) );
    }

    Line2d li2( Point2d(350,120),Point2d(20,50));
    li2.draw( data.img );

    auto inters1 = data.seg1.intersects( li2 );
    if( inters1() )
         inters1.get().draw( data.img, img::DrawParams().setPointStyle(img::PtStyle::Diam).setColor( 250,0,0));
    auto inters2 = data.seg2.intersects( li2 );
    if( inters2() )
         inters2.get().draw( data.img, img::DrawParams().setPointStyle(img::PtStyle::Diam).setColor( 250,0,0));

    auto segDist1 = action_SI_drawDist( data.seg1, param );
    auto segDist2 = action_SI_drawDist( data.seg2, param );
    data.putTextLine( "distance mouse/s1=" + std::to_string(segDist1) + " mouse/s2=" + std::to_string(segDist2) ,0 );
    data.showImage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

action_SI_drawDist()

double action_SI_drawDist	(	const Segment &	seg,
		void *	param
	)

{
    auto& data = *reinterpret_cast<Param_SI*>(param);

    int segDistCase;
    auto segDist = seg.distTo( data._pt_mouse, &segDistCase );

    auto col_A = img::DrawParams().setColor( 0,200,200 );
    auto col_B = img::DrawParams().setColor( 200,200,0 );
    switch( segDistCase )
    {
        case -1:
            draw( data.img, Segment( data._pt_mouse, seg.getPts().first ), col_B );
        break;
        case +1:
            draw( data.img, Segment( data._pt_mouse, seg.getPts().second ), col_B );
        break;
        default:
            if( data._pt_mouse.distTo( seg.getLine() ) > 3. )
            {
                auto orthog_seg = seg.getLine().getOrthogSegment( data._pt_mouse );
                orthog_seg.draw( data.img, col_A );
            }
    }
    return segDist;
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_1()

void demo_1

(

int

demidx

)

{
    Data data( demidx, "lines" );
    std::cout << "Demo " << demidx << ": click on points and move them\n";

    data.setMouseCB( action_1 );

    int n=5;
    data.vpt[0].set( data._imWidth/2,       data._imHeight/n );
    data.vpt[1].set( data._imWidth/2,       data._imHeight*(n-1)/n );
    data.vpt[2].set( data._imWidth/n,       data._imHeight/2 );
    data.vpt[3].set( data._imWidth*(n-1)/n, data._imHeight/2 );

    data.clearImage();
    action_1( &data );
    data.showImage();

    auto k = cv::waitKey(0);
    if( k == 27 )
        std::exit(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_6()

void demo_6

(

int

demidx

)

{
    Param_6 data( demidx, "homography_lines_seg",
    "Apply homography to lines and segments\n Hit [lm] to change angle, \
    and select points of blue segment with mouse" );

    double angle_delta = 5.; // degrees

    data.setMouseCB( action_6 );
    action_6( &data );

    data.showImage();

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'm', [&](void*){ data.angle += angle_delta; std::cout << "val=" <<data.angle<<'\n'; }, "increment angle" );
    kbloop.addKeyAction( 'l', [&](void*){ data.angle -= angle_delta; std::cout << "val=" <<data.angle<<'\n'; }, "decrement angle" );
    kbloop.addCommonAction( [&](void*){ action_6(&data);} );
    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_B()

void demo_B

(

int

demidx

)

Build H from R,T,S (no mouse)

{
    Param_B data( demidx, "build Homography", "build Homography from Rotation, Translation, Scale \
        Hit a key: scale:[op], angle:[lm], translation:[gh,yb], reset: r" );

    double angle = 0.;
    double angle_delta = 5.;
    double scale = 1.;
    double scale_delta = 1.2;
    double tx = 0;
    double ty = 0;
    double trans_delta = 20;
    double K = M_PI/180.;

    data.clearImage();
    data.initPts();
    data.drawLines();
    data.showImage();

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'r', [&](void*){ scale = 1.; angle = tx = ty = 0.; }, "reset" );
    kbloop.addKeyAction( 'm', [&](void*){ angle += angle_delta; }, "increment angle" );
    kbloop.addKeyAction( 'l', [&](void*){ angle -= angle_delta; }, "decrement angle" );
    kbloop.addKeyAction( 'z', [&](void*){ tx += trans_delta;    }, "increment tx" );
    kbloop.addKeyAction( 'a', [&](void*){ tx -= trans_delta;    }, "decrement tx" );
    kbloop.addKeyAction( 'b', [&](void*){ ty += trans_delta;    }, "increment ty" );
    kbloop.addKeyAction( 'y', [&](void*){ ty -= trans_delta;    }, "decrement ty" );
    kbloop.addKeyAction( 'p', [&](void*){ scale *= scale_delta; }, "increment scale" );
    kbloop.addKeyAction( 'o', [&](void*){ scale /= scale_delta; }, "reduce scale" );
    kbloop.addCommonAction( [&](void*)
        {
            data.clearImage();
            Homogr H;
            H.addRotation( angle*K ).addTranslation( tx, ty ).addScale( scale );
            data.initPts();
            H.applyTo(data.vpt);
            data.drawLines();
            data.showImage();
        }
    );

    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_BB()

void demo_BB

(

int

demidx

)

{
    Param_BB data( demidx, "Generalized Bounding Box demo", ": Bounding Box demo\n \
    Move the points to see the common bounding box of the two elements. hit [w] and [x] to change." );

    action_BB( &data );
    data.setMouseCB( action_BB );

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'w', [&](void*){ std::cout << "red: " <<  data.switchToNext(0) << '\n'; },   "Switch to next 1" );
    kbloop.addKeyAction( 'x', [&](void*){ std::cout << "blue: " << data.switchToNext(1) << '\n'; },   "Switch to next 2" );
    kbloop.addCommonAction( action_BB );

    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_C()

void demo_C

(

int

demidx

)

{
    Param_C data( demidx, "circle demo", "move circle over line, hit [lm] to change circle radius" );

    data.li[0] = Point2d() * Point2d(200,100);
    data.li[1] = Point2d(200,0) * Point2d(200,200);
    data.li[2] = Point2d(0,200) * Point2d(200,200);

    data.clearImage();
    data.drawLines();
    action_C( &data );
    data.showImage();

    data.setMouseCB( action_C );

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'l', [&](void*){ data.radius += 10; }, "increment radius" );
    kbloop.addKeyAction( 'm', [&](void*){ data.radius -= 10; }, "decrement radius" );
    kbloop.addKeyAction( 'r', [&](void*){ data.radius = 80;  }, "reset radius" );
    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_CH()

void demo_CH

(

int

demidx

)

{
    Param_CH data( demidx, "Convex Hull + MEC demo",
        "Convex hull + Minimum Enclosing Circle. Lclick to add points, Rclick to remove" );
    action_CH( &data );
    data.setMouseCB( action_CH );

    data.leftClicAddPoint=true;

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'a', [&](void*){ data._mode  = !data._mode; }, "Toggle drawing mode (Hull, or hull lines)" );
    kbloop.addCommonAction( action_CH );
    action_CH( &data );
    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_CIR()

void demo_CIR

(

int

demidx

)

{
    Param_CIR data( demidx, "Circle demo", "Compute circle from 3 points/2 points\n \
        Colors: green if inside, blue if not\n \
        if 3 points, also computes the corresponding parallelogram" );

    action_CIR( &data );
    data.setMouseCB( action_CIR );

    KeyboardLoop kbloop;
    kbloop.addCommonAction( action_CIR );

    kbloop.addKeyAction( 'a', [&](void*)
        {
            data._buildFrom3Pts = !data._buildFrom3Pts;
        },
        "switch circle from 2 pts / 3 pts"
    );
    kbloop.addKeyAction( 'w', [&](void*)
        {
            data._drawRect = !data._drawRect;
        },
        "switch circle/rectangle"
    );

    kbloop.start( data ); // blocking function
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_ELL()

void demo_ELL

(

int

demidx

)

Ellipse demo.

{
    Param_ELL data( demidx, "Ellipse demo",
        "Ellipse (no mouse, enter 'h' for valid keys)\n \
         -blue rectangle: ellipse bounding box\n \
         -green rectangle: blue rectangle bounding box" );

    double trans_delta = 20;
    double angle_delta = 5.;

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'z', [&](void*){ data.tx += trans_delta;    }, "increment tx" );
    kbloop.addKeyAction( 'a', [&](void*){ data.tx -= trans_delta;    }, "decrement tx" );
    kbloop.addKeyAction( 'b', [&](void*){ data.ty += trans_delta;    }, "increment ty" );
    kbloop.addKeyAction( 'y', [&](void*){ data.ty -= trans_delta;    }, "decrement ty" );
    kbloop.addKeyAction( 'm', [&](void*){ data.angle += angle_delta; }, "increment angle" );
    kbloop.addKeyAction( 'l', [&](void*){ data.angle -= angle_delta; }, "decrement angle" );
    kbloop.addKeyAction( 'o', [&](void*){ data.ratio_mm = std::min(data.ratio_mm*1.1, 1.00); }, "inc ratio" );
    kbloop.addKeyAction( 'p', [&](void*){ data.ratio_mm = std::max(data.ratio_mm/1.1, 0.05); }, "dec ratio" );

    kbloop.addCommonAction( action_ELL );
    action_ELL( &data );
    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_H()

void demo_H

(

int

demidx

)

Demo of computing a homography from two sets of 4 points.

{
    Param_H data( demidx, "Compute Homography from 4 points" );
    data.vpt.resize(8);
    data.reset();
    std::cout << "Demo " << demidx << ": compute homography from two sets of 4 points\n"
        << " - usage: move points with mouse in left window, right window will show source rectangle (blue)\n"
        << "and computed projected rectangle (green)\n"
        << " - keys:\n  -a: switch backend computing library\n  -r: reset points\n";

    data.setMouseCB( action_H );
    action_H( &data );

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'r', [&](void*){ data.reset(); } );
    kbloop.addKeyAction( 'a', [&](void*)
        {
            data.hmethod = data.hmethod?0:1;
#if !defined(HOMOG2D_USE_EIGEN)
            if( data.hmethod == 0 )
            {
                std::cout << "Unable, build without Eigen support, see manual, switch to Opencv\n";
                data.hmethod = 1;
            }
#endif
        }
    );
    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_NFP()

void demo_NFP

(

int

demidx

)

{
    Param_NFP data( demidx, "Closest/Farthest Point" );

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'a', [&](void*){ data._mode==2? data._mode=0: data._mode++; }, "switch mode (nearest/farthest/both)" );
    kbloop.addKeyAction( 'b', [&](void*){ data.genRandomPoints(); }, "Re-generate random points" );

    kbloop.addCommonAction( action_NFP );
    action_NFP( &data );
    data.setMouseCB( action_NFP );

    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_orthSeg()

void demo_orthSeg

(

int

demidx

)

{
    Param_ORS data( demidx, "Orthogonal segments", "Orthogonal segments\n(Move the segment with mouse)" );

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'a', [&](void*){ data._ptsOrSegs=!data._ptsOrSegs; }, "switch mode: points or segments" );
    kbloop.addKeyAction( 'w', [&](void*){ data._drawPolyg=!data._drawPolyg; }, "switch mode: draw polygon in points mode" );

    kbloop.addCommonAction( action_ORS );
    action_ORS( &data );
    data.setMouseCB( action_ORS );

    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_OSegAngle()

void demo_OSegAngle

(

int

demidx

)

{
    Param_OSegAngle data( demidx, "OSegment angle", "move the 3 points with mouse" );
    data.setMouseCB( action_OSegAngle );
    data.vpt.resize(3);
    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'a', [&](void*){ toggle(data._reverseS1,"reverse S1"); }, "reverse S1" );
    kbloop.addKeyAction( 'z', [&](void*){ toggle(data._reverseS2,"reverse S2"); }, "reverse S2" );
    kbloop.addKeyAction( 'w', [&](void*){ toggle(data._showParallel,"showParallel lines"); }, "showParallel lines" );

    kbloop.addCommonAction( action_OSegAngle );
    action_OSegAngle( &data );
    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_PL()

void demo_PL

(

int

demidx

)

{
    Param_PL data( demidx, "Polyline demo",
        "polyline\n-Colors\n -Red: polygon (needs to be closed)\n -Blue: intersections\n \
        Lclick to add point, Rclick to remove" );

    data.leftClicAddPoint=true;
    data.setMouseCB( action_PL );

    action_PL( &data );

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'a', [&](void*)
        {
            data.showClosedPoly = !data.showClosedPoly;
        },
        "switch open/close"
    );
//  kbloop.addCommonAction( [&] { action_PL(&data); } );
    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_PO()

void demo_PO

(

int

demidx

)

Polygon Offset demo start.

{
    Param_PO data( demidx, "Polygon Offset" );
    data.leftClicAddPoint=true;

    data.setMouseCB( action_PO );
    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'w', [&](void*){ data._offsetDist += 2;                                 }, "Increase distance" );
    kbloop.addKeyAction( 'x', [&](void*){ data._offsetDist = std::max(1,data._offsetDist-2);     }, "Reduce distance" );
    kbloop.addKeyAction( 'a', [&](void*){ toggle(data._showSegs,           "showSegs");          }, "Toggle segments to centroid" );
    kbloop.addKeyAction( 'q', [&](void*){ toggle(data._side,               "side");              }, "Reverse side" );
    kbloop.addKeyAction( 'b', [&](void*){ toggle(data._drawBisectorLines,  "drawBisectorLines"); }, "toggle draw bisector lines" );
    kbloop.addKeyAction( 'v', [&](void*){ toggle(data._params._angleSplit, "angleSplit");        }, "switch angles cut" );
    kbloop.addKeyAction( 'f', [&](void*){ toggle(data._showPolyAngles,     "showPolyAngles");    }, "toggle angles" );
    kbloop.addKeyAction( 'g', [&](void*){ toggle(data._showPolyIdx,        "showPolyIdx");       }, "toggle indexes" );
    kbloop.addKeyAction( 'k', [&](void*){ toggle(data._closedPol,          "closedPol");         }, "toggle open/closed" );

    kbloop.addCommonAction( action_PO );
    action_PO( &data );
    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_polRot()

void demo_polRot

(

int

demidx

)

{
    Param_polRot data( demidx, "Polyline/Rectangle full step rotate demo",
        "Polyline/Rectangle full step rotate demo\n \
        - Polyline: center point is one of the points\n \
        - Rectangle: center point is free, use mouse\n \
        Warning: as images as shown here with vertical axis reversed, what appears as a CW is actually a CCW rotation!" );

    data.setMouseCB( action_polRot );

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'a', [&](void*){ data._rotateType=Rotate::CW;       data.doIt(); }, "rotate CW" );
    kbloop.addKeyAction( 'z', [&](void*){ data._rotateType=Rotate::CCW;      data.doIt(); }, "rotate CCW" );
    kbloop.addKeyAction( 'e', [&](void*){ data._rotateType=Rotate::Full;     data.doIt(); }, "rotate Full" );
    kbloop.addKeyAction( 'o', [&](void*){ data._rotateType=Rotate::VMirror;  data.doIt(); }, "VMirror" );
    kbloop.addKeyAction( 'p', [&](void*){ data._rotateType=Rotate::HMirror;  data.doIt(); }, "HMirror" );
    kbloop.addKeyAction( 'w', [&](void*){ data.nextRefPt();                  data.doIt(false); }, "move to next reference point" );
    kbloop.addKeyAction( 'r', [&](void*){ data._item = !data._item;          data.doIt(false); }, "toggle poly/rectangle" );

    kbloop.addCommonAction( action_polRot );
    action_polRot( &data );

    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_RCP()

void demo_RCP

(

int

demidx

)

{
    Param_RCP data( demidx, "Regular Convex Polygon" );

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'w', [&](void*){ data._nbPts++; },      "more points" );
    kbloop.addKeyAction( 'x', [&](void*){ data.nbPts_less(); }, "less points" );
    kbloop.addKeyAction( 'a', [&](void*){ data._radius += data._radiusStep; }, "increase radius" );
    kbloop.addKeyAction( 'z', [&](void*){ data.radius_less(); },               "decrease radius" );

    kbloop.addCommonAction( action_RCP );
    action_RCP( &data );
    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_RI()

void demo_RI

(

int

demidx

)

{
    Param_RI data( demidx, "Rectangle intersection demo" );

    data.setMouseCB( action_RI );
    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'a', [&](void*){ data.doUnion  = !data.doUnion; }, "Toggle union/intersection" );
    kbloop.addCommonAction( action_RI );
    action_RI( &data );
    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_SEG()

void demo_SEG

(

int

demidx

)

{
    Param_SEG data( demidx, "Segments demo" );
    data.generateSegments();

    KeyboardLoop kbloop;
    kbloop.addKeyAction( 'm', [&](void*){ data.showMiddlePoint  = !data.showMiddlePoint; }, "show middle point" );
    kbloop.addKeyAction( 'n', [&](void*){ data.showIndexes      = !data.showIndexes; }, "show indexes" );
    kbloop.addKeyAction( 'i', [&](void*){ data.showIntersection = !data.showIntersection; }, "show intersection points" );
    kbloop.addKeyAction( 'b', [&](void*){ data.showBisector     = !data.showBisector; }, "show bisector lines" );

    kbloop.addKeyAction( 'r', [&](void*){ data.regen = true; }, "Re-generate" );
    kbloop.addKeyAction( 'w', [&](void*){ data.nbSegs = data.nbSegs*2; data.regen = true; }, "double nb points" );
    kbloop.addKeyAction( 'x', [&](void*){ data.nbSegs = data.nbSegs/2; data.regen = true; }, "half nb points" );

    kbloop.addCommonAction( action_SEG );
    action_SEG( &data );

    kbloop.start( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

demo_SI()

void demo_SI

(

int

demidx

)

Segment intersection demo.

{
    Param_SI data( demidx, "segment_intersection",
        "Intersection of segments\n Select a point and move it around.  \
        When they intersect, you get the orthogonal lines of the two segments, at the intersection point.\n \
        Also shows parallel segments" );

    data.vpt[0] = Point2d(100,200);
    data.vpt[1] = Point2d(200,300);
    data.vpt[2] = Point2d(150,50);
    data.vpt[3] = Point2d(300,250);

    action_SI( &data );
    data.setMouseCB( action_SI );

    if( 27 == cv::waitKey(0) )
        std::exit(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
	)

Demo program, using Opencv.

• if called with no arguments, will switch through all the demos, with SPC
• if called with an (integer) argument, will launch only that demo

{
    std::cout << "homog2d graphical demo using Opencv"
        << "\n - homog version: " << HOMOG2D_VERSION
        << "\n - build with OpenCV version: " << CV_VERSION << '\n';

        Point2dF pt1;
        std::cout << "float: size=" << pt1.dsize().first << "-" << pt1.dsize().second << '\n';

        Point2dL pt2;
        std::cout << "long: size=" << pt2.dsize().first << "-" << pt2.dsize().second << '\n';

        Point2dD pt3;
        std::cout << "double: size=" << pt3.dsize().first << "-" << pt3.dsize().second << '\n';

        img::DrawParams dp;
        std::cout << "Default draw parameters: " << dp;

    std::vector<std::function<void(int)>> v_demo{
#ifdef HOMOG2D_PRELIMINAR
        demo_Square,
#endif
        demo_OSegAngle,
        demo_PO,
        demo_BB,
        demo_RCP,
        demo_orthSeg,   // Perpendicular segment
        demo_NFP,   // Nearest/Farthest Point
        demo_RI,    // rectangle intersection
        demo_CIR,
        demo_CH,    // Convex Hull + Minimum Enclosing Circle (MEC)
        demo_SEG,
        demo_B,
        demo_ELL,
        demo_H,
        demo_PL,
        demo_1,
        demo_C,
        demo_SI,
        demo_6,
        demo_polRot // full step rotation of Polyline and rectangle
    };

    if( argc > 1 )
    {
        int d = std::atoi( argv[1] );
        assert( d>0 && d<=(int)v_demo.size() );
        std:: cout << " - calling demo " << d << "\n";
        v_demo[d-1](d);
        return 0;
    }

    std::cout << " - currently " << v_demo.size() << " demo cases available\n"
        << " - to switch to next demo, hit [SPC]\n - to exit, hit [ESC]\n";
    for( size_t i=0; i<v_demo.size(); i++ )
    {
        std::cout << "----------------------------------\n";
        v_demo[i](i+1);
    }
    std::cout << "Demo end\n";
}

myMouseCB()

void myMouseCB	(	int	event,
		int	x,
		int	y,
		int	,
		void *	param
	)

Mouse callback functions, checks if one of the points is selected.

• If so, that point gets moved by the mouse, and the function action is called (if it has been assigned)

{
    auto& data = *reinterpret_cast<Data*>(param);

    data.setMousePos(x,y);
    bool doSomething = true;

    switch( event )
    {
        case cv::EVENT_LBUTTONUP:
            data._selected = -1;
        break;

        case cv::EVENT_LBUTTONDOWN:
            data._selected = -1;
            for( int i=0; i<data.nbPts(); i++ )
                if( data._pt_mouse.distTo( data.vpt[i]) < 10 )  // if mouse is less than 10 pixel away
                {
                    data._selected = i;
                    data.vpt[i].draw( data.img, img::DrawParams().setPointStyle(img::PtStyle::Diam) );
                }
            if( data._selected == -1 )
                if( data.leftClicAddPoint )
                    data.addMousePoint();
        break;

        case cv::EVENT_MOUSEMOVE:
            if( data._selected != -1 )
            {
                data.vpt[data._selected] = data._pt_mouse;
                data.vpt[data._selected].draw( data.img, img::DrawParams().selectPoint() );
            }
        break;

        case cv::EVENT_RBUTTONDOWN:
            data._selected = -1;
            for( int i=0; i<data.nbPts(); i++ )
                if( data._pt_mouse.distTo( data.vpt[i]) < 10 )  // if mouse is less than 10 pixel away
                    data._selected = i;
            if( data._selected != -1 )
            {
                data.vpt.erase( std::begin(data.vpt) + data._selected );
                data._selected = -1;
            }
        break;

        default: doSomething = false; break;
    }
    if( doSomething )
    {
        data.clearImage();
        if( data._mouseCB )
        {
            data._mouseCB( param );
        }
        data.showImage();
    }
}

Here is the call graph for this function:

process_PO()

template<typename IM , typename POL >

void process_PO	(	IM &	im,
		const POL &	pol,
		Param_PO &	data
	)

{
    if( data._drawBisectorLines )
        draw( im, pol.getBisectorLines() );

    if( pol.isSimple() )
    {
        auto cpoly_off = pol.getOffsetPoly( (data._side?1:-1)*data._offsetDist, data._params );
        draw( im, cpoly_off , img::DrawParams().showPoints(false).setColor(0,0,250) );

//      draw( im, dbg.psegs );
        auto centr = pol.centroid();
        draw( im, centr, img::DrawParams().showPoints().setColor(0,0,250) );

        draw( im, pol.centroid(), img::DrawParams().showPoints().setColor(0,0,250) );

        if( data._showSegs )
        {
            for( const auto& seg: pol.getSegs() )
            {
                auto mid= seg.getCenter();
                im.draw( Segment(mid, centr), img::DrawParams().setColor(0,150,0) );
            }
        }
    }
    draw( im, pol,
        img::DrawParams().showPoints().setColor(250,0,0).showAngles(data._showPolyAngles).showIndex(data._showPolyIdx) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

removeDupes()

std::vector<Point2d> removeDupes

(

const std::vector< Point2d > &

vec

)

Helper function. Only removes duplicates if there are consecutive.

{
    std::vector<Point2d> out( vec );
    out.erase( std::unique( out.begin(), out.end() ), out.end() );
    if( out.front() == out.back() ) // if first == last, remove last element
        out.pop_back();
    return out;
}

Here is the caller graph for this function:

toggle()

void toggle	(	bool &	b,
		std::string	msg
	)

{
    b = !b;
    std::cout << "toogle " << msg << "=" << b << '\n';
}

Here is the caller graph for this function:

---

Generated by   1.8.13