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

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

/* ------------------------------------------------------------------------ */
int usage()
{
    printf("\n\n\tUsage:\n");
    printf("\t\t\t--delay <delay value in microseconds>\tdelay between frame updates\n");
    printf("\t\t\t--fps <fps>\t\tframes per second speed for the displaying of the video.\n");
    printf("\t\t\t--loop <value>\tloop the video <value> times; -1 for infinity\n");
    printf("\t\t\t--help\t\t\tdisplay usage\n");
    printf("\t\t\t--nodisplay\tdisable the allocation, opening or any use of a display.\n");
    printf("\t\t\t--test <value>\tload 'value' number of frames/files/images\n");
    printf("\t\t\t--file <avi_data_file>\t\t\tavi source (required)\n");
    printf("\n\n");
    exit(1);
}


/* ------------------------------------------------------------------------ */
class phEffectsThread : public phThread
{
private:
    phImage *m_input[2];
    uint32_t m_input_count;
    
    float   m_alpha;

    uint32_t m_output_format;
    phImage *m_output;

    uint8_t *m_buf;
    uint32_t m_buf_size;

protected:
    int run();
    int wakeup();

public:
    phEffectsThread( phLiveObject *one, phLiveObject *two, uint32_t output_format );
    ~phEffectsThread();

    int mosaic_images( phImage *one, phImage *two, phImage *out);
    int overlay_images( phImage *one, phImage *two, phImage *out );

    phLiveObject *getLiveSourceOutput() { return this->m_output; };
};

/* ------------------------------------------------------------------------ */
phEffectsThread::phEffectsThread( phLiveObject *one, 
                                phLiveObject *two, 
                                uint32_t output_format )
{
    phFUNCTION("phEffectsThread::phEffectsThread")
    int locked = 0;

    phTHIS_LOOSE_LOCK(locked);
    
    this->setName("phEffectsThread");
    this->m_input[0] = (phImage *)one;
    this->m_input[1] = (phImage *)two;
    this->m_input_count = 2;

    this->m_alpha = 0.00;

    this->m_output_format = output_format;

    this->m_output = new phImage();

    this->m_buf = NULL;
    this->m_buf_size = 0;

    phTHIS_LOOSE_UNLOCK(locked);
}

/* ------------------------------------------------------------------------ */
phEffectsThread::~phEffectsThread()
{
    phFree(this->m_buf);
    this->m_buf_size = 0;
    phDelete(this->m_output);
}

/* ------------------------------------------------------------------------ */
int phEffectsThread::mosaic_images( phImage *one, phImage *two, phImage *out )
{
    phFUNCTION("phEffectsThread::mosaic_images")
    int locked = 0;
    uint8_t *ptr[2];
    uint32_t height[2];
    uint32_t width[2];
    uint32_t offset;
    uint32_t output_height = 0;
    uint32_t output_width = 0;

    uint32_t i = 0;
    uint32_t j = 0;

    uint32_t depth = 0;

    if ((one == NULL) ||
        (two == NULL) ||
        (one->isNull()) || 
        (two->isNull()))
    {
        return phFAIL;
    }
    
    phTHIS_LOCK(locked);

    /* Convert the input images to one color space */
    rc = one->convert(this->m_output_format);
    phPRINT_RC(rc,NULL,"one->convert(%s)",
            phImageFormatToString(this->m_output_format));
    
    rc = two->convert(this->m_output_format);
    phPRINT_RC(rc,NULL,"two->convert(%s)",
            phImageFormatToString(this->m_output_format));
   
    /* Make sure our buffer is large enough */ 
    phDALLOC_RESIZE(this->m_buf,
                    this->m_buf_size,
                    one->getSize() + two->getSize(),
                    uint8_t );
    
    depth = phImageFormatToDepth(this->m_output_format);
    
    /* Get the pointers to the image only after the conversions */
    ptr[0] = (uint8_t*)one->getImage();
    ptr[1] = (uint8_t*)two->getImage();
  
    height[0] = one->getHeight();
    height[1] = two->getHeight();

    width[0] = one->getWidth();
    width[1] = two->getWidth();

    output_height = (height[0] > height[1] ? height[0] : height[1]);
    output_width = width[0] + width[1];

    offset = 0;
    for (j = 0; j < this->m_input_count; j++)
    {
        for (i = 0; i < height[j]; i++ )
        {
            phMemcpy(&(this->m_buf[((i * output_width) + offset) * depth]),
                     &(ptr[j][i * width[j] * depth]),
                     width[j] * depth);
        }
        offset += width[j];
    }

    rc = out->setImage(output_width,
                       output_height,
                       this->m_output_format,
                       this->m_buf_size,
                       this->m_buf);
    phCHECK_RC(rc,NULL,"out->setImage");
    
    phTHIS_UNLOCK(locked);

    return phSUCCESS;
error:

    phTHIS_ERROR_UNLOCK(locked);
    
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phEffectsThread::overlay_images( phImage *one, phImage *two, phImage *out )
{
    phFUNCTION("phEffectsThread::mosaic_images")
    int locked = 0;
    
    float alpha = this->m_alpha;
    float alphainv = 1.0 - alpha;
    
    float tmp = 0;
    uint8_t *outptr = NULL;
    uint8_t *ptr[2];
    uint32_t height[2];
    uint32_t width[2];
    uint32_t offset;
    uint32_t output_height = 0;
    uint32_t output_width = 0;

    uint32_t i = 0;
    uint32_t j = 0;

    uint32_t depth = 0;
    uint32_t limit = 0;

    if ((one == NULL) ||
        (two == NULL) ||
        (one->isNull()) || 
        (two->isNull()))
    {
        return phFAIL;
    }
    
    phTHIS_LOCK(locked);

    /* Convert the input images to one color space */
    rc = one->convert(this->m_output_format);
    phPRINT_RC(rc,NULL,"one->convert(%s)",
            phImageFormatToString(this->m_output_format));
    
    rc = two->convert(this->m_output_format);
    phPRINT_RC(rc,NULL,"two->convert(%s)",
            phImageFormatToString(this->m_output_format));
   
    rc = two->resize(one->getWidth(),one->getHeight());
    phPRINT_RC(rc,NULL,"two->resize");
   
    /* Make sure our buffer is large enough */ 
    phDALLOC_RESIZE(this->m_buf,
                    this->m_buf_size,
                    one->getSize(),
                    uint8_t );
    
    depth = phImageFormatToDepth(this->m_output_format);
    
    /* Get the pointers to the image only after the conversions */
    ptr[0] = (uint8_t*)one->getImage();
    ptr[1] = (uint8_t*)two->getImage();
  
    height[0] = one->getHeight();
    height[1] = two->getHeight();

    width[0] = one->getWidth();
    width[1] = two->getWidth();

    output_width = one->getWidth();
    output_height = one->getHeight();
   
    limit = one->getWidth() * one->getHeight() * depth;
    outptr = this->m_buf;
    
    for (j = 0; j < limit; j++)
    {
        tmp = ((*ptr[0]) * alphainv) + ((*ptr[1]) * alpha);
        if (tmp < 0) tmp = 0;
        *outptr = (uint8_t)(tmp > 255 ? 255 : tmp);
        outptr++;
        ptr[0]++;
        ptr[1]++;
    }

    rc = out->setImage(output_width,
                       output_height,
                       this->m_output_format,
                       this->m_buf_size,
                       this->m_buf);
    phCHECK_RC(rc,NULL,"out->setImage");
    
    phTHIS_UNLOCK(locked);

    return phSUCCESS;
error:

    phTHIS_ERROR_UNLOCK(locked);
    
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phEffectsThread::run()
{   
    phFUNCTION("phEffectsThread::run") 
    phImage local_copy[2];
    uint32_t i = 0;
    uint32_t counter = 0;
    int32_t  direction = 1;
    
    for (i = 0; i < 2; i++ )
    {
        rc = local_copy[i].connect(this->m_input[i]);
        phCHECK_RC(rc,NULL,"this->local_copy[%d].connect(%p)",i,this->m_input[i]);
    }
    
    rc = this->signal_running();
    phCHECK_RC(rc,NULL,"this->signal_running");
   
    while (this->isRunning())
    {    
        for (i = 0; i < 2; i++ )
        {
            rc = local_copy[i].update();
            phPRINT_RC(rc,NULL,"this->local_copy[%d].update()",i);
        }
#if 0
        rc = this->mosaic_images(&(local_copy[0]),&(local_copy[1]),this->m_output);
        phPRINT_RC(rc,NULL,"this->mosaic_images");
#else
        rc = this->overlay_images(&(local_copy[0]),&(local_copy[1]),this->m_output);
        phPRINT_RC(rc,NULL,"this->mosaic_images");
#endif

        if (counter == 0)
        {
            if (this->m_alpha >= 1.00)
                direction = -1;
            if (this->m_alpha <= 0.00)
                direction = 1;
                
            this->m_alpha += 0.1 * direction;
            counter = 0;
        }
        else
        {
            counter++;
        }
    }

    for (i = 0; i < 2; i++ )
    {
        rc = local_copy[i].disconnect();
        phPRINT_RC(rc,NULL,"this->local_copy[%d].disconnect()",i);
    }
    
    return phSUCCESS;
error:
    rc = this->signal_error();
    phPRINT_RC(rc,NULL,"this->signal_error");

    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phEffectsThread::wakeup()
{
    phFUNCTION("phEffectsThread::wakeup")
    uint32_t i = 0;
    
    for (i = 0; i < 2; i++ )
    {
        rc = this->m_input[i]->wakeup_clients();
        phCHECK_RC(rc,NULL,"this->m_input[%d]->wakeup_clients();",i);
    }
    
    return phSUCCESS;
error:
    return phFAIL;
}

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

    int             displaysOpen= 1;
    
    unsigned int    i           = 0;
    unsigned int    image_count = 50;
    char*           filename = NULL;

    phDisplayInterface *display = NULL;

    int             delay           = 0;
    int             fps             = 0;
    int             loop            = 0;

    /* Utility class to ease the starting and stopping of displays, captures and
     * pipelines */
    phSystem        system;
    phAvcodecSource *capture    = new phAvcodecSource();
    V4LCapture      *capture2   = new V4LCapture();

    phEffectsThread  mosaic(capture->getOutput(),
                           capture2->getOutput(),
                           phImageRGBA32);
   
    /* 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("--delay", &delay, phARG_INT);
    phCHECK_RC(rc, NULL, "arg_parser->add");
    rc = arg_parser->add("--fps", &fps, phARG_INT);
    phCHECK_RC(rc, NULL, "arg_parser->add");
    rc = arg_parser->add("--file", &filename, phARG_CHAR);
    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("--nodisplay", (void *)&glbl_disable_displays, phARG_BOOL);
    phCHECK_RC(rc,NULL,"arg_parser->add");
    rc = arg_parser->add("--loop",&loop, 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->parse(argc,argv);
    phCHECK_RC(rc,NULL,"arg_parser->parse");

    if (filename == NULL)
    {
        phCHECK_PTR(filename,NULL,"filename not given");
    }

    capture->setDelay(delay);
    if (fps)
        capture->setFps(fps);
    capture->setLoop(loop);
    capture->setFormat(phImageRGB24);
    
    rc = capture->setPath(filename);
    phCHECK_RC(rc,NULL,"capture->setPath(%s)",filename);
  
    rc = system.add(capture);
    phCHECK_RC(rc,NULL,"system.add(capture:%p)",capture);
    
    /* Set up the capture parameters */
    capture2->set        ( 320, 240, "/dev/video0" );
    capture2->setChannel ( 1 );
    capture2->setFormat  ( phImageRGB24 );

    rc = system.add(capture2);
    phCHECK_RC(rc,NULL,"system.add(capture2:%p)",capture2);

    /* TODO: init capture */
    if (glbl_disable_displays == 0)
    {
#if 0
        display = new X11Display(capture->getWidth(),
                                 capture->getHeight(),
                                 "phAvcodecSourceTest");
        phCHECK_PTR(display,"new","new X11Display failed.");
        
        display->setLiveSourceInput(capture->getLiveSourceOutput());
#else
        display = new X11Display(160,120,
                                 "EffectsTest");
        phCHECK_PTR(display,"new","new X11Display failed.");
        
        display->setLiveSourceInput(mosaic.getLiveSourceOutput());
#endif
        rc = system.addDisplay(display);
    }

    rc = system.add(&mosaic);
    phCHECK_RC(rc,NULL,"system.add(&mosaic)");

    /* startup */
    rc = system.startup();
    phPRINT_RC(rc,NULL,"system.startup()");
    
    // now loop continuously for as long as we have a display open and a frame available from the avi file
    while ((displaysOpen) && (system.capturesActive()))
    {
        if (glbl_disable_displays == 0)
        {
            displaysOpen = 0;
            if (system.displaysOpen())
            {
                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)
        { 
            /* loop once through for this test */
            if (i == (image_count - 1))
            {
                displaysOpen = 0;
            }
        }

        phMSleep(100);
    }
    
 error:
    rc = system.shutdown();
    phPRINT_RC(rc,NULL,"system.shutdown()");
    
    phDelete(display);
    phDelete(capture);
    phDelete(capture2);

    // free up the filename string allocation
    phFree(filename);

    phDelete(arg_parser);

    return phSUCCESS;
}

Copyright (C) 2002 - 2007

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

---