def getFeaturesByDetector(mode,img):
detector = cv2.SimpleBlobDetector_create()
if mode == featuresDetector.Agast:
detector = cv2.AgastFeatureDetector_create()
elif mode == featuresDetector.AKAZE:
detector = cv2.AKAZE_create()
elif mode == featuresDetector.BRISK:
detector = cv2.BRISK_create()
elif mode == featuresDetector.FAST:
detector = cv2.FastFeatureDetector_create()
elif mode == featuresDetector.KAZE:
detector = cv2.KAZE_create()
elif mode == featuresDetector.MSER:
detector = cv2.MSER_create()
elif mode == featuresDetector.ORB:
detector = cv2.ORB_create()
elif mode == featuresDetector.SIFT:
detector = cv2.xfeatures2d.SIFT_create()
elif mode == featuresDetector.SimpleBlob:
detector = cv2.SimpleBlobDetector_create()
keypoints = detector.detect(img)
descriptors = detector.compute(img, keypoints)
return descriptors
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, 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 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):
self._det = cv2.AgastFeatureDetector_create(threshold=30)
self._desc = cv2.ORB_create()
self.perf = PerfCounter()
FLANN_INDEX_LSH = 6
index_params = dict(algorithm = FLANN_INDEX_LSH, table_number = 6, key_size = 12, multi_probe_level = 1)
search_params = dict(checks = 50)
self._matcher = cv2.FlannBasedMatcher(index_params, search_params)
def dCreate(_detType, _desType):
print('Detector : ' + _detType)
print('Descriptor: ' + _desType)
""" Keypoint Detector """
if _detType == 'SIFT':
detect_ = cv2.xfeatures2d.SIFT_create()
elif _detType == 'SURF':
detect_ = cv2.xfeatures2d.SURF_create()
elif _detType == 'ORB':
detect_ = cv2.ORB_create()
elif _detType == 'AGAST':
detect_ = cv2.AgastFeatureDetector_create()
elif _detType == 'AKAZE':
detect_ = cv2.AKAZE_create()
else:
detect_ = cv2.ORB_create()
print('No keypoint detection method is specified.')
print('Use ORB detector.')
""" Keypoint Descriptor """
if _desType == 'SIFT':
descript_ = cv2.xfeatures2d.SIFT_create()
elif _desType == 'SURF':
descript_ = cv2.xfeatures2d.SURF_create()
elif _desType == 'DAISY':
descript_ = cv2.xfeatures2d.DAISY_create()
elif _desType == 'ORB':
descript_ = cv2.ORB_create()
elif _desType == 'BRISK':
descript_ = cv2.BRISK_create()
elif _desType == 'FREAK':
descript_ = cv2.xfeatures2d.FREAK_create()
elif _desType == 'AKAZE':
descript_ = cv2.AKAZE_create()
else:
descript_ = cv2.ORB_create()
print('No keypoint description method is specified.')
print('Use ORB descriptor.')
return [detect_, descript_]
def detect(self):
src_image = self.get_opencv_image()
if src_image.all() != None:
detector = cv2.AgastFeatureDetector_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 agast(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
agast = cv.AgastFeatureDetector_create()
brief = cv.xfeatures2d.BriefDescriptorExtractor_create()
#Detecta Rasgos y Calcula el descriptor
kpa= agast.detect(img1,None)
kp1,des1=brief.compute(img1,kpa)
kpb= agast.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 agast(detector, emparejador):
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
# Initiate SIFT detector
agast = cv.AgastFeatureDetector_create()
brief = cv.xfeatures2d.BriefDescriptorExtractor_create()
# find the keypoints and descriptors with SIFT
kpa = agast.detect(img1, None)
kp1, des1 = brief.compute(img1, kpa)
kpb = agast.detect(img2, None)
kp2, des2 = brief.compute(img2, kpb)
menu_emparejamiento(emparejador, kp1, des1, kp2, des2, img1, img2)
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 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 detechAndDescribe(self, image):
# 단일 채널인 grayscale로 전환
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# 버전 체크 (__init__참고)를 하여 버전에 맞는 SIFT 알고리즘을 사용함.
# SIFT 결과로 특징 점들과 디스크립터를 튜플의 형태로 받는다.
if self.isv3:
descriptor = cv2.xfeatures2d.SIFT_create()
(kps, features) = descriptor.detectAndCompute(image, None)
else:
detector = cv2.AgastFeatureDetector_create("SIFT")
kps = detector.detect(gray)
extractor = cv2.BOWImgDescriptorExtractor("SIFT")
(kps, features) = extractor.compute(gray, kps)
# 특징점을 KeyPoint 객체에서 numpy 배열로 전환
kps = np.float32([kp.pt for kp in kps])
# 특징점과 특징을 튜플로 반환함 eturn a tuple of keypoints and features
return (kps, features)
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
3: cv.AGAST_FEATURE_DETECTOR_OAST_9_16,
}
# Set Agast detector parameter callbacks
cv.createTrackbar("Threshold", "Agast", 15, 50, f)
cv.createTrackbar("Non Max Suppression", "Agast", 1, 1, f)
cv.createTrackbar("Type", "Agast", 0, len(detector_types) - 1, f)
while True:
agast_threshold = cv.getTrackbarPos("Threshold", "Agast")
non_max_suppression = cv.getTrackbarPos("Non Max Suppression", "Agast")
current_type = cv.getTrackbarPos("Type", "Agast")
agast = cv.AgastFeatureDetector_create(
threshold=agast_threshold,
nonmaxSuppression=non_max_suppression,
type=detector_types[current_type],
)
# find the keypoints with Agast
kp = agast.detect(img, None)
# draw only keypoints location,not size and orientation
img2 = cv.drawKeypoints(img, kp, None, color=(0, 255, 0))
cv.imshow("Agast", img2)
if cv.waitKey(10) & 0xFF == 27:
break
cv.destroyAllWindows()
from typing import List, Tuple, Iterable, Optional
import numpy as np
import cv2 as cv
import numpy as np
import time
from util.collection_util import *
from functools import reduce
from motion_match import MotionMatch, KP
#### Detectors, fastest first. (fast is a bit faster but agast is a bit better. Orb offers sparse but good quality features and surf is very good but very slow) :
#fast = cv.FastFeatureDetector_create(threshold=5, nonmaxSuppression=True, type=cv.FastFeatureDetector_TYPE_9_16)
agast = cv.AgastFeatureDetector_create(threshold=5, nonmaxSuppression=True, type=cv.AgastFeatureDetector_OAST_9_16)
orb_dtc = cv.ORB_create(edgeThreshold=24, patchSize=31, nlevels=3, fastThreshold=8, scaleFactor=1.2, WTA_K=2, scoreType=cv.ORB_HARRIS_SCORE, firstLevel=0, nfeatures=6000)
## SURF Defaults : hessianThreshold=100, nOctaves=4, nOctaveLayers=3, extended=False, upright=False
#surf_dtc = cv.xfeatures2d.SURF_create(hessianThreshold=10, nOctaves=4, nOctaveLayers=3, extended=False, upright=True)
default_dtc = agast
#### Descriptors, Matchers, and match-distance result scale (worst to best. orb and brief are good choices)
surf_dsc = (cv.xfeatures2d.SURF_create(hessianThreshold=10,nOctaves=4,nOctaveLayers=3,extended=False,upright=True),
cv.BFMatcher_create(normType=cv.NORM_L1), 1 / (1))
orb_dsc = (cv.ORB_create(edgeThreshold=24, patchSize=31, nlevels=8, fastThreshold=14, scaleFactor=1.2, WTA_K=2, scoreType=cv.ORB_HARRIS_SCORE, firstLevel=0, nfeatures=6000),
cv.BFMatcher_create(normType=cv.NORM_HAMMING), 1 / (18))
brief = (cv.xfeatures2d.BriefDescriptorExtractor_create(bytes=32, use_orientation=False),
cv.BFMatcher_create(normType=cv.NORM_HAMMING), 1 / (12))
sift = (cv.xfeatures2d.SIFT_create(nOctaveLayers=3, contrastThreshold=0.01, edgeThreshold=100.0, sigma=1.6),
cv.BFMatcher_create(normType=cv.NORM_L1), 1 / (500))
default_dsc = brief
def computeMotion(imgs: Iterable[np.ndarray], degree: int = 1, detector: cv.Feature2D = default_dtc,
descriptor: cv.Feature2D = default_dsc[0], matcher: cv.DescriptorMatcher = default_dsc[1],
distscale: float = default_dsc[2], dist_thresh: float = 1.5, better_thresh: float = 1.5
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)
def __init__(self,
image_topic,
depth_image_topic,
pose_topic,
detector,
descriptor,
focal_length,
chi,
alpha,
realtime=False):
self.camera_model = DoubleSphereModel(focal_length, chi, alpha)
if detector == 'FAST':
self.detector = cv2.FastFeatureDetector_create(threshold=50)
elif detector == 'SIFT':
self.detector = cv2.xfeatures2d.SIFT_create(nfeatures=5000)
elif detector == 'SURF':
self.detector = cv2.xfeatures2d.SURF_create(hessianThreshold=500)
elif detector == 'ORB':
self.detector = cv2.ORB_create(nfeatures=5000)
elif detector == 'BRISK':
self.detector = cv2.BRISK_create(thresh=50)
elif detector == 'STAR':
self.detector = cv2.xfeatures2d.StarDetector_create()
elif detector == 'AKAZE':
self.detector = cv2.AKAZE_create(threshold=0.001)
elif detector == 'KAZE':
self.detector = cv2.KAZE_create(threshold=0.001)
elif detector == 'AGAST':
self.detector = cv2.AgastFeatureDetector_create(threshold=65)
else:
print 'Invalid feature detector specified'
self.rgb = False
self.vgg = False
if descriptor == 'SIFT':
self.descriptor = cv2.xfeatures2d.SIFT_create(nfeatures=5000)
elif descriptor == 'SURF':
self.descriptor = cv2.xfeatures2d.SURF_create()
elif descriptor == 'ORB':
self.descriptor = cv2.ORB_create(nfeatures=5000)
elif descriptor == 'BRISK':
self.descriptor = cv2.BRISK_create(thresh=50, octaves=3)
elif descriptor == 'AKAZE':
self.descriptor = cv2.AKAZE_create()
elif descriptor == 'KAZE':
self.descriptor = cv2.KAZE_create()
elif descriptor == 'FREAK':
self.descriptor = cv2.xfeatures2d.FREAK_create()
elif descriptor == 'DAISY':
self.descriptor = cv2.xfeatures2d.DAISY_create()
elif descriptor == 'LUCID':
self.descriptor = cv2.xfeatures2d.LUCID_create()
self.rgb = True
elif descriptor == 'LATCH':
self.descriptor = cv2.xfeatures2d.LATCH_create()
elif descriptor == 'VGG':
self.descriptor = cv2.xfeatures2d.VGG_create()
self.vgg = True
elif descriptor == 'BOOST':
scale = 1.5
if detector == 'KAZE' or detector == 'SURF':
scale = 6.25
if detector == 'SIFT':
scale = 6.75
elif detector == 'AKAZE' or detector == 'AGAST' or detector == 'FAST' or detector == 'BRISK':
scale = 5.0
elif detector == 'ORB':
scale = 0.75
self.descriptor = cv2.xfeatures2d.BoostDesc_create(
scale_factor=scale)
np.random.seed(3)
if descriptor == '' and (
detector == 'SIFT' or detector == 'SURF' or detector == 'KAZE'
) or descriptor == 'SIFT' or descriptor == 'SURF' or descriptor == 'KAZE' or descriptor == 'DAISY' or descriptor == 'LUCID' or descriptor == 'VGG':
self.matcher = cv2.BFMatcher(cv2.NORM_L2, crossCheck=True)
elif descriptor == '' and (
detector == 'ORB' or detector == 'BRISK' or detector == 'AKAZE'
) or descriptor == 'ORB' or descriptor == 'BRISK' or descriptor == 'AKAZE' or descriptor == 'FREAK' or descriptor == 'LATCH' or descriptor == 'BOOST':
self.matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
self.color = np.random.randint(0, 200, (32768, 3))
self.frame_inx = 0
self.num_matches = []
self.recall = []
self.precision = []
self.t = tf.TransformListener()
self.old_tf = geometry_msgs.msg.TransformStamped()
self.image_pub = rospy.Publisher("/matcher/matches",
Image,
queue_size=2)
self.bridge = CvBridge()
if realtime:
self.image_sub = message_filters.Subscriber(image_topic, Image)
self.depth_sub = message_filters.Subscriber(
depth_image_topic, Image)
self.pose_sub = message_filters.Subscriber(pose_topic, PoseStamped)
self.sync = message_filters.ApproximateTimeSynchronizer(
[self.image_sub, self.depth_sub, self.pose_sub],
queue_size=3,
slop=0.1)
self.sync.registerCallback(self.on_new_image)
detectorHasChanged = True
while True:
ret, frame = video_capture.read()
threshold = cv2.getTrackbarPos('Threshold', 'Keypoints')
key = cv2.waitKey(1)
if key == ord('1'):
detector = cv2.FastFeatureDetector_create(threshold=threshold)
detectorName = "FAST"
detectorHasChanged = True
elif key == ord('2'):
detector = cv2.AKAZE_create(threshold=threshold)
detectorName = "AKAZE"
detectorHasChanged = True
elif key == ord('3'):
detector = cv2.AgastFeatureDetector_create(threshold=threshold)
detectorName = "AGAST"
detectorHasChanged = True
elif key == ord('4'):
detector = cv2.ORB_create()
detectorName = "ORB"
detectorHasChanged = True
elif key == ord('q'):
break
initTime = datetime.datetime.now()
keypoints = detector.detect(frame, None)
endTime = datetime.datetime.now()
if detectorHasChanged:
print("Chosen detector: " + detectorName)
print("Calculation time for " + detectorName + " : " +
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
testSet = numpy.load("testSetInUint8.npy")
testLabels = numpy.load(preprocessing.testLabelPath).astype(numpy.float32)
except FileNotFoundError:
testSet, testLabels = preprocessing.loadTestSet()
numpy.save("testSetInUint8.npy", testSet)
#surf = cv2.ORB_create()
#surf.setFastThreshold(0)
#surf.setEdgeThreshold(0)
# surf = cv2.xfeatures2d.BriefDescriptorExtractor_create()
surf = cv2.xfeatures2d.SURF_create()
# surf = cv2.xfeatures2d.SIFT_create()
# det = cv2.xfeatures2d.StarDetector_create()
# det = cv2.xfeatures2d.SURF_create()
# det = cv2.xfeatures2d.SIFT_create()
det = cv2.AgastFeatureDetector_create()
#det = cv2.ORB_create()
#det.setFastThreshold(0)
#det.setEdgeThreshold(0)
print("Extracting train features")
try:
descriptors = pickle.load(open(descriptor+"allTrainDescriptors.pkl", "rb"))
except FileNotFoundError:
descriptors = {}
count = 0
for im in trainSet:
count += 1
if count % 100 == 0:
print(count/15000, end="\r", flush=True)
for i in range(5):
def setup(detector_type, descriptor_type):
binary_match = True
# Detector !
if detector_type == 'FAST':
detector = cv2.FastFeatureDetector_create()
if detector_type == 'ORB':
detector = cv2.ORB_create(nfeatures=100000)
if detector_type == 'AGAST':
detector = cv2.AgastFeatureDetector_create()
if detector_type == 'SURF':
detector = cv2.xfeatures2d.SURF_create()
if detector_type == 'SIFT':
detector = cv2.xfeatures2d.SIFT_create()
if detector_type == 'AKAZE':
detector = cv2.AKAZE_create()
#Descriptor
if descriptor_type == 'FAST':
descriptor = cv2.BRISK_create()
if descriptor_type == 'BRIEF':
descriptor = cv2.xfeatures2d.BriefDescriptorExtractor_create()
if descriptor_type == 'BRISK':
descriptor = cv2.BRISK_create()
if descriptor_type == 'ORB':
descriptor = cv2.ORB_create()
if descriptor_type == 'FREAK':
descriptor = cv2.xfeatures2d.FREAK_create()
if descriptor_type == 'AKAZE':
descriptor = cv2.AKAZE_create()
if descriptor_type == 'SIFT':
descriptor = cv2.xfeatures2d.SIFT_create()
binary_match = False
if descriptor_type == 'SURF':
descriptor = cv2.xfeatures2d.SURF_create()
binary_match = False
if binary_match is False:
FLANN_INDEX_KDTREE = 0
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50)
matcher = cv2.FlannBasedMatcher(index_params, search_params)
match_type = "FLANN Matcher"
# matches = flann.knnMatch(self.features_descriptors[-1], descriptor, k=2)
else:
matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
# matcher = cv2.BFMatcher(cv2.NORM_L1, crossCheck=False)
match_type = "Hamming Distance"
# matches = bf.knnMatch(self.features_descriptors[-1], descriptor, k=2)
print('Detector = ', detector_type)
print('Desc = ', descriptor_type)
print('Match =', match_type)
return detector, descriptor, matcher
