Effects

Functions:

• XYZ_to_xyY –

  Converts from CIE XYZ to xyY.

• add_canvas –

  Adds a background canvas to an image.

• apply_grain –

  Applies a grain filter to an image.

• blur_horizontal_masked –

  Horizontal blur with a mask.

• blur_vertical_masked –

  Vertical blur with a mask.

• burn –

  Simulates highlight burning, which is a darkroom printing technique to reduce

• chroma_nr_filter –

  A simple chroma noise reduction filter by blurring only color channels.

• compute_kernel_from_function –

  Computes a convolution kernel from a mtf function.

• crop_image –

  Crops rgb data to aspect ratio.

• down_up_blur –

  Blur by downsampling and then upsampling. Very fast on CPU compared to accurate

• exponential_blur_kernel –

  Compute an exponential blur kernel for halation.

• film_sharpness –

  Apply the sharpness and micro-contrast of a film stock ot an image.

• gaussian_blur_separable_masked –

  image: (H, W, C) float32

• gaussian_kernel_1d –

  A fast 1D gaussian kernel.

• halation –

  A halation image processing effect.

• lens_correction –

  Apply lens correction using lensfunpy.

• mtf_curve –

  Turn mtf values into an interpolated function on log space.

• mtf_kernel –

  Cache a mtf convolution kernel.

• rotate –

  Rotate an image by a specified angle in degrees.

• xyY_to_XYZ –

  Converts from CIE xyY to XYZ.

XYZ_to_xyY(image: ndarray, eps: float = 1e-08)

add_canvas(
    image: ndarray,
    canvas_mode: CANVAS_MODES,
    canvas_scale: float = 1.0,
    canvas_ratio: float = 1.0,
)

apply_grain(
    rgb: ndarray,
    stock: FilmSpectral,
    scale: float,
    grain_size_mm: float = 0.01,
    grain_sigma: float = 0.4,
    bw_grain: bool = False,
    adx: bool = True,
)

blur_horizontal_masked(image: ndarray, kernel: ndarray, blur_mask: ndarray)

blur_vertical_masked(image: ndarray, kernel: ndarray, blur_mask: ndarray)

burn(
    image: ndarray,
    negative_film: FilmSpectral,
    highlight_burn: float,
    burn_scale: float,
)

chroma_nr_filter(image: ndarray, size: int = 0)

compute_kernel_from_function(func, kernel_size_mm, pixel_size_mm)

crop_image(rgb: ndarray, zoom=1, aspect=1.5, flip=False) -> ndarray

down_up_blur(image: ndarray, scale: int = 50, func: Callable | None = None)

exponential_blur_kernel(size)

film_sharpness(
    rgb: ndarray,
    stock: FilmSpectral,
    scale: float,
    sharpening_strength,
    sharpening_sigma,
)

gaussian_blur_separable_masked(image, kernel, blur_channels)

gaussian_kernel_1d(size: int, sigma: float) -> ndarray

halation(
    rgb: ndarray,
    scale: float,
    halation_size: float = 1.0,
    halation_red_factor: float = 1.0,
    halation_green_factor: float = 0.4,
    halation_blue_factor: float = 0.0,
    halation_intensity: float = 1.0,
    bw: bool = False,
) -> ndarray

lens_correction(
    rgb: ndarray, metadata: dict, cam: None | str, lens: None | str
) -> ndarray

mtf_curve(logf, vals)

mtf_kernel(
    stock: FilmSpectral,
    scale,
    sharpening_strength: float = 0.0,
    sharpening_sigma: float = 1.0,
)

rotate(rgb: ndarray, degrees: float) -> ndarray

xyY_to_XYZ(image: ndarray, eps: float = 1e-08)