The Machine Perception Toolbox

[Introduction]- [News]- [Download]- [Screenshots]- [Manual (pdf)]- [Forums]- [API Reference]- [Repository ]

 

Apps/unix/colortracker/main.cc

Go to the documentation of this file.

/*
 * main.cc
 *  
 * Copyright (c) 2002 Machine Perception Laboratory 
 * University of California San Diego.
 *
 *
 * Authors: Ian Fasel, Bret Fortenberry
 * Fixes:
 * 
 * Please do not distribute source or binaries derived from the source
 * without explicit permission from UCSD's Machine Perception Laboratory
 * http://mplab.ucsd.edu. Library and code may be used for non-commercial
 * research, evaluations, or demonstrations. Please provide appropriate
 * acknowledgments.
 *
 */

#include <iostream.h>
#include <iomanip.h>
#include "MPColorTracker.h"
#include <list>
#include <Magick++.h>
extern "C" {
#include <math.h>
#include <time.h>
#include <string.h>
#include <sys/times.h>
#include <stdlib.h>
}

#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#endif

using namespace Magick;

class SingleShotColorSearch : public MPColorTracker {
public:
  SingleShotColorSearch(char * filename): m_image(filename){
        try{
          //Image image(filename);
          //image.display();
          m_pixels = new RImage<RGBTRIPLE>(m_image.columns(), m_image.rows());
          m_image.write(0,0, m_image.columns(), m_image.rows(), "RGB", CharPixel, m_pixels->array);
        } catch ( ErrorFileOpen &error ) {
          cerr << "Error opening file: "
          <<  filename
          << ". ImageMagick said: "
          << error.what()
          << endl;
          return;
        }
        
        cout << "Image: " << filename
                << " - " << m_pixels->width
                << "x" << m_pixels->height
                << endl;

        InitStreaming();
  }
  
  void Search(int frameCount){
                PutImage(m_pixels->array, m_pixels->width, m_pixels->height, (long)frameCount);
                MPIUpdate();
                m_results = DoSearch();
        }

  void displayResults(){
                
                /*if(m_results) {
                        Image im2(m_pixels->width, m_pixels->height, "RGB", CharPixel, m_pixels->array);
        im2.display();
                }*/
                        
                FaceBoxList faces;
                TSquare<double> box;
    cout << ".";
    if(m_results){
      //cout << endl << "Just got a Detect " << GetElapsedTime() << " ms ago" << endl;
      GetColorBox(box);
      cout << "Bounding Box is [" << box.x << "," << box.y << "; " << box.x+box.size << "," << box.y+box.size << "]" << endl;
        Image im2(m_pixels->width, m_pixels->height, "RGB", CharPixel, m_pixels->array);
                        im2.strokeColor("white");
      im2.strokeWidth(1);
      im2.fillColor("none" );
      im2.draw( DrawableRectangle(box.x, box.y, box.x+box.size, box.y+box.size) );
                        GetLastFaces(faces);
      if(faces.size() != 0) {
        im2.strokeColor("red");
        im2.strokeWidth(1);
        im2.fillColor("none" );

        while(!faces.empty( ))
        {
          Square face = faces.front();  
          faces.pop_front();

          im2.draw( DrawableRectangle(face.x, face.y, 
                face.x + face.size, face.y + face.size));

        }
                        }                                               
      im2.display();
    }
  }

  ~SingleShotColorSearch(){ delete m_pixels; EndStreaming();};

private:
  RImage<RGBTRIPLE> *m_pixels;
  Image m_image;
        int m_results;
};
#define MAX_NUM_IMAGES 20
struct arguments {
  char *args[MAX_NUM_IMAGES];   // up to xx images can be processed at once
};

int main (int argc, char **argv)
{  
        int i;
  struct arguments arguments;
  for(i = 0; i<MAX_NUM_IMAGES; i++)
    arguments.args[i] = 0;
    
  // get values from command line
  if(argc==2) {
        arguments.args[0] = (char *)malloc(256 * sizeof(char));
    strcpy(arguments.args[0],argv[1]);
        }
  else{
                for (i = 0; i < argc-1 && i < MAX_NUM_IMAGES; i++) {
                        arguments.args[i] = (char *)malloc(256 * sizeof(char));
        strcpy(arguments.args[i],argv[i+1]);
                }
  }

        int im = 0;
        while (arguments.args[im] && im < MAX_NUM_IMAGES) {
        cout << "instantiate SingleShotColorSearch for image " << arguments.args[im] << endl;
  
        SingleShotColorSearch s(arguments.args[im]);

        s.Search(0);
        struct tms tms_buf;
        clock_t start_time;
        double elapsed_time;
        // start the clock
    start_time = times(&tms_buf);

        // SEARCH 100 times!
        int NSearch = 20;
                int showResults = 0;
        for(int i = 1; i< NSearch; i++){
        s.Search(i);
                        if (showResults > 5) {
                s.displayResults();
                                showResults = 0;
                        }
                        cout << ".";
                        showResults++;
        }
        cout << endl;
        elapsed_time = (double)(times(&tms_buf) - start_time) / 1000;
        cout << endl << NSearch/elapsed_time << " Frames per second" << endl;
        // stop the clock  
        printf("\tThe search took %g seconds. \n", elapsed_time);
                im++;
        }
  
}

---