def hist_eq(self, frame):
cv.Split(frame, self.B, self.G, self.R, None)
cv.EqualizeHist(self.R, self.R)
cv.EqualizeHist(self.R, self.B)
cv.EqualizeHist(self.G, self.G)
cv.Merge(self.B, self.G, self.R, None, self.Ieq)
return self.Ieq
def detect_faces(backend, cascade_filename='haarcascade_frontalface_alt2.xml'):
cv = backend.get_opencv()
# If a relative path was provided, check local cascades directory
if not os.path.isabs(cascade_filename):
cascade_filename = os.path.join(
os.path.dirname(__file__),
'face_detection',
cascade_filename,
)
cascade = cv.Load(cascade_filename)
image = backend.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)
return [(
face[0][0],
face[0][1],
face[0][0] + face[0][2],
face[0][1] + face[0][3],
) for face in faces]
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 grayscale(self):
convert_mode = getattr(cv, 'CV_%s2GRAY' % self.mode)
gray = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
cv.CvtColor(self.image, gray, convert_mode)
cv.EqualizeHist(gray, gray)
self.image = gray
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 work(image):
image_size = cv.GetSize(image)
grayscale = cv.CreateImage(image_size, 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
storage = cv.CreateMemStorage(0)
cv.EqualizeHist(grayscale, grayscale)
return image
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 detect(image, config):
angle = None
image_size = cv.GetSize(image)
# create grayscale version
grayscale = cv.CreateImage(image_size, 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
if config["EqualizeHist"]:
cv.EqualizeHist(grayscale, grayscale)
pattern_width = 5
pattern_height = 4
found, corners = cv.FindChessboardCorners(grayscale,
(pattern_width, pattern_height))
if found:
new_corners = cv.FindCornerSubPix(
grayscale, corners, (11, 11), (-1, -1),
(cv.CV_TERMCRIT_EPS + cv.CV_TERMCRIT_ITER, 30, 0.1))
angle = corners_to_angle(new_corners)
#print "angle: ", angle
def to_int(t):
return (int(t[0]), int(t[1]))
#nc = [to_int(corner) for corner in new_corners]
#cv.Line( grayscale, nc[0], nc[4], (255,0,0), 2)
#cv.Line( grayscale, nc[4], nc[19], (0,255,0),2)
#cv.Line( grayscale, nc[19], nc[15], (0,0,255),2)
#cv.Line( grayscale, nc[15], nc[0], (255,255,0),2)
#cv.ShowImage('Processed', grayscale)
return angle
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 DetectFace(image, faceCascade, returnImage=False):
# variables
min_size = (50, 50)
haar_scale = 1.1
min_neighbors = 3
haar_flags = 0
DOWNSCALE = 4
# 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))
cv2.rectangle(image, pt1, pt2, (255, 0, 0), 5, 8, 0)
if returnImage:
return image
else:
return faces
def detect_faces(self,
cascade_filename='haarcascade_frontalface_alt2.xml'):
cv = _cv()
# If a relative path was provided, check local cascades directory
if not os.path.isabs(cascade_filename):
cascade_filename = os.path.join(
os.path.dirname(os.path.dirname(__file__)),
'data/cascades',
cascade_filename,
)
# Load cascade file
cascade = cv.Load(cascade_filename)
# Equalise the images histogram
equalised_image = cv.CloneImage(self.image)
cv.EqualizeHist(self.image, equalised_image)
# Detect faces
min_size = (40, 40)
haar_scale = 1.1
min_neighbors = 3
haar_flags = 0
faces = cv.HaarDetectObjects(equalised_image, cascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
return [(
face[0][0],
face[0][1],
face[0][0] + face[0][2],
face[0][1] + face[0][3],
) for face in faces]
def run(self):
while True:
frame = cv.QueryFrame(self.capture)
image_size = cv.GetSize(frame)
gray = cv.CreateImage((image_size[0], image_size[1]), 8, 1)
cv.CvtColor(frame, gray, cv.CV_BGR2GRAY)
# scale input image for faster processing
small_img = cv.CreateImage((cv.Round(image_size[0] / __scale__),
cv.Round(image_size[1] / __scale__)),
8, 1)
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)
cv.EqualizeHist(small_img, small_img)
s_res = sift(np.array(cv.GetMat(small_img)).flatten('C'))
n_res = np.array(s_res)
for item in n_res:
xx = item[0] * __scale__
yy = item[1] * __scale__
label_sift_point(frame, xx, yy)
cv.ShowImage("CamShiftDemo", frame)
c = cv.WaitKey(7)
if c == 27:
break
elif c == ord("t"):
frame = cv.QueryFrame(self.capture)
self.save(frame)
self.i += 1
def detect_face(image, face_cascade, return_image=False):
# This function takes a grey scale cv image and finds
# the patterns defined in the haarcascade function
min_size = (20, 20)
haar_scale = 1.1
min_neighbors = 5
haar_flags = 0
# Equalize histogram
cv.EqualizeHist(image, image)
# Detect faces
faces = cv.HaarDetectObjects(image, face_cascade, cv.CreateMemStorage(0),
haar_scale, min_neighbors, haar_flags,
min_size)
# If faces are found
if faces and return_image:
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 return_image:
return image
else:
return faces
def DetectFace(self,image, faceCascade):
min_size = (20,20)
image_scale = 2
haar_scale = 1.1
min_neighbors = 3
haar_flags = 0
# Allocate the temporary images
grayscale = cv.CreateImage((image.width, image.height), 8, 1)
#grayscale = cv.CreateImage((image.shape[1], image.shape[0]), 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, grayscale, cv.CV_BGR2GRAY)
# Scale input image for faster processing
cv.Resize(grayscale, 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:
payload=targets()
payload.ref_img_width=smallImage.width
payload.ref_img_height=smallImage.height
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)
fbox=face_box()
fbox.top_left.x=float(x)/float(smallImage.width)
fbox.top_left.y=float(y)/float(smallImage.height)
fbox.width_height.x=float(w)/float(smallImage.width)
fbox.width_height.y=float(h)/float(smallImage.height)
payload.faces.append(fbox)
#fpt=Point()
#fpt.x=(float(x) + float(w)/2.0)/float(smallImage.width)
#fpt.y=(float(y) + float(h)/2.0)/float(smallImage.height)
#payload.faces.append(fpt)
msg = payload
rospy.loginfo(msg)
self.pub.publish(msg)
return image
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(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 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
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_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 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 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(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 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 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, 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 main():
global val1, val2
img = cv.LoadImage(sys.argv[1])
if img:
cv.NamedWindow("bar")
img2 = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 1)
img21 = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 1)
img3 = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_16S, 1)
img4 = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 1)
cv.CvtColor(img, img2, cv.CV_BGR2GRAY)
cv.EqualizeHist(img2, img21)
stor = cv.CreateMemStorage()
cv.AdaptiveThreshold(img21, img4, 255,
cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C,
cv.CV_THRESH_BINARY_INV, 7, 7)
cont = cv.FindContours(img4, stor, cv.CV_RETR_LIST,
cv.CV_CHAIN_APPROX_NONE)
img5 = cv.CloneImage(img)
while cont:
if validate_contour(cont):
cv.DrawContours(img5, cont, (255, 255, 255), (255, 255, 255),
0, 2, 8, (0, 0))
cont = cont.h_next()
cv.ShowImage("bar", img5)
cv.WaitKey(0)
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 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 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 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):
objects = cv.HaarDetectObjects(small_img, cascade, cv.CreateMemStorage(0),
haar_scale, min_neighbors, haar_flags, min_size)
if objects:
for ((x, y, w, h), n) in objects:
# the input to cv.HaarDetectObjects was resized, so scale the
# bounding box of each object and convert it to two points
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
# check the diagonal of the bounding box is within max_size
if w*image_scale<max_size[0] and h*image_scale<max_size[1] :
cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0)
cv.ShowImage("result", img)
