def modify(img): """Randomly modify an image This is a preprocessing step for training an OCR classifier. It takes in an image and casts it to greyscale, reshapes it, and adds some (1) rotations, (2) translations and (3) noise. If more efficiency is needed, we could factor out some of the initial nonrandom transforms. """ block_size = np.random.uniform(20, 40) rotation = 5*np.random.randn() #print 'BLOCK SIZE', block_size #print 'ROTATION ', rotation img = color.rgb2grey(img) img = transform.resize(img, output_shape=(50,30)) img = filter.threshold_adaptive(img, block_size=block_size) # rotate the image img = np.logical_not(transform.rotate(np.logical_not(img), rotation)) # translate the image img = shift(img) # add some noise to the image img = noise(img) img = transform.resize(img, output_shape=(25,15)) return filter.threshold_adaptive(img, block_size=25)
def run_cmd(method, block_size=40): stdin = sys.stdin.read() if stdin == '\n': exit() img = Image.open(StringIO.StringIO(stdin)).convert('L') imgc = np.array(img) imggray = rgb2gray(imgc) if method is None or method == '': imgthresh = threshold_adaptive(imggray, block_size, 'gaussian', offset=10) elif method == 'gaussian': imgthresh = threshold_adaptive(imggray, block_size, 'gaussian', offset=10) elif method == 'median': imgthresh = threshold_adaptive(imggray, block_size, 'median', offset=10) elif method == 'mean': imgthresh = threshold_adaptive(imggray, block_size, 'mean', offset=10) elif method == 'otsu': thresh = threshold_otsu(imggray) imgthresh = imggray > thresh elif method == 'yen': thresh = threshold_yen(imggray) imgthresh = imggray > thresh elif method == 'iso': thresh = threshold_isodata(imggray) imgthresh = imggray > thresh rescaled = (255.0 / imgthresh.max() * (imgthresh - imgthresh.min())).astype(np.uint8) out = Image.fromarray(rescaled) out.save(sys.stdout, format='PNG')
def sino_remove_bragg_spots(sinogram, block_size=5, tolerance=0.05, sensitivity_low=1.5, sensitivity_high=0.2): """ If value is above some local threshold, replace by median. Removes dodgy highlights and shadows resulting from bragg peaks from large crystallites in diffracting orientations """ # Footprint for median value to replace bragg spots. # Usually the spots are contained to one projection, # so we sample above and below for good values. footprint = np.array( [[ False, True, False ], [ True, True, True ], [ False, False, False ], [ True, True, True ], [ False, True, False ]]) # Only consider pixels which differ from the local median by this offset. # Highlights and shadows will skew the arithmetic mean so use median. median_value = np.median(sinogram) offset_high = np.median(sinogram[sinogram>median_value]) offset_low = np.median(sinogram[sinogram<median_value]) utils.debug_print(median=median_value,offset_high=offset_high, offset_low=offset_low) mask_low = ~filters.threshold_adaptive( sinogram, block_size, method='median', offset=-sensitivity_low*(offset_low-median_value), ) mask_high = filters.threshold_adaptive( sinogram, block_size, method='median', offset=-sensitivity_high*(offset_high-median_value), ) if float(mask_high.sum()) > tolerance * mask_high.size: # Too many values marked as spots. Ignoring hilights. print('Found more than %s%% of values as hilights' % (tolerance * 100)) mask_high = np.zeros(shape=sinogram.shape, dtype=bool) if float(mask_low.sum()) > tolerance * mask_low.size: # Too many values marked as spots. Ignoring shadows. print('Found more than %s%% of values as shadows' % (tolerance * 100)) mask_low = np.zeros(shape=sinogram.shape, dtype=bool) mask = mask_low + mask_high # FIXME, only calculate values in mask. median = ndimage.median_filter(sinogram, footprint=footprint) ret = sinogram.copy() ret[mask==True] = median[mask==True] return ret
def segment(self, src): ''' pychron: preprocessing cv.Mat ''' # image = pychron.ndarray[:] # image = asarray(pychron) image = src[:] if self.use_adaptive_threshold: # block_size = 25 markers = threshold_adaptive(image, self.block_size) n = markers[:].astype('uint8') n[markers == True] = 255 n[markers == False] = 1 markers = n else: markers = zeros_like(image) markers[image < self.threshold_low] = 1 markers[image > self.threshold_high] = 255 elmap = sobel(image, mask=image) wsrc = watershed(elmap, markers, mask=image) # wsrc = wsrc.astype('uint8') return invert(wsrc)
def Adaptive_Thresholding(self): # read image im = cv2.imread(self.Image) gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (7, 7), 0) cv2.imshow("Image", im) # instead of manually specifying the threshold value, we can use adaptive # thresholding to examine neighborhoods of pixels and adaptively threshold # each neighborhood -- in this example, we'll calculate the mean value # of the neighborhood area of 25 pixels and threshold based on that value; # finally, our constant C is subtracted from the mean calculation (in this # case 15) thresh = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 25, 15) cv2.imshow("OpenCV Mean Thresh", thresh) # personally, I prefer the scikit-image adaptive thresholding, it just # feels a lot more "Pythonic" thresh = threshold_adaptive(blurred, 30, offset=5).astype("uint8") * 255 thresh = cv2.bitwise_not(thresh) cv2.imshow("scikit-image Mean Thresh", thresh) cv2.waitKey(0)
def intensity_object_features(im, adaptive_t_radius=51, sample_size=None): """Segment objects based on intensity threshold and compute properties. Parameters ---------- im : 2D np.ndarray of float or uint8. The input image. adaptive_t_radius : int, optional The radius to calculate background with adaptive threshold. sample_size : int, optional Sample this many objects randomly, rather than measuring all objects. Returns ------- f : 1D np.ndarray of float The feature vector. names : list of string The list of feature names. """ tim1 = im > imfilter.threshold_otsu(im) f1, names1 = object_features(tim1, im, sample_size=sample_size) names1 = ['otsu-threshold-' + name for name in names1] tim2 = imfilter.threshold_adaptive(im, adaptive_t_radius) f2, names2 = object_features(tim2, im, sample_size=sample_size) names2 = ['adaptive-threshold-' + name for name in names2] f = np.concatenate([f1, f2]) return f, names1 + names2
def segment(self, src): image = src.ndarray[:] if self.use_adaptive_threshold: block_size = 25 markers = threshold_adaptive(image, block_size) * 255 markers = invert(markers) else: markers = zeros_like(image) markers[image < self.threshold_low] = 1 markers[image > self.threshold_high] = 255 elmap = sobel(image, mask=image) wsrc = watershed(elmap, markers, mask=image) # elmap = ndimage.distance_transform_edt(image) # local_maxi = is_local_maximum(elmap, image, # ones((3, 3)) # ) # markers = ndimage.label(local_maxi)[0] # wsrc = watershed(-elmap, markers, mask=image) # fwsrc = ndimage.binary_fill_holes(out) # return wsrc if self.use_inverted_image: out = invert(wsrc) else: out = wsrc # time.sleep(1) # do_later(lambda:self.show_image(image, -elmap, out)) return out
def __call__(self, image, window_size=10, threshold=0, fill_holes=True, outline_smoothing=2, remove_borderobjects=True, size_min=1, *args, **kw): thresh = threshold_adaptive(image, block_size=window_size, offset=-1*threshold) if outline_smoothing >= 1: thresh = outlineSmoothing(thresh, outline_smoothing) thresh = remove_small_objects(thresh, size_min) seeds = ndi.label(clear_border(~thresh))[0] thresh = ndi.binary_fill_holes(thresh) smask = seeds.astype(bool) # object don't touch border after outline smoothing if remove_borderobjects: thresh = clear_border(thresh) img = np.zeros(thresh.shape) img[~smask] = 1 edt = ndi.morphology.distance_transform_edt(img) edt -= ndi.morphology.distance_transform_edt(seeds) labels = watershed(edt, seeds) labels[smask] = 0 labels[~thresh] = 0 return labels
def plot_preprocessed_image(self): """ plots pre-processed image. The plotted image is the same as obtained at the end of the get_text_candidates method. """ image = restoration.denoise_tv_chambolle(self.image, weight=0.1) thresh = filter.threshold_adaptive(image, 21) bw = closing(image > thresh, square(1)) cleared = bw.copy() label_image = measure.label(cleared) borders = np.logical_xor(bw, cleared) label_image[borders] = -1 image_label_overlay = label2rgb(label_image, image=image) fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(12, 12)) ax.imshow(image_label_overlay) for region in regionprops(label_image): if region.area < 10: continue minr, minc, maxr, maxc = region.bbox rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr, fill=False, edgecolor='red', linewidth=2) ax.add_patch(rect) plt.show()
def adapative_threshold(image, block_size=100): """ This method returns the adaptively-thresholded image. """ thresholded_image = threshold_adaptive(image, block_size) imshow(thresholded_image) return thresholded_image
def adaptive_segment(args): """ Applies an adaptive threshold to reconstructed data. Also known as local or dynamic thresholding where the threshold value is the weighted mean for the local neighborhood of a pixel subtracted by constant. Alternatively the threshold can be determined dynamically by a given function using the 'generic' method. Parameters ---------- data : ndarray, float32 3-D reconstructed data with dimensions: [slices, pixels, pixels] block_size : scalar, int Uneven size of pixel neighborhood which is used to calculate the threshold value (e.g. 3, 5, 7, ..., 21, ...). offset : scalar, float Constant subtracted from weighted mean of neighborhood to calculate the local threshold value. Default offset is 0. Returns ------- output : ndarray Thresholded data. References ---------- - `http://scikit-image.org/docs/dev/auto_examples/plot_threshold_adaptive.html \ <http://scikit-image.org/docs/dev/auto_examples/plot_threshold_adaptive.html>`_ """ # Arguments passed by multi-processing wrapper ind, dshape, inputs = args # Function inputs data = mp.tonumpyarray(mp.shared_arr, dshape) # shared-array block_size, offset = inputs for m in ind: img = data[m, :, :] # Perform scikit adaptive thresholding. img = threshold_adaptive(img, block_size=block_size, offset=offset) # Remove small white regions img = ndimage.binary_opening(img) # Remove small black holes img = ndimage.binary_closing(img) data[m, :, :] = img
def preprocess_image(self): """ Denoises and increases contrast. """ #image = restoration.denoise_tv_chambolle(self.image, weight=0.1) thresh = filter.threshold_adaptive(self.image, 21) self.bw = closing(self.image > thresh, square(2)) self.cleared = self.bw.copy() return self.cleared
def extract_bill(image, screen, ratio): """"Extract the bill of the image""" warped = four_point_transform(image, screen.reshape(4, 2) * ratio) # convert the warped image to grayscale, then threshold it # to give it that 'black and white' paper effect warped = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY) warped = threshold_adaptive(warped, 250, offset=10) warped = warped.astype("uint8") * 255 return warped
def image_features_hog2(img, num_features,orientation,maxcell,maxPixel): # X is the feature vector with one row of features per image # consisting of the pixel values a, num_featuresnd our metric block_size = 10 image = threshold_adaptive(img, block_size, offset=5) im = resize(image, (maxPixel, maxPixel)) ##hog scikit transform return image_features_hog_fd(im)
def scan(cls, filepath): print("Starting scan") # load the image and compute the ratio of the old height # to the new height, clone it, and resize it image = cv2.imread(filepath) ratio = image.shape[0] / 500.0 orig = image.copy() image = imutils.resize(image, height=500) # convert the image to grayscale, blur it, and find edges # in the image gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) gray = cv2.GaussianBlur(gray, (5, 5), 0) edged = cv2.Canny(gray, 75, 200) # find the contours in the edged image, keeping only the # largest ones, and initialize the screen contour cnts, hierarchy = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:5] screenCnt = None # loop over the contours for c in cnts: # approximate contours peri = cv2.arcLength(c, True) approx = cv2.approxPolyDP(c, 0.02 * peri, True) # if our approximated contour has four points, then we # can assume that we have found our screen if len(approx) == 4: screenCnt = approx break # Check if we found a 4 point contour. If not, we create our own bounding box # with the largest contour if screenCnt is None: height, width, channels = image.shape imageBounds = np.array([[1, 1], [width, 1], [width, height], [1, height]]) screenCnt = imutils.get_bounding_box(imageBounds) # apply the four point transform to obtain a top-down # view of the original image warped = four_point_transform(orig, screenCnt.reshape(4, 2) * ratio) # convert the warped image to grayscale, then threshold it # to give it that 'black and white' paper effect warped = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY) warped = threshold_adaptive(warped, 250, offset=10) warped = warped.astype("uint8") * 255 # Write out image to tmp file filename = "tmp/tmp-result.png" cv2.imwrite(filename, warped) print("Finished scan") return filename
def thresholdImage(self): """Threshold Image""" ### THRESHOLDING ### #======================================================================= # self.ThresholdMethod: # thresholdGlobalOtsu = filter.threshold_otsu(pyLaneTracker.Img, 64) # thresholdGlobalYen = filter.threshold_yen(pyLaneTracker.Img, 64) #======================================================================= thresholdAdaptive = filter.threshold_adaptive(self.Img, 96, method='median', offset=0, mode='reflect', param=None) self.Threshold = thresholdAdaptive
def generate_mask(fn): try: img_rgb = imread(os.path.join(input_dir, fn + '.tif')) img = rgb2gray(img_rgb) entropy_mask = generate_entropy_mask(img) init_contours = [ xys for xys in find_contour_points(entropy_mask.astype(np.int), sample_every=1)[1] if len(xys) > 50 ] assert len(init_contours ) > 0, 'No contour is detected from entropy mask %s' % fn img_adap = threshold_adaptive(img, 51) img_adap[~entropy_mask] = 1 final_masks = [] for init_cnt in init_contours: img_adap_gauss = gaussian(img_adap.astype(np.float), 1) snake = active_contour(img_adap_gauss, init_cnt.astype(np.float), alpha=1., beta=1000., gamma=1., w_line=0., w_edge=10., max_iterations=1000) bg = np.zeros(img.shape[:2], bool) xys = points_inside_contour(snake.astype(np.int)) bg[np.minimum(xys[:, 1], bg.shape[0] - 1), np.minimum(xys[:, 0], bg.shape[1] - 1)] = 1 final_mask = bg & entropy_mask final_masks.append(final_mask) final_mask = np.any(final_masks, axis=0) mask_fn = os.path.join(output_dir, '%(fn)s_mask.png' % dict(fn=fn)) if os.path.exists(mask_fn): sys.stderr.write('Mask exists, overwrite: %s\n' % mask_fn) imsave(mask_fn, img_as_ubyte(final_mask)) except Exception as e: sys.stderr.write(e.message + '\n') sys.stderr.write('%d, Mask error: %s\n' % (len(final_masks), fn)) return
def image_features_resize_adaptive(img, maxPixel, num_features,imageSize): # X is the feature vector with one row of features per image # consisting of the pixel values a, num_featuresnd our metric block_size = 20 im = threshold_adaptive(img, block_size, offset=5) X=np.zeros(num_features, dtype=float) image = resize(im, (maxPixel, maxPixel)) # Store the rescaled image pixels X[0:imageSize] = np.reshape(image,(1, imageSize)) return X
def image_features_hog2(img, num_features,orientation,maxcell,maxPixel): # X is the feature vector with one row of features per image # consisting of the pixel values a, num_featuresnd our metric block_size = 10 image = threshold_adaptive(img, block_size, offset=5) im = resize(image, (maxPixel, maxPixel)) ##hog scikit transform fd= hog(im, orientations=orientation, pixels_per_cell=(maxcell, maxcell), cells_per_block=(1, 1), visualise=False,normalise=True) return fd
def preprocess(image, height=50, block_size=50): """Turn to greyscale, scale to a height, and then threshold to binary """ image = color.rgb2grey(image) size_factor = float(height) / image.shape[0] new_size = [int(e * size_factor) for e in image.shape] image = transform.resize(image, new_size) image = filter.threshold_adaptive(image, block_size=30) return image
def determine_threshold(avg_image, block_size=100, offset=-2): '''Used to determine the right threshold value for the segmentation. The input is the average of the image stack of particles on the ring. Play with the offset and block size to make a clear ring with minimal background noise. Negative values of offset should reduce background noise. This functions returns the thresholded array in addition to showing what it looks like.''' from skimage.filter import threshold_adaptive threshold=threshold_adaptive(avg_image, block_size, offset=offset) import matplotlib.pyplot as plt plt.imshow(threshold) plt.show() return threshold
def feature_vector_from_rgb(image, sample_size=None): """Compute a feature vector from the composite images. The channels are assumed to be in the following order: - Red: MCF-7 - Green: cytoplasm GFP - Blue: DAPI/Hoechst Parameters ---------- im : array, shape (M, N, 3) The input image. sample_size : int, optional For features based on quantiles, sample this many objects rather than computing full distribution. This can considerably speed up computation with little cost to feature accuracy. Returns ------- fs : 1D array of float The features of the image. names : list of string The feature names. """ all_fs, all_names = [], [] ims = np.rollaxis(image[..., :3], -1, 0) # toss out alpha chan if present mcf, cells, nuclei = ims prefixes = ['mcf', 'cells', 'nuclei'] for im, prefix in zip(ims, prefixes): fs, names = features.intensity_object_features(im, sample_size=sample_size) names = [prefix + '-' + name for name in names] all_fs.append(fs) all_names.extend(names) nuclei_mean = nd.label(nuclei > np.mean(nuclei))[0] fs, names = features.nearest_neighbors(nuclei_mean) all_fs.append(fs) all_names.extend(['nuclei-' + name for name in names]) mcf_mean = nd.label(mcf)[0] fs, names = features.fraction_positive(nuclei_mean, mcf_mean, positive_name='mcf') all_fs.append(fs) all_names.extend(names) cells_t_otsu = cells > threshold_otsu(cells) cells_t_adapt = threshold_adaptive(cells, 51) fs, names = features.nuclei_per_cell_histogram(nuclei_mean, cells_t_otsu) all_fs.append(fs) all_names.extend(['otsu-' + name for name in names]) fs, names = features.nuclei_per_cell_histogram(nuclei_mean, cells_t_adapt) all_fs.append(fs) all_names.extend(['adapt-' + name for name in names]) return np.concatenate(all_fs), all_names
def split_rigid(image, charseps): """Split an image into characters. Charseps should be a list of ints giving the horizontal location to split """ n_chars = len(charseps) - 1 chars = [] for i in range(n_chars): char = image[:, charseps[i] : charseps[i + 1]] char = transform.resize(char, output_shape=(25, 15)) char = filter.threshold_adaptive(char, block_size=30) chars.append(char) return chars
def encode_centro_telomeres(image_centro, image_telo, centro_offset=0.0, centro_factor=1.0, centro_min_size=36, centro_radius=10, telo_offset=0.0, telo_adapt_radius=49, telo_open_radius=4): """Find centromeres, telomeres, and their overlap. Parameters ---------- image_centro : array, shape (M, N) The grayscale channel for centromeres. image_telo : array, shape (M, N) The grayscale channel for telomeres. centro_offset : float, optional Offset Otsu's threshold by this amount (i.e. be less stringent about what image intensity constitutes a centromere) centro_factor : float, optional Offset Otsu's threshold by a multiplicative constant. centro_min_size : int, optional Remove objects smaller than this, as they would be too small to be a centromere. centro_radius : int, optional Consider anything within this radius to be "near" a centromere. telo_offset : float, optional Offset the telomere image threshold by this amount. telo_adapt_radius : int, optional Use this radius to threshold telomere image adaptively. telo_open_radius : int, optional Use this radius for a binary opening of thresholded telomeres (removes noise). Returns ------- encoded_regions : array of int, shape (M, N) A uint8 image with the following values: - 0: background - 1: telomeres - 2: centromeres - 3: centromere/telomere overlap """ centros = otsu(image_centro, centro_offset, centro_factor) centros = remove_small_objects(centros, centro_min_size) centro_strel = selem.disk(centro_radius) centros = nd.binary_dilation(centros, structure=centro_strel) telos = imfilter.threshold_adaptive(image_telo, telo_adapt_radius, offset=telo_offset) telo_strel = selem.disk(telo_open_radius) telos = nd.binary_opening(telos, structure=telo_strel) encoded_regions = 2 * centros.astype(np.uint8) + telos return encoded_regions
def find_symbols(input_image): """ Pronalazi na karti pozicije broja i boje te ih ekstraktira u nove matrice :param input_image: image for processing :return: dimensions of new image matrix for rank and suit """ grey_warped_image = cv2.cvtColor(input_image, cv2.COLOR_BGR2GRAY) black_and_white = threshold_adaptive(grey_warped_image, 250, offset=10) # napravi binarnu sliku, crno-bijelu black_and_white = black_and_white.astype("uint8") * 255 kernel = np.ones((3, 2), 'uint8') # print black_and_white[20][20] black_and_white = cv2.erode(black_and_white, kernel, iterations=1) # cv2.imshow('Erodirana', black_and_white) blob_found = False region_width, region_height = 32, 93 rect_top, rect_bot = input_image[5:region_height, 5:region_width], input_image[247:(247 + 98), 208:(208 + 37)] blob_found = False region_width, region_height = 32, 93 # rect_top, rect_bot = input_image[5:region_height, 5:region_width], input_image[247:(247 + 98), 208:(208 + 37)] # print black_and_white.shape mask = np.zeros((black_and_white.shape[0] + 2, black_and_white.shape[1] + 2), 'uint8') bin_card = black_and_white.copy() rects = [] # cnt = 0 for y in np.arange(5, region_height): for x in np.arange(5, region_width): bgr = black_and_white[y, x] if bgr == 0: cv2.floodFill(black_and_white, mask, (x, y), (255, 255, 255)) # cv2.imshow("flooded", black_and_white) # cv2.imwrite("flooded" + str(cnt) +".jpg", black_and_white) # cnt += 1 # cv2.waitKey(0) # cv2.destroyAllWindows() rects.append(xor(black_and_white, bin_card, rects)) # print "RECTS: ", rects if len(rects) < 3: rank_dim, suit_dim = rects[0], rects[1] else: x1, y1, w1, h1 = rects[0] x2, y2, w2, h2 = rects[1] rank_dim = (x1, y1, w1 + w2 + 2, h1) suit_dim = rects[2] return rank_dim, suit_dim
def noise(img, rho=0.01, sigma=0.5, block_size=50): """Add two forms of noise to a binary image First, flip a fraction, rho, of the bits. The bits to flip are selected uniformly at random. Second, add white noise to the image, and then re-threshold it back to binary. Here, errors in the thresholding lead to a new "splotchy" error pattern, especially near the edges. """ mask = scipy.sparse.rand(img.shape[0], img.shape[1], density=rho) mask.data = np.ones_like(mask.data) img = np.mod(img + mask, 2) img = img + sigma * np.random.random(img.shape) img = filter.threshold_adaptive(img, block_size=block_size) return img
def detect_value(input_image): """ Vraca vrijednost karte (2 - 10) :param input_image: image for processing :return: value of input image """ grey_warped_image = cv2.cvtColor(input_image, cv2.COLOR_BGR2GRAY) black_and_white = threshold_adaptive(grey_warped_image, 250, offset=10) # napravi binarnu sliku, crno-bijelu black_and_white = black_and_white.astype("uint8") * 255 # cv2.imshow('binarna', black_and_white) kernel = np.ones((3, 3), 'uint8') # ignoriraj kuteve region_width, region_height = 32, 93 rect_top, rect_bot = black_and_white[5:region_height, 5:region_width], black_and_white[247:(247 + 98), 208:(208 + 37)] cv2.rectangle(black_and_white, (2, 2), (2 + region_width, 2 + region_height), (255, 255, 255), -1) cv2.rectangle(black_and_white, (218, 263), (218 + 29, 263 + 82), (255, 255, 255), -1) # cv2.imshow("bez kuteva", black_and_white) # cv2.imwrite('bezkuteva.jpg', black_and_white) black_and_white = cv2.dilate(black_and_white, kernel, iterations=1) # cv2.imshow("Dilate", black_and_white) cv2.waitKey(0) cv2.destroyAllWindows() black_and_white = cv2.morphologyEx(black_and_white, cv2.MORPH_CLOSE, kernel=np.ones((5, 5), 'uint8'), iterations=3) mask = np.zeros((black_and_white.shape[0] + 2, black_and_white.shape[1] + 2), 'uint8') # cv2.imshow("Closed", black_and_white) # cv2.waitKey(0) # cv2.destroyAllWindows() # .imwrite("closed.jpg", black_and_white) count_blobs = 0 for y in np.arange(black_and_white.shape[0]): for x in np.arange(black_and_white.shape[1]): if black_and_white[y, x] == 0: count_blobs += 1 cv2.floodFill(black_and_white, mask, (x, y), (255, 255, 255)) return count_blobs
def _adaptive_segment(args): """ Adaptive thresholding based segmentation. """ data, args, ind_start, ind_end = args block_size, offset = args for m in range(ind_end-ind_start): img = data[m, :, :] # Perform scikit adaptive thresholding. img = threshold_adaptive(img, block_size=block_size, offset=offset) # Remove small white regions img = ndimage.binary_opening(img) # Remove small black holes img = ndimage.binary_closing(img) data[m, :, :] = img return ind_start, ind_end, data
def segment(self, src): ''' src: preprocessing cv.Mat ''' image = src.ndarray[:] if self.use_adaptive_threshold: # block_size = 25 markers = threshold_adaptive(image, self.block_size) n = markers[:].astype('uint8') n[markers == True] = 255 n[markers == False] = 1 markers = n # print markers # markers = markers.astype('uint8') # n = ones_like(markers) # n[markers] = 255 # print n # markers[markers] = 255 # markers[not markers] = 1 # print markers # markers = n.astype('uint8') # markers = invert(markers).astype('uint8') else: markers = zeros_like(image) markers[image < self.threshold_low] = 1 markers[image > self.threshold_high] = 255 # global cnt # # remove holes # if cnt % 2 == 0: # markers = binary_closing(markers).astype('uint8') * 255 # cnt += 1 # print markers elmap = sobel(image, mask=image) wsrc = watershed(elmap, markers, mask=image) return invert(wsrc)
def segment_cells(img): """label the cells in an image. Returns the labeled image and the number of labels. """ if img.ndim == 3 and img.shape[-1] > 1: img = make_grey(img) # # global threshold and watershed # binary = img < threshold_otsu(img) # distance = ndimage.distance_transform_edt(binary) # local_maxi = peak_local_max(distance, indices=False, footprint=np.ones((3, 3)), labels=binary) # markers = ndimage.label(local_maxi)[0] # labels = watershed(-distance, markers, mask=binary) # local threshold and erosion / dilation t_img = threshold_adaptive(img, 25, offset=.01) b_img = binary_erosion(-t_img, np.ones((3, 3))) d_img = binary_dilation(b_img, np.ones((3, 3))) clear_border(d_img) labels, n_labels = ndimage.label(d_img) return labels, n_labels
def threshold(image): gaussian_image = scpy.gaussian_filter(image, (10, 10)) display(gaussian_image, 'gaussian_image', 0) clahe = cv2.createCLAHE(clipLimit=15.0, tileGridSize=(6, 6)) cl1 = clahe.apply(gaussian_image) display(cl1, 'clahe', 0) threshold_image = threshold_adaptive(cl1, 255, offset=10) threshold_average_image = threshold_image.astype(np.uint8) * 255 display(threshold_average_image, 'threshold_average_image', 0) image, contours, hier = cv2.findContours( threshold_average_image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) #, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) smears = [] for cnt in contours: area = cv2.contourArea(cnt) # if area>6000 and area<25000: #cam1 if area > 25000 and area < 26000: #cam3 # if area>6800 and area<7000: #cam5 # if area>6800 and area<7000: #cam0,2 print 'area=', area smears.append(cnt) mask = np.zeros(threshold_average_image.shape, np.uint8) cv2.drawContours(mask, smears, -1, (255, 255, 255), -1) # cv2.drawContours(mask, smears, 1, (255, 255, 255), -1) #cam 1 # cv2.drawContours(mask, smears, 2, (255, 255, 255), -1) #cam 1 # cv2.drawContours(mask, smears, 3, (255, 255, 255), -1) #cam 1 cv2.imwrite('mask.jpg', mask) print 'mask saved' cv2.destroyAllWindows() return 255 - mask
def compute_base_mask(self,image,params): """Creates the base mask for the phase image params is a MaskParameters object with the necessary parameters """ self.mask = np.copy(image) if params.auto_threshold: params.absolute_threshold = threshold_isodata(self.mask) if params.algorithm == "Local Average": #need to invert because threshold_adaptive sets dark parts to 0 self.mask = 1.0-filter.threshold_adaptive(self.mask, params.blocksize,offset=params.offset) else: if params.auto_threshold: params.absolute_threshold = threshold_isodata(self.mask) #the convention is that dark is foreground and with mask set to 1 self.mask = img_as_float(image <= params.absolute_threshold) if params.invert: self.invert_mask()
def get_bounding_boxes(filename): image = Image.open(filename) image = np.asarray(image)[0::1,0::1] block_size = image.shape[0]/7. binary_adaptive = np.invert(threshold_adaptive(image, block_size, offset=70)) mask = binary_adaptive > binary_adaptive.mean() label_im, n_labels = ndimage.label(binary_adaptive)#mask) extrema = {} for i in range(1, n_labels+1): extrema[i] = ((1000, 1000), (0, 0)) # i: row # j: col for i,row in enumerate(label_im): for j, label in enumerate(row): if label[0] > 0: top, bottom = extrema[label[0]] if i > bottom[0]: bottom = (i, bottom[1]) if j > bottom[1]: bottom = (bottom[0], j) if i < top[0]: top = (i, top[1]) if j < top[1]: top = (top[0], j) extrema[label[0]] = (top, bottom) boxes = [] for label,coords in extrema.items(): b = Box(coords[0][0], coords[0][1], coords[1][0], coords[1][1]) boxes.append(b) return boxes
def get_chromatin(im, background_diameter=51, opening_size=2, opening_iter=2, size_filter=256): """Find the chromatin in an unevenly illuminated image. Parameters ---------- im : np.ndarray, shape (M, N) The chromatin grayscale image. background_diameter : int, optional The diameter of the block size in which to find the background. (This is used by the scikit-image function `threshold_adaptive`.) (default: 51) opening_size : int, optional Perform a binary opening with a disk of this radius. (default: 2) opening_iter : int, optional Perform this many opening iterations. (default: 2) size_filter : int, optional After the morphological opening, filter out segments smaller than this size. (default: 256) Returns ------- chrs : np.ndarray, shape (M, N) A thresholded image of the chromatin regions. """ if im.ndim == 3 and im.shape[2] == 3: im = im[..., 0] fg = imfilter.threshold_adaptive(im, background_diameter) # on an unevenly lit image, `fg` will have all sorts of muck lying around, # in addition to the chromatin. Thankfully, the muck is noisy and full of # holes, whereas the chromatin is solid. An opening followed by a size # filtering removes it quite effectively. strel = selem.disk(opening_size) fg_open = nd.binary_opening(fg, strel, iterations=opening_iter) chrs = remove_small_objects(fg_open, size_filter) return chrs
def threshold2(path): i = 0 for image_path in glob.glob(path + '/*.png'): print i, image_path img = cv2.imread(image_path, 0) gaussian_image = scpy.gaussian_filter(img, (10, 10)) display(gaussian_image, 'gaussian_image', 0) threshold_image = threshold_adaptive(gaussian_image, 255, offset=9) threshold_average_image = threshold_image.astype(np.uint8) * 255 display(threshold_average_image, 'threshold_average_image', 0) edge_detection_image = cv2.Canny(threshold_average_image, 200, 200) display(edge_detection_image, 'edge_detection_image', 0) (_, cnts, _) = cv2.findContours(edge_detection_image, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) cv2.drawContours(img, cnts, -1, (0, 0, 255), 2) display(img, 'final', 0) cv2.destroyAllWindows() i += 1
dirq = "data/" files = [] for i in os.listdir(dirq) : if i.endswith(".jpg") : files.append(dirq + i) for f in files : image = exposure.equalize_adapthist(io.imread(f)) binary = filter.threshold_adaptive(exposure.adjust_sigmoid(image[:, :, 0], cutoff=0.4, gain = 30), 301).astype(bool) clean = morphology.binary_closing(binary, morphology.disk(3)).astype(bool) clean = morphology.remove_small_objects(clean, 200) clean = morphology.remove_small_objects( (1-clean).astype(bool), 200) local_density = filter.gaussian_filter(clean, 61) ent = filter.gaussian_filter(filter.rank.entropy(local_density, morphology.disk(3)), 75) ent -= ent.min() ent /= ent.max() local_density -= local_density.min() local_density /= local_density.max() info = ent * (1 + local_density)
# Histogram values, bins = np.histogram(image, bins=np.arange(256)) label_1 = "(b) Histogram" ax1.plot(bins[:-1], values, lw=2, c='k') ax1.set_xlim(xmax=256) ax1.set_yticks([0, 400]) ax1.set_aspect(.2) ax1.set_title(label_1) # Apply threshold from skimage.filter import threshold_adaptive bw = threshold_adaptive(image, 95, offset=-15) label_2 = "(c) Adaptive threshold" ax2.imshow(bw, cmap=plt.cm.gray) ax2.set_title(label_2) ax2.axis('off') # Find maxima from skimage.feature import peak_local_max coordinates = peak_local_max(image, min_distance=20) label_3 = "(d) Peak local maxima" ax3.imshow(image, cmap=plt.cm.gray) ax3.autoscale(False) ax3.plot(coordinates[:, 1], coordinates[:, 0], 'r.')
#!/usr/bin/env python # -*- coding:utf-8 -*- from PIL import Image from pylab import imshow,show,subplot,array,figure,gray,zeros,ones,uint8,jet from skimage.filter import threshold_adaptive from scipy.ndimage import filters,measurements file_name='../../data/cv_data/empire.jpg' # load the image file img_gray = array(Image.open(file_name).convert('L')) # binary the image img_bin = threshold_adaptive(img_gray, block_size=15, offset=10) #refers to http://docs.scipy.org/doc/scipy/reference/ndimage.html #none-zero pixels are considered. #label begin from 1. #structure defines the connect condition. s = array([[1,1,1],[1,1,1],[1,1,1]]) labeled_array, num_features = measurements.label(img_bin, structure=s) print labeled_array print num_features figure() gray() # don't use colors subplot(1,2,1) imshow(img_gray) subplot(1,2,2)
def processImage(args): # load the image and compute the ratio of the old height # to the new height, clone it, and resize it image = cv2.imread(args["image"]) ratio = image.shape[0] / 500.0 orig = image.copy() image = imutils.resize(image, height=500) edged = cv2.Canny(image, 75, 200) # res = np.hstack((gray,eqgray)) # find the contours in the edged image, keeping only the # largest ones, and initialize the screen contour (cnts, _) = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) # sort by perimeter first and then area cnts = sorted(cnts, key=lambda x: cv2.arcLength(x, False), reverse=True)[:3] contour = sorted(cnts, key=lambda x: cv2.contourArea(x, False), reverse=True)[0] def removeInlier(points, closeLine=False): initial_area = cv2.contourArea(points) new_contour = points ratios = [] for i in range(len(points)): # new_contour = points.pop(i) new_contour = np.delete(new_contour, i, 0) new_area = cv2.contourArea(new_contour) ratios += [new_area / initial_area] new_contour = points index = np.argmax(ratios) return np.delete(points, index, 0) # approximate the contour peri = cv2.arcLength(contour, True) approx = cv2.approxPolyDP(contour, 0.02 * peri, True) approx = cv2.convexHull(approx) approx = approx.reshape((len(approx), 2)) while len(approx) > 4: approx = removeInlier(approx) # apply the four point transform to obtain a top-down # view of the original image warped = four_point_transform(orig, approx.reshape(4, 2) * ratio) if args["bw"] == "true": warped = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY) warped = threshold_adaptive(warped, 40, offset=7) warped = warped.astype("uint8") * 255 else: b, g, r = cv2.split(warped) # get b,g,r warped = cv2.merge([r, g, b]) # switch it to rgb final = imutils.resize(warped, height=650) sheet_ratio = final.shape[0] / float(final.shape[1]) fig = plt.figure(frameon=False) if str(args["a4"]) == "true": fig.set_size_inches(11.69, 8.27) ax = plt.Axes(fig, [0., 0., 1., 1.]) ax.set_axis_off() fig.add_axes(ax) else: fig.set_size_inches(3, 3 / sheet_ratio) ax = plt.Axes(fig, [0., 0., 1., 1.]) ax.set_axis_off() fig.add_axes(ax) if args["bw"] == "true": ax.imshow(final, aspect='auto', cmap=plt.get_cmap('gray')) else: ax.imshow(final, aspect='auto') format = str(args["format"]) path = str(args["out"]) filename = str(args["name"]).split(".")[0] plt.savefig(os.path.join(path, filename + "." + format), format=format, dpi=int(args["dpi"])) if args["koriginal"] == "true": orig_path = args["image"] orig_format = orig_path.split(".")[-1] shutil.copyfile(orig_path, os.path.join(path, filename + "." + orig_format))
clean[(x, y)] += 5 clean = ndimage.gaussian_filter(clean, 3) clean = clean / np.max(clean) # Combining both the non-uniform background # and points fimg = bkg + clean fimg = fimg / np.max(fimg) # Defining minimum neighboring size of objects block_size = 3 # Adaptive threshold function which returns image # map of structures that are different relative to # background adaptive_cut = skif.threshold_adaptive(fimg, block_size, offset=0) # Global threshold global_thresh = skif.threshold_otsu(fimg) global_cut = fimg > global_thresh # Creating figure to highlight difference between # adaptive and global threshold methods fig = plt.figure(figsize=(8, 4)) fig.subplots_adjust(hspace=0.05, wspace=0.05) ax1 = fig.add_subplot(131) ax1.imshow(fimg) ax1.xaxis.set_visible(False) ax1.yaxis.set_visible(False)
from scipy import ndimage import matplotlib.pyplot as plt import numpy as np import mahotas from parser.lines import * from skimage.filter import threshold_otsu, threshold_adaptive image = mahotas.imread('photo.jpg')[0::20,0::20] block_size = 50 binary_adaptive = np.invert(threshold_adaptive(image, block_size, offset=30)) mask = binary_adaptive > binary_adaptive.mean() label_im, n_labels = ndimage.label(binary_adaptive)#mask) print n_labels plt.figure(figsize=(9,3)) extrema = {} for i in range(1, n_labels+1): extrema[i] = ((1000, 1000), (0, 0)) # i: row # j: col for i,row in enumerate(label_im): for j, label in enumerate(row): if label[0] > 0: top, bottom = extrema[label[0]] if i > bottom[0]:
from skimage.filter import median_filter ptsCropSouth = array([[3000, 4650], [3700, 5200]]) oilCropSouth = imcrop(ptsCropSouth, delta) ptsCropNorth = array([[3400, 0], [5000, 1650]]) oilCropNorth = imcrop(ptsCropNorth, delta) image = oilCropNorth image = median_filter(image, radius=50) global_thresh = threshold_otsu(image) binary_global = image > global_thresh block_size = 300 binary_adaptive = threshold_adaptive(image, block_size) markers = ones(image.shape, dtype=uint) markers[image < global_thresh * 0.78] = 0 # display results plt.figure() plt.subplot(221) plt.imshow(image, cmap=plt.cm.gray) plt.axis('off') plt.title('noisy image', fontsize=20) plt.subplot(222) plt.imshow(binary_global, cmap=plt.cm.gray) plt.axis('off') plt.title('Global thresholding', fontsize=20) plt.subplot(223)
# from skimage import filter from skimage import filter import scipy.misc import Image, numpy # opening the image and converting it to grayscale a = Image.open('../Figures/adaptive_example1.png').convert('L') # a is converted to an ndarray a = scipy.misc.fromimage(a) # performing adaptive thresholding b = filter.threshold_adaptive(a, 40, offset=10) # b is converted from an ndarray to an image b = scipy.misc.toimage(b) # saving the image as adaptive_output.png # in the folder Figurespb b.save('../Figures/adaptive_output.png')
def threshold_images(images, offset_arg): binary_masks = [] for img in images: img = threshold_adaptive(img, 21, offset=-160) #img > threshold binary_masks.append(img) return binary_masks
def mySegmentation(img,s,method='adaptive',BoW='B',thr=0.75,l_th1=0,l_th2=550,seeds_thr1=50,seeds_thr2=500,block_size=7,offs=-0,visual=0): """the user can choose wether to use otsu for seeds (merkers) definition or get seeds from the standard deviation map""" img=Prepare_im(img); sz=np.shape(img) seeds=np.zeros((sz[0],sz[1])) if method=='otsu': t=threshold_otsu(img.astype(uint16))*thr l=img<t #seeds=abs(seeds-1) [l,N]=msr.label(l,return_num=True) [l,N]=remove_reg(l,l_th1,l_th2) if visual: figure();imshow(img) figure();imshow(seeds) figure();imshow(l) if method=='adaptive': binary_adaptive = threshold_adaptive(-img, block_size, offset=offs) l=binary_adaptive [l,N]=msr.label(l,return_num=True) l,N=remove_reg(l,l_th1,l_th2) l=l!=0 l=sgm.clear_border(l) l=mph.dilation(l) [l,n]=msr.label(l,return_num=True) if method=='std' : #%compute otsu mask #s=std_image(img,0) t=mht.otsu(img.astype(uint16))*thr tempseeds=img<t s2=np.copy(s) s2=ndi.maximum_filter(s2,10) local_maxi = peak_local_max((s2 ).astype(np.double), indices=False,footprint=np.ones((10, 10)),min_distance=100000) #seeds=pymorph.regmin((-s2).astype(np.uint16)) #,array([[False,True,True,False],[False,True,True,False]])) seeds=local_maxi #seeds,n=mht.label(seeds) im=Prepare_im(img) t=threshold_otsu(im) mask=im<t*0.85 seeds=msr.label(seeds) seeds,N=remove_reg(seeds,seeds_thr1,seeds_thr2) # l = mht.cwatershed(img, seeds) l = mph.watershed(img, msr.label(local_maxi),mask=mph.binary_dilation(mask)) #l=mph.watershed(img,seeds) l=l.astype(int32) l,n=remove_reg(l,l_th1,l_th2) l=mht.labeled.remove_bordering(l) print 'label' print mht.labeled.labeled_size(l) [l,n]=msr.label(l,return_num=True) if visual: figure();imshow(img) figure();imshow(seeds) figure();imshow(l) return seeds,N,l if visual: figure();imshow(img) figure();imshow(seeds) figure();imshow(l) return seeds,N,l
def adaptthreshold(array): return filter.threshold_adaptive(array, 40, 'gaussian')
import numpy as np import matplotlib.pyplot as plt from skimage import data from skimage import segmentation from skimage import morphology from skimage import filter coins = data.coins() simple_threshold = coins > filter.threshold_otsu(coins) adaptive_threshold = filter.threshold_adaptive(coins, 151) filter_res = morphology.remove_small_objects(adaptive_threshold) clear_image = segmentation.clear_border(filter_res) plt.figure() plt.subplot(221) plt.imshow(coins, cmap='gray') plt.title('Image d\'origine') plt.axis('off') plt.subplot(222) plt.imshow(simple_threshold, cmap='gray') plt.title('Simple seuillage') plt.axis('off') plt.subplot(223) plt.imshow(adaptive_threshold, cmap='gray') plt.title('Seuillage adaptatif') plt.axis('off') plt.subplot(224) plt.imshow(clear_image, cmap='gray') plt.title('Image nettoyee')
def extract_features(im_cat_path_list): ''' Extract Features takes a list of 2 element lists: [catagory of image , path to image] and extracts 15 features from this image. The output is a list of 3 element lists: [catagory of image , path to image, [list of features]] The 15 features are: 1 Product of image pixel dimensions (image size) 2 Mean of Grayscale Image 3 Area of Sobel Edges Normalized By Image Size 4 Area of Sobel Edges Above 2x Mean of Sobel Edges Normalized By Image Size 5 Area of Canny Edges (Sum of booleans) Normalized By Image Size 6 Number of Harris Corners 7 Unique Felzenszwalb Image Segmentation Lines 8 Area of Vertical Sobel Edges Above 2x Mean of Sobel Edges Normalized By Image Size 9 Area of Horizontal Sobel Edges Above 2x Mean of Sobel Edges Normalized By Image Size 10-12 Mean of Red/Green/Blue Channels (if grayscale: mean of the only color channel) 13 Maximum Pixel Value of the Histogram of Oriented Gradients 14 Percent of image that is light versus dark with adaptive thresholding 15-17 Percent of image that is red/green/blue with adaptive thresholding ''' cat_path_features = [] for im_cat, im_path in im_cat_path_list: #RAW IMAGE im_raw = imread(im_path) #image matrix #RAW IMAGE FLATTENED IF NOT ALREADY FLAT if len(np.shape(im_raw)) == 3: im_raw_flat = np.median(im_raw, axis=2) else: im_raw_flat = im_raw #Size of image im_y = float(im_raw.shape[0]) im_x = float(im_raw.shape[1]) im_size = im_y * im_x #LIST OF FEATURES features = [] #FEATURE 1: Product of image pixel dimensions (image size) features.append(float(im_size)) #FEATURE 2: Mean of Grayscale Image features.append(im_raw_flat.mean()) #FEATURE 3: Area of Sobel Edges Normalized By Image Size im_edge_sobel = filter.sobel(im_raw_flat) features.append(im_edge_sobel.sum() / im_size) #FEATURE 4: Area of Sobel Edges Above 2x Mean of Sobel Edges Normalized By Image Size features.append( float((im_edge_sobel > im_edge_sobel.mean() * 2).sum()) / im_size) #FEATURE 5: Area of Canny Edges (Sum of booleans) Normalized By Image Size im_canny = filter.canny(im_raw_flat, sigma=8) features.append(im_canny.sum().astype(float) / im_size) #FEATURE 6: Number of Harris Corners im_corners = feature.corner_peaks(feature.corner_harris(im_raw_flat), min_distance=5) features.append(float(len(im_corners))) #FEATURE 7: Unique Felzenszwalb Image Segmentation Lines im_raw_float = util.img_as_float(im_raw[::2, ::2]) im_felzen_segments = segmentation.felzenszwalb(im_raw_float, scale=100, sigma=0.5, min_size=50) features.append(float(len(np.unique(im_felzen_segments)))) #FEATURE 8: Area of Vertical Sobel Edges Above 2x Mean of Sobel Edges Normalized By Image Size im_edge_vsobel = filter.vsobel(im_raw_flat) features.append( float( (im_edge_vsobel > im_edge_vsobel.mean() * 2).sum()) / im_size) #FEATURE 9: Area of Horizontal Sobel Edges Above 2x Mean of Sobel Edges Normalized By Image Size im_edge_hsobel = filter.hsobel(im_raw_flat) features.append( float( (im_edge_hsobel > im_edge_hsobel.mean() * 2).sum()) / im_size) #FEATURE 10-12: Mean of Red/Green/Blue Channels (if grayscale: mean of the only color channel) if len(np.shape(im_raw)) == 3: features.append(im_raw[..., 0].mean()) features.append(im_raw[..., 1].mean()) features.append(im_raw[..., 2].mean()) else: features.append(im_raw_flat.mean()) features.append(im_raw_flat.mean()) features.append(im_raw_flat.mean()) #FEATURE 13: Maximum Pixel Value of the Histogram of Oriented Gradients im_fd, im_hog = feature.hog(im_raw_flat, orientations=8, pixels_per_cell=(16, 16), cells_per_block=(1, 1), visualise=True) features.append(im_hog.max()) #FEATURE 14: Percent of image that is light versus dark with adaptive thresholding im_thres_flat = filter.threshold_adaptive(im_raw_flat, 100, 'mean') features.append(im_thres_flat.sum() / im_size) #FEATURE 15-17: Percent of image that is red/green/blue with adaptive thresholding im_thres_red = filter.threshold_adaptive(im_raw[..., 0], 100, 'mean') im_thres_green = filter.threshold_adaptive(im_raw[..., 1], 100, 'mean') im_thres_blue = filter.threshold_adaptive(im_raw[..., 2], 100, 'mean') features.append(im_thres_red.sum() / im_size) features.append(im_thres_green.sum() / im_size) features.append(im_thres_blue.sum() / im_size) #BUILD OUTPUT LIST FOR THIS IMAGE cat_path_features.append([im_cat, im_path, features]) #CLEAR IMAGE PROC DATA del im_raw del im_raw_flat del im_raw_float del im_edge_sobel del im_canny del im_corners del im_felzen_segments del im_edge_vsobel del im_edge_hsobel del im_fd del im_hog return cat_path_features
plt.imshow(gy) mag, angle = cv2.cartToPolar(gx, gy, angleInDegrees=True) plt.imshow(angle) ## from skimage.filter import threshold_otsu, threshold_adaptive global_thresh = threshold_otsu(gray0.astype(np.float32)) binary_global = gray0.astype(np.float32) > global_thresh plt.imshow(binary_global) block_size = 45 binary_adaptive = threshold_adaptive(gray0, block_size, offset=5) plt.imshow(binary_adaptive) from skimage.filters import gabor from skimage import data, io from matplotlib import pyplot as plt #### ESSE E FODA !!!!! filt_real, filt_imag = gabor(gray0, frequency=2.1) plt.figure() io.imshow(filt_real) io.show() plt.figure() io.imshow(filt_imag) io.show()
def threshold(image, block_size=100, offset=-5): return image_filter.threshold_adaptive(renorm(image), block_size=block_size, offset=offset)
from skimage import io from skimage import filter from skimage import img_as_uint from skimage import data image = io.imread('/home/mallikarjuna/Desktop/white.png') #image2 = data.page() #print (type(image2)) import numpy as np #print(np.shape(image2)) global_thresh = filter.threshold_otsu(image) binary_global = image > global_thresh io.imsave('/home/mallikarjuna/Desktop/global2.png', img_as_uint(binary_global)) block_size = 35 binary_adaptive = filter.threshold_adaptive(image, block_size, offset=10) io.imsave('/home/mallikarjuna/Desktop/adaptive2.png', img_as_uint(binary_adaptive)) fig, axes = plt.subplots(nrows=3, figsize=(7, 8)) ax0, ax1, ax2 = axes plt.gray() ax0.imshow(image) ax0.set_title('Image') ax1.imshow(binary_global) ax1.set_title('Global thresholding') ax2.imshow(binary_adaptive) ax2.set_title('Adaptive thresholding')
cv2.waitKey(1) if GPIO.input(button) == False: break lcd.clear() lcd.message("Capturing Image.") speak("Capturing Image") time.sleep(2) ret, img = camera.read() camera.release() cv2.imwrite("test1.jpeg", img) warped = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) warped = threshold_adaptive(warped, 251, offset=10) warped = warped.astype("uint8") * 255 time.sleep(1) lcd.clear() lcd.message("Image captured") speak("Image captured.") time.sleep(1) # show the original and scanned images print("STEP 3: Apply perspective transform") lcd.clear() lcd.message('Processing...') speak("Processing for the speech.") time.sleep(2)