challenge-bot.com Git - ozzloy@gmail.com/oble/blob - oble.cpp

   1 //use the camera to aid the decision to sleep.
   2 //Copyright 2009 Daniel Watson
   3 /*
   4     use a camera to prevent screensaver
   5     Copyright (C) 2009  daniel watson, ozzloy@gmail.com
   6
   7     This program is free software: you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation, either version 3 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20 /*
  21          This file is part of oble.
  22
  23          oble is free software: you can redistribute it and/or modify
  24          it under the terms of the GNU General Public License as published by
  25          the Free Software Foundation, either version 3 of the License, or
  26          (at your option) any later version.
  27
  28          oble is distributed in the hope that it will be useful,
  29          but WITHOUT ANY WARRANTY; without even the implied warranty of
  30          MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31          GNU General Public License for more details.
  32
  33          You should have received a copy of the GNU General Public License
  34          along with oble.  If not, see <http://www.gnu.org/licenses/>.
  35
  36 */
  37 #include <cv.h>
  38 #include <highgui.h>
  39 #include <stdio.h>
  40 #include <iostream>
  41 #include <time.h>
  42 #include "oble.h"
  43 #include "idle_x11.h"
  44
  45 using namespace std;
  46
  47 // argument for cvFlip(src, dest, FLIP_TYPE)
  48 #define MIRROR 1
  49
  50 #define DEBUG 0
  51
  52 CvHaarClassifierCascade* load_object_detector(const char* cascade_path)
  53 {
  54         return (CvHaarClassifierCascade*)cvLoad(cascade_path);
  55 }
  56
  57 void detect_and_draw_objects(IplImage* image,
  58                 CvHaarClassifierCascade* cascade,
  59                 int do_pyramids)
  60 {
  61         IplImage* small_image = image;
  62         CvMemStorage* storage = cvCreateMemStorage(0);
  63         CvSeq* faces;
  64         int i, scale = 1;
  65         static int saw_last_time = 0;
  66
  67         /* if the flag is specified, down-scale the input image to get a
  68                  performance boost w/o loosing quality (perhaps) */
  69         if(do_pyramids)
  70         {
  71                 small_image = cvCreateImage(cvSize(image->width/2,image->height/2),
  72                                 IPL_DEPTH_8U, 3);
  73                 cvPyrDown(image, small_image, CV_GAUSSIAN_5x5);
  74                 scale = 2;
  75         }
  76
  77         /* use the fastest variant */
  78         faces = cvHaarDetectObjects(small_image, cascade, storage, 1.2, 2,
  79                         CV_HAAR_DO_CANNY_PRUNING);
  80
  81         if(0 < faces->total)
  82         {
  83                 t_current = time(NULL);
  84                 if(DEBUG)
  85                 {
  86                         printf(":) face \n");
  87                 }
  88                 if(saw_last_time)
  89                 {
  90                         if(DEBUG)printf("\t\tpoking\n");
  91                         reset_idle_time();
  92                         system("gnome-screensaver-command --poke");
  93                 }
  94                 saw_last_time = 1;
  95         }
  96         else
  97         {
  98                 saw_last_time = 0;
  99                 if(DEBUG)
 100                 {
 101                         printf(":( no face \n");
 102                 }
 103         }
 104
 105         /* draw all the rectangles */
 106         for(i = 0; i < faces->total; i++)
 107         {
 108                 /* extract the rectangles only */
 109                 CvRect face = *(CvRect*)cvGetSeqElem(faces, i);
 110                 CvPoint upperLeft = cvPoint(face.x * scale, face.y * scale);
 111                 CvPoint bottomRight = cvPoint((face.x + face.width) * scale,
 112                                 (face.y + face.height) * scale);
 113                 cvRectangle(image, upperLeft, bottomRight, CV_RGB(255,0,0), 3);
 114         }
 115
 116         if(small_image != image)
 117                 cvReleaseImage(&small_image);
 118         cvReleaseMemStorage(&storage);
 119 }
 120
 121 void screensave(time_t t_current)
 122 {
 123         static int last_elapse = 0;
 124         static int activated = 0;
 125         int elapse = difftime(time(NULL), t_current);
 126         int timeout = 10;
 127         if(elapse > timeout && elapse != last_elapse)
 128         {
 129                 last_elapse = elapse;
 130                 if(DEBUG)
 131                 {
 132                         printf("elapse = %d\n", elapse);
 133                 }
 134                 if(!activated)
 135                 {
 136                         printf("activated\n");
 137                         activated = 1;
 138                         system("gnome-screensaver-command -a");
 139                 }
 140         }
 141         if(elapse < timeout && activated)
 142         {
 143                 printf("deactivated\n");
 144                 activated = 0;
 145                 system("gnome-screensaver-command -d");
 146         }
 147 }
 148
 149 // A Simple Camera Capture Framework.
 150 int main(int argc, char** argv)
 151 {
 152         CvHaarClassifierCascade* cascade = load_object_detector(argv[1]);
 153
 154         CvCapture* capture = cvCaptureFromCAM(CV_CAP_ANY);
 155         if(!capture) {
 156                 cerr << "ERROR: capture is NULL " << endl;
 157                 getchar();
 158                 return -1;
 159         }
 160
 161         // Create a window in which the captured images will be presented
 162         cvNamedWindow("mywindow", CV_WINDOW_AUTOSIZE);
 163
 164         IplImage* frame = cvQueryFrame(capture);
 165         if(!frame) {
 166                 cerr << "ERROR: frame is null..." << endl;
 167                 getchar();
 168                 return -1;
 169         }
 170         IplImage* mirrored =
 171                 cvCreateImage(cvGetSize(frame), frame->depth, frame->nChannels);
 172         t_current = time(NULL);
 173         // Show the image captured from the camera in the window and repeat
 174         while(1) {
 175                 // Get one frame
 176                 frame = cvQueryFrame(capture);
 177                 if(!frame) {
 178                         cerr << "ERROR: frame is null..." << endl;
 179                         getchar();
 180                         break;
 181                 }
 182
 183                 //flip the image so displayed right/left corresponds to physical right/left
 184                 cvFlip(frame, mirrored, MIRROR);
 185
 186                 detect_and_draw_objects(mirrored, cascade, 1);
 187                 cvShowImage("mywindow", mirrored);
 188                 // Do not release the frame!
 189                 //screensave(t_current);
 190
 191                 //If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version),
 192                 //remove higher bits using AND operator
 193                 if((cvWaitKey(100) & 255) == 27) break;
 194         }
 195
 196         // Release the capture device housekeeping
 197         cvReleaseCapture(&capture);
 198         cvDestroyWindow("mywindow");
 199         cvReleaseImage(&mirrored);
 200         return 0;
 201 }