def worker(input_file_path, queue): int_values = [] path_sections = input_file_path.split("/") for string in path_sections: if re.search(r'\d+', string) is not None: int_values.append(int(re.search(r'\d+', string).group())) file_count = int_values[-1] image = cv2.imread(input_file_path, cv2.CV_LOAD_IMAGE_GRAYSCALE) edges = img_as_ubyte(canny(image, sigma=canny_sigma)) img_bw = cv2.threshold(edges, 250, 255, cv2.THRESH_BINARY)[1] point = _find_bottom_edge(img_bw) try: distance = len(img_bw) - point[1] except TypeError: try: edges = img_as_ubyte(canny(image, sigma=canny_sigma_closeup)) img_bw = cv2.threshold(edges, 250, 255, cv2.THRESH_BINARY)[1] distance = len(img_bw) - point[1] except TypeError: distance = 0 output = str(file_count) + ":" + str(distance) + "\n" queue.put(output) return output
def CannyFilter(time,sep,rawForce,Meta,tauMultiple=25,**kwargs): """ Uses a canny filter (from image processing) to detect change points Args: time,sep,force,Meta,tauMultiple: see ZScoreByDwell Returns: 0/1 matrix if we think there is or isnt an array """ force = FilterToTau(time,tauMultiple,rawForce) n = force.size minV = np.min(force) maxV = np.max(force) # normalize the force force -= minV force /= (maxV-minV) gradV = np.gradient(force) stdev = np.std(gradV) mu = np.mean(gradV) # convert the force to an image, to make Canny happy im = np.zeros((n,3)) im[:,1] = force # set the 'sigma' value to our filtering value sigma = tauMultiple edges1 = feature.canny(im,sigma=sigma,low_threshold=0.8, high_threshold=(1-10/n),use_quantiles=True) edges2 = feature.canny(im * -1,sigma=sigma,low_threshold=0.8, high_threshold=(1-10/n),use_quantiles=True) # get where the algorithm thinks a transtition is happenening idx = np.where((edges1 == True) | (edges2 == True))[0] idx = WalkEventIdx(rawForce,idx) # switch canny to be between -0.5 and 0.5 return idx - 0.5
def edge(ifile, ofile): img = io.imread(ifile, flatten=True) edges1 = feature.canny(img) edges2 = feature.canny(img, sigma=VALUE_SIGMA) out = np.uint8(edges2 * 255) io.imsave(ofile, out) # display results fig, (ax1, ax2, ax3) = plt.subplots(nrows=1, ncols=3, figsize=(8, 3), sharex=True, sharey=True) ax1.imshow(img, cmap=plt.cm.jet) ax1.axis('off') ax1.set_title('noisy image', fontsize=20) ax2.imshow(edges1, cmap=plt.cm.gray) ax2.axis('off') ax2.set_title('Canny filter, $\sigma=1$', fontsize=20) ax3.imshow(edges2, cmap=plt.cm.gray) ax3.axis('off') ax3.set_title('Canny filter, $\sigma=' + str(VALUE_SIGMA) + '$', fontsize=20) fig.subplots_adjust(wspace=0.02, hspace=0.02, top=0.9, bottom=0.02, left=0.02, right=0.98) plt.show()
def my_canny(img, fn = None, sigma=6, with_mask=False, save=False, show=False): height = img.shape[0] width = img.shape[1] if with_mask: import numpy as np mymask = np.zeros((height, width),'uint8') y1, x1 = 200, 150 y2, x2 = 500, 350 mymask[y1: y2, x1: x2] = 1 ret = canny(img, sigma=sigma, mask=mymask) else: ret = canny(img, sigma) if show: from src.utils.io import showimage_pil showimage_pil(255*ret.astype('uint8')) if save: from src.utils.io import saveimage_pil if with_mask: feature = '_sigma' + str(sigma) + '_mask' else: feature = '_sigma' + str(sigma) saveimage_pil(255*ret.astype('uint8'), fn+feature+'.jpg',show=False) return ret
def compare(file1, file2): image1 = io.imread(file1, as_grey = True) image2 = io.imread(file2, as_grey = True) image1 = feature.canny(image1) image2 = feature.canny(image2) return ssim(image1, image2)
def findSigma(image): sig = 3.5 total = len(image)*len(image[0]) flag = True cnt = 0 while(flag): cnt = cnt+1 edges = feature.canny(image, sigma=sig) edSum = np.sum(edges) tmp = total/edSum print sig ###if there are too many pixels, increase sig if tmp<200: sig = sig + .13 ###too few pixels, decr sig if tmp>401: sig = sig - .13 elif tmp>200 and tmp <401: return edges ##sometimes any sigma we put in will be incorct so we let feature decide after some trying elif cnt>10 and tmp == 0: edges = feature.canny(image) return edges
def edge(ifile, ofile): img = io.imread(ifile, flatten=True) edges1 = feature.canny(img) edges2 = feature.canny(img, sigma=VAL_SIGMA) out = np.uint8(edges2 * 255) io.imsave(ofile, out) return ofile
def main(): for file_path in glob.glob("/home/lucas/Downloads/Lucas/GSK 10uM/*.JPG"): img = data.imread(file_path, as_grey=True) img = transform.resize(img, [600, 600]) img_color = transform.resize(data.imread(file_path), [600, 600]) img[img >img.mean()-0.1] = 0 # io.imshow(img) # io.show() # edges = canny(img) bordas_fechadas = closing(img > 0.1, square(15)) # fechando gaps fill_cells = ndi.binary_fill_holes(bordas_fechadas) # io.imshow(fill_cells) # io.show() img_label = label(fill_cells, background=0) n= 0 for x in regionprops(img_label): if x.area < 2000 and x.area > 300: n +=1 print x.area minr, minc, maxr, maxc = x.bbox try: out_path_name = file_path.split("/")[-1].rstrip(".JPG") io.imsave("out/cell_{}_pic_{}_area_{}.png".format(n, out_path_name, str(round(x.area))),img_color[minr-3: maxr+3, minc-3: maxc+3]) #io.show() except: pass
def _calc_crispness(self, grey_array): """Calculate three measures of the crispness of an channel. PARAMETERS ---------- grey_array : 2D numpy array Raw data for the grey channel. PRODUCES -------- crispnesses : list Three measures of the crispness in the grey channel of types: - ``sobel``, ``canny``, and ``laplace`` """ grey_array = grey_array/255 sobel_var = filters.sobel(grey_array).var() canny_array = feature.canny(grey_array, sigma=1).var() canny_ratio = np.sum(canny_array == True)/float( len(canny_array.flatten())) laplace_var = filters.laplace(grey_array, ksize=3).var() self.feature_data.extend([sobel_var, canny_ratio, laplace_var]) if self.columns_out: self.column_names.extend(['crisp_sobel', 'crisp_canny', 'crisp_laplace'])
def analyze_ra_rotation(rotate_fn): """ Get RA axis center of rotation XY coordinates Args: rotate_fn (str): FITS file of RA rotation Returns: tuple(int): A tuple of integers corresponding to the XY pixel position of the center of rotation around RA axis """ d0 = fits.getdata(rotate_fn) # - 2048 # Get center position = (d0.shape[1] // 2, d0.shape[0] // 2) size = (1500, 1500) d1 = Cutout2D(d0, position, size) d1.data = d1.data / d1.data.max() # Get edges for rotation rotate_edges = canny(d1.data, sigma=1.0) rotate_hough_radii = np.arange(100, 500, 50) rotate_hough_res = hough_circle(rotate_edges, rotate_hough_radii) rotate_accums, rotate_cx, rotate_cy, rotate_radii = \ hough_circle_peaks(rotate_hough_res, rotate_hough_radii, total_num_peaks=1) return d1.to_original_position((rotate_cx[-1], rotate_cy[-1]))
def manipulate(): edges_sigma = 1.75 while len(framesToConvert) > 0: currentFrame = framesToConvert.pop(-1) if not os.path.isdir(currentFrame.basePath + "/raw/"): os.mkdir(currentFrame.basePath + "/raw/") os.mkdir(currentFrame.basePath + "/grayscale/") os.mkdir(currentFrame.basePath + "/cropped/") os.mkdir(currentFrame.basePath + "/resize150/") os.mkdir(currentFrame.basePath + "/edges_" + str(edges_sigma) + "/") cv2.imwrite(currentFrame.basePath + "/raw/FRAME_" + str(currentFrame.count) + ".jpg", currentFrame.image) grayscaleImage = cv2.cvtColor(currentFrame.image, cv2.COLOR_BGR2GRAY) cv2.imwrite(currentFrame.basePath + "/grayscale/FRAME_" + str(currentFrame.count) + ".jpg", grayscaleImage) croppedImage = grayscaleImage[0:RAW_IMAGE_HEIGHT, ((RAW_IMAGE_WIDTH - RAW_IMAGE_HEIGHT) / 2):RAW_IMAGE_WIDTH - ((RAW_IMAGE_WIDTH - RAW_IMAGE_HEIGHT) / 2)] cv2.imwrite(currentFrame.basePath + "/cropped/FRAME_" + str(currentFrame.count) + ".jpg", croppedImage) resizedImage = cv2.resize(croppedImage, (FINAL_IMAGE_SIZE, FINAL_IMAGE_SIZE), interpolation=cv2.INTER_AREA) cv2.imwrite(currentFrame.basePath + "/resize150/FRAME_" + str(currentFrame.count) + ".jpg", resizedImage) edges = img_as_ubyte(canny(resizedImage, sigma=1.75)) cv2.imwrite(currentFrame.basePath + "/edges_" + str(edges_sigma) + "/FRAME_" + str(currentFrame.count) + ".jpg", edges)
def edges(cls): from scipy import ndimage, misc import numpy as np from skimage import feature col = Image.open("f990.jpg") gray = col.convert('L') # Let numpy do the heavy lifting for converting pixels to pure black or white bw = np.asarray(gray).copy() # Pixel range is 0...255, 256/2 = 128 bw[bw < 245] = 0 # Black bw[bw >= 245] = 255 # White bw[bw == 0] = 254 bw[bw == 255] = 0 im = bw im = ndimage.gaussian_filter(im, 1) edges2 = feature.canny(im, sigma=2) labels, numobjects =ndimage.label(im) slices = ndimage.find_objects(labels) print('\n'.join(map(str, slices))) misc.imsave('f990_sob.jpg', im) return #im = misc.imread('f990.jpg') #im = ndimage.gaussian_filter(im, 8) sx = ndimage.sobel(im, axis=0, mode='constant') sy = ndimage.sobel(im, axis=1, mode='constant') sob = np.hypot(sx, sy) misc.imsave('f990_sob.jpg', edges2)
def animate(i): print 'Frame %d' % i plt.title('Frame %d' % i) image = data[i] hough_radii = np.arange(10, 100, 10) edges = feature.canny(data[i], sigma=3.0, low_threshold=0.4, high_threshold=0.8) hough_res = hough_circle(edges, hough_radii) centers = [] accums = [] radii = [] for radius, h in zip(hough_radii, hough_res): peaks = feature.peak_local_max(h) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius] * len(peaks)) image = ski.color.gray2rgb(data[i]) for idx in np.argsort(accums)[::-1][:5]: center_x, center_y = centers[idx] radius = radii[idx] cx, cy = circle_perimeter(center_y, center_x, radius) if max(cx) < 150 and max(cy) < 200: image[cy, cx] = (220, 20, 20) im.set_data(image) return im,
def test_circles2(): data = np.memmap("E:\\guts_tracking\\data\\fish202_aligned_masked_8bit_150x200x440.raw", dtype='uint8', shape=(440,200,150)).copy() i = 157 hough_radii = np.arange(10, 100, 10) edges = feature.canny(data[i], sigma=3.0, low_threshold=0.4, high_threshold=0.8) hough_res = hough_circle(edges, hough_radii) centers = [] accums = [] radii = [] for radius, h in zip(hough_radii, hough_res): peaks = feature.peak_local_max(h) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius] * len(peaks)) image = ski.color.gray2rgb(data[i]) for idx in np.argsort(accums)[::-1][:5]: center_x, center_y = centers[idx] radius = radii[idx] cx, cy = circle_perimeter(center_y, center_x, radius) if max(cx) < 150 and max(cy) < 200: image[cy, cx] = (220, 20, 20) plt.imshow(image, cmap='gray') plt.show()
def edge(pathfile,maskpath): image = imread(pathfile, as_grey=True) mask = imread(maskpath, as_grey=True) mask = mask.astype(bool) edges = feature.canny(image, sigma=2) num = np.sum(edges[mask]) return float(num),edges
def detect_Hough(data): image = data.copy() edges = canny(image, sigma=10, low_threshold=60, high_threshold=90) # Detect circles between 80% and 100% of image semi-diagonal lx, ly = data.shape sizex, sizey = lx/2., ly/2. max_r = numpy.sqrt(sizex**2 + sizey**2) hough_radii = numpy.linspace(0.5*max_r, 0.9 * max_r, 20) hough_res = hough_circle(edges, hough_radii) centers = [] accums = [] radii = [] for radius, h in zip(hough_radii, hough_res): # For each radius, extract two circles num_peaks = 2 peaks = peak_local_max(h, num_peaks=num_peaks) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius] * num_peaks) # Use the most prominent circle idx = numpy.argsort(accums)[::-1][:1] center_x, center_y = centers[idx] radius = radii[idx] return center_x, center_y, radius
def find_edges(img, sigma = 4): img = feature.canny(img, sigma) selem = disk(10) img = dilation(img, selem) return img
def blackout_outside(self, img, sigma=3): img_g = skic.rgb2gray(img) edges = skif.canny(img_g, sigma=sigma) hough_radii = np.arange(180, 210, 2) hough_res = skit.hough_circle(edges, hough_radii) centers = [] accums = [] radii = [] for radius, h in zip(hough_radii, hough_res): # For each radius, extract two circles num_peaks = 1 peaks = skif.peak_local_max(h, min_distance=40, num_peaks=num_peaks) if peaks != []: centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius] * num_peaks) # print radius, np.max(h.ravel()), len(peaks) if accums == [] and sigma==3: return self.blackout_outside(img, sigma=3) # Draw the most prominent 5 circles image = (img.copy() / 4.0).astype(np.uint8) cx, cy = skid.circle(*self.average_hough_detections(hough_radii, hough_res)) image[cy, cx] = img[cy, cx] return image
def hugh_circle_detection(image): # Load picture and detect edges edges = canny(image, sigma=3, low_threshold=10, high_threshold=50) fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(5, 2)) # Detect two radii hough_radii = np.arange(15, 30, 2) hough_res = hough_circle(edges, hough_radii) centers = [] accums = [] radii = [] for radius, h in zip(hough_radii, hough_res): # For each radius, extract two circles num_peaks = 2 peaks = peak_local_max(h, num_peaks=num_peaks) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius] * num_peaks) # Draw the most prominent 5 circles image = color.gray2rgb(image) for idx in np.argsort(accums)[::-1][:5]: center_x, center_y = centers[idx] radius = radii[idx] cx, cy = circle_perimeter(center_y, center_x, radius) image[cy, cx] = (220, 20, 20) ax.imshow(image, cmap=plt.cm.gray) plt.show()
def process(self, im): (width, height, _) = im.image.shape img_adapted = im.prep(self.transform) if width > self.max_resized or height > self.max_resized: scale_height = self.max_resized / height scale_width = self.max_resized / width scale = min(scale_height, scale_width) img_adapted = resize(img_adapted, (int(width * scale), int(height * scale))) edges = canny(img_adapted, sigma=self.sigma) # Detect two radii # Calculate image diameter shape = im.image.shape diam = math.sqrt(shape[0] ** 2 + shape[1] ** 2) radii = np.arange(diam / 3, diam * 0.8, 2) hough_res = hough_circle(edges, radii) accums = [] for radius, h in zip(radii, hough_res): # For each radius, extract two circles peaks = peak_local_max(h, num_peaks=1, min_distance=1) if len(peaks) > 0: accums.extend(h[peaks[:, 0], peaks[:, 1]]) if len(accums) == 0: # TODO: fix, should not happen return [0] idx = np.argmax(accums) return [accums[idx]]
def get_image_dynamics(image): edges = canny(image, 1, .4, .6) lines = probabilistic_hough_line(edges, line_gap=6) TAN15 = 0.26794919243 TAN75 = 3.73205080757 EPS = 0.0000000005 c1, c2, c3 = (0, 0, 0) dynamics = np.zeros(6, dtype=np.float64) for (x1, y1), (x2, y2) in lines: aslope = abs((x2 - x1) / (y2 - y1 + EPS)) linelen = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) if (aslope < TAN15): c1 = c1 + 1 dynamics[0] = dynamics[0] + aslope dynamics[3] = linelen elif (aslope > TAN75): c2 = c2 + 1 dynamics[1] = dynamics[1] + aslope dynamics[4] = linelen else: c3 = c3 + 1 dynamics[2] = dynamics[2] + aslope dynamics[5] = linelen if (c1 > 0): dynamics[0] /= c1 dynamics[1] /= c1 if (c2 > 0): dynamics[2] /= c2 dynamics[3] /= c2 if (c3 > 0): dynamics[4] /= c3 dynamics[5] /= c3 return dynamics;
def segment(self, image): """ """ # image = src[:] if self.use_adaptive_threshold: bs = self.blocksize if not bs % 2: bs += 1 markers = threshold_adaptive(image, bs) # n = markers[:].astype('uint8') n = markers.astype('uint8') # n[markers] = 255 # n[invert(markers)] = 1 # markers = n return n else: markers = zeros_like(image) # print('image',image.max(), image.min()) # print('le', image<self.threshold_low) # print('ge', image>self.threshold_high) markers[image <= self.threshold_low] = 1 markers[image > self.threshold_high] = 255 #elmap = sobel(image, mask=image) elmap = canny(image, sigma=1) wsrc = watershed(elmap, markers, mask=image) return invert(wsrc)
def test_tif_series_2otsu_Y23(self): frame_list = glob("./test_resources/Y23_0.4X_raw_tifs/*.tif") for idx in range(400,450): frame = frame_list[idx] self.image = np.array(Image.open(frame)) self.thresholds = otsu(self.image, nclasses=2) if idx==425: # Plot intensity histogram and thresholds plt.hist(self.image.flatten(), bins=256, log=True) for t in self.thresholds: plt.axvline(t, color='r') plt.title('Y23 using class=2') plt.draw() plt.savefig('Y23_2-class.png', dpi=300) plt.clf() Image.open('Y23_2-class.png').show() # Plot actual data and thresholded edge = feature.canny(self.image>self.thresholds[0]) highlight = np.copy(self.image) highlight[edge] = 2*self.image.max() - self.image.min() fig = plt.figure() ax11 = fig.add_subplot(221) ax12 = fig.add_subplot(222) ax21 = fig.add_subplot(223) ax22 = fig.add_subplot(224) ax11.imshow(self.image) ax12.imshow(self.image>self.thresholds[0]) ax21.imshow(highlight) ax22.imshow(edge) plt.show()
def getBoundary(img, debug=False, **kwds): from skimage import feature edge = feature.canny(img, **kwds) start_row = None middle_col = (edge.shape[1]-1)//2 start_cols = np.ones(edge.shape[0], dtype=int)*middle_col stop_cols = np.ones(edge.shape[0], dtype=int)*middle_col for i, row in enumerate(edge): isedge = row > 0 if isedge.any(): w = np.where(isedge)[0] start_cols[i], stop_cols[i] = w[0], w[-1] # set the row that starts to have object to be measured if start_row is None: start_row = i stop_row = i+1 continue if debug: print(start_row, stop_row) # for start, stop in zip(start_cols, stop_cols): # print(start, stop) # continue from matplotlib import pyplot as plt plt.figure() plt.plot(start_cols, '.') plt.plot(stop_cols, '.') plt.savefig("edge.png") plt.close() return start_row, stop_row, start_cols, stop_cols
def add_auto_masks_area(areaFile,addMasks=False): from skimage.morphology import binary_dilation, binary_erosion, disk from skimage import exposure from skimage.transform import hough_circle from skimage.morphology import convex_hull_image from skimage.feature import canny from skimage.draw import circle_perimeter import h5py MASKs = np.zeros(areaFile.attrs['ROI_patches'].shape) if 'ROI_masks' in (areaFile.attrs.iterkeys()): print 'Masks have already been created' awns = raw_input('Would you like to redo them from scratch: (answer y/n): ') else: awns = 'y' if awns=='y': MASKs = np.zeros(areaFile.attrs['ROI_patches'].shape) for i in range(areaFile.attrs['ROI_patches'].shape[2]): patch = areaFile.attrs['ROI_patches'][:,:,i] tt0 = exposure.equalize_hist(patch) tt = 255*tt0/np.max(tt0) thresh = 1*tt>0.3*255 thresh2 = 1*tt<0.1*255 tt[thresh] = 255 tt[thresh2] = 0 edges = canny(tt, sigma=2, low_threshold=20, high_threshold=30) try_radii = np.arange(3,5) res = hough_circle(edges, try_radii) ridx, r, c = np.unravel_index(np.argmax(res), res.shape) r, c, try_radii[ridx] image = np.zeros([20,20,4]) cx, cy = circle_perimeter(c, r, try_radii[ridx]+2) try: image[cy, cx] = (220, 80, 20, 1) original_image = np.copy(image[:,:,3]) chull = convex_hull_image(original_image) image[chull,:] = (255, 0, 0, .4) except: pass MASKs[:,:,i] = (1*image[:,:,-1]>0) if addMasks: areaFile.attrs['ROI_masks'] = MASKs else: pass return np.array(MASKs)
def _detect_spots_hough_circle(image, radius): edges = canny(image) imshow(edges) show() hough_radii = np.arange(radius/2, radius*2, 10) hough_circles = hough_circle(edges, hough_radii) print(hough_circles)
def __call__(self,sigma, keepSourceWindow=False): self.start(keepSourceWindow) nDim=len(self.tif.shape) newtif=np.copy(self.tif) if self.tif.dtype == np.float16: g.alert("Canny Edge Detection does not work on float32 images. Change the data type to use this function.") return None if nDim==2: newtif=feature.canny(self.tif,sigma) else: for i in np.arange(len(newtif)): newtif[i] = feature.canny(self.tif[i],sigma) self.newtif=newtif.astype(np.uint8) self.newname=self.oldname+' - Canny ' return self.end()
def getEdge(img, edgepath, **kwds): from skimage import feature edge = feature.canny(img, **kwds) edge = np.array(edge, dtype="float32") edgeimg = io.ImageFile(path=edgepath) edgeimg.data = edge edgeimg.save() return edge
def test(): image_series = glob.glob('full_dewar/puck*_*in*_200.jpg') templates = [n.replace('200', '*') for n in image_series] template_empty = imread('template_empty.jpg') h, w = template_empty.shape print 'len(templates)', len(templates) fig, axes = plt.subplots(3, 4) a = axes.ravel() k = 0 used = [] while k<12: #for template in templates[:12]: template = random.choice(templates) if template in used: pass else: used.append(template) original_image = img_as_float(combine(template, length=200)) ax = a[k] gray_image = color.rgb2gray(original_image) img_sharp = unsharp(gray_image) edges = canny(img_sharp, sigma=3.0, low_threshold=0.04, high_threshold=0.05) med_unsharp = median(img_sharp/img_sharp.max(), selem=disk(4)) sharp_med_unsharp = unsharp(med_unsharp) edges_med = canny(sharp_med_unsharp, sigma=7) match = match_template(gaussian(edges_med, 4), template_empty) print 'match.max()' print match.max() peaks = peak_local_max(gaussian(match, 3), threshold_abs=0.3, indices=True) print 'template', template print '# peaks', len(peaks) print peaks ax.imshow(original_image) #, cmap='gray') #ax.imshow(gaussian(edges_med, 3), cmap='gnuplot') for peak in peaks: y, x = peak rect = plt.Rectangle((x, y), w, h, edgecolor='g', linewidth=2, facecolor='none') ax.add_patch(rect) #ax[edges] = (0, 1, 0) #image = img_as_int(original_image) #image[edges==True] = (0, 255, 0) ax.set_title(template.replace('full_dewar/', '').replace('_*.jpg', '') + ' detected %s' % (16-len(peaks),)) k += 1 plt.show()
def extract_canny(image): edges = canny(image, sigma=4) fig, ax = plt.subplots(nrows=1, ncols=1) ax.imshow(edges, cmap=plt.cm.gray) ax.axis('off') ax.set_title('Canny filter, $\sigma=1$', fontsize=20) plt.show()
def canny_hsv(image): return canny(image)
def average_pixel_width(img): im = IMG.open(img) im_array = np.asarray(im.convert(mode='L')) edges_sigma1 = feature.canny(im_array, sigma=3) apw = (float(np.sum(edges_sigma1)) / (im.size[0]*im.size[1])) return apw*100
for root, dirs, files in os.walk(rootDir + "Albums"): for filename in files: if '.csv' not in filename and 'Uploaded' not in root and 'Blurred' not in root: imagePath = root + "\\" + filename #os.path.join(root, filename) images.append(imagePath) for image in images: #try: im = scipy.misc.imread(image) img_gray = rgb2gray(im) edge_roberts = roberts(img_gray) edge_sobel = sobel(img_gray) edge_canny1 = feature.canny(img_gray) edge_canny2 = feature.canny(img_gray, sigma=0.2) edge_canny3 = feature.canny(img_gray, sigma=0.25) edge_canny4 = feature.canny(img_gray, sigma=0.3) edge_prewitt = prewitt(img_gray) noise_gaussian = random_noise(im, "gaussian") noise_salt = random_noise(im, "salt") noise_pepper = random_noise(im, "pepper") noise_speckle = random_noise(im, "speckle") blur_avg = cv2.blur(im,(5,5)) blur_gaussian = cv2.GaussianBlur(im,(5,5),0) blur_median = cv2.medianBlur(im,5)
w = np.sum(np.sum(f, axis=-1), axis=-1) + 0.00001 filtered = np.expand_dims( np.sum(np.sum(patch_sdm * f, axis=3), axis=2) / w, -1) return filtered # load image as grey fname = './lena.tiff' #fname = './input.png' im = skimage.img_as_float(io.imread(fname)) im_grey = color.rgb2grey(im) # canny edge detection sigma = 1. edge_map = feature.canny(im_grey, sigma) # estimate defocus map std_1 = 1. std_2 = std_1 * 2.5 ratio = gaussian_gradient_magnitude( im_grey, std_1) / gaussian_gradient_magnitude(im_grey, std_2) # get edge index sdm = np.zeros_like(ratio) mx, my = np.where(edge_map * (ratio > 1.01) * (ratio <= std_2 / std_1)) # enhancement sdm[mx, my] = np.sqrt(((ratio[mx, my]**2 * std_1**2 - std_2**2) + 0.001) / (1 - ratio[mx, my]**2))
print img.shape img = img.astype('float32') print "check1" dx = ndimage.sobel(img, 0) # horizontal derivative print "check2" dy = ndimage.sobel(img, 1) # vertical derivative mag = np.hypot(dx, dy) # magnitude print mag mag *= 255.0 / np.max(mag) # normalize (Q&D) plt.imshow(img, cmap=plt.get_cmap('gray')) plt.show() scipy.misc.imsave('sobel.jpg', mag) im = io.imread('sobel.jpg') # Compute the Canny filter for two values of sigma edges = np.uint8(feature.canny(im, sigma=1) * 255) print edges.shape newArr = [] for y in range(edges.shape[1]): for x in range(edges.shape[0]): if (edges[x][y] == 255): tempVar = str(x) + "," + str(y) newArr.append(tempVar) plt.imshow(edges) plt.show() scipy.misc.imsave('canny.jpg', edges)
def load_edge(self, img, mask): sigma = self.sigma return canny(img, sigma=sigma).astype(np.float)
def edge_detection(frames, n_samples, method='canny', track=False): """ To detect the edges of the wells, fill and label them to determine their centroids. Parameters ----------- frames : Array The frames to be processed and determine the sample temperature from. n_samples : Int The number of samples in the input video. method : String Edge detection algorithm to be used track : Boolean to enable spatial tracking (to be implemented with real-time in the future) Returns -------- labeled_samples : Array All the samples in the frame are labeled so that they can be used as props to get pixel data. """ # when enable spatial tracking if track: # type cast to ndarray if not isinstance(frames, np.ndarray): frames_array = np.array(frames) else: frames_array = frames video_length = len(frames_array) video_with_label = np.empty(frames_array.shape, dtype=int) background = frames_array.mean(0) alpha = 2 # intensity threshold counter = 0 missing = 0 boolean_mask = None for time in range(video_length): # remove background proportional to time in video img_lin_bg = frames_array[time] - background * time / ( video_length - 1) # apply sobel filter edges_lin_bg = filters.sobel(img_lin_bg) # booleanize with certain threshold alpha edges_lin_bg = edges_lin_bg > edges_lin_bg.mean() * alpha # erode edges, fill in holes edges_lin_bg = ndimage.binary_erosion(edges_lin_bg, mask=boolean_mask) edges_lin_bg = binary_fill_holes(edges_lin_bg) # find progressive background if time is 0: progressive_background = 0 else: progressive_background = frames_array[0:time].mean(0) # remove background img_prog_bg = frames_array[time] - progressive_background # apply sobel filter edges_prog_bg = filters.sobel(img_prog_bg) # booleanize with certain threshold alpha edges_prog_bg = edges_prog_bg > edges_prog_bg.mean() * alpha # erode edges, fill in holes edges_prog_bg = ndimage.binary_erosion(edges_prog_bg, mask=boolean_mask) edges_prog_bg = binary_fill_holes(edges_prog_bg) # combining combined_samples = edges_lin_bg + edges_prog_bg # make the boolean mask for the for frame if time is 0: boolean_mask = ~ndimage.binary_erosion(combined_samples) # boolean_mask = ~combined_samples # labeled_samples = ndimage.binary_erosion(labeled_samples, mask=boolean_mask) # labeled_samples = binary_fill_holes(labeled_samples, structure=np.ones((2,2))) # remove stray pixels and label combined_samples = remove_small_objects(combined_samples, min_size=2) labeled_samples = label(combined_samples) # confirm matching labels vs n_samples unique, counts = np.unique(labeled_samples, return_counts=True) label_dict = dict(zip(unique, counts)) # in case of missing label if len(label_dict) < n_samples + 1: trial = 0 # keep eroding to separate the samples while len(label_dict) < n_samples + 1 and trial < 10: labeled_samples = ndimage.binary_erosion(labeled_samples, mask=boolean_mask) labeled_samples = label(labeled_samples) unique, counts = np.unique(labeled_samples, return_counts=True) label_dict = dict(zip(unique, counts)) trial += 1 # print('missing:', time) missing += 1 # in case of extra label identify if len(label_dict) > n_samples + 1: trial = 0 # keep removing smaller labels until matching with n_samples while len(label_dict) > n_samples + 1 and trial < 10: temp = min(label_dict.values()) labeled_samples = remove_small_objects(labeled_samples, min_size=temp + 1) unique, counts = np.unique(labeled_samples, return_counts=True) label_dict = dict(zip(unique, counts)) trial += 1 # print('excess:', time, val) counter += 1 video_with_label[time] = labeled_samples # print(counter) # print(missing) return video_with_label # when disable spatial tracking (default) else: labeled_samples = None size = None thres = None props = None # use canny edge detection method if method is 'canny': for size in range(15, 9, -1): for thres in range(1500, 900, -100): edges = feature.canny(frames[0] / thres) # fig = plt.figure(2) # for debugging # plt.imshow(edges) # plt.show() filled_samples = binary_fill_holes(edges) cl_samples = remove_small_objects(filled_samples, min_size=size) labeled_samples = label(cl_samples) props = regionprops(labeled_samples, intensity_image=frames[0]) # fig = plt.figure(3) # plt.imshow(filled_samples) # for debugging if len(props) == n_samples: break # if thres == 1000 and len(props) != n_samples: # print('Not all the samples are being recognized with # the set threshold range for size ',size) if len(props) == n_samples: break if size == 10 and thres == 1000 and len(props) != n_samples: print('Not all the samples are being recognized with the set \ minimum size and threshold range') # plt.show() # for debugging return labeled_samples # use sobel edge detection method if method is 'sobel': for size in range(15, 9, -1): # use sobel edges = filters.sobel(frames[0]) edges = edges > edges.mean() * 3 # booleanize data # fig = plt.figure(2) # for debugging # plt.imshow(edges) # plt.colorbar() # fill holes and remove noise filled_samples = binary_fill_holes(edges) cl_samples = remove_small_objects(filled_samples, min_size=size) labeled_samples = label(cl_samples) props = regionprops(labeled_samples, intensity_image=frames[0]) # fig = plt.figure(3) # plt.imshow(filled_samples) # for debugging if len(props) == n_samples: break if size == 10 and len(props) != n_samples: print('Not all the samples are being recognized with the set \ minimum size and threshold range') # plt.show() # for debugging return labeled_samples
import numpy as np import matplotlib.pyplot as plt from skimage import data, color from skimage.transform import hough_circle, hough_circle_peaks from skimage.feature import canny from skimage.draw import circle_perimeter from skimage.util import img_as_ubyte # Load picture and detect edges image = img_as_ubyte(data.coins()[160:230, 70:270]) edges = canny(image, sigma=3, low_threshold=10, high_threshold=50) # Detect two radii hough_radii = np.arange(20, 35, 2) hough_res = hough_circle(edges, hough_radii) # Select the most prominent 5 circles accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii, total_num_peaks=3) # Draw them fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(10, 4)) image = color.gray2rgb(image) for center_y, center_x, radius in zip(cy, cx, radii): circy, circx = circle_perimeter(center_y, center_x, radius) image[circy, circx] = (220, 20, 20) ax.imshow(image, cmap=plt.cm.gray) plt.show()
def keep_tile(tile, tile_size, tissue_threshold): """ Determine if a tile should be kept. This filters out tiles based on size and a tissue percentage threshold, using a custom algorithm. If a tile has height & width equal to (tile_size, tile_size), and contains greater than or equal to the given percentage, then it will be kept; otherwise it will be filtered out. Args: tile: tile is a 3D NumPy array of shape (tile_size, tile_size, channels). tile_size: The width and height of a square tile to be generated. tissue_threshold: Tissue percentage threshold. Returns: A Boolean indicating whether or not a tile should be kept for future usage. """ if tile.shape[0:2] == (tile_size, tile_size): tile_orig = tile # Check 1 # Convert 3D RGB image to 2D grayscale image, from # 0 (dense tissue) to 1 (plain background). tile = rgb2gray(tile) # 8-bit depth complement, from 1 (dense tissue) # to 0 (plain background). tile = 1 - tile # # Canny edge detection with hysteresis thresholding. # # This returns a binary map of edges, with 1 equal to # # an edge. The idea is that tissue would be full of # # edges, while background would not. tile = canny(tile) # Binary closing, which is a dilation followed by # an erosion. This removes small dark spots, which # helps remove noise in the background. tile = binary_closing(tile, disk(10)) # Binary dilation, which enlarges bright areas, # and shrinks dark areas. This helps fill in holes # within regions of tissue. tile = binary_dilation(tile, disk(10)) # Fill remaining holes within regions of tissue. tile = binary_fill_holes(tile) # Calculate percentage of tissue coverage. percentage = tile.mean() check1 = percentage >= tissue_threshold # Check 2 # Convert to optical density values tile = optical_density(tile_orig) # Threshold at beta beta = 0.15 tile = np.min(tile, axis=2) >= beta # Apply morphology for same reasons as above. tile = binary_closing(tile, disk(2)) tile = binary_dilation(tile, disk(2)) percentage = tile.mean() check2 = percentage >= tissue_threshold #set the tile back to the original tile tile = tile_orig return check1 and check2 else: return False
def Fix_Cam_Height_Analysis(self): ''' step 1 : Line detection using canny edge detection ''' if self.isPlaying == False: self.current_Frame = int(self.cap.get(cv2.CAP_PROP_POS_FRAMES)) self.Current_Frame.set(self.current_Frame) success, Height_Analysis_Img = self.cap.read() ''' step 1 : Line detection using canny edge detection Uses canny edge detection and then finds (small) lines using probabilstic hough transform as edgelets. Parameters ---------- image: ndarray Image for which edgelets are to be computed. sigma: float Smoothing to be used for canny edge detection. Returns ------- locations: ndarray of shape (n_edgelets, 2) Locations of each of the edgelets. directions: ndarray of shape (n_edgelets, 2) Direction of the edge (tangent) at each of the edgelet. strengths: ndarray of shape (n_edgelets,) Length of the line segments detected for the edgelet. ''' #============================================================================== # #compute median of singel channel pixel intensities # median_intensity = np.median(Height_Analysis_Img) # # #apply cutomatic thresholding # sigma = 0.33 # lower = int (max(0, (1.0 - sigma) * median_intensity)) # upper = int (min(255, (1.0 + sigma) * median_intensity)) # # Height_Analysis_Img_Gray = cv2.cvtColor(Height_Analysis_Img, cv2.COLOR_BGR2GRAY) # # Height_Analysis_Img_blurred = cv2.GaussianBlur(Height_Analysis_Img_Gray, (3, 3),0) # # Canny_edge = cv2.Canny(Height_Analysis_Img_blurred, lower, upper) #============================================================================== Height_Analysis_Img_Gray = color.rgb2gray(Height_Analysis_Img) sigma = 3 Canny_edge = feature.canny(Height_Analysis_Img_Gray, sigma) lines = transform.probabilistic_hough_line(Canny_edge, line_length=3, line_gap=2) locations = [] directions = [] strengths = [] for p0, p1 in lines: p0, p1 = np.array(p0), np.array(p1) locations.append((p0 + p1) / 2) directions.append(p1 - p0) strengths.append(np.linalg.norm(p1 - p0)) #convert to numpy arrays and normalize locations = np.array(locations) directions = np.array(directions) strengths = np.array(strengths) directions = np.array(directions) / \ np.linalg.norm(directions, axis=1)[:, np.newaxis] """ Step 2 : Compute lines in homogenous system for edglets. Parameters ---------- edgelets: tuple of ndarrays (locations, directions, strengths) as computed by `compute_edgelets`. Returns ------- lines: ndarray of shape (n_edgelets, 3) Lines at each of edgelet locations in homogenous system. """ cv2.imshow("canny edge", Canny_edge) cv2.waitKey(5000) cv2.destroyWindow()
def compute(addr): loc = getgeocodfromadd(addr) image = getpic(loc) #image = io.imread('staticmap3.png') plt.imshow(image) img2 = image.copy() mask = image[:, :, 0] > 80 img2[mask] = [0, 0, 0] mask = image[:, :, 2] > 80 img2[mask] = [0, 0, 0] #plt.imshow(img2) img3 = rgb2gray(img2) plt.imshow(img3, 'gray') plt.hist(img3.ravel(), bins=256, histtype='step', color='black') elevation = sobel(img3) plt.imshow(elevation) img3_denoised = filters.median(img3, selem=np.ones((7, 7))) f, (ax0, ax1) = plt.subplots(1, 2, figsize=(15, 5)) ax0.imshow(img3) ax1.imshow(img3_denoised) masks = np.zeros_like(img3_denoised) masks[img3_denoised > 0.2] = 1 plt.imshow(masks) edges = feature.canny(img3_denoised, sigma=3) dt = distance_transform_edt(~edges) plt.imshow(dt) local_max = feature.peak_local_max(dt, indices=False, min_distance=5) plt.imshow(local_max, cmap='gray') peak_idx = feature.peak_local_max(dt, indices=False, min_distance=5) peak_idx[:5] plt.plot(peak_idx[:, 1], peak_idx[:, 0], 'r.') plt.imshow(dt) markers = measure.label(local_max) labels = morphology.watershed(-dt, markers) plt.imshow(segmentation.mark_boundaries(image, labels)) plt.imshow(color.label2rgb(labels, image)) plt.imshow(color.label2rgb(labels, image, kind='avg')) regions = measure.regionprops(labels, intensity_image=img3) region_means = [r.mean_intensity for r in regions] plt.hist(region_means, bins=20) model = KMeans(n_clusters=2) region_means = np.array(region_means).reshape(-1, 1) model.fit(region_means) print(model.cluster_centers_) bg_fg_labels = model.predict(region_means) #bg_fg_labels classified_labels = labels.copy() for bg_fg, region in zip(bg_fg_labels, regions): classified_labels[tuple(region.coords.T)] = bg_fg plt.imshow(color.label2rgb(classified_labels, image)) fr_cvg = for_cvr(masks) print(fr_cvg)
def edge_based_segmentation(image): im = cv2.cvtColor(image[0], cv2.COLOR_BGR2GRAY) edges = canny(im / 255.) fill = ndi.binary_fill_holes(edges) plt.imshow(fill.astype('float'))
for im_idx in np.r_[0:num_imgs]: print("Starting img %u/%u" % (im_idx, num_imgs)) filename = img_paths[im_idx][-12:] img = pyvips.Image.new_from_file(img_paths[im_idx], access="sequential") this_img = np.ndarray( buffer=img.write_to_memory(), dtype=format_to_dtype[img.format], shape=[img.height, img.width, img.bands], ) # this_img = img_imports[im_idx] im_greyscale = ski.color.rgb2gray(this_img) # Detect the edges of the lunar disk edges = feature.canny(im_greyscale, sigma=sm_sigma) edge_pts = np.nonzero(edges) my = int(np.mean(edge_pts[0])) + np.r_[-winsize, winsize] mx = int(np.mean(edge_pts[1])) + np.r_[-winsize, winsize] print("Edges detected") # Find the centre by minimizing the variance of the radius function x0 = np.mean(edge_pts, axis=1) opt_res = scp.optimize.minimize( lambda x: cost_fn(x, edge_pts), x0, method="nelder-mead", options={ "xtol": 1e-8, "disp": opt_verbose }, )
import skimage from skimage import feature # Read in CT scan from # https://www.yxlon.com/Yxlon/media/Content/Applications/Aerospace/Turbine%20blades/CT-feanbeame_Aerospace_Turbine_blade_001_144.jpg?ext=.jpg filename = 'istockphoto-683494078-612x612.jpg' img = skimage.io.imread(filename) # Convert to greyscale img_grey = skimage.color.rgb2grey(img) # Compute contours contours = skimage.measure.find_contours(img_grey, 0.8) # Compute Canny filter edges1 = feature.canny(img_grey, sigma=1) edges2 = feature.canny(img_grey, sigma=3) # Compute Edge Operators edge_roberts = skimage.filters.roberts(img_grey) edge_sobel = skimage.filters.sobel(img_grey) # Show original fig, ax = plt.subplots(nrows=3, ncols=2) ax[0, 0].imshow(img) ax[0, 0].set_title('Original') # Show contour ax[0, 1].imshow(img) ax[0, 1].set_title('With Contours') for n, contour in enumerate(contours):
import matplotlib.pyplot as plt import numpy as np from skimage.feature import canny from scipy import misc from scipy.ndimage import label from scipy.ndimage import center_of_mass from scipy.spatial import distance from skimage.feature import corner_fast, corner_peaks, corner_orientations img1 = misc.imread("155c012t4.tif", mode='L') labels1, num_features1 = label(img1) location1 = (center_of_mass(img1, labels1, 1)) print("Object {} center of mass at {}".format(1, location1)) center_1_x, center_1_y = location1[1], location1[0] edges = canny(img1, sigma=8.8) corner_response = corner_fast(edges, threshold=0.5) corner_pos = corner_peaks(corner_response) fig, axes = plt.subplots(ncols=2, figsize=(8, 4.5)) ax = axes.ravel() ax[0] = plt.subplot(1, 2, 1) ax[1] = plt.subplot(1, 2, 2) ax[0].imshow(img1) ax[0].plot(center_1_x, center_1_y, 'r^', markersize=20) radius_array = np.zeros(len(corner_pos)) for k in range(0, len(corner_pos)): y, x = corner_pos[k]
import numpy as np import matplotlib.pyplot as plt from scipy import ndimage as ndi from skimage import feature # Generate noisy image of a square im = np.zeros((128, 128)) im[32:-32, 32:-32] = 1 im = ndi.rotate(im, 15, mode='constant') im = ndi.gaussian_filter(im, 4) im += 0.2 * np.random.random(im.shape) # Compute the Canny filter for two values of sigma edges1 = feature.canny(im) edges2 = feature.canny(im, sigma=3) # display results fig, (ax1, ax2, ax3) = plt.subplots(nrows=1, ncols=3, figsize=(8, 3), sharex=True, sharey=True) ax1.imshow(im, cmap=plt.cm.jet) ax1.axis('off') ax1.set_title('noisy image', fontsize=20) ax2.imshow(edges1, cmap=plt.cm.gray) ax2.axis('off')
# Hough transform from skimage import data, feature from skimage.transform import hough_circle from skimage.draw import circle_perimeter image = data.coins()[0:95, 180:370] edges = feature.canny(image, sigma=3, low_threshold=10, high_threshold=60) hough_radii = np.arange(15, 30, 2) hough_response = hough_circle(edges, hough_radii) centers = [] likelihood = [] radii = [] # Your code here for idx, resp in enumerate(hough_response): # Find the local peaks: peaks = feature.peak_local_max(resp) centers.extend(peaks) # The likelihood for each of these peaks is given by the Hough response: likelihood.extend(resp[peaks[:, 0], peaks[:, 1]]) # Radius is given by the array index, but we need to save the radius for # every peak we added to the list above. So we create an array of equal # length (`peaks.shape[0]`) radii.extend(np.ones(peaks.shape[0]) * hough_radii[idx]) # Make a copy of the image so we can draw on it without messing up the original im = image.copy()
from skimage.transform import hough_circle, hough_circle_peaks from skimage.feature import canny from skimage.draw import circle_perimeter from skimage.util import img_as_ubyte # Load picture and detect edges image = imageio.imread("results_L3.jpg") #convert to grayscale image = color.rgb2gray(image) #sx = ndimage.sobel(image, axis=0, mode='constant') #sy = ndimage.sobel(image, axis=1, mode='constant') #edges = np.hypot(sx, sy) edges = canny(image, sigma=1.7) # this work better plt.imshow(edges) # Detect two radii hough_radii = np.arange(70, 120, 2) hough_res = hough_circle(edges, hough_radii) # Select the most prominent 10 circles accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii, total_num_peaks=10) # Draw them fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(25, 20)) image = color.gray2rgb(image) for center_y, center_x, radius in zip(cy, cx, radii):
def determine_skew(self, img_file): img = io.imread(img_file, as_grey=True) edges = canny(img, sigma=self.sigma) h, a, d = hough_line(edges) _, ap, _ = hough_line_peaks(h, a, d, num_peaks=self.num_peaks) if len(ap) == 0: return {"Image File": img_file, "Message": "Bad Quality"} absolute_deviations = [self.calculate_deviation(k) for k in ap] average_deviation = np.mean(np.rad2deg(absolute_deviations)) ap_deg = [np.rad2deg(x) for x in ap] bin_0_45 = [] bin_45_90 = [] bin_0_45n = [] bin_45_90n = [] for ang in ap_deg: deviation_sum = int(90 - ang + average_deviation) if self.compare_sum(deviation_sum): bin_45_90.append(ang) continue deviation_sum = int(ang + average_deviation) if self.compare_sum(deviation_sum): bin_0_45.append(ang) continue deviation_sum = int(-ang + average_deviation) if self.compare_sum(deviation_sum): bin_0_45n.append(ang) continue deviation_sum = int(90 + ang + average_deviation) if self.compare_sum(deviation_sum): bin_45_90n.append(ang) angles = [bin_0_45, bin_45_90, bin_0_45n, bin_45_90n] lmax = 0 for j in range(len(angles)): l = len(angles[j]) if l > lmax: lmax = l maxi = j if lmax: ans_arr = self.get_max_freq_elem(angles[maxi]) ans_res = np.mean(ans_arr) else: ans_arr = self.get_max_freq_elem(ap_deg) ans_res = np.mean(ans_arr) data = { "Image File": img_file, "Average Deviation from pi/4": average_deviation, "Estimated Angle": ans_res, "Angle bins": angles } if self.display_output: self.display(data) if self.plot_hough: self.display_hough(h, a, d) return data
def _process_image(image_in: Image) -> Image: grayscale_data = np.array(image_in.convert('L')) edges = feature.canny(grayscale_data, sigma=3) image_out = Image.fromarray(edges) image_out.format = image_in.format return image_out
def DetectImplant(array, pixel, area): image=array.copy() original=image.copy() """Takes a Grey-Scale image (e.g dicom pixel array) and calculates the percentage of pixels that are above an intensity threshold within the most circular object in the image. Returns True if more than x percentage of the image is greater than y percentage of maximum intensity""" #percentile for pixels to be in to be considered "implant bright" pixel_threshold=pixel #percentage of the image that needs to be "implant bright" to trigger implant detection area_threshold=area global detected_implant_count, dicom_implant_count rows, cols = image.shape #Cuts image in half (taking left or right depending on image try: if re.match(r"L.*MLO",ds.SeriesDescription) or re.match(r"L.*CC", ds.SeriesDescription): image=image[:,:int(cols/2)] elif re.match(r"R.*MLO",ds.SeriesDescription) or re.match(r"R.*CC", ds.SeriesDescription): image=image[:,int(cols/2):] elif "L" in ds.PatientOrientation[1]: image=image[:,:int(cols/2)] elif "R" in ds.PatientOrientation[1]: image=image[:,int(cols/2):] except: pass cropped=image.copy() #resets dimensions for the new, cropped, image rows, cols = image.shape #Calculates true area of the image, based on pixels that are not zero AOI=np.count_nonzero(image) #resets image if AOI is too low (e.g DiCom tag mis entered for Left/Right if AOI<75000: image=original.copy() cropped=original.copy() rows, cols = image.shape AOI=np.count_nonzero(image) #calculates minimum pixel intensity required for a pixel to be "implant bright" pixels_intensity=round(image.max()*pixel_threshold) try: #'pre-mask' to filter out tisue/breast outline etc... (as breast outline is #also circular it causes inconsitency in the RANSAC mask = image<round(image.max()*0.80) image[mask]=0 #creates a circular mask around the most circular object, helps to limit intensity search to implant only #and also for magviews the circle is the middle of the magview, so all the white metal #around the circle gets blacked out (jsut doing intensity some magviews were implant positive) edges = feature.canny(image, sigma=10, low_threshold=10, high_threshold=500) points = np.array(np.nonzero(edges)).T model_robust, inliers = ransac(points, CircleModel, min_samples=5, residual_threshold=1, max_trials=100) cy, cx, r = model_robust.params y,x=np.ogrid[-cy:rows-cy, -cx:cols-cx] mask = x*x + y*y <= r*r #as mask is the circle, ~mask inverts it #Sometimes mask is 1-2 pixels larger than image (not sure why) #[:rows, :cols] only applies mask where there is image image[~mask[:rows,:cols]]=0 except Exception as e: pass #zeros out all pixels below the threshold mask = image < pixels_intensity image[mask]=0 #gets area of pixels that are above threshold IMP_area=np.count_nonzero(image) try: percent=IMP_area/AOI except Exception as e: print(e) pdb.set_trace() if show==True: f, (ax0, ax1, ax2, ax3) = plt.subplots(1, 4, figsize=(15, 8)) ax0.imshow(original, cmap=plt.cm.bone) ax0.set_title("ORIGINAL") ax1.imshow(cropped>(round(image.max()*0.90)), cmap=plt.cm.bone) ax1.set_title("FIRST THRESH") ax2.imshow(cropped, cmap=plt.cm.bone) circle = plt.Circle((cx, cy), radius=r, facecolor='r', linewidth=2) ax2.add_patch(circle) ax2.set_title("CIRCLE MASK") ax3.imshow(image, cmap=plt.cm.bone) ax3.set_title("PIXELS COUTNING FOR 'IMPLANT'") plt.show() if percent>area_threshold: return True
sample_saving_path, file_name + image_name + channel_color + file_suffix) mm = np.load(file_reading) mmm = np.copy(mm) total_pixel_y, total_pixel_x = mmm.shape ### reading mmm_array --- ### ### filtering_noise_particle --- #from skimage import filters #mmm = filters.median(mmm) #mmm = (mmm - mmm.min()) / (mmm.max() - mmm.min()) ### filtering_noise_particle +++ ### from skimage import feature #bool_mmm = feature.canny(mmm, sigma = 2.5, low_threshold = 0.1, high_threshold = 0.94, use_quantiles = True) bool_mmm = feature.canny(mmm) ### boundary_masking +++ bool_mmm[:, :2] = False bool_mmm[:, -2:] = False bool_mmm[:2, :] = False bool_mmm[-2:, :] = False ### boundary_masking --- ### new_mmm = np.array(bool_mmm, dtype=np.int64) file_suffix = '.png' saving_data_file = file_name + section_name_in mpl.image.imsave( os.path.join(sample_saving_path, saving_data_file + file_suffix), new_mmm) ### file_suffix = '.npy'
def main(): imgLoc = sys.argv[1] imgDir, exactImageLoc = os.path.split(imgLoc) img = io.imread(imgLoc) imgray = color.rgb2gray(img) edge = canny(imgray) #show_img(rescale(edge,0.5)) print edge.shape #show_img(edge) print "edge found" s = [[1, 1, 1], [1, 1, 1], [1, 1, 1]] labeled_array, num_features = label(edge, structure=s) print "labeling done" temp = [] print "started with", num_features, "connected components" for i in range(1, num_features + 1): label_i_indices = [(labeled_array == i).nonzero()] if getBoundingBoxfromPixels(label_i_indices, (img.shape[1], img.shape[0])): temp.append( getBoundingBoxfromPixels(label_i_indices, (img.shape[1], img.shape[0]))) print "started with", len(temp), "bounding boxes" imgarea = (img.shape[0] * img.shape[1]) print imgarea interimBoundingboxes = [] for item in temp: if not (item[2] - item[0]) * (item[3] - item[1]) > 0.01 * imgarea: if (item[2] - item[0]) > 5 or (item[3] - item[1]) > 5: interimBoundingboxes.append(item) interimBoundingboxesDict = {} for item in interimBoundingboxes: interimBoundingboxesDict[','.join([str(i) for i in item])] = True for item1 in interimBoundingboxes: toberemoved = [] for item2 in interimBoundingboxes: if (item1 != item2): result = boundingBoxiConsumedbyj(item1, item2) if result: toberemoved.append(item1) for item in toberemoved: interimBoundingboxesDict[','.join([str(i) for i in item])] = False finalBoundingboxes = [] for key in interimBoundingboxesDict.keys(): if interimBoundingboxesDict[key]: item = [int(x) for x in key.split(',')] finalBoundingboxes.append(item) #starting to merge finalBoundingboxesFiltered = finalBoundingboxes print "starting to merge" edges = sp.zeros(edge.shape) labeldict = {} colornumber = [0] for i in range(0, len(finalBoundingboxesFiltered)): item1 = finalBoundingboxesFiltered[i] stritem1 = ','.join([str(x) for x in item1]) currentcolors = [labeldict[item] for item in labeldict.keys()] if currentcolors: for color1 in currentcolors: colornumber.append(color1) currentcolornumber = max(colornumber) + 1 if not stritem1 in labeldict: labeldict[stritem1] = currentcolornumber else: currentcolornumber = labeldict[stritem1] edges[item1[0]:item1[2], item1[1]:item1[3]] = currentcolornumber for j in range(i + 1, len(finalBoundingboxesFiltered)): item2 = finalBoundingboxesFiltered[j] stritem2 = ','.join([str(x) for x in item2]) if rectmanDist(item1, item2) < 1: #if rectmanDistHorizontal(item1,item2)<10: #print item1,"merged with",item2,"with",currentcolornumber if stritem2 in labeldict: currentcolornumber = labeldict[stritem2] edges[item1[0]:item1[2], item1[1]:item1[3]] = currentcolornumber labeldict[stritem1] = currentcolornumber else: labeldict[stritem2] = currentcolornumber edges[item2[0]:item2[2], item2[1]:item2[3]] = currentcolornumber labeled_array = edges.copy() num_features = max(colornumber) + 1 temp = [] for i in range(1, num_features + 1): label_i_indices = [(labeled_array == i).nonzero()] #print i,len(label_i_indices[0][0]) if len(label_i_indices[0][0]) > 0: temp.append( getBoundingBoxfromPixelsLarge(label_i_indices, (img.shape[1], img.shape[0]))) print "after merging boundingboxes", len(temp) interimBoundingboxes = list(temp) interimBoundingboxesDict = {} for item in interimBoundingboxes: interimBoundingboxesDict[','.join([str(i) for i in item])] = True for item1 in temp: toberemoved = [] for item2 in temp: if (item1 != item2): result = boundingBoxiConsumedbyj(item1, item2) if result: toberemoved.append(item1) for item in toberemoved: interimBoundingboxesDict[','.join([str(i) for i in item])] = False finalBoundingboxes = [] for key in interimBoundingboxesDict.keys(): if interimBoundingboxesDict[key]: item = [int(x) for x in key.split(',')] finalBoundingboxes.append(item) #finalBoundingboxes=interimBoundingboxes pilImg = Image.fromarray(img) draw = ImageDraw.Draw(pilImg) font = ImageFont.truetype("Berylium.ttf", 16) for item in finalBoundingboxes: draw.rectangle([item[1] - 2, item[0] - 2, item[3] + 2, item[2] + 2], outline="red") cutimg = Image.fromarray(img[item[0] - 2:item[2] + 2, item[1] - 2:item[3] + 2]) #cutimg=pilImg.crop((item[1],item[0],item[3],item[2])) #cutimg.show() text = pytesseract.image_to_string(cutimg) print item, text #draw.text((item[1], item[0]),text,(0,0,255),font=font) #print item,((item[2]-item[0])*(item[3]-item[1]))/imgarea pilImg.show() #pilImg.save(os.path.join(imgDir,"textextraction/ccsaurabhonepercentmerged",exactImageLoc[:-4]+"-ccsaurabh.png")) '''
def detectionAlgorithm(BL_Image, FU_Image): """ this function detects the changes in the base line and follow up images :param BL_Image: base line image :param FU_Image: follow up image :return: """ fu_im = io.imread(FU_Image, as_gray=True)[:BOTTOM_CAPTION, :] registered_bl = firstRegistrationAlgorithm(FU_Image, BL_Image) # used for case3 # registered_bl = secondRegistrationAlgorithm(FU_filename, BL_filename) # used for case4 # Normalize both images by columns: normalized_bl = registered_bl / np.amax(registered_bl) normalized_fu = fu_im / np.amax(fu_im) # Subtract FU from BL after registration: new_im = normalized_bl - normalized_fu above_zero = new_im > 0 new_im[above_zero] = 0 new_im = np.abs(new_im) fig = plt.figure() fig.add_subplot(221) plt.imshow(new_im, cmap='gray') plt.title("After stages 1-3") # remove some of the noise: th = 0.2 above_th = new_im > th underneath_th = new_im <= th new_im[above_th] = 1 new_im[underneath_th] = 0 fig.add_subplot(222) plt.imshow(new_im, cmap='gray') plt.title("After stage 4") # clean noise touching the boundary: new_im = segmentation.clear_border(new_im) # remove small object: new_im = findingBiggestComponent(new_im) fig.add_subplot(223) plt.imshow(new_im, cmap='gray') plt.title("After stage 5-6") # Remove Blood Vessels: fu_seg = SegmentBloodVessel(fu_im) bl_seg = SegmentBloodVessel(registered_bl) new_im = np.bitwise_or(fu_seg, bl_seg).astype(int) - new_im new_im[new_im < 1] = 0 fig.add_subplot(224) plt.imshow(new_im, cmap='gray') plt.title("After stage 7") plt.show() # Morphologically close: new_im = morphology.dilation(new_im) # Draw the borders/polygons: new_im = canny(new_im) new_im = morphology.dilation(new_im) fu_im[np.nonzero(new_im)] = 0 registered_bl[np.nonzero(new_im)] = 0 fig = plt.figure() fig.add_subplot(121) plt.imshow(fu_im, cmap='gray') plt.title("final output Follow-Up scan") fig.add_subplot(122) plt.imshow(registered_bl, cmap='gray') plt.title("final output Base-Line scan") plt.show()
def getCoordMask(mask): edge = feature.canny(np.copy(mask), sigma=6) pixelpoints = np.transpose(np.nonzero(np.copy(edge))) X = pixelpoints[:, 0] Y = pixelpoints[:, 1] return pixelpoints
block_size = 15 #image = threshold_local(image_unthresholded, block_size, offset=10) #image_647 = threshold_local(image_647_unthresholded, block_size, offset=10) radius = 5 selem = disk(radius) #thresholding both files (getting rid of this because it should not be necessary!) #image = rank.otsu(image_unthresholded, selem) #image_647 = rank.otsu(image_647_unthresholded, selem) image = image_unthresholded image_647 = image_647_unthresholded #perfoming edge detection and morphological filling edges_open = canny(image, 3, 1, 25) #originally 2,1,25 #edges_open = canny(image, 2) #originally 2,1,25 selem = disk(5) edges = closing(edges_open, selem) fill_tubes = ndi.binary_fill_holes(edges) io.imsave(cy3_file + "fill_tubes.png", img_as_uint(fill_tubes), cmap=cm.gray) cy3_endpoint_mask = make_endpoints_mask(fill_tubes) edges_open_647 = canny(image_647, 2, 1, 25) selem = disk(2) edges_647 = closing(edges_open_647, selem) fill_tubes_647 = ndi.binary_fill_holes(edges_647) io.imsave(atto647_file + "fill_tubes.png", img_as_uint(fill_tubes_647),
curr_filtered_coord, curr_filtered_coord_x, curr_filtered_coord_y, curr_filtered_2d,curr_filtered_1d= curr_thresh_filter(X,Y,Z,curr_thresh_factor) #plot filtered current # fig = plt.figure() # plt.contourf(X, Y, curr_filtered_2d, 30, cmap=cm.coolwarm) # plt.show() #apply filter to smoothen the image. makes edge detection better curr_filtered_2d=ndimage.median_filter(curr_filtered_2d, size=10) # plot smoothened data # fig = plt.figure() # plt.contourf(X, Y, curr_filtered_2d, 30, cmap=cm.coolwarm) # plt.show() Current_edge= feature.canny(1000.0*curr_filtered_2d) Curr_edge_shape= Current_edge.shape #plot image edges # fig = plt.figure() # plt.contourf(X, Y, Current_edge, 30, cmap=cm.coolwarm) # ax = fig.add_subplot(111, projection='3d') # ax.plot_surface(VplgR, VplgL, Current_edge, cmap=cm.coolwarm) # plt.show() # put the points on edges into curr_filtered_coord_x and _y curr_filtered_coord_x=[] curr_filtered_coord_y=[] for r in range(0,Curr_edge_shape[0]): for s in range(0, Curr_edge_shape[1]): if Current_edge[r][s]==True: curr_filtered_coord_x+=[X[r][s]]
ax1.set_ylabel('Distance (pixels)') ax1.axis('image') ax2.imshow(image, cmap=cm.gray) row1, col1 = image.shape for _, angle, dist in zip(*hough_line_peaks(h, theta, d)): y0 = (dist - 0 * np.cos(angle)) / np.sin(angle) y1 = (dist - col1 * np.cos(angle)) / np.sin(angle) ax2.plot((0, col1), (y0, y1), '-r') ax2.axis((0, col1, row1, 0)) ax2.set_title('Detected lines') ax2.set_axis_off() # Line finding using the Probabilistic Hough Transform. image = data.camera() edges = canny(image, 2, 1, 25) lines = probabilistic_hough_line(edges, threshold=10, line_length=5, line_gap=3) # Generating figure 2. fig, (ax0, ax1, ax2) = plt.subplots(1, 3, figsize=(16, 6), sharex=True, sharey=True) plt.tight_layout() ax0.imshow(image, cmap=cm.gray) ax0.set_title('Input image')
def extract_roi_mask(image: np.ndarray, min_hull_ratio: float = 0.3) -> Tuple[np.ndarray, float]: """ Extract region of interest (ROI) for the given image. Parameters ---------- image : np.ndarray Input document image covering the entire ROI. min_hull_ratio : float, optional Minimum ratio All/ROI for counting as "success", by default 0.3. Returns ------- mask_fullsize : np.ndarray Binary image respresenting the ROI. White pixels (1) = ROI. mask_ratio : float Pixel ratio (widht * height) / ROI. Raises ------ Exception If the minimum desired ratio could not be achieved, an error is raised. """ # Scale image to fixed size size = 1000 width, height, _ = image.shape image_resized = cv2.resize(image, (size, size)) # Search for edges with canny filter on each channel of HSV image image_hsv = cv2.cvtColor(image_resized, cv2.COLOR_RGB2HSV) image_canny = np.empty_like(image_hsv) for channel in range(3): # Apply adaptive histogram equalization channel_eq = equalize_adapthist(image_hsv[:, :, channel], kernel_size=200) # Apply canny filter channel_canny = canny(channel_eq, sigma=3) image_canny[:, :, channel] = channel_canny # Perform segmentation using the Felzenszwalb-Huttenlocher algorithm # and sort segments by size in descending order image_segmented = felzenszwalb(image_canny, scale=1000, sigma=0.3, min_size=50) segment_sizes = np.bincount(image_segmented.flatten()) segments = np.argsort(-segment_sizes) # Iterate over segments, starting from largest for s in segments: # Get segment and fill all holes segment = image_segmented == s hull = ndimage.binary_fill_holes(segment) # Exit if hull_ratio is sufficient hull_ratio = np.sum(hull) / (size**2) if hull_ratio >= min_hull_ratio: break # Raise error if hull_ratio criterion could not be met if hull_ratio < min_hull_ratio: raise Exception('ROI could not be computed') ### Postprocessing # Removes areas that are only connected by few pixels to the hull hull_opened = cv2.morphologyEx(hull.astype(np.uint8), cv2.MORPH_OPEN, kernel=disk(20)) # Take center blob blobs_segmented = measure.label(hull_opened) center_blob_label = blobs_segmented[size // 2, size // 2] mask = blobs_segmented == center_blob_label # Resize mask back to original image size mask_fullsize = cv2.resize(mask.astype(np.uint8), (height, width)) mask_ratio = np.sum(mask) / (size**2) return mask_fullsize, mask_ratio
def canny(self, image): return feature.canny(image, sigma=self.sigma_spinbox.value())