mirror of
https://github.com/jlengrand/Ivolution.git
synced 2026-03-10 08:21:18 +00:00
420 lines
16 KiB
Python
420 lines
16 KiB
Python
"""
|
|
.. 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.
|
|
|
|
.. moduleauthor:: Julien Lengrand-Lambert <jlengrand@gmail.com>
|
|
|
|
"""
|
|
import os
|
|
import sys
|
|
import sys
|
|
|
|
import cv
|
|
|
|
from lib import exif
|
|
import Guy
|
|
|
|
class FaceMovie(object):
|
|
'''
|
|
Main class of the whole application.
|
|
Contains the core image processing functions.
|
|
Takes a bunch of parameters and a list of images and creates the ouput, depending what the user asked for.
|
|
Contains general methods, aimed at being used trough an interface.
|
|
'''
|
|
def __init__(self, in_folder, out_folder, face_params):
|
|
"""
|
|
Initializes all parameters of the application. Input and output folders
|
|
are defined, together with the classifier profile.
|
|
|
|
:param in_folder: the location where input files will be searched
|
|
:type in_folder: string
|
|
:param out_folder: the location where the outputs will be saved
|
|
:type out_folder: string
|
|
:param face_param: the location of the profile file used to train the classifier
|
|
:type face_param: string
|
|
"""
|
|
|
|
###checked params
|
|
self.source= in_folder # Source folder for pictures
|
|
# Retrieving parameters for Face Detection
|
|
self.face_params = face_params
|
|
|
|
self.out_path = "./data"
|
|
self.out_name = "output"
|
|
self.out_format = "avi"
|
|
# updating the out_folder if needed
|
|
self.check_out_name(out_folder)
|
|
|
|
self.sort_method = "name" # sorting by name or using metadata (n or e)
|
|
self.mode = "default" # can be crop or default.
|
|
|
|
###
|
|
#self.CV_MAX_PIXEL = 13000 * 13000 # experimental maximal size of an IplImage
|
|
self.guys = [] # List of pictures in source folder
|
|
|
|
self.center = [0, 0] # Position of the center in output images (x, y)
|
|
|
|
# Size of the final output image (x, y). Depends on selected mode
|
|
self.dims = [0, 0]
|
|
|
|
self.weight_steps = 5 # number of images to be inserted between each frame to reduce violent switch
|
|
|
|
self.speed = [2, 5, 9]# this one should be internal. Number of fps for the video
|
|
|
|
### checked methods
|
|
|
|
def list_guys(self):
|
|
"""
|
|
Aims at populating the guys list, using the source folder as an input.
|
|
Guys list can be sorted either by name, or using metadata.
|
|
In case source folder is not found; Exits without processing.
|
|
Non Image files are autmatically skipped.
|
|
Source folder is searched recursively. All subfolders are also processed.
|
|
.. note::In case no valid date is found for metadata mode, the images are taken in name order
|
|
"""
|
|
try:
|
|
os.path.exists(self.source)
|
|
os.path.isdir(self.source) # checking if folder exists
|
|
except : # find precise exception
|
|
print "ERROR : Source folder not found ! Exiting. . ."
|
|
sys.exit(0)
|
|
|
|
# loading images, create Guys and store it into guys
|
|
for root, _, files in os.walk(self.source):
|
|
for a_file in files:
|
|
guy_source = os.path.join(root, a_file)
|
|
try:
|
|
image = cv.LoadImage(guy_source)
|
|
guy_name = os.path.splitext(a_file)[0]
|
|
try:
|
|
guy_date = exif.parse(guy_source)['DateTime']
|
|
except Exception:
|
|
print "===> Warning : No metadata found for %s" %(guy_name)
|
|
guy_date = ''
|
|
|
|
a_guy = Guy.Guy(guy_name, guy_date, guy_source)
|
|
|
|
# populating guys
|
|
self.guys.append(a_guy)
|
|
except:
|
|
print "=> Skipping %s. Not an image file" %(guy_source)
|
|
|
|
self.sort_guys()
|
|
print "INFO : %d guys found in source folder." %(self.number_guys())
|
|
|
|
def sort_guys(self):
|
|
"""
|
|
Guys list has just been populated, but elements are not ordered yet.
|
|
Sorts the elements of the list either by name or by date extracted from metadata,
|
|
depending on the chosen mode.
|
|
"""
|
|
# Sorting either by exif date or name
|
|
if self.sort_method == "exif":
|
|
self.guys.sort(key=lambda g: g.date)
|
|
else: # default is sort by name
|
|
self.guys.sort(key=lambda g: g.name)
|
|
|
|
def search_faces(self):
|
|
"""
|
|
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)
|
|
if a_guy.has_face(): # face(s) have been found
|
|
print "Face found for %s" % (a_guy.name)
|
|
else:
|
|
print "Warning! No face found for %s. Skipped . . ." %(a_guy.name)
|
|
|
|
def clean_guys(self):
|
|
"""
|
|
Removes all guys for who no face has been found.
|
|
This avoids all has_face loops in the rest of the application
|
|
"""
|
|
return [a_guy for a_guy in self.guys if a_guy.has_face()]
|
|
|
|
def prepare_faces(self):
|
|
"""
|
|
Searches for all faces and keep only the one that may be properly used.
|
|
Images without face are discarded.
|
|
The program is exited in case no face is found.
|
|
Searches for the reference size. If will be used later for image resizing, so that
|
|
all faces have the same size.
|
|
"""
|
|
self.search_faces()
|
|
# removes guys that have no faces
|
|
self.guys = self.clean_guys()
|
|
|
|
if self.number_guys() == 0:
|
|
print "No face has been found in the whole repository! Exiting. . . "
|
|
sys.exit(0)
|
|
|
|
# normalize faces to make them clean
|
|
self.set_guys_ratio() # sets all faces to the same size, by calculating a ratio to a reference
|
|
|
|
def set_guys_ratio(self):
|
|
"""
|
|
For each Guy, calculates the factor by which the image is going to be resized so that all faces finally have the same size.
|
|
"""
|
|
ref = self.find_reference()
|
|
for a_guy in self.guys:
|
|
a_guy.set_ratio(ref)
|
|
|
|
def find_reference(self):
|
|
"""
|
|
Searched for the best face size we want to have.
|
|
Defined (for now), as the smallest of all found faces.
|
|
|
|
:returns int - the reference size of the bounding square for faces.
|
|
"""
|
|
references = []
|
|
for a_guy in self.guys:
|
|
if a_guy.has_face():
|
|
references.append(a_guy.faces[0][0][3]) # catch face size (width)
|
|
|
|
return min(references)
|
|
|
|
def find_final_dimensions(self, cropdims=(0, 0)):
|
|
"""
|
|
Finds the final dimensions that will be needed to create the output.
|
|
Depending on the desired output, it can be
|
|
- (default) the maximal size of the image, by overlapping all images and adding black borders.
|
|
- (crop) the maximal size of the image by overlapping all the images, without adding any black borders
|
|
- (custom crop) A chosen user size, defined as x * y times the head size.
|
|
"""
|
|
if self.mode == "default":
|
|
self.find_default_dims()
|
|
elif self.mode == "crop":
|
|
self.find_crop_dims()
|
|
elif self.mode == "custom crop":
|
|
# TODO : implement
|
|
print "custom crop is not yet implemented"
|
|
raise Exception
|
|
|
|
def find_default_dims(self):
|
|
"""
|
|
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 !
|
|
x_af = 0
|
|
y_af = 0
|
|
for a_guy in self.guys:
|
|
(xc, yc) = a_guy.resized_center()
|
|
(inx, iny) = a_guy.resized_dims()
|
|
|
|
# update center
|
|
if xc > self.center[0]:
|
|
self.center[0] = xc
|
|
if yc > self.center[1]:
|
|
self.center[1] = yc
|
|
# update right part
|
|
if (inx - xc) > x_af:
|
|
x_af = inx - xc
|
|
if (iny - yc) > y_af:
|
|
y_af = iny - yc
|
|
|
|
self.dims = [x_af + self.center[0], y_af + self.center[1]]
|
|
|
|
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.
|
|
"""
|
|
ht = 1000000 # space left above eyes
|
|
hb = 1000000 # space left beneath eyes
|
|
wl = 1000000 # space left left of eyes
|
|
wr = 1000000 # space left right of eyes
|
|
for a_guy in self.guys:
|
|
(xc, yc) = a_guy.resized_center()
|
|
(inx, iny) = a_guy.resized_dims()
|
|
|
|
# finding width
|
|
if xc < wl:
|
|
wl = xc
|
|
if (inx - xc) < wr:
|
|
wr = inx - xc
|
|
# finding height
|
|
if yc < ht:
|
|
ht = yc
|
|
if (iny - yc) < hb:
|
|
hb = iny - yc
|
|
|
|
self.dims = [wl + wr, ht + hb]
|
|
self.center = [wl, ht]
|
|
|
|
def get_out_file(self):
|
|
"""
|
|
Reconstructs the final output file for the movie creation
|
|
:returns: String -- The ouput file path to be saved
|
|
"""
|
|
return os.path.join(self.out_path, (self.out_name + "." + self.out_format))
|
|
|
|
def save_movie(self, speed=2):
|
|
"""
|
|
Creates a movie with all faces found in the inputs.
|
|
Guy is skipped if no face is found.
|
|
|
|
:param out_folder: the location where to save the output image.
|
|
:type out_folder: string
|
|
|
|
:param fps: the number of frames per second to be displayed in final video (3)
|
|
:type fps: int
|
|
"""
|
|
|
|
if "win" in sys.platform:
|
|
fourcc = cv.CV_FOURCC('C', 'V', 'I', 'D')
|
|
else: # some kind of Linux/Unix platform
|
|
fourcc = cv.CV_FOURCC('F', 'M', 'P', '4')
|
|
|
|
frameSize = (self.dims[0], self.dims[1])
|
|
|
|
pace = ["slow", "normal", "fast"]
|
|
print "Speed is set to %s" %(pace[speed - 1])
|
|
my_video = cv.CreateVideoWriter(self.get_out_file(),
|
|
fourcc,
|
|
self.speed[speed - 1],
|
|
frameSize,
|
|
1)
|
|
ii = 0
|
|
for a_guy in self.guys:
|
|
ii += 1
|
|
print "Saving frame %d / %d" %(ii, self.number_guys())
|
|
out_im = self.prepare_image(a_guy)
|
|
cv.WriteFrame(my_video, out_im)
|
|
|
|
def show_faces(self, mytime=1000):
|
|
"""
|
|
Show all faces that have been found for the guys.
|
|
The time for which each image will be displayed can be chosen.
|
|
|
|
:param mytime: time for which the image should be displayed (in ms) (1000)
|
|
:type mytime: int
|
|
"""
|
|
win_name = " Face Results"
|
|
cv.NamedWindow(win_name, cv.CV_WINDOW_NORMAL)
|
|
cv.ResizeWindow(win_name, 640, 480)
|
|
|
|
for a_guy in self.guys:
|
|
out_im = self.prepare_image(a_guy)
|
|
cv.ShowImage(win_name, out_im)
|
|
cv.WaitKey(mytime)
|
|
|
|
cv.DestroyWindow(win_name)
|
|
|
|
def save_faces(self, im_format="png"):
|
|
"""
|
|
Save all faces into out_folder, in the given image format
|
|
|
|
:param out_folder: the location where to save the output image.
|
|
:type out_folder: string
|
|
|
|
:param im_format: Format in which the image should be saved ("png")
|
|
:type im_format: string
|
|
"""
|
|
for a_guy in self.guys:
|
|
out_im = self.prepare_image(a_guy)
|
|
self.save_guy(out_im, a_guy.name, im_format)
|
|
|
|
def number_guys(self):
|
|
"""
|
|
Simply returns the number of guys in the current to-be movie
|
|
|
|
.. note::
|
|
Designed for interface use only
|
|
"""
|
|
return len(self.guys)
|
|
|
|
def out_display(self, im, name, time=1000, im_x=640, im_y=480):
|
|
"""
|
|
Displays the output image, for time ms.
|
|
Setting time to 0 causes the image to remains open.
|
|
Window name slightly changed to match output
|
|
|
|
:param im: the image to be saved, formatted as an OpenCV Image
|
|
:type im: IplImage
|
|
:param name: the name of the image to be saved
|
|
:type name: string
|
|
|
|
:param time: time for which the image should be displayed (in ms) (1000)
|
|
:type time: int
|
|
:param im_x: output size of the displayed image (in pixels) (640)
|
|
:type im_x: int
|
|
:param im_y: output size of the displayed image (in pixels) (480)
|
|
:type im_y: int
|
|
"""
|
|
win_name = name + " - out"
|
|
cv.NamedWindow(win_name, cv.CV_WINDOW_NORMAL)
|
|
cv.ResizeWindow(win_name, im_x, im_y)
|
|
cv.ShowImage(win_name, im)
|
|
cv.WaitKey(time)
|
|
cv.DestroyWindow(win_name)
|
|
|
|
def check_out_name(self, out_folder):
|
|
"""
|
|
Checks the desired output selected by the user.
|
|
It can be either a folder or a file itself.
|
|
Checks whether the designated path ends with a extension name.
|
|
|
|
In case it is, the extension is checked and changed if needed
|
|
|
|
:param out_folder: the path slected by the user as output location
|
|
:type out_folder: String
|
|
"""
|
|
|
|
if len(os.path.splitext(out_folder)[1]) > 0:# if ends up with an extension
|
|
self.out_path, complete_name = os.path.split(out_folder)
|
|
self.out_name, format = os.path.splitext(complete_name)
|
|
if format != self.out_format:
|
|
# the format is not compliant with what we can do. We refuse it
|
|
print "Changing format to avi"
|
|
else:
|
|
# no filename is given. We keep the default
|
|
self.out_path = os.path.split(out_folder)[0]
|
|
|
|
def save_guy(self, im, name, ext):
|
|
"""
|
|
Saves output image to the given format (given in extension)
|
|
|
|
:param im: the image to be saved, formatted as an OpenCV Image
|
|
:type im: IplImage
|
|
:param name: the name of the image to be saved
|
|
:type name: string
|
|
:param out_folder: the location where to save the image
|
|
:type out_folder: string
|
|
:param ext: Format in which the image should be saved ("png")
|
|
:type ext: string
|
|
"""
|
|
file_name = name + "." + ext
|
|
out_name = os.path.join(self.out_path, file_name)
|
|
print "Saving %s" %(out_name)
|
|
|
|
cv.SaveImage(out_name, im)
|
|
|
|
def prepare_image(self, a_guy):
|
|
"""
|
|
Takes a Guy and processes its input image. Prepares the final output image for this
|
|
Guy, so that it is ready to be saved in the desired output.
|
|
|
|
:param a_guy: The Guy currently being processed.
|
|
:type a_guy: Guy
|
|
:returns: IplImage -- The ouput image, created depending on the chosen mode, ready to be saved
|
|
"""
|
|
if self.mode == "default":
|
|
out_im = a_guy.create_default_output(self.dims,
|
|
self.center)
|
|
elif self.mode == "crop":
|
|
out_im = a_guy.create_crop_output(self.dims,
|
|
self.center)
|
|
return out_im
|
|
|