def feature_matching(images,base_dir): for j in range(len(images)): filenames = images[j][50] featurename1 = base_dir+ '/features/' + str(j) + '_' + filenames.split('/')[-1] p1, f1, c1= load_features(config,featurename1+'.npz') index1 = cv2.flann_Index()# if context.OPENCV3 else cv2.flann_Index() index1.load(f1,featurename1+'.flann') im1_matches = {} for match in range(len(images)): if match == j: continue image_name = str(match) + '_' + filenames.split('/')[-1] featurename2 = base_dir+ '/features/' + str(match) + '_' + filenames.split('/')[-1] p2, f2, c2= load_features(config,featurename2+'.npz') index2 = cv2.flann_Index()# if context.OPENCV3 else cv2.flann_Index() index2.load(f2,featurename2+'.flann') matches = matching.match_symmetric(f1, index1, f2, index2, config) rmatches = matching.robust_match_fundamental(p1, p2, matches,config) im1_matches[image_name] = rmatches matches_path = base_dir+ '/matches/' io.mkdir_p(matches_path) with gzip.open(os.path.join(matches_path, '{}_matches.pkl.gz'.format(str(j) + '_' + filenames.split('/')[-1] )), 'wb') as fout: pickle.dump(im1_matches, fout)
def findKeyPoints(img, template, distance=200): """ find key points in image """ # SIFT FEATURE_DETECTOR = "SIFT" #"SURF" # "SIFT" detector = cv2.FeatureDetector_create(FEATURE_DETECTOR) descriptor = cv2.DescriptorExtractor_create(FEATURE_DETECTOR) #print(dir(descriptor)) #print descriptor.paramType() skp = detector.detect(img) skp, sd = descriptor.compute(img, skp) if sd == None: return None, None tkp = detector.detect(template) tkp, td = descriptor.compute(template, tkp) flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(sd, flann_params) idx, dist = flann.knnSearch(td, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] skp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: skp_final.append(skp[i]) flann = cv2.flann_Index(td, flann_params) idx, dist = flann.knnSearch(sd, 1, params={}) del flann #print descriptor.getParams() dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] tkp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: tkp_final.append(tkp[i]) return skp_final, tkp_final
def findKeyPoints(img, template, distance=200): """ find key points in image """ # SIFT FEATURE_DETECTOR = "SIFT" #"SURF" # "SIFT" detector = cv2.FeatureDetector_create(FEATURE_DETECTOR) descriptor = cv2.DescriptorExtractor_create(FEATURE_DETECTOR) #print(dir(descriptor)) #print descriptor.paramType() skp = detector.detect(img) skp, sd = descriptor.compute(img, skp) if sd == None: return None, None tkp = detector.detect(template) tkp, td = descriptor.compute(template, tkp) flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(sd, flann_params) idx, dist = flann.knnSearch(td, 1, params={}) del flann dist = dist[:, 0] / 2500.0 dist = dist.reshape(-1, ).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] skp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: skp_final.append(skp[i]) flann = cv2.flann_Index(td, flann_params) idx, dist = flann.knnSearch(sd, 1, params={}) del flann #print descriptor.getParams() dist = dist[:, 0] / 2500.0 dist = dist.reshape(-1, ).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] tkp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: tkp_final.append(tkp[i]) return skp_final, tkp_final
def findKeyPoints(img, template, distance=20): detector = cv2.FeatureDetector_create("SIFT") descriptor = cv2.DescriptorExtractor_create("SIFT") skp = detector.detect(img) skp, sd = descriptor.compute(img, skp) tkp = detector.detect(template) tkp, td = descriptor.compute(template, tkp) ''' gray1 = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) gray2 = cv2.cvtColor(template,cv2.COLOR_BGR2GRAY) #SIFT detector = cv2.SIFT(1000) skp, sd = detector.detectAndCompute(gray1,None) tkp, td = detector.detectAndCompute(gray2,None) ''' flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(sd, flann_params) idx, dist = flann.knnSearch(td, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] skp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: skp_final.append(skp[i]) flann = cv2.flann_Index(td, flann_params) idx, dist = flann.knnSearch(sd, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] tkp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: tkp_final.append(tkp[i]) return skp_final, tkp_final
def findKeyPoints(img, template, distance=20): detector = cv2.FeatureDetector_create("SIFT") descriptor = cv2.DescriptorExtractor_create("SIFT") skp = detector.detect(img) skp, sd = descriptor.compute(img, skp) tkp = detector.detect(template) tkp, td = descriptor.compute(template, tkp) ''' gray1 = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) gray2 = cv2.cvtColor(template,cv2.COLOR_BGR2GRAY) #SIFT detector = cv2.SIFT(1000) skp, sd = detector.detectAndCompute(gray1,None) tkp, td = detector.detectAndCompute(gray2,None) ''' flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(sd, flann_params) idx, dist = flann.knnSearch(td, 1, params={}) del flann dist = dist[:, 0] / 2500.0 dist = dist.reshape(-1, ).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] skp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: skp_final.append(skp[i]) flann = cv2.flann_Index(td, flann_params) idx, dist = flann.knnSearch(sd, 1, params={}) del flann dist = dist[:, 0] / 2500.0 dist = dist.reshape(-1, ).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] tkp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: tkp_final.append(tkp[i]) return skp_final, tkp_final
def findKeyPoints(img, template, maxdist=200): import cv2 import numpy as np import itertools import sys detector = cv2.FeatureDetector_create("FAST") descriptor = cv2.DescriptorExtractor_create("SIFT") skp = detector.detect(img) skp, sd = descriptor.compute(img, skp) tkp = detector.detect(template) tkp, td = descriptor.compute(template, tkp) flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(sd, flann_params) idx, dist = flann.knnSearch(td, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] skp_final = [] for i, dis in itertools.izip(idx, dist): if dis < maxdist: skp_final.append(skp[i]) flann = cv2.flann_Index(td, flann_params) idx, dist = flann.knnSearch(sd, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] tkp_final = [] for i, dis in itertools.izip(idx, dist): if dis < maxdist: tkp_final.append(tkp[i]) return skp_final, tkp_final
def match_flann(desc1, desc2, r_threshold = 0.6): flann = cv2.flann_Index(desc2, flann_params) idx2, dist = flann.knnSearch(desc1, 2, params = {}) # bug: need to provide empty dict mask = dist[:,0] / dist[:,1] < r_threshold idx1 = np.arange(len(desc1)) pairs = np.int32( zip(idx1, idx2[:,0]) ) return pairs[mask]
def match_lowe(feature1,feature2): FLANN_INDEX_KDTREE = 1 flann_params = dict(algorithm=FLANN_INDEX_KDTREE, tree=4) flann = cv2.flann_Index(feature1, flann_params) idx, dist = flann.knnSearch(feature2, 2, params={}) good1 = dist[:, 0] < dist[:, 1] * 0.8 * 0.8 matches_good1 = zip(idx[good1, 0], good1.nonzero()[0]) #(a, b) = np.array(matches_good, dtype=int) flann = cv2.flann_Index(feature2, flann_params) idx, dist = flann.knnSearch(feature1, 2, params={}) good2 = dist[:, 0] < dist[:, 1] * 0.8 * 0.8 matches_good2 = zip(idx[good2, 0], good2.nonzero()[0]) matches1 = [(a, b) for a, b in np.array(matches_good1, dtype=int)] matches2 = [(b, a) for a, b in np.array(matches_good2, dtype=int)] matches = set(matches1).intersection(matches2) return np.array(list(matches),dtype=int)
def match_flann(desc1, desc2, r_threshold=0.5): 'Finds strong corresponding features in the two given vectors.' ## Adapted from <http://stackoverflow.com/a/8311498/72470>. if len(desc1) == 0 or len(desc2) == 0: print "No features passed into match_flann" return [] ## Build a kd-tree from the second feature vector. FLANN_INDEX_KDTREE = 1 # bug: flann enums are missing flann = cv2.flann_Index(desc2, { 'algorithm': FLANN_INDEX_KDTREE, 'trees': 4 }) ## For each feature in desc1, find the two closest ones in desc2. (idx2, dist) = flann.knnSearch(desc1, 2, params={}) # bug: need empty {} ## Create a mask that indicates if the first-found item is sufficiently ## closer than the second-found, to check if the match is robust. mask = dist[:, 0] / dist[:, 1] < r_threshold ## Only return robust feature pairs. idx1 = np.arange(len(desc1)) pairs = np.int32(zip(idx1, idx2[:, 0])) return [(i, j) for (i, j) in pairs[mask]]
def build(self, image_names, cv_train_images): self.flann_index = cv2.flann_Index() self.train_images_names = [] self.train_images_descriptors = None self.index_list = [] for idx in range(len(image_names)): train_image = cv_train_images[idx] train_keypoints = self.feature_algorithm.detect(train_image, None) if not train_keypoints: print("Image: \"" + image_names[idx] + "\" is too simple for the FLANN index.") continue (train_keypoints, train_descriptors) = self.feature_algorithm.compute( train_image, train_keypoints) self.train_images_names.append(image_names[idx]) if self.train_images_descriptors is not None: self.train_images_descriptors = np.concatenate( (self.train_images_descriptors, train_descriptors)) else: self.train_images_descriptors = train_descriptors descriptors_size = train_descriptors.shape[0] self.index_list.extend([idx] * descriptors_size) self.flann_index.build(self.train_images_descriptors, params=self.flann_index_params)
def load_feature_index(self, image, features): try: index = cv2.flann_Index() except: index = cv2.flann.Index() index.load(features, self.__feature_index_file(image)) return index
def kmSIFTMAtches(descriptors_dst, descriptors_src, knn=5): """ **Definition**: kmSIFTMAtches(descriptors_dst, descriptors_src, knn = 5) Computes the matches between two different sets of SIFT descriptors. Specifically, \ it computes the matches from *descriptors_src* to *descriptors_dst* and find the *knn* \ best matches. **Inputs**: * descriptors_dst: set of descriptors **to** match. * descriptors_src: set of descriptors **from** which the matching process is performed. * knn (optional): default *5*. *knn* denotes how many matches betweent the \ two sets of descriptors will be computed. **Outputs**: * idx: an *number_of_descriptors_src x knn* matrix. The i-th row contains \ the *knn* nearest neigbors for descriptor i of descriptors_src set. * dist: an *number_of_descriptors_src x knn* matrix. The i-th row contains \ the distances to the *knn* nearest neigbors for descriptor i of descriptors_src set. """ flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(descriptors_dst, flann_params) idx, dist = flann.knnSearch(descriptors_src, knn, params={}) del flann return idx, dist
def grid_match(points, directions=4): """returns index to neighbors for each point in grid""" flann = cv2.flann_Index() flann.build(points, {'algorithm': 1, 'trees': 1}) best_score, best_result = -float("inf"), None for m in range(len(points)): origin = points[m:m + 1, :] # neighbors[m, i] = n means that neighbor of points[m] in directions[i] is points[n] # last row in the result array represents a "no match" point result = -np.ones((points.shape[0] + 1, directions), np.int32) score = 0 for i, n in enumerate( flann.knnSearch(origin, directions + 1)[0].T[1:]): target = points[n] cv2.arrowedLine(img, (round(origin[0, 0]), round(origin[0, 1])), (round(target[0, 0]), round(target[0, 1])), (50, 50, 200)) shifted = points + (target - origin) indices, distances = flann.knnSearch(shifted, 1) indices[distances > scale] = -1 result[indices[:, 0], i] = np.arange(len(indices)) score += sum(indices >= 0) score -= sum( sum(result[:, i] == result[:, j]) for i in range(1, 4) for j in range(i)) if score > best_score: best_score, best_result = score, result return best_result[:-1]
def findKeyPointsDist(tkp, td, skp, sd, maxdist=200): detector = cv2.FeatureDetector_create("FAST") descriptor = cv2.DescriptorExtractor_create("SIFT") flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(sd, flann_params) idx, dist = flann.knnSearch(td, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] skp_final = [] skp_final_dist = [] for i, dis in itertools.izip(idx, dist): if dis <= maxdist: skp_final.append(skp[i]) skp_final_dist.append(dis) return skp_final, skp_final_dist
def match_flann(desc1, desc2, r_threshold = 0.6): FLANN_INDEX_KDTREE = 1 flann = cv2.flann_Index(desc2, dict(algorithm = FLANN_INDEX_KDTREE, trees = 4)) idx2, dist = flann.knnSearch(desc1, 2, params = {}) # bug: need to provide empty dict mask = dist[:,0] / dist[:,1] < r_threshold idx1 = np.arange(len(desc1)) pairs = np.int32( zip(idx1, idx2[:,0]) ) return pairs[mask]
def findKeyPoints(img, template, distance=200): detector = cv2.FeatureDetector_create("SIFT") descriptor = cv2.DescriptorExtractor_create("SIFT") skp = detector.detect(img) skp, sd = descriptor.compute(img, skp) tkp = detector.detect(template) tkp, td = descriptor.compute(template, tkp) flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(sd, flann_params) idx, dist = flann.knnSearch(td, 1, params={}) #idx, dist = RandomForestClassifier(td,n_estimators=10,max_depth=10) del flann dist = dist[:, 0] / 2500.0 dist = dist.reshape(-1, ).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] skp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: skp_final.append(skp[i]) flann = cv2.flann_Index(td, flann_params) idx, dist = flann.knnSearch(sd, 1, params={}) del flann dist = dist[:, 0] / 2500.0 dist = dist.reshape(-1, ).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] tkp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: tkp_final.append(tkp[i]) return skp_final, tkp_final
def findKeyPoints(img, template, distance=200): detector = cv2.FeatureDetector_create("SIFT") descriptor = cv2.DescriptorExtractor_create("SIFT") skp = detector.detect(img) skp, sd = descriptor.compute(img, skp) tkp = detector.detect(template) tkp, td = descriptor.compute(template, tkp) flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(sd, flann_params) idx, dist = flann.knnSearch(td, 1, params={}) #idx, dist = RandomForestClassifier(td,n_estimators=10,max_depth=10) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] skp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: skp_final.append(skp[i]) flann = cv2.flann_Index(td, flann_params) idx, dist = flann.knnSearch(sd, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] tkp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: tkp_final.append(tkp[i]) return skp_final, tkp_final
def findKeyPoints(im, ref, distance=200): detector = cv2.SIFT() descriptor = cv2.DescriptorExtractor_create("SIFT") im_kp = detector.detect(im) im_kp, im_d = descriptor.compute(im, im_kp) ref_kp = detector.detect(ref) ref_kp, ref_d = descriptor.compute(ref, ref_kp) flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(im_d, flann_params) idx, dist = flann.knnSearch(ref_d, 1, params={}) del flann dist = dist[:, 0] / 2500.0 dist = dist.reshape(-1, ).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] im_kp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: im_kp_final.append(im_kp[i]) flann = cv2.flann_Index(ref_d, flann_params) idx, dist = flann.knnSearch(im_d, 1, params={}) del flann dist = dist[:, 0] / 2500.0 dist = dist.reshape(-1, ).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] ref_kp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: ref_kp_final.append(ref_kp[i]) return im_kp_final, ref_kp_final
def __init__(self, desc, method): method_to_option = {"SURF":1, "SIFT":1,"FAST":1,"ORB":0} self._option = method_to_option[method] if self._option == self.FLANN_INDEX_LININD: nd = desc.view(np.float32).copy() desc = nd options = [{'algorithm': self.FLANN_INDEX_LININD}, {'algorithm': self.FLANN_INDEX_KDTREE, 'trees': 4}] self._flann = cv2.flann_Index(desc, options[method_to_option[method]])
def load(self, directory): with open(directory + "/matcher.bin", "rb") as infile: input_obj = pickle.load(infile) self.flann_index = cv2.flann_Index() self.train_images_names = input_obj["names"] self.train_images_descriptors = input_obj["descriptors"] self.index_list = input_obj["index_list"] self.flann_index.build(self.train_images_descriptors, params=self.flann_index_params)
def match_flann(desc1, desc2, r_threshold = 0.06): FLANN_INDEX_KDTREE = 1 flann = cv2.flann_Index(desc2, {'algorithm': FLANN_INDEX_KDTREE, 'trees': 4}) (idx2, dist) = flann.knnSearch(desc1, 2, params={}) # bug: need empty {} mask = dist[:,0] / dist[:,1] < r_threshold idx1 = np.arange(len(desc1)) pairs = np.int32(zip(idx1, idx2[:,0])) return pairs[mask]
def createTargetFeatures(self,image,rect): #extract features using suf and train kmeans matcher, run this on every frame #kps = self.surf.detect(image) #self.FLANN = cv2.flann_Index(kps, self.FLANN_params) kp,des = self.findFeatures(image,USE_SIFT_FT) points, descs = [], [] descs = np.uint8(descs) self.FlannMatcher.add([descs]) self.FlannMatcher2 = cv2.flann_Index(des,self.FLANN_params) track = PlanarTarget(image = image, rect=rect, keypoints = kp, descrs=descs, data=None) self.toTrack.append(track)
def find_key_points(img, template): detector = cv2.FeatureDetector_create('SIFT') descriptor = cv2.DescriptorExtractor_create('SIFT') img_key_points = detector.detect(img) img_key_points, img_descriptors = descriptor.compute(img, img_key_points) template_key_points = detector.detect(template) template_key_points, template_descriptors = descriptor.compute(template, template_key_points) flann_params = {'trees': 4, 'algorithm': 1} flann = cv2.flann_Index(img_descriptors, flann_params) idx, dist = flann.knnSearch(template_descriptors, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] skp_final = [] for i, dis in itertools.izip(idx, dist): if dis < SIFT_DISTANCE: skp_final.append(img_key_points[i]) flann = cv2.flann_Index(template_descriptors, flann_params) idx, dist = flann.knnSearch(img_descriptors, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] tkp_final = [] for i, dis in itertools.izip(idx, dist): if dis < SIFT_DISTANCE: tkp_final.append(template_key_points[i]) return skp_final, tkp_final
def findKeyPointsEps(kp1, d1, kp2, d2, epsilon=1): flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(d1, flann_params) idx, dist = flann.knnSearch(d2, 2, params={}) kp1_result = [] kp2_result = [] for i in xrange(len(kp1)): if dist[i][0] / dist[i][1] < epsilon: kp1_result.append(kp1[idx[i][0]]) kp2_result.append(kp2[i]) return kp1_result, kp2_result
def main(dim, db_size, q_size, knn, FLANN_INDEX_ALGO): print("Dimension : {0}".format(dim)) ####### Utilisation flann # - les matrices descripteurs ou requetes doivent etre du type 'np.float32' # - le vecteur requete doit etre correctement formate : qdesc.shape = (1, desc_dim) # -> reshape # distance (a,b) calculee par knnSearch = sum (ai-bi)^2 ######## #### Generer aleatoirement une matrice des descripteurs de la base # - randint(100) : distribution uniforme, nombres entiers entre 0 et 100 # - size=(10,5) : 10 descripteurs de dimension 5 mat_desc = np.array(np.random.randint(100, size=(db_size, dim)), dtype=np.float32) #print("Database descriptors : \n{0}".format(mat_desc)) #### Generer un vecteur ou une matrice de vecteurs requete qdesc = np.array(np.random.randint(100, size=(q_size, dim)), dtype=np.float32) #print("Query descriptor : \n{0}".format(qdesc)) ######## Database Descriptors indexing # FLANN parameters # Algorithms # 0 : FLANN_INDEX_LINEAR, # 1 : FLANN_INDEX_KDTREE, start = timer() index_params = dict(algorithm=FLANN_INDEX_ALGO) # for linear search #index_params = dict(algorithm = FLANN_INDEX_ALGO, trees = 5) # for kdtree search ### OpenCV 3 fl = cv2.flann_Index(mat_desc, index_params) end = timer() print("Indexing time: {0}".format(end - start)) ######## Query search start = timer() #search_params = dict(checks=50) idx, dist = fl.knnSearch(qdesc, knn, params={}) end = timer() print("Search time: {0}".format(end - start)) #print idx.shape #print("indices \n{0}".format(idx)) #print("distances \n{0}".format(dist)) print("Distance to neareast neighbor = {0}".format(dist[0][0])) print("Distance to farthest neighbor = {0}".format(dist[0][db_size - 1])) print("Ratio 1-nn and 2-nn = {0}".format(dist[0][0] / dist[0][1])) print("Ratio 1-nn and N-nn = {0}".format(dist[0][0] / dist[0][db_size - 1]))
def match_template(imagename, templatename, threshold, cutoff): img = cv2.imread(imagename) template = cv2.imread(templatename) [kpi, di] = detect_keypoints(imagename, threshold) [kpt, dt] = detect_keypoints(templatename, threshold) flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(np.asarray(di, np.float32), flann_params) idx, dist = flann.knnSearch(np.asarray(dt, np.float32), 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] kpi_cut = [] for i, dis in itertools.izip(idx, dist): print ("distance: " + str(dis)) if dis < cutoff: kpi_cut.append(kpi[i]) else: break kpt_cut = [] for i, dis in itertools.izip(indices, dist): print ("distance: " + str(dis)) if dis < cutoff: kpt_cut.append(kpt[i]) else: break h1, w1 = img.shape[:2] h2, w2 = template.shape[:2] nWidth = w1 + w2 nHeight = max(h1, h2) hdif = (h1 - h2) / 2 newimg = np.zeros((nHeight, nWidth, 3), np.uint8) newimg[hdif:hdif+h2, :w2] = template newimg[:h1, w2:w1+w2] = img for i in range(min(len(kpi), len(kpt))): pt_a = (int(kpt[i,1]), int(kpt[i,0] + hdif)) pt_b = (int(kpi[i,1] + w2), int(kpi[i,0])) cv2.line(newimg, pt_a, pt_b, (255, 0, 0)) cv2.imwrite('matches.jpg', newimg)
def __matchUsingFlann(self, desc1, desc2, r_threshold=0.6): ''' Internal flann descriptors matcher in order to find the best match. @param desc1, desc2: SURF features descriptors of currently processed object orientation and the test image. @param r_threshold: Tunnable threshold for kNN normalized distance inside the descriptors space. ''' flann = cv2.flann_Index(desc2, self.flann_params) idx2, dist = flann.knnSearch(desc1, 2, params={}) # bug: need to provide empty dict mask = dist[:, 0] / dist[:, 1] < r_threshold idx1 = np.arange(len(desc1)) pairs = np.int32(zip(idx1, idx2[:, 0])) return pairs[mask]
def findKeyPoints(img, template, distance=200): surf = cv2.SURF(400) skp, sd = surf.detectAndCompute(img,None) tkp, td = surf.detectAndCompute(template,None) flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(sd, flann_params) idx, dist = flann.knnSearch(td, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] skp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: skp_final.append(skp[i]) flann = cv2.flann_Index(td, flann_params) idx, dist = flann.knnSearch(sd, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] tkp_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: tkp_final.append(tkp[i]) return skp_final, tkp_final
def match_template(imagename, templatename, threshold, cutoff): img = cv2.imread(imagename) template = cv2.imread(templatename) [kpi, di] = detect_keypoints(imagename, threshold) [kpt, dt] = detect_keypoints(templatename, threshold) flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(np.asarray(di, np.float32), flann_params) idx, dist = flann.knnSearch(np.asarray(dt, np.float32), 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] kpi_cut = [] for i, dis in itertools.izip(idx, dist): if dis < cutoff: kpi_cut.append(kpi[i]) else: break kpt_cut = [] for i, dis in itertools.izip(indices, dist): if dis < cutoff: kpt_cut.append(kpt[i]) else: break h1, w1 = img.shape[:2] h2, w2 = template.shape[:2] nWidth = w1 + w2 nHeight = max(h1, h2) hdif = (h1 - h2) / 2 newimg = np.zeros((nHeight, nWidth, 3), np.uint8) newimg[hdif:hdif+h2, :w2] = template newimg[:h1, w2:w1+w2] = img for i in range(min(len(kpi), len(kpt))): pt_a = (int(kpt[i,1]), int(kpt[i,0] + hdif)) pt_b = (int(kpi[i,1] + w2), int(kpi[i,0])) cv2.line(newimg, pt_a, pt_b, (255, 0, 0)) cv2.imwrite('matches.jpg', newimg)
def match_flann(desc1, desc2, key1, key2, max_dist = 0.05): "Nearest neighbors matching of sets of features." flann = cv2.flann_Index(desc2, flann_params) idx2, dist = flann.knnSearch(desc1, 5, params = {}) # bug: need to provide empty dict matches = [-1] * len(desc1) for id1, match2 in zip(range(len(desc1)), idx2): best = 100 for i, m in enumerate(match2): if dist[id1][i] > max_dist: continue diff = abs(np.array(key1[id1].pt) - numpy.array(key2[m].pt)) l2 = numpy.linalg.norm(diff) if l2 < best: best = l2 matches[id1] = m break return [(i,m) for i, m in enumerate(matches) if m != -1]
def find_matches(desc, template_descriptors, current_img_descriptors, match_thresh): # print '\n*' # print desc # print len(template_descriptors) # print len(current_img_descriptors) # print '*\n' flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(current_img_descriptors, flann_params) idx, dist = flann.knnSearch(template_descriptors, 2, params={}) del flann matches = np.c_[np.arange(len(idx)), idx[:,0]] pass_filter = dist[:,0]*match_thresh < dist[:,1] matches = matches[pass_filter] return len(matches)
def match_flann(desc1, desc2, r_threshold = 0.12): 'Finds strong corresponding features in the two given vectors.' # Build a kd-tree from the second feature vector. FLANN_INDEX_KDTREE = 1 flann = cv2.flann_Index(desc2, {'algorithm': FLANN_INDEX_KDTREE, 'trees': 4}) # For each feature in desc1, find the two closest ones in desc2. (idx2, dist) = flann.knnSearch(desc1, 2, params={}) # Create a mask that indicates if the first-found item is sufficiently # closer than the second-found, to check if the match is robust. mask = dist[:,0] / dist[:,1] < r_threshold # Only return robust feature pairs. idx1 = np.arange(len(desc1)) pairs = np.int32(zip(idx1, idx2[:,0])) return pairs[mask]
def getKP(img1, img2, threshold): detector = cv2.FeatureDetector_create("SIFT") descriptor = cv2.DescriptorExtractor_create("SIFT") kp1 = detector.detect(img1) kp1, d1 = descriptor.compute(img1, kp1) kp2 = detector.detect(img2) kp2, d2 = descriptor.compute(img2, kp2) flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(d1, flann_params) idx, dist = flann.knnSearch(d2, 2, params={}) kp1_result = [] kp2_result = [] for i in xrange(len(dist)): if dist[i][0] / dist[i][1] < threshold: kp1_result.append(kp1[idx[i][0]]) kp2_result.append(kp2[i]) return kp1_result, kp2_result
def get_nearest_neighbors(desc1, desc2): """ Parameters ---------- desc1, desc2 : lists of descriptors Feature descriptors. Returns -------- points : list of list of pairs For each descriptor in desc1, the n-best matches as an index and distance pair. """ flann = cv2.flann_Index(desc2, flann_params) idx2, dist = flann.knnSearch(desc1, 5, params = {}) return [zip(matches, dists) for matches, dists in izip(idx2, dist)]
def build_flann_index(features, config): FLANN_INDEX_LINEAR = 0 FLANN_INDEX_KDTREE = 1 FLANN_INDEX_KMEANS = 2 FLANN_INDEX_COMPOSITE = 3 FLANN_INDEX_KDTREE_SINGLE = 4 FLANN_INDEX_HIERARCHICAL = 5 FLANN_INDEX_LSH = 6 if features.dtype.type is np.float32: FLANN_INDEX_METHOD = FLANN_INDEX_KMEANS else: FLANN_INDEX_METHOD = FLANN_INDEX_LSH flann_params = dict(algorithm=FLANN_INDEX_METHOD, branching=config.get('flann_branching', 16), iterations=config.get('flann_iterations', 20)) index = cv2.flann_Index(features, flann_params) return index
def search_index(retcfg): q_features = load_features(retcfg['path']['qfeature']) q_namelist = np.loadtxt(retcfg['path']['qlist'], dtype=dict(names=('qname', 'nfeat'), formats=('U100', np.int32))) assert q_features.shape[0] == np.sum(q_namelist['nfeat']), "Inconsistent number of features sum and size of" \ "query features array" norm = retcfg.get('feature', 'norm', fallback=None) db_features = load_features(retcfg['path']['dbfeature']) if norm: db_features = normalize(db_features, norm) fidx = cv2.flann_Index() ifile = get_index_path(retcfg['path']['outdir'], retcfg['DEFAULT']['expname']) fidx.load(db_features, ifile) outdir = retcfg['path']['outdir'] + "queryfiles/" safe_create_dir(outdir) search_type = retcfg['search']['search_type'] knn = retcfg.getint('search', 'knn') rfactor = retcfg.getfloat('search', 'radius_factor') sidx = 0 for qname, n in q_namelist: qfeat = q_features[sidx:sidx+n] if norm: qfeat = normalize(qfeat, norm) matchfpath = "{0:s}{1:s}.matches".format(outdir, qname) distfpath = "{0:s}{1:s}.dist".format(outdir, qname) votes, dists, _ = flann_search(qfeat, fidx, stype=search_type, k=knn, f=rfactor, flib="cv") print(qname, "-> ", sidx, ":", sidx+n) print(votes.shape) print(dists.shape, end="\n---\n") np.save(matchfpath + ".npy", votes) np.save(distfpath + ".npy", dists) sidx += n
def match_flann(desc1, desc2, r_threshold = 0.06): 'Finds strong corresponding features in the two given vectors.' ## Adapted from <http://stackoverflow.com/a/8311498/72470>. ## Build a kd-tree from the second feature vector. FLANN_INDEX_KDTREE = 1 # bug: flann enums are missing flann = cv2.flann_Index(desc2, {'algorithm': FLANN_INDEX_KDTREE, 'trees': 4}) ## For each feature in desc1, find the two closest ones in desc2. (idx2, dist) = flann.knnSearch(desc1, 2, params={}) # bug: need empty {} ## Create a mask that indicates if the first-found item is sufficiently ## closer than the second-found, to check if the match is robust. mask = dist[:,0] / dist[:,1] < r_threshold ## Only return robust feature pairs. idx1 = np.arange(len(desc1)) pairs = np.int32(zip(idx1, idx2[:,0])) return pairs[mask]
def __init__(self, config): ''' 参数 config: 配置 ''' self.__config = config self.__hashFeatures = np.fromfile(config['hashFeatureFilename'], dtype=np.float32) self.__hashFeatures.shape = self.__hashFeatures.size // ImageDb._HASH_FEATURE_DIM, ImageDb._HASH_FEATURE_DIM self.__imageFeatures = np.fromfile(config['imageFeatureFilename'], dtype=np.float32) self.__imageFeatures.shape = self.__imageFeatures.size // ImageDb._IMGE_FEATURE_DIM, ImageDb._IMGE_FEATURE_DIM # self.__imageLabels = np.fromfile(config['imageLabelsFilename'],dtype=np.string_) imageLabels = np.loadtxt(config['labelsFilename'], dtype=np.string_).astype(str).tolist() self.__imageLabels = imageLabels if isinstance( imageLabels, list) else [imageLabels] self.__indexer = cv2.flann_Index(self.__hashFeatures, ImageDb._FLANN_INDEX_PARAM)
def match_flann(desc1, desc2, r_threshold=0.2): 'Finds strong corresponding features in the two given vectors.' ## Build a kd-tree from the second feature vector. FLANN_INDEX_KDTREE = 1 # bug: flann enums are missing flann = cv2.flann_Index(desc2, { 'algorithm': FLANN_INDEX_KDTREE, 'trees': 4 }) ## For each feature in desc1, find the two closest ones in desc2. (idx2, dist) = flann.knnSearch(desc1, 2, params={}) # bug: need empty {} ## Create a mask that indicates if the first-found item is sufficiently ## closer than the second-found, to check if the match is robust. mask = dist[:, 0] / dist[:, 1] < r_threshold ## Only return robust feature pairs. idx1 = np.arange(len(desc1)) pairs = np.int32(zip(idx1, idx2[:, 0])) return pairs[mask]
def flann_matcher(desc1, desc2, threshold=0.6, trees=4): """Returns a 2 by N ndarray of matching indices. Column 0 are indices of first set and col 1 are corresponding indices in second set. Uses the KDTree algorithm in cv2.flann_index. :PARAMETERS: *desc1* --- List of descriptors for first set *desc2* --- List of descriptors for second set **threshold** --- Lower value returns fewer but better matches **trees** --- The number of parallel kd-trees to use. Try [1 to 16]. :RETURNS: 2 by N ndarray, where N is the number of matches. """ flann = cv2.flann_Index(desc2, dict(algorithm=1, trees=trees)) idx2, dist = flann.knnSearch(desc1, 2, params={}) mask = dist[:,0] / dist[:,1] < threshold idx1 = arange(len(desc1)) pairs = int32( zip(idx1, idx2[:,0]) ) return pairs[mask].astype(int).T
def get_sift_descriptors_and_matches(img1, img2): ''' img1 is test image, img2 is template ''' kp1, des1 = SIFT.detectAndCompute(img1, None) kp2, des2 = SIFT.detectAndCompute(img2, None) # FLANN parameters detector = cv2.FeatureDetector_create("SIFT") descriptor = cv2.DescriptorExtractor_create("SIFT") kps1 = detector.detect(img1) kps1, descr1 = descriptor.compute(img1, kps1) kps2 = detector.detect(img2) kps2, descr2 = descriptor.compute(img2, kps2) flann_params = dict(algorithm=1, trees=10) flann = cv2.flann_Index(descr1, flann_params) idx, dist = flann.knnSearch(descr2, 1, params={}) return idx, dist, descr1, descr2
def flann_matcher(desc1, desc2, threshold=0.6, trees=4): """Returns a 2 by N ndarray of matching indices. Column 0 are indices of first set and col 1 are corresponding indices in second set. Uses the KDTree algorithm in cv2.flann_index. :PARAMETERS: *desc1* --- List of descriptors for first set *desc2* --- List of descriptors for second set **threshold** --- Lower value returns fewer but better matches **trees** --- The number of parallel kd-trees to use. Try [1 to 16]. :RETURNS: 2 by N ndarray, where N is the number of matches. """ flann = cv2.flann_Index(desc2, dict(algorithm=1, trees=trees)) idx2, dist = flann.knnSearch(desc1, 2, params={}) mask = dist[:, 0] / dist[:, 1] < threshold idx1 = arange(len(desc1)) pairs = int32(zip(idx1, idx2[:, 0])) return pairs[mask].astype(int).T
def orb(image): votacion = np.zeros((image.shape[0], image.shape[1])) flann = cv2.flann_Index(descs, index_params) imgPrueba = image kp, des = detector.detectAndCompute(imgPrueba, None) idx, dist = flann.knnSearch(des, knn=1) keypnts = [] puntos = [] for i in range(len(idx)): puntos.append(idx[i]) x, y = idx.shape for i in range(x): ind = idx[i] for j in range(y): vector = indxKpV[ind[j]] print(vector) output = imgPrueba.copy() output = cv2.drawKeypoints(imgPrueba, points, output, (0, 255, 0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) return output
def match_flann(desc1, desc2, r_threshold = 0.5): # 'Finds strong corresponding features in the two given vectors.' if len(desc1) == 0 or len(desc2) == 0: print "No features passed into match_flann" return [] ## Build a kd-tree from the second feature vector. FLANN_INDEX_KDTREE = 1 # bug: flann enums are missing flann = cv2.flann_Index(desc2, {'algorithm': FLANN_INDEX_KDTREE, 'trees': 4}) ## For each feature in desc1, find the two closest ones in desc2. (idx2, dist) = flann.knnSearch(desc1, 2, params={}) # bug: need empty {} ## Create a mask that indicates if the first-found item is sufficiently ## closer than the second-found, to check if the match is robust. mask = dist[:,0] / dist[:,1] < r_threshold ## Only return robust feature pairs. idx1 = np.arange(len(desc1)) pairs = np.int32(zip(idx1, idx2[:,0])) return [(i,j) for (i,j) in pairs[mask]]
def flann_key_points(kp1, desc1, desc2, distance): flann_params = dict(algorithm=1, trees=4) flann = cv.flann_Index(desc1, flann_params) idx, dist = flann.knnSearch(desc2, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] key_points_final = [] description_final = [] for i, dis in itertools.izip(idx, dist): if dis < distance: key_points_final.append(kp1[i]) description_final.append(desc1[i]) else: break; return key_points_final, description_final
def _find_neighbours(self, descriptors0, descriptors1, flann0): # return a list of pairs (idx0, idx1) such that descriptors0[idx0] is # very likely to describe the same feature as descriptors1[idx1] # using the same params as the find_obj.cpp demo from opencv flann1 = None if flann0 is None: flann1 = cv2.flann_Index(descriptors1, {'algorithm': FLANN_INDEX_KDTREE, 'trees': 4}) indices, dists = flann1.knnSearch(descriptors0, 2, params={}) needles_number = len(descriptors0) # we did a search of descriptors0 in descriptors1, and we got the # indices in descriptors1 where we can find the elements of # descriptors0, indices are for descriptors1 # descriptors1[indices[i][0]] <-> descriptors0[i] else: print "searching using flann", flann0 needles_number = len(descriptors1) indices, dists = flann0.knnSearch(descriptors1, 2, params={}) # reverse case of above, indices are for descriptors0 # descriptors0[indices[i][0]] <-> descriptors1[i] result = [] result_dists = [] for i, flann_idx, (small_dist, big_dist) in izip(xrange(needles_number), indices, dists): if small_dist < big_dist * 0.6: if flann0 is not None: result.append((flann_idx[0], i)) else: result.append((i, flann_idx[0])) result_dists.append(small_dist) return result, result_dists, flann1
def flann_matcher(desc1, desc2, r_threshold=0.20): 'Finds strong corresponding features in the two given vectors.' ## Adapted from http://stackoverflow.com/a/8311498/72470 ## Build a kd-tree from the second feature vector. FLANN_INDEX_KDTREE = 1 # bug: flann enums are missing flann = cv2.flann_Index(desc2, { 'algorithm': FLANN_INDEX_KDTREE, 'trees': 4 }) ## For each feature in desc1, find the two closest ones in desc2. (idx2, dist) = flann.knnSearch(desc1, 2, params={}) # bug: need empty {} ## Create a mask that indicates if the first-found item is sufficiently ## closer than the second-found, to check if the match is robust. mask = dist[:, 0] / dist[:, 1] < r_threshold ## Only return robust feature pairs. idx1 = np.arange(len(desc1)) pairs = np.int32(zip(idx1, idx2[:, 0])) return pairs[mask] # apply r_threshold mask # pairs = [list(pair) for pair in zipped_pairs] # pairs.sort(key=lambda x: abs(dist[x[0]][0] - dist[x[1]][1])) # sort by closest distances def bf_matcher(desc1, desc2, k=2): bf = cv2.BFMatcher(cv2.NORM_L2) matches = bf.knnMatch(desc1, desc2, k) # Apply ratio test good = [] for m, n in matches: if m.distance < 0.75 * n.distance: good.append((m.queryIdx, m.trainIdx)) return good
print(input_mat_1) print(search_mat) FLANN_INDEX_KDTREE = 1 #从本地加载模型 params = dict(algorithm=FLANN_INDEX_KDTREE, trees=1) def read_yml(): fs = cv2.FileStorage("tree.yml", cv2.FILE_STORAGE_READ) fn = fs.getNode("tree") print(fn.mat()) #建树 kdtree = cv2.flann_Index() kdtree.build(input_mat, params) kdtree.build(input_mat_1, params) print("build tree success") #检索 indices, dists = kdtree.knnSearch(search_mat, 2, params=-1) print("search kdtree") #输出检索结果 print(indices) print(np.sqrt(dists)) #使用numpy下的欧式距离验证结果是否正确 print((np.linalg.norm(input_mat - search_mat, axis=1))) #模型 f = cv2.FileStorage("tree.yml", cv2.FILE_STORAGE_WRITE) f.write("tree", input_mat) f.release()
def main(options, args): global test_bodypart global bodypart_knn_pos, bodypart_knn_neg, bodypart_trained_data_pos, bodypart_vote bodypart_trained_data_pos = SaveClass() bodypart_trained_data_pos = pickle.load(open(options.train_data_p, 'rb')) bodypart_trained_data_neg = SaveClass() bodypart_trained_data_neg = pickle.load(open(options.train_data_n, 'rb')) test_bodypart = bodypart_trained_data_neg.bodypart print "test_bodypart:", test_bodypart bodypart_knn_pos = cv2.flann_Index(bodypart_trained_data_pos.descriptors, dict(algorithm=1, trees=4)) bodypart_knn_neg = cv2.flann_Index(bodypart_trained_data_neg.descriptors, dict(algorithm=1, trees=4)) bodypart_vote = np.zeros( (2 * options.vote_patch_size + 1, 2 * options.vote_patch_size + 1, 1), np.float) for x in range(-options.vote_patch_size, options.vote_patch_size + 1): for y in range(-options.vote_patch_size, options.vote_patch_size + 1): bodypart_vote[y + options.vote_patch_size, x + options.vote_patch_size] = 1.0 + np.exp( -0.5 * (x * x + y * y) / (np.square(options.vote_sigma))) / ( options.vote_sigma * np.sqrt(2 * np.pi)) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind(("", options.socket_port)) sock.listen(1) conn, addr = sock.accept() conn.setblocking(1) print 'Connected by', addr while 1: data = conn.recv(unpacker_header.size) header = unpacker_header.unpack(data) packet = {} packet["version"] = header[0] assert packet["version"] == "01" packet["size"] = header[1] if (options.verbosity >= 1): print "packet version:", packet["version"] print "packet size:", packet["size"] data = conn.recv(unpacker_list_header.size) list_header = unpacker_list_header.unpack(data) packet["list"] = {} packet["list"]["version"] = list_header[0] assert packet["list"]["version"] == "00" packet["list"]["frame_index"] = list_header[1] packet["list"]["length"] = list_header[2] thresh = list_header[3] if (options.verbosity >= 1): print "list version:", packet["list"]["version"] print "list frame_index:", packet["list"]["frame_index"] print "list length:", packet["list"]["length"] ack_message = '{ "received" : "' + str(packet["list"]["frame_index"]) frame_vote_max = -1 bodypart_coords_est = {} for i in range(0, packet["list"]["length"]): data = conn.recv(unpacker_image_header.size) header_data = unpacker_image_header.unpack(data) image_header = {} image_header["version"] = header_data[0] assert image_header["version"] == "01" image_header["rows"] = header_data[1] image_header["cols"] = header_data[2] image_header["crop_x"] = header_data[3] image_header["crop_y"] = header_data[4] if (options.verbosity >= 1): print "image header version:", image_header["version"] print "image header num rows:", image_header["rows"] print "image header num cols:", image_header["cols"] print "image header origin-x-coord:", image_header["crop_x"] print "image header origin-y-coord:", image_header["crop_y"] image_buffer_size = image_header["rows"] * image_header["cols"] data = bytearray(image_buffer_size) view = memoryview(data) toread = image_buffer_size while toread: nbytes = conn.recv_into(view, toread) view = view[nbytes:] toread -= nbytes if (options.verbosity >= 1): print len(data) image_buffer = np.frombuffer(data, dtype='uint8') frame = image_buffer.reshape( (image_header["rows"], image_header["cols"])) bodypart_vote_map = np.zeros( (np.shape(frame)[0], np.shape(frame)[1], 1), np.float) if (options.display_level >= 2): display_voters = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR) ack_message += " " + str(image_header["rows"]) + "x" + str( image_header["cols"]) kp_frame, desc_frame = surf.detectAndCompute(frame, None) if desc_frame == None: print "skipped frame: ", packet["list"]["frame_index"] continue for h, desc in enumerate(desc_frame): desc = np.array(desc, np.float32).reshape((1, 128)) r_pos, d_pos = bodypart_knn_pos.knnSearch( desc, 1, params=dict(checks=8)) r_neg, d_neg = bodypart_knn_neg.knnSearch( desc, 1, params=dict(checks=8)) relative_distance = d_pos - d_neg if (relative_distance <= thresh): a = np.pi * kp_frame[h].angle / 180.0 R = np.array([[np.cos(a), -np.sin(a)], [np.sin(a), np.cos(a)]]) p = kp_frame[h].pt + np.dot( R, bodypart_trained_data_pos.votes[r_pos]) x, y = p if (not (x <= options.vote_patch_size or x >= np.shape(frame)[1] - options.vote_patch_size or y <= options.vote_patch_size or y >= np.shape(frame)[0] - options.vote_patch_size)): bodypart_vote_map[y - options.vote_patch_size:y + options.vote_patch_size + 1, x - options.vote_patch_size:x + options.vote_patch_size + 1] += bodypart_vote if (options.display_level >= 2): cv2.circle(display_voters, (int(x), int(y)), 4, (0, 0, 255), thickness=-1) if (options.display_level >= 2): display_voters = cv2.resize(display_voters, (0, 0), fx=0.5, fy=0.5) cv2.imshow("voters", display_voters) vote_max = np.amax(bodypart_vote_map) if (vote_max > options.vote_threshold and vote_max > frame_vote_max): frame_vote_max = vote_max vote_max_loc = np.array( np.where(bodypart_vote_map == vote_max)) vote_max_loc = vote_max_loc[:, 0] bodypart_coords_est["conf"] = vote_max bodypart_coords_est["x"] = int(vote_max_loc[1]) + int( image_header["crop_x"]) bodypart_coords_est["y"] = int(vote_max_loc[0]) + int( image_header["crop_y"]) if (options.display_level >= 1): display_vote_map = np.array( cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR).copy(), np.float) display_vote_map /= 255.0 bodypart_vote_map /= np.amax(bodypart_vote_map) display_vote_map[:, :, 2] = bodypart_vote_map[:, :, 0] if ("x" in bodypart_coords_est): cv2.circle( display_vote_map, (bodypart_coords_est["x"], bodypart_coords_est["y"]), 4, (0, 255, 255), thickness=-1) display_vote_map = cv2.resize(display_vote_map, (0, 0), fx=0.5, fy=0.5) cv2.imshow("voters", display_vote_map) if ("x" in bodypart_coords_est): ack_message += '" , "detections" : [ { "frame_index" : ' + str( packet["list"]["frame_index"] ) + ' , "test_bodypart" : "' + test_bodypart + '" , "coord_x" : ' + str( bodypart_coords_est["x"]) + ' , "coord_y" : ' + str( bodypart_coords_est["y"] ) + ' , "conf" : ' + "{:.2f}".format( bodypart_coords_est["conf"]) + ' } ] }' else: ack_message += '" , "detections" : [ { "frame_index" : ' + str( packet["list"]["frame_index"]) + ' } ] }' if (options.display_level >= 1): cv2.waitKey(100) cv2.destroyAllWindows() if (options.verbosity >= 1): print "ack message:", ack_message header = ('01', len(ack_message)) packed_ack_header = packer_ack_header.pack(*header) conn.sendall(packed_ack_header) conn.sendall(ack_message) conn.close()
def build_flann_index(f, index_file, config): flann_params = dict(algorithm=2, branching=config['flann_branching'], terations=config['flann_iterations']) index = cv2.flann_Index(f, flann_params) index.save(index_file)
def load_feature_index(self, image, features): index = cv2.flann_Index() index.load(features, self.__feature_index_file(image)) return index
def load_feature_index(self, image, features): index = cv2.flann.Index() if context.OPENCV3 else cv2.flann_Index() index.load(features, self.__feature_index_file(image)) return index
#ANN!!! # next we need to flatten our 3D feature vector into 2D for ANN to work f_A_reshape = [] f_B_reshape = [] for i in xrange(5): f_hA,f_wA = feature_vectorA[i].shape[0:2] f_A_reshape.append(kernel5*np.array(np.reshape(feature_vectorA[i],[f_hA*f_wA,25]),dtype=np.float32)) f_hB,f_wB = feature_vectorB[i].shape[0:2] f_B_reshape.append(kernel5*np.array(np.reshape(feature_vectorB[i],[f_hB*f_wB,25]),dtype=np.float32)) # train dataset n = 0 trainset = np.array(f_A_reshape[n],dtype=np.float32) params = dict(algorithm=1,trees=4) flnn = cv2.flann_Index(trainset,params) # now to perform the actual ANN hh,ww = pyramidB[n].shape ilist,jlist,B_prime_Y = ANNalgo(flnn,n,hh,ww,feature_vectorA_prime,f_B_reshape) stop_time = time.time() print "algo complete" print "Serial: %f" % (stop_time - start_time) start_time = time.time() # COHERENCE CODE for i in xrange(2, heightB - 1, 1): for j in xrange(2, widthB - 1, 1): #set coh distance = infinity
imageBasePaths = np.load(output_dir + args.db_name + "_imagesPaths.npy") imageBaseIndex = np.load(output_dir + args.db_name + "_imagesIndex.npy") end = timer() print "load descriptors: " + str(end - start) ## Load database index (computed offline) start = timer() FLANN_INDEX_ALGO = 1 index_params = dict(algorithm=254, filename=output_dir + args.db_name + "_flann_index" + str(FLANN_INDEX_ALGO) + ".dat") d = np.asarray(dataBaseDescriptors, np.float32) print 'd type', type(d) print 'd size', d.shape fl = cv2.flann_Index(np.asarray(dataBaseDescriptors, np.float32), index_params) end = timer() print "load index: " + str(end - start) ## Search on the database index start = timer() knn = 50 #idx = np.zeros((1,5)) search_params = dict(checks=50) # or pass empty dictionary idx, dist = fl.knnSearch(np.asarray(qdesc, np.float32), knn, params={}) end = timer() print "knn search: " + str(end - start) print idx.shape print type(imageBaseIndex) print imageBaseIndex.shape
height, width = template.shape[:2] template = cv2.resize(template,(width/3, height/3), interpolation = cv2.INTER_CUBIC) #find keypoints detector = cv2.FeatureDetector_create("SIFT") descriptor = cv2.DescriptorExtractor_create("SIFT") skp = detector.detect(img)#list of all the keypoints found on the image skp, sd = descriptor.compute(img, skp)#sd is the descriptor for the image tkp = detector.detect(template) tkp, td = descriptor.compute(template, tkp) flann_params = dict(algorithm=1, trees=4) flann = cv2.flann_Index(sd, flann_params) idx, dist = flann.knnSearch(td, 1, params={}) del flann dist = dist[:,0]/2500.0 dist = dist.reshape(-1,).tolist() idx = idx.reshape(-1).tolist() indices = range(len(dist)) indices.sort(key=lambda i: dist[i]) dist = [dist[i] for i in indices] idx = [idx[i] for i in indices] skp_final = [] tkp_final = [] for i, dis in itertools.izip(idx, dist): if dis < dist: