def score_of(self,line,image):
image_grad_x = cv.CreateImage(cv.GetSize(image),cv.IPL_DEPTH_16S,1)
image_grad_y = cv.CreateImage(cv.GetSize(image),cv.IPL_DEPTH_16S,1)
cv.Sobel(image,image_grad_x,0,1)
cv.Sobel(image,image_grad_y,0,1)
scores = [self.score_pt(pt,image_grad_y) for pt in sampled(line,50)]
return norm(scores)
def edge_threshold(image, roi=None, debug=0):
thresholded = cv.CloneImage(image)
horizontal = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 1)
magnitude32f = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_32F, 1)
vertical = cv.CloneImage(horizontal)
v_edge = cv.CloneImage(image)
magnitude = cv.CloneImage(horizontal)
storage = cv.CreateMemStorage(0)
mag = cv.CloneImage(image)
cv.Sobel(image, horizontal, 0, 1, 1)
cv.Sobel(image, vertical, 1, 0, 1)
cv.Pow(horizontal, horizontal, 2)
cv.Pow(vertical, vertical, 2)
cv.Add(vertical, horizontal, magnitude)
cv.Convert(magnitude, magnitude32f)
cv.Pow(magnitude32f, magnitude32f, 0.5)
cv.Convert(magnitude32f, mag)
if roi:
cv.And(mag, roi, mag)
cv.Normalize(mag, mag, 0, 255, cv.CV_MINMAX, None)
cv.Threshold(mag, mag, 122, 255, cv.CV_THRESH_BINARY)
draw_image = cv.CloneImage(image)
and_image = cv.CloneImage(image)
results = []
threshold_start = 17
for window_size in range(threshold_start, threshold_start + 1, 1):
r = 20
for threshold in range(0, r):
cv.AdaptiveThreshold(image, thresholded, 255, \
cv.CV_ADAPTIVE_THRESH_MEAN_C, cv.CV_THRESH_BINARY_INV, window_size, threshold)
contour_image = cv.CloneImage(thresholded)
contours = cv.FindContours(contour_image, storage, cv.CV_RETR_LIST)
cv.Zero(draw_image)
cv.DrawContours(draw_image, contours, (255, 255, 255),
(255, 255, 255), 1, 1)
if roi:
cv.And(draw_image, roi, draw_image)
cv.And(draw_image, mag, and_image)
m1 = np.asarray(cv.GetMat(draw_image))
m2 = np.asarray(cv.GetMat(mag))
total = mag.width * mag.height #cv.Sum(draw_image)[0]
coverage = cv.Sum(and_image)[0] / (mag.width * mag.height)
if debug:
print threshold, coverage
cv.ShowImage("main", draw_image)
cv.ShowImage("main2", thresholded)
cv.WaitKey(0)
results.append((coverage, threshold, window_size))
results.sort(lambda x, y: cmp(y, x))
_, threshold, window_size = results[0]
cv.AdaptiveThreshold(image, thresholded, 255, cv.CV_ADAPTIVE_THRESH_MEAN_C, \
cv.CV_THRESH_BINARY, window_size, threshold)
return thresholded
def gradient(img): cols, rows = cv.GetSize(img) x_drv = cv.CreateMat(rows,cols,cv.CV_32FC1) y_drv = cv.CreateMat(rows,cols,cv.CV_32FC1) mag = cv.CreateMat(rows,cols,cv.CV_32FC1) ang = cv.CreateMat(rows,cols,cv.CV_32FC1) cv.Sobel(img, x_drv, 1, 0) cv.Sobel(img, y_drv, 0, 1) cv.CartToPolar(x_drv,y_drv,mag,ang) return (mag,ang)
def calc_hog(im, numorient=9):
"""
calculate integral HOG (Histogram of Orientation Gradient) image (w,h,numorient)
calc_hog(im, numorient=9)
returns
Integral HOG image
params
im : color image
numorient : number of orientation bins, default is 9 (-4..4)
"""
sz = cv.GetSize(im)
gr = cv.CreateImage(sz, 8, 1)
gx = cv.CreateImage(sz, 32, 1)
gy = cv.CreateImage(sz, 32, 1)
#convert to grayscale
cv.CvtColor(im, gr, cv.CV_BGR2GRAY)
#calc gradient using sobel
cv.Sobel(gr, gx, 1, 0, 3)
cv.Sobel(gr, gy, 0, 1, 3)
#calc initial result
hog = np.zeros((sz[1], sz[0], numorient))
mid = numorient / 2
for y in xrange(0, sz[1] - 1):
for x in xrange(0, sz[0] - 1):
angle = int(round(
mid * np.arctan2(gy[y, x], gx[y, x]) / np.pi)) + mid
magnitude = np.sqrt(gx[y, x] * gx[y, x] + gy[y, x] * gy[y, x])
hog[y, x, angle] += magnitude
#build integral image
for x in xrange(1, sz[0] - 1):
for ang in xrange(numorient):
hog[y, x, ang] += hog[y, x - 1, ang]
for y in xrange(1, sz[1] - 1):
for ang in xrange(numorient):
hog[y, x, ang] += hog[y - 1, x, ang]
for y in xrange(1, sz[1] - 1):
for x in xrange(1, sz[0] - 1):
for ang in xrange(numorient):
#tambah kiri dan atas, kurangi dengan kiri-atas
hog[y, x, ang] += hog[y - 1, x,
ang] + hog[y, x - 1,
ang] - hog[y - 1, x - 1, ang]
return hog
def sobel(im, xorder=1, yorder=0, aperture_size=3, sigma=None):
'''
void cv.Sobel(src, dst, xorder, yorder, apertureSize = 3)
@param im: Input image
@param xorder: The order of the x derivative (see cv.Sobel openCV docs)
@param yorder: The order of the y derivative (see cv.Sobel openCV docs)
@param aperture_size: How large a convolution window to use
@param sigma: Optional smoothing parameter to be applied prior to detecting edges
'''
gray = im.asOpenCVBW()
edges = cv.CreateImage(cv.GetSize(gray), 8, 1)
if sigma != None:
cv.Smooth(gray, gray, cv.CV_GAUSSIAN,
int(sigma) * 4 + 1,
int(sigma) * 4 + 1, sigma, sigma)
#sobel requires a destination image with larger bit depth...
#...so we have to convert it back to 8 bit for the pv Image...
dst32f = cv.CreateImage(cv.GetSize(gray), cv.IPL_DEPTH_32F, 1)
cv.Sobel(gray, dst32f, xorder, yorder, aperture_size)
cv.Convert(dst32f, edges)
edges = pv.Image(edges)
return edges
def processFrames(self):
self.vidcap = cv2.VideoCapture(self.path)
count = 0
success, image = self.vidcap.read()
print success
self.createWindows()
while True:
success, image = self.vidcap.read()
if not success:
return
spare = cv.fromarray(image)
size = (spare.width / 2, spare.height / 2)
cv.Smooth(spare, spare, cv.CV_GAUSSIAN, BLUR_SIZE, BLUR_SIZE)
out = cv.CreateImage(size, 8, 3)
cv.PyrDown(spare, out)
yuv = cv.CreateImage(size, 8, 3)
gray = cv.CreateImage(size, 8, 1)
canny = cv.CreateImage(size, 8, 1)
sobel = cv.CreateImage(size, 8, 1)
harris = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
cv.CvtColor(out, yuv, cv.CV_BGR2YCrCb)
cv.Split(yuv, gray, None, None, None)
cv.Canny(gray, canny, 50, 200, 3)
cv.CornerHarris(gray, harris, 3)
cv.Sobel(gray, sobel, 1, 0, 3)
cv.ConvertScale(canny, canny, -1, 255)
cv.ConvertScale(sobel, sobel, -1, 255)
for y in range(0, out.height):
for x in range(0, out.width):
harr = cv.Get2D(sobel, y, x)
if harr[0] < 10e-06:
cv.Circle(out, (x, y), 2, cv.RGB(155, 0, 25))
#cv2.imwrite("frame%d.jpg" % count, np.asarray(canny[:,:]))
cv.ShowImage('canny', canny)
#cv.ShowImage( 'harris' , harris )
cv.ShowImage('sobel', sobel)
cv.ShowImage('output', out)
if cv2.waitKey(1) == 27:
break
count += 1
return
def edge_magnitude(image):
magnitude32f = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_32F, 1)
horizontal = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 1)
vertical = cv.CloneImage(horizontal)
magnitude = cv.CloneImage(horizontal)
mag = cv.CloneImage(image)
cv.Sobel(image, horizontal, 0, 1, 1)
cv.Sobel(image, vertical, 1, 0, 1)
cv.Pow(horizontal, horizontal, 2)
cv.Pow(vertical, vertical, 2)
cv.Add(vertical, horizontal, magnitude)
cv.Convert(magnitude, magnitude32f)
cv.Pow(magnitude32f, magnitude32f, 0.5)
cv.Convert(magnitude32f, mag)
return mag
def sobel(im, xorder=1, yorder=1):
recommended_size = {
1: 3, 2: 3, 3: 5,
4: 5, 5:7, 6: 7, 7:9, 8:9
}
im = rgb2gray(im)
new_im = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_16S, 1)
cv.Sobel(im, new_im, xorder, yorder,
apertureSize=recommended_size[max(xorder, yorder)])
cv.ConvertScaleAbs(new_im, im)
return im
def image_to_show( self ):
if self.mode == 0:
return self.image
gray_image = cv.CreateImage( (self.image.width, self.image.height), self.image.depth, 1 )
cv.CvtColor(self.image, gray_image, cv.CV_BGR2GRAY)
smooth_image = cv.CreateImage( (gray_image.width, gray_image.height), gray_image.depth, 1 )
cv.Smooth(gray_image, smooth_image, param1=self.smooth_param, param2=self.smooth_param)
if self.mode == 1:
return smooth_image
dx = cv.CreateImage( (smooth_image.width, smooth_image.height), cv.IPL_DEPTH_32F, 1 )
cv.Sobel(smooth_image,dx,1,0)
dy = cv.CreateImage( (smooth_image.width, smooth_image.height), cv.IPL_DEPTH_32F, 1 )
cv.Sobel(smooth_image,dy,0,1)
if self.mode == 2:
return dx
if self.mode == 3:
return dy
else:
sum = cv.CreateImage( (dx.width,dx.height),dx.depth,1 )
cv.Add(dx,dy,sum)
cv.ConvertScale(sum,sum,0.5)
return sum
return self.view_image
def process_image(self, image, texture_type):
spare = image
#return image
# get the size of the current image
size = (image.width, image.height)
cv.Smooth(spare, spare, cv.CV_GAUSSIAN, BLUR_SIZE, BLUR_SIZE)
#out = cv.CreateImage( size, 8, 1)
cannyB = cv.CreateImage(size, 8, 1)
cannyR = cv.CreateImage(size, 8, 1)
sobel = cv.CreateImage(size, 8, 1)
yuv = cv.CreateImage(size, 8, 3)
dest_canny = cv.CreateImage(size, 8, 3)
gray = cv.CreateImage(size, 8, 1)
cv.CvtColor(spare, yuv, cv.CV_BGR2YCrCb)
cv.Split(yuv, gray, None, None, None)
cv.Canny(gray, cannyB, 5, 50, 3)
cv.Canny(gray, cannyR, 5, 150, 3)
cv.Sobel(gray, sobel, 1, 0, 3)
#cv.ConvertScale(sobel, sobel, -1, 255 )
#cv.ConvertScale(cannyR, cannyR, -1, 155 )
#cv.ConvertScale(gray, gray, -1, 255 )
#cv.ConvertScale(cannyB, cannyB, -1, 255 )
cv.Smooth(cannyR, cannyR, cv.CV_GAUSSIAN, 3, 3)
cv.Smooth(cannyB, cannyB, cv.CV_GAUSSIAN, 3, 3)
#cv.CvtColor( canny, canny, cv.CV_YCrCb2BGR )
#cv.Merge(sobel, gray, sobel, None, dest)
cv.Merge(cannyR, cannyB, gray, None, dest_canny)
#cv.Merge(sobel, sobel, sobel, None, dest_sobel)
#cv.Smooth( dest, dest, cv.CV_GAUSSIAN, BLUR_SIZE, BLUR_SIZE )
#cv.ShowImage( 'canny', dest)
#cv.Merge
#cv.Smooth( dest_canny, dest_canny, cv.CV_GAUSSIAN, BLUR_SIZE, BLUR_SIZE )
#success = True
self.prevImage = image
options = {'normal': dest_canny, 'post': dest_canny}
#return yuv
return options[texture_type]
def __produce_gradient_image(self, i, scale):
size = cv.GetSize(i)
grey_image = cv.CreateImage(size, 8, 1)
size = [s / scale for s in size]
grey_image_small = cv.CreateImage(size, 8, 1)
cv.CvtColor(i, grey_image, cv.CV_RGB2GRAY)
df_dx = cv.CreateImage(cv.GetSize(i), cv.IPL_DEPTH_16S, 1)
cv.Sobel(grey_image, df_dx, 1, 1)
cv.Convert(df_dx, grey_image)
cv.Resize(grey_image,
grey_image_small) #, interpolation=cv.CV_INTER_NN)
cv.Resize(grey_image_small,
grey_image) #, interpolation=cv.CV_INTER_NN)
return grey_image
def edge_classify(self,cv_image,l_line,r_line):
image_hsv = cv.CloneImage(cv_image)
cv.CvtColor(cv_image,image_hsv,cv.CV_RGB2HSV)
image_hue = cv.CreateImage(cv.GetSize(image_hsv),cv.IPL_DEPTH_8U,1)
cv.Split(image_hsv,image_hue,None,None,None)
image_grad = cv.CreateImage(cv.GetSize(image_hsv),cv.IPL_DEPTH_16S,1)
cv.Sobel(image_hue,image_grad,0,1)
scores = []
for line in (l_line,r_line):
score = self.score_of(line,image_hue)
print "Score: "
print score
scores.append(score)
if scores[0] > scores[1]:
return RIGHT
else:
return LEFT
def find_wrinkles(self):
rect = self.rect
sob_mat = cv.CreateImage((rect[2], rect[3]), cv.IPL_DEPTH_8U,
self.frame_copy.nChannels)
if self.frame_copy.origin == cv.IPL_ORIGIN_TL:
cv.Copy(self.frame_copy, sob_mat)
else:
cv.Flip(self.frame_copy, sob_mat, 0)
#sob_mat = cv.CloneMat(self.frame_copy)
cv.Sobel(sob_mat, sob_mat, 1, 1)
y_max, y_badania1, y_badania2, x_max, i = rect[
3], rect[3] / 5, rect[3] / 4, rect[2], 0
twarz = sob_mat
for x in range(x_max):
if twarz[x, y_badania1][0] + twarz[x, y_badania1][1] + twarz[
x, y_badania1][2] > self.white_level:
i += 1
if twarz[x, y_badania2][0] + twarz[x, y_badania2][1] + twarz[
x, y_badania2][2] > self.white_level:
i += 1
self.wrinkles = i / 2
return self.wrinkles
def find_wrinkles(self):
#full face image wrinkles
rect = self.rect
sob_mat = cv.CreateImage((rect[2], rect[3]), cv.IPL_DEPTH_8U,
self.frame_copy.nChannels)
if self.frame_copy.origin == cv.IPL_ORIGIN_TL:
cv.Copy(self.frame_copy, sob_mat)
else:
cv.Flip(self.frame_copy, sob_mat, 0)
cv.Sobel(sob_mat, sob_mat, 1, 1)
y_max, y_badania1, y_badania2, x_max, i = rect[
3], rect[3] / 5, rect[3] / 4, rect[2], 0
twarz = sob_mat
for x in range(x_max):
if twarz[x, y_badania1][0] + twarz[x, y_badania1][1] + twarz[
x, y_badania1][2] > self.white_level:
i += 1
if twarz[x, y_badania2][0] + twarz[x, y_badania2][1] + twarz[
x, y_badania2][2] > self.white_level:
i += 1
wrinkles_full = i / 2
#teraz badam tylko cere
#crop ratio - left:0.25 , right:0.25 , up:0.12 , down:0.12
rect_skin = (int(rect[2] * 0.25), int(rect[3] * 0.12),
int(rect[2] * 0.5), int(rect[3] * 0.76))
twarz = cv.GetSubRect(sob_mat, rect_skin)
y_max, y_badania1, y_badania2, x_max, i = rect_skin[
3], rect_skin[3] / 5, rect_skin[3] / 4, rect_skin[2], 0
for x in range(x_max):
if twarz[x, y_badania1][0] + twarz[x, y_badania1][1] + twarz[
x, y_badania1][2] > self.white_level:
i += 1
if twarz[x, y_badania2][0] + twarz[x, y_badania2][1] + twarz[
x, y_badania2][2] > self.white_level:
i += 1
wrinkles_small = i / 2
#zwracam stosunek zmarszczek na cerze do zmarszczek na calym zdjeciu twarzy
return wrinkles_small / float(wrinkles_full)
from numpy import *
from pylab import *
import cv
image = cv.LoadImage('miches.jpg',cv.CV_LOAD_IMAGE_GRAYSCALE)
# create the window
cv.NamedWindow('Miches', cv.CV_WINDOW_AUTOSIZE)
cv.ShowImage('Miches', image) # show the image
cv.WaitKey() # close window
# Sobel operator
sobel = cv.CreateMat(image.height, image.width, cv.CV_32FC1)
cv.Sobel(image,sobel,1,1,3)
cv.ShowImage('Miches Sobel', sobel)
cv.SaveImage('miches_sobel.jpg', sobel)
cv.WaitKey()
___________________________________________________________________
blur_smooth.py
from PIL import Image
from numpy import *
from pylab import *
import cv
# this will load and show an image in gray scale
def detect(image, debug=False, display=None):
work_image = cv.CreateImage((image.width, image.height), 8, 1)
cv.CvtColor(image, work_image, cv.CV_BGR2GRAY)
image = work_image
edge = cv.CloneImage(image)
thresholded = cv.CloneImage(image)
v_edges = cv.CloneImage(image)
h_edges = cv.CloneImage(image)
vertical = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 1)
cv.Sobel(image, vertical, 1, 0, 1)
cv.Abs(vertical, vertical)
cv.Convert(vertical, v_edges)
storage = cv.CreateMemStorage(0)
result = np.asarray(cv.GetMat(v_edges), dtype=np.float)
threshold = 6
rects = []
while len(rects) < 1 and threshold > 0:
rects = []
cv.Convert(vertical, v_edges)
cv.AdaptiveThreshold(v_edges, v_edges, 255,
cv.CV_ADAPTIVE_THRESH_MEAN_C,
cv.CV_THRESH_BINARY_INV, 17, threshold)
threshold -= 1
storage = cv.CreateMemStorage(0)
contour_image = cv.CloneImage(v_edges)
contours = cv.FindContours(contour_image, storage, cv.CV_RETR_LIST,
cv.CV_CHAIN_APPROX_NONE, (0, 0))
ext.filter_contours(contours, 30, ext.LESSTHAN)
max_size = int(image.width * image.height * 0.1)
# ext.filter_contours(contours, 200**2, ext.GREATERTHAN)
ext.filter_contours(contours, max_size, ext.GREATERTHAN)
if display:
cv.Merge(v_edges, v_edges, v_edges, None, display)
seeds = []
if contours:
seq = contours
rects = []
while seq:
c = ext.as_contour(ext.wrapped(seq))
r = (c.rect.x, c.rect.y, c.rect.width, c.rect.height)
rects.append(r)
if display:
cv.Rectangle(
display, (c.rect.x, c.rect.y),
(c.rect.x + c.rect.width, c.rect.y + c.rect.height),
(0, 0, 255), 1)
seq = seq.h_next()
rects.sort(lambda x, y: cmp(x[0] + x[2] / 2, y[0] + y[2] / 2))
seeds = rects[:]
seeds.sort(lambda x, y: cmp(y[2] * y[3], x[2] * x[3]))
groups = []
skip = False
for seed in seeds:
if seed not in rects:
break
found = False
for group in groups:
if seed in group:
found = True
if found:
continue
r = seed
start = seed
start_index = rects.index(seed)
groups.append([seed])
i = start_index - 1
# delta = max(150, seed[2]/2)
delta = seed[2] * 0.66
if debug:
print "left", seed, delta
col = (randint(0, 255), randint(0, 255), randint(0, 255))
cv.Rectangle(display, (r[0], r[1]), (r[0] + r[2], r[1] + r[3]),
(255, 255, 255), 3)
cv.Rectangle(display, (r[0], r[1]), (r[0] + r[2], r[1] + r[3]),
col, -1)
cv.ShowImage("main", display)
if not skip:
c = cv.WaitKey(0)
if c == ord("a"):
skip = True
# scan left
while 1:
if i < 0:
break
rect = rects[i]
if rect[0] + rect[2] < seed[0] - delta:
if debug:
print "esc1", rect
break
if in_vertical(seed, start, rect):
seed = rect
groups[-1].append(rect)
r = rect
if debug:
print rect
cv.Rectangle(display, (r[0], r[1]),
(r[0] + r[2], r[1] + r[3]), col, -1)
cv.ShowImage("main", display)
if not skip:
c = cv.WaitKey(0)
if c == ord("a"):
skip = True
else:
if debug:
print "rej1", rect
i -= 1
# scan right
seed = start
start_index = rects.index(seed)
i = start_index + 1
if debug:
print
print "right", seed
while 1:
if i >= len(rects):
break
rect = rects[i]
if rect[0] > seed[0] + seed[2] + delta:
if debug:
print "esc2", rect, rect[0] + rect[2] / 2, seed[
0] + seed[2] / 2 + delta
break
if in_vertical(seed, start, rect):
seed = rect
groups[-1].append(rect)
r = rect
if debug:
print rect
cv.Rectangle(display, (r[0], r[1]),
(r[0] + r[2], r[1] + r[3]), col, -1)
cv.ShowImage("main", display)
if not skip:
c = cv.WaitKey(0)
if c == ord("a"):
skip = True
else:
if debug:
print "rej2", rect
i += 1
if debug:
print
# find min and max extent of group
group_rects = []
for group in groups:
min_x, min_y = 1E6, 1E6
max_x, max_y = -1, -1
dev = []
col = (randint(0, 255), randint(0, 255), randint(0, 255))
for rect in group:
r = rect
if display:
if r == group[0]:
cv.Rectangle(display, (r[0], r[1]),
(r[0] + r[2], r[1] + r[3]), (255, 255, 255),
3)
cv.Rectangle(display, (r[0], r[1]), (r[0] + r[2], r[1] + r[3]),
col, -1)
min_x = min(min_x, r[0])
min_y = min(min_y, r[1])
max_x = max(max_x, r[0] + r[2])
max_y = max(max_y, r[1] + r[3])
if display:
cv.Rectangle(display, (min_x, min_y), (max_x, max_y), (0, 255, 0),
1)
width = max_x - min_x
height = max_y - min_y
rect = (min_x, min_y, width, height)
group_rects.append(rect)
return group_rects
def segment_rect(image,
rect,
debug=False,
display=None,
target_size=None,
group_range=(3, 25)):
global next
skip = False
best_chars = []
best_threshold = None
thresholded = cv.CloneImage(image)
contour_image = cv.CloneImage(image)
edges = cv.CloneImage(image)
min_x, min_y, width, height = rect
# cv.SetImageROI(thresholded, rect)
cv.SetImageROI(contour_image, rect)
cv.SetImageROI(image, rect)
cv.SetImageROI(edges, rect)
horizontal = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_16S, 1)
magnitude32f = cv.CreateImage(cv.GetSize(image), cv.IPL_DEPTH_32F, 1)
vertical = cv.CloneImage(horizontal)
magnitude = cv.CloneImage(horizontal)
cv.Sobel(image, horizontal, 0, 1, 3)
cv.Sobel(image, vertical, 1, 0, 3)
cv.Pow(horizontal, horizontal, 2)
cv.Pow(vertical, vertical, 2)
cv.Add(vertical, horizontal, magnitude)
cv.Convert(magnitude, magnitude32f)
cv.Pow(magnitude32f, magnitude32f, 0.5)
cv.Convert(magnitude32f, edges)
original_rect = rect
if display:
cv.SetImageROI(display, rect)
for threshold in range(1, 20, 1):
cv.SetImageROI(thresholded, original_rect)
#for i in range(30, 60, 1):
if display:
cv.Merge(image, image, image, None, display)
cv.Copy(image, thresholded)
#cv.Threshold(thresholded, thresholded, i, 255, cv.CV_THRESH_BINARY_INV)
cv.AdaptiveThreshold(thresholded, thresholded, 255,
cv.CV_ADAPTIVE_THRESH_MEAN_C,
cv.CV_THRESH_BINARY_INV, 17, threshold)
#cv.AdaptiveThreshold(thresholded, thresholded, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY_INV, 5, i)
# skip rects greater than 50% thresholded
summed = cv.Norm(thresholded, None, cv.CV_L1,
None) / 255 / thresholded.width / thresholded.height
if summed > 0.5:
continue
if debug:
cv.ShowImage("edge", thresholded)
storage = cv.CreateMemStorage(0)
cv.Copy(thresholded, contour_image)
contours = cv.FindContours(contour_image, storage, cv.CV_RETR_LIST,
cv.CV_CHAIN_APPROX_SIMPLE, (0, 0))
ext.filter_contours(contours, 20, ext.LESSTHAN)
groups = []
rects = []
edge_counts = []
overlappings = {}
if contours:
seq = contours
while seq:
c = ext.as_contour(ext.wrapped(seq))
r = (c.rect.x, c.rect.y, c.rect.width, c.rect.height)
rects.append(r)
seq = seq.h_next()
similarity = 0.45 #0.3
rects.sort(lambda x, y: cmp(y[2] * y[3], x[2] * x[3]))
for rect in rects:
if debug:
print
print "R", rect, len(groups)
cv.SetImageROI(edges,
(original_rect[0] + rect[0],
original_rect[1] + rect[1], rect[2], rect[3]))
edge_count = cv.Sum(edges)[0] / 255 / (rect[2] * rect[3])
edge_counts.append(edge_count)
# cv.ShowImage("edges", edges)
# cv.WaitKey(0)
if debug and target_size:
print "X", target_size, rect
print(target_size[0] - rect[2]) / target_size[0]
print(target_size[1] - rect[3]) / target_size[1]
if rect[2] > rect[3] or float(rect[3])/rect[2] < 3./3 or edge_count < 0.1\
or (rect[2] == image.width and rect[3] == image.height) \
or (target_size and not 0 < (target_size[0] - rect[2]) / target_size[0] < 0.3 \
and not 0 < (target_size[1] - rect[3]) / target_size[1] < 0.05):
if debug:
print "rej", rect[2], ">", rect[3], "edge=", edge_count
cv.Rectangle(display, (rect[0], rect[1]),
(rect[0] + rect[2], rect[1] + rect[3]),
(0, 0, 255), 1)
cv.ShowImage("main", display)
if not skip and not next:
c = cv.WaitKey(0)
if c == ord("a"):
skip = True
if c == ord("z"):
next = True
continue
added = False
for group_id, group in enumerate(groups):
avg_width, avg_height, avg_y = 0, 0, 0
overlap = None
c = 0
for r in group:
avg_y += r[1] + r[3] / 2.0
avg_width += r[2]
avg_height += r[3]
irect = intersect(r, rect)
if irect[2] * irect[3] > 0.2 * r[2] * r[3]:
overlappings.setdefault(group_id,
[]).append([r, rect])
avg_y /= float(len(group))
avg_width /= float(len(group))
avg_height /= float(len(group))
if debug:
print group
if (abs(avg_width - rect[2]) / avg_width < similarity or \
(rect[2] < avg_width)) and \
abs(avg_height - rect[3])/ avg_height < similarity and \
abs(avg_y - (rect[1] + rect[3]/2.0)) / avg_y < similarity:
group.append(rect)
added = True
else:
pass
if not added:
# first char in group
groups.append([rect])
if debug:
print "now:"
for g in groups:
print g
cv.Rectangle(display, (rect[0], rect[1]),
(rect[0] + rect[2], rect[1] + rect[3]),
(255, 0, 0), 1)
cv.ShowImage("main", display)
if not skip and not next:
c = cv.WaitKey(0)
if c == ord("a"):
skip = True
if c == ord("z"):
next = True
if groups:
#handle overlapping regions, default to average width match
for group_id, over in overlappings.items():
group = groups[group_id]
avg_width = 0
avg_height = 0
for r in group:
avg_width += r[2]
avg_height += r[3]
avg_width /= float(len(group))
avg_height /= float(len(group))
for r1, r2 in over:
if r2 not in group or r1 not in group:
continue
if debug:
print "over", r1, r2, r1[2] * r1[3], r2[2] * r2[
3], avg_width
d1 = abs(r1[2] - avg_width) + abs(r1[3] - avg_height)
d2 = abs(r2[2] - avg_width) + abs(r2[3] - avg_height)
if d1 < d2:
group.remove(r2)
else:
group.remove(r1)
#group = max(groups, key=len)
# from longest groups, find largest area
groups.sort(key=len)
groups.reverse()
max_area = 0
mad_index = -1
for i, g in enumerate(groups[:5]):
area = 0
for r in g:
area += r[2] * r[3]
if area > max_area:
max_area = area
max_index = i
group = groups[max_index]
# vertical splitting
avg_width, avg_height, avg_y = 0, 0, 0
if debug:
print "G", group
for r in group:
avg_y += r[1] + r[3] / 2.0
avg_width += r[2]
avg_height += r[3]
avg_y /= float(len(group))
avg_width /= float(len(group))
avg_height /= float(len(group))
band_rects = []
bound = bounding_rect(group)
for i, rect in enumerate(rects):
if edge_counts[i] < 0.1:
continue
if (abs(avg_width - rect[2]) / avg_width < similarity or \
(rect[2] < avg_width)) and \
(abs(avg_height - rect[3]) / avg_height < similarity or \
(rect[3] < avg_height)) and \
abs(avg_y - (rect[1] + rect[3]/2.0)) < avg_height/2:
band_rects.append(rect)
band_rects.sort(lambda x, y: cmp(y[2] * y[3], x[2] * x[3]))
for i, rect_a in enumerate(band_rects[:-1]):
if rect_a[2] * rect_a[3] < 0.2 * avg_width * avg_height:
continue
merge_rects = []
for rect_b in band_rects[i + 1:]:
w = avg_width
m1 = rect_a[0] + rect_a[2] / 2
m2 = rect_b[0] + rect_b[2] / 2
if abs(m1 - m2) < w:
merge_rects.append(rect_b)
if debug:
print "M", merge_rects
if merge_rects:
merge_rects.append(rect_a)
rect = bounding_rect(merge_rects)
area = 0
for r in merge_rects:
area += r[2] * r[3]
if (abs(avg_width - rect[2]) / avg_width < similarity or \
(rect[2] < avg_width)) and \
abs(avg_height - rect[3])/ avg_height < similarity and \
area > 0.5*(avg_width*avg_height) and \
abs(avg_y - (rect[1] + rect[3]/2.0)) / avg_y < similarity:
for r in merge_rects:
if r in group:
group.remove(r)
# merge into group
new_group = []
merged = False
for gr in group:
area2 = max(gr[2] * gr[3], rect[2] * rect[3])
isect = intersect(gr, rect)
if isect[2] * isect[3] > 0.4 * area2:
x = min(gr[0], rect[0])
y = min(gr[1], rect[1])
x2 = max(gr[0] + gr[2], rect[0] + rect[2])
y2 = max(gr[1] + gr[3], rect[1] + rect[3])
new_rect = (x, y, x2 - x, y2 - y)
new_group.append(new_rect)
merged = True
else:
new_group.append(gr)
if not merged:
new_group.append(rect)
group = new_group
cv.Rectangle(display, (rect[0], rect[1]),
(rect[0] + rect[2], rect[1] + rect[3]),
(255, 0, 255), 2)
# avoid splitting
split = False
# select higher threshold if innovates significantly
best_width = 0.0
if best_chars:
best_area = 0.0
for rect in best_chars:
best_area += rect[2] * rect[3]
best_width += rect[2]
best_width /= len(best_chars)
area = 0.0
overlapped = 0.0
avg_width = 0.0
avg_height = 0.0
for rect in group:
area += rect[2] * rect[3]
avg_width += rect[2]
avg_height += rect[3]
for char in best_chars:
section = intersect(rect, char)
if section[2] * section[3] > 0:
overlapped += section[2] * section[3]
avg_width /= len(group)
avg_height /= len(group)
quotient = overlapped / area
quotient2 = (area - overlapped) / best_area
if debug:
print area, overlapped, best_area
print group
print "QUO", quotient
print "QUO2", quotient2
else:
quotient = 0
quotient2 = 1
best_area = 0
group.sort(lambda x, y: cmp(x[0] + x[2] / 2, y[0] + y[2] / 2))
best_chars.sort(lambda x, y: cmp(x[0] + x[2] / 2, y[0] + y[2] / 2))
if group_range[0] <= len(group) <= group_range[1] and avg_width > 5 and avg_height > 10 and \
((quotient2 > 0.05 and (best_area == 0 or abs(area - best_area)/best_area < 0.4))
or (quotient2 > 0.3 and area > best_area)):
if debug:
print "ASSIGNED", group
best_chars = group
best_threshold = threshold #get_patch(thresholded, original_rect)
else:
if debug:
print "not", quotient2, len(
group), avg_width, avg_height, area, best_area
# best_chars = groups
if debug:
for rect in best_chars:
cv.Rectangle(display, (rect[0], rect[1]),
(rect[0] + rect[2], rect[1] + rect[3]),
(0, 255, 0), 1)
cv.ShowImage("main", display)
if not skip and not next:
c = cv.WaitKey(0)
if c == ord("a"):
skip = True
if c == ord("z"):
next = True
best_chars.sort(lambda x, y: cmp(x[0], y[0]))
cv.ResetImageROI(thresholded)
cv.ResetImageROI(contour_image)
cv.ResetImageROI(image)
cv.ResetImageROI(edges)
if display:
cv.ResetImageROI(display)
return best_chars, best_threshold
fo.write('\t')
#fo.write(str(loopVar1+1))
if loopVar1 != len(features) - 1:
fo.write('\n')
fo.close()
#---------------------------------------------------------------------------------------------#
# Load image 1 and get the corner points
feature_vectors = []
for loopVar1 in range(0, 26):
orig_img_1 = cv.LoadImage(filename1 + str(loopVar1 + 1) + ".jpg", 1)
input_img_1 = cv.LoadImage(filename1 + str(loopVar1 + 1) + ".jpg", 0)
dy_img_1 = cv.CreateMat(orig_img_1.height, orig_img_1.width, cv.CV_32F)
dx_img_1 = cv.CreateMat(orig_img_1.height, orig_img_1.width, cv.CV_32F)
cv.Sobel(input_img_1, dy_img_1, 0, 1, apertureSize=3)
cv.Sobel(input_img_1, dx_img_1, 1, 0, apertureSize=3)
corner_img_1 = find_corner_strength(dx_img_1, dy_img_1, k,
wh) # Find the corner strengths
th_r = 9e+8
corner_strengths = non_max_supress(
orig_img_1, corner_img_1, wr,
th_r) # Apply threshold and non-maximum supression
#print len(corner_strengths), len(corner_strengths)-N
#print corner_strengths
corner_strengths = sorted(corner_strengths, key=itemgetter(0))
best_corners = []
for loopVar2 in range(
len(corner_strengths) - 1,
len(corner_strengths) - 1 - N, -1):
def find(self, img):
started = time.time()
gray = self.Cached('gray', img.height, img.width, cv.CV_8UC1)
cv.CvtColor(img, gray, cv.CV_BGR2GRAY)
sobel = self.Cached('sobel', img.height, img.width, cv.CV_16SC1)
sobely = self.Cached('sobely', img.height, img.width, cv.CV_16SC1)
cv.Sobel(gray, sobel, 1, 0)
cv.Sobel(gray, sobely, 0, 1)
cv.Add(sobel, sobely, sobel)
sobel8 = self.Cached('sobel8', sobel.height, sobel.width, cv.CV_8UC1)
absnorm8(sobel, sobel8)
cv.Threshold(sobel8, sobel8, 128.0, 255.0, cv.CV_THRESH_BINARY)
sobel_integral = self.Cached('sobel_integral', img.height + 1,
img.width + 1, cv.CV_32SC1)
cv.Integral(sobel8, sobel_integral)
d = 16
_x1y1 = cv.GetSubRect(
sobel_integral,
(0, 0, sobel_integral.cols - d, sobel_integral.rows - d))
_x1y2 = cv.GetSubRect(
sobel_integral,
(0, d, sobel_integral.cols - d, sobel_integral.rows - d))
_x2y1 = cv.GetSubRect(
sobel_integral,
(d, 0, sobel_integral.cols - d, sobel_integral.rows - d))
_x2y2 = cv.GetSubRect(
sobel_integral,
(d, d, sobel_integral.cols - d, sobel_integral.rows - d))
summation = cv.CloneMat(_x2y2)
cv.Sub(summation, _x1y2, summation)
cv.Sub(summation, _x2y1, summation)
cv.Add(summation, _x1y1, summation)
sum8 = self.Cached('sum8', summation.height, summation.width,
cv.CV_8UC1)
absnorm8(summation, sum8)
cv.Threshold(sum8, sum8, 32.0, 255.0, cv.CV_THRESH_BINARY)
cv.ShowImage("sum8", sum8)
seq = cv.FindContours(sum8, cv.CreateMemStorage(), cv.CV_RETR_EXTERNAL)
subimg = cv.GetSubRect(img, (d / 2, d / 2, sum8.cols, sum8.rows))
t_cull = time.time() - started
seqs = []
while seq:
seqs.append(seq)
seq = seq.h_next()
started = time.time()
found = {}
print 'seqs', len(seqs)
for seq in seqs:
area = cv.ContourArea(seq)
if area > 1000:
rect = cv.BoundingRect(seq)
edge = int((14 / 14.) * math.sqrt(area) / 2 + 0.5)
candidate = cv.GetSubRect(subimg, rect)
sym = self.dm.decode(
candidate.width,
candidate.height,
buffer(candidate.tostring()),
max_count=1,
#min_edge = 6,
#max_edge = int(edge) # Units of 2 pixels
)
if sym:
onscreen = [(d / 2 + rect[0] + x, d / 2 + rect[1] + y)
for (x, y) in self.dm.stats(1)[1]]
found[sym] = onscreen
else:
print "FAILED"
t_brute = time.time() - started
print "cull took", t_cull, "brute", t_brute
return found
#! /usr/bin/env python
from SimpleCV import Camera, Display, Image
import time
import matplotlib.pyplot as plt
import cv
import numpy as np
im = cv.LoadImage('/home/pi/Documents/Lab3/foto4.png',
cv.CV_LOAD_IMAGE_GRAYSCALE)
sobx = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_16S, 1)
cv.Sobel(im, sobx, 1, 0, 3) #Sobel with x-order=1
soby = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_16S, 1)
cv.Sobel(im, soby, 0, 1, 3) #Sobel withy-oder=1
cv.Abs(sobx, sobx)
cv.Abs(soby, soby)
result = cv.CloneImage(im)
cv.Add(sobx, soby, result) #Add the two results together.
cv.Threshold(result, result, 100, 255, cv.CV_THRESH_BINARY_INV)
cv.ShowImage('Image', im)
cv.ShowImage('Result', result)
cv.WaitKey(0)
#!/usr/bin/env python
import cv
from cv2 import *
import math
# Set the camera
cam = VideoCapture(0)
# Read an image and save it
s, image = cam.read()
if s:
# *** USER: change name of the file
imwrite('cam_image.jpg', image)
# Open the image
image = cv.LoadImage('cam_image.jpg', cv.CV_LOAD_IMAGE_GRAYSCALE)
# Code from glowing python (glowingpython.blogspot.co.uk/2011/10/beginning-with-opencv-in-python.html)
# Create a matrix of the same size than the original but with one channel.
dstSobel = cv.CreateMat(image.height, image.width, cv.CV_32FC1)
# Apply sobel algorithm
cv.Sobel(image, dstSobel, 1, 1, 3)
# End of code from glowing python
# Save the image
cv.SaveImage('sobel.jpg', dstSobel)
#### Code for BARCODE detection ######
import cv, sys
imgco = cv.LoadImage('/home/agnihotri/barcode/JPEG/counterservice_03.jpg')
img = cv.CreateImage(cv.GetSize(imgco), 8, 1)
imgx = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_16S, 1)
imgy = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_16S, 1)
thresh = cv.CreateImage(cv.GetSize(img), 8, 1)
### Convert image to grayscale ###
cv.CvtColor(imgco, img, cv.CV_BGR2GRAY)
### Finding horizontal and vertical gradient ###
cv.Sobel(img, imgx, 1, 0, 3)
cv.Abs(imgx, imgx)
cv.Sobel(img, imgy, 0, 1, 3)
cv.Abs(imgy, imgy)
cv.Sub(imgx, imgy, imgx)
cv.ConvertScale(imgx, img)
### Low pass filtering ###
cv.Smooth(img, img, cv.CV_GAUSSIAN, 7, 7, 0)
### Applying Threshold ###
cv.Threshold(img, thresh, 100, 255, cv.CV_THRESH_BINARY)
cv.Erode(thresh, thresh, None, 2)
cv.Dilate(thresh, thresh, None, 5)
def colorEdgeDetector():
# Declare as globals since we are assigning to them now
global capture
global capture_index
# Declare tesseract variables
api = tesseract.TessBaseAPI()
api.Init(".", "eng", tesseract.OEM_DEFAULT)
api.SetPageSegMode(tesseract.PSM_SINGLE_LINE)
# Variable to control size of peeking window
xDiff = 120.0
yDiff = 40.0
rectArea = int(xDiff * 2) * int(yDiff * 2)
# Capture current frame
frame = cv.QueryFrame(capture)
# Declare other variables used to manipulate the frame
threshold_frame = cv.CreateImage(cv.GetSize(frame), 8, 1)
hsv_frame = cv.CreateImage(cv.GetSize(frame), 8, 3)
while True:
# Copy the original frame to display later
original_frame = cv.CloneImage(frame)
# Use Sobel filter to detect edges
cv.Smooth(frame, frame, cv.CV_BLUR, 3, 3)
cv.Sobel(frame, frame, 2, 0, 5)
cv.Smooth(frame, frame, cv.CV_BLUR, 3, 3)
# Convert frame to HSV
cv.CvtColor(frame, hsv_frame, cv.CV_BGR2HSV)
# Remove all pixels that aren't a teal color: RGB(0, 180, 170) HSV(170, 75, 100)
cv.InRangeS(hsv_frame, (70, 150, 150), (100, 255, 255),
threshold_frame)
# Get moments to see if what was found is a license plate or not
moments = cv.Moments(cv.GetMat(threshold_frame, 1), 0)
area = cv.GetCentralMoment(moments, 0, 0)
if (area > 60000):
# Determine the x and y coordinates of the center of the object
x = cv.GetSpatialMoment(moments, 1, 0) / area
y = cv.GetSpatialMoment(moments, 0, 1) / area
# Retrieve candidate license plate and test it's characters
if int(x - xDiff) > 0 and int(y - yDiff) > 0 and (
int(x - xDiff) + int(xDiff * 2)) < 640 and (
int(y - yDiff) + int(yDiff * 2)) < 480:
candidate = cv.GetSubRect(original_frame,
(int(x - xDiff), int(y - yDiff),
int(xDiff * 2), int(yDiff * 2)))
candidateImg = cv.CreateImage(cv.GetSize(candidate), 8, 3)
cv.Convert(candidate, candidateImg)
candidateGrey = cv.CreateImage(cv.GetSize(candidate), 8, 1)
cv.CvtColor(candidateImg, candidateGrey, cv.CV_RGB2GRAY)
tesseract.SetCvImage(candidateImg, api)
text = api.GetUTF8Text()
print "License Plate Characters:", text
"""
# Regex and this don't seem to work
if text.isalnum():
print "License Plate Characters:",text
"""
# Draw circle on center of object
cv.Circle(original_frame, (int(x), int(y)), 2, (255, 255, 255), 10)
# Rectangle
cv.Rectangle(original_frame, (int(x - xDiff), int(y - yDiff)),
(int(x + xDiff), int(y + yDiff)),
cv.CV_RGB(0, 0, 255), 1)
# Display image
cv.ShowImage("CS201 - Tyler Boraski - Final Project", original_frame)
# Capture new frame
frame = cv.QueryFrame(capture)
# If wrong camera index is initialized, press "n" to cycle through camera indexes.
c = cv.WaitKey(10)
if c == "n":
camera_index += 1 # Try the next camera index
capture = cv.CaptureFromCAM(camera_index)
if not capture: # If the next camera index didn't work, reset to 0.
camera_index = 0
capture = cv.CaptureFromCAM(camera_index)
# If "esc" is pressed the program will end
esc = cv.WaitKey(7) % 0x100
if esc == 27:
quit()
def get_xposition(image):
"""
Param: image
Returns: x position of the center of barcode
"""
imgco = cv.LoadImage(image)
img = cv.CreateImage(cv.GetSize(imgco), 8, 1)
imgx = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_16S, 1)
imgy = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_16S, 1)
thresh = cv.CreateImage(cv.GetSize(img), 8, 1)
### Convert image to grayscale ###
cv.CvtColor(imgco, img, cv.CV_BGR2GRAY)
### Finding horizontal and vertical gradient ###
cv.Sobel(img, imgx, 1, 0, 3)
cv.Abs(imgx, imgx)
cv.Sobel(img, imgy, 0, 1, 3)
cv.Abs(imgy, imgy)
cv.Sub(imgx, imgy, imgx)
cv.ConvertScale(imgx, img)
### Low pass filtering ###
cv.Smooth(img, img, cv.CV_GAUSSIAN, 7, 7, 0)
### Applying Threshold ###
cv.Threshold(img, thresh, 100, 255, cv.CV_THRESH_BINARY)
cv.Erode(thresh, thresh, None, 2)
cv.Dilate(thresh, thresh, None, 5)
### Contour finding with max. area ###
storage = cv.CreateMemStorage(0)
barcode_found = False
contour = cv.FindContours(thresh, storage, cv.CV_RETR_CCOMP,
cv.CV_CHAIN_APPROX_SIMPLE)
area = 0
while contour:
max_area = cv.ContourArea(contour)
if max_area > area:
area = max_area
bar = list(contour)
barcode_found = True
contour = contour.h_next()
### Draw bounding rectangles ###
if barcode_found:
bound_rect = cv.BoundingRect(bar)
pt1 = (bound_rect[0], bound_rect[1])
pt2 = (bound_rect[0] + bound_rect[2], bound_rect[1] + bound_rect[3])
cv.Rectangle(imgco, pt1, pt2, cv.CV_RGB(0, 255, 255), 2)
pt = ((pt2[0] - pt1[0]), (pt2[1] - pt1[1]))
middle = ((pt[0] / 2 + pt1[0]), (pt[1] / 2 + pt1[1]))
print middle[0]
if DESKTOPMODE is True:
cv.ShowImage('img', imgco)
cv.WaitKey(0)
return middle[0]
elif barcode_found is False:
print "No barcode was found."
return 512
