visiontext 0.33.4__py3-none-any.whl

visiontext/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.33.4"

visiontext/__main__.py

@@ -0,0 +1,33 @@
+import importlib
+import importlib.util
+import shutil
+import sys
+
+
+def main():
+    lib_module_name = __file__.replace("\\", "/").split("/")[-2]
+    if len(sys.argv) <= 1:
+        print(f"Usage: {lib_module_name} <module> <*args>\n")
+        from packg.packaging import get_modules_for_autocomplete
+        from packg.strings import format_pseudo_table
+
+        output_modules = get_modules_for_autocomplete(lib_module_name, run_dir=None)
+        terminal_width = shutil.get_terminal_size().columns
+        print(format_pseudo_table(output_modules, max_width=terminal_width))
+        sys.exit(1)
+    target_module = sys.argv[1]
+    args = sys.argv[2:]
+    # load the spec to modify sys.argv before importing, otherwise it's too late
+    module_to_load = f"{lib_module_name}.{target_module}"
+    spec = importlib.util.find_spec(module_to_load)
+    if spec is None:
+        raise ValueError(f"Module {module_to_load} not found")
+    origin = spec.origin
+    sys.argv = [origin] + args
+    # import the module and run the main function
+    module = importlib.import_module(module_to_load)
+    module.main()
+
+
+if __name__ == "__main__":
+    main()

visiontext/audiotools.py

@@ -0,0 +1,83 @@
+from tempfile import NamedTemporaryFile
+from typing import Tuple
+
+import numpy as np
+from loguru import logger
+from pydub import AudioSegment
+from scipy.io import wavfile
+from scipy.signal import spectrogram
+
+from packg import Const
+from packg.typext import PathType
+
+
+class AudioConvertC(Const):
+    NONE = "none"
+    MONO = "mono"
+    STEREO = "stereo"
+
+
+def load_audio_file(
+    input_file: PathType, verbose: bool = False, convert=AudioConvertC.STEREO
+) -> Tuple[int, np.ndarray]:
+    """
+    Load audio file and return frequency and data.
+
+    Args:
+        input_file:
+        verbose: print debug info
+        convert: convert to either stereo (shape (N, 2)) or mono (shape (N,)) or leave as is.
+
+    Returns:
+        tuple of frequency int and data numpy array of shape (N, 2) (stereo) or (N,) (mono)
+
+    """
+    file_format = input_file.name.split(".")[-1]
+    if verbose:
+        logger.info(f"Reading file {input_file} detected format {file_format}")
+    audio = AudioSegment.from_file(input_file, format=file_format)
+
+    # convert to wav
+    with NamedTemporaryFile(suffix=".wav") as tmpfile:
+        audio.export(tmpfile, format="wav")
+        frequency, data = wavfile.read(tmpfile)
+
+    # convert to stereo or mono as needed
+    if convert == AudioConvertC.STEREO and len(data.shape) == 1:
+        data = np.stack([data, data], axis=-1)  # mono to stereo
+    elif convert == AudioConvertC.MONO and len(data.shape) == 2:
+        data = data.mean(-1)  # stereo to mono
+
+    if verbose:
+        logger.info(f"Got frequency {frequency} shape {data.shape} after conversion '{convert}'")
+
+    return frequency, data
+
+
+def check_audio_quality(frequency, data, eps=1e-6) -> bool:
+    """
+    logic: a good quality music file will have audio at 20khz. a bad one will not.
+    """
+    # dmin, dmax = data.min(), data.max()
+    # dnorm = (data - dmin) / (dmax - dmin)
+    # print_ndarray_lovely(data)  # raw mono audio
+    # example data shape 11,796,960 freq 48000 => 246 seconds
+
+    freqs, time, spec = spectrogram(data, fs=frequency, nperseg=256, noverlap=128)
+
+    # print_ndarray_lovely(freqs)  # frequency bins
+    # select all bins within 19 and 21 khz
+    freqs_to_use = np.less_equal(19000, freqs) & np.less_equal(freqs, 21000)
+    # example: 129 equally spaced values from 0 ... 24000
+
+    # print_ndarray_lovely(time)  # time bins
+    # print_ndarray_lovely(spec)  # spec shape (n_freq, n_time)
+    smin, smax = spec.min(), spec.max()
+    snorm = (spec - smin) / (smax - smin)
+
+    srel = snorm[freqs_to_use]
+    return srel.max() > eps
+    # now we want to normalize with something between mean (1-norm) and max (inf-norm)
+    # srel_norm_freq = np.linalg.norm(srel, ord=np.inf, axis=0)
+    # srel_norm_all = np.linalg.norm(srel_norm_freq, ord=np.inf, axis=0)
+    # return srel_norm_all

visiontext/bboxes.py

@@ -0,0 +1,250 @@
+from typing import Dict, List, Optional, Tuple, Union
+
+from matplotlib import colors as mpl_colors
+from PIL import Image, ImageDraw, ImageFont
+
+from packg.maths import clip_rectangle_coords
+from visiontext.colormaps import (
+    create_colorgetter_from_colormap,
+    create_colormap_for_dark_background,
+)
+from visiontext.font import get_dejavusans_font_path
+
+
+def create_bbox_images(
+    bx: int,
+    by: int,
+    bw: int,
+    bh: int,
+    w: int,
+    h: int,
+    box_color=(0, 0, 255, 255),
+    bbox_width: int = 5,
+    mask_opacity: int = 64,
+) -> Dict[str, Image.Image]:
+    """
+    Create box overlay images, originally used in the OVAD visualizer e.g.:
+    https://lmb.informatik.uni-freiburg.de/resources/datasets/ovad/?imgnum=14#top
+
+    This function creates transparent PNGs that can be overlayed on top of an image to show or
+    highlight a bounding box.
+    """
+    # create one image with transparent background and one with half transparent
+    img = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(img)
+    img2 = Image.new("RGBA", (w, h), (0, 0, 0, mask_opacity))
+    draw2 = ImageDraw.Draw(img2)
+
+    # boxes should be approximately the same width after scaling the image
+    # so we have to scale the box thickness now
+    target_w = 800
+    rel_w = w / target_w  # if small image, create smaller boxes
+    rel_bbox_width = round(bbox_width * rel_w)
+
+    # the inside of the thick drawn box will be the true bbox
+    # this means that the box can clip outside the image and become almost invisible
+    # to avoid that, we move the edges of the box outwards and then clip them
+    x1 = bx - rel_bbox_width
+    y1 = by - rel_bbox_width
+    x2 = bx + bw + rel_bbox_width
+    y2 = by + bh + rel_bbox_width
+    (x1, y1, x2, y2) = clip_rectangle_coords((x1, y1, x2, y2), w, h)
+
+    for bbox_step in range(rel_bbox_width):
+        rectangle_coords = (
+            x1 + bbox_step,
+            y1 + bbox_step,
+            x2 - bbox_step,
+            y2 - bbox_step,
+        )
+        # a 2nd clip should now not be necessary anymore and we assert instead
+        assert (
+            rectangle_coords[0] >= 0
+            and rectangle_coords[1] >= 0
+            and rectangle_coords[2] <= w
+            and rectangle_coords[3] <= h
+        ), f"{rectangle_coords} outside {w}x{h}"
+
+        draw.rectangle(rectangle_coords, fill=(0, 0, 0, 0), outline=box_color)
+        draw2.rectangle(rectangle_coords, fill=(0, 0, 0, 0), outline=box_color)
+
+    return {"box": img, "box-mask": img2}
+
+
+def convert_bbox_abs_to_rel(bx, by, bw, bh, image_w, image_h):
+    """
+    Convert bounding box coordinates to relative coordinates.
+
+    Args:
+        bx: x coordinate of the top-left corner of the bounding box
+        by: y coordinate of the top-left corner of the bounding box
+        bw: width of the bounding box
+        bh: height of the bounding box
+        image_w: width of the image
+        image_h: height of the image
+
+    Returns:
+        Tuple of relative coordinates (x, y, w, h)
+
+    """
+    x = bx / image_w
+    y = by / image_h
+    w = bw / image_w
+    h = bh / image_h
+    return x, y, w, h
+
+
+def convert_bbox_rel_to_abs(x, y, w, h, image_w, image_h):
+    """
+    Convert bounding box coordinates to absolute coordinates.
+
+    Args:
+        x: x coordinate of the top-left corner of the bounding box
+        y: y coordinate of the top-left corner of the bounding box
+        w: width of the bounding box
+        h: height of the bounding box
+        image_w: width of the image
+        image_h: height of the image
+
+    Returns:
+        Tuple of absolute coordinates (bx, by, bw, bh)
+
+    """
+    bx = x * image_w
+    by = y * image_h
+    bw = w * image_w
+    bh = h * image_h
+    return bx, by, bw, bh
+
+
+def get_bbox_bounds(
+    box_x: float,
+    box_y: float,
+    box_w: float,
+    box_h: float,
+    image_w: int,
+    image_h: int,
+    min_w=32,
+    min_h=32,
+    create_squares=False,
+):
+    """
+    Get the bounding box boundaries for cropping the image.
+    Increase the box size if it is too small.
+
+    Args:
+        box_x: absolute box coordinates for the given image
+        box_y:
+        box_w:
+        box_h:
+        image_w: image size
+        image_h:
+        min_w: minimum box size
+        min_h:
+        create_squares: if True, try to create a square bounding box instead of a rectangle
+
+    Returns:
+        Cropping parameters tuple (x1, y1, x2, y2)
+
+    """
+    # Calculate the center coordinates of the bounding box
+    center_x = box_x + (box_w / 2)
+    center_y = box_y + (box_h / 2)
+
+    # Calculate the new width and height of the bounding box
+    new_w = max(box_w, min_w)
+    new_h = max(box_h, min_h)
+
+    if create_squares:
+        new_w = max(new_w, new_h)
+        new_h = max(new_w, new_h)
+        pass
+
+    # Calculate the new x and y coordinates of the top-left corner of the bounding box
+    new_x = center_x - (new_w / 2)
+    new_y = center_y - (new_h / 2)
+
+    # Adjust the new x coordinate if the box is too close to the left border
+    if new_x < 0:
+        new_x = 0
+        new_x2 = min(new_x + new_w, image_w)
+    else:
+        new_x2 = min(new_x + new_w, image_w)
+        if new_x2 > image_w:
+            new_x2 = image_w
+            new_x = max(new_x2 - new_w, 0)
+
+    # Adjust the new y coordinate if the box is too close to the top border
+    if new_y < 0:
+        new_y = 0
+        new_y2 = min(new_y + new_h, image_h)
+    else:
+        new_y2 = min(new_y + new_h, image_h)
+        if new_y2 > image_h:
+            new_y2 = image_h
+            new_y = max(new_y2 - new_h, 0)
+
+    # Again make sure all bounds are respected
+    new_x = max(new_x, 0)
+    new_y = max(new_y, 0)
+    new_x2 = min(new_x2, image_w)
+    new_y2 = min(new_y2, image_h)
+
+    # Return the cropping boundaries as integers
+    return int(new_x), int(new_y), int(new_x2), int(new_y2)
+
+
+def draw_bounding_boxes_pil(
+    image: Image.Image,
+    boxes: List[Tuple[float, float, float, float]],  # x, y, w, h
+    labels: Tuple[List[str], str, None] = "numbers",
+    colors: Optional[List[Tuple[int, int, int]]] = None,
+    width: int = 3,
+    font_size: int = 14,
+    cmap: Optional[Union[str, mpl_colors.Colormap]] = None,
+):
+    draw = ImageDraw.Draw(image)
+    font = ImageFont.truetype(get_dejavusans_font_path(), font_size)
+
+    if colors is None:
+        if cmap is None:
+            cmap = create_colormap_for_dark_background(add_brightness=0.5)
+        # automatically generate a bunch of colors from the colormap
+        getter = create_colorgetter_from_colormap(cmap)
+        colors = [tuple(getter(i / len(boxes))) for i in range(len(boxes))]
+
+    if isinstance(labels, str):
+        if labels == "numbers":
+            labels = [str(i) for i in range(len(boxes))]
+        else:
+            raise ValueError(f"Unknown label type: {labels}")
+
+    for i, (box, color) in enumerate(zip(boxes, colors)):
+        x, y, w, h = box
+        x1, y1, x2, y2 = get_bbox_bounds(x, y, w, h, image.width, image.height, min_w=0, min_h=0)
+        draw.rectangle([(x1, y1), (x2, y2)], outline=color, width=width)
+
+        text_args = dict(font=font, stroke_width=2)
+        if labels is not None:
+            label = labels[i]
+
+            # # removed in pillow 10...
+            # text_width, text_height = draw.textsize(label, **text_args)
+
+            # new version with textbbox
+            tx0, ty0, tx1, ty1 = draw.textbbox((0, 0), label, **text_args)
+            text_width = tx1 - tx0
+            text_height = ty1 - ty0
+
+            text_x = min(x1 + width + 2, image.width - text_width)
+            text_y = min(y1 + width + 2, image.height - text_height)
+            draw.text(
+                (text_x, text_y),
+                label,
+                fill=color,
+                anchor="lt",
+                stroke_fill="black",
+                **text_args,
+            )
+
+    return image

visiontext/cacheutils.py

@@ -0,0 +1,66 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+import lmdb
+import msgpack
+from platformdirs import user_cache_path
+
+from packg.strings import hash_object
+from packg.typext import PathType
+
+
+class CachePlugin:
+    """
+    Helper to create a cache for a class.
+
+    cache_name and cache_kwargs define a unique filename.
+    cache_kwargs must be jsonable
+    """
+
+    def __init__(
+        self,
+        cache_name: str,
+        cache_kwargs: Optional[dict] = None,
+        cache_dir: Optional[PathType] = None,
+        map_size=10 * 1024**3,  # 10 GB max size of database, increase if necessary
+        verbose: bool = False,
+    ):
+        if cache_dir is None:
+            cache_dir = user_cache_path("python_visiontext")
+        if cache_kwargs is None:
+            kwargs_str = "none"
+        else:
+            kwargs_str = hash_object(cache_kwargs)
+
+        lmdb_file = Path(cache_dir) / "cache_plugin" / f"{cache_name}~{kwargs_str}.lmdb"
+        os.makedirs(lmdb_file.parent, exist_ok=True)
+        self.db: lmdb.Environment = lmdb.open(lmdb_file.as_posix(), map_size=map_size)
+        self.lmdb_file = lmdb_file
+        if verbose:
+            print(f"Using cache file: {self.lmdb_file}")
+
+    def get_values(self, list_of_keys):
+        outputs = []
+        with self.db.begin(write=False) as txn:
+            for key in list_of_keys:
+                bkey = msgpack.packb(key)
+                bvalue = txn.get(bkey)
+                if bvalue is None:
+                    outputs.append(None)
+                else:
+                    value = msgpack.unpackb(bvalue)
+                    outputs.append(value)
+        return outputs
+
+    def put_values(self, list_of_keys, list_of_values):
+        assert len(list_of_keys) == len(
+            list_of_values
+        ), f"Got {len(list_of_keys)} keys and {len(list_of_values)} values."
+        if len(list_of_keys) == 0:
+            return
+        with self.db.begin(write=True) as txn:
+            for key, value in zip(list_of_keys, list_of_values):
+                bkey = msgpack.packb(key)
+                bvalue = msgpack.packb(value)
+                txn.put(bkey, bvalue)

visiontext/cli/collect_env_details.py

@@ -0,0 +1,92 @@
+# source: github lightning-ai pytorch-lightning
+#
+# Copyright The Lightning AI team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Diagnose your system and show basic information.
+
+This server mainly to get detail info for better bug reporting.
+
+"""
+
+import os
+import platform
+import sys
+
+import pkg_resources
+import torch
+
+sys.path += [os.path.abspath(".."), os.path.abspath("")]
+
+
+LEVEL_OFFSET = "\t"
+KEY_PADDING = 20
+
+
+def info_system() -> dict:
+    return {
+        "OS": platform.system(),
+        "architecture": platform.architecture(),
+        "version": platform.version(),
+        "release": platform.release(),
+        "processor": platform.processor(),
+        "python": platform.python_version(),
+    }
+
+
+def info_cuda() -> dict:
+    return {
+        "GPU": [torch.cuda.get_device_name(i) for i in range(torch.cuda.device_count())] or None,
+        "available": torch.cuda.is_available(),
+        "version": torch.version.cuda,
+    }
+
+
+def info_packages() -> dict:
+    """Get name and version of all installed packages."""
+    packages = {}
+    for dist in pkg_resources.working_set:
+        package = dist.as_requirement()
+        packages[package.key] = package.specs[0][1]
+    return packages
+
+
+def nice_print(details: dict, level: int = 0) -> list:
+    lines = []
+    for k in sorted(details):
+        key = f"* {k}:" if level == 0 else f"- {k}:"
+        if isinstance(details[k], dict):
+            lines += [level * LEVEL_OFFSET + key]
+            lines += nice_print(details[k], level + 1)
+        elif isinstance(details[k], (set, list, tuple)):
+            lines += [level * LEVEL_OFFSET + key]
+            lines += [(level + 1) * LEVEL_OFFSET + "- " + v for v in details[k]]
+        else:
+            template = "{:%is} {}" % KEY_PADDING
+            key_val = template.format(key, details[k])
+            lines += [(level * LEVEL_OFFSET) + key_val]
+    return lines
+
+
+def main() -> None:
+    details = {"System": info_system(), "CUDA": info_cuda(), "Packages": info_packages()}
+    details["Lightning"] = {
+        k: v for k, v in details["Packages"].items() if "torch" in k or "lightning" in k
+    }
+    lines = nice_print(details)
+    text = os.linesep.join(lines)
+    print(f"<details>\n  <summary>Current environment</summary>\n\n{text}\n\n</details>")
+
+
+if __name__ == "__main__":
+    main()

visiontext/cli/compare_jpeg_decoder_performance.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+from timeit import default_timer
+
+from visiontext.examples import cc0images
+from visiontext.images import JPEGDecoderConst, decode_jpeg
+
+image_shapes_highres = [(5184, 3456, 3), (2038, 3057, 3), (2560, 2048, 3)]
+image_shapes_lowres = [(500, 333, 3), (333, 500, 3), (500, 400, 3)]
+
+
+def main():
+    src_dir_base = Path(cc0images.__file__).parent
+
+    for src_dir, image_shapes, n_trials in [
+        (src_dir_base, image_shapes_highres, 2),
+        (src_dir_base / "lowres", image_shapes_lowres, 100),
+    ]:
+        print(f"Test images in {src_dir}")
+        images_f = list(sorted(src_dir.glob("*.jpg")))
+
+        if len(images_f) != len(image_shapes):
+            raise ValueError(
+                f"Expected {len(image_shapes)} images in {src_dir}, got {len(images_f)}"
+            )
+        images_b = [Path(image_f).read_bytes() for image_f in images_f]
+
+        for decoder in JPEGDecoderConst.values():
+            if decoder == JPEGDecoderConst.PILLOW_IMAGE:
+                continue
+            t0 = default_timer()
+            for n in range(n_trials):
+                for i, image_b in enumerate(images_b):
+                    arr = decode_jpeg(image_b, method=decoder)
+                    if n == 0:
+                        # only test shape for first trial to not disturb the performance test
+                        ex_s = image_shapes[i]
+                        act_s = arr.shape
+                        if ex_s != act_s:
+                            raise ValueError(
+                                f"Expected shape {ex_s} for {images_f[i]}, got {act_s}"
+                            )
+            tdelta = default_timer() - t0
+            tper_ms = (tdelta / n_trials / len(images_f)) * 1000
+            print(f"    Decoder {decoder} took {tper_ms:.2f} ms per image on average")
+
+
+if __name__ == "__main__":
+    main()

visiontext/cli/download_hf_dataset.py

@@ -0,0 +1,59 @@
+"""
+download a dataset from huggingface.
+
+potentially useful args:
+    -o name=DatasetConfigName
+    -o use_auth_token=True
+    -o split="train"
+"""
+
+from pathlib import Path
+
+from attrs import define
+from loguru import logger
+
+from packg.log import SHORTEST_FORMAT, configure_logger, get_logger_level_from_args
+from packg.paths import get_packg_data_dir
+from typedparser import TypedParser, VerboseQuietArgs, add_argument
+from visiontext.configutils import load_dotlist
+
+
+@define
+class Args(VerboseQuietArgs):
+    base_dir: Path | None = add_argument(
+        shortcut="-d", type=str, help="Base dir", default=get_packg_data_dir()
+    )
+    dataset_name: str = add_argument(positional=True, type=str, help="Dataset name")
+    options: list[str] | None = add_argument(shortcut="-o", action="append", help="dataset kwargs")
+    subdir: str | None = add_argument(
+        shortcut="-s", type=str, help="Subdir (none=auto)", default=None
+    )
+
+
+def main():
+    parser = TypedParser.create_parser(Args, description=__doc__)
+    args: Args = parser.parse_args()
+    configure_logger(level=get_logger_level_from_args(args), format=SHORTEST_FORMAT)
+    logger.info(f"{args}")
+
+    dict_dotlist = load_dotlist(args.options)
+    subdir = args.subdir
+    if subdir is None:
+        subdir = args.dataset_name.replace("/", "__")
+
+    logger.info(f"Downloading dataset {args.dataset_name} to {args.base_dir / subdir}")
+    try:
+        from datasets import load_dataset
+    except ImportError as e:
+        logger.error(f"datasets is not installed. Please install it with `pip install datasets`.")
+        raise e
+    dataset = load_dataset(
+        args.dataset_name,
+        streaming=False,  # this downloads to disk
+        cache_dir=(args.base_dir / subdir).as_posix(),
+        **dict_dotlist,
+    )
+
+
+if __name__ == "__main__":
+    main()

visiontext/cli/export_sqlite_to_csv.py

@@ -0,0 +1,57 @@
+import os
+import sqlite3
+from pathlib import Path
+
+import pandas as pd
+from attrs import define
+from loguru import logger
+
+from packg.log import SHORTEST_FORMAT, configure_logger, get_logger_level_from_args
+from typedparser import TypedParser, VerboseQuietArgs, add_argument
+
+
+@define
+class Args(VerboseQuietArgs):
+    sqlite_file: Path = add_argument(positional=True, help="sqlite file")
+    run_export: bool = add_argument(action="store_true", help="Run the export", shortcut="-e")
+
+
+def main():
+    parser = TypedParser.create_parser(Args, description=__doc__)
+    args: Args = parser.parse_args()
+    configure_logger(level=get_logger_level_from_args(args), format=SHORTEST_FORMAT)
+    logger.info(f"{args}")
+
+    conn = sqlite3.connect(args.sqlite_file)
+
+    tables = pd.read_sql_query("SELECT name FROM sqlite_master WHERE type='table';", conn)
+    print("Tables in the database:")
+    print(tables)
+
+    # For each table, display the first few rows
+    for table_name in tables["name"]:
+        print(f"\nTable: {table_name}")
+        df = pd.read_sql_query(f"SELECT * FROM {table_name} LIMIT 5;", conn)
+        print(df)
+        cursor = conn.execute(f"SELECT COUNT(*) FROM {table_name}")
+        count = cursor.fetchone()[0]
+        print(f"Count: {count}")
+
+    if args.run_export:
+        export_dir = Path(f"{args.sqlite_file}_export")
+        if export_dir.is_dir():
+            logger.warning(f"Export directory already exists: {export_dir}")
+        os.makedirs(export_dir, exist_ok=True)
+        for table_name in tables["name"]:
+            print(f"\nTable: {table_name}")
+            df = pd.read_sql_query(f"SELECT * FROM {table_name}", conn)
+            print(df.shape)
+            csv_file = export_dir / f"{table_name}.csv"
+            df.to_csv(csv_file, sep=",", index=False)
+            print(f"Exported to: {csv_file}")
+
+    conn.close()
+
+
+if __name__ == "__main__":
+    main()