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 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 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
cv.Canny(im, dst, 200, 200)
cv.Threshold(dst, dst, 100, 255, cv.CV_THRESH_BINARY)
#---- Standard ----
color_dst_standard = cv.CreateImage(cv.GetSize(im), 8, 3)
cv.CvtColor(im, color_dst_standard,
cv.CV_GRAY2BGR) #Create output image in RGB to put red lines
lines = cv.HoughLines2(dst, cv.CreateMemStorage(0), cv.CV_HOUGH_STANDARD, 1,
pi / 180, 100, 0, 0)
for (rho, theta) in lines[:100]:
a = math.cos(theta) #Calculate orientation in order to print them
b = math.sin(theta)
x0 = a * rho
y0 = b * rho
pt1 = (cv.Round(x0 + 1000 * (-b)), cv.Round(y0 + 1000 * (a)))
pt2 = (cv.Round(x0 - 1000 * (-b)), cv.Round(y0 - 1000 * (a)))
cv.Line(color_dst_standard, pt1, pt2, cv.CV_RGB(255, 0, 0), 2,
4) #Draw the line
#---- Probabilistic ----
color_dst_proba = cv.CreateImage(cv.GetSize(im), 8, 3)
cv.CvtColor(im, color_dst_proba, cv.CV_GRAY2BGR) # idem
rho = 1
theta = pi / 180
thresh = 50
minLength = 120 # Values can be changed approximately to fit your image edges
maxGap = 20
lines = cv.HoughLines2(dst, cv.CreateMemStorage(0), cv.CV_HOUGH_PROBABILISTIC,
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
cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH, 1280)
cv.SetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_HEIGHT, 720)
frame = cv.QueryFrame(capture)
test = cv.CreateImage(cv.GetSize(frame), 8, 3)
cv.NamedWindow("output")
previous_x = 0
previous_y = 0
while (1):
frame = cv.QueryFrame(capture)
cv.Flip(frame, frame, 1)
# we make all drawings on imdraw.
imdraw = cv.CreateImage(cv.GetSize(frame), 8, 3)
# we get coordinates from imgyellowthresh
imgyellowthresh = getthresholdedimg(frame)
# eroding removes small noises
cv.Erode(imgyellowthresh, imgyellowthresh, None, 1)
(leftmost, rightmost, topmost, bottommost) = getpositions(imgyellowthresh)
if (leftmost - rightmost != 0) or (topmost - bottommost != 0):
lastx = posx
lasty = posy
posx = cv.Round((rightmost + leftmost) / 2)
posy = cv.Round((bottommost + topmost) / 2)
if lastx != 0 and lasty != 0:
win32api.SetCursorPos((posx, posy))
cv.Add(test, imdraw, test)
cv.ShowImage("output", test)
if cv.WaitKey(10) >= 0:
break
cv.DestroyWindow("output")
while (True):
# Capture frame-by-frame
result, frame = capture.read()
#frame = cv.QueryFrame(cap)
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.Flip(frame, frame, -1)
# Our operations on the frame come here
gray = cv.CreateImage((frame.width, frame.height), 8, 1)
small_img = cv.CreateImage((cv.Round(
frame.width / image_scale), cv.Round(frame.height / image_scale)), 8,
1)
# 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
def process_image(self, slider_pos):
global cimg, source_image1, ellipse_size, maxf, maxs, eoc, lastcx,lastcy,lastr
"""
This function finds contours, draws them and their approximation by ellipses.
"""
stor = cv.CreateMemStorage()
# Create the destination images
cimg = cv.CloneImage(self.source_image)
cv.Zero(cimg)
image02 = cv.CloneImage(self.source_image)
cv.Zero(image02)
image04 = cv.CreateImage(cv.GetSize(self.source_image), cv.IPL_DEPTH_8U, 3)
cv.Zero(image04)
# Threshold the source image. This needful for cv.FindContours().
cv.Threshold(self.source_image, image02, slider_pos, 255, cv.CV_THRESH_BINARY)
# Find all contours.
cont = cv.FindContours(image02,
stor,
cv.CV_RETR_LIST,
cv.CV_CHAIN_APPROX_NONE,
(0, 0))
maxf = 0
maxs = 0
size1 = 0
for c in contour_iterator(cont):
if len(c) > ellipse_size:
PointArray2D32f = cv.CreateMat(1, len(c), cv.CV_32FC2)
for (i, (x, y)) in enumerate(c):
PointArray2D32f[0, i] = (x, y)
# Draw the current contour in gray
gray = cv.CV_RGB(100, 100, 100)
cv.DrawContours(image04, c, gray, gray,0,1,8,(0,0))
if iter == 0:
strng = segF + '/' + 'contour1.png'
cv.SaveImage(strng,image04)
color = (255,255,255)
(center, size, angle) = cv.FitEllipse2(PointArray2D32f)
# Convert ellipse data from float to integer representation.
center = (cv.Round(center[0]), cv.Round(center[1]))
size = (cv.Round(size[0] * 0.5), cv.Round(size[1] * 0.5))
if iter == 1:
if size[0] > size[1]:
size2 = size[0]
else:
size2 = size[1]
if size2 > size1:
size1 = size2
size3 = size
# Fits ellipse to current contour.
if eoc == 0 and iter == 2:
rand_val = abs((lastr - ((size[0]+size[1])/2)))
if rand_val > 20 and float(max(size[0],size[1]))/float(min(size[0],size[1])) < 1.5:
lastcx = center[0]
lastcy = center[1]
lastr = (size[0]+size[1])/2
if rand_val > 20 and float(max(size[0],size[1]))/float(min(size[0],size[1])) < 1.4:
cv.Ellipse(cimg, center, size,
angle, 0, 360,
color,2, cv.CV_AA, 0)
cv.Ellipse(source_image1, center, size,
angle, 0, 360,
color,2, cv.CV_AA, 0)
elif eoc == 1 and iter == 2:
(int,cntr,rad) = cv.MinEnclosingCircle(PointArray2D32f)
cntr = (cv.Round(cntr[0]), cv.Round(cntr[1]))
rad = (cv.Round(rad))
if maxf == 0 and maxs == 0:
cv.Circle(cimg, cntr, rad, color, 1, cv.CV_AA, shift=0)
cv.Circle(source_image1, cntr, rad, color, 2, cv.CV_AA, shift=0)
maxf = rad
elif (maxf > 0 and maxs == 0) and abs(rad - maxf) > 30:
cv.Circle(cimg, cntr, rad, color, 2, cv.CV_AA, shift=0)
cv.Circle(source_image1, cntr, rad, color, 2, cv.CV_AA, shift=0)
maxs = len(c)
if iter == 1:
temp3 = 2*abs(size3[1] - size3[0])
if (temp3 > 40):
eoc = 1
def drawGraph(arraySrc,
nArrayLength,
imageDst,
minV=0,
maxV=0,
width=0,
height=0,
graphLabel='',
showScale=True):
w, h, b = width, height, 10
w = nArrayLength + b * 2 if w <= 20 else w
h = 220 if h <= 20 else h
s, xscale = h - b * 2, 1.0
if nArrayLength > 1:
xscale = (w - b * 2) / float(nArrayLength - 1)
# Assume imageDst is a numpy array
if not imageDst:
imageGraph = Image.new('RGB', (w, h), WHITE)
# imageGraph.show()
else:
imageGraph = imageDst
if not imageGraph:
print 'Error in drawGraph'
return
colorGraph = getGraphColor()
if abs(minV) < 1e-7 and abs(maxV) < 1e-7:
for i in range(nArrayLength):
v = arraySrc[i]
minV = v if v < minV else minV
maxV = v if v > maxV else maxV
diffV = maxV - minV
diffV = 1e-7 if diffV == 0 else diffV
fscale = float(s) / diffV
# Draw the horizontal and vertical axis
y0 = cv2.Round(minV * fscale)
cv2.Line(imageGraph, (b, h - (b - y0)), (w - b, h - (b - y0)), BLACK)
cv2.Line(imageGraph, (b, h - b), (b, h - (b + s)), BLACK)
# Write the scale of the y and x axis
if showScale:
#cv2.putText(frame, text, (int(x), int(y)), cv2.FONT_HERSHEY_SIMPLEX, size, color, thickness)
cv2.putText(imageGraph, '%.1f' % maxV, (1, b + 4),
cv2.FONT_HERSHEY_PLAIN, 2, GREY, 0.1)
cv2.putText(imageGraph, '%d' % (nArrayLength - 1),
(w - b + 4 - 5 * 2, h / 2 + 10), cv2.FONT_HERSHEY_PLAIN, 2,
GREY, 0.1)
# Draw the values
ptPrev = (b, h - (b - y))
for i in range(nArrayLength):
y = cv2.Round((arraySrc[i] - minV) * fscale)
x = cv2.Round(i * xscale)
ptNew = (b + x, h - (b + y))
cv2.Line(imageGraph, ptPrev, ptNew, colorGraph, 1, cv2.CV_AA)
ptPrev = ptNew
# Write the graph label
if graphLabel != None and graphLabel != '':
cv2.putText(imageGraph, graphLabel, (30, 10), cv2.FONT_HERSHEY_PLAIN,
2, GREY, 0.1)
return imageGraph
def rectify_uncalibrated(x1, x2, F, imsize, threshold=5):
"""
Compute rectification homography for two images. This is based on
algo 11.12.3 of HZ2
This is also heavily inspired by cv::stereoRectifyUncalibrated
Args:
- imsize is (width, height)
"""
U, W, V = la.svd(F)
# Enforce rank 2 on fundamental matrix
W[2] = 0
W = np.diag(W)
F = U.dot(W).dot(V)
# Filter points based on their distance to epipolar lines
if threshold > 0:
lines1 = epipolar_lines(x1, F)
lines2 = epipolar_lines(x2, F.T)
def epi_threshold(i):
return (abs(x1[0,i]*lines2[0,i] +
x1[1,i]*lines2[1,i] +
lines2[2,i]) <= threshold) and \
(abs(x2[0,i]*lines1[0,i] +
x2[1,i]*lines1[1,i] +
lines1[2,i]) <= threshold)
inliers = filter(epi_threshold, range(x1.shape[1]))
else:
inliers = range(x1.shape[1])
assert len(inliers) > 0
x1 = x1[:, inliers]
x2 = x2[:, inliers]
# HZ2 11.12.1 : Compute H = GRT where :
# - T is a translation taking point x0 to the origin
# - R is a rotation about the origin taking the epipole e' to (f,0,1)
# - G is a mapping taking (f,0,1) to infinity
# e2 is the left null vector of F (the one corresponding to the singular
# value that is 0 => the third column of U)
e2 = U[:, 2]
# TODO: They do this in OpenCV, not sure why
if e2[2] < 0:
e2 *= -1
# Translation bringing the image center to the origin
# FIXME: This is kind of stupid, but to get the same results as OpenCV,
# use cv.Round function, which has a strange behaviour :
# cv.Round(99.5) => 100
# cv.Round(132.5) => 132
cx = cv2.Round((imsize[0] - 1) * 0.5)
cy = cv2.Round((imsize[1] - 1) * 0.5)
T = np.array([[1, 0, -cx], [0, 1, -cy], [0, 0, 1]], dtype=float)
e2 = T.dot(e2)
mirror = e2[0] < 0
# Compute rotation matrix R that should bring e2 to (f,0,1)
# 2D norm of the epipole, avoid division by zero
d = max(np.sqrt(e2[0] * e2[0] + e2[1] * e2[1]), 1e-7)
alpha = e2[0] / d
beta = e2[1] / d
R = np.array([[alpha, beta, 0], [-beta, alpha, 0], [0, 0, 1]], dtype=float)
e2 = R.dot(e2)
# Compute G : mapping taking (f,0,1) to infinity
invf = 0 if abs(e2[2]) < 1e-6 * abs(e2[0]) else -e2[2] / e2[0]
G = np.array([[1, 0, 0], [0, 1, 0], [invf, 0, 1]], dtype=float)
# Map the origin back to the center of the image
iT = np.array([[1, 0, cx], [0, 1, cy], [0, 0, 1]], dtype=float)
H2 = iT.dot(G.dot(R.dot(T)))
# HZ2 11.12.2 : Find matching projective transform H1 that minimize
# leaste-square distance between reprojected points
e2 = U[:, 2]
# TODO: They do this in OpenCV, not sure why
if e2[2] < 0:
e2 *= -1
e2_x = np.array(
[[0, -e2[2], e2[1]], [e2[2], 0, -e2[0]], [-e2[1], e2[0], 0]],
dtype=float)
e2_111 = np.array(
[[e2[0], e2[0], e2[0]], [e2[1], e2[1], e2[1]], [e2[2], e2[2], e2[2]]],
dtype=float)
H0 = H2.dot(e2_x.dot(F) + e2_111)
# Minimize \sum{(a*x_i + b*y_i + c - x'_i)^2} (HZ2 p.307)
# Compute H1*x1 and H2*x2
x1h = homg.to_homg(x1)
x2h = homg.to_homg(x2)
A = H0.dot(x1h).T
# We want last (homogeneous) coordinate to be 1 (coefficient of c
# in the equation)
A = (A.T / A[:, 2]).T # for some reason, A / A[:,2] doesn't work
B = H2.dot(x2h)
B = B / B[2, :] # from homogeneous
B = B[0, :] # only interested in x coordinate
X, _, _, _ = la.lstsq(A, B)
# Build Ha (HZ2 eq. 11.20)
Ha = np.array([[X[0], X[1], X[2]], [0, 1, 0], [0, 0, 1]], dtype=float)
H1 = Ha.dot(H0)
if mirror:
mm = np.array([[-1, 0, cx * 2], [0, -1, cy * 2], [0, 0, 1]],
dtype=float)
H1 = mm.dot(H1)
H2 = mm.dot(H2)
return H1, H2
#Source: https://github.com/julienr/cvscripts/tree/master/rectification
