def store_test_des(dataset): ''' Stores the descriptors for the testing set in one file per object. Each file has a matrix where a row represent a descriptor. ''' # e.g. test = [[bear/img1.jpg, bear/img2.jpg], [cat/img1.jpg, ...], ...] test = dataset.get_test_set() counter = 0 n_files = 30 folders = glob.glob("test/*") for files in test: s = "Getting descriptors in class {0}.".format(counter) print(s) for i in range(n_files): # iteration over files inside a class # if i % step == 0: percentage = (i * 100) / n_files print("Getting SIFT from file {0} of {1} ({2}%) ...".format( i, n_files, percentage)) fname = files[i] test_img = cv2.imread(fname) kp, current_des = descriptors.sift(test_img) # Store current descriptors if "/" in fname: obj_name = fname.split("/")[-1] obj_name = obj_name.split(".")[0] storage_name = folders[counter] + "/" + obj_name + ".mat" else: obj_name = fname.split("\\")[-1] obj_name = obj_name.split(".")[0] storage_name = folders[counter] + "\\" + obj_name + ".mat" data = {"stored": current_des} sio.savemat(storage_name, data) counter += 1
def test_sift(): img_path = glob.glob("dataset/bear/*.JPEG")[0] img = cv2.imread(img_path) kp, des = descriptors.sift(img) img = cv2.drawKeypoints(img, kp, color=(255,0,0)) cv2.imshow("image", img) cv2.waitKey(0) print("descriptors len = {0}".format(len(des))) print("descriptors[0] len = {0}".format(len(des[0]))) print("descriptors[0][:5] = {0}".format(np.array(des[0][:], dtype=np.uint16)))
def test_sift(): img_path = glob.glob("dataset/bear/*.JPEG")[0] img = cv2.imread(img_path) kp, des = descriptors.sift(img) img = cv2.drawKeypoints(img, kp, color=(255, 0, 0)) cv2.imshow("image", img) cv2.waitKey(0) print("descriptors len = {0}".format(len(des))) print("descriptors[0] len = {0}".format(len(des[0]))) print("descriptors[0][:5] = {0}".format( np.array(des[0][:], dtype=np.uint16)))
def get_data_and_labels(self, img_set, test_image, cluster_model, k, des_name, codebook,isTrain, des_option = constants.ORB_FEAT_OPTION): """ Calculates all the local descriptors for an image set and then uses a codebook to calculate the VLAD global descriptor for each image and stores the label with the class of the image. Args: img_set (string array): The list of image paths for the set. codebook (numpy float matrix): Each row is a center and each column is a dimension of the centers. des_option (integer): The option of the feature that is going to be used as local descriptor. Returns: NumPy float matrix: Each row is the global descriptor of an image and each column is a dimension. NumPy float array: Each element is the number of the class for the corresponding image. """ y = [] x = None img_descs = [] for class_number in range(len(img_set)): img_paths = img_set[class_number] step = round(constants.STEP_PERCENTAGE * len(img_paths) / 100) for i in range(len(img_paths)): if (step > 0) and (i % step == 0): percentage = (100 * i) / len(img_paths) img = cv2.imread(img_paths[i]) des,y = descriptors.sift(img,img_descs,y,class_number) """ des : descriptor y : class_number """ isTrain = int(isTrain) X, X_test, y1, testimg_hist, cluster_model = descriptors.cluster_features(des, test_image, cluster_model=KMeans(n_clusters=128)) """ X: histogram of words cluster_model : MiniBatchKMeans testimg_hist : testImage histogram """ """ if isTrain == 1: else: X = descriptors.img_to_vect(des,cluster_model) """ print('X',X.shape,X) y = np.float32(y)[:,np.newaxis] x = np.matrix(X) y1 = np.float32(y1)[:, np.newaxis] x_test = np.matrix(X_test) testimg_h = np.matrix(testimg_hist) return x, y, x_test, y1, testimg_h, cluster_model
def test_vlad(): img = cv2.imread(constants.TESTING_IMG_PATH) option = input("Enter [1] for using ORB features or [2] to use SIFT features.\n") if option == 1: des = descriptors.orb(img) else: des = descriptors.sift(img) des_name = constants.ORB_FEAT_NAME if option == constants.ORB_FEAT_OPTION else constants.SIFT_FEAT_NAME k = 128 codebook_filename = "codebook_{0}_{1}.csv".format(k, des_name) centers = np.loadtxt(codebook_filename, delimiter=constants.NUMPY_DELIMITER) vlad_vector = descriptors.vlad(des, centers) print(vlad_vector) return vlad_vector
def get_data_and_labels(self, img_set, codebook, des_option = constants.ORB_FEAT_OPTION): """ Calculates all the local descriptors for an image set and then uses a codebook to calculate the VLAD global descriptor for each image and stores the label with the class of the image. Args: img_set (string array): The list of image paths for the set. codebook (numpy float matrix): Each row is a center and each column is a dimension of the centers. des_option (integer): The option of the feature that is going to be used as local descriptor. Returns: NumPy float matrix: Each row is the global descriptor of an image and each column is a dimension. NumPy float array: Each element is the number of the class for the corresponding image. """ target = open("result.txt", 'a') y = [] x = None #print len(img_set) #print img_set[0] for class_number in range(len(img_set)): img_paths = img_set[class_number] #print img_paths step = round(constants.STEP_PERCENTAGE * len(img_paths) / 100) for i in range(len(img_paths)): end = img_paths[i].find('.png', 5) target.write(img_paths[i][5:end]+",\n") if (step > 0) and (i % step == 0): percentage = (100 * i) / len(img_paths) print("Calculating global descriptors for image number {0} of {1}({2}%)".format( i, len(img_paths), percentage) ) #print img_paths[i] img = cv2.imread(img_paths[i]) if des_option == constants.ORB_FEAT_OPTION: des = descriptors.orb(img) else: des = descriptors.sift(img) if des is not None: des = nmpy.array(des, dtype=nmpy.float32) vlad_vector = descriptors.vlad(des, codebook) if x is None: x = vlad_vector y.append(class_number) else: x = nmpy.vstack((x, vlad_vector)) y.append(class_number) else: print("Img with None descriptor: {0}".format(img_paths[i])) y = nmpy.float32(y)[:, nmpy.newaxis] x = nmpy.matrix(x) return x, y
def process_dataset(codebook, set_paths): vlad = Vlad(codebook) X = None y = [] i = 0 for class_paths in set_paths: for img_path in class_paths: keypoints, image_descriptors = descriptors.sift(cv2.imread(img_path.replace('\\','/'))) image_vlad = vlad.get_image_vlad(image_descriptors) if X == None: X = image_vlad else: X = np.vstack((X, image_vlad)) y += len(class_paths)*[i] i += 1 return X, y
def test_one_img_classification(): img = cv2.imread("test.jpg") resize_to = 640 h, w, channels = img.shape img = utils.resize(img, resize_to, h, w) des = descriptors.sift(img) k = 128 des_name = "SIFT" codebook_filename = filenames.codebook(k, des_name) codebook = utils.load(codebook_filename) img_vlad = descriptors.vlad(des, codebook) svm_filename = filenames.svm(k, des_name) svm = cv2.SVM() svm.load(svm_filename) result = svm.predict(img_vlad) print("result is {0}".format(result))
def class_descriptors(class_files): class_des = None step = (len(class_files) * 5) / 100 for i in range(len(class_files)): if i % step == 0: percentage = (i * 100) / len(class_files) print("Getting SIFT from image {0} of {1}({2}%) ...".format( i, len(class_files), percentage)) path = class_files[i] img = cv2.imread(path) kp, des = descriptors.sift(img) if class_des is None: class_des = np.array(des, dtype=np.uint16) else: class_des = np.vstack((class_des, np.array(des, dtype=np.uint16))) return class_des
def process_dataset(codebook, set_paths): vlad = Vlad(codebook) X = None y = [] i = 0 for class_paths in set_paths: for img_path in class_paths: keypoints, image_descriptors = descriptors.sift( cv2.imread(img_path.replace('\\', '/'))) image_vlad = vlad.get_image_vlad(image_descriptors) if X == None: X = image_vlad else: X = np.vstack((X, image_vlad)) y += len(class_paths) * [i] i += 1 return X, y
def test_sift(): opt = input( "Choose an option:\n"\ " [0] Write the image in this folder\n"\ " [1] Show image\n" ) n = input("Enter the image number to use.\n") WRITE = (opt == 0) dataset = pickle.load(open("dataset.obj", "rb")) img_path = dataset.get_train_set()[8][n] first_img = cv2.imread(img_path) kp, des = descriptors.sift(first_img) img = cv2.drawKeypoints(first_img, kp) if WRITE: cv2.imwrite("sift.jpg", img) else: cv2.imshow("Keypoints", img) cv2.waitKey()
def get_data_and_labels(self, img_set, codebook, des_option = constants.ORB_FEAT_OPTION): """ Calculates all the local descriptors for an image set and then uses a codebook to calculate the VLAD global descriptor for each image and stores the label with the class of the image. Args: img_set (string array): The list of image paths for the set. codebook (numpy float matrix): Each row is a center and each column is a dimension of the centers. des_option (integer): The option of the feature that is going to be used as local descriptor. Returns: NumPy float matrix: Each row is the global descriptor of an image and each column is a dimension. NumPy float array: Each element is the number of the class for the corresponding image. """ y = [] x = None for class_number in range(len(img_set)): img_paths = img_set[class_number] step = round(constants.STEP_PERCENTAGE * len(img_paths) / 100) for i in range(len(img_paths)): if (step > 0) and (i % step == 0): percentage = (100 * i) / len(img_paths) print("Calculating global descriptors for image number {0} of {1}({2}%)".format( i, len(img_paths), percentage) ) img = cv2.imread(img_paths[i]) if des_option == constants.ORB_FEAT_OPTION: des = descriptors.orb(img) else: des = descriptors.sift(img) if des is not None: des = np.array(des, dtype=np.float32) vlad_vector = descriptors.vlad(des, codebook) if x is None: x = vlad_vector y.append(class_number) else: x = np.vstack((x, vlad_vector)) y.append(class_number) else: print("Img with None descriptor: {0}".format(img_paths[i])) y = np.float32(y)[:, np.newaxis] x = np.matrix(x) return x, y
def store_train_des(filenames, class_name): class_des = None step = (len(filenames) * 5) / 100 for i in range(len(filenames)): path = filenames[i] if i % step == 0: percentage = (i * 100) / len(filenames) print("Getting SIFT from image {0} of {1}({2}%) ...".format( i, len(filenames), percentage)) img = cv2.imread(path) kp, des = descriptors.sift(img) if class_des == None: class_des = np.array(des, dtype=np.uint16) else: class_des = np.vstack((class_des, np.array(des, dtype=np.uint16))) print("descriptors of shape = {0}".format(class_des.shape)) filename = "train/des_" + class_name + ".mat" data = {"stored": class_des} sio.savemat(filename, data)
def store_train_des(filenames, class_name): class_des = None step = (len(filenames) * 5) / 100 for i in range(len(filenames)): path = filenames[i] if i % step == 0: percentage = (i * 100) / len(filenames) print("Getting SIFT from image {0} of {1}({2}%) ...".format( i, len(filenames), percentage ) ) img = cv2.imread(path) kp, des = descriptors.sift(img) if class_des == None: class_des = np.array(des, dtype=np.uint16) else: class_des = np.vstack((class_des, np.array(des, dtype=np.uint16))) print("descriptors of shape = {0}".format(class_des.shape)) filename = "train/des_" + class_name + ".mat" data = {"stored": class_des} sio.savemat(filename, data)
def store_test_des(dataset): ''' Stores the descriptors for the testing set in one file per object. Each file has a matrix where a row represent a descriptor. ''' # e.g. test = [[bear/img1.jpg, bear/img2.jpg], [cat/img1.jpg, ...], ...] test = dataset.get_test_set() counter = 0 n_files = 30 folders = glob.glob("test/*") for files in test: s = "Getting descriptors in class {0}.".format(counter) print(s) for i in range(n_files): # iteration over files inside a class # if i % step == 0: percentage = (i * 100) / n_files print( "Getting SIFT from file {0} of {1} ({2}%) ...".format( i, n_files, percentage ) ) fname = files[i] test_img = cv2.imread(fname) kp, current_des = descriptors.sift(test_img) # Store current descriptors if "/" in fname: obj_name = fname.split("/")[-1] obj_name = obj_name.split(".")[0] storage_name = folders[counter] + "/" + obj_name + ".mat" else: obj_name = fname.split("\\")[-1] obj_name = obj_name.split(".")[0] storage_name = folders[counter] + "\\" + obj_name + ".mat" data = {"stored": current_des} sio.savemat(storage_name, data) counter += 1
def knn_kdtree(dataset): # n_classes = len(dataset.get_classes()) n_classes = 5 des_files = glob.glob("train/*.mat") predictions = [] counter = 0 # Get KDTrees with the descriptors of the training set print("Getting sample of the descriptors for classes in their KD-trees") classes_trees = [] start = time.time() for c in range(n_classes): fname = des_files[c] print("fname = {0}".format(fname)) data = sio.loadmat(fname) class_des = data["stored"] sample_size = 1000 current_sample = utils.random_sample(class_des, sample_size) tree = spatial.KDTree(current_sample) classes_trees.append(tree) # cleaning this variable class_des = None end = time.time() elapsed_time = utils.humanize_time(end - start) print("Elapsed time building KDTrees {0}".format(elapsed_time)) for test_files in dataset.get_test_set(): # Using only the first n_files objects of the test set for each class n_files = 15 # TESTING! # if counter == n_classes: break ############ print("Starting to predict the test set of class {0}.".format(counter)) # iteration over classes predictions.append([]) # The i-th element of this list has the descriptors for the i-th image; # all the images are in the same class-folder test_des_list = [] # step = (len(test_files) * 5) / 100 # for i in range(len(test_files)): for i in range(n_files): # iteration over files inside a class # if i % step == 0: # percentage = (i * 100) / len(test_files) # print( # "Getting SIFT from file {0} of {1} ({2}%) ...".format( # i, len(test_files), percentage # ) # ) fname = test_files[i] test_img = cv2.imread(fname) kp, current_des = descriptors.sift(test_img) test_des_list.append(current_des) # We can't add more descriptors because it would be too expensive in RAM # distances = np.zeros((len(test_files), n_classes)) distances = np.zeros((n_files, n_classes)) for c in range(n_classes): # for img_index in range(len(test_files)): for img_index in range(n_files): des = test_des_list[img_index] print("Getting dist for img index = {0}".format(img_index)) start = time.time() current_dists, ids = classes_trees[c].query(des) distances[img_index][c] = sum(current_dists) end = time.time() s = "Seconds getting distances {0} for {1} descriptors".format( (end - start), len(des)) print(s) # for img_index in range(len(test_files)): for img_index in range(n_files): predictions[-1].append(np.argmin(distances[img_index])) counter += 1 return predictions