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

/* ------------------------------------------------------------------------ */
int     glbl_disable_displays       =   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>            Iterate <value> times through the loop\n");
    printf("\t--path <pathstr>          Path to the input device\n");
    printf("\t--channel <value>         The channel to set a capture card to\n");
    printf("\n\n");
    exit(1);
}

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

    /* Display variables */
    char                *capture_path   = NULL;
    int                 channel         = 0;
    int                 i               = 0;
    int                 j               = 0;
    char                title[255];
    
    phImageCapture      *capture    = NULL;
    phPipeline          *pipeline   = new phPipeline();
    phDisplayInterface  *display    = NULL;
    phSystem            *system     = new phSystem();

    draw_Filter         *draw       = new draw_Filter();
    const int           width       = 320;
    const int           height      = 240;
    const int           cols        = 4;
    const int           rows        = 4;
    const int           divisions   = cols * rows;
    const int32_t       rect_width  = width/cols;
    const int32_t       rect_height = height/rows;
    phDrawing           drawing[divisions] = {0};
    int32_t x1;
    int32_t y1;

    /* 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;
    int             done = 0;

    /* --------------------------------------------------------------------- */
    phArgTable      *arg_parser = new phArgTable();

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

    rc = arg_parser->add("--test",&test, phARG_INT);
    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",&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 the command line switch to disable the displays was given, then
     * don't allocate or open any displays */
#ifdef WIN32
    capture = new VFWSource();
#else
    capture = new V4LCapture();
#endif
    capture->set(width,height,capture_path );
    capture->setChannel(channel);
#if 1
    capture->setColour(48495);
    capture->setHue(30583);
    capture->setContrast(30583);
    capture->setBrightness(38447);
#endif
    rc = system->addCapture(capture);
    phPRINT_RC(rc,NULL,"system->addCapture(capture)");
    
    /* --------------------------------------------------------------------- */
    if (!glbl_disable_displays)
    {
        sprintf(title,"DrawTest[%u]",i);

#if defined(PH_HAVE_X11)
        display = new X11Display(width,height,title);
#elif defined(PH_HAVE_GDI)
        display = new GDIDisplay(width,height,title);
#endif
        
        rc = system->addDisplay(display);
        phPRINT_RC(rc,NULL,"system->addDisplay(display)");
    }
    
    /* --------------------------------------------------------------------- */
    rc = system->addPipeline(pipeline);
    phPRINT_RC(rc,NULL,"system->addPipeline(pipeline)");
    
    /* --------------------------------------------------------------------- */
    /* <> Attach the displays to the live sources */
    /* Image -> (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 */
    if (!glbl_disable_displays)
        display->setLiveSourceInput(pipeline->getLiveSourceOutput());
   
    pipeline->setLiveSourceInput(capture->getLiveSourceOutput());

    /* --------------------------------------------------------------------- */
    /*
     * Example 1:
     * Add the drawing data to the draw filter directly.
     * This shows the ability to add primitives to the the draw filter's 
     * internal phDrawing object.
     */
    capture->setFormat(phImageRGB24);
    draw->add(phCircle_new( 160,120,5 ),
              phColorRGB24_new(0,255,0),
              1,                    /* size */
              phDrawingNoFill,      /* color fill */
              0                     /* transparency */
              );
              
    draw->add(phCircle_new( 160,120,20 ),
              phColorRGB24_new(255,0,255),
              1,                    /* size */
              phDrawingNoFill,      /* color fill */
              0                     /* transparency */
              );
              
    draw->add(phCircle_new( 260,120,30 ),
              phColorRGB24_new(255,255,0),
              1,                    /* size */
              phDrawingFill,        /* color fill */
              50                    /* transparency */
              );
              
    draw->add(phRectangle_new( 0, 10, 50, 100 ),
              phColorRGB24_new(0,255,255),
              1,                    /* size */
              phDrawingFill,        /* color fill */
              50                     /* transparency */
              );

    draw->add(phRectangle_new( 200, 10, 70, 50 ),
              phColorRGB24_new(0,255,255),
              1,                    /* size */
              phDrawingNoFill,      /* color fill */
              0                     /* transparency */
              );
              
    draw->add(phTriangle_new( 40,40, 220,120, 10,120 ),
              phColorRGB24_new(128,128,128),
              1,                    /* size */
              phDrawingNoFill,      /* color fill */
              50                    /* transparency */
              );
    
    draw->add(phTriangle_new( 40,60, 220,140, 10,141 ),
              phColorRGB24_new(128,128,255),
              1,                    /* size */
              phDrawingFill,        /* color fill */
              75                     /* transparency */
              );
              
    draw->add(phLine_new( 4,230, 220,0 ),
              phColorRGB24_new(128,0,128),
              1,                    /* size */
              0                     /* transparency */
              );
    
    draw->add(phPoint_new(260,120),
              phColorRGB24_new(255,0,0),
              1,                    /* size */
              0                     /* transparency */
              );
              
    draw->add(phCross_new(200,200,20,10),
              phColorRGB24_new(255,100,128),
              1,                    /* size */
              0                     /* transparency */
              );
              
    /* Example 2:
     * Create a couple phDrawings and switch between them while the system is 
     * running.
     * This shows a way of cycling through overlaying information on the image
     * using prestored phDrawing objects.
     */
    for (j = 0; j < divisions; j++)
    {
        drawing[j] = NULL;
        rc = phDrawing_alloc(&drawing[j]);
        for (i = 0; i < divisions; i++)
        {
            x1 = (i % cols) * rect_width;
            y1 = (i / cols) * rect_height;
            
            /* i != j leaves the division open */
            if (i != j)
            {
                phDrawing_addRectangle(
                    drawing[j],                     /* phDrawing */
                    phRectangle_new(x1,y1,                                    
                                    rect_width,
                                    rect_height),   /* phRectangle */
                    phColorRGB24_new(0,0,0),        /* color */
                    1,                              /* size */
                    phDrawingFill,                  /* fill */
                    50                              /* transparency */
                    );
            }
        }
    }
    /* --------------------------------------------------------------------- */
    /* Add the draw filter to the pipeline */
    pipeline->add(draw);

    /* <> Startup the system */
    rc = system->startup();
    phPRINT_RC(rc,NULL,"system->startup()");

    phMSleep(3500);
    /* --------------------------------------------------------------------- */
    /* <> Keep going until all the windows are closed */
    i = 0;
    while ((system->displaysOpen() > 0) && (!done))
    {
        /* Cycle through the drawings */
        rc = draw->set(drawing[i]);
        phPRINT_RC(rc,NULL,"draw->set(drawing[%d])",i);
        i = (i + 1) % divisions;
        phMSleep(125);
        
        /* 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();
        
        /* 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--;
            phSleep(1);
            if (test == 0) done = 1;
        }
    }

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

error:
    for (j = 0; j < 4; j++)
        phDrawing_free(&drawing[j]);
    phDelete(draw);
    phDelete(display);
    phDelete(pipeline);
    phDelete(capture);
    phDelete(system);

    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

---