def measure(im, blur, noise=None, debug=False):
focus_points = blur[0]
#is_noisy = noise[2]
size = cv.GetSize(im)
npixels = size[0] * size[1]
#if focused_regions is None:
# focused_regions = image.new_from(im)
# cv.Set(focused_regions, 0)
# groups = form_groups(focus_points,
# estimated_size=min(max(int(len(npixels) / 1000), 2), 15))
# #groups = form_groups(points, threshold=max(cv.GetSize(im))/16)
# #print 'groups', len(groups)
# draw_groups(groups, focused_regions)
im2 = cv.CloneImage(im)
g = Grid(cv.GetSize(im2))
if debug:
image.show(g.draw(im2), "Image with Grid + ROI")
roi = image.new_from(im, nChannels=1)
cv.Set(roi, 0)
#g.draw_lines(roi, thickness=int(max(min((size[0] + size[1]) * 1/100.0, 255), 1)))
g.draw_regions(roi)
area = cv.Sum(roi)[0]
(_, face_rects), face_score = faces.measure(im)
face_block = image.new_from(im, nChannels=1)
cv.Set(face_block, 0)
for r in face_rects:
r.draw(face_block, color=cv.RGB(255,255,255), thickness=cv.CV_FILLED)
if debug:
face_roi = cv.CloneImage(im)
cv.Set(face_roi, 0, image.invert(roi))
cv.Set(face_roi, 0, image.invert(image.threshold(face_block, threshold=1)))
image.show(face_block, "Faces in Binary")
image.show(g.draw(face_roi), "Face + ROI")
return (im, (
measure_focused_roi(im, roi, area, focus_points, debug),
#measure_color_roi(im, roi, area, focus_points, debug),
measure_contrast(im, debug),
measure_saturation(im, debug),
faces.measure(im, debug)[1],
))
def draw(self, images, layers):
if layers == 0:
gray, r,g,b = images
im = cv.CloneImage(r)
for i in (g,b):
im = image.add(im, i)
white = image.new_from(gray)
cv.Set(white, (0,0,0))
cv.Set(white, (255,255,255), image.invert(image.threshold(im, threshold=1)))
im = image.Or(image.blend(im, gray), white)
else:
im = cv.CloneImage(images[layers-1])
if layers != 1:
white = image.new_from(images[0])
cv.Set(white, (0,0,0))
cv.Set(white, (255,255,255), image.invert(image.threshold(im, threshold=1)))
im = image.Or(im, white)
return im
def draw(self, images, layers):
if layers == 0:
gray, r, g, b = images
im = cv.CloneImage(r)
for i in (g, b):
im = image.add(im, i)
white = image.new_from(gray)
cv.Set(white, (0, 0, 0))
cv.Set(white, (255, 255, 255),
image.invert(image.threshold(im, threshold=1)))
im = image.Or(image.blend(im, gray), white)
else:
im = cv.CloneImage(images[layers - 1])
if layers != 1:
white = image.new_from(images[0])
cv.Set(white, (0, 0, 0))
cv.Set(white, (255, 255, 255),
image.invert(image.threshold(im, threshold=1)))
im = image.Or(im, white)
return im
def measure_color_roi(im, roi, area, focused_regions, debug=False):
im = cv.CloneImage(im)
g = Grid(cv.GetSize(im))
"""
contours = Contours(image.threshold(focused_regions, threshold=1)).approx_poly()
if debug:
test = image.new_from(im)
cv.Set(test, 0)
for c in contours:
i = 1
while c:
cv.FillPoly(test, [[c[x] for x in range(len(c))]], cv.RGB(0,64*i,0))
c = c.v_next()
i += 1
#contours.draw(test, levels=9)
image.show(test, "Test")
"""
#mask = image.And(image.threshold(focused_regions, threshold=1), roi)
#
#canvas = image.new_from(im, nChannels=1)
#cv.Set(canvas, 0)
#if cv.CountNonZero(mask) <= 1:
# return 0, 0
#contours = Contours(image.dilate(mask)).approx_poly()
#for c in contours:
# i = 1
# while c:
# cv.FillPoly(canvas, [[c[x] for x in range(len(c))]], 255)
# c = c.v_next()
# i += 1
#mask = image.Or(mask, canvas)
#if debug:
# image.show(mask, "MASK")
#
#cv.Set(im, 0, image.invert(mask))
cv.Set(im, 0, image.invert(roi))
#area = cv.CountNonZero(image.threshold(im, threshold=1))
if debug:
image.show(g.draw(im,thickness=2), "Image + ROI + Focus point mask")
scores = []
im = image.rgb2gray(im)
#canvas = image.And(plane, roi)
quadrants = g.split_in_four(im)
hist = []
for q,quad in enumerate(quadrants):
#scores.append(cv.Sum(quad)[0] / float(area/4))
h = GrayscaleHist(value_range=(1,255)).use_image(quad)
#image.show(h.to_img(), ['gray', 'red','green','blue'][i] + ' in ' + str(q))
hist.append(h.to_array())
scores = []
excluded_points = set([(2, 1), (3, 0)])
for i,h1 in enumerate(hist):
for j,h2 in enumerate(hist):
if i <= j or (i,j) in excluded_points:
continue
h = abs(h2-h1)
ht = GrayscaleHist(value_range=(0,255)).use_array_as_hist(h)
scores.append((h[5:].mean(), h[5:].std()))
means = max([x[0] for x in scores])
stddevs = max([x[1] for x in scores])
return means/255.0, stddevs/255.0
for x in range(256):
for y in range(size[1]):
cv.Set2D(u, y, x, x)
cv.Set2D(v, 255 - x, min(y, 255), x)
image.show(u, "U")
image.show(v, "V")
rgb = image.luv2rgb(image.merge(l, u, v))
r, g, b = image.split(rgb)
#xor = image.threshold(image.Xor(u,v), 0, cv.CV_THRESH_BINARY)
xor = image.Xor(u, v)
cv.Threshold(xor, xor, 16, 255, cv.CV_THRESH_TOZERO)
image.show(rgb, "RGB")
image.show(xor, "Xor")
#cv.Sub(rgb, image.gray2rgb(image.invert(xor)), rgb)
_, sat, _ = image.split(image.rgb2hsv(rgb))
image.show(sat, 'Saturation')
#cv.Set(xor, 0, image.invert(image.threshold(sat, threshold=4)))
cv.Sub(rgb, image.invert(image.gray2rgb(xor)), rgb)
image.show(rgb, "Rgb - Xor")
arr = image.cv2array(xor)
avg_mean, avg_std = arr.mean(), arr.std()
print cv.CountNonZero(xor) / float(size[0] * size[1]), avg_mean, avg_std
cv.WaitKey()
cv.DestroyAllWindows()
def measure(im, debug=False):
size = cv.GetSize(im)
npixels = size[0] * size[1]
#print 'np', npixels
focused = get_focus_points(im, debug)
points = convert_to_points(focused)
if debug:
print "\t" + str(
len(points)), '/', npixels, '=', len(points) / float(npixels)
print "\tlen(points) =", len(points)
image.show(focused, "4. Focused Points")
saturation_score = 0
if not image.is_grayscale(im):
edges = image.auto_edges(im)
_, saturation, _ = image.split(image.rgb2hsv(im))
if debug:
image.show(saturation, "5. Saturation")
#saturation = image.laplace(image.gaussian(saturation, 3))
saturation = image.invert(saturation)
mask = image.invert(image.threshold(im, threshold=16))
if debug:
image.show(saturation, "5.3. Laplace of Saturation")
cv.Set(saturation, 0, mask)
cv.Set(saturation, 0, focused)
if debug:
image.show(mask,
"5.6. Mask(focused AND invert(threshold(im, 16)))")
image.show(saturation, "6. Set(<5.3>, 0, <5.6>)")
saturation_score = cv.Sum(saturation)[0] / float(npixels * 255)
print "\tSaturation Score:", saturation_score
# light exposure
h, s, v = image.split(image.rgb2hsv(im))
if debug:
image.show(h, "7. Hue")
image.show(s, "7. Saturation")
image.show(v, "7. Value")
diff = cv.CloneImage(v)
cv.Set(diff, 0, image.threshold(s, threshold=16))
diff = image.dilate(diff, iterations=10)
if debug:
thres_s = image.threshold(s, threshold=16)
image.show(thres_s, "8.3. Mask(threshold(<7.Saturation>, 16))")
image.show(diff, "8.6. Dilate(Set(<7.Value>, 0, <8.3>), 10)")
cdiff = cv.CountNonZero(diff)
if cdiff > 0 and cdiff / float(npixels) > 0.01:
test = cv.CloneImage(v)
cv.Set(test, 0, image.invert(diff))
s = cv.Sum(test)[0] / float(cdiff * 255)
if debug:
print '\tLight Exposure Score:', s
else:
s = 0
if image.is_grayscale(im):
return focused, (1, 1, 1, saturation_score, s)
# we want to short circuit ASAP to avoid doing KMeans 50% of the image's pixels
if len(points) > npixels / 2:
return focused, (1, 1, 1, saturation_score, s)
# we're so blurry we don't have any points!
if len(points) < 1:
return focused, (0, 0, 0, saturation_score, s)
if debug:
im2 = cv.CloneImage(im)
focused_regions = image.new_from(im)
cv.Set(focused_regions, 0)
r = lambda x: random.randrange(1, x)
groups = form_groups(points,
estimated_size=min(max(int(len(points) / 1000), 2),
15))
#groups = form_groups(points, threshold=max(cv.GetSize(im))/16)
#print 'groups', len(groups)
hulls = draw_groups(groups, focused_regions)
focused_regions = image.threshold(focused_regions,
threshold=32,
type=cv.CV_THRESH_TOZERO)
min_area = npixels * 0.0005
densities = [h.points_per_pixel() for h in hulls if h.area() >= min_area]
if debug:
#image.show(focused, "Focused Points")
image.show(focused_regions, "9. Focused Regions from <4>")
cv.Sub(
im2,
image.gray2rgb(
image.invert(image.threshold(focused_regions, threshold=1))),
im2)
image.show(im2, "10. threshold(<9>)")
focused_regions = image.rgb2gray(focused_regions)
densities = array(densities)
c = cv.CountNonZero(focused_regions)
c /= float(npixels)
score = (c, densities.mean(), densities.std(), saturation_score, s)
return focused, score
for x in range(256):
for y in range(size[1]):
cv.Set2D(u, y, x, x)
cv.Set2D(v, 255-x, min(y, 255), x)
image.show(u, "U")
image.show(v, "V")
rgb = image.luv2rgb(image.merge(l,u,v))
r,g,b = image.split(rgb)
#xor = image.threshold(image.Xor(u,v), 0, cv.CV_THRESH_BINARY)
xor = image.Xor(u,v)
cv.Threshold(xor, xor, 16, 255, cv.CV_THRESH_TOZERO)
image.show(rgb, "RGB")
image.show(xor, "Xor")
#cv.Sub(rgb, image.gray2rgb(image.invert(xor)), rgb)
_, sat, _ = image.split(image.rgb2hsv(rgb))
image.show(sat, 'Saturation')
#cv.Set(xor, 0, image.invert(image.threshold(sat, threshold=4)))
cv.Sub(rgb, image.invert(image.gray2rgb(xor)), rgb)
image.show(rgb, "Rgb - Xor")
arr = image.cv2array(xor)
avg_mean, avg_std = arr.mean(), arr.std()
print cv.CountNonZero(xor) / float(size[0] * size[1]), avg_mean, avg_std
cv.WaitKey()
cv.DestroyAllWindows()
def measure(im, debug=False):
size = cv.GetSize(im)
npixels = size[0] * size[1]
#print 'np', npixels
focused = get_focus_points(im, debug)
points = convert_to_points(focused)
if debug:
print "\t"+str(len(points)), '/', npixels, '=', len(points) / float(npixels)
print "\tlen(points) =", len(points)
image.show(focused, "4. Focused Points")
saturation_score = 0
if not image.is_grayscale(im):
edges = image.auto_edges(im)
_, saturation, _ = image.split(image.rgb2hsv(im))
if debug:
image.show(saturation, "5. Saturation")
#saturation = image.laplace(image.gaussian(saturation, 3))
saturation = image.invert(saturation)
mask = image.invert(image.threshold(im, threshold=16))
if debug:
image.show(saturation, "5.3. Laplace of Saturation")
cv.Set(saturation, 0, mask)
cv.Set(saturation, 0, focused)
if debug:
image.show(mask, "5.6. Mask(focused AND invert(threshold(im, 16)))")
image.show(saturation, "6. Set(<5.3>, 0, <5.6>)")
saturation_score = cv.Sum(saturation)[0] / float(npixels * 255)
print "\tSaturation Score:", saturation_score
# light exposure
h,s,v = image.split(image.rgb2hsv(im))
if debug:
image.show(h, "7. Hue")
image.show(s, "7. Saturation")
image.show(v, "7. Value")
diff = cv.CloneImage(v)
cv.Set(diff, 0, image.threshold(s, threshold=16))
diff = image.dilate(diff, iterations=10)
if debug:
thres_s = image.threshold(s, threshold=16)
image.show(thres_s, "8.3. Mask(threshold(<7.Saturation>, 16))")
image.show(diff, "8.6. Dilate(Set(<7.Value>, 0, <8.3>), 10)")
cdiff = cv.CountNonZero(diff)
if cdiff > 0 and cdiff / float(npixels) > 0.01:
test = cv.CloneImage(v)
cv.Set(test, 0, image.invert(diff))
s = cv.Sum(test)[0] / float(cdiff * 255)
if debug:
print '\tLight Exposure Score:', s
else:
s = 0
if image.is_grayscale(im):
return focused, (1, 1, 1, saturation_score, s)
# we want to short circuit ASAP to avoid doing KMeans 50% of the image's pixels
if len(points) > npixels/2:
return focused, (1, 1, 1, saturation_score, s)
# we're so blurry we don't have any points!
if len(points) < 1:
return focused, (0, 0, 0, saturation_score, s)
if debug:
im2 = cv.CloneImage(im)
focused_regions = image.new_from(im)
cv.Set(focused_regions, 0)
r = lambda x: random.randrange(1, x)
groups = form_groups(points,
estimated_size=min(max(int(len(points) / 1000), 2), 15))
#groups = form_groups(points, threshold=max(cv.GetSize(im))/16)
#print 'groups', len(groups)
hulls = draw_groups(groups, focused_regions)
focused_regions = image.threshold(focused_regions, threshold=32, type=cv.CV_THRESH_TOZERO)
min_area = npixels * 0.0005
densities = [h.points_per_pixel() for h in hulls if h.area() >= min_area]
if debug:
#image.show(focused, "Focused Points")
image.show(focused_regions, "9. Focused Regions from <4>")
cv.Sub(im2, image.gray2rgb(image.invert(image.threshold(focused_regions, threshold=1))), im2)
image.show(im2, "10. threshold(<9>)")
focused_regions = image.rgb2gray(focused_regions)
densities = array(densities)
c = cv.CountNonZero(focused_regions)
c /= float(npixels)
score = (c, densities.mean(), densities.std(), saturation_score, s)
return focused, score
