def featurePoints(greyscaleImg, mask): surf_keypoints, surf_descriptors = cv.ExtractSURF(greyscaleImg, mask, cv.CreateMemStorage(), (1, 3000, 3, 4)) img2 = np.array(img) for ((x, y), laplacian, size, dir, hessian) in surf_keypoints: if laplacian == -1: img2[int(y), int(x), 0] = 255 img2[int(y), int(x), 1] = 0 img2[int(y), int(x), 2] = 0 else: img2[int(y), int(x), 0] = 0 img2[int(y), int(x), 1] = 0 img2[int(y), int(x), 2] = 255 imsave('/home/cplab/workspace/imageex/src/imageex/static/SURFFFFFF.png', img2) #params = (maxSize, responseThreshold, lineThresholdProjected, lineThresholdBinarized, suppressNonmaxSize) star_keypoints = cv.GetStarKeypoints(greyscaleImg, cv.CreateMemStorage(), (8, 30, 10, 8, 3)) img3 = np.array(img) for ((x, y), size, response) in star_keypoints: if response >= 0: img3[int(y), int(x), 0] = 255 img3[int(y), int(x), 1] = 0 img3[int(y), int(x), 2] = 0 else: img3[int(y), int(x), 0] = 0 img3[int(y), int(x), 1] = 0 img3[int(y), int(x), 2] = 255 imsave('/home/cplab/workspace/imageex/src/imageex/static/STARRRRR.png', img3) return []
def ExtractSURF(im, min_hessian=300): ''' Uses OpenCV to extract SURF keypoints. Currently does not compute SURF features. TODO: An option should be added to also compute and return the SURF descriptors. TODO: This should be extended with options for octaves and levels. TODO: I believe there are no memory leaks but this should be checked. cvSURFParams? ''' cvim = im.asOpenCVBW() #mat = int(cvim.this) min_hessian = float(min_hessian) #TODO: OpenCV python interface now includes cv.ExtractSURF(cvim, mask, storage, params) #This is my (Steve's) attempt at this, but I am concerned we're not returning the # some of the information once this gets back to the caller...perhaps the parent # class is filtering out the addtnl data that SURF points provide? #TODO: Now that we have the descriptors, we need to return them to user if desired. (keypts, _) = cv.ExtractSURF(cvim, None, cv.CreateMemStorage(), (0, min_hessian, 3, 1)) keypoints = list() for ((x, y), laplacian, size, direction, hessian) in keypts: keypoints.append((hessian, x, y, size, direction, laplacian)) return keypoints
def __get_key_points(self, image_path): DESCRIPTORS_MIN = 300 DESCRIPTORS_MAX = 420 keypoints = 0 descriptors = 0 range = 600 range_gap = 40 do_surf = True image = cv.LoadImage(image_path, cv.CV_LOAD_IMAGE_GRAYSCALE) while (do_surf): (keypoints, descriptors) = cv.ExtractSURF(image, None, cv.CreateMemStorage(), (1, range, 3, 1)) do_surf = False print "Descriptors: %d (range=%d)" % (len(descriptors), range) if (len(descriptors) < DESCRIPTORS_MIN): range = range - range_gap if (len(descriptors) > DESCRIPTORS_MAX): range = range + range_gap if (len(descriptors) >= DESCRIPTORS_MIN and len(descriptors) <= DESCRIPTORS_MAX): do_surf = False return (keypoints, descriptors)
def surf(im, mask=None, extended=False, hessianThreshold=500, nOctaves=3, nOctaveLayers=4): ''' Keypoints contain a 0: center point 1 sign of laplacian (-1,0,+1) 2 scale - diameter or radius 3 angle 4 response value Descriptors contain 64 floating point numbers @param im: image to extract features from. @type im: pv.Image @param mask: a mask that controls where features are extracted from. @type mask: OpenCV 8bit image @return: (keypoints,descriptors) ''' cvim = im.asOpenCVBW() keypoints, descriptors = cv.ExtractSURF( cvim, mask, cv.CreateMemStorage(), (int(extended), hessianThreshold, nOctaves, nOctaveLayers)) return keypoints, descriptors
def detect_surf(image, equalize=False): if equalize: cv.EqualizeHist(image, image) keypoints, descriptors = cv.ExtractSURF(image, None, cv.CreateMemStorage(), (0, 800, 4, 5)) for keypoint in keypoints: x, y = int(keypoint[0][0]), int(keypoint[0][1]) cv.Circle(image, (x, y), 1, cv.RGB(0, 0, 255), 3, 8, 0) return image
def add_features(self, cv_image, face): """ Look for any new features around the current feature cloud """ """ Create the ROI mask""" roi = cv.CreateImage(cv.GetSize(cv_image), 8, 1) """ Begin with all black pixels """ cv.Zero(roi) """ Get the coordinates and dimensions of the current track box """ try: ((x, y), (w, h), a) = face.track_box except: logger.info("Track box has shrunk to zero...") return """ Expand the track box to look for new features """ w = int(face.expand_roi * w) h = int(face.expand_roi * h) roi_box = ((x, y), (w, h), a) """ Create a filled white ellipse within the track_box to define the ROI. """ cv.EllipseBox(roi, roi_box, cv.CV_RGB(255, 255, 255), cv.CV_FILLED) """ Create the temporary scratchpad images """ eig = cv.CreateImage(cv.GetSize(self.grey), 32, 1) temp = cv.CreateImage(cv.GetSize(self.grey), 32, 1) if self.feature_type == 0: """ Get the new features using Good Features to Track """ features = cv.GoodFeaturesToTrack(self.grey, eig, temp, self.max_count, self.quality, self.good_feature_distance, mask=roi, blockSize=3, useHarris=0, k=0.04) elif self.feature_type == 1: """ Get the new features using SURF """ features = [] (surf_features, descriptors) = cv.ExtractSURF( self.grey, roi, cv.CreateMemStorage(0), (0, self.surf_hessian_quality, 3, 1)) for feature in surf_features: features.append(feature[0]) """ Append new features to the current list if they are not too far from the current cluster """ for new_feature in features: try: distance = self.distance_to_cluster(new_feature, face.features) if distance > self.add_feature_distance: face.features.append(new_feature) except: pass """ Remove duplicate features """ face.features = list(set(face.features))
def train_on_file(self, filename, display_name): """train the system on the file in filename with the given name""" print "loading image %s" % filename example_img_gray = cv.LoadImage(filename, iscolor=cv.CV_LOAD_IMAGE_GRAYSCALE) (object_keypoints, object_descriptors) = cv.ExtractSURF(example_img_gray, None, cv.CreateMemStorage(), self.surf_params) self.keypoints += object_keypoints self.descriptors += object_descriptors self.displaynames[filename] = display_name self.names += len(object_keypoints)*[filename] object_image = cv.CreateImage(cv.GetSize(example_img_gray), cv.IPL_DEPTH_8U, 3) cv.Set(object_image,0) cv.CvtColor(example_img_gray, object_image, cv.CV_GRAY2RGB) self.images[filename] = object_image self.sizes[display_name] = cv.GetSize(example_img_gray) self.modelKeypoints[display_name] = object_keypoints
def get_similar_actresses(self, target_image_path): img = cv.LoadImageM(target_image_path , cv.CV_LOAD_IMAGE_GRAYSCALE) (keypoints, descriptors) = cv.ExtractSURF(img, None, cv.CreateMemStorage(), (1 , 500, 3, 4)) bag_of_keypoints = self._calc_a_bag_of_keypoints(descriptors) distance = ((self.pd_feature_data - bag_of_keypoints)**2).sum(axis=1) distance.sort(ascending=True) # distance = ((self.pd_feature_data * bag_of_keypoints)).sum(axis=1) # distance.sort(ascending=False) return distance.index.values[0:10]
def Execute(self): images = self.GetInputStageValue(0, "images") self.StartProcess() import cv MIN_DESC_VAL = -0.5 MAX_DESC_VAL = 0.8 CONV_FACTOR = 255.0 / (MAX_DESC_VAL-MIN_DESC_VAL) kds = [] for im in images.GetImages(): keypointDescriptorFile = os.path.join(os.path.splitext(im.GetFilePath())[0]+".key") if (Common.Utility.ShouldRun(self._properties["Force Run"], keypointDescriptorFile)): cvim = cv.LoadImageM(im.GetFilePath(), cv.CV_LOAD_IMAGE_GRAYSCALE) keypoints, descriptors = cv.ExtractSURF(cvim, None, cv.CreateMemStorage(), (1, self._properties["Hessian Threshold"], self._properties["Number Octaves"], self._properties["Number Octave Layers"])) l = [] for i,descriptor in enumerate(descriptors): descr = [int((x-MIN_DESC_VAL)*CONV_FACTOR) for x in descriptor] l.append(FeatureExtraction.KeypointDescriptor(keypoints[i][0][1], keypoints[i][0][0], keypoints[i][2], math.radians(keypoints[i][3]), descr)) kdfl = FeatureExtraction.KeypointDescriptorFileLowe(l) kdfl.Write(keypointDescriptorFile) kdfl = FeatureExtraction.KeypointDescriptorFileLowe(keypointDescriptorFile, False) kds.append(kdfl) kds = FeatureExtraction.KeypointDescriptors(images.GetPath(), kds, False) self.SetOutputValue("keypointDescriptors", kds)
def findSurfBlobs(cvImg): """ Run the OpenCV ExtractSURF algorithm on the given input cvImage. Render the results as circles with directional lines onto a copy of the input image and return this cvImage as the result of the method call. @param cvImg: input OpenCV image to perform SURF analysis on. @return: a copy of the input image with SURF results rendered onto it. """ #Algorithm params tuple (extended, hessianThreshold, nOctaves, nOctaveLayers): #extended: 0 means basic descriptors (64 elements each), 1 means extended (128 each) #hessianThreshold: only features with hessian larger than that are extracted. # good default value is ~300-500 (can depend on the average local contrast # and sharpness of the image). user can further filter out some features based # on their hessian values and other characteristics. #nOctaves: the number of octaves to be used for extraction. # With each next octave the feature size is doubled (3 by default) #nOctaveLayers: The number of layers within each octave (4 by default) storage = cv.CreateMemStorage() (keypts, descs) = cv.ExtractSURF(cvImg, None, storage, (1, 100, 4, 1)) cimg = cv.CreateImage((80,60), cv.IPL_DEPTH_8U, 3) cv.CvtColor(cvImg, cimg, cv.CV_GRAY2BGR) maxSize = 1 for ((x, y), laplacian, size, dir, hessian) in keypts: maxSize = max(maxSize, size) for ((x, y), laplacian, size, dir, hessian) in keypts: print "x=%d y=%d laplacian=%d size=%d dir=%f hessian=%f" % (x, y, laplacian, size, dir, hessian) if size>=maxSize: x = int(x) y = int(y) cv.Circle(cimg, (x,y), size, cv.CV_RGB(0,0,255)) deg = radians(dir) xd = int((x+(size*cos(deg)))) yd = int(y+(size*sin(deg)*-1)) cv.Line(cimg, (x,y), (xd,yd), cv.CV_RGB(0,0,255)) print " " return cimg
def process_image(self, image, visualize=False, min_matches=3, min_distance=0.05, close_objects=[]): """ Process the next image, trying to recognize any trained objects Parameters: int min_matches: number of minimum keypoint mathches int min_distances: minimum distance between keypoints matches """ self.imageSize = cv.GetSize(image) if image.nChannels > 1: image_gray = cv.CreateImage(self.imageSize, cv.IPL_DEPTH_8U, 1) cv.Set(image_gray,0) cv.CvtColor(image, image_gray, cv.CV_RGB2GRAY) else: image_gray = image try: (keypoints2, descriptors2) = cv.ExtractSURF(image_gray, None, cv.CreateMemStorage(), self.surf_params) neighbours, dists = self.NNdatabase.nn_index(numpy.array(descriptors2), checks=self.db_params["checks"]) close_enough = self.get_close_indexes(dists, min_distance) keys_per_name = self.get_keys_per_name(neighbours, close_enough) deletes_counter = 0 if close_objects != []: for key in keys_per_name.keys(): if key not in close_objects: del(keys_per_name[key]) deletes_counter += 1 print 'Deleted KPN:\t', deletes_counter print 'Remaining KPN:\t', len(keys_per_name) detections = self.detect_objects(keys_per_name, self.keypoints, keypoints2, dists, neighbours, image, visualize, min_matches) return detections except: #If no objects detected only show image: if visualize: cv.ShowImage(self.vision_window, image) cv.WaitKey(10) return []
def extract_surf(jpgfile): start = time.time() out = os.path.join(os.path.dirname(jpgfile), os.path.basename(jpgfile)[:-4] + 'surf.npy') if os.path.exists(out): INFO('%s already exists' % out) return im = cv.LoadImageM(jpgfile, cv.CV_LOAD_IMAGE_GRAYSCALE) INFO('cv loaded %dx%d image' % (im.rows, im.cols)) g, features = cv.ExtractSURF(im, None, cv.CreateMemStorage(), (0, 500, 3, 4)) data = np.ndarray(len(features), SURFReader.surf_dtype) for i in range(len(features)): data[i]['vec'] = np.fromiter(features[i], np.float32) data[i]['geom'] = np.fromiter([g[i][0][0], g[i][0][1], g[i][2]], np.uint16) data[i]['index'] = 0 ## Simple Quantization into bytes # for i in range(len(features)): # surfvalues = np.fromiter(features[i], np.float) # # assert max(surfvalues) <= 1.0 # assert min(surfvalues) >= -1.0 # # data[i]['vec'] = np.int8(127*surfvalues) # data[i]['geom'] = np.fromiter([g[i][0][0], g[i][0][1], g[i][2]], np.uint16) # data[i]['index'] = 0 save_atomic(lambda d: np.save(d, data), out) INFO('cv wrote %d features' % len(features)) INFO_TIMING('took %f seconds' % (time.time() - start))
def surf(image_gray, params=(1, 3000, 3, 4)): surf_stor = cv.CreateMemStorage() surf_r = cv.ExtractSURF(image_gray, None, surf_stor, params) del surf_stor return surf_r
# CAPTURE IMAGE img = cv.QueryFrame(camera) cv.CvtColor(img, img_rgb, cv.CV_BGR2RGB) cv.CvtColor(img_rgb, grayscale, cv.CV_BGR2GRAY) # CONVERT IMAGE to PIL img_pil = Image.fromstring("RGB", cv.GetSize(img_rgb), img_rgb.tostring()) pgimg = pygame.image.frombuffer(img_pil.tostring(), img_pil.size,img_pil.mode) #descriptors =[] try: (keypoints, descriptors) =cv.ExtractSURF(grayscale, None, cv.CreateMemStorage(),(0, 2000, 3, 2)) # DRAW KEYPOINT if DRAW_DESC: for ((x, y), laplacian, size, dir, hessian) in keypoints: radio = size*1.2/9.*2 #print "radioOld: ", int(radio) color = (255, 0, 0) if radio < 3: radio = 2 color = (255, 0, 200)
# but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from __future__ import division import logging import cv import numpy as np import os, pickle logging.basicConfig(level=logging.DEBUG) PICS_DIR = "256_ObjectCategories" CATS = {'moto': '145.motorbikes-101', 'plane': '251.airplanes-101'} for name, dir in CATS.items(): dir = os.path.join(PICS_DIR, dir) surfs = {} for file in os.listdir(dir): file = os.path.join(dir, file) logging.debug('%s in progress ...' % file) image = cv.LoadImage(file) image_gray = cv.CreateImage(cv.GetSize(image), image.depth, 1) cv.CvtColor(image, image_gray, cv.CV_BGR2GRAY) k, v = cv.ExtractSURF(image_gray, None, cv.CreateMemStorage(), (1, 300, 3, 1)) surfs[file] = np.array(v) pickle.dump(surfs, open(name, 'wb'))
def track_lk(self, cv_image, face): feature_box = None """ Initialize intermediate images if necessary """ if not face.pyramid: face.grey = cv.CreateImage(cv.GetSize(cv_image), 8, 1) face.prev_grey = cv.CreateImage(cv.GetSize(cv_image), 8, 1) face.pyramid = cv.CreateImage(cv.GetSize(cv_image), 8, 1) face.prev_pyramid = cv.CreateImage(cv.GetSize(cv_image), 8, 1) face.features = [] """ Create a grey version of the image """ cv.CvtColor(cv_image, face.grey, cv.CV_BGR2GRAY) """ Equalize the histogram to reduce lighting effects """ cv.EqualizeHist(face.grey, face.grey) if face.track_box and face.features != []: """ We have feature points, so track and display them """ """ Calculate the optical flow """ face.features, status, track_error = cv.CalcOpticalFlowPyrLK( face.prev_grey, face.grey, face.prev_pyramid, face.pyramid, face.features, (self.win_size, self.win_size), 3, (cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 20, 0.01), self.flags) """ Keep only high status points """ face.features = [p for (st, p) in zip(status, face.features) if st] elif face.track_box and self.is_rect_nonzero(face.track_box): """ Get the initial features to track """ """ Create a mask image to be used to select the tracked points """ mask = cv.CreateImage(cv.GetSize(cv_image), 8, 1) """ Begin with all black pixels """ cv.Zero(mask) """ Get the coordinates and dimensions of the track box """ try: x, y, w, h = face.track_box except: return None if self.auto_face_tracking: # """ For faces, the detect box tends to extend beyond the actual object so shrink it slightly """ # x = int(0.97 * x) # y = int(0.97 * y) # w = int(1 * w) # h = int(1 * h) """ Get the center of the track box (type CvRect) so we can create the equivalent CvBox2D (rotated rectangle) required by EllipseBox below. """ center_x = int(x + w / 2) center_y = int(y + h / 2) roi_box = ((center_x, center_y), (w, h), 0) """ Create a filled white ellipse within the track_box to define the ROI. """ cv.EllipseBox(mask, roi_box, cv.CV_RGB(255, 255, 255), cv.CV_FILLED) else: """ For manually selected regions, just use a rectangle """ pt1 = (x, y) pt2 = (x + w, y + h) cv.Rectangle(mask, pt1, pt2, cv.CV_RGB(255, 255, 255), cv.CV_FILLED) """ Create the temporary scratchpad images """ eig = cv.CreateImage(cv.GetSize(self.grey), 32, 1) temp = cv.CreateImage(cv.GetSize(self.grey), 32, 1) if self.feature_type == 0: """ Find keypoints to track using Good Features to Track """ face.features = cv.GoodFeaturesToTrack( face.grey, eig, temp, self.max_count, self.quality, self.good_feature_distance, mask=mask, blockSize=self.block_size, useHarris=self.use_harris, k=0.04) elif self.feature_type == 1: """ Get the new features using SURF """ (surf_features, descriptors) = cv.ExtractSURF( face.grey, mask, cv.CreateMemStorage(0), (0, self.surf_hessian_quality, 3, 1)) for feature in surf_features: face.features.append(feature[0]) # if self.auto_min_features: """ Since the detect box is larger than the actual face or desired patch, shrink the number of features by 10% """ face.min_features = int(len(face.features) * 0.9) face.abs_min_features = int(0.5 * face.min_features) """ Swapping the images """ face.prev_grey, face.grey = face.grey, face.prev_grey face.prev_pyramid, face.pyramid = face.pyramid, face.prev_pyramid """ If we have some features... """ if len(face.features) > 0: """ The FitEllipse2 function below requires us to convert the feature array into a CvMat matrix """ try: self.feature_matrix = cv.CreateMat(1, len(face.features), cv.CV_32SC2) except: pass """ Draw the points as green circles and add them to the features matrix """ i = 0 for the_point in face.features: if self.show_features: cv.Circle(self.marker_image, (int(the_point[0]), int(the_point[1])), 2, (0, 255, 0, 0), cv.CV_FILLED, 8, 0) try: cv.Set2D(self.feature_matrix, 0, i, (int(the_point[0]), int(the_point[1]))) except: pass i = i + 1 """ Draw the best fit ellipse around the feature points """ if len(face.features) > 6: feature_box = cv.FitEllipse2(self.feature_matrix) else: feature_box = None """ Publish the ROI for the tracked object """ # try: # (roi_center, roi_size, roi_angle) = feature_box # except: # logger.info("Patch box has shrunk to zeros...") # feature_box = None # if feature_box and not self.drag_start and self.is_rect_nonzero(face.track_box): # self.ROI = RegionOfInterest() # self.ROI.x_offset = min(self.image_size[0], max(0, int(roi_center[0] - roi_size[0] / 2))) # self.ROI.y_offset = min(self.image_size[1], max(0, int(roi_center[1] - roi_size[1] / 2))) # self.ROI.width = min(self.image_size[0], int(roi_size[0])) # self.ROI.height = min(self.image_size[1], int(roi_size[1])) # self.pubROI.publish(self.ROI) if feature_box is not None and len(face.features) > 0: return feature_box else: return None
def _extract_surf_features(self, img_path): img = cv.LoadImageM(img_path, cv.CV_LOAD_IMAGE_GRAYSCALE) _, descriptors = cv.ExtractSURF(img, None, cv.CreateMemStorage(), (1, 500, 3, 4)) return descriptors
#! /usr/bin/python # -*- encoding: utf-8 -*- import cv from sys import * ''' 引数に画像のパスを指定するとsurfを表示します。 ''' im = cv.LoadImageM(argv[1], cv.CV_LOAD_IMAGE_GRAYSCALE) (keypoints, descriptors) = cv.ExtractSURF(im, None, cv.CreateMemStorage(), (1, 500, 3, 4)) for ((x, y), laplacian, size, dir, hessian) in keypoints: cv.Circle(im, (int(x), int(y)), int(hessian / 1000), cv.RGB(255, 255, 255), 1, cv.CV_AA, 0) cv.SaveImage("face_detected.jpg", im) #cv.ShowImage("aaa",im)
def main(argv=None): if argv is None: argv = sys.argv flann = FLANN() try: sample_dir = argv[1] sample_name = argv[2] start_frame = int(argv[3]) end_frame = int(argv[4]) hessian_threshold = int(argv[5]) except (IndexError): print "Argument error\n Usage: python tracker.py sample_dir\ sample_filename start_frame end_frame hessian_threshold" return # Loading first frame im = cv.LoadImageM(sample_dir + sample_name + str(start_frame) + '.jpg', cv.CV_LOAD_IMAGE_GRAYSCALE) # Extracting SURF descriptors from reference image # to make selecting the tracked region easier (k, d) = cv.ExtractSURF(im, None, cv.CreateMemStorage(), (0, hessian_threshold, 3, 1)) draw_features(im, k) frames = [im] # Create window and controls tr = get_tracked_region(im) # Extracting descriptors from each target image and # calculating the distances to the nearest neighbors # Tracked region must be updated in each step for x in range(start_frame, end_frame): im2 = cv.LoadImageM(sample_dir + sample_name + str(x) + '.jpg', cv.CV_LOAD_IMAGE_GRAYSCALE) # Creating mask for extracting features from new image mask = tr.get_mask() (k2, d2) = cv.ExtractSURF(im2, mask, cv.CreateMemStorage(), (0, hessian_threshold, 3, 1)) d2 = array(d2, dtype=float32) result = None dists = None if x == start_frame: params = flann.build_index(d2, target_precision=0.9) tr.size = 1.1 * tr.size else: if len(d2) > 0: result, dists = flann.nn_index(d2, 1, checks=params['checks']) # Creating full neighbor table neighbors = [] nearest_neighbors = [] for n in range(len(d2)): neighbors.append((d2[n], k2[n], result[n], dists[n])) # Removing not-nearest neighbors for k in range(len(d2)): k_neighbors = filter(lambda x: x[2] == k, neighbors) num_neighbors = len(k_neighbors) if num_neighbors >= 1: if num_neighbors > 1: nearest = reduce( lambda x, y: x if x[3] < y[3] else y, k_neighbors) else: nearest = k_neighbors[0] nearest_neighbors.append(nearest) nearest_keypoints = [kp[1] for kp in nearest_neighbors] if len(nearest_keypoints) > 0: centroid = calc_centroid(nearest_keypoints) tr.xpos = centroid[0] - tr.size / 2 tr.ypos = centroid[1] - tr.size / 2 draw_tracked_region(im2, tr) #print "Frame %d had %d feature(s)!" % (x, len(d2)) else: #print "Frame %d had no features!" % x pass frames.append((im2, k2, d2, result, dists)) cv.NamedWindow("target") esc_pressed = False while True: for frame in frames: cv.ShowImage("target", frame[0]) if cv.WaitKey(50) == 27: esc_pressed = True break if esc_pressed: cv.DestroyAllWindows() break return frames, params
final_image=array(concatenate((img1, img2), axis=1)) # Concatenate the two images for loopVar1 in range(0, len(matches)): # For each pair of point in the matched set cv2.line(final_image, (int(matches[loopVar1][0][1]), int(matches[loopVar1][0][0])), (int(matches[loopVar1][1][1])+offset, int(matches[loopVar1][1][0])), (255*(loopVar1%4),255*((loopVar1+1)%4),255*((loopVar1+2)%4)), 1) # Draw a line cv2.circle(final_image, (int(matches[loopVar1][0][1]), int(matches[loopVar1][0][0])), 2, (255,0,0), -1) # Draw a point cv2.circle(final_image, (int(matches[loopVar1][1][1])+offset, int(matches[loopVar1][1][0])), 2, (255,0,0), -1) # Draw a point cv2.imshow('final_matched', final_image) cv2.imwrite("matched_SURF.jpg", final_image) # Save the resultant image cv2.waitKey(0) #Wait for key-press #---------------------------------------------------------------------------------------------# #---------------------------------------------------------------------------------------------# # Load image 1 orig_img_1 = cv2.imread(filename1,1) input_img_1 = cv.LoadImage(filename1,0) # Load image 2 orig_img_2 = cv2.imread(filename2,1) input_img_2 = cv.LoadImage(filename2,0) #---------------------------------------------------------------------------------------------# # Use OpenCV's built in SURF function to get the corner points and their descriptors (points1, desc1)=cv.ExtractSURF(input_img_1, None, cv.CreateMemStorage(), (0, surf_th, 3, 1)) (points2, desc2)=cv.ExtractSURF(input_img_2, None, cv.CreateMemStorage(), (0, surf_th, 3, 1)) matches=[] find_matches(points1, points2, desc1, desc2, matches, score_th, ratio_th) # Use the descriptors to find the matches draw_lines(orig_img_1, orig_img_2, matches) # Draw the lines between matches points print len(matches) # print the number of matched points
img = cv.LoadImageM("/home/lforet/Downloads/photo.JPG") tempimage = cv.LoadImageM("/home/lforet/Downloads/eye.JPG") size = cv.GetSize(img) size2 = cv.GetSize(tempimage) width = (size[0] - size2[0] + 1) height = (size[1] - size2[1] + 1) resultimage = cv.CreateImage((width, height), cv.IPL_DEPTH_32F, 1) cv.MatchTemplate(img, tempimage, resultimage, 1) cv.ShowImage("result", resultimage) cv.ShowImage("photo", img) # wait some key to end img = cv.LoadImageM("2005_Nickel_Proof_Obv.tif", cv.CV_LOAD_IMAGE_GRAYSCALE) (keypoints, descriptors) = cv.ExtractSURF(img, None, cv.CreateMemStorage(), (0, 30000, 3, 1)) print len(keypoints), len(descriptors) for ((x, y), laplacian, size, dir, hessian) in keypoints: print "x=%d y=%d laplacian=%d size=%d dir=%f hessian=%f" % ( x, y, laplacian, size, dir, hessian) cv.Circle(img, (x, y), size, (255, 0, 0), 1, cv.CV_AA, 0) cv.ShowImage("SURF", img) stor = cv.CreateMemStorage() seq = cv.FindContours(canny_image, stor, cv.CV_RETR_LIST, cv.CV_CHAIN_APPROX_SIMPLE) cv.DrawContours(canny_image, seq, (255, 0, 0), (0, 0, 255), 20, thickness=1) cv.ShowImage("Contours", canny_image)