def set_detector_by_name(name): det = None if name == "Agast": det = cv2.AgastFeatureDetector_create() elif name == "FAST": det = cv2.FastFeatureDetector_create() elif name == "GFTT": det = cv2.GFTTDetector_create(310) elif name == "HARRIS": det = cv2.GFTTDetector_create(310, 0.001, 10, 3, useHarrisDetector=True) elif name == "KAZE": det = cv2.KAZE_create(False, False, 0.001, 4, 4) elif name == "ORB": det = cv2.ORB_create() elif name == "STAR": det = cv2.xfeatures2d.StarDetector_create() elif name == "SURF": det = cv2.xfeatures2d.SURF_create() elif name == "SIFT": det = cv2.xfeatures2d.SIFT_create() elif name == "AKAZE": det = cv2.AKAZE_create() else: print "Not Implemented Error ..." return det
def __init__(self, config='GFTT-BRIEF'): super().__init__() if config == 'GFTT-BRIEF': self.feature_detector = cv2.GFTTDetector_create( maxCorners=1000, minDistance=12.0, qualityLevel=0.001, useHarrisDetector=False) self.descriptor_extractor = cv2.xfeatures2d.BriefDescriptorExtractor_create( bytes=32, use_orientation=False) elif config == 'GFTT-BRISK': self.feature_detector = cv2.GFTTDetector_create( maxCorners=2000, minDistance=15.0, qualityLevel=0.01, useHarrisDetector=False) self.descriptor_extractor = cv2.BRISK_create() elif config == 'ORB-ORB': self.feature_detector = cv2.ORB_create(nfeatures=1000, scaleFactor=1.2, nlevels=1, edgeThreshold=31) self.descriptor_extractor = self.feature_detector else: raise NotImplementedError self.descriptor_matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False) self.matching_cell_size = 15 # pixels self.matching_neighborhood = 3 self.matching_distance = 30 self.frustum_near = 0.1 # meters self.frustum_far = 1000.0 self.ground = True self.lc_max_inbetween_distance = 50 self.lc_distance_threshold = 15 self.lc_embedding_distance = 20.0 self.view_image_width = 400 self.view_image_height = 130 self.view_camera_width = 0.75 self.view_viewpoint_x = 0 self.view_viewpoint_y = -500 # -10 self.view_viewpoint_z = -100 # -0.1 self.view_viewpoint_f = 2000 self.line_detector = cv2.line_descriptor.BinaryDescriptor_createBinaryDescriptor( ) self.line_extractor = self.line_detector self.line_matching_distance = 30
def __init__(self, config='GFTT-BRIEF'): super().__init__() # Set descriptor-descriptor pair GFTT-BRIEF for feature detection if config == 'GFTT-BRIEF': self.feature_detector = cv2.GFTTDetector_create( maxCorners=1000, minDistance=12.0, qualityLevel=0.001, useHarrisDetector=False) self.descriptor_extractor = cv2.xfeatures2d.BriefDescriptorExtractor_create( bytes=32, use_orientation=False) # Set alternative descriptor pair ORB-BRIEF elif config == 'GFTT-BRISK': self.feature_detector = cv2.GFTTDetector_create( maxCorners=2000, minDistance=15.0, qualityLevel=0.01, useHarrisDetector=False) self.descriptor_extractor = cv2.BRISK_create() elif config == 'ORB-ORB': self.feature_detector = cv2.ORB_create( nfeatures=1000, scaleFactor=1.2, nlevels=1, edgeThreshold=31) self.descriptor_extractor = self.feature_detector else: raise NotImplementedError # Set bruce force matcher of cv2 defined with hamming distance and return all values not only best match, # therefore crossCheck = false self.descriptor_matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False) # Set visual aspects for matching self.matching_cell_size = 15 # pixels self.matching_neighborhood = 3 self.matching_distance = 30 # Frustum projection of the map points around the predicted pose self.frustum_near = 0.1 # meters self.frustum_far = 1000.0 self.ground = True # Set values for distances to detect valid ones self.lc_max_inbetween_distance = 50 self.lc_distance_threshold = 15 self.lc_embedding_distance = 20.0 self.view_image_width = 400 self.view_image_height = 130 self.view_camera_width = 0.75 self.view_viewpoint_x = 0 self.view_viewpoint_y = -500 # -10 self.view_viewpoint_z = -100 # -0.1 self.view_viewpoint_f = 2000
def detect(videoCapture): frameCount = int(videoCapture.get(cv2.CAP_PROP_FRAME_COUNT)) - 2 kps = [] descriptors = [] i = 0 while True and i <= frameCount: showProgress(i, frameCount, "Detecting video:") i += 1 videoCapture.grab() r, img = videoCapture.retrieve() if not r: videoCapture.release() break gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) featDetector = cv2.GFTTDetector_create(500, 0.01, 1, 3, True, 0.04) features = featDetector.detect(gray) brief = cv2.xfeatures2d.BriefDescriptorExtractor_create() kp, des = brief.compute(gray, features) kps.append(kp) descriptors.append(des) sys.stdout.write("\n") return kps, descriptors
def __init__(self, ratio_matching = 0.5, ratio_pose = 0.5, detecteur = 'fast', descripteur = 'orb'): self.ratio_matching = ratio_matching self.ratio_pose = ratio_pose self.detecteur = detecteur self.descripteur = descripteur self.detecteurs = { 'akaze': cv2.AKAZE_create(), 'agast': cv2.AgastFeatureDetector_create(), 'brisk': cv2.BRISK_create(), 'fast' : cv2.FastFeatureDetector_create(), 'gftt' : cv2.GFTTDetector_create(), 'kaze' : cv2.KAZE_create(), 'mser' : cv2.MSER_create(), 'orb' : cv2.ORB_create(), 'blob' : cv2.SimpleBlobDetector_create() } self.descripteurs = {'brisk': cv2.BRISK_create(), 'orb' : cv2.ORB_create(),} self.detector = self.detecteurs[self.detecteur] self.descriptor = self.descripteurs[self.descripteur] self.matcheur = cv2.BFMatcher(normType = self.descriptor.defaultNorm(), crossCheck = True ) self.KF = [] self.current_kf = None self.traj = [] self.current_time = 0 self.prev_pts = None print 'construction du SLAM'
def feature_detector_create(self, detector_name, adaptation): if int(self.OPENCV_MAJOR) < 3: name = adaptation + detector_name detector = cv2.FeatureDetector_create(name) else: if detector_name == DetectorType.ORB: detector = cv2.ORB(adaptation) elif detector_name == DetectorType.FAST: # noinspection PyUnresolvedReferences detector = cv2.FastFeatureDetector_create() elif detector_name == DetectorType.STAR: # noinspection PyUnresolvedReferences detector = cv2.xfeatures2d.StarDetector_create() elif detector_name == DetectorType.MSER: # noinspection PyUnresolvedReferences detector = cv2.MSER_create() elif detector_name == DetectorType.GFTT: # noinspection PyUnresolvedReferences detector = cv2.GFTTDetector_create() elif detector_name == DetectorType.HARRIS: # noinspection PyUnresolvedReferences detector = cv2.xfeatures2d.HarrisLaplaceFeatureDetector_create() elif detector_name == DetectorType.BLOB: # noinspection PyUnresolvedReferences detector = cv2.SimpleBlobDetector_create() else: # detector.detector() == DetectorType.BRISK: detector = cv2.BRISK(adaptation) return detector
def __init__(self, feature='GFTT'): self.epipolar_range = 1.0 # pixel self.max_depth = 20 # meter self.min_depth = 0.01 # meter if feature == 'GFTT': self.detector = cv2.GFTTDetector_create(maxCorners=500, qualityLevel=0.01, minDistance=9, blockSize=9) self.extractor = cv2.xfeatures2d.BriefDescriptorExtractor_create( bytes=32, use_orientation=False) elif feature == 'ORB': self.detector = cv2.ORB_create(nfeatures=1000, scaleFactor=1.2, nlevels=8, edgeThreshold=31, patchSize=31) self.extractor = self.detector else: raise NotImplementedError self.matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) self.dist_std_scale = 0.4 self.disparity_matches = 40 self.min_good_matches = 40 self.matching_distance = 25 self.min_inliers = 40 self.restart_tracking = 3 self.max_update_time = 0.45 self.cell_size = 15
def __init__(self): self.feature_detector = cv2.GFTTDetector_create( maxCorners=600, minDistance=15.0, qualityLevel=0.001, useHarrisDetector=False) self.descriptor_extractor = cv2.xfeatures2d.BriefDescriptorExtractor_create( bytes=32, use_orientation=False) self.descriptor_matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False) self.matching_distance = 30 self.matching_distance_ratio = 0.8 self.depth_near = 0.1 self.depth_far = 10 self.lc_min_inbetween_keyframes = 2 # frames self.lc_max_inbetween_distance = 3 # meters self.lc_embedding_distance = 30 self.lc_inliers_threshold = 13 self.lc_inliers_ratio = 0.3 self.view_camera_width = 0.05 self.view_viewpoint_x = 0 self.view_viewpoint_y = -1 self.view_viewpoint_z = -10 self.view_viewpoint_f = 2000 self.view_image_width = 320 self.view_image_height = 240 self.view_point_cloud = False
def __init__(self): self.detector = cv2.GFTTDetector_create(maxCorners=1000, minDistance=15.0, qualityLevel=0.001, useHarrisDetector=False) self.descriptor = cv2.xfeatures2d.BriefDescriptorExtractor_create( bytes=32, use_orientation=False) self.matcher = cv2.BFMatcher(cv2.NORM_HAMMING)
def detectar(x): t = cv.getTrackbarPos('Threshold', 'Deteccion de Rasgos') # Crea un objeto de acuerdo al metodo seleccionado # y llama a la funcion para detectar los rasgos if metodo == '1': # Crea un objeto "Good Features to Track" gftt = cv.GFTTDetector_create(0, 0.01, t, 3) kp = gftt.detect(input_img, None) elif metodo == '2': # Crea un objeto tipo FAST fast = cv.FastFeatureDetector_create(t) # Detecta los rasgos kp = fast.detect(input_img, None) elif metodo == '3': # Crea un objeto tipo AGAST agast = cv.AgastFeatureDetector_create(t) # Detecta los rasgos kp = agast.detect(input_img, None) elif metodo == '4': #Crea un objeto tipo star(?) / BRIEF star = cv.xfeatures2d.StarDetector_create(t) #Detecta los rasgos kp = star.detect(input_img, None) elif metodo == '5': #Crea un objeto tipo ORB orb = cv.ORB_create(t) #Detecta los ragos kp = orb.detect(input_img, None) elif metodo == '6': # Crea un objeto tipo AKAZE, la funcion requiere valores mas bajos de t akaze = cv.AKAZE_create(threshold=0.001 * t) kp = akaze.detect(input_img, None) print(t) elif metodo == '7': # Crea un objeto tipo BRISK brisk = cv.BRISK_create(t) kp = brisk.detect(input_img, None) elif metodo == '8': # Crea un objeto tipo KAZE, la funcion requiere valores mas bajos de t kaze = cv.KAZE_create(threshold=0.001 * t) kp = kaze.detect(input_img, None) elif metodo == '9': # Crea un objeto tipo SIFT sift = cv.xfeatures2d.SIFT_create(t) kp = sift.detect(input_img, None) elif metodo == '10': # Crea un objeto tipo SURF surf = cv.xfeatures2d.SURF_create(t) kp = surf.detect(input_img, None) else: return # Dibuja los rasgos detectados sobre la imagen original output_img = cv.drawKeypoints(input_img, kp, None, color=(255, 0, 0)) cv.imshow('Deteccion de Rasgos', output_img)
def __init__(self, pixels_per_feature=500, min_match_n=20, grid_cells_cols=8): self.min_match_n = min_match_n self.pixels_per_feature = pixels_per_feature self.gftt = cv2.GFTTDetector_create(maxCorners=4096 * 4, qualityLevel=0.02, minDistance=9, blockSize=5) self.grid_cells_cols = grid_cells_cols
def detect(self): src_image = self.get_opencv_image() if src_image.all() != None: detector = cv2.GFTTDetector_create() keypoints = detector.detect(src_image) detected_image = cv2.drawKeypoints( src_image, keypoints, None, color=(0, 0, 255), ) self.set_opencv_image(detected_image) self.update()
def __init__(self): self.feature_detector = cv2.GFTTDetector_create( maxCorners=600, minDistance=15.0, qualityLevel=0.001, useHarrisDetector=False) self.descriptor_extractor = cv2.xfeatures2d.BriefDescriptorExtractor_create( bytes=32, use_orientation=False) self.descriptor_matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False) self.matching_cell_size = 15 # pixels self.matching_neighborhood = 2 self.matching_distance = 30 self.matching_distance_ratio = 0.8 self.virtual_baseline = 0.1 # meters self.depth_near = 0.1 self.depth_far = 10 self.frustum_near = 0.1 self.frustum_far = 50.0 self.pnp_min_measurements = 30 self.pnp_max_iterations = 10 self.init_min_points = 30 self.local_window_size = 10 self.keyframes_buffer_size = 5 self.ba_max_iterations = 10 self.min_tracked_points = 150 self.min_tracked_points_ratio = 0.75 self.lc_min_inbetween_keyframes = 15 # frames self.lc_max_inbetween_distance = 3 # meters self.lc_embedding_distance = 30 self.lc_inliers_threshold = 13 self.lc_inliers_ratio = 0.3 self.lc_distance_threshold = 1.5 # meters self.lc_max_iterations = 20 self.view_camera_width = 0.05 self.view_viewpoint_x = 0 self.view_viewpoint_y = -1 self.view_viewpoint_z = -10 self.view_viewpoint_f = 2000 self.view_image_width = 400 self.view_image_height = 250
def gftt(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 gftt = cv.GFTTDetector_create() brief = cv.xfeatures2d.BriefDescriptorExtractor_create() #Detecta Rasgos y Calcula el descriptor kpa = gftt.detect(img1, None) kp1, des1 = brief.compute(img1, kpa) kpb = gftt.detect(img2, None) kp2, des2 = brief.compute(img2, kpb) #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 callback(self, ros_data): '''Callback function of subscribed topic. Here images get converted and features detected''' if VERBOSE: print 'received image of type: "%s"' % ros_data.format #### direct conversion to CV2 #### np_arr = np.fromstring(ros_data.data, np.uint8) #image_np = cv2.imdecode(np_arr, cv2.CV_LOAD_IMAGE_COLOR) image_np = cv2.imdecode(np_arr, cv2.IMREAD_COLOR) # OpenCV >= 3.0: #### Feature detectors using CV2 #### # "","Grid","Pyramid" + # "FAST","GFTT","HARRIS","MSER","ORB","SIFT","STAR","SURF" method = "GridFAST" #feat_det = cv2.FeatureDetector_create(method) feat_det = cv2.GFTTDetector_create() time1 = time.time() # convert np image to grayscale featPoints = feat_det.detect(cv2.cvtColor(image_np, cv2.COLOR_BGR2GRAY)) time2 = time.time() if VERBOSE: print '%s detector found: %s points in: %s sec.' % ( method, len(featPoints), time2 - time1) for featpoint in featPoints: x, y = featpoint.pt cv2.circle(image_np, (int(x), int(y)), 3, (0, 0, 255), -1) #cv2.imshow('cv_img', image_np) #cv2.waitKey(2) #### Create CompressedIamge #### msg = CompressedImage() msg.header.stamp = rospy.Time.now() msg.format = "jpeg" msg.data = np.array(cv2.imencode('.jpg', image_np)[1]).tostring() # Publish new image self.image_pub.publish(msg)
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 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 gftt(detector, emparejador, opcion, nombre1, nombre2): #img1 = cv.imread('box.png',cv.IMREAD_GRAYSCALE) # queryImage if opcion == 'd': img1 = cv.imread('graf1.png', cv.IMREAD_GRAYSCALE) # queryImage img2 = cv.imread('graf3.png', cv.IMREAD_GRAYSCALE) # trainImage if opcion == 'n': img1 = cv.imread(nombre1, cv.IMREAD_GRAYSCALE) # queryImage img2 = cv.imread(nombre2, cv.IMREAD_GRAYSCALE) # trainImage gftt = cv.GFTTDetector_create() # Initiate BRIEF extractor brief = cv.xfeatures2d.BriefDescriptorExtractor_create() kpa = gftt.detect(img1, None) kp1, des1 = brief.compute(img1, kpa) kpb = gftt.detect(img1, None) kp2, des2 = brief.compute(img2, kpb) menu_emparejamiento(emparejador, kp1, des1, kp2, des2, img1, img2)
def __init__(self, camera, annotations): self.prev_frame = None self.current_frame = None self.prev_keypoints = None self.current_keypoints = None self.prev_des = None self.current_des = None self.matches = None self.detector = cv2.GFTTDetector_create( maxCorners=1000, minDistance=15.0, qualityLevel=0.001, useHarrisDetector=False) self.descriptor = cv2.xfeatures2d.BriefDescriptorExtractor_create( bytes=32, use_orientation=False) self.matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck = True) self.focal = camera.focal self.projection_center = (camera.cx, camera.cy) self.frame_number = 0 self.R = np.eye(3) self.t = np.zeros((3,1)) self.trueX, self.trueY, self.trueZ = 0, 0, 0 with open(annotations) as f: self.annotations = f.readlines()
def detectar(x): t = cv.getTrackbarPos('Threshold', 'Deteccion de Rasgos') # Crea un objeto de acuerdo al metodo seleccionado # y llama a la funcion para detectar los rasgos if metodo == '1': gftt = cv.GFTTDetector_create(0, 0.01, t, 3) kp = gftt.detect(input_img, None) elif metodo == '2': # Crea un objeto tipo FAST fast = cv.FastFeatureDetector_create(t) # Detecta los rasgos kp = fast.detect(input_img, None) elif metodo == '3': # Crea un objeto tipo AGAST agast = cv.AgastFeatureDetector_create(t) # Detecta los rasgos kp = agast.detect(input_img, None) else: return # Dibuja los rasgos detectados sobre la imagen original output_img = cv.drawKeypoints(input_img, kp, None, color=(255, 0, 0)) cv.imshow('Deteccion de Rasgos', output_img)
def create_detector(self, detector): """ Create detector object. Parameters ---------- detector : str The detector type to create. """ if detector is 'Agast': det = cv2.AgastFeatureDetector_create() elif detector is 'AKAZE': det = cv2.AKAZE_create() elif detector is 'BRISK': det = cv2.BRISK_create() elif detector is 'Fast': det = cv2.FastFeatureDetector_create() elif detector is 'GFTT': det = cv2.GFTTDetector_create() elif detector is 'KAZE': det = cv2.KAZE_create() elif detector is 'MSER': det = cv2.MSER_create() elif detector is 'ORB': det = cv2.ORB_create() elif detector is 'MSD': det = xfeatures2d.MSDDetector_create() elif detector is 'SIFT': det = xfeatures2d.SIFT_create() elif detector is 'SURF': det = xfeatures2d.SURF_create() elif detector is 'Star': det = xfeatures2d.StarDetector_create() else: raise ValueError("Unsupported detector") return det
def descriptors_matching(self, datasetName, dirPath, csvTest, Ns=500, good=0.3): df = pandas.read_csv(csvTest) IMAGE = np.random.randint(0, len(df)) fileName = df['rgb'][IMAGE] if datasetName == "VEDAI": imageRgbPath = dirPath + fileName[:-6] + "co.png" imageIrPath = dirPath + fileName[:-6] + "ir.png" else: sys.exit("ERROR: Unknown dataset") print("Loading: ", imageRgbPath) img_rgb = cv2.imread(imageRgbPath) print("[image RGB]: ", np.shape(img_rgb)) print("Loading: ", imageIrPath) img_ir = cv2.imread(imageIrPath) print("[image IR]: ", np.shape(img_ir)) if np.size(img_rgb) != np.size(img_ir): sys.exit("ERROR: Different images resolution") if np.size(img_rgb, 0) % self.patchSize != 0: img_rgb = img_rgb[0:np.size(img_rgb, 0) // self.patchSize * self.patchSize, :] img_ir = img_ir[0:np.size(img_rgb, 0) // self.patchSize * self.patchSize, :] print("[image RGB]: ", np.shape(img_rgb)) print("[image IR]: ", np.shape(img_ir)) if np.size(img_rgb, 1) % self.patchSize != 0: img_rgb = img_rgb[:, 0:np.size(img_rgb, 0) // self.patchSize * self.patchSize] img_ir = img_ir[:, 0:np.size(img_rgb, 0) // self.patchSize * self.patchSize] print("[image RGB]: ", np.shape(img_rgb)) print("[image IR]: ", np.shape(img_ir)) img_rgb_raw = img_rgb img_ir_raw = img_ir img_rgb = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY) img_ir = cv2.cvtColor(img_ir, cv2.COLOR_RGB2GRAY) img_rgb_gray = img_rgb img_ir_gray = img_ir # Extract keypoints using GFTT mask = np.zeros(np.shape(img_rgb), np.uint8) mask[self.patchSize:np.size(img_rgb, 0) - self.patchSize - 1, self.patchSize:np.size(img_rgb, 1) - self.patchSize - 1] = 255 rgb_corners = cv2.goodFeaturesToTrack(img_rgb, Ns, 0.01, 3, mask=mask) ir_corners = cv2.goodFeaturesToTrack(img_ir, Ns, 0.01, 3, mask=mask) if np.size(rgb_corners, 0) != Ns and np.size(ir_corners, 0) != Ns: sys.exit("Error: Not enough features detected") # Extract patches around keypoints img_rgb = img_rgb - np.mean(img_rgb) img_ir = img_ir - np.mean(img_ir) img_rgb_input = np.empty( (np.size(rgb_corners, 0), self.patchSize, self.patchSize, 1)) img_ir_input = np.empty( (np.size(ir_corners, 0), self.patchSize, self.patchSize, 1)) for c in range(np.size(rgb_corners, 0)): x = int(rgb_corners[c, 0, 0]) y = int(rgb_corners[c, 0, 1]) img_rgb_input[c, :, :, 0] = img_rgb[y:y + self.patchSize, x:x + self.patchSize] for c in range(np.size(ir_corners, 0)): x = int(ir_corners[c, 0, 0]) y = int(ir_corners[c, 0, 1]) img_ir_input[c, :, :, 0] = img_ir[y:y + self.patchSize, x:x + self.patchSize] # Feed network x_representation, y_representation, Ws_x, Ws_y, Wx_x, Wy_y, siamese_features_x, siamese_features_y, asymmetric_features_x, asymmetric_features_y = self.hybridModel( [img_rgb_input, img_ir_input], training=False) # Brute Force Matcher solution, pick 2-norm distance minimum as a pair dis_list = [] min_min_dis = float("inf") for current in range(Ns): min_dis = float("inf") min_idx = 0 for candidate in range(Ns): dis = np.linalg.norm(x_representation[current, :] - y_representation[candidate, :]) if dis < min_dis: min_idx = candidate min_dis = dis dis_list.append([current, min_idx, min_dis]) if min_dis < min_min_dis: min_min_dis = min_dis dis_list = np.array(dis_list) sorted_idx = np.argsort(dis_list[:, 2]) sorted_idx = sorted_idx[:int(good * len(sorted_idx))] matchesImage = np.hstack([img_rgb_raw, img_ir_raw]) h, w = np.shape(img_rgb) for f in range(len(sorted_idx)): rgb_x = int(rgb_corners[int(dis_list[f, 0]), 0, 0]) rgb_y = int(rgb_corners[int(dis_list[f, 0]), 0, 1]) ir_x = int(ir_corners[int(dis_list[f, 1]), 0, 0]) + w ir_y = int(ir_corners[int(dis_list[f, 1]), 0, 1]) R = np.random.randint(0, 255) G = np.random.randint(0, 255) B = np.random.randint(0, 255) cv2.line(matchesImage, (rgb_x, rgb_y), (ir_x, ir_y), (B, G, R), 1) matchesImage = cv2.cvtColor(matchesImage, cv2.COLOR_BGR2RGB) plt.figure() plt.imshow(matchesImage) plt.title("Siamese Matching") plt.show() # GFTT + ORB Feature matching gftt = cv2.GFTTDetector_create(Ns, 0.01, 3) rgb_kp = gftt.detect(img_rgb_gray, mask) ir_kp = gftt.detect(img_ir_gray, mask) orb = cv2.ORB_create() _, rgb_des = orb.compute(img_rgb_gray, rgb_kp) _, ir_des = orb.compute(img_ir_gray, ir_kp) bf = cv2.BFMatcher(cv2.NORM_HAMMING, False) # Match descriptors. matches = bf.match(rgb_des, ir_des) # Sort them in the order of their distance. matches = sorted(matches, key=lambda x: x.distance) # Draw first matches. img_rgb_raw = cv2.cvtColor(img_rgb_raw, cv2.COLOR_BGR2RGB) orb_img = cv2.drawMatches(img_rgb_raw, rgb_kp, img_ir_raw, ir_kp, matches[:len(sorted_idx)], None) plt.figure() plt.imshow(orb_img) plt.title("ORB Matching") plt.show()
def detectFeatures(img, detector): ##Detects new features in the frame. ##Uses the Feature Detector selected. if detector == 'SIFT': sift = cv2.xfeatures2d.SIFT_create() feature_pts, des = sift.detectAndCompute(img, None) elif detector == 'SURF': surf = cv2.xfeatures2d.SURF_create(1000) feature_pts, des = surf.detectAndCompute(img, None) elif detector == 'ORB': orb = cv2.ORB_create(1000) feature_pts, des = orb.detectAndCompute(img, None) elif detector == 'BRISK': brisk = cv2.BRISK_create() feature_pts, des = brisk.detectAndCompute(img, None) elif detector == 'KAZE': kaze = cv2.KAZE_create() feature_pts, des = kaze.detectAndCompute(img, None) elif detector == 'AKAZE': akaze = cv2.AKAZE_create() feature_pts, des = akaze.detectAndCompute(img, None) ########################### SimpleBlobDetector as detector############################################# elif detector == 'SimpleBlobDetector_BRIEF': retval = cv2.SimpleBlobDetector_create() feature_pts = retval.detect(img, None) brief = cv2.xfeatures2d.BriefDescriptorExtractor_create() feature_pts, des = brief.compute(img, feature_pts) elif detector == 'SimpleBlobDetector_VGG': retval = cv2.SimpleBlobDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.VGG_create() des = retval.compute(img, feature_pts) elif detector == 'SimpleBlobDetector_BoostDesc': retval = cv2.SimpleBlobDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.BoostDesc_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'SimpleBlobDetector_LATCH': retval = cv2.SimpleBlobDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.LATCH_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'SimpleBlobDetector_DAISY': retval = cv2.SimpleBlobDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.DAISY_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'SimpleBlobDetector_FREAK': retval = cv2.SimpleBlobDetector_create() feature_pts = retval.detect(img, None) freakExtractor = cv2.xfeatures2d.FREAK_create() feature_pts, des = freakExtractor.compute(img, feature_pts) elif detector == 'SimpleBlobDetector_LUCID': retval = cv2.SimpleBlobDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.LUCID_create() feature_pts, des = retval.compute(img, feature_pts) ################################### FAST as detector############################################## elif detector == 'FAST_BRIEF': fast = cv2.FastFeatureDetector_create(threshold=50, nonmaxSuppression=True) feature_pts = fast.detect(img, None) brief = cv2.xfeatures2d.BriefDescriptorExtractor_create() feature_pts, des = brief.compute(img, feature_pts) elif detector == 'FAST_VGG': fast = cv2.FastFeatureDetector_create(threshold=50, nonmaxSuppression=True) feature_pts = fast.detect(img, None) retval = cv2.xfeatures2d.VGG_create() des = retval.compute(img, feature_pts) elif detector == 'FAST_BoostDesc': fast = cv2.FastFeatureDetector_create(threshold=50, nonmaxSuppression=True) feature_pts = fast.detect(img, None) retval = cv2.xfeatures2d.BoostDesc_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'FAST_LATCH': fast = cv2.FastFeatureDetector_create(threshold=50, nonmaxSuppression=True) feature_pts = fast.detect(img, None) retval = cv2.xfeatures2d.LATCH_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'FAST_DAISY': fast = cv2.FastFeatureDetector_create(threshold=50, nonmaxSuppression=True) feature_pts = fast.detect(img, None) retval = cv2.xfeatures2d.DAISY_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'FAST_FREAK': fast = cv2.FastFeatureDetector_create(threshold=50, nonmaxSuppression=True) feature_pts = fast.detect(img, None) freakExtractor = cv2.xfeatures2d.FREAK_create() feature_pts, des = freakExtractor.compute(img, feature_pts) elif detector == 'FAST_LUCID': fast = cv2.FastFeatureDetector_create(threshold=50, nonmaxSuppression=True) feature_pts = fast.detect(img, None) retval = cv2.xfeatures2d.LUCID_create() feature_pts, des = retval.compute(img, feature_pts) #################################### GFTT as detector############################################# elif detector == 'GFTT_BRIEF': retval = cv2.GFTTDetector_create() feature_pts = retval.detect(img, None) brief = cv2.xfeatures2d.BriefDescriptorExtractor_create() feature_pts, des = brief.compute(img, feature_pts) elif detector == 'GFTT_VGG': retval = cv2.GFTTDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.VGG_create() des = retval.compute(img, feature_pts) elif detector == 'GFTT_BoostDesc': retval = cv2.GFTTDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.BoostDesc_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'GFTT_LATCH': retval = cv2.GFTTDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.LATCH_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'GFTT_DAISY': retval = cv2.GFTTDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.DAISY_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'GFTT_FREAK': retval = cv2.GFTTDetector_create() feature_pts = retval.detect(img, None) freakExtractor = cv2.xfeatures2d.FREAK_create() feature_pts, des = freakExtractor.compute(img, feature_pts) elif detector == 'GFTT_LUCID': retval = cv2.GFTTDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.LUCID_create() feature_pts, des = retval.compute(img, feature_pts) ################################### AGAST as detector ################################################ elif detector == 'AGAST_BRIEF': retval = cv2.AgastFeatureDetector_create() feature_pts = retval.detect(img, None) brief = cv2.xfeatures2d.BriefDescriptorExtractor_create() feature_pts, des = brief.compute(img, feature_pts) elif detector == 'AGAST_VGG': retval = cv2.AgastFeatureDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.VGG_create() des = retval.compute(img, feature_pts) elif detector == 'AGAST_BoostDesc': retval = cv2.AgastFeatureDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.BoostDesc_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'AGAST_LATCH': retval = cv2.AgastFeatureDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.LATCH_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'AGAST_DAISY': retval = cv2.AgastFeatureDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.DAISY_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'AGAST_FREAK': retval = cv2.AgastFeatureDetector_create() feature_pts = retval.detect(img, None) freakExtractor = cv2.xfeatures2d.FREAK_create() feature_pts, des = freakExtractor.compute(img, feature_pts) elif detector == 'AGAST_LUCID': retval = cv2.AgastFeatureDetector_create() feature_pts = retval.detect(img, None) retval = cv2.xfeatures2d.LUCID_create() feature_pts, des = retval.compute(img, feature_pts) ################################# STAR as detector ################################################## elif detector == 'STAR_BRIEF': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) brief = cv2.xfeatures2d.BriefDescriptorExtractor_create() feature_pts, des = brief.compute(img, feature_pts) elif detector == 'STAR_VGG': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) retval = cv2.xfeatures2d.VGG_create() des = retval.compute(img, feature_pts) elif detector == 'STAR_BoostDesc': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) retval = cv2.xfeatures2d.BoostDesc_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'STAR_LATCH': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) retval = cv2.xfeatures2d.LATCH_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'STAR_DAISY': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) retval = cv2.xfeatures2d.DAISY_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'STAR_FREAK': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) freakExtractor = cv2.xfeatures2d.FREAK_create() feature_pts, des = freakExtractor.compute(img, feature_pts) elif detector == 'STAR_LUCID': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) retval = cv2.xfeatures2d.LUCID_create() feature_pts, des = retval.compute(img, feature_pts) ################################ MSER as detector ################################################ elif detector == 'MSER_BRIEF': mser = cv2.MSER_create() feature_pts = mser.detect(img, None) brief = cv2.xfeatures2d.BriefDescriptorExtractor_create() feature_pts, des = brief.compute(img, feature_pts) elif detector == 'MSER_VGG': mser = cv2.MSER_create() feature_pts = mser.detect(img, None) retval = cv2.xfeatures2d.VGG_create() des = retval.compute(img, feature_pts) elif detector == 'MSER_BoostDesc': mser = cv2.MSER_create() feature_pts = mser.detect(img, None) retval = cv2.xfeatures2d.BoostDesc_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'MSER_LATCH': mser = cv2.MSER_create() feature_pts = mser.detect(img, None) retval = cv2.xfeatures2d.LATCH_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'MSER_DAISY': mser = cv2.MSER_create() feature_pts = mser.detect(img, None) retval = cv2.xfeatures2d.DAISY_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'MSER_FREAK': mser = cv2.MSER_create() feature_pts = mser.detect(img, None) freakExtractor = cv2.xfeatures2d.FREAK_create() feature_pts, des = freakExtractor.compute(img, feature_pts) elif detector == 'MSER_LUCID': mser = cv2.MSER_create() feature_pts = mser.detect(img, None) retval = cv2.xfeatures2d.LUCID_create() feature_pts, des = retval.compute(img, feature_pts) ##################################### SIFT as detector ################################################# elif detector == 'SIFT_BRIEF': sift = cv2.xfeatures2d.SIFT_create() feature_pts = sift.detect(img, None) brief = cv2.xfeatures2d.BriefDescriptorExtractor_create() feature_pts, des = brief.compute(img, feature_pts) elif detector == 'SIFT_VGG': sift = cv2.xfeatures2d.SIFT_create() feature_pts = sift.detect(img, None) retval = cv2.xfeatures2d.VGG_create() des = retval.compute(img, feature_pts) elif detector == 'SIFT_BoostDesc': sift = cv2.xfeatures2d.SIFT_create() feature_pts = sift.detect(img, None) retval = cv2.xfeatures2d.BoostDesc_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'SIFT_LATCH': sift = cv2.xfeatures2d.SIFT_create() feature_pts = sift.detect(img, None) retval = cv2.xfeatures2d.LATCH_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'SIFT_DAISY': sift = cv2.xfeatures2d.SIFT_create() feature_pts = sift.detect(img, None) retval = cv2.xfeatures2d.DAISY_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'SIFT_FREAK': sift = cv2.xfeatures2d.SIFT_create() feature_pts = sift.detect(img, None) freakExtractor = cv2.xfeatures2d.FREAK_create() feature_pts, des = freakExtractor.compute(img, feature_pts) elif detector == 'SIFT_LUCID': sift = cv2.xfeatures2d.SIFT_create() feature_pts = sift.detect(img, None) retval = cv2.xfeatures2d.LUCID_create() feature_pts, des = retval.compute(img, feature_pts) ################################### SURF as detector ################################################### elif detector == 'SURF_BRIEF': surf = cv2.xfeatures2d.SURF_create(1000) feature_pts = surf.detect(img, None) brief = cv2.xfeatures2d.BriefDescriptorExtractor_create() feature_pts, des = brief.compute(img, feature_pts) elif detector == 'SURF_VGG': surf = cv2.xfeatures2d.SURF_create(1000) feature_pts = surf.detect(img, None) retval = cv2.xfeatures2d.VGG_create() des = retval.compute(img, feature_pts) elif detector == 'SURF_BoostDesc': surf = cv2.xfeatures2d.SURF_create(1000) feature_pts = surf.detect(img, None) retval = cv2.xfeatures2d.BoostDesc_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'SURF_LATCH': surf = cv2.xfeatures2d.SURF_create(1000) feature_pts = surf.detect(img, None) retval = cv2.xfeatures2d.LATCH_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'SURF_DAISY': surf = cv2.xfeatures2d.SURF_create(1000) feature_pts = surf.detect(img, None) retval = cv2.xfeatures2d.DAISY_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'SURF_FREAK': surf = cv2.xfeatures2d.SURF_create(1000) feature_pts = surf.detect(img, None) freakExtractor = cv2.xfeatures2d.FREAK_create() feature_pts, des = freakExtractor.compute(img, feature_pts) elif detector == 'SURF_LUCID': surf = cv2.xfeatures2d.SURF_create(1000) feature_pts = surf.detect(img, None) retval = cv2.xfeatures2d.LUCID_create() feature_pts, des = retval.compute(img, feature_pts) ##################################### ORB as detector ############################################### elif detector == 'ORB_BRIEF': orb = cv2.ORB_create(1000) feature_pts = orb.detect(img, None) brief = cv2.xfeatures2d.BriefDescriptorExtractor_create() feature_pts, des = brief.compute(img, feature_pts) elif detector == 'ORB_VGG': orb = cv2.ORB_create(1000) feature_pts = orb.detect(img, None) retval = cv2.xfeatures2d.VGG_create() des = retval.compute(img, feature_pts) elif detector == 'ORB_BoostDesc': orb = cv2.ORB_create(1000) feature_pts = orb.detect(img, None) retval = cv2.xfeatures2d.BoostDesc_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'ORB_LATCH': orb = cv2.ORB_create(1000) feature_pts = orb.detect(img, None) retval = cv2.xfeatures2d.LATCH_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'ORB_DAISY': orb = cv2.ORB_create(1000) feature_pts = orb.detect(img, None) retval = cv2.xfeatures2d.DAISY_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'ORB_FREAK': orb = cv2.ORB_create(1000) feature_pts = orb.detect(img, None) freakExtractor = cv2.xfeatures2d.FREAK_create() feature_pts, des = freakExtractor.compute(img, feature_pts) elif detector == 'ORB_LUCID': orb = cv2.ORB_create(1000) feature_pts = orb.detect(img, None) retval = cv2.xfeatures2d.LUCID_create() feature_pts, des = retval.compute(img, feature_pts) #################################### BRISK as detector ################################################ elif detector == 'BRISK_BRIEF': brisk = cv2.BRISK_create() feature_pts = brisk.detect(img, None) brief = cv2.xfeatures2d.BriefDescriptorExtractor_create() feature_pts, des = brief.compute(img, feature_pts) elif detector == 'BRISK_VGG': brisk = cv2.BRISK_create() feature_pts = brisk.detect(img, None) retval = cv2.xfeatures2d.VGG_create() des = retval.compute(img, feature_pts) elif detector == 'BRISK_BoostDesc': brisk = cv2.BRISK_create() feature_pts = brisk.detect(img, None) retval = cv2.xfeatures2d.BoostDesc_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'BRISK_LATCH': brisk = cv2.BRISK_create() feature_pts = brisk.detect(img, None) retval = cv2.xfeatures2d.LATCH_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'BRISK_DAISY': brisk = cv2.BRISK_create() feature_pts = brisk.detect(img, None) retval = cv2.xfeatures2d.DAISY_create() feature_pts, des = retval.compute(img, feature_pts) elif detector == 'BRISK_FREAK': brisk = cv2.BRISK_create() feature_pts = brisk.detect(img, None) freakExtractor = cv2.xfeatures2d.FREAK_create() feature_pts, des = freakExtractor.compute(img, feature_pts) elif detector == 'BRISK_LUCID': brisk = cv2.BRISK_create() feature_pts = brisk.detect(img, None) retval = cv2.xfeatures2d.LUCID_create() feature_pts, des = retval.compute(img, feature_pts) ####################################### SIFT as Descriptor ####################################### elif detector == 'SimpleBlobDetector_SIFT': retval = cv2.SimpleBlobDetector_create() feature_pts = retval.detect(img, None) sift = cv2.xfeatures2d.SIFT_create() feature_pts, des = sift.compute(img, feature_pts) elif detector == 'FAST_SIFT': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) sift = cv2.xfeatures2d.SIFT_create() feature_pts, des = sift.compute(img, feature_pts) elif detector == 'GFTT_SIFT': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) sift = cv2.xfeatures2d.SIFT_create() feature_pts, des = sift.compute(img, feature_pts) elif detector == 'AGAST_SIFT': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) sift = cv2.xfeatures2d.SIFT_create() feature_pts, des = sift.compute(img, feature_pts) elif detector == 'STAR_SIFT': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) sift = cv2.xfeatures2d.SIFT_create() feature_pts, des = sift.compute(img, feature_pts) elif detector == 'MSER_SIFT': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) sift = cv2.xfeatures2d.SIFT_create() feature_pts, des = sift.compute(img, feature_pts) ###################################### SURF as Descriptor ############################################# elif detector == 'SimpleBlobDetector_SURF': retval = cv2.SimpleBlobDetector_create() feature_pts = retval.detect(img, None) surf = cv2.xfeatures2d.SURF_create(1000) feature_pts, des = surf.compute(img, feature_pts) elif detector == 'FAST_SURF': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) surf = cv2.xfeatures2d.SURF_create(1000) feature_pts, des = surf.compute(img, feature_pts) elif detector == 'GFTT_SURF': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) surf = cv2.xfeatures2d.SURF_create(1000) feature_pts, des = surf.compute(img, feature_pts) elif detector == 'AGAST_SURF': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) surf = cv2.xfeatures2d.SURF_create(1000) feature_pts, des = surf.compute(img, feature_pts) elif detector == 'STAR_SURF': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) surf = cv2.xfeatures2d.SURF_create(1000) feature_pts, des = surf.compute(img, feature_pts) elif detector == 'MSER_SURF': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) surf = cv2.xfeatures2d.SURF_create(1000) feature_pts, des = surf.compute(img, feature_pts) #################################### ORB as Descriptor ############################################# elif detector == 'SimpleBlobDetector_ORB': retval = cv2.SimpleBlobDetector_create() feature_pts = retval.detect(img, None) orb = cv2.ORB_create(1000) feature_pts, des = orb.compute(img, feature_pts) elif detector == 'FAST_ORB': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) orb = cv2.ORB_create(1000) feature_pts, des = orb.compute(img, feature_pts) elif detector == 'GFTT_ORB': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) orb = cv2.ORB_create(1000) feature_pts, des = orb.compute(img, feature_pts) elif detector == 'AGAST_ORB': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) orb = cv2.ORB_create(1000) feature_pts, des = orb.compute(img, feature_pts) elif detector == 'STAR_ORB': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) orb = cv2.ORB_create(1000) feature_pts, des = orb.compute(img, feature_pts) elif detector == 'MSER_ORB': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) orb = cv2.ORB_create(1000) feature_pts, des = orb.compute(img, feature_pts) ################################### BRISK as Descriptor ############################################# elif detector == 'SimpleBlobDetector_BRISK': retval = cv2.SimpleBlobDetector_create() feature_pts = retval.detect(img, None) brisk = cv2.BRISK_create() feature_pts, des = brisk.compute(img, feature_pts) elif detector == 'FAST_BRISK': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) brisk = cv2.BRISK_create() feature_pts, des = brisk.compute(img, feature_pts) elif detector == 'GFTT_BRISK': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) brisk = cv2.BRISK_create() feature_pts, des = brisk.compute(img, feature_pts) elif detector == 'AGAST_BRISK': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) brisk = cv2.BRISK_create() feature_pts, des = brisk.compute(img, feature_pts) elif detector == 'STAR_BRISK': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) brisk = cv2.BRISK_create() feature_pts, des = brisk.compute(img, feature_pts) elif detector == 'MSER_BRISK': star = cv2.xfeatures2d.StarDetector_create() feature_pts = star.detect(img, None) brisk = cv2.BRISK_create() feature_pts, des = brisk.compute(img, feature_pts) elif detector == 'Tomasi_ORB': orb = cv2.ORB_create() features = cv2.goodFeaturesToTrack(img, 1000, qualityLevel=0.01, minDistance=7) keypoints = [ cv2.KeyPoint(x=feature[0][0], y=feature[0][1], _size=20) for feature in features ] feature_pts, des = orb.compute(img, keypoints) # return features extracted feature_pts = np.array([x.pt for x in feature_pts], dtype=np.float32) return feature_pts
# 0905.py import cv2 import numpy as np src = cv2.imread('./data/chessBoard.jpg') gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY) #1 ##goodF = cv2.GFTTDetector.create() goodF = cv2.GFTTDetector_create() kp = goodF.detect(gray) print('len(kp)=', len(kp)) dst = cv2.drawKeypoints(gray, kp, None, color=(0, 0, 255)) cv2.imshow('dst', dst) #2 goodF2 = cv2.GFTTDetector_create(maxCorners=50, qualityLevel=0.1, minDistance=10, useHarrisDetector=True) kp2 = goodF2.detect(gray) print('len(kp2)=', len(kp2)) dst2 = cv2.drawKeypoints(gray, kp2, None, color=(0, 0, 255)) cv2.imshow('dst2', dst2) cv2.waitKey() cv2.destroyAllWindows()
def fastDetect(img1L,img2L,feature_detector = 0): """ Feature detection Parameters: img1L : Left image of first frame img2L : Left image of second frame feature detector : 0 = FAST 1 = GFTT Returns: matched features in left and right images """ H,W = img1L.shape TILE_H = 10 TILE_W = 20 kp = [] if(feature_detector == 0): featureEngine = cv2.FastFeatureDetector_create() for y in range(0, H, TILE_H): for x in range(0, W, TILE_W): imPatch = img1L[y:y+TILE_H, x:x+TILE_W] keypoints = featureEngine.detect(imPatch) for pt in keypoints: pt.pt = (pt.pt[0] + x, pt.pt[1] + y) if (len(keypoints) > 10): keypoints = sorted(keypoints, key=lambda x: -x.response) for kpt in keypoints[0:10]: kp.append(kpt) else: for kpt in keypoints: kp.append(kpt) if(feature_detector == 1): featureEngine = cv2.GFTTDetector_create(maxCorners=4000, minDistance=8.0, qualityLevel=0.001, useHarrisDetector=False) keypoints = featureEngine.detect(img1L) for kpt in keypoints: kp.append(kpt) features1 = cv2.KeyPoint_convert(kp) features1 = np.expand_dims(features1, axis=1) # Parameters for lucas kanade optical flow lk_params = dict( winSize = (15,15), maxLevel = 3, criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 50, 0.03)) features2, st, err = cv2.calcOpticalFlowPyrLK(img1L, img2L, features1, None, flags=cv2.MOTION_AFFINE, **lk_params) # separate points that were tracked successfully ptTrackable = np.where(st == 1, 1,0).astype(bool) features1_KLT = features1[ptTrackable, ...] features2_KLT = features2[ptTrackable, ...] features2_KLT = np.around(features2_KLT) # among tracked points take points within error measue error = 4 errTrackablePoints = err[ptTrackable, ...] errThresholdedPoints = np.where(errTrackablePoints < error, 1, 0).astype(bool) features1_KLT = features1_KLT[errThresholdedPoints, ...] features2_KLT = features2_KLT[errThresholdedPoints, ...] # check for validity of tracked point Coordinates hPts = np.where(features2_KLT[:,1] >= H) wPts = np.where(features2_KLT[:,0] >= W) outTrackPts = hPts[0].tolist() + wPts[0].tolist() outDeletePts = list(set(outTrackPts)) if len(outDeletePts) > 0: features1_KLT_L = np.delete(features1_KLT, outDeletePts, axis=0) features2_KLT_L = np.delete(features2_KLT, outDeletePts, axis=0) else: features1_KLT_L = features1_KLT features2_KLT_L = features2_KLT return features1_KLT_L,features2_KLT_L
""" 特征提取之关键点检测(GFTTDetector) """ import cv2 as cv image = cv.imread("images/test4.jpg") cv.imshow("input", image) # 创建GFTT特征检测器 gftt = cv.GFTTDetector_create(100, 0.01, 1, 3, False, 0.04) kp1 = gftt.detect(image, None) for marker in kp1: result = cv.drawMarker(image, tuple(int(i) for i in marker.pt), color=(0, 255, 0)) cv.imshow("GFTT-Keypoint-Detect", result) cv.waitKey(0) cv.destroyAllWindows()
LastEditTime : 2021-09-01 10:55:15 Description : 特征提取之关键点检测 - GFTTDetector 该方法是基于shi-tomas角点检测变化而来的一种特征提取方法,OpenCV创建该检测器的API与goodfeaturetotrack的API参数极其类似: Ptr<GFTTDetector> cv::GFTTDetector::create( int maxCorners = 1000, double qualityLevel = 0.01, double minDistance = 1, int blockSize = 3, bool useHarrisDetector = false, double k = 0.04 ) 唯一不同的,该方法返回一个指针。 PS: 需要注意的是该方法无法提取描述子,只支持提取关键点! ''' import cv2 as cv img = cv.imread("../data/images/test1.png") gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) gftt = cv.GFTTDetector_create() keypoints = gftt.detect(gray, None) img = cv.drawKeypoints(img, keypoints, None) cv.imshow("result", img) cv.waitKey(0) cv.destroyAllWindows()
class DetectorDescriptor: detectors = { 'Agast': cv2.AgastFeatureDetector_create(), 'AKAZE': cv2.AKAZE_create(), 'BRISK': cv2.BRISK_create(), 'Fast': cv2.FastFeatureDetector_create(), 'GFTT': cv2.GFTTDetector_create(), 'KAZE': cv2.KAZE_create(), 'MSER': cv2.MSER_create(), 'ORB': cv2.ORB_create() } xdetectors = { # 'Boost': xfeatures2d.BoostDesc_create(), 'Harris': xfeatures2d.HarrisLaplaceFeatureDetector_create(), # 'PCT': xfeatures2d.PCTSignatures_create(), 'Star': xfeatures2d.StarDetector_create() } descriptors = { 'AKAZE': None, 'BRISK': cv2.BRISK_create(), 'KAZE': None, 'ORB': cv2.ORB_create(), } xdescriptors = { # 'Boost': xfeatures2d.BoostDesc_create(), 'BRIEF': xfeatures2d.BriefDescriptorExtractor_create(), 'DAISY': xfeatures2d.DAISY_create(), 'FREAK': xfeatures2d.FREAK_create(), 'LATCH': xfeatures2d.LATCH_create(), # 'LUCID': xfeatures2d.LUCID_create(), 'VGG': xfeatures2d.VGG_create() } def __init__(self, det_s, des_s=None): self._string_re = re.compile(r'<([^\W_]+)_?(\w+)?') try: self.det = self.detectors[det_s] except KeyError: try: self.det = self.xdetectors[det_s] except KeyError: raise ValueError("Unsupported detector") if des_s: try: self.desc = self.descriptors[des_s] except KeyError: try: self.desc = self.xdescriptors[des_s] except KeyError: raise ValueError("Unsupported descriptor") # AKAZE and KAZE special case if self.desc is None: self.desc = self._create_kaze_descriptor(des_s) else: self.desc = None def _create_kaze_descriptor(self, des_s): """AKAZE only allows AKAZE or KAZE detectors.""" if isinstance(self.det, cv2.AKAZE) or isinstance(self.det, cv2.KAZE): if des_s == 'AKAZE': return cv2.AKAZE_create() else: return cv2.KAZE_create() else: return None def _stringify(self, obj): match = self._string_re.match(str(obj)) if match.group(2): # In the case of 'xfeatures2d_SIFT' etc. return match.group(2) else: return match.group(1) @property def detector_s(self): return self._stringify(self.det) @property def descriptor_s(self): return self._stringify(self.desc) def detect_and_compute(self, image): return self.det.detectAndCompute(image, None) def detect(self, image): try: keypoints = self.det.detect(image) except: return ([]) else: return keypoints def compute(self, image, keypoints): try: (keypoints, descriptors) = self.desc.compute(image, keypoints) except: return ([], []) else: return (keypoints, descriptors)
This shows to use different algorithms for detector and descriptor in two steps instead of single step in detectAndCompute. """ import cv2 import matplotlib.pyplot as plt import time img1 = cv2.imread(r'imgs/1.png', cv2.IMREAD_GRAYSCALE) img2 = cv2.imread(r'imgs/6.png', cv2.IMREAD_GRAYSCALE) start1 = time.time() #kp_detector = cv2.AKAZE_create() kp_detector = cv2.GFTTDetector_create() descriptor_extractor = cv2.SIFT_create() #descriptor_extractor = cv2.KAZE_create() keypoints1 = kp_detector.detect(img1) keypoints2 = kp_detector.detect(img2) print(keypoints1) print(keypoints2) keypoints1, descriptors1 = descriptor_extractor.compute(img1, keypoints1) keypoints2, descriptors2 = descriptor_extractor.compute(img2, keypoints2) # print(img1_kp) # print(img1_desc)
for j, f2 in enumerate(kp): if i == j: continue if distance(f1, f2)<distE: mask[j] = False np_kp = np.array(kp) return list(np_kp[mask]) src = cv2.imread('Chessboard.jpg') gray= cv2.cvtColor(src,cv2.COLOR_BGR2GRAY) gray = cv2.GaussianBlur(gray, (5, 5), 0.0) fastF = cv2.FastFeatureDetector_create(threshold=30) mserF = cv2.MSER_create(10) blobF = cv2.SimpleBlobDetector_create() goodF = cv2.GFTTDetector_create(maxCorners= 20,minDistance = 10) kp= fastF.detect(gray) print('len(kp)=', len(kp)) filtered_kp = filteringByDistance(kp, 10) print('len(filtered_kp)=', len(filtered_kp)) dst = cv2.drawKeypoints(gray, filtered_kp, None, color=(0,0,255)) cv2.imshow('dst', dst) briskF = cv2.BRISK_create() filtered_kp, des = briskF.compute(gray, filtered_kp) print('des.shape=', des.shape) print('des=', des) dst2 = cv2.drawKeypoints(gray, filtered_kp, None, color=(0,0,255))