fotolab 0.21.1__py3-none-any.whl

fotolab/env.py

@@ -0,0 +1,52 @@
+# Copyright (C) 2024 Kian-Meng Ang
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+"""Env subcommand."""
+
+import argparse
+import logging
+import platform
+import sys
+
+from fotolab import __version__
+
+log = logging.getLogger(__name__)
+
+
+def build_subparser(subparsers) -> None:
+    """Build the subparser."""
+    env_parser = subparsers.add_parser(
+        "env", help="print environment information for bug reporting"
+    )
+
+    env_parser.set_defaults(func=run)
+
+
+def run(_args: argparse.Namespace) -> None:
+    """Run env subcommand.
+
+    Args:
+        config (argparse.Namespace): Config from command line arguments
+
+    Returns:
+        None
+    """
+    sys_version = sys.version.replace("\n", "")
+    print(
+        f"fotolab: {__version__}",
+        f"python: {sys_version}",
+        f"platform: {platform.platform()}",
+        sep="\n",
+    )

fotolab/info.py

@@ -0,0 +1,103 @@
+# Copyright (C) 2024 Kian-Meng Ang
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+"""Info subcommand."""
+
+import argparse
+import logging
+
+from PIL import ExifTags, Image
+
+log = logging.getLogger(__name__)
+
+
+def build_subparser(subparsers) -> None:
+    """Build the subparser."""
+    info_parser = subparsers.add_parser("info", help="info an image")
+
+    info_parser.set_defaults(func=run)
+
+    info_parser.add_argument(
+        dest="image_filename",
+        help="set the image filename",
+        type=str,
+        default=None,
+        metavar="IMAGE_FILENAME",
+    )
+
+    info_parser.add_argument(
+        "-s",
+        "--sort",
+        default=False,
+        action="store_true",
+        dest="sort",
+        help="show image info by sorted field name",
+    )
+
+    info_parser.add_argument(
+        "--camera",
+        default=False,
+        action="store_true",
+        dest="camera",
+        help="show the camera maker details",
+    )
+
+
+def run(args: argparse.Namespace) -> None:
+    """Run info subcommand.
+
+    Args:
+        config (argparse.Namespace): Config from command line arguments
+
+    Returns:
+        None
+    """
+    log.debug(args)
+    if args.camera:
+        print(camera_metadata(args.image_filename))
+    else:
+        exif_tags = extract_exif_tags(args.image_filename)
+        if exif_tags:
+            tag_name_width = max(map(len, exif_tags))
+            for tag_name, tag_value in exif_tags.items():
+                print(f"{tag_name:<{tag_name_width}}: {tag_value}")
+        else:
+            print("No metadata found!")
+
+
+def extract_exif_tags(image_filename: str, sort: bool = False) -> dict:
+    """Extract Exif metadata from image."""
+    image = Image.open(image_filename)
+    exif = image._getexif()
+    log.debug(exif)
+
+    info = {}
+    if exif:
+        info = {ExifTags.TAGS.get(tag_id): exif.get(tag_id) for tag_id in exif}
+
+    filtered_info = {
+        key: value for key, value in info.items() if key is not None
+    }
+    if sort:
+        filtered_info = dict(sorted(filtered_info.items()))
+
+    return filtered_info
+
+
+def camera_metadata(image_filename):
+    """Extract camera and model metadata."""
+    exif_tags = extract_exif_tags(image_filename)
+    metadata = f'{exif_tags["Make"]} {exif_tags["Model"]}'
+    return metadata.strip()

fotolab/montage.py

@@ -0,0 +1,71 @@
+# Copyright (C) 2024 Kian-Meng Ang
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+"""Montage subcommand."""
+
+import argparse
+import logging
+
+from PIL import Image
+
+from fotolab import save_image
+
+log = logging.getLogger(__name__)
+
+
+def build_subparser(subparsers) -> None:
+    """Build the subparser."""
+    montage_parser = subparsers.add_parser(
+        "montage", help="montage a list of image"
+    )
+
+    montage_parser.set_defaults(func=run)
+
+    montage_parser.add_argument(
+        dest="image_filenames",
+        help="set the image filenames",
+        nargs="+",
+        type=argparse.FileType("r"),
+        default=None,
+        metavar="IMAGE_FILENAMES",
+    )
+
+
+def run(args: argparse.Namespace) -> None:
+    """Run montage subcommand.
+
+    Args:
+        config (argparse.Namespace): Config from command line arguments
+
+    Returns:
+        None
+    """
+    log.debug(args)
+    images = []
+    for image_filename in args.image_filenames:
+        images.append(Image.open(image_filename.name))
+
+    total_width = sum(img.width for img in images)
+    total_height = max(img.height for img in images)
+
+    montaged_image = Image.new("RGB", (total_width, total_height))
+
+    x_offset = 0
+    for img in images:
+        montaged_image.paste(img, (x_offset, 0))
+        x_offset += img.width
+
+    output_image_filename = args.image_filenames[0].name
+    save_image(args, montaged_image, output_image_filename, "montage")

fotolab/resize.py

@@ -0,0 +1,176 @@
+# Copyright (C) 2024 Kian-Meng Ang
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+"""Resize subcommand."""
+
+import argparse
+import logging
+import math
+import sys
+
+from PIL import Image, ImageColor
+
+from fotolab import save_image
+
+log = logging.getLogger(__name__)
+
+DEFAULT_WIDTH = 600
+DEFAULT_HEIGHT = 277
+
+
+def build_subparser(subparsers) -> None:
+    """Build the subparser."""
+    resize_parser = subparsers.add_parser("resize", help="resize an image")
+
+    resize_parser.set_defaults(func=run)
+
+    resize_parser.add_argument(
+        dest="image_filenames",
+        help="set the image filename",
+        nargs="+",
+        type=str,
+        default=None,
+        metavar="IMAGE_FILENAMES",
+    )
+
+    resize_parser.add_argument(
+        "-c",
+        "--canvas",
+        default=False,
+        action="store_true",
+        dest="canvas",
+        help="paste image onto a larger canvas",
+    )
+
+    resize_parser.add_argument(
+        "-l",
+        "--canvas-color",
+        default="black",
+        dest="canvas_color",
+        help=(
+            "the color of the extended larger canvas"
+            "(default: '%(default)s')"
+        ),
+    )
+
+    if "-c" in sys.argv or "--canvas" in sys.argv:
+        resize_parser.add_argument(
+            "-W",
+            "--width",
+            dest="width",
+            help="set the width of the image (default: '%(default)s')",
+            type=int,
+            required=True,
+            metavar="WIDTH",
+        )
+
+        resize_parser.add_argument(
+            "-H",
+            "--height",
+            dest="height",
+            help="set the height of the image (default: '%(default)s')",
+            type=int,
+            required=True,
+            metavar="HEIGHT",
+        )
+    else:
+        group = resize_parser.add_mutually_exclusive_group(required=False)
+
+        group.add_argument(
+            "-W",
+            "--width",
+            dest="width",
+            help="set the width of the image (default: '%(default)s')",
+            type=int,
+            default=DEFAULT_WIDTH,
+            metavar="WIDTH",
+        )
+
+        group.add_argument(
+            "-H",
+            "--height",
+            dest="height",
+            help="set the height of the image (default: '%(default)s')",
+            type=int,
+            default=DEFAULT_HEIGHT,
+            metavar="HEIGHT",
+        )
+
+
+def run(args: argparse.Namespace) -> None:
+    """Run resize subcommand.
+
+    Args:
+        args (argparse.Namespace): Config from command line arguments
+
+    Returns:
+        None
+    """
+    log.debug(args)
+
+    for image_filename in args.image_filenames:
+        original_image = Image.open(image_filename)
+        if args.canvas:
+            resized_image = _resize_image_onto_canvas(original_image, args)
+        else:
+            resized_image = _resize_image(original_image, args)
+        save_image(args, resized_image, image_filename, "resize")
+
+
+def _resize_image_onto_canvas(original_image, args):
+    resized_image = Image.new(
+        "RGB",
+        (args.width, args.height),
+        (*ImageColor.getrgb(args.canvas_color), 128),
+    )
+    x_offset = (args.width - original_image.width) // 2
+    y_offset = (args.height - original_image.height) // 2
+    resized_image.paste(original_image, (x_offset, y_offset))
+    return resized_image
+
+
+def _resize_image(original_image, args):
+    new_width, new_height = _calc_new_image_dimension(original_image, args)
+    resized_image = original_image.copy()
+    resized_image = resized_image.resize(
+        (new_width, new_height), Image.Resampling.LANCZOS
+    )
+    return resized_image
+
+
+def _calc_new_image_dimension(image, args) -> tuple:
+    new_width = args.width
+    new_height = args.height
+
+    old_width, old_height = image.size
+    log.debug("old image dimension: %d x %d", old_width, old_height)
+
+    if args.width != DEFAULT_WIDTH:
+        aspect_ratio = old_height / old_width
+        log.debug("aspect ratio: %f", aspect_ratio)
+
+        new_height = math.ceil(args.width * aspect_ratio)
+        log.debug("new height: %d", new_height)
+
+    if args.height != DEFAULT_HEIGHT:
+        aspect_ratio = old_width / old_height
+        log.debug("aspect ratio: %f", aspect_ratio)
+
+        new_width = math.floor(args.height * aspect_ratio)
+        log.debug("new width: %d", new_width)
+
+    log.debug("new image dimension: %d x %d", new_width, new_height)
+
+    return (new_width, new_height)

fotolab/rotate.py

@@ -0,0 +1,61 @@
+# Copyright (C) 2024 Kian-Meng Ang
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+"""Rotate subcommand."""
+
+import argparse
+import logging
+
+from PIL import Image
+
+from fotolab import save_image
+
+log = logging.getLogger(__name__)
+
+
+def build_subparser(subparsers) -> None:
+    """Build the subparser."""
+    rotate_parser = subparsers.add_parser("rotate", help="rotate an image")
+
+    rotate_parser.set_defaults(func=run)
+
+    rotate_parser.add_argument(
+        dest="image_filenames",
+        help="set the image filenames",
+        nargs="+",
+        type=str,
+        default=None,
+        metavar="IMAGE_FILENAMES",
+    )
+
+
+def run(args: argparse.Namespace) -> None:
+    """Run rotate subcommand.
+
+    Args:
+        config (argparse.Namespace): Config from command line arguments
+
+    Returns:
+        None
+    """
+    log.debug(args)
+
+    for image_filename in args.image_filenames:
+        original_image = Image.open(image_filename)
+        rotated_image = original_image.rotate(
+            180,
+            expand=True,
+        )
+        save_image(args, rotated_image, image_filename, "rotate")

fotolab/sharpen.py

@@ -0,0 +1,98 @@
+# Copyright (C) 2024 Kian-Meng Ang
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+"""Sharpen subcommand."""
+
+import argparse
+import logging
+
+from PIL import Image, ImageFilter
+
+from fotolab import save_image
+
+log = logging.getLogger(__name__)
+
+
+def build_subparser(subparsers) -> None:
+    """Build the subparser."""
+    sharpen_parser = subparsers.add_parser("sharpen", help="sharpen an image")
+
+    sharpen_parser.set_defaults(func=run)
+
+    sharpen_parser.add_argument(
+        dest="image_filenames",
+        help="set the image filenames",
+        nargs="+",
+        type=str,
+        default=None,
+        metavar="IMAGE_FILENAMES",
+    )
+
+    sharpen_parser.add_argument(
+        "-r",
+        "--radius",
+        dest="radius",
+        type=int,
+        default=1,
+        help="set the radius or size of edges (default: '%(default)s')",
+        metavar="RADIUS",
+    )
+
+    sharpen_parser.add_argument(
+        "-p",
+        "--percent",
+        dest="percent",
+        type=int,
+        default=100,
+        help=(
+            "set the amount of overall strength of sharpening effect "
+            "(default: '%(default)s')"
+        ),
+        metavar="PERCENT",
+    )
+
+    sharpen_parser.add_argument(
+        "-t",
+        "--threshold",
+        dest="threshold",
+        type=int,
+        default=3,
+        help=(
+            "set the minimum brightness changed to be sharpened "
+            "(default: '%(default)s')"
+        ),
+        metavar="THRESHOLD",
+    )
+
+
+def run(args: argparse.Namespace) -> None:
+    """Run sharpen subcommand.
+
+    Args:
+        config (argparse.Namespace): Config from command line arguments
+
+    Returns:
+        None
+    """
+    log.debug(args)
+
+    for image_filename in args.image_filenames:
+        original_image = Image.open(image_filename)
+        sharpen_image = original_image.filter(
+            ImageFilter.UnsharpMask(
+                args.radius, percent=args.percent, threshold=args.threshold
+            )
+        )
+        save_image(args, sharpen_image, image_filename, "sharpen")