in progress, need libxss-dev for screensaverpoking

[ozzloy@gmail.com/oble] / oble.cpp

//use the camera to aid the decision to sleep.
//Copyright 2009 Daniel Watson
/*
    use a camera to prevent screensaver
    Copyright (C) 2009  daniel watson, ozzloy@gmail.com

    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 file is part of oble.

	 oble 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.

	 oble 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 oble.  If not, see <http://www.gnu.org/licenses/>.

*/
#include <cv.h>
#include <highgui.h>
#include <stdio.h>
#include <iostream>
#include <time.h>
#include <unistd.h>
#include "oble.h"
#include "idle_x11.h"

using namespace std;

static string cascade_filename = "";
static int verbose = 0;

// argument for cvFlip(src, dest, FLIP_TYPE)
#define MIRROR 1

CvHaarClassifierCascade* load_object_detector(const char* cascade_path)
{
	return (CvHaarClassifierCascade*)cvLoad(cascade_path);
}

void detect_and_draw_objects(IplImage* image,
		CvHaarClassifierCascade* cascade,
		int do_pyramids)
{
	IplImage* small_image = image;
	CvMemStorage* storage = cvCreateMemStorage(0);
	CvSeq* faces;
	int i, scale = 1;

	/* if the flag is specified, down-scale the input image to get a
		 performance boost w/o loosing quality (perhaps) */
	if(do_pyramids)
	{
		small_image = cvCreateImage(cvSize(image->width/2,image->height/2),
				IPL_DEPTH_8U, 3);
		cvPyrDown(image, small_image, CV_GAUSSIAN_5x5);
		scale = 2;
	}

	/* use the fastest variant */
	faces = cvHaarDetectObjects(small_image, cascade, storage, 1.2, 2,
			CV_HAAR_DO_CANNY_PRUNING);

	update_idle(faces->total);

	/* draw all the rectangles */
	for(i = 0; i < faces->total; i++)
	{
		/* extract the rectangles only */
		CvRect face = *(CvRect*)cvGetSeqElem(faces, i);
		CvPoint upperLeft = cvPoint(face.x * scale, face.y * scale);
		CvPoint bottomRight = cvPoint((face.x + face.width) * scale,
				(face.y + face.height) * scale);
		cvRectangle(image, upperLeft, bottomRight, CV_RGB(255,0,0), 3);
	}

	if(small_image != image)
		cvReleaseImage(&small_image);
	cvReleaseMemStorage(&storage);
}

void update_idle(int faces_total)
{
	static int saw_last_time = 0;

	if(0 < faces_total)
	{
		t_current = time(NULL);
		if(verbose)
		{
			printf(":) face \n");
		}
		if(saw_last_time)
		{
			if(verbose)printf("\t\tpoking\n");
			reset_idle_time();
			system("gnome-screensaver-command --poke");
		}
		saw_last_time = 1;
	}
	else
	{
		saw_last_time = 0;
		if(verbose)
		{
			printf(":( no face \n");
		}
	}

}

void screensave(time_t t_current)
{
	static int last_elapse = 0;
	static int activated = 0;
	int elapse = difftime(time(NULL), t_current);
	int timeout = 10;
	if(elapse > timeout && elapse != last_elapse)
	{
		last_elapse = elapse;
		if(verbose)
		{
			printf("elapse = %d\n", elapse);
		}
		if(!activated)
		{
			printf("activated\n");
			activated = 1;
			system("gnome-screensaver-command -a");
		}
	}
	if(elapse < timeout && activated)
	{
		printf("deactivated\n");
		activated = 0;
		system("gnome-screensaver-command -d");
	}
}

int parse_opts(int argc, char **argv)
{
	int index, c;
	opterr = 0;
	const char *options = "vc:\x0";
	while((c = getopt(argc, argv, options)) != -1)
	{
		switch(c)
		{
			case 'v': verbose = 1; break;
			case 'c': cascade_filename = string(optarg); break;
			case '?':
				if(optopt == 'c')
				{
					printf("option -%c requires an argument.\n", optopt);
				}
				else if(isprint (optopt))
				{
					printf("unknown option `-%c'.\n", optopt);
				}
				else
				{
					printf("unknown option char `\\x%x'.\n", optopt);
				}
				break;
			case '\x0': break; //ignore.  not sure why this shows up.  maybe zsh?
			default: abort();
		}
	}

	for(index = optind; index < argc; index++)
		printf("Non-option arg %s\n", argv[index]);

	if(cascade_filename == "")
	{
		printf("you must supply a filename with -c option.  example:\n");
		printf(
				"%s -c %s\n",
				argv[0],
				"/usr/share/opencv/haarcascades/haarcascade_frontalface_alt.xml"
				);
		return 1;
	}
	if(verbose) printf("SILENT ALARM ACTIVATED!!!\n");
	return 0;
}

void get_frames(CvCapture* capture, CvHaarClassifierCascade* cascade)
{
	IplImage* frame = NULL;
	get_one_frame(capture, frame);

	IplImage* mirrored =
		cvCreateImage(cvGetSize(frame), frame->depth, frame->nChannels);
	// Show the image captured from the camera in the window and repeat
	while(1) {
		if(get_one_frame(capture, frame)) break;

		//flip the image so displayed right/left corresponds to physical right/left
		cvFlip(frame, mirrored, MIRROR);

		detect_and_draw_objects(mirrored, cascade, 1);
		cvShowImage("mywindow", mirrored);
		// Do not release the frame!
		//screensave(t_current);

		//If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version),
		//remove higher bits using AND operator
		if((cvWaitKey(100) & 255) == 27) break;
	}
	cvReleaseImage(&mirrored);
}

int do_capture()
{
	CvHaarClassifierCascade* cascade =
		load_object_detector(cascade_filename.c_str());

	CvCapture* capture = cvCaptureFromCAM(CV_CAP_ANY);
	if(!capture) {
		cerr << "ERROR: capture is NULL " << endl;
		getchar();
		return -1;
	}

	// Create a window in which the captured images will be presented
	cvNamedWindow("mywindow", CV_WINDOW_AUTOSIZE);
	t_current = time(NULL);
	get_frames(capture, cascade);

	// Release the capture device housekeeping
	cvReleaseCapture(&capture);
	cvDestroyWindow("mywindow");
	return 0;
}

int get_one_frame(CvCapture* capture, IplImage* &frame)
{
		frame = cvQueryFrame(capture);
		if(!frame) {
			cerr << "ERROR: frame is null..." << endl;
			getchar();
			return 1;
		}
		return 0;
}

// A Simple Camera Capture Framework.
int main(int argc, char** argv)
{
	if(parse_opts(argc, argv)) return 0;

	return do_capture();
}