def fom(img, img_gold_std, alpha = DEFAULT_ALPHA): """ Computes Pratt's Figure of Merit for the given image img, using a gold standard image as source of the ideal edge pixels. """ # To avoid oversmoothing, we apply canny edge detection with very low # standard deviation of the Gaussian kernel (sigma = 0.1). edges_img = canny(img, 0.1, 20, 50) edges_gold = canny(img_gold_std, 0.1, 20, 50) # Compute the distance transform for the gold standard image. dist = distance_transform_edt(np.invert(edges_gold)) fom = 1.0 / np.maximum( np.count_nonzero(edges_img), np.count_nonzero(edges_gold)) N, M = img.shape for i in xrange(0, N): for j in xrange(0, M): if edges_img[i, j]: fom += 1.0 / ( 1.0 + dist[i, j] * dist[i, j] * alpha) fom /= np.maximum( np.count_nonzero(edges_img), np.count_nonzero(edges_gold)) return fom
def fom(img, img_gold_std, alpha=DEFAULT_ALPHA): """ Computes Pratt's Figure of Merit for the given image img, using a gold standard image as source of the ideal edge pixels. """ # To avoid oversmoothing, we apply canny edge detection with very low # standard deviation of the Gaussian kernel (sigma = 0.1). edges_img = canny(img, 0.1, 20, 50) edges_gold = canny(img_gold_std, 0.1, 20, 50) # Compute the distance transform for the gold standard image. dist = distance_transform_edt(np.invert(edges_gold)) fom = 1.0 / np.maximum(np.count_nonzero(edges_img), np.count_nonzero(edges_gold)) N, M = img.shape for i in xrange(0, N): for j in xrange(0, M): if edges_img[i, j]: fom += 1.0 / (1.0 + dist[i, j] * dist[i, j] * alpha) fom /= np.maximum(np.count_nonzero(edges_img), np.count_nonzero(edges_gold)) return fom
def get_contours(img): '''Calculate the image contours using Canny edge detection. Automatically adjusts the Canny parameters so that the ratio of edge pixels in the image falls within a certain range. Args: img (np.ndarray): image as a numpy array Returns: Image contours as a numpy array of 0s and 1s ''' rmin = 0.05 rmax = 0.15 n = 105 alpha = 0.35 beta = 1.5 sp0 = sp1 = 0 sig = 1 for i in range(5): c = canny(img, sig, n, alpha, beta) r = c.sum() / c.size if r < rmin: alpha -= .02 beta -= .1 elif r > rmax: alpha += .05 beta += .1 else: break return c
def localize(img2): edges = canny(img2) edges = np.array(edges * 255, dtype=np.uint8) image1, contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE) out = cv2.drawContours(img2, contours, -1, (0, 250, 0), 1) try: hierarchy = hierarchy[0] except: hierarchy = [] height, width, _ = img2.shape min_x, min_y = width, height max_x = max_y = 0 # computes the bounding box for the contour, and draws it on the frame, for contour, hier in zip(contours, hierarchy): (x, y, w, h) = cv2.boundingRect(contour) min_x, max_x = min(x, min_x), max(x + w, max_x) min_y, max_y = min(y, min_y), max(y + h, max_y) if w > 80 and h > 80: cv2.rectangle(img2, (x, y), (x + w, y + h), (255, 0, 0), 2) if max_x - min_x > 0 and max_y - min_y > 0: cv2.rectangle(img2, (min_x, min_y), (max_x, max_y), (255, 0, 0), 2) cv2.imshow("Show", img2) cv2.waitKey(0) cv2.destroyAllWindows()
def main(infile): c = canny.canny() img3 = misc.imread(infile, mode='RGBA') (height, width, channels) = img3.shape img = numpy.zeros((height,width)) img[:,:] += img3[:,:,0] << 24 img[:,:] += img3[:,:,1] << 16 img[:,:] += img3[:,:,2] << 8 img[:,:] += img3[:,:,3] << 0 edges = c.main(50, 100, img) print edges
def edge_detect(hr): canned = [] if 1: for hr_i in hr: canned.append(canny(hr_i.unsqueeze(0).half(),use_cuda=True)) canned = torch.cat(canned,dim=0).detach().float() EDGE_SIZE = 1 canned[:,:,:EDGE_SIZE,:] = 0 canned[:,:,-EDGE_SIZE:,:] = 0 canned[:,:,:,:EDGE_SIZE] = 0 canned[:,:,:,-EDGE_SIZE:] = 0 return canned
def test_canny(img): start = perf_counter() res = canny(img) finish = perf_counter() cv2.imshow('Canny', res) print('Time = ' + str(finish - start)) start = perf_counter() res_cv = cv2.Canny(img, 50, 70) finish = perf_counter() cv2.imshow('OpenCV Canny', res_cv) print('Time_opencv = ' + str(finish - start)) mse_value = mse(res, res_cv) print('MSE: ' + str(mse_value) + '\n')
def run(updateImageSignal, mode, setLabelSignal): camera.capture('image.jpg') ogImg = cv2.imread('image.jpg') colorImg = ogImg.copy() img = resize(ogImg, 50) imgContour = img.copy() img = img[20:200, 0:500] imgContour = imgContour[20:200, 0:500] cv2.imwrite('imageCrop.jpg', imgContour) form = canny(imgContour) print(form.corners) imgContour = resize(imgContour, 50) cv2.imwrite('output.jpg', imgContour) updateImageSignal.emit() classifyForm(form, mode, setLabelSignal)
""" canvasImg = copy(rawImg) lines = cv2.HoughLinesP(edges, rho=args.rho, theta=args.theta, threshold=args.threshold, lines=args.lines, minLineLength=args.minLineLength, maxLineGap=args.maxLineGap) try: lines = np.asarray([line for l in lines for line in l]) if (args.debug or args.opt): p = ProgressBar(1, len(lines)) i = 0 for x1, y1, x2, y2 in lines: cv2.line(canvasImg, (x1, y1), (x2, y2), (0, 255, 0), 2) p.update(i+1) i += 1 except TypeError, ZeroDivisionError: pass cv2.imwrite("./results/result.jpg", canvasImg) return (lines) if __name__ == "__main__": args = get_args() pre_img, raw_img = preprocess(args) edges_img = canny(pre_img, args) hough_img = hough(edges_img, raw_img, args)
theta = theta + ran_theta # Make sure it doesn't get below 0 (max can get up to is 135+15=150) if theta < 0: theta = 180+theta return theta if __name__ == "__main__": # Read image and convert it to double, and scale each R,G,B # channel to range [0,1]. imRGB = array(Image.open('orchid.jpg')) # Get monochrome image mono_im = convert_monochrome(imRGB) canny_im = can.canny(mono_im, 2.0, 7500, 2000) theta_im = get_theta(mono_im) imRGB = double(imRGB) / 255.0 plt.clf() plt.axis('off') sizeIm = imRGB.shape sizeIm = sizeIm[0:2] # Set radius of paint brush and half length of drawn lines rad = 3 halfLen = 5 # Set up x, y coordinate images, and canvas. [x, y] = np.meshgrid(np.array([i+1 for i in range(int(sizeIm[1]))]), np.array([i+1 for i in range(int(sizeIm[0]))])) canvas = np.zeros((sizeIm[0],sizeIm[1], 3))
def __init__(self): super(FromImage, self).__init__() self.theCanny = canny() self.showLine = displayLine() self.predLine = lineImg() self.theROI = roi()
plt.yticks([]) for spine in plt.gca().spines.values(): spine.set_visible(False) plt.show() def plot_edge(img1, edgepts): data = 255 * np.ones(img1.shape) data[edgepts[:, 0], edgepts[:, 1]] = 0 edge_img = Image.fromarray(data) plt.imshow(edge_img, cmap='gray') plt.xticks([]) plt.yticks([]) for spine in plt.gca().spines.values(): spine.set_visible(False) plt.show() # Main function if __name__ == '__main__': filenames = ['a1.png'] for file in filenames: img = imread(file, flatten=True) edges = canny.canny(img, sigma=0.8, low_thresh=0.01, high_thresh=0.1) edges_sample = edges[np.sort( np.random.choice(edges.shape[0], (200, ), replace=False))] # plot_fig(img) # plot_edge(img, edges) # plot_edge(img, edges_sample) shape_hist = build_histograms( edges_sample, 5, 12, np.sqrt(img.shape[0]**2 + img.shape[1]**2))
rad = 1 # Set up x, y coordinate images, and canvas. [x, y] = np.meshgrid(np.array([i+1 for i in range(int(sizeIm[1]))]), np.array([i+1 for i in range(int(sizeIm[0]))])) canvas = np.zeros((sizeIm[0],sizeIm[1], 3)) canvas.fill(-1) ## Initially mark the canvas with a value out of range. # Negative values will be used to denote pixels which are unpainted. # Random number seed np.random.seed(29645) red, green, blue = imRGB[:,:,0], imRGB[:,:,1], imRGB[:,:,2] imGray = 0.30 * red + 0.59 * green + 0.11 * blue part3 = canny.canny(imGray, 2.0, 25, 5) # Orientation of paint brush strokes theta = 2 * pi * np.random.rand(1,1)[0][0] gradientArray = findAngle(imGray, 4.0, 5) # Set vector from center to one end of the stroke. time.time() time.clock() numOfStrokes = 0 while (len(np.where(canvas==-1)[0])>0): leftHalfLen = 5 rightHalfLen = 5 # finding a negative pixel
def getdropcenters(image, sizedict, entire): temp = entire.split("/")[-1] name = temp.split(".")[0] height, width = sizedict[0], sizedict[1] #== Processing ======================================================================= title = image.split(".")[0] #-- Read image ----------------------------------------------------------------------- im = cv2.imread(image) im = fillhole(im) contours, _ = canny(im, CANNY_THRESH_1, CANNY_THRESH_2) contours_area = [] # calculate area and filter into new array for con in contours: area = cv2.contourArea(con) if 10000 < area < 25000: contours_area.append(con) contours_circles = [] # check if contour is of circular shape for con in contours_area: perimeter = cv2.arcLength(con, True) area = cv2.contourArea(con) if perimeter == 0: break circularity = 4*math.pi*(area/(perimeter*perimeter)) if 0.6 < circularity < 1.4: contours_circles.append(con) centers = [] bounds = [] plt.imshow(im) temp = [] for c in contours_circles: (x,y),radius = cv2.minEnclosingCircle(c) temp.append((x,y,radius)) count = 1 length = len(contours_circles) actual = [1] * len(contours_circles) for i in range(length): x,y,r = temp[i] for j in range(i+1, length): x1, y1, r2 = temp[j] if abs(x-x1) < r and abs(y-y1) < r: if actual[j] == 1: actual[j] = 0 for c in range(length): if actual[c] == 1: x,y,r = temp[c] radius = r /math.sqrt(2) plt.plot(x, y, 'ro') centers.append((round(x),round(y),round(radius))) lowerx = max(0, round(x - radius)) higherx = min(width, round(x + radius)) lowery = max(0, round(y - radius)) highery = min(height, round(y + radius)) bounds.append((lowery, highery, lowerx, higherx)) plt.text(x, y + 5, str(count)) count +=1 # print("BOUNDS: " + str(bounds)) directory = "centers" if not os.path.exists(directory): os.makedirs(directory) plt.savefig("centers/" + name + "centers" + ".jpg") plt.clf() return centers, bounds
def getdropcenters(image): #-- Read image ----------------------------------------------------------------------- im = cv2.imread(image) im = fillhole(im) contours, _ = canny(im, CANNY_THRESH_1, CANNY_THRESH_2) # cv2.drawContours(im, contours, -1, (0, 0, 255), 3) # cv2.imshow("all contours", im) # cv2.waitKey(0) # print("CONTOURS:" + str(len(contours))) contours_area = [] # calculate area and filter into new array for con in contours: area = cv2.contourArea(con) if 20 < area < 1000: contours_area.append(con) # cv2.drawContours(im, contours, -1, (0, 255, 0), 3) # cv2.imshow("contours area", im) # cv2.waitKey(0) # print("CONTOURS AREAS:" + str(len(contours_area))) contours_circles = [] # check if contour is of circular shape for con in contours_area: perimeter = cv2.arcLength(con, True) area = cv2.contourArea(con) if perimeter == 0: break circularity = 4 * math.pi * (area / (perimeter * perimeter)) if 0.6 < circularity < 1.4: contours_circles.append(con) # centers = [] # bounds = [] # plt.imshow(im) # for c in contours_circles: # (x,y),radius = cv2.minEnclosingCircle(c) # plt.plot(x, y, 'ro') centers = [] bounds = [] plt.imshow(im) temp = [] for c in contours_circles: (x, y), radius = cv2.minEnclosingCircle(c) temp.append((x, y, radius)) count = 1 length = len(contours_circles) actual = [1] * len(contours_circles) for i in range(length): x, y, r = temp[i] for j in range(i + 1, length): x1, y1, r2 = temp[j] if abs(x - x1) < r and abs(y - y1) < r: if actual[j] == 1: actual[j] = 0 final = [] for c in range(length): if actual[c] == 1: final.append(contours_circles[c]) x, y, r = temp[c] radius = r / math.sqrt(2) plt.plot(x, y, 'ro') centers.append((round(x), round(y), round(radius))) plt.text(x, y + 5, str(count)) count += 1 print(len(centers)) cv2.drawContours(im, final, -1, (255, 0, 0), 3) cv2.imshow("contours circles", im) cv2.waitKey(0) print("CONTOURS CIRCLES:" + str(len(final))) directory = "centers" if not os.path.exists(directory): os.makedirs(directory) plt.savefig("centers/" + datetime.now().strftime('%Y-%m-%d=%H-%M-%S') + "centers" + ".jpg") plt.clf()
# Set up x, y coordinate images, and canvas. [x, y] = np.meshgrid(np.array([i+1 for i in range(int(sizeIm[1]))]), np.array([i+1 for i in range(int(sizeIm[0]))])) canvas = np.zeros((sizeIm[0],sizeIm[1], 3)) canvas.fill(-1) ## Initially mark the canvas with a value out of range. # Negative values will be used to denote pixels which are unpainted. cannyluma = None cannyimg = None mytheta = None mygradient = None if(part_number >= 3): cannyluma = imRGB[:,:,1] * 0.59 + imRGB[:,:,2] * 0.11 + imRGB[:,:,0] * 0.30 cannyimg = canny.canny(cannyluma, 2.0, 25, 5) if(part_number == 3): cannyimgfilename = os.path.join(args.dir, base_file+'_canny'+ext) colorImSave(cannyimgfilename, cannyimg, 'gray') if(part_number >= 5): mythetafilename = os.path.join(args.dir, base_file+'_theta'+ext) if(part_number >= 7): (mytheta, mygradient) = computeGradient(cannyluma, 2, cannyimg, 10, True) if(part_number == 7): colorImSave(mythetafilename, mytheta) else: (mytheta, mygradient) = computeGradient(cannyluma, 4, cannyimg, 1, False) if(part_number == 5): colorImSave(mythetafilename, mytheta)
rad = 1 # Set up x, y coordinate images, and canvas. [x, y] = np.meshgrid(np.array([i + 1 for i in range(int(sizeIm[1]))]), np.array([i + 1 for i in range(int(sizeIm[0]))])) canvas = np.zeros((sizeIm[0], sizeIm[1], 3)) canvas.fill(-1) ## Initially mark the canvas with a value out of range. # Negative values will be used to denote pixels which are unpainted. # Random number seed np.random.seed(29645) red, green, blue = imRGB[:, :, 0], imRGB[:, :, 1], imRGB[:, :, 2] imGray = 0.30 * red + 0.59 * green + 0.11 * blue part3 = canny.canny(imGray, 2.0, 25, 5) # Orientation of paint brush strokes theta = 2 * pi * np.random.rand(1, 1)[0][0] gradientArray = findAngle(imGray, 4.0, 5) # Set vector from center to one end of the stroke. time.time() time.clock() numOfStrokes = 0 while (len(np.where(canvas == -1)[0]) > 0): leftHalfLen = 5 rightHalfLen = 5 # finding a negative pixel
import sys from gradient import gradient from nonmax import nonmax from canny import canny from bilateral import bilateral if __name__ == '__main__': if len(sys.argv) < 5: print('Usage: python main.py (command) [parameters...] (input_image) (output_image) \n\ commands: \n\ canny (sigma) (thr_high) (thr_low) \n\ dir (sigma) \n\ nonmax (sigma) \n\ bilateral (sigma_d) (sigma_r)') sys.exit(0) input_image = np.float64(imread(sys.argv[-2])) / 255. output_image = sys.argv[-1] command = sys.argv[1] if command == 'dir': _, directions = gradient(input_image, float(sys.argv[2])) imsave(output_image, directions) elif command == 'nonmax': imsave(output_image, nonmax(input_image, float(sys.argv[2]))) elif command == 'canny': imsave(output_image, canny(input_image, float(sys.argv[2]), float(sys.argv[4]), float(sys.argv[3]))) elif command == 'bilateral': imsave(output_image, bilateral(input_image, np.float64(sys.argv[2]), np.float64(sys.argv[3]) / 255))