Test/astc_image_info.py

#!/usr/bin/env python3
# SPDX-License-Identifier: Apache-2.0
# -----------------------------------------------------------------------------
# Copyright 2020 Arm Limited
#
# 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.
# -----------------------------------------------------------------------------
"""
The ``astc_image_info`` utility provides basic image query capabilities. It is
a modal command line utility, exposing multiple available operators.

* ``info``: Query structural information about the image, such as image
      dimensions, number of color channels, and the min/max of each channel.
* ``color``: Query the stored color value at a specific pixel coordinate, and
      print the result in a variety of different formats.

Both modes allow multiple images to be specified on the command line.
"""

import argparse
import sys

from PIL import Image


def main_color(args):
    """
    Main function for the "color" mode.

    This mode prints the color at a specific pixel coordinate in each image.
    The color value is printed in a variety of color formats (decimal, HTML
    string, float).

    Args:
        args (Namespace): The parsed command line arguments.

    Returns:
        int: The process return code.
    """
    retCode = 0

    for i, image in enumerate(args.images):
        if i != 0:
            print("")

        img = Image.open(image.name)
        x = args.location[0]
        y = args.location[1]

        print(image.name)
        print("=" * len(image.name))

        if (x >= img.size[0]) or (y >= img.size[1]):
            print("- ERROR: location out-of-bounds [%ux%u]" % img.size)
            retCode = 1
        else:
            color = img.getpixel((x, y))

            # Print byte values
            print("+ Byte: %s" % str(color))

            # Print hex values
            fmtString = "+ Hex: #" + ("%02X" * len(color))
            print(fmtString % color)

            # Print float values
            parts = ["%g"] * len(color)
            parts = ", ".join(parts)
            fmtString = "+ Float: (" + parts + ")"
            print(fmtString % tuple(float(x)/255.0 for x in color))

    return retCode


def main_info(args):
    """
    Main function for the "info" mode.

    This mode prints the basic metadata of an image:

        - the overall image size.
        - the number of color channels.
        - the min/max value in each color channel.

    Args:
        args (Namespace): The parsed command line arguments.

    Returns:
        int: The process return code.
    """
    for i, image in enumerate(args.images):
        if i != 0:
            print("")

        img = Image.open(image.name)
        minmax = img.getextrema()

        print(image.name)
        print("=" * len(image.name))
        print("+ Size: %ux%u" % (img.size[0], img.size[1]))
        print("+ Channels: %s" % ("".join(img.getbands())))
        for j, channel in enumerate(img.getbands()):
            print("  + %s: %u - %u" % (channel, *minmax[j]))

    return 0


def parse_loc(value):
    """
    Command line argument parser for position arguments.

    Args:
        value (str): The command line argument string to parse. Must be of the
            form <int>x<int>", where both integers must be zero or positive.

    Returns:
        list(int, int): The parsed location.

    Raises:
        ArgumentTypeError: The value is not a valid location.
    """
    error = argparse.ArgumentTypeError("%s is an invalid location" % value)
    svalue = value.split("x")

    if len(svalue) != 2:
        raise error

    try:
        ivalue = [int(x) for x in svalue if int(x) >= 0]
    except ValueError:
        raise error

    if len(ivalue) != len(svalue):
        raise error

    return ivalue


def parse_command_line():
    """
    Parse the command line.

    Returns:
        Namespace: The parsed command line container.
    """
    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers(
        title="Operations")

    # Create the parser for the "pipette" command
    parserA = subparsers.add_parser(
        "color",
        help="Print color at given coordinate")

    parserA.set_defaults(func=main_color)

    parserA.add_argument(
        "location", metavar="loc", type=parse_loc,
        help="The location spec XxY")

    parserA.add_argument(
        "images", metavar="image", nargs="+", type=argparse.FileType("r"),
        help="The images to query")

    # Create the parser for the "size" command
    parserB = subparsers.add_parser(
        "info",
        help="Print image metadata info")

    parserB.set_defaults(func=main_info)

    parserB.add_argument(
        "images", metavar="image", nargs="+", type=argparse.FileType("r"),
        help="The images to query")

    # Cope with the user failing to specify any sub-command. Note on Python 3.8
    # we could use required=True on the add_subparsers call, but we cannot do
    # this on 3.6 which is our current min-spec.
    args = parser.parse_args()
    if not hasattr(args, "func"):
        parser.print_help()
        return None

    return args


def main():
    """
    The main function.

    Returns:
        int: The process return code.
    """
    args = parse_command_line()
    if args:
        return args.func(args)

    return 0


if __name__ == "__main__":
    sys.exit(main())