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 = cv2.LoadImage(self.full_path,
cv2.CV_LOAD_IMAGE_GRAYSCALE)
o_width, o_height = self.cv_image.width, self.cv_image.height
cv2.EqualizeHist(self.cv_image, self.cv_image)
cascade = cv2.Load(HAARCASCADE_PATH)
faces = cv2.HaarDetectObjects(self.cv_image, cascade,
cv2.CreateMemStorage(0), 1.2, 2,
cv2.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 DetectFace(image, faceCascade):
#modified from: http://www.lucaamore.com/?p=638
min_size = (20, 20)
image_scale = 1
haar_scale = 1.1
min_neighbors = 3
haar_flags = 0
# Allocate the temporary images
smallImage = cv2.CreateImage((cv2.Round(
image.width / image_scale), cv2.Round(image.height / image_scale)), 8,
1)
# Scale input image for faster processing
cv2.Resize(image, smallImage, cv2.CV_INTER_LINEAR)
# Equalize the histogram
cv2.EqualizeHist(smallImage, smallImage)
# Detect the faces
faces = cv2.HaarDetectObjects(smallImage, faceCascade,
cv2.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))
cv2.Rectangle(image, pt1, pt2, cv2.RGB(255, 0, 0), 5, 8, 0)
return image
def DetectFace(image, faceCascade, returnImage=False):
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 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
cv2.EqualizeHist(image, image)
# Detect the faces
faces = cv2.HaarDetectObjects(image, faceCascade, cv2.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, cv2.RGB(255, 0, 0), 5, 8, 0)
if returnImage:
return image
else:
return faces
def detect_faces(self, image_filename):
""" Detects all faces and returns a list with
images and corresponding coordinates"""
logging.debug(
'Start method "detect_faces" for file %s (face-detector.py)' %
image_filename)
cascade = cv.Load(parameter.cascadefile) # load face cascade
image = cv.LoadImage(image_filename) # loads and converts image
# detect and save coordinates of detected faces
coordinates = cv.HaarDetectObjects(
image, cascade, cv.CreateMemStorage(), parameter.scaleFactor,
parameter.minNeighbors, parameter.flags, parameter.min_facesize)
# Convert to greyscale - better results when converting AFTER facedetection with viola jones
if image.channels == 3:
logging.debug(
'Bild %s wird in Graustufenbild umgewandelt (face-detector.py)'
% image_filename)
grey_face = (cv.CreateImage((image.width, image.height), 8,
1)) # Create grey-scale Image
cv.CvtColor(image, grey_face, cv.CV_RGB2GRAY
) # convert Image to Greyscale (necessary for SURF)
image = grey_face
logging.debug(
'%d faces successfully detected in file %s (face-detector.py)' %
(len(coordinates), image_filename))
return image, coordinates
def detect_no_draw(self, img):
# allocate temporary images
gray = cv.CreateImage((img.width, img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(img.width / self.image_scale),
cv.Round(img.height / self.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 self.cascade:
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, self.cascade,
cv.CreateMemStorage(0),
self.haar_scale, self.min_neighbors,
self.haar_flags, self.min_size)
t = cv.GetTickCount() - t
if faces:
return True
else:
return False
def DetectEyes(imageCV, faceCascade, eyeCascade):
minSize = (20, 20)
imageScale = 2
haarScale = 1.2
minNeighbors = 2
haarFlags = 0
# Allocate the temporary images
#gray = cv2.CreateImage((imageCV.width, image.height), 8, 1)
#smallImage = cv.CreateImage((cv.Round(image.width / image_scale), cv2.Round (image.height / image_scale)), 8 ,1)
# Convert color input image to grayscale
cv2.cvtColor(image, gray, cv.CV_BGR2GRAY)
# Scale input image for faster processing
cv2.Resize(gray, smallImage, cv.CV_INTER_LINEAR)
# Equalize the histogram
cv2.EqualizeHist(smallImage, smallImage)
# Detect the faces
faces = cv2.HaarDetectObjects(smallImage, faceCascade,
cv2.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))
cv2.Rectangle(image, pt1, pt2, cv2.RGB(255, 0, 0), 3, 8, 0)
def detect(image):
image_faces = []
bitmap = cv.fromarray(image)
faces = cv.HaarDetectObjects(bitmap, cascade, cv.CreateMemStorage(0))
if faces:
for (x, y, w, h), n in faces:
image_faces.append(image[y:(y + h), x:(x + w)])
#cv2.rectangle(image,(x,y),(x+w,y+h),(255,255,255),3)
return image_faces
def faces_from_pil_image(pil_image):
"Return a list of (x,y,h,w) tuples for faces detected in the PIL image"
storage = cv2.CvMemStorage(0)
facial_features = cv2.Load('haarcascade_frontalface_alt.xml', storage=storage)
cv_im = cv2.CreateImageHeader(pil_image.size, cv.IPL_DEPTH_8U, 3)
cv2.SetData(cv_im, pil_image.tostring())
faces = cv2.HaarDetectObjects(cv2_im, facial_features, storage)
# faces includes a `neighbors` field that we aren't going to use here
return [f[0] for f in faces]
def detect_faces(image_path, min_face_size):
cv_image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
o_width, o_height = cv_image.shape[0], cv_image.shape[1]
cv2.equalizeHist(cv_image, cv_image)
cascade = cv2.CascadeClassifier(HAARCASCADE_PATH)
# ???
faces = cv2.HaarDetectObjects(cv_image, cascade, cv2.CreateMemStorage(0),
1.2, 2, cv2.CV_HAAR_DO_CANNY_PRUNING,
min_face_size)
return faces
def detect_object(image):
'''dect'''
grayscale = cv2.CreateImage((image.width, image.height), 8, 1)
cv2.CvtColor(image, grayscale, cv2.CV_BGR2GRAY)
cascade = cv2.Load("data/haarcascades/haarcascade_frontalface_alt.xml")
rect = cv2.HaarDetectObjects(grayscale, cascade, cv2.CreateMemStorage(),
1.1, 2, cv2.CV_HAAR_DO_CANNY_PRUNING,
(20, 20))
result = []
for r in rect:
result.append((r[0][0], r[0][1], r[0][0] + r[0][2], r[0][1] + r[0][3]))
return result
def detect_object(image):
'''检测图片，获取人脸在图片中的坐标'''
grayscale = cv.CreateImage((image.width, image.height), 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
cascade = cv.Load(
"/usr/local/opencv-2.4.9/data/haarcascades/haarcascade_frontalface_alt_tree.xml"
)
rect = cv.HaarDetectObjects(grayscale, cascade, cv.CreateMemStorage(), 1.1,
2, cv.CV_HAAR_DO_CANNY_PRUNING, (20, 20))
result = []
for r in rect:
result.append((r[0][0], r[0][1], r[0][0] + r[0][2], r[0][1] + r[0][3]))
return result
def detect_object(image):
print('aaa')
'''检测图片，获取人脸在图片中的坐标'''
grayscale = numpy.zeros(image.shape, numpy.uint8) # v2.CreateImage((image.width, image.height), 8, 1)
cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cascade = cv2.Load("C:/Users/polyv-1107/opencv-3.3.0/data/haarcascades/haarcascade_frontalface_alt_tree.xml")
rect = cv2.HaarDetectObjects(grayscale, cascade, cv2.CreateMemStorage(), 1.1, 2,
cv2.CV_HAAR_DO_CANNY_PRUNING, (20,20))
result = []
for r in rect:
result.append((r[0][0], r[0][1], r[0][0]+r[0][2], r[0][1]+r[0][3]))
return result
def get_faces(self, image):
"""
Given an opencv image, return a ((x,y,w,h), certainty) tuple for each face
detected.
"""
# Convert the image to grayscale and normalise
cv.CvtColor(image, self.gray, cv.CV_BGR2GRAY)
cv.EqualizeHist(self.gray, self.gray)
# Detect faces
return cv.HaarDetectObjects(self.gray,
self.cascade,
self.storage,
scale_factor=1.3,
min_neighbors=2,
flags=cv.CV_HAAR_DO_CANNY_PRUNING,
min_size=(40, 40))
def detect_and_draw(self, img):
# allocate temporary images
gray = cv.CreateImage((img.width, img.height), 8, 1)
small_img = cv.CreateImage((cv.Round(img.width / self.image_scale),
cv.Round(img.height / self.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 self.cascade:
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, self.cascade,
cv.CreateMemStorage(0),
self.haar_scale, self.min_neighbors,
self.haar_flags, self.min_size)
t = cv.GetTickCount() - t
# print "time taken for detection = %gms" % (t/(cv.GetTickFrequency()*1000.))
if faces:
face_found = True
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))
cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0)
else:
face_found = False
cv.ShowImage("video", img)
return face_found
def detect_nose(cv2_image, storage):
"""Detects nose based on haar. Returns ponts"""
return cv2.HaarDetectObjects(cv2image_grayscale(cv2_image), NOSE_HAAR,
storage)
#BuildingES.py
#!/usr/bin/python
import cv2 #import the openCV lib to python
import serial #import the pyserial module
#Module -1: Image Processing
hc = cv2.imread(
'/home/george/PycharmProjects/Embeded image processing system/haarcascade_frontalface_alt2.xml'
)
img = cv2.imshow('/home/jayneil/beautiful-faces.jpg', 0)
faces = cv2.HaarDetectObjects(img, hc, cv2.CreateMemStorage())
a = 1
print(faces)
for (x, y, w, h), n in faces:
cv2.Rectangle(img, (x, y), (x + w, y + h), 255)
cv2.SaveImage("faces_detected.jpg", img)
dst = cv2.imread('faces_detected.jpg')
cv2.NamedWindow('Face Detected', cv2.CV_WINDOW_AUTOSIZE)
cv2.imshow('Face Detected', dst)
cv2.WaitKey(5000)
cv2.DestroyWindow('Face Detected')
#Module -2: Trigger Pyserial
if faces == []:
ser = serial.Serial('/dev/ttyUSB0', 9600)
print(ser)
ser.write('N')
else:
import cv2
import sys
storage = cv2.CreateMemStorage()
image_path = "yusei.jpg"
img = cv2.imread(image_path)
hc = cv2.Load("../data/haarcascades/haarcascade_frontalface_default.xml")
faces = cv2.HaarDetectObjects(img, hc, storage, 1.1, 3, 0, (0, 0))
max = 0
maxh = 0
maxw = 0
resx = 0
resy = 0
for (x, y, w, h), n in faces:
if max < w * h:
maxw = w
maxh = h
resx = x
resy = y
max = w * h
sub = cv2.GetSubRect(img, (resx, resy, maxw, maxh))
cv2.SaveImage("face_" + sys.argv[1], sub)
# convert color input image to grayscale
cv.CvtColor(frame, 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)
midFace = None
if (cascade):
t = cv.GetTickCount()
# HaarDetectObjects takes 0.02s
faces = cv.HaarDetectObjects(small_img, cascade,
cv.CreateMemStorage(0), haar_scale,
min_neighbors, haar_flags, min_size)
t = cv.GetTickCount() - t
if faces:
lights(50 if len(faces) == 0 else 0, 50 if len(faces) > 0 else 0,
0, 50)
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(frame, pt1, pt2, cv.RGB(100, 220, 255), 1, 8, 0)
# get the xy corner co-ords, calc the midFace location
x1 = pt1[0]
x2 = pt2[0]
def detectFace(self, cam_img, faceCascade, eyeCascade, mouthCascade): # cam_img should be cv2.cv.iplcam_img
min_size = (20, 20)
image_scale = 2
haar_scale = 1.2
min_neighbors = 2
haar_flags = 0
image_width = int(cam_img.get(cv.CV_CAP_PROP_FRAME_WIDTH))
image_height = int(cam_img.get(cv.CV_CAP_PROP_FRAME_HEIGHT))
# Allocate the temporary images
gray = cv.CreateImage((image_width, image_height), 8, 1) # tuple as the first arg
smallImage = cv.CreateImage((cv.Round(image_width / image_scale), cv.Round(image_height / image_scale)), 8, 1)
(ok, img) = cam_img.read()
# print 'gray is of ',type(gray) >>> gray is of <type 'cv2.cv.iplimage'>
# print type(smallImage) >>> <type 'cv2.cv.iplimage'>
# print type(image) >>> <type 'cv2.VideoCapture'>
# print type(img) >>> <type 'numpy.ndarray'>
# convert numpy.ndarray to iplimage
ipl_img = cv2.cv.CreateImageHeader((img.shape[1], img.shape[0]), cv.IPL_DEPTH_8U, 3)
cv2.cv.SetData(ipl_img, img.tostring(), img.dtype.itemsize * 3 * img.shape[1])
# Convert color input image to grayscale
cv.CvtColor(ipl_img, 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)
# => The function returns a list of tuples, (rect, neighbors) , where rect is a CvRect specifying the object’s extents and neighbors is a number of neighbors.
# => CvRect cvRect(int x, int y, int width, int height)
# If faces are found
if faces:
face = faces[0]
self.faceX = face[0][0]
self.faceY = face[0][1]
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(ipl_img, pt1, pt2, cv.RGB(0, 0, 255), 3, 8, 0)
# face_region = cv.GetSubRect(ipl_img,(x,int(y + (h/4)),w,int(h/2)))
cv.SetImageROI(ipl_img, (pt1[0],
pt1[1],
pt2[0] - pt1[0],
int((pt2[1] - pt1[1]) * 0.7)))
eyes = cv.HaarDetectObjects(ipl_img, 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(ipl_img, # image
(eye[0][0], # vertex pt1
eye[0][1]),
(eye[0][0] + eye[0][2], # vertex pt2 opposite to pt1
eye[0][1] + eye[0][3]),
cv.RGB(255, 0, 0), 1, 4, 0) # color,thickness,lineType(8,4,cv.CV_AA),shift
cv.ResetImageROI(ipl_img)
return ipl_img
def detect_and_draw(img, cascade):
t = cv2.GetTickCount() ## start counter
cv2.CvtColor(img, gray, cv2.CV_BGR2GRAY)
cv2.Resize(gray, small_img, cv2.CV_INTER_LINEAR)
#Ages all trackedFaces
for f in trackedFaces:
f.updateLife()
#Remove expired faces
for f in trackedFaces:
if (f.isTooOld()):
trackedFaces.remove(f)
faces = cv2.HaarDetectObjects(small_img, cascade, storage, haar_scale,
min_neighbors, haar_flags, min_size)
drawline = 0
if faces:
#found a face
for ((x, y, w, h), n) in faces:
matchedFace = False
pt1 = (int(x * image_scale), int(y * image_scale))
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale))
pt3 = (int(x * image_scale) + int(
((x + w) * image_scale - x * image_scale) / 3),
int(y * image_scale))
pt4 = (int((x + w) * image_scale) - int(
((x + w) * image_scale - x * image_scale) / 3),
int((y * image_scale) + int((
(y + h) * image_scale) - int(y * image_scale)) / 3))
#check if there are trackedFaces
if (len(trackedFaces) > 0):
#each face being tracked
for f in trackedFaces:
#the face is found (small movement)
if ((abs(f.xpt - pt1[0]) < FACE_MAX_MOVEMENT)
and (abs(f.ypt - pt1[1]) < FACE_MAX_MOVEMENT)):
matchedFace = True
f.updateFace(int(w * image_scale),
int(h * image_scale), pt1[0], pt1[1])
mf = f
break
#if face not found, add a new face
if (matchedFace == False):
f = Face(0, int(w * image_scale), int(h * image_scale),
pt1[0], pt1[1], 0)
trackedFaces.append(f)
mf = f
#No tracked faces: adding one
else:
f = Face(0, int(w * image_scale), int(h * image_scale), pt1[0],
pt1[1], 0)
trackedFaces.append(f)
mf = f
#where to draw face and properties
if (mf.age > 5):
#draw attention line
lnpt1 = (int(mf.xpt * scale), int(mf.ypt * scale - 5) - 5)
if (mf.age > mf.width):
lnpt2 = (int(mf.xpt * scale + mf.width),
int(mf.ypt * scale - 5))
else:
lnpt2 = (int(mf.xpt * scale + mf.age),
int(mf.ypt * scale - 5))
cv2.Rectangle(img, lnpt1, lnpt2, RED, 4, 8,
0) ## drawing bolded attention line
### draw eyes
cv2.Rectangle(img, mf.eyeLeft1, mf.eyeLeft2, MAGENTA, 3, 8, 0)
cv2.Rectangle(img, mf.eyeRight1, mf.eyeRight2, MAGENTA, 3, 8,
0)
#
### draw mouth
cv2.Rectangle(img, mf.mouthTopLeft, mf.mouthBotRight, ORANGE,
3, 8, 0)
#
### draw face
cv2.Rectangle(img, pt1, pt2, getColor(mf), 3, 8, 0)
#cv2.Rectangle( img, pt3, pt4, MAGENTA, 1, 8, 0 ) #forehead
drawline = mf.age
if (CAPTURING): saveAsJPG(img)
if (osName == "nt"): cv2.Flip(img, img, 0)
cv2.ShowImage('Camera', img)
t = cv2.GetTickCount() - t ## counter for FPS
print("%i fps." % (cv2.GetTickFrequency() * 1000000. / t)) ## print FPS
def detect_eyes(cv2_image, storage):
"""Detects eyes based on haar. Returns points"""
return cv2.HaarDetectObjects(cv2image_grayscale(cv2_image), EYE_HAAR,
storage)
def detect_mouth(cv2_image, storage):
"""Detects mouth based on haar. Returns points"""
return cv2.HaarDetectObjects(cv2image_grayscale(cv2_image), MOUTH_HAAR,
storage)
import cv2 as cv
img = cv.LoadImage("friend1.jpg")
image_size = cv.GetSize(img) #获取图片的大小
greyscale = cv.CreateImage(image_size, 8, 1) #建立一个相同大小的灰度图像
cv.CvtColor(img, greyscale, cv.CV_BGR2GRAY) #将获取的彩色图像，转换成灰度图像
storage = cv.CreateMemStorage(0) #创建一个内存空间，人脸检测是要利用，具体作用不清楚
cv.EqualizeHist(greyscale, greyscale) #将灰度图像直方图均衡化，貌似可以使灰度图像信息量减少，加快检测速度
# detect objects
cascade = cv.Load('haarcascade_frontalface_alt2.xml') #加载Intel公司的训练库
#检测图片中的人脸，并返回一个包含了人脸信息的对象faces
faces = cv.HaarDetectObjects(greyscale, cascade, storage, 1.2, 2,
cv.CV_HAAR_DO_CANNY_PRUNING, (50, 50))
#获得人脸所在位置的数据
j = 0 #记录个数
for (x, y, w, h), n in faces:
j += 1
cv.SetImageROI(img, (x, y, w, h)) #获取头像的区域
cv.SaveImage("face" + str(j) + ".jpg", img)
#保存下来
