def test_percentile_median(): # check that percentile p0 = 0.5 is identical to local median img = data.camera() img16 = img.astype(np.uint16) selem = disk(15) # check for 8bit img_p0 = rank.percentile(img, selem=selem, p0=.5) img_max = rank.median(img, selem=selem) assert_array_equal(img_p0, img_max) # check for 16bit img_p0 = rank.percentile(img16, selem=selem, p0=.5) img_max = rank.median(img16, selem=selem) assert_array_equal(img_p0, img_max)
def Image_ws_tranche(image): laser = Detect_laser(image) laser_tranche = tranche_image(laser,60) image_g = skimage.color.rgb2gray(image) image_g = image_g * laser_tranche image_med = rank2.median((image_g*255).astype('uint8'),disk(8)) image_clahe = exposure.equalize_adapthist(image_med, clip_limit=0.03) image_clahe_stretch = exposure.rescale_intensity(image_clahe, out_range=(0, 256)) image_grad = rank2.gradient(image_clahe_stretch,disk(3)) image_grad_mark = image_grad<20 image_grad_forws = rank2.gradient(image_clahe_stretch,disk(1)) image_grad_mark_closed = closing(image_grad_mark,disk(1)) Labelised = (skimage.measure.label(image_grad_mark_closed,8,0))+1 Watersheded = watershed(image_grad_forws,Labelised) cooc = coocurence_liste(Watersheded,laser,3) x,y = compte_occurences(cooc) return x,y
def _find_bad_pixel_candidates_generic(raw, isCandidateFn): color_masks = _colormasks(raw) rawimg = raw.raw_image_visible coords = [] # median filtering for each channel r = 5 kernel = np.ones((r,r)) for mask in color_masks: t1 = time.time() # skimage's median is quite slow, it uses an O(r) filtering algorithm. # There exist O(log(r)) and O(1) algorithms, see https://nomis80.org/ctmf.pdf. # Also, we only need the median values for the masked pixels. # Currently, they are calculated for all pixels for each color. med = median(rawimg, kernel, mask=mask) print('median:', time.time()-t1, 's') # detect possible bad pixels candidates = isCandidateFn(rawimg, med) candidates &= mask y,x = np.nonzero(candidates) # note: the following is much faster than np.transpose((y,x)) candidates = np.empty((len(y),2), dtype=y.dtype) candidates[:,0] = y candidates[:,1] = x coords.append(candidates) return coords
def _repair_bad_pixels_generic(raw, coords, method='median'): color_masks = _colormasks(raw) rawimg = raw.raw_image_visible r = 5 kernel = np.ones((r,r)) for color_mask in color_masks: mask = np.zeros_like(color_mask) mask[coords[:,0],coords[:,1]] = True mask &= color_mask # interpolate all bad pixels belonging to this color if method == 'mean': # With mean filtering we have to ignore the bad pixels as they # would influence the mean too much. # FIXME could lead to invalid values if bad pixels are clustered # such that no valid pixels are left in a block raise NotImplementedError elif method == 'median': # bad pixels won't influence the median in most cases and just using # the color mask prevents bad pixel clusters from producing # bad interpolated values (NaNs) smooth = median(rawimg, kernel, mask=color_mask) else: raise ValueError rawimg[mask] = smooth[mask]
def substract_background(data, radius, background='mean', show=0): dmin, dmax = data.min(), data.max() tmp = ((data - dmin) / (dmax - dmin) * 255).astype(np.uint8) lforeground = rank.minimum(tmp, disk(radius // 2)) if background == 'mean': lbackground = rank.mean(lforeground, disk(radius * 4)).astype(int) elif background == 'median': lbackground = rank.median(lforeground, disk(radius * 4)).astype(int) elif background == 'maximum': lbackground = rank.maximum(lforeground, disk(radius * 4)).astype(int) else: lbackground = rank.modal(lforeground, disk(radius * 4)).astype(int) rdata = (lforeground - lbackground) if show > 2: fig, axes = plt.subplots(ncols=3, nrows=1, figsize=(30, 10)) for ax, im, title in zip(axes, [lforeground, lbackground, rdata], ['Foreground', 'Background', 'Substraction']): ax.imshow(im, 'optiona') ax.set_xticks([]) ax.set_yticks([]) ax.set_title(title) plt.show() return rdata
def split_object(self, labeled_image): """ split object when it's necessary """ labeled_image = labeled_image.astype(np.uint16) labeled_mask = np.zeros_like(labeled_image, dtype=np.uint16) labeled_mask[labeled_image != 0] = 1 #ift structuring element about center point. This only affects eccentric structuring elements (i.e. selem with even num=============================== labeled_image = skr.median(labeled_image, skm.disk(4)) labeled_mask = np.zeros_like(labeled_image, dtype=np.uint16) labeled_mask[labeled_image != 0] = 1 distance = scipym.distance_transform_edt(labeled_image).astype(np.uint16) #======================================================================= # binary = np.zeros(np.shape(labeled_image)) # binary[labeled_image > 0] = 1 #======================================================================= distance = skr.mean(distance, skm.disk(15)) l_max = skr.maximum(distance, skm.disk(5)) #l_max = skf.peak_local_max(distance, indices=False,labels=labeled_image, footprint=np.ones((3,3))) l_max = l_max - distance <= 0 l_max = skr.maximum(l_max.astype(np.uint8), skm.disk(6)) marker = ndimage.label(l_max)[0] split_image = skm.watershed(-distance, marker) split_image[split_image[0,0] == split_image] = 0 return split_image
def _repair_bad_pixels_generic(raw, coords, method='median'): color_masks = _colormasks(raw) rawimg = raw.raw_image_visible r = 5 kernel = np.ones((r, r)) for color_mask in color_masks: mask = np.zeros_like(color_mask) mask[coords[:, 0], coords[:, 1]] = True mask &= color_mask # interpolate all bad pixels belonging to this color if method == 'mean': # With mean filtering we have to ignore the bad pixels as they # would influence the mean too much. # FIXME could lead to invalid values if bad pixels are clustered # such that no valid pixels are left in a block raise NotImplementedError elif method == 'median': # bad pixels won't influence the median in most cases and just using # the color mask prevents bad pixel clusters from producing # bad interpolated values (NaNs) smooth = median(rawimg, kernel, mask=color_mask) else: raise ValueError rawimg[mask] = smooth[mask]
def _find_bad_pixel_candidates_generic(raw, isCandidateFn): color_masks = _colormasks(raw) rawimg = raw.raw_image_visible coords = [] # median filtering for each channel r = 5 kernel = np.ones((r, r)) for mask in color_masks: t1 = time.time() # skimage's median is quite slow, it uses an O(r) filtering algorithm. # There exist O(log(r)) and O(1) algorithms, see https://nomis80.org/ctmf.pdf. # Also, we only need the median values for the masked pixels. # Currently, they are calculated for all pixels for each color. med = median(rawimg, kernel, mask=mask) print('median:', time.time() - t1, 's') # detect possible bad pixels candidates = isCandidateFn(rawimg, med) candidates &= mask y, x = np.nonzero(candidates) # note: the following is much faster than np.transpose((y,x)) candidates = np.empty((len(y), 2), dtype=y.dtype) candidates[:, 0] = y candidates[:, 1] = x coords.append(candidates) return coords
def median_filter(image, selem=None): if selem is None: # default mask is 5x5 square selem = square(5) depth = image.shape[2] return np.dstack(median(channel[...,0], selem) for channel in np.dsplit(image, depth)) / 255.
def segm(img): den = rank.median(img, morph.disk(3)) # continuous regions (low gradient) markers = rank.gradient(den, morph.disk(5)) < 10 mrk, tot = ndimage.label(markers) grad = rank.gradient(den, morph.disk(2)) labels = morph.watershed(grad, mrk) return seg_regions(img, labels, tot)
def outlineSmoothing(image, radius=1): """Smooth outlines of foreground object using morphological operations.""" struct = median(disk(radius), disk(1)) label_image = binary_closing(image, struct) label_image = binary_opening(label_image, struct) return label_image.astype(image.dtype)
def processing_ndarray(data, median_disks, closing_disks, histogram_clip=[0.0, 99.], func=np.sqrt): """ :param data: 3d ndarray of the form (ny,nx,nt) :param median_disks: disks used to do median noise cleaning :param closing_disks: disks used to morphological closing :param histogram_clip: clip the data :param func: function used to scale the data nicely :return: an AWARE processed """ nt = data.shape[2] rdpi = datacube_tools.running_difference(datacube_tools.persistence(data)) mc_data = func(rdpi) mc_data[mc_data < 0] = 0.0 clip_limit = np.nanpercentile(mc_data, histogram_clip) # Rescale the data using the input function, and subtract the lower # clip limit so it begins at zero. f_data = mc_data - clip_limit[0] / (clip_limit[1]-clip_limit[0]) # Replace the nans with zeros - the reason for doing this rather than # something more sophisticated is that nans will not contribute # greatly to the final answer. The nans are put back in at the end # and get carried through in the maps. nans_here = np.logical_not(np.isfinite(f_data)) nans_replaced = deepcopy(f_data) nans_replaced[nans_here] = 0.0 # Final datacube processed_datacube = np.zeros_like(data) for t in range(0, nt): this = f_data[:, :, t] for d in range(0, len(median_disks)): # Get rid of noise by applying the median filter. Although the # input is a byte array make sure that the output is a floating # point array for use with the morphological closing operation. new_d = 1.0*median(this, median_disks[d]) # Apply the morphological closing operation to rejoin separated # parts of the wave front. new_d = closing(new_d, closing_disks[d]) # Sum all the final results processed_datacube[:, :, t] += new_d*1.0 return processed_datacube, nans_here
def segmente(self): #lecture de l'image vers un ndarray. toutes les images fournies ont une taille de 12051000 pixels. self.im = imread(self.name) if self.equalizeHist == 1: self.im = equalize_hist(self.im) #Filtrage median pour enlever le bruit et eviter le repliement spectral en cas d'echantillonnage. Point positif : c'est un filtre qui conserve les bords !!! #plus le rayon du disque est important plus le lissage est fort et plus il y a risque de perte d'information, le filtre supprimant les details. self.im = rank.median(self.im,disk(8)) #on reduit l'image pour diminuer le temps de computation. On ne s'interesse qu'a certaines parties de l'image plus echantillonnage. C'est l'image grayscale. On diminue par deux le nombre de pixels contenu dans l'image. self.im_red = self.im[::2,::2] # slic attend une image rgb il faut donc faire la conversion self.img_temp= gray2rgb(self.im_red) # cette fonction attend egalement des valeurs d'intensite en float self.img = img_as_float(self.img_temp) #segmentation en superpixel, fonction slic de skimage.segmentation, le parametre sigma prend la std dev d'un filtre gaussien applique a l'image avant de la segmenter self.segments_slic = slic(self.img,n_segments = self.segments,compactness = self.compacite, sigma =1) #on doit avoir tous les indices sup a 0 pour region props donc on les augmente tous de 1 self.segments_slic = self.segments_slic + np.ones(self.segments_slic.shape,dtype = np.int64) # liste de proprietes par superpixel self.props = regionprops(self.segments_slic, intensity_image = self.im_red) # on cree la matrice d'adjacence self.create_neighbour_matrix() #liste qui permettra de stocker les labels des superpixel qui ont ete colore self.colored_pixel_label = list() # appliquons maintenant un deuxieme clustering sur ces superpixels base sur leurs proprietes #self.clustering() # Liaison de click avec la fonction onclick et des evenements clavier self.fig = plt.figure('segmentation') self.cid1 = self.fig.canvas.mpl_connect('button_press_event', self.onclick) #Affichage self.affichage(mark_boundaries(self.img,self.segments_slic))
def __call__(self, image, range_, shrink_per_label=False): radius = np.abs(range_[0]) struct = median(disk(radius), disk(1)) if shrink_per_label: out = np.zeros(image.shape, dtype=np.int16) for label in np.unique(image)[1:]: bin_ = (image == label).astype(np.uint8) # ev. as bool bin_ = binary_erosion(bin_, struct) out += (bin_*label).astype(out.dtype) else: out = binary_erosion(image.astype(np.uint8), struct) return out*image.astype(np.int16)
def gen_mask(slide_ind=None, in_dir=None, stack=None, use_hsv=True, out_dir=None, num_section_per_slide=5, mirror=None, rotate=None): imgcolor = Image.open(os.path.join(in_dir, '%s_%02d_x0.3125_z0.tif'%(stack, slide_ind))) imgcolor = imgcolor.convert('RGB') imgcolor = np.array(imgcolor) img_gray = rgb2gray(imgcolor) # slide_height, slide_width = img_gray.shape[:2] if use_hsv: imghsv = rgb2hsv(imgcolor) img = imghsv[...,1] else: img = img_gray # utilize bounding box selected during scanning process a = img_gray < 0.98 a = median(a.astype(np.float), disk(3)) a = remove_small_objects(a.astype(np.bool), min_size=50, connectivity=2, in_place=False) column_labels, n_columns = label(a, neighbors=8, return_num=True, background=0) column_props = regionprops(column_labels+1) column_bboxes = np.array([p.bbox for p in column_props]) indices = np.argsort(column_bboxes[:,1]) mask = np.zeros_like(img_gray, dtype=np.bool) col_margin = 2 row_margin = 2 for i, b in enumerate(column_bboxes[indices, :]): minr, minc, maxr, maxc = b mask[minr+row_margin:maxr-row_margin, minc+col_margin:maxc-col_margin] = 1 section_masks, bboxes, exists = foreground_mask_morphsnakes_slide(img, levelset=mask, num_section_per_slide=num_section_per_slide, min_iters=400) ids = np.where(exists)[0] # section_images = [] for _, ((minr, minc, maxr, maxc), mask, section_id) in enumerate(zip(bboxes, section_masks, ids)): img = imgcolor[minr:maxr+1, minc:maxc+1].copy() img[~mask] = 0 # section_images.append(img) image_filepath = os.path.join(out_dir, '%s_x0.3125_%02d_%d.tif'%(stack, slide_ind, section_id)) imsave(image_filepath, img) # bboxes_percent = np.array(bboxes, dtype=np.float)/np.r_[img_gray.shape[:2], img_gray.shape[:2]][np.newaxis, :] return bboxes
def ZOI_selection(self, eclick, erelease): x1, y1 = eclick.xdata, eclick.ydata x2, y2 = erelease.xdata, erelease.ydata xmin=round(min(x1,x2)) xmax=round(max(x1,x2)) ymin=round(min(y1,y2)) ymax=round(max(y1,y2)) # update dimension of the image: self.height = (ymax-ymin) self.width = (xmax-xmin) self.yoffset = ymin self.xoffset = xmin #print "1" ###################################################################### camera INIT with ZOI selection if self.videoextenso['enabled']: # the following is to initialise the spot detection image=self.cam.getImage() #plt.imsave("/home/corentin/Bureau/image_originale.tiff",image) croped_image = image[self.yoffset:self.height+self.yoffset,self.xoffset:self.xoffset+self.width] image = croped_image #plt.imsave("/home/corentin/Bureau/image.tiff",image) image=rank.median(image,square(15)) # median filter to smooth the image and avoid little reflection that may appear as spots. self.thresh = threshold_otsu(image) # calculate most effective threshold bw= image>self.thresh #print "1" #applying threshold if not (self.videoextenso['white_spot']): bw=(1-bw).astype(np.uint8) #still smoothing bw = dilation(bw,square(3)) bw = erosion(bw,square(3)) #plt.imsave("/home/corentin/Bureau/bw.tiff",bw) # Remove artifacts connected to image border cleared = bw.copy() clear_border(cleared) # Label image regions label_image = label(cleared) borders = np.logical_xor(bw, cleared) label_image[borders] = -1 #plt.imsave("/home/corentin/Bureau/label_image.tiff",label_image) # Create the empty vectors for corners of each ZOI regions=regionprops(label_image) print [region.area for region in regions] #mean_area=np.mean[region.area for region in regions] regions=[region for region in regions if region.area>200]
def label_from_thresh(frame, thresh, parameters): smooth = parameters['smooth'] min_distance = np.int(parameters['nuc_distance']) image = rank.median(frame, disk(smooth)) image = rank.enhance_contrast(image, disk(smooth)) im_max = image.max() if im_max < thresh: return np.zeros(image.shape, dtype=np.int32) else: image = image > thresh distance = ndimage.distance_transform_edt(image) local_maxi = peak_local_max(distance, footprint=disk(min_distance), #min_distance=min_distance, indices=False, labels=image) markers = ndimage.label(local_maxi)[0] return watershed(-distance, markers, mask=image)
def __call__(self, image, range_, *args, **kw): """Binary dilation without merging of foreground objects.""" radius = np.abs(range_[1]) # just in case vigra is 10x faster, plays a role for large radii # img_exp = vigra.filters.discDilation(image.astype("uint8"), radius) if radius > 0: struct = median(disk(radius), disk(1)) img_exp = ndi.morphology.binary_dilation(image, structure=struct) elif radius == 0: img_exp = image.copy().astype(bool) else: img_exp = ndi.morphology.binary_dilation(image, iterations=0) edt = ndi.morphology.distance_transform_edt( np.invert(image.astype(bool))) return watershed(edt, image, mask=img_exp)
def test_line_profile_dynamic(): """Test a line profile updating after an image transform""" image = data.coins()[:-50, :] # shave some off to make the line lower image = skimage.img_as_float(image) viewer = ImageViewer(image) lp = LineProfile(limits='dtype') viewer += lp line = lp.get_profiles()[-1][0] assert line.size == 129 assert_almost_equal(np.std(viewer.image), 0.208, 3) assert_almost_equal(np.std(line), 0.229, 3) assert_almost_equal(np.max(line) - np.min(line), 0.725, 1) viewer.image = skimage.img_as_float(median(image, selem=disk(radius=3))) line = lp.get_profiles()[-1][0] assert_almost_equal(np.std(viewer.image), 0.198, 3) assert_almost_equal(np.std(line), 0.220, 3) assert_almost_equal(np.max(line) - np.min(line), 0.639, 1)
def segment(img, outimg): img = np.array(Image.open(img)) den = rank.median(img, morph.disk(3)) # continuous regions (low gradient) markers = rank.gradient(den, morph.disk(5)) < 10 mrk, tot = ndimage.label(markers) grad = rank.gradient(den, morph.disk(2)) labels = morph.watershed(grad, mrk) print 'Total regions:', tot regs = big_regions(labels, tot) spr = 3 spc = 6 plot_seg(spr, spc, 1, img, cm.gray, 1, 'image') plot_seg(spr, spc, 2, den, cm.gray, 1, 'denoised') plot_seg(spr, spc, 3, grad, cm.spectral, 1, 'gradient') plot_seg(spr, spc, 4, mrk, cm.spectral, 1, 'markers') plot_seg(spr, spc, 5, labels, cm.spectral, 1, 'regions\n%i' % tot) plot_seg(spr, spc, 6, img, cm.gray, 1, 'composite') plot_seg(spr, spc, 6, labels, cm.spectral, 0.7, 'composite') plot_mask(spr, spc, 7, 0, labels, regs, cm.spectral, 'main region') plot_mask(spr, spc, 8, 1, labels, regs, cm.spectral, '2nd region') plot_mask(spr, spc, 9, 2, labels, regs, cm.spectral, '3rd region') plot_mask(spr, spc, 10, 3, labels, regs, cm.spectral, '4th region') plot_mask(spr, spc, 11, 4, labels, regs, cm.spectral, '5th region') plot_mask(spr, spc, 12, 5, labels, regs, cm.spectral, '6th region') plot_crop(spr, spc, 13, 0, img, labels, regs, cm.gray) plot_crop(spr, spc, 14, 1, img, labels, regs, cm.gray) plot_crop(spr, spc, 15, 2, img, labels, regs, cm.gray) plot_crop(spr, spc, 16, 3, img, labels, regs, cm.gray) plot_crop(spr, spc, 17, 4, img, labels, regs, cm.gray) plot_crop(spr, spc, 18, 5, img, labels, regs, cm.gray) #plt.savefig('test.eps', dpi=300) plt.savefig(outimg, dpi=300)
def gredientSeg(preprocessedImage1, raw_image, minAreaSize, maxAreaSize, thre): """ :param preprocessedImage: a greyscale image :param raw_image: a raw image for highlighting segmented cells :param minAreaSize: the minimum area size of the cell :param maxAreaSize: maximum area size of the cell :return: """ preprocessedImage, denoised, gradientIm, thresh, imgDisplay, contours = [], [], [], [], [], [] imgDisplay = raw_image preprocessedImage = preprocessedImage1.astype(np.uint8) if len(preprocessedImage.shape) > 2: preprocessedImage = cv2.cvtColor(preprocessedImage, cv2.COLOR_BGR2GRAY) preprocessedImage = img_as_ubyte(preprocessedImage) # denoise image denoised = rank.median(preprocessedImage, disk(2)) # local ingredient gradientIm = rank.gradient(denoised, disk(thre)) thresh = cv2.threshold(gradientIm, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1] # fused the the mask and the original image for extracting morph features thresh = cv2.bitwise_and(thresh, preprocessedImage) # find contours in the the mask _, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) color = np.random.randint(0, 255, (len(contours), 3)) mask_colored = np.zeros_like(raw_image, ) pts, rectang, cellFeatures = [], [], [] for (ii, cnt) in enumerate(contours): ((x, y), radius) = cv2.minEnclosingCircle(cnt) tmp_perim = cv2.arcLength(cnt, True) tmp_approx = cv2.approxPolyDP(cnt, 0.04 * tmp_perim, True) (x, y, tmp_w, tmp_h) = cv2.boundingRect(tmp_approx) ar = tmp_w / float(tmp_h) # if ar >= 0.95 and ar <= 1.05: # "sss" # else: # del cnt # continue area = cv2.contourArea(cnt) rect = cv2.boundingRect(cnt) (x1, y1, w1, h1) = rect cntIndex, mergedCnt = mergeOverSegmentedContours(contours, cnt) if mergedCnt is not None: cnt = [] cnt = mergedCnt del contours[cntIndex] if area < minAreaSize or area > maxAreaSize or hierarchy[0, ii, 3] != -1: # del contours[ii] continue else: cellMorph = getCellIntensityModule(cnt, imgDisplay) cellFeatures.append(cellMorph) cv2.drawContours( mask_colored, [cnt], -1, color[ii].tolist(), thickness=cv2.FILLED, ) cv2.drawContours(imgDisplay, [cnt], -1, (0, 255, 0), 1) rectang.append((x1, y1, w1, h1)) pts.append([x, y]) del thresh, raw_image, preprocessedImage, preprocessedImage1, denoised, gradientIm return pts, rectang, mask_colored, imgDisplay, cellFeatures
from skimage.filter.rank import median from skimage.morphology import disk noise = np.random.random(noisy_image.shape) noisy_image = img_as_ubyte(data.camera()) noisy_image[noise > 0.99] = 255 noisy_image[noise < 0.01] = 0 fig, ax = plt.subplots(2, 2, figsize=(10, 7)) ax1, ax2, ax3, ax4 = ax.ravel() ax1.imshow(noisy_image, vmin=0, vmax=255, cmap=plt.cm.gray) ax1.set_title('Noisy image') ax1.axis('off') ax2.imshow(median(noisy_image, disk(1)), vmin=0, vmax=255, cmap=plt.cm.gray) ax2.set_title('Median $r=1$') ax2.axis('off') ax3.imshow(median(noisy_image, disk(5)), vmin=0, vmax=255, cmap=plt.cm.gray) ax3.set_title('Median $r=5$') ax3.axis('off') ax4.imshow(median(noisy_image, disk(20)), vmin=0, vmax=255, cmap=plt.cm.gray) ax4.set_title('Median $r=20$') ax4.axis('off') """ .. image:: PLOT2RST.current_figure
def median_filter(img, radius=3): return median(img, selem=disk(radius=radius))
def median_filter(image, radius): return median(image, selem=disk(radius))
""" from scipy import ndimage import matplotlib.pyplot as plt from skimage.morphology import watershed, disk from skimage import data from skimage.filter import rank from skimage.util import img_as_ubyte image = img_as_ubyte(data.camera()) # denoise image denoised = rank.median(image, disk(2)) # find continuous region (low gradient) --> markers markers = rank.gradient(denoised, disk(5)) < 10 markers = ndimage.label(markers)[0] #local gradient gradient = rank.gradient(denoised, disk(2)) # process the watershed labels = watershed(gradient, markers) # display results fig, axes = plt.subplots(ncols=4, figsize=(8, 2.7)) fig,suptitle('George - Sementation (scikit-image)') ax0, ax1, ax2, ax3 = axes
def processing(mc, radii=[[11, 11]*u.degree], clip_limit=None, histogram_clip=[0.0, 99.], func=np.sqrt, develop=False, verbose=True): """ Image processing steps used to isolate the EUV wave from the data. Use this part of AWARE to perform the image processing steps that segment propagating features that brighten new pixels as they propagate. Parameters ---------- mc : sunpy.map.MapCube radii : list of lists. Each list contains a pair of numbers that describe the radius of the median filter and the closing operation histogram_clip func """ # Define the disks that will be used on all the images. # The first disk in each pair is the disk that is used by the median # filter. The second disk is used by the morphological closing # operation. disks = [] for r in radii: e1 = (r[0]/mc[0].scale.x).to('pixel').value # median ellipse width - across wavefront e2 = (r[0]/mc[0].scale.y).to('pixel').value # median ellipse height - along wavefront e3 = (r[1]/mc[0].scale.x).to('pixel').value # closing ellipse width - across wavefront e4 = (r[1]/mc[0].scale.y).to('pixel').value # closing ellipse height - along wavefront disks.append([disk(e1), disk(e3)]) # For the dump images rstring = '' for r in radii: z = '%i_%i__' % (r[0].value, r[1].value) rstring += z # Calculate the persistence new = mapcube_tools.persistence(mc) if develop: aware_utils.dump_images(new, rstring, '%s_1_persistence' % rstring) # Calculate the running difference new = mapcube_tools.running_difference(new) if develop: aware_utils.dump_images(new, rstring, '%s_2_rdiff' % rstring) # Storage for the processed mapcube. new_mc = [] # Only want positive differences, so everything lower than zero # should be set to zero mc_data = func(new.as_array()) mc_data[mc_data < 0.0] = 0.0 # Clip the data to be within a range, and then normalize it. if clip_limit is None: cl = np.nanpercentile(mc_data, histogram_clip) mc_data[mc_data > cl[1]] = cl[1] mc_data = (mc_data - cl[0]) / (cl[1]-cl[0]) # Get each map out of the cube an clean it up to better isolate the wave # front for im, m in enumerate(new): if verbose: print(" AWARE: processing map %i out of %i" % (im, len(new))) # Dump images - identities ident = (rstring, im) # Rescale the data using the input function, and subtract the lower # clip limit so it begins at zero. f_data = mc_data[:, :, im] # Replace the nans with zeros - the reason for doing this rather than # something more sophisticated is that nans will not contribute # greatly to the final answer. The nans are put back in at the end # and get carried through in the maps. nans_here = np.logical_not(np.isfinite(f_data)) nans_replaced = deepcopy(f_data) nans_replaced[nans_here] = 0.0 # Byte scale the data - recommended input type for the median. new_data = bytescale(nans_replaced) if develop: aware_utils.dump_image(new_data, rstring, '%s_345_bytscale_%i_%05d.png' % (rstring, im, im)) # Final image used to measure the location of the wave front final_image = np.zeros_like(new_data, dtype=np.float32) # Clean the data to isolate the wave front. for j, d in enumerate(disks): # Get rid of noise by applying the median filter. Although the # input is a byte array make sure that the output is a floating # point array for use with the morphological closing operation. new_d = 1.0*median(new_data, d[0]) if develop: aware_utils.dump_image(new_d, rstring, '%s_6_median_%i_%05d.png' % (rstring, radii[j][0].value, im)) # Apply the morphological closing operation to rejoin separated # parts of the wave front. new_d = closing(new_d, d[1]) if develop: aware_utils.dump_image(new_d, rstring, '%s_7_closing_%i_%05d.png' % (rstring, radii[j][1].value, im)) # Further insurance that we get floating point arrays which are # summed below. final_image += new_d*1.0 if develop: aware_utils.dump_image(final_image, rstring, '%s_final_%05d.png' % ident) # Put the NANs back in - useful to have them in. final_image[nans_here] = np.nan # New mapcube list new_mc.append(Map(ma.masked_array(final_image, mask=nans_here), m.meta)) # Return the cleaned mapcube return Map(new_mc, cube=True)
for i in range(0,experimentLength): frameCounts=[] # Estimate of number of objects detected per 'frame' (image taken this minute) for j in range(0,FPM): # Iterate over 5 images taken this minute if os.path.isfile(filePath+baseName+str(i).zfill(6)+'-'+str(j).zfill(2)+'.pgm'): # (Do nothing otherwise) loadedImage=True # Be optimistic try: image_gray= io.imread(filePath+baseName+str(i).zfill(6)+'-'+str(j).zfill(2)+'.pgm') # Load the image! except: loadedImage=False if loadedImage: # (Do nothing otherwise) # We run a median filter over the image to eliminate both isolated 'hot' and 'cold' pixels, # due to the camera itself or random noise, without actually blurring the image. This adds # slightly unpredictable distortion to the image, but because we only consider a tiny local # neighborhood of each pixel, in practice it doesn't matter. image_gray=median(image_gray, disk(1)) # The bilateral mean is effectively a selective Gaussian blur, # smoothing the image without mixing across edges of substantially # different structures. image_gray= rank.mean_bilateral(image_gray,selem=disk10, s0=5, s1=5) # Average and max brightness across entire image... imAvBrightness=np.mean(image_gray) imMaxBrightness=np.max(image_gray) # Use DoG method to find 'blobs' (hypothetical cells in general size range of cells) # in image, using slightly dynamic thresholding based on overall image brightness blobs_dog = blob_dog(image_gray,min_sigma = 2, max_sigma=8, threshold=0.02+0.02*imMaxBrightness/255.0,overlap=0.9) if len(blobs_dog)>0: # Proceed with cell analysis if we see any blobs blobs_dog[:,2]=blobs_dog[:,2]*sqrt(2) # Convert column to approximate radius of blob
def gen_mask(slide_ind=None, in_dir=None, stack=None, stain='nissl', out_dir=None, num_section_per_slide=5, mirror=None, rotate=None, show=False, resol='x0.3125'): scaling = 4**['x0.3125', 'x1.25', 'x5'].index(resol) # scaling = 1 try: img_rgb = np.array( Image.open( os.path.join(in_dir, '%s_%02d_%s_z0.tif' % (stack, slide_ind, resol))).convert('RGB')) except IOError as e: print e return img_gray = rgb2gray(img_rgb) if stain == 'nissl': imghsv = rgb2hsv(img_rgb) img = imghsv[..., 0] # imghue = imghsv[...,0] elif stain == 'fluorescent': img = img_gray # plt.imshow(imghsv[...,2], cmap=plt.cm.gray) # plt.colorbar() # plt.show() # plt.imshow(img_gray, cmap=plt.cm.gray) # plt.colorbar() # plt.show() # detect scanned zones on whole-slide images if stain == 'nissl': scanzone_mask = img_gray < 0.98 elif stain == 'fluorescent': scanzone_mask = img_gray > 0.0001 scanzone_mask = median(scanzone_mask.astype(np.float), disk(3 * scaling)) scanzone_mask = remove_small_objects(scanzone_mask.astype(np.bool), min_size=50 * scaling, connectivity=2, in_place=False) # min_size=2000*scaling, connectivity=2, in_place=False) if show: plt.imshow(scanzone_mask, cmap=plt.cm.gray) plt.title('detect scanned zones') plt.show() column_labels, n_columns = label(scanzone_mask, neighbors=8, return_num=True, background=0) column_props = regionprops(column_labels + 1) print len(column_props), 'scanned zones detected' mask = np.zeros_like(img_gray, dtype=np.bool) section_masks_all = [] section_bboxes_all = [] centers_slide_all = [] for i, cp in enumerate(column_props): minr, minc, maxr, maxc = cp.bbox sys.stderr.write('start slide %d column %d\n' % (slide_ind, i)) section_masks, section_bboxes = foreground_mask_simple(img[minr:maxr, minc:maxc], show=show, scaling=scaling) sys.stderr.write('finish slide %d column %d\n' % (slide_ind, i)) if len(section_masks) > 0: section_masks_all += section_masks bboxes_slide = section_bboxes + np.r_[minr, minc, minr, minc][np.newaxis, :] section_bboxes_all += list(bboxes_slide) centers_slide = np.atleast_2d( np.column_stack([ bboxes_slide[:, [1, 3]].mean(axis=1), bboxes_slide[:, [0, 2]].mean(axis=1) ])) centers_slide_all += list(centers_slide) numbering, n_slots = renumber_blobs(np.array(centers_slide_all), img.shape) # if len(section_bboxes_all) != len(numbering): # raise Exception('Error: number of section boxes does not match length of numbering: slide %d' % (slide_ind)) if len(section_bboxes_all) != len(numbering): print 'Error: number of section boxes does not match length of numbering: slide %d' % ( slide_ind) return [] for (minr, minc, maxr, maxc), mask, section_id in zip(section_bboxes_all, section_masks_all, numbering): img = img_rgb[minr:maxr, minc:maxc] masked_img = np.dstack([img, img_as_ubyte(mask)]) if show: plt.imshow(masked_img) plt.title(section_id) plt.show() if out_dir is not None: image_filepath = os.path.join( out_dir, '%s_%s_%02d_%d.tif' % (stack, resol, slide_ind, section_id)) imsave(image_filepath, masked_img) filled_bboxes = -1 * np.ones((n_slots, 4), dtype=np.int) filled_bboxes[numbering, :] = section_bboxes_all return filled_bboxes
there are different implementations of median filter : `skimage.filter.median_filter` and `skimage.filter.rank.median` """ noise = np.random.random(ima.shape) nima = data.camera() nima[noise > 0.99] = 255 nima[noise < 0.01] = 0 from skimage.filter.rank import median from skimage.morphology import disk fig = plt.figure(figsize=[10, 7]) lo = median(nima, disk(1)) hi = median(nima, disk(5)) ext = median(nima, disk(20)) plt.subplot(2, 2, 1) plt.imshow(nima, cmap=plt.cm.gray, vmin=0, vmax=255) plt.xlabel('noised image') plt.subplot(2, 2, 2) plt.imshow(lo, cmap=plt.cm.gray, vmin=0, vmax=255) plt.xlabel('median $r=1$') plt.subplot(2, 2, 3) plt.imshow(hi, cmap=plt.cm.gray, vmin=0, vmax=255) plt.xlabel('median $r=5$') plt.subplot(2, 2, 4) plt.imshow(ext, cmap=plt.cm.gray, vmin=0, vmax=255) plt.xlabel('median $r=20$') """
from skimage.morphology import disk noise = np.random.random(noisy_image.shape) noisy_image = img_as_ubyte(data.camera()) noisy_image[noise > 0.99] = 255 noisy_image[noise < 0.01] = 0 fig = plt.figure(figsize=(10, 7)) plt.subplot(2, 2, 1) plt.imshow(noisy_image, vmin=0, vmax=255) plt.title('Noisy image') plt.axis('off') plt.subplot(2, 2, 2) plt.imshow(median(noisy_image, disk(1)), vmin=0, vmax=255) plt.title('Median $r=1$') plt.axis('off') plt.subplot(2, 2, 3) plt.imshow(median(noisy_image, disk(5)), vmin=0, vmax=255) plt.title('Median $r=5$') plt.axis('off') plt.subplot(2, 2, 4) plt.imshow(median(noisy_image, disk(20)), vmin=0, vmax=255) plt.title('Median $r=20$') plt.axis('off') """ .. image:: PLOT2RST.current_figure
from skimage.morphology import disk noise = np.random.random(noisy_image.shape) noisy_image = img_as_ubyte(data.camera()) noisy_image[noise > 0.99] = 255 noisy_image[noise < 0.01] = 0 fig = plt.figure(figsize=(10, 7)) plt.subplot(2, 2, 1) plt.imshow(noisy_image, vmin=0, vmax=255) plt.title('Noisy image') plt.axis('off') plt.subplot(2, 2, 2) plt.imshow(median(noisy_image, disk(1)), vmin=0, vmax=255) plt.title('Median $r=1$') plt.axis('off') plt.subplot(2, 2, 3) plt.imshow(median(noisy_image, disk(5)), vmin=0, vmax=255) plt.title('Median $r=5$') plt.axis('off') plt.subplot(2, 2, 4) plt.imshow(median(noisy_image, disk(20)), vmin=0, vmax=255) plt.title('Median $r=20$') plt.axis('off') """
def gen_mask(slide_ind=None, in_dir=None, stack=None, use_hsv=True, out_dir=None, num_section_per_slide=5, mirror=None, rotate=None): imgcolor = Image.open( os.path.join(in_dir, '%s_%02d_x0.3125_z0.tif' % (stack, slide_ind))) # imgcolor = Image.open(os.path.join(in_dir, '%s_%02d_x5_z0.tif'%(stack, slide_ind))) imgcolor = imgcolor.convert('RGB') imgcolor = np.array(imgcolor) img_gray = rgb2gray(imgcolor) # slide_height, slide_width = img_gray.shape[:2] if use_hsv: imghsv = rgb2hsv(imgcolor) img = imghsv[..., 1] else: img = img_gray # utilize bounding box selected during scanning process a = img_gray < 0.98 a = median(a.astype(np.float), disk(3)) a = remove_small_objects(a.astype(np.bool), min_size=50, connectivity=2, in_place=False) column_labels, n_columns = label(a, neighbors=8, return_num=True, background=0) column_props = regionprops(column_labels + 1) column_bboxes = np.array([p.bbox for p in column_props]) indices = np.argsort(column_bboxes[:, 1]) mask = np.zeros_like(img_gray, dtype=np.bool) for i, box in enumerate(column_bboxes[indices, :]): minr, minc, maxr, maxc = box # touch_top t = 0 if np.std(img[minr, minc:maxc + 1]) > .06 else 5 # touch_bottom b = 0 if np.std(img[maxr - 1, minc:maxc + 1]) > .06 else 5 # touch_left l = 0 if np.std(img[minr:maxr + 1, minc]) > .06 else 5 # touch_right r = 0 if np.std(img[minr:maxr + 1, maxc - 1]) > .06 else 5 mask[minr + t:maxr - b, minc + l:maxc - r] = 1 section_masks, bboxes, exists = foreground_mask_morphsnakes_slide( img, levelset=mask, num_section_per_slide=num_section_per_slide, min_iters=400, dilate_iters=1) ids = np.where(exists)[0] # section_images = [] for _, ((minr, minc, maxr, maxc), mask, section_id) in enumerate(zip(bboxes, section_masks, ids)): img = imgcolor[minr:maxr + 1, minc:maxc + 1].copy() mask = 255 * mask.astype(np.uint8) masked_img = np.dstack([img, mask]) # img[~mask] = 0 # section_images.append(img) image_filepath = os.path.join( out_dir, '%s_x0.3125_%02d_%d.tif' % (stack, slide_ind, section_id)) # image_filepath = os.path.join(out_dir, '%s_x5_%02d_%d.tif'%(stack, slide_ind, section_id)) imsave(image_filepath, masked_img) # bboxes_percent = np.array(bboxes, dtype=np.float)/np.r_[img_gray.shape[:2], img_gray.shape[:2]][np.newaxis, :] filled_bboxes = -1 * np.ones((len(exists), 4), dtype=np.int) filled_bboxes[ids, :] = bboxes return filled_bboxes
def preprocessing(image, smooth_size, folder): """ 'The image low contrast and under segmentation problem is not yet addressed by most of the researchers' 'Other researchers also proposed different method to remedy the problem of watershed. Li, El- moataz, Fadili, and Ruan, S. (2003) proposed an improved image segmentation approach based on level set and mathematical morphology' THE SPHERES MUST BE ALMOST ALONG THE SAME PLANES IN Z DIRECTION IF THEY ARE TOUCHING AND OVERLAP, WHILE BEING ALMOST MERGED IT IS IMPOSSIBLE TO RESOLVE THEM ONE IDEA MIGHT BE TO DETECT CENTRES ALONG ONE AXIS AND THEN ANOTHER AFTER ALL THE CENTRES WERE FOUND COMBINE THEM SOMEHOW... """ from skimage.restoration import denoise_tv_chambolle dim = int(image.shape[0] / 50.) smoothed = rank.median(image, disk(smooth_size)) #smoothed = denoise_tv_chambolle(image, weight=0.002) smoothed = rank.enhance_contrast(smoothed, disk(smooth_size)) pl.subplot(2, 3, 1) pl.title("after median") pl.imshow(smoothed) pl.gray() # If after smoothing the "dot" disappears # use the image value # TODO: wat do with thresh? try: im_max = smoothed.max() thresh = threshold_otsu(image) except: im_max = image.max() thresh = threshold_otsu(image) if im_max < thresh: labeled = np.zeros(smoothed.shape, dtype=np.int32) else: binary = smoothed > thresh # TODO: this array size is the fault of errors bin_open = binary_opening(binary, np.ones((dim, dim)), iterations=5) bin_close = binary_closing(bin_open, np.ones((5, 5)), iterations=5) pl.subplot(2, 3, 2) pl.title("threshold") pl.imshow(binary, interpolation='nearest') pl.subplot(2, 3, 3) pl.title("opening") pl.imshow(bin_open, interpolation='nearest') pl.subplot(2, 3, 4) pl.title("closing") pl.imshow(bin_close, interpolation='nearest') distance = ndimage.distance_transform_edt(bin_open) local_maxi = peak_local_max(distance, indices=False, labels=bin_open) markers = ndimage.label(local_maxi)[0] labeled = watershed(-distance, markers, mask=bin_open) pl.subplot(2, 3, 5) pl.title("label") pl.imshow(labeled) #pl.show() pl.savefig(folder) pl.close('all') #misc.imsave(folder, labeled) # labels_rw = random_walker(bin_close, markers, mode='cg_mg') # # pl.imshow(labels_rw, interpolation='nearest') # pl.show() return labeled
def recognize(img, digit_templates): # table selection table_coord = table(img) img = img[img.shape[0]*0.02:img.shape[0]*0.95, \ img.shape[1]*0.05:img.shape[1]*0.95] img = img[table_coord[1]:table_coord[3], \ table_coord[0]:table_coord[2]] # end of table selection st_img = img.copy() # image processing img = rescale_intensity(img) img = rank.median(img, disk(2)) img = ssr(img, 9) img = unsharp(img, 3) # end of image processing result = giveNumbers(img, digit_templates, 0, 0) # numbers very near: without median(else connect) # and low sigma in gaussian in ssr(else connect too) if result == (-1, -1, -1): img = st_img.copy() img = rescale_intensity(img) img = ssr(img, 3) img = unsharp(img, 3) imsave('tmp.bmp', img) result = giveNumbers(img, digit_templates, 0, 0) # very bright picture: need closing in giveNumbers if result == (-1, -1, -1): img = st_img.copy() img = rescale_intensity(img) img = rank.median(img, disk(2)) img = ssr(img, 9) img = unsharp(img, 3) result = giveNumbers(img, digit_templates, 1, 0) # and play with threshold of binarization delta = 0 bool = -1 while result == (-1, -1, -1) and abs(delta) <= (240): delta *= -1 if bool == -1: delta -= 5 bool *= -1 img = st_img.copy() img = rescale_intensity(img) img = rank.median(img, disk(2)) img = ssr(img, 9) img = unsharp(img, 3) result = giveNumbers(img, digit_templates, 0, delta) if result == (-1, -1, -1): result = (0, 0, 0) return result
def sharpness(image, edge_threshold=0.0001, w=5, t=1.0): """ Code implemented by the following article: Sharpness Estimation for Document and Scene Images, Kumar, Chen, Doermann """ # Median filtering w_size = (w * 2) + 1 image = util.img_as_float(image) image_m = util.img_as_float(median(image, mph.square(3))) # Window functions def dom_func(window): # import pdb; pdb.set_trace() return abs( abs(window[4] - window[2]) - abs(window[2] - window[0]) ) def contrast_func(window): # print window s = 0.0 for i in xrange(0, len(window) - 1): # print i s += abs(window[i] - window[i+1]) return s # Delta DoM in horizontal direction dom_x_values = generic_filter(image_m, dom_func, size=(1, 5), mode='reflect') # Delta DoM in vertical direction dom_y_values = generic_filter(image_m, dom_func, size=(5, 1), mode='reflect') dom_x = generic_filter( dom_x_values, lambda w: sum(w), size=(1, w_size), mode='reflect') dom_y = generic_filter( dom_y_values, lambda w: sum(w), size=(w_size, 1), mode='reflect') edges_x = vsobel(image) # Normalize edges_x *= (1.0 / edges_x.max()) edges_x_pixels = len(edges_x[edges_x > edge_threshold].ravel()) edges_y = hsobel(image) # Normalize edges_y *= (1.0 / edges_y.max()) edges_y_pixels = len(edges_y[edges_y > edge_threshold].ravel()) # Contrast in horizontal direction contrast_x = generic_filter(image, contrast_func, size=(1, w_size + 1), mode='reflect') # Contrast in vertical direction contrast_y = generic_filter(image, contrast_func, size=(w_size + 1, 1), mode='reflect') sharpness_x = dom_x / contrast_x sharpness_y = dom_y / contrast_y # import pdb; pdb.set_trace() sharp_x_pixels = len(np.where( sharpness_x[edges_x > edge_threshold] > t )[0]) sharp_y_pixels = len(np.where( sharpness_y[edges_y > edge_threshold] > t )[0]) # import pdb; pdb.set_trace() if edges_x_pixels > 0: rx = (float(sharp_x_pixels) / edges_x_pixels) else: rx = 1 if edges_y_pixels > 0: ry = (float(sharp_y_pixels) / edges_y_pixels) else: ry = 1 final_estimate = np.sqrt( (rx ** 2) + (ry ** 2) ) return final_estimate
def table(img): img = rescale_intensity(img) img = ssr(img, 3) img = rank.median(img, disk(2)) img = img[img.shape[0]*0.02:img.shape[0]*0.95, img.shape[1]*0.05:img.shape[1]*0.95] height = img.shape[0] width = img.shape[1] img = (img < threshold_otsu(img[height/5:height/5*4, width/5:width/5*4], nbins = 256)) # Horizontal whiteList = [] for i in range((height/2), height-4): img_lbl = label(img[i:i+4, 0:width], 4, background = 255) props = regionprops(img_lbl) whiteList.append(max_area(props)) max_wh = max(whiteList) bool = 0 for i in arange(len(whiteList))[::-1]: if (whiteList[i] > (0.95*max_wh)) and (bool == 0): h_top = i bool = 1 whiteList = [] for i in arange(4, height/2)[::-1]: img_lbl = label(img[i-4:i, 0:width], 4, background = 255) props = regionprops(img_lbl) whiteList.append(max_area(props)) max_wh = max(whiteList) bool = 0 for i in arange(len(whiteList))[::-1]: if (whiteList[i] > (0.95*max_wh)) and (bool == 0): h_bot = i bool = 1 img = img[(height/2) - h_bot:(height/2) + h_top,] * 255 x_min = (height/2) - h_bot x_max = (height/2) + h_top # Vertical whiteList = [] for i in range((width/2), width): whiteList.append(img[height/4:height/4*3, i].sum()) max_wh = max(whiteList) bool = 0 for i in arange(len(whiteList))[::-1]: if (whiteList[i] > (0.95*max_wh)) and (bool == 0): v_top = i bool = 1 whiteList = [] for i in arange(width/2)[::-1]: whiteList.append(img[height/4:height/4*3,i].sum()) max_wh = max(whiteList) bool = 0 for i in arange(len(whiteList))[::-1]: if (whiteList[i] > (0.95*max_wh)) and (bool == 0): v_bot = i bool = 1 y_min = (width/2) - v_bot y_max = (width/2) + v_top if float(v_top + v_bot)/height < 1.5: y_min = 0 y_max = width return (y_min, x_min, y_max, x_max)
from skimage.morphology import disk, closing, watershed, remove_small_objects, disk, label, convex_hull_image, binary_dilation from skimage.morphology import octagon, opening, diamond, reconstruction from skimage.feature import peak_local_max from skimage.transform import hough_ellipse from skimage.filter import threshold_yen, rank from skimage.measure import regionprops from skimage.draw import circle_perimeter #################################################### #################################### Distance Image - Internal Marker Locus image = io.imread("/Users/rishabgargeya/Desktop/database/DRIVE/training/images/22_training.tif") plt.imshow(image) gray_image = rgb2gray(image) io.imshow(gray_image) med = median(gray_image, disk(3)) io.imshow(med) clahe_image = exposure.equalize_adapthist(med) io.imshow(clahe_image) clahe_image = img_as_ubyte(clahe_image) binary = clahe_image > threshold_yen(clahe_image) io.imshow(binary) binary_label = label(binary) rps = regionprops(binary_label)[1:] #regionprops, ignore background areas = [rp.area for rp in rps] region_with_largest_area = np.argmax(areas) binary = binary_label == rps[region_with_largest_area].label #binary = convex_hull_image(binary) #binary = binary_dilation(binary, disk(15)) != 0
there are different implementations of median filter : `skimage.filter.median_filter` and `skimage.filter.rank.median` """ noise = np.random.random(ima.shape) nima = data.camera() nima[noise > 0.99] = 255 nima[noise < 0.01] = 0 from skimage.filter.rank import median from skimage.morphology import disk fig = plt.figure(figsize=[10, 7]) lo = median(nima, disk(1)) hi = median(nima, disk(5)) ext = median(nima, disk(20)) plt.subplot(2, 2, 1) plt.imshow(nima, cmap=plt.cm.gray, vmin=0, vmax=255) plt.xlabel('noised image') plt.subplot(2, 2, 2) plt.imshow(lo, cmap=plt.cm.gray, vmin=0, vmax=255) plt.xlabel('median $r=1$') plt.subplot(2, 2, 3) plt.imshow(hi, cmap=plt.cm.gray, vmin=0, vmax=255) plt.xlabel('median $r=5$') plt.subplot(2, 2, 4) plt.imshow(ext, cmap=plt.cm.gray, vmin=0, vmax=255) plt.xlabel('median $r=20$')
def process(self): if verbose: print "Opening", self.input_file ds = gdal.Open(self.input_file) if ds is None: print('ERROR: file no data:') sys.exit(-1) RasterXSize = ds.RasterXSize RasterYSize = ds.RasterYSize RasterCount = ds.RasterCount projection = ds.GetProjection() geotransform = ds.GetGeoTransform() xorg = geotransform[0] yorg = geotransform[3] xres = geotransform[1] yres = geotransform[5] xmax = xorg + geotransform[1] * RasterXSize ymax = yorg + geotransform[5] * RasterYSize if verbose: print "size", RasterXSize, RasterYSize, RasterCount print "xorg", xorg, "yorg", yorg print "xmax", xmax, "ymax", ymax print "Read red" rb = ds.GetRasterBand(1) red = (rb.ReadAsArray(0, 0, ds.RasterXSize, ds.RasterYSize)).astype(float) print "Read green" gb = ds.GetRasterBand(2) green = (gb.ReadAsArray(0, 0, ds.RasterXSize, ds.RasterYSize)).astype(float) print "Read blue" bb = ds.GetRasterBand(3) blue = (bb.ReadAsArray(0, 0, ds.RasterXSize, ds.RasterYSize)).astype(float) data = self.gray1(red, green, blue, RasterXSize, RasterYSize) #data = self.rgb2gray(red, green, blue, RasterXSize, RasterYSize) #data = equalize_hist(data) #data *= 255.0 mean = numpy.mean(data) minimum = numpy.min(data) maximum = numpy.max(data) #threshold = mean print minimum, mean, maximum #threshold = mean #data = equalize_hist(data) #data *= 255 #print numpy.min(data), numpy.mean(data), numpy.max(data) #data[data>threshold] = 0 thresh2 = threshold_otsu(data, nbins=100) print "otsu threshold", thresh2 data[data > thresh2] = 0 data[data > 0] = 1 print "de-speckle..." data = median(data.astype(numpy.uint8), disk(3)) print "Write data..." data[data > 0] = 255 driver = gdal.GetDriverByName("GTiff") dst_ds = driver.Create(self.output_file, RasterXSize, RasterYSize, 1, gdal.GDT_Byte, ['INTERLEAVE=PIXEL', 'COMPRESS=DEFLATE']) band = dst_ds.GetRasterBand(1) band.WriteArray(data.astype(int), 0, 0) band.SetNoDataValue(0) dst_ds = None ds = None # Convert to BMP cmd = "gdal_translate -q -scale 0 255 0 65535 " + self.output_file + " -of BMP " + self.bmp_file self.execute(cmd) sys.exit(0) #if force or not os.path.exists(self.geojson_file): cmd = str.format( "potrace -z black -a 1.5 -t 2 -i -b geojson -o {0} {1} -x {2}x{3} -L {4} -B {5} ", self.geojson_file, self.bmp_file, xres, -yres, xorg, ymax) self.execute(cmd) # We need to add a water property # This may or may not be necessary based on styling or multi color requirements #cmd = str.format("node add_geojson_props.js {0}", self.geojson_file) #self.execute(cmd) # Convert to Topojson cmd = str.format( "topojson -o {0} --simplify-proportion 0.5 -- surface_water={1}", self.topojson_file, self.geojson_file) self.execute(cmd) # Convert back to geojson now that it has been simplified cmd = str.format("topojson-geojson --precision 5 -o {0} {1}", self.outpath, self.topojson_file) self.execute(cmd) # convert it to OSM to visualize in JOSM and update reference water data_source = "WorldView-2" cmd = str.format("node geojson2osm {0} {1}", self.surface_water_json, data_source) self.execute(cmd) # gzip it cmd = str.format("gzip {0} ", self.topojson_file) self.execute(cmd) # compress it cmd = "bzip2 " + self.surface_water_osm self.execute(cmd) cmd = str.format("gzip {0} ", self.surface_water_json) self.execute(cmd)
def cr_med(image, selem): return median(image=image, selem=selem)
(stack, stack, slide_ind)) # imgcolor = Image.open("/home/yuncong/DavidData2015slides/%s/x5/%s_%02d_x5_z0.tif" % (stack, stack, slide_ind)) imgcolor = imgcolor.convert('RGB') imgcolor = np.array(imgcolor) img_gray = rgb2gray(imgcolor) slide_height, slide_width = img_gray.shape[:2] if use_hsv: imghsv = rgb2hsv(imgcolor) img = imghsv[..., 1] else: img = img_gray # utilize bounding box selected during scanning process a = img_gray < 0.98 a = median(a.astype(np.float), disk(3)) a = remove_small_objects(a.astype(np.bool), min_size=50, connectivity=2, in_place=False) column_labels, n_columns = label(a, neighbors=8, return_num=True, background=0) print n_columns, 'columns detected' column_props = regionprops(column_labels + 1) column_bboxes = np.array([p.bbox for p in column_props]) indices = np.argsort(column_bboxes[:, 1]) mask = np.zeros_like(img_gray, dtype=np.bool) for i, box in enumerate(column_bboxes[indices, :]):
#Transformation en image en niveau de gris polDia_g = skimage.color.rgb2gray(polDia) polDia_g = polDia_g * laser_copy plt.subplot(3,3,2) plt.title("Image en gris") plt.imshow(polDia_g,cmap = plt.cm.gray) plt.colorbar() # applique un filtre median sur l'image en niveau de gris, ceci afin #de flouter et lisser les bords polDia_med = rank2.median((polDia_g*255).astype('uint8'),disk(8)) plt.subplot(3,3,3) plt.title("Image apres filtre median") plt.imshow(polDia_med,cmap = plt.cm.gray) plt.colorbar() type(polDia_med) # applique une normalisation adaptive a contraste limitee de l'histogramme # (CLAHE) polDia_clahe = exposure.equalize_adapthist(polDia_med, clip_limit=0.03) polDia_clahe_stretch = exposure.rescale_intensity(polDia_clahe, out_range=(0, 256)) #revient a faire polDia_clahe multiplie par 256 plt.subplot(3,3,4)
from skimage.filter.rank import median from skimage.morphology import disk noise = np.random.random(noisy_image.shape) noisy_image = img_as_ubyte(data.camera()) noisy_image[noise > 0.99] = 255 noisy_image[noise < 0.01] = 0 fig, ax = plt.subplots(2, 2, figsize=(10, 7)) ax1, ax2, ax3, ax4 = ax.ravel() ax1.imshow(noisy_image, vmin=0, vmax=255, cmap=plt.cm.gray) ax1.set_title('Noisy image') ax1.axis('off') ax2.imshow(median(noisy_image, disk(1)), vmin=0, vmax=255, cmap=plt.cm.gray) ax2.set_title('Median $r=1$') ax2.axis('off') ax3.imshow(median(noisy_image, disk(5)), vmin=0, vmax=255, cmap=plt.cm.gray) ax3.set_title('Median $r=5$') ax3.axis('off') ax4.imshow(median(noisy_image, disk(20)), vmin=0, vmax=255, cmap=plt.cm.gray) ax4.set_title('Median $r=20$') ax4.axis('off') """ .. image:: PLOT2RST.current_figure The added noise is efficiently removed, as the image defaults are small (1
.. _Wikipedia: http://en.wikipedia.org/wiki/Watershed_(image_processing) """ from scipy import ndimage import matplotlib.pyplot as plt from skimage.morphology import watershed, disk from skimage import data # original data from skimage.filter import rank image = data.camera() # denoise image denoised = rank.median(image, disk(2)) # find continuous region (low gradient) --> markers markers = rank.gradient(denoised, disk(5)) < 10 markers = ndimage.label(markers)[0] #local gradient gradient = rank.gradient(denoised, disk(2)) # process the watershed labels = watershed(gradient, markers) # display results fig, axes = plt.subplots(ncols=4, figsize=(8, 2.7)) ax0, ax1, ax2, ax3 = axes
def process(self): if verbose: print "Opening", self.input_file ds = gdal.Open(self.input_file) if ds is None: print('ERROR: file no data:') sys.exit(-1) RasterXSize = ds.RasterXSize RasterYSize = ds.RasterYSize RasterCount = ds.RasterCount projection = ds.GetProjection() geotransform = ds.GetGeoTransform() xorg = geotransform[0] yorg = geotransform[3] xres = geotransform[1] yres = geotransform[5] xmax = xorg + geotransform[1] * RasterXSize ymax = yorg + geotransform[5] * RasterYSize if verbose: print "size", RasterXSize, RasterYSize, RasterCount print "xorg", xorg, "yorg", yorg print "xmax", xmax, "ymax", ymax band = ds.GetRasterBand(1) data = band.ReadAsArray(0, 0, ds.RasterXSize, ds.RasterYSize) mean = numpy.mean(data) minimum = numpy.min(data) #threshold = (mean+minimum)/2 threshold = mean print minimum, mean, threshold data[data > threshold] = 0 thresh2 = threshold_otsu(data, nbins=100) print "otsu threshold", thresh2 data[data > thresh2] = 0 #data = denoise_bilateral(data, sigma_range=0.05, sigma_spatial=15) #data = binary_opening(data, disk(3)) data = median(data, disk(3)) data[data > 0] = 255 # Compute the Canny filter for two values of sigma #edges = filter.canny(data, sigma=3) driver = gdal.GetDriverByName("GTiff") dst_ds = driver.Create(self.output_file, RasterXSize, RasterYSize, 1, gdal.GDT_Byte, ['INTERLEAVE=PIXEL', 'COMPRESS=DEFLATE']) band = dst_ds.GetRasterBand(1) band.WriteArray(data, 0, 0) band.SetNoDataValue(0) if verbose: print "Written", self.output_file dst_ds = None ds = None # Convert to PGM #cmd = "gdal_translate -q -scale 0 255 0 65535 " + self.output_file + " -of PNM "+self.pgm_file cmd = "gdal_translate -q -scale 0 255 0 65535 " + self.output_file + " -of BMP " + self.bmp_file self.execute(cmd) #if force or not os.path.exists(self.geojson_file): cmd = str.format( "potrace -z black -a 1.5 -t 2 -i -b geojson -o {0} {1} -x {2}x{3} -L {4} -B {5} ", self.geojson_file, self.bmp_file, xres, -yres, xorg, ymax) self.execute(cmd) # We need to add a water property # This may or may not be nexessary based on styling or multi color requirements #cmd = str.format("node add_geojson_props.js {0}", self.geojson_file) #self.execute(cmd) # Convert to Topojson cmd = str.format( "topojson -o {0} --simplify-proportion 0.5 -- surface_water={1}", self.topojson_file, self.geojson_file) self.execute(cmd) # Convert back to geojson now that it has been simplified cmd = str.format("topojson-geojson --precision 5 -o {0} {1}", self.outpath, self.topojson_file) self.execute(cmd) # convert it to OSM to visualize in JOSM and update reference water cmd = str.format("node geojson2osm {0}", self.surface_water_json) self.execute(cmd) # gzip it cmd = str.format("gzip {0} ", self.topojson_file) self.execute(cmd) # compress it cmd = "bzip2 " + self.surface_water_osm self.execute(cmd) cmd = str.format("gzip {0} ", self.surface_water_json) self.execute(cmd)
from scipy import ndimage as ndi import matplotlib.pyplot as plt from skimage import io from skimage.morphology import watershed, disk from skimage import data from skimage.filter import rank import cv2 image = io.imread('cerebro.jpg') # makes the image grey colormap gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # denoise image denoised = rank.median(gray, disk(1)) # create the sheds markers = rank.gradient(denoised, disk(1)) < 15 markers = ndi.label(markers)[0] # process the watershed labels = watershed(gray, markers) # display results fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(8, 8), sharex=True, sharey=True) ax = axes.ravel()