anshitsu 3.2.0__py3-none-win_amd64.whl

anshitsu/__version__.py

@@ -0,0 +1 @@
+version: str = "v2.0.2"

anshitsu/cli.py

@@ -0,0 +1,193 @@
+import datetime
+import glob
+import os
+import os.path
+import re
+from typing import Optional
+
+import fire
+import fire.core
+from PIL import Image, UnidentifiedImageError
+
+from anshitsu.__version__ import version as __version__
+from anshitsu.process.processor import Processor
+
+
+def cli(
+    path: Optional[str] = None,
+    keep_alpha: bool = False,
+    colorautoadjust: bool = False,
+    colorstretch: bool = False,
+    grayscale: bool = False,
+    orthochromatic: bool = False,
+    invert: bool = False,
+    color: Optional[float] = None,
+    brightness: Optional[float] = None,
+    sharpness: Optional[float] = None,
+    contrast: Optional[float] = None,
+    tosaka: Optional[float] = None,
+    outputrgb: bool = False,
+    sepia: bool = False,
+    cyanotype: bool = False,
+    rochester: bool = False,
+    ashigara: bool = False,
+    crossprocess: bool = False,
+    apocalypse: bool = False,
+    ultramarine: bool = False,
+    roppongi: bool = False,
+    classic: bool = False,
+    noise: Optional[float] = None,
+    overwrite: bool = False,
+    version: bool = False,
+    line_drawing: bool = False,
+    posterize: Optional[int] = None,
+    vignette: Optional[float] = None,
+) -> str:
+    """
+    Process Runnner for Command Line Interface
+
+    This utility converts the colors of images such as photos.
+
+    If you specify a directory path, it will convert
+    the image files in the specified directory.
+    If you specify a file path, it will convert the specified file.
+    If you specify an option, the specified conversion will be performed.
+
+    Tosaka mode is named after Tosaka-senpai's "Tri-X de banzen"
+    line from "Kyūkyoku Chōjin R". It aims for a grainy
+    black-and-white photo look similar to Kodak Tri-X film.
+    This mode converts the image to grayscale and adjusts contrast.
+    Use floating-point numbers; values around 2.4 usually work well.
+
+    Args:
+        path (Optional[str], optional): Directory or file path. Defaults to None.
+        keep_alpha (bool, optional): Keep the alpha channel. Defaults to False.
+        colorautoadjust (bool, optional): Correct colors using Automatic Color Equalization. Defaults to False.
+        colorstretch (bool, optional): Apply gray-world white balance and color stretching. Defaults to False.
+        grayscale (bool, optional): Convert to grayscale. Defaults to False.
+        orthochromatic (bool, optional): Convert to orthochromatic-style grayscale. Defaults to False.
+        invert (bool, optional): Invert image colors. Defaults to False.
+        color (Optional[float], optional): Adjust color. Defaults to None.
+        brightness (Optional[float], optional): Adjust brightness. Defaults to None.
+        sharpness (Optional[float], optional): Adjust sharpness. Defaults to None.
+        contrast (Optional[float], optional): Adjust contrast. Defaults to None.
+        tosaka (Optional[float], optional): Use Tosaka mode. Defaults to None.
+        outputrgb (bool, optional): Convert a monochrome image to RGB. Defaults to False.
+        sepia (bool, optional): Colorize a monochrome image with sepia tones. Defaults to False.
+        cyanotype (bool, optional): Colorize a monochrome image with cyanotype-like Prussian blue. Defaults to False.
+        rochester (bool, optional): Apply a warm color grade inspired by Kodak PORTRA 400. Defaults to False.
+        ashigara (bool, optional): Apply a vivid color grade inspired by Fujifilm Velvia 100. Defaults to False.
+        crossprocess (bool, optional): Apply a random cross-process-style color grade. Defaults to False.
+        apocalypse (bool, optional): Apply a red-orange Velvia 100 cross-process preset. Defaults to False.
+        ultramarine (bool, optional): Apply a blue-forward color grade inspired by Kodak Ultramax. Defaults to False.
+        roppongi (bool, optional): Apply a smooth fine-grain monochrome preset. Defaults to False.
+        classic (bool, optional): Apply a classic high-acutance monochrome preset. Defaults to False.
+        noise (Optional[float], optional): Add Gaussian noise. Defaults to None.
+        overwrite (bool, optional): Overwrite original files. Defaults to False.
+        version (bool, optional): Show version. Defaults to False.
+        line_drawing (bool, optional): Convert to a line drawing. Defaults to False.
+        posterize (Optional[int], optional): Posterize the image. Defaults to None.
+        vignette (Optional[float], optional): Darken image edges with a radial vignette. Defaults to None.
+
+    Raises:
+        fire.core.FireError: Error that occurs when the specified string is not a path.
+
+    Returns:
+        str: Message.
+    """
+    if version:
+        return "Anshitsu version {}".format(__version__)
+    if path is None:
+        raise fire.core.FireError("No path specified!")
+    types = ("*.jpg", "*.JPG", "*.jpeg", "*.JPEG", "*.png", "*.PNG")
+    files_glob = []
+    return_path = ""
+    now_s = datetime.datetime.now()
+    output_dir = "anshitsu_out"
+    original_dir = "anshitsu_orig"
+    if os.path.isdir(path):
+        for type in types:
+            files_glob.extend(glob.glob(os.path.join(path, "**", type), recursive=True))
+        files_glob = [file for file in files_glob if not file.__contains__(output_dir)]
+        return_path = path
+
+        if len(files_glob) == 0:
+            raise fire.core.FireError(
+                "There are no JPEG or PNG files in this directory."
+            )
+    elif os.path.isfile(path):
+        files_glob.extend(glob.glob(path))
+        return_path = os.path.abspath(os.path.join(path, os.pardir))
+    else:
+        raise fire.core.FireError("A non-path string was passed.")
+    if overwrite is True:
+        os.makedirs(os.path.join(return_path, original_dir))
+    for i, file in enumerate(files_glob):
+        try:
+            image = Image.open(file)
+        except UnidentifiedImageError as e:
+            raise fire.core.FireError(e)
+        exif = image.getexif()
+        original_filename: str = os.path.split(file)[1]
+        extension = original_filename.split(".")[-1]
+        timestamp = now_s.strftime("%Y-%m-%d_%H-%M-%S")
+        if overwrite is True:
+            backup_filename = original_filename
+            image.save(os.path.join(return_path, original_dir, backup_filename))
+            filename = os.path.join(
+                return_path, re.sub(r"\.[^.]+$", "", original_filename) + ".png"
+            )
+            remove_file_list = [".jpg", ".JPG", ".jpeg", ".JPEG", ".PNG"]
+            for remove_file in remove_file_list:
+                remove_file_name = (
+                    re.sub(r"\.[^.]+$", "", original_filename) + remove_file
+                )
+                remove_file_path = os.path.join(return_path, remove_file_name)
+                if os.path.isfile(remove_file_path):
+                    os.remove(remove_file_path)
+        else:
+            filename = os.path.join(
+                return_path,
+                output_dir,
+                re.sub(r"\.[^.]+$", "_", original_filename)
+                + "_{0}_converted_at_{1}.png".format(extension, timestamp),
+            )
+        psr = Processor(
+            image=image,
+            keep_alpha=keep_alpha,
+            colorautoadjust=colorautoadjust,
+            colorstretch=colorstretch,
+            grayscale=grayscale,
+            orthochromatic=orthochromatic,
+            color=color,
+            contrast=contrast,
+            brightness=brightness,
+            sharpness=sharpness,
+            invert=invert,
+            tosaka=tosaka,
+            outputrgb=outputrgb,
+            cyanotype=cyanotype,
+            sepia=sepia,
+            rochester=rochester,
+            ashigara=ashigara,
+            crossprocess=crossprocess,
+            apocalypse=apocalypse,
+            ultramarine=ultramarine,
+            roppongi=roppongi,
+            classic=classic,
+            noise=noise,
+            line_drawing=line_drawing,
+            posterize=posterize,
+            vignette=vignette,
+        )
+        saved_image = psr.process()
+        os.makedirs(os.path.join(return_path, output_dir), exist_ok=True)
+        saved_image.save(
+            filename,
+            quality=100,  # Specify 100 as the highest image quality
+            subsampling=0,
+            exif=exif,
+        )
+        print("{0}/{1} done!".format((i + 1), str(len(files_glob))))
+
+    return "The cli was completed successfully."

anshitsu/main.py

@@ -0,0 +1,14 @@
+import fire
+
+from anshitsu.cli import cli
+
+
+def main():
+    """
+    main [summary]
+    """
+    fire.Fire(cli)
+
+
+if __name__ == "__main__":
+    main()

anshitsu/process/_native_color.py

@@ -0,0 +1,168 @@
+import ctypes
+import os
+import platform
+from pathlib import Path
+from typing import Optional
+
+from PIL import Image
+
+
+def automatic_color_equalization(
+    image: Image,
+    samples: int = 500,
+    slope: float = 10.0,
+    limit: float = 1000.0,
+) -> Optional[Image]:
+    """
+    Apply the Rust Automatic Color Equalization backend when available.
+
+    Args:
+        image: RGB image to process.
+        samples: Maximum number of spatial samples used for ACE comparison.
+        slope: Slope applied to channel differences before clipping.
+        limit: Maximum absolute contrast contribution.
+
+    Returns:
+        Processed RGB image, or None when the native backend is unavailable.
+    """
+    library = _load_library()
+    if library is None:
+        return None
+
+    rgb_image = image.convert("RGB")
+    width, height = rgb_image.size
+    buffer = bytearray(rgb_image.tobytes())
+    array_type = ctypes.c_ubyte * len(buffer)
+    c_buffer = array_type.from_buffer(buffer)
+
+    result = library.anshitsu_ace_rgb(
+        c_buffer,
+        ctypes.c_size_t(len(buffer)),
+        ctypes.c_size_t(width),
+        ctypes.c_size_t(height),
+        ctypes.c_size_t(samples),
+        ctypes.c_float(slope),
+        ctypes.c_float(limit),
+    )
+    if result != 0:
+        return None
+
+    return Image.frombytes("RGB", rgb_image.size, bytes(buffer))
+
+
+def color_stretch(image: Image) -> Optional[Image]:
+    """
+    Apply the Rust gray-world and color stretching backend when available.
+
+    Args:
+        image: RGB image to process.
+
+    Returns:
+        Processed RGB image, or None when the native backend is unavailable.
+    """
+    library = _load_library()
+    if library is None:
+        return None
+
+    rgb_image = image.convert("RGB")
+    width, height = rgb_image.size
+    buffer = bytearray(rgb_image.tobytes())
+    array_type = ctypes.c_ubyte * len(buffer)
+    c_buffer = array_type.from_buffer(buffer)
+
+    result = library.anshitsu_color_stretch_rgb(
+        c_buffer,
+        ctypes.c_size_t(len(buffer)),
+        ctypes.c_size_t(width),
+        ctypes.c_size_t(height),
+    )
+    if result != 0:
+        return None
+
+    return Image.frombytes("RGB", rgb_image.size, bytes(buffer))
+
+
+def _load_library() -> Optional[ctypes.CDLL]:
+    path = _find_library_path()
+    if path is None:
+        return None
+
+    try:
+        library = ctypes.CDLL(str(path))
+    except OSError:
+        return None
+
+    try:
+        library.anshitsu_ace_rgb.argtypes = [
+            ctypes.POINTER(ctypes.c_ubyte),
+            ctypes.c_size_t,
+            ctypes.c_size_t,
+            ctypes.c_size_t,
+            ctypes.c_size_t,
+            ctypes.c_float,
+            ctypes.c_float,
+        ]
+        library.anshitsu_ace_rgb.restype = ctypes.c_int
+        library.anshitsu_color_stretch_rgb.argtypes = [
+            ctypes.POINTER(ctypes.c_ubyte),
+            ctypes.c_size_t,
+            ctypes.c_size_t,
+            ctypes.c_size_t,
+        ]
+        library.anshitsu_color_stretch_rgb.restype = ctypes.c_int
+    except AttributeError:
+        return None
+    return library
+
+
+def _find_library_path() -> Optional[Path]:
+    env_path = os.environ.get("ANSHITSU_COLOR_LIB")
+    if env_path:
+        path = Path(env_path)
+        if path.exists():
+            return path
+
+    library_name = _library_name()
+    candidates = [
+        Path(__file__).resolve().parents[1] / "_native" / library_name,
+    ]
+    repository_root = _repository_root()
+    if repository_root is not None:
+        candidates.append(
+            repository_root
+            / "native"
+            / "anshitsu-color"
+            / "target"
+            / "release"
+            / library_name
+        )
+        candidates.append(
+            repository_root
+            / "native"
+            / "anshitsu-color"
+            / "target"
+            / "debug"
+            / library_name
+        )
+
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+
+    return None
+
+
+def _library_name() -> str:
+    system = platform.system()
+    if system == "Darwin":
+        return "libanshitsu_color.dylib"
+    if system == "Windows":
+        return "anshitsu_color.dll"
+    return "libanshitsu_color.so"
+
+
+def _repository_root() -> Optional[Path]:
+    for parent in Path(__file__).resolve().parents:
+        if (parent / "pyproject.toml").exists():
+            return parent
+    return None

anshitsu/process/apocalypse.py

@@ -0,0 +1,67 @@
+from typing import Optional
+
+import numpy as np
+from PIL import Image
+
+
+def _soft_clip_highlights(image_array: np.ndarray) -> np.ndarray:
+    """
+    Compress highlights after the warm cross-process color shift.
+
+    Parameters:
+        image_array: normalized RGB image array
+
+    Returns:
+        np.ndarray: highlight-compressed normalized RGB image array.
+    """
+    highlight_start = 0.80
+    compression = 2.6
+    highlights = np.maximum(image_array - highlight_start, 0.0)
+    compressed = highlights / (1.0 + highlights * compression)
+    return np.minimum(image_array, highlight_start + compressed)
+
+
+def apocalypse(image: Image, seed: Optional[int] = None) -> Image:
+    """
+    Apply a red-orange cross-process preset inspired by Velvia 100.
+
+    This preset leans into the orange-to-red color cast often associated with
+    cross-processing Velvia 100. It aims for a dramatic end-of-days palette:
+    hot reds, heavy oranges, suppressed blues, strong saturation, and controlled
+    highlights. The strength of the red shift varies slightly each time it runs;
+    pass a seed to make the result reproducible for tests or comparisons.
+
+    Parameters:
+        image: Image
+        seed: optional random seed
+
+    Returns:
+        Image: processed RGB image.
+    """
+    rng = np.random.default_rng(seed)
+    red_shift = float(rng.uniform(0.75, 1.25))
+    image_array = np.array(image.convert("RGB"), dtype="float32") / 255.0
+
+    image_array = np.power(np.clip(image_array, 0.0, 1.0), (0.88, 0.98, 1.18))
+    red = image_array[:, :, 0] * (1.18 + 0.10 * red_shift) + (
+        0.035 + 0.020 * red_shift
+    )
+    green = image_array[:, :, 1] * (0.98 - 0.035 * red_shift) + 0.020
+    blue = image_array[:, :, 2] * (0.78 - 0.12 * red_shift) - (
+        0.010 + 0.010 * red_shift
+    )
+    image_array = np.stack((red, green, blue), axis=2)
+    image_array = (image_array - 0.5) * (1.12 + 0.10 * red_shift) + 0.5
+
+    luminance = (
+        image_array[:, :, 0] * 0.299
+        + image_array[:, :, 1] * 0.587
+        + image_array[:, :, 2] * 0.114
+    )
+    image_array = luminance[:, :, np.newaxis] + (
+        image_array - luminance[:, :, np.newaxis]
+    ) * (1.18 + 0.20 * red_shift)
+
+    image_array = _soft_clip_highlights(image_array)
+    image_array = np.clip(image_array, 0.0, 0.992)
+    return Image.fromarray((image_array * 255).astype("uint8"))

anshitsu/process/ashigara.py

@@ -0,0 +1,44 @@
+import numpy as np
+from PIL import Image
+
+
+def _soft_clip_highlights(image_array: np.ndarray) -> np.ndarray:
+    highlight_start = 0.78
+    compression = 3.8
+    highlights = np.maximum(image_array - highlight_start, 0.0)
+    compressed = highlights / (1.0 + highlights * compression)
+    return np.minimum(image_array, highlight_start + compressed)
+
+
+def ashigara(image: Image) -> Image:
+    """
+    Apply a vivid, high-contrast color grade inspired by Fujifilm Velvia 100.
+
+    Returns:
+        Image: processed image.
+    """
+    rgb_image = image.convert("RGB")
+    image_array = np.array(rgb_image, dtype="float32") / 255.0
+
+    # Increase contrast with a restrained S-curve.
+    image_array = 3 * image_array**2 - 2 * image_array**3
+    image_array = (image_array - 0.5) * 1.035 + 0.5
+
+    red = image_array[:, :, 0] * 1.025
+    green = image_array[:, :, 1] * 1.02
+    blue = image_array[:, :, 2] * 1.03
+    image_array = np.stack((red, green, blue), axis=2)
+
+    luminance = (
+        image_array[:, :, 0] * 0.299
+        + image_array[:, :, 1] * 0.587
+        + image_array[:, :, 2] * 0.114
+    )
+    saturation = 1.14
+    image_array = luminance[:, :, np.newaxis] + (
+        image_array - luminance[:, :, np.newaxis]
+    ) * saturation
+
+    image_array = _soft_clip_highlights(image_array)
+    image_array = np.clip(image_array, 0.0, 1.0)
+    return Image.fromarray((image_array * 255).astype("uint8"))

anshitsu/process/brightness.py

@@ -0,0 +1,17 @@
+from PIL import Image, ImageEnhance
+
+
+def brightness(image: Image, brightness: float) -> Image:
+    """
+    Adjust image brightness.
+
+    Parameters:
+        image: Image
+        brightness: enhancement factor
+
+    Returns:
+        Image: processed image.
+    """
+    enhancer = ImageEnhance.Brightness(image)
+    image = enhancer.enhance(brightness)
+    return image

anshitsu/process/classic.py

@@ -0,0 +1,65 @@
+import numpy as np
+from PIL import Image, ImageChops, ImageFilter
+
+from anshitsu.process.grayscale import grayscale
+
+
+def _classic_tone_curve(gray: np.ndarray) -> np.ndarray:
+    """
+    Apply a classic high-acutance monochrome tone curve.
+
+    Parameters:
+        gray: normalized grayscale image array
+
+    Returns:
+        np.ndarray: tone-adjusted normalized image array.
+    """
+    shadows = np.clip((gray - 0.015) / 0.985, 0.0, 1.0)
+    contrast = 3 * shadows**2 - 2 * shadows**3
+    contrast = (contrast - 0.5) * 1.12 + 0.5
+
+    highlight_start = 0.86
+    highlights = np.maximum(contrast - highlight_start, 0.0)
+    compressed = highlights / (1.0 + highlights * 1.6)
+    return np.minimum(contrast, highlight_start + compressed)
+
+
+def _add_classic_grain(image: Image, amount: float) -> Image:
+    """
+    Add visible but restrained monochrome grain to an L image.
+
+    Parameters:
+        image: L mode image
+        amount: grain strength
+
+    Returns:
+        Image: grain-adjusted L image.
+    """
+    noise_image = Image.effect_noise(image.size, amount)
+    table = [x * 2 for x in range(256)]
+    return ImageChops.multiply(image, noise_image).point(table)
+
+
+def classic(image: Image) -> Image:
+    """
+    Apply a classic monochrome preset inspired by Kodak TRI-X in Rodinal.
+
+    The preset converts the image to L mode, adds a firm but not extreme tone
+    curve, protects the brightest highlights, adds visible fine grain, and
+    applies mild sharpening. It is intended to be less aggressive than Tosaka
+    mode while keeping the traditional high-acutance feel of TRI-X developed in
+    Rodinal.
+
+    Parameters:
+        image: Image
+
+    Returns:
+        Image: processed image in L mode.
+    """
+    monochrome = grayscale(image)
+    gray = np.array(monochrome, dtype="float32") / 255.0
+    toned = np.clip(_classic_tone_curve(gray), 0.0, 1.0)
+    processed = Image.fromarray((toned * 255).astype("uint8"))
+    processed = _add_classic_grain(processed, 7.0)
+    processed = processed.filter(ImageFilter.UnsharpMask(radius=1.0, percent=70, threshold=2))
+    return processed.point(lambda value: min(value, 252))

anshitsu/process/color.py

@@ -0,0 +1,17 @@
+from PIL import Image, ImageEnhance
+
+
+def color(image: Image, color: float) -> Image:
+    """
+    Adjust image color.
+
+    Parameters:
+        image: Image
+        color: enhancement factor
+
+    Returns:
+        Image: processed image.
+    """
+    enhancer = ImageEnhance.Contrast(image)
+    image = enhancer.enhance(color)
+    return image

anshitsu/process/color_auto_adjust.py

@@ -0,0 +1,23 @@
+import colorcorrect.algorithm as cca
+from PIL import Image
+from colorcorrect.util import to_pil, from_pil
+
+from anshitsu.process import _native_color
+
+
+def color_auto_adjust(image: Image) -> Image:
+    """
+    Correct colors using the Automatic Color Equalization algorithm.
+
+    This process is based on the 2002 paper on Automatic Color Equalization
+    by Carlo Gatta and coauthors.
+
+    Returns:
+        Image: processed image.
+    """
+    if image.mode == "L":
+        return image
+    native_image = _native_color.automatic_color_equalization(image)
+    if native_image is not None:
+        return native_image
+    return to_pil(cca.automatic_color_equalization(from_pil(image)))

anshitsu/process/color_stretch.py

@@ -0,0 +1,23 @@
+import colorcorrect.algorithm as cca
+from PIL import Image
+from colorcorrect.util import to_pil, from_pil
+
+from anshitsu.process import _native_color
+
+
+def color_stretch(image: Image) -> Image:
+    """
+    Apply gray-world white balance and color stretching.
+
+    Parameters:
+        image: Image
+
+    Returns:
+        Image: processed image.
+    """
+    if image.mode == "L":
+        return image
+    native_image = _native_color.color_stretch(image)
+    if native_image is not None:
+        return native_image
+    return to_pil(cca.stretch(cca.grey_world(from_pil(image))))

anshitsu/process/contrast.py

@@ -0,0 +1,24 @@
+from PIL import Image, ImageEnhance
+
+
+def contrast(image: Image, contrast: float) -> Image:
+    """
+    Adjust image contrast.
+
+    Used by Tosaka mode.
+
+    Tosaka mode is named after Tosaka-senpai's "Tri-X de banzen"
+    line from "Kyūkyoku Chōjin R". It aims for a grainy
+    black-and-white photo look similar to Kodak Tri-X film.
+    Values around 2.4 usually work well.
+
+    Parameters:
+        image: Image
+        contrast: enhancement factor
+
+    Returns:
+        Image: processed image.
+    """
+    enhancer = ImageEnhance.Contrast(image)
+    image = enhancer.enhance(contrast)
+    return image