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]