bluer-objects 6.3.1__py3-none-any.whl

bluer_objects/graphics/text.py

@@ -0,0 +1,165 @@
+from typing import Tuple, List, Union
+import cv2
+from functools import reduce
+import numpy as np
+
+from blueness import module
+
+from bluer_objects import NAME
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+def render_text(
+    text: List[str],
+    box: bool = False,
+    centered: bool = False,
+    color_depth: int = 3,
+    font_color: Union[Tuple, List, int] = 3 * (127,),
+    font_face: int = cv2.FONT_HERSHEY_SIMPLEX,
+    font_size: int = 2,
+    height: float = 1.0,
+    image: Union[None, np.array] = None,
+    image_width: Union[None, int] = None,
+    left: float = 0.0,
+    line_type: int = cv2.LINE_AA,
+    thickness: int = 1,
+    top: float = 0.0,
+    width: float = 1.0,
+) -> np.ndarray:
+    if image is None:
+        if image_width is None:
+            logger.error(f"-{NAME}: render_text(None): image_width is missing.")
+            return image
+    else:
+        if not image.shape or len(image.shape) < 2:
+            return image
+
+    if not isinstance(font_color, list) and not isinstance(font_color, tuple):
+        font_color = 3 * (font_color,)
+
+    if not isinstance(text, list):
+        text = [text]
+
+    # https://stackoverflow.com/a/51285918/10917551
+    # (label_width, label_height), baseline
+    text_line_size = [
+        cv2.getTextSize(
+            text=text_line,
+            fontFace=font_face,
+            fontScale=font_size,
+            thickness=thickness,
+        )
+        for text_line in text
+    ]
+
+    required_text_height = reduce(
+        lambda x, y: x + y,
+        [
+            text_line_size_[0][1] + text_line_size_[1] + 2
+            for text_line_size_ in text_line_size
+        ],
+        0,
+    )
+    required_text_width = max(
+        [text_line_size_[0][0] for text_line_size_ in text_line_size]
+    )
+
+    if image is None:
+        text_width = int(image_width * width)
+
+        font_size *= text_width / required_text_width
+    else:
+        text_height = int(image.shape[0] * height)
+        text_width = int(image.shape[1] * width)
+
+        font_size *= min(
+            [text_width / required_text_width, text_height / required_text_height]
+        )
+
+    # (label_width, label_height), baseline
+    text_line_size = [
+        cv2.getTextSize(
+            text=text_line,
+            fontFace=font_face,
+            fontScale=font_size,
+            thickness=thickness,
+        )
+        for text_line in text
+    ]
+
+    required_text_height = reduce(
+        lambda x, y: x + y,
+        [
+            text_line_size_[0][1] + text_line_size_[1] + 2
+            for text_line_size_ in text_line_size
+        ],
+        0,
+    )
+
+    if image is None:
+        image = np.zeros(
+            (required_text_height, image_width, color_depth),
+            dtype=np.uint8,
+        )
+
+    text_height = int(image.shape[0] * height)
+    text_width = int(image.shape[1] * width)
+
+    line_spacing = (text_height - required_text_height) / (1 + len(text))
+
+    text_left = int(image.shape[1] * left)
+    text_top = int(image.shape[0] * top)
+
+    x = text_left
+    y = text_top + line_spacing
+    for index, text_line in enumerate(text):
+        y += text_line_size[index][0][1] + 2
+
+        actual_x = int(
+            x + text_width / 2 - text_line_size[index][0][0] / 2 if centered else x
+        )
+
+        cv2.putText(
+            image,
+            text=text_line,
+            org=(
+                actual_x,
+                int(y),
+            ),
+            fontFace=font_face,
+            fontScale=font_size,
+            color=font_color,
+            lineType=line_type,
+            thickness=thickness,
+        )
+        if box:
+            cv2.rectangle(
+                image,
+                (
+                    int(actual_x),
+                    int(y - text_line_size[index][0][1]),
+                ),
+                (
+                    int(actual_x + text_line_size[index][0][0]),
+                    int(y + text_line_size[index][1]),
+                ),
+                color=font_color,
+                thickness=thickness // 2,
+                lineType=line_type,
+            )
+
+        y += line_spacing
+
+    if box:
+        cv2.rectangle(
+            image,
+            (text_left, text_top),
+            (text_left + text_width, text_top + text_height),
+            color=font_color,
+            thickness=thickness,
+            lineType=line_type,
+        )
+
+    return image

bluer_objects/help/__main__.py

@@ -0,0 +1,10 @@
+from blueness import module
+from blue_options.help.functions import help_main
+
+from bluer_objects import NAME
+from bluer_objects.help.functions import help_functions
+
+NAME = module.name(__file__, NAME)
+
+
+help_main(NAME, help_functions)

bluer_objects/help/functions.py

@@ -0,0 +1,5 @@
+from abcli.help.generic import help_functions as generic_help_functions
+
+from bluer_objects import ALIAS
+
+help_functions = generic_help_functions(plugin_name=ALIAS)

bluer_objects/host/__init__.py

@@ -0,0 +1 @@
+from bluer_objects.host.functions import shell, unzip

bluer_objects/host/__main__.py

@@ -0,0 +1,84 @@
+import argparse
+
+from blueness import module
+from blueness.argparse.generic import sys_exit
+
+from bluer_objects import NAME, file
+from blue_options.host import signature as host_signature
+from bluer_objects.graphics import add_signature
+from bluer_objects.objects import signature as object_signature
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+parser = argparse.ArgumentParser(NAME)
+parser.add_argument(
+    "task",
+    type=str,
+    default="get",
+    help="add_signature",
+)
+parser.add_argument(
+    "--application",
+    type=str,
+    default="",
+)
+parser.add_argument(
+    "--header",
+    type=str,
+    default="",
+    help="this|that",
+)
+parser.add_argument(
+    "--filename",
+    type=str,
+    default="",
+)
+parser.add_argument(
+    "--footer",
+    type=str,
+    default="",
+    help="this|that",
+)
+parser.add_argument(
+    "--item_name",
+    default="tag",
+    type=str,
+)
+parser.add_argument(
+    "--log",
+    default=1,
+    type=int,
+    help="0|1",
+)
+parser.add_argument(
+    "--word_wrap",
+    default=0,
+    type=int,
+    help="0|1",
+)
+args = parser.parse_args()
+
+success = False
+if args.task == "add_signature":
+    success, image = file.load_image(args.filename)
+    if success:
+        success = file.save_image(
+            args.filename,
+            add_signature(
+                image,
+                [args.header] + [" | ".join(object_signature())],
+                [args.footer] + [" | ".join([args.application] + host_signature())],
+                word_wrap=args.word_wrap,
+            ),
+        )
+
+    if success:
+        logger.info(
+            f"{NAME}.add_signature({args.filename},{args.header},{args.footer})"
+        )
+else:
+    success = None
+
+
+sys_exit(logger, NAME, args.task, success, log=args.log)

bluer_objects/host/functions.py

@@ -0,0 +1,66 @@
+import os
+from typing import Union, Tuple, List
+
+from blueness import module
+from blue_options.logger import crash_report
+
+from bluer_objects import NAME, file
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+def shell(
+    command: str,
+    clean_after: bool = False,
+    return_output: bool = False,
+    work_dir: str = ".",
+    log: bool = False,
+) -> Union[
+    bool,
+    Tuple[bool, List[str]],
+]:
+    if log:
+        logger.info(f"{NAME}.shell({command})")
+
+    success = True
+    output = []
+
+    if return_output:
+        output_filename = file.auxiliary("shell", "txt")
+        command += f" > {output_filename}"
+
+    current_path = os.getcwd()
+    try:
+        os.chdir(work_dir)
+
+        try:
+            os.system(command)
+        except:
+            crash_report(f"host.shell({command}) failed")
+            success = False
+
+    finally:
+        os.chdir(current_path)
+
+    if success and return_output:
+        success, output = file.load_text(output_filename)
+
+        if clean_after:
+            file.delete(output_filename)
+
+    return (success, output) if return_output else success
+
+
+def unzip(
+    zip_filename: str,
+    output_folder: str = "",
+    log: bool = False,
+) -> bool:
+    if not output_folder:
+        output_folder = file.path(zip_filename)
+
+    return shell(
+        command=f'unzip -q -o "{zip_filename}" -d "{output_folder}"',
+        log=log,
+    )

bluer_objects/logger/__init__.py

@@ -0,0 +1,4 @@
+from blue_options.logger import get_logger
+from bluer_objects import ICON
+
+logger = get_logger(ICON)

bluer_objects/logger/matrix.py

@@ -0,0 +1,209 @@
+from typing import List, Tuple
+import numpy as np
+import matplotlib.pyplot as plt
+import math
+import cv2
+
+from blueness import module
+from blue_options import string
+from abcli.host import signature
+
+from bluer_objects import NAME
+from bluer_objects import file
+from bluer_objects.graphics.signature import add_signature, justify_text
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+def log_matrix(
+    matrix: np.ndarray,
+    header: List[str],
+    footer: List[str],
+    filename: str,
+    dynamic_range: Tuple[float] = (-100, 100),
+    line_width: int = 80,
+    min_width: int = 1200,
+    max_width: int = 2400,
+    colorbar_width: int = 20,
+    colormap: int = -1,  # example: cv2.COLORMAP_JET
+    invert_color_map: bool = True,
+    invert_color_map_rgb: bool = True,
+    verbose: bool = False,
+    log: bool = True,
+    log_range: bool = False,
+    log_shape_of_matrix: bool = True,
+    suffix: List[np.ndarray] = [],
+) -> bool:
+    if log:
+        logger.info(
+            "{}.log_matrix({})".format(
+                NAME,
+                string.pretty_shape_of_matrix(matrix),
+            )
+        )
+
+    shape_of_matrix = string.pretty_shape_of_matrix(matrix)
+
+    range_signature: List[str] = (
+        [f"range: {string.pretty_range_of_matrix(matrix)}"] if log_range else []
+    )
+
+    scale = 1
+    if min_width != -1 and matrix.shape[1] < min_width and matrix.shape[1] > 0:
+        scale = int(math.ceil(min_width / matrix.shape[1]))
+    elif max_width != -1 and (
+        matrix.shape[0] > max_width or matrix.shape[1] > max_width
+    ):
+        scale = min([max_width / matrix.shape[index] for index in [0, 1]])
+
+    if scale != 1:
+        if verbose:
+            logger.info(f"scale: {scale}")
+
+        matrix = cv2.resize(
+            matrix,
+            (
+                int(scale * matrix.shape[1]),
+                int(scale * matrix.shape[0]),
+            ),
+            interpolation=cv2.INTER_NEAREST_EXACT,
+        )
+
+    if colormap != -1:
+        normalized_matrix = (matrix - dynamic_range[0]) / (
+            dynamic_range[1] - dynamic_range[0]
+        )
+        normalized_matrix[normalized_matrix < 0] = 0
+        normalized_matrix[normalized_matrix > 1] = 1
+
+        colored_matrix = cv2.applyColorMap(
+            (
+                (1 - normalized_matrix if invert_color_map else normalized_matrix) * 255
+            ).astype(np.uint8),
+            colormap,
+        )
+        if not invert_color_map_rgb:
+            colored_matrix = colored_matrix[:, :, [2, 1, 0]]
+
+        gradient = (
+            255
+            * np.linspace(0, 1, colored_matrix.shape[0]).reshape(-1, 1)
+            * np.ones((1, colorbar_width))
+        ).astype(np.uint8)
+        colorbar = cv2.applyColorMap(gradient, colormap)
+        if not invert_color_map:
+            colorbar = np.flipud(colorbar)
+        if not invert_color_map_rgb:
+            colorbar = colorbar[:, :, [2, 1, 0]]
+
+        colored_matrix = np.hstack(
+            (
+                colored_matrix,
+                np.zeros(
+                    (colored_matrix.shape[0], colorbar_width // 2, 3),
+                    dtype=np.uint8,
+                ),
+                colorbar,
+            )
+        )
+
+        matrix = colored_matrix
+
+    if suffix:
+        if scale != 1:
+            suffix = [
+                cv2.resize(
+                    matrix,
+                    (
+                        int(scale * matrix.shape[1]),
+                        int(scale * matrix.shape[0]),
+                    ),
+                    interpolation=cv2.INTER_NEAREST_EXACT,
+                )
+                for matrix in suffix
+            ]
+
+        matrix = np.concatenate([matrix] + suffix, axis=1)
+
+    matrix = add_signature(
+        matrix,
+        header=[
+            " | ".join(
+                header
+                + ([shape_of_matrix] if log_shape_of_matrix else [])
+                + [
+                    f"scale: {scale:.2f}X",
+                ]
+                + (
+                    []
+                    if colormap == -1
+                    else [
+                        "dynamic-range: ( {:.03f} , {:.03f} )".format(
+                            dynamic_range[0],
+                            dynamic_range[1],
+                        ),
+                    ]
+                )
+                + range_signature
+            )
+        ],
+        footer=[" | ".join(footer + signature())],
+        word_wrap=True,
+        line_width=line_width,
+    )
+
+    return file.save_image(filename, matrix, log=verbose)
+
+
+def log_matrix_hist(
+    matrix: np.ndarray,
+    dynamic_range: Tuple[float],
+    filename: str,
+    header: List[str] = [],
+    footer: List[str] = [],
+    line_width: int = 80,
+    bins: int = 64,
+    ylabel: str = "frequency",
+    log: bool = True,
+    verbose: bool = False,
+) -> bool:
+    if log:
+        logger.info(
+            "{}.log_matrix_hist({})".format(
+                NAME,
+                string.pretty_shape_of_matrix(matrix),
+            )
+        )
+
+    plt.figure(figsize=(10, 6))
+    plt.hist(
+        matrix.ravel(),
+        bins=bins,
+        range=dynamic_range,
+    )
+    plt.title(
+        justify_text(
+            " | ".join(
+                header
+                + [
+                    string.pretty_shape_of_matrix(matrix),
+                    f"dynamic-range: {dynamic_range}",
+                    f"bins: {bins}",
+                ]
+            ),
+            line_width=line_width,
+            return_str=True,
+        )
+    )
+    plt.xlabel(
+        justify_text(
+            " | ".join(footer + signature()),
+            line_width=line_width,
+            return_str=True,
+        )
+    )
+    plt.ylabel(ylabel)
+    plt.grid(True)
+
+    return file.save_fig(filename, log=verbose)

bluer_objects/markdown.py

@@ -0,0 +1,43 @@
+from typing import List
+import math
+
+from blueness import module
+
+from bluer_objects import NAME
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+def generate_table(
+    items: List[str],
+    cols: int = 3,
+) -> List[str]:
+    if not items:
+        return []
+
+    items_dict = {index: item for index, item in enumerate(items)}
+
+    cols = min(cols, len(items))
+
+    row_count = int(math.ceil(len(items) / cols))
+
+    logger.info(
+        "{}.generate_table(): {} item(s), {} row(s)".format(
+            NAME,
+            len(items),
+            row_count,
+        )
+    )
+
+    return [
+        "| {} |".format(" | ".join(cols * [" "])),
+        "| {} |".format(" | ".join(cols * ["---"])),
+    ] + [
+        "| {} |".format(
+            " | ".join(
+                [items_dict.get(cols * row_index + index, "") for index in range(cols)]
+            )
+        )
+        for row_index in range(row_count)
+    ]

bluer_objects/metadata/__init__.py

@@ -0,0 +1,8 @@
+from bluer_objects.metadata.enums import MetadataSourceType
+from bluer_objects.metadata.get import (
+    get,
+    get_from_file,
+    get_from_object,
+    get_from_path,
+)
+from bluer_objects.metadata.post import post, post_to_file, post_to_object, post_to_path