SL1_to_Photon.py

#!/usr/bin/env python3

import glob
import os
import sys
import zipfile
import tempfile
import argparse
import pyphotonfile
import multiprocessing
import io
from PIL import Image
from pyphotonfile.photonfile import SubLayer


class SL1Reader:
    def __init__(self, filepath):
        self.zf = zipfile.ZipFile(filepath, "r")
        self.config = self._read_config_file("config.ini")
        self.prusa_config = self._read_config_file("prusaslicer.ini")
        self.n_layers = 0

        for filename in self.zf.namelist():
            # skip all files in subdirectories (e.g. thumbnails)
            if os.path.dirname(filename) != "":
                continue
            if filename.startswith(self.config["jobDir"]) and ".png" in filename:
                self.n_layers += 1

    def _read_config_file(self, name="config.ini") -> dict[str, str]:
        try:
            config_file = self.zf.read(name)
        except KeyError:
            raise FileNotFoundError(f"ERROR: Did not find {name} in zip file. Is that really an SL1 file?")

        config = {}
        for line in config_file.decode().splitlines():
            key, value = line.strip().split("=", 1)
            config[key.strip()] = value.strip().replace("\\n", "\n")
        return config

    def read_thumbnail(self, size="800x480") -> Image.Image:
        try:
            tb = self.zf.read(f"thumbnail/thumbnail{size}.png")
        except KeyError:
            raise FileNotFoundError(
                f"ERROR: Did not find thumbnail of size {size} in zip file. Is that really an SL1 file?"
            )
        return Image.open(io.BytesIO(tb))

    def extract_images(self, dirpath):
        try:
            os.makedirs(dirpath)
        except OSError:
            pass  # Means it already exists. We're file with that.
        for filename in self.zf.namelist():
            if os.path.dirname(filename) != "":  # skip all files in subdirectories (e.g. thumbnails)
                continue
            if ".png" in filename:
                data = self.zf.read(filename)
                with open(os.path.join(dirpath, filename), "bw") as f:
                    f.write(data)


if __name__ == "__main__":
    desc = """Convert an SL1 file to a Photon file."""
    parser = argparse.ArgumentParser(description=desc)
    parser.add_argument("sl1_file", help="SL1 file to convert.")
    parser.add_argument("-f", "--force", action="store_true", help="overwrite existing files")
    # parser.add_argument("--timelapse", action='store_true', default=False, help="set all exposures to 1s. Useful for debugging exposure with no resin.")
    parser.add_argument("-q", "--quiet", action="store_true", default=False)
    parser.add_argument("-bls", "--bottomliftspeed", help="bottom lifting speed (40)", default="40")
    parser.add_argument("-ls", "--liftspeed", help="lifting speed (40)", default="40")
    parser.add_argument("-rs", "--retractspeed", help="retract speed (180)", default="180")
    parser.add_argument("-o", "--output", help="photon file output path")
    args = parser.parse_args()

    def log(*a, **b):
        if not args.quiet:
            print(*a, **b)

    if not os.path.exists(args.sl1_file):
        raise FileNotFoundError(f"File {args.sl1_file} does not exist!")

    sl1 = SL1Reader(args.sl1_file)

    all_args = []

    # Additional args from material_notes

    locations = ["material_notes", "printer_notes"]

    for location in locations:
        notes = sl1.prusa_config[location]
        _flags_designator = "photonflags "
        for line in notes.splitlines():
            if line.startswith(_flags_designator):
                flags = line[len(_flags_designator) :]
                log(f"Found additional flags in {location}: {flags}")
                # all_args += [a for a in flags.split() if len(a)]

    if len(all_args):
        # sys.argv += all_args
        log(f"Final args: {sys.argv}")

    args = parser.parse_args()

    parser.parse_args()

    if args.output is None:
        base, ext = os.path.splitext(args.sl1_file)
        photon_path = sl1.config["jobDir"] + ".photon"
    else:
        photon_path = args.output
    if os.path.exists(photon_path) and not args.force:
        raise FileExistsError(
            f"File {os.path.basename(photon_path)} already exists!. move or use -f flag to force overwrite."
        )

    photon = pyphotonfile.Photon()
    photon.version = 2

    # Printer settings

    photon.bed_x = 68.04000091552734
    photon.bed_y = 120.95999908447266
    photon.bed_z = 155.0

    # Slicing settings

    photon.anti_aliasing_level = 0
    photon.layer_levels = 1
    photon.layer_height = float(sl1.config["layerHeight"])
    photon.bottom_layers = int(sl1.config["numFade"])
    photon.bottom_layer_count = int(sl1.config["numFade"])

    # Lift settings

    photon.lifting_speed = float(args.liftspeed)
    photon.lifting_distance = 5.0

    photon.bottom_lift_speed = float(args.bottomliftspeed)
    photon.bottom_lift_distance = 6.0

    photon.retract_speed = float(args.retractspeed)

    # Curing settings

    photon.exposure_time = float(sl1.config["expTime"])
    photon.exposure_time_bottom = float(sl1.config["expTimeFirst"])
    photon.bottom_light_off_delay = 0.0
    photon.light_off_delay = 0.0
    photon.off_time = 1.0
    photon.light_pwm = 255
    photon.light_pwm_bottom = 255

    # Meta
    photon.volume_ml = float(sl1.config["usedMaterial"])
    photon.weight_g = float(sl1.config["usedMaterial"])
    photon.cost_dollars = 1.0
    photon.print_properties_length = 60
    photon.print_time = int(float(sl1.config["printTime"]))
    photon.set_preview_highres(sl1.read_thumbnail(size="800x480"))
    photon.set_preview_lowres(sl1.read_thumbnail(size="400x400"))

    # Strange settings
    photon.p1 = 1.875
    photon.p2 = 9.453131998900351e23
    photon.p3 = 0.0
    photon.p4 = 8.407790785948902e-45

    log("=== PARAMETERS ===")
    log("Layers: {}".format(sl1.n_layers))
    log("  Height: {}".format(photon.layer_height))
    log("  Exposure Time: {}".format(photon.exposure_time))
    log("  Lifting Speed: {}".format(photon.lifting_speed))
    log("  Lifting distance: {}".format(photon.lifting_distance))
    log()
    log("Bottom Layers: {}".format(photon.bottom_layers))
    log("  Exposure Time: {}".format(photon.exposure_time_bottom))
    log("  Lifting Speed: {}".format(photon.bottom_lift_speed))
    log("  Lifting distance: {}".format(photon.bottom_lift_distance))
    log("Retract speed: {}".format(photon.retract_speed))
    log()
    log("=== META ===")
    log("Used material: {} g.".format(sl1.config["usedMaterial"]))
    log()
    log("=== CONVERSION ===")

    with tempfile.TemporaryDirectory() as tmpdirname:

        log("extracting layers... ", end="")

        sl1.extract_images(tmpdirname)

        log("DONE")

        layers = sorted(glob.glob(os.path.join(tmpdirname, "*.png")))

        def convert_layer(filepath):
            global counter

            with counter.get_lock():
                counter.value += 1
                log(f"converting layer {counter.value} / {sl1.n_layers}", end="\r")

            Image.open(filepath).rotate(180).save(filepath)
            return photon.create_layer(filepath)

        counter = multiprocessing.Value("i", 0)
        pool = multiprocessing.Pool(initargs=(counter,))
        try:
            photon.layers = pool.map(convert_layer, layers)
        except KeyboardInterrupt:
            log("Aborted.")

        log()

    photon.write(photon_path)
    log("Output file written to: {}".format(photon_path))