def find_Lines(im): out = cv.CreateImage(cv.GetSize(im), 8, 1) tmp = cv.CreateImage(cv.GetSize(im), 8, 3) storage = cv.CreateMemStorage(0) cv.Canny(im, out, 50, 200, 3) cv.CvtColor(out, tmp, cv.CV_GRAY2BGR) return cv.HoughLines2(out, storage, cv.CV_HOUGH_STANDARD, 1, pi / 180, 100, 0, 0)
def find_lines_in_map_probabilistic(self, map_img): #Finds lines in the image using the probabilistic hough transform lines=cv.CreateMemStorage(0) line_img=cv.CreateMat(map_img.height, map_img.width, cv.CV_8UC1) cv.Set(line_img, 255) lines = cv.HoughLines2(map_img,cv.CreateMemStorage(), cv.CV_HOUGH_PROBABILISTIC, self.hough_rho,np.pi/2,self.hough_threshold) np_line=np.asarray(lines) print "list of probabilistic lines: ", np_line
def lines2(): im = cv.LoadImage('roi_edges.jpg', cv.CV_LOAD_IMAGE_GRAYSCALE) pi = math.pi x = 0 dst = cv.CreateImage(cv.GetSize(im), 8, 1) cv.Canny(im, dst, 200, 200) cv.Threshold(dst, dst, 100, 255, cv.CV_THRESH_BINARY) color_dst_standard = cv.CreateImage(cv.GetSize(im), 8, 3) cv.CvtColor(im, color_dst_standard, cv.CV_GRAY2BGR) #Create output image in RGB to put red lines lines = cv.HoughLines2(dst, cv.CreateMemStorage(0), cv.CV_HOUGH_STANDARD, 1, pi / 100, 71, 0, 0) klsum = 0 klaver = 0 krsum = 0 kraver = 0 #global k #k=0 for (rho, theta) in lines[:100]: kl = [] kr = [] a = math.cos(theta) b = math.sin(theta) x0 = a * rho y0 = b * rho pt1 = (cv.Round(x0 + 1000 * (-b)), cv.Round(y0 + 1000 * (a))) pt2 = (cv.Round(x0 - 1000 * (-b)), cv.Round(y0 - 1000 * (a))) k = ((y0 - 1000 * (a)) - (y0 + 1000 * (a))) / ((x0 - 1000 * (-b)) - (x0 + 1000 * (-b))) if abs(k) < 0.4: pass elif k > 0: kr.append(k) len_kr = len(kr) for i in kr: krsum = krsum + i kraver = krsum / len_kr cv.Line(color_dst_standard, pt1, pt2, cv.CV_RGB(255, 0, 0), 2, 4) elif k < 0: kr.append(k) kl.append(k) len_kl = len(kl) for i in kl: klsum = klsum + i klaver = klsum / len_kl cv.Line(color_dst_standard, pt1, pt2, cv.CV_RGB(255, 0, 0), 2, 4) #print k # cv.Line(color_dst_standard, pt1, pt2, cv.CV_RGB(255, 0, 0), 2, 4) cv.SaveImage('lane.jpg', color_dst_standard) print '左车道平均斜率:', klaver, ' 右车道平均斜率:', kraver cv.ShowImage("Hough Standard", color_dst_standard) cv.WaitKey(0)
def process(self): range_x = np.ceil((self.maxx - self.minx) * (1. / self.resolution)) + 1 range_y = np.ceil((self.maxy - self.miny) * (1. / self.resolution)) + 1 np_src = np.zeros((range_x, range_y), dtype=np.uint8) for el in self.xy.T: el_x = np.ceil((el[0] - self.minx) * (1. / self.resolution)) el_y = np.ceil((el[1] - self.miny) * (1. / self.resolution)) np_src[el_x, el_y] = 255 src = cv.fromarray(np_src) storage = cv.CreateMemStorage(0) self.lines = 0 self.lines = cv.HoughLines2(src, storage, cv.CV_HOUGH_PROBABILISTIC, self.pixel_res, self.theta_res, threshold=self.accum_thresh, param1=self.min_length, param2=self.gap_length)
if tracking == 0: detected = 0 cv.Smooth(grey, dst2, cv.CV_GAUSSIAN, 3) cv.Laplace(dst2, d) cv.CmpS(d, 8, d2, cv.CV_CMP_GT) if onlyBlackCubes: #can also detect on black lines for improved robustness cv.CmpS(grey, 100, b, cv.CV_CMP_LT) cv.And(b, d2, d2) #these weights should be adaptive. We should always detect 100 lines if lastdetected > dects: THR = THR + 1 if lastdetected < dects: THR = max(2, THR - 1) li = cv.HoughLines2(d2, cv.CreateMemStorage(), cv.CV_HOUGH_PROBABILISTIC, 1, 3.1415926 / 45, THR, 10, 5) #store angles for later angs = [] for (p1, p2) in li: #cv.Line(sg,p1,p2,(0,255,0)) a = atan2(p2[1] - p1[1], p2[0] - p1[0]) if a < 0: a += pi angs.append(a) #lets look for lines that share a common end point t = 10 totry = [] for i in range(len(li)): p1, p2 = li[i]
def extract_features(filename, is_url=False): '''Extracts features to be used in text image classifier. :param filename: input image :param is_url: is input image a url or a file path on disk :return: tuple of features: (average_slope, median_slope, average_tilt, median_tilt, median_differences, average_differences, nr_straight_lines) Most relevant ones are average_slope, average_differences and nr_straight_lines. ''' if is_url: filedata = urllib2.urlopen(filename).read() imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) cv.SetData(imagefiledata, filedata, len(filedata)) src = cv.DecodeImageM(imagefiledata, cv.CV_LOAD_IMAGE_GRAYSCALE) else: src = cv.LoadImage(filename, cv.CV_LOAD_IMAGE_GRAYSCALE) # normalize size normalized_size = 400 # smaller dimension will be 400, longer dimension will be proportional orig_size = cv.GetSize(src) max_dim_idx = max(enumerate(orig_size), key=lambda l: l[1])[0] min_dim_idx = [idx for idx in [0, 1] if idx != max_dim_idx][0] new_size = [0, 0] new_size[min_dim_idx] = normalized_size new_size[max_dim_idx] = int( float(orig_size[max_dim_idx]) / orig_size[min_dim_idx] * normalized_size) dst = cv.CreateImage(new_size, 8, 1) cv.Resize(src, dst) # cv.SaveImage("/tmp/resized.jpg",dst) src = dst dst = cv.CreateImage(cv.GetSize(src), 8, 1) color_dst = cv.CreateImage(cv.GetSize(src), 8, 3) storage = cv.CreateMemStorage(0) cv.Canny(src, dst, 50, 200, 3) cv.CvtColor(dst, color_dst, cv.CV_GRAY2BGR) slopes = [] # difference between xs or ys - variant of slope tilts = [] # x coordinates of horizontal lines horizontals = [] # y coordinates of vertical lines verticals = [] if USE_STANDARD: coords = cv.HoughLines2(dst, storage, cv.CV_HOUGH_STANDARD, 1, pi / 180, 50, 50, 10) lines = [] for coord in coords: (rho, theta) = coord a = cos(theta) b = sin(theta) x0 = a * rho y0 = b * rho pt1 = (cv.Round(x0 + 1000 * (-b)), cv.Round(y0 + 1000 * (a))) pt2 = (cv.Round(x0 - 1000 * (-b)), cv.Round(y0 - 1000 * (a))) lines += [(pt1, pt2)] else: lines = cv.HoughLines2(dst, storage, cv.CV_HOUGH_PROBABILISTIC, 1, pi / 180, 50, 50, 10) # eliminate duplicates - there are many especially with the standard version # first round the coordinates to integers divisible with 5 (to eliminate different but really close ones) # TODO # lines = list(set(map(lambda l: tuple([int(p) - int(p)%5 for p in l]), lines))) nr_straight_lines = 0 for line in lines: (pt1, pt2) = line # compute slope, rotate the line so that the slope is smallest # (slope is either delta x/ delta y or the reverse) # add smoothing term in denominator in case of 0 slope = min( abs(pt1[1] - pt2[1]), (abs(pt1[0] - pt2[0]))) / (max(abs(pt1[1] - pt2[1]), (abs(pt1[0] - pt2[0]))) + 0.01) # if slope < 0.1: # if slope < 5: if slope < 0.05: if abs(pt1[0] - pt2[0]) < abs(pt1[1] - pt2[1]): # means it's a horizontal line horizontals.append(pt1[0]) else: verticals.append(pt1[1]) if slope < 0.05: # if slope < 5: # if slope < 0.1: nr_straight_lines += 1 slopes.append(slope) tilts.append(min(abs(pt1[1] - pt2[1]), (abs(pt1[0] - pt2[0])))) # print slope average_slope = sum(slopes) / float(len(slopes)) median_slope = npmedian(nparray(slopes)) average_tilt = sum(tilts) / float(len(tilts)) median_tilt = npmedian(nparray(tilts)) differences = [] horizontals = sorted(horizontals) verticals = sorted(verticals) print "x_differences:" for (i, x) in enumerate(horizontals): if i > 0: # print abs(horizontals[i] - horizontals[i-1]) differences.append(abs(horizontals[i] - horizontals[i - 1])) print "y_differences:" for (i, y) in enumerate(verticals): if i > 0: # print abs(verticals[i] - verticals[i-1]) differences.append(abs(verticals[i] - verticals[i - 1])) print filename print "average_slope:", average_slope print "median_slope:", median_slope print "average_tilt:", average_tilt print "median_tilt:", median_tilt median_differences = npmedian(nparray(differences)) print "median_differences:", median_differences if not differences: # big random number for average difference average_differences = 50 else: average_differences = sum(differences) / float(len(differences)) print "average_differences:", average_differences print "nr_lines:", nr_straight_lines # print "sorted xs:", sorted(lines) return (average_slope, median_slope, average_tilt, median_tilt, median_differences, average_differences, nr_straight_lines)
cv.SetData(imagefiledata, filedata, len(filedata)) src = cv.DecodeImageM(imagefiledata, cv.CV_LOAD_IMAGE_GRAYSCALE) cv.NamedWindow("Source", 1) cv.NamedWindow("Hough", 1) while True: dst = cv.CreateImage(cv.GetSize(src), 8, 1) color_dst = cv.CreateImage(cv.GetSize(src), 8, 3) storage = cv.CreateMemStorage(0) lines = 0 cv.Canny(src, dst, 50, 200, 3) cv.CvtColor(dst, color_dst, cv.CV_GRAY2BGR) if USE_STANDARD: lines = cv.HoughLines2(dst, storage, cv.CV_HOUGH_STANDARD, 1, pi / 180, 100, 0, 0) for (rho, theta) in lines[:100]: a = cos(theta) b = sin(theta) x0 = a * rho y0 = b * rho pt1 = (cv.Round(x0 + 1000 * (-b)), cv.Round(y0 + 1000 * (a))) pt2 = (cv.Round(x0 - 1000 * (-b)), cv.Round(y0 - 1000 * (a))) cv.Line(color_dst, pt1, pt2, cv.RGB(255, 0, 0), 3, 8) else: lines = cv.HoughLines2(dst, storage, cv.CV_HOUGH_PROBABILISTIC, 1, pi / 180, 50, 50, 10) for line in lines: cv.Line(color_dst, line[0], line[1], cv.CV_RGB(255, 0, 0), 3, 8)
cv.DestroyAllWindows() sys.exit(-1) cv.NamedWindow("Source", 1) cv.NamedWindow("Hough", 1) while True: dst = cv.CreateImage(cv.GetSize(src), 8, 1) color_dst = cv.CreateImage(cv.GetSize(src), 8, 3) storage = cv.CreateMemStorage(0) lines = 0 cv.Canny(src, dst, 50, 200, 3) cv.CvtColor(dst, color_dst, cv.CV_GRAY2BGR) if USE_STANDARD: lines = cv.HoughLines2(dst, storage, cv.CV_HOUGH_STANDARD, 1, pi / 180, 100, 0, 0) for (rho, theta) in lines[:100]: a = cos(theta) b = sin(theta) x0 = a * rho y0 = b * rho pt1 = (cv.Round(x0 + 1000 * (-b)), cv.Round(y0 + 1000 * (a))) pt2 = (cv.Round(x0 - 1000 * (-b)), cv.Round(y0 - 1000 * (a))) cv.Line(color_dst, pt1, pt2, cv.RGB(255, 0, 0), 3, 8) print('detected line at(' + str(x0) + ',' + str(y0) + ')') print('(' + str(pt1) + ',' + str(pt2) + ')') else: deltaRho = float(1) deltaTheta = float(pi / 2) minVote = 20 minLength = 50
im = cv.LoadImage('14_108_eae2591dbc033d9.jpg', cv.CV_LOAD_IMAGE_GRAYSCALE) pi = math.pi #Pi value dst = cv.CreateImage(cv.GetSize(im), 8, 1) cv.Canny(im, dst, 200, 200) cv.Threshold(dst, dst, 100, 255, cv.CV_THRESH_BINARY) #---- Standard ---- color_dst_standard = cv.CreateImage(cv.GetSize(im), 8, 3) cv.CvtColor(im, color_dst_standard, cv.CV_GRAY2BGR) #Create output image in RGB to put red lines lines = cv.HoughLines2(dst, cv.CreateMemStorage(0), cv.CV_HOUGH_STANDARD, 1, pi / 180, 100, 0, 0) for (rho, theta) in lines[:100]: a = math.cos(theta) #Calculate orientation in order to print them b = math.sin(theta) x0 = a * rho y0 = b * rho pt1 = (cv.Round(x0 + 1000 * (-b)), cv.Round(y0 + 1000 * (a))) pt2 = (cv.Round(x0 - 1000 * (-b)), cv.Round(y0 - 1000 * (a))) cv.Line(color_dst_standard, pt1, pt2, cv.CV_RGB(255, 0, 0), 2, 4) #Draw the line #---- Probabilistic ---- color_dst_proba = cv.CreateImage(cv.GetSize(im), 8, 3) cv.CvtColor(im, color_dst_proba, cv.CV_GRAY2BGR) # idem rho = 1
import time import math import matplotlib.pyplot as plt import cv2.cv as cv2 import numpy as np # Foto con fondo cuadrado img = Image('/home/pi/Documents/Lab3/foto4.png') (r, g, b) = img.splitChannels(False) r.save('/home/pi/Documents/Lab3/red4.png') g.save('/home/pi/Documents/Lab3/green4.png') b.save('/home/pi/Documents/Lab3/blue4.png') img = cv2.LoadImage('/home/pi/Documents/Lab3/foto4.png', cv2.CV_LOAD_IMAGE_GRAYSCALE) pi = math.pi dst = cv2.CreateImage(cv2.GetSize(img), 8, 1) cv2.Canny(img, dst, 100, 200) cv2.Threshold(dst, dst, 100, 255, cv2.CV_THRESH_BINARY) color_dst_standard = cv2.CreateImage(cv2.GetSize(img), 8, 3) cv2.CvtColor(img, color_dst_standard, cv2.CV_GRAY2BGR) lines = cv2.HoughLines2(dst, cv2.CreateMemStorage(0), cv2.CV_HOUGH_STANDARD, 1, pi / 180, 100, 0, 0) cv2.ShowImage('Image', img) cv2.ShowImage("Cannied", dst) cv2.WaitKey(0)
def find_lines_in_map(self, map_img): #Finds lines in the image lines=cv.CreateMemStorage(0) line_img=cv.CreateMat(map_img.height, map_img.width, cv.CV_8UC1) cv.Set(line_img, 255) lines = cv.HoughLines2(map_img,cv.CreateMemStorage(), cv.CV_HOUGH_MULTI_SCALE, self.hough_rho,np.pi/2,self.hough_threshold) np_line=np.asarray(lines) print x0=[]#A vector of all the X0 y0=[]#A vector of all the Y0 theta0=[] n=0 #Print the lines so that we can see what is happening for rho,theta in np_line: a = np.cos(theta) b = np.sin(theta) x0.append(a*rho) y0.append(b*rho) theta0.append(theta) x1 = int(x0[n] + 3000*(-b)) y1 = int(y0[n] + 3000*(a)) x2 = int(x0[n] - 3000*(-b)) y2 = int(y0[n] - 3000*(a)) cv.Line(map_img,(x1,y1),(x2,y2),0,1) cv.Line(line_img,(x1,y1),(x2,y2),0,1) n = n+1 #create two lists with the x coordinate of vertical lines and y coordinate of horixontal lines. theta_rounded = np.round(theta0, 1) y_sorted = np.sort(np.round(y0,0)) ylist=[] xlist=[] n=0 for element in theta_rounded: if element == 0:#Horizontal line xlist.append(x0[n]) else: ylist.append(y0[n]) n=n+1 Ym=[] Xm=[] ordered_y = np.sort(ylist) ordered_x = np.sort(xlist) print ordered_x last_element =0 #Find middle points between lines for element in ordered_y: delta_element = element - last_element Ym.append(last_element+(delta_element)/2) last_element = deepcopy(element) last_element =0 for element in ordered_x: delta_element = element - last_element Xm.append(last_element+(delta_element)/2) last_element = deepcopy(element) #Printing the points in a map for yi in Ym: for xi in Xm: if self.map_img[yi,xi] >= 250: #If free space self.goal_list.append([yi,xi]) map_img[yi,xi]=255 self.goal_map[yi,xi]=0 return map_img