zii/JustMotion
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
64fe9fcad0
JustMotion/README.md

112 lines
4.6 KiB
Markdown
Raw Normal View History

Changed comparison functions again decided to change frame comparison functions again from optical flow to a home brewed function that compares gray levels in the pixels of each frame. significant differences in gray levels between the frames can potentially trigger a motion event. also moved away command line arguments to an external config file to set app parameters. created a README file to get this project ready for general open source release.
2022-07-08 15:24:45 -04:00
# Motion Watch #
Motion Watch is a video surveillance application that monitors the video feeds
of an IP camera and records only footage that contains motion. The main
advantage of this is reduced storage requirements as opposed to continuous
recording because only video footage of interest is recorded to storage.
The entire app is designed to operate on just one camera but multiple instances
of this app can be used to operate multiple cameras.
### Usage ###
```
Usage: mow <argument>
-h : display usage information about this application.
-c : path to the config file.
```
### Config File ###
The config file is a simple text file that contain parameters that dictate the
behavior of the application. Below is an example of a config file with all
parameters supported and descriptions of each parameter.
```
v1.2 Update Video clips recorded from the camera are no longer append, instead the clips are kept as is and then linked together in a playlist file in the output_dir. this makes it much more efficient and easier to maintain code. Also discovered that ffmpeg have a tendency to stall mid execution of recording from the rtsp stream every now and then. added a work around in the form of calling ffmpeg via the timeout command instead of directly so it will force kill ffmpeg if it goes longer than the expected BUF_SZ. Increased BUF_SZ to 10 secs. Added a clause in the recording loop that will make it write out a second clip if motion was detected.
2022-09-11 12:56:32 -04:00
# Motion Watch config file v1.2
Changed comparison functions again decided to change frame comparison functions again from optical flow to a home brewed function that compares gray levels in the pixels of each frame. significant differences in gray levels between the frames can potentially trigger a motion event. also moved away command line arguments to an external config file to set app parameters. created a README file to get this project ready for general open source release.
2022-07-08 15:24:45 -04:00
#
# note all lines in this config file that starts with a '#' are ignored.
# also note to avoid using empty lines. if you're going to need an empty
# line, start it with a '#'
#
recording_stream = rtsp://1.2.3.4:554/h264
Major changes to application internals and efficiency increases removed all threads from the application as there is no used for them at at this time. instead, the application will now operate on a single event loop and now directly utilize use ffmpeg to record video footage instead of opencv's implementation. old code pulled tons of frames the detection stream at full speed, wasting a lot of cpu cycles. instead it will now pull frames in a steady speed at the new detect_fps value. doing this significantly reduced cpu usage and can potentially further reduce cpu usage for end users by pulling the fps value lower then the default.
2022-07-28 10:30:07 -04:00
# this is the url to the main stream of the IP camera that will be used
v1.1 Update major changes to the motion detection scheme and re-introduced multi-threading. this further sped up the motion detection to a point that it can now be called in line with the recording loop without loosing any extra camera footage due to heavy cpu usage. pixels are now read in blocks to further increase efficiency and to filter out movements of small objects. the footage clip size is now hard coded to 3 seconds instead of it being external adjustable. changed the way footage with motion is now stored. its now down to single level files with the current date. if footage of the same date already exists, new footage will be appended to it. the version number shall be updated going forward.
2022-08-12 21:46:36 -04:00
# to record footage.
Changed comparison functions again decided to change frame comparison functions again from optical flow to a home brewed function that compares gray levels in the pixels of each frame. significant differences in gray levels between the frames can potentially trigger a motion event. also moved away command line arguments to an external config file to set app parameters. created a README file to get this project ready for general open source release.
2022-07-08 15:24:45 -04:00
#
output_dir = /path/to/footage/directory
# this is the output directory that will be used to store recorded footage
v1.2 Update Video clips recorded from the camera are no longer append, instead the clips are kept as is and then linked together in a playlist file in the output_dir. this makes it much more efficient and easier to maintain code. Also discovered that ffmpeg have a tendency to stall mid execution of recording from the rtsp stream every now and then. added a work around in the form of calling ffmpeg via the timeout command instead of directly so it will force kill ffmpeg if it goes longer than the expected BUF_SZ. Increased BUF_SZ to 10 secs. Added a clause in the recording loop that will make it write out a second clip if motion was detected.
2022-09-11 12:56:32 -04:00
# from the camera. the file naming convention uses the current date for
# playlist files which points to hidden video clips taken from the camera.
Major changes to application internals and efficiency increases removed all threads from the application as there is no used for them at at this time. instead, the application will now operate on a single event loop and now directly utilize use ffmpeg to record video footage instead of opencv's implementation. old code pulled tons of frames the detection stream at full speed, wasting a lot of cpu cycles. instead it will now pull frames in a steady speed at the new detect_fps value. doing this significantly reduced cpu usage and can potentially further reduce cpu usage for end users by pulling the fps value lower then the default.
2022-07-28 10:30:07 -04:00
#
v1.1 Update major changes to the motion detection scheme and re-introduced multi-threading. this further sped up the motion detection to a point that it can now be called in line with the recording loop without loosing any extra camera footage due to heavy cpu usage. pixels are now read in blocks to further increase efficiency and to filter out movements of small objects. the footage clip size is now hard coded to 3 seconds instead of it being external adjustable. changed the way footage with motion is now stored. its now down to single level files with the current date. if footage of the same date already exists, new footage will be appended to it. the version number shall be updated going forward.
2022-08-12 21:46:36 -04:00
buff_dir = /tmp/ramdisk/cam_name
# this application records small clips of the footage from the camera and
# then stores them into this directory. any clips with motion detected in
# them are moved to output_dir, if no motion they are deleted. highly
# recommend to use a ramdisk tempfs for this since this directory is used
# for lots of writes.
Major changes to application internals and efficiency increases removed all threads from the application as there is no used for them at at this time. instead, the application will now operate on a single event loop and now directly utilize use ffmpeg to record video footage instead of opencv's implementation. old code pulled tons of frames the detection stream at full speed, wasting a lot of cpu cycles. instead it will now pull frames in a steady speed at the new detect_fps value. doing this significantly reduced cpu usage and can potentially further reduce cpu usage for end users by pulling the fps value lower then the default.
2022-07-28 10:30:07 -04:00
#
v1.1 Update major changes to the motion detection scheme and re-introduced multi-threading. this further sped up the motion detection to a point that it can now be called in line with the recording loop without loosing any extra camera footage due to heavy cpu usage. pixels are now read in blocks to further increase efficiency and to filter out movements of small objects. the footage clip size is now hard coded to 3 seconds instead of it being external adjustable. changed the way footage with motion is now stored. its now down to single level files with the current date. if footage of the same date already exists, new footage will be appended to it. the version number shall be updated going forward.
2022-08-12 21:46:36 -04:00
color_threshold = 8
v1.2 Update Video clips recorded from the camera are no longer append, instead the clips are kept as is and then linked together in a playlist file in the output_dir. this makes it much more efficient and easier to maintain code. Also discovered that ffmpeg have a tendency to stall mid execution of recording from the rtsp stream every now and then. added a work around in the form of calling ffmpeg via the timeout command instead of directly so it will force kill ffmpeg if it goes longer than the expected BUF_SZ. Increased BUF_SZ to 10 secs. Added a clause in the recording loop that will make it write out a second clip if motion was detected.
2022-09-11 12:56:32 -04:00
# the color levels in each pixel of the camera stream can range from 0-255.
# in an ideal world the color differences in between frames should be 0 if
# there is no motion but must cameras can't do this. the threshold value
# here is used to filter if the pixels are truly different.
Major changes to application internals and efficiency increases removed all threads from the application as there is no used for them at at this time. instead, the application will now operate on a single event loop and now directly utilize use ffmpeg to record video footage instead of opencv's implementation. old code pulled tons of frames the detection stream at full speed, wasting a lot of cpu cycles. instead it will now pull frames in a steady speed at the new detect_fps value. doing this significantly reduced cpu usage and can potentially further reduce cpu usage for end users by pulling the fps value lower then the default.
2022-07-28 10:30:07 -04:00
#
v1.1 Update major changes to the motion detection scheme and re-introduced multi-threading. this further sped up the motion detection to a point that it can now be called in line with the recording loop without loosing any extra camera footage due to heavy cpu usage. pixels are now read in blocks to further increase efficiency and to filter out movements of small objects. the footage clip size is now hard coded to 3 seconds instead of it being external adjustable. changed the way footage with motion is now stored. its now down to single level files with the current date. if footage of the same date already exists, new footage will be appended to it. the version number shall be updated going forward.
2022-08-12 21:46:36 -04:00
block_threshold = 3456
# this application detects motion by loading frames from the camera and
# then compare the pixels of each back to back frame for any significant
# differences between the pixels based on color_threshold. it loads the
# pixels of each frame in blocks. the size of the blocks are adjustable
# below. it counts how many pixels are different in the block and this is
# used to tell if the footage has motion if the different pixel count
# exceeds it.
#
block_x = 64
# this is the x coordinate size or horizontal size of a block of pixels
# that the application will use to detect the presents of motion.
#
block_y = 60
# this is the y coordinate size or vertical size of a block of pixels
# that the application will use to detect the presents of motion.
Changed comparison functions again decided to change frame comparison functions again from optical flow to a home brewed function that compares gray levels in the pixels of each frame. significant differences in gray levels between the frames can potentially trigger a motion event. also moved away command line arguments to an external config file to set app parameters. created a README file to get this project ready for general open source release.
2022-07-08 15:24:45 -04:00
#
duration = 60
Major changes to application internals and efficiency increases removed all threads from the application as there is no used for them at at this time. instead, the application will now operate on a single event loop and now directly utilize use ffmpeg to record video footage instead of opencv's implementation. old code pulled tons of frames the detection stream at full speed, wasting a lot of cpu cycles. instead it will now pull frames in a steady speed at the new detect_fps value. doing this significantly reduced cpu usage and can potentially further reduce cpu usage for end users by pulling the fps value lower then the default.
2022-07-28 10:30:07 -04:00
# this sets the internal timer used to reset to the detection loop and
v1.1 Update major changes to the motion detection scheme and re-introduced multi-threading. this further sped up the motion detection to a point that it can now be called in line with the recording loop without loosing any extra camera footage due to heavy cpu usage. pixels are now read in blocks to further increase efficiency and to filter out movements of small objects. the footage clip size is now hard coded to 3 seconds instead of it being external adjustable. changed the way footage with motion is now stored. its now down to single level files with the current date. if footage of the same date already exists, new footage will be appended to it. the version number shall be updated going forward.
2022-08-12 21:46:36 -04:00
# then call post_cmd if it is defined. note: this time is extended if
Major changes to application internals and efficiency increases removed all threads from the application as there is no used for them at at this time. instead, the application will now operate on a single event loop and now directly utilize use ffmpeg to record video footage instead of opencv's implementation. old code pulled tons of frames the detection stream at full speed, wasting a lot of cpu cycles. instead it will now pull frames in a steady speed at the new detect_fps value. doing this significantly reduced cpu usage and can potentially further reduce cpu usage for end users by pulling the fps value lower then the default.
2022-07-28 10:30:07 -04:00
# motion was detected. this will also reload the config file so changes
v1.1 Update major changes to the motion detection scheme and re-introduced multi-threading. this further sped up the motion detection to a point that it can now be called in line with the recording loop without loosing any extra camera footage due to heavy cpu usage. pixels are now read in blocks to further increase efficiency and to filter out movements of small objects. the footage clip size is now hard coded to 3 seconds instead of it being external adjustable. changed the way footage with motion is now stored. its now down to single level files with the current date. if footage of the same date already exists, new footage will be appended to it. the version number shall be updated going forward.
2022-08-12 21:46:36 -04:00
# to the settings will be applied without restarting the application.
Changed comparison functions again decided to change frame comparison functions again from optical flow to a home brewed function that compares gray levels in the pixels of each frame. significant differences in gray levels between the frames can potentially trigger a motion event. also moved away command line arguments to an external config file to set app parameters. created a README file to get this project ready for general open source release.
2022-07-08 15:24:45 -04:00
#
post_cmd = move_the_ptz_camera.py
# this an optional command to run after the internal timer duration has
# elapsed. one great use for this is to move a ptz camera to the next
Major changes to application internals and efficiency increases removed all threads from the application as there is no used for them at at this time. instead, the application will now operate on a single event loop and now directly utilize use ffmpeg to record video footage instead of opencv's implementation. old code pulled tons of frames the detection stream at full speed, wasting a lot of cpu cycles. instead it will now pull frames in a steady speed at the new detect_fps value. doing this significantly reduced cpu usage and can potentially further reduce cpu usage for end users by pulling the fps value lower then the default.
2022-07-28 10:30:07 -04:00
# position of it's patrol pattern. note: the call to this command can be
# delayed if motion was detected.
Changed comparison functions again decided to change frame comparison functions again from optical flow to a home brewed function that compares gray levels in the pixels of each frame. significant differences in gray levels between the frames can potentially trigger a motion event. also moved away command line arguments to an external config file to set app parameters. created a README file to get this project ready for general open source release.
2022-07-08 15:24:45 -04:00
#
v1.2 Update Video clips recorded from the camera are no longer append, instead the clips are kept as is and then linked together in a playlist file in the output_dir. this makes it much more efficient and easier to maintain code. Also discovered that ffmpeg have a tendency to stall mid execution of recording from the rtsp stream every now and then. added a work around in the form of calling ffmpeg via the timeout command instead of directly so it will force kill ffmpeg if it goes longer than the expected BUF_SZ. Increased BUF_SZ to 10 secs. Added a clause in the recording loop that will make it write out a second clip if motion was detected.
2022-09-11 12:56:32 -04:00
max_days = 15
# this defines the maximum amount of days worth of video clips that is
# allowed to be stored in the output_dir. whenever this limit is met,
# the oldest day is deleted.
#
vid_container = mp4
# this is the video file format to use from recording footage from the
# camera. the format support depends entirely on the under laying ffmpeg
# installation.
Changed comparison functions again decided to change frame comparison functions again from optical flow to a home brewed function that compares gray levels in the pixels of each frame. significant differences in gray levels between the frames can potentially trigger a motion event. also moved away command line arguments to an external config file to set app parameters. created a README file to get this project ready for general open source release.
2022-07-08 15:24:45 -04:00
```
Compile and installation method updates created setup, build and install scripts to make it easier and convenient to compile and install the application from source. no plans distribute pre-compiled binaries because it's just so much easier to guarantee the application will actually work in the target machine when compiled by the target machine.
2022-09-17 09:53:52 -04:00
### Setup/Build/Install ###
Changed comparison functions again decided to change frame comparison functions again from optical flow to a home brewed function that compares gray levels in the pixels of each frame. significant differences in gray levels between the frames can potentially trigger a motion event. also moved away command line arguments to an external config file to set app parameters. created a README file to get this project ready for general open source release.
2022-07-08 15:24:45 -04:00
This application is currently only compatible with a Linux based operating
systems that are capable of building and installing the opencv API from source.
Major changes to application internals and efficiency increases removed all threads from the application as there is no used for them at at this time. instead, the application will now operate on a single event loop and now directly utilize use ffmpeg to record video footage instead of opencv's implementation. old code pulled tons of frames the detection stream at full speed, wasting a lot of cpu cycles. instead it will now pull frames in a steady speed at the new detect_fps value. doing this significantly reduced cpu usage and can potentially further reduce cpu usage for end users by pulling the fps value lower then the default.
2022-07-28 10:30:07 -04:00
Compile and installation method updates created setup, build and install scripts to make it easier and convenient to compile and install the application from source. no plans distribute pre-compiled binaries because it's just so much easier to guarantee the application will actually work in the target machine when compiled by the target machine.
2022-09-17 09:53:52 -04:00
The following 3 scripts make this convenient by downloading, compiling and then
installing the opencv API for you directly from opencv's git repository. This
also makes sure FFMPEG and all of it's dependencies are installed because this
application needs it to work properly.
note 1: be sure to run setup.sh and install.sh as root (or use sudo).
note 2: if building from scratch the following scripts will need to
be run in this order - setup.sh -> build.sh -> install.sh.
Changed comparison functions again decided to change frame comparison functions again from optical flow to a home brewed function that compares gray levels in the pixels of each frame. significant differences in gray levels between the frames can potentially trigger a motion event. also moved away command line arguments to an external config file to set app parameters. created a README file to get this project ready for general open source release.
2022-07-08 15:24:45 -04:00
```
Compile and installation method updates created setup, build and install scripts to make it easier and convenient to compile and install the application from source. no plans distribute pre-compiled binaries because it's just so much easier to guarantee the application will actually work in the target machine when compiled by the target machine.
2022-09-17 09:53:52 -04:00
sh ./setup.sh <--- only need to run this once if compiling for the first
sh ./build.sh time or if upgrading from the ground up.
sh ./install.sh
Changed comparison functions again decided to change frame comparison functions again from optical flow to a home brewed function that compares gray levels in the pixels of each frame. significant differences in gray levels between the frames can potentially trigger a motion event. also moved away command line arguments to an external config file to set app parameters. created a README file to get this project ready for general open source release.
2022-07-08 15:24:45 -04:00
```
Reference in New Issue Copy Permalink