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 ccoeff_normed(img1, img2): size = cv.GetSize(img1) tmp1 = float_version(img1) tmp2 = float_version(img2) cv.SubS(tmp1, cv.Avg(tmp1), tmp1) cv.SubS(tmp2, cv.Avg(tmp2), tmp2) norm1 = cv.CloneImage(tmp1) norm2 = cv.CloneImage(tmp2) cv.Pow(tmp1, norm1, 2.0) cv.Pow(tmp2, norm2, 2.0) #cv.Mul(tmp1, tmp2, tmp1) return cv.DotProduct(tmp1, tmp2) / (cv.Sum(norm1)[0]*cv.Sum(norm2)[0])**0.5
def avgstd_image_list(images):
mean = None
std = None
if len(images) > 0:
scale = 1. / len(images)
mean = cv.CreateImage(cv.GetSize(images[0]), cv.IPL_DEPTH_32F,
images[0].channels)
std = cv.CreateImage(cv.GetSize(images[0]), cv.IPL_DEPTH_32F,
images[0].channels)
buf = cv.CreateImage(cv.GetSize(images[0]), cv.IPL_DEPTH_32F,
images[0].channels)
for image in images:
cv.Add(image, mean, mean)
cv.Mul(image, image, buf)
cv.Add(buf, std, std)
cv.ConvertScale(mean, mean, scale)
cv.ConvertScale(std, std, scale)
cv.Mul(mean, mean, buf)
cv.Sub(std, buf, std)
cv.Pow(std, std, 0.5)
meanresult = cv.CreateImage(cv.GetSize(images[0]), images[0].depth,
images[0].channels)
stdresult = cv.CreateImage(cv.GetSize(images[0]), images[0].depth,
images[0].channels)
cv.ConvertScale(mean, meanresult)
cv.ConvertScale(std, stdresult)
del buf
del std
del mean
return (meanresult, stdresult)
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 ssdScore(f1, f2):
global size #size o f SSD window
#subtracts f2 from f1
sub_f1_f2 = cv.CreateMat(size, size, cv.CV_64FC1)
cv.Sub(f1, f2, sub_f1_f2)
#square and add
f1_f2_square = cv.CreateMat(size, size, cv.CV_64FC1)
cv.Pow(sub_f1_f2, f1_f2_square, 2)
score = cv.Sum(f1_f2_square)
return score[0] / (size * size)
def project_pixels_to_3d_rays(pixels, model):
x = cv.CreateMat(pixels.height, pixels.width, cv.CV_32FC1)
y = cv.CreateMat(pixels.height, pixels.width, cv.CV_32FC1)
cv.Split(pixels, x, y, None, None)
x_squared = cv.CreateMat(pixels.height, pixels.width, cv.CV_32FC1)
cv.Pow(x, x_squared, 2)
y_squared = cv.CreateMat(pixels.height, pixels.width, cv.CV_32FC1)
cv.Pow(y, y_squared, 2)
inverse_norm = cv.CreateMat(pixels.height, pixels.width, cv.CV_32FC1)
cv.Add(x_squared, y_squared, inverse_norm)
cv.AddS(inverse_norm, 1, inverse_norm)
cv.Pow(inverse_norm, inverse_norm, -0.5)
cv.Mul(x, inverse_norm, x)
cv.Mul(y, inverse_norm, y)
result = cv.CreateMat(pixels.height, pixels.width, cv.CV_32FC3)
cv.Merge(x, y, inverse_norm, None, result)
return result
def pixel_distance_matrix(images):
buf = cv.CreateImage(cv.GetSize(images[0]), images[0].depth,
images[0].channels)
distances = np.zeros((len(images), len(images)))
for i in xrange(len(images)):
for j in xrange(i + 1, len(images)):
cv.Sub(images[i], images[j], buf)
cv.Pow(buf, buf, 2)
distance = cv.Sum(buf)[0]
distances[i, j] = distance
distances[j, i] = distance
del buf
return distances
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
cv.Zero(tmp)
# no need to pad bottom part of dft_A with zeros because of
# use nonzero_rows parameter in cv.FT() call below
cv.DFT(dft_A, dft_A, cv.CV_DXT_FORWARD, complexInput.height)
cv.NamedWindow("win", 0)
cv.NamedWindow("magnitude", 0)
cv.ShowImage("win", im)
# Split Fourier in real and imaginary parts
cv.Split(dft_A, image_Re, image_Im, None, None)
# Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
cv.Pow(image_Re, image_Re, 2.0)
cv.Pow(image_Im, image_Im, 2.0)
cv.Add(image_Re, image_Im, image_Re, None)
cv.Pow(image_Re, image_Re, 0.5)
# Compute log(1 + Mag)
cv.AddS(image_Re, cv.ScalarAll(1.0), image_Re, None) # 1 + Mag
cv.Log(image_Re, image_Re) # log(1 + Mag)
# Rearrange the quadrants of Fourier image so that the origin is at
# the image center
cvShiftDFT(image_Re, image_Re)
min, max, pt1, pt2 = cv.MinMaxLoc(image_Re)
cv.Scale(image_Re, image_Re, 1.0 / (max - min), 1.0 * (-min) / (max - min))
cv.ShowImage("magnitude", image_Re)
def atualiza_foto(self):
real = cv.CreateImage(cv.GetSize(imagem), cv.IPL_DEPTH_64F, 1)
imaginario = cv.CreateImage(cv.GetSize(imagem), cv.IPL_DEPTH_64F, 1)
complexo = cv.CreateImage(cv.GetSize(imagem), cv.IPL_DEPTH_64F, 2)
cv.Scale(imagem_cinza, real, 1.0, 0.0)
cv.Zero(imaginario)
cv.Merge(real, imaginario, None, None, complexo)
Altura_M = cv.GetOptimalDFTSize(imagem.height - 1)
Largura_N = cv.GetOptimalDFTSize(imagem.width - 1)
Vetor_dft = cv.CreateMat(Altura_M, Largura_N, cv.CV_64FC2)
imagem_Real = cv.CreateImage((Largura_N, Altura_M), cv.IPL_DEPTH_64F,
1)
imagem_Imaginaria = cv.CreateImage((Largura_N, Altura_M),
cv.IPL_DEPTH_64F, 1)
temporario = cv.GetSubRect(Vetor_dft,
(0, 0, imagem.width, imagem.height))
cv.Copy(complexo, temporario, None)
if (Vetor_dft.width > imagem.width):
temporario = cv.GetSubRect(
Vetor_dft,
(imagem.width, 0, Largura_N - imagem.width, imagem.height))
cv.Zero(temporario)
# APLICANDO FOURIER
cv.DFT(Vetor_dft, Vetor_dft, cv.CV_DXT_FORWARD, complexo.height)
cv.Split(Vetor_dft, imagem_Real, imagem_Imaginaria, None, None)
cv.Pow(imagem_Real, imagem_Real, 2.0)
cv.Pow(imagem_Imaginaria, imagem_Imaginaria, 2.0)
cv.Add(imagem_Real, imagem_Imaginaria, imagem_Real, None)
cv.Pow(imagem_Real, imagem_Real, 0.5)
cv.AddS(imagem_Real, cv.ScalarAll(1.0), imagem_Real, None)
cv.Log(imagem_Real, imagem_Real)
cvShiftDFT(imagem_Real, imagem_Real)
min, max, pt1, pt2 = cv.MinMaxLoc(imagem_Real)
cv.Scale(imagem_Real, imagem_Real, 1.0 / (max - min),
1.0 * (-min) / (max - min))
#APLICANDO FILTRO passa-baixa circular
cv.Circle(Vetor_dft, (0, 0), self.raio, [0, 0, 0], -1, 1, 0)
cv.Circle(Vetor_dft, (Vetor_dft.cols, 0), self.raio, [0, 0, 0], -1, 1,
0)
cv.Circle(Vetor_dft, (0, Vetor_dft.rows), self.raio, [0, 0, 0], -1, 1,
0)
cv.Circle(Vetor_dft, (Vetor_dft.cols, Vetor_dft.rows), self.raio,
[0, 0, 0], -1, 1, 0)
cv.Split(Vetor_dft, imagem_Real, imagem_Imaginaria, None, None)
cv.Pow(imagem_Real, imagem_Real, 2.0)
cv.Pow(imagem_Imaginaria, imagem_Imaginaria, 2.0)
cv.Add(imagem_Real, imagem_Imaginaria, imagem_Real, None)
cv.Pow(imagem_Real, imagem_Real, 0.5)
cv.AddS(imagem_Real, cv.ScalarAll(1.0), imagem_Real, None)
cv.Log(imagem_Real, imagem_Real)
cvShiftDFT(imagem_Real, imagem_Real)
min, max, pt1, pt2 = cv.MinMaxLoc(imagem_Real)
cv.Scale(imagem_Real, imagem_Real, 1.0 / (max - min),
1.0 * (-min) / (max - min))
cv.ShowImage("Transformada de Fourier", imagem_Real)
# APLICANDO A INVERSA de Fourier
cv.DFT(Vetor_dft, Vetor_dft, cv.CV_DXT_INVERSE_SCALE, Largura_N)
cv.Split(Vetor_dft, imagem_Real, imagem_Imaginaria, None, None)
min, max, pt1, pt2 = cv.MinMaxLoc(imagem_Real)
if ((pt1 < 0) or (pt2 > 255)):
cv.Scale(imagem_Real, imagem_Real, 1.0 / (max - min),
1.0 * (-min) / (max - min))
else:
cv.Scale(imagem_Real, imagem_Real, 1.0 / 255, 0)
cv.ShowImage("Inversa da Fourier", imagem_Real)
def normalize_gamma(cls, img, gamma):
out = cv.CreateMat(img.rows, img.cols, img.type)
cv.Pow(img, out, gamma)
cv.ConvertScaleAbs(out, out)
return out
def sum_squared(img1, img2):
tmp = cv.CreateImage(cv.GetSize(img1), 8, 1)
cv.Sub(img1, img2, tmp)
cv.Pow(tmp, tmp, 2.0)
return cv.Sum(tmp)[0]
def doSSIM(frame1, frame2):
'''
The equivalent of Zhou Wang's SSIM matlab code using OpenCV.
from http://www.cns.nyu.edu/~zwang/files/research/ssim/index.html
The measure is described in :
"Image quality assessment: From error measurement to structural similarity"
C++ code by Rabah Mehdi. http://mehdi.rabah.free.fr/SSIM
C++ to Python translation and adaptation by Iñaki Úcar
'''
def array2cv(a):
dtype2depth = {
'uint8': cv.IPL_DEPTH_8U,
'int8': cv.IPL_DEPTH_8S,
'uint16': cv.IPL_DEPTH_16U,
'int16': cv.IPL_DEPTH_16S,
'int32': cv.IPL_DEPTH_32S,
'float32': cv.IPL_DEPTH_32F,
'float64': cv.IPL_DEPTH_64F,
}
try:
nChannels = a.shape[2]
except:
nChannels = 1
cv_im = cv.CreateImageHeader((a.shape[1], a.shape[0]),
dtype2depth[str(a.dtype)], nChannels)
cv.SetData(cv_im, a.tostring(),
a.dtype.itemsize * nChannels * a.shape[1])
return cv_im
C1 = 6.5025
C2 = 58.5225
img1_temp = array2cv(frame1)
img2_temp = array2cv(frame2)
nChan = img1_temp.nChannels
d = cv.IPL_DEPTH_32F
size = img1_temp.width, img1_temp.height
img1 = cv.CreateImage(size, d, nChan)
img2 = cv.CreateImage(size, d, nChan)
cv.Convert(img1_temp, img1)
cv.Convert(img2_temp, img2)
img1_sq = cv.CreateImage(size, d, nChan)
img2_sq = cv.CreateImage(size, d, nChan)
img1_img2 = cv.CreateImage(size, d, nChan)
cv.Pow(img1, img1_sq, 2)
cv.Pow(img2, img2_sq, 2)
cv.Mul(img1, img2, img1_img2, 1)
mu1 = cv.CreateImage(size, d, nChan)
mu2 = cv.CreateImage(size, d, nChan)
mu1_sq = cv.CreateImage(size, d, nChan)
mu2_sq = cv.CreateImage(size, d, nChan)
mu1_mu2 = cv.CreateImage(size, d, nChan)
sigma1_sq = cv.CreateImage(size, d, nChan)
sigma2_sq = cv.CreateImage(size, d, nChan)
sigma12 = cv.CreateImage(size, d, nChan)
temp1 = cv.CreateImage(size, d, nChan)
temp2 = cv.CreateImage(size, d, nChan)
temp3 = cv.CreateImage(size, d, nChan)
ssim_map = cv.CreateImage(size, d, nChan)
#/*************************** END INITS **********************************/
#// PRELIMINARY COMPUTING
cv.Smooth(img1, mu1, cv.CV_GAUSSIAN, 11, 11, 1.5)
cv.Smooth(img2, mu2, cv.CV_GAUSSIAN, 11, 11, 1.5)
cv.Pow(mu1, mu1_sq, 2)
cv.Pow(mu2, mu2_sq, 2)
cv.Mul(mu1, mu2, mu1_mu2, 1)
cv.Smooth(img1_sq, sigma1_sq, cv.CV_GAUSSIAN, 11, 11, 1.5)
cv.AddWeighted(sigma1_sq, 1, mu1_sq, -1, 0, sigma1_sq)
cv.Smooth(img2_sq, sigma2_sq, cv.CV_GAUSSIAN, 11, 11, 1.5)
cv.AddWeighted(sigma2_sq, 1, mu2_sq, -1, 0, sigma2_sq)
cv.Smooth(img1_img2, sigma12, cv.CV_GAUSSIAN, 11, 11, 1.5)
cv.AddWeighted(sigma12, 1, mu1_mu2, -1, 0, sigma12)
#//////////////////////////////////////////////////////////////////////////
#// FORMULA
#// (2*mu1_mu2 + C1)
cv.Scale(mu1_mu2, temp1, 2)
cv.AddS(temp1, C1, temp1)
#// (2*sigma12 + C2)
cv.Scale(sigma12, temp2, 2)
cv.AddS(temp2, C2, temp2)
#// ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
cv.Mul(temp1, temp2, temp3, 1)
#// (mu1_sq + mu2_sq + C1)
cv.Add(mu1_sq, mu2_sq, temp1)
cv.AddS(temp1, C1, temp1)
#// (sigma1_sq + sigma2_sq + C2)
cv.Add(sigma1_sq, sigma2_sq, temp2)
cv.AddS(temp2, C2, temp2)
#// ((mu1_sq + mu2_sq + C1).*(sigma1_sq + sigma2_sq + C2))
cv.Mul(temp1, temp2, temp1, 1)
#// ((2*mu1_mu2 + C1).*(2*sigma12 + C2))./((mu1_sq + mu2_sq + C1).*(sigma1_sq + sigma2_sq + C2))
cv.Div(temp3, temp1, ssim_map, 1)
index_scalar = cv.Avg(ssim_map)
#// through observation, there is approximately
#// 1% error max with the original matlab program
return index_scalar[0]
def line_line_intersections(P_0, u, Q_0, v):
rows = P_0.height
cols = P_0.width
w_0 = cv.CreateMat(rows, cols, cv.CV_32FC3)
cv.Sub(P_0, Q_0, w_0)
a = element_wise_dot_product(u, u)
b = element_wise_dot_product(u, v)
c = element_wise_dot_product(v, v)
d = element_wise_dot_product(u, w_0)
e = element_wise_dot_product(v, w_0)
a_mul_c = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Mul(a, c, a_mul_c)
b_squared = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Pow(b, b_squared, 2)
denominator = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Sub(a_mul_c, b_squared, denominator)
b_mul_e = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Mul(b, e, b_mul_e)
c_mul_d = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Mul(c, d, c_mul_d)
b_mul_d = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Mul(b, d, b_mul_d)
a_mul_e = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Mul(a, e, a_mul_e)
s_c = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Sub(b_mul_e, c_mul_d, s_c)
cv.Div(s_c, denominator, s_c)
t_c = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Sub(a_mul_e, b_mul_d, t_c)
cv.Div(t_c, denominator, t_c)
u_x = cv.CreateMat(rows, cols, cv.CV_32FC1)
u_y = cv.CreateMat(rows, cols, cv.CV_32FC1)
u_z = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Split(u, u_x, u_y, u_z, None)
su_x = cv.CreateMat(rows, cols, cv.CV_32FC1)
su_y = cv.CreateMat(rows, cols, cv.CV_32FC1)
su_z = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Mul(s_c, u_x, su_x)
cv.Mul(s_c, u_y, su_y)
cv.Mul(s_c, u_z, su_z)
su = cv.CreateMat(rows, cols, cv.CV_32FC3)
cv.Merge(su_x, su_y, su_z, None, su)
tu_x = cv.CreateMat(rows, cols, cv.CV_32FC1)
tu_y = cv.CreateMat(rows, cols, cv.CV_32FC1)
tu_z = cv.CreateMat(rows, cols, cv.CV_32FC1)
cv.Mul(t_c, u_x, tu_x)
cv.Mul(t_c, u_y, tu_y)
cv.Mul(t_c, u_z, tu_z)
tu = cv.CreateMat(rows, cols, cv.CV_32FC3)
cv.Merge(tu_x, tu_y, tu_z, None, tu)
closest_point = cv.CreateMat(rows, cols, cv.CV_32FC3)
cv.Add(P_0, su, closest_point)
return closest_point
def __SSIM(self, frame1, frame2):
"""
The equivalent of Zhou Wang's SSIM matlab code using OpenCV.
from http://www.cns.nyu.edu/~zwang/files/research/ssim/index.html
The measure is described in :
"Image quality assessment: From error measurement to structural similarity"
C++ code by Rabah Mehdi. http://mehdi.rabah.free.fr/SSIM
C++ to Python translation and adaptation by Iñaki Úcar
"""
C1 = 6.5025
C2 = 58.5225
img1_temp = self.__array2cv(frame1)
img2_temp = self.__array2cv(frame2)
nChan = img1_temp.nChannels
d = cv.IPL_DEPTH_32F
size = img1_temp.width, img1_temp.height
img1 = cv.CreateImage(size, d, nChan)
img2 = cv.CreateImage(size, d, nChan)
cv.Convert(img1_temp, img1)
cv.Convert(img2_temp, img2)
img1_sq = cv.CreateImage(size, d, nChan)
img2_sq = cv.CreateImage(size, d, nChan)
img1_img2 = cv.CreateImage(size, d, nChan)
cv.Pow(img1, img1_sq, 2)
cv.Pow(img2, img2_sq, 2)
cv.Mul(img1, img2, img1_img2, 1)
mu1 = cv.CreateImage(size, d, nChan)
mu2 = cv.CreateImage(size, d, nChan)
mu1_sq = cv.CreateImage(size, d, nChan)
mu2_sq = cv.CreateImage(size, d, nChan)
mu1_mu2 = cv.CreateImage(size, d, nChan)
sigma1_sq = cv.CreateImage(size, d, nChan)
sigma2_sq = cv.CreateImage(size, d, nChan)
sigma12 = cv.CreateImage(size, d, nChan)
temp1 = cv.CreateImage(size, d, nChan)
temp2 = cv.CreateImage(size, d, nChan)
temp3 = cv.CreateImage(size, d, nChan)
ssim_map = cv.CreateImage(size, d, nChan)
#/*************************** END INITS **********************************/
#// PRELIMINARY COMPUTING
cv.Smooth(img1, mu1, cv.CV_GAUSSIAN, 11, 11, 1.5)
cv.Smooth(img2, mu2, cv.CV_GAUSSIAN, 11, 11, 1.5)
cv.Pow(mu1, mu1_sq, 2)
cv.Pow(mu2, mu2_sq, 2)
cv.Mul(mu1, mu2, mu1_mu2, 1)
cv.Smooth(img1_sq, sigma1_sq, cv.CV_GAUSSIAN, 11, 11, 1.5)
cv.AddWeighted(sigma1_sq, 1, mu1_sq, -1, 0, sigma1_sq)
cv.Smooth(img2_sq, sigma2_sq, cv.CV_GAUSSIAN, 11, 11, 1.5)
cv.AddWeighted(sigma2_sq, 1, mu2_sq, -1, 0, sigma2_sq)
cv.Smooth(img1_img2, sigma12, cv.CV_GAUSSIAN, 11, 11, 1.5)
cv.AddWeighted(sigma12, 1, mu1_mu2, -1, 0, sigma12)
#//////////////////////////////////////////////////////////////////////////
#// FORMULA
#// (2*mu1_mu2 + C1)
cv.Scale(mu1_mu2, temp1, 2)
cv.AddS(temp1, C1, temp1)
#// (2*sigma12 + C2)
cv.Scale(sigma12, temp2, 2)
cv.AddS(temp2, C2, temp2)
#// ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
cv.Mul(temp1, temp2, temp3, 1)
#// (mu1_sq + mu2_sq + C1)
cv.Add(mu1_sq, mu2_sq, temp1)
cv.AddS(temp1, C1, temp1)
#// (sigma1_sq + sigma2_sq + C2)
cv.Add(sigma1_sq, sigma2_sq, temp2)
cv.AddS(temp2, C2, temp2)
#// ((mu1_sq + mu2_sq + C1).*(sigma1_sq + sigma2_sq + C2))
cv.Mul(temp1, temp2, temp1, 1)
#// ((2*mu1_mu2 + C1).*(2*sigma12 + C2))./((mu1_sq + mu2_sq + C1).*(sigma1_sq + sigma2_sq + C2))
cv.Div(temp3, temp1, ssim_map, 1)
index_scalar = cv.Avg(ssim_map)
#// through observation, there is approximately
#// 1% error max with the original matlab program
return index_scalar[0]
def opencvSaliency(self, scaledImageGray):
cvImageGray = cv.CreateMat(scaledImageGray.height,
scaledImageGray.width, cv.CV_32FC1)
cv.Convert(scaledImageGray, cvImageGray)
src = cvImageGray
dftWidth = cv.GetOptimalDFTSize(src.width - 1)
dftHeight = cv.GetOptimalDFTSize(src.height - 1)
real = cv.CreateMat(dftHeight, dftWidth, cv.CV_32FC1)
imaginary = cv.CreateMat(dftHeight, dftWidth, cv.CV_32FC1)
dft = cv.CreateMat(dftHeight, dftWidth, cv.CV_32FC2)
tmp = cv.GetSubRect(real, (0, 0, src.width, src.height))
cv.Copy(src, tmp)
cv.Zero(imaginary)
cv.Merge(real, imaginary, None, None, dft)
# do the fft
cv.DFT(dft, dft, cv.CV_DXT_FORWARD, src.height)
cv.Split(dft, real, imaginary, None, None)
cv.CartToPolar(real, imaginary, real, imaginary, 0)
cv.Log(real, real)
filtered = cv.CreateMat(dftHeight, dftWidth, cv.CV_32FC1)
cv.Copy(real, filtered)
cv.Smooth(filtered, filtered, cv.CV_BLUR)
cv.Sub(real, filtered, real, None)
cv.Exp(real, real)
cv.PolarToCart(real, imaginary, real, imaginary, 0)
#cv.PolarToCart( np.ones( shape=(dftHeight,dftWidth), dtype=np.float32 ), imaginary, real, imaginary,0 )
# do inverse fourier transform
cv.Merge(real, imaginary, None, None, dft)
cv.DFT(dft, dft, cv.CV_DXT_INV_SCALE, src.height)
cv.Split(dft, real, imaginary, None, None)
# get magnitude
cv.CartToPolar(real, imaginary, real, None, 0)
cv.Pow(real, real, 2.0)
FILTER_RAD = 3
IPL_BORDER_CONSTANT = 0
sfiltered = cv.CreateMat(real.height + FILTER_RAD * 2,
real.width + FILTER_RAD * 2, cv.CV_32FC1)
cv.CopyMakeBorder(real, sfiltered, (FILTER_RAD, FILTER_RAD),
IPL_BORDER_CONSTANT)
cv.Smooth(sfiltered, sfiltered, cv.CV_GAUSSIAN, 2 * FILTER_RAD + 1)
(min, max, minLoc, maxLoc) = cv.MinMaxLoc(sfiltered)
cv.ConvertScale(sfiltered, sfiltered, 1 / (max - min),
-min / (max - min))
# copy result to output image
tmp = cv.GetSubRect(sfiltered,
(FILTER_RAD, FILTER_RAD, src.width, src.height))
cv.Copy(tmp, cvImageGray)
#cvReleaseMat(&sfiltered);
#cvReleaseMat(&real);
#cvReleaseMat(&filtered);
#cvReleaseMat(&imaginary);
#cvReleaseMat(&dft);
saliencyMap = np.array(255.0 * np.array(cvImageGray), dtype=np.uint8)
return saliencyMap