def extract_features(image_path): img = cv2.imread(image_path, cv2.IMREAD_COLOR) surf = cv2.SIFT(400) kp, des = surf.detectAndCompute(img, None) print "extracted", image_path
def sift(*args, **kwargs): try: return cv2.xfeatures2d.SIFT_create(*args, **kwargs) except: return cv2.SIFT()
def C2OPatch(image, dE, dAlpha, dBeta): ur""" Function for the :math:`C_2O` feature calculation relative to keypoint detection (from openCV's SIFT). This function uses the :py:func:`C2O` function on patch of 64*64 pixel around each keypoint. This function is called as shown below : .. code-block:: python :emphasize-lines: 3,5 MatSigC2O = C2OPatch(image,kp) :param image: Path directory of the image on which you need the :math:`C_2O` feature calculation. :type image: string :param kp: Keypoints matrix from OpenCv's SIFT keypoint detection. :type kp: OpenCV keypoint structure array :return: The C2O signatures for each keypoint in an array. :rtype: np.ndarray This function use :py:func:`C2O` """ imag = Image.open(image) imag = np.array(imag) a = Queue() rows, cols, plans = imag.shape # print rows, cols , plans gray = cv2.cvtColor(imag, cv2.COLOR_RGB2GRAY) sift = cv2.SIFT() kp = sift.detect(gray, None) size = dE * dAlpha * dBeta matC2OPatch = np.zeros((len(kp), size)) mat_kp = np.zeros([len(kp), 2]) for i in range(len(kp)): mat_kp[i][0] = np.round(kp[i].pt[0]) for j in range(len(kp)): mat_kp[j][1] = np.round(kp[j].pt[1]) matkpret = np.zeros(np.shape(mat_kp)) n = 0 # print np.max(mat_kp[:,1]) , np.min(mat_kp[:,1]) for i in np.arange(0, len(kp) - 1): # print i # print mat_kp[i][0]-31 , mat_kp[i][0]+32 , mat_kp[i][1]-31 , mat_kp[i][1]+32, np.shape(imag) # if (((mat_kp[i][0]-31)<0) | ((mat_kp[i][0]+32)>rows-1) | ((mat_kp[i][1]-31)<0) | ((mat_kp[i][1]+32)>cols-1)): if (((mat_kp[i][0] - 31) > 0) & ((mat_kp[i][0] + 32) < rows - 1) & ((mat_kp[i][1] - 31) > 0) & ((mat_kp[i][1] + 32) < cols - 1)): # print i # else: matkpret[n][0] = mat_kp[i][0] matkpret[n][1] = mat_kp[i][1] matC2OPatch[n, :] = C2O( imag[mat_kp[i][0] - 31:mat_kp[i][0] + 32, mat_kp[i][1] - 31:mat_kp[i][1] + 32], 1, 0, 4, 6, 3, a) n = n + 1 matC2OPatch = np.resize(matC2OPatch, (n, size)) matkpret = np.resize(matkpret, (n, 2)) return matkpret, matC2OPatch
def sift(img1, img2): MIN_MATCH_COUNT = 10 print img2.shape # Initiate sift detector sift = cv2.SIFT() # find the keypoints and descriptors with sift kp1, des1 = sift.detectAndCompute(img1, None) kp2, des2 = sift.detectAndCompute(img2, None) # img2 = cv2.drawKeypoints(img2,kp2) # cv2.imwrite('../results/img2_sift_keypoints.jpg', img2) FLANN_INDEX_KDTREE = 0 index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5) search_params = dict(checks=50) flann = cv2.FlannBasedMatcher(index_params, search_params) matches = flann.knnMatch(des1, des2, k=2) # store all the good matches as per Lowe's ratio test. good = [] found = False M = None for m, n in matches: if m.distance < 0.7 * n.distance: good.append(m) print 'len(good):\t' + str(len(good)) if len(good) > MIN_MATCH_COUNT: found = True src_pts = np.float32([kp1[m.queryIdx].pt for m in good]).reshape(-1, 1, 2) dst_pts = np.float32([kp2[m.trainIdx].pt for m in good]).reshape(-1, 1, 2) # print 'len(src_pts)' + str(len(src_pts)) # print 'len(dst_pts)' + str(len(dst_pts)) M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0) h, w = img1.shape pts = np.float32([[0, 0], [0, h - 1], [w - 1, h - 1], [w - 1, 0]]).reshape(-1, 1, 2) dst = cv2.perspectiveTransform(pts, M) # for pt in dst: # p = pt[0] # p = list(p) # # p = [int(i) for i in p] # print p # cv2.circle(img2, tuple(p), 5, (255, 255, 255), -1) # cv2.polylines(img2,[np.int32(dst)],True,255,3) # cv2.imshow('detected',img2) # cv2.waitKey(0) # cv2.destroyAllWindows() else: found = False print "Not enough matches are found - %d/%d" % (len(good), MIN_MATCH_COUNT) return good, found, M
def _sift_instance(self, edge_threshold=100): if hasattr(cv2, 'SIFT'): return cv2.SIFT(edgeThreshold=edge_threshold) return cv2.xfeatures2d.SIFT_create(edgeThreshold=edge_threshold)
def __init__(self, sift_kp_size=16, concat=True, kps_idx=numpy.arange(4, 31, 8)): self.concat = concat self.sift = cv2.SIFT() coordinates = list(itertools.product(kps_idx, kps_idx)) self.kps = [cv2.KeyPoint(i, j, sift_kp_size) for (i, j) in coordinates]
def track_objects(vid_path, gaze, matches, verbose=True): """ Tracks gaze over matches using sift feature matching in openCV. Saves a video of gaze plotted over each match as well as a .npy file of gaze coordinates in each match image's coordinates """ if verbose: print "Tracking gaze over match images..." sys.stdout.write(' 0.00%') gaze = pd.read_csv(gaze) gaze = gaze[ ~gaze.vts_time.isnull()] # only start tracking eyes once video starts matches = [{'path': m} for m in matches] vid = cv2.VideoCapture(vid_path) if OPENCV3: sift = cv2.xfeatures2d.SIFT_create() fourcc = cv2.VideoWriter_fourcc(*'mp4v') tot = vid.get(cv2.CAP_PROP_FRAME_COUNT) * 2.0 fps = vid.get(cv2.CAP_PROP_FPS) * 2 else: sift = cv2.SIFT() fourcc = cv2.cv.CV_FOURCC(*'mp4v') tot = vid.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT) * 2.0 fps = vid.get(cv2.cv.CV_CAP_PROP_FPS) * 2 ind = 1 # get gaze values gaze_val = gaze['gaze_pos_val'].values gaze_x = gaze['gaze_pos_x'].values gaze_y = gaze['gaze_pos_y'].values vts = gaze['vts_time'].values / 1000. # setup sift features and output for each match for i in range(len(matches)): matches[i]['name'] = os.path.basename(matches[i]['path']).split('.')[0] outfile = vid_path.split( '.mp4')[0] + '_match_%s.m4v' % matches[i]['name'] matches[i]['img'] = cv2.imread(matches[i]['path']) matches[i]['sift'] = sift.detectAndCompute( cv2.cvtColor(matches[i]['img'], cv2.COLOR_BGR2GRAY), None) matches[i]['size'] = (matches[i]['img'].shape[1], matches[i]['img'].shape[0]) matches[i]['video'] = cv2.VideoWriter() matches[i]['video'].open(outfile, fourcc, fps, matches[i]['size'], True) # x, y pairs of gaze locations over object. Init as -1 matches[i]['obj_gaze'] = np.ones((len(gaze_x), 2)) * -1 while vid.isOpened(): if OPENCV3: vid_time = vid.get(cv2.CAP_PROP_POS_MSEC) else: vid_time = vid.get(cv2.cv.CV_CAP_PROP_POS_MSEC) ret, frame = vid.read() if ret: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) for i in range(len(matches)): matches[i]['M'] = object_find(matches[i]['sift'], frame, 50) # 2 frames per original frame for j in range(2): # make sure eye tracking data exists for current frame if ind < len(vts): # make sure eye tracking data is not ahead of video if vts[ind] <= vid_time: for match in matches: # draw on every match image img_cp = match['img'].copy() if gaze_val[ind] == 0: # if gaze point is valid if match['M'] is not None: org_pos = np.array( (1920 * gaze_x[ind], 1080 * gaze_y[ind])).reshape(-1, 1, 2) trans_pos = cv2.perspectiveTransform( org_pos, match['M']) trans_pos = tuple(np.int32(trans_pos[0, 0])) if (trans_pos[0] <= match['size'][0] and trans_pos[0] >= 0 and trans_pos[1] <= match['size'][1] and trans_pos[1] >= 0): cv2.circle( img_cp, trans_pos, 8, [255, 0, 0], -2 ) # draw blue circle on current frame cv2.circle( match['img'], trans_pos, 8, [0, 255, 0], 2) # draw green circle as trace match['obj_gaze'][ind, :] = trans_pos match['video'].write(img_cp) ind += 1 else: for match in matches: match['video'].write(match['img']) else: for match in matches: match['video'].write(match['img']) if ind % 10 == 0 and verbose: sys.stdout.write('\r' + '%6.2f%%' % ((ind / tot) * 100)) sys.stdout.flush() else: break # catch up gaze data in case it's behind try: while vts[ind + 1] < vid_time: ind += 1 except IndexError: # in case vts reaches end pass vid.release() for i in range(len(matches)): obj_gaze_path = vid_path.split( '.mp4')[0] + '_match_%s.npy' % matches[i]['name'] matches[i]['video'].release() # save video np.save(obj_gaze_path, matches[i]['obj_gaze']) # save gaze points if verbose: print print "Done!"
import cv2 import numpy opencv_haystack =cv2.imread('michael_jordan.jpg') opencv_needle =cv2.imread('temp.png') ngrey = cv2.cvtColor(opencv_needle, cv2.COLOR_BGR2GRAY) hgrey = cv2.cvtColor(opencv_haystack, cv2.COLOR_BGR2GRAY) # build feature detector and descriptor extractor hessian_threshold = 5000 detector = cv2.SIFT(hessian_threshold) hkeypoints,hdescriptors = detector.detectAndCompute(hgrey,None) nkeypoints,ndescriptors = detector.detectAndCompute(ngrey,None) # extract vectors of size 64 from raw descriptors numpy arrays rowsize = len(hdescriptors) / len(hkeypoints) if rowsize > 1: hrows = numpy.array(hdescriptors, dtype = numpy.float32).reshape((-1, rowsize)) nrows = numpy.array(ndescriptors, dtype = numpy.float32).reshape((-1, rowsize)) #print hrows.shape, nrows.shape else: hrows = numpy.array(hdescriptors, dtype = numpy.float32) nrows = numpy.array(ndescriptors, dtype = numpy.float32) rowsize = len(hrows[0]) # kNN training - learn mapping from hrow to hkeypoints index samples = hrows responses = numpy.arange(len(hkeypoints), dtype = numpy.float32) #print len(samples), len(responses) knn = cv2.KNearest()
open('dat_files/test_images_filenames.dat', 'r')) train_labels = cPickle.load(open('dat_files/train_labels.dat', 'r')) test_labels = cPickle.load(open('dat_files/test_labels.dat', 'r')) print 'Loaded ' + str( len(train_images_filenames )) + ' training images filenames with classes ', set(train_labels) print 'Loaded ' + str( len(test_images_filenames )) + ' testing images filenames with classes ', set(test_labels) # PCA components pca = PCA(n_components=20) # Create the SIFT detector object extractor = cv2.SIFT(nfeatures=100) # Create the SURF detector object # extractor = cv2.SURF(nfeaures = 100) num_images = 15 apply_pca = True D, L = train_features(train_images_filenames, train_labels, extractor, num_images, apply_pca) # Train a linear SVM classifier stdSlr = StandardScaler().fit(D) D_scaled = stdSlr.transform(D) kernel = 'linear' clf = train_svm(D_scaled, L, kernel)
def Detect(objectName,type): start = time.time() time.clock() elapsed = 0 seconds = 10 # 20 S. MIN_MATCH_COUNT = 30 setpath = '/home/uawsscu/PycharmProjects/Project2/image/' + objectName + '.jpg' detector = cv2.SIFT() FLANN_INDEX_KDITREE = 0 flannParam = dict(algorithm=FLANN_INDEX_KDITREE, tree=5) flann = cv2.FlannBasedMatcher(flannParam, {}) trainImg = cv2.imread(setpath, 0) trainKP, trainDesc = detector.detectAndCompute(trainImg, None) QUESTION_COUNT = -1 while elapsed < seconds: QueryImgBGR = get_video() QueryImg = cv2.cvtColor(QueryImgBGR, cv2.COLOR_BGR2GRAY) queryKP, queryDesc = detector.detectAndCompute(QueryImg, None) matches = flann.knnMatch(queryDesc, trainDesc, k=2) goodMatch = [] for m, n in matches: if m.distance < 0.65 * n.distance: goodMatch.append(m) if len(goodMatch) > MIN_MATCH_COUNT: if type == "question" : QUESTION_COUNT = 1 print "Yes" break tp = [] qp = [] for m in goodMatch: tp.append(trainKP[m.trainIdx].pt) qp.append(queryKP[m.queryIdx].pt) tp, qp = np.float32((tp, qp)) H, status = cv2.findHomography(tp, qp, cv2.RANSAC, 3.0) h, w = trainImg.shape trainBorder = np.float32([[[0, 0], [0, h - 1], [w - 1, h - 1], [w - 1, 0]]]) queryBorder = cv2.perspectiveTransform(trainBorder, H) cv2.polylines(QueryImgBGR, [np.int32(queryBorder)], True, (0, 255, 0), 5) else: print "Not Enough -->> %d : %d" % (len(goodMatch), MIN_MATCH_COUNT) QueryImgBGR = cv2.drawKeypoints(QueryImgBGR, queryKP) cv2.imshow('result', QueryImgBGR) if cv2.waitKey(10) == ord('q'): break elapsed = time.time() - start time.sleep(1) if QUESTION_COUNT == -1 : print "NO" cv2.destroyAllWindows()
[inst for inst_array in zwd_test_inst_mat for inst in inst_array] ) def grey_convert(wd_array): """convert [0, 1] greyscale to [0, 255] (dark, white)""" return np.round((1 - wd_array) * 255).astype(np.uint8) sigma = 1.4 # default: 1.6 contrastThreshold = 0.03 # default: 0.04 nOctaveLayers = 5 # default: 3 edgeThreshold = 7 # default: 10 sift = cv2.SIFT( sigma=sigma, contrastThreshold=contrastThreshold, nOctaveLayers=nOctaveLayers, edgeThreshold=edgeThreshold ) print("work on SIFT") def detect_SIFT(inst): inst.kp_list, inst.desc_list = sift.detectAndCompute( grey_convert(train_X[inst.ix].reshape(PIXEL_X, PIXEL_Y)), None ) map(detect_SIFT, flatten_inst_arary) map(detect_SIFT, flatten_test_inst_arary) TOP_K = 20
def SIFT(gray): sift = cv2.SIFT() kp = sift.detect(gray, None) return kp
def test(input1, input2): print input2 image1 = input1 + '.png' image2 = input2 + '.jpg' MIN_MATCH_COUNT = 30 img1 = cv2.imread(image1) # queryImage img2_total = cv2.imread(image2) # trainImage circles = circleDetection(input2) sift = cv2.SIFT() kp1, des1 = sift.detectAndCompute(img1, None) num = -1 img3 = img2_total points = [] good_num = [] for i in circles[0, :]: num += 1 r = int(i[2] * 1.2) sx = max(i[0] - r, 0) sy = max(i[1] - r, 0) ex = min(i[0] + r, img2_total.shape[1]) ey = min(i[1] + r, img2_total.shape[0]) #print i # print sx, ex, sy, ey img2 = img2_total[sy:ey, sx:ex].copy() # print img2 # print img2_total[sx:ex,sy:ey,:] # find the keypoints and descriptors with SIFT kp2, des2 = sift.detectAndCompute(img2, None) FLANN_INDEX_KDTREE = 0 index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5) search_params = dict(checks=50) flann = cv2.FlannBasedMatcher(index_params, search_params) try: matches = flann.knnMatch(des1, des2, k=2) except Exception, e: continue # store all the good matches as per Lowe's ratio test. good = [] for m, n in matches: if m.distance < 0.72 * n.distance: good.append(m) print len(good) if len(good) > MIN_MATCH_COUNT: src_pts = np.float32([kp1[m.queryIdx].pt for m in good]).reshape(-1, 1, 2) dst_pts = np.float32([kp2[m.trainIdx].pt for m in good]).reshape(-1, 1, 2) try: M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 3.0) matchesMask = mask.ravel().tolist() #showMatches(img1, img2, src_pts, dst_pts, matchesMask, 'ratiotest_'+input1+'_'+input2+'_'+str(num)) #alignImages(img1, img2, M, input1+'_'+input2) points.append( drawRetangle(img1, img2_total, src_pts, dst_pts, matchesMask, 0, 0, sx, sy)) good_num.append(len(good)) except Exception, e: print e pass
print('\n') print(output_dir) #################### #### Compute descriptors of the whole database #################### dataBaseDescriptors = [] imageBaseIndex = [] imageBasePaths = [] im_nb = 0 des_nb = 0 if (args.features == "surf"): feat_extractor = cv2.SURF(400) if (args.features == "sift"): feat_extractor = cv2.SIFT() imagesNameList = open(imagesNameFile) for imageName in imagesNameList: imagePath = img_dir + imageName[:-1] + ".jpg" print "Compute descriptors for : " + imagePath image = cv2.imread(imagePath) kp, des = feat_extractor.detectAndCompute(image, None) if (des != None): for descriptor in des: dataBaseDescriptors.append(descriptor) imageBaseIndex.append(im_nb) des_nb += 1
Rickshaw_limit = 0 Rickshaw_max_limit = 70 Autorickshaw_limit = 0 Autorickshaw_max_limit = 70 descriptors = np.array([]) #creating a list of images path = "Mlt_data" for root, dir_names, file_names in os.walk(path): # print root, dir_names, file_names for name in dir_names: # print name if (name == "Person"): for file in os.listdir(path+"/"+name): if person_limit < person_max_limit : pic = cv2.imread(path+"/"+name+"/"+file) kp, des = cv2.SIFT().detectAndCompute(pic, None) if des == None: continue descriptors = np.append(descriptors, des) person_limit+=1 # print path+"/"+name+"/"+file elif (name == "Bicycle"): for file in os.listdir(path+"/"+name): if Bicycle_limit < Bicycle_max_limit : pic = cv2.imread(path+"/"+name+"/"+file) kp, des = cv2.SIFT().detectAndCompute(pic, None) if des == None: continue descriptors = np.append(descriptors, des) Bicycle_limit+=1 # print path+"/"+name+"/"+file
train_images_filenames = cPickle.load( open('./dataset/train_images_filenames.dat', 'r')) test_images_filenames = cPickle.load( open('./dataset/test_images_filenames.dat', 'r')) train_labels = cPickle.load(open('./dataset/train_labels.dat', 'r')) test_labels = cPickle.load(open('./dataset/test_labels.dat', 'r')) print( 'Loaded ' + str(len(train_images_filenames)) + ' training images filenames with classes ', set(train_labels)) print( 'Loaded ' + str(len(test_images_filenames)) + ' testing images filenames with classes ', set(test_labels)) # create the sift detector object SIFT_detector = cv2.SIFT(nfeatures=100) # read the just 30 train images per class # extract sift keypoints and descriptors # store descriptors in a python list of numpy arrays Train_descriptors = [] Train_label_per_descriptor = [] Accuracy = [] Time = [] Cost = [] for i in range(len(train_images_filenames)): filename = train_images_filenames[i] if Train_label_per_descriptor.count(train_labels[i]) < 30: print('Reading image ' + filename)
def extract_r_t_f(im1, im2, mtx, dst): """ This function will find the essential matrix from an estimation of the fundamental matrix and from that we shall extract rotation and translation vectors. This information may later be used to help determine the depth of various objects in the image. In the course of finding the fundamental matrix we are also getting a second layer of false match elimination. Inputs: im1 -> first image file path im2 -> second image file path Returns: pts1, pts2 -> list of points that based on their position match well enough with other image points to make the fundamental matrix T -> translation matrix R -> rotation matrix F -> fundamental matrix Reference: A large amount of the code in this function (anything from essential matrix on) comes from code developed here: https://gist.github.com/jensenb/8668000 """ # K = [[ 598.28339238 0. 338.53221923] # [ 0. 595.80675436 230.06429972] # [ 0. 0. 1. ]] #d = [[ 0.10643171 -0.55556305 -0.00786038 0.00290519 0.98123148]] #d the distortion matrix with three extra zeros on the end...we're not yet sure why the zeros are there # d = np.array([ 0.10643171, -0.55556305, -0.00786038, 0.00290519, 0.98123148, 0.0, 0.0, 0.0]).reshape(1,8) # #K the camera matrix (contains intrinsic camrea parameters) # K = np.array([598.28339238, 0.0, 338.53221923, 0.0, 595.80675436, 230.06429972, 0.0, 0.0, 1.0]).reshape(3,3) d = dst K = mtx #K_inv is the inverse of K K_inv = np.linalg.inv(K) img1 = cv2.imread(im1,0) #queryimage # left image img2 = cv2.imread(im2,0) #trainimage # right image sift = cv2.SIFT() # find the keypoints and descriptors with SIFT kp1, des1 = sift.detectAndCompute(img1,None) kp2, des2 = sift.detectAndCompute(img2,None) # FLANN parameters FLANN_INDEX_KDTREE = 0 index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5) search_params = dict(checks=50) flann = cv2.FlannBasedMatcher(index_params,search_params) matches = flann.knnMatch(des1,des2,k=2) good = [] pts1 = [] pts2 = [] # ratio test as per Lowe's paper for i,(m,n) in enumerate(matches): if m.distance < 0.8*n.distance: good.append(m) pts2.append(kp2[m.trainIdx].pt) pts1.append(kp1[m.queryIdx].pt) pts1 = np.int32(pts1) pts2 = np.int32(pts2) pts1 = np.array([[float(pt[0]), float(pt[1])] for pt in pts1]) pts2 = np.array([[float(pt[0]), float(pt[1])] for pt in pts2]) F, mask = cv2.findFundamentalMat(pts1,pts2,cv2.FM_LMEDS) # We select only inlier points pts1 = pts1[mask.ravel()==1] pts1 = [np.append(pt, 0.0) for pt in pts1] pts2 = pts2[mask.ravel()==1] pts2 = [np.append(pt, 0.0) for pt in pts2] #Decompsing the essential matrix from the fundamental matrix based on MATH! E = K.T.dot(F).dot(K) #Singular value decomposition #U and V are the unitary matrices -> not clear on what these are #S are the singular values U, S, V = np.linalg.svd(E) W = np.array([0.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]).reshape(3, 3) R = U.dot(W).dot(V) T = U[:, 2] if not in_front_of_both_cameras(pts1, pts2, R, T): # Second choice: R = U * W * Vt, T = -u_3 T = - U[:, 2] if not in_front_of_both_cameras(pts1, pts2, R, T): # Third choice: R = U * Wt * Vt, T = u_3 R = U.dot(W.T).dot(V) T = U[:, 2] if not in_front_of_both_cameras(pts1, pts2, R, T): # Fourth choice: R = U * Wt * Vt, T = -u_3 T = - U[:, 2] return R, T, F, pts1, pts2
def _sift_extract(image): sift = cv2.SIFT() keypoints, descriptors = sift.detectAndCompute(image, None) return keypoints, descriptors
start = time.time() # read the train and test files train_images_filenames = cPickle.load(open('train_images_filenames.dat', 'r')) test_images_filenames = cPickle.load(open('test_images_filenames.dat', 'r')) train_labels = cPickle.load(open('train_labels.dat', 'r')) test_labels = cPickle.load(open('test_labels.dat', 'r')) print 'Loaded ' + str( len(train_images_filenames )) + ' training images filenames with classes ', set(train_labels) print 'Loaded ' + str( len(test_images_filenames )) + ' testing images filenames with classes ', set(test_labels) # create the SIFT detector object SIFTdetector = cv2.SIFT(nfeatures=300) # extract SIFT keypoints and descriptors # store descriptors in a python list of numpy arrays Train_descriptors = [] Train_label_per_descriptor = [] for i in range(len(train_images_filenames)): filename = train_images_filenames[i] print 'Reading image ' + filename ima = cv2.imread(filename) gray = cv2.cvtColor(ima, cv2.COLOR_BGR2GRAY) kpt, des = SIFTdetector.detectAndCompute(gray, None) Train_descriptors.append(des) Train_label_per_descriptor.append(train_labels[i]) print str(len(kpt)) + ' extracted keypoints and descriptors'
np.array([ tempM0[:, 1][i][0] / tempM0[:, 1][i][1] for i in np.arange(tempM0.shape[0]) ]) < ratio) matches = np.transpose(matches)[0] ptsA = [] ptsB = [] for i in matches: ptsA.append(tempM0[i][0][0].data[0]) ptsB.append(kpsB[i]) return np.array(ptsA), np.array(ptsB) if __name__ == '__main__': # figuring out how to get to the img directory path = os.path.realpath(__file__) path = path[:path.rindex('/')] #importing 2 placeholder images imA = cv2.imread(path + '/img/tree.jpeg') imB = cv2.imread(path + '/img/home.jpeg') # getting the grayscale imAG = cv2.cvtColor(imA, cv2.COLOR_BGR2GRAY) imBG = cv2.cvtColor(imB, cv2.COLOR_BGR2GRAY) # get the kp and descriptors kpA, desA = cv2.SIFT().detectAndCompute(imAG, None) kpB, desB = cv2.SIFT().detectAndCompute(imBG, None) # match the keypoints and kaboom mptsA, mptsB = matchKeypoints(kpA, kpB, desA, desB)
def generateCorners(img): sift = cv.SIFT() kp, des = sift.detectAndCompute(img.gray, None) img.keypoints = kp img.descriptors = des return img
import cv2 if __name__ == "__main__": image_folder = sys.argv[1] # location (directory) of image files feat_detect = sys.argv[2] # only support SIFT extract & detect for now... out_folder = sys.argv[3] # location (directory) where yaml files will go if not image_folder.endswith('/'): image_folder += '/' image_names = [] # list of image file names image_keypoints = [ ] # list of lists of keypoints associated with each image image_descriptors = [] # list of lists of descriptors features = cv2.SIFT() # opencv SIFT feature extractor for im in os.listdir(image_folder): if im.startswith('.'): continue pic = cv2.imread(image_folder + im, 0) # extract features from pic # keypoints: x,y locations # descriptors: feature vectors keypoints, descriptors = features.detectAndCompute(pic, None) # convert from np.float32 to in descriptors = descriptors.astype(int)
#SIFT ALGORITHM import Tkinter as Tk from skimage.measure import structural_similarity as ssim import matplotlib.pyplot as plt import numpy as np import cv2 import time img1 = cv2.imread('dataset\obama.jpg', cv2.IMREAD_COLOR) img2 = cv2.imread('dataset1\obama1.jpg', cv2.IMREAD_COLOR) gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY) gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY) #SIFT detector = cv2.SIFT() keypoints1 = detector.detect(gray1, None) keypoints2 = detector.detect(gray2, None) outimg1 = cv2.drawKeypoints(gray1, keypoints1) outimg2 = cv2.drawKeypoints(gray2, keypoints2) cv2.imshow('img1', outimg1) cv2.imshow('img2', outimg2) #kp,des = sift.compute(gray,kp) kp1, des1 = detector.compute(gray1, keypoints1) kp2, des2 = detector.compute(gray2, keypoints2) print kp1
def describeSIFT(image): sift = cv2.SIFT() kp, des = sift.detectAndCompute(image, None) return kp, des
def describe(path): img = cv2.imread(path) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) sift = cv2.SIFT() kp, des = sift.detectAndCompute(gray, None) return kp, des
def sift_count(img): sift = cv2.SIFT(edgeThreshold=100) kp, des = sift.detectAndCompute(img, None) return len(kp)
''' def objdraw(matchesMask,img1,img2,keypts1,keypts2): draw_params = dict(matchColor = (0,255,0), # draw matches in green color singlePointColor = None, matchesMask = matchesMask, # draw only inliers flags = 2) #print the below image to show corresponding points and transformations img3 = cv2.drawMatches(img1,keypts1,img2,keypts2,good,None,**draw_params) #plt.imshow(img2, 'gray'),plt.show() cv2.imshow('img3',img3) ''' ######################################################################### #surf=cv2.xfeatures2d.SIFT_create() surf = cv2.SIFT() ############# host = "192.168.0.100:8080" if len(sys.argv) > 1: host = sys.argv[1] hoststr = 'http://' + host + '/video' print 'Streaming ' + hoststr stream = urllib2.urlopen(hoststr) bytes = '' ############# img2 = cv2.imread('pi1.jpg', 0)
def find_all_sift(im_source, im_search, min_match_count=4, maxcnt=0): ''' 使用sift算法进行多个相同元素的查找 Args: im_source(string): 图像、素材 im_search(string): 需要查找的图片 threshold: 阈值,当相识度小于该阈值的时候,就忽略掉 maxcnt: 限制匹配的数量 Returns: A tuple of found [(point, rectangle), ...] A tuple of found [{"point": point, "rectangle": rectangle, "confidence": 0.76}, ...] rectangle is a 4 points list ''' sift = cv2.SIFT(edgeThreshold=100) flann = cv2.FlannBasedMatcher({ 'algorithm': FLANN_INDEX_KDTREE, 'trees': 5 }, dict(checks=50)) kp_sch, des_sch = sift.detectAndCompute(im_search, None) if len(kp_sch) < min_match_count: return None kp_src, des_src = sift.detectAndCompute(im_source, None) if len(kp_src) < min_match_count: return None h, w = im_search.shape[1:] result = [] while True: # 匹配两个图片中的特征点,k=2表示每个特征点取2个最匹配的点 matches = flann.knnMatch(des_sch, des_src, k=2) good = [] for m, n in matches: # 剔除掉跟第二匹配太接近的特征点 if m.distance < 0.9 * n.distance: good.append(m) if len(good) < min_match_count: break sch_pts = np.float32([kp_sch[m.queryIdx].pt for m in good]).reshape(-1, 1, 2) img_pts = np.float32([kp_src[m.trainIdx].pt for m in good]).reshape(-1, 1, 2) # M是转化矩阵 M, mask = cv2.findHomography(sch_pts, img_pts, cv2.RANSAC, 5.0) matches_mask = mask.ravel().tolist() # 计算四个角矩阵变换后的坐标,也就是在大图中的坐标 h, w = im_search.shape[:2] pts = np.float32([[0, 0], [0, h - 1], [w - 1, h - 1], [w - 1, 0]]).reshape(-1, 1, 2) dst = cv2.perspectiveTransform(pts, M) # trans numpy arrary to python list # [(a, b), (a1, b1), ...] pypts = [] for npt in dst.astype(int).tolist(): pypts.append(tuple(npt[0])) lt, br = pypts[0], pypts[2] middle_point = (lt[0] + br[0]) / 2, (lt[1] + br[1]) / 2 result.append( dict( result=middle_point, rectangle=pypts, confidence=(matches_mask.count(1), len(good) ) #min(1.0 * matches_mask.count(1) / 10, 1.0) )) if maxcnt and len(result) >= maxcnt: break # 从特征点中删掉那些已经匹配过的, 用于寻找多个目标 qindexes, tindexes = [], [] for m in good: qindexes.append(m.queryIdx) # need to remove from kp_sch tindexes.append(m.trainIdx) # need to remove from kp_img def filter_index(indexes, arr): r = np.ndarray(0, np.float32) for i, item in enumerate(arr): if i not in qindexes: r = np.append(r, item) return r kp_src = filter_index(tindexes, kp_src) des_src = filter_index(tindexes, des_src) return result
#!/usr/bin/env python # -*- coding: utf-8 -*- # import auto # import template # import sift import cv2 _sift = cv2.SIFT() def _cv2open(filename, arg=1): if isinstance(filename, basestring): obj = cv2.imread(filename, arg) else: obj = filename return obj def sift_point_count(image_file): im = _cv2open(image_file) if im == None: return 0 kp_sch, des_sch = _sift.detectAndCompute(im, None) return len(kp_sch) # def find(img, template, rect=None, method='auto'): # ''' # @return rect, ratio
# -*- coding: utf-8 -*- """ Created on Sun May 20 11:53:21 2018 @author: Fakrul-IslamTUSHAR """ import numpy as np import cv2 as cv from matplotlib import pyplot as plt img1 = cv.imread('20587902_8dbbd4e51f549ff0_MG_R_CC_ANON_2.tif',0) # queryImage img2 = cv.imread('20587902_8dbbd4e51f549ff0_MG_R_CC_ANON.tif',0) # trainImage # Initiate SIFT detector sift = cv.SIFT() # find the keypoints and descriptors with SIFT kp1, des1 = sift.detectAndCompute(img1,None) kp2, des2 = sift.detectAndCompute(img2,None) # BFMatcher with default params bf = cv.BFMatcher() matches = bf.knnMatch(des1,des2, k=2) # Apply ratio test good = [] for m,n in matches: if m.distance < 0.75*n.distance: good.append([m]) # cv.drawMatchesKnn expects list of lists as matches. img3 = cv.drawMatchesKnn(img1,kp1,img2,kp2,good,flags=2) plt.imshow(img3),plt.show()