def element_wise_dot_product(a, b):
a_as_row_vectors = cv.Reshape(a, 1, a.width * a.height)
b_as_row_vectors = cv.Reshape(b, 1, b.width * b.height)
a_as_rows_mul_b_as_rows = cv.CreateMat(a.width * a.height, 3, cv.CV_32FC1)
cv.Mul(a_as_row_vectors, b_as_row_vectors, a_as_rows_mul_b_as_rows)
dot_product = cv.CreateMat(a.width * a.height, 1, cv.CV_32FC1)
cv.Reduce(a_as_rows_mul_b_as_rows, dot_product, dim=1, op=cv.CV_REDUCE_SUM)
return cv.Reshape(dot_product, 1, a.height)
def kmeansUsingRGB(im, k, iterations, epsilon):
#create the samples and labels vector
col = cv.Reshape(im, 3, im.width * im.height)
samples = cv.CreateMat(col.height, 1, cv.CV_32FC3)
cv.Scale(col, samples)
labels = cv.CreateMat(col.height, 1, cv.CV_32SC1)
crit = (cv.CV_TERMCRIT_EPS | cv.CV_TERMCRIT_ITER, iterations, epsilon)
cv.KMeans2(samples, k, labels, crit)
#calculate the means
clusters = getClusters(col, samples, labels)
means = {}
for c in clusters:
means[c] = [0.0, 0.0, 0.0]
for v in clusters[c]:
means[c][0] += v[0]
means[c][1] += v[1]
means[c][2] += v[2]
means[c][0] /= len(clusters[c])
means[c][1] /= len(clusters[c])
means[c][2] /= len(clusters[c])
for m in means:
print m, means[m], len(clusters[m])
#apply clustering to the image
for i in xrange(0, col.rows):
lbl = labels[i, 0]
col[i, 0] = means[lbl]
def classify(img):
nearest=cv.CreateMat(1,K,cv.CV_32FC1)
prs_image = preprocessing(img, size, size)
img32 = cv.CreateImage( ( size, size ), cv.IPL_DEPTH_32F, 1 )
cv.ConvertScale(prs_image, img32, 0.0039215, 0)
data = cv.GetSubRect(img32, (0,0, size,size))
row1 = cv.Reshape( data, 0, 1 )
result = knn.find_nearest(nearest,row1,K,0,0,0)
result = 0
indices = cv.Mat(N, K, cv.CV_32S)
dists = cv.Mat(N, K, cv.CV_32F)
flann.knnSearch(m_object, indices, dists, K, cv.SearchParams(250))
accuracy=0
for i in range (0,K):
# print nearest
# if nearest.data.fl[i] == result:
accuracy+=1
pre= 100*(float(accuracy)/float(K))
#print "r: ",result," pre ",pre," accu ",accuracy," K ",K
return result
def getData():
for i in range (0 , classes):
for j in range (0, train_samples):
if j < 10 :
fichero = "OCR/"+str(i) + "/"+str(i)+"0"+str(j)+".pbm"
else:
fichero = "OCR/"+str(i) + "/"+str(i)+str(j)+".pbm"
src_image = cv.LoadImage(fichero,0)
prs_image = preprocessing(src_image, size, size)
row = cv.GetRow(trainClasses, i*train_samples + j)
cv.Set(row, cv.RealScalar(i))
row = cv.GetRow(trainData, i*train_samples + j)
img = cv.CreateImage( ( size, size ), cv.IPL_DEPTH_32F, 1)
cv.ConvertScale(prs_image,img,0.0039215, 0)
data = cv.GetSubRect(img, (0,0, size,size))
row1 = cv.Reshape( data, 0, 1 )
cv.Copy(row1, row)
def kmeansUsingIntensityAndLocation(im, k, iterations, epsilon):
#create the samples and labels vector
col = cv.Reshape(im, 1, im.width * im.height)
samples = cv.CreateMat(col.height, 3, cv.CV_32FC1)
count = 0
for j in xrange(0, im.height):
for i in xrange(0, im.width):
samples[count, 0] = im[j, i]
samples[count, 1] = i
samples[count, 2] = j
count += 1
labels = cv.CreateMat(col.height, 1, cv.CV_32SC1)
crit = (cv.CV_TERMCRIT_EPS | cv.CV_TERMCRIT_ITER, iterations, epsilon)
cv.KMeans2(samples, k, labels, crit)
clusters = getClusters(col, samples, labels)
#calculate the means
means = {}
for c in clusters:
means[c] = sum(clusters[c]) / len(clusters[c])
for m in means:
print m, means[m], len(clusters[m])
#apply clustering to the image
for i in xrange(0, col.rows):
lbl = labels[i, 0]
col[i, 0] = means[lbl]
def image_corners(self, im):
(ok, corners, b) = self.mc.get_corners(im)
if ok:
return list(
cvmat_iterator(
cv.Reshape(self.mc.mk_image_points([(corners, b)]), 2)))
else:
return None
def mk_image_points(self, good):
total_pts = _get_total_num_pts([b for (_, b) in good])
ipts = cv.CreateMat(total_pts, 2, cv.CV_32FC1)
idx = 0
for (corners, _) in good:
for j in range(len(corners)):
ipts[idx + j, 0] = corners[j][0]
ipts[idx + j, 1] = corners[j][1]
idx += len(corners)
return cv.Reshape(ipts, 2)
def convolveImg(self, data, isPrint):
_, wavelet = self.createGabor(isPrint)
finalData = cv.CreateMat(data.height, data.width, cv.CV_8UC1)
dataVect = cv.CreateMat(1, data.width, cv.CV_8UC1)
for i in range(0, data.height):
for j in range(0, data.width):
dataVect[0, j] = data[i, j]
reshData = cv.Reshape(dataVect, 0, self.pca.sizeImg)
if (isPrint == True and i == 0):
cv.NamedWindow("img", 1)
cv.ShowImage("img", reshData)
cv.Filter2D(reshData, reshData, wavelet)
temp = cv.Reshape(reshData, 0, 1)
for j in range(0, temp.width):
finalData[i, j] = temp[0, j]
if (isPrint == True and i == 0):
cv.NamedWindow("response", 1)
cv.ShowImage("response", reshData)
print "press any key.." + str(i)
cv.WaitKey()
return finalData
def mk_image_points(self, good_corners):
total_num = len(good_corners) * len(good_corners[0])
ipts = cv.CreateMat(total_num, 2, cv.CV_32FC1)
idx = 0
for corners in good_corners:
for i in range(len(corners)):
ipts[idx + i, 0] = corners[i][0]
ipts[idx + i, 1] = corners[i][1]
idx += len(corners)
image_points = cv.Reshape(ipts, 2)
return image_points
def rectifyPoint(self, uv_raw):
"""
:param uv_raw: pixel coordinates
:type uv_raw: (u, v)
Applies the rectification specified by camera parameters
:math:`K` and and :math:`D` to point (u, v) and returns the
pixel coordinates of the rectified point.
"""
src = mkmat(1, 2, list(uv_raw))
src = cv.Reshape(src, 2)
dst = cv.CloneMat(src)
cv.UndistortPoints(src, dst, self.K, self.D, self.R, self.P)
return dst[0, 0]
def backf(hypH, im, found):
(code,corners,pattern) = found
persp = cv.CreateMat(3, 3, cv.CV_32FC1)
fc = [corners[i,0] for i in range(4)]
cv.GetPerspectiveTransform(fc, sizcorners, persp)
cc = cv.Reshape(cv.fromarray(numpy.array(sizcorners).astype(numpy.float32)), 2)
t1 = cv.CreateMat(4, 1, cv.CV_32FC2)
t2 = cv.CreateMat(4, 1, cv.CV_32FC2)
_persp = cv.CreateMat(3, 3, cv.CV_32FC1)
cv.Invert(persp, _persp)
_hypH = cv.CreateMat(3, 3, cv.CV_32FC1)
cv.Invert(hypH, _hypH)
cv.PerspectiveTransform(cc, t1, _hypH)
cv.PerspectiveTransform(t1, t2, _persp)
return [t2[i,0] for i in range(4)]
def kmeansUsingLM(im, k, iterations, epsilon):
#array of filter kernels
filterBank = lmfilters.loadLMFilters()
#create the samples and labels vector
col = cv.Reshape(im, 3, im.width * im.height)
samples = cv.CreateMat(col.height, 48, cv.CV_32FC1)
for f in xrange(0, 48):
filter = filterBank[f]
dst = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_32F, 3)
cv.Filter2D(im, dst, filter)
count = 0
for j in xrange(0, im.height):
for i in xrange(0, im.width):
#take the maximum response from the 3 channels
maxRes = max(dst[j, i])
if math.isnan(maxRes):
maxRes = 0.0
samples[count, f] = maxRes
count += 1
labels = cv.CreateMat(col.height, 1, cv.CV_32SC1)
crit = (cv.CV_TERMCRIT_EPS | cv.CV_TERMCRIT_ITER, iterations, epsilon)
cv.KMeans2(samples, k, labels, crit)
clusters = getClusters(col, samples, labels)
means = {}
for c in clusters:
means[c] = [0.0, 0.0, 0.0]
for v in clusters[c]:
means[c][0] += v[0]
means[c][1] += v[1]
means[c][2] += v[2]
means[c][0] /= len(clusters[c])
means[c][1] /= len(clusters[c])
means[c][2] /= len(clusters[c])
for m in means:
print m, means[m], len(clusters[m])
#apply clustering to the image
for i in xrange(0, col.rows):
lbl = labels[i, 0]
col[i, 0] = means[lbl]
def projPCA(self, X, showIm, folder, sign):
X = numpy.asfarray(X)
#1) Load the eigenVector and the Mean of the data:
eigen = self.cv2array(
cv.Load("data_train/" + str(folder) + "PcaEigen" +
str(self.sizeImg) + ".dat"), False)
meanX = self.cv2array(
cv.Load("data_train/" + str(folder) + "PcaMean" +
str(self.sizeImg) + ".dat"), False)
#2) Substract the mean of the data
for i in range(0, X.shape[0]):
X[i, :] -= meanX[0, :]
#3) do projection on first "?" components: [N,4900]x[4900,?] => [N,?]
projX = numpy.dot(X, eigen)
#5) do back-projection on first "?" components to check: [N,?]x[?,4900] => [N,4900]
if (showIm == True):
backX = numpy.dot(projX, eigen.T)
for i in range(0, X.shape[0]):
backX[i, :] += meanX[0, :] #add the mean back
#6) normalize the backprojection
mini = numpy.min(backX)
backX -= mini
maxi = numpy.max(backX)
backX = numpy.multiply(backX, float(255.0) / float(abs(maxi)))
#7) Shot the backprojected image
eigenHand = self.array2cv(backX[0:1, :], True)
cv.ShowImage("PCA_" + str(sign),
cv.Reshape(eigenHand, 0, self.sizeImg))
print "press any key.."
cv.WaitKey()
#8) store the projection of the data
if (len(sign) > 1):
cvData = self.array2cv(projX, False)
cv.Save(
"data_train/" + str(folder) + str(sign) + "Train" +
str(self.sizeImg) + ".dat", cvData)
return projX
def InitPredistortMap(cameraMatrix, distCoeffs, map1, map2):
rows = map1.height
cols = map1.width
mat = cv.CreateMat(1, rows * cols, cv.CV_32FC2)
for row in range(rows):
for col in range(cols):
mat[0, row * cols + col] = (col, row)
R = cv.CreateMat(3, 3, cv.CV_32FC1)
cv.SetIdentity(R)
P = cv.CreateMat(3, 4, cv.CV_64FC1)
cv.SetZero(P)
cv.Copy(cameraMatrix, cv.GetSubRect(P, (0, 0, 3, 3)))
cv.UndistortPoints(mat, mat, cameraMatrix, distCoeffs, R, P)
mat = cv.Reshape(mat, 2, rows)
cv.Split(mat, map1, map2, None, None)
def preprocessImg(self, image, zaType):
#1) resize the image to the needed size
resizeImg = cv.CreateMat(self.pca.sizeImg, self.pca.sizeImg,
cv.CV_8UC1)
cv.Resize(image, resizeImg, interpolation=cv.CV_INTER_AREA)
#2) reshape the image as a row
imgMat = cv.Reshape(resizeImg, 0, 1)
if (zaType == 1): # original images
return self.pca.cv2array(imgMat, True)
elif (zaType == 2): # PCA over the original images
return self.pca.projPCA(self.pca.cv2array(imgMat, True), False,
"PCA/", "")
elif (
zaType == 3
): # convolve with 4 kernels and add the original image -- NO PCA
return self.prep.doSmallManyGabors(self.pca.cv2array(imgMat, True),
None, "", False)
elif (zaType == 4): # convolve with 4 kernels -- NO PCA
return self.prep.doManyGabors(self.pca.cv2array(imgMat, True),
None, "", False)
def makeMatrix(self, fold):
files = os.listdir('train/' + fold)
anIndex = 0
matches = glob.glob(os.path.join("train/" + fold, '*.jpg'))
print(self.sizeImg * self.sizeImg)
print len(matches)
imgMatrix = cv.CreateMat(len(matches), (self.sizeImg * self.sizeImg),
cv.CV_8UC1)
oneLine = cv.CreateMat(1, (self.sizeImg * self.sizeImg), cv.CV_8UC1)
resizeImg = cv.CreateMat(self.sizeImg, self.sizeImg, cv.CV_8UC1)
matches.sort()
for aImage in matches:
hands = cv.LoadImageM(aImage, cv.CV_LOAD_IMAGE_GRAYSCALE)
cv.Resize(hands, resizeImg, interpolation=cv.CV_INTER_AREA)
handsMat = cv.Reshape(resizeImg, 0, 1)
for j in range(0, handsMat.width):
imgMatrix[anIndex, j] = handsMat[0, j]
anIndex += 1
cv.Save("data_train/" + fold + "Train" + str(self.sizeImg) + ".dat",
imgMatrix)
def refinecorners(im, found):
""" For a found marker, return the refined corner positions """
t0 = time.time()
(code,corners,pattern) = found
persp = cv.CreateMat(3, 3, cv.CV_32FC1)
fc = [corners[i,0] for i in range(4)]
cv.GetPerspectiveTransform(fc, sizcorners, persp)
cim = cv.CreateMat(siz, siz, cv.CV_8UC1)
cv.WarpPerspective(im, cim, persp, flags = cv.CV_INTER_LINEAR|cv.CV_WARP_FILL_OUTLIERS, fillval = 255)
unit = siz / 14.
hunit = unit / 2
def nearest1(x, y):
ix = int((x + hunit) / unit)
iy = int((y + hunit) / unit)
if (2 <= ix < 13) and (2 <= iy < 13):
nx = int(unit * ix)
ny = int(unit * iy)
return (nx, ny)
else:
return (0,0)
def nearest(x, y):
""" Return all grid points within sqrt(2) units of (x,y), closest first """
close = []
for ix in range(2, 14):
for iy in range(2, 14):
(nx, ny) = (unit * ix, unit * iy)
d = l2(x, y, nx, ny)
close.append((d, (nx, ny)))
return [p for (d,p) in sorted(close) if d < 2*unit*unit]
corners = strongest(cim)
pool = [((x,y), nearest(x, y)) for (x, y) in corners]
ga = dict([(x+y,((x,y),P)) for ((x,y),P) in pool])
gb = dict([(x-y,((x,y),P)) for ((x,y),P) in pool])
hyp = [ga[min(ga)], ga[max(ga)],
gb[min(gb)], gb[max(gb)]]
aL = [a for (a,bs) in hyp]
oldcorners = cv.fromarray(numpy.array(corners).astype(numpy.float32))
oldcorners = cv.Reshape(oldcorners, 2)
newcorners = cv.CreateMat(len(corners), 1, cv.CV_32FC2)
best = (9999999, None)
for bL in itertools.product(*[bs for (a,bs) in hyp]):
hypH = cv.CreateMat(3, 3, cv.CV_32FC1)
cv.GetPerspectiveTransform(aL, bL, hypH)
cv.PerspectiveTransform(oldcorners, newcorners, hypH)
error = 0
for i in range(newcorners.rows):
(x,y) = newcorners[i,0]
(nx, ny) = nearest1(x, y)
error += l2(x, y, nx, ny)
best = min(best, (error, hypH))
if error < 1000:
break
# print "took", time.time() - t0, best[0]
if best[0] < 2500:
pose = best[1]
return backf(pose, im, found)
else:
return None
def kmeansUsingPCA(im, k, iterations, epsilon):
#convert image to YUV color space
cv.CvtColor(im, im, cv.CV_BGR2YCrCb)
#array of filter kernels
filterBank = lmfilters.loadLMFilters()
#create the samples and labels vector
col = cv.Reshape(im, 3, im.width * im.height)
#samples = cv.CreateMat(col.height, 51, cv.CV_32FC1)
samples = zeros([col.height, 51])
for f in xrange(0, 48):
filter = filterBank[f]
dst = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_32F, 3)
cv.Filter2D(im, dst, filter)
count = 0
for j in xrange(0, im.height):
for i in xrange(0, im.width):
#take the maximum response from the 3 channels
maxRes = max(dst[j, i])
if math.isnan(maxRes):
maxRes = 0.0
samples[count, f] = maxRes
count += 1
#YUV features
count = 0
for j in xrange(0, im.height):
for i in xrange(0, im.width):
samples[count, 48] = im[j, i][0]
samples[count, 49] = im[j, i][1]
samples[count, 50] = im[j, i][2]
count += 1
#get the first 4 primary components using pca
pca = PCA(samples)
pcaSamples = zeros([col.height, 4])
for i in xrange(0, col.height):
pcaSamples[i] = pca.getPCA(samples[i], 4)
samples = cv.fromarray(pcaSamples)
samplesMat = cv.CreateMat(col.height, 4, cv.CV_32FC1)
cv.Scale(samples, samplesMat)
labels = cv.CreateMat(col.height, 1, cv.CV_32SC1)
crit = (cv.CV_TERMCRIT_EPS | cv.CV_TERMCRIT_ITER, iterations, epsilon)
cv.KMeans2(samplesMat, k, labels, crit)
clusters = getClusters(col, samplesMat, labels)
means = {}
for c in clusters:
means[c] = [0.0, 0.0, 0.0]
for v in clusters[c]:
means[c][0] += v[0]
means[c][1] += v[1]
means[c][2] += v[2]
means[c][0] /= len(clusters[c])
means[c][1] /= len(clusters[c])
means[c][2] /= len(clusters[c])
for m in means:
print m, means[m], len(clusters[m])
#apply clustering to the image
for i in xrange(0, col.rows):
lbl = labels[i, 0]
col[i, 0] = means[lbl]
