def epipolar_rectify(imL,imR,show_matches=True): descriptor_extractor = ORB(n_keypoints=2000) descriptor_extractor.detect_and_extract(imL) keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors descriptor_extractor.detect_and_extract(imR) keypoints2 = descriptor_extractor.keypoints descriptors2 = descriptor_extractor.descriptors matches12 = match_descriptors(descriptors1, descriptors2,metric='hamming', cross_check=True) pts1=keypoints1[matches12[:,0],:] pts2=keypoints2[matches12[:,1],:] F, mask = cv2.findFundamentalMat(pts1,pts2,cv2.FM_RANSAC) pts1 = pts1[mask.ravel()==1] pts2 = pts2[mask.ravel()==1] res,H1,H2=cv2.stereoRectifyUncalibrated(pts1,pts2,F,imL.shape,10) if show_matches: fig, ax = plt.subplots(nrows=1, ncols=1) plot_matches(ax, imL, imR, keypoints1, keypoints2, matches12) return H1,H2
def __init__(self, test_image, orb_file, verbose, testall): self.test_image = test_image self.orb_file = orb_file self.verbose = verbose self.testall = testall self.test_image_shape = None # training ORB features self.train_orb_features = np.load(self.orb_file) self.keypoints_test = None self.descriptors_test = None self.matches = None # test set (30 images from the original data) self.test_dir = "./test/" self.labels_file = os.path.join(self.test_dir, "labels.txt") self.test_dict = defaultdict(list) # predictions self.predicted_kprc = [ ] # (n, 2) for n train image features, stores n predicted keypoint in r, c format self.predicted_centroid_rc = np.array( [0, 0]) # final predicted r, c location of the object # clustering params self.db_thresh = 25 # 25 pixel DBSCAN clustering threshold self.descriptor_extractor = ORB(n_keypoints=50, fast_n=9, fast_threshold=0.15) # evaluation self.pck_at_dot05_thresh = 0.05
def iris_scan_orb(request): from skimage import io from skimage.feature import (match_descriptors, ORB) from skimage.color import rgb2gray from .settings import MEDIA_ROOT img1 = rgb2gray(io.imread(MEDIA_ROOT + '/IRIS3.jpg')) # Query img2 = rgb2gray(io.imread(MEDIA_ROOT + '/IRIS6.jpg')) # Comparing to descriptor_extractor = ORB(n_keypoints=200) descriptor_extractor.detect_and_extract(img1) keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors # Query Descriptor descriptor_extractor.detect_and_extract(img2) keypoints2 = descriptor_extractor.keypoints descriptors2 = descriptor_extractor.descriptors # Comparing To Descriptors matches12 = match_descriptors(descriptors1, descriptors2, cross_check=True) # print("Matched: ", len(matches12), " of ", len(descriptors1)) percent = len(matches12) / len(descriptors1) * 100 # print("Percent Match - ", percent, "%") """if percent > 80: print("Matched!") else: print("Not Matched!")""" return render(request, 'scan.html', {'percent': percent})
def test_keypoints_orb_less_than_desired_no_of_keypoints(): detector_extractor = ORB(n_keypoints=15, fast_n=12, fast_threshold=0.33, downscale=2, n_scales=2) detector_extractor.detect(img) exp_rows = np.array([ 67., 247., 269., 413., 435., 230., 264., 330., 372.]) exp_cols = np.array([ 157., 146., 111., 70., 180., 136., 336., 148., 156.]) exp_scales = np.array([ 1., 1., 1., 1., 1., 2., 2., 2., 2.]) exp_orientations = np.array([-105.76503839, -96.28973044, -53.08162354, -173.4479964 , -175.64733392, -106.07927215, -163.40016243, 75.80865813, -154.73195911]) exp_response = np.array([ 0.13197835, 0.24931321, 0.44351774, 0.39063076, 0.96770745, 0.04935129, 0.21431068, 0.15826555, 0.42403573]) assert_almost_equal(exp_rows, detector_extractor.keypoints[:, 0]) assert_almost_equal(exp_cols, detector_extractor.keypoints[:, 1]) assert_almost_equal(exp_scales, detector_extractor.scales) assert_almost_equal(exp_response, detector_extractor.responses) assert_almost_equal(exp_orientations, np.rad2deg(detector_extractor.orientations), 5) detector_extractor.detect_and_extract(img) assert_almost_equal(exp_rows, detector_extractor.keypoints[:, 0]) assert_almost_equal(exp_cols, detector_extractor.keypoints[:, 1])
def test_keypoints_orb_desired_no_of_keypoints(): detector_extractor = ORB(n_keypoints=10, fast_n=12, fast_threshold=0.20) detector_extractor.detect(img) exp_rows = np.array([ 435. , 435.6 , 376. , 455. , 434.88, 269. , 375.6 , 310.8 , 413. , 311.04]) exp_cols = np.array([ 180. , 180. , 156. , 176. , 180. , 111. , 156. , 172.8, 70. , 172.8]) exp_scales = np.array([ 1. , 1.2 , 1. , 1. , 1.44 , 1. , 1.2 , 1.2 , 1. , 1.728]) exp_orientations = np.array([-175.64733392, -167.94842949, -148.98350192, -142.03599837, -176.08535837, -53.08162354, -150.89208271, 97.7693776 , -173.4479964 , 38.66312042]) exp_response = np.array([ 0.96770745, 0.81027306, 0.72376257, 0.5626413 , 0.5097993 , 0.44351774, 0.39154173, 0.39084861, 0.39063076, 0.37602487]) assert_almost_equal(exp_rows, detector_extractor.keypoints[:, 0]) assert_almost_equal(exp_cols, detector_extractor.keypoints[:, 1]) assert_almost_equal(exp_scales, detector_extractor.scales) assert_almost_equal(exp_response, detector_extractor.responses) assert_almost_equal(exp_orientations, np.rad2deg(detector_extractor.orientations), 5) detector_extractor.detect_and_extract(img) assert_almost_equal(exp_rows, detector_extractor.keypoints[:, 0]) assert_almost_equal(exp_cols, detector_extractor.keypoints[:, 1])
def test_keypoints_orb_desired_no_of_keypoints(): detector_extractor = ORB(n_keypoints=10, fast_n=12, fast_threshold=0.20) detector_extractor.detect(img) exp_rows = np.array([ 141. , 108. , 214.56 , 131. , 214.272, 67. , 206. , 177. , 108. , 141. ]) exp_cols = np.array([ 323. , 328. , 282.24 , 292. , 281.664, 85. , 260. , 284. , 328.8 , 267. ]) exp_scales = np.array([1, 1, 1.44, 1, 1.728, 1, 1, 1, 1.2, 1]) exp_orientations = np.array([ -53.97446153, 59.5055285 , -96.01885186, -149.70789506, -94.70171899, -45.76429535, -51.49752849, 113.57081195, 63.30428063, -79.56091118]) exp_response = np.array([ 1.01168357, 0.82934145, 0.67784179, 0.57176438, 0.56637459, 0.52248355, 0.43696175, 0.42992376, 0.37700486, 0.36126832]) assert_almost_equal(exp_rows, detector_extractor.keypoints[:, 0]) assert_almost_equal(exp_cols, detector_extractor.keypoints[:, 1]) assert_almost_equal(exp_scales, detector_extractor.scales) assert_almost_equal(exp_response, detector_extractor.responses) assert_almost_equal(exp_orientations, np.rad2deg(detector_extractor.orientations), 5) detector_extractor.detect_and_extract(img) assert_almost_equal(exp_rows, detector_extractor.keypoints[:, 0]) assert_almost_equal(exp_cols, detector_extractor.keypoints[:, 1])
def detect_kp_desc(img, method='orb', n_keypoints=2000, **args): """Find keypoints and their descriptors on the image. img: `np.array` of shape == WxHx3 RGB image method: str Name of the method to use. Options are: ['orb', 'lf-net'] n_keypoints: int Number of keypoints to find **args: dict Other parameters to pass to keypoints detector without any chanages return: tuple (2,) Coordinates and descriptors of found keypoints """ if method == 'orb': detector_exctractor = ORB(n_keypoints=n_keypoints, **args) # detector_exctractor = cv2.ORB_create(nfeatures=n_keypoints, **args) elif method == 'lf-net': # https://github.com/vcg-uvic/lf-net-release raise NotImplemetedError() detector_exctractor.detect_and_extract(rgb2gray(img).astype(np.float64)) return detector_exctractor.keypoints, detector_exctractor.descriptors
def test_keypoints_orb_less_than_desired_no_of_keypoints(): detector_extractor = ORB(n_keypoints=15, fast_n=12, fast_threshold=0.33, downscale=2, n_scales=2) detector_extractor.detect(img) exp_rows = np.array([ 58., 65., 108., 140., 203.]) exp_cols = np.array([ 291., 130., 293., 202., 267.]) exp_scales = np.array([1., 1., 1., 1., 1.]) exp_orientations = np.array([-158.26941428, -59.42996346, 151.93905955, -79.46341354, -56.90052451]) exp_response = np.array([ 0.2667641 , 0.04009017, -0.17641695, -0.03243431, 0.26521259]) assert_almost_equal(exp_rows, detector_extractor.keypoints[:, 0]) assert_almost_equal(exp_cols, detector_extractor.keypoints[:, 1]) assert_almost_equal(exp_scales, detector_extractor.scales) assert_almost_equal(exp_response, detector_extractor.responses) assert_almost_equal(exp_orientations, np.rad2deg(detector_extractor.orientations), 5) detector_extractor.detect_and_extract(img) assert_almost_equal(exp_rows, detector_extractor.keypoints[:, 0]) assert_almost_equal(exp_cols, detector_extractor.keypoints[:, 1])
def iris_scan_orb_android(file_name): from skimage import io from skimage.feature import (match_descriptors, ORB) from skimage.color import rgb2gray from .settings import MEDIA_ROOT img1 = rgb2gray(io.imread(MEDIA_ROOT + '/'+ file_name)) # Query img2 = rgb2gray(io.imread(MEDIA_ROOT + '/IRIS9.jpg')) # Comparing to descriptor_extractor = ORB(n_keypoints=200) descriptor_extractor.detect_and_extract(img1) keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors # Query Descriptor descriptor_extractor.detect_and_extract(img2) keypoints2 = descriptor_extractor.keypoints descriptors2 = descriptor_extractor.descriptors # Comparing To Descriptors matches12 = match_descriptors(descriptors1, descriptors2, cross_check=True) percent = len(matches12) / len(descriptors1) * 100 return percent
def get_descriptor(img): descriptor_extractor = ORB(n_keypoints=100) descriptor_extractor.detect_and_extract(img) keypoints = descriptor_extractor.keypoints descriptors = descriptor_extractor.descriptors return keypoints, descriptors
def feature_extractor(image_path, options=None): """Extracts a set of features (described in config file) from an image. Args: image_path: the path to the image options: the configuration file settings. In this case the settings should contain relevant image processing feature options. Return: an array of features which depending on the config options """ features = [] image = imread(image_path) if 'grey_required' in options: grey_image = rgb2grey(image) # GLCM features if 'glcm' in options: glcm_config = options['glcm'] glcm_features = glcm.glcm_features(grey_image, glcm_config['modes']) features.append(glcm_features) # ORB features if 'orb' in options: orb_config = options['orb'] orb_extractor = ORB(downscale=orb_config['downscale'], n_scales=orb_config['n_scales'], n_keypoints=orb_config['n_keypoints'], fast_n=orb_config['fast_n'], fast_threshold=orb_config['fast_threshold'], harris_k=orb_config['harris_k']) orb_extractor.detect_and_extract(grey_image) # TODO add these to config system features.append(orb_extractor.keypoints.tolist()) # features.append(orb_extractor.scales.tolist()) # features.append(orb_extractor.orientations.tolist()) # features.append(orb_extractor.responses.tolist()) # features.append(orb_extractor.descriptors.tolist()) if 'kmeans' in options: k_image = np.array(image, dtype=np.float64) / 255 w, h, d = original_shape = tuple(k_image.shape) assert d == 3 image_array = np.reshape(k_image, (w * h, d)) kmeans = KMeans( n_clusters=options['kmeans']['clusters']).fit(image_array) features.append(kmeans.cluster_centers_.tolist()) return list(flatten.flatten(features))
def main(): baseImg = loadResized("base.jpg", 600, 410) atlasImg = loadResized("atlas.jpg", 600, 410) orb = (ORB(n_keypoints=800, fast_threshold=0.05), ORB(n_keypoints=800, fast_threshold=0.05)) orb[0].detect_and_extract(baseImg) orb[1].detect_and_extract(atlasImg) baseData = [orb[0].keypoints, orb[0].descriptors] atlasData = [orb[1].keypoints, orb[1].descriptors] match = match_descriptors(baseData[1], atlasData[1]) dst = baseData[0][match[:, 0]][:, ::-1] src = atlasData[0][match[:, 1]][:, ::-1] robust, inliers = ransac((src, dst), ProjectiveTransform, min_samples=4, residual_threshold=1, max_trials=300) r, c = baseImg.shape[:2] corners = np.array([[0, 0], [0, r], [c, 0], [c, r]]) warpedCorners = robust(corners) allCorners = np.vstack((warpedCorners, corners)) cornerMin = np.min(allCorners, axis=0) cornerMax = np.max(allCorners, axis=0) outputShape = (cornerMax - cornerMin) outputShape = np.ceil(outputShape[::-1]).astype(int) offSet = SimilarityTransform(translation=cornerMin) atlasWarped = warp(atlasImg, offSet.inverse, order=3, output_shape=outputShape, cval=-1) atlasMask = (atlasWarped != -1) atlasWarped[~atlasMask] = 0 fig, ax = plt.subplots(figsize=(12, 12)) diffImg = atlasWarped - baseImg ax.imshow(diffImg, cmap="gray") ax.axis("off") plt.show() compare(atlasWarped, baseImg, figsize=(12, 10)) costs = generateCosts(np.abs(atlasWarped, baseImg), atlasWarped & baseImg) fig, ax = plt.subplots(figsize=(15, 12)) ax.imshow(costs, cmap="gray", interpolation="none") ax.axis("off") outputImg = cv2.addWeighted(baseImg, .3, atlasImg, 1, 0) cv2.imshow("Output", outputImg) cv2.waitKey(0) cv2.destroyAllWindows()
def calc_orb(*imgs): descriptor_extractor = ORB(n_keypoints=100) for c_img in imgs: descriptor_extractor.detect_and_extract(c_img) yield { "keypoints": descriptor_extractor.keypoints, "descriptors": descriptor_extractor.descriptors, }
def selectFeatures(useList): DataSet = [] LabelSet = [] lengthV = [] trainPaths = ['./fruit/' + c + '_train/' for c in classes] testPaths = ['./fruit/' + c + ' test/' for c in classes] for c in range(len(classes)): className = classes[c] path = trainPaths[c] detector = CENSURE() detector2 = ORB(n_keypoints=50) detector3 = BRIEF(patch_size=49) files = os.listdir(path) #sample files = random.sample(files, 100) nfiles = len(files) for i in range(nfiles): featureVector = [] infile = files[i] img = io.imread(path + infile, as_grey=True) hist = np.histogram(img, bins=256) img = resize(img, (400, 400)) detector2.detect_and_extract(img) detector.detect(img) a = fd = hog(img, orientations=9, pixels_per_cell=(32, 32), cells_per_block=(1, 1), visualise=False) for h in hist: fd = np.append(fd, h) if (useList[0]): fd = np.append(fd, [np.array(detector.keypoints).flatten()]) if (useList[1]): fd = np.append(fd, detector2.keypoints) if (useList[2]): fd = np.append(fd, edgeExtract(img, 100)) l1 = len(fd) corners = corner_peaks(corner_harris(img), min_distance=1) if (useList[3]): fd = np.append(fd, corners) lengthV.append(len(fd)) DataSet.append(fd) ind = classes.index(className) LabelSet.append(ind) max = np.amax(lengthV) lengthV = [] DataSet2 = [] for d in DataSet: d = np.pad(d, (0, max - len(d)), 'constant') DataSet2.append(d) lengthV.append(len(d)) DataSet = DataSet2 res = 0 #perform gridsearch with one thread if __name__ == '__main__': res = gridSearch(DataSet, LabelSet, False) return res
def __init__(self, name, startGID=0): super(PanormaGroup, self).__init__(name, startGID=startGID) # "Oriented FAST and rotated BRIEF" feature detector self.orb = ORB(n_keypoints=4000, fast_threshold=0.05) # self.ImagesWithOverlap = [] # List to store images which has overlap self.ImagesKeypointsDescriptors = [ ] # List of tuples storing ORB (keypoints, descrioptors) # Minus one to compensate for the increment which will happen for the first image self.CurrentGroupID -= 1
class PanormaGroup(GroupChecker): """ This is to check wheter the new image can be considered to be part of a panorama of previous image Based on: http://nbviewer.ipython.org/github/scikit-image/skimage-demos/blob/master/pano/pano.ipynb?raw=true """ def __init__(self, name, startGID = 0): super(PanormaGroup,self).__init__(name, startGID = startGID) # "Oriented FAST and rotated BRIEF" feature detector self.orb = ORB(n_keypoints=4000, fast_threshold=0.05) # self.ImagesWithOverlap = [] # List to store images which has overlap self.ImagesKeypointsDescriptors = [] # List of tuples storing ORB (keypoints, descrioptors) # Minus one to compensate for the increment which will happen for the first image self.CurrentGroupID -= 1 def NextGID(self,image): """ Calculates the next Group ID for the input image """ NewImg = self.LoadImage(image,Greyscale=True,scale=0.25) self.orb.detect_and_extract(NewImg) NewImgKeyDescr = (self.orb.keypoints, self.orb.descriptors) for PreImgKeyDescr in reversed(self.ImagesKeypointsDescriptors): # Check for overlap matcheOfDesc = match_descriptors(PreImgKeyDescr[1], NewImgKeyDescr[1], cross_check=True) # Select keypoints from the source (image to be registered) # and target (reference image) src = NewImgKeyDescr[0][matcheOfDesc[:, 1]][:, ::-1] dst = PreImgKeyDescr[0][matcheOfDesc[:, 0]][:, ::-1] model_robust, inliers = ransac((src, dst), ProjectiveTransform, min_samples=4, residual_threshold=1, max_trials=300) NumberOfTrueMatches = np.sum(inliers) #len(inliers[inliers]) if NumberOfTrueMatches > 100 : # Image has overlap logger.debug('Image {0} found a match! (No: of Matches={1})'.format(image,NumberOfTrueMatches)) break else : logger.debug('Image {0} not matching..(No: of Matches={1})'.format(image,NumberOfTrueMatches)) continue else: # None of the images in the for loop has any overlap...So this is a new Group self.ImagesKeypointsDescriptors = [] # Erase all previous group items # self.ImagesWithOverlap = [] # Increment Group ID self.CurrentGroupID += 1 logger.debug('Starting a new Panorama group (GID={0})'.format(self.CurrentGroupID)) # Append the latest image to the current group self.ImagesKeypointsDescriptors.append(NewImgKeyDescr) # self.ImagesWithOverlap.append(NewImg) # Return the current group ID return self.CurrentGroupID
def get_displacement(image0, image1): """ Gets displacement (in pixels I think) difference between 2 images using scikit-image not as accurate as the opencv version i think. :param image0: reference image :param image1: target image :return: """ from skimage.feature import (match_descriptors, ORB, plot_matches) from skimage.color import rgb2gray from scipy.spatial.distance import hamming from scipy import misc image0_gray = rgb2gray(image0) image1_gray = rgb2gray(image1) descriptor_extractor = ORB(n_keypoints=200) descriptor_extractor.detect_and_extract(image0_gray) keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors descriptor_extractor.detect_and_extract(image1_gray) keypoints2 = descriptor_extractor.keypoints descriptors2 = descriptor_extractor.descriptors matches12 = match_descriptors(descriptors1, descriptors2, cross_check=True) # Sort the matches based on distance. Least distance # is better distances12 = [] for match in matches12: distance = hamming(descriptors1[match[0]], descriptors2[match[1]]) distances12.append(distance) indices = np.arange(len(matches12)) indices = [index for (_, index) in sorted(zip(distances12, indices))] matches12 = matches12[indices] # collect displacement from the first 10 matches dx_list = [] dy_list = [] for mat in matches12[:10]: # Get the matching key points for each of the images img1_idx = mat[0] img2_idx = mat[1] # x - columns # y - rows (x1, y1) = keypoints1[img1_idx] (x2, y2) = keypoints2[img2_idx] dx_list.append(abs(x1 - x2)) dy_list.append(abs(y1 - y2)) dx_median = np.median(np.asarray(dx_list, dtype=np.double)) dy_median = np.median(np.asarray(dy_list, dtype=np.double)) # plot_matches(image0, image1, descriptors1, descriptors2, matches12[:10]) return dx_median, dy_median
def load_descriptors(file_names, num_keypoints=200): # Load images descriptor_extractor = ORB(n_keypoints=num_keypoints) descriptors = [] for im_path in file_names: img = plt.imread("data/" + im_path) img = rgb2gray(img) descriptor_extractor.detect_and_extract(img) descriptors.append(descriptor_extractor.descriptors) return np.array(descriptors)
def image_features_orb(img,keypoints): # X is the feature vector with one row of features per image # Xsize=2*keypoints X=np.zeros(Xsize, dtype=float) # extract patches using scikit library. orb=ORB(downscale=1.2, n_scales=8, n_keypoints=keypoints, fast_n=4, fast_threshold=0.00001, harris_k=0.01) orb.detect_and_extract(img) X[0:Xsize] = np.reshape(orb.keypoints,(1, Xsize)) return X
def getORB(img, kpn=200): # extract features descriptor_extractor = ORB(n_keypoints=kpn) # get the good stuff descriptor_extractor.detect_and_extract(img) keys = descriptor_extractor.keypoints # convert bool to nums descs = descriptor_extractor.descriptors * 1.0 return keys, descs
def orb_extractor(img, n_keypoints=100): """Try orb binary descriptor using binaries created by Otsu's method.""" descriptor_extractor = ORB(n_keypoints) """ Extract descriptors for the original images """ descriptor_extractor.detect_and_extract(img) keypoints = descriptor_extractor.keypoints descriptors = descriptor_extractor.descriptors return (keypoints, descriptors)
def calculate(self, resource): except_image_only(resource) im = image2numpy(resource.image, remap='gray') extractor = ORB() extractor.detect_and_extract(im) return (extractor.descriptors, extractor.keypoints[:,0], extractor.keypoints[:,1], extractor.responses, extractor.scales, extractor.orientations)
def orb_extractor(img, n_keypoints=100): """Try orb binary descriptor using binaries created by Otsu's method.""" descriptor_extractor = ORB(n_keypoints) """ Extract descriptors for the original images """ descriptor_extractor.detect_and_extract(img) keypoints = descriptor_extractor.keypoints descriptors = descriptor_extractor.descriptors return(keypoints, descriptors)
def orb_descriptors(img, keypoints=800): """ Вычисление ORB дескрипторов. Params: img - изображение keypoints - максимальное количество точек детектора Return: np.array - массив дескрипторов (как минмум двумерный) """ extractor = ORB(n_keypoints=keypoints) extractor.detect_and_extract(img) return extractor.descriptors
def FindRetinaFeatures(Image): """ this function finds strong features in the image to use for registration. :param Image: the images to find the features in :return: """ Image = gaussian_filter(Image, 3) orb = ORB(n_keypoints=200) orb.detect_and_extract(Image) keypoints = orb.keypoints descriptors = orb.descriptors return keypoints, descriptors
def orb_feature(image): """ 提取图像的orb特征 :param image: :return: """ image_gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY) orb = ORB(n_keypoints=50) orb.detect_and_extract(image_gray) descriptors = orb.descriptors keypoints = orb.keypoints return keypoints
def orb_extractor_generator(stack): """Orb binary descriptor generator This returns a descriptor object. The descriptor object encodes both keypoints and descriptors. """ """Set parameters""" number_of_keypoints = 10 """Get descriptor_extractor object""" for img in stack: descriptor_extractor = ORB(n_keypoints=number_of_keypoints) descriptor_extractor.detect_and_extract(img) yield descriptor_extractor
def __next__(self): from skimage import transform as tf from skimage.feature import (match_descriptors, corner_harris, corner_peaks, ORB, plot_matches) from skimage.color import rgb2gray img1 = rgb2gray(self.image) descriptor_extractor = ORB(n_keypoints=200) descriptor_extractor.detect_and_extract(img1) keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors for x,y in keypoints1: yield ((x,y))
def orb(img): img1 = rgb2gray(img) img2 = transform.rotate(img1, 180) tform = transform.AffineTransform(scale=(1.3, 1.1), rotation=0.5, translation=(0, -200)) img3 = transform.warp(img1, tform) descriptor_extractor = ORB(n_keypoints=200) descriptor_extractor.detect_and_extract(img1) keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors descriptor_extractor.detect_and_extract(img2) keypoints2 = descriptor_extractor.keypoints descriptors2 = descriptor_extractor.descriptors descriptor_extractor.detect_and_extract(img3) keypoints3 = descriptor_extractor.keypoints descriptors3 = descriptor_extractor.descriptors matches1 = match_descriptors(descriptors1, descriptors2, cross_check=True) matches2 = match_descriptors(descriptors1, descriptors3, cross_check=True) return np.hstack( (keypoints1[matches1[:, 0]].ravel(), keypoints2[matches2[:, 1]].ravel()))
def test_descriptor_orb(): detector_extractor = ORB(fast_n=12, fast_threshold=0.20) exp_descriptors = np.array( [[0, 1, 1, 1, 0, 1, 0, 1, 0, 1], [1, 1, 1, 0, 0, 1, 0, 0, 1, 1], [1, 0, 1, 1, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 0, 0, 0, 0, 1, 0], [1, 1, 0, 1, 1, 1, 0, 0, 1, 1], [1, 1, 0, 1, 0, 0, 1, 0, 1, 1], [0, 0, 1, 0, 1, 0, 0, 1, 1, 0], [1, 0, 0, 0, 1, 0, 0, 0, 0, 1], [0, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 0, 1, 0, 1, 0, 0, 1, 1], [1, 1, 1, 0, 0, 0, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 0, 0, 0, 0], [1, 1, 1, 0, 1, 1, 1, 1, 0, 0], [1, 1, 0, 0, 1, 0, 0, 1, 0, 1], [1, 1, 0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 1, 1, 1, 0, 1, 0], [0, 0, 0, 0, 1, 1, 1, 0, 0, 1], [0, 0, 0, 0, 0, 1, 1, 0, 1, 1], [0, 0, 0, 0, 1, 0, 1, 0, 1, 1]], dtype=bool) detector_extractor.detect(img) detector_extractor.extract(img, detector_extractor.keypoints, detector_extractor.scales, detector_extractor.orientations) assert_equal(exp_descriptors, detector_extractor.descriptors[100:120, 10:20]) detector_extractor.detect_and_extract(img) assert_equal(exp_descriptors, detector_extractor.descriptors[100:120, 10:20])
def find_orb(img, keypoints=500): """Find keypoints and their descriptors in image. img ((W, H, 3) np.ndarray) : 3-channel image n_keypoints (int) : number of keypoints to find Returns: (N, 2) np.ndarray : keypoints (N, 256) np.ndarray, type=np.bool : descriptors """ extractor = ORB(n_keypoints=keypoints) grey_img = rgb2gray(img) extractor.detect_and_extract(grey_img) return extractor.keypoints, extractor.descriptors
def findH(img1, img2): from skimage.feature import ORB, match_descriptors # load image img1_gray = skimage.color.rgb2gray(img1) img2_gray = skimage.color.rgb2gray(img2) # extract points detector_extractor1 = ORB(n_keypoints=3000) detector_extractor1.detect_and_extract(img1_gray) detector_extractor2 = ORB(n_keypoints=3000) detector_extractor2.detect_and_extract(img2_gray) matches = match_descriptors(detector_extractor1.descriptors, detector_extractor2.descriptors) match_pts1 = detector_extractor1.keypoints[matches[:, 0]].astype(int) match_pts2 = detector_extractor2.keypoints[matches[:, 1]].astype(int) # call RANSAC match_pts1 = np.flip(match_pts1, axis=1) match_pts2 = np.flip(match_pts2, axis=1) H_2to1, _ = computeHransac(match_pts1, match_pts2) H_2to1 = H_2to1 / H_2to1[2, 2] print('tranform H:') print(H_2to1) return H_2to1
def keypoint_extractor(img_dir_list): # orb = cv2.ORB_create(nfeatures=100) orb = ORB(n_keypoints=100) descriptors = [] for index, i in enumerate(img_dir_list): img_name = os.path.join(base_path, img_list + "\\" + i) # image = cv2.imread(img_name) # image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) image = io.imread(img_name) image = color.rgb2gray(image) # train_keypoints, train_descriptor = orb.detectAndCompute(image , None) orb.detect_and_extract(image) descriptors.append(orb.descriptors) print(index) return descriptors
def extract_features(self): '''Extract interest points and their feature vector (descriptors)''' self.keypoints, self.descriptors, self.corners = [], [], np.empty( (self.num_imgs, 4, 2)) orb = ORB(n_keypoints=1000, fast_threshold=0.05) for idx, img in enumerate(self.grays): orb.detect_and_extract(img) self.keypoints.append(orb.keypoints) self.descriptors.append(orb.descriptors) # get 4 corners of images r, c = img.shape self.corners[idx] = np.array([[0, 0], [0, r], [c, 0], [c, r]])
def FindRetinaFeatures(Image): """ this function finds strong features in the image to use for registration. :param Image: the images to find the features in :return: """ Image = read_image(Image, 1) plt.imshow(Image, cmap='gray') orb = ORB(n_keypoints=50, harris_k=20) orb.detect_and_extract(Image) key_points = orb.keypoints plt.scatter(key_points[:, 0], key_points[:, 1]) plt.ylim(BOTTOM_CAPTION, 0) # removing the caption at the bottom plt.title("Retina Features") plt.show()
def find_orb(img, n_keypoints=N_KEYPOINTS): """Find keypoints and their descriptors in image. img ((W, H, 3) np.ndarray) : 3-channel image n_keypoints (int) : number of keypoints to find Returns: (N, 2) np.ndarray : keypoints (N, 256) np.ndarray, type=np.bool : descriptors """ # your code here orb = ORB(n_keypoints=n_keypoints) orb.detect_and_extract(rgb2gray(img)) return (orb.keypoints, orb.descriptors)
def register_image_pair(idx, path_img_target, path_img_source, path_out): """ register two images together :param int idx: empty parameter for using the function in parallel :param str path_img_target: path to the target image :param str path_img_source: path to the source image :param str path_out: path for exporting the output :return tuple(str,float): """ start = time.time() # load and denoise reference image img_target = io.imread(path_img_target)[..., :3] img_target = denoise_wavelet(img_target, wavelet_levels=7, multichannel=True) img_target_gray = rgb2gray(img_target) # load and denoise moving image img_source = io.imread(path_img_source)[..., :3] img_source = denoise_bilateral(img_source, sigma_color=0.05, sigma_spatial=2, multichannel=True) img_source_gray = rgb2gray(img_source) # detect ORB features on both images detector_target = ORB(n_keypoints=150) detector_source = ORB(n_keypoints=150) detector_target.detect_and_extract(img_target_gray) detector_source.detect_and_extract(img_source_gray) matches = match_descriptors(detector_target.descriptors, detector_source.descriptors) # robustly estimate affine transform model with RANSAC model, _ = ransac( (detector_target.keypoints[matches[:, 0]], detector_source.keypoints[matches[:, 1]]), AffineTransform, min_samples=25, max_trials=500, residual_threshold=0.9, ) # warping source image with estimated transformations path_img_warped = os.path.join(path_out, NAME_IMAGE_WARPED % idx) if model: img_warped = warp(img_target, model.inverse, output_shape=img_target.shape[:2]) try: io.imsave(path_img_warped, img_warped) except Exception: traceback.print_exc() else: warnings.warn("Image registration failed.", RuntimeWarning) path_img_warped = None # summarise experiment execution_time = time.time() - start return path_img_warped, execution_time
def keypoint_extractor_test(img_dir_list): # orb = cv2.ORB_create(nfeatures=100) orb = ORB(n_keypoints=100) descriptors = [] keypoints = [] for i in img_dir_list: # image = cv2.imread(img_name) # image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) image = io.imread(i) image = color.rgb2gray(image) # train_keypoints, train_descriptor = orb.detectAndCompute(image , None) orb.detect_and_extract(image) descriptors.append(orb.descriptors) keypoints.append(orb.keypoints) return descriptors, keypoints
def get_matrix(image_tif_bgrn, image_jpg_bgr, verbose=False): """Get similarity transform matrix ORB Limitation: https://github.com/scikit-image/scikit-image/issues/1472 """ im_tif_adjusted = match_color_curve_tif2jpg(image_tif_bgrn, image_jpg_bgr) jpg_gray = cv2.cvtColor(image_jpg_bgr, cv2.COLOR_BGR2GRAY).astype(np.uint8) tif_gray = cv2.cvtColor(im_tif_adjusted, cv2.COLOR_BGR2GRAY).astype(np.uint8) number_of_keypoints = 100 # Initialize ORB # This number of keypoints is large enough for robust results, # but low enough to run quickly. orb = ORB(n_keypoints=number_of_keypoints, fast_threshold=0.05) orb2 = ORB(n_keypoints=number_of_keypoints, fast_threshold=0.05) try: # Detect keypoints orb.detect_and_extract(jpg_gray) keypoints_jpg = orb.keypoints descriptors_jpg = orb.descriptors orb2.detect_and_extract(tif_gray) keypoints_tif = orb2.keypoints descriptors_tif = orb2.descriptors except IndexError: raise KeypointDetectionException('ORB Keypoint detection failed') # Match descriptors between images matches = match_descriptors(descriptors_jpg, descriptors_tif, cross_check=True) # Select keypoints from # * source (image to be registered) # * target (reference image) src = keypoints_jpg[matches[:, 0]][:, ::-1] dst = keypoints_tif[matches[:, 1]][:, ::-1] model_robust, inliers = ransac((src, dst), TranslationTransform, min_samples=4, residual_threshold=1, max_trials=300) if verbose: print(inliers) print("number of matching keypoints", np.sum(inliers)) if inliers is None or np.sum(inliers) < 3 or model_robust is None: raise ValueError('Possible mismatched JPG and TIF') if is_translational(model_robust): # we assume src and dst are not rotated relative to each other # get rid of any rotational noise introduced during normalization/centering in transform estimate function model_robust.params[0, 0] = 1.0 model_robust.params[1, 1] = 1.0 return model_robust else: raise ValueError('Invalid Model')
def __init__(self, train_dir, verbose): self.train_dir = train_dir self.verbose = verbose self.labels_file = os.path.join(self.train_dir, "labels.txt") self.train_on_full_data = True self.n_train = 100 self.train_dict = defaultdict(list) self.thresh = 25 # 25 pixel threshold to decide if the detected ORB keypoint is within this threshold of the ground truth object location self.descriptor_extractor = ORB(n_keypoints=50, fast_n=9, fast_threshold=0.15) self.all_train_descriptors = [] self.train_descriptor_outfile = os.path.join(os.getcwd(), "train_descriptors.npy")
def __init__(self, name, startGID = 0): super(PanormaGroup,self).__init__(name, startGID = startGID) # "Oriented FAST and rotated BRIEF" feature detector self.orb = ORB(n_keypoints=4000, fast_threshold=0.05) # self.ImagesWithOverlap = [] # List to store images which has overlap self.ImagesKeypointsDescriptors = [] # List of tuples storing ORB (keypoints, descrioptors) # Minus one to compensate for the increment which will happen for the first image self.CurrentGroupID -= 1
def getDisplacement(Image0, Image1): Image0Gray = rgb2gray(Image0) Image1Gray = rgb2gray(Image1) descriptor_extractor = ORB(n_keypoints=200) descriptor_extractor.detect_and_extract(Image0Gray) keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors descriptor_extractor.detect_and_extract(Image1Gray) keypoints2 = descriptor_extractor.keypoints descriptors2 = descriptor_extractor.descriptors matches12 = match_descriptors(descriptors1, descriptors2, cross_check=True) # Sort the matches based on distance. Least distance # is better distances12 = [] for match in matches12: distance = hamming(descriptors1[match[0]], descriptors2[match[1]]) distances12.append(distance) indices = np.range(len(matches12)) indices = [index for (_, index) in sorted(zip(distances12, indices))] matches12 = matches12[indices] # collect displacement from the first 10 matches dxList = [] dyList = [] for mat in matches12[:10]: # Get the matching keypoints for each of the images img1_idx = mat[0] img2_idx = mat[1] # x - columns # y - rows (x1, y1) = keypoints1[img1_idx] (x2, y2) = keypoints2[img2_idx] dxList.append(abs(x1 - x2)) dyList.append(abs(y1 - y2)) dxMedian = np.median(np.asarray(dxList, dtype=np.double)) dyMedian = np.median(np.asarray(dyList, dtype=np.double)) plot_matches(Image0, Image1, descriptors1, descriptors2, matches12[:10]) return dxMedian, dyMedian
def test_descriptor_orb(): detector_extractor = ORB(fast_n=12, fast_threshold=0.20) exp_descriptors = np.array([[ True, False, True, True, False, False, False, False, False, False], [False, False, True, True, False, True, True, False, True, True], [ True, False, False, False, True, False, True, True, True, False], [ True, False, False, True, False, True, True, False, False, False], [False, True, True, True, False, False, False, True, True, False], [False, False, False, False, False, True, False, True, True, True], [False, True, True, True, True, False, False, True, False, True], [ True, True, True, False, True, True, True, True, False, False], [ True, True, False, True, True, True, True, False, False, False], [ True, False, False, False, False, True, False, False, True, True], [ True, False, False, False, True, True, True, False, False, False], [False, False, True, False, True, False, False, True, False, False], [False, False, True, True, False, False, False, False, False, True], [ True, True, False, False, False, True, True, True, True, True], [ True, True, True, False, False, True, False, True, True, False], [False, True, True, False, False, True, True, True, True, True], [ True, True, True, False, False, False, False, True, True, True], [False, False, False, False, True, False, False, True, True, False], [False, True, False, False, True, False, False, False, True, True], [ True, False, True, False, False, False, True, True, False, False]], dtype=bool) detector_extractor.detect(img) detector_extractor.extract(img, detector_extractor.keypoints, detector_extractor.scales, detector_extractor.orientations) assert_equal(exp_descriptors, detector_extractor.descriptors[100:120, 10:20]) detector_extractor.detect_and_extract(img) assert_equal(exp_descriptors, detector_extractor.descriptors[100:120, 10:20])
def get_translation_tool(self, n_keypoints=1000): # Convert images to grayscale src_image = rgb2gray(self.src_image) dst_image = rgb2gray(self.dst_image) # Initiate an ORB class object which can extract features & descriptors from images. # Set the amount of features that should be found (more = more accurate) descriptor_extractor = ORB(n_keypoints=n_keypoints) # Extract features and descriptors from source image descriptor_extractor.detect_and_extract(src_image) self.keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors # Extract features and descriptors from destination image descriptor_extractor.detect_and_extract(dst_image) self.keypoints2 = descriptor_extractor.keypoints descriptors2 = descriptor_extractor.descriptors # Matches the descriptors and gives them rating as to how similar they are self.matches12 = match_descriptors(descriptors1, descriptors2, cross_check=True) # Selects the coordinates from source image and destination image based on the # indices given from the match_descriptors function. src = self.keypoints1[self.matches12[:, 0]][:, ::-1] dst = self.keypoints2[self.matches12[:, 1]][:, ::-1] # Filters out the outliers and generates the transformation matrix based on only the inliers model_robust, inliers = \ ransac((src, dst), ProjectiveTransform, min_samples=4, residual_threshold=2) # This returns the object "model_robust" which contains the tranformation matrix and # uses that to translate any coordinate point from source to destination image. return model_robust, inliers
# Read image from file, then inspect the image dimensions img = cv2.imread("/media/dick/External/KaggleRetina/" + folder1 + "/" + file_names[i],1) print(file_names[i]), height, width, channels = img.shape gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) del img # Make a PIL image so we can use PIL.Image.thumbnail to resize if needed gray_ = Image.fromarray(gray) # Check if dimensions are above desired, if so then resize keepig aspect ratio m, n = 512,512 if height > m or width > n: gray_.thumbnail((m,n), Image.ANTIALIAS) orb = ORB(n_keypoints=100) try: orb.detect_and_extract(gray_) except IndexError: print(file_names[i] + " had an issue.") issues.append(file_names[i]) continue kp = orb.keypoints des = orb.descriptors print(len(des)) #Store keypoint features temp_array = [] temp = pickle_keypoints(kp, des) temp_array.append(temp)
def main(): image_base_dir = '/home/dek/makerfaire-booth/2018/burger/experimental/dek/train_object_detector/decoded' canonical_dir = 'canonical' # template = os.path.join(image_base_dir, 'bottombun.0.00.27.34.-24.61.0.81.png') fig, axes = plt.subplots(7, 7, figsize=(7, 6), sharex=True, sharey=True) fig.delaxes(axes[0][0]) ssims = numpy.zeros( (len(BurgerElement.__members__), len(BurgerElement.__members__)), dtype=float) mses = numpy.zeros( (len(BurgerElement.__members__), len(BurgerElement.__members__)), dtype=float) for i, layer in enumerate(BurgerElement.__members__): template = os.path.join(canonical_dir, '%s.png' % layer) img1 = imread(template) # img1_padded = numpy.zeros( (WIDTH, HEIGHT,3), dtype=numpy.uint8) img1_padded = numpy.resize( [255,255,255], (WIDTH, HEIGHT, 3)) s = img1.shape w = s[0] h = s[1] nb = img1_padded.shape[0] na = img1.shape[0] lower1 = (nb) // 2 - (na // 2) upper1 = (nb // 2) + (na // 2) nb = img1_padded.shape[1] na = img1.shape[1] lower2 = (nb) // 2 - (na // 2) upper2 = (nb // 2) + (na // 2) img1_padded[lower1:upper1, lower2:upper2] = img1 img1_padded_float = img1_padded.astype(numpy.float64)/255. print img1_padded_float.shape img1_gray = rgb2gray(img1_padded_float) descriptor_extractor = ORB() try: descriptor_extractor.detect_and_extract(img1_gray) except RuntimeError: continue keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors axes[i][0].imshow(img1_padded_float) axes[i][0].set_title("Template image") for j, layer2 in enumerate(BurgerElement.__members__): rot, tx, ty, scale = get_random_orientation() img2 = draw_example(layer2, WIDTH, HEIGHT, rot, tx, ty, scale) # match = os.path.join(canonical_dir, '%s.png' % layer2) # img2 = imread(match) img2_padded = numpy.resize( [255,255,255], (WIDTH, HEIGHT, 3)) s = img2.shape img2_padded[:s[0], :s[1]] = img2 img2_padded_float = img2_padded.astype(numpy.float64)/255. img2_gray = rgb2gray(img2_padded_float) try: descriptor_extractor.detect_and_extract(img2_gray) except RuntimeError: continue keypoints2 = descriptor_extractor.keypoints descriptors2 = descriptor_extractor.descriptors matches12 = match_descriptors(descriptors1, descriptors2, cross_check=True) src = keypoints2[matches12[:, 1]][:, ::-1] dst = keypoints1[matches12[:, 0]][:, ::-1] model_robust, inliers = \ ransac((src, dst), SimilarityTransform, min_samples=4, residual_threshold=2) if not model_robust: print "bad" continue img2_transformed = transform.warp(img2_padded_float, model_robust.inverse, mode='constant', cval=1) sub = img2_transformed - img1_padded_float ssim = compare_ssim(img2_transformed, img1_padded_float, win_size=5, multichannel=True) mse = compare_mse(img2_transformed, img1_padded_float) ssims[i,j] = ssim mses[i,j] = mse axes[0][j].imshow(img2_padded_float) axes[0][j].set_title("Match image") axes[i][j].imshow(img2_transformed) axes[i][j].set_title("Transformed image") axes[i][j].set_xlabel("SSIM: %9.4f MSE: %9.4f" % (ssim, mse)) # ax = plt.gca() # plot_matches(ax, img1, img2, keypoints1, keypoints2, matches12) print ssims print numpy.argmax(ssims, axis=1) print numpy.argmin(mses, axis=1) plt.show()
def test_no_descriptors_extracted_orb(): img = np.ones((128, 128)) detector_extractor = ORB() with testing.raises(RuntimeError): detector_extractor.detect_and_extract(img)
def main(): image_base_dir = '/home/dek/makerfaire-booth/2018/burger/experimental/dek/train_object_detector/decoded' canonical_dir = 'canonical' # template = os.path.join(image_base_dir, 'bottombun.0.00.27.34.-24.61.0.81.png') template = os.path.join(canonical_dir, 'patty.png') img1 = imread(template) # img1_padded = numpy.zeros( (256, 256,3), dtype=numpy.uint8) img1_padded = numpy.resize( [255,255,255], (256, 256, 3)) s = img1.shape img1_padded[:s[0], :s[1]] = img1 img1_gray = rgb2gray(img1) descriptor_extractor = ORB() descriptor_extractor.detect_and_extract(img1_gray) keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors # g = glob.glob(os.path.join(image_base_dir, 'patty*.nobox.png')) # for moving in g: while True: rot, tx, ty, scale = get_random_orientation() # img2 = imread(moving) img2 = draw_example('patty', 256, 256, rot, tx, ty, scale) img2_gray = rgb2gray(img2) try: descriptor_extractor.detect_and_extract(img2_gray) except RuntimeError: continue keypoints2 = descriptor_extractor.keypoints descriptors2 = descriptor_extractor.descriptors matches12 = match_descriptors(descriptors1, descriptors2, cross_check=True) src = keypoints2[matches12[:, 1]][:, ::-1] dst = keypoints1[matches12[:, 0]][:, ::-1] model_robust, inliers = \ ransac((src, dst), SimilarityTransform, min_samples=4, residual_threshold=2) if not model_robust: print "bad" continue img2_transformed = transform.warp(img2, model_robust.inverse, mode='constant', cval=1) img1_padded_float = img1_padded.astype(numpy.float64)/255. sub = img2_transformed - img1_padded_float print compare_ssim(img2_transformed, img1_padded_float, win_size=5, multichannel=True) fig, axes = plt.subplots(2, 2, figsize=(7, 6), sharex=True, sharey=True) ax = axes.ravel() ax[0].imshow(img1_padded_float) ax[1].imshow(img2) ax[1].set_title("Template image") ax[2].imshow(img2_transformed) ax[2].set_title("Matched image") ax[3].imshow(sub) ax[3].set_title("Subtracted image") # plt.gray() # ax = plt.gca() # plot_matches(ax, img1, img2, keypoints1, keypoints2, matches12) plt.show()
import numpy as np from skimage import data from skimage.color import rgb2gray from skimage.feature import match_descriptors, ORB, plot_matches from skimage.measure import ransac from skimage.transform import FundamentalMatrixTransform import matplotlib.pyplot as plt np.random.seed(0) img_left, img_right, groundtruth_disp = data.stereo_motorcycle() img_left, img_right = map(rgb2gray, (img_left, img_right)) # Find sparse feature correspondences between left and right image. descriptor_extractor = ORB() descriptor_extractor.detect_and_extract(img_left) keypoints_left = descriptor_extractor.keypoints descriptors_left = descriptor_extractor.descriptors descriptor_extractor.detect_and_extract(img_right) keypoints_right = descriptor_extractor.keypoints descriptors_right = descriptor_extractor.descriptors matches = match_descriptors(descriptors_left, descriptors_right, cross_check=True) # Estimate the epipolar geometry between the left and right image. model, inliers = ransac((keypoints_left[matches[:, 0]],
from skimage import data from skimage import transform as tf from skimage.feature import (match_descriptors, corner_harris, corner_peaks, ORB, plot_matches) from skimage.color import rgb2gray import matplotlib.pyplot as plt import numpy as np test = np.array([2,6,4,8,9]) descriptor_extractor = ORB(n_keypoints=200) descriptor_extractor.detect_and_extract(test)
from skimage import data from skimage import transform as tf from skimage.feature import (match_descriptors, corner_harris, corner_peaks, ORB, plot_matches) from skimage.color import rgb2gray import matplotlib.pyplot as plt img1 = rgb2gray(data.coins()) img2 = tf.rotate(img1, 180) tform = tf.AffineTransform(scale=(1.3, 1.1), rotation=0.5, translation=(0, -200)) img3 = tf.warp(img1, tform) descriptor_extractor = ORB(n_keypoints=200) descriptor_extractor.detect_and_extract(img1) keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors descriptor_extractor.detect_and_extract(img2) keypoints2 = descriptor_extractor.keypoints descriptors2 = descriptor_extractor.descriptors descriptor_extractor.detect_and_extract(img3) keypoints3 = descriptor_extractor.keypoints descriptors3 = descriptor_extractor.descriptors matches12 = match_descriptors(descriptors1, descriptors2, cross_check=True) matches13 = match_descriptors(descriptors1, descriptors3, cross_check=True)
from skimage.feature import (match_descriptors, ORB, plot_matches) schroedinger = misc.imread('Schroedinger.jpg') # Transform the image using the skimage.transform library # "rotate" does what you might expect schroedinger_rotate = tf.rotate(schroedinger, 180) # This sets up a transformation that changes the image's scale, rotates it, # and moves it. "warp" then applies that transformation to the image tform = tf.AffineTransform(scale=(1.3, 1.1), rotation=0.5, translation=(0, -200)) schroedinger_warped = tf.warp(schroedinger, tform) # ORB is an algorithm that detects good features in an image and then # describes them in a compact way. The descriptions can then be matched # across multiple images. descriptor_extractor = ORB(n_keypoints=200) # Apply the ORB algorithm to our images descriptor_extractor.detect_and_extract(schroedinger) keypoints1 = descriptor_extractor.keypoints descriptors1 = descriptor_extractor.descriptors descriptor_extractor.detect_and_extract(schroedinger_rotate) keypoints2 = descriptor_extractor.keypoints descriptors2 = descriptor_extractor.descriptors descriptor_extractor.detect_and_extract(schroedinger_warped) keypoints3 = descriptor_extractor.keypoints descriptors3 = descriptor_extractor.descriptors # See which descriptors match across the images