def train():
training_set = []
training_labels = []
os.chdir("/Users/muyunyan/Desktop/EC500FINAL/logo/")
counter = 0
a = os.listdir(".")
for i in a:
os.chdir(i)
print(i)
for d in os.listdir("."):
img = cv2.imread(d)
res = cv2.resize(img, (250, 250))
gray_image = cv2.cvtColor(res, cv2.COLOR_BGR2GRAY)
xarr = np.squeeze(np.array(gray_image).astype(np.float32))
m, v = cv2.PCACompute(xarr)
arr = np.array(v)
flat_arr = arr.ravel()
training_set.append(flat_arr)
training_labels.append(i)
os.chdir("..")
trainData = training_set
responses = training_labels
svm = svm.SVC()
svm.fit(trainData, responses)
return svm
def __init__(self, image_feature, max_components):
assert image_feature.ndim == 3
feature = np.reshape(image_feature, (-1, image_feature.shape[2]))
_mean = np.mean(feature, axis=0, keepdims=True)
self.mean, self.eigen_vecs = cv2.PCACompute(
feature, _mean, maxComponents=max_components)
print('\tPCA computed!')
def is_line(image):
if not have_solid_field(image):
return False
pixels = np.vstack(image.nonzero()).transpose().astype(np.float32)
mean, eigenvectors = cv2.PCACompute(pixels, mean=None)
projects = cv2.PCAProject(pixels, mean, eigenvectors)
return np.std(projects, axis=0)[1] < 1
def pointing_line(gray, x, y, R, perimeter):
epsilon = 0.4
r = int(epsilon * R)
img = gray[x - r:x + r, y - r:y + r]
#thresh
ret, thresh = cv2.threshold(img, 50, 255, cv2.THRESH_BINARY)
#if thresh is not None:
#conv
#kernel = np.ones((9,9),np.uint8)
#thresh = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)
#countor
_, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)
if contours != []:
perimeter = []
#max perimeter
for cnt in contours[1:]:
perimeter.append(cv2.arcLength(cnt, True))
if perimeter != []:
maxindex = perimeter.index(max(perimeter))
X = np.array(contours[maxindex + 1], dtype=np.float).reshape(
(contours[maxindex + 1].shape[0], contours[maxindex + 1].shape[2]))
mean, eigenvectors = cv2.PCACompute(X,
mean=np.array([], dtype=np.float),
maxComponents=1)
vec = (-eigenvectors[0][0], -eigenvectors[0][1])
drawAxis(gray, (x, y), vec, (0, 255, 0), R)
def pca_to_grey(image, mask, inverted=True):
x,y,z = image.shape
mat = image.reshape([x*y,z])
filter_array = mask.reshape([x*y])
pointlist = mat[filter_array > 0]
mean, eigenvectors = cv2.PCACompute(pointlist, mean=None)
axis = eigenvectors[0,:].reshape([3])
newmat = np.dot(mat.astype(np.float32) - mean, axis)
newpoints = newmat[filter_array > 0]
Q1, Q3 = np.percentile(newpoints, 25), np.percentile(newpoints,75)
iqr = Q3 - Q1
cut_off_val = iqr * 1.5
lower_bound= Q1 - cut_off_val
non_outliers = [x for x in newpoints if x >= lower_bound]
new_max = max(non_outliers)
new_min = min(newpoints)
np.clip(newpoints, new_min, new_max, out=newpoints)
newpoints = np.asarray(newpoints, dtype=np.float64)
rescale = np.interp(newmat, (np.min(newpoints), np.max(newpoints)), (0,255))
rescale = np.around(rescale).astype(np.uint8)
grey = rescale.reshape([x,y])
if inverted:
grey = cv2.bitwise_not(grey)
pigment = cv2.bitwise_and(grey, mask)
return pigment
def linePtCloud(self, pts3D):
if pts3D !=[]:
mean, eigenVectors = cv2.PCACompute(np.transpose(pts3D), mean=None)
line = np.concatenate((np.ravel(mean), eigenVectors[0, :]), axis=0)
else:
line = np.array([0, 0, 0, 0, 0, 0])
return line
def compute_PCA(image: np.ndarray, display=False) -> tuple:
mat = np.argwhere(image != 0)
mat[:, [0, 1]] = mat[:, [1, 0]]
mat = np.array(mat).astype(np.float32) # have to convert type for PCA
# mean (e. g. the geometrical center)
# and eigenvectors (e. g. directions of principal components)
m, e = cv2.PCACompute(mat, mean=np.array([]))
# now to draw: let's scale our primary axis by 100,
# and the secondary by 50
centre = tuple(m[0])
endpoint1 = tuple(m[0] + e[0] * 100)
endpoint2 = tuple(m[0] + e[1] * 50)
if display:
img_show = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
cv2.circle(img_show, centre, 5, (255, 255, 0))
cv2.line(img_show, centre, endpoint1, (255, 255, 0))
cv2.line(img_show, centre, endpoint2, (255, 255, 0))
show(img_show)
return centre, endpoint1, endpoint2
def template_match(image):
f = open("standard deviation.txt", "a")
global template_image
res = cv2.matchTemplate(image, template_image, cv2.TM_CCOEFF)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)
h, w, _ = template_image.shape
bottom_right = (max_loc[0] + w, max_loc[1] + h)
cv2.rectangle(image, max_loc, bottom_right, 255, 2)
cv2.imshow("image", image)
template_image_new = image[max_loc[1]:max_loc[1] + h,
max_loc[0]:max_loc[0] + w]
manhattan_deviation = np.sum(template_image - template_image_new)
print "Manhattan " + str(manhattan_deviation)
euclidean_deviation = np.sqrt(
np.sum(np.square(template_image - template_image_new)))
print "Euclidean " + str(euclidean_deviation)
standard_deviation = np.sqrt(
np.sum(np.square(template_image - template_image_new)) /
np.size(template_image))
print "Standard " + str(standard_deviation)
mean = np.mean(template_image, axis=0)
mean, eigenVector = cv2.PCACompute(template_image, mean).reshape(1, -1)
print eigenVector
template_image = template_image_new
cv2.imwrite("templates/template_picture" + str(time.time()) + ".jpg",
template_image,
params=[])
f.write(str(standard_deviation) + "\n")
cv2.imshow("image_crop", template_image)
f.close()
return 0
def process(src, dest):
fd = open(os.path.join(src, 't10k-images-idx3-ubyte'), 'rb')
arr = loadData(
fd, 10000
)[:
7000, :] #the test set has 10k samples but to avoid timeout we only take the first 7000
print arr.shape
#perform PCA
mean, eigenvectors = cv2.PCACompute(arr, mean=None, retainedVariance=0.9)
compressed = arr.dot(np.transpose(eigenvectors))
print compressed.shape
#sort images by k-means
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 1000, 0.99)
flags = cv2.KMEANS_RANDOM_CENTERS
compactness, labels, centers = cv2.kmeans(compressed, 10, None, criteria,
10, flags)
print "K-means done"
for i in xrange(10):
os.mkdir(os.path.join(dest, "[" + str(i) + "]"))
for i in xrange(arr.shape[0]):
img = arr[i].reshape((28, 28))
cv2.imwrite(os.path.join(dest, str(labels[i]), str(i) + ".png"), img)
print "Images saved"
def train_pca(train_file, dimension=100):
"""
Performs Principle Component Analysis of the training data and save mean, eigenvectors
"""
print 'PCA for grasp training data...\n'
f_feat = open(train_file, "r")
first_line = f_feat.readline()
tags = first_line.split(',')
idx_f = -1
idx_s = -1
for i in range(len(tags)):
if tags[i].find("feature") == 0:
idx_f = i
if tags[i] == "side":
idx_s = i
assert (idx_f != -1 and idx_s != -1)
features = f_feat.readlines()
feature_listOfList = []
for item in features:
item_split = item.split(',')
#only process right hand; modify this if double hands are to be process
if "left" == item_split[idx_s]:
continue
feature_listOfList.append(item_split[idx_f:len(item_split) - 1])
dataMatrix = np.array(feature_listOfList, dtype=np.float32)
print dataMatrix.shape, dataMatrix.dtype
mean, eigenvectors = cv2.PCACompute(data=dataMatrix,
maxComponents=dimension)
print mean.shape, eigenvectors.shape
return [mean, eigenvectors]
def getPrincipalAxes(imgp):
mean = np.empty((0))
mean, eigen = cv2.PCACompute(imgp, mean)
x = [eigen[0][0], eigen[1][0]]
y = [eigen[0][1], eigen[1][1]]
rotation = getAngle(horizontal, x, False)
return x, y, np.ravel(mean), rotation
def visualize_span_points(name, small, span_points, corners):
display = small.copy()
for i, points in enumerate(span_points):
points = norm2pix(small.shape, points, False)
mean, small_evec = cv2.PCACompute(points.reshape((-1, 2)),
None,
maxComponents=1)
dps = np.dot(points.reshape((-1, 2)), small_evec.reshape((2, 1)))
dpm = np.dot(mean.flatten(), small_evec.flatten())
point0 = mean + small_evec * (dps.min() - dpm)
point1 = mean + small_evec * (dps.max() - dpm)
for point in points:
cv2.circle(display, fltp(point), 3, CCOLORS[i % len(CCOLORS)], -1,
cv2.LINE_AA)
cv2.line(display, fltp(point0), fltp(point1), (255, 255, 255), 1,
cv2.LINE_AA)
cv2.polylines(display, [norm2pix(small.shape, corners, True)], True,
(255, 255, 255))
debug_show(name, 3, 'span points', display)
def extract_features(X, V=None, m=None, num_components=None):
"""Performs feature extraction
This function is used to extract features from the dataset
(currently only PCA is supported).
It can also be used to preprocess a single data sample using some
previously obtained PCA output. This makes it possible to obtain a
set of basis vectors from an entire training set and apply this same
set of basis vectors to a single test sample.
:param X: data (rows=images, cols=pixels)
:param V: PCA basis vectors
:param m: PCA mean vector
:returns: X (rows=samples, cols=features), V, m
"""
if V is None or m is None:
# need to perform PCA from scratch
if num_components is None:
num_components = 50
# cols are pixels, rows are frames
Xarr = np.squeeze(np.array(X).astype(np.float32))
# perform PCA, returns mean and basis vectors
m, V = cv2.PCACompute(Xarr)
# use only the first num_components principal components
V = V[:num_components]
# backproject
for i in range(len(X)):
X[i] = np.dot(V, X[i] - m[0, i])
return X, V, m
def mark_hand_center(self, frame_in, cont):
max_d = 0
pt = (0, 0)
x, y, w, h = cv2.boundingRect(cont)
self.box = (x, y, w, h)
for ind_y in xrange(int(y), int(y + h)):
for ind_x in xrange(int(x), int(x + w)):
dist = cv2.pointPolygonTest(cont, (ind_x, ind_y), True)
if (dist > max_d):
max_d = dist
pt = (ind_x, ind_y)
cv2.circle(frame_in, pt, int(max_d), (0, 0, 255), 2)
sub_thresh = self.mask[y:y + h, x:x + w].copy()
mat = np.argwhere(sub_thresh != 0)
mat[:, [0, 1]] = mat[:, [1, 0]]
mat = np.array(mat).astype(np.float32) #have to convert type for PCA
m, e = cv2.PCACompute(mat, mean=np.array([]))
center = tuple(m[0])
center = tuple([pt[0], pt[1]])
rows, cols = frame_in.shape[:2]
[vx, vy, x, y] = cv2.fitLine(cont, cv2.DIST_L2, 0, 0.01, 0.01)
cv2.line(frame_in, (x - vx * 70, y - vy * 70), (x, y), (0, 255, 0), 2)
endpoint1 = (x - vx * 70, y - vy * 70)
# lefty = int((-x*vy/vx) + y)
# righty = int(((cols-x)*vy/vx)+y)
#cv2.line(frame_in,(cols-1,righty),(0,lefty),(0,255,0),2)
# ec = cv2.fitEllipse(cont)
# (x,y),(MA,ma),angle = ec
# cv2.ellipse(frame_in,ec,(0, 0, 255),1)
# print(angle)
# if angle != 0:
# if angle > 90:
# k = math.tan(math.radians(90 + angle))
# x1 = center[0] - 1/k
# y1 = center[1] - 1
# elif angle>0 and angle < 90:
# #print("hg")
# k = math.tan(math.radians(90 -angle))
# x1 = center[0] - 1/k
# y1 = center[1] - 1
# else:
# x1 = center[0]
# y1 = center[1] - 10
#endpoint1 = tuple([x1, y1])
#endpoint1 = tuple(m[0] + e[0]*10)
#endpoint1 = tuple(m[0] + k*10)
if endpoint1[0] < x:
self.end = (endpoint1, (x, y))
else:
self.end = ((x, y), endpoint1)
#self.end = ((int(endpoint1[0] + x), int(endpoint1[1] + y)), (int(center[0] + x), int(center[1] + y)))
#cv2.circle(frame_in,self.end[0],5,(0,255,255),-1)
#cv2.circle(frame_in,self.end[1],5,(0,255,255),-1)
#print(len(cont))
for [cnt_pts] in cont:
self.cnt_pts.append(distant(cnt_pts, pt))
#print(self.cnt_pts)
return frame_in, pt, max_d
def primaryComponentAnalysis(imageFiltered, imageOriginal, agent):
"""Use primary component analysis to detect the agent's orientation."""
# cv2.CHAIN_APPROX_NONE save all points
# cv2.CHAIN_APPROX_SIMPLE only save key points
img, contours, hierarchy = cv2.findContours(imageFiltered, cv2.RETR_LIST,
cv2.CHAIN_APPROX_NONE)
for i in range(0, len(contours)):
area = cv2.contourArea(contours[i]) # calculate contour area
# Remove small areas (noise) and big areas (the edges of the screen)
if area < 1e2 or 1e5 < area:
continue
cv2.drawContours(imageOriginal, contours, i, (0, 255, 0), 2, 8,
hierarchy, 0)
X = np.array(contours[i], dtype=np.float).reshape(
(contours[i].shape[0],
contours[i].shape[2])) # save contour as float array
# one-dimensioanl Primary Component Analysis
mean, eigenvectors = cv2.PCACompute(X,
mean=np.array([], dtype=np.float),
maxComponents=1)
pt = (mean[0][0], mean[0][1])
vec = (eigenvectors[0][0], eigenvectors[0][1]) # eigen vectors
drawAxis(imageOriginal, pt, vec, (0, 0, 255), 150)
angle = math.atan2(-vec[1], vec[0])
return imageOriginal
def get_angle_pca(detectedObject: np.ndarray) -> float:
# extract the PCA from segmentation object
img_gray = cv2.cvtColor(detectedObject, cv2.IMREAD_GRAYSCALE) # convert to grayscale
# _, thresh = cv2.threshold(img_gray, 255, 1, cv2.THRESH_BINARY_INV)
imag_arr = np.array(img_gray)
mat = np.argwhere(imag_arr == 255)
mat[:, [0, 1]] = mat[:, [1, 0]]
mat = np.array(mat).astype(np.float32) # have to convert type for PCA
m, e = cv2.PCACompute(mat, mean=np.array([]))
center = tuple(m[0])
center = (int(center[0]), int(center[1]))
# endpoint1 = tuple(m[0] + e[0] * 100)
# endpoint1 = (int(endpoint1[0]), int(endpoint1[1]))
endpoint2 = tuple(m[0] + e[1] * 50)
endpoint2 = (int(endpoint2[0]), int(endpoint2[1]))
x = center
y = (center[0], center[1] + 50)
z = endpoint2
b = distance.euclidean(x, y)
c = distance.euclidean(x, z)
a = distance.euclidean(y, z)
cos_alpha = (b * b + c * c - a * a) / (2 * b * c)
pca_angle = float(np.degrees(np.arccos(cos_alpha)))
return pca_angle
def extract_training_data():
# cap = cv2.VideoCapture('stove pics/stove_off_vid.mp4')
cap = cv2.VideoCapture('stove pics/training_off.mp4')
hasFrame, frame = cap.read()
draw_img(resize_img(frame, 50))
# extracting features from the training videos
X0, t0 = image_to_array('stove pics/training_off.mp4', 'off')
# X0, t0 = image_to_array('stove pics/tobii stove off training.mp4', 'off')
X1, t1 = image_to_array('stove pics/training_on.mp4', 'on')
# X1, t1 = image_to_array('stove pics/tobii stove on training.mp4', 'on')
X = np.append(X1, X0, axis=0)
t = np.append(t1, t0, axis=0)
# applying PCA for some reason the accuracy is really high witout PCA
mean, eigenvectors = cv2.PCACompute(X.astype(np.float32),
mean=None,
maxComponents=X.shape[0])
X = (X - mean) @ eigenvectors.T
print(X.shape)
np.savez('PCA parameters', mean=mean, eigenv=eigenvectors)
np.savez("training data and labels", X=X, t=t)
def main():
for v in face:
in_matrix = None
imgcnt = 0
print('Read from: ' + v + ' Directory ')
for f in os.listdir(os.path.join('training/', v)):
imgcnt += 1
print(f)
# Read the image in as a gray level image.
img = cv2.imread(os.path.join('training/', v, f),
cv2.IMREAD_GRAYSCALE)
img_resized = cv2.resize(img, (w, h))
# let's resize them to w * h
vec = img_resized.reshape(w * h)
# stack them up to form the matrix
try:
in_matrix = np.vstack((in_matrix, vec))
except:
in_matrix = vec
# PCA
if in_matrix is not None:
mean, eigenvectors = cv2.PCACompute(
in_matrix,
np.mean(in_matrix, axis=0).reshape(1, -1))
img = unFlatten(mean.transpose(), w,
h) # Reconstruct mean to represent an image
cv2.imwrite('trained/pca_face_' + v + '.png', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def get_pca_all_acts(self, acts):
'''Give three matrices (eigenvectors, eigenvalues, mean face for all PCA on actors) and six matrices (training set alphas, training labels, validation set and its labels, test set and its labels)'''
act_filenames = [act_name for act_name in acts]
train_set = zeros((TRAIN_SIZE * len(acts), IMG_DIM))
vald_set = zeros((VALD_SIZE * len(acts), IMG_DIM))
test_set = zeros((TEST_SIZE * len(acts), IMG_DIM))
train_labels = zeros(TRAIN_SIZE * len(acts))
vald_labels = zeros(VALD_SIZE * len(acts))
test_labels = zeros(TEST_SIZE * len(acts))
i = 0
for act in act_filenames:
train_set[TRAIN_SIZE*i:TRAIN_SIZE*(i+1), :], train_labels[TRAIN_SIZE*i:TRAIN_SIZE*(i+1)], \
vald_set[VALD_SIZE*i:VALD_SIZE*(i+1), :], vald_labels[VALD_SIZE*i:VALD_SIZE*(i+1)], \
test_set[TEST_SIZE*i:TEST_SIZE*(i+1), :], test_labels[TEST_SIZE*i:TEST_SIZE*(i+1)] = self.get_random_imgset(act, i, './'+CROPPED)
i += 1
#V, S, mean_X = pca(train_set)
mean_X, V = cv2.PCACompute(train_set,
np.mean(train_set, axis=0).reshape(1, -1))
mean_X = mean_X.flatten()
return V, mean_X, self.get_alpha_basis(
V, mean_X, train_set
), train_set, train_labels, vald_set, vald_labels, test_set, test_labels
def load_precomputed_pca(train_images, k):
try:
d = np.load('mnist_pca.npz')
mean = d['mean']
eigenvectors = d['eigenvectors']
print('loaded precomputed PCA from mnist_pca.npz')
except:
print('precomputing PCA one time only for train_images...')
ndim = train_images.shape[1]
mean, eigenvectors = cv2.PCACompute(
train_images, mean=None, maxComponents=train_images.shape[1])
print('done\n')
np.savez_compressed('mnist_pca.npz',
mean=mean,
eigenvectors=eigenvectors)
eigenvectors = eigenvectors[:k]
return mean, eigenvectors
def performPCA(images):
# Allocate space for all images in one data matrix. The size of the data matrix is
# ( w * h * c, numImages ) where, w = width of an image in the dataset.
# h = height of an image in the dataset. c is for the number of color channels.
numImages = len(images)
sz = images[0].shape
channels = 1 # grayescale
data = np.zeros((numImages, sz[0] * sz[1] * channels), dtype=np.float32)
# store images as floating point vectors normalized 0 -> 1
for i in range(0, numImages):
image = np.float32(images[i])/255.0
data[i,:] = image.flatten() # N.B. data is stored as rows
# compute the eigenvectors from the stack of image vectors created
mean, eigenVectors = cv2.PCACompute(data, mean=None, maxComponents=args.eigenfaces)
# use the eigenvectors to project the set of images to the new PCA space representation
coefficients = cv2.PCAProject(data, mean, eigenVectors)
# calculate the covariance and mean of the PCA space representation of the images
# (skipping the first N eigenfaces that often contain just illumination variance, default N=3 )
covariance_coeffs, mean_coeffs = cv2.calcCovarMatrix(coefficients[:,args.eigenfaces_to_skip:args.eigenfaces], mean=None, flags=cv2.COVAR_NORMAL | cv2.COVAR_ROWS, ctype = cv2.CV_32F)
return (mean, eigenVectors, coefficients, mean_coeffs, covariance_coeffs)
def getOrientation(pts, img):
sz = len(pts)
data_pts = np.empty((sz, 2), dtype=np.float64)
for i in range(data_pts.shape[0]):
data_pts[i, 0] = pts[i, 0, 0]
data_pts[i, 1] = pts[i, 0, 1]
# Perform PCA analysis
mean = np.empty((0))
mean, eigenvectors = cv.PCACompute(data_pts, mean)
# eigenvalues, eigenvectors = np.linalg.eig(eigenvectors)
#eigenvalues = cv.eigen(eigenvectors)
#np.linalg.eig
# Store the center of the object
cntr = (int(mean[0, 0]), int(mean[0, 1]))
cv.circle(img, cntr, 3, (255, 0, 255), 2)
p1 = (cntr[0] + 0.02 * eigenvectors[0, 0],
cntr[1] + 0.02 * eigenvectors[0, 1])
p2 = (cntr[0] - 0.02 * eigenvectors[1, 0],
cntr[1] - 0.02 * eigenvectors[1, 1])
drawAxis(img, cntr, p1, (0, 255, 0), 1)
drawAxis(img, cntr, p2, (255, 255, 0), 5)
angle = atan2(eigenvectors[0, 1],
eigenvectors[0, 0]) # orientation in radians
return angle, cntr
def keypoints_from_samples(name, small, pagemask, page_outline,
span_points):
all_evecs = np.array([[0.0, 0.0]])
all_weights = 0
for points in span_points:
_, evec = cv2.PCACompute(points.reshape((-1, 2)),
None, maxComponents=1)
weight = np.linalg.norm(points[-1] - points[0])
all_evecs += evec * weight
all_weights += weight
evec = all_evecs / all_weights
x_dir = evec.flatten()
if x_dir[0] < 0:
x_dir = -x_dir
y_dir = np.array([-x_dir[1], x_dir[0]])
pagecoords = cv2.convexHull(page_outline)
pagecoords = pix2norm(pagemask.shape, pagecoords.reshape((-1, 1, 2)))
pagecoords = pagecoords.reshape((-1, 2))
px_coords = np.dot(pagecoords, x_dir)
py_coords = np.dot(pagecoords, y_dir)
px0 = px_coords.min()
px1 = px_coords.max()
py0 = py_coords.min()
py1 = py_coords.max()
p00 = px0 * x_dir + py0 * y_dir
p10 = px1 * x_dir + py0 * y_dir
p11 = px1 * x_dir + py1 * y_dir
p01 = px0 * x_dir + py1 * y_dir
corners = np.vstack((p00, p10, p11, p01)).reshape((-1, 1, 2))
ycoords = []
xcoords = []
for points in span_points:
pts = points.reshape((-1, 2))
px_coords = np.dot(pts, x_dir)
py_coords = np.dot(pts, y_dir)
ycoords.append(py_coords.mean() - py0)
xcoords.append(px_coords - px0)
if DEBUG_LEVEL >= 2:
visualize_span_points(name, small, span_points, corners)
return corners, np.array(ycoords), xcoords
def preprocess_item_sift(img, sift):
keyPoints, descriptors = sift.detectAndCompute(img, None)
print cv2.PCACompute(keyPoints, maxComponents=2)
# V,S,m = pca.pca(keyPoints)
print V
def __computeEigenVectors(self):
print("Computing PCA ", end="... ")
mean, eigenvectors = cv2.PCACompute(self.__trainingDataMatrix,
mean=None)
print("DONE")
self.__mean = mean
self.__eigenVectors = eigenvectors
self.__eigenVectors = np.transpose(self.__eigenVectors)
def pca(X, number_of_components):
mean = np.mean(X, axis=0) / 255
eigenvalues = np.array([])
_, eigenvectors = cv2.PCACompute(X,
mean=None,
maxComponents=number_of_components)
return [mean, eigenvalues, eigenvectors]
def all(input, output):
# adaptive_threshold.py
img = cv2.imread(input,0)
img = cv2.medianBlur(img,5)
img = cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,2)
# erosion-dilation.py
kernel = np.ones((3,3),np.uint8)
img = cv2.dilate(img,kernel,iterations = 1)
img = cv2.erode(img,kernel,iterations = 1)
img = cv2.medianBlur(img,5)
# main_axis2.py
h, w = img.shape
mat = np.argwhere(img != 255)
mat[:, [0, 1]] = mat[:, [1, 0]]
mat = np.array(mat).astype(np.float32)
m, e = cv2.PCACompute(mat, mean = np.array([])) # อ่าน PCA
center = tuple(m[0])
endpoint1 = tuple(m[0] + e[0]*100)
endpoint2 = tuple(m[0] + e[1]*50)
delta0 = endpoint1[0]-center[0]
delta1 = endpoint1[1]-center[1]
angle = math.atan2(delta0, delta1)
angle = angle*180/math.pi
print(angle)
inv = cv2.bitwise_not(img)
rotated = ndimage.rotate(inv, -angle+90)
inv = cv2.bitwise_not(rotated)
img = inv
# auto_crop2.py
points = np.argwhere(img==0)
points = np.fliplr(points)
x, y, w, h = cv2.boundingRect(points)
crop = img[y:y+h, x:x+w]
img = crop
# resize2.py
height = 100
width = int(img.shape[1] * height / img.shape[0])
dim = (width, height)
resize = cv2.resize(img, dim, interpolation = cv2.INTER_AREA)
img = resize
# add_white.py
desired_size = 500
old_size = img.shape[:2]
old_size_int = functools.reduce(lambda sub, ele: sub * 10 + ele, old_size)
top = bottom = left = 0
right = desired_size - old_size[1]
color = [255, 255, 255]
white = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)
img = white
cv2.imwrite(output,img)
def get3dPCA(self, frames):
#vcube = np.empty(shape=self.vCubeDimens,dtype=np.float32) x,y,t = self.vCubeDimens
vcube = np.array(frames,dtype=np.float32)
self.outCount = self.outCount + 1
sliceXY = np.swapaxes(vcube,1,2).reshape(t,y*x,order='F')#.swapaxes(0,1)
sliceXT = np.swapaxes(vcube,0,2).reshape(x,y*t)#.swapaxes(0,1)
sliceYT = np.swapaxes(vcube,0,1).reshape(y,x*t,order='F')#.swapaxes(0,1)
mean1, eigenXY = cv2.PCACompute(sliceXY, None)#,cv2.PCA_DATA_AS_COL)
# optional : write out eigenvectors#eign = copy.deepcopy(eigenXY)
#cv2.normalize(eign, eign, 0, 255, cv2.NORM_MINMAX)
#single = eign[0]
#rolled = np.reshape(single,(-1,x))
#frame = cv2.cvtColor(rolled, cv2.COLOR_GRAY2BGR)
#cv2.imwrite('frames/' + repr(self.outCount) + 'frame.jpg', frames[0]);
#cv2.imwrite('frames/' + repr(self.outCount) + 'pca.jpg', frame);
mean2, eigenXT = cv2.PCACompute(sliceXT, None,cv2.PCA_DATA_AS_COL)
mean3, eigenYT = cv2.PCACompute(sliceYT, None,cv2.PCA_DATA_AS_COL)
return (eigenXY,eigenXT,eigenYT)
def anotherPCA():
global eigenVectors, avg
# mean, eigenvectors2 = cv2.PCACompute(convertArrayToNPArray(setOfImages), np.mean(convertArrayToNPArray(setOfImages), axis=0).reshape(1, -1))
avg, eigenVectors = cv2.PCACompute(
convertArrayToNPArray(setOfImages),
np.mean(convertArrayToNPArray(setOfImages), axis=0).reshape(1, -1))
print("avg,", avg.shape)
print("eigenvectors", eigenVectors.shape)
print("eigenvectors[0]", eigenVectors[0].shape)
def create_descriptors_pca(self, dim=90):
'''
计算描述子pca
:param dim:
:return:
'''
print("start create_descriptors_pca ...")
query = DB.DescriptorModel.select(
DB.DescriptorModel.id,
DB.DescriptorModel.descriptor).tuples().iterator()
features = numpy.array(map(lambda x: [x[0]] + list(x[1]), query))
print("create_descriptors_pca,count=%d,dim=%d" % (len(features), dim))
start = time()
print("build eigenvectors start time %s" % start)
mean, eigenvectors = cv2.PCACompute(features[:, 1:],
None,
maxComponents=dim)
fitted = cv2.PCAProject(features[:, 1:], mean, eigenvectors)
#pca = PCA(n_components=dim)
#fitted = pca.fit_transform(features[:,1:])
print("build eigenvectors cost time %s" % (time() - start))
print("saving data ...")
#scaler = preprocessing.MinMaxScaler()
#pca = scaler.fit_transform(pca)
DB.db.connect()
with DB.db.transaction():
DB.PcaModel.drop_table(fail_silently=True)
DB.PcaModel.create_table()
#res = DB.TrainingResult()
#res.name = "daisy_pca"
#res.data = pca
#res.save()
for i in range(0, len(fitted)):
model = DB.PcaModel()
model.pca = fitted[i]
model.feature = features[i][0]
model.save()
DB.TrainingResult.delete().where(
DB.TrainingResult.name == "pca_mean").execute()
DB.TrainingResult.delete().where(
DB.TrainingResult.name == "pca_eigenvectors").execute()
tr = DB.TrainingResult()
tr.name = "pca_mean"
tr.data = mean
tr.save()
tr = DB.TrainingResult()
tr.name = "pca_eigenvectors"
tr.data = eigenvectors
tr.save()
print("create_descriptors_pca done")
