import cv2 as cv import numpy as np from bills.algo.image_utils import scale_down NUM_KEYPOINTS = 2000 HOMOGRAPHY_METHOD = cv.RANSAC RANSAC_REPROJ_THRESHOLD = 4.0 orb_detector = cv.ORB_create(NUM_KEYPOINTS, patchSize=41, edgeThreshold=55) # create BFMatcher object bf_matcher = cv.BFMatcher(cv.NORM_HAMMING, crossCheck=True) def preapre_image_for_keypoints(img): return scale_down(img, 550, 550) def get_keypoints(front): # find the keypoints and descriptors with ORB kp1, des1 = orb_detector.detectAndCompute(front, mask=None) return kp1, des1 def match_and_score(a1, a2, debug=False): (kp1, des1) = a1 (kp2, des2) = a2 matches = bf_matcher.match(des1, des2) src_pts = np.float32([kp1[m.queryIdx].pt for m in matches]).reshape(-1, 1, 2) dst_pts = np.float32([kp2[m.trainIdx].pt
def find_centroids(apriltag_query_path, apriltag_frame_path): apriltag_query = cv2.imread(apriltag_query_path,0) apriltag_frame = cv2.imread(apriltag_frame_path, 0) #Task:Initiate SIFT detector orb = cv2.ORB_create() #Task:Find the keypoints and descriptors with SIFT kp1, des1 = orb.detectAndCompute(apriltag_query,None) kp2, des2 = orb.detectAndCompute(apriltag_frame,None) #Task:Create BFMatcher object bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) #Task:Match descriptors. matches_ = bf.match(des1,des2) #Task:Sort them in the order of their distance. matches = sorted(matches_, key = lambda x:x.distance) good_matches = matches[:7] #Task:Get coordinates of all those matches(keypoints) in the frame list_kp1 = [kp1[mat.queryIdx].pt for mat in good_matches] temp_list_kp2 = [kp2[mat.trainIdx].pt for mat in good_matches] #print(temp_list_kp2) temp_dat = [] for i in temp_list_kp2: temp_dat.append(apriltag_frame.shape[0]-i[1]) list_kp2 = [] for kp,temp in zip(temp_list_kp2,temp_dat): list_kp2.append((kp[0],temp)) #Task:Make accessible lists for x and y coordinates x = np.array([int(item[0]) for item in list_kp2]) y = np.array([int(item[1]) for item in list_kp2]) X = np.array(list(zip(x,y))).reshape(len(x), 2) ###READ:UNSUPERVISED LEARNING METHOD #Task:Apply kmeans method to determine optimal k number of clusters in frame distortions = [] K = range(1,len(X)+1) for k in K: kmeanModel = KMeans(n_clusters=k).fit(X) kmeanModel.fit(X) distortions.append(sum(np.min(cdist(X, kmeanModel.cluster_centers_, 'euclidean'), axis=1)) / X.shape[0]) #Get list of all the points on elbow plot; Get points at min(k) and max(k) k_points = [] for k,d in zip(K,distortions): k_points.append((k,d)) point1 = k_points[0] point2 = k_points[-1] #Task:Use elbow to find out optimal k temp_lst = (point1,point2) #Subtask 1: Get all x values and y values x_vals = np.array([item[0] for item in temp_lst]).reshape(-1,1) y_vals = np.array([item[1] for item in temp_lst]).reshape(-1,1) #Subtask 2: Create linear model and fit linear_regressor = LinearRegression() linear_regressor.fit(x_vals,y_vals) #Subtask 3: Use model to predict all values of k y_pred = [] for k in K: y_pred.append(linear_regressor.intercept_ + linear_regressor.coef_ * k) temp_points = np.array(y_pred).ravel() y_pred_points = [] for k,p in zip(K,temp_points): y_pred_points.append((k,p)) #Subtask 3: Find distance between all the elbow points and the points on line distances = [] for k_pts,y_pts in zip(k_points,y_pred_points): distances.append(distance(k_pts,y_pts)) #Subtask 4: OptK is the associated k-value of the max distance opt_k = [] for k,d in zip(K,distances): if d == max(distances): opt_k = k #Task:Use optimal k to create the clusters kmeans_model = KMeans(n_clusters=opt_k).fit(X) #Task:Find the centroids of those clusters centers = np.array(kmeans_model.cluster_centers_) print(centers) return centers
import cv2 from matplotlib import pyplot as plt img1=cv2.imread('human.jpg',cv2.IMREAD_COLOR); #image read in color img1_gray=cv2.cvtColor(img1,cv2.COLOR_BGR2GRAY); #convert color of image from bgr2gray img2=cv2.imread('human_rotate.jpg',cv2.IMREAD_COLOR); #image read in color img2_gray=cv2.cvtColor(img2,cv2.COLOR_BGR2GRAY); #convert color of image from bgr2gray orb=cv2.ORB_create(); #create an orb object kp1,des1=orb.detectAndCompute(img1_gray,None); #detect and compute keypoints and descriptors on image kp2,des2=orb.detectAndCompute(img2_gray,None); #detect keypoints and compute descriptors on image #===>Create a brute-force matcher bf=cv2.BFMatcher(cv2.NORM_HAMMING,crossCheck=True); #create a bfmatcher matches=bf.match(des1,des2); #match the descriptors together matches=sorted(matches,key=lambda x:x.distance); #sort the matches from smallest to highest res=cv2.drawMatches(img1,kp1,img2,kp2,matches[:20],None); #draw 20 matches on image cv2.namedWindow('BFMatcher in orb',cv2.WINDOW_NORMAL); #create a named window cv2.imshow('BFMatcher in orb',res); #Image show if cv2.waitKey(0)&0xFF==ord('q'): cv2.destroyWindow('BFMatcher in orb'); #destroy window
import cv2 import numpy as np cap = cv2.VideoCapture(0) imgTarget = cv2.imread('TargetImage.jpg') myVid = cv2.VideoCapture('Chicago_360p.mp4') hT, wT, cT = imgTarget.shape success, imgVideo = myVid.read() imgVideo = cv2.resize(imgVideo, (wT, hT)) orb = cv2.ORB_create(nfeatures=1000) kp1, des1 = orb.detectAndCompute(imgTarget, None) # imgTarget = cv2.drawKeypoints(imgTarget , kp1 , None) while True: success, imgWebcam = cap.read() imgWebcam = cv2.flip(imgWebcam, 1) kp2, des2 = orb.detectAndCompute(imgWebcam, None) # imgWebcam = cv2.drawKeypoints(imgWebcam , kp2 , None) bf = cv2.BFMatcher() matches = bf.knnMatch(des1, des2, k=2) good = [] for m, n in matches: if m.distance < 0.75 * n.distance: good.append(m) print(len(good)) imgFeatures = cv2.drawMatches(imgTarget, kp1,
"""Dececting key points in images""" import numpy import cv2 from matplotlib import pyplot as plt """Load Image""" img = cv2.imread("focusedMarchantia1.jpg", cv2.IMREAD_COLOR) """Initialise detector""" orb = cv2.ORB_create() """find keypoints""" kp = orb.detect(img, None) """Compute descriptors with orb""" kp, des = orb.compute(img, kp) """Draw only keypoints location, not size or orientation""" img2 = img.copy() cv2.drawKeypoints(img, kp, img2, color=(255, 0, 0), flags=0) plt.imshow(img2), plt.show() #=============================================================================================================================# """Matching up key points in two images""" import numpy import cv2 from matplotlib import pyplot as plt """Load Images""" img1 = cv2.imread("small crop.jpg", cv2.IMREAD_GRAYSCALE) img2 = cv2.imread("focusedMarchantia1.jpg", cv2.IMREAD_GRAYSCALE) """Initialise detector""" orb = cv2.ORB_create() """find keypointsand compute""" kp1, des1 = orb.detectAndCompute(img1, None)
def main(child_conn): # play the background sound mixer.music.load('sounds/background.mp3') mixer.music.play(-1) # Get the data from the XML solarSystem = ET.parse('planet_info.xml') celestialBodies = solarSystem.getroot() # Parse everything from XML into global variables for cBodies in celestialBodies: planets = cBodies.findall("planet") stars = cBodies.findall("star") if planets: for planet in planets: planet_list.append( Planet(planet[0].text, planet[1].text, planet[2].text, planet[3].text, planet[4].text, planet[5].text, planet[6].text, planet[7].text, planet[8].text)) elif stars: # since there is only one star (sun), we just add it into the list of planets for star in stars: planet_list.append( Planet(star[0].text, star[1].text, star[2].text, star[3].text, star[4].text, star[5].text, star[6].text, star[7].text, star[8].text)) else: print("Nothing was read from the XML.") # Set up the camera cam, camera_height, camera_width = init_webcam() CAM_WIDTH = camera_width CAM_HEIGHT = camera_height # Load the image that is going to be projected projectionImage = cv2.imread(imageToBeProjected) shuttleIcon = cv2.imread(shuttleToBeDrawn, cv2.IMREAD_UNCHANGED) # read with the alpha channel # Draw markers on the image for marker_index, cp in enumerate(marker_points): marker_image = cv2.imread(marker_file_name[marker_index]) h, w, d = marker_image.shape projectionImage[cp[1]:cp[1] + h, cp[0]:cp[0] + w] = marker_image.copy() h, w, d = projectionImage.shape # Create an opencv window to display the projection onto cv2.namedWindow("Projector", cv2.WND_PROP_FULLSCREEN) cv2.setWindowProperty("Projector", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN) cv2.imshow('Projector', projectionImage) cv2.namedWindow("Debug", cv2.WINDOW_NORMAL) while True: # work with a copy processedImage = projectionImage.copy() # Find keypoints in the projected image orb2 = cv2.ORB_create(nfeatures=500) projectionImage_kp = orb2.detect(processedImage, None) projectionImage_kp, projectionImage_des = orb2.compute(processedImage, projectionImage_kp) # Get an image from the camera ret_val, cameraImage = cam.read() # Get the matching features in the camera image using the descriptors from the projection image matches, cameraImage_kp = get_feature_matches(projectionImage_des, cameraImage) # if we can't find any matches, just keep displaying the image and inform the user if len(matches) <= MIN_MATCH_COUNT: cv2.imshow('Projector', processedImage) print('Could not find matches.') cv2.waitKey(10) continue # Now compute the Homography homographyMatrix, matchesMask = get_homography(matches, projectionImage_kp, cameraImage_kp) # Visualize! #show_matches(processedImage, cameraImage, projectionImage_kp, cameraImage_kp, homographyMatrix) # Get a virtual point on the image # Check first if the image is fully visible # Update the position to the new found position, otherwise keep the old one if isImageFullyVisible(homographyMatrix, projectedImageWidth, projectedImageHeight): smoothenMatrix(homographyMatrix) virtualPoint = virtual_point(smoothenedMatrix) updatedPoint = virtualPoint[0][0] else: updatedPoint = [p for p in trackedCenterPoint] # we don't want scattering or abrupt weird moves, so smoothen the motion smoothenCenterMotion(updatedPoint, DELTA_T) # convert tuple coordinates to list coordinates coordinates = [] coordinates[0] = updatedPoint[0] coordinates[1] = updatedPoint[1] # send to blender child_conn.send(coordinates) child_conn.close() # get from the blender, wait for an answer #while not x.recv(): # planetname = x.recv(4096) print(planetname) # loop over the objects of planets for planet in planet_list: if planet.name == planetname: # find the one that matches the one we landed # prepare the information of the planet we land info = prepare_info(planet) # get the font fontsize = 20 font = ImageFont.truetype("spacefont.ttf", fontsize) # load the image to PIL format img_pil = Image.fromarray(processedImage) # draw the text draw = ImageDraw.Draw(img_pil) draw.text((DISPLAY_INFO_LOCATION_X, DISPLAY_INFO_LOCATION_Y), info, font=font, fill=(0, 255, 255, 0)) # color BGR # back to opencv format processedImage = np.array(img_pil) break # rotate the shuttle as the camera does # first though, get a copy toBeRotatedShuttle = shuttleIcon.copy() rows, cols, w = toBeRotatedShuttle.shape angle = get_camera_rotation(smoothenedMatrix) angleInDegrees = round(math.degrees(clean_asin(angle)), 2) # convert radian to degrees rotationMatrix = cv2.getRotationMatrix2D((cols / 2, rows / 2), angleInDegrees, 1) toBeRotatedShuttle = cv2.warpAffine(toBeRotatedShuttle, rotationMatrix, (cols, rows), cv2.INTER_LANCZOS4) # Overlay transparent images at desired position(x,y) and scale. result = transparentOverlay(processedImage, toBeRotatedShuttle, tuple(trackedCenterPoint), 0.7) # Display the resulting projector image with a dot for the camera location cv2.imshow('Projector', processedImage) if cv2.waitKey(20) == ord('a'): break # When everything done, release the capture cam.release() cv2.destroyAllWindows() if __name__ == "__main__": # execute only if run as a script main(child_conn)
new_img.paste(re_img) new_img.save(NEW_IMG_FILE) # Create feature descriptors # print("Create feature descriptors") # print(NEW_IMG_FILE) img = cv.imread(NEW_IMG_FILE) # print(new_img.size) # print(NEW_IMG_FILE) # View Image # cv.imshow('image', img) # cv.waitKey(0) # cv.destroyAllWindows() orb = cv.ORB_create() kp = orb.detect(img, None) kp, des = orb.compute(img, kp) # print(kp,des) # View KeyPoints on Image # https://github.com/skvark/opencv-python/issues/168 # print("View keypoints on new image") # img2 = img.copy() # for marker in kp: # img2 = cv.drawMarker(img2, tuple(int(i) for i in marker.pt), color=(0, 255, 0)) # plt.imshow(img2), plt.show() # # [print(point.pt, point.size, point.angle) for point in kp] # print(des) # print(kp)
def FindTransform(ima, imb, fd_type=None): """ ima(DataArray of shape YaXa with uint8): Image to be aligned imb(DataArray of shape YbXb with uint8): Base image Note that the shape doesn't have to be any relationship with the shape of the first dimension(doesn't even need to be the same ratio) fd_type(None or str): Feature detector type. Must be 'SIFT' or 'ORB'. ORB is faster, but SIFT usually has better results. If None, it will pick the best available. return (ndarray of shape 3, 3): transformation matrix to align the first image on the base image. (right column is translation) raises: ValueError: if no good transformation is found. """ # Instantiate the feature detector and the matcher # TODO: try BRISK, AZAKE and other detectors? if fd_type is None: for fd in ("SIFT", "ORB"): if hasattr(cv2, "%s_create" % fd): fd_type = fd break if fd_type == "ORB": feature_detector = cv2.ORB_create() if USE_BF: matcher = cv2.BFMatcher(normType=cv2.NORM_HAMMING) else: index_params = dict( algorithm=FLANN_INDEX_LSH, table_number=6, # 12 key_size=12, # 20 multi_probe_level=1) # 2 search_params = {} matcher = cv2.FlannBasedMatcher(index_params, search_params) elif fd_type == "SIFT": # Extra arguments for SIFT # contrastThreshold = 0.04 # edgeThreshold = 10 # sigma = 1.6 # TODO: no need for Gaussian as preprocess already does it? feature_detector = cv2.SIFT_create( nfeatures=2000) # avoid going crazy on keypoints if USE_BF: matcher = cv2.BFMatcher(normType=cv2.NORM_L2) else: # Note: with KDTree, every call returns slightly different matches, # which is quite annoying for reproducibility # index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5) index_params = dict(algorithm=FLANN_INDEX_KMEANS) search_params = dict(checks=32) # default value matcher = cv2.FlannBasedMatcher(index_params, search_params) else: raise ValueError("Unknown feature detector %s" % (fd_type, )) logging.debug("Using feature detector %s", fd_type) # find and compute the descriptors ima_kp, ima_des = feature_detector.detectAndCompute(ima, None) imb_kp, imb_des = feature_detector.detectAndCompute(imb, None) logging.debug("Found %d and %d keypoints", len(ima_kp), len(imb_kp)) # run the matcher of the detected features if USE_KNN: # For each keypoint, return up to k(=2) best ones in the other image matches = matcher.knnMatch(ima_des, imb_des, k=2) # store all the good matches as per Lowe's ratio test dist_ratio = 0.75 selected_matches = [ m[0] for m in matches if len(m) == 2 and m[0].distance < m[1].distance * dist_ratio ] else: # For each keypoint, pick the closest one in the other image matches = matcher.match(ima_des, imb_des) # Pick up to the best 10 matches min_dist = 100 # almost random value selected_matches = [m for m in matches if m.distance < min_dist] selected_matches.sort(key=lambda m: m.distance) selected_matches = selected_matches[:10] logging.debug("Found %d matches and %d good ones", len(matches), len(selected_matches)) if len(selected_matches) < 5: raise ValueError( "Less than 5 common features (%d) detected on the images" % (len(selected_matches), )) # get keypoints for selected matches selected_ima_kp = [list(ima_kp[m.queryIdx].pt) for m in selected_matches] selected_imb_kp = [list(imb_kp[m.trainIdx].pt) for m in selected_matches] selected_ima_kp = numpy.array([selected_ima_kp]) selected_imb_kp = numpy.array([selected_imb_kp]) ima_mkp = [ima_kp[m.queryIdx] for m in selected_matches] imb_mkp = [imb_kp[m.trainIdx] for m in selected_matches] # testing detecting the matching points automatically try: mat, mask = cv2.findHomography(selected_ima_kp, selected_imb_kp, cv2.RANSAC) except Exception: raise ValueError("The images does not match") if mat is None: raise ValueError("The images does not match") return mat, ima_kp, imb_kp, ima_mkp, imb_mkp
def __init__(self): self.orb = cv2.ORB_create(1000)
def main(): # Setup Log logging.basicConfig(filename='Stitch_image.log', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s', filemode='w') # Setup argument parser ap = argparse.ArgumentParser() ap.add_argument("-d", "--directory", required=True, help="image directory") args = vars(ap.parse_args()) # Save Parameters input_directory = args['directory'] # Print input parameters to log logging.info('Input Parameters:\n' '\tDirectory: {}\n'.format(input_directory)) # Create output image folder if doesn't exits output_image_folder = os.path.join( os.path.dirname(input_directory), 'output_images/{}'.format(args['directory'])) if not os.path.exists(output_image_folder): os.mkdir(output_image_folder) ###### image_directory = os.path.join(definitions.ROOT_DIR, input_directory) image_RGB_list = [] image_GRAY_list = [] for image_file_name in sorted(os.listdir(image_directory), reverse=True): logging.info('Processing image {}'.format(image_file_name)) image_path = os.path.join(image_directory, image_file_name) gray_image = cv2.imread(image_path, 0) image_GRAY_list.append(gray_image) rgb_image = cv2.imread(image_path) image_RGB_list.append(rgb_image) # Test 2 images orb = cv2.ORB_create() # create BFMatcher object bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) H_list = [] mosaic_image = [image_RGB_list[0]] offset_list = [] try: for i in range(len(image_GRAY_list) - 1): # find the keypoints and descriptors with SIFT train_GRAY_image = image_GRAY_list[i] train_BGR_image = equalize_image(image_RGB_list[i]) query_GRAY_image = image_GRAY_list[i + 1] query_BGR_image = equalize_image(image_RGB_list[i + 1]) kp_train, des_train = orb.detectAndCompute(train_GRAY_image, None) kp_query, des_query = orb.detectAndCompute(query_GRAY_image, None) # Match descriptors. matches = bf.match(des_query, des_train) # Sort them in the order of their distance. matches = sorted(matches, key=lambda x: x.distance) # Compute H Matrix implementing RANSAC algorithm H = compute_H_from_RANSAC(kp_query, kp_train, matches) if not H_list: pass else: H = np.matmul(H_list[i], H) H_list.append(H) # Compute size of mosaic mosaic_x_range, mosaic_y_range, train_image_x_offset, train_image_y_offset, x,y \ = compute_size_of_mosaic(mosaic_image[i], query_GRAY_image, H_list[i]) train_image_x_offset = int(math.ceil(train_image_x_offset)) train_image_y_offset = int(math.ceil(train_image_y_offset)) mosaic_x_range = int(math.ceil(np.shape(mosaic_image[i])[1])) mosaic_y_range = int(math.ceil(np.shape(mosaic_image[i])[0])) im_out = cv2.warpPerspective( query_BGR_image, H_list[i], (math.ceil(mosaic_x_range), math.ceil(mosaic_y_range))) im_out[train_image_y_offset:y + train_image_y_offset, train_image_x_offset:x + train_image_x_offset] = train_BGR_image offset_list.append([train_image_y_offset, train_image_x_offset]) save_stiched_image(output_image_folder, im_out, i) mosaic_image.append(im_out) except: pass
roi = [[(98, 984), (680, 1074), 'text', 'Name'], [(740, 980), (1320, 1078), 'text', 'Phone'], [(98, 1154), (150, 1200), 'box', 'Sign'], [(738, 1152), (790, 1200), 'box', 'Allergic'], [(100, 1418), (686, 1518), 'text', 'Email'], [(740, 1416), (1318, 1512), 'text', 'ID'], [(110, 1598), (676, 1680), 'text', 'City'], [(748, 1592), (1328, 1686), 'text', 'Country']] path = "Resources/Query.png" imgQ = cv2.imread(path) h,w,c = imgQ.shape #imgQ = cv2.resize(imgQ, (w//3, h//3)) orb = cv2.ORB_create(1000) #To create our ORB (Oriented FAST and Rotated BRIEF) detector we can simply write kp1, des1 = orb.detectAndCompute(imgQ, None) #imgKp1 = cv2.drawKeypoints(img, kp1, None) path = 'UserForms' myPicList = os.listdir(path) print(myPicList) for j,y in enumerate(myPicList): img = cv2.imread(path +"/"+y) #img = cv2.resize(img, (w // 3, h // 3)) #cv2.imshow(y, img) kp2, des2 = orb.detectAndCompute(img, None) bf = cv2. BFMatcher(cv2.NORM_HAMMING) matches = bf.match(des2,des1) matches.sort(key = lambda x: x.distance)
def orb_desc(images_path, good_image_path, pref, f, name_dataset): images = [] for file in os.listdir(images_path): if file.endswith(".jpg"): images.append(cv2.imread(images_path + file)) gray_images = [] for image in images: gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) gray_images.append(gray) good_image = cv2.imread(good_image_path) good_gray_image = cv2.cvtColor(good_image, cv2.COLOR_BGR2GRAY) detector = cv2.ORB_create() results = [] for image in gray_images: (kps, desc) = detector.detectAndCompute(image, None) #br = cv2.BRISK_create(); #(kps,desc) = br.compute(image, kps) results.append((kps, desc, image)) (kps_good, descs_good) = detector.detectAndCompute(good_gray_image, None) # br_g = cv2.BRISK_create(); #(kps_good,descs_good) = br_g.compute(image, kps_good) i = 0 for (kps, desc, image) in results: f.write(pref + " Image " + name_dataset + str(i) + "\n") f.write("keypoints: {}, descriptors: {}".format(len(kps), desc.shape) + "\n") print("keypoints: {}, descriptors: {}".format(len(kps), desc.shape)) print("i: ", i) start_time = time.time() # create BFMatcher object bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) # Match descriptors. matches = bf.match(desc, descs_good) print("matches") # Sort them in the order of their distance. matches = sorted(matches, key=lambda x: x.distance) matches2 = np.asarray(matches) good = np.array([]) #for m,n in matches: # if m.distance < 0.9: # good.append([m]) img3 = cv2.drawMatches(image, kps, good_gray_image, kps_good, matches, good, flags=2) cv2.imwrite( "results_orb/" + pref + "res" + name_dataset + str(i) + ".jpg", img3) # img3 = cv2.drawMatches(image, kps, good_gray_image, kps_good, good, None, flags=2) #cv2.imwrite("../results_fast/"+pref+"res"+name_dataset+str(i)+".jpg", img3) f.write("Time: {}\n".format(time.time() - start_time)) i = i + 1
def calc_features(data): orb = cv2.ORB_create() # sift = cv2.xfeatures2d.SIFT_create() # surf = cv2.xfeatures2d.SURF_create() # brief = cv2.xfeatures2d.BriefDescriptorExtractor_create() progresser = tqdm(iterable=range(0, len(data)), desc='calc video features', total=len(data), unit='files') feat, targets = [], [] for i in progresser: clip = data[i] rm_list = [] for i, sample in enumerate(clip.data_samples): dist_nose = [] dist_mouth = [] dist_mouth_down = [] dist_mouth_right = [] dist_mouth_left = [] dist_eye_left = [] dist_eye_right = [] dist_brown_left = [] dist_brown_right = [] kp = [] lm_nose = sample.landmarks[30] # point on the nose lm_mouth = sample.landmarks[63] lm_mouth_down = sample.landmarks[58] lm_mouth_right = sample.landmarks[65] lm_mouth_left = sample.landmarks[61] lm_left_brown = sample.landmarks[20] lm_right_brown = sample.landmarks[25] lm_eye_left = sample.landmarks[42] lm_eye_right = sample.landmarks[44] img = cv2.copyMakeBorder(sample.image, BORDER, BORDER, BORDER, BORDER, cv2.BORDER_REPLICATE) for j in range(len(sample.landmarks)): lm = sample.landmarks[j] dist_nose.append(np.sqrt((lm_nose[0] - lm[0]) ** 2 + (lm_nose[1] - lm[1]) ** 2)) dist_mouth.append(np.sqrt((lm_mouth[0] - lm[0]) ** 2 + (lm_mouth[1] - lm[1]) ** 2)) dist_mouth_down.append(np.sqrt((lm_mouth_down[0] - lm[0]) ** 2 + (lm_mouth_down[1] - lm[1]) ** 2)) dist_mouth_left.append(np.sqrt((lm_mouth_left[0] - lm[0]) ** 2 + (lm_mouth_left[1] - lm[1]) ** 2)) dist_mouth_right.append(np.sqrt((lm_mouth_right[0] - lm[0]) ** 2 + (lm_mouth_right[1] - lm[1]) ** 2)) dist_eye_left.append(np.sqrt((lm_eye_left[0] - lm[0]) ** 2 + (lm_eye_left[1] - lm[1]) ** 2)) dist_eye_right.append(np.sqrt((lm_eye_right[0] - lm[0]) ** 2 + (lm_eye_right[1] - lm[1]) ** 2)) dist_brown_left.append(np.sqrt((lm_left_brown[0] - lm[0]) ** 2 + (lm_left_brown[1] - lm[1]) ** 2)) dist_brown_right.append(np.sqrt((lm_right_brown[0] - lm[0]) ** 2 + (lm_right_brown[1] - lm[1]) ** 2)) p = cv2.KeyPoint(lm[0] + BORDER, lm[1] + BORDER, _size=120) kp.append(p) _, desk = orb.compute(img, kp) #_, desk_brief = brief.compute(img, kp) # _, desk_sift = sift.compute(img, kp) # _, desk_surf = surf.compute(img, kp) # gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #lbp = local_binary_pattern(gray, NPOINTS_LBP, RADIUS_LPB, 'uniform') #(hist, _) = np.histogram(lbp.ravel(), bins=np.arange(0, NPOINTS_LBP + 3), range=(0, NPOINTS_LBP + 2)) #hist = hist.astype("float") # normalize the histogram #hist /= (hist.sum() + 1e-7) if check_dim_desc([ desk ]): feat.append( desk.flatten().tolist() + # desk_brief.flatten().tolist() + # desk_sift.flatten().tolist() + # desk_surf.flatten().tolist() + # hist.tolist() + dist_nose + dist_mouth + dist_mouth_down + dist_mouth_right + dist_mouth_left + dist_brown_right + dist_brown_left + dist_eye_left + dist_eye_right ) targets.append(sample.labels) else: rm_list.append(sample) # feat.append(features_per_clip) # targets.append(clip.labels) # feat_len.append(len(features_per_clip)) if rm_list: for sample in rm_list: clip.data_samples.remove(sample) # count_vector_frames_per_clip = Counter(feat_len) # optimal_size = 30 # max_frame_vector_per_clip = 39 # max([k for k in count_vector_frames_per_clip]) # min_frame_vector_per_clip = min([k for k in count_vector_frames_per_clip]) # print('frame_vector_len:', len(feat[0][0])) # print('max frames vectors per clip:', max_frame_vector_per_clip) # print('min frames vectors per clip:', min_frame_vector_per_clip) #feat_transform = [] #for f_v in feat: # if len(f_v) == optimal_size: # feat_transform.append([el for v in f_v for el in v]) # else: # # f_v = f_v + [np.zeros(len(feat[0][0])) for i in range(0, max_frame_vector_per_clip - len(f_v))] # feat_transform.append([el for v in f_v for el in v]) #print('Check feat_v clips len:', Counter([len(f_v) for f_v in feat_transform])) print('objects count:', len(feat)) print('unique labels count:', len(set(targets))) return np.asarray(feat, dtype=np.float32), np.asarray(targets, dtype=np.float32)
def detect(self, imggray, outimg=None): h, w = imggray.shape hlist = [] # Create a keypoint detector if needed: if not hasattr(self, 'detector'): self.detector = cv2.ORB_create() # Load training image and detect keypoints on it if needed: if not hasattr(self, 'refkp'): refimg = cv2.imread(self.fname, 0) self.refkp, self.refdes = self.detector.detectAndCompute( refimg, None) # Also store corners of reference image and of window for homography mapping: refh, refw = refimg.shape self.refcorners = np.float32([[0.0, 0.0], [0.0, refh], [refw, refh], [refw, 0.0]]).reshape(-1, 1, 2) self.wincorners = np.float32( [[ self.winleft * refw / self.owm, self.wintop * refh / self.ohm ], [ self.winleft * refw / self.owm, (self.wintop + self.winh) * refh / self.ohm ], [(self.winleft + self.winw) * refw / self.owm, (self.wintop + self.winh) * refh / self.ohm], [(self.winleft + self.winw) * refw / self.owm, self.wintop * refh / self.ohm]]).reshape(-1, 1, 2) jevois.LINFO( "Extracted {} keypoints and descriptors from {}".format( len(self.refkp), self.fname)) # Compute keypoints and descriptors: kp, des = self.detector.detectAndCompute(imggray, None) str = "{} keypoints".format(len(kp)) # Create a matcher if needed: if not hasattr(self, 'matcher'): self.matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) # Compute matches between reference image and camera image, then sort them by distance: matches = self.matcher.match(des, self.refdes) matches = sorted(matches, key=lambda x: x.distance) str += ", {} matches".format(len(matches)) # Keep only good matches: lastidx = 0 for m in matches: if m.distance < self.distth: lastidx += 1 else: break matches = matches[0:lastidx] str += ", {} good".format(len(matches)) # If we have enough matches, compute homography: corners = [] wincorners = [] if len(matches) >= 10: obj = [] scene = [] # Localize the object (see JeVois C++ class ObjectMatcher for details): for m in matches: obj.append(self.refkp[m.trainIdx].pt) scene.append(kp[m.queryIdx].pt) # compute the homography hmg, mask = cv2.findHomography(np.array(obj), np.array(scene), cv2.RANSAC, 5.0) # Check homography conditioning using SVD: u, s, v = np.linalg.svd(hmg, full_matrices=False) # We need the smallest eigenvalue to not be too small, and the ratio of largest to smallest eigenvalue to be # quite large for our homography to be declared good here. Note that linalg.svd returns the eigenvalues in # descending order already: if s[-1] > 0.001 and s[0] / s[-1] > 100: # Project the reference image corners to the camera image: corners = cv2.perspectiveTransform(self.refcorners, hmg) wincorners = cv2.perspectiveTransform(self.wincorners, hmg) # Display any results requested by the users: if outimg is not None and outimg.valid(): if len(corners) == 4: jevois.drawLine(outimg, int(corners[0][0, 0] + 0.5), int(corners[0][0, 1] + 0.5), int(corners[1][0, 0] + 0.5), int(corners[1][0, 1] + 0.5), 2, jevois.YUYV.LightPink) jevois.drawLine(outimg, int(corners[1][0, 0] + 0.5), int(corners[1][0, 1] + 0.5), int(corners[2][0, 0] + 0.5), int(corners[2][0, 1] + 0.5), 2, jevois.YUYV.LightPink) jevois.drawLine(outimg, int(corners[2][0, 0] + 0.5), int(corners[2][0, 1] + 0.5), int(corners[3][0, 0] + 0.5), int(corners[3][0, 1] + 0.5), 2, jevois.YUYV.LightPink) jevois.drawLine(outimg, int(corners[3][0, 0] + 0.5), int(corners[3][0, 1] + 0.5), int(corners[0][0, 0] + 0.5), int(corners[0][0, 1] + 0.5), 2, jevois.YUYV.LightPink) jevois.writeText(outimg, str, 3, h + 4, jevois.YUYV.White, jevois.Font.Font6x10) # Return window corners if we did indeed detect the object: hlist = [] if len(wincorners) == 4: hlist.append(wincorners) return hlist
from OpenGL.GL import * from OpenGL.GLU import * from OpenGL.GLUT import * import pygame import pygame.image from pygame.locals import * import numpy as np import pickle import cv2 import camera width, height = 1280, 720 sift = cv2.ORB_create() model = cv2.imread('model.jpg', 0) model = cv2.resize(model, (int(width / 1.2), int(height / 1.2))) kp1, des1 = sift.detectAndCompute(model, None) bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) # K = np.array([[640, 0, 320], [0, 480, 240], [0, 0, 1]]) K = np.array([[1186, 0, 656], [0, 1168, 380], [0, 0, 1]]) def set_projection_from_camera(K): glMatrixMode(GL_PROJECTION) glLoadIdentity() fx = float(K[0, 0]) fy = float(K[1, 1]) fovy = 2 * np.arctan(0.5 * height / fy) * 180 / np.pi aspect = (width * fy) / (height * fx)
def kp_orb_detection(img, num_kp): # find features using orb orb = cv2.ORB_create(nfeatures=num_kp).detect(img) return orb
smoothenedMatrix = np.float32([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) # Global variable to hold all celestial bodies planets = stars = planet_list = [] # images to be loaded imageToBeProjected = 'solar_system2.png' shuttleToBeDrawn = 'shuttleIcon.png' # marker stuff marker_file_name = ["markers/marker_one_small.png", "markers/marker_two_small.png", "markers/marker_three_small.png", "markers/marker_four_small.png"] marker_points = [[0, 0], [0, projectedImageHeight - 100], [projectedImageWidth - 100, 0], [projectedImageWidth - 100, projectedImageHeight - 100]] # initialize the feature detector # we use orb, make it ready orb = cv2.ORB_create(nfeatures=500) bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) matches = [] matchesMask = [] """Specific class which is used to read template images with filenames associated with it""" class PlanetTemplateImage: def __init__(self, img_name): self.img = cv2.imread(img_name, 0) self.__name = img_name def __str__(self): return self.__name """
def kp_orb_descriptor(img, kp, num_kp): # compute the descriptors with orb kp, desc = cv2.ORB_create(nfeatures=num_kp).compute(img, kp) return desc
# percent of the best compare matches percent = 25 pixelThreshold = 160 roi = [[(123, 65), (259, 76), 'text', 'Name'], [(71, 214), (90, 224), 'box', 'Vehicletype']] pytesseract.pytesseract.tesseract_cmd = 'C:\\Program Files\\Tesseract-OCR\\tesseract.exe' # load query image as compare default imQ = cv2.imread('sampleData/Query.jpg') h, w, c = imQ.shape # image detection orb = cv2.ORB_create(1100) kp1, des1 = orb.detectAndCompute(imQ, None) path = 'compareData' myPictureList = os.listdir(path) #print(myPictureList) for j, y in enumerate(myPictureList): image = cv2.imread(path + "/" + y) kp2, des2 = orb.detectAndCompute(image, None) bruteForce = cv2.BFMatcher(cv2.NORM_HAMMING) matches = bruteForce.match(des2, des1) # lower the distance equals better that result matches.sort(key=lambda x: x.distance) good = matches[:int(len(matches) * (percent / 100))] # imageMatch = cv2.drawMatches(image, kp2, imQ, kp1, good[:50], None, flags=2) # cv2.imshow(y, imageMatch)
def orb_sift_ransac(image_orig, image_warp, kp='sift'): """compute transformation matrix H from img_warp to img_orig """ if kp == 'orb': print('ORB') detector = cv2.ORB_create() #cv2.xfeatures2d.ORB_create() elif kp == 'sift': print('SIFT') detector = cv2.xfeatures2d.SIFT_create() kp_warp = detector.detect(image_warp ,None) kp_warp, des_warp = detector.compute(image_warp, kp_warp) kp_orig = detector.detect(image_orig ,None) kp_orig, des_orig = detector.compute(image_orig, kp_orig) MIN_MATCH_COUNT = 10 if des_warp is None or des_orig is None: return None, None #np.identity(3) if len(des_warp) < MIN_MATCH_COUNT or len(des_orig) < MIN_MATCH_COUNT: return None, None M, matchesMask, img_match = None, None, None if 1: # create BFMatcher object bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) # Match descriptors. if kp == 'sift': matches = bf.match(des_warp.astype(np.uint8), des_orig.astype(np.uint8)) else: matches = bf.match(des_warp, des_orig) # Sort them in the order of their distance. matches = sorted(matches, key = lambda x:x.distance) good = matches[:25] # we take the first 25 matches if len(good) >= MIN_MATCH_COUNT: src_pts = np.float32([kp_warp[m.queryIdx].pt for m in good ]).reshape(-1,1,2) dst_pts = np.float32([kp_orig[m.trainIdx].pt for m in good ]).reshape(-1,1,2) M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0) matchesMask = mask.ravel().tolist() else: 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(np.float32(des_warp), np.float32(des_orig), k=2) # store all the good matches as per Lowe's ratio test. good = [] for m, n in matches: if m.distance < 0.7*n.distance: good.append(m) #good.append(m) if len(good) >= MIN_MATCH_COUNT: src_pts = np.float32([kp_warp[m.queryIdx].pt for m in good ]).reshape(-1,1,2) dst_pts = np.float32([kp_orig[m.trainIdx].pt for m in good ]).reshape(-1,1,2) M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0) matchesMask = mask.ravel().tolist() ###### tmp if matchesMask: draw_params = dict(matchColor = (0,255,0), # draw matches in green color singlePointColor = None, #matchesMask = matchesMask, # draw only inliers flags = 2) img_match = cv2.drawMatches(image_warp, kp_warp, image_orig, kp_orig, good, None,**draw_params) return M, img_match
camera.shutter_speed = 20000 #camera.contrast = 100 #camera.image_effect = '' rawCapture = PiRGBArray(camera, size=(dimx, dimy)) c = 0 tmp = cv2.imread("target_qrcode/barcode2.png") target_barcode = cv2.resize(tmp, (96, 96)) orb = cv2.ORB_create(nfeatures=100, nlevels=6, scaleFactor=1.2, patchSize=31, edgeThreshold=15, fastThreshold=1) kp_target = orb.detect(target_barcode, None) print([kp.size for kp in kp_target]) #kp_target = cv2.KeyPoint(64,64, 63.0) kp_target_, des_target_ = orb.compute(target_barcode, kp_target) def remove_similar_feature(kp, des, threshold=40): flag = False print("number of kp:", len(kp))
def transformMap(groundTruthFile, saveFile, testPath, saveFolder, poorMapsfolder, hit, miss, unknown, feature='sift'): if feature == 'orb': orb = cv2.ORB_create() if feature == 'sift': sift = cv2.xfeatures2d.SIFT_create() print "Load Images: " print "Loading: %s" % (groundTruthFile) gtImage = cv2.imread(groundTruthFile, 0) print "Loaded: %s" % (groundTruthFile) cv2.imwrite(saveFile, gtImage) height, width = gtImage.shape if feature == 'orb': kp1, des1 = orb.detectAndCompute(gtImage, None) if feature == 'sift': kp1, des1 = sift.detectAndCompute(gtImage, None) des1 = np.asarray(des1, np.float32) for fileN in os.listdir(testPath): if not fileN.endswith(".pgm"): continue imFile = "%s%s" % (testPath, fileN) imFileW = "%s%s" % (saveFolder, fileN) imFileP = "%s%s" % (poorMapsfolder, fileN) print "Loading: %s" % (imFile) im = cv2.imread(imFile, 0) print "Loaded!" if feature == 'orb': kp2, des2 = orb.detectAndCompute(im, None) if feature == 'sift': kp2, des2 = sift.detectAndCompute(im, None) des2 = np.asarray(des2, np.float32) print "Featur points detected." 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(des2, des1, k=2) print "Points matched." good = deque() for m, n in matches: if m.distance < 0.7 * n.distance: good.append(m) print len(good) if len(good) < 1: print "Not enough points!" cv2.imwrite(imFileP, im) continue dst_pts = np.float32([kp2[m.queryIdx].pt for m in good]).reshape(-1, 1, 2) src_pts = np.float32([kp1[m.trainIdx].pt for m in good]).reshape(-1, 1, 2) M = cv2.estimateRigidTransform(src_pts, dst_pts, False) if M != None: M = np.asarray(M, np.float32) M = cv2.invertAffineTransform(M) imW = cv2.warpAffine(im, M, (width, height), cv2.INTER_NEAREST) imW = imW - hit imW = cv2.threshold(imW, unknown - 2 - hit, 255, 3) # (255-(imW+hit))-(255-miss) imW = miss - hit - imW[1] imW = cv2.threshold(imW, miss - unknown, 255, 3) # 255-(imw[1]+(255-miss)) imW = miss - imW[1] cv2.imwrite(imFileW, imW) else: print "No homography found!" cv2.imwrite(imFileP, im)
import numpy as np import cv2 from matplotlib import pyplot as plt im1 = cv2.imread('piano4.jpg') im2 = cv2.imread('piano5.jpg') gray1 = cv2.cvtColor(im1, cv2.COLOR_BGR2GRAY) gray2 = cv2.cvtColor(im2, cv2.COLOR_BGR2GRAY) orb = cv2.ORB_create(nfeatures=100, nlevels=1, edgeThreshold=30) corners1 = cv2.cornerHarris(gray1, 2, 3, 0.04) corners2 = cv2.cornerHarris(gray2, 2, 3, 0.04) kpCorners1 = np.argwhere(corners1 > 0.01 * corners1.max()) kpCorners2 = np.argwhere(corners2 > 0.01 * corners2.max()) kpCorners1 = [cv2.KeyPoint(pt[1], pt[0], 3) for pt in kpCorners1] kpCorners2 = [cv2.KeyPoint(pt[1], pt[0], 3) for pt in kpCorners2] kp1, des1 = orb.compute(gray1, kpCorners1) kp2, des2 = orb.compute(gray2, kpCorners2) # Matching bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) matches = bf.match(des1, des2) matches = sorted(matches, key=lambda x: x.distance) im3 = cv2.drawMatches(im1, kp1, im2, kp2, matches[:10], outImg=None) # Show cv2.imshow('result', im3) cv2.waitKey(0) cv2.imwrite('result.png', im3)
training_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Display the images plt.subplot(121) plt.title('Original Training Image') plt.imshow(training_image) plt.subplot(122) plt.title('Gray Scale Training Image') plt.imshow(training_gray, cmap='gray') plt.show() # Locating key points using ORB plt.rcParams['figure.figsize'] = [14.0, 7.0] # Set the parameters of the ORB algorithm by specifying the maximum number of keypoints to locate and # the pyramid decimation ratio orb = cv2.ORB_create(2000, 2.0) # Find the keypoints in the gray scale training image and compute their ORB descriptor. # The None parameter is needed to indicate that we are not using a mask. keypoints, descriptor = orb.detectAndCompute(training_gray, None) # Create copies of the training image to draw our keypoints on keyp_without_size = copy.copy(training_image) keyp_with_size = copy.copy(training_image) # Draw the keypoints without size or orientation on one copy of the training image cv2.drawKeypoints(training_image, keypoints, keyp_without_size, color=(0, 255, 0)) # Draw the keypoints with size and orientation on the other copy of the training image
def search_lock(target, algo): #Capturing Real Time Video cap = cv2.VideoCapture(0) #width cap.set(3, 432) #height cap.set(4, 432) if (algo == "orb"): #ORB orb = cv2.ORB_create() keypoints, descriptors = orb.detectAndCompute(target, None) output = cv2.drawKeypoints(target, keypoints, None) #Flann parameters for ORB indexparameters = dict( algorithm=6, table_number=12, #6, # 12 key_size=20, #12, # 20 multi_probe_level=2) #1) #2 searchparameters = dict(checks=30) flann = cv2.FlannBasedMatcher(indexparameters, searchparameters) #for SURF if (algo == "surf"): #SURF surf = cv2.xfeatures2d.SURF_create() # FEATURES keypoints, descriptors = surf.detectAndCompute(target, None) # KEYPOINTS output = cv2.drawKeypoints( target, keypoints, None ) #outImage = cv.drawKeypoints( image, keypoints, outImage[, color[, flags]] ) #Flann parameters for SURF indexparameters1 = dict(algorithm=0, trees=5) # searchparameters1 = dict() flann = cv2.FlannBasedMatcher(indexparameters1, searchparameters1) # Parameters for lucas kanade optical flow lk_params = dict(winSize=(15, 15), maxLevel=2, criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03)) # Create some random colors color = np.random.randint(0, 255, (100, 3)) if cap.isOpened(): ret, frame = cap.read() #cap.read() returns a bool (True/False). If frame is read correctly, it will be True. So you can check end of the video by checking this return value. #ret will store that bool value else: ret = False while ret: cv2.imshow("ORB-TARGET", output) ret, frame = cap.read() #frame2 = frame #cv2.imshow("Live Video Feed",frame) #gaussianBlur = cv2.GaussianBlur(frame,(5,5),0) medianBlur = cv2.medianBlur(frame, 5) grayFrame = cv2.cvtColor(medianBlur, cv2.COLOR_BGR2GRAY) #GRAYSCALE if (algo == "orb"): print("ORB ALGORITHM ") #ORB ALGORITHM APPLIED TO REAL TIME CAPTURING keypoints_grayFrame, descriptors_grayFrame = orb.detectAndCompute( grayFrame, None) show_keypoints_grayFrame = cv2.drawKeypoints( grayFrame, keypoints_grayFrame, None) #cv2.imshow("Real Time Cap orb", show_keypoints_grayFrame_orb) if (algo == "surf"): print("SURF ALGORITHM ") #SURF ALGORITHM APPLIED TO REAL TIME CAPTURING keypoints_grayFrame, descriptors_grayFrame = surf.detectAndCompute( grayFrame, None) show_keypoints_grayFrame = cv2.drawKeypoints( grayFrame, keypoints_grayFrame, None) cv2.imshow("Real Time Cap surf", show_keypoints_grayFrame) matches_flann = flann.knnMatch(descriptors, descriptors_grayFrame, k=2) goodMatches_flann = [] for m in matches_flann: if len(m) > 0 and m[0].distance < 0.2 * m[-1].distance: goodMatches_flann.append(m[0]) result_flann = cv2.drawMatches(target, keypoints, grayFrame, keypoints_grayFrame, goodMatches_flann, grayFrame) #cv2.imshow("Result_flann_orb", result_flann_orb) if len(goodMatches_flann) > 7: cv2.destroyWindow("Result") cv2.putText(result_flann, 'TARGET-DETECTED', (650, 100), cv2.FONT_HERSHEY_SIMPLEX, .5, (0, 0, 255), 2, cv2.LINE_AA) cv2.imshow("Target-detected", result_flann) queryPoints = np.float32([ keypoints[i.queryIdx].pt for i in goodMatches_flann ]).reshape( -1, 1, 2) # extracting location of good matches from targeted image trainPoints = np.float32([ keypoints_grayFrame[j.trainIdx].pt for j in goodMatches_flann ]).reshape( -1, 1, 2) # extracting location of good matches from real time vision #print(queryPoints) #representativematrix, maskk = cv2.findHomography(queryPoints, trainPoints, cv2.RANSAC, 5.0) # this matrix represents location of target in real time vision #matchesMask = maskk.ravel().tolist() #height, width = target.shape # height and width of original targeted image #points = np.float32([[0, 0],[0, height],[width, height],[width,0]]).reshape(-1, 1, 2) #adaptiveTemplate = cv2.perspectiveTransform(points, representativematrix) # points will adapt matrix #homography = cv2.polylines(frame, [np.int32(adaptiveTemplate)], True, (255,0,0), 3) #cv2.imshow("Homograpyh", homography) targetPoints = trainPoints #cv2.goodFeaturesToTrack(image, maxCorners, qualityLevel, minDistance[, corners[, mask[, blockSize[, useHarrisDetector[, k]]]]]) → corners #STMpoints = cv2.goodFeaturesToTrack(grayFrame, mask=None, **feature_params) # Create a mask image for drawing purposes mask = np.zeros_like(frame) while (len(goodMatches_flann) > 7): ret, frame2 = cap.read() newGrayFrame = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY) # calculate optical flow flowMatches, st, err = cv2.calcOpticalFlowPyrLK( grayFrame, newGrayFrame, targetPoints, None, **lk_params) # Select good points try: good_new = flowMatches[st == 1] good_old = targetPoints[st == 1] except: break # draw the tracks for i, (new, old) in enumerate(zip(good_new, good_old)): a, b = new.ravel() print("new points", (a, b)) c, d = old.ravel() print("old points", (c, d)) maskk = cv2.line(mask, (a, b), (c, d), color[i].tolist(), 2) frame3 = cv2.circle(frame2, (a, b), 5, color[i].tolist(), -1) """ if (c-a)>0: print("*******DOWN********") elif (c-a)<0: print("*******UP********") elif (d-b) >0: print("*******RIGHT*******") elif (d-b) <0: print("*******LEFT*******") """ if not ( (150 < a and a < 195) and (115 < b and b < 155) ): #160 middle 145middle #(130<a and a<220) and (114<b and b<190) if (a < 130): print("RIGHT!") send_body_ned_velocity(0.5, 0, 0, duration=1) if (a > 220): print("LEFT!") send_body_ned_velocity(-0.5, 0, 0, duration=1) if (b < 114): print("BACK!") send_body_ned_velocity(0, -0.5, 0, duration=1) if (b > 190): print("FRONT!") send_body_ned_velocity(0, 0.5, 0, duration=1) else: cv2.putText(frame3, 'Initializing Landing...', (80, 80), cv2.FONT_HERSHEY_SIMPLEX, .5, (30, 40, 50), 2, cv2.LINE_AA) print("Initiate Landing...") return True """ print(maskk.shape) print(frame3.shape) print(maskk.dtype) print(frame3.dtype) """ img = cv2.add(frame3, maskk) img = cv2.rectangle(img, (100, 95), (250, 175), (255, 0, 0), 2) img = cv2.rectangle(img, (120, 115), (230, 155), (0, 255, 0), 2) #(0,10), (350,275) cv2.imshow('frame', img) # Now update the previous frame and previous points grayFrame = newGrayFrame.copy() targetPoints = good_new.reshape(-1, 1, 2) if cv2.waitKey(1) == 27: break else: cv2.destroyWindow("Target-detected") cv2.destroyWindow("frame") #cv2.destroyWindow("Homograpyh") cv2.imshow("Result", result_flann) if cv2.waitKey(1) == 27: break # When everything done, release the capture cv2.destroyAllWindows() cap.release()
import cv2 import imutils # load the image and convert it to grayscale image = cv2.imread("./images/Station.png") orig = image.copy() gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # detect ORB keypoints in the image for OpenCV 2.4 if imutils.is_cv2(): detector = cv2.FeatureDetector_create("ORB") kps = detector.detect(gray) # detect ORB keypoints in the image for OpenCV 3+ else: detector = cv2.ORB_create() kps = detector.detect(gray, None) print("# of keypoints: {}".format(len(kps))) # loop over the keypoints and draw them for kp in kps: r = int(0.5 * kp.size) (x, y) = np.int0(kp.pt) cv2.circle(image, (x, y), r, (0, 255, 255), 2) # show the image cv2.imshow("Images", np.hstack([orig, image])) cv2.waitKey(0)
def get_descriptor_from_img(img): orb = cv2.ORB_create() kp, des = orb.detectAndCompute(img, None) return kp, des
def find_1(cls, image, similarity=DEFAULT_SIMILARITY, show=False): template = cv2.imread("assets/{}.png".format(image), 0) orb = cv2.ORB_create() kp1, des1 = orb.detectAndCompute(template, None) kp2, des2 = orb.detectAndCompute(screen, None) # plt.imshow(template), plt.show() # plt.imshow(screen), plt.show() # 定义FLANN匹配器 index_params = dict(algorithm=1, trees=5) search_params = dict(checks=50) flann = cv2.FlannBasedMatcher(index_params, search_params) # 使用KNN算法匹配 des1 = des1.astype('float32') des2 = des2.astype('float32') matches = flann.knnMatch(des1, des2, k=2) # 去除错误匹配 good = [] for m, n in matches: # if m.distance < 0.1 * n.distance: good.append(m) # if len(good) > 10: # # 改变数组的表现形式,不改变数据内容,数据内容是每个关键点的坐标位置 # src_pts = numpy.float32([kp1[m.queryIdx].pt for m in good]).reshape(-1, 1, 2) # dst_pts = numpy.float32([kp2[m.trainIdx].pt for m in good]).reshape(-1, 1, 2) # # findHomography 函数是计算变换矩阵 # # 参数cv2.RANSAC是使用RANSAC算法寻找一个最佳单应性矩阵H,即返回值M # # 返回值:M 为变换矩阵,mask是掩模 # M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0) # # ravel方法将数据降维处理,最后并转换成列表格式 # matchesMask = mask.ravel().tolist() # # 获取img1的图像尺寸 # h, w = template.shape # # pts是图像img1的四个顶点 # pts = numpy.float32([[0, 0], [0, h - 1], [w - 1, h - 1], [w - 1, 0]]).reshape(-1, 1, 2) # # 计算变换后的四个顶点坐标位置 # dst = cv2.perspectiveTransform(pts, M) # # # b = np.int32(dst).reshape(4, 2) # # img_temp = img2.copy() # # cv2.fillConvexPoly(img_temp, b, 0) # # # 根据四个顶点坐标位置在img2图像画出变换后的边框 # img2 = cv2.polylines(screen, [numpy.int32(dst)], True, (0, 255, 0), 3, cv2.LINE_AA) # else: # print("Not enough matches are found - %d/%d") % (len(good), MIN_MATCH_COUNT) matchesMask = None # draw_params = dict( matchColor=(0, 255, 0), # draw matches in green color singlePointColor=None, matchesMask=matchesMask, # draw only inliers flags=2, ) img3 = cv2.drawMatches(template, kp1, screen, kp2, good, None, **draw_params) plt.imshow(img3, "gray"), plt.show() pass
cv2.imshow('Dense LK', vis) # experirement using a feature based dectection elif method is "feature": # detect key feature points featureDetectorType = "ORB" if featureDetectorType is "SIFT": detector = cv2.xfeatures2d.SIFT_create() kp1 = detector.detect(im1) kp2 = detector.detect(im2) elif featureDetectorType is "SURF": detector = cv2.xfeatures2d.SURF_create() kp1 = detector.detect(im1) kp2 = detector.detect(im2) elif featureDetectorType is "ORB": detector = cv2.ORB_create(nfeatures=1500) kp1 = detector.detect(im1) kp2 = detector.detect(im2) else: assert (False, "Invalid Feature Detector") featureDescriptorType = "ORB" if featureDescriptorType is "SIFT": descriptor = cv2.xfeatures2d.SIFT_create() kp1, des1 = detector.compute(im1, kp1) kp2, des2 = detector.compute(im2, kp2) elif featureDescriptorType is "SURF": descriptor = cv2.xfeatures2d.SURF_create() kp1, des1 = detector.compute(im1, kp1) kp2, des2 = detector.compute(im2, kp2) elif featureDescriptorType is "ORB":
def orbgen(img, n=1000): orb = cv2.ORB_create(nfeatures=n) #detect features (keypoints, descriptors) = orb.detectAndCompute(img, None) return keypoints, descriptors