FLPipelineTest.cpp

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
    Phission : 
        Realtime Vision Processing System
    
    Copyright (C) 2003 Philip D.S. Thoren (pthoren@cs.uml.edu)
    University of Massachusetts at Lowell,
    Laboratory for Artificial Intelligence and Robotics
    
    This file is part of Phission.

 ---------------------------------------------------------------------------*/
#include <FLPipelineTest.h>
#include <phission.h>

/* ------------------------------------------------------------------------ */
int glbl_disable_displays = 0;
int glbl_do_timing = 0;

/* ------------------------------------------------------------------------ */
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--test <value>    Loop <value> times and then close test\n");
    printf("\t--timing          Print pipeline runtime (forced when --test is used)\n");
    printf("\n\n");
    
    exit(1);
}

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

    unsigned int    i           = 0;

    unsigned int        nDisplays   = 1;
    int                 displaysOpen= 1;
    char                title[255];
    phDisplayInterface  **display   = NULL;
    
    char            *capture_path   = NULL;
    int             channel         = 0;
    
#ifdef WIN32
    VFWSource       *capture    = new VFWSource();
#else
    V4LCapture      *capture    = new V4LCapture();
#endif
    
    phPipeline      *pipeline   = new phPipeline();
    
    empty_Filter    *empty      = new empty_Filter();
#if PH_HAVE_OPENCV
    cv_canny_Filter *canny      = new cv_canny_Filter(50,105);
#else
    canny_Filter    *canny      = new canny_Filter(50,105);
#endif
    inverse_Filter  *inverse    = new inverse_Filter();
    
    /* Utility class to ease the starting and stopping of displays, captures and
     * pipelines */
    phSystem        system;
   
    /* Remove the code below when using this code as an example.
     * 
     * This just checks whether "--test" has been specified with
     * a time value argument. It's for testing all the examples
     * without the need for human intervention. */
    int             test = 0;

    phArgTable      *arg_parser = new phArgTable();

    /* Setup and parse all the arguments */
    rc = arg_parser->add("--test",&test,phARG_INT);
    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("--timing",&glbl_do_timing,phARG_BOOL);
    phCHECK_RC(rc,NULL,"arg_parser->add");
    
    rc = arg_parser->add("--path",&capture_path,phARG_CHAR);
    phCHECK_RC(rc,NULL,"arg_parser->add");

    rc = arg_parser->add("--channel",&channel,phARG_INT);
    phCHECK_RC(rc,NULL,"arg_parser->add");
    
    rc = arg_parser->parse(argc,argv);
    phCHECK_RC(rc,NULL,"arg_parser->parse");
    
    if (glbl_disable_displays) nDisplays = 0;
    if (test) glbl_do_timing = 1;

    /* <> Setup the capture device parameters */
    capture->set(320,240,capture_path);
    capture->setChannel(channel);

    rc = system.addCapture(capture);
    phPRINT_RC(rc,NULL,"system.addCapture(capture)");
    

    display = new phDisplayInterface *[nDisplays];
    phCHECK_NULLPTR(display,"new","new phDisplayInterface *[nDisplays];");
    
    for (i = 0; i < nDisplays; i++ )
    {
        sprintf(title,"FLPipelineTest[%u]",i);
        
        display[i] = new FLDisplay(320,240,title);
        
        rc = system.addDisplay(display[i]);
        phPRINT_RC(rc,NULL,"system.addDisplay(display[%u])",i);
    }
    

    rc = system.addPipeline(pipeline);
    phPRINT_RC(rc,NULL,"system.addPipeline(pipeline)");
    
    /* <> Attach the displays to the live sources */
    /* Capture -> (b)phPipeline -> (a)Processed Output Display */
    
    /* <> Attach the Pipeline output image to the display so the
     * display updates when a processing has been completed
     * for each loop */
    for (i = 0; i < nDisplays; i++)
    {
        display[i]->setLiveSourceInput(pipeline->getLiveSourceOutput());
    }
    
    /* <> Attach the capture image to the live source input of the
     * Pipeline so processing is done automatically once the 
     * pipeline is started. */
    pipeline->setLiveSourceInput(capture->getLiveSourceOutput());
    
    /* <> Add the filter(s) into the pipeline in the order they will 
     * be used */
    pipeline->add(empty);
    pipeline->add(canny);
    pipeline->add(inverse);

    /* Since timing in the pipeline is disabled by default, enable it */
    if (glbl_do_timing)
    {
        rc = pipeline->enableTiming();
        phPRINT_RC(rc,NULL,"pipeline->enableTiming()");
    }

    /* <> Startup the system */
    rc = system.startup();
    phPRINT_RC(rc,NULL,"");
    
    /* <> Keep going until all the windows are closed */
    displaysOpen = 1;
    while (displaysOpen)
    {
        if (glbl_do_timing)
        {
            /* Reset the average calculations and sleep a second */
            rc = pipeline->resetAverage();
            phPRINT_RC(rc,NULL,"pipeline->resetAverage()");
            
            phMSleep(1000);
            
            /* Report the average using the phTimeStamp report facility
             * to allow for portable/robust reporting */
            pipeline->averageRuntime().report("FLPipelineTest - Filtering Average");
            phPRINT_RC(rc,NULL,"pipeline->averageRuntime()");
        }
        else
        {
            /* Sleep a while, don't loop tightly */
            phMSleep(100);
        }
        
        
        /* Yielding is optional. This gives up the thread's timeslice
         * to prevent slow response in other threads. It consumes more
         * CPU cycles than sleeping. Use it instead of sleeping if
         * this loop is processing anything */
        
        /* phYield(); */
        
        if (nDisplays > 0)
        {
            displaysOpen = 0;
            for (i = 0; (i < nDisplays) && (displaysOpen == 0); i++)
            {
                if (display[i]->isOpen() == 1)
                {
                    displaysOpen = 1;
                }
            }
        }
        
        /* Remove this if block when using this code as an example */
        /* Set the loop control value to end the loop when testing */
        if (test > 0)
        { 
            test--;
            if (test == 0)
                displaysOpen = 0;
        }
    }

    /* <> Shutdown the system */
    rc = system.shutdown();
    phPRINT_RC(rc,NULL,"");

error:
    for (i = 0; (i < nDisplays) && (display != NULL); i++)
    {
        phDelete(display[i]);
    }
  
    phDeleteArray(display);

    phDelete(capture);
    
    phDelete(empty);
    phDelete(canny);
    phDelete(inverse);
  
    phDelete(pipeline);

    phFree(capture_path);
    phDelete(arg_parser);

    return phSUCCESS;
}

Copyright (C) 2002 - 2007

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

---