build_command.py

# This functions create commands, that can be executed in a terminal or a subprocess.
# There are two reasons for this approach for compression:
# 1. CLI tools offer more parameters for adjusting the compression
# 2. Different compression algorithms require specific libraries, which sometimes causes conflicts.
#    This approach offers the possibility to use different environments (for example: conda)
#
# The main disadvantage are the specific paths that must be provided.

import paths

def build_command_jpeg(image_path, output_path, **kwargs):
    # cjpeg does not take .png as input -> convert to .ppm first
    command = f"""convert {image_path} {output_path[:-3]}ppm && cjpeg """

    command += f"""-q {kwargs['quality']} -outfile {output_path} """

    if "smooth" in kwargs:
        command += f"""-smooth {kwargs["smooth"]} """

    if "grayscale" in kwargs and kwargs["grayscale"] == True:
        command += f"""-grayscale """

    if "rgb" in kwargs and kwargs["rgb"] == True:
        command += f"""-rgb """

    if "progressive" in kwargs and kwargs["progressive"] == True:
        command += f"""-progressive """

    if "optimize" in kwargs and kwargs["optimize"] == True:
        command += f"""-optimize """

    if "arithmetic" in kwargs and kwargs["arithmetic"] == True:
        command += f"""-arithmetic """

    command += f"""{output_path[:-3]}ppm """

    return command

def build_command_j2k(input_path, output_path_j2k, **kwargs):
    command = "opj_compress "

    command += f"""-i {input_path} -o {output_path_j2k} """

    if "ratio" in kwargs:
        command += f"""-r {kwargs["ratio"]} """

    if "psnr" in kwargs:
        command += f"""-q {kwargs["psnr"]} """

    if "number_of_resolutions" in kwargs:
        command += f"""-n {kwargs["number_of_resolutions"]} """

    if "block_width" in kwargs and "block_height" in kwargs:
        command += f"""-b {kwargs["block_width"]},{kwargs["block_height"]} """

    if "tile_width" in kwargs and "tile_height" in kwargs:
        command += f"""-t {kwargs["tile_width"]},{kwargs["tile_height"]} """

    if "subsampling_x" in kwargs and "subsampling_y" in kwargs:
        command += f"""-s {kwargs["subsampling_x"]},{kwargs["subsampling_y"]} """

    if "progression_order" in kwargs:
        command += f"""-p {kwargs["progression_order"]} """

    return command

def build_command_heif(input_path, output_path_heif, **kwargs):
    command = "heif-enc "

    if "quality" in kwargs:
        command += f"""-q {kwargs["quality"]} """

    if "no_alpha" in kwargs and kwargs["no_alpha"] == True:
        command += f"""--no-alpha """

    if "bit_depth" in kwargs:
        command += f"""-b {kwargs["bit_depth"]} """

    if "chroma_downsampling" in kwargs:
        command += f"""-C {kwargs["chroma_downsampling"]} """

    if "cut_tiles" in kwargs:
        command += f"""--cut-tiles {kwargs["cut_tiles"]} """

    command += f"""-o {output_path_heif} {input_path} """

    return command

def build_command_webp(input_path, output_path_webp, **kwargs):
    command = "cwebp "

    if "preset" in kwargs:
        command += f"""-preset {kwargs["preset"]} """

    command += f"""-size 1024 """

    if "method" in kwargs:
        command += f"""-m {kwargs["method"]} """

    if "segments" in kwargs:
        command += f"""-segments {kwargs["segments"]} """

    if "psnr" in kwargs:
        command += f"""-psnr {kwargs["psnr"]} """

    if "filter_strength" in kwargs:
        command += f"""-f {kwargs["filter_strength"]} """

    if "sharpness" in kwargs:
        command += f"""-sharpness {kwargs["sharpness"]} """

    if "analysis_pass" in kwargs:
        command += f"""-pass {kwargs["analysis_pass"]} """

    if "no_alpha" in kwargs and kwargs["no_alpha"] == True:
        command += f"""-noalpha """

    if "sns" in kwargs:
        command += f"""-sns {kwargs["sns"]} """

    command += f""""{input_path}" -o "{output_path_webp}" """

    return command


def build_command_jxl(input_path, output_path_jxl, **kwargs):
    command = set_conda_env_base()

    command += f"""cjxl "{input_path}" "{output_path_jxl}" """

    if "quality" in kwargs:
        command += f"""-q {kwargs["quality"]} """

    if "distance" in kwargs:
        command += f"""-d {kwargs["distance"]} """

    if "effort" in kwargs:
        command += f"""-e {kwargs["effort"]} """

    if "alpha_distance" in kwargs:
        command += f"""-a {kwargs["alpha_distance"]} """

    if "progressive" in kwargs and kwargs["progressive"] == True:
        command += f"""-p """

    if "compress_boxes" in kwargs:
        command += f"""--compress_boxes {kwargs["compress_boxes"]} """

    if "brotli_effort" in kwargs:
        command += f"""--brotli_effort {kwargs["brotli_effort"]} """

    if "override_bit_depth" in kwargs:
        command += f"""--override_bitdepth {kwargs["override_bit_depth"]} """

    if "resampling" in kwargs:
        command += f"""--resampling {kwargs["resampling"]} """

    return command

def build_command_avif(input_path, output_path_avif, **kwargs):
    command = f"""avifenc """

    if "quality_color" in kwargs:
        command += f"""--qcolor {kwargs["quality_color"]} """

    if "quality_alpha" in kwargs:
        command += f"""--qalpha {kwargs["quality_alpha"]} """

    if "yuv_format" in kwargs:
        command += f"""--yuv {kwargs["yuv_format"]} """

    if "depth" in kwargs:
        command += f"""--depth {kwargs["depth"]} """

    if "premultiply" in kwargs and kwargs["premultiply"] == True:
        command += f"""--premultiply """

    if "tile_cols" in kwargs:
        command += f"""--tilecolslog2 {kwargs["tile_cols"]} """

    if "tile_rows" in kwargs:
        command += f"""--tilerowslog2 {kwargs["tile_rows"]} """

    if "speed" in kwargs:
        command += f"""--speed {kwargs["speed"]} """

    if "range" in kwargs:
        command += f"""--range {kwargs["range"]} """

    if "sharp_yuv" in kwargs and kwargs["sharp_yuv"] == True:
        command += f"""--sharpyuv """

    if "progressive" in kwargs and kwargs["progressive"] == True:
        command += f"""--progressive """

    if "target_size" in kwargs:
        command += f"""--target-size {kwargs["target_size"]} """

    command += f""" "{input_path}" "{output_path_avif}" """
    return command

def build_command_jai(input_path, output_path_jai, **kwargs):
    command = set_conda_env_jpeg_ai_vm()
    command += f"""cd {paths.jpeg_ai_reference_software} && """
    command += f"""python -m src.reco.coders.encoder {input_path} {output_path_jai} """

    if "target_bpp" in kwargs:
        command += f"""--set_target_bpp {kwargs["target_bpp"]} """

    return command

def build_command_jxl_decompress(input_path, output_path_png):
    command = set_conda_env_base()
    command += f"""djxl "{input_path}" "{output_path_png}" """
    return command

def build_command_heif_decompress(input_path, output_path_png):
    command = f"""heif-dec "{input_path}" -o "{output_path_png}" """
    return command

def build_command_j2k_decompress(input_path, output_path_png):
    command = f"""opj_decompress -i "{input_path}" -o "{output_path_png}" """
    return command

def build_command_jai_decompress(input_path, output_path_png):
    command = set_conda_env_jpeg_ai_vm()
    command += f"""cd {paths.jpeg_ai_reference_software} && """
    command += f"""python -m src.reco.coders.decoder {input_path} {output_path_png}"""
    return command

def set_conda_env_base():
    return f"""source {paths.conda_envs} base && """

def set_conda_env_jpeg_ai_vm():
    return f"""source {paths.conda_envs} jpeg_ai_vm && """