From 09c3f09e081fde25df72da4e88272b05edbe88ce Mon Sep 17 00:00:00 2001 From: Julien Lengrand-Lambert Date: Thu, 31 May 2012 10:59:28 +0200 Subject: [PATCH] Adds Documentation for the code. Trying to include Sphinx auto generated doc --- README.markdown | 8 +- README.rst | 143 ------------------------------------ facemovie/Eye.py | 33 ++++++--- facemovie/Face.py | 33 ++++++--- facemovie/FaceParams.py | 32 +++++--- facemovie/Facemovie.py | 101 ++++++++++++++++++++----- facemovie/Facemoviefier.py | 25 +++++-- facemovie/Guy.py | 93 ++++++++++++++++++----- facemovie/__init__.py | 7 ++ facemovie/facemovie.rst | 7 ++ facemovie/lib/__init__.py | 6 ++ facemovie/training_types.py | 12 ++- test/exif_test.py | 12 --- test/test_script.py | 33 --------- 14 files changed, 277 insertions(+), 268 deletions(-) delete mode 100644 README.rst create mode 100644 facemovie/facemovie.rst delete mode 100755 test/exif_test.py delete mode 100644 test/test_script.py diff --git a/README.markdown b/README.markdown index e35163c..3fcfd4e 100644 --- a/README.markdown +++ b/README.markdown @@ -10,7 +10,7 @@ The main difference with everyday is that Facemovie searches automatically for f Due to its general implementation, FaceMovie may be used for faces, but also profiles (for projects showing [women along pregnancy for example](http://www.youtube.com/watch?v=CG_KArKYTq4) or full body([for people workouting](http://www.youtube.com/watch?v=02Pzfv7JV48)). The only limitation comes from you ! -**[You can check out an example of video here.](http://www.youtube.com/watch?v=2pUHK7Sf23I)** +**[You can check out an example of video here.](http://www.youtube.com/watch?v=2pUHK7Sf23I)**. ## Getting started @@ -24,7 +24,7 @@ Please not that you best pick as this stage would be to choose the executable. This is the current safest and easiest solution for you. Download the archive available [here](). By default, choose the full archive. -The light archive is intended for users having Python2.7 already installed on their system. +The light archive is intended for users having Python2.7 already installed on their system. In this case, a python.dll is given with the executable. Uncompress the archive. It contains three elements : - The executable itself, called Facemovifier.exe. @@ -195,4 +195,6 @@ I never experienced any problem using the software, but you should always back u I would enjoy having feedback if you like this idea, or even used it. Send me a link to your creations so that I can put them here ! Feel free to mail me for any comment or request. -You can contact me at julien at lengrand dot fr, or on my [current website](http://www.lengrand.fr). \ No newline at end of file +You can contact me at julien at lengrand dot fr, or on my [current website](http://www.lengrand.fr). + +Version : 0.8.1 \ No newline at end of file diff --git a/README.rst b/README.rst deleted file mode 100644 index 7c7f14d..0000000 --- a/README.rst +++ /dev/null @@ -1,143 +0,0 @@ -Take one picture of yourself a day, simply get the results! -=========================================================== - -**`FaceMovie `_** is a -simple project that aims at helping you create videos of yourself over -time, using photos as input. I see a growing interest for this kind of -projects, where people take one picture of themselves a day for several -months (years ?) and compile it into a -`video `_. I started this -project for a friend currently `travelling around the -world `_. He wanted to create a -video of his face changes along the trip. - -The main idea is simple. The software takes a batch of images as input. -The images are assumed to be named by date (so that an alphabetical -order is also the chronological order). The output is a video containing -each image, where the face is always placed in the same position. This -way, people can actually see the face change over time. - -**`You can check out the last results in video here -! `_** - -\*\*In progress: \*\* - -- The very central part of the code is finished. -- I currently work on video quality enhancement (compression, speed, - fade effects, ...) -- I plan to include a GUI to help people use the software, and later - add support for a broader type of input images (profiles, eyes, - glasses, . . .) -- I also think about a way for user to help the software in case it - struggles with images (by manually pointing face on problematic - images?). -- Any other idea is welcome - -Getting started ---------------- - -I have just started searching for a nice way to package the application -in a single executable, which means if you want to test Facemovie you -will have to directly run the code in the development branch. - -In this part, I will thus consider that you have Python 2.7 and OpenCV -(and of course its Python bindings) installed on your machine. To get -the last version of Facemovie, simply clone the project from Github -``git clone git://github.com/jlengrand/FaceMovie.git`` - -You will also need to have a bunch of photos of your face stored in a -folder. Those images should contain only one person; and you should try -to always keep the same angle with the camera. If you dont, some samples -are included in the project (placed in data/input/Axel) - -Since version 0.4, Facemovie supports user interaction through the -Facemovifier. That means that you should be able to run the application -without modifying it. If you are like me, you ight want to start by -calling the helper : ``$ python Facemoviefier -h`` which will list the -available parameters in the application. - -The simplest example you can run would be : -``$ python Facemoviefier -i input_folder -o output_folder`` , where -input\_folder and output\_folder are strings. If you place yourself in -the facemovie folder and run the application from here, this line should -work : -``$ python Facemoviefier -i "../data/input/Axel" -o "../data/output"`` - -If you decide to run the Facemovifier from another location, you should -update the folders accordingly, and use the root\_folder option: -``$ python Facemoviefier -i input_folder -o output_folder -r facemovie_folder_location`` - -You might want to save images instead of a movie as output: -``$ python Facemoviefier -i "../data/input/Axel" -o "../data/output" -t i`` - -And if you have profile images, you can (must) also decide to change the -file used for training the classifier: -``$ python Facemoviefier -i "../data/input/Axel" -o "../data/output" -p "profile face"`` -An extensive list of training files is available while calling the -helper. - -Options available in the Facemoviefier -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -**Required :** - -- -i, --input : Input folder of the images to be processed -- -o, --output : Output folder where the final results will be saved - -**Optional :** - -- -h, --help : Shows help message and exits -- -r, --root : Location of the facemovie folder. Required if you run - the Facemovifier from an external location -- -e, --equalize : If this option is activated, images will NOT be - resized so that all faces have the same size. -- -p, --param: Used to change the file used to train the classifier. - Useful you want to detect something else than front faces. -- -t, --type : The type of output to be created. Can be either images, - video or simple display (nothing written on disc). - -Libraries ---------- - -This piece of code is developed in `Python `_, -simply because I love it :P (and because it allows easy testing while -developing Image Processing applications). I used Python 2.7 for -development. The only library needed to run the code for now is -`Opencv `_ (and by extension -`Numpy `_). See `the -documentation `_ for -more information. - -This project is developed on a Windows (7) platform, but there should -(and, as a fanatic Linux User, will) be no compatibility problems with -UNIX. - -License -------- - -This project is released under the new BSD license (3 clauses version). -You can read more about the license in the LICENSE file. - -Acknowledgment --------------- - -This project comes from an idea of Axel Catoire, currently `travelling -around the world `_ with his -girlfriend. He also provides me with new pictures :). - -As a starter for my code, I used an excellent example from JAPSKUA, that -you can find -`here `_ - -Contact -------- - -I would enjoy having feedback if you like this idea, or even used it -(even though you should change the source code to run it for now :) ). I -would also like to know if you have heard about any other solution to -make this kind of stuff ! (Couldn't find any but this Iphone -`app `_ on the internet !) Feel free to mail -me for any comment or request. - -You can contact me at julien at lengrand dot fr, or on my `current -website `_. diff --git a/facemovie/Eye.py b/facemovie/Eye.py index f1299c2..631989d 100644 --- a/facemovie/Eye.py +++ b/facemovie/Eye.py @@ -1,17 +1,30 @@ -''' -Created on 29 mars 2012 +""" +.. module:: Eye + :platform: Unix, Windows + :synopsis: Class defining an Eye in the sense of the FaceMovie -@author: jll -''' +.. moduleauthor:: Julien Lengrand-Lambert + +""" class Eye(object): - ''' - Created is an Eye-like blob is found using the Face Detection algorithm. - ''' + """ + Eye-like blob used in the Face Detection algorithm. + + .. note:: + + This class **is not used for now**, but should get useful when implementing + the use interaction feature + """ def __init__(self): - ''' - Constructor - ''' + """A facemovie redefinition of the human eye + Args: + x_pos (int) : x position of the eye in the image (in pixels) + y_pos (int) : y position of the eye in the image (in pixels) + x_size (int) : x size of the blob (in pixels) + y_size (int) : y size of the blob (in pixels) + conf (float) : confidence indice, indicating the probability of the target to actually be an eye + """ x_pos = None # x position of the eye in the image y_pos = None # y position of the eye in the image x_size = None # x size of the blob in pixel diff --git a/facemovie/Face.py b/facemovie/Face.py index e29672a..eab2081 100644 --- a/facemovie/Face.py +++ b/facemovie/Face.py @@ -1,17 +1,30 @@ -''' -Created on 29 mars 2012 +""" +.. module:: Face + :platform: Unix, Windows + :synopsis: Class defining a Face in the sense of the FaceMovie -@author: jll -''' +.. moduleauthor:: Julien Lengrand-Lambert + +""" class Face(object): - ''' - Created is an Face-like blob is found using the Face Detection algorithm. - ''' + """ + Face-like blob used in the Face Detection algorithm. + + .. note:: + + This class is the very root of our detection part for now; as Eye is not yet used. + We use Faces to store data while processing images + """ def __init__(self): - ''' - Constructor - ''' + """A facemovie redifinition of the human face. + + x_pos (int) : x position of the face in the image (in pixels) + y_pos (int) : y position of the face in the image (in pixels) + x_size (int) : x size of the blob (in pixels) + y_size (int) : y size of the blob (in pixels) + conf (float) : confidence indice, indicating the probability of the target to actually be an face + """ x_center = None # x position of the face in the image y_center = None # y position of the face in the image x_size = None # x size of the blob in pixel diff --git a/facemovie/FaceParams.py b/facemovie/FaceParams.py index 1285cce..c9293e7 100644 --- a/facemovie/FaceParams.py +++ b/facemovie/FaceParams.py @@ -1,8 +1,11 @@ -''' -Created on 30 mars 2012 +""" +.. module:: FaceParams + :platform: Unix, Windows + :synopsis: Simple class used to store parameters used for Face detection. -@author: jll -''' +.. moduleauthor:: Julien Lengrand-Lambert + +""" import cv import os @@ -13,12 +16,21 @@ class FaceParams(object): Simple class used to store parameters used for Face detection ''' def __init__(self, xml_folder, training_type, i_scale=2, h_scale=1.2, h_flags=0, mn=2): - ''' - Constructor - ''' - # Creates dictionary for all types of training files - # some of them shall never be used. Perhaps would it be good to lower the dict size, or hide some of them - # postpend .xml + """ + Creates dictionary for all types of training files + some of them shall never be used. Perhaps would it be good to lower the dict size, or hide some of them + postpend .xml + + Args: + xml_folder (string) : the location where xml files are located + training_type (string) : the type of profile we are going to use + KArgs: + i_scale (float) : Image scaling chosen for classification + h_scale (float) : Haar scaling chosen for classification + h_flags (int) : the chosen number of haar flags + mn (int) : the Minimum number of neighbors to be defined + """ + cascade_name = training_types.simple_set[training_type] + ".xml" # Setting up some default parameters for Face Detection print os.path.join(xml_folder, cascade_name) diff --git a/facemovie/Facemovie.py b/facemovie/Facemovie.py index 6c596e3..726b691 100644 --- a/facemovie/Facemovie.py +++ b/facemovie/Facemovie.py @@ -1,27 +1,43 @@ -''' -Created on 27 mars 2012 +""" +.. module:: Facemovie + :platform: Unix, Windows + :synopsis: Main class of the application. Contains the core image processing + functions. + Plays the role of a controller for the application, as it supports the + communication layer with the end user interface. -@author: jll -''' +.. moduleauthor:: Julien Lengrand-Lambert + +""" import os import sys import cv + from facemovie.lib import exif - from facemovie import Guy - class FaceMovie(object): ''' Main class of the whole application. Contains the core image processing functions. - Supports the communication layer with the end user interface. + Takes a bunch of parameters and a list of images and tries to create a + video out of it. + Contains general methods, aimed at being used trough an interface. ''' def __init__(self, in_folder, out_folder, face_params): - ''' - Constructor - ''' + """ + Initializes all parameters of the application. Input and output folders + are defined, together with the classifier profile. + + Args: + in_folder (string) : the location where input files will be + searched + out_folder (string) : the location where the outputs will be + saved + face_param (string) : the location of the profile file used + to train the classifier + """ self.source= in_folder # Source folder for pictures self.out = out_folder # Folder to save outputs @@ -54,13 +70,19 @@ class FaceMovie(object): def set_crop_dims(self, crop_x, crop_y): """ Sets the cropping dimension in case they have been provided by the end user + + Args: + crop_x (int) : dimension of the desired cropping in x (in number of face size) + crop_y (int) : dimension of the desired cropping in y (in number of face size) """ self.cropdims = [crop_x, crop_y] def list_guys(self): """ Aims at populating the guys list, using the source folder as an input. - Guys list shall be sorted by file name alphabetical order + Guys list shall be sorted chronologically. + In case no valid date is found, it is set to ''. + """ try: os.path.exists(self.source) @@ -100,6 +122,10 @@ class FaceMovie(object): """ Searches for all faces in the guys we have Results to be stored directly in guys + + Takes each image one after the other, and create a guy out of it. + The Face of each guy is searched. + In case no face is found, a warning is returned and Guy is set to None """ for a_guy in self.guys: a_guy.search_face(self.face_params) @@ -111,6 +137,11 @@ class FaceMovie(object): def normalize_faces(self, reference=0): """ Creates new images, normalized by face size + A reference is given in input. The idea is to get all images to have the + same size in Guy. + + KArgs: + reference (int) : the reference size of the face that we want to have """ # FIXME: May be enhanced by choosing a more educated reference if reference == 0: @@ -125,6 +156,8 @@ class FaceMovie(object): """ Returns the mean size of all faces in input Used to correctly crop images + + **Designed for internal use only** """ tot_x = 0 tot_y = 0 @@ -139,8 +172,10 @@ class FaceMovie(object): self.face_mean = [float(tot_x) / nb_face, float(tot_y) / nb_face] def find_crop_dims(self): - """ + """ Calculates smallest output image that can be used to avoid adding black borders on image + It will later be used to create the final image. + The idea is the same as for :func:find_out_dims , but while avoiding black brders. """ ht = 1000000 # space left above eyes hb = 1000000 # space left beneath eyes @@ -184,6 +219,10 @@ class FaceMovie(object): """ Calculates best output image size and position depending on faces found in guys. + The system is simple. The output image should be as big as possible, + and faces are always placed in the same position. Depending on that, + the image input image is placed in the output at the correct position. + Black borders are set everywhere else. """ # FIXME: badly done ! for a_guy in self.guys: @@ -213,6 +252,9 @@ class FaceMovie(object): def crop_im(self, image): """ If needed, crops the image to avoid having black borders. + + Args: + image (IplImage) : the image to be cropped """ # TODO : implement width = self.width#[0, 0] @@ -237,7 +279,9 @@ class FaceMovie(object): """ Show all faces that have been found for the guys. The time for which each image will be displayed can be chosen. - Several modes can be chosen to adapt the result. + + KArgs : + mytime (int) : time for which the image should be displayed (in ms) """ for a_guy in self.guys: if a_guy.has_face(): @@ -252,7 +296,12 @@ class FaceMovie(object): def save_faces(self, out_folder, im_format="png"): """ Save all faces into out_folder, in the given image format - Debug is used to draw rectangles around found faces + + Args: + out_folder (string) : the location where to save the output image. + + KArgs : + mytime (int) : time for which the image should be displayed (in ms) """ for a_guy in self.guys: if a_guy.has_face(): @@ -269,9 +318,11 @@ class FaceMovie(object): Creates a movie with all faces found in the inputs. Guy is skipped if no face is found. - TODO : No codec involved ! - TODO : Can FPS be changed? - Resize should be done somewhere else ! + Args: + out_folder (string) : the location where to save the output image. + + KArgs : + fps (int) : the number of frames per second to be displayed in final video """ filename = os.path.join(out_folder, "output.avi") fourcc = cv.CV_FOURCC('C', 'V', 'I', 'D') @@ -303,7 +354,8 @@ class FaceMovie(object): def number_guys(self): """ Simply returns the number of guys in the current to-be movie - """ + __Designed for interface use only__ + """ return len(self.guys) def out_display(self, im, name, time=1000, im_x=640, im_y=480): @@ -311,6 +363,13 @@ class FaceMovie(object): Displays the output image, for time ms. Setting time to 0 causes the image to remains open. Window name slightly changed to match output + Args: + im (IplImage) : the image to be saved, formatted as an OpenCV Image + name (string) : the name of the image to be saved + KArgs : + time (int) : time for which the image should be displayed (in ms) + im_x (int) : output size of the displayed image (in pixels) + im_y (int) : output size of the displayed image (in pixels) """ win_name = name + " - out" cv.NamedWindow(win_name, cv.CV_WINDOW_NORMAL) @@ -322,6 +381,12 @@ class FaceMovie(object): def save_result(self, im, name, out_folder, ext): """ Saves output image to the given format (given in extension) + + Args: + im (IplImage) : the image to be saved, formatted as an OpenCV Image + name (string) : the name of the image to be saved + out_folder (string) : the location where to save the image + ext (string) : Format in which the image should be saved """ file_name = name + "." + ext out_name = os.path.join(out_folder, file_name) diff --git a/facemovie/Facemoviefier.py b/facemovie/Facemoviefier.py index 213a06a..490bae4 100644 --- a/facemovie/Facemoviefier.py +++ b/facemovie/Facemoviefier.py @@ -1,8 +1,12 @@ -''' -Created on 29 mars 2012 +""" +.. module:: FaceMovifier + :platform: Unix, Windows + :synopsis: Higher class of the application. Used to handle the command line interface. + Direclty interfaces user commands with FaceMovie actions. -@author: jll -''' +.. moduleauthor:: Julien Lengrand-Lambert + +""" # This file should never be imported anywhere import os @@ -18,12 +22,17 @@ class Facemoviefier(): Class defining the interactions with the end user. Should be used as point of entry for all end users. """ - def __init__(self): - #inits Command Line Parser + def __init__(self): + """ + Inits the Command Line Parser on Startup + """ self.args = self.initCLParser() def init_facemovie(self): - # FIXME : par folder should be known (contained somewhere in the installation) + """ + Inits the Facemovie parameters, so that it can be run efficiently + FIXME : par folder should be known (contained somewhere in the installation) + """ par_fo = os.path.join(self.args['root'], "haarcascades") self.face_params = FaceParams.FaceParams(par_fo, self.args['param']) self.facemovie = Facemovie.FaceMovie(self.args['input'], self.args['output'], self.face_params) @@ -31,6 +40,7 @@ class Facemoviefier(): def initCLParser(self): """ Inits and Configures the command line parser designed to help the user configure the application + Defines all possible options, and also creats the Helper. """ parser = argparse.ArgumentParser(description="Creates a movie from a bunch of photos containing a Face.") @@ -100,6 +110,7 @@ class Facemoviefier(): def run(self): """ Runs all the steps needed to get the desired output + Checks which parameters have been run, and runs the algorithm accordingly. """ # selects xml used to train the classifier if self.args['param'] == '?': diff --git a/facemovie/Guy.py b/facemovie/Guy.py index c7b042f..b51b02c 100644 --- a/facemovie/Guy.py +++ b/facemovie/Guy.py @@ -1,21 +1,29 @@ -''' -Created on 29 mars 2012 +""" +.. module:: Guy + :platform: Unix, Windows + :synopsis: Class defining a Guy in the sense of the FaceMovie. Corresponds + to one input image. An input folder is transformed in fact to a list of guys. -@author: jll -''' +.. moduleauthor:: Julien Lengrand-Lambert + +""" import cv import time class Guy(object): - ''' - Represents the user on the people at a fixed time. - All data found for this time may be found here. - ''' + """ + A new Guy is declared for each input image. + A Guy should have a face, and owns the input image. + + """ def __init__(self, image, image_id, date): - ''' - Constructor - ''' + """All data linked to an input image + Args: + image (IplImage) : the input image, formatted as an OpenCV Image + image_id (string) : the name of the image, formatted as a string + date (datetime) : the date where the input image was taken. + """ self.in_x = None self.in_y = None @@ -39,9 +47,16 @@ class Guy(object): cv.Copy(image, self.in_image) def find_date(self, date): - """ - Transforms given string formatted date into proper date - Used afterwards to sort images + """This function takes a date as a string, and returns a date object. + Used afterwards to sort images chronologically + + Args: + date (str): The date where the image was taken + + Returns: + datetime. Returns a date object according to time library. + + In case of error, set the date to be the current time. """ try: my_date = time.strptime(date, "%Y:%m:%d %H:%M:%S") @@ -54,6 +69,13 @@ class Guy(object): Search on the picture for a face. Populates faces list. This function is the only one containing scaling information + + Set several Guy information, such as the face size, or the virtual center of the image + + Args: + face_params (str): The type of file to be used to train the classifier. + + Once Faces have been found, they are listed and ordered """ # Allocate the temporary images gray = cv.CreateImage((self.in_x, self.in_y), @@ -99,7 +121,14 @@ class Guy(object): def sort_faces(self): """ - sort faces by number of neighbours found, most probable one first + Sorts faces by number of neighbours found, most probable one first + + Args: + face_params (str): The type of file to be used to train the classifier. + + Returns: + A list of faces, ordered by probability + If no faces is found, returns a void list. """ if self.has_face() : # needed ? self.faces.sort(key= lambda prob : prob[1], reverse=True) @@ -109,6 +138,9 @@ class Guy(object): def update_center(self): """ Using sorted faces, defines the new center of interest of the output image + + Updates the center of the image, using the most probable face as reference. + Íf no face was found, the center is not updated. """ if self.has_face(): ((x, y, w, h), n) = self.faces[0] @@ -117,7 +149,12 @@ class Guy(object): def normalize_face(self, reference): """ - Creates intermediate image, whose face fits reference size + Creates intermediate image, whose face fits reference size. + This method aloows faces to always keep the same size during all the video. + Changes the center of the image and adds a new resized image. + + Args: + reference (int): The refence size of the face (in pixels). Defined as the first face size for now """ self.normalize = 1 @@ -140,6 +177,15 @@ class Guy(object): Creates image output, centering the face center with the required position If eq_ratio is set to something different than one, input image is scaled so that face/size = eq_ratio + + Args: + x_size (int): The size of the ouput image in x (in pixels) + y_size (int): The size of the ouput image in y (in pixels) + x_point (int): The center of the output image, where the Guy image has to fit in (in pixels) + y_point (int): The center of the output image, where the Guy image has to fit in (in pixels) + + Returns: + The ouput image, centered to fit with all other images """ out_im = cv.CreateImage((x_size, y_size),cv.IPL_DEPTH_8U, self.in_channels) cv.Zero(out_im) @@ -160,7 +206,7 @@ class Guy(object): def create_debug_output(self): """ - NOT FUNCTIONAL ANY MORE + **DEPRECATED** Creates output image If debug is set to true, output image is the input image with a red box around the most probable face. @@ -195,6 +241,11 @@ class Guy(object): """ Displays the input image, for time ms. Setting time to 0 causes the image to remains open. + + Args: + time (int): The time for which image stays diaplyed (in ms). 0 causes the frams to remain open + im_x (int): The output of the display frame in x (in pixels) + im_y (int): The output of the display frame in y (in pixels) """ cv.NamedWindow(self.name, cv.CV_WINDOW_NORMAL) cv.ResizeWindow(self.name, im_x, im_y) @@ -205,12 +256,18 @@ class Guy(object): def num_faces(self): """ Returns the number of faces found for this guy + + Returns: + int The number of faces found for the input image """ return len(self.faces) def has_face(self): """ - Returns True if at least one face has been found + Returns True of False whether images have been found for the current image or not. + + Returns: + True if at least one face has been found """ return (len(self.faces) > 0) \ No newline at end of file diff --git a/facemovie/__init__.py b/facemovie/__init__.py index e69de29..01f8409 100644 --- a/facemovie/__init__.py +++ b/facemovie/__init__.py @@ -0,0 +1,7 @@ +""" + Aims at helping you create videos of yourself over time, using photos as input. + Take great pictures, FaceMovie will do the rest ! + +.. moduleauthor:: Julien Lengrand-Lambert + +""" \ No newline at end of file diff --git a/facemovie/facemovie.rst b/facemovie/facemovie.rst new file mode 100644 index 0000000..0174234 --- /dev/null +++ b/facemovie/facemovie.rst @@ -0,0 +1,7 @@ +Documentation of the FaceMovie project +************************************** + +.. automodule:: facemovie + +.. automodule:: facemovie.useful_1 + :members: \ No newline at end of file diff --git a/facemovie/lib/__init__.py b/facemovie/lib/__init__.py index e69de29..4257bd0 100644 --- a/facemovie/lib/__init__.py +++ b/facemovie/lib/__init__.py @@ -0,0 +1,6 @@ +""" + This package aims at containing all libraries or external elements needed to create the FaceMovie + +.. moduleauthor:: Julien Lengrand-Lambert + +""" \ No newline at end of file diff --git a/facemovie/training_types.py b/facemovie/training_types.py index aa011fc..2b7a300 100644 --- a/facemovie/training_types.py +++ b/facemovie/training_types.py @@ -1,8 +1,12 @@ -''' -Created on 25 avr. 2012 +""" +.. module:: training_types + :platform: Unix, Windows + :synopsis: Dumb class aiming at regrouping all information concerning the trainers for classification. + Each entry is linked to a label, corresponding to a different type of recognition (frontal, profile, . . . ) -@author: jll -''' +.. moduleauthor:: Julien Lengrand-Lambert + +""" # File used only to store a dictionary off all xml files used to train the classifier complete_set = {#eyes 'eyes':"haarcascade_eye", diff --git a/test/exif_test.py b/test/exif_test.py deleted file mode 100755 index 2875dc3..0000000 --- a/test/exif_test.py +++ /dev/null @@ -1,12 +0,0 @@ -import sys -sys.path.append("../facemovie/lib") -import exif -import time - -path = "../data/input/Axel/2012-01-15-06h13m41DSCN9849.JPG" - -plop = exif.parse(path)['DateTime'] -print plop - -my_date = time.strptime(plop, "%Y:%m:%d %H:%M:%S") -print my_date diff --git a/test/test_script.py b/test/test_script.py deleted file mode 100644 index b699c87..0000000 --- a/test/test_script.py +++ /dev/null @@ -1,33 +0,0 @@ -''' -Created on 16 avr. 2012 - -@author: jll -''' - -import os -from context import facemovie -from facemovie.Facemovie import FaceMovie - -import facemovie.training_types - -if __name__ == '__main__': - root_fo = "C:\Users\jll\perso\workspace\FaceMovie" - in_fo = os.path.join(root_fo, "data/input\Axel") - out_fo = os.path.join(root_fo, "data/output") - par_fo = os.path.join(root_fo, "facemovie/haarcascades") - - my_movie = FaceMovie(in_fo, out_fo, par_fo) - my_movie.list_guys() # find images in input folder - - #my_movie.search_faces() # search for images with faces - # I want to change images so that all faces have the same size - #my_movie.normalize_faces() # sets all faces to the same size - # I want to know the size of the output frame, knowing initial conditions - #my_movie.find_out_dims() # finds output minimal size to get all eyes in the same place - - #choose your final step - #my_movie.show_faces(1000) - #my_movie.save_faces("output") - #my_movie.save_movie("output") - - print "Facemovie finished !" \ No newline at end of file