def getColorVector(im, nbin): h1, v1 = exposure.histogram(im[:,:,0], nbin) h2, v2 = exposure.histogram(im[:,:,1], nbin) h3, v3 = exposure.histogram(im[:,:,2], nbin) h1 = h1 / (h1.sum() * 1.0) h2 = h2 / (h2.sum() * 1.0) h3 = h3 / (h3.sum() * 1.0) return np.append(h1,[h2,h3])
def color_feature(blur, hbins=15, sbins=15): hsv = color.rgb2hsv(blur) # cal hist h_hist = exposure.histogram(hsv[:, :, 0], nbins=hbins) s_hist = exposure.histogram(hsv[:, :, 1], nbins=sbins) return np.append(normalize(h_hist[0]), normalize(s_hist[0]))
def plotImageWithHistogram(im, size, alpha=0.3, interpolation='nearest'): r"""Plot an image alongside its histogram Parameters ---------- im : a numpy array The input image size : number The size (in in) for the single figure. The plot will be that high and twice that wide. alpha : float The transparency. A value of 0.3 is great for an RGB image, a value of 0.8 is a bit better for a grayscale image. Returns ------- (ax__image, ax_hist) The matplotlib axes for the figure. Examples -------- from jmToolsPy3 import plotImageWithHistogram import numpy as np from skimage import data img1 = data.camera() axImg1, axHis1 = plotImageWithHistogram(img1, 5, alpha=0.8) img2 = data.lena() axImg2, axHis2 = plotImageWithHistogram(img2, 5, alpha=0.3) """ from skimage import exposure from matplotlib import pyplot as plt fig, (ax_image, ax_hist) = plt.subplots(ncols=2, figsize=(2*size, size)) ax_image.imshow(im, cmap=plt.cm.gray, interpolation=interplolation) if im.ndim == 2: hist, bin_centers = exposure.histogram(im) ax_hist.fill_between(bin_centers, hist, alpha=alpha, color='gray') elif im.ndim == 3: for channel, channel_color in zip(iter_channels(im), 'rgb'): hist, bin_centers = exposure.histogram(channel) ax_hist.fill_between(bin_centers, hist, alpha=alpha, color=channel_color) ax_hist.set_ylabel('# pixels') ax_hist.set_xlabel('intensity') ax_hist.set_yticklabels("") ax_image.set_axis_off() # match_axes_height(ax_image, ax_hist) dst = ax_hist.get_position() src = ax_image.get_position() ax_hist.set_position([dst.xmin, src.ymin, dst.width, src.height]) return ax_image, ax_hist
def test_normalize(): im = np.array([0, 255, 255], dtype=np.uint8) frequencies, bin_centers = exposure.histogram(im, source_range='dtype', normalize=False) expected = np.zeros(256) expected[0] = 1 expected[-1] = 2 assert_equal(frequencies, expected) frequencies, bin_centers = exposure.histogram(im, source_range='dtype', normalize=True) expected /= 3. assert_equal(frequencies, expected)
def threshHist(imgIn): imgIn1 = imgIn.ravel() # Histogram analysis to find maximum peak and associated gl pxCnt, gL = exposure.histogram( imgIn ) indMaxBG = int(np.arange( len(imgIn1) )[pxCnt == pxCnt.max()]) #int() BGlevel = gL[indMaxBG] # Nearest min below this max is threshold d1 = np.zeros( np.shape(pxCnt) ) for i in range( 2 , len(pxCnt) - 1): # derivative approximation d1[i] = pxCnt[ i + 1 ] - pxCnt[ i ] i = 1 p = 0 while ( d1[ indMaxBG - i ] > 0): ### - i!!! p = indMaxBG - i i = i + 1 t = gL[ p ] imgOut = imgProc.applyThresh( imgIn, t ) return imgOut
def preprocImageV(fimg): nbin=64 dn = 24 img=skimage.img_as_float(io.imread(fimg,as_grey=True)) siz=img.shape sizMax=np.max(siz) siz2=(sizMax,sizMax) msk=np.zeros(siz) cv2.circle(msk, (siz[1]/2, siz[0]/2), (np.min(siz)/2)-3, (1,1,1), -1) ##cv2.cv.CV_FILLED s0 = 0.3440 h1,xx = exposure.histogram(img[msk==1], nbin) s1 = np.std(img[msk==1]) h = h1.copy() h[np.argwhere(h > 0)[-1]] = 0 h[np.argwhere(h > 0)[-1]] = 0 st = np.percentile(img[msk==1], 1) p1 = np.argwhere(np.fabs(xx - st)==np.min(abs(xx - st)))[0][0] h[p1:np.min((nbin, p1 + np.round(dn * s1 / s0)))]=0 p2 = np.argwhere(h==np.max(h))[0][0] max1=xx[p1] max2=xx[p2] ret= 0.8*(img-max1)/(max2-max1) ret[ret<0]=0 ret[ret>1]=1 ret=np.uint8(255*ret) ret2=np.zeros(siz2, np.uint8) r0=np.floor((sizMax-siz[0])/2) c0=np.floor((sizMax-siz[1])/2) ret2[r0:r0+siz[0], c0:c0+siz[1]]=ret # cv2.imshow("ret", ret) # cv2.imshow("ret2", ret2) # cv2.waitKey(0) return ret2
def _plot_histogram(ax, image, alpha=0.3, **kwargs): # Use skimage's histogram function which has nice defaults for # integer and float images. hist, bin_centers = exposure.histogram(image) ax.fill_between(bin_centers, hist, alpha=alpha, **kwargs) ax.set_xlabel('intensity') ax.set_ylabel('# pixels')
def set_data(self, data):#, mask): self.data = data # self.mask = mask # if self.data is not None: self.hist, self.bins = skiexp.histogram(self.data, nbins=1000) # if mask is not None: # self.data_m = self.data[np.nonzero(self.mask)] # else: # self.data_m = self.data if self.params and self.params.has_key('data_min'): self.data_min = self.params['data_min'] # elif self.data is not None: self.data_min = self.data.min() # else: # self.data_min = 0 if self.params and self.params.has_key('datam_max'): self.data_max = self.params['data_max'] # elif self.data is not None: self.data_max = self.data.max() # else: # self.data_max = 0 self.ui.hypo_mean_SL.setMinimum(self.data_min) self.ui.heal_mean_SL.setMinimum(self.data_min) self.ui.hyper_mean_SL.setMinimum(self.data_min) self.ui.hypo_mean_SL.setMaximum(self.data_max) self.ui.heal_mean_SL.setMaximum(self.data_max) self.ui.hyper_mean_SL.setMaximum(self.data_max) self.update_figures()
def test_negative_overflow(): im = np.array([-1, 127], dtype=np.int8) frequencies, bin_centers = exposure.histogram(im) assert_array_equal(bin_centers, np.arange(-1, 128)) assert frequencies[0] == 1 assert frequencies[-1] == 1 assert_array_equal(frequencies[1:-1], 0)
def threshold_yen(image, nbins=256, shift=None): """Return threshold value based on Yen's method. Parameters ---------- image : array Input image. nbins : int, optional Number of bins used to calculate histogram. This value is ignored for integer arrays. shift : int, optional Shift threshold value by percent up (positive) or down (negative). Returns ------- threshold : float Upper threshold value. All pixels intensities that less or equal of this value assumed as foreground. References ---------- .. [1] Yen J.C., Chang F.J., and Chang S. (1995) "A New Criterion for Automatic Multilevel Thresholding" IEEE Trans. on Image Processing, 4(3): 370-378 .. [2] Sezgin M. and Sankur B. (2004) "Survey over Image Thresholding Techniques and Quantitative Performance Evaluation" Journal of Electronic Imaging, 13(1): 146-165, http://www.busim.ee.boun.edu.tr/~sankur/SankurFolder/Threshold_survey.pdf .. [3] ImageJ AutoThresholder code, http://fiji.sc/wiki/index.php/Auto_Threshold Examples -------- >>> from skimage.data import camera >>> image = camera() >>> thresh = threshold_yen(image) >>> binary = image <= thresh """ hist, bin_centers = histogram(image, nbins) # On blank images (e.g. filled with 0) with int dtype, `histogram()` # returns `bin_centers` containing only one value. Speed up with it. if bin_centers.size == 1: return bin_centers[0] # Calculate probability mass function pmf = hist.astype(np.float32) / hist.sum() P1 = np.cumsum(pmf) # Cumulative normalized histogram P1_sq = np.cumsum(pmf ** 2) # Get cumsum calculated from end of squared array: P2_sq = np.cumsum(pmf[::-1] ** 2)[::-1] # P2_sq indexes is shifted +1. I assume, with P1[:-1] it's help avoid '-inf' # in crit. ImageJ Yen implementation replaces those values by zero. crit = np.log(((P1_sq[:-1] * P2_sq[1:]) ** -1) * (P1[:-1] * (1.0 - P1[:-1])) ** 2) threshold = bin_centers[crit.argmax()] ptp = (bin_centers[-1] - bin_centers[0]) / 100. # Peek to peek range if shift: threshold += ptp * shift # print("Threshold value shift", (threshold - bin_centers[0]) / float(ptp)) return threshold
def statxture(pixels): """computes a variety of texture stats from the image histogram. See Digital Image Processing Using MATLAB, ch. 11""" average_gray_level = np.mean(pixels) average_contrast = np.std(pixels) H = histogram(pixels)[0] H = H / (1. * len(pixels)) L = len(H) d = (L - 1.)**2 normvar = np.var(pixels) / d smoothness = 1. - 1. / (1. + normvar) third_moment = moment(pixels,3) / d uniformity = np.sum(H**2) eps = np.finfo(float).eps entropy = 0. - np.sum(H * np.log2(H + eps)) return average_gray_level, average_contrast, smoothness, \ third_moment, uniformity, entropy
def test_peak_float_out_of_range_dtype(): im = np.array([10, 100], dtype=np.float16) nbins = 10 frequencies, bin_centers = exposure.histogram(im, nbins=nbins, source_range='dtype') assert_almost_equal(np.min(bin_centers), -0.9, 3) assert_almost_equal(np.max(bin_centers), 0.9, 3) assert_equal(len(bin_centers), 10)
def analyse_histogram(data, roi=None, debug=False, dens_min=20, dens_max=255, minT=0.95, maxT=1.05): if roi == None: #roi = np.ones(data.shape, dtype=np.bool) roi = np.logical_and(data >= dens_min, data <= dens_max) voxels = data[np.nonzero(roi)] hist, bins = skiexp.histogram(voxels) max_peakIdx = hist.argmax() minT = minT * hist[max_peakIdx] maxT = maxT * hist[max_peakIdx] histTIdxs = (hist >= minT) * (hist <= maxT) histTIdxs = np.nonzero(histTIdxs)[0] histTIdxs = histTIdxs.astype(np.int) class1TMin = bins[histTIdxs[0]] class1TMax = bins[histTIdxs[-1]] liver = data * (roi > 0) class1 = np.where( (liver >= class1TMin) * (liver <= class1TMax), 1, 0) if debug: plt.figure() plt.plot(bins, hist) plt.hold(True) plt.plot(bins[max_peakIdx], hist[max_peakIdx], 'ro') plt.plot(bins[histTIdxs], hist[histTIdxs], 'r') plt.plot(bins[histTIdxs[0]], hist[histTIdxs[0]], 'rx') plt.plot(bins[histTIdxs[-1]], hist[histTIdxs[-1]], 'rx') plt.title('Histogram of liver density and its class1 = maximal peak (red dot) +-5% of its density (red line).') plt.show() return class1
def test_all_negative_image(): im = np.array([-128, -1], dtype=np.int8) frequencies, bin_centers = exposure.histogram(im) assert_array_equal(bin_centers, np.arange(-128, 0)) assert frequencies[0] == 1 assert frequencies[-1] == 1 assert_array_equal(frequencies[1:-1], 0)
def testSkimage2(): img = Image.open('../img/1.png') # img = Image.open('../img/2.png') img = np.array(img) imggray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # (thresh, imgbw) = cv2.threshold(imggray, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU) camera = imggray # camera = data.camera() val = filters.threshold_otsu(camera) hist, bins_center = exposure.histogram(camera) plt.figure(figsize=(9, 4)) plt.subplot(131) plt.imshow(camera, cmap='gray', interpolation='nearest') plt.axis('off') plt.subplot(132) plt.imshow(camera < val, cmap='gray', interpolation='nearest') plt.axis('off') plt.subplot(133) plt.plot(bins_center, hist, lw=2) plt.axvline(val, color='k', ls='--') plt.tight_layout() plt.show() return
def histogram(image): # Iterate throught a.) Colors, b.) Channels to create lines for color, channel in zip('rgb', np.rollaxis(image, axis=-1)): counts, bin_centers = exposure.histogram(channel) a = plt.fill_between(bin_centers, counts, color=color, alpha=0.4) return a;
def test_peak_int_range_dtype(): im = np.array([10, 100], dtype=np.int8) frequencies, bin_centers = exposure.histogram(im, source_range='dtype') assert_array_equal(bin_centers, np.arange(-128, 128)) assert_equal(frequencies[128+10], 1) assert_equal(frequencies[128+100], 1) assert_equal(frequencies[128+101], 0) assert_equal(frequencies.shape, (256,))
def estimate_healthy_pdf(self, data, mask, params): perc = params['perc'] k_std_l = params['k_std_h'] simple_estim = params['healthy_simple_estim'] show_me = params['show_healthy_pdf_estim'] # data = tools.smoothing_tv(data.astype(np.uint8), tv_weight) ints = data[np.nonzero(mask)] hist, bins = skiexp.histogram(ints, nbins=256) if simple_estim: mu, sigma = scista.norm.fit(ints) else: ints = data[np.nonzero(mask)] n_pts = mask.sum() perc_in = n_pts * perc / 100 peak_idx = np.argmax(hist) n_in = hist[peak_idx] win_width = 0 while n_in < perc_in: win_width += 1 n_in = hist[peak_idx - win_width:peak_idx + win_width].sum() idx_start = bins[peak_idx - win_width] idx_end = bins[peak_idx + win_width] inners_m = np.logical_and(ints > idx_start, ints < idx_end) inners = ints[np.nonzero(inners_m)] # liver pdf ------------- mu = bins[peak_idx] + params['hack_healthy_mu'] sigma = k_std_l * np.std(inners) + params['hack_healthy_sigma'] mu = int(mu) sigma = int(sigma) rv = scista.norm(mu, sigma) if show_me: plt.figure() plt.subplot(211) plt.plot(bins, hist) plt.title('histogram with max peak') plt.hold(True) plt.plot([mu, mu], [0, hist.max()], 'g') ax = plt.axis() plt.axis([0, 256, ax[2], ax[3]]) # plt.subplot(212), plt.plot(bins, rv_l.pdf(bins), 'g') x = np.arange(0, 256, 0.1) plt.subplot(212), plt.plot(x, rv.pdf(x), 'g') plt.hold(True) plt.plot(mu, rv.pdf(mu), 'go') ax = plt.axis() plt.axis([0, 256, ax[2], ax[3]]) plt.title('estimated normal pdf of healthy parenchym') # plt.show() return rv
def features_extractor(trimmed): from color_quantinization import quantinization image_gray = quantinization(trimmed) # image_gray = color.rgb2hsv(image_gray) featuresh = [] hh = exposure.histogram(image_gray[:, :, 0]) featuresh.extend(hh[0]) hs = exposure.histogram(image_gray[:, :, 1]) featuresh.extend(hs[0]) hv = exposure.histogram(image_gray[:, :, 2]) featuresh.extend(hv[0]) return featuresh
def test_dask_histogram(): pytest.importorskip('dask', reason="dask python library is not installed") import dask.array as da dask_array = da.from_array(np.array([[0, 1], [1, 2]]), chunks=(1, 2)) output_hist, output_bins = exposure.histogram(dask_array) expected_bins = [0, 1, 2] expected_hist = [1, 2, 1] assert np.allclose(expected_bins, output_bins) assert np.allclose(expected_hist, output_hist)
def open_image(self): ''' Open the image given the path''' img = imread(self.path) counts,grays = histogram(img, nbins = 256) #img = (img-0)/(255 -0) return img,counts,grays
def cal_edge_curvature(binary, contours, cbins=15): contours = contours[0] height = binary.shape[0] width = binary.shape[1] mask = np.zeros((height, width), dtype=np.uint8) radius = 20 rr, cc = draw.circle(height // 2, width // 2, radius) mask[rr, cc] = 1 S = np.count_nonzero(mask) def count_with_edge(dot): r, c = dot mask = np.zeros((height, width), dtype=np.uint8) rr, cc = draw.circle(r, c, radius) # min_r = np.where(rr >= 0)[0][0] # min_c = np.where(cc >= 0)[0][0] # min_i = max(min_r, min_c) # print(r, c) # print(height, width) # print(rr) # print(cc) # max_r = np.where(rr < height)[0][-1] # max_c = np.where(cc < width)[0][-1] # max_i = min(max_r, max_c) # # print(width, height) # # print(rr.shape) # # print(cc.shape) # # print(rr[min_i: max_i]) # # print(cc[min_i: max_i]) # rr = rr[min_i: max_i] # cc = cc[min_i: max_i] # print(rr) # print(cc) for _r, _c in zip(rr, cc): if 0 <= _r < height and 0 <= _c < width: mask[_r, _c] = 1 # mask[rr, cc] = 1 binary_for_cal = np.where(mask == 1, binary, False) return np.count_nonzero(binary_for_cal) I = np.array([count_with_edge(contour) for contour in contours]) c = I / S c_hist = exposure.histogram(c, nbins=cbins) return c_hist
def preprocImage(fimg): nbin=64 img=io.imread(fimg,as_grey=True) siz=img.shape msk=np.zeros(siz, np.uint8) rr,cc=draw.circle(siz[1]/2, siz[0]/2, (np.min(siz)/2)-3) msk[rr,cc]=1 thresh=threshold_otsu(img[msk==1]) msk1=msk&(img<=thresh) msk2=msk&(img>thresh) ret1=exposure.histogram(img[msk1==1],nbins=nbin) ret2=exposure.histogram(img[msk2==1],nbins=nbin) var1=0*np.std(img[msk1==1]) max1=-var1+ret1[1][np.argmax(ret1[0])] max2=ret2[1][np.argmax(ret2[0])] ret=(0.8*(img-max1)/(max2-max1)) ret[ret<0]=0 ret[ret>1]=1 # print np.min(ret), " * " , np.max(ret) return np.uint8(255*ret)
def __init__(self, image_window): with utils.toolbar_off(): figure = plt.figure(figsize=(6.5, 2)) ax_hist = plt.subplot2grid((6, 1), (0, 0), rowspan=4) ax_low = plt.subplot2grid((6, 1), (4, 0), rowspan=1) ax_high = plt.subplot2grid((6, 1), (5, 0), rowspan=1) self.ax_hist = ax_hist Plugin.__init__(self, image_window, figure=figure) hmin, hmax = dtype_range[self.image.dtype.type] if hmax > 255: bins = int(hmax - hmin) else: bins = 256 self.hist, self.bin_centers = histogram(self.image.data, bins) self.cmin = self.bin_centers[0] self.cmax = self.bin_centers[-1] # draw marker lines before histogram so they're behind histogram self.low_marker = self.ax_hist.axvline(self.cmin, color='w') self.high_marker = self.ax_hist.axvline(self.cmax, color='k') ax_hist.step(self.bin_centers, self.hist, color='r', lw=2, alpha=1.) self.ax_hist.set_xlim(self.cmin, self.cmax) self.ax_hist.set_xticks([]) self.ax_hist.set_yticks([]) slider_range = self.cmin, self.cmax self.slider_high = Slider(ax_high, slider_range, label='Max', value=self.cmax, on_release=self.update_image) self.slider_low = Slider(ax_low, slider_range, label='Min', value=self.cmin, on_release=self.update_image) self.slider_low.slidermax = self.slider_high self.slider_high.slidermin = self.slider_low # initialize histogram background imshow = self.ax_hist.imshow xmin, xmax, ymin, ymax = self.ax_hist.axis() self.black_bg = imshow(zeros((1, 2)), aspect='auto', extent=(xmin, self.cmin, ymin, ymax)) self.white_bg = imshow(ones((1, 2)), aspect='auto', vmin=0, vmax=1, extent=(self.cmax, xmax, ymin, ymax)) gradient = linspace(self.cmin, self.cmax, 256).reshape((1, 256)) self.grad_bg = imshow(gradient, aspect='auto', extent=(self.cmin, self.cmax, ymin, ymax)) self.connect_event('key_press_event', self.on_key_press) self.connect_event('scroll_event', self.on_scroll) self.original_image = self.imgview.image.copy() self.update_image() print self.help
def test_loadImage(): import matplotlib.pyplot as plt resistor_path = HAND_DRAWN_DIR + 'resistor1.jpg' img = Data.loadImage(resistor_path, square=True) print img plt.imshow(img, cmap='gray') plt.title("Should be Square") plt.show() hist, bins = exposure.histogram(img) plt.plot(bins, hist) plt.show()
def get_histogram(image, channel, bins=None): """ Calculate histogram and bins for an image based on specification of Red, Green, Blue or Greyscale :params image: image for calculating histogram :params channel: 0 = Red, 1 = Green, 2 = Blue, 3 = Greyscale :return: array of bin counts, array of bins """ if channel == 3: return expoure.histogram(image) else: return exposure.histogram(image[:, :, channel])
def threshAUHist( imgIn, avg, sd ): pxCnt, gL = exposure.histogram( imgIn ) auh = 0 gli = 0 #index into pxCnt and gL while( auh < avg + sd ): auh += pxCnt[gli] gli += 1 t = gL[gli-1] imgOut = imgProc.applyThresh( imgIn, t ) return imgOut
def test_loadTrainTest(): import matplotlib.pyplot as plt trX, teX, trY, teY = Data.loadTrainTest(0.8, RAND_ECOMPS_DIR) img = teX[0].reshape((100, 100)) print img img_label = "resistor" if teY[0, 0] == 1 else "capacitor" plt.imshow(img, cmap='gray') plt.title("Should be %s" % img_label) plt.show() hist, bins = exposure.histogram(img) plt.plot(bins, hist) plt.show()
def mean_exposure_hist(nbins, *images): """ calculates mean histogram of many exposure histograms args: nbins: number of bins *args: must be images (ndarrays) i.e r1, r2 returns: histogram capturing pixel intensities """ hists = [] for img in images: hist, _ = exposure.histogram(img, nbins) hists.append(hist) return np.sum(hists, axis=0) / len(images)
def loadImage(filename): scaler = 15 image = misc.imread(filename) h = [] for channel in range(3): tmp = image.astype(np.float64) h.append(exposure.histogram(tmp[:,:,channel], nbins=10)[0]) image = transform.resize(image, (int(scaler*2.56), int(scaler*1.53))) # small image 256px x 153px, largeimage 2592px 1552px image = image.flatten() h = np.array(h) h = h.flatten() return np.hstack((image, h))
def showHist(img): # An "interface" to matplotlib.axes.Axes.hist() method plt.figure() imgHist = histogram(img, nbins=256) bar(imgHist[1].astype(np.uint8), imgHist[0], width=0.8, align='center')
def test_threshold_minimum_histogram(): camera = util.img_as_ubyte(data.camera()) hist = histogram(camera.ravel(), 256, source_range='image') threshold = threshold_minimum(hist=hist) assert_equal(threshold, 85)
def build_histogram_file(in_image, dest, hist_type: HistogramType, overwrite: bool = False): """ Build an histogram for an image and save it as zarr file. Parameters ---------- in_image : Image The image from which histogram has to be extracted. dest : Path The path where the histogram file will be saved. hist_type : HistogramType The type of histogram to build (FAST or COMPLETE) overwrite : bool (default: False) Whether overwrite existing histogram file at `dest` if any Returns ------- histogram : Histogram The zarr histogram file in read-only mode """ n_values = 2**min(in_image.significant_bits, 16) if in_image.n_pixels <= MAX_PIXELS_COMPLETE_HISTOGRAM: extract_fn = _extract_np_thumb hist_type = HistogramType.COMPLETE else: if hist_type == HistogramType.FAST: extract_fn = _extract_np_thumb else: extract_fn = in_image.tile raise NotImplementedError() # TODO if not overwrite and dest.exists(): raise FileExistsError(dest) # While the file is not fully built, we save it at a temporary location tmp_dest = dest.parent / Path(f"tmp_{dest.name}") zroot = zarr.open_group(str(tmp_dest), mode='w') zroot.attrs[ZHF_ATTR_TYPE] = hist_type zroot.attrs[ZHF_ATTR_FORMAT] = "PIMS-1.0" # Create the group for plane histogram # TODO: usa Dask to manipulate Zarr arrays (for bounds) # so that we can fill the zarr array incrementally # https://github.com/zarr-developers/zarr-python/issues/446 shape = (in_image.duration, in_image.depth, in_image.n_channels) zplane = zroot.create_group(ZHF_PER_PLANE) npplane_hist = np.zeros(shape=shape + (n_values, ), dtype=np.uint64) for data, c_range, z, t, ratio in extract_fn(in_image): for read, c in enumerate(c_range): h, _ = histogram(data[:, :, read], source_range='dtype') npplane_hist[t, z, c, :] += np.rint(h * ratio).astype(np.uint64) zplane.array(ZHF_HIST, npplane_hist) zplane.array( ZHF_BOUNDS, np.stack((argmin_nonzero(npplane_hist), argmax_nonzero(npplane_hist)), axis=-1)) # Create the group for channel histogram zchannel = zroot.create_group(ZHF_PER_CHANNEL) npchannel_hist = np.sum(npplane_hist, axis=(0, 1)) zchannel.array(ZHF_HIST, npchannel_hist) zchannel.array( ZHF_BOUNDS, np.stack( (argmin_nonzero(npchannel_hist), argmax_nonzero(npchannel_hist)), axis=-1)) # Create the group for image histogram zimage = zroot.create_group(ZHF_PER_IMAGE) npimage_hist = np.sum(npchannel_hist, axis=0) zimage.array(ZHF_HIST, npimage_hist) zimage.array(ZHF_BOUNDS, [argmin_nonzero(npimage_hist), argmax_nonzero(npimage_hist)]) # Remove redundant data if in_image.duration == 1 and in_image.depth == 1: del zroot[ZHF_PER_PLANE] if in_image.n_channels == 1: del zroot[ZHF_PER_CHANNEL] # Move the zarr file (directory) to final location if overwrite and dest.exists(): shutil.rmtree(dest) tmp_dest.replace(dest) return Histogram(dest, format=ZarrHistogramFormat)
def threshold_otsu(image, nbins=256): """Return threshold value based on Otsu's method. Parameters ---------- image : (N, M) ndarray Grayscale input image. nbins : int, optional Number of bins used to calculate histogram. This value is ignored for integer arrays. Returns ------- threshold : float Upper threshold value. All pixels with an intensity higher than this value are assumed to be foreground. Raises ------ ValueError If `image` only contains a single grayscale value. References ---------- .. [1] Wikipedia, http://en.wikipedia.org/wiki/Otsu's_Method Examples -------- >>> from skimage.data import camera >>> image = camera() >>> thresh = threshold_otsu(image) >>> binary = image <= thresh Notes ----- The input image must be grayscale. """ if len(image.shape) > 2 and image.shape[-1] in (3, 4): msg = "threshold_otsu is expected to work correctly only for " \ "grayscale images; image shape {0} looks like an RGB image" warn(msg.format(image.shape)) # Check if the image is multi-colored or not if image.min() == image.max(): raise ValueError("threshold_otsu is expected to work with images " "having more than one color. The input image seems " "to have just one color {0}.".format(image.min())) image = np.asarray([x for x in image.ravel() if x != 255]) image = np.asarray([x for x in image.ravel() if x != 0]) print(image.ravel()) hist, bin_centers = histogram(image.ravel(), nbins) hist = hist.astype(float) # class probabilities for all possible thresholds weight1 = np.cumsum(hist) weight2 = np.cumsum(hist[::-1])[::-1] # class means for all possible thresholds mean1 = np.cumsum(hist * bin_centers) / weight1 mean2 = (np.cumsum((hist * bin_centers)[::-1]) / weight2[::-1])[::-1] # Clip ends to align class 1 and class 2 variables: # The last value of `weight1`/`mean1` should pair with zero values in # `weight2`/`mean2`, which do not exist. variance12 = weight1[:-1] * weight2[1:] * (mean1[:-1] - mean2[1:])**2 idx = np.argmax(variance12) threshold = bin_centers[:-1][idx] #threshold = 150 return threshold
def test_yen_camera_image_counts(): camera = util.img_as_ubyte(data.camera()) counts, bin_centers = histogram(camera.ravel(), 256, source_range='image') assert 145 < threshold_yen(hist=counts) < 147
def test_isodata_camera_image_histogram(): camera = util.img_as_ubyte(data.camera()) hist = histogram(camera.ravel(), 256, source_range='image') threshold = threshold_isodata(hist=hist) assert threshold == 102
def test_int_range_image(): im = np.array([10, 100], dtype=np.int8) frequencies, bin_centers = exposure.histogram(im) assert_equal(len(bin_centers), len(frequencies)) assert_equal(bin_centers[0], 10) assert_equal(bin_centers[-1], 100)
def HistCues_img(greyimg, area): hist5 = exposure.histogram(greyimg, nbins=5)[0] / area hist3 = exposure.histogram(greyimg, nbins=3)[0] / area return hist5, hist3
def test_wrong_source_range(): im = np.array([-1, 100], dtype=np.int8) with testing.raises(ValueError): frequencies, bin_centers = exposure.histogram(im, source_range='foobar')
def time_histogram(self): # Running it 10 times to achieve significant performance time. for i in range(10): result = exposure.histogram(self.image)
def threshold_isodata(image, nbins=256): """Return threshold value based on ISODATA method. Histogram-based threshold, known as Ridler-Calvard method or intermeans. Parameters ---------- image : array Input image. nbins : int, optional Number of bins used to calculate histogram. This value is ignored for integer arrays. Returns ------- threshold : float or int, corresponding input array dtype. Upper threshold value. All pixels intensities that less or equal of this value assumed as background. References ---------- .. [1] Ridler, TW & Calvard, S (1978), "Picture thresholding using an iterative selection method" .. [2] IEEE Transactions on Systems, Man and Cybernetics 8: 630-632, http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=4310039 .. [3] Sezgin M. and Sankur B. (2004) "Survey over Image Thresholding Techniques and Quantitative Performance Evaluation" Journal of Electronic Imaging, 13(1): 146-165, http://www.busim.ee.boun.edu.tr/~sankur/SankurFolder/Threshold_survey.pdf .. [4] ImageJ AutoThresholder code, http://fiji.sc/wiki/index.php/Auto_Threshold Examples -------- >>> from skimage.data import coins >>> image = coins() >>> thresh = threshold_isodata(image) >>> binary = image > thresh """ hist, bin_centers = histogram(image, nbins) # On blank images (e.g. filled with 0) with int dtype, `histogram()` # returns `bin_centers` containing only one value. Speed up with it. if bin_centers.size == 1: return bin_centers[0] # It is not necessary to calculate the probability mass function here, # because the l and h fractions already include the normalization. pmf = hist.astype(np.float32) # / hist.sum() cpmfl = np.cumsum(pmf, dtype=np.float32) cpmfh = np.cumsum(pmf[::-1], dtype=np.float32)[::-1] binnums = np.arange(pmf.size, dtype=np.uint8) # l and h contain average value of pixels in sum of bins, calculated # from lower to higher and from higher to lower respectively. l = np.ma.divide(np.cumsum(pmf * binnums, dtype=np.float32), cpmfl) h = np.ma.divide( np.cumsum((pmf[::-1] * binnums[::-1]), dtype=np.float32)[::-1], cpmfh) allmean = (l + h) / 2.0 threshold = bin_centers[np.nonzero(allmean.round() == binnums)[0][0]] # This implementation returns threshold where # `background <= threshold < foreground`. return threshold
def findfeatures_training(filename, ploton): # type: (basestring, bool) -> list img = io.imread(filename) fileletter = filename[0] if ploton: print img.shape io.imshow(img) plt.title('Original Image') io.show() hist = exposure.histogram(img) plt.bar(hist[1], hist[0]) plt.title('Histogram') plt.show() th = threshold_otsu(img) img_binary = (img < th).astype(np.double) if ploton: print th io.imshow(img_binary) plt.title('Binary Image') io.show() selem = square(1) dilated_img_binary = dilation(img_binary, selem) if ploton: io.imshow(dilated_img_binary) plt.title('closed') io.show() img_label = label(dilated_img_binary, background=0) if ploton: io.imshow(img_label) plt.title('Labeled Image') io.show() print np.amax(img_label) regions = regionprops(img_label) ax = plt.gca() if ploton: io.imshow(dilated_img_binary) plt.title('Bounding boxes') features = [] count = 0 for props in regions: minr, minc, maxr, maxc = props.bbox if maxc - minc > 9 and maxr - minr > 9: count += 1 ax.add_patch( Rectangle((minc, minr), maxc - minc, maxr - minr, fill=False, edgecolor='red', linewidth=1)) roi = dilated_img_binary[minr:maxr, minc:maxc] m = moments(roi) cr = m[0, 1] / m[0, 0] cc = m[1, 0] / m[0, 0] mu = moments_central(roi, cr, cc) nu = moments_normalized(mu) hu = moments_hu(nu) features.append(hu) letters.append(fileletter) if ploton: print count io.show() return features
def test_isodata_camera_image_counts(): camera = util.img_as_ubyte(data.camera()) counts, bin_centers = histogram(camera.ravel(), 256, source_range='image') threshold = threshold_isodata(hist=counts) assert threshold == 102
def test_threshold_minimum_deprecated_max_iter_kwarg(): camera = util.img_as_ubyte(data.camera()) hist = histogram(camera.ravel(), 256, source_range='image') with expected_warnings(["`max_iter` is a deprecated argument"]): threshold_minimum(hist=hist, max_iter=5000)
import numpy as np import matplotlib.pyplot as plt from skimage.color import label2rgb from skimage.exposure import histogram from skimage.io import imread from skimage import morphology from skimage.filters import sobel from scipy import ndimage as ndi coins = imread('Cap403.bmp', as_gray=True) hist, hist_centers = histogram(coins) fig, axes = plt.subplots(1, 2, figsize=(8, 3)) axes[0].imshow(coins, cmap=plt.cm.gray, interpolation='nearest') # axes[0].axis('off') axes[1].plot(hist_centers, hist, lw=2) axes[1].set_title('histogram of gray values') # Region-based segmentation # ========================= # # We therefore try a region-based method using the watershed transform. # First, we find an elevation map using the Sobel gradient of the image. elevation_map = sobel(coins) fig, ax = plt.subplots(figsize=(4, 3)) ax.imshow(elevation_map, cmap=plt.cm.gray, interpolation='nearest') ax.set_title('elevation map') ax.axis('off') ######################################################################
labels[i, j] = 1 else: () return labels plt.close('all') # Close all remaining figures fileList = os.listdir(os.getcwd() + '/move1-polar/') i = 1 # Try to get a pattern from histograms for filename in fileList: try: if filename[0] == 'D': im = io.imread('move1-polar/' + filename) im = img_as_ubyte(im) hist, bins = exposure.histogram(im) m = 1. / np.max(bins) bins = m * bins #plt.plot(bins, hist) labels = thresholding(im, 0.2, 0.3) plt.imshow(labels) plt.savefig('misc2/' + filename) except IOError: print( filename + ' : Not a file or not an image (IOError). This file will be skipped.' )
def get_down_up(img, thrs=(0.7, 1.0)): hist = exposure.histogram(img)[0] histmax = np.argmax(hist) down = histmax * thrs[0] up = histmax * thrs[1] return down, up
linear and non-linear filters available in skimage. We use the ``camera`` image from ``skimage.data`` for all comparisons. .. [1] Pierre Soille, On morphological operators based on rank filters, Pattern Recognition 35 (2002) 527-535, :DOI:`10.1016/S0031-3203(01)00047-4` """ import numpy as np import matplotlib.pyplot as plt from skimage.util import img_as_ubyte from skimage import data from skimage.exposure import histogram noisy_image = img_as_ubyte(data.camera()) hist, hist_centers = histogram(noisy_image) fig, ax = plt.subplots(ncols=2, figsize=(10, 5)) ax[0].imshow(noisy_image, cmap=plt.cm.gray) ax[0].axis('off') ax[1].plot(hist_centers, hist, lw=2) ax[1].set_title('Histogram of grey values') plt.tight_layout() ###################################################################### # # Noise removal # =============
from skimage.color import rgb2gray from skimage.exposure import histogram from matplotlib.pyplot import imread def cum_hist(histogram): """Takes a histogram of length 256 with integer values as input and returns the cumulative histogram represented as an array from 0 to 255 with elements normalized from 0 to 1""" cum_his = np.cumsum(histogram) total = sum(histogram) normalized = cum_his / total return np.round(normalized, 8) def fix_bins(histogram_as_pair): (counts, bins) = histogram_as_pair result = [0 for i in range(256)] for i in range(min(bins), max(bins) + 1): result[i] = counts[i - min(bins)] return result im1= imread("Images/pout.tif") im2= rgb2gray(imread("Images/movie_flicker1.tif")) from skimage.exposure import histogram h1 = histogram(im1) h2 = histogram(im2) fix = fix_bins(h1) result = cum_hist(fix)
def threshold_minimum(image, nbins=256, bias='min', max_iter=10000): """Return threshold value based on minimum method. The histogram of the input `image` is computed and smoothed until there are only two maxima. Then the minimum in between is the threshold value. Parameters ---------- image : (M, N) ndarray Input image. nbins : int, optional Number of bins used to calculate histogram. This value is ignored for integer arrays. bias : {'min', 'mid', 'max'}, optional 'min', 'mid', 'max' return lowest, middle, or highest pixel value with minimum histogram value. max_iter: int, optional Maximum number of iterations to smooth the histogram. Returns ------- threshold : float Upper threshold value. All pixels with an intensity higher than this value are assumed to be foreground. Raises ------ RuntimeError If unable to find two local maxima in the histogram or if the smoothing takes more than 1e4 iterations. References ---------- .. [1] Prewitt, JMS & Mendelsohn, ML (1966), "The analysis of cell images", Annals of the New York Academy of Sciences 128: 1035-1053 DOI:10.1111/j.1749-6632.1965.tb11715.x Examples -------- >>> from skimage.data import camera >>> image = camera() >>> thresh = threshold_minimum(image) >>> binary = image > thresh """ def find_local_maxima(hist): # We can't use scipy.signal.argrelmax # as it fails on plateaus maximums = list() direction = 1 for i in range(hist.shape[0] - 1): if direction > 0: if hist[i + 1] < hist[i]: direction = -1 maximums.append(i) else: if hist[i + 1] > hist[i]: direction = 1 return maximums if bias not in ('min', 'mid', 'max'): raise ValueError("Unknown bias: {0}".format(bias)) hist, bin_centers = histogram(image.ravel(), nbins) smooth_hist = np.copy(hist) for counter in range(max_iter): smooth_hist = ndif.uniform_filter1d(smooth_hist, 3) maximums = find_local_maxima(smooth_hist) if len(maximums) < 3: break if len(maximums) != 2: raise RuntimeError('Unable to find two maxima in histogram') elif counter == max_iter - 1: raise RuntimeError('Maximum iteration reached for histogram' 'smoothing') # Find lowest point between the maxima, biased to the low end (min) minimum = smooth_hist[maximums[0]] threshold = maximums[0] for i in range(maximums[0], maximums[1] + 1): if smooth_hist[i] < minimum: minimum = smooth_hist[i] threshold = i if bias == 'min': return bin_centers[threshold] else: upper_bound = threshold while smooth_hist[upper_bound] == smooth_hist[threshold]: upper_bound += 1 upper_bound -= 1 if bias == 'max': return bin_centers[upper_bound] elif bias == 'mid': return bin_centers[(threshold + upper_bound) // 2]
def test_yen_camera_image_histogram(): camera = util.img_as_ubyte(data.camera()) hist = histogram(camera.ravel(), 256, source_range='image') assert 145 < threshold_yen(hist=hist) < 147
def threshold_isodata(image, nbins=256, return_all=False): """Return threshold value(s) based on ISODATA method. Histogram-based threshold, known as Ridler-Calvard method or inter-means. Threshold values returned satisfy the following equality: `threshold = (image[image <= threshold].mean() +` `image[image > threshold].mean()) / 2.0` That is, returned thresholds are intensities that separate the image into two groups of pixels, where the threshold intensity is midway between the mean intensities of these groups. For integer images, the above equality holds to within one; for floating- point images, the equality holds to within the histogram bin-width. Parameters ---------- image : (N, M) ndarray Input image. nbins : int, optional Number of bins used to calculate histogram. This value is ignored for integer arrays. return_all: bool, optional If False (default), return only the lowest threshold that satisfies the above equality. If True, return all valid thresholds. Returns ------- threshold : float or int or array Threshold value(s). References ---------- .. [1] Ridler, TW & Calvard, S (1978), "Picture thresholding using an iterative selection method" IEEE Transactions on Systems, Man and Cybernetics 8: 630-632, DOI:10.1109/TSMC.1978.4310039 .. [2] Sezgin M. and Sankur B. (2004) "Survey over Image Thresholding Techniques and Quantitative Performance Evaluation" Journal of Electronic Imaging, 13(1): 146-165, http://www.busim.ee.boun.edu.tr/~sankur/SankurFolder/Threshold_survey.pdf DOI:10.1117/1.1631315 .. [3] ImageJ AutoThresholder code, http://fiji.sc/wiki/index.php/Auto_Threshold Examples -------- >>> from skimage.data import coins >>> image = coins() >>> thresh = threshold_isodata(image) >>> binary = image > thresh """ hist, bin_centers = histogram(image.ravel(), nbins) # image only contains one unique value if len(bin_centers) == 1: if return_all: return bin_centers else: return bin_centers[0] hist = hist.astype(np.float32) # csuml and csumh contain the count of pixels in that bin or lower, and # in all bins strictly higher than that bin, respectively csuml = np.cumsum(hist) csumh = np.cumsum(hist[::-1])[::-1] - hist # intensity_sum contains the total pixel intensity from each bin intensity_sum = hist * bin_centers # l and h contain average value of all pixels in that bin or lower, and # in all bins strictly higher than that bin, respectively. # Note that since exp.histogram does not include empty bins at the low or # high end of the range, csuml and csumh are strictly > 0, except in the # last bin of csumh, which is zero by construction. # So no worries about division by zero in the following lines, except # for the last bin, but we can ignore that because no valid threshold # can be in the top bin. So we just patch up csumh[-1] to not cause 0/0 # errors. csumh[-1] = 1 l = np.cumsum(intensity_sum) / csuml h = (np.cumsum(intensity_sum[::-1])[::-1] - intensity_sum) / csumh # isodata finds threshold values that meet the criterion t = (l + m)/2 # where l is the mean of all pixels <= t and h is the mean of all pixels # > t, as calculated above. So we are looking for places where # (l + m) / 2 equals the intensity value for which those l and m figures # were calculated -- which is, of course, the histogram bin centers. # We only require this equality to be within the precision of the bin # width, of course. all_mean = (l + h) / 2.0 bin_width = bin_centers[1] - bin_centers[0] # Look only at thresholds that are below the actual all_mean value, # for consistency with the threshold being included in the lower pixel # group. Otherwise can get thresholds that are not actually fixed-points # of the isodata algorithm. For float images, this matters less, since # there really can't be any guarantees anymore anyway. distances = all_mean - bin_centers thresholds = bin_centers[(distances >= 0) & (distances < bin_width)] if return_all: return thresholds else: return thresholds[0]
def test_flat_int_range_dtype(): im = np.linspace(-128, 128, 256, dtype=np.int8) frequencies, bin_centers = exposure.histogram(im, source_range='dtype') assert_array_equal(bin_centers, np.arange(-128, 128)) assert_equal(frequencies.shape, (256, ))
def test_threshold_minimum_counts(): camera = util.img_as_ubyte(data.camera()) counts, bin_centers = histogram(camera.ravel(), 256, source_range='image') threshold = threshold_minimum(hist=counts) assert_equal(threshold, 85)
# variance between the two segmented groups of pixels. Therefore, it is can be # interpreted as a **clustering** algorithm. Samples are pixels and have a # single feature, which is their grayscale value. # <codecell> from skimage import data, exposure, filters camera = data.camera() # <codecell> hi = exposure.histogram(camera) # <codecell> val = filters.threshold_otsu(camera) # <codecell> fig, axes = plt.subplots(1, 2) axes[0].imshow(camera, cmap='gray') axes[0].contour(camera, [val], colors='y') axes[1].plot(hi[1], hi[0])
def test_peak_float_out_of_range_image(): im = np.array([10, 100], dtype=np.float16) frequencies, bin_centers = exposure.histogram(im, nbins=90) # offset values by 0.5 for float... assert_array_equal(bin_centers, np.arange(10, 100) + 0.5)
from skimage import data, exposure, img_as_float, img_as_ubyte import matplotlib.pyplot as plt image = img_as_float(data.camera()) image_uint8 = img_as_ubyte(data.camera()) hi = exposure.histogram(image_uint8) cdf = exposure.cumulative_distribution(image_uint8) plt.figure(1) plt.subplot(1, 2, 1) plt.imshow(image_uint8, cmap='gray') plt.title('Sample Image') plt.subplot(1, 2, 2) plt.bar(hi[1], hi[0]) plt.hold(True) plt.plot(cdf[1], cdf[0] * 6400, 'r') plt.hold(False) plt.title('Histogram and CDF') plt.xlabel('Pixel Intensity') plt.show()
def histo(img, bins): return exposure.histogram(img, nbins=bins)
def threshold_triangle(image, nbins=256): """Return threshold value based on the triangle algorithm. Parameters ---------- image : (N, M[, ..., P]) ndarray Grayscale input image. nbins : int, optional Number of bins used to calculate histogram. This value is ignored for integer arrays. Returns ------- threshold : float Upper threshold value. All pixels with an intensity higher than this value are assumed to be foreground. References ---------- .. [1] Zack, G. W., Rogers, W. E. and Latt, S. A., 1977, Automatic Measurement of Sister Chromatid Exchange Frequency, Journal of Histochemistry and Cytochemistry 25 (7), pp. 741-753 DOI:10.1177/25.7.70454 .. [2] ImageJ AutoThresholder code, http://fiji.sc/wiki/index.php/Auto_Threshold Examples -------- >>> from skimage.data import camera >>> image = camera() >>> thresh = threshold_triangle(image) >>> binary = image > thresh """ # nbins is ignored for integer arrays # so, we recalculate the effective nbins. hist, bin_centers = histogram(image.ravel(), nbins) nbins = len(hist) # Find peak, lowest and highest gray levels. arg_peak_height = np.argmax(hist) peak_height = hist[arg_peak_height] arg_low_level, arg_high_level = np.where(hist > 0)[0][[0, -1]] # Flip is True if left tail is shorter. flip = arg_peak_height - arg_low_level < arg_high_level - arg_peak_height if flip: hist = hist[::-1] arg_low_level = nbins - arg_high_level - 1 arg_peak_height = nbins - arg_peak_height - 1 # If flip == True, arg_high_level becomes incorrect # but we don't need it anymore. del (arg_high_level) # Set up the coordinate system. width = arg_peak_height - arg_low_level x1 = np.arange(width) y1 = hist[x1 + arg_low_level] # Normalize. norm = np.sqrt(peak_height**2 + width**2) peak_height /= norm width /= norm # Maximize the length. # The ImageJ implementation includes an additional constant when calculating # the length, but here we omit it as it does not affect the location of the # minimum. length = peak_height * x1 - width * y1 arg_level = np.argmax(length) + arg_low_level if flip: arg_level = nbins - arg_level - 1 return bin_centers[arg_level]
def vector_hist(image, nbins): vctr, b = exposure.histogram(img_as_float(image), nbins=nbins) out = vctr out = out / max(out) return out