Revision as of 16:23, 15 March 2013

The MouseTrap Program

Here is a complete dissection of the hierarchy done by gnome: http://gnome-mousetrap.sourcearchive.com/documentation/0.3plus-psvn17-2ubuntu1/main.html

Definitions

Haar wavelet

First proposed by Alfred Haar, the Haar wavelet is a series of square-shaped functions that when shown together form a basis otherwise known as a wavelet family and expressed in terms of an orthonormal function basis. For more information, see: [[1]]

Haar-like features

Uses adjacent rectangular regions in a specified detection window, sums up the pixel intensities and calculates the difference between those sums. They are called Haar-like features because they are computed using similar coeffients in the Haar wavelet transforms. These regions can then be concatenated with boosted classifiers into a classifier cascade to cross reference these regions with other positive samples to form a model for object detection. For more information, see [[2]] [[3]]

Boosted Classifiers

The result of increasing the accuracy of a classifier cascade through the means of positive object recognition of scaled images.

Boosting

Attempts to produce new classifiers that are better able to predict examples for which the current ensemble's performance is poor. [[4]]

Classifier Cascade

Proposed by Paul Viola and refined by Rainer Lienhart, a classifier cascade

ROI (Region of Interest)

This is usually a subset of the original frame represented as a rectangle. It is most often compared to a classifier cascade to determine a positive match.

Ocvfw (OpenCV FrameWork)

A MouseTrap in house framework that manages OpenCV methods and includes functions to initiate the camera and detect further Haar-like features.

Optical flow

Detecting the pattern of motion of moving objects. [[5]] [[6]]

Lucas-Kanade method

Differential method to estimate optical flow, it combines several nearby pixels to resolve the ambiguity of the optical flow equation [[7]].

Singleton

Restricts the instantiation of a class to one object so coordination over program actions can be achieved.

Classes

app

main.py

• Loads the Image Detection Module (idm)

commons.py

• Stores global variables for Ocvfw

 * cv: OpenCV related variables
 * hg: OpenCV.highgui related variables. Set in ocvfw/idm/ color.py to be used in the creation of the Window and Trackbar
 * abs_path: the absolute path to the commons file
 * haar_cds: array with the haar xml file paths
 * colors: array with the types of colors the image can appear in
 * singleton: class instance to be passed through program globally

• Methods:

 get_ch(color): returns channel corresponding to the color given (rgb, bgr, gray)

environment.py

debug.py

• This is used to display messages to the command line
• Very helpful to troubleshoot

ui

main.py

lib

addons

OpenCV Framework (ocvfw)

• This is the wrapper around OpenCV
• View diagram here: [[8]]

ocvfw/ _ocv.py

• Contains three classes:

 OcvfwBase: direct copy of backends/ OcvfwBase
 OcvfwPython: direct copy of backends/ OcvfwPython
 OcvfwCtypes: direct copy of backends/ OcvfwCtypes

ocvfw/ idm

• Detects features based on an xml file

ctypesopencv

• This is used instead of the python bindings for OpenCV

pocv.py

• Returns an instance of the idm

ocvfw/ haars

• Used thousands of samples to concatenate an xml file to predict features

dev/ camera

• checks for gtk
• loads the camera backend
• sets Camera as a singleton with backend as the base
• Class Capture
  • first gets a region of interest and then matches it against a haar classifier
  • Sets all variables associated with video capture
  • Methods:

 set_async(fps, async): sets the frames per second and whether the image should have asynchronous querying.
                        If it is true, then it will set a gobject timeout of the specified frames per second
 sync(): Synchronizes the Capture image with the Camera image
 set_camera(key, value): sets the Camera object with key and value specified
 image(new_img): sets the self.__image variable to specified value
 resize(width, height, copy): manipulates the self.__image variable and resizes it using cv.Resize() and width
                              and height given, will not replace the self.__image if copy is True.
 to_gtk_buff(): Converts image to gtkImage and returns it
 points(): returns self.__graphics["point"], a list with rectangles that have been added?
 rectangles(): returns self.__graphics["rect"], a list with rectangles that have been added
 show_rectangles(rectangles): draws the rectangles onto the self.__image
 original(): returns the Capture object with the self.__image_orig image, setting the Capture to the original image
 rect(*args): uses the args (a rectangle) to get a sub-part of the self.__image using cv.GetSubRect()
 flip(flip): flip is a string that can contain 'hor' 'ver' or 'both' to use cv.Flip() to manipulate the
             self.__image. Returns self.__image
 color(new_color, channel, copy): if new_color is true it will set the image to the new channel provided.
                                  If copy is set, it will only manipulate a new image and keep the
                                  existing image as is.
 change(size, color, flip): will set self.__color_set to the new color value and set self.__flip
                            to the new flip value. Does not currently support the change in image size.
 add(graphic): has checks to see if the capture is locked or if the graphic exists already. Otherwise
               it will add the graphic passed to it to the image using set_lkpoint()
 remove(label): removes a graphic object from self.__graphics[] by its label. 
 get_area(haar_csd, roi, orig): uses the haartraining file (haar_csd) to it will use get_haar_points()
                                or get_haar_roi_points() depending whether roi is set. It can also get
                                the area within an area using the roi and setting the origin point.
 message(message): does nothing, just pass
 lock(): sets the self.__lock to true, which is used in add() and remove()
 unlock(): sets self.__lock to false
 is_locked(): returns self.__lock
 

• Classes

 Graphic()
   init(): x and y stored in a list coords[x, y]
           size: list [width, height]
           type: could be a point
           label: string
           color: rgb color or tuple
           follow: used for optical flow
           parent: what is the parent class
   is_point(): checks if type is true

 Point(): contains a graphic and additional variables and methods
   init(): graphic(**args)
           __ocv: opencv attribute
           last: opencv attribute
           diff: difference between two points
           abs_diff: difference between original and current
           rel_diff: difference between last and current
           orig: an opencv Point objec
   set_opencv(opencv): updates the current attributes, updates the points in abs_diff and rel_diff
                       and sets self.__ocv to opencv given
   opencv(): returns the graphic object with the opencv attributes (__ocv)

backend

• link to image on how the backend distributes variables ["]

• Contains three classes:

backend/ OcvfwBase

• sets image variables
• Methods:

 set(key, value): sets the key (image variables) to the value specified
 lk_swap(set): switches the boolean of the Lucas-Kanade points, if true, it will append current to last
 new_image(size, num, ch): Will CreatImage(size, depth, channel) using a Size(width, height), depth and channel
 set_camera_idx(idx): sets the global var self.idx to specified idx number
 wait_key(num): uses cv WaitKey() and inputs number specified
 start_camera(params): grabs the video capture and sets it as a global variable
 query_image: grabs the first frame and creates self.img, the pyramids and grey images for optical flow.
              Uses wait_key(). returns true
 set_lkpoint(point): uses cv.Point, sets the self.img_lkpoints image, uses dev/ camera.set_opencv()
                     to manipulate the graphic object (made my Mousetrap), sets the ["current"] using FindCornerSubPix()
                     and if ["last"] exists, it appends current, appends point to ["points"]
 clean_lkpoints(): sets self.img_lkpoints current, last and points to empty
 show_lkpoints(): calculates the optical flow and assigns it to the ["current"] lkpoints if it resolves.
                  Recursively goes through ["points"]  and draws them, then sets ["current"] back to points
 swap_lkpoints(): only after the new points were shown, swap prev with original and current with last

backend/ OcvfwPython

• inherits from OcvfwBase
• imports global and local variables from Commons.hg (highgui related variables) and Commons.cv(Opencv) variables
• has the ability to get_motion_points but is not used
• has the ability to add_message to the image shown but is not used
• Methods:

 get_haar_roi_points: finds regions of interest within the entire frame image and returns the matches against the classifier cascade
                      using the HaarDetectObjects() OpenCV function.
 get_haar_points: resizes the image by 1.5

backend/ OcvfwCtypes

• imports global and local variables from Commons.hg (highgui), Commons.cv(which is a CV common lib), and OcvfwBase

Files affected by OpenCV 2.4.3 upgrade

• main.py
• ocvfw
  • _ocv.py
  • ocvfw/ idm
    • eyes.py
    • finger.py
    • forehead.py
    • color.py
  • commons.py
  • ocvfw/ dev
    • camera.py
  • ocvfw/ backends
    • OcvfwBase.py
    • OcfwCtypes.py
    • OcvfwPython.py