def DetectRedEyes(image, faceCascade, eyeCascade):
min_size = (20, 20)
image_scale = 2
haar_scale = 1.2
min_neighbors = 2
haar_flags = 0
# Allocate the temporary images
gray = cv.CreateImage((image.width, image.height), 8, 1)
smallImage = cv.CreateImage((cv.Round(
image.width / image_scale), cv.Round(image.height / image_scale)), 8,
1)
# Convert color input image to grayscale
cv.CvtColor(image, gray, cv.CV_BGR2GRAY)
# Scale input image for faster processing
cv.Resize(gray, smallImage, cv.CV_INTER_LINEAR)
# Equalize the histogram
cv.EqualizeHist(smallImage, smallImage)
# Detect the faces
faces = cv.HaarDetectObjects(smallImage, faceCascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
# If faces are found
if faces:
print "face detected"
for ((x, y, w, h), n) in faces:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
cv.Rectangle(image, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0)
face_region = cv.GetSubRect(image,
(x, int(y + (h / 4)), w, int(h / 2)))
cv.SetImageROI(
image,
(pt1[0], pt1[1], pt2[0] - pt1[0], int((pt2[1] - pt1[1]) * 0.7)))
eyes = cv.HaarDetectObjects(image, eyeCascade, cv.CreateMemStorage(0),
haar_scale, min_neighbors, haar_flags,
(15, 15))
# if eyes:
# # For each eye found
# for eye in eyes:
# # Draw a rectangle around the eye
# cv.Rectangle(image,
# (eye[0][0],
# eye[0][1]),
# (eye[0][0] + eye[0][2],
# eye[0][1] + eye[0][3]),
# cv.RGB(255, 0, 0), 1, 8, 0)
cv.ResetImageROI(image)
return image
def get_face_roi(img):
frontals = cv.HaarDetectObjects(img, feature_detectors[0],
cv.CreateMemStorage())
if len(frontals) == 0:
profiles = cv.HaarDetectObjects(img, feature_detectors[1],
cv.CreateMemStorage())
return profiles
return frontals
def detectRedEyes(image, faceCascade, eyeCascade):
min_size = (20, 20)
image_scale = 2
haar_scale = 1.2
min_neighbors = 2
haar_flags = 0
# Allocate the temporary images
gray = cv.CreateImage((image.width, image.height), 8, 1)
smallImage = cv.CreateImage((cv.Round(
image.width / image_scale), cv.Round(image.height / image_scale)), 8,
1)
# Convert color input image to grayscale
cv.CvtColor(image, gray, cv.CV_BGR2GRAY)
# Scale input image for faster processing
cv.Resize(gray, smallImage, cv.CV_INTER_LINEAR)
# Equalize the histogram
cv.EqualizeHist(smallImage, smallImage)
# Detect the faces
faces = cv.HaarDetectObjects(smallImage, faceCascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
# If faces are found
if faces:
for ((x, y, w, h), n) in faces:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
cv.Rectangle(image, pt1, pt2, cv.RGB(255, 0, 0), 3, 8,
0) # If faces are found
# Estimate the eyes position
# First, set the image region of interest
# The last division removes the lower part of the face to lower probability for false recognition
cv.SetImageROI(
image, (pt1[0], pt1[1], pt2[0] - pt1[0], int((pt2[1] - pt1[1]) * 0.6)))
# Detect the eyes
eyes = cv.HaarDetectObjects(image, eyeCascade, cv.CreateMemStorage(0),
haar_scale, min_neighbors, haar_flags,
(20, 15))
# If eyes were found
if eyes:
# For each eye found
for eye in eyes:
# Draw a rectangle around the eye
cv.Rectangle(image, (eye[0][0], eye[0][1]),
(eye[0][0] + eye[0][2], eye[0][1] + eye[0][3]),
cv.RGB(255, 0, 0), 1, 8, 0)
# Finally, reset the image region of interest (otherwise this won t
# be drawn correctly
cv.ResetImageROI(image)
return image
def detect_face(self, cv_image):
if self.grey is None:
""" Allocate temporary images """
self.grey = cv.CreateImage(self.image_size, 8, 1)
if self.small_image is None:
self.small_image = cv.CreateImage(
(cv.Round(self.image_size[0] / self.image_scale),
cv.Round(self.image_size[1] / self.image_scale)), 8, 1)
""" Convert color input image to grayscale """
cv.CvtColor(cv_image, self.grey, cv.CV_BGR2GRAY)
""" Equalize the histogram to reduce lighting effects. """
cv.EqualizeHist(self.grey, self.grey)
""" Scale input image for faster processing """
cv.Resize(self.grey, self.small_image, cv.CV_INTER_LINEAR)
""" First check one of the frontal templates """
if self.cascade_frontal_alt:
faces = cv.HaarDetectObjects(self.small_image,
self.cascade_frontal_alt,
cv.CreateMemStorage(0),
self.haar_scale, self.min_neighbors,
self.haar_flags, self.min_size)
""" If that fails, check the profile template """
if not faces:
if self.cascade_profile:
faces = cv.HaarDetectObjects(self.small_image,
self.cascade_profile,
cv.CreateMemStorage(0),
self.haar_scale,
self.min_neighbors,
self.haar_flags, self.min_size)
if not faces:
""" If that fails, check a different frontal profile """
if self.cascade_frontal_alt2:
faces = cv.HaarDetectObjects(
self.small_image, self.cascade_frontal_alt2,
cv.CreateMemStorage(0), self.haar_scale,
self.min_neighbors, self.haar_flags, self.min_size)
if not faces:
return None
fs = []
for ((x, y, w, h), n) in faces:
""" The input to cv.HaarDetectObjects was resized, so scale the
bounding box of each face and convert it to two CvPoints """
pt1 = (int(x * self.image_scale), int(y * self.image_scale))
pt2 = (int(
(x + w) * self.image_scale), int((y + h) * self.image_scale))
if (pt2[0] - pt1[0]) * (pt2[1] - pt1[1]) == 0:
logger.warn("Area of detected face is 0")
continue
fs.append((pt1, pt2))
added = self.detect_box.addFaces(fs)
self.save_faces(added)
return self.detect_box.faces
def DetectFace(image, faceCascade, eyeCascade):
min_size = (20, 20)
image_scale = 2
haar_scale = 1.1
min_neighbors = 3
haar_flags = 0
# Allocate the temporary images
gray_scale = cv.CreateImage((image.width, image.height), 8, 1)
small_Image = cv.CreateImage((cv.Round(
image.width / image_scale), cv.Round(image.height / image_scale)), 8,
1)
# Convert color input image to grayscale
cv.CvtColor(image, gray_scale, cv.CV_BGR2GRAY)
# Scale input image for faster processing
cv.Resize(gray_scale, small_Image, cv.CV_INTER_LINEAR)
# Equalize the histogram
cv.EqualizeHist(small_Image, small_Image)
faces = cv.HaarDetectObjects( # Haarcascade objects for face detection
small_Image, faceCascade, cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
eyes = cv.HaarDetectObjects(
small_Image,
eyeCascade, # Haarcascade objects for eyes detection
cv.CreateMemStorage(0),
haar_scale,
min_neighbors,
haar_flags,
min_size)
# If face is detected
if faces:
for ((x, y, w, h), n) in faces:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
cv.Rectangle(image, pt1, pt2, cv.RGB(255, 0, 0), 5, 8, 0)
# if eyes detected once face is detected
if eyes:
for ((x, y, w, h), n) in eyes:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each eye and convert it to two CvPoints
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
cv.Rectangle(image, pt1, pt2, cv.RGB(0, 255, 0), 5, 8, 0)
else:
os.system("scrot ab.png")
os.system("python detect.py")
# os.system("mplayer 1.mp3")
else:
os.system("scrot noface.png")
print('User not detected')
# os.system("mplayer 1.mp3")
return image
def findmouth(img):
# INITIALIZE: loading the classifiers
haarFace = cv.Load(path_to_file + '/haarcascade_frontalface_default.xml')
haarMouth = cv.Load(path_to_file + '/haarcascade_mouth.xml')
# running the classifiers
storage = cv.CreateMemStorage()
detectedFace = cv.HaarDetectObjects(img, haarFace, storage)
detectedMouth = cv.HaarDetectObjects(img, haarMouth, storage)
# FACE: find the largest detected face as detected face
maxFaceSize = 0
maxFace = 0
if detectedFace:
# face: [0][0]: x; [0][1]: y; [0][2]: width; [0][3]: height
for face in detectedFace:
if face[0][3] * face[0][2] > maxFaceSize:
maxFaceSize = face[0][3] * face[0][2]
maxFace = face
if maxFace == 0: # did not detect face
return 2
def mouth_in_lower_face(mouth, face):
# if the mouth is in the lower 2/5 of the face
# and the lower edge of mouth is above that of the face
# and the horizontal center of the mouth is the center of the face
if (mouth[0][1] > face[0][1] + face[0][3] * 3 / float(5)
and mouth[0][1] + mouth[0][3] < face[0][1] + face[0][3]
and abs((mouth[0][0] + mouth[0][2] / float(2)) -
(face[0][0] + face[0][2] / float(2))) <
face[0][2] / float(10)):
return True
else:
return False
# FILTER MOUTH
filteredMouth = []
if detectedMouth:
for mouth in detectedMouth:
if mouth_in_lower_face(mouth, maxFace):
filteredMouth.append(mouth)
maxMouthSize = 0
for mouth in filteredMouth:
if mouth[0][3] * mouth[0][2] > maxMouthSize:
maxMouthSize = mouth[0][3] * mouth[0][2]
maxMouth = mouth
try:
return maxMouth
except UnboundLocalError:
return 2
def detect_faces(self, cv_image):
if self.grey is None:
""" Allocate temporary images """
self.grey = cv.CreateImage(self.image_size, 8, 1)
if self.small_image is None:
self.small_image = cv.CreateImage(
(cv.Round(self.image_size[0] / self.image_scale),
cv.Round(self.image_size[1] / self.image_scale)), 8, 1)
""" Convert color input image to grayscale """
cv.CvtColor(cv_image, self.grey, cv.CV_BGR2GRAY)
""" Equalize the histogram to reduce lighting effects. """
cv.EqualizeHist(self.grey, self.grey)
""" Scale input image for faster processing """
cv.Resize(self.grey, self.small_image, cv.CV_INTER_LINEAR)
""" First check one of the frontal templates """
frontal_faces = cv.HaarDetectObjects(self.small_image,
self.cascade_frontal_alt,
cv.CreateMemStorage(0),
self.haar_scale,
self.min_neighbors,
self.haar_flags, self.min_size)
""" Now check the profile template """
profile_faces = cv.HaarDetectObjects(self.small_image,
self.cascade_profile,
cv.CreateMemStorage(0),
self.haar_scale,
self.min_neighbors,
self.haar_flags, self.min_size)
""" Lastly, check a different frontal profile """
#faces = cv.HaarDetectObjects(self.small_image, self.cascade_frontal_alt2, cv.CreateMemStorage(0),
# self.haar_scale, self.min_neighbors, self.haar_flags, self.min_size)
#profile_faces.extend(faces)
'''if not frontal_faces and not profile_faces:
if self.show_text:
text_font = cv.InitFont(cv.CV_FONT_VECTOR0, 3, 2, 0, 3)
cv.PutText(self.marker_image, "NO FACES!", (50, int(self.image_size[1] * 0.9)), text_font, cv.RGB(255, 255, 0))'''
faces_boxes = []
for ((x, y, w, h), n) in frontal_faces + profile_faces:
""" The input to cv.HaarDetectObjects was resized, so scale the
bounding box of each face and convert it to two CvPoints """
pt1 = (int(x * self.image_scale), int(y * self.image_scale))
pt2 = (int(
(x + w) * self.image_scale), int((y + h) * self.image_scale))
face_box = (pt1[0], pt1[1], pt2[0], pt2[1])
faces_boxes.append(face_box)
return faces_boxes
def find_face(self, image):
w, h = cv.GetSize(image)
# I actually think cv.CreateImage returns a BGR image, but it gets gray-scaled in the line after:
grayscale = cv.CreateImage((w, h), 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
# note: if face detecton seems off you might have to tweak the minimum object size argument
faces = cv.HaarDetectObjects(grayscale, self.face_cascade,
self.storage, 1.2, 2, 0, (300, 250))
if faces:
print 'face detected!'
# TODO: if it found more than 1 face it will return before cycling through each:
for f in faces:
self.frames_since_face = 0
self.last_face_position = f # remember this face as the last one, again for the no-face-detected case
self.drawrect(
image, f[0], (0, 255, 0)
) # this draws a green (black in grayscale) rectangle to frame the object that was found
return f
# if it didn't find a face it will draw one where the last one was, so there's no blank. this is a good guess anyway
# (BUG (sorta): I think if 2 or more faces were detected in the last frame, this will only draw the most recent of them)
elif self.last_face_position:
# print 'can\'t find face, using old postion'
self.frames_since_face += 1
f = self.last_face_position
self.drawrect(image, f[0], (0, 100, 200)) # gray in grayscale
return f
else:
print 'no face'
def detect_and_draw(img, cascade):
gray = cv.CreateImage((img.width,img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(img.width / image_scale),
cv.Round (img.height / image_scale)), 8, 1)
# convert color input image to grayscale
cv.CvtColor(img, gray, cv.CV_BGR2GRAY)
# scale input image for faster processing
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(small_img, small_img)
if(cascade):
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, cascade, cv.CreateMemStorage(0),
haar_scale, min_neighbors, haar_flags, min_size)
index = 0
if faces:
for ((x, y, w, h), n) in faces:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
x1, y1 = (int(x * image_scale), int(y * image_scale))
x2, y2 = (int((x + w) * image_scale), int((y + h) * image_scale))
pi = Image.fromstring("L", cv.GetSize(gray), gray.tostring())
pi = pi.crop((x1, y1, x2, y2))
pi = pi.resize((64, 64), Image.ANTIALIAS)
path = os.path.join(sys.argv[1])
pi.save(path)
index += 1
else:
os.remove(sys.argv[1])
def show_photo():
# Get the photo
img = c.get_photo() \
.get_response() \
.resize((300, 300), Img.ANTIALIAS)
# Convert the photo for OpenCV
cv_img = cv.CreateImageHeader(img.size, cv.IPL_DEPTH_8U, 1)
cv.SetData(cv_img, img.tostring())
# Find any faces in the image
storage = cv.CreateMemStorage(0)
cv.EqualizeHist(cv_img, cv_img)
faces = cv.HaarDetectObjects(cv_img, cascade, storage, 1.2, 2,
cv.CV_HAAR_DO_CANNY_PRUNING)
if faces:
for f in faces:
# Draw a border around a found face.
draw = ImageDraw.Draw(img)
draw.setfill(0)
draw.rectangle([(f[0][0], f[0][1]),
(f[0][0] + f[0][2], f[0][1] + f[0][3])])
image = PhotoImage(img)
img_face.config(image=image)
img_face.img = image
img_face.after(10, show_photo)
def detectFaces(im):
# This function takes a PIL image and finds the patterns defined in the
# haarcascade function modified from: http://www.lucaamore.com/?p=638
# Convert a PIL image to a greyscale cv image
# from: http://pythonpath.wordpress.com/2012/05/08/pil-to-opencv-image/
im = im.convert('L')
cv_im = cv.CreateImageHeader(im.size, cv.IPL_DEPTH_8U, 1)
cv.SetData(cv_im, im.tobytes(), im.size[0])
# variables
min_size = (20, 20)
haar_scale = 1.1
min_neighbors = 3
haar_flags = 0
# Equalize the histogram
cv.EqualizeHist(cv_im, cv_im)
# Detect the faces
faces = cv.HaarDetectObjects(cv_im, faceCascade, cv.CreateMemStorage(0),
haar_scale, min_neighbors, haar_flags,
min_size)
return faces
def detect_faces(image):
faces = []
detected = cv.HaarDetectObjects(image, cascade, storage, 1.2, 2, cv.CV_HAAR_DO_CANNY_PRUNING, (100,100))
if detected:
for (x,y,w,h),n in detected:
faces.append((x,y,w,h))
return faces
def detect_and_draw(img, cascade):
# allocate temporary images
gray = cv.CreateImage((img.width, img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(
img.width / image_scale), cv.Round(img.height / image_scale)), 8, 1)
# convert color input image to grayscale
cv.CvtColor(img, gray, cv.CV_BGR2GRAY)
# scale input image for faster processing
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(small_img, small_img)
if (cascade):
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, cascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
t = cv.GetTickCount() - t
print "detection time = %gms" % (t / (cv.GetTickFrequency() * 1000.))
if faces:
for ((x, y, w, h), n) in faces:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0)
cv.ShowImage("result", img)
def normalisation(src):
res = []
# On fait une copie l'image pour le traitement (en gris)
gris = cv.CreateImage((src.width, src.height), cv.IPL_DEPTH_8U, 1)
normal = cv.CreateImage((NORM_W, NORM_H), cv.IPL_DEPTH_8U, 1)
cv.CvtColor(src, gris, cv.CV_BGR2GRAY)
# On detecte les visages (objects) sur l'image copiee
faces = cv.HaarDetectObjects(gris, face_path, cv.CreateMemStorage())
print "Nombre faces detectes : " + str(len(faces))
for (x, y, w, h), n in faces:
tmp = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 1)
cv.GetRectSubPix(gris, tmp, (float(x + w / 2), float(y + h / 2)))
cv.Resize(tmp, normal)
cv.EqualizeHist(normal, normal)
#Detection oeil nez bouche sur l'image source:
d = detection(normal)
# On detecte au moins 2 yeux "normaux", au moins un oeil avec lunette, au moins une bouche et au moins un nez
if ((len(d['eyes']) >= 2 or len(d['eyes2']) >= 1)
and len(d['mouth']) >= 1 and len(d['nose']) >= 1):
print "Visage detecte dans la photo"
res.append((normal, (x, y, w, h)))
return res
def detect(image):
image_size = cv.GetSize(image)
#create greyscale version
grayscale = cv.CreateImage(image_size, 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
# create storage
storage = cv.CreateMemStorage(0)
#cv.ClearMemStorage(storage)
# equalize histogram
cv.EqualizeHist(grayscale, grayscale)
# detect objects
cascade = cv.Load('haarcascade_frontalface_alt.xml')
faces = cv.HaarDetectObjects(grayscale, cascade, storage, 1.2, 2,
cv.HAAR_DO_CANNY_PRUNING, CV.SIZE(50, 50))
if faces:
print 'face detected!'
for i in faces:
cv.Rectangle(image, cv.Point(int(i.x), int(i.y)),
cv.Point(int(i.x + i.width), int(i.y + i.height)),
cv.RGB(0, 255, 0), 3, 8, 0)
cv.ShowImage('Video', image)
return faces
def detect(self, im):
''' Runs the cascade classifer on an image. '''
image = im.asOpenCV()
min_size = (self.min_size[0], self.min_size[1])
# Create a resized gray scale image
if image.nChannels == 3:
gray = cv.CreateImage((image.width, image.height), image.depth, 1)
cv.CvtColor(image, gray, cv.CV_BGR2GRAY)
image = gray
image = self._resizeImage(image, self.image_scale)
# Equalize the image
cv.EqualizeHist(image, image)
# Detect faces
faces = cv.HaarDetectObjects(image, self.cascade, self.storage,
self.haar_scale, self.min_neighbors,
self.haar_flags, min_size)
# Transform and return the points
result = []
for r in faces:
rect = pv.Rect(r[0][0] / self.image_scale,
r[0][1] / self.image_scale,
r[0][2] / self.image_scale,
r[0][3] / self.image_scale)
result.append(rect)
return result
def __init__(self, image_name, cascade):
try:
image = cv.LoadImage(image_name, 1)
except IOError:
return
except:
return
else:
self.faces = []
#Allocate Space for grayscale image and tiny image
#Dramatically reduces computation time in exchange for temporary space
grayscale = cv.CreateImage((image.width, image.height), 8, 1)
img = cv.CreateImage((cv.Round(image.width / IMAGE_SCALE),
cv.Round(image.height / IMAGE_SCALE)), 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
cv.Resize(grayscale, img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(img, img)
matches = cv.HaarDetectObjects(img, cascade,
cv.CreateMemStorage(0), HAAR_SCALE,
IMAGE_SCALE, HAAR_FLAGS, MIN_SIZE)
for ((x, y, width, height), wat) in matches:
self.faces.append({
"x": x,
"y": y,
"width": width,
"height": height
})
self.name = image_name
def detect_and_save(img, cascade, output_name):
# allocate temporary images
gray = cv.CreateImage((img.width, img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(
img.width / image_scale), cv.Round(img.height / image_scale)), 8, 1)
# convert color input image to grayscale
cv.CvtColor(img, gray, cv.CV_BGR2GRAY)
# scale input image for faster processing
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(small_img, small_img)
if (cascade):
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, cascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
t = cv.GetTickCount() - t
print "detection time = %gms" % (t / (cv.GetTickFrequency() * 1000.))
f = open(output_name, 'w')
if faces:
for ((x, y, w, h), n) in faces:
f.write("%d %d %d %d\n" % (x, y, w, h))
def detect(self, image):
"""
Determines the location of one or more faces in the given image.
"""
if isinstance(image, basestring):
image = cv.LoadImage(image)
image_size = cv.GetSize(image)
# Convert to grayscale.
grayscale = cv.CreateImage(image_size, 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
#cv.EqualizeHist(grayscale, grayscale)
_image = image
image = grayscale
# Assume an image equal to the target size contains a single face.
target_size = (self.target_width, self.target_height)
if image_size == target_size:
rect = 0, 0, self.target_width, self.target_height
neighbors = None
return [(rect, neighbors)], image
# Locate one or more faces in the image.
t0 = time.time()
faces = cv.HaarDetectObjects(image, self.face_cascade,
cv.CreateMemStorage(0), 1.2, 2, 0,
(20, 20))
t1 = time.time() - t0
LOG.info('Haar detect took %.2f seconds.' % (t1, ))
return faces, image
def detect_faces(self):
if opencv_available:
cascade_filename = os.path.join(
os.path.dirname(__file__), 'face_detection',
'haarcascade_frontalface_alt2.xml')
cascade = cv.Load(cascade_filename)
image = self.opencv_grey_image()
cv.EqualizeHist(image, image)
min_size = (40, 40)
haar_scale = 1.1
min_neighbors = 3
haar_flags = 0
faces = cv.HaarDetectObjects(image, cascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
if faces:
return [
FocalPoint.from_square(face[0][0], face[0][1], face[0][2],
face[0][3]) for face in faces
]
return []
def find_faces(self, file_name=None):
try:
import cv
except ImportError:
return
if file_name is None:
return
logger.debug("%s: %s" % (self.__class__.__name__, file_name))
imcolor = cv.LoadImage(file_name) #@UndefinedVariable
detectors = [
"haarcascade_frontalface_default.xml",
"haarcascade_profileface.xml"
]
for detector in detectors:
haarFace = cv.Load(os.path.join(settings.STATIC_ROOT,
detector)) # @UndefinedVariable
storage = cv.CreateMemStorage() #@UndefinedVariable
detectedFaces = cv.HaarDetectObjects(
imcolor, haarFace, storage,
min_size=(200, 200)) #@UndefinedVariable
if detectedFaces:
for face in detectedFaces:
fata = DetectedFace(imagine=self,
x=face[0][0],
y=face[0][1],
width=face[0][2],
height=face[0][3])
fata.save()
self.is_face_processed = True
self.save()
def Detect_Face(Img, faceCascade, Give_Image=False):
# Detects face with haarcascade -- http://www.lucaamore.com/?p=638
# Set haarcascade object options
HaarScale = 1.1
HaarFlags = 0
MinSize = (20, 20)
MinNeighbouring = 3
# Equalize the histogram
cv.EqualizeHist(Img, Img)
# Detection of the user's face
Faces = cv.HaarDetectObjects(Img, faceCascade, cv.CreateMemStorage(0),
HaarScale, MinNeighbouring, HaarFlags,
MinSize)
# Draw rectangles when found
if Faces and Give_Image:
for ((x, y, w, h), n) in Faces:
# Set two CV Points in order to draw the rectangular box.
Point1 = (int(x), int(y))
Point2 = (int(x + w), int(y + h))
cv.Rectangle(Img, Point1, Point2, cv.RGB(255, 0, 0), 5, 8, 0)
if Give_Image:
return Img
else:
return Faces
def DetectFace(image, faceCascade, returnImage=False):
# This function takes a grey scale cv image and finds
# the patterns defined in the haarcascade function
# modified from: http://www.lucaamore.com/?p=638
#variables
min_size = (20, 20)
haar_scale = 1.1
min_neighbors = 3
haar_flags = 0
# Equalize the histogram
cv.EqualizeHist(image, image)
# Detect the faces
faces = cv.HaarDetectObjects(image, faceCascade, cv.CreateMemStorage(0),
haar_scale, min_neighbors, haar_flags,
min_size)
# If faces are found
if faces and returnImage:
for ((x, y, w, h), n) in faces:
# Convert bounding box to two CvPoints
pt1 = (int(x), int(y))
pt2 = (int(x + w), int(y + h))
cv.Rectangle(image, pt1, pt2, cv.RGB(255, 0, 0), 5, 8, 0)
if returnImage:
return image
else:
return faces
def detect(image):
image_size = cv.GetSize(image)
# create grayscale version
grayscale = cv.CreateImage(image_size, 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
# create storage
storage = cv.CreateMemStorage(0)
# cv.ClearMemStorage(storage)
# equalize histogram
cv.EqualizeHist(grayscale, grayscale)
# detect objects
cascade = cv.Load('haarcascade_frontalface_alt.xml')
faces = cv.HaarDetectObjects(
grayscale,
cascade,
storage,
1.2,
2,
)
if faces:
print 'face detected!'
for i in faces:
print i
cv.Rectangle(image, (i[0][0], i[0][1]),
(int(i[0][0] + i[0][2]), int(i[0][1] + i[0][3])),
cv.RGB(0, 255, 0), 3, 8, 0)
def detect(self, obj, event):
# First, reset image, in case of previous detections:
active_handle = self.get_active('Media')
media = self.dbstate.db.get_media_from_handle(active_handle)
self.load_image(media)
min_face_size = (50, 50) # FIXME: get from setting
self.cv_image = cv.LoadImage(self.full_path,
cv.CV_LOAD_IMAGE_GRAYSCALE)
o_width, o_height = self.cv_image.width, self.cv_image.height
cv.EqualizeHist(self.cv_image, self.cv_image)
cascade = cv.Load(HAARCASCADE_PATH)
faces = cv.HaarDetectObjects(self.cv_image, cascade,
cv.CreateMemStorage(0), 1.2, 2,
cv.CV_HAAR_DO_CANNY_PRUNING,
min_face_size)
references = self.find_references()
rects = []
o_width, o_height = [
float(t) for t in (self.cv_image.width, self.cv_image.height)
]
for ((x, y, width, height), neighbors) in faces:
# percentages:
rects.append((x / o_width, y / o_height, width / o_width,
height / o_height))
self.draw_rectangles(rects, references)
def detect(image):
#cv.Rectangle(image, (10,10), (50,50), cv.RGB(255,0,0))
image_size = cv.GetSize(image)
# create grayscale version
grayscale = cv.CreateImage(image_size, 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
# create storage
storage = cv.CreateMemStorage(0)
#cv.ClearMemStorage(storage)
# equalize histogram
cv.EqualizeHist(grayscale, grayscale)
# detect objects
cascade = cv.Load('haarcascade_frontalface_alt.xml') #, cv.Size(1,1))
faces = cv.HaarDetectObjects(grayscale, cascade, storage, 1.2, 2,
cv.CV_HAAR_DO_CANNY_PRUNING, (100, 100))
if faces:
#print len(faces), 'face(s) detected!'
#if len(faces)>1: print '2 faces found'
for i in faces:
j = i[0]
cv.Rectangle(image, (int(j[0]), int(j[1])),
(int(j[0] + j[2]), int(j[1] + j[3])),
cv.RGB(0, 255, 0), 3, 8, 0)
def detect(image):
image_size = cv.GetSize(image)
# create grayscale version
grayscale = cv.CreateImage(image_size, 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
# create storage
storage = cv.CreateMemStorage(0)
# equalize histogram
cv.EqualizeHist(grayscale, grayscale)
# show processed image
#cv.ShowImage('Processed', grayscale)
# detect objects
cascade = cv.Load(
'/usr/local/share/OpenCV/haarcascades/haarcascade_frontalface_alt.xml')
faces = cv.HaarDetectObjects(grayscale, cascade, storage, 1.2, 2,
cv.CV_HAAR_DO_CANNY_PRUNING)
if faces:
for i in faces:
cv.Rectangle(image, (i[0][0], i[0][1]),
(i[0][0] + i[0][2], i[0][1] + i[0][3]), (0, 0, 255),
1, 8, 0)
def detect_eyes(img):
haarEyes = cv.Load('haarcascade_eye.xml')
#haarEyes = cv.Load('haarcascade_eye_tree_eyeglasses.xml')
allEyes = cv.HaarDetectObjects(img,
haarEyes,
cv.CreateMemStorage(),
scale_factor=1.25,
min_neighbors=10,
flags=0,
min_size=(10, 10))
print('All Eyes: ' + str(allEyes))
#print('LENGTH: '+str(len(allEyes)))
if (allEyes != []):
if (len(allEyes) == 1):
return allEyes
else:
eye_confid = [c for ((x, y, w, h), c) in allEyes]
eye_confid_inds = np.argsort(eye_confid)[::-1][:2]
#print(eye_confid_inds)
eye0 = allEyes[eye_confid_inds[0]]
eye1 = allEyes[eye_confid_inds[1]]
return [eye0, eye1]
return []
def get_features(self):
engine = self.context.modules.engine
mode, converted_image = engine.image_data_as_rgb(False)
size = engine.size
image = cv.CreateImageHeader(size, cv.IPL_DEPTH_8U, 3)
cv.SetData(image, converted_image)
gray = cv.CreateImage(size, 8, 1)
convert_mode = getattr(cv, 'CV_%s2GRAY' % mode)
cv.CvtColor(image, gray, convert_mode)
min_size = self.get_min_size_for(size)
haar_scale = 1.2
min_neighbors = 3
cv.EqualizeHist(gray, gray)
faces = cv.HaarDetectObjects(gray, self.__class__.cascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors,
cv.CV_HAAR_DO_CANNY_PRUNING, min_size)
faces_scaled = []
for ((x, y, w, h), n) in faces:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
x2, y2 = (x + w), (y + h)
faces_scaled.append(((x, y, x2 - x, y2 - y), n))
return faces_scaled
def detectObjects(image):
"""Converts an image to grayscale and prints the locations of any
faces found"""
grayscale = cv.CreateImage(cv.GetSize(image), 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
# Deprecated v1 code???
storage = cv.CreateMemStorage(0)
#cv.ClearMemStorage(storage)
cv.EqualizeHist(grayscale, grayscale)
cascade = cv.Load(
'/home/brian/code/twisted-faces/haarcascade_frontalface_default.xml')
faces = cv.HaarDetectObjects(grayscale, cascade, storage, 1.2, 2,
cv.CV_HAAR_DO_CANNY_PRUNING)
# if faces:
coords = []
if faces.total > 0:
for f in faces:
#print("[(%d,%d) -> (%d,%d)]" % (f.x, f.y, f.x+f.width, f.y+f.height))
coords.append({
'start': {
'x': f.x,
'y': f.y
},
'end': {
'x': f.x + f.width,
'y': f.y + f.height
}
})
return coords
