// private method which sends the created image to the projector
static void drawToProjector()
{
// Display Image
IplImage* img;
cvNamedWindow( "Projection", CV_WINDOW_NORMAL );
cvSetWindowProperty("Projection", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
img = cvLoadImage( "arrow_test.jpg", CV_LOAD_IMAGE_UNCHANGED );
cvShowImage("Projection", img);
//cvWaitKey(150);
}
// Timer Callback - uiImage_timer
//# Start uiImage_timer_operation Marker
void user_input_imager::uiImage_timer_operation(const NAMESPACE::TimerEvent& event)
{
#ifdef USE_ROSMOD
comp_queue.ROSMOD_LOGGER->log("DEBUG", "Entering user_input_imager::uiImage_timer_operation");
#endif
// Business Logic for uiImage_timer_operation
agse_package::captureImage arg;
Mat camera_feed;
if (this->captureImage_client.call(arg)) {
ROS_INFO("Capture Image Client Call Successful; Height: %d, Width: %d ", arg.response.height, arg.response.width);
camera_feed = Mat(arg.response.height,
arg.response.width,
CV_8UC3,
arg.response.imgVector.data());
// Mat to IplImage *
IplImage ipltemp = camera_feed;
cvCopy(&ipltemp, processed_image);
cvResize(processed_image, Mode_1);
cvShowImage( "UIP", Mode_1);
cvNamedWindow( "UIP", 1 );
cvSetWindowProperty("UIP", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
}
key = 0;
key = cvWaitKey(1);
// RAW CAMERA FEED
if (key == 65361) {
ROS_INFO("Mode 1 Activated");
cvShowImage( "UIP", Mode_1);
}
/*
// SAMPLE PROCESSED IMAGE
else if (key == 65363) {
ROS_INFO("Mode 2 Activated");
// Mat to IplImage *
processed_image = cvCreateImage(cvSize(sample_rawImage.cols, sample_rawImage.rows), 8, 3);
IplImage ipltemp = sample_rawImage;
cvCopy(&ipltemp, processed_image);
cvResize(processed_image, Mode_2);
cvShowImage( "UIP", Mode_2);
cvNamedWindow( "UIP", 1 );
cvSetWindowProperty("UIP", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
key = 0;
}
else if (key == 65362) {
ROS_INFO("Mode 3 Activated");
// Mat to IplImage *
processed_image = cvCreateImage(cvSize(pb_rawImage.cols, pb_rawImage.rows), 8, 3);
IplImage ipltemp = pb_rawImage;
cvCopy(&ipltemp, processed_image);
cvResize(processed_image, Mode_3);
cvShowImage( "UIP", Mode_3);
cvNamedWindow( "UIP", 1 );
cvSetWindowProperty("UIP", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
key = 0;
}
else if (key == 65364) {
ROS_INFO("Mode 4 Activated");
// Mat to IplImage *
processed_image = cvCreateImage(cvSize(pb_gsImage.cols, pb_gsImage.rows), 8, 3);
IplImage ipltemp = pb_gsImage;
cvCopy(&ipltemp, processed_image);
cvResize(processed_image, Mode_4);
cvShowImage( "UIP", Mode_4);
cvNamedWindow( "UIP", 1 );
cvSetWindowProperty("UIP", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
key = 0;
}
else if (key == 13) {
ROS_INFO("Mode 5 Activated");
cvShowManyImages("UIP", 4, top_left, top_right, bottom_left, bottom_right);
key = 0;
}
*/
else {
ROS_INFO("No Mode Activated");
cvShowImage( "UIP", Mode_1);
}
#ifdef USE_ROSMOD
comp_queue.ROSMOD_LOGGER->log("DEBUG", "Exiting user_input_imager::uiImage_timer_operation");
#endif
}
void cv::setWindowProperty(const std::string& winname, int prop_id, double prop_value)
{
cvSetWindowProperty( winname.c_str(), prop_id, prop_value);
}
/*******************************************************************************************************************//**
* @brief Program entry point
*
* Handles image processing and display of annotated results
*
* @param[in] argc command line argument count
* @param[in] argv command line argument vector
* @returnS return status
* @author Christopher D. McMurrough
**********************************************************************************************************************/
int main(int argc, char** argv)
{
// validate and parse the command line arguments
int cameraIndex = 0;
bool displayMode = true;
bool flipDisplay = false;
if(argc != NUM_COMNMAND_LINE_ARGUMENTS + 1)
{
std::printf("USAGE: <camera_index> <display_mode>\n");
std::printf("Running with default parameters... \n");
}
else
{
cameraIndex = atoi(argv[1]);
displayMode = atoi(argv[2]) > 0;
flipDisplay = atoi(argv[2]) == 2;
}
// initialize the eye camera video capture
// cv::VideoCapture occulography(cameraIndex);
cv::VideoCapture occulography("pupil_test.mp4");
if(!occulography.isOpened())
{
std::printf("Unable to initialize camera %u! \n", cameraIndex);
return 0;
}
// THESE ARE FOR GETTING THE PROPERTIES OF THE CAMERA IF APPLICABLE
std::cout<<"width "<< occulography.get(CV_CAP_PROP_FRAME_WIDTH) << std::endl;
std::cout<<"height "<< occulography.get(CV_CAP_PROP_FRAME_WIDTH) << std::endl;
// std::cout<<"format "<< occulography.get(CV_CAP_PROP_FORMAT) << std::endl;
// std::cout<<"fps "<< occulography.get(CV_CAP_PROP_FPS) << std::endl;
// std::cout<<"brightness "<< occulography.get(CV_CAP_PROP_BRIGHTNESS) << std::endl;
// std::cout<<"contrast "<< occulography.get(CV_CAP_PROP_CONTRAST) << std::endl;
// std::cout<<"saturation "<< occulography.get(CV_CAP_PROP_SATURATION) << std::endl;
// std::cout<<"hue "<< occulography.get(CV_CAP_PROP_HUE) << std::endl;
// std::cout<<"gain "<< occulography.get(CV_CAP_PROP_GAIN) << std::endl;
// std::cout<<"exposure "<< occulography.get(CV_CAP_PROP_EXPOSURE) << std::endl;
// std::cout<<"convert rgb "<< occulography.get(CV_CAP_PROP_CONVERT_RGB) << std::endl;
// THESE ARE FOR SETTING THE PROPERTIES OF THE CAMERA IF APPLICABLE
occulography.set(CV_CAP_PROP_FRAME_WIDTH, CAMERA_FRAME_WIDTH);
occulography.set(CV_CAP_PROP_FRAME_HEIGHT, CAMERA_FRAME_HEIGHT);
// occulography.set(CV_CAP_PROP_FORMAT, CAMERA_FORMAT);
// occulography.set(CV_CAP_PROP_FPS, CAMERA_FPS);
occulography.set(CV_CAP_PROP_BRIGHTNESS, CAMERA_BRIGHTNESS);
occulography.set(CV_CAP_PROP_CONTRAST, CAMERA_CONTRAST);
occulography.set(CV_CAP_PROP_SATURATION, CAMERA_SATURATION);
// occulography.set(CV_CAP_PROP_HUE, CAMERA_HUE);
// occulography.set(CV_CAP_PROP_GAIN, CAMERA_GAIN);
// occulography.set(CV_CAP_PROP_EXPOSURE, CAMERA_EXPOSURE);
// occulography.set(CV_CAP_PROP_CONVERT_RGB, CAMERA_CONVERT_RGB);
// intialize the display window if necessary
if(displayMode)
{
cvNamedWindow("eyeImage", CV_WINDOW_NORMAL);
cvSetWindowProperty("eyeImage", CV_WND_PROP_FULLSCREEN, CV_WINDOW_NORMAL);
cvSetWindowProperty("eyeImage", CV_WND_PROP_AUTOSIZE, CV_WINDOW_NORMAL);
cvSetWindowProperty("eyeImage", CV_WND_PROP_ASPECTRATIO, CV_WINDOW_KEEPRATIO);
}
// create the pupil tracking object
PupilTracker tracker;
tracker.setDisplay(displayMode);
// store the frame data
cv::Mat eyeImage;
//struct PupilData result;
bool trackingSuccess = false;
// store the time between frames
int frameStartTicks, frameEndTicks, processStartTicks, processEndTicks;
float processTime, totalTime;
// process data until program termination
bool isRunning = true;
while(isRunning)
{
// start the timer
frameStartTicks = clock();
// attempt to acquire an image frame
if(occulography.read(eyeImage))
{
// process the image frame
processStartTicks = clock();
trackingSuccess = tracker.findPupil(eyeImage);
processEndTicks = clock();
processTime = ((float)(processEndTicks - processStartTicks)) / CLOCKS_PER_SEC;
// warn on tracking failure
if(!trackingSuccess)
{
std::cout<< "Unable to locate pupil!" << std::endl;
}
// update the display
if(displayMode)
{
cv::Mat displayImage(eyeImage);
// annotate the image if tracking was successful
if(trackingSuccess)
{
// draw the pupil center and boundary
//cvx::cross(displayImage, result.pupil_center, 5, COLOR_RED);
cv::ellipse(displayImage, tracker.getEllipseRectangle(), COLOR_BLUE, 2);
// shade the pupil area
cv::Mat annotation(eyeImage.rows, eyeImage.cols, CV_8UC3, 0.0);
cv::RotatedRect my_rotated_rect_property;
my_rotated_rect_property = tracker.getEllipseRectangle();
cv::Point2f Center;
Center = my_rotated_rect_property.center;
double x1, y1, x2, y2;
x1 = Center.x - 40; y1 = Center.y - 40; x2 = Center.x + 40; y2 = Center.y + 40;
// Draw a square/rectangle around the ellipse based off of the center
// This is for the rectangle
cv::Point x1y1 = cv::Point(x1, y1);
cv::Point x2y2 = cv::Point(x2, y2);
// This is for the lines around the rectangle
cv::Point x1y2 = cv::Point(x1, y2);
cv::Point x2y1 = cv::Point(x2, y1);
// here is the math to draw the lines
// for the horizontal line
cv::Point horizontal_start = cv::Point(x1-20, (y1+y2)/2);
cv::Point horizontal_end = cv::Point(x1+100, (y1+y2)/2);
// for the vertical line
cv::Point vertical_start = cv::Point((x1+x2)/2, y1-20);
cv::Point vertical_end = cv::Point((x1+x2)/2, y1+100);
// done with the lines
cv::ellipse(annotation, tracker.getEllipseRectangle(), COLOR_PURPLE, -1);
const double alpha = 0.7;
cv::addWeighted(displayImage, alpha, annotation, 1.0 - alpha, 0.0, displayImage);
// The centre is actually a tiny circle (neat trick)
cv::circle(displayImage, Center, 2.5, COLOR_RED, 2, 4);
// The bounding rectangle based off of the centre
cv::rectangle(displayImage, x1y1, x2y2, COLOR_GREEN, 1);
// The lines across the rectangle
cv::line(displayImage, horizontal_start, horizontal_end, COLOR_GREEN, 1);
cv::line(displayImage, vertical_start, vertical_end, COLOR_GREEN, 1);
int fontFace = cv::FONT_HERSHEY_PLAIN;
double scale = 1.5;
int thickness = 1;
int baseline = 0;
char pupil_center[25];
char ellipse_size[25];
char pupil_angle[25];
sprintf(pupil_center, "Pupil Center: (%.2lf, %.2lf)", Center.x, Center.y);
sprintf(ellipse_size, "Pupil Size: (%.2lf, %.2lf)", my_rotated_rect_property.size.width,my_rotated_rect_property.size.height);
sprintf(pupil_angle, "Pupil Angle: (%.2lf)", my_rotated_rect_property.angle);
cv::putText(displayImage, "OptiFind :: Real Time Eye Tracker", cv::Point(40, 40), fontFace, 1, COLOR_WHITE, thickness, 8);
cv::putText(displayImage, pupil_center, cv::Point(350, 315), fontFace, 1, COLOR_WHITE, thickness, 8);
cv::putText(displayImage, ellipse_size, cv::Point(350, 330), fontFace, 1, COLOR_WHITE, thickness, 8);
cv::putText(displayImage, pupil_angle, cv::Point(350, 345), fontFace, 1, COLOR_WHITE, thickness, 8);
}
if(flipDisplay)
{
// annotate the image
cv::Mat displayFlipped;
cv::flip(displayImage, displayFlipped, 1);
cv::imshow("eyeImage", displayFlipped);
// display the annotated image
isRunning = cv::waitKey(1) != 'q';
char key = cvWaitKey(10);
// If the user pressed 'ESC' Key then break the loop and exit the program
if (key == 27)
break;
displayFlipped.release();
}
else
{
// display the image
cv::imshow("eyeImage", displayImage);
//char key1 = cvWaitKey(0);
isRunning = cv::waitKey(1) != 'q';
char key = cvWaitKey(10);
// If the user pressed 'ESC' Key then break the loop and exit the program
if (key == 27)
break;
}
// release display image
displayImage.release();
}
}
else
{
std::cout<<"WARNING: Unable to capture image from source!\n"<<std::endl;
std::cout<< "Reading the video from frame 0 again!" << std::endl;
occulography.set(CV_CAP_PROP_POS_FRAMES, 0);
continue;
}
// stop the timer and print the elapsed time
// frameEndTicks = clock();
// totalTime = ((float)(frameEndTicks - frameStartTicks)) / CLOCKS_PER_SEC;
// std::printf("Processing time (pupil, total) (result x,y): %.4f %.4f - %.2f %.2f\n", processTime, totalTime, tracker.getEllipseRectangle().center.x, tracker.getEllipseRectangle().center.y);
//std::cout<< "Processing time (pupil)"<< processTime << "total time" << totalTime << "pupil center" << tracker.getEllipseRectangle().center << std::endl;
}
// release the video source before exiting
occulography.release();
}
void demo(char *cfgfile, char *weightfile, float thresh, int cam_index, const char *filename, char **names, int classes, int delay, char *prefix, int avg_frames, float hier, int w, int h, int frames, int fullscreen)
{
demo_delay = delay;
demo_frame = avg_frames;
predictions = calloc(demo_frame, sizeof(float*));
image **alphabet = load_alphabet();
demo_names = names;
demo_alphabet = alphabet;
demo_classes = classes;
demo_thresh = thresh;
demo_hier = hier;
printf("Demo\n");
net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
set_batch_network(&net, 1);
pthread_t detect_thread;
pthread_t fetch_thread;
srand(2222222);
if(filename){
printf("video file: %s\n", filename);
cap = cvCaptureFromFile(filename);
}else{
cap = cvCaptureFromCAM(cam_index);
if(w){
cvSetCaptureProperty(cap, CV_CAP_PROP_FRAME_WIDTH, w);
}
if(h){
cvSetCaptureProperty(cap, CV_CAP_PROP_FRAME_HEIGHT, h);
}
if(frames){
cvSetCaptureProperty(cap, CV_CAP_PROP_FPS, frames);
}
}
if(!cap) error("Couldn't connect to webcam.\n");
layer l = net.layers[net.n-1];
demo_detections = l.n*l.w*l.h;
int j;
avg = (float *) calloc(l.outputs, sizeof(float));
last_avg = (float *) calloc(l.outputs, sizeof(float));
last_avg2 = (float *) calloc(l.outputs, sizeof(float));
for(j = 0; j < demo_frame; ++j) predictions[j] = (float *) calloc(l.outputs, sizeof(float));
boxes = (box *)calloc(l.w*l.h*l.n, sizeof(box));
probs = (float **)calloc(l.w*l.h*l.n, sizeof(float *));
for(j = 0; j < l.w*l.h*l.n; ++j) probs[j] = (float *)calloc(l.classes+1, sizeof(float));
buff[0] = get_image_from_stream(cap);
buff[1] = copy_image(buff[0]);
buff[2] = copy_image(buff[0]);
buff_letter[0] = letterbox_image(buff[0], net.w, net.h);
buff_letter[1] = letterbox_image(buff[0], net.w, net.h);
buff_letter[2] = letterbox_image(buff[0], net.w, net.h);
ipl = cvCreateImage(cvSize(buff[0].w,buff[0].h), IPL_DEPTH_8U, buff[0].c);
int count = 0;
if(!prefix){
cvNamedWindow("Demo", CV_WINDOW_NORMAL);
if(fullscreen){
cvSetWindowProperty("Demo", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
} else {
cvMoveWindow("Demo", 0, 0);
cvResizeWindow("Demo", 1352, 1013);
}
}
demo_time = get_wall_time();
while(!demo_done){
buff_index = (buff_index + 1) %3;
if(pthread_create(&fetch_thread, 0, fetch_in_thread, 0)) error("Thread creation failed");
if(pthread_create(&detect_thread, 0, detect_in_thread, 0)) error("Thread creation failed");
if(!prefix){
if(count % (demo_delay+1) == 0){
fps = 1./(get_wall_time() - demo_time);
demo_time = get_wall_time();
float *swap = last_avg;
last_avg = last_avg2;
last_avg2 = swap;
memcpy(last_avg, avg, l.outputs*sizeof(float));
}
display_in_thread(0);
}else{
char name[256];
sprintf(name, "%s_%08d", prefix, count);
save_image(buff[(buff_index + 1)%3], name);
}
pthread_join(fetch_thread, 0);
pthread_join(detect_thread, 0);
++count;
}
}
void graphicalJoystick(int joy_idx, SDL_Joystick *joy, FILE* fichierKernel){
const char* original = "FAJA" ;
char key ;
CvCapture *capture ;
IplImage* cap ;
IplImage* cap_resize ;
capture = cvCreateCameraCapture(CV_CAP_ANY);
if(!capture){
printf("! Error while capturing from camera !\n");
exit(1);
}
CvFont cross,faja;
cvInitFont(&cross,CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, 1,1,0,1,1);
cvInitFont(&faja,CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, 1,1,0,2,3);
cap = cvQueryFrame(capture);
cap_resize = cvCreateImage(cvSize(1366,768), cap->depth, cap->nChannels);
cvNamedWindow(original, CV_WINDOW_NORMAL);
cvMoveWindow(original, 0, 0);
cvSetWindowProperty(original, CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
int num_axes = SDL_JoystickNumAxes(joy) -1;
int num_buttons = SDL_JoystickNumButtons(joy);
int num_hats = SDL_JoystickNumHats(joy);
FILE* f = NULL;
f=fopen("/dev/servoblaster", "w");
if (f == NULL)
exit(1);
int quit = 0;
SDL_Event event;
while(!quit)
{
SDL_Delay(10);
bool something_new = false;
while (SDL_PollEvent(&event)) {
cap = cvQueryFrame(capture);
cvPutText (cap,"+",cvPoint(cap->width/2,cap->height/2), &cross, cvScalar(0,255,0,0));
cvPutText (cap,"FAJA - Mode manuel",cvPoint(10,30), &faja, cvScalar(255,0,0,0));
cvResize(cap, cap_resize, CV_INTER_LINEAR);
cvShowImage(original, cap_resize);
something_new = true;
switch(event.type)
{
case SDL_JOYAXISMOTION:
assert(event.jaxis.axis < num_axes+1);
axes[event.jaxis.axis] = event.jaxis.value;
break;
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
assert(event.jbutton.button < num_buttons);
buttons[event.jbutton.button] = event.jbutton.state;
break;
case SDL_JOYHATMOTION:
assert(event.jhat.hat < num_hats);
hats[event.jhat.hat] = event.jhat.value;
break;
case SDL_QUIT:
quit = 1;
printf("Recieved interrupt, exiting\n");
break;
default:
fprintf(stderr, "Error: Unhandled event type: %d\n", event.type);
break;
}
}
if (something_new)
{
//clear();
res = 50+(((-1 * (axes[0])+32768)*190)/65535);
fprintf(f,"1=%i\n",(int)res);
printf("echo 1=%i > /dev/servoblaster\n", (int) res);
fflush(f);
res = 50+(((-1 * (axes[1])+32768)*190)/65535);
fprintf(f,"0=%i\n", (int)res);
printf("echo 0=%i > /dev/servoblaster\n", (int) res);
fflush(f);
}
}
} // while
int main(int argc, char **argv) {
cv::Mat frame;
cv::Mat orig;
cv::Mat fore;
time_t camAdaptationStartTime = time(NULL);
bool camAdapted = false;
std::vector <std::vector<cv::Point>> contours;
EnableCameraAutoAdjust(GetVideoNum(argc, argv));
cv::VideoCapture cap(GetVideoNum(argc, argv));
cv::Ptr<cv::BackgroundSubtractor> bgsub;
cvNamedWindow("Contador de Votos", CV_WINDOW_NORMAL);
cvSetWindowProperty("Contador de Votos", CV_WND_PROP_AUTOSIZE, CV_WINDOW_AUTOSIZE);
ScreenSize ss = GetScreenSize();
cvResizeWindow("Contador de Votos", ss.width, ss.height);
cap >> frame;
const int squareSize = 150;
const int squareMargin = 10;
cv::Point leftOrigin(squareMargin, squareMargin);
cv::Point rightOrigin(frame.size().width - squareSize - squareMargin, squareMargin);
InteractiveObject left(cv::Rect(leftOrigin.x, leftOrigin.y, squareSize, squareSize));
InteractiveObject right(cv::Rect(rightOrigin.x, rightOrigin.y, squareSize, squareSize));
cv::Mat yesc = cv::imread("SWC.png", CV_LOAD_IMAGE_COLOR);
cv::resize(yesc, yesc, cv::Size(squareSize, squareSize));
cv::Mat yesbw = cv::imread("vader.jpg", CV_LOAD_IMAGE_COLOR);
cv::resize(yesbw, yesbw, cv::Size(squareSize, squareSize));
cv::Mat noc = cv::imread("STC.png", CV_LOAD_IMAGE_COLOR);
cv::resize(noc, noc, cv::Size(squareSize, squareSize));
cv::Mat nobw = cv::imread("spock.png", CV_LOAD_IMAGE_COLOR);
cv::resize(nobw, nobw, cv::Size(squareSize, squareSize));
cv::Mat vote = cv::imread("vote.png", CV_LOAD_IMAGE_COLOR);
cv::resize(vote,vote, cv::Size(squareSize, squareSize));
// VideoCapture video("Game.mp4");
while(true) {
cap >> frame;
cv::flip(frame, frame, 1);
frame.copyTo(orig);
/*Mat game;
video >> game;
cv::resize(game,game, cv::Size(squareSize, squareSize));
game.copyTo(orig(cv::Rect((rightOrigin.x + leftOrigin.x)/2, (rightOrigin.y + leftOrigin.y)/2 + 2*game.size().height , game.size().width, game.size().height)));*/
if (camAdapted) {
cv::blur(frame, frame, cv::Size(3, 3));
cv::blur(frame, frame, cv::Size(5, 5));
cv::erode( frame, frame, cv::Mat());
cv::erode( frame, frame, cv::Mat());
cv::Mat cropped;
cv::Rect roi(0, 0, frame.size().width, 150);
frame(roi).copyTo(cropped);
cv::Mat dst;
bgsub->apply(cropped, dst, 0.0001);
cv::threshold(dst, dst, 230, 255, CV_THRESH_BINARY);
cv::findContours(dst , contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
std::vector<std::vector<cv::Point> >hull( contours.size() );
for( int i = 0; i < contours.size(); i++ )
{ cv::convexHull( cv::Mat(contours[i]), hull[i], false ); }
int counter = 0;
bool leftActive = false;
bool rightActive = false;
for( int i = 0; i< contours.size(); i++ )
{
cv::Scalar color( 255, 0, 255);
if (cv::contourArea(hull[i]) > 600) {
cv::drawContours( orig, hull, i, color, 1, 8, std::vector<cv::Vec4i>(), 0, cv::Point() );
counter++;
}
}
left.ProcessHulls(hull);
right.ProcessHulls(hull);
std::string text = "VOTE";
cv::Size txtSz = cv::getTextSize(text, cv::FONT_HERSHEY_DUPLEX, 4, 4, NULL);
//cv::putText(orig, text, cv::Point(orig.size().width / 2 - txtSz.width /2, orig.size().height - 2* txtSz.height), cv::FONT_HERSHEY_PLAIN, 7, cv::Scalar(0, 255, 255), 4);
vote.copyTo(orig(cv::Rect((rightOrigin.x + leftOrigin.x)/2, (rightOrigin.y + leftOrigin.y)/2, vote.size().width, vote.size().height)));
if (!(left.IsActive() && right.IsActive())) {
char buff[11];
sprintf(buff, "%02d", left.GetCount());
cv::putText(orig, buff, cv::Point(40, orig.size().height - 40), cv::FONT_HERSHEY_PLAIN, 4, cv::Scalar(0, 255, 0), 4);
sprintf(buff, "%02d", right.GetCount());
cv::Size txtSz = cv::getTextSize(buff, cv::FONT_HERSHEY_PLAIN, 4, 4, NULL);
cv::putText(orig, buff, cv::Point(orig.size().width - txtSz.width - 40, orig.size().height - 40), cv::FONT_HERSHEY_PLAIN, 4, cv::Scalar(0, 255, 0), 4);
left.Draw(orig);
right.Draw(orig);
if (right.IsCounted()) {
yesc.copyTo(orig(cv::Rect(rightOrigin.x, rightOrigin.y, yesc.size().width, yesc.size().height)));
}
else {
yesbw.copyTo(orig(cv::Rect(rightOrigin.x, rightOrigin.y, yesbw.size().width, yesbw.size().height)));
}
if (left.IsCounted()) {
noc.copyTo(orig(cv::Rect(leftOrigin.x, leftOrigin.y, noc.size().width, noc.size().height)));
}
else {
nobw.copyTo(orig(cv::Rect(leftOrigin.x, leftOrigin.y, nobw.size().width, nobw.size().height)));
}
int totalVotes = right.GetCount() + left.GetCount();
std::string out = "FotosVote/votacao" + std::to_string(totalVotes) + ".png";
imwrite(out, orig);
}
else {
left.Deactivate();
right.Deactivate();
/* std::string text = "Fraude!";
cv::Size txtSz = cv::getTextSize(text, cv::FONT_HERSHEY_PLAIN, 4, 4, NULL);
cv::putText(orig, text, cv::Point(orig.size().width / 2 - txtSz.width / 2, orig.size().height /2), cv::FONT_HERSHEY_PLAIN, 4, cv::Scalar(0, 0, 255), 4);*/
}
}
else {
if ((time(NULL) - camAdaptationStartTime) > ADAPTATION_TIME_SEC) {
camAdapted = true;
bgsub = cv::createBackgroundSubtractorMOG2();
DisableCameraAutoAdjust(GetVideoNum(argc, argv));
}
else {
std::string text = "Configurando...";
cv::Size txtSz = cv::getTextSize(text, cv::FONT_HERSHEY_PLAIN, 4, 4, NULL);
cv::putText(orig, text, cv::Point(orig.size().width / 2 - txtSz.width / 2, orig.size().height /2 - 2* txtSz.height), cv::FONT_HERSHEY_PLAIN, 4, cv::Scalar(0, 0, 255), 4);
char buff[3];
sprintf(buff, "%d", ADAPTATION_TIME_SEC - abs(time(NULL) - camAdaptationStartTime));
txtSz = cv::getTextSize(buff, cv::FONT_HERSHEY_PLAIN, 4, 4, NULL);
cv::putText(orig, buff, cv::Point(orig.size().width / 2 - txtSz.width / 2, orig.size().height /2 ), cv::FONT_HERSHEY_PLAIN, 4, cv::Scalar(0, 0, 255), 4);
}
}
imshow("Contador de Votos", orig);
int key = cv::waitKey(30);
if ((key & 0xFF) == 27) {
exit(0);
}
else if ((key & 0xFF) == ' '){
camAdapted = false;
EnableCameraAutoAdjust(GetVideoNum(argc, argv));
camAdaptationStartTime = time(NULL);
}
else if ((key & 0xFF) == 'c') {
imwrite("out.png", orig);
system("python sendmail.py");
}
}
return 0;
}
int main (void)
{
MyFreenectDevice * freenect;
Freenect::Freenect freeNect;
IplImage * tmp2 = cvCreateImage(cvSize(640, 480), 8, 3);
IplImage * tmp = cvCreateImage(cvSize(800, 600), 8, 3);
CvFont font;
int selected = 1;
Menu * menu = new Menu(5);
cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, 1.0, 1.0, 0, 5);
freenect = &freeNect.createDevice<MyFreenectDevice>(0);
cvNamedWindow("fingers", CV_WINDOW_NORMAL);
cvSetWindowProperty("fingers", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
cvNamedWindow("surface");
cvResizeWindow("fingers", 800, 600);
cvSet(tmp, CV_RGB(255, 255, 255));
cvMoveWindow("fingers", 0, 1050);
cvMoveWindow("surface", 0, 0);
cvSet(tmp, CV_RGB(255, 255, 255));
cvShowImage("fingers", tmp);
cvNamedWindow("rgb");
cvMoveWindow("rgb", 0 , 480);
cvNamedWindow("depth");
cvMoveWindow("depth", 640 , 480);
freenect->startStream();
freenect->setTilt(0);
freenect->setThresh(true, 0, 700);
int waitTime = 0;
while (freenect->isKinectRunning())
{
if (freenect->isDepthReady() && freenect->isRgbReady())
{
cvSet(tmp, CV_RGB(255, 255, 255));
cvZero(tmp2);
IplImage * img = (IplImage*)cvClone(freenect->fetchKinectRgbFrame());
if (freenect->isCalibrated() == false && !freenect->getSurface())
{
sleep(1);
freenect->calibrate();
}
else if (freenect->isCalibrated() == false)
{
if (waitTime < 30)
{
cvPutText(tmp, "Initiating manual calibration",
cvPoint(250, 200), &font, CV_RGB(255, 0 , 0));
cvPutText(tmp, "due to bad lighting conditions",
cvPoint(250, 300), &font, CV_RGB(255, 0 , 0));
++waitTime;
}
}
else
{
cvSet(tmp, CV_RGB(0, 0, 0));
freenect->calcFingerPositions();
std::list<Finger> fList = freenect->getFingerList();
std::list<CvPoint> fListRaw = freenect->getRawFingerList();
for (std::list<CvPoint>::iterator it = fListRaw.begin() ; it != fListRaw.end() ; ++it)
{
cvCircle(freenect->fetchKinectDepthFrame(), cvPoint(it->x, it->y),
10, CV_RGB(0, 255, 0), CV_FILLED);
}
std::vector<CvPoint> twoFirst;
for (std::list<Finger>::iterator it = fList.begin() ; it != fList.end() ;)
{
cvCircle(tmp, cvPoint(it->x, it->y), 10, CV_RGB(255, 0, 0), CV_FILLED);
++it;
}
menu->interpretGesture(fList);
}
menu->drawMenu(tmp);
cvShowImage("fingers", tmp);
cvShowImage("surface", tmp2);
cvShowImage("rgb", freenect->fetchKinectRgbFrame());
cvShowImage("depth", freenect->fetchKinectDepthFrame());
cvReleaseImage(&img);
}
freenect->update();
int k = freenect->getKey();
if (k == 27)
freenect->setRunning(false);
}
freenect->stopStream();
cvDestroyAllWindows();
exit(0);
return 0;
}
void WebcamHandler::run()
{
// initialize webcam
VideoCapture cap = VideoCapture(0);
cap.set(CV_CAP_PROP_FRAME_WIDTH, m_frameWidth);
cap.set(CV_CAP_PROP_FRAME_HEIGHT, m_frameHeight);
// initialize window
namedWindow("Settings", CV_WINDOW_AUTOSIZE);
namedWindow("FaceRepair", CV_WINDOW_NORMAL);
cvSetWindowProperty("FaceRepair", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
cvWaitKey(1000);
float* hidden;
float* visible;
while (m_loop)
{
// read frame and continue with next frame if not successfull
Mat frame;
cap.retrieve(frame);
flip(frame, frame, 1);
// take subimage at faceArea
Mat subimage;
frame(*m_faceArea).copyTo(subimage);
Mat subimageHSV;
cvtColor(subimage, subimageHSV, COLOR_BGR2HSV); //Convert the captured frame from BGR to HSV
// detect color
Mat mask;
inRange(subimageHSV, *m_detectionColorMin, *m_detectionColorMax, mask);
erode(mask, mask, getStructuringElement(MORPH_ELLIPSE, Size(5, 5)));
dilate(mask, mask, getStructuringElement(MORPH_ELLIPSE, Size(15, 15)));
Mat invertedMask = 255 - mask;
// scale to rbm input size
Size size = Size(m_edgeLength, m_edgeLength);
Mat scaledSubimage;
resize(subimage, scaledSubimage, size, 0.0, 0.0, INTER_LINEAR);
Mat scaledMask;
resize(mask, scaledMask, size, 0.0, 0.0, INTER_NEAREST);
Mat invertedScaledMask = 255 - scaledMask;
// calc mean rgb of preserved area
Scalar bgr = mean(scaledSubimage, invertedScaledMask);
// set mean rgb at reconstructionArea
scaledSubimage.setTo(bgr, scaledMask);
// subimage to normalized float array
visible = matToNormalizedFloatArrayWithBias(&scaledSubimage);
// process RBMs
hidden = m_rbm1000->runHidden(visible, 1);
delete visible;
hidden[0] = 1;
visible = m_rbm1000->runVisible(hidden, 1);
delete hidden;
visible[0] = 1;
resetPreservedArea(&scaledSubimage, &invertedScaledMask, visible);
hidden = m_rbm1500->runHidden(visible, 1);
delete visible;
hidden[0] = 1;
visible = m_rbm1500->runVisible(hidden, 1);
delete hidden;
visible[0] = 1;
resetPreservedArea(&scaledSubimage, &invertedScaledMask, visible);
hidden = m_rbm2000->runHidden(visible, 1);
delete visible;
hidden[0] = 1;
visible = m_rbm2000->runVisible(hidden, 1);
delete hidden;
// normalized float array to subimage
normalizedFloatArrayToMatWithoutBias(visible, &scaledSubimage);
// scale to original faceArea size
Mat result;
size = Size(m_faceArea->width, m_faceArea->height);
resize(scaledSubimage, result, size, 0.0, 0.0, INTER_CUBIC);
// reset pixels of preserved area in native resolution
subimage.copyTo(result, invertedMask);
// create fullscreen image
Mat fs;
frame.copyTo(fs);
result.copyTo(fs(*m_faceArea));
flip(fs, fs, 1);
// maybe not necessary
//result.copyTo(frame(*m_faceArea));
// paint visualizations for settings image
rectangle(frame, *m_faceArea, Scalar(0, 255, 0));
Point* eyePositions = calculateEyePositions(m_faceArea, m_relativeEyePositionX, m_relativeEyePositionY);
circle(frame, eyePositions[0], 4, Scalar(255, 255, 0));
circle(frame, eyePositions[1], 4, Scalar(255, 255, 0));
delete eyePositions;
// show frames
imshow("Settings", frame);
imshow("FaceRepair", fs);
// check keyboard input
checkKeys();
}
// terminate webcam
cap.release();
}
void cv::setWindowProperty(const String& winname, int prop_id, double prop_value)
{
CV_TRACE_FUNCTION();
cvSetWindowProperty( winname.c_str(), prop_id, prop_value);
}
/*******************************************************************************************************************//**
* @brief Program entry point
*
* Handles image processing and display of annotated results
*
* @param[in] argc command line argument count
* @param[in] argv command line argument vector
* @returnS return status
* @author Christopher D. McMurrough
**********************************************************************************************************************/
int main(int argc, char** argv)
{
// validate and parse the command line arguments
int cameraIndex = 0;
bool displayMode = true;
bool flipDisplay = false;
if(argc != NUM_COMNMAND_LINE_ARGUMENTS + 1)
{
std::printf("USAGE: <camera_index> <display_mode>\n");
std::printf("Running with default parameters... \n");
}
else
{
cameraIndex = atoi(argv[1]);
displayMode = atoi(argv[2]) > 0;
flipDisplay = atoi(argv[2]) == 2;
}
// initialize the eye camera video capture
//cv::VideoCapture occulography(cameraIndex);
cv::VideoCapture occulography("pupil_test.mp4");
// cv::VideoCapture occulography("test.mov");
if(!occulography.isOpened())
{
std::printf("Unable to initialize camera %u! \n", cameraIndex);
return 0;
}
occulography.set(CV_CAP_PROP_FRAME_WIDTH, CAMERA_FRAME_WIDTH);
occulography.set(CV_CAP_PROP_FRAME_HEIGHT, CAMERA_FRAME_HEIGHT);
occulography.set(CV_CAP_PROP_FORMAT, CAMERA_FORMAT);
occulography.set(CV_CAP_PROP_FPS, CAMERA_FPS);
occulography.set(CV_CAP_PROP_BRIGHTNESS, CAMERA_BRIGHTNESS);
occulography.set(CV_CAP_PROP_CONTRAST, CAMERA_CONTRAST);
occulography.set(CV_CAP_PROP_SATURATION, CAMERA_SATURATION);
occulography.set(CV_CAP_PROP_HUE, CAMERA_HUE);
occulography.set(CV_CAP_PROP_GAIN, CAMERA_GAIN);
occulography.set(CV_CAP_PROP_EXPOSURE, CAMERA_EXPOSURE);
occulography.set(CV_CAP_PROP_CONVERT_RGB, CAMERA_CONVERT_RGB);
// intialize the display window if necessary
if(displayMode)
{
cvNamedWindow("eyeImage", CV_WINDOW_NORMAL);
cvSetWindowProperty("eyeImage", CV_WND_PROP_FULLSCREEN, CV_WINDOW_NORMAL);
cvSetWindowProperty("eyeImage", CV_WND_PROP_AUTOSIZE, CV_WINDOW_NORMAL);
cvSetWindowProperty("eyeImage", CV_WND_PROP_ASPECTRATIO, CV_WINDOW_KEEPRATIO);
}
// create the pupil tracking object
PupilTracker tracker;
tracker.setDisplay(displayMode);
// store the frame data
cv::Mat eyeImage;
//struct PupilData result;
bool trackingSuccess = false;
// store the time between frames
int frameStartTicks, frameEndTicks, processStartTicks, processEndTicks;
float processTime, totalTime;
// process data until program termination
bool isRunning = true;
while(isRunning)
{
// start the timer
frameStartTicks = clock();
// attempt to acquire an image frame
if(occulography.read(eyeImage))
{
// process the image frame
processStartTicks = clock();
trackingSuccess = tracker.findPupil(eyeImage);
processEndTicks = clock();
processTime = ((float)(processEndTicks - processStartTicks)) / CLOCKS_PER_SEC;
// warn on tracking failure
if(!trackingSuccess)
{
std::printf("Unable to locate pupil! \n");
}
// update the display
if(displayMode)
{
cv::Mat displayImage(eyeImage);
// annotate the image if tracking was successful
if(trackingSuccess)
{
// draw the pupil center and boundary
//cvx::cross(displayImage, result.pupil_center, 5, COLOR_RED);
cv::ellipse(displayImage, tracker.getEllipseRectangle(), COLOR_RED);
// shade the pupil area
cv::Mat annotation(eyeImage.rows, eyeImage.cols, CV_8UC3, 0.0);
cv::ellipse(annotation, tracker.getEllipseRectangle(), COLOR_MAGENTA, -1);
const double alpha = 0.7;
cv::addWeighted(displayImage, alpha, annotation, 1.0 - alpha, 0.0, displayImage);
}
if(flipDisplay)
{
// annotate the image
cv::Mat displayFlipped;
cv::flip(displayImage, displayFlipped, 1);
cv::imshow("eyeImage", displayFlipped);
// display the annotated image
isRunning = cv::waitKey(1) != 'q';
displayFlipped.release();
}
else
{
// display the image
cv::imshow("eyeImage", displayImage);
isRunning = cv::waitKey(1) != 'q';
}
// release display image
displayImage.release();
}
}
else
{
std::printf("WARNING: Unable to capture image from source!\n");
occulography.set(CV_CAP_PROP_POS_FRAMES, 0);
continue;
}
// stop the timer and print the elapsed time
frameEndTicks = clock();
totalTime = ((float)(frameEndTicks - frameStartTicks)) / CLOCKS_PER_SEC;
//std::printf("Processing time (pupil, total) (result x,y): %.4f %.4f - %.2f %.2f\n", processTime, totalTime, tracker.getEllipseCentroid().x, tracker.getEllipseCentroid().y);
}
// release the video source before exiting
occulography.release();
}
void demo(char *cfgfile, char *weightfile, float thresh, int cam_index, const char *filename, char **names, int classes, int frame_skip, char *prefix, float hier, int w, int h, int frames, int fullscreen)
{
//skip = frame_skip;
image **alphabet = load_alphabet();
int delay = frame_skip;
demo_names = names;
demo_alphabet = alphabet;
demo_classes = classes;
demo_thresh = thresh;
demo_hier = hier;
printf("Demo\n");
net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
set_batch_network(&net, 1);
srand(2222222);
if(filename){
printf("video file: %s\n", filename);
cap = cvCaptureFromFile(filename);
}else{
cap = cvCaptureFromCAM(cam_index);
if(w){
cvSetCaptureProperty(cap, CV_CAP_PROP_FRAME_WIDTH, w);
}
if(h){
cvSetCaptureProperty(cap, CV_CAP_PROP_FRAME_HEIGHT, h);
}
if(frames){
cvSetCaptureProperty(cap, CV_CAP_PROP_FPS, frames);
}
}
if(!cap) error("Couldn't connect to webcam.\n");
layer l = net.layers[net.n-1];
int j;
avg = (float *) calloc(l.outputs, sizeof(float));
for(j = 0; j < FRAMES; ++j) predictions[j] = (float *) calloc(l.outputs, sizeof(float));
for(j = 0; j < FRAMES; ++j) images[j] = make_image(1,1,3);
boxes = (box *)calloc(l.w*l.h*l.n, sizeof(box));
probs = (float **)calloc(l.w*l.h*l.n, sizeof(float *));
for(j = 0; j < l.w*l.h*l.n; ++j) probs[j] = (float *)calloc(l.classes, sizeof(float));
pthread_t fetch_thread;
pthread_t detect_thread;
fetch_in_thread(0);
det = in;
det_s = in_s;
fetch_in_thread(0);
detect_in_thread(0);
disp = det;
det = in;
det_s = in_s;
for(j = 0; j < FRAMES/2; ++j){
fetch_in_thread(0);
detect_in_thread(0);
disp = det;
det = in;
det_s = in_s;
}
int count = 0;
if(!prefix){
cvNamedWindow("Demo", CV_WINDOW_NORMAL);
if(fullscreen){
cvSetWindowProperty("Demo", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
} else {
cvMoveWindow("Demo", 0, 0);
cvResizeWindow("Demo", 1352, 1013);
}
}
double before = get_wall_time();
while(1){
++count;
if(1){
if(pthread_create(&fetch_thread, 0, fetch_in_thread, 0)) error("Thread creation failed");
if(pthread_create(&detect_thread, 0, detect_in_thread, 0)) error("Thread creation failed");
if(!prefix){
show_image(disp, "Demo");
int c = cvWaitKey(1);
if (c != -1) c = c%256;
if (c == 10){
if(frame_skip == 0) frame_skip = 60;
else if(frame_skip == 4) frame_skip = 0;
else if(frame_skip == 60) frame_skip = 4;
else frame_skip = 0;
} else if (c == 27) {
return;
} else if (c == 82) {
demo_thresh += .02;
} else if (c == 84) {
demo_thresh -= .02;
if(demo_thresh <= .02) demo_thresh = .02;
} else if (c == 83) {
demo_hier += .02;
} else if (c == 81) {
demo_hier -= .02;
if(demo_hier <= .0) demo_hier = .0;
}
}else{
char buff[256];
sprintf(buff, "%s_%08d", prefix, count);
save_image(disp, buff);
}
pthread_join(fetch_thread, 0);
pthread_join(detect_thread, 0);
if(delay == 0){
free_image(disp);
disp = det;
}
det = in;
det_s = in_s;
}else {
fetch_in_thread(0);
det = in;
det_s = in_s;
detect_in_thread(0);
if(delay == 0) {
free_image(disp);
disp = det;
}
show_image(disp, "Demo");
cvWaitKey(1);
}
--delay;
if(delay < 0){
delay = frame_skip;
double after = get_wall_time();
float curr = 1./(after - before);
fps = curr;
before = after;
}
}
}
int main() {
cv::namedWindow("Planetarium", cv::WINDOW_NORMAL);
planetarium wall;
wall.psf_spread_size = 8;
wall.screen_distance = 5.954;
wall.screen_width = 1920;
wall.screen_height = 1080;
wall.screen_horizontal_pixel_size = 2.364 / wall.screen_width;
wall.screen_vertical_pixel_size = 1.335 / wall.screen_height;
// Orion
wall.attitude_ra = 84*M_PI/180;
wall.attitude_de = 2*M_PI/180;
// Juno
// wall.attitude_ra = -2.885402;
// wall.attitude_de = 0.133802;
// Twist: 0.054906
wall.I_ref = 1.0;
wall.m_ref = 6.0;
wall.sigma_0 = 1.0;
wall.camera_x_offset = 0.0;
wall.camera_y_offset = 0.0;
// Load star catalog
cv::Mat catalog = load_catalog("../hip6.tsv");
cv::Mat image = wall.render(catalog);
int k;
while((k = cvWaitKey(30)) != 27) {
if (k >= 65361 and k <= 65364) {
// Left
if (k == 65361) {
wall.attitude_ra += 1*M_PI/180;
}
// Right
else if (k == 65363) {
wall.attitude_ra -= 1*M_PI/180;
}
// Up
else if (k == 65362) {
wall.attitude_de += 1*M_PI/180;
}
// Down
else if (k == 65364) {
wall.attitude_de -= 1*M_PI/180;
}
std::cout << "Attitude: Right Ascension: " << 180/M_PI * wall.attitude_ra << std::endl;
std::cout << " Declination : " << 180/M_PI * wall.attitude_de << std::endl;
image = wall.render(catalog);
} else if (k == 102) {
cvSetWindowProperty("Planetarium", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN );
}
cv::imshow("Planetarium", image);
}
return 0;
}
/**
Fonction qui récupère l'image de la webcam et effectue le traitement en
faisant appel aux autres fonctions.
**/
void imageTreatement() {
/*
Déclaration des variables
*/
int i, j ;
char key ;
color_pixel_hsv color ;
CvCapture *capture ;
//IplImage* cap = cvLoadImage("imagetest.jpg", CV_LOAD_IMAGE_UNCHANGED);
IplImage* cap ;
IplImage* cap_resize ;
IplImage* hsv ;
coordonnees center ;
coordonnees barycenter ;
center.x = center.y = barycenter.x = barycenter.y = 0 ;
int *barycenter_x ;
int *barycenter_y ;
int pixel_tracked_number = 0 ;
uchar pixel_h ;
uchar pixel_s ;
uchar pixel_v ;
int tolerance_h = 20 ;
int tolerance_s = 20 ;
/*
On capture à partir de la webcam, si la capture echoue un message s'affiche.
*/
capture = cvCreateCameraCapture(CV_CAP_ANY);
if(!capture){
printf("! Error while capturing from camera !\n");
exit(1);
}
/*
On capture l'image une seule fois pour connaitre les informations de
l'image et pouvoir définir la nouvelle image avec résolution plus faible.
*/
cap = cvQueryFrame(capture);
cap_resize = cvCreateImage(cvSize(320, 240), cap->depth, cap->nChannels);
center_calcul(cap_resize, ¢er);
//printf("Width image = %d, Height image = %d, Centre théorique = [%d][%d], Centre calculé = [%d][%d]\n", cap_resize->width, cap_resize->height, (cap_resize->width)/2, (cap_resize->height)/2, center.x, center.y);
//printf("Width = %d, Height = %d\n", cap_resize->width ,cap_resize->height);*/
/*
conversion de l'image original (BVR) en image HSV.
*/
//hsv = hsvConvert(cap);
/*
Déclaration et création des fenêtres.
*/
const char* original = "Image Originale" ;
const char* hsv_window = "Image HSV" ;
cvNamedWindow(original, CV_WINDOW_NORMAL);
cvMoveWindow(original, 0, 0);
cvSetWindowProperty(original, CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
cvNamedWindow(hsv_window, CV_WINDOW_AUTOSIZE);
cvCreateTrackbar("Hue Tolerance", "Image Originale", &tolerance_h, 125, NULL);
cvCreateTrackbar("Saturation Tolerance", "Image Originale", &tolerance_s, 125, NULL);
// Enlever le commentaire pour afficher la matrice de l'image dans le terminal.
//showMatImage(hsv);
/*
Traitement des images.
*/
while(key != 'q' && key != 'Q') {
pixel_tracked_number = 0 ;
// On alloue la mémoire pour les tableaux des barycentres.
barycenter_x = (int*)calloc(cap->width, sizeof(int));
barycenter_y = (int*)calloc(cap->height, sizeof(int));
// On met à jour l'image et on la convertis.
cap = cvQueryFrame(capture);
cvResize(cap, cap_resize, CV_INTER_LINEAR);
hsv = hsvConvert(cap_resize);
// On met les pointeurs sur les images dans la structure "color".
color.cam = cap_resize ;
color.hsv = hsv ;
// Fonction du clic de la souris.
cvSetMouseCallback(original, mouseEvent, &color);
// On parcours toute l'image, pixel par pixel.
for (i = 0 ; i < (hsv->width)*3 ; i=i+3) {
for (j = 0 ; j < hsv->height ; j++) {
// Pixels H,S,V en fonction de la position.
pixel_h = (uchar)(hsv->imageData[((i*3)+(j*hsv->widthStep))]) ;
pixel_s = (uchar)(hsv->imageData[((i*3)+(j*hsv->widthStep))+1]) ;
pixel_v = (uchar)(hsv->imageData[((i*3)+(j*hsv->widthStep))+2]) ;
// Tracking des pixels en fonction de la couleur.
if(ColorTracking(color, ((i*3)+(j*cap_resize->widthStep)), pixel_h, pixel_s, pixel_v, tolerance_h, tolerance_s)){
//printf("y = %d, x = %d\n", i/((cap->width)*3), i%((cap->width)*3));
barycenter_y[j]++ ;
barycenter_x[i/3]++ ;
pixel_tracked_number++ ;
}
}
}
// Calcul des barycentres.
barycenter = barycenter_calculation(barycenter_x, cap->width, barycenter_y, cap->height, pixel_tracked_number);
CvPoint p ;
p.x = barycenter.x ;
p.y = barycenter.y ;
cvCircle(cap_resize, p, 5, CV_RGB(0,0,255), -1, 8, 0);
// Calculé le barycentre et y mettre un point.
// On met les images dans les fenêtres.
cvShowImage(original, cap_resize);
cvShowImage(hsv_window, hsv);
// Libération de la mémoire des tableaux de barycentres.
free(barycenter_x);
free(barycenter_y);
key = cvWaitKey(10);
}
}
