X11MultiCapPipelineTest.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 <X11MultiCapPipelineTest.h>
#include <phission.h>

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

/* Connect multiple pipelines to multiple capture devices.
 * Connect multiple displays to pipelines and captures. */

/* ------------------------------------------------------------------------ */
int 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>    Sleep 'value' seconds and then close test\n");
    printf("\n\n");
    exit(1);
}
        
/* ------------------------------------------------------------------------ */
int main(int argc, char *argv[] )
{
    phFUNCTION("main")

    uint32_t        i = 0;

    /* CAPTURE ------------------------------------------------------------ */
    uint32_t        nCaptures   = 4;
    char            device[255];
#ifdef WIN32
    VFWSource       *capture[nCaptures];
#else
    V4LCapture      *capture[nCaptures];
#endif

    uint32_t        width = 320;
    uint32_t        height = 240;

    char        *capture_path   = NULL;
    int         channel         = 0;
        
    /* PIPIELINE AND FILTERS ---------------------------------------------- */
    uint32_t        nPipelines  = 2;
    phPipeline      *pipelines[nPipelines];
    uint32_t        format      = phImageRGB24;

    sobel_Filter    *sobels[nPipelines];
    phFilter        *gauss[nPipelines];
    phFilter        *mean[nPipelines];
    phFilter        *median[nPipelines];
    
    /* DISPLAYS ----------------------------------------------------------- */
    uint32_t            nDisplays   = nPipelines + nCaptures;
    int                 displaysOpen= 1;
    char                title[255];
    phDisplayInterface  **display = NULL;
    
    /* 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();

    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->parse(argc,argv);
    phCHECK_RC(rc,NULL,"arg_parser->parse");
    
    if (glbl_disable_displays) nDisplays = 0;
    

    /* SETUP ROUTINES ----------------------------------------------------- */
    for (i = 0; i < nCaptures; i++ )
    {   
        
#ifdef WIN32
        sprintf(device,"%d",i);
        capture[i] = new VFWSource();
#else
        sprintf(device,"/dev/video%u",i);
        capture[i] = new V4LCapture();
#endif
        
        capture[i]->set(width,height,device);
        capture[i]->setChannel(channel);
        capture[i]->setBrightness(20000);

        rc = system.addCapture(capture[i]);
        phPRINT_RC(rc,NULL,"system.addCapture(capture[%u])",i);
    }
    
    for (i = 0; i < nPipelines; i++)
    {
        pipelines[i] = new phPipeline();
        
        /* TODO: This causes a BUG; */
        /* if (i < nCaptures && 0) */
        if (i < nCaptures)
        {
            pipelines[i]->setLiveSourceInput(capture[i]->getLiveSourceOutput());
            format = capture[i]->getFormat();
        }
        else if (nCaptures > 0) /* Make sure there is a capture to retrieve from */
        {
            format = capture[nCaptures-1]->getFormat();
        }
        else /* default not gauranteed to be correct */
        {
            format = phImageRGB24;
        }
        
        /* use the optimized version, this really should be done internally */
        if (format & (phImageRGB24 | phImageRGBA32))
        {
            gauss[i] = new gaussian3x3_Filter();
            mean[i] = new meanNxN_Filter(3);
            median[i] = new medianBlur_Filter(3);
        }
        else
        {
            gauss[i] = new gaussianBlur_Filter();
            mean[i] = new meanBlur_Filter(3);
            median[i] = new medianBlur_Filter(3);
        }
        sobels[i] = new sobel_Filter();

        pipelines[i]->add(gauss[i]);
        pipelines[i]->add(mean[i]);
        pipelines[i]->add(median[i]);
        pipelines[i]->add(sobels[i]);

        rc = system.addPipeline(pipelines[i]);
        phPRINT_RC(rc,NULL,"system.addPipeline(pipelines[%u])",i);
    }
    
    display = new phDisplayInterface *[nDisplays];
    phCHECK_NULLPTR(display,"new","new phDisplayInterface *[nDisplays];");

    for (i = 0; i < nDisplays; i++)
    {
        sprintf(title,"X11MultiCapPipelineTest[%u]",i);
        
        display[i] = new X11Display(width,height,title);

        rc = system.addDisplay(display[i]);
        phPRINT_RC(rc,NULL,"system.addDisplay(display[%d])",i);
       
        /* Connect the lower indexed displays to the pipeline output */
        /* Connect displays to pipeline outputs */
        if (i < nPipelines)
            display[i]->setLiveSourceInput(pipelines[i]->getLiveSourceOutput());
        /* Connect displays to capture outputs */
        else if (( i >= nPipelines ) && ((i - nPipelines) > nCaptures))            
            display[i]->setLiveSourceInput(capture[i - nPipelines]->getLiveSourceOutput());
    }
    

    /* startup */
    rc = system.startup();
    phPRINT_RC(rc,NULL,"system.startup()");
    
    displaysOpen = 1;
    while (displaysOpen)
    {
        /* 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)
        { 
            displaysOpen = 0;
            phSleep(test); /* test's value should be a time (in secs) value > 0*/
        }
    }

    rc = system.shutdown();
    phPRINT_RC(rc,NULL,"system.shutdown()");
    

error:
    for (i = 0; i < nCaptures; i++)
    {
        phDelete(capture[i]);
    }

    for (i = 0; i < nPipelines; i++)
    {
        phDelete(pipelines[i]);
        phDelete(gauss[i]);
        phDelete(mean[i]);
        phDelete(median[i]);
        phDelete(sobels[i]);
    }

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

    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

---