#include "WatchPoint.h"
#include "Image.h"
#include "cvUtils.h"
int WatchPoint::total_watch_point = 0;
Timer *WatchPoint::timer = NULL;
WatchPoint::WatchPoint(IplImage *_image,CvPoint p1,CvPoint p2) : Box(p1,p2)
{
counter = 0;
motion = false;
improvement_has_been_made = false;
improvement_level = 1;
tolerance = 5;
if(!_image)
{
cout<<"Image to WatchPoint constructor null"<<endl;
return;
}
ipl_initial_image = cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,3);
cvCopy(_image,ipl_initial_image);
current_watch_point = total_watch_point;
total_watch_point++;
stringstream ss;
ss<<"Watch point "<<current_watch_point;
window_name = ss.str();
cvNamedWindow(window_name.c_str(),CV_WINDOW_NORMAL);
cvMoveWindow(window_name.c_str(),100,100);
cvResizeWindow(window_name.c_str(),640,480);
on_motion_image = NULL;
if(!timer)
{
timer = new Timer();
timer->start();
}
spawn_sec = timer->get_seconds();
fliptime = 30;
}
WatchPoint::~WatchPoint()
{
/*total_watch_point--;
if(total_watch_point == 0)
{
timer->stop();
delete timer;
}*/
}
void WatchPoint::flip_image(IplImage *img)
{
ipl_current_image = img;
}
void WatchPoint::set_tolerance(float t)
{
tolerance = t;
}
void WatchPoint::set_motion_image(IplImage *img)
{
on_motion_image = img;
}
void WatchPoint::set_fliptime(int time)
{
fliptime = time;
}
void WatchPoint::createRgbImage(RgbImage &initial_image,RgbImage ¤t_image)
{
CvSize size;
size.height = (_p1.y < _p2.y ? _p2.y - _p1.y : _p1.y - _p2.y);
size.width = (_p1.x < _p2.x ? _p2.x - _p1.x : _p1.x - _p2.x);
CvPoint start;
start.x = (_p1.x < _p2.x ? _p1.x : _p2.x);
start.y = (_p1.y < _p2.y ? _p1.y : _p2.y);
for(int x = start.x; x < start.x + size.width; x++)
for(int y = start.y; y < start.y + size.height; y++)
{
if(x < 0 || x > 640 || y < 0 || y > 480)continue;
initial_image[y-start.y][x-start.x] = RgbImage(ipl_initial_image)[y][x];
current_image[y-start.y][x-start.x] = RgbImage(ipl_current_image)[y][x];
}
if(improvement_has_been_made)
{
improve_quality(true);
}
}
bool WatchPoint::movement()
{
int pix_num = 0;
int tot_pix = 0;
IplImage *temp_image1,*temp_image2;
CvSize size;
size.height = (_p1.y < _p2.y ? _p2.y - _p1.y : _p1.y - _p2.y);
size.width = (_p1.x < _p2.x ? _p2.x - _p1.x : _p1.x - _p2.x);
CvPoint start;
start.x = (_p1.x < _p2.x ? _p1.x : _p2.x);
start.y = (_p1.y < _p2.y ? _p1.y : _p2.y);
if(improvement_has_been_made)
{
size.height *= 2;
size.width *= 2;
start.x *= 2;
start.y *= 2;
}
temp_image1 = cvCreateImage(size,IPL_DEPTH_8U,3);
temp_image2 = cvCreateImage(size,IPL_DEPTH_8U,3);
RgbImage initial_image(temp_image1);
RgbImage current_image(temp_image2);
createRgbImage(initial_image,current_image);
for(int x = start.x; x < start.x + size.width; x++)
for(int y = start.y; y < start.y + size.height; y++)
{
if(!improvement_has_been_made)
{
if(x < 0 || x > 640 || y < 0 || y > 480)continue;
}
else
{
if(x < 0 || x > 640*2 || y < 0 || y > 480*2)continue;
}
tot_pix++;
if((current_image[y-start.y][x-start.x].r >= initial_image[y-start.y][x-start.x].r-tolerance && current_image[y-start.y][x-start.x].r <= initial_image[y-start.y][x-start.x].r+tolerance) ||
(current_image[y-start.y][x-start.x].g >= initial_image[y-start.y][x-start.x].g-tolerance && current_image[y-start.y][x-start.x].g <= initial_image[y-start.y][x-start.x].g+tolerance) ||
(current_image[y-start.y][x-start.x].b >= initial_image[y-start.y][x-start.x].b-tolerance && current_image[y-start.y][x-start.x].b <= initial_image[y-start.y][x-start.x].b+tolerance))
{
}
else
{
pix_num++;
}
}
if(pix_num >= (10*tot_pix)/100)
{
motion = true;
}
else
{
motion = false;
}
draw(initial_image,current_image,on_motion_image);
//cvShowManyImages(window_name.c_str(),2,initial_image,current_image);
cvReleaseImage(&temp_image1);
cvReleaseImage(&temp_image2);
int sec = timer->get_seconds();
if(timer->delta_time(sec,spawn_sec) > fliptime)
{
spawn_sec = timer->get_seconds();
if(!motion)
{
cout<<"Updating image on watchpoint "<<current_watch_point<<endl;
cvCopy(ipl_current_image,ipl_initial_image);
}
}
return motion;
}
void WatchPoint::draw(IplImage *img1,IplImage *img2,IplImage *img3)
{
if(!motion)
cvShowManyImages(window_name.c_str(),2,img1,img2);
else
cvShowManyImages(window_name.c_str(),3,img1,img2,img3);
}
void WatchPoint::improve_quality(bool called_by_movement)
{
CvSize size;
size.width = ipl_current_image->width*2;
size.height = ipl_current_image->height*2;
RgbImage initial_image(ipl_initial_image);
RgbImage current_image(ipl_current_image);
RgbImage new_initial_image = cvCreateImage(size,IPL_DEPTH_8U,3);
RgbImage new_current_image = cvCreateImage(size,IPL_DEPTH_8U,3);
int i = 0,j = 0;
cout<<"making new images"<<endl;
for(int x = 0;x < size.width-2;x += 2)
{
for(int y = 0;y < size.height;y++)
{
new_current_image[y][x] = current_image[j][i];
new_current_image[y][x+1] = current_image[j][i];
new_initial_image[y][x] = initial_image[j][i];
new_initial_image[y][x+1] = initial_image[j][i];
j = y/2;
}
i = x/2;
}
cout<<"made"<<endl;
if(!called_by_movement)
{
cvReleaseImage(&ipl_initial_image);
ipl_initial_image = cvCreateImage(size,IPL_DEPTH_8U,3);
cvCopy(new_initial_image,ipl_initial_image);
}
ipl_current_image = new_current_image;
cvReleaseImage((IplImage**)&new_initial_image);
cvReleaseImage((IplImage**)&new_current_image);
improvement_has_been_made = true;
//improvement_level++;
}