def ApplyThresholdToImageRegion(image2, Tb, Bb, Lb, Rb,shouldThresholdImage): image = rgb2gray(image2) global foregroundPixelValue global backgroundPixelValue thresholdValue = threshold_otsu(image) NumberOfRows = image.shape[0] NumberOfColumns = image.shape[1] numberOfBlackPixels = 0 numberOfWhitePixels = 0 selem = disk(3) # simpe thresholding for y in range(NumberOfRows): for x in range(NumberOfColumns): isWithinBoundary = IsWithinBoundary(y,x,image2, Tb, Bb, Lb, Rb,shouldThresholdImage) if (isWithinBoundary): if image[y,x] > thresholdValue: #black image[y,x] = 0 numberOfBlackPixels += 1 else: #white image[y,x] = 1 numberOfWhitePixels += 1 # assume foreground has more pixels in face region if (numberOfWhitePixels > numberOfBlackPixels): foregroundPixelValue = 1 backgroundPixelValue = 0 #print("foreground color is white") else: foregroundPixelValue = 0 backgroundPixelValue = 1 #print("foreground color is black") image = opening(image,selem) if (foregroundPixelValue == 0): image = opening(image,selem) else: image = closing(image,selem) if drawFaceImages: io.imshow(image) io.show() return image
def smooth_disk(index_array, threshold, disk_size): """Applies morphological opening to a numpy array User inputs numpy array to be opened, threshold and disk_size for disk shaped structuring element Parameters ---------------- morph_index : numpy array (either MSI or MBI) threshold : numerical input (integer, float) disk_size : numerical input (integer) size of structuring elements (number of pixels) Returns --------------- Morphologically opened and "smoothed" numpy arrays Return is a mask (values of 0 or 1) that has had smal """ # Create a mask based on user defined threshold values index_threshold_mask = (index_array >= threshold).astype(int) # Define the structure element based on the user defined disk size selem = disk(disk_size) # Apply the morphological opening function to the thresholded raster index_opened = opening(index_threshold_mask, selem) return index_opened
def cleanForFigure(czi_f, coords_f, dapi_f, gfp_f): coords = [] for line in open(coords_f): fname, xmin, xmax, ymin, ymax = line.strip().split() coords.append(map(int, [xmin, xmax, ymin, ymax])) image_arrays = openFile(czi_f) images = image_arrays[0, :, 0, :, :, :, 0] colors, zsize, xsize, ysize = images.shape dapi = images[0, :, :, :] gfp = images[1, :, :, :] newdapi = zeros((zsize, xsize, ysize), dtype=float) newgfp = zeros((zsize, xsize, ysize), dtype=float) for xmin, xmax, ymin, ymax in coords: print xmin, xmax, ymin, ymax # Subtract backgrounds. dapiblock = img_as_float(dapi[:, xmin:xmax, ymin:ymax]) gfpblock = img_as_float(gfp[:, xmin:xmax, ymin:ymax]) print 'GFP Opening' gfpbg = 3 * morphology.opening(gfpblock, morphology.ball(3)) newdapi[:, xmin:xmax, ymin:ymax] = dapiblock newgfp[:, xmin:xmax, ymin:ymax] = gfpblock - gfpbg print dapi.shape io.imsave(dapi_f, img_as_ubyte(newdapi.max(axis=0))) io.imsave(gfp_f, img_as_ubyte(newgfp.max(axis=0)))
def rmSpecales(img): ''' img should be greyscale ''' selem = disk(4) exp = opening(img, selem) return (exp)
def compute_spiculation(orig, segmented_mask): # filter approach based on Huo and Giger (1995) # they use Sobel but Scharr is supposed to be rotation invariant (?) theta_A, magnitude_A = compute_scharr(orig, mask=segmented_mask) std_dev_A = compute_gradient_std(theta_A, magnitude_A) # B: just use a 3? pixel border border_mask = get_border_pixels(segmented_mask) theta_B, magnitude_B = compute_scharr(orig, mask=border_mask) std_dev_B = compute_gradient_std(theta_B, magnitude_B) # C: use the whole ROI # ideally would reduce to 20 pixel adjacent area but not working right now # ymin, xmin, ymax, xmax = regionprops(segmented_mask[0]).bbox # bbox_mask = np.zeros(orig.shape) # bbox_mask[ymin:ymax, xmin:xmax] = 1 # region_bbox = orig * bbox_mask theta_C, magnitude_C = compute_scharr(orig) std_dev_C = compute_gradient_std(theta_C, magnitude_C) # D: use non-region ROI after applying opening (circular, arbitrary size right now) open_nonregion = opening(np.where(segmented_mask == 0, 1, 0), disk(5)) theta_D, magnitude_D = compute_scharr(orig, mask=open_nonregion) std_dev_D = compute_gradient_std(theta_D, magnitude_D) # higher standard deviation here indicates more spiculation return {'A': std_dev_A, 'B': std_dev_B, 'C': std_dev_C, 'D': std_dev_D}
def get_results(file_list, cfg): for img_path in file_list: img_name = img_path.split('\\')[-1][:-4] c = '' if not cfg.sub_folder else k test_img, rec_img, ssim_residual_map, l1_residual_map = get_residual_map( img_path, cfg) ssim_residual_map *= cfg.depr_mask if 'ssim' in cfg.loss: l1_residual_map *= cfg.depr_mask mask = np.zeros((cfg.im_resize, cfg.im_resize)) mask[ssim_residual_map > cfg.ssim_threshold] = 1 mask[l1_residual_map > cfg.l1_threshold] = 1 kernel = morphology.disk(4) mask = morphology.opening(mask, kernel) mask *= 255 vis_img = set_img_color(test_img.copy(), mask, weight_foreground=0.3, grayscale=cfg.grayscale) cv2.imwrite(cfg.save_dir + '/' + c + '_' + img_name + '_residual.png', mask) cv2.imwrite(cfg.save_dir + '/' + c + '_' + img_name + '_origin.png', test_img) cv2.imwrite(cfg.save_dir + '/' + c + '_' + img_name + '_rec.png', rec_img) cv2.imwrite(cfg.save_dir + '/' + c + '_' + img_name + '_visual.png', vis_img)
def smooth(image): filename_split = os.path.splitext(image) filename_zero, fileext = filename_split basename = os.path.basename(filename_zero) im = np.array(Image.open(image)) with rasterio.open(image) as r: im = r.read() p = r.profile im = im.squeeze() selem = disk(1) print("image min and max: ", im.min(),im.max()) dilated = skimage.morphology.dilation(im, selem) print("dilated image min and max: ", dilated.min(),dilated.max()) eroded = skimage.morphology.erosion(im, selem) print("eroded image min and max: ", eroded.min(),eroded.max()) opened = opening(im, selem) print("opened image min and max: ", opened.min(),opened.max()) closed = closing(im, selem) print("closed image min and max: ", closed.min(),closed.max()) #im[im==1]=0 #im[im==2]=1 median = cv2.medianBlur(im,9) average = cv2.blur(im,(9,9)) #gaussian = cv2.GaussianBlur(im,(9,9),0) gaussian = cv2.GaussianBlur(dilated,(9,9),0) #bilateral = cv2.bilateralFilter(im,9,75,75) bilateral = cv2.bilateralFilter(gaussian,9,75,75) with rasterio.open(outPath+basename+fileext, 'w', **p) as dst: dst.write(bilateral, 1) color_outPath = outPath+'color/' if not os.path.exists(color_outPath): os.mkdir(color_outPath) colored_image = color_outPath+basename+'.png' os.system("gdaldem color-relief", bilateral, colorfile, colored_image) return im, dilated, eroded, opened, closed, median, average, gaussian, bilateral
def lightness_mask(img_rgb, lightness=0.45, gamma=3, remove_disk=2, rejoin=8): # params: lightness_param = lightness gamma_param = gamma remove_disk_param = remove_disk rejoin_square_param = rejoin # enhance contrast img = exposure.adjust_gamma(img_rgb, gamma_param, 1) # split to h s v img = rgb2hsv(img) h = img[:, :, 0] s = img[:, :, 1] v = img[:, :, 2] # make lightness mask mask = (v > lightness_param).astype(np.uint8) # remove small regions from mask disk_elem = disk(remove_disk_param) opened = opening(mask, selem=disk_elem) # rejoin colored pionts square_elem = square(rejoin_square_param) dilated = dilation(opened, selem=square_elem) io.imshow(dilated) plt.show() return dilated.astype(bool)
def Mask_ROI_op(im,disk_size,thresh=None,black_spots=None,with_morph=False): l=np.array([0,0]) if not isinstance(im,l.__class__): numpy_array=np.array(im) else: numpy_array=im if len(numpy_array.shape)==3: numpy_array=numpy_array[:,:,0:3].mean(axis=2) selem = disk(disk_size) openin = opening(numpy_array, selem) if thresh is None: thresh = threshold_otsu(openin) binary = openin > thresh if binary.dtype=='bool': binary=binary+0 if black_spots is not None: binary2 = openin > black_spots binary2 = binary2 + 0 binary = binary - binary2 else: binary -=1 binary=binary * -1 if with_morph: return(binary,openin) else: return(binary)
def upsample_smooth(image): filename_split = os.path.splitext(image) filename_zero, fileext = filename_split basename = os.path.basename(filename_zero) upsampleRes = int(upsampleRes) upsampled_image = outPath+basename+'_cubicSpline.png' os.system("gdalwarp -tr", upsample_res, upsample_res," -r cubicspline ", image, upsampled_image) im = np.array(Image.open(upsampled_image)) with rasterio.open(image) as r: im = r.read() p = r.profile im = im.squeeze() selem = disk(1) print("image min and max: ", im.min(),im.max()) dilated = skimage.morphology.dilation(im, selem) print("dilated image min and max: ", dilated.min(),dilated.max()) eroded = skimage.morphology.erosion(im, selem) print("eroded image min and max: ", eroded.min(),eroded.max()) opened = opening(im, selem) print("opened image min and max: ", opened.min(),opened.max()) closed = closing(im, selem) print("closed image min and max: ", closed.min(),closed.max()) dilated = Image.fromarray(dilated) dilated.save(outPath+basename+'.png') with rasterio.open(outPath+basename+fileext, 'w', **p) as dst: dst.write(dilated, 1) color_outPath = outPath+'color/' if not os.path.exists(color_outPath): os.mkdir(color_outPath) colored_image = color_outPath+basename+'.png' os.system("gdaldem color-relief", dilated, colorfile, colored_image) return im, dilated, eroded, opened, closed
def open_image(img, mask_length): # Morphological opening on greyscale/binary image img = img.astype(np.uint8) img = opening(img, rectangle(mask_length,1)) return(img)
def opening(gray_img, kernel=None): """Wrapper for scikit-image opening functions. Opening can remove small bright spots (i.e. salt). Inputs: gray_img = input image (grayscale or binary) kernel = optional neighborhood, expressed as an array of 1s and 0s. If None, use cross-shaped structuring element. :param gray_img: ndarray :param kernel = ndarray :return filtered_img: ndarray """ params.device += 1 # Make sure the image is binary/grayscale if len(np.shape(gray_img)) != 2: fatal_error("Input image must be grayscale or binary") # If image is binary use the faster method if len(np.unique(gray_img)) == 2: bool_img = morphology.binary_opening(gray_img, kernel) filtered_img = np.copy(bool_img.astype(np.uint8) * 255) # Otherwise use method appropriate for grayscale images else: filtered_img = morphology.opening(gray_img, kernel) if params.debug == 'print': print_image(filtered_img, os.path.join(params.debug_outdir, str(params.device) + '_opening' + '.png')) elif params.debug == 'plot': plot_image(filtered_img, cmap='gray') return filtered_img
def detectOpticDisc(image): kernel = octagon(10, 10) thresh = threshold_otsu(image[:,:,1]) binary = image > thresh print binary.dtype luminance = convertToHLS(image)[:,:,2] t = threshold_otsu(luminance) t = erosion(luminance, kernel) labels = segmentation.slic(image[:,:,1], n_segments = 3) out = color.label2rgb(labels, image[:,:,1], kind='avg') skio.imshow(out) x, y = computeCentroid(t) print x, y rows, cols, _ = image.shape p1 = closing(image[:,:,1],kernel) p2 = opening(p1, kernel) p3 = reconstruction(p2, p1, 'dilation') p3 = p3.astype(np.uint8) #g = dilation(p3, kernel)-erosion(p3, kernel) #g = rank.gradient(p3, disk(5)) g = cv2.morphologyEx(p3, cv2.MORPH_GRADIENT, kernel) #markers = rank.gradient(p3, disk(5)) < 10 markers = drawCircle(rows, cols, x, y, 85) #markers = ndimage.label(markers)[0] #skio.imshow(markers) g = g.astype(np.uint8) #g = cv2.cvtColor(g, cv2.COLOR_GRAY2RGB) w = watershed(g, markers) print np.max(w), np.min(w) w = w.astype(np.uint8) #skio.imshow(w) return w
def opening(img): orig_img = util.img_as_ubyte(img) selem = morphology.disk(6) eroded = morphology.opening(orig_img, selem) plot_comparison(orig_img, eroded, 'Opening') plt.tight_layout() plt.show()
def judge(img): #判断能否识别验证码 img = img[97:, :] img = gaussian(img, sigma=0.85) img = equalize_hist(img) img = (img > 0.7) * 1.0 img = opening(img, selem=np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]])) image_region = img * 0 img = label(img, connectivity=1) props = regionprops(img) cnt = 0 centerx = [] width = [] for i in range(np.max(img)): if props[i]['area'] > 290: image_region = image_region + (img == props[i]['label']) centerx.append(props[i]['centroid'][1]) width.append(props[i]['image'].shape[1]) cnt += 1 # 八个连通域 if cnt != 8: return False # 连通域之间距离;宽高比 centerx.sort() if np.std(np.diff(np.array(centerx))) > 10 or np.min(np.array(width)) < 18: return False return True
def apply_opening(binary_img, selem_parameter=7, remove_objects=1000): ''' This function applies opening algorithm to the input binary map and remove small objects afterwards. Opening can remove small bright spots (i.e. “salt”) and connect small dark cracks. This tends to “open” up (dark) gaps between (bright) features. Input ---------- binary_img: ndarray input binary image, where foreground denotes detected violet cells selem_parameter: int, default 7 parameter affects the neighborhood structure in opening algorithm remove_objects: int, default 1000 the smallest allowable object size. Returns ------- opened_image: ndarray the binary image after opening algorithm and removing small objects ''' selem = disk(selem_parameter) opened_image = opening(binary_img, selem) opened_image = remove_small_objects(opened_image.astype(bool), remove_objects).astype(np.int64) return opened_image
def binarization(mat, ratio=0.3, thres=None, denoise=True): """ Apply a list of operations: binarizing an 2D array; inverting the contrast of dots if needs to; removing border components; cleaning salty noise; and filling holes. Parameters ---------- mat : array_like 2D array. ratio : float Used to select the ROI around the middle of the image for calculating threshold. thres : float, optional Threshold for binarizing. Automatically calculated if None. Returns ------- array_like 2D binary array. """ if denoise: mat = ndi.median_filter(np.abs(mat), (2, 2)) if thres is None: thres = threshold_otsu(_select_roi(mat, ratio), nbins=512) mat = np.asarray(mat > thres, dtype=np.float32) mat = _invert_dots_contrast(mat) mat = clear_border(mat) mat = morph.opening(mat, morph.disk(1)) mat = np.int16(ndi.binary_fill_holes(mat)) return mat
def imagePreProcess(imgPath, imgName): fpath = "%s/%s" % (imgPath, imgName) tdata = fits.getdata(fpath) ''' imgAvg = np.average(tdata) imgRms = np.std(tdata) thred1 = imgAvg + 0.5 * imgRms img2 = np.zeros(tdata.shape) img2[tdata<thred1]=0 img2[tdata>=thred1]=1 kernel = np.ones((3,3)) sub1 = cv2.filter2D(img2, -1, kernel) sub1[sub1<6]=0 sub1[sub1>0]=255 ''' sub1 = morphology.opening(tdata, morphology.square(3)) #闭运算 timg = getThumbnail_(sub1, stampSize=(100, 100), grid=(5, 5), innerSpace=1) timg = scipy.ndimage.zoom(timg, 4, order=0) import matplotlib.pyplot as plt plt.figure(figsize=(12, 12)) plt.imshow(timg, cmap='gray') plt.show()
def opening_ski(image, opening_para, shape_type=MorpShapeSKI.disk, is_binary=True): """ 开运算 :param image: 输入的图像 :param shape_type: { 'square' # 正方形 'disk' # 平面圆形 'ball' # 球形 'cube' # 立方体形 'diamond' # 钻石形 'rectangle' # 矩形 'star' # 星形 'octagon' # 八角形 'octahedron' # 八面体 } :param opening_para: 开运算系数 :param is_binary: 输入的图像是否是二值化的, 如果是会调用 binary_opening 方法加速, 默认为 True :return: 处理后的图像 """ if is_binary: image = morphology.binary_opening(image, shape_type(opening_para)) else: image = morphology.opening(image, shape_type(opening_para)) return image
def _generate_tissue_mask(wsi, level): """ To generate a tissue mask for the WSI. This is achieved by Otsu thresholding on the saturation channel, then to remove the noise morphological closing and opening operations are applied. :param wsi: openSlide object for the WSI :param level:the level to process the mask generation at :return: the generated mask """ temp = wsi.read_region(location=(0, 0), level=level, size=wsi.level_dimensions[level]) # Convert to Hue-Saturation-Value. hsv = color.convert_colorspace(temp, 'RGB', 'HSV') # Get saturation channel. saturation = hsv[:, :, 1] # Otsu threshold. threshold = filters.threshold_otsu(saturation) # Tissue is 'high saturation' region. mask = (saturation > threshold) # Morphological operations----------------- # radius of disk for morphological operations. disk_r = 10 disk_o = disk(disk_r) # remove pepper noise mask = closing(mask, disk_o) # remove salt noise mask = opening(mask, disk_o) return mask
def create_mask(img, background_probability=0.75, use_triangle=False, use_otsu=False): test_mask = None if use_triangle: test_mask = sitk.GetArrayFromImage(sitk.TriangleThreshold(img, 0, 1)) elif use_otsu: test_mask = sitk.GetArrayFromImage(sitk.OtsuThreshold(img, 0, 1)) else: if type(img) is sitk.SimpleITK.Image: img = sitk.GetArrayFromImage(img) gmix = GaussianMixture(n_components=3, covariance_type='full', init_params='kmeans', verbose=0) gmix.fit(img.ravel().reshape(-1, 1)) covariances = gmix.covariances_ mean_background = gmix.means_.min() covariance_background = covariances[np.where( gmix.means_ == mean_background ) ][0][0] z_score = st.norm.ppf(background_probability) threshold = z_score * np.sqrt(covariance_background) + mean_background test_mask = (img > threshold) eroded_im = morphology.opening(test_mask, selem=morphology.ball(2)) connected_comp = skimage.measure.label(eroded_im) out = skimage.measure.regionprops(connected_comp) area_max = 0.0 idx_max = 0 for i in range(len(out)): if out[i].area > area_max: area_max = out[i].area idx_max = i+1 connected_comp[ connected_comp != idx_max ] = 0 mask = connected_comp mask_sitk = sitk.GetImageFromArray(mask) mask_sitk.CopyInformation(img) return mask_sitk
def init_Segmentation(phase_contrast_img, shape_indexing_sigma=2): # shape_indexed = Shape_indexing_normalization(phase_contrast_img, \ shape_indexing_sigma=shape_indexing_sigma) # ph_gau = filters.gaussian(phase_contrast_img, sigma=1) ph_binary_glob = (ph_gau < filters.threshold_isodata(ph_gau)) * 1 ph_binary_local = (ph_gau < filters.threshold_local( ph_gau, method="mean", block_size=15)) ph_binary_local[morphology.dilation(ph_binary_glob, morphology.disk(5)) == 0] = 0 ph_binary_local.dtype = bool ph_binary_local = morphology.remove_small_objects(ph_binary_local, min_size=80) ph_binary_local = morphology.remove_small_holes(ph_binary_local, area_threshold=80) * 1 ph_binary_local = morphology.opening(ph_binary_local, morphology.disk(1)) * 1 # deprecated #if use_shape_indexed_binary: # shape_indexed_binary = util.invert(shape_indexed > filters.threshold_local(shape_indexed, 27)) # shape_indexed_binary[ph_binary_local == 0] = 0 # shape_indexed_binary = (filters.median(shape_indexed_binary, morphology.disk(3)))*1 # shape_indexed_binary = (morphology.remove_small_holes(shape_indexed_binary, area_threshold=100))*1 # microcolony_labels = measure.label(ph_binary_local, connectivity=1) region_info = measure.regionprops(microcolony_labels, coordinates='xy') #return ph_binary_local, shape_indexed, shape_indexed_binary, microcolony_labels, region_info return ph_binary_local, shape_indexed, microcolony_labels, region_info
def central_pixel_without_cells(pixels: np.array): """ Find the location closest to the center that does not have an object (cell) near by :param pixels: Input image as n.array :return: location as a tuple, or False if not found """ s2 = disk(2) s15 = disk(15) binary = pixels > threshold_triangle(pixels) opened = opening(binary, s2) dilated = dilation(opened, s15) location = [pixels.shape[0] // 2, pixels.shape[1] // 2] center = [pixels.shape[0] // 2, pixels.shape[1] // 2] distance = 1 test = dilated[center[0], center[1]] while test and distance < pixels.shape[0] // 2: subarray = dilated[center[0] - distance:center[0] + distance, center[1] - distance:center[1] + distance] if False in subarray: rows, cols = np.where(subarray == False) location = [ rows[0] + center[0] - distance, cols[0] + center[1] - distance ] test = False else: distance += 1 if not test: return location return False
def process_image(img): img = rank.median(img, mp.disk(1)) p1, p99 = np.percentile(img, (1, 99)) img = rescale_intensity(img, in_range=(p1, p99)) img = mp.erosion(img) img = mp.erosion(img) img = mp.opening(img, mp.square(15)) img = mp.erosion(img) MIN = 0 MAX = 100 norm = ((img - MIN) / (MAX - MIN)) * 255 norm[norm > 255] = 255 norm[norm < 0] = 0 norm = mp.erosion(norm) norm = (norm > 100) * 255 elevation_map = filters.sobel(img) markers = np.zeros_like(img) markers[img < 5] = 1 markers[img > 200] = 2 img = mp.watershed(elevation_map, markers) mean_img = (img + norm / 255) / 2 if np.mean(np.array(mean_img[:, :])) < 1.4: img = norm img = img_as_ubyte(img) img = 1 - img contours = measure.find_contours(img, 1, fully_connected='high') return contours
def opening(gray_img, kernel=None): """Wrapper for scikit-image opening functions. Opening can remove small bright spots (i.e. salt). Inputs: gray_img = input image (grayscale or binary) kernel = optional neighborhood, expressed as an array of 1s and 0s. If None, use cross-shaped structuring element. :param gray_img: ndarray :param kernel = ndarray :return filtered_img: ndarray """ params.device += 1 # Make sure the image is binary/grayscale if len(np.shape(gray_img)) != 2: fatal_error("Input image must be grayscale or binary") # If image is binary use the faster method if len(np.unique(gray_img)) == 2: bool_img = morphology.binary_opening(gray_img, kernel) filtered_img = np.copy(bool_img.astype(np.uint8) * 255) # Otherwise use method appropriate for grayscale images else: filtered_img = morphology.opening(gray_img, kernel) if params.debug == 'print': print_image( filtered_img, os.path.join(params.debug_outdir, str(params.device) + '_opening.png')) elif params.debug == 'plot': plot_image(filtered_img, cmap='gray') return filtered_img
def apply_pipeline(im, pipeline): for pip in pipeline: name = pip['name'] pms = pip['params'] if (name == 'gabor'): im = filters.gabor(im, frequency=pms['frequency'], theta=pms['theta'], bandwidth=pms['bandwidth'], mode=pms['mode']) elif (name == 'gaussian'): im = filters.gaussian(im, sigma=float(pms['sigma']), mode=pms['mode']) elif (name == 'median'): im = filters.median(im) elif (name == 'scharr'): im = filters.scharr(im) elif (name == 'roberts'): im = filters.roberts(im) # Morphology elif (name == 'closing'): im = morphology.closing(im) elif (name == 'dilation'): im = morphology.dilation(im) elif (name == 'erosion'): im = morphology.erosion(im) elif (name == 'opening'): im = morphology.opening(im) # Transforms elif (name == 'rgb2gray'): im = color.rgb2gray(im) else: print '$$$ Error: ' + name + ' not valid kernel.' return im
def process_regions(image, blur_sigma=3, opening_size=3, orientation_deviation=15, overlap_minimum=0.8): ''' Attempt to find any possible marker corner regions in a given image Inputs: - image: grayscale image that may contain a marker - blur_sigma: parameter for Gaussian blur to use on image - opening_size: parameter for morphological opening to use on image - orientation_deviation: see orientation parameter used by region_filter_heuristic(...) - overlap_minimum: see similarity parameter used by region_filter_heuristic(...) Returns: a 2-tuple of: - the image after pre-processing steps like blurring, thresholding, etc. - the list of regionprops that may be possible marker corners ''' # Blur and equalize the image image = exposure.equalize_hist(image) image = filters.gaussian(image, sigma=blur_sigma) # Use local thresholding image = (image <= filters.threshold_sauvola(image, k=0.1)) image = morphology.opening(image, selem=morphology.disk(opening_size)) # Label components in the image labeled = measure.label(image, connectivity=2) components = measure.regionprops(labeled, intensity_image=image) # Sort the components by our rectangle heuristic return image, labeled, [r for r in components if region_filter_heuristic(r, orientation_deviation, overlap_minimum)]
def _floodfill(self, img): back = Back._scharr(img) #print(type(back)) # Binary thresholding. back = back > 0.05 #print(type(back)) # Thin all edges to be 1-pixel wide. back = skm.skeletonize(back) # Edges are not detected on the borders, make artificial ones. back[0, :] = back[-1, :] = True back[:, 0] = back[:, -1] = True # Label adjacent pixels of the same color. labels = label(back, background=-1, connectivity=1) # Count as background all pixels labeled like one of the corners. corners = [(1, 1), (-2, 1), (1, -2), (-2, -2)] for l in (labels[i, j] for i, j in corners): back[labels == l] = True # Remove remaining inner edges. return skm.opening(back)
def motion_segment_morphology(frame0, frame1): #img0 = lm(cv2.imread('../input_data/cleaned_gray_tunnel_sequence/0025.png')) #img1 = lm(cv2.imread('../input_data/cleaned_gray_tunnel_sequence/0026.png')) #canny_edges0 = canny(img0).astype(int) * 255 #canny_edges1 = canny(img1).astype(int) * 255 sobel_edges0 = sobel(frame0) sobel_edges1 = sobel(frame1) sobel_edges0 = np.where(sobel_edges0 > 10, 1, 0) sobel_edges1 = np.where(sobel_edges1 > 10, 1, 0) sobel_diff = sobel_edges1 - sobel_edges0 # sobel_diff = erosion(sobel_diff, np.ones((3,3))) #sobel_diff = erosion(sobel_diff, selem=np.ones((3,3))) # sobel_diff = erosion(sobel_diff, selem=np.ones((5,5))) sobel_diff = opening(sobel_diff, selem=np.ones((7, 7))) """ sobel_diff = dilation(sobel_diff, selem=np.ones((11,11))) sobel_diff = dilation(sobel_diff, selem=np.ones((11,11))) sobel_diff = dilation(sobel_diff, selem=np.ones((3,3))) sobel_diff = dilation(sobel_diff, selem=np.ones((5,5))) sobel_diff = dilation(sobel_diff, selem=np.ones((7,7))) sobel_diff = dilation(sobel_diff, selem=np.ones((9,9))) sobel_diff = closing(sobel_diff, selem=np.ones((11,11))) sobel_diff = closing(sobel_diff, np.ones((15,15))) """ sobel_diff = closing(sobel_diff, selem=np.ones((41, 41))) sobel_diff = dilation(sobel_diff, selem=np.ones((25, 25))) sobel_diff = closing(sobel_diff, selem=np.ones((1, 27))) sobel_diff = closing(sobel_diff, selem=np.ones((27, 1))) #sobel_diff = closing(sobel_diff, selem=np.ones((25,25))) r = sobel_diff.astype(int) * 255 return r
def polar_hull(slc): """Find the largest convex region using a polar transform.""" old_dtype = slc.dtype # Convert to polar coordinates slc = slc.astype('uint8') * 256 center = center_of_mass(slc) center_is_valid = not np.any(np.isnan(center)) if not center_is_valid: log.warning("Unvalid center by center of mass method. " "Defaulting to center of image") center = None log.debug("Performing polar transform") pim, ptSettings = polarTransform.convertToPolarImage(slc, center=center) log.debug("Applying anisotropic morphology filters to polar image.") pim = pim.astype('bool') pim = ndimage.median_filter(pim, size=9) pim = closing(pim, selem=np.ones((10, 1))) pim = opening(pim, selem=np.ones((1, 10))) # Mesh grid in order to compare edge positions my, mx = np.mgrid[:pim.shape[0], :pim.shape[1]] # Find the outside of the shape in the x direction log.debug("Calculating hull boundary") edge_r_idx = pim.shape[1] - np.argmax(pim[:, ::-1], axis=1) edge_r_idx[edge_r_idx == pim.shape[1]] = 0 edge_r = mx < edge_r_idx[:, np.newaxis] edge_r = ndimage.median_filter(edge_r, size=9) log.debug("Performing inverse polar transform") hull, uptSetting = polarTransform.convertToCartesianImage( edge_r.astype('uint8') * 256, settings=ptSettings) return hull.astype(old_dtype)
def preprocess_nucl( im_nucl, shift_planes=0, filter='median', sigma=1, outstem='', save_steps=False, ): """Preprocess nuclear channel. - shift in z by an integer number of planes. - greyscale opening. - in-plane smoothing. - difference of gaussians. """ # preprocess dapi: shift in z, opening and smoothing # TODO: move this step outside of this segmentation pipeline # it's too data-acquisition specific NOTE: (into sumsplit?) nucl_pp = shift_channel(im_nucl.ds[:], n_planes=shift_planes) if save_steps: write(nucl_pp, outstem, '_shifted', im_nucl) selem = None # TODO nucl_pp = opening(nucl_pp, selem=selem, out=nucl_pp) if save_steps: write(nucl_pp, outstem, '_opened', im_nucl) nucl_pp = smooth_channel_inplane(nucl_pp, sigma, filter) im_nucl_pp = write(nucl_pp, outstem, '_preprocess', im_nucl) return im_nucl_pp
def open_binary(img_binary, k=5, plot=True, verbose=True): if verbose: print('\t - Removing artifacts with disk of radius %d' % k) opened = opening(img_binary, disk(k)) if plot: d.compare2(img_binary, opened, 'Opening: k = %d' % k) return opened
def preprocess(self): # edges = filters.sobel(self.gray) # edges = img_as_ubyte(edges) ret, binary = cv2.threshold(self.gray, 0, 255, cv2.THRESH_OTSU + cv2.THRESH_BINARY) binary = 255 - binary # if SAVE_IMAGES_TAG: # cv2.imwrite(IMAGE_PATH + str(self.num) + "_binary.png", binary) lines = cv2.HoughLinesP(binary, rho=1.0, theta=np.pi / 180, threshold=PREPROCESS_THRESHOLD, lines=None, minLineLength=PREPROCESS_MINLINELENGTH, maxLineGap=PREPROCESS_MAXLINEGAP) if type(lines) == np.ndarray: for line in lines: x1, y1, x2, y2 = line[0][0], line[0][1], line[0][2], line[0][3] cv2.line(binary, (x1, y1), (x2, y2), 0, PREPROCESS_WIPEWIDTH) # cv2.line(self.img, (x1, y1), (x2, y2), (0, 255, 255), 5) binary = sm.opening(binary, sm.square(PREPROCESS_FIRSTSQUARE)) # if SAVE_IMAGES_TAG: # cv2.imwrite(IMAGE_PATH + str(self.num) + "_binary1.png", binary) binary = sm.dilation(binary, sm.square(PREPROCESS_FIRSTSQUARE)) self.dilation = sm.dilation(binary, sm.square(PREPROCESS_SECONDSQUARE)) # self.dilation = sm.dilation(binary, sm.square(PREPROCESS_FIRSTSQUARE)) if SAVE_IMAGES_TAG: cv2.imwrite(IMAGE_PATH + '\\' + str(self.num) + ".png", self.img)
def extended_morphological_profile(self, components, disk_radius): """ :param components: :param disk_radius: :return:2-dim emp """ rows, cols, bands = components.shape n = disk_radius.__len__() import numpy as np emp = np.zeros((rows * cols, bands * (2 * n + 1))) from skimage.morphology import opening, closing, disk for band in range(bands): position = band * (n * 2 + 1) + n emp_ = np.zeros((rows, cols, 2 * n + 1)) emp_[:, :, n] = components[:, :, band] i = 1 for r in disk_radius: closed = closing(components[:, :, band], selem=disk(r)) opened = opening(components[:, :, band], selem=disk(r)) emp_[:, :, n - i] = closed emp_[:, :, n + i] = opened i += 1 emp[:, position - n:position + n + 1] = emp_.reshape((rows * cols, 2 * n + 1)) return emp.reshape(rows, cols, bands * (2 * n + 1))
def create_mask(img, use_triangle=False): """Creates a mask of the image to separate brain from background using triangle or otsu thresholding. Otsu thresholding is the default. Parameters: ---------- img : {SimpleITK.SimpleITK.Image} Image to compute the mask on. use_triangle : {bool}, optional Set to True if you want to use triangle thresholding. (the default is False, which results in Otsu thresholding) Returns ------- SimpleITK.SimpleITK.Image Binary mask with 1s as the foreground and 0s as the background. """ test_mask = None if use_triangle: test_mask = sitk.GetArrayFromImage(sitk.TriangleThreshold(img, 0, 1)) else: test_mask = sitk.GetArrayFromImage(sitk.OtsuThreshold(img, 0, 1)) eroded_im = morphology.opening(test_mask, selem=morphology.ball(2)) connected_comp = skimage.measure.label(eroded_im) out = skimage.measure.regionprops(connected_comp) area_max = 0.0 idx_max = 0 for i in range(len(out)): if out[i].area > area_max: area_max = out[i].area idx_max = i + 1 connected_comp[connected_comp != idx_max] = 0 mask = connected_comp mask_sitk = sitk.GetImageFromArray(mask) mask_sitk.CopyInformation(img) return mask_sitk
def saturation_mask(img_rgb, saturation=0.75, remove=0, rejoin=5): # params: saturation_param = saturation remove_disk_param = remove rejoin_square_param = rejoin # split to h s v img = rgb2hsv(img_rgb) h = img[:, :, 0] s = img[:, :, 1] v = img[:, :, 2] # create mask mask = (s > saturation_param).astype(np.uint8) # remove small regions from mask disk_elem = disk(remove_disk_param) opened = opening(mask, selem=disk_elem) # rejoin colored pionts square_elem = square(rejoin_square_param) dilated = dilation(opened, selem=square_elem) io.imshow(dilated) plt.show() return dilated.astype(bool)
def predict(self, file_path): X = load_imgs([file_path], im_shape=(512, 256)) xx_ = X[0, :, :, :] xx = xx_[None, ...] inp_shape = X[0].shape pred = self.UNet.predict(xx)[..., 0].reshape(inp_shape[:2]) # Binarize masks pr = pred > 0.5 pr_bin = img_as_ubyte(pr) pr_openned = morphology.opening(pr_bin) im_x_ray_original_size = cv2.imread(file_path, cv2.IMREAD_GRAYSCALE) height, width = im_x_ray_original_size.shape[: 2] # height, width -- original image size ratio = float(height) / width new_shape = (4 * 256, int(4 * 256 * ratio)) im_x_ray_4x = cv2.resize(im_x_ray_original_size, new_shape) pr_openned_4x = cv2.resize(pr_openned, new_shape) gt_4x = cv2.resize(img_as_ubyte(pr), new_shape) gt_4x = gt_4x > 0.5 pr_openned_4x = pr_openned_4x > 0.5 im_masked_4x = masked(im_x_ray_4x, gt_4x, pr_openned_4x, 0.5) # img.max()=1.0 gt.max()=True pr.max()=True im_masked_4x = img_as_ubyte(im_masked_4x) io.imsave(file_path, im_masked_4x)
def get_nuclei(img, opening_radius=6, block_size=80, threshold_offset=0): s = Sample(DOWNSAMPLE) binary = threshold_adaptive(s.downsample(img), int(block_size / s.rate), offset=threshold_offset) filled = fill_holes(binary) opened = opening(filled, selem=disk(opening_radius / s.rate)) nuclei = apply_watershed(opened) nuclei = s.upsample(nuclei) return img_as_uint(nuclei)
def ProcessImage(im, targetDim = 250, doDenoiseOpening = True): #Resize to specified pixels max edge size scaling = 1. if im.shape[0] > im.shape[1]: if im.shape[0] != targetDim: scaling = float(targetDim) / im.shape[0] im = misc.imresize(im, (targetDim, int(round(im.shape[1] * scaling)))) else: if im.shape[1] != targetDim: scaling = float(targetDim) / im.shape[1] im = misc.imresize(im, (int(round(im.shape[0] * scaling)), targetDim)) #print "scaling", scaling greyim = 0.2126 * im[:,:,0] + 0.7152 * im[:,:,1] + 0.0722 * im[:,:,2] #Highlight number plate imnorm = np.array(greyim, dtype=np.uint8) se = np.ones((3, 30), dtype=np.uint8) opim = morph.opening(imnorm, se) diff = greyim - opim + 128. misc.imsave("diff.png", diff) #Binarize image vals = diff.copy() vals = vals.reshape((vals.size)) meanVal = vals.mean() stdVal = vals.std() threshold = meanVal + stdVal #print "Threshold", threshold binIm = diff > threshold misc.imsave("threshold.png", binIm) #print vals.shape #plt.plot(vals) #plt.show() #Denoise diamond = morph.diamond(2) if doDenoiseOpening: currentIm = morph.binary_opening(binIm, diamond) else: currentIm = binIm denoiseIm2 = morph.binary_closing(currentIm, np.ones((3, 13))) #print "currentIm", currentIm.min(), currentIm.max(), currentIm.mean() #print "denoiseIm2", denoiseIm2.min(), denoiseIm2.max(), currentIm.mean() #misc.imsave("denoised1.png", currentIm * 255) #misc.imsave("denoised2.png", denoiseIm2 * 255) #Number candidate regions #print "Numbering regions" numberedRegions, maxRegionNum = morph.label(denoiseIm2, 4, 0, return_num = True) return numberedRegions, scaling
def func(frame): _dtype = frame.dtype kernel = mor.disk(3) frameWP = frame - mor.white_tophat(frame, kernel) * (mor.white_tophat(frame, kernel) > 1000).astype(float) kernel = mor.rectangle(25, 1) closed = mor.closing(frameWP, kernel) opened = mor.opening(closed, kernel) result = ((frameWP.astype(float) / opened.astype(float)) * 3000.0) return result.astype(_dtype)
def segment_image(image, plantid, threshold, locations, opening_size=5): """ Segments an image based on simple thresholding Inputs: - image : the image (as a numpy array) - plantid : which plant on the image (int) - threshold : the threshold to use - locations : the coordinates of the plants in the Output: - mask of the image """ image_part = get_piece(image, locations[plantid]) mask = median_filter(image_part.mean(2), (4,4)) > threshold opening(mask, selem=square(opening_size), out=mask) # open image, remove # clutter return mask # gaussian_filter(image_part[mask, :], sigma=convolve_sigma)
def find_border_centroids(hfp, keys, areas, largeobjkey, disttransfkey, resultkey): for k, bounds in keys.iteritems(): # bounds = (shp[0],) * 2 for lbl, lblim in hfp['faces', largeobjkey].label_image_iterator(key=k, background=0, area=areas[k]): hfp.logging('---\nLabel {} found in image {}', lbl, k) # Avoid very small artifacts lblim = morphology.opening(lblim) # Connected component analysis to detect when a label touches the border multiple times conncomp = vigra.analysis.labelImageWithBackground(lblim.astype(np.uint32), neighborhood=8, background_value=0) for l in np.unique(conncomp): # Ignore background if l == 0: continue # Get the current label object curobj = conncomp == l # Get disttancetransf of the object curdist = np.array(hfp['faces', disttransfkey, k]) curdist[curobj == False] = 0 # Detect the global maximum of this object amax = np.amax(curdist) curdist[curdist < amax] = 0 curdist[curdist > 0] = lbl # Only one pixel is allowed to be selected bds = lib.find_bounding_rect(curdist) centroid = (int((bds[1][0] + bds[1][1]-1) / 2), int((bds[0][0] + bds[0][1]-1) / 2)) # Now translate the calculated centroid to the position within the orignial 3D volume centroidm = (centroid[0] - bounds, centroid[1] - bounds) # hfp.logging('centroidxy = {}', centroidm) # Set the pixel try: if centroidm[0] < 0 or centroidm[1] < 0: raise IndexError else: if k == 'xyf': hfp[resultkey][centroidm[0], centroidm[1], 0] = lbl elif k == 'xyb': hfp[resultkey][centroidm[0], centroidm[1], -1] = lbl elif k == 'xzf': hfp[resultkey][centroidm[0], 0, centroidm[1]] = lbl elif k == 'xzb': hfp[resultkey][centroidm[0], -1, centroidm[1]] = lbl elif k == 'yzf': hfp[resultkey][0, centroidm[0], centroidm[1]] = lbl elif k == 'yzb': hfp[resultkey][-1, centroidm[0], centroidm[1]] = lbl except IndexError: pass
def GrayMM(img,thresh,size): structElement = morphology.rectangle(size,size) img[img == -9999] = 0 img = img/5000 img[img < 0] = 0 img[img > 1] = 1 outdata = morphology.opening(img, structElement) #threshold after bin imgOut = outdata > 255*thresh/5000 return imgOut
def ROI_binary_mask(sample, size=5, ticket=(80, 80, 80)): # very slow function at resolution 4 PreprocRes = np.copy(sample) for i in range(3): # RGB # this one is painfully slow.. PreprocRes[:, :, i] = Preprocessing(sample[:, :, i]) res = combining(PreprocRes) ticket = FindTicket(sample, ticket) res = res - ticket res[res > 0] = 1 res[res < 0] = 0 res = opening(res, disk(size)) return res
def buffer_mask(stuff): stuff_shape = stuff.shape stuff_buff = np.array(np.copy(stuff)) for x in range(1,stuff_shape[0]): for y in range(1,stuff_shape[1]): if stuff[x,y] == False: if np.count_nonzero(stuff[x-1:x+2,y-1:y+2]) > 4: # print x,y stuff_buff[x,y] = True selem = morphology.disk(1) stuff_buff = morphology.opening(stuff_buff, selem) selem = morphology.disk(1) stuff_buff = morphology.closing(stuff_buff, selem) return stuff_buff
def label_clouds(pcp, opening_selem, closing_selem): # img = buffer_pcl() # pcp = calc_pcp img = pcp _img = np.zeros((img.shape[0]+30, img.shape[1]+30)) _img[15:-15, 15:-15] = img o_selem = morphology.disk(opening_selem) _img = morphology.opening(_img, o_selem) c_selem = morphology.disk(closing_selem) bin_im = morphology.closing(_img, c_selem) labels, nbr_objs = measurements.label(bin_im) print(nbr_objs) return labels[15:-15, 15:-15], nbr_objs
def clean_footprint(self, OPENING_THRESH = 5): self.FOOTPRINT_cleaned_opening = opening(self.FOOTPRINT_added_boundary, square(OPENING_THRESH)) labeled_image, num_of_labels = ndimage.measurements.label(self.FOOTPRINT_cleaned_opening, [[1,1,1],[1,1,1],[1,1,1]]) if num_of_labels > 1: b_slices = ndimage.find_objects(labeled_image) area = [] for idx,s in enumerate(b_slices): area.append(len(self.FOOTPRINT_cleaned_opening[self.FOOTPRINT_cleaned_opening[s] != 0])) self.FOOTPRINT_cleaned_opening[labeled_image != (area.index( max(area))) + 1] = 0 # area = np.bincount(obj.flatten())[indexedObject[0]] return len(self.FOOTPRINT_cleaned_opening[self.FOOTPRINT_cleaned_opening!=0])
def FindTicket(RGB_image, _3tuple=(80, 80, 80)): # Find the "black ticket on the images" temp_image_3 = np.copy(RGB_image) temp_image_3[:, :, :] = 0 for i in range(3): temp_image_1 = np.zeros(shape=RGB_image.shape[0:2]) temp_image_1[np.where(RGB_image[:, :, i] < _3tuple[i])] = 1 temp_image_3[:, :, i] = temp_image_1 temp_resultat = temp_image_3.sum(axis=2) temp_resultat[temp_resultat > 2] = 3 temp_resultat[temp_resultat < 3] = 0 temp_resultat[temp_resultat == 3] = 1 #temp_resultat = Filling_holes_2(temp_resultat) temp_resultat = closing(temp_resultat, disk(20)) temp_resultat = opening(temp_resultat, disk(20)) temp_resultat = RemoveBorder(temp_resultat) return temp_resultat
def _floodfill(self, img): back = self._scharr(img) # Binary thresholding. back = back > 0.05 # Thin all edges to be 1-pixel wide. back = skm.skeletonize(back) # Edges are not detected on the borders, make artificial ones. back[0, :] = back[-1, :] = True back[:, 0] = back[:, -1] = True # Label adjacent pixels of the same color. labels = label(back, background=-1, connectivity=1) # Count as background all pixels labeled like one of the corners. corners = [(1, 1), (-2, 1), (1, -2), (-2, -2)] for l in (labels[i, j] for i, j in corners): back[labels == l] = True # Remove remaining inner edges. return skm.opening(back)
def change_bg(orig, background=None, threshold_yellow=[(80, 145), (65, 145), (0, 50)], threshold_black=[(0, 30), (0, 30), (0, 30)], threshold_face=[(42, 90), (20, 70), (0, 42)], show_pic=False, ): thresholds = [threshold_yellow, threshold_black, threshold_face] if background is None: background = orig * 0 background = array(Image.fromarray(background).resize(orig.shape[:2][::-1])) masks = [orig.copy() for i in range(len(thresholds))] for mask_i, threshold in enumerate(thresholds): for i, (th_lo, th_hi) in enumerate(threshold): masks[mask_i][:, :, i] = (th_lo <= masks[mask_i][:, :, i]).astype(int) * (masks[mask_i][:, :, i] <= th_hi).astype(int) mask = masks[mask_i][:, :, 0] * masks[mask_i][:, :, 1] * masks[mask_i][:, :, 2] masks[mask_i][:, :, 0], masks[mask_i][:, :, 1], masks[mask_i][:, :, 2] = [mask for i in range(3)] mask = 1-reduce(lambda x, y: x * y, [1-w for w in masks]) mask_orig = mask.copy() mask = morphology.dilation(mask, ones([10, 3, 1])) mask = morphology.opening(mask, ones([18, 12, 1])) mask = morphology.dilation(mask, ones([3, 6, 1])) result = (orig * mask + background * (1 - mask)) if show_pic: subplot(221) imshow(orig) title('orig') subplot(222) imshow(mask*255) title('mask') subplot(223) imshow(mask_orig*255) title('mask_orig') subplot(224) imshow(result) title('result') show() return result, mask, mask_orig
Notice how the white boundary of the image thickens, or gets dilated, as we increase the size of the disk. Also notice the decrease in size of the two black ellipses in the centre, and the thickening of the light grey circle in the center and the 3 patches in the lower part of the image. Opening ======= Morphological ``opening`` on an image is defined as an *erosion followed by a dilation*. Opening can remove small bright spots (i.e. "salt") and connect small dark cracks. """ opened = opening(phantom, selem) plot_comparison(phantom, opened, 'opening') """ .. image:: PLOT2RST.current_figure Since ``opening`` an image starts with an erosion operation, light regions that are *smaller* than the structuring element are removed. The dilation operation that follows ensures that light regions that are *larger* than the structuring element retain their original size. Notice how the light and dark shapes in the center their original thickness but the 3 lighter patches in the bottom get completely eroded. The size dependence is highlighted by the outer white ring: The parts of the ring thinner than the structuring element were completely erased, while the thicker region at the top retains its original thickness.
def demoMorphologicalOperationsImage(self, filename='/Users/mangotee/Dropbox/Teaching/CDTM ARdrones Lecture/imgTennisBallBed.jpg'): img = cv2.imread(filename) mask = self.utilFilterColorRGB(img,np.array([0, 255, 255]), 8) displayOpenCV = False if displayOpenCV: cv2.imshow('img',img) cv2.imshow('mask',mask) cv2.waitKey(0) cv2.destroyAllWindows() else: #fname = '/Users/mangotee/Dropbox/Teaching/CDTM ARdrones Lecture/imgTennisBallBed_v1_colfilSingle.png' #cv2.imwrite(fname,np.uint8(mask)) maskLargestComponent = self.findLargestComponent(mask) fig1 = plt.figure(facecolor='w') #fig1.set_tight_layout(True) #plt.use('Agg') plt.subplot(121),plt.imshow(self.utilCvColorOpenCV2Matplotlib(img)),plt.title('Image') plt.axis('off') plt.subplot(122),plt.imshow(mask, cmap='gray'),plt.title('Mask') plt.axis('off') #fname = '/Users/mangotee/Dropbox/Teaching/CDTM ARdrones Lecture/imgTennisBallBed_v1_colfil.png' #plt.savefig(fname) plt.show() fig2 = plt.figure(facecolor='w') plt.subplot(131),plt.imshow(self.utilCvColorOpenCV2Matplotlib(img)),plt.title('Image') plt.axis('off') plt.subplot(132),plt.imshow(mask, cmap='gray'),plt.title('Mask') plt.axis('off') plt.subplot(133),plt.imshow(maskLargestComponent, cmap='gray'),plt.title('Largest Component') plt.axis('off') fname = '/Users/mangotee/Dropbox/Teaching/CDTM ARdrones Lecture/imgTennisBallBed_v2_LargestComp.png' plt.savefig(fname) plt.show() # morphological operations on the largest component se = morphology.disk(9) maskLCmorph = morphology.opening(maskLargestComponent, se) maskLCmorph = morphology.closing(maskLCmorph, se) fig3 = plt.figure(facecolor='w') plt.subplot(131),plt.imshow(self.utilCvColorOpenCV2Matplotlib(img)),plt.title('Image') plt.axis('off') plt.subplot(132),plt.imshow(maskLargestComponent, cmap='gray'),plt.title('Largest Component') plt.axis('off') plt.subplot(133),plt.imshow(maskLCmorph, cmap='gray'),plt.title('Opening/Closing') plt.axis('off') fname = '/Users/mangotee/Dropbox/Teaching/CDTM ARdrones Lecture/imgTennisBallBed_v3_LargestCompMorph.png' plt.savefig(fname) plt.show() # hough circle detection on the image circles = cv2.HoughCircles(maskLCmorph, cv2.cv.CV_HOUGH_GRADIENT, 1, param1=200, param2=10, minDist=250, minRadius=80) # and here #print "start Hough" if circles is not None: #print circles circles = np.round(circles[0, :]).astype("int") for (x, y, r) in circles: print 'x=%0.2f y=%0.2f r=%0.2f' % (x,y,r) cv2.circle(img, (x, y), r, color=[0,0,255], thickness=4) #cv2.rectangle(gray, (x - 5, y - 5), (x + 5, y + 5), (0, 128, 255), -1) cv2.imshow('result',img) fname = '/Users/mangotee/Dropbox/Teaching/CDTM ARdrones Lecture/imgTennisBallBed_v4_LargestCompMorphWithHoughCircle.png' cv2.imwrite(fname,img) fname = '/Users/mangotee/Dropbox/Teaching/CDTM ARdrones Lecture/imgTennisBallBed_v4_LargestCompMorph.png' cv2.imwrite(fname,maskLCmorph)
def special(video_name): if not os.path.exists(global_path + video_name[video_name.rfind('/') + 1:video_name.rfind('.')]): os.makedirs(global_path + video_name[video_name.rfind('/') + 1:video_name.rfind('.')]) print video_name[video_name.rfind('/') + 1:video_name.rfind('.')] #main loop first_detect = True video = VideoFileClip(video_name) folder_name = global_path + video_name[video_name.rfind('/') + 1:video_name.rfind('.')] + "/" print folder_name mean_r = np.zeros((video.size[1], video.size[0], size)) mean_g = np.zeros((video.size[1], video.size[0], size)) mean_b = np.zeros((video.size[1], video.size[0], size)) for i in range(0, size): mean_r[:,:,i] = video.get_frame(i * step / video.fps)[:,:,0] mean_b[:,:,i] = video.get_frame(i * step / video.fps)[:,:,1] mean_g[:,:,i] = video.get_frame(i * step / video.fps)[:,:,2] cell_size = 300 #detect = np.zeros((int(round((float(video.size[1]) / cell_size))), int(round(float(video.size[0]) / cell_size)))) #detect = np.zeros((amount_height, amount_width, length_size)) detect = [] start = time.time() num_frame_in_background = 0 for frame in range(size * step + step, int(video.duration * video.fps), step): print frame background = np.dstack((np.median(mean_r, axis = 2), np.median(mean_g, axis = 2), np.median(mean_b, axis = 2))) cur_image = video.get_frame(frame / video.fps) cur_image_copy = np.copy(cur_image) cur_image_with_rectangle = np.copy(cur_image) cur_image = rgb2gray(abs(cur_image - background)) cur_image = (cur_image > 5) * 255 cur_image = opening(cur_image, disk(2)) image_label = label(cur_image) i = 0 asdf = 0 for region in regionprops(image_label): if region.area < 50: continue i = i + 1 print i y, x, y_end, x_end = region.bbox x = (x + x_end) / 2 - 50 y = (y + y_end) / 2 - 50 x_end = x + 100 y_end = y + 100 if x_end > video.size[0] - 1: x_end = video.size[0] - 1 x = x_end - 100 if y_end > video.size[1] - 1: y_end = video.size[1] - 1 y = y_end - 100 if x < 0: x = 0 x_end = x + 100 if y < 0: y = 0 y_end = y + 100 frame_info = np.zeros((100, 100, 3, 4), dtype = np.uint8) mean_r1 = np.zeros((100, 100, 4)) mean_g1 = np.zeros((100, 100, 4)) mean_b1 = np.zeros((100, 100, 4)) temp1 = np.zeros(()) for j in range(0, 4): temp1 = video.get_frame((frame + j * 5) / float(video.fps)) # imsave(folder_name + str(i) + ".jpg", temp1[y:y_end, x:x_end, :]) frame_info[:,:,:,j] = temp1[y:y_end, x:x_end,:] mean_r1[:,:,j] = temp1[y:y_end,x:x_end,0] mean_g1[:,:,j] = temp1[y:y_end,x:x_end,1] mean_b1[:,:,j] = temp1[y:y_end,x:x_end,2] temp22 = np.dstack((np.median(mean_r1, axis = 2), np.median(mean_g1, axis = 2), np.median(mean_b1, axis = 2))) # for j in range(0, 4): # temp1 = video.get_frame((frame + j * 5) / float(video.fps)) # imsave(folder_name + "%06d" % (50 * asdf + j * 5 + 1) + ".jpg", np.abs(temp1[y:y_end, x:x_end, :] - temp22)) # asdf+=1 for j in range(0, 4): frame_info[:,:,:,j] = np.abs(frame_info[:,:,:,j] - temp22) for k in range(0,100): for m in range(0,100): print frame_info[k,m,:,j] print frame_info[0,0,:,j] frame_info[:,:,:,j] = frame_info[:,:,[2, 1, 0],j].astype(np.uint8) print frame_info[10,10,:,j] imsave(global_path + "temp.jpg",frame_info[:,:,:,j]) frame_info[:,:,:,j] = cv.imread(global_path + "temp.jpg",cv.IMREAD_UNCHANGED) for k in range(0,100): for m in range(0,100): print frame_info[k,m,:,j] exit() prediction = c3d_classify( images= frame_info, image_mean=image_mean, net=net, prob_layer='prob' ) print prediction res_cnn = int(prediction.argmax()) color = (0, 0, 0) if (res_cnn == 0): color = (255, 0, 0) for i, n in enumerate(detect): center_x = (x + x_end) / 2 center_y = (y + y_end) / 2 if (n[0][0] - cell_size <= center_y <= n[0][0] + cell_size) and (n[0][1] - cell_size <= center_x <= n[0][1] + cell_size) and n[2] != frame: n[1][0] = 1 break else: detect.append((((y+y_end)/2, (x + x_end) /2), np.array([1, 0, 0, 0]), frame)) cv.rectangle(cur_image_with_rectangle, ((x + x_end) /2 - cell_size, (y+y_end)/2 - cell_size), ((x + x_end) /2 + cell_size, (y+y_end)/2 + cell_size), (0,0, 255), 2) else: color = (0, 255, 0) cv.rectangle(cur_image_with_rectangle, (x, y), (x_end, y_end), color, 2) print frame ##print detect #print for i, n in enumerate(detect): if (np.sum(n[1]) == 3 or np.sum(n[1]) == 4): #print frame / video.fps if first_detect: # f.write(' %f' % (frame / video.fps)) first_detect = False cv.rectangle(cur_image_with_rectangle,(n[0][1] - cell_size, n[0][0] - cell_size), (n[0][1] + cell_size, n[0][0] + cell_size), (255, 0, 0), 2) if (n[1][0] == 0 and n[1][1] == 1 and n[1][2] == 1): continue if (n[1][0] == 0 and n[1][1] == 1 and n[1][2] == 0): del detect[i] for i, n in enumerate(detect): n[1][1:] = n[1][0:-1] n[1][0] = 0 imsave(folder_name + str(frame) + ".png", cur_image_with_rectangle) mean_r[:,:,num_frame_in_background] = cur_image_copy[:,:,0] mean_g[:,:,num_frame_in_background] = cur_image_copy[:,:,1] mean_b[:,:,num_frame_in_background] = cur_image_copy[:,:,2] num_frame_in_background += 1 num_frame_in_background = num_frame_in_background % size print video_name, time.time() - start
def detectVessels(image): kernel = square(2) image = ndimage.gaussian_filter(image[:,:,2], 2) image = opening(image, kernel) return image
binary = binary_label == rps[region_with_largest_area].label #binary = convex_hull_image(binary) #binary = binary_dilation(binary, disk(15)) != 0 distance = distance_transform_edt(binary) local_maxi = peak_local_max(distance) # internal marker / center of [circle] <- (external marker) #################################### #################################### Gradient Image red_chan = gray_image io.imshow(red_chan) close = closing(red_chan, octagon(4,4)) io.imshow(close) opening = opening(close, octagon(6,6)) io.imshow(opening) rec = reconstruction(opening, close) rec = exposure.rescale_intensity(rec, out_range=(0,1)) gradient = gradient(rec, disk(5)) ######################################################## Apply watershed to gradient using imposed markers ### This is where I am having trouble. I have the gradient image and the internal marker location. I want ### to create a marker image with the internal marker (located at the center of the optic disk) and ### the external marker drawn as a circle around the optic disk so that the watershed algorithm can ### evaluate the specific contour of the disk when feeding in the gradient image and the marker image. ### What I need to know is how to create that marker image. ### The radius of the circle (external marker) with center as the internal marker can be anything as long as it is ### larger than the optic disk, completely covering it.
plot_comparison(orig_phantom, dilated, 'dilation') ###################################################################### # Notice how the white boundary of the image thickens, or gets dilated, as we #increase the size of the disk. Also notice the decrease in size of the two #black ellipses in the centre, and the thickening of the light grey circle #in the center and the 3 patches in the lower part of the image. # #Opening #======= # #Morphological ``opening`` on an image is defined as an *erosion followed by #a dilation*. Opening can remove small bright spots (i.e. "salt") and #connect small dark cracks. opened = opening(orig_phantom, selem) plot_comparison(orig_phantom, opened, 'opening') ###################################################################### #Since ``opening`` an image starts with an erosion operation, light regions #that are *smaller* than the structuring element are removed. The dilation #operation that follows ensures that light regions that are *larger* than #the structuring element retain their original size. Notice how the light #and dark shapes in the center their original thickness but the 3 lighter #patches in the bottom get completely eroded. The size dependence is #highlighted by the outer white ring: The parts of the ring thinner than the #structuring element were completely erased, while the thicker region at the #top retains its original thickness. # #Closing #=======
def default_masking(snr,snr_min=5.0): planemask = (snr>snr_min) planemask = remove_small_objects(planemask,min_size=40) planemask = opening(planemask,disk(1)) return(planemask)
file_thin= 'fits/Core2_N2Hp_thin_fitted_parameters_snr3.fits' snr_min = 3. cube = pyspeckit.Cube(file_in) cube.xarr.refX = freq_line cube.xarr.velocity_convention = 'radio' cube.xarr.convert_to_unit('km/s') xmax=4; ymax=6 vmin=5.0; vmax=8.0 rms_map = cube.slice(-12, -4, unit='km/s').cube.std(axis=0) peaksnr = cube.slice(vmin, vmax, unit='km/s').cube.max(axis=0)/rms_map planemask = (peaksnr>snr_min) planemask = remove_small_objects(planemask,min_size=40) planemask = opening(planemask,disk(1)) F=False T=True multicore=4 import matplotlib.pyplot as plt plt.ion() if Optically_Thin: cube.Registry.add_fitter('n2hp_vtau', pyspeckit.models.n2hp.n2hp_vtau_fitter, 4) print('start optically thin fit') cube.fiteach(fittype='n2hp_vtau', guesses=[80.0, 0.1, 6.7, 0.1], # Tex=5K, tau=0.1, v_center=7.1, \sigma_v=0.3 km/s verbose_level=1, signal_cut=snr_min, limitedmax=[F,F,T,T],
def find_map(url, min_int=0.03, max_int=0.97, disk_sz=2, opt=None): """Find the map in an image (using morphological operations) and return it. Heuristic assumption the map is the largest object in the map. Parameters ---------- img: (M, N, 3) or (M, N, 4) An RGB or RGBA image. min_int : threshold value to eliminate ~black background. If min_int is not given, a default value of 0.03 is uded. max_int : threshold value to eliminate ~white background. If max_int is not given, a default value of 0.97 is uded. disk_sz : size of disk-shaped structuring element for opening. If disk_sz is not given, a default value of 2 is uded. opt : optional flag. Default is None; if set to not None, the convex hull of the largest detected object is returned. Returns ------- out : (M, N, 3) array An image with only the main map. """ # rgb from url rspns = requests.get(url) img = np.asarray(Image.open(StringIO(rspns.content)))[:, :, :3] # image must be RGB or RGB(A) if not len(img.shape) > 2: raise ValueError("Sorry, image has to be RGB (M, N, 3) or RGBA (M, N, 4)") # remove alpha channel img = img[:, :, :3] # stretch contrast p2, p98 = np.percentile(img, (2, 98)) rescale = exposure.rescale_intensity(img, in_range=(p2, p98)) # binary from rgb binary = np.logical_and(color.rgb2gray(rescale) > min_int, color.rgb2gray(rescale) < max_int) # apply very mild opening binary = opening(binary, disk(disk_sz)) # keep only largest white object label_objects, nb_labels = ndi.label(binary) sizes = np.bincount(label_objects.ravel()) sizes[0] = 0 if nb_labels < 2: # background not included in the count binary_objects = binary # in case the image already contained only the map else: binary_objects = remove_small_objects(binary, max(sizes)) # remove holes from it binary_holes = ndi.morphology.binary_fill_holes(binary_objects) # optional: get convex hull image (smallest convex polygon that surround all white pixels) if opt is not None: binary_holes = convex_hull_image(binary_holes) # use it to make 3D mask mask3 = np.zeros(img.shape) mask3[:, :, 0] = binary_holes mask3[:, :, 1] = binary_holes mask3[:, :, 2] = binary_holes # use mask to get only map in original image final = np.ma.masked_where(mask3 == 0, img) final = final.filled(0) # crop zero columns and zero rows # see http://stackoverflow.com/a/31402351/1034648 # plus a few columns and rows to counter the initial opening non_empty = np.where(final != 0) out = final[np.min(non_empty[0]) : np.max(non_empty[0]), np.min(non_empty[1]) : np.max(non_empty[1])][ disk_sz:-disk_sz, disk_sz:-disk_sz ] # output return out
def find_border_centroids(ipl, faces, key, facesinfo, facesd, resultkey, resultshp): """ :param ipl: the result is stored here using resultkey :param faces: ipl containing faces as returned by compute_faces :param key: key of the image in ipl :param facesinfo: ipl containing facesinfo as returned by compute_faces :param facesd: ipl containing the faces of the distance transform as returned by compute_faces :param resultkey: :return: """ ipl[resultkey, key] = np.zeros(resultshp) for k, startpoint in facesinfo[key, 'startpoints'].iteritems(): # bounds = (shp[0],) * 2 for lbl, lblim in faces[key].label_image_iterator(key=k, background=0, area=facesinfo[key, 'areas', k]): ipl.logging('---\nLabel {} found in image {}', lbl, k) # Avoid very small artifacts lblim = morphology.opening(lblim) # Connected component analysis to detect when a label touches the border multiple times conncomp = vigra.analysis.labelImageWithBackground(lblim.astype(np.uint32), neighborhood=8, background_value=0) for l in np.unique(conncomp): # Ignore background if l == 0: continue # Get the current label object curobj = conncomp == l # Get disttancetransf of the object curdist = np.array(facesd[key, k]) curdist[curobj == False] = 0 # Detect the global maximum of this object amax = np.amax(curdist) curdist[curdist < amax] = 0 curdist[curdist > 0] = lbl # Only one pixel is allowed to be selected try: bds = lib.find_bounding_rect(curdist) except ValueError: # A value error is thrown when the current object is just one pixel in size # This can be ignored without ignoring relevant border contacts pass centroid = (int((bds[1][0] + bds[1][1]-1) / 2), int((bds[0][0] + bds[0][1]-1) / 2)) # Now translate the calculated centroid to the position within the orignial 3D volume centroidm = (centroid[0] - startpoint, centroid[1] - startpoint) # ipl.logging('centroidxy = {}', centroidm) # Set the pixel try: if centroidm[0] < 0 or centroidm[1] < 0: raise IndexError else: if k == 'xyf': ipl[resultkey, key][centroidm[0], centroidm[1], 0] = lbl elif k == 'xyb': ipl[resultkey, key][centroidm[0], centroidm[1], -1] = lbl elif k == 'xzf': ipl[resultkey, key][centroidm[0], 0, centroidm[1]] = lbl elif k == 'xzb': ipl[resultkey, key][centroidm[0], -1, centroidm[1]] = lbl elif k == 'yzf': ipl[resultkey, key][0, centroidm[0], centroidm[1]] = lbl elif k == 'yzb': ipl[resultkey, key][-1, centroidm[0], centroidm[1]] = lbl except IndexError: pass