Python skimage.filters 模块，gaussian_filter() 实例源码

def _extraction_iterator_corners(image, use_local_thresholding=False, apply_gaussian=False, n=5):
    # If the image is too small, then double its scale until big enough.
    img = image
    while max(img.shape) < 500:
        img = resize(img, np.array(img.shape) * 2)

    if apply_gaussian:
        img = gaussian_filter(image, (3.0, 3.0))

    for corner_points in iter_blob_extremes(img, n=n):
        try:
            warped_image = geometry.warp_image_by_corner_points_projection(corner_points, img)
            sudoku, bin_image = geometry.split_image_into_sudoku_pieces_adaptive_global(
                warped_image, otsu_local=use_local_thresholding, apply_gaussian=apply_gaussian)
        except SudokuExtractError:
            # Try next blob.
            pass
        except Exception as e:
            raise
        else:
            yield sudoku, bin_image

def _extraction_iterator_map(image, use_local_thresholding=False, apply_gaussian=False, n=5):

    if apply_gaussian:
        img = gaussian_filter(image, (3.0, 3.0))
    else:
        img = image

    for edges in iter_blob_contours(img, n=n):
        try:
            warped_image = geometry.warp_image_by_interp_borders(edges, img)
            sudoku, bin_image = geometry.split_image_into_sudoku_pieces_adaptive_global(
                warped_image, otsu_local=use_local_thresholding, apply_gaussian=apply_gaussian)
        except SudokuExtractError as e:
            pass
        except Exception as e:
            # Try next blob
            raise
        else:
            yield sudoku, bin_image

def to_binary_adaptive(img):

    sigma = 1.0
    m = max(img.shape)
    if m > 2000:
        block_size = 80
    elif m > 1500:
        block_size = 50
    elif m > 1000:
        block_size = 35
    else:
        block_size = 20

    bimg = gaussian_filter(img, sigma=sigma)
    bimg = threshold_adaptive(bimg, block_size, offset=2 / 255)
    bimg = np.array(bimg, 'uint8') * 255
    return bimg

def split_image_into_sudoku_pieces_adaptive_global(image, otsu_local=False, apply_gaussian=False):
    L = image.shape[0]
    d = int(np.ceil(L / 9))
    dd = d // 5
    output = []
    if apply_gaussian:
        image = gaussian_filter(image, sigma=1.0)
    if not otsu_local:
        image = to_binary_adaptive(image)
    for k in range(9):
        this_row = []
        start_row_i = max([k * d - dd, 0])
        stop_row_i = min([(k + 1) * d + dd, L])
        for kk in range(9):
            start_col_i = max([kk * d - dd, 0])
            stop_col_i = min([(kk + 1) * d + dd, L])
            i = image[start_row_i:stop_row_i, start_col_i:stop_col_i].copy()
            if otsu_local:
                i = to_binary_otsu(i)
            i = binary_opening(i)
            i = to_binary_otsu(i)
            if apply_gaussian:
                i = to_binary_otsu(binary_dilation(i))
            this_row.append(i)
        output.append(this_row)
    return output, image

def gaussianFilter(img,sigma=2.,debug=False,axes=None):

    """Applies gaussian filter to image.

    Args:
        img (numpy.ndarray): Input image.

    Keyword Args:
        sigma (float): Standard deviation of gaussian kernel applied.
        axes (list): List of matplotlib axes used for plotting. If not specified, will generate new ones.
        debug (bool): Print debugging messages and show debugging plots.

    Returns:
        numpy.ndarray: Processed image.
    """


    #Grab original image
    orgImg=img.copy()

    #Apply gaussian filter
    try:
        img = skifilt.gaussian_filter(img,sigma)
    except AttributeError:
        img = skifilt.gaussian(img,sigma)

    #Debugging plots
    if debug:

        #Make figure
        if axes==None:
            fig,axes = pyfrp_plot_module.makeSubplot([2,2],titles=["Original Image", "After gaussian","Histogram Original","Histogram gaussian"],sup="gaussianFilter debugging output") 

        #Get common range
        vmin,vmax=getCommonRange([orgImg,img])

        showImgAndHist(orgImg,axes=axes[0:2],vmin=vmin,vmax=vmax)
        showImgAndHist(img,axes=axes[2:],vmin=vmin,vmax=vmax)

    return img

def dslre(img):
    timestep = 1.0
    mu = 0.2/timestep
    iter_basic = 1000
    iter_refine = 10
    lambdap = 5
    alpha = 1.5 # -3
    epsilon = 1.5
    sigma = 1.5

    smoothed = filters.gaussian_filter(img,sigma)
    dy,dx = np.gradient(smoothed)
    mag = (dx**2)+(dy**2)
    edge = 1.0/(1.0+mag)

    c0 = 2
    initialLSF = c0*np.ones(img.shape)
    initialLSF[10:50,10:50] = -c0

    #initialLSF[10:55,10:75] = -c0

    #initialLSF[25:35,20:25] -= c0
    #initialLSF[25:35,40:50] -= c0
    phi = initialLSF
    drlse_edge(phi,edge,lambdap,mu,alpha,epsilon,timestep,iter_basic)
    drlse_edge(phi,edge,lambdap,mu,0,epsilon,timestep,iter_refine)
    return phi

def get_candidate_symbol_regions(image, text_regions, updated_width, updated_height):
    img = skimage.io.imread(image.name)[:, :, :3]
    if not (updated_height == len(img) and updated_width == len(img[0])):
        img = skimage.transform.resize(img, (updated_height, updated_width))

    symbol_regions = dict()
    for x, y, w, h in text_regions:
        text_region_image = img[y: y + h, x: x + w]
        text_region_image_width = len(text_region_image[0])
        text_region_image_height = len(text_region_image)

        text_region_gray_image = skimage.color.rgb2gray(text_region_image)
        text_region_binary_image = image <= threshold_otsu(text_region_gray_image)

        temp = TemporaryFile(".png")
        skimage.io.imsave(temp.name, text_region_binary_image)
        text_region_binary_image = skimage.io.imread(temp.name)

        text_region_blurred_image = gaussian_filter(text_region_binary_image, sigma=3.5)
        text_region_blobs = text_region_blurred_image > text_region_blurred_image.mean()

        text_region_labels = skimage.morphology.label(text_region_blobs, neighbors=4)

        symbol_blobs = ndimage.find_objects(text_region_labels)
        candidate_symbol_regions = set()

        for c1, c2 in symbol_blobs:
            if (c2.stop - c2.start) * c1.stop - c1.start > (text_region_image.shape[0] * text_region_image.shape[1]) * (0.026):
                if (c2.stop - c2.start) * c1.stop - c1.start < (text_region_image.shape[0] * text_region_image.shape[1]) * (0.90):
                    candidate_symbol_regions.add(
                        (c2.start, c1.start, c2.stop - c2.start, c1.stop - c1.start))

        symbol_regions[str((x, y, w, h))] = dict()
        symbol_regions[str((x, y, w, h))]["image"] = text_region_image
        symbol_regions[str((x, y, w, h))]["regions"] = candidate_symbol_regions
        symbol_regions[str((x, y, w, h))]["width"] = text_region_image_width
        symbol_regions[str((x, y, w, h))]["height"] = text_region_image_height

    return symbol_regions

def iter_blob_extremes(image, n=5):
    original_shape = image.shape[::-1]
    if max(original_shape) < 2000:
        size = (500, 500)
        y_scale = original_shape[0] / 500
        x_scale = original_shape[1] / 500
    else:
        size = (1000, 1000)
        y_scale = original_shape[0] / 1000
        x_scale = original_shape[1] / 1000

    img = resize(image, size)
    bimg = gaussian_filter(img, sigma=1.0)
    bimg = threshold_adaptive(bimg, 20, offset=2/255)
    bimg = -bimg
    bimg = ndi.binary_fill_holes(bimg)
    label_image = label(bimg, background=False)
    label_image += 1

    regions = regionprops(label_image)
    regions.sort(key=attrgetter('area'), reverse=True)
    iter_n = 0

    for region in regions:
        try:
            iter_n += 1
            if iter_n > n:
                break

            # Skip small images
            if region.area < int(np.prod(size) * 0.05):
                continue
            coords = get_contours(add_border(label_image == region.label,
                                             size=label_image.shape,
                                             border_size=1,
                                             background_value=False))[0]
            coords = np.fliplr(coords)

            top_left = sorted(coords, key=lambda x: np.linalg.norm(np.array(x)))[0]
            top_right = sorted(coords, key=lambda x: np.linalg.norm(np.array(x) - [img.shape[1], 0]))[0]
            bottom_left = sorted(coords, key=lambda x: np.linalg.norm(np.array(x) - [0, img.shape[0]]))[0]
            bottom_right = sorted(coords, key=lambda x: np.linalg.norm(np.array(x) - [img.shape[1], img.shape[0]]))[0]
            scaled_extremes = [(int(x[0] * y_scale), int(x[1]*x_scale)) for x in (top_left, top_right, bottom_left, bottom_right)]

            yield scaled_extremes
        except Exception:
            pass
    raise SudokuExtractError("No suitable blob could be found.")