def roberts(data, sliceId=2): edges = np.zeros(data.shape) if sliceId == 2: for idx in range(data.shape[2]): edges[:, :, idx] = skifil.roberts(data[:, :, idx]) elif sliceId == 0: for idx in range(data.shape[0]): edges[idx, :, :] = skifil.roberts(data[idx, :, :]) return edges
def filter(data, filtType, par): if filtType == "sobel": filt_data = sobel(data) elif filtType == "roberts": filt_data = roberts(data) elif filtType == "canny": filt_data = canny(data) elif filtType == "lowpass_avg": from scipy import ndimage p = int(par) kernel = np.ones((p, p), np.float32) / (p * p) filt_data = ndimage.convolve(data, kernel) elif filtType == "lowpass_gaussian": s = float(par) filt_data = gaussian_filter(data, sigma=s) elif filtType == "highpass_gaussian": s = float(par) lp_data = gaussian_filter(data, sigma=s) filt_data = data - lp_data elif filtType == "highpass_avg": from scipy import ndimage p = int(par) kernel = np.ones((p, p), np.float32) / (p * p) lp_data = ndimage.convolve(data, kernel) filt_data = data - lp_data #elif filtType == "gradient": return filt_data
def test_roberts_diagonal2(): """Roberts' filter on a diagonal edge should be a diagonal line.""" image = np.rot90(np.tri(10, 10, 0), 3) expected = ~np.rot90(np.tri(10, 10, -1).astype(bool) | np.tri(10, 10, -2).astype(bool).transpose()) expected = _mask_filter_result(expected, None) result = F.roberts(image).astype(bool) assert_close(result, expected)
def test_roberts_diagonal1(): """Roberts' on an edge should be a one diagonal""" image = np.tri(10, 10, 0) expected = ~(np.tri(10, 10, -1).astype(bool) | \ np.tri(10, 10, -2).astype(bool).transpose()) expected = _mask_filter_result(expected,None) result = F.roberts(image).astype(bool) assert_close(result,expected)
def filter(self, array, *args, **kwargs): shp = array.shape array = array.reshape((np.prod(shp[0:-2]),) + shp[-2:]) # reshape to (nch, ny, nx) for k, arr in enumerate(np.abs(array)): # loop over channels array[k, ...] = filter.roberts(arr) array = array.reshape(shp) # back to original shape return array
def test_roberts_diagonal2(): """Roberts' on an edge should be a other diagonal""" diagonal = np.tri(10, 10, 0,dtype=int) rev_diagonal = np.rot90(diagonal.transpose(),1) image = (rev_diagonal > 0).astype(float) expected = ~np.rot90((np.tri(10, 10, -1).astype(bool) | \ np.tri(10, 10, -2).astype(bool).transpose()),1) expected = _mask_filter_result(expected,None) result = F.roberts(image).astype(bool) assert_close(result,expected)
def getEdges(image): """Computes sobel and robers edges on uint8 single channel grayscale image input: image, single channel numpy array, uint8, and 0-255 range outputs: edge_roberts, single channel numpy array, uint64, and 0-1 range edge_sobel, single channel numpy array, uint64, and 0-1 range""" from skimage.filter import roberts, sobel edge_roberts = roberts(image) edge_sobel = sobel(image) #print 'Image info', type(image), image.shape, image.dtype, image.min(), image.max() #print 'Sobel info', type(edge_sobel), edge_sobel.shape, edge_sobel.dtype, edge_sobel.min(), edge_sobel.max() # Change the range to 0-255 and the type to uint8 edge_sobel = np.uint8(edge_sobel * 255) edge_roberts = np.uint8(edge_roberts * 255) cv2.imshow('input || sobel || roberts', np.hstack((image, edge_sobel, edge_roberts))) # cv2.waitKey(0) return edge_roberts, edge_sobel
def filter_function(img_grey, filt='canny'): """ Grayscales and apply edge detectors to image. Returns the flattened filtered image array. input: raw image 3d tensor output: filtered image filters: 'sobel', 'roberts', 'scharr' default filter = 'canny' """ # grayscale filters: if filt == 'sobel': return sobel(img_grey) elif filt == 'roberts': return roberts(img_grey) elif filt == 'canny': return canny(img_grey) elif filt == 'scharr': return scharr(image_grey) elif filt == ('canny', 'sobel'): return canny(sobel(img_grey)) else: raise Exception('No Such Filter!')
def filter(data, filtType, par): if filtType == "sobel": filt_data = sobel(data) elif filtType == "roberts": filt_data = roberts(data) elif filtType == "canny": filt_data = canny(data) elif filtType == "lowpass_avg": from scipy import ndimage p = int(par) kernel = np.ones((p, p), np.float32) / (p * p) filt_data = ndimage.convolve(data, kernel) elif filtType == "lowpass_gaussian": s = float(par) filt_data = gaussian_filter(data, sigma=s) elif filtType == "highpass_gaussian": s = float(par) lp_data = gaussian_filter(data, sigma=s) filt_data = data - lp_data elif filtType == "highpass_avg": from scipy import ndimage p = int(par) kernel = np.ones((p, p), np.float32) / (p * p) lp_data = ndimage.convolve(data, kernel) filt_data = data - lp_data # elif filtType == "gradient": return filt_data
from __future__ import print_function import matplotlib.pyplot as plt import numpy as np import sys import nrrd from skimage.segmentation import felzenszwalb, slic, quickshift from skimage.segmentation import mark_boundaries from skimage.util import img_as_float from skimage import filter img = img_as_float(nrrd.read(sys.argv[1])[0]) sobel = filter.sobel(img) roberts = filter.roberts(img) #segments_fz = felzenszwalb(img, scale=100, sigma=0.5, min_size=50) #segments_slic = slic(img, n_segments=250, compactness=10, sigma=1) #segments_quick = quickshift(img, kernel_size=3, max_dist=6, ratio=0.5) #print("Felzenszwalb's number of segments: %d" % len(np.unique(segments_fz))) #print("Slic number of segments: %d" % len(np.unique(segments_slic))) #print("Quickshift number of segments: %d" % len(np.unique(segments_quick))) #fig, ax = plt.subplots(1, 3) #fig.set_size_inches(8, 3, forward=True)
def seeds(args): """ %prog seeds [pngfile|jpgfile] Extract seed metrics from [pngfile|jpgfile]. Use --rows and --cols to crop image. """ p = OptionParser(seeds.__doc__) p.set_outfile() opts, args, iopts = add_seeds_options(p, args) if len(args) != 1: sys.exit(not p.print_help()) pngfile, = args pf = opts.prefix or op.basename(pngfile).rsplit(".", 1)[0] sigma, kernel = opts.sigma, opts.kernel rows, cols = opts.rows, opts.cols labelrows, labelcols = opts.labelrows, opts.labelcols ff = opts.filter calib = opts.calibrate outdir = opts.outdir if outdir != ".": mkdir(outdir) if calib: calib = json.load(must_open(calib)) pixel_cm_ratio, tr = calib["PixelCMratio"], calib["RGBtransform"] tr = np.array(tr) resizefile, mainfile, labelfile, exif = convert_image( pngfile, pf, outdir=outdir, rotate=opts.rotate, rows=rows, cols=cols, labelrows=labelrows, labelcols=labelcols ) oimg = load_image(resizefile) img = load_image(mainfile) fig, (ax1, ax2, ax3, ax4) = plt.subplots(ncols=4, nrows=1, figsize=(iopts.w, iopts.h)) # Edge detection img_gray = rgb2gray(img) logging.debug("Running {0} edge detection ...".format(ff)) if ff == "canny": edges = canny(img_gray, sigma=opts.sigma) elif ff == "roberts": edges = roberts(img_gray) elif ff == "sobel": edges = sobel(img_gray) edges = clear_border(edges, buffer_size=opts.border) selem = disk(kernel) closed = closing(edges, selem) if kernel else edges filled = binary_fill_holes(closed) # Watershed algorithm if opts.watershed: distance = distance_transform_edt(filled) local_maxi = peak_local_max(distance, threshold_rel=0.05, indices=False) coordinates = peak_local_max(distance, threshold_rel=0.05) markers, nmarkers = label(local_maxi, return_num=True) logging.debug("Identified {0} watershed markers".format(nmarkers)) labels = watershed(closed, markers, mask=filled) else: labels = label(filled) # Object size filtering w, h = img_gray.shape canvas_size = w * h min_size = int(round(canvas_size * opts.minsize / 100)) max_size = int(round(canvas_size * opts.maxsize / 100)) logging.debug( "Find objects with pixels between {0} ({1}%) and {2} ({3}%)".format( min_size, opts.minsize, max_size, opts.maxsize ) ) # Plotting ax1.set_title("Original picture") ax1.imshow(oimg) params = "{0}, $\sigma$={1}, $k$={2}".format(ff, sigma, kernel) if opts.watershed: params += ", watershed" ax2.set_title("Edge detection\n({0})".format(params)) closed = gray2rgb(closed) ax2_img = labels if opts.edges: ax2_img = closed elif opts.watershed: ax2.plot(coordinates[:, 1], coordinates[:, 0], "g.") ax2.imshow(ax2_img, cmap=iopts.cmap) ax3.set_title("Object detection") ax3.imshow(img) filename = op.basename(pngfile) if labelfile: accession = extract_label(labelfile) else: accession = pf # Calculate region properties rp = regionprops(labels) rp = [x for x in rp if min_size <= x.area <= max_size] nb_labels = len(rp) logging.debug("A total of {0} objects identified.".format(nb_labels)) objects = [] for i, props in enumerate(rp): i += 1 if i > opts.count: break y0, x0 = props.centroid orientation = props.orientation major, minor = props.major_axis_length, props.minor_axis_length major_dx = cos(orientation) * major / 2 major_dy = sin(orientation) * major / 2 minor_dx = sin(orientation) * minor / 2 minor_dy = cos(orientation) * minor / 2 ax2.plot((x0 - major_dx, x0 + major_dx), (y0 + major_dy, y0 - major_dy), "r-") ax2.plot((x0 - minor_dx, x0 + minor_dx), (y0 - minor_dy, y0 + minor_dy), "r-") npixels = int(props.area) # Sample the center of the blob for color d = min(int(round(minor / 2 * 0.35)) + 1, 50) square = img[(y0 - d) : (y0 + d), (x0 - d) : (x0 + d)] pixels = [] for row in square: pixels.extend(row) logging.debug( "Seed #{0}: {1} pixels ({2} sampled) - {3:.2f}%".format( i, npixels, len(pixels), 100.0 * npixels / canvas_size ) ) rgb = pixel_stats(pixels) objects.append(Seed(filename, accession, i, rgb, props, exif)) minr, minc, maxr, maxc = props.bbox rect = Rectangle((minc, minr), maxc - minc, maxr - minr, fill=False, ec="w", lw=1) ax3.add_patch(rect) mc, mr = (minc + maxc) / 2, (minr + maxr) / 2 ax3.text(mc, mr, "{0}".format(i), color="w", ha="center", va="center", size=6) for ax in (ax2, ax3): ax.set_xlim(0, h) ax.set_ylim(w, 0) # Output identified seed stats ax4.text(0.1, 0.92, "File: {0}".format(latex(filename)), color="g") ax4.text(0.1, 0.86, "Label: {0}".format(latex(accession)), color="m") yy = 0.8 fw = must_open(opts.outfile, "w") if not opts.noheader: print >> fw, Seed.header(calibrate=calib) for o in objects: if calib: o.calibrate(pixel_cm_ratio, tr) print >> fw, o i = o.seedno if i > 7: continue ax4.text(0.01, yy, str(i), va="center", bbox=dict(fc="none", ec="k")) ax4.text(0.1, yy, o.pixeltag, va="center") yy -= 0.04 ax4.add_patch(Rectangle((0.1, yy - 0.025), 0.12, 0.05, lw=0, fc=rgb_to_hex(o.rgb))) ax4.text(0.27, yy, o.hashtag, va="center") yy -= 0.06 ax4.text(0.1, yy, "(A total of {0} objects displayed)".format(nb_labels), color="darkslategrey") normalize_axes(ax4) for ax in (ax1, ax2, ax3): xticklabels = [int(x) for x in ax.get_xticks()] yticklabels = [int(x) for x in ax.get_yticks()] ax.set_xticklabels(xticklabels, family="Helvetica", size=8) ax.set_yticklabels(yticklabels, family="Helvetica", size=8) image_name = op.join(outdir, pf + "." + iopts.format) savefig(image_name, dpi=iopts.dpi, iopts=iopts) return objects
__author__ = 'mikhail' import numpy as np from skimage import filter arr = np.array([[4, 4, 4, 4, 4, 4, 4, 4], [3, 2, 1, 2, 1, 2, 1, 3], [3, 1, 2, 1, 2, 1, 2, 3], [3, 2, 1, 2, 1, 2, 1, 3], [3, 1, 2, 1, 2, 1, 2, 3], [3, 2, 1, 2, 1, 2, 1, 3], [3, 1, 2, 1, 2, 1, 2, 3], [4, 4, 4, 4, 4, 4, 4, 4]]) gaussian = filter.gaussian_filter(arr) roberts = filter.roberts(arr) print gaussian print roberts
def test_roberts_zeros(): """Roberts' filter on an array of all zeros.""" result = F.roberts(np.zeros((10, 10)), np.ones((10, 10), bool)) assert (np.all(result == 0))
def seeds(args): """ %prog seeds [pngfile|jpgfile] Extract seed metrics from [pngfile|jpgfile]. Use --rows and --cols to crop image. """ p = OptionParser(seeds.__doc__) p.set_outfile() opts, args, iopts = add_seeds_options(p, args) if len(args) != 1: sys.exit(not p.print_help()) pngfile, = args pf = opts.prefix or op.basename(pngfile).rsplit(".", 1)[0] sigma, kernel = opts.sigma, opts.kernel rows, cols = opts.rows, opts.cols labelrows, labelcols = opts.labelrows, opts.labelcols ff = opts.filter calib = opts.calibrate outdir = opts.outdir if outdir != '.': mkdir(outdir) if calib: calib = json.load(must_open(calib)) pixel_cm_ratio, tr = calib["PixelCMratio"], calib["RGBtransform"] tr = np.array(tr) resizefile, mainfile, labelfile, exif = \ convert_image(pngfile, pf, outdir=outdir, rotate=opts.rotate, rows=rows, cols=cols, labelrows=labelrows, labelcols=labelcols) oimg = load_image(resizefile) img = load_image(mainfile) fig, (ax1, ax2, ax3, ax4) = plt.subplots(ncols=4, nrows=1, figsize=(iopts.w, iopts.h)) # Edge detection img_gray = rgb2gray(img) logging.debug("Running {0} edge detection ...".format(ff)) if ff == "canny": edges = canny(img_gray, sigma=opts.sigma) elif ff == "roberts": edges = roberts(img_gray) elif ff == "sobel": edges = sobel(img_gray) edges = clear_border(edges, buffer_size=opts.border) selem = disk(kernel) closed = closing(edges, selem) if kernel else edges filled = binary_fill_holes(closed) # Watershed algorithm if opts.watershed: distance = distance_transform_edt(filled) local_maxi = peak_local_max(distance, threshold_rel=.05, indices=False) coordinates = peak_local_max(distance, threshold_rel=.05) markers, nmarkers = label(local_maxi, return_num=True) logging.debug("Identified {0} watershed markers".format(nmarkers)) labels = watershed(closed, markers, mask=filled) else: labels = label(filled) # Object size filtering w, h = img_gray.shape canvas_size = w * h min_size = int(round(canvas_size * opts.minsize / 100)) max_size = int(round(canvas_size * opts.maxsize / 100)) logging.debug("Find objects with pixels between {0} ({1}%) and {2} ({3}%)"\ .format(min_size, opts.minsize, max_size, opts.maxsize)) # Plotting ax1.set_title('Original picture') ax1.imshow(oimg) params = "{0}, $\sigma$={1}, $k$={2}".format(ff, sigma, kernel) if opts.watershed: params += ", watershed" ax2.set_title('Edge detection\n({0})'.format(params)) closed = gray2rgb(closed) ax2_img = labels if opts.edges: ax2_img = closed elif opts.watershed: ax2.plot(coordinates[:, 1], coordinates[:, 0], 'g.') ax2.imshow(ax2_img, cmap=iopts.cmap) ax3.set_title('Object detection') ax3.imshow(img) filename = op.basename(pngfile) if labelfile: accession = extract_label(labelfile) else: accession = pf # Calculate region properties rp = regionprops(labels) rp = [x for x in rp if min_size <= x.area <= max_size] nb_labels = len(rp) logging.debug("A total of {0} objects identified.".format(nb_labels)) objects = [] for i, props in enumerate(rp): i += 1 if i > opts.count: break y0, x0 = props.centroid orientation = props.orientation major, minor = props.major_axis_length, props.minor_axis_length major_dx = cos(orientation) * major / 2 major_dy = sin(orientation) * major / 2 minor_dx = sin(orientation) * minor / 2 minor_dy = cos(orientation) * minor / 2 ax2.plot((x0 - major_dx, x0 + major_dx), (y0 + major_dy, y0 - major_dy), 'r-') ax2.plot((x0 - minor_dx, x0 + minor_dx), (y0 - minor_dy, y0 + minor_dy), 'r-') npixels = int(props.area) # Sample the center of the blob for color d = min(int(round(minor / 2 * .35)) + 1, 50) square = img[(y0 - d):(y0 + d), (x0 - d):(x0 + d)] pixels = [] for row in square: pixels.extend(row) logging.debug("Seed #{0}: {1} pixels ({2} sampled) - {3:.2f}%".\ format(i, npixels, len(pixels), 100. * npixels / canvas_size)) rgb = pixel_stats(pixels) objects.append(Seed(filename, accession, i, rgb, props, exif)) minr, minc, maxr, maxc = props.bbox rect = Rectangle((minc, minr), maxc - minc, maxr - minr, fill=False, ec='w', lw=1) ax3.add_patch(rect) mc, mr = (minc + maxc) / 2, (minr + maxr) / 2 ax3.text(mc, mr, "{0}".format(i), color='w', ha="center", va="center", size=6) for ax in (ax2, ax3): ax.set_xlim(0, h) ax.set_ylim(w, 0) # Output identified seed stats ax4.text(.1, .92, "File: {0}".format(latex(filename)), color='g') ax4.text(.1, .86, "Label: {0}".format(latex(accession)), color='m') yy = .8 fw = must_open(opts.outfile, "w") if not opts.noheader: print >> fw, Seed.header(calibrate=calib) for o in objects: if calib: o.calibrate(pixel_cm_ratio, tr) print >> fw, o i = o.seedno if i > 7: continue ax4.text(.01, yy, str(i), va="center", bbox=dict(fc='none', ec='k')) ax4.text(.1, yy, o.pixeltag, va="center") yy -= .04 ax4.add_patch( Rectangle((.1, yy - .025), .12, .05, lw=0, fc=rgb_to_hex(o.rgb))) ax4.text(.27, yy, o.hashtag, va="center") yy -= .06 ax4.text(.1, yy, "(A total of {0} objects displayed)".format(nb_labels), color="darkslategrey") normalize_axes(ax4) for ax in (ax1, ax2, ax3): xticklabels = [int(x) for x in ax.get_xticks()] yticklabels = [int(x) for x in ax.get_yticks()] ax.set_xticklabels(xticklabels, family='Helvetica', size=8) ax.set_yticklabels(yticklabels, family='Helvetica', size=8) image_name = op.join(outdir, pf + "." + iopts.format) savefig(image_name, dpi=iopts.dpi, iopts=iopts) return objects
import matplotlib.pyplot as plt from skimage.filter import roberts, sobel img_col = imread("brain.png") edge_roberts = roberts(img) edge_sobel = sobel(img) #Normalize edge_roberts = (edge_roberts - edge_roberts.min()) / (edge_roberts.max() - edge_roberts.min()) edge_sobel = (edge_sobel - edge_sobel.min()) / (edge_sobel.max() - edge_sobel.min()) #Clean edge_roberts *= (edge_roberts > 0.1) edge_sobel *= (edge_sobel > 0.1) # Red brain_red = np.ones_like(img_col) brain_red[:, :, 1] = 1 - edge_sobel brain_red[:, :, 2] = 1 - edge_sobel plt.figure() imshow(brain_red) # Black brain_green = np.ones_like(img_col) brain_green[:, :, 0] = (1 - edge_sobel) brain_green[:, :, 1] = (1 - edge_sobel) brain_green[:, :, 2] = (1 - edge_sobel) plt.figure() imshow(brain_green)
def process_image(image): img = filter.roberts(image[:, :, 0] / 255.) return (255 - img * 255).astype(np.uint8)
def skinDetection(img, show_img=False): def visualize(img, show_img): if show_img: plt.imshow(img, cmap=plt.cm.gray) plt.colorbar() plt.show() gray_img = rgb2gray(img) filtered = yCbCr_to_bin(img, 161.9964, -11.1051, 22.9265, 25.9997, \ 4.3568, 3.9479, 2) filtered = morphology.binary_fill_holes(filtered) visualize(filtered, show_img) # Remove areas smaller than threshold # filtered = morphology.binary_opening(filtered, structure=np.ones( (15, 15) )) filtered = remove_small_objects(filtered, 170) visualize(filtered, show_img) # First erosion filtered = morphology.binary_erosion(filtered, np.ones( (6, 6) )) visualize(filtered, show_img) visualize(gray_img, show_img) # Run canny edge detection on gray image # edge_img = canny(gray_img) edge_img = roberts(gray_img) edge_idx = np.where(edge_img > 0.1) edge_img = np.zeros(edge_img.shape, dtype=bool) edge_img[edge_idx] = True visualize(edge_img, show_img) # Combine edge detection result and filtered image to create composite edge_img = np.invert(edge_img) composite = np.logical_and(edge_img, filtered) visualize(composite, show_img) composite = morphology.binary_erosion(composite) visualize(composite, show_img) # Fill small holes composite = morphology.binary_fill_holes(composite) visualize(composite, show_img) # composite = morphology.binary_opening(composite, structure=np.ones( (3, 3) )) # composite = remove_area(composite, 170) composite = remove_small_objects(composite, 170) visualize(composite, show_img) # Label all connected components segments, num_segments = label(composite, background=0, return_num=True) # Generate square windows to encapsulate regions img_windows = [] for i in range(num_segments): segment_idx = np.where(segments == i) box_info = gen_box(segment_idx) img_windows.append(box_info) corners = [] for box in img_windows: (x, y), width = box corner = [(x - width//2, y - width//2), (x + width//2, y + width//2)] corners.append(corner) # Extract interesting image segments from the image img_segments = extract_boxes_from_img(img, corners) # draw = ImageDraw.Draw(img) # for corner in corners: # draw.rectangle(corner) # img = np.asarray(img) visualize(img, show_img) return img_segments
category = 'boots' image = data.imread( '%s/%s/%s' % (store, category, file_name), as_grey=True).astype('int32') # img= scipy.misc.imread('%s/%s/%s' % (store, category,file_name)).astype('int32') print file_name resized_image = resize(image, (250, 250)) # In[8]: edge_roberts = roberts(resized_image) edge_roberts_re = roberts(resized_image) edge_sobel = sobel(image) fig, (ax0, ax1) = plt.subplots(ncols=2, figsize=(12, 7)) ax0.imshow(edge_roberts, cmap=plt.cm.gray) ax0.set_title('Roberts Edge Detection') ax0.axis('off') ax1.imshow(edge_sobel, cmap=plt.cm.gray) ax1.set_title('Sobel Edge Detection') ax1.axis('off')
import numpy as np from sklearn.ensemble import RandomForestClassifier from sklearn.cross_validation import train_test_split import os import matplotlib.pyplot as plt get_ipython().magic(u'matplotlib inline') path = '/Users/heymanhn/Virginia/Zipfian/Capstone_Project/Test_Output_Images/boots' file_name = 'barneys_158585078.jpg' image = io.imread('%s/%s' % (path, file_name)) plt.imshow(image) image_grey = color.rgb2gray(image) # In[58]: edge_roberts = roberts(image_grey) edge_canny = canny(image_grey) edge_sobel = sobel(image_grey) edge_scharr = scharr(image_grey) # In[59]: fig, ((ax0, ax1), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 7)) ax0.imshow(edge_roberts, cmap=plt.cm.gray) ax0.set_title('Roberts Edge Detection') ax0.axis('off') ax1.imshow(edge_canny, cmap=plt.cm.gray) ax1.set_title('Canny Edge Detection') ax1.axis('off')
============== Edge operators ============== Edge operators are used in image processing within edge detection algorithms. They are discrete differentiation operators, computing an approximation of the gradient of the image intensity function. """ import matplotlib.pyplot as plt from skimage.data import camera from skimage.filter import roberts, sobel image = camera() edge_roberts = roberts(image) edge_sobel = sobel(image) fig, (ax0, ax1) = plt.subplots(ncols=2) ax0.imshow(edge_roberts, cmap=plt.cm.gray) ax0.set_title('Roberts Edge Detection') ax0.axis('off') ax1.imshow(edge_sobel, cmap=plt.cm.gray) ax1.set_title('Sobel Edge Detection') ax1.axis('off') plt.show()
def preprocessing_center(img, det): return im_crop((img / MaximumPixelIntensity) , 6.0) im_list, det = load_img_det(1000) im = im_list[1] im_0_gen = generator_crop_flip_8fold(im_list[1], det, preprocessing_gauss_center_entr) im_1_gen = generator_crop_flip_8fold(im_list[1], det, preprocessing_gauss_center) sob = roberts(im) #edges = preprocessing_center(sob, det) #edges = filter.canny(im_list[0], sigma=3, low_threshold=0, high_threshold=1000) # Detect two radii hough_radii = np.arange(15, 30, 2) hough_res = hough_circle(sob, hough_radii) #centers = [] #accums = [] #radii = [] # #for radius, h in zip(hough_radii, hough_res): # # For each radius, extract two circles # peaks = peak_local_max(h, num_peaks=2) # centers.extend(peaks) # accums.extend(h[peaks[:, 0], peaks[:, 1]])