/* Copyright (C) 2012 Christian Lutz, Thorsten Engesser

*

* This file is part of motld

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

/*

This is a live demo invoking a webcam.

It makes use of OpenCV to capture the frames and highgui to display the output.

Use your mouse to draw bounding boxes for tracking.

There are some keys to customize which components are displayed:

D - dis/enable drawing of detections (green boxes)

P - dis/enable drawing of learned patches

T - dis/enable drawing of tracked points

L - dis/enable learning

S - save current classifier to CLASSIFIERFILENAME

O - load classifier from CLASSIFIERFILENAME (not implemented)

R - reset classifier (not implemented)

ESC - exit

*/

#include <stdlib.h>

#include <stdio.h>

#include <chrono>

#include <ctime>

#include <iostream>

#include <fstream>

#include <opencv/cv.h>

#include <opencv/highgui.h>

#include "motld/MultiObjectTLD.h"

#define LOADCLASSIFIERATSTART 0

#define CLASSIFIERFILENAME "test.moctld"

//uncomment if you have a high resolution camera and want to speed up tracking

#define FORCE_RESIZING

#define RESOLUTION_X 320

#define RESOLUTION_Y 240

#define MOUSE_MODE_MARKER 0

#define MOUSE_MODE_ADD_BOX 1

#define MOUSE_MODE_IDLE 2

#define MOUSE_MODE_ADD_GATE 4

// #define _GLIBCXX_USE_CXX11_ABI 0

cv::Mat curImage;

bool ivQuit = false;

int ivWidth, ivHeight;

ObjectBox mouseBox = {0,0,0,0,0,boost::circular_buffer<CvPoint>(CB_LEN)};

//int gate[2][2];

cv::Point gate[2];

int mouseMode = MOUSE_MODE_IDLE;

int drawMode = 255;

bool learningEnabled = true, save = false, load = false, reset = false, cascadeDetect = false, drawPath = true, drawGateEnabled = false;

std::string cascadePath = "../haarcascades/haarcascade_frontalface_alt.xml";

std::clock_t c_start;

std::clock_t c_end;

std::clock_t c_start1;

std::clock_t c_end1;

std::clock_t c_start2;

std::clock_t c_end2;

std::clock_t c_start3;

std::clock_t c_end3;

// auto t_start;

// auto t_end;

int Ndetections = 0;

typedef struct DebugInfo

} DebugInfo;

void Init(cv::VideoCapture& capture);

void* Run(cv::VideoCapture& capture);

void HandleInput(int interval = 1);

void MouseHandler(int event, int x, int y, int flags, void* param);

void BGR2RGB(Matrix& maRed, Matrix& maGreen, Matrix& maBlue);

void drawMouseBox();

void writeDebug(DebugInfo dbgInfo);

void drawGate();

int main(int argc, char *argv[])

}

void Init(cv::VideoCapture& capture)

}

void* Run(cv::VideoCapture& capture)

{

int size = ivWidth*ivHeight;

int count = 1;

DebugInfo dbgInfo;

cv::CascadeClassifier cascade;

std::vector<cv::Rect> detectedFaces;

std::vector<ObjectBox> trackBoxes;

ObjectBox detectBox;

// Initialize MultiObjectTLD

#if LOADCLASSIFIERATSTART

MultiObjectTLD p = MultiObjectTLD::loadClassifier((char*)CLASSIFIERFILENAME);

#else

MOTLDSettings settings(COLOR_MODE_RGB);

settings.useColor = false;

MultiObjectTLD p(ivWidth, ivHeight, settings);

#endif

if(cascadePath != "")

cascade.load( cascadePath );

Matrix maRed;

Matrix maGreen;

Matrix maBlue;

unsigned char img[size*3];

while(!ivQuit)

{

/*

if(reset){

p = *(new MultiObjectTLD(ivWidth, ivHeight, COLOR_MODE_RGB));

reset = false;

}

if(load){

p = MultiObjectTLD::loadClassifier(CLASSIFIERFILENAME);

load = false;

}

*/

#if TIMING

c_end = std::clock();

std::cout << "Total: " << (c_end-c_start) << std::endl;

c_start = std::clock();

#endif

// Grab an image

if(!capture.grab()){

std::cout << "error grabbing frame" << std::endl;

break;

}

cv::Mat frame;

capture.retrieve(frame);

frame.copyTo(curImage);

//BGR to RGB

// for(int j = 0; j<size; j++){

// img[j] = frame.at<cv::Vec3b>(j).val[2];

// img[j+size] = frame.at<cv::Vec3b>(j).val[1];

// img[j+2*size] = frame.at<cv::Vec3b>(j).val[0];

// }

#if TIMING

c_start1 = std::clock();

#endif

for(int i = 0; i < ivHeight; ++i){

for(int j = 0; j < ivWidth; ++j){

img[i*ivWidth+j] = curImage.at<cv::Vec3b>(i,j).val[2];

img[i*ivWidth+j+size] = curImage.at<cv::Vec3b>(i,j).val[1];

img[i*ivWidth+j+2*size] = curImage.at<cv::Vec3b>(i,j).val[0];

}

}

#if TIMING

c_end1 = std::clock();

std::cout << "time1: " << (c_end1-c_start1) << std::endl;

#endif

// for(int i = 0; i < ivHeight; ++i){

// for(int j = 0; j < ivWidth; ++j){

// curImage.at<cv::Vec3b>(i,j).val[2] = 0;

// curImage.at<cv::Vec3b>(i,j).val[1] = 0;

// curImage.at<cv::Vec3b>(i,j).val[0] = 0;

// }

// }

// cv::imshow("MOCTLD", curImage);

#if TIMING

c_start2 = std::clock();

#endif

// Process it with motld

p.processFrame(img);

#if TIMING

c_end2 = std::clock();

std::cout << "time2: " << (c_end2-c_start2) << std::endl;

#endif

// Add new box

if(mouseMode == MOUSE_MODE_ADD_BOX){

p.addObject(mouseBox);

mouseMode = MOUSE_MODE_IDLE;

}

if(mouseMode == MOUSE_MODE_ADD_GATE){

p.addGate(gate);

mouseMode = MOUSE_MODE_IDLE;

}

if(((count%20)==0) && cascadeDetect)

{

cascade.detectMultiScale( frame, detectedFaces,

1.1, 2, 0

//|CASCADE_FIND_BIGGEST_OBJECT

//|CASCADE_DO_ROUGH_SEARCH

|cv::CASCADE_SCALE_IMAGE,

cv::Size(30, 30) );

Ndetections = detectedFaces.size();

for( std::vector<cv::Rect>::const_iterator r = detectedFaces.begin(); r != detectedFaces.end(); r++ )

{

detectBox.x = r->x;

detectBox.y = r->y;

detectBox.width = r->width;

detectBox.height = r->height;

if(p.isNewObject(detectBox))

p.addObject(detectBox);

}

//printf("size detectedFaces: %i\n", detectedFaces.size());

}

count++;

// Display result

HandleInput();

p.getDebugImage(img, maRed, maGreen, maBlue, drawMode);

#if TIMING

c_start3 = std::clock();

#endif

BGR2RGB(maRed, maGreen, maBlue);

#if TIMING

c_end3 = std::clock();

std::cout << "time3: " << (c_end3-c_start3) << std::endl;

#endif

drawGate();

drawMouseBox();

dbgInfo.NObjects = p.getObjectTotal();

dbgInfo.side0Cnt = p.getSide0Cnt();

dbgInfo.side1Cnt = p.getSide1Cnt();

writeDebug(dbgInfo);

cv::imshow("MOCTLD", curImage);

p.enableLearning(learningEnabled);

if(save){

p.saveClassifier((char*)CLASSIFIERFILENAME);

save = false;

}

}

//delete[] img;

capture.release();

return 0;

}

void HandleInput(int interval)

}

void MouseHandler(int event, int x, int y, int flags, void* param)

}

void BGR2RGB(Matrix& maRed, Matrix& maGreen, Matrix& maBlue)

}

void drawGate()

}

void writeDebug(DebugInfo dbgInfo)

}

void drawMouseBox()

}