HoughTransform.cpp

Go to the documentation of this file.

/* ------------------------------------------------------------------------- *
 * Copyright (C) Philip D.S. Thoren
 * Graph based segmentation application.
 * 05/27/2007
 * 
 * This program does graph based segmentation on files or a live feed.
 *
 * If you change this, add your copyrights and comments for what you changed.
 *
 * ------------------------------------------------------------------------- */
#include <phission.h>

/* ------------------------------------------------------------------------- */
/* I need to make this code here part of Phission, this just makes the code
 * easier to work with if the portable stuff is renamed to a common name */
#if defined(PH_HAVE_X11)
    #define phDisplay X11Display
#elif defined(PH_HAVE_GDI)
    #define phDisplay GDIDisplay
#endif

#if defined(PH_HAVE_V4L)
    #define phCapture V4LCapture
    #define default_path "/dev/video0"
#else
    #define phCapture VFWSource
    #define default_path "0"
#endif

/* ------------------------------------------------------------------------ */
/* Global variables */
int             glbl_disable_displays       =   0;
int             glbl_print_blobs            =   0;
int             glbl_save_images            =   0;

/* image reading variables */
int             glbl_use_images             =   0;
uint32_t        glbl_input_total            =   2;
char           *glbl_prefix                 =NULL;
char           *glbl_extension              =NULL;

/* Capture variables */
char           *glbl_path                   =NULL;
int             glbl_channel                =   1;
int32_t         glbl_width                  = 320;
int32_t         glbl_height                 = 240;

/* ------------------------------------------------------------------------ */
void usage()
{
    printf("\n\nUsage:\n");
    printf("\t--help                    Display usage\n");
    printf("\t--nodisplay               Disable the allocation, opening or any use of a display.\n");
    printf("\t--save                    Save pipeline output images (0 by default)\n");
    printf("\t--nimages <total>         Filename format: <prefix>_%%04d.ppm (2 by default).\n");
    printf("\t--prefix <prefix>         Use images. (<prefix> = image by default)\n");
    printf("\t--ext <extension>         The input image file extension (default: ppm\n");
    printf("\t--printdata               Print the blob data\n");
    printf("\t-w <width>                Width of the input data. (default: 320).\n");
    printf("\t-h <height>               Height of the input data. (default: 240).\n");
    printf("\n\n");
    exit(1);
}

/* ------------------------------------------------------------------------ */
int parse_command_line( int argc, char *argv[] )
{
    phFUNCTION("parse_command_line")

    phArgTable          *arg_parser     = new phArgTable();

    /* <> Setup all the command line options to the parser */
    rc = arg_parser->add("-w",&glbl_width, phARG_INT32);
    phCHECK_RC(rc,NULL,"arg_parser->add");

    rc = arg_parser->add("-h",&glbl_height, phARG_INT32);
    phCHECK_RC(rc,NULL,"arg_parser->add");

    rc = arg_parser->add("--prefix",&glbl_prefix, phARG_CHAR);
    phCHECK_RC(rc,NULL,"arg_parser->add");

    rc = arg_parser->add("--ext",&glbl_extension, phARG_CHAR);
    phCHECK_RC(rc,NULL,"arg_parser->add");

    rc = arg_parser->add("--nimages",&glbl_input_total, phARG_UINT);
    phCHECK_RC(rc,NULL,"arg_parser->add");

    rc = arg_parser->add("--save",&glbl_save_images, phARG_BOOL);
    phCHECK_RC(rc,NULL,"arg_parser->add");

    rc = arg_parser->add("--printdata",&glbl_print_blobs, phARG_BOOL);
    phCHECK_RC(rc,NULL,"arg_parser->add");

    rc = arg_parser->add("--nodisplay",&glbl_disable_displays, phARG_BOOL);
    phCHECK_RC(rc,NULL,"arg_parser->add");

    rc = arg_parser->add("--help",(void *)&usage, phARG_FUNC);
    phCHECK_RC(rc,NULL,"arg_parser->add");
    
    rc = arg_parser->add("--path",&glbl_path,phARG_CHAR);
    phCHECK_RC(rc,NULL,"arg_parser->add");

    rc = arg_parser->add("--channel",&glbl_channel,phARG_INT);
    phCHECK_RC(rc,NULL,"arg_parser->add");
   
    /* <> Parse */
    rc = arg_parser->parse(argc,argv);
    phCHECK_RC(rc,NULL,"arg_parser->parse");

    /* <> Do error checking and variable default setup */
   
    phDelete(arg_parser);

    return phSUCCESS;
error:
    phDelete(arg_parser);

    return phFAIL;
}

/* ------------------------------------------------------------------------ */
void next_image( char      *prefix,
                 char      *ext,
                 int        total,
                 uint32_t  *index,
                 phImage   *image )
{
    phFUNCTION("next_image")
    char filename[255];

    snprintf(filename,255,"%s%010u.%s",prefix,*index,ext);

    if (strcmp(ext,"ppm") != 0)
    {
        image->disableNotify();

        rc = image->load(filename);
        phPRINT_RC(rc,NULL,"image->load(%s)",filename);

        image->enableNotify();

        image->convert(phImageRGB24);
    }
    else
    {
        rc = image->load(filename);
        phPRINT_RC(rc,NULL,"image->load(%s)",filename);
    }
    *index = (*index + 1) % total;
}

/* ------------------------------------------------------------------------- */
int main (int argc, char *argv[] )
{
    phFUNCTION("main")

    int i = 0;
    int done = 0;

    /* Declare ------------------------------------------------------------- */
    phSystem                   *system              = NULL;
    phDisplayInterface         *display             = NULL;
    phDisplayInterface         *pipeline_display    = NULL;
    phImageCapture             *capture             = NULL;
    phPipeline                 *pipeline            = NULL;
    
    phLiveObject               *input_source        = NULL;
    phImage                    *input_image         = NULL;
    uint32_t                    input_index         = 0;
    char                       *input_ext           = "ppm";
    
    char                        output_filename[255];
    uint32_t                    output_index        = 0;
    phImage                    *output_image        = NULL;
    
    cv_houghLines2_Filter      *hough               = NULL;
    gaussian3x3_Filter         *gauss               = NULL;
    convert_Filter             *gray                = NULL;
    threshold_Filter           *thresh              = NULL;
    meanNxN_Filter             *mean                = NULL;
    resize_Filter              *resize              = NULL;
    subtract_Filter            *sub                 = NULL;
    cv_canny_Filter            *canny               = NULL;
    
    const int           canny_low           = 80;
    const int           canny_high          = 200;

    phHoughData         *hough_data         = NULL;

    phPROGRESS("Program started.\n");

    /* Parse the command line ---------------------------------------------- */
    rc = parse_command_line(argc, argv );
    phCHECK_RC(rc,NULL,"parse_command_line");

    if (glbl_extension != NULL)
    {
        input_ext = glbl_extension;
    }
 
    /* Allocate ------------------------------------------------------------ */
    system   = new phSystem();
    pipeline = new phPipeline();
    gauss    = new gaussian3x3_Filter();
    gray     = new convert_Filter(phImageGRAY8);
    thresh   = new threshold_Filter(0,140);
    mean     = new meanNxN_Filter(5);
    resize   = new resize_Filter(320,240);
    sub      = new subtract_Filter(2,1,2);
    canny    = new cv_canny_Filter(canny_low,canny_high);
    hough    = new cv_houghLines2_Filter();
    hough_data = new phHoughData();
    
    /* live data */
    if (glbl_prefix == NULL)
    {
        capture         = new phCapture();
        input_source    = capture->getOutput();
    }
    /* Data being loaded from files */
    else
    {
        input_image     = new phImage();
        input_source    = input_image;
    }
        
    output_image    = new phImage();

    /* Don't allocate displays if we're not using them */
    if (!glbl_disable_displays)
    {
        display             = new phDisplay( glbl_width, glbl_height,"Capture" );
        pipeline_display    = new phDisplay( glbl_width, glbl_height,"Pipeline" );
    }

    /* Connect ------------------------------------------------------------- */
    pipeline->setInput          ( input_source );
    
    /* Don't connect displays if we're not using them */
    if (!glbl_disable_displays)
    {
        display->setInput           ( input_source );
        display->setInput(resize->getLiveSourceOutput());
        pipeline_display->setInput  ( pipeline->getOutput() );
    }
        
    output_image->connect(pipeline->getOutput());

    hough_data->connect(hough->getOutput());

    /* Tell the system about it all --------------------------------------- */
    if (capture != NULL)
    {
        system->add(capture);
    }
    
    /* Don't add displays if we're not using them */
    if (!glbl_disable_displays)
    {
        system->add(display);
        system->add(pipeline_display);
    }

    system->add(pipeline);

    /* Calibrate / Setup -------------------------------------------------- */
    if (capture != NULL)
    {
        capture->set(glbl_width,glbl_height,glbl_path);
        if (glbl_path == NULL)
        {
            capture->setPath((char *)default_path);
        }
        capture->setChannel(glbl_channel);
    }

    /* Don't adjust/setup displays if we're not using them */
    if (!glbl_disable_displays)
    {
        display->move(0,0);
        pipeline_display->move(glbl_width + 50,0);
    }

    /* Setup the pipeline ------------------------------------------------- */
    pipeline->add(resize);
    pipeline->add(gauss);
    pipeline->add(gray);
    pipeline->add(thresh);
    pipeline->add(canny);
    
    pipeline->add(hough);

    pipeline->enableTiming();

    /* -------------------------------------------------------------------- */
    hough->setMethod(phHoughProbalistic);
    hough->setDrawLines (1);
    hough->setRho       (1);
    hough->setTheta     (0.0174532925);
    hough->setThreshold (50);
    hough->setParam1    (30);
    hough->setParam2    (10);

    /* Start -------------------------------------------------------------- */
    system->startup();
    
    if (!glbl_disable_displays)
        done = 1;
    while ((system->displaysOpen() > 0) || (!done))
    {
        /* ----------------------------------------------------------------- */
        /* Load an image to segment */
        if (glbl_prefix != NULL)
        {
            next_image( glbl_prefix, 
                        input_ext,
                        glbl_input_total,
                        &input_index, 
                        input_image );
            phMSleep(1000);
        }

        /* ----------------------------------------------------------------- */
        if (glbl_save_images)
        {
            snprintf(output_filename,255,
                    "images/input/cv_houghLines2_%04u.ppm",
                    output_index);
            input_image->save(output_filename);
        }

        /* ----------------------------------------------------------------- */
        /* Throttle the loop to wait for the pipeline to complete */
        if ((glbl_prefix != NULL) || 0)
        {
            output_image->update();
        }
        /* if we're saving images, get the frames to save */
        if (glbl_save_images)
        {
            snprintf(output_filename,255,
                     "images/output/cv_houghLines2_%04u.ppm",
                     output_index);
            
            output_image->save(output_filename);

            output_index++;
        }

        rc = hough_data->update();
        if ((rc == phLiveObjectUPDATED) &&
            (hough_data->getLineCount()))
        {
            hough_data->print_data();
        }
#if 1
        phPRINT("-> %d (%d of %d)\n", pipeline->runtime().getMilliseconds(),
                input_index, glbl_input_total );
#endif   
        /* Shutdown if we're saving */
        /* When input_index == 0, it will be the next run through the list */
        if (glbl_save_images && (input_index == 0))
        {
            done = 1;
            system->stopDisplays();
            continue;
        }
    }

    /* Stop --------------------------------------------------------------- */
    system->shutdown();

#if 0
    phPRINT("Average %d\n", 
            pipeline->averageRuntime().getMilliseconds(),
            input_index, 
            glbl_input_total );
#endif
    
error:
    /* Cleanup ------------------------------------------------------------ */
    phDelete(hough);
    phDelete(canny);
    phDelete(sub);

    phDelete(output_image);
    phDelete(input_image);
    phDelete(pipeline);
    phDelete(capture);
    phDelete(display);
    phDelete(pipeline_display);
    phDelete(system);

    phFree(glbl_prefix);
    phFree(glbl_path);
    phFree(glbl_extension);
 
    phPROGRESS("Program finished.\n");

    return phSUCCESS;
}

Copyright (C) 2002 - 2007

Philip D.S. Thoren ( pthoren@users.sourceforge.net ) University Of Massachusetts at Lowell Robotics Lab

---