def _complex_dblquad(func, a, b, gfun, hfun, kwargs={}):
"""Integrate real and imaginary part of the given function."""
if cython_imported and cython.compiled:
# pure python formulation of: cdef void *f_ptr = <void*>func
f_ptr = cython.declare(cython.p_void, cython.cast(cython.p_void, func))
func_capsule = PyCapsule_New(f_ptr, cython.NULL, cython.NULL)
current_module = sys.modules[__name__]
ll_real_2d_func_c = LowLevelCallable.from_cython(current_module,
'_real_2d_func_c',
func_capsule)
ll_imag_2d_func_c = LowLevelCallable.from_cython(current_module,
'_imag_2d_func_c',
func_capsule)
real, real_tol = dblquad(ll_real_2d_func_c, a, b, gfun, hfun, **kwargs)
imag, imag_tol = dblquad(ll_imag_2d_func_c, a, b, gfun, hfun, **kwargs)
else:
real, real_tol = dblquad(
_real_2d_func, a, b, gfun, hfun, (func,), **kwargs)
imag, imag_tol = dblquad(
_imag_2d_func, a, b, gfun, hfun, (func,), **kwargs)
return real + 1j*imag, real_tol, imag_tol
def erosion_fast(image, footprint):
out = ndimage.generic_filter(
image,
LowLevelCallable.from_cython(sys.modules['test9'], name='erosion_kernel'),
footprint=footprint
)
return out
def __count_votes(im, out, size, invert):
"""
Count the votes for each pixel in a size-by-size region around each one, saving the totals to
out. If invert is supplied, every pixel less than the values for it, otherwise every pixel
greater than it votes for it.
REFERENCES
1. Eramian M and Mould D, 2005, "Histogram Equalization using Neighborhood Metrics",
Proceedings of the Second Canadian Conference on Computer and Robot Vision.
"""
if is_on_gpu(im):
voting = __get_count_votes_cupy_kernel(invert)
else:
# Try to use the Cython functions if possible - they are ~160x faster!
try:
from scipy import LowLevelCallable
import hist.exact.__basic as cy
voting = LowLevelCallable.from_cython(
cy, 'vote_lesser' if invert else 'vote_greater')
except ImportError:
# Fallback
from numpy import empty, greater, less
compare = greater if invert else less
tmp = empty(size**im.ndim, bool)
mid = tmp.size // 2
voting = lambda x: compare(x[mid], x, tmp).sum()
# Once we get the appropriate voting function we can call generic filter
get_ndimage_module(im).generic_filter(im, voting, size, output=out)
def bilateral_filter(im, size=None, sigma_r=None, sigma_d=1, **kwargs):
"""
Bilaterally filter an image. Uses Gaussian kernels for the spatial and intensity filters.
im is the image to filter, must be grayscale but can be any dimension
size is the kernel size, must be odd and >=3, defaults to int(max(5, 2*ceil(3*sigma_d)+1)).
sigma_r is the range/intensity standard deviation, defaults to image standard deviation.
sigma_d is the domain/spatial standard deviation, default to 1.
other keyword arguments are passed to scipy.ndimage.generic_filter.
This attempts to use a Cython optimized function if possible. Additionally in common cases many
parts are computed to greatly speed up the function.
REFERENCES
1. Tomasi C and Manduchi R, 1998, "Bilateral filtering for gray and color images". Sixth
International Conference on Computer Vision. pp. 839–846.
2. R A and Wilscu M, 2008, "Enhancing Contrast in Color Images Using Bilateral Filter and
Histogram Equalization Using Wavelet Coefficients", 2008 Second International Conference on
Future Generation Communication and Networking Symposia.
"""
from scipy.ndimage import generic_filter
if sigma_r is None: sigma_r = im.std()
if size is None:
size = int(max(5, 2*ceil(3*sigma_d)+1))
elif size < 3 or size%2 != 1:
raise ValueError(size)
# Calculate the kernels
spatial, scale, inten_lut = __bilateral_kernels(im.dtype, im.ndim, size, sigma_r, sigma_d)
try:
# Try to import Cython optimized code - 20 to 75x faster
from scipy import LowLevelCallable
import hist.exact.__bilateral_cy as cy
_bilateral_filter = LowLevelCallable.from_cython(
cy, 'bilateral_filter' if inten_lut is None else 'bilateral_filter_inten_lut',
cy.get_user_data(spatial, scale, inten_lut)) # pylint: disable=c-extension-no-member
except ImportError:
# Fallback to pure Python function
# Note: it seems the pure Python function actually gets slower with the intensity LUT
def _bilateral_filter(data):
diff = data - data[data.size // 2]
weight = exp(diff*diff*scale) * spatial
return dot(data, weight) / weight.sum()
return generic_filter(im, _bilateral_filter, size, **kwargs)
import numpy as np
import pandas as pd
from scipy import LowLevelCallable
from scipy.integrate import quad
from toolz import memoize
import textnets as tn
from .corpus import TidyText
from .fca import FormalContext
from .viz import decorate_plot
try:
from . import _ext # type: ignore
integrand = LowLevelCallable.from_cython(_ext, "df_integrand")
except ImportError:
def integrand(x: float, degree: int) -> float:
"""Fallback version of integrand function for the disparity filter."""
return (1 - x) ** (degree - 2)
warn("Could not import compiled extension, backbone extraction will be slow.")
class TextnetBase:
"""
Base class for `Textnet` and `ProjectedTextnet`.
Attributes
----------
def get_cy_callback(module_name):
lib = import_module(module_name)
return LowLevelCallable.from_cython(
lib,
'f') # , signature='double (int, double *, void *)') # , user_data)
# Example from https://ilovesymposia.com/2017/03/12/scipys-new-lowlevelcallable-is-a-game-changer/
import contextlib
import time
from scipy import ndimage as ndi
import numpy as np
from scipy import LowLevelCallable
import callable
image = np.random.random((2048, 2048))
footprint = np.array([[0, 1, 0],
[1, 1, 1],
[0, 1, 0]], dtype=bool)
c = LowLevelCallable.from_cython(callable, "nbmin")
ndi.generic_filter(image, c, footprint=footprint)