├── .gitignore
├── LICENSE
├── README.md
├── logo.png
├── requirements.txt
├── rodent.py
└── utils.py


/.gitignore:
--------------------------------------------------------------------------------
1 | output.avi
2 | photos/
3 | opencv-2.4.9
4 | *.pyc
5 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Vincent Prouillet
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Find out who/what the fuck is eating my lunch at night
 2 | 
 3 | ![Rodent](/logo.png)
 4 | 
 5 | ## Goal
 6 | See title.  
 7 | Takes picture every time interval (defaults to one picture a second) and make a video of it at the end.  
 8 | It has a motion detection mode that will detect motion and put a purple rectangle around it (by default it does not do a video at the end but you can call make_video manually if you want to).
 9 | 
10 | ## Installation
11 | 
12 | ```python
13 | pip install -r requirements.txt
14 | ```
15 | Don't forget to install dependencies (jpg lib and ffmpeg or something that works with opencv, libav for Ubuntu) for OpenCV before installing it, otherwise things won't work.
16 | On Ubuntu:
17 | 
18 | ```bash
19 | $ sudo apt-get install libjpeg-dev libavcodec-dev libavformat-dev libswscale-dev
20 | ```
21 | 
22 | OpenCV is not pip installable so either install it from your package manager or follow the instructions for your OS at [the download page](http://opencv.org/downloads.html) (you can install it in a virtualenv by following this post: [Installation of Opencv, numpy, scipy inside a virtualenv](https://medium.com/@manuganji/installation-of-opencv-numpy-scipy-inside-a-virtualenv-bf4d82220313)).  
23 | 
24 | 
25 | ## How to use
26 | ```python
27 | $ python rodent.py
28 | ```
29 | There are 4 commands:
30 | 
31 | - capture: takes a picture from the webcam at a given interval forever or until the time specified in the folder given
32 | - make_video: takes all the pictures in the folder and makes a video out of it (better than watching pictures!)
33 | - automate: does both capture and make_video, I use it for example to record until 15 minutes before I wake up and the video will be ready by the time I get to the kitchen for example
34 | - motion: takes a picture only if it detects a movement
35 | 
36 | 
37 | ## How it works
38 | Look at the [article on my blog](http://vincent.is/turning-a-laptop-into-cctv/)
39 | 


--------------------------------------------------------------------------------
/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Keats/rodent/60844ec55a936e0b6e021d20ff711eb9628dfa9f/logo.png


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | argparse==1.2.1
2 | ipdb==0.8
3 | ipython==2.2.0
4 | numpy==1.9.0
5 | wsgiref==0.1.2
6 | 


--------------------------------------------------------------------------------
/rodent.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Rodent
  3 | 
  4 | Usage:
  5 |   rodent.py capture [--until=<time>] [--folder=<folder>] [--interval=<interval>]
  6 |   rodent.py make_video [--folder=<folder>]
  7 |   rodent.py automate [--until=<time>] [--folder=<folder>] [--interval=<interval>]
  8 |   rodent.py motion [--until=<time>] [--folder=<folder>]
  9 | 
 10 | Options:
 11 |   -h --help               Show this screen
 12 |   --until=<time>          Until when to record, needs to be a HH:MM format (ie 12:45)
 13 |   --folder=<folder>       The folder in which the pictures are stored [default: photos]
 14 |   --interval=<interval>   The interval between 2 photos [default: 1]
 15 | """
 16 | 
 17 | import datetime
 18 | import os
 19 | import time
 20 | 
 21 | import cv2
 22 | from docopt import docopt
 23 | 
 24 | import utils
 25 | 
 26 | 
 27 | def start_camera(camera, folder, interval, until=None):
 28 |     """
 29 |     Start taking pictures every interval.
 30 |     If until is specified, it will take pictures
 31 |     until that time is reached (24h format).
 32 |     Needs to be of the following format: HH:MM
 33 |     """
 34 |     utils.clear_directory(folder)
 35 |     number = 0
 36 | 
 37 |     while True:
 38 |         _, image = camera.read()
 39 |         now = datetime.datetime.now()
 40 | 
 41 |         number += 1
 42 |         print 'Taking picture number %d at %s' % (number, now.isoformat())
 43 |         utils.save_image(image, folder, now)
 44 | 
 45 |         if utils.time_over(until, now):
 46 |             break
 47 | 
 48 |         time.sleep(interval)
 49 | 
 50 |     del(camera)
 51 | 
 52 | 
 53 | def make_video(folder):
 54 |     """
 55 |     Takes all the pics in the folder given and make a video
 56 |     out of it.
 57 |     """
 58 |     # Sorting on dates, ISO ftw
 59 |     filenames = sorted(os.listdir(folder))
 60 | 
 61 |     # Completely arbitrary values, probably will need to fix that later
 62 |     # If the video is too fast or too slow, change the fps value manually
 63 |     fps = 2
 64 |     if 20 <= len(filenames) <= 40:
 65 |         fps = 4
 66 |     elif 41 <= len(filenames) <= 200:
 67 |         fps = 10
 68 |     elif 201 <= len(filenames) <= 500:
 69 |         fps = 20
 70 |     elif len(filenames) > 500:
 71 |         fps = 40
 72 | 
 73 |     # Find out size of the pictures we're taking
 74 |     first_pic = cv2.imread('%s/%s' % (folder, filenames[0]))
 75 | 
 76 |     # shape gives a tuple (height, width, layer)
 77 |     height, width, _ = first_pic.shape
 78 | 
 79 |     # magic below, might need to change the codec for your own webcam
 80 |     fourcc = cv2.cv.CV_FOURCC(*'XVID')
 81 |     video = cv2.VideoWriter('output.avi', fourcc, fps, (width, height))
 82 | 
 83 |     for filename in filenames:
 84 |         video.write(cv2.imread('%s/%s' % (folder, filename)))
 85 | 
 86 |     video.release()
 87 | 
 88 | 
 89 | def motion_detection(camera, folder, until):
 90 |     """
 91 |     Uses 3 frames to look for motion, can't remember where
 92 |     I found it but it gives better result than my first try
 93 |     with comparing 2 frames.
 94 |     """
 95 |     utils.clear_directory(folder)
 96 | 
 97 |     # Need to get 2 images to start with
 98 |     previous_image = cv2.cvtColor(camera.read()[1], cv2.cv.CV_RGB2GRAY)
 99 |     current_image = cv2.cvtColor(camera.read()[1], cv2.cv.CV_RGB2GRAY)
100 |     purple = (140, 25, 71)
101 | 
102 |     while True:
103 |         now = datetime.datetime.now()
104 |         _, image = camera.read()
105 |         gray_image = cv2.cvtColor(image, cv2.cv.CV_RGB2GRAY)
106 | 
107 |         difference1 = cv2.absdiff(previous_image, gray_image)
108 |         difference2 = cv2.absdiff(current_image, gray_image)
109 |         result = cv2.bitwise_and(difference1, difference2)
110 | 
111 |         # Basic threshold, turn the bitwise_and into a black or white (haha)
112 |         # result, white (255) being a motion
113 |         _, result = cv2.threshold(result, 40, 255, cv2.THRESH_BINARY)
114 | 
115 |         # Let's show a square around the detected motion in the original pic
116 |         low_point, high_point = utils.find_motion_boundaries(result.tolist())
117 |         if low_point is not None and high_point is not None:
118 |             cv2.rectangle(image, low_point, high_point, purple, 3)
119 |             print 'Motion detected ! Taking picture'
120 |             utils.save_image(image, folder, now)
121 | 
122 |         previous_image = current_image
123 |         current_image = gray_image
124 | 
125 |         if utils.time_over(until, now):
126 |             break
127 | 
128 |     del(camera)
129 | 
130 | if __name__ == "__main__":
131 |     arguments = docopt(__doc__)
132 | 
133 |     folder = arguments['--folder']
134 |     interval = int(arguments['--interval'])
135 |     until = arguments['--until']
136 | 
137 |     camera = cv2.VideoCapture(0)
138 | 
139 |     try:
140 |         if arguments['capture']:
141 |             start_camera(camera, folder, interval, until)
142 |         elif arguments['make_video']:
143 |             make_video(folder)
144 |         elif arguments['automate']:
145 |             start_camera(camera, folder, interval, until)
146 |             make_video(folder)
147 |         elif arguments['motion']:
148 |             motion_detection(camera, folder, until)
149 |     except KeyboardInterrupt:
150 |         # OpenCV doesn't like CTRL+C sometimes.
151 |         del(camera)
152 | 


--------------------------------------------------------------------------------
/utils.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | import cv2
 4 | 
 5 | 
 6 | def clear_directory(folder):
 7 |     """
 8 |     Delete all the pics in the given folder
 9 |     """
10 |     for filename in os.listdir(folder):
11 |         os.remove('%s/%s' % (folder, filename))
12 | 
13 | 
14 | def save_image(image, folder, now):
15 |     """
16 |     Save an image using OpenCV and then resaves it using
17 |     PIL for better compression
18 |     """
19 |     filename = '%s/%s.jpg'
20 |     filepath = filename % (folder, now)
21 |     cv2.imwrite(filepath, image, [cv2.cv.CV_IMWRITE_JPEG_QUALITY, 80])
22 | 
23 |     # Resave it with pillow to do a better compression
24 |     # img = Image.open(filepath)
25 |     # img.save(filepath, optimize=True, quality=80)
26 | 
27 | 
28 | def time_over(until, now):
29 |     """
30 |     Checks if we are over the time we want to film until.
31 |     Splits on every loop but it's not like it's a big
32 |     performance drain.
33 |     """
34 |     if until is None:
35 |         return False
36 | 
37 |     until_hour, until_minutes = until.split(':')
38 |     hour = int(until_hour)
39 |     minutes = int(until_minutes)
40 | 
41 |     # If we want to watch something overnight, now will be greater before midnight
42 |     if hour < 12 and now.hour > 12:
43 |         return False
44 |     if now.hour > hour or (now.hour == hour and now.minute >= minutes):
45 |         return True
46 | 
47 | 
48 | def find_motion_boundaries(data):
49 |     """
50 |     data is a numpy ndarray of the image following the format
51 |     [
52 |         [0, 0, 0, 0, 255, 0, ...]
53 |         [..]
54 |     ]
55 |     255 are the values we are interested in, which means a motion was
56 |     detected at that pixel.
57 |     We want to find out the smallest rectangle that matches all the
58 |     motions.
59 |     Returns 2 points forming the diagonal for the rectangle or None, None
60 |     if it didn't have any motion.
61 |     """
62 |     number_changes = 0
63 |     # Bear with me with these names
64 |     # this is going to be used to put a rectangle around where the motion
65 |     # is
66 |     low_x = len(data[0])
67 |     high_x = 0
68 |     low_y = len(data)
69 |     high_y = 0
70 | 
71 |     for i, row in enumerate(data):
72 |         for j, column in enumerate(row):
73 |             if column != 255:
74 |                 continue
75 | 
76 |             number_changes += 1
77 |             if low_y > i:
78 |                 low_y = i
79 |             if high_y < i:
80 |                 high_y = i
81 | 
82 |             if low_x > j:
83 |                 low_x = j
84 |             if high_x < j:
85 |                 high_x = j
86 | 
87 |     if number_changes == 0:
88 |         return None, None
89 | 
90 |     low_x = low_x - 5 if low_x >= 5 else low_x
91 |     low_y = low_y - 5 if low_y >= 5 else low_y
92 |     high_x = high_x + 5 if high_x >= len(data[0]) - 6 else high_x
93 |     high_y = high_y + 5 if high_y >= len(data) - 6 else high_y
94 | 
95 |     return (low_x, low_y), (high_x, high_y)
96 | 


--------------------------------------------------------------------------------