def draw_matches(imgL, imgR, mode='SIFT'): MIN_MATCH_COUNT = 100 # минимальное число заматченных точек, чтоб отрисовало if mode == 'ORB': algorithm = cv2.ORB_create(nfeatures=10000, scoreType=cv2.ORB_FAST_SCORE) if mode == 'SIFT': algorithm = cv2.SIFT_create() if mode == 'KAZE': algorithm = cv2.KAZE_create() matcher = Matcher(algorithm, imgL, imgR) bf_matches = matcher.BF_matcher(mode) print(f'количество заматченный точек после фильтра: {mode}', len(bf_matches)) if len(bf_matches) > MIN_MATCH_COUNT: src_pts = np.float32([matcher.kp2[m.queryIdx].pt for m in bf_matches]).reshape(-1, 1, 2) dst_pts = np.float32([matcher.kp1[m.trainIdx].pt for m in bf_matches]).reshape(-1, 1, 2) matrix, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0) matchesMask = mask.ravel().tolist() draw_params = dict( outImg=None, # matchColor=(0, 255, 0), # matchesMask=matchesMask, # draw only inliers flags=2) result_mathing_bf = cv2.drawMatches(imgR, matcher.kp2, imgL, matcher.kp1, bf_matches, **draw_params) cv2.namedWindow('draw_matches', cv2.WINDOW_NORMAL) cv2.imshow('draw_matches', result_mathing_bf) cv2.waitKey(0) if mode == 'KAZE': cv2.imwrite('res_kaze.png', result_mathing_bf) if mode == 'SIFT': cv2.imwrite('res_sift.png', result_mathing_bf) if mode == 'ORB': cv2.imwrite('res_orb.png', result_mathing_bf)
def extract_diffusion_features(self, image, vector_size=10): alg = cv.KAZE_create() # image keypoints kps = alg.detect(image) # Number of keypoints is varies depend on image size and color pallet # Sorting them based on keypoint response value(bigger is better) kps = sorted(kps, key=lambda x: -x.response)[:vector_size] # computing descriptors vector kps, dsc = alg.compute(image, kps) dsc = dsc.flatten() needed_size = (vector_size * 64) if dsc.size < needed_size: dsc = np.concatenate([dsc, np.zeros(needed_size - dsc.size)]) return dsc
def train(self, listOfImages): #detector = cv.xfeatures2d.SIFT_create() detector = cv.KAZE_create() allDescriptors = [] for name in listOfImages: img = openImage(name) if img is None: continue keypoints, descriptors = detector.detectAndCompute(img, None) allDescriptors.extend(descriptors) criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 10, 1.0) compactness, labels, centers = cv.kmeans(np.float32(allDescriptors), self.nWords, None, criteria, 100, cv.KMEANS_PP_CENTERS) self.vocabulary = centers
def match_pair(a, b): """ Find SIFT matching points in two images represented as numpy arrays. Args: a, b (arrays): two numpy arrays containing the input images to match Return: pts1, pts2: two lists of pairs of coordinates of matching points """ a = utils.simple_equalization_8bit(a) b = utils.simple_equalization_8bit(b) # KP sift = kaze = cv2.KAZE_create() #cv2.xfeatures2d.SIFT_create() kp1, des1 = sift.detectAndCompute(a, None) kp2, des2 = sift.detectAndCompute(b, None) # https://docs.opencv.org/3.0-beta/doc/py_tutorials/py_feature2d/py_matcher/py_matcher.html bf = cv2.BFMatcher() matches = bf.knnMatch(des1, des2, k=2) # Apply ratio test good = [] pts1 = [] pts2 = [] # ratio test as per Lowe's paper for m, n in matches: if m.distance < 0.8 * n.distance: good.append(m) pts2.append(kp2[m.trainIdx].pt) pts1.append(kp1[m.queryIdx].pt) # cv2.drawMatchesKnn expects list of lists as matches. #img3 = cv2.drawMatchesKnn(a,kp1,b,kp2,good,a,flags=2) #display_image(img3) pts1 = np.asarray(pts1) pts2 = np.asarray(pts2) F, mask = cv2.findFundamentalMat(pts1, pts2, cv2.FM_LMEDS) # select only inlier points pts1 = pts1[mask.ravel()==1] pts2 = pts2[mask.ravel()==1] return pts1, pts2
def select_detector(method): ''' select CV2 detector ''' if method == 'FAST': detector = cv2.FAST_create() elif method == 'MSER': detector = cv2.MSER_create() elif method == 'ORB': detector = cv2.ORB_create() elif method == 'BRISK': detector = cv2.BRISK_create() elif method == 'KAZE': detector = cv2.KAZE_create() elif method == 'AKAZE': detector = cv2.AKAZE_create(descriptor_type=5) elif method == 'SIFT': detector = cv2.xfeatures2d.SIFT_create() return detector
def get_features(f): # Read image and extract label from filename img = cv2.imread(f) label = f.split('/')[2] # We use AKAZE since SIFT has moved to a external library, # that is a pain to install # We could also use something like HOG descriptor alg = cv2.KAZE_create() alg.setThreshold(1e-3) # Detech keypoints kps = alg.detect(img) if len(kps) > 0: # Extract descriptors at each keypoint _, dsc = alg.compute(img, kps) return label, dsc
def extract_features(image, vector_size=32): try: alg = cv2.KAZE_create() kps = alg.detect(image) kps = sorted(kps, key=lambda x: -x.response)[:vector_size] kps, dsc, = alg.compute(image, kps) if dsc is None: dsc = np.asarray([]) dsc = dsc.flatten() needed_size = (vector_size * 64) if dsc.size < needed_size: dsc = np.concatenate([dsc, np.zeros(needed_size - dsc.size)]) except cv2.error as e: print('Error: ', e) return None return dsc
def kaze(selectors: List[ImageSectionSelectorWithLoaderButton]): method = cv2.KAZE_create() # GetImage devuelve PIL Image, no ImageWrapper threshold = my_config.MainWindowSelf.askForFloat( "Enter distance threshold", 500) howManyToMatch = my_config.MainWindowSelf.askForInt( "Enter minimum number of valid matches to consider equality", 50) open_cv_image_1 = numpy.array(selectors[0].getImage())[:, :, ::-1].copy() open_cv_image_2 = numpy.array(selectors[1].getImage())[:, :, ::-1].copy() img1 = cv2.cvtColor(open_cv_image_1, cv2.COLOR_BGR2GRAY) img2 = cv2.cvtColor(open_cv_image_2, cv2.COLOR_BGR2GRAY) keypoints_1, descriptors_1 = method.detectAndCompute(img1, None) keypoints_2, descriptors_2 = method.detectAndCompute(img2, None) # feature matching bf = cv2.BFMatcher(cv2.NORM_L1, crossCheck=True) matches = bf.match(descriptors_1, descriptors_2) matches = sorted(matches, key=lambda x: x.distance) passing_matches = [] for match in matches: if match.distance <= threshold: passing_matches.append(match) if len(passing_matches) >= howManyToMatch: my_config.MainWindowSelf.showMessage( f"Image matchs ({len(passing_matches)} passing matches / {len(matches)} total)", "SIFT result") else: my_config.MainWindowSelf.showMessage("Image does not match", "SIFT result") img3 = cv2.drawMatches(img1, keypoints_1, img2, keypoints_2, passing_matches[:50], img2, flags=2) Image.fromarray(img3).show()
def extract_features(image_path, vector_size=24): image = cv2.imread(image_path, cv2.IMREAD_COLOR) # crop img 300x300 image = image[0:300, 0:300] alg = cv2.KAZE_create() # keypoints keypoints = alg.detect(image) keypoints = sorted(keypoints, key=lambda x: -x.response)[:vector_size] keypoints, dsc = alg.compute(image, keypoints) dsc = dsc.flatten() needed_size = (vector_size * 64) if dsc.size < needed_size: # if vectornya kurang besar (keypoints detectednya sedikit, fill w/ 0's) dsc = np.concatenate([dsc, np.zeros(needed_size - dsc.size)]) return dsc
def train_vocabulary(path): k_means_trainer = cv2.BOWKMeansTrainer(N) image_paths = sorted(list(paths.list_images(path))) for path_to_image in image_paths: img = cv2.imread(path_to_image, cv2.IMREAD_GRAYSCALE) detector = cv2.KAZE_create() key_points, descriptors = detector.detectAndCompute(img, None) if len(key_points) <= 0: continue descriptors = np.float32(descriptors) k_means_trainer.add(descriptors) vocabulary = k_means_trainer.cluster() return vocabulary
def get_feature_vector(self, image_path, vector_size=32): image = cv2.imread(image_path, cv2.IMREAD_COLOR) try: alg = cv2.KAZE_create() key_points = alg.detect(image) # All key points # Reduces top vector_size number of key points. I read that larger is better key_points = sorted(key_points, key=lambda x: -x.response)[:vector_size] key_points, descriptor = alg.compute(image, key_points) descriptor = descriptor.flatten() expected_size = (vector_size * 64) if descriptor.size < expected_size: descriptor = np.concatenate( [descriptor, np.zeros(expected_size - descriptor.size)]) except cv2.error as e: print 'Error: ', e return None return descriptor
def get_image_kaze(image, vector_size=32): alg = cv2.KAZE_create() kps = alg.detect(image) kps = sorted(kps, key=lambda x: -x.response)[:vector_size] # Making descriptor of same size # Descriptor vector size is 64 needed_size = (vector_size * 64) if len(kps) == 0: return np.zeros(needed_size) kps, dsc = alg.compute(image, kps) dsc = dsc.flatten() if dsc.size < needed_size: # if we have less than 32 descriptors then just adding zeros at the # end of our feature vector dsc = np.concatenate([dsc, np.zeros(needed_size - dsc.size)]) return dsc
def kaze(detector, emparejador, opcion, nombre1, nombre2, norma): #Lee las imagenes a analizar if opcion == 'd': img1 = cv.imread('tpic5.png', cv.IMREAD_GRAYSCALE) img2 = cv.imread('tpic5_flipped.png', cv.IMREAD_GRAYSCALE) if opcion == 'db': img1 = cv.imread('thome.jpg', cv.IMREAD_GRAYSCALE) img2 = cv.imread('thome_escale.jpg', cv.IMREAD_GRAYSCALE) if opcion == 'dc': img1 = cv.imread('tgrafizq.png', cv.IMREAD_GRAYSCALE) img2 = cv.imread('tgrafder.png', cv.IMREAD_GRAYSCALE) if opcion == 'n': img1 = cv.imread(nombre1, cv.IMREAD_GRAYSCALE) img2 = cv.imread(nombre2, cv.IMREAD_GRAYSCALE) #Inicia el Detector y Descriptor kaze = cv.KAZE_create() #Detecta Rasgos y Calcula el descriptor kp1, des1 = kaze.detectAndCompute(img1, None) kp2, des2 = kaze.detectAndCompute(img2, None) #Muestra Rasgos y Guarda la imagen correspondiente imgx = cv.drawKeypoints(img1, kp1, None, color=(0, 255, 255)) imgy = cv.drawKeypoints(img2, kp2, None, color=(0, 255, 255)) window_namex = "Rasgos Caracteristicos imagen 1" window_namey = "Rasgos Caracteristicos imagen 2" cv.namedWindow(window_namex) cv.namedWindow(window_namey) cv.resizeWindow(window_namex, 500, 400) cv.resizeWindow(window_namey, 500, 400) cv.imshow(window_namex, imgx) cv.imshow(window_namey, imgy) save(imgx, emparejador, detector, norma, tag1) save(imgy, emparejador, detector, norma, tag2) #Envia los datos a la etapa de emparejamiento menu_emparejamiento(emparejador, kp1, des1, kp2, des2, img1, img2, norma, detector)
def getKAZE(self, image, vector_size=8): alg = cv2.KAZE_create() # Finding image keypoints kps = alg.detect(image) # Getting first vector_size of them # Sorting them based on keypoint response value(bigger is better) kps = sorted(kps, key=lambda x: -x.response)[:vector_size] # computing descriptors vector kps, dsc = alg.compute(image, kps) # Flatten all of them in one big vector - our feature vector fd = dsc.flatten() # Making descriptor of same size (descriptor vector size is 64) needed_size = (vector_size * 64) if dsc.size < needed_size: # if we have less the 32 descriptors then just adding zeros at the # end of our feature vector fd = np.concatenate([dsc, np.zeros(needed_size - dsc.size)]) f_names = ['KAZE' + str(i).zfill(2) for i in range(len(fd))] return fd, f_names
def extract(image_path, vsize=8): #RGB img = cv2.imread(image_path, 1) kaze = cv2.KAZE_create() kps = kaze.detect(img) kps_temp = sorted(kps, key=lambda x: abs(x.response))[:vsize // 2] dsc = kaze.compute(img, kps_temp)[1] kps_temp = sorted(kps, key=lambda x: x.size)[:vsize // 2] dsc2 = kaze.compute(img, kps_temp)[1] kps_temp = sorted(kps, key=lambda x: x.angle)[:vsize // 4] dsc3 = kaze.compute(img, kps_temp)[1] dsc = np.concatenate( [dsc.flatten('C'), dsc2.flatten('C'), dsc3.flatten('C')], axis=None) needed_size = (vsize * 2 * 64) if dsc.size < needed_size: dsc = np.concatenate([dsc, np.zeros(needed_size - dsc.size)]) return dsc
def extract_features(image_path, vector_size=32): image = imread(image_path, pilmode="RGB") try: alg = cv2.KAZE_create() kps = alg.detect(image) kps = sorted(kps, key=lambda x: -x.response)[:vector_size] kps, dsc = alg.compute(image, kps) if (len(kps) < 1 or dsc is None): print('\nFailed to read from %s.' % image_path) dsc = np.zeros(vector_size * 64) else: dsc = dsc.flatten() needed_size = (vector_size * 64) if dsc.size < needed_size: dsc = np.concatenate([dsc, np.zeros(needed_size - dsc.size)]) except cv2.error as e: print("Error", e) return None return dsc
def extract_features(image, vector_size=32): try: # Using KAZE, cause SIFT, ORB and other was moved to additional module # which is adding addtional pain during install alg = cv.KAZE_create() # Dinding image keypoints kps = alg.detect(image) print("KPS: ", kps) # Getting first 32 of them. # Number of keypoints is varies depend on image size and color pallet DEBUG_MODE = 1 if DEBUG_MODE > 0: debug_image = image cv.imshow("Image", image) cv.waitKey(0) debug_image = cv.drawKeypoints(image, kps, numpy.array([]), color=(0, 255, 0), flags=0) cv.imshow('Image Keypoints', debug_image) cv.waitKey(0) # Sorting them based on keypoint response value(bigger is better) kps = sorted(kps, key=lambda x: -x.response)[:vector_size] # computing descriptors vector kps, dsc = alg.compute(image, kps) # Flatten all of them in one big vector - our feature vector dsc = dsc.flatten() # Making descriptor of same size # Descriptor vector size is 64 needed_size = (vector_size * 64) if dsc.size < needed_size: # if we have less the 32 descriptors then just adding zeros at the # end of our feature vector dsc = numpy.concatenate([dsc, numpy.zeros(needed_size - dsc.size)]) except Exception as e: print('Error: ', e) return None return dsc
def check_bonus_ruby(self): KAZE = cv2.KAZE_create() BF = cv2.BFMatcher() ruby_area = self.img[370:650, 0:80] bonus_ruby = self.pics['bonus_ruby.png'] kp1, des1 = KAZE.detectAndCompute(bonus_ruby, None) kp2, des2 = KAZE.detectAndCompute(ruby_area, None) if kp2: matches = BF.knnMatch(des1, des2, k=2) good = [] append = good.append for m, n in matches: if m.distance < n.distance * 0.7: append([m]) if len(good) >= 2: good_trainIdx = [value.trainIdx for [value] in good] x = sum([kp2[idx].pt[0] for idx in good_trainIdx]) / len(good) y = sum([kp2[idx].pt[1] for idx in good_trainIdx]) / len(good) return x, y + 370
def calc_kp_des_hist_by_table(table, masks, checked): KAZE = cv2.KAZE_create() def calc_kp_des_hist(img, mask): kp, des = KAZE.detectAndCompute(img, mask) hist = [ cv2.calcHist([img], [0], mask, [256], [0, 256]), cv2.calcHist([img], [1], mask, [256], [0, 256]), cv2.calcHist([img], [2], mask, [256], [0, 256]) ] return kp, des, hist with ThreadPool() as pool: results = [] for y, data in enumerate(table): temp = [] for x, pic in enumerate(data): if (x, y) not in checked: mask = masks[y][x] res = pool.apply_async(calc_kp_des_hist, (pic, mask)) temp.append(res) else: res = None temp.append(res) results.append(temp) pool.close() pool.join() final = [] for y in results: temp = [] for kp_res in y: if kp_res is not None: kp, des, hist = kp_res.get() if len(kp) > 0: temp.append((kp, des, hist)) else: temp.append(None) else: temp.append(None) final.append(temp) return final
def create_descriptor(self, descriptor, detector): """ Create descriptor object. Parameters ---------- descriptor : str An optional descriptor type to create. detector: str Detector name, to check if valid combination. """ if descriptor is 'AKAZE': # AKAZE only allows AKAZE or KAZE detectors if detector is 'AKAZE' or detector is 'KAZE': desc = cv2.AKAZE_create() else: return None elif descriptor is 'BRISK': desc = cv2.BRISK_create() elif descriptor is 'FREAK': desc = xfeatures2d.FREAK_create() elif descriptor is 'KAZE': # KAZE only allows KAZE or AKAZE detectors if detector is 'AKAZE' or detector is 'KAZE': desc = cv2.KAZE_create() else: return None elif descriptor is 'ORB': desc = cv2.ORB_create() elif descriptor is 'BRIEF': desc = xfeatures2d.BriefDescriptorExtractor_create() elif descriptor is 'DAISY': desc = xfeatures2d.DAISY_create() elif descriptor is 'FREAK': desc = xfeatures2d.FREAK_create() elif descriptor is 'LATCH': desc = xfeatures2d.LATCH_create() elif descriptor is 'SIFT': desc = xfeatures2d.SIFT_create() elif descriptor is 'SURF': desc = xfeatures2d.SURF_create() else: raise ValueError("Unsupported descriptor") return desc
def make_bag_of_words(): #resizing the images imdataset = [] for root, dirnames, filenames in os.walk("./dataset/image_dataset"): for filename in filenames: filepath = os.path.join(root, filename) imdata = ndimage.imread(filepath, mode="L") imdata_resized = misc.imresize(imdata, (300, 300)) imdataset.append(imdata_resized) sift = cv2.xfeatures2d.SIFT_create() alg = cv2.KAZE_create() feature_dataset = [] for x in range(len(imdataset)): train_image = imdataset[x] getfeatures = extract_features(train_image, alg) #getfeatures = getFeatureMap(train_image,sift) feature_dataset.append(getfeatures) return (feature_dataset, alg, imdataset)
def _initialize_feature_extractor(self, feature_type: str): """Initializes the feature extractor. Args: feature_type: Feature extractor { SIFT, SURF, KAZE }. Raises: ValueError: If the feature type is not known. """ if feature_type == 'SIFT': self._feature_extractor = cv2.xfeatures2d.SIFT_create() elif feature_type == 'SURF': self._feature_extractor = cv2.xfeatures2d.SURF_create() elif feature_type == 'KAZE': self._feature_extractor = cv2.KAZE_create() else: raise ValueError("Feature type not supported. Possible values are 'SIFT', 'SURF', and 'KAZE'.") self._feature_type = feature_type
def create_panorama(descriptor_name, detector_name, normalized_imgs, output_path, img_name): # (2) detect keypoints and extract local invariant descriptors detector = { "MSER": lambda: cv.MSER_create(), "FAST": lambda: cv.FastFeatureDetector_create(), "AGAST": lambda: cv.AgastFeatureDetector_create(), "GFFT": lambda: cv.GFTTDetector_create(), "STAR": lambda: cv.xfeatures2d.StarDetector_create() }[detector_name]() descriptor = { "sift": lambda: cv.xfeatures2d.SIFT_create(), "surf": lambda: cv.xfeatures2d.SURF_create(), "brief": lambda: cv.xfeatures2d.BriefDescriptorExtractor_create(), "orb": lambda: cv.ORB_create(nfeatures=1500), "kaze": lambda: cv.KAZE_create(), "akaze": lambda: cv.AKAZE_create(), }[descriptor_name]() def default_describe(img): return descriptor.detectAndCompute(img.astype('uint8'), None) descriptor_apply_function = { "brief": lambda img: extract_and_describe_with_brief(img, detector, descriptor) }.get(descriptor_name, lambda img: default_describe(img)) matcher = cv.BFMatcher() ratio = 0.75 reproj_threshold = 4. alg = descriptor_name if descriptor_name in [ "sift", "surf", "orb", "kaze", "akaze" ] else "{}_{}".format(descriptor_name, detector_name) def r_stitch(a, b): return stitch(a[1], b[1], ratio, descriptor_apply_function, matcher, reproj_threshold, True, a[0] + 1, b[0] + 1, img_name, alg) result = reduce(r_stitch, enumerate(normalized_imgs)) save_img(result[1], "{}/{}_result_{}.jpg".format(output_path, img_name, alg))
def AKAZE_descriptor_matcher(img1, img2, use_KAZE_detector=False, points_mask=None, show_matches=True, sort_points_by_distance_parameter=True): # KAZE detector if not use_KAZE_detector: detector = cv2.AKAZE_create() else: detector = cv2.KAZE_create() # obtenemos las imágenes en blanco y negro img1_gray = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY) img2_gray = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY) # detectamos y computamos los keypoints y los descriptores # los almacenamos. Estos descriptres serán descriptores SIFT keypoints1, descriptors1 = detector.detectAndCompute(image=img1_gray, mask=points_mask) keypoints2, descriptors2 = detector.detectAndCompute(image=img2_gray, mask=points_mask) # Creamos el BFmatcher (Brute Force) que usará validación cruzada bf = cv2.BFMatcher(normType=cv2.NORM_L2, crossCheck=True) # Detectamos las correspondencias o matches matches = bf.match(descriptors1, descriptors2) # Y las ordenamos según la distancia if sort_points_by_distance_parameter: matches = sorted(matches, key=lambda x: x.distance) if show_matches: match_img = cv2.drawMatches(img1=img1, keypoints1=keypoints1, img2=img2, keypoints2=keypoints2, matches1to2=matches[:50], outImg=None, flags=4) show_img(match_img, "Correspondencias") return [keypoints1, descriptors1], [keypoints2, descriptors2], matches
def main(): # paths to the thumbnails and the test images thumbnail_path = './Pictures' test_path = './TestImages' # path to write pickled feature vectors. naming convention: {pictures, test}FV.pck picklePath = 'picturesKaze.pck' # all the keypoint descriptors kaze = cv2.KAZE_create() orb = cv2.ORB_create() akaze = cv2.AKAZE_create() brisk = cv2.BRISK_create() batch_extractor(images_path=thumbnail_path, alg=kaze, pickled_db_path='picturesKAZE.pck') batch_extractor(images_path=test_path, alg=kaze, pickled_db_path='testKAZE.pck') batch_extractor(images_path=thumbnail_path, alg=akaze, pickled_db_path='picturesAKAZE.pck') batch_extractor(images_path=test_path, alg=akaze, pickled_db_path='testAKAZE.pck') batch_extractor(images_path=thumbnail_path, alg=orb, pickled_db_path='picturesORB.pck') batch_extractor(images_path=test_path, alg=orb, pickled_db_path='testORB.pck') batch_extractor(images_path=thumbnail_path, alg=brisk, pickled_db_path='picturesBRISK.pck') batch_extractor(images_path=test_path, alg=brisk, pickled_db_path='testBRISK.pck')
def setup(self): super(FeatureExtraction, self).setup() if self._feature_type == 'ORB': defaults = dict(nfeatures=10000) defaults.update(self._kwargs) self._descriptor = cv2.ORB_create(**defaults) elif self._feature_type == 'BRISK': defaults = dict() defaults.update(self._kwargs) self._descriptor = cv2.BRISK_create(**defaults) elif self._feature_type == 'SURF': defaults = dict() defaults.update(self._kwargs) self._descriptor = cv2.xfeatures2d.SURF_create(**defaults) elif self._feature_type == 'SIFT': defaults = dict() defaults.update(self._kwargs) self._descriptor = cv2.xfeatures2d.SIFT_create(**defaults) elif self._feature_type == 'KAZE': defaults = dict() defaults.update(self._kwargs) self._descriptor = cv2.KAZE_create(**defaults) elif self._feature_type == 'AKAZE': defaults = dict() defaults.update(self._kwargs) self._descriptor = cv2.AKAZE_create(**defaults) elif self._feature_type == 'FREAK': defaults = dict() defaults.update(self._kwargs) self._descriptor = cv2.xfeatures2d.FREAK_create(**defaults) self._detector = cv2.xfeatures2d.SURF_create() elif self._feature_type == 'FAST': defaults = dict() defaults.update(self._kwargs) self._descriptor = cv2.FastFeatureDetector_create(**defaults) elif self._feature_type == 'GFTT': defaults = dict() defaults.update(self._kwargs) self._descriptor = cv2.GFTTDetector_create(**defaults) else: raise ValueError("Invalid feature type")
def feature_matching_kaze(query_image_small, reference_image_small): detector = cv2.KAZE_create(upright=True) # kp_query = detector.detect(query_image_small) # kp_reference = detector.detect(reference_image_small) # kp_query = sorted(kp_query, key=lambda x: -x.response)[:800] # kp_reference = sorted(kp_reference, key=lambda x: -x.response)[:800] # kps, dsc_q = detector.compute(query_image_small, kp_query) # todo: use cv2.detectAndCompute instead, is faster # kps, dsc_r = detector.compute(reference_image_small, kp_reference) kp_query, dsc_q = detector.detectAndCompute(query_image_small, None) kp_reference, dsc_r = detector.detectAndCompute(reference_image_small, None) logging.info("#kps query %d" % len(kp_query)) logging.info("#kps reference %d" % len(kp_query)) # create BFMatcher object bf = cv2.BFMatcher(cv2.NORM_L2, crossCheck=True) # Match descriptors. matches = bf.match(dsc_q, dsc_r) # Sort them in the order of their distance. # matches = sorted(matches, key = lambda x:x.distance) # FLANN_INDEX_KDTREE = 1 # index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5) # search_params = dict(checks=50) # or pass empty dictionary # flann = cv2.FlannBasedMatcher(index_params,search_params) # knn_matches = flann.knnMatch(dsc_q, dsc_r, 2) # logging.info("#matches raw %d" % len(knn_matches)) # # Filter matches using Lowe's ratio test # ratio_thresh = 0.7 # matches = [] # for m,n in knn_matches: # if m.distance < ratio_thresh * n.distance: # matches.append(m) # logging.info("#matches refined %d" % len(matches)) keypoints_q = [kp_query[x.queryIdx].pt for x in matches] keypoints_r = [kp_reference[x.trainIdx].pt for x in matches] keypoints_q = np.array(keypoints_q) keypoints_r = np.array(keypoints_r) return keypoints_q, keypoints_r
def SIFT_detector(gray_path): images_sift = os.listdir(gray_path) for i, image_sift in enumerate(images_sift): print(i) print(image_sift) img = cv2.imread(os.path.join(gray_path, image_sift), 0) ''' #sift检测 sift = cv2.xfeatures2d.SIFT_create() kp = sift.detect(img,None) img_sift=cv2.drawKeypoints(img,kp,img,flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) ''' ''' #SURF检测 surf = cv2.xfeatures2d.SURF_create() kp = surf.detect(img,None) img_surf=cv2.drawKeypoints(img,kp,img,flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) ''' ''' #ORB检测,几乎没有 orb = cv2.ORB_create() kp = orb.detect(img,None) img_orb=cv2.drawKeypoints(img,kp,img,flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) ''' #KAZE检测 kaze = cv2.KAZE_create() kp = kaze.detect(img, None) img_kaze = cv2.drawKeypoints( img, kp, img, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) #cv2.imwrite('sift_keypoints.jpg',img) plt.figure(figsize=(30, 30)) plt.subplot(1, 2, 1), plt.title('img') plt.imshow(img, cmap=plt.cm.gray) plt.subplot(1, 2, 2), plt.title('img_kaze') plt.imshow(img_kaze, cmap=plt.cm.gray) # plt.subplot(1, 3, 3), plt.title('lbp_hist') # plt.imshow(lbp_hist) plt.show()
def _get_kaze_vector(image_file, roi=None): """Generates a feature vector for the image using the KAZE keypoint detection method. INPUT: Image file, [Coordinates of ROI in a list [x,y,w,h]] OUTPUT: Descriptor vector""" # Check the extension of the image file extension = image_file.rstrip().split('.')[-1] if extension == 'dcm': dicom_image = pydicom.dcmread(image_file) arr = dicom_image.pixel_array rgb_image = apply_color_lut(arr, dicom_image, palette='PET') gray = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2GRAY) scale_percent = 60 # percent of original size width = int(gray.shape[1] * scale_percent / 100) height = int(gray.shape[0] * scale_percent / 100) dim = (width, height) gray = cv2.resize(gray, dim, interpolation=cv2.INTER_AREA) else: image = imread(image_file) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) if roi: gray = gray[int(roi[1]):int(roi[1] + roi[3]), int(roi[0]):int(roi[0] + roi[2])] alg = cv2.KAZE_create() kps = alg.detect(gray) kps = sorted(kps, key=lambda x: -x.response)[:128] kps, dsc = alg.compute(gray, kps) if dsc is None: return kps, np.zeros((512,)) dsc = dsc.flatten() if dsc.size < 512: # if we have less the 32 descriptors then just adding zeros at the # end of our feature vector dsc = np.concatenate([dsc, np.zeros(512 - dsc.size)]) elif dsc.size > 512: n = 64 while dsc.size > 512: n = int(n / 2) kps = sorted(kps, key=lambda x: -x.response)[:n] kps, dsc = alg.compute(gray, kps) dsc = dsc.flatten() return dsc
def kaze_func(image): alg = cv2.KAZE_create() # Dinding image keypoints kps = alg.detect(image) # Getting first 32 of them. # Number of keypoints is varies depend on image size and color pallet # Sorting them based on keypoint response value(bigger is better) kps = sorted(kps, key=lambda x: -x.response)[:32] # computing descriptors vector kps, dsc = alg.compute(image, kps) cv2.normalize(dsc, dsc) # Flatten all of them in one big vector - our feature vector return dsc.flatten() ''''''''' sobelx8u = cv2.Sobel(image, cv2.CV_8U, 1, 0, ksize=5) # Output dtype = cv2.CV_64F. Then take its absolute and convert to cv2.CV_8U sobelx64f = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=5) cv2.normalize(sobelx8u, sobelx8u) return sobelx8u.flatten() '''''''''