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_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 __findObjects(self):
t = cv.GetTickCount()
self.__objects = cv.HaarDetectObjects(
self.__capturedImageSmall, self.__detectPattern,
cv.CreateMemStorage(0), self.__haar_scale, self.__min_neighbors,
self.__haar_flags, self.__min_size)
t = cv.GetTickCount() - t
self.__detectionTime = (t / (cv.GetTickFrequency() * 1000.))
class image_converter:
def __init__(self):
self.image_pub = rospy.Publisher("/imagecv",Image)
cv.NamedWindow("Image window", 1)
self.bridge = CvBridge()
self.image_sub = rospy.Subscriber("/usb_cam/image_raw",Image,self.callback)
self.cascade = cv.Load("/home/anton/work_files/ros/my_package/haarcascade_frontalface_alt2.xml")
def callback(self,data):
try:
cv_image = self.bridge.imgmsg_to_cv(data, "bgr8")
except CvBridgeError, e:
print e
gray = cv.CreateImage((cv_image.width,cv_image.height), 8, 1)
small_img = cv.CreateImage((cv.Round(cv_image.width / image_scale),
cv.Round (cv_image.height / image_scale)), 8, 1)
# convert color input image to grayscale
cv.CvtColor(cv_image, 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)
#say = 0
if(self.cascade):
t = cv.GetTickCount()
faces = cv.HaarDetectObjects(small_img, self.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(cv_image, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0)
#say = 1
cv.ShowImage("Image window", cv_image)
cv.WaitKey(3)
try:
self.image_pub.publish(self.bridge.cv_to_imgmsg(cv_image, "bgr8"))
#if say == 1:
# import festival
# tts = pyTTS.Create()
# tts.SetVoiceByName('MSSam')
# tts.Speak("Hello, fellow Python programmer")
except CvBridgeError, e:
print e
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)
window = cv.CreateImage((cv.Round(img.width), cv.Round(img.height)), 8, 3)
if (cascade):
t = cv.GetTickCount()
faces = local_haar_detect(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.))
channels = None
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 = (cv.Round(
(x + w * .2) * image_scale), cv.Round(y * image_scale))
pt2 = (cv.Round(
(x + w * .8) * image_scale), cv.Round(
(y + h) * image_scale))
window = cv.CreateImage((cv.Round(w * .6) * image_scale,
cv.Round(h) * image_scale), 8, 3)
cv.Smooth(window, window, cv.CV_GAUSSIAN)
channels = [
cv.CreateImage((cv.Round(w * .6) * image_scale,
cv.Round(h) * image_scale), 8, 1),
cv.CreateImage((cv.Round(w * .6) * image_scale,
cv.Round(h) * image_scale), 8, 1),
cv.CreateImage((cv.Round(w * .6) * image_scale,
cv.Round(h) * image_scale), 8, 1)
]
cv.GetRectSubPix(img, window, (cv.Round(
(pt1[0] + pt2[0]) / 2.0), cv.Round(
(pt1[1] + pt2[1]) / 2.0)))
cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0)
cv.Split(window, channels[0], channels[1], channels[2], None)
result.append([
cv.Avg(channels[0])[0],
cv.Avg(channels[1])[0],
cv.Avg(channels[2])[0]
])
cv.ShowImage("result", img)
def classifyKNN(self, onImg, theSign, neighbors): #0) get training data data and the labels indexs,labels,train = self.getDataLabels(onImg, theSign, True) #1) initialize the svm and compute the model problem = mlpy.Knn(neighbors, dist='se') #2) shuffle input data to do the 10-fold split shuffle(indexs) labels = labels[indexs] train = train[indexs,:] #3) define the folds, train and test pred_err = 0.0 err_rock = 0.0 err_paper = 0.0 err_scissors = 0.0 fold_ind = 0 folds = self.myFolds(labels, [1,2,3], 50) for (trainI,testI) in folds: fold_ind += 1 trainSet, testSet = train[trainI], train[testI] trainLab, testLab = labels[trainI], labels[testI] learned = problem.compute(trainSet, trainLab) print "it learned ["+str(fold_ind)+"] >>> "+str(learned) zaTime = cv.GetTickCount() totalTime = 0 prediction = problem.predict(testSet) wrong = numpy.where(numpy.array(prediction) != numpy.array(testLab))[0] if(theSign == "rock"): labWrong = testLab[map(None,wrong)] wrong_rock = numpy.where(labWrong == 1)[0] wrong_paper = numpy.where(labWrong == 2)[0] wrong_scissors = numpy.where(labWrong == 3)[0] rocks = numpy.where(testLab == 1)[0] papers = numpy.where(testLab == 2)[0] scissors = numpy.where(testLab == 3)[0] err_rock += float(float(wrong_rock.shape[0])/float(len(rocks))) err_paper += float(float(wrong_paper.shape[0])/float(len(papers))) err_scissors += float(float(wrong_scissors.shape[0])/float(len(scissors))) pred_err += float(float(wrong.shape[0])/float(len(testLab))) print prediction print testLab zaTime = cv.GetTickCount() - zaTime totalTime += zaTime/(cv.GetTickFrequency()*1000.0*float(len(testLab))) print "cumulative error %f >>> prediction time/image %gms" % (pred_err, totalTime) avg_err = float(pred_err)/float(len(folds)) if(theSign == "rock"): avg_rock = float(err_rock)/float(len(folds)) avg_paper = float(err_paper)/float(len(folds)) avg_scissors = float(err_scissors)/float(len(folds)) print "\nAvg Error:"+str(avg_err)+" >>> Avg Rock Error:"+str(avg_rock)+" >>> Avg Paper Error:"+str(avg_paper)+" >>> Avg Scissors Error:"+str(avg_scissors) return problem
def track(img, threshold=100):
'''Accepts BGR image and optional object threshold between 0 and 255 (default = 100).
Returns: (x,y) coordinates of centroid if found
(-1,-1) if no centroid was found
None if user hit ESC
'''
cascade = cv.Load("haarcascade_frontalface_alt_tree.xml")
#cascade = cv.Load("haarcascade_frontalface_default.xml")
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)
center = (-1, -1, -1)
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:
faces.sort()
((x, y, w, h), n) = faces[-1]
# 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.Rectangle(img, (x,y), (x+w,y+h), 255)
# get the xy corner co-ords, calc the center location
x1 = pt1[0]
x2 = pt2[0]
y1 = pt1[1]
y2 = pt2[1]
centerx = x1 + ((x2 - x1) / 2)
centery = y1 + ((y2 - y1) / 2)
center = (centerx, centery, h * 3)
if cmp(center, (-1, -1, -1)) == 0:
center = None
cv.NamedWindow(WINDOW_NAME, 1)
cv.ShowImage(WINDOW_NAME, img)
if cv.WaitKey(5) == 27:
center = None
return center
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 findFrame(img, haarcascade, scaleFactor=1.2, minNeighbors=2):
global loaded, lastcascadefile, cascade
if (haarcascade <> lastcascadefile):
loaded = False
if (loaded == False):
loaded = True
print haarcascade
cascade = cv.Load(haarcascade)
lastcascadefile = haarcascade
# 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)
faces = None
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:
print "found 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)
print "x= " + str(x) + " y= " + str(y) + " w= " + str(
w) + " h= " + str(h)
cv.ShowImage("Face detection", img)
return faces
def detect_and_draw(img, cascade):
rect = (1, 1, 1, 1)
# 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:
faceX = int(x * image_scale)
faceY = int(y * image_scale)
faceW = int((x + w))
faceH = int((y + h))
rect = (faceX, faceY, faceW, faceH)
# 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)
#sets the Region of Interest
cv.SetImageROI(img, rect)
face = cv.CreateImage(cv.GetSize(img), img.depth, img.nChannels)
#copy subimage */
cv.Copy(img, face)
#always reset the Region of Interest */
cv.ResetImageROI(img)
cv.ShowImage("resultFace", face)
def doPrediction(self, zaType, model, problem, what, image):
totalTime = 0
if (model == "svm"):
classifyWhat = {
"hands": {
"1": "hands",
"-1": "garb"
},
"rock": {
"1": "rock",
"-1": "paper or scissors"
},
"paper": {
"1": "paper",
"-1": "scissors"
}
}
else:
classifyWhat = {
"hands": {
"1": "hands",
"-1": "garb",
"0": "none"
},
"rock": {
"1": "rock",
"2": "paper",
"3": "scissors",
"0": "none"
}
}
zaTime = cv.GetTickCount()
testImg = self.preprocessImg(image, zaType)
prediction = problem.predict(testImg)
zaTime = cv.GetTickCount() - zaTime
totalTime += zaTime / (cv.GetTickFrequency() * 1000.0)
if ((what != "hands") or (prediction[0] == 0 and what == "hands")):
print "it is a..." + str(
classifyWhat[str(what)][str(prediction[0])]
) + " >>> prediction time/image %gms" % totalTime
return str(classifyWhat[str(what)][str(prediction[0])])
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)
centre = 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:
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)
# get the xy corner co-ords, calc the centre location
x1 = pt1[0]
x2 = pt2[0]
y1 = pt1[1]
y2 = pt2[1]
centrex = x1 + ((x2 - x1) / 2)
centrey = y1 + ((y2 - y1) / 2)
centre = (centrex, centrey)
cv.ShowImage("result", img)
return centre
def find_objects(img, cascade, shiftX = 0, shiftY = 0):
min_size = (20, 20)
image_scale = 2
haar_scale = 1.2
min_neighbors = 2
haar_flags = cv.CV_HAAR_DO_CANNY_PRUNING
# 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)
width = 640
height = 480
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.))
locations = []
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 = (width-(shiftX+int(x * image_scale)), height-(shiftY+int(y * image_scale)))
pt2 = (width-(shiftX+int((x + w) * image_scale)), height-(shiftY+int((y + h) * image_scale)))
locations.append((pt2, pt1))
#cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0)
#cv.ShowImage("result", img)
return locations
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:
x1, y1 = (int(x * image_scale), int(y * image_scale))
x2, y2 = (int((x + w) * image_scale), int(
(y + h) * image_scale))
print index, x1, y1, x2, y2
index += 1
hasHist = False
bestFaceX = 0
bestFaceY = 0
bestFaceW = 0
bestFaceH = 0
if capture:
inputFrame = None
while True:
frameCount += 1
if frameCount % 50 == 0:
hasHist = False
t = cv.GetTickCount() #start timer
frame = cv.QueryFrame(capture)
if not frame:
cv.WaitKey(0)
break
if not inputFrame:
inputFrame = cv.CreateImage((frame.width, frame.height),
cv.IPL_DEPTH_8U, frame.nChannels)
if frame.origin == cv.IPL_ORIGIN_TL:
cv.Copy(frame, inputFrame)
else:
cv.Flip(frame, inputFrame, 0)
#### resize and convert images ####
# resized color input image
frameSmall = cv.CreateImage(
def detect_and_draw(img, cascade):
t = cv.GetTickCount() ## start counter
cv.CvtColor(img, gray, cv.CV_BGR2GRAY)
cv.Resize(gray, small_img, cv.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 = cv.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))
cv.Rectangle(img, lnpt1, lnpt2, RED, 4, 8,
0) ## drawing bolded attention line
### draw eyes
cv.Rectangle(img, mf.eyeLeft1, mf.eyeLeft2, MAGENTA, 3, 8, 0)
cv.Rectangle(img, mf.eyeRight1, mf.eyeRight2, MAGENTA, 3, 8, 0)
#
### draw mouth
cv.Rectangle(img, mf.mouthTopLeft, mf.mouthBotRight, ORANGE, 3,
8, 0)
#
### draw face
cv.Rectangle(img, pt1, pt2, getColor(mf), 3, 8, 0)
#cv.Rectangle( img, pt3, pt4, MAGENTA, 1, 8, 0 ) #forehead
drawline = mf.age
if (CAPTURING): saveAsJPG(img)
if (osName == "nt"): cv.Flip(img, img, 0)
cv.ShowImage('Camera', img)
t = cv.GetTickCount() - t ## counter for FPS
print "%i fps." % (cv.GetTickFrequency() * 1000000. / t) ## print FPS
def detect_and_draw(img, cascade):
global time_point
global frame_no
global input_data
global fs
global max_bps
global last_f
# 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)
window = cv.CreateImage((cv.Round(img.width), cv.Round(img.height)), 8, 3)
if (cascade):
faces = local_haar_detect(small_img, cascade, cv.CreateMemStorage(0),
haar_scale, min_neighbors, haar_flags,
min_size)
channels = None
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 = (cv.Round(
(x + w * .2) * image_scale), cv.Round(y * image_scale))
pt2 = (cv.Round(
(x + w * .8) * image_scale), cv.Round(
(y + h) * image_scale))
window = cv.CreateImage((cv.Round(w * .6) * image_scale,
cv.Round(h) * image_scale), 8, 3)
#cv.Smooth(window, window, cv.CV_GAUSSIAN, 3, 3)
channels = [
cv.CreateImage((cv.Round(w * .6) * image_scale,
cv.Round(h) * image_scale), 8, 1),
cv.CreateImage((cv.Round(w * .6) * image_scale,
cv.Round(h) * image_scale), 8, 1),
cv.CreateImage((cv.Round(w * .6) * image_scale,
cv.Round(h) * image_scale), 8, 1)
]
cv.GetRectSubPix(img, window, (cv.Round(
(pt1[0] + pt2[0]) / 2.0), cv.Round(
(pt1[1] + pt2[1]) / 2.0)))
cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0)
cv.Split(window, channels[0], channels[1], channels[2], None)
input_data.append([
cv.Avg(channels[0])[0],
cv.Avg(channels[1])[0],
cv.Avg(channels[2])[0]
])
#measure the sampling frequency
now_point = cv.GetTickCount()
if float(fs) / 2 < max_bps and fs != 0:
max_bps = float(fs) / 2
if len(input_data) > frame_no:
fs = cv.GetTickFrequency() * 1000000. / (now_point -
time_point)
input_data.pop(0)
#print my_functions.calc_heart_rate(input_data)
final_data = my_functions.calc_heart_rate(input_data)
tmp_last_f = my_functions.plot_diagrams(
final_data, fs, last_f)
last_f = tmp_last_f
print last_f
time_point = now_point
else:
print "Can not detect face"
cv.ShowImage("result", img)
def detect_and_draw(img, cascade):
# allocate temporary images
global var1
global pos
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)
var1 = var1 + 1
if var1 == 5:
center = ((pt1[0] + pt2[0]) / 2, (pt1[1] + pt2[1]) / 2)
print center[0], center[1]
#LEFT
#if center[0]>220 and center[0]<320:
# client_socket.send("6")
#elif center[0]>120 and center[0]<220:
# client_socket.send("5")
if center[0] > 420:
if pos < 9:
pos = pos + 1
client_socket.send(str(pos))
#RIGHT
#elif center[0]>320 and center[0]<420:
# client_socket.send("7")
#elif center[0]>420 and center[0]<520:
# client_socket.send("8")
elif center[0] < 200:
if pos > 3:
pos = pos - 1
client_socket.send(str(pos))
print pos
var1 = 0
cv.ShowImage("result", img)
def detect_and_draw(img, cascade):
global previousPos
# 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()
xcenter = 640/2
ycenter = 480/2
centersize = 150
innercentersize = 100
cv.Rectangle(img, (xcenter-centersize,ycenter-centersize), (xcenter+centersize,ycenter+centersize), cv.RGB(0, 255, 0), 3, 8, 0)
cv.Rectangle(img, (xcenter-innercentersize,ycenter-innercentersize), (xcenter+innercentersize,ycenter+innercentersize), cv.RGB(0, 0, 255), 3, 8, 0)
faces = cv.HaarDetectObjects(small_img, cascade, cv.CreateMemStorage(0),
haar_scale, min_neighbors, 1, 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)
xval = x+w/2
yval = y+h/2
print "(%sx%s,%sx%s)" % (x,y,w,h)
print "(%s,%s)=%s" % (xcenter,xval,xcenter-xval)
msgs = False
if 1:
#if previousPos:
if (xval>170):
controlMessage("left")
msgs = True
elif (xval<130):
controlMessage("right")
msgs = True
#else:
# controlMessage("stayx")
if (w>centersize):
msgs = True
controlMessage("up")
elif (w<innercentersize):
msgs = True
controlMessage("down")
if not msgs:
controlMessage("stay")
#previousPos = (xval,yval)
# if (xval
cv.ShowImage("result", img)
def detect_and_send(img, cascade):
global screenW, screenH, threshold, Debug, showCamera
global oldTimeDebug
global somme, cpt
# 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)
# l'algo de reconnaissance de forme est basé sur des images en niveaux de gris
cv.CvtColor(img, gray, cv.CV_BGR2GRAY)
# Réduit la taille de l'image pour un traitement plus rapide
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)
#Augmente le contraste (égalise la luminosité)
cv.EqualizeHist(small_img, small_img)
centreCercle = (0, 0)
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
cpt += 1
somme += t / (cv.GetTickFrequency() * 1000.)
if Debug == 1:
print "detection time = %gms" % (t /
(cv.GetTickFrequency() * 1000.))
if faces:
oldx = centreCercle[0]
oldy = centreCercle[1]
for ((x, y, w, h), n) in faces:
#la bounding box encadrant le visage, sachant que l'image a été remdimensionnée pour le traitement (+ rapide)
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, (255, 0, 0))
#On doit calculer l'opposé de la valeur qu'on trouverait car la caméra n'agit pas comme un miroir
#en effet si je bouge vers la droite l'image fait bouger la tête vers la gauche (donc vers la droite selon mon
#point de vue)
ex = -(float(centreCercle[0]) / float(img.width) * screenW -
screenW / 2.0)
ey = -(
(float(centreCercle[1]) / float(img.height) * screenH -
screenH / 2.0)
) #+ screenH / 2.0 #compense le fait que la caméra est au dessus de l'écran
oldx = centreCercle[0]
oldy = centreCercle[1]
#Détermination de ez en fonction de la taille de la tête à l'écran
ez = -1.50567 * (h * image_scale) + 893.688
#assure la stabilité de l'image, si on enlève ce test ça tremblote à mort car la détection n'étant pas ultra précise
#la position de la tête est considérée comme changeante en permanence
#la constante a été déterminée empiriquement sur une webcam intégrée de mcbook 13,3"(voir fichier conf.cfg)
#Gestion du temps pour permettre de bouger lentement (fonctionne mal pour l'instant)
newTime = time.time()
if abs(oldx - centreCercle[0]) > threshold or abs(
oldy - centreCercle[1]
) > threshold: #or (newTime - oldTimeThr) > 1
liblo.send(target, "/coordonnees/", ex, ey, ez)
oldTimeThr = newTime
#DEBUG, affiche la position des yeux toutes les 1/2 secondes
if Debug == 1:
if (newTime - oldTimeDebug) > 0.5:
print "\n-----------DEBUG----------"
print "Coordonnée centre sur image : " + str(
centreCercle[0]) + " " + str(centreCercle[1])
print "Coordonnées yeux dans référentiel 3D : "
print "ex = " + str(ex) + " ey = " + str(
ey) + " ez = " + str(ez)
oldTimeDebug = newTime
#debug tracking visage
if showCamera == 1:
cv.ShowImage("result", img)
if capture:
frame_copy = None
while True:
frame = cv.QueryFrame(capture)
if not frame:
cv.WaitKey(0)
break
if not frame_copy:
frame_copy = cv.CreateImage((frame.width, frame.height),
cv.IPL_DEPTH_8U, frame.nChannels)
if frame.origin == cv.IPL_ORIGIN_TL:
cv.Copy(frame, frame_copy)
else:
cv.Flip(frame, frame_copy, 0)
time_point = cv.GetTickCount()
detect_and_draw(frame_copy, cascade)
if cv.WaitKey(10) >= 0:
break
else:
image = cv.LoadImage(input_name, 1)
detect_and_draw(image, cascade)
cv.WaitKey(0)
#for i in input_data:
#print ",".join(["%s" % k for k in i])
cv.DestroyWindow("result")
