path: root/bin/pyggle

#!/usr/bin/env python3
# vim:tabstop=4 softtabstop=4 shiftwidth=4 textwidth=160 smarttab expandtab colorcolumn=160
#
# Copyright (C) 2021-2024 Birte Kristina Friesel
#
# SPDX-License-Identifier: BSD-2-Clause

import argparse
from datetime import datetime
import exifread
import json
import os
import PIL
from PIL import Image
from progress.bar import Bar
import shutil
import subprocess
import sys
import tempfile

geocoder = None
location_cache = dict()


def rotate_image(image, exif_tag):
    if "Image Orientation" not in exif_tag:
        return image

    orientation = exif_tag["Image Orientation"].values

    if 3 in orientation:
        image = image.transpose(Image.Transpose.ROTATE_180)
    if 6 in orientation:
        image = image.transpose(Image.Transpose.ROTATE_270)
    if 8 in orientation:
        image = image.transpose(Image.Transpose.ROTATE_90)

    return image


def rotate_preview(filename, exif_tag):
    if "Image Orientation" not in exif_tag:
        return

    orientation = exif_tag["Image Orientation"].values
    rotation = None

    if 3 in orientation:
        rotation = "-1"
    if 6 in orientation:
        rotation = "-9"
    if 8 in orientation:
        rotation = "-2"

    if not rotation:
        return

    subprocess.run(
        [
            "exiftran",
            "-i",
            rotation,
            filename,
        ],
        stdout=subprocess.DEVNULL,
        stderr=subprocess.DEVNULL,
    )


def format_f(value, precision=1):
    if value % 1 == 0:
        return f"{value:.0f}"
    return f"{value:.{precision}f}"


class ProgressBar(Bar):
    suffix = "%(percent).0f%% [%(elapsed_td)s/%(eta_td)s]"


class GPSData:
    def __init__(self, lat, lon, location):
        self.lat = lat
        self.lon = lon
        self.location = location


class ImageHTML:
    def __init__(self):
        self.gps = None
        self.datetime = None
        self.file_link = None
        self.make = None
        self.focus = None
        self.caption = None

        self.ev = None
        self.exposure = None
        self.exposure_mode = None
        self.exposure_program = None
        self.f_num = None
        self.flash = None
        self.focal_length = None
        self.focus_distance = None
        self.focus_mode = None
        self.iso = None
        self.lv = None
        self.software = None
        self.subject_distance = None

    def set_caption(self, caption):
        self.caption = caption

    def set_datetime(self, dt):
        self.datetime = dt.strftime("""<span class="datetime">%d.%m.%Y %H:%M</span>""")

    def set_ev(self, ev):
        self.ev = f"""<span class="ev">{ev} EV</span>"""

    def set_exposure_mode(self, exposure_mode):
        self.exposure_mode = f"""<span class="exposure-mode">{exposure_mode}</span>"""

    def set_exposure_program(self, exposure_program):
        self.exposure_program = (
            f"""<span class="exposure-program">{exposure_program}</span>"""
        )

    def set_flash(self, flash):
        self.flash = f"""<span class="flash">{flash}</span>"""

    def set_focus_distance(self, lower, upper):
        if upper == "inf":
            upper = "∞"
        self.focus_distance = (
            f"""<span class="focus-distance">{lower} – {upper}</span>"""
        )

    def set_focus_mode(self, mode):
        self.focus_mode = f"""<span class="focus-mode">{mode}</span>"""

    def set_focus(
        self, f_num, exposure, focal_length, focal_length35, crop_factor, iso
    ):
        entries = list()
        if f_num is not None:
            self.f_num = f"""<span class="fnumber">f/{format_f(f_num)}</span>"""
            entries.append(self.f_num)

        if exposure is not None:
            if exposure >= 1:
                self.exposure = (
                    f"""<span class="exposure">{format_f(exposure)}s</span>"""
                )
            elif exposure >= 1e-3:
                self.exposure = (
                    f"""<span class="exposure">{format_f(exposure * 1e3)}ms</span>"""
                )
            else:
                self.exposure = (
                    f"""<span class="exposure">{format_f(exposure * 1e6)}µs</span>"""
                )
            entries.append(self.exposure)

        if focal_length is not None:
            entry = f"{format_f(focal_length)}mm"
            if focal_length35 is not None and focal_length35 != focal_length:
                entry += f" (≙ {format_f(focal_length35)}mm)"
            elif crop_factor is not None:
                entry += f" (≙ {format_f(focal_length * crop_factor, 0)}mm)"
            self.focal_length = f"""<span class="focal">{entry}</span>"""
            entries.append(self.focal_length)

        if iso is not None:
            self.iso_iso = f"""<span class="iso">ISO{iso}</span>"""
            self.iso = f"""<span class="iso">{iso}</span>"""
            entries.append(self.iso_iso)

        self.focus = " ".join(entries)

    def set_gps(self, gps):
        self.gps = f"""<span class="gps"><a href="https://www.openstreetmap.org/?mlat={gps.lat}&mlon={gps.lon}#map=13/{gps.lat}/{gps.lon}">{gps.location}</a></span>"""

    def set_lv(self, lv):
        self.lv = f"""<span class="lv">{lv} LV</span>"""

    def set_makemodel(self, make, model):
        self.make = f"""<span class="makemodel">{make} {model}</span>"""

    def set_software(self, software):
        self.software = f"""<span class="software">{software}</span>"""

    def set_subject_distance(self, distance):
        if distance < 10000:
            self.subject_distance = (
                f"""<span class="subject-distance">{distance} m</span>"""
            )
        else:
            self.subject_distance = f"""<span class="subject-distance">∞</span>"""

    def to_thumbnail_html(
        self, index, filename, thumbname, with_detail_page=False, jpegfile=None
    ):

        if with_detail_page:
            self.focus = f"""<a href="{filename}.html">{self.focus}</a>"""

        if self.caption:
            linktext = self.caption
        else:
            linktext = filename

        exif_lines = (self.datetime, self.gps, self.make, self.focus)
        exif_html = """ <span class="sep">•</span> """.join(filter(bool, exif_lines))

        buf = """<div class="image-container">\n"""
        buf += f"""<a href="{jpegfile or filename}" class="glightbox" data-gallery="gallery1" data-description=".gdesc{index}">"""
        buf += f"""<img src="{thumbname}" alt="{linktext}" />"""
        buf += "</a>"
        buf += "</div>"
        buf += f"""<div class="glightbox-desc gdesc{index}">\n"""
        buf += (
            f"""<p><span class="download"><a href="{filename}">{linktext}</a></span>"""
        )
        buf += f"""<span class="sep">•</span>{exif_html}</p>\n"""
        buf += "</div>\n"

        return buf

    def to_detail_html(self, filename):
        buf = """<div class="image-page">"""
        buf += f"""<a href="{filename}"><img src="{filename}"></a>"""
        buf += "</div>\n"
        buf += """<div class="image-details">\n"""
        if self.caption:
            buf += f"<p>{self.caption}</p>\n"
        buf += "<p><table>\n"

        if self.datetime:
            buf += f"<tr><th>Zeit</th><td>{self.datetime}</td></tr>\n"
        if self.gps:
            buf += f"<tr><th>Ort</th><td>{self.gps}</td></tr>\n"
        if self.make:
            buf += f"<tr><th>Kamera</th><td>{self.make}</td></tr>\n"
        buf += "<tr><th></th><td>&nbsp;</td></tr>\n"
        if self.f_num:
            buf += f"<tr><th>Blende</th><td>{self.f_num}</td></tr>\n"
        if self.exposure:
            buf += f"<tr><th>Belichtung</th><td>{self.exposure}</td></tr>\n"
        if self.iso:
            buf += f"<tr><th>ISO</th><td>{self.iso}</td></tr>\n"
        if self.focal_length:
            buf += f"<tr><th>Brennweite</th><td>{self.focal_length}</td></tr>\n"
        if self.ev or self.lv:
            if self.ev and self.lv:
                text = f"{self.lv} / {self.ev}"
            elif self.ev:
                text = self.ev
            elif self.lv:
                text = self.lv
            buf += f"<tr><th>Helligkeit</th><td>{text}</td></tr>\n"
        buf += "<tr><th></th><td>&nbsp;</td></tr>\n"
        if self.exposure_program:
            buf += f"<tr><th>Modus</th><td>{self.exposure_program}</td></tr>\n"
        if self.exposure_mode:
            buf += f"<tr><th>Belichtung</th><td>{self.exposure_mode}</td></tr>\n"
        if self.focus_mode:
            buf += f"<tr><th>Fokus</th><td>{self.focus_mode}</td></tr>\n"
        if self.subject_distance:
            buf += f"<tr><th>Entfernung</th><td>{self.subject_distance}</td></tr>\n"
        if self.focus_distance:
            buf += f"<tr><th>Schärfebereich</th><td>{self.focus_distance}</td></tr>\n"
        if self.flash:
            buf += f"<tr><th>Blitz</th><td>{self.flash}</td></tr>\n"
        if self.software:
            buf += f"<tr><th>Software</th><td>{self.software}</td></tr>\n"
        buf += "</table></p></div>\n"

        return buf


class Thumbnail:
    def __init__(
        self,
        filename,
        im,
        size=250,
        with_gps=False,
        group_key_template=None,
        file_key_template=None,
        have_thumbnail=dict(),
    ):
        self.filename = filename
        self.jpegname = None
        self.size = size
        self.exif_dt = None
        self.gps = None
        self.group_key = None
        self.file_key = None

        with open(filename, "rb") as f:
            try:
                self.exif_tag = exifread.process_file(f)
            except Exception as e:
                print(f"Cannot read EXIF data fom '{filename}': {e}", file=sys.stderr)
                self.exif_tag = dict()

        self.exiftool = dict()
        try:
            exiftool = subprocess.run(
                ["exiftool", "-json", "-escapeHTML", "-groupNames", filename],
                stdout=subprocess.PIPE,
                text=True,
            )
            if exiftool.returncode == 0:
                self.exiftool = json.loads(exiftool.stdout)[0]
        except FileNotFoundError:
            pass

        have_subthumb = False

        if "/" in filename:
            sub_dirname, sub_filename = filename.rsplit("/", 1)
            sub_thumbname = sub_filename
            if not sub_thumbname.lower().endswith((".jpeg", ".jpg")):
                sub_thumbname += ".jpg"
            if os.path.exists(f"{sub_dirname}/.thumbnails/{sub_thumbname}"):
                self.thumbname = f"{sub_dirname}/.thumbnails/{sub_thumbname}"
                have_subthumb = True
            if os.path.exists(f"{sub_dirname}/.thumbnails/{sub_filename}.p.jpg"):
                self.jpegname = f"{sub_dirname}/.thumbnails/{sub_filename}"

        if not have_subthumb:
            thumb_filename = filename.replace("/", "-")
            self.thumbname = f".thumbnails/{thumb_filename}"
            if not self.thumbname.lower().endswith((".jpeg", ".jpg")):
                self.thumbname += ".jpg"

            if not have_thumbnail.pop(self.thumbname, False):
                if not filename.lower().endswith((".cr2", ".cr3", ".rw2")):
                    im = rotate_image(im, self.exif_tag)

                im.thumbnail((self.size * 4, self.size * 2))
                im = im.convert("RGB")
                im.save(self.thumbname, "JPEG")

                if filename.lower().endswith((".cr2", ".cr3", ".rw2")):
                    try:
                        jpegname = f".thumbnails/{thumb_filename}.p.jpg"
                        subprocess.run(
                            [
                                "exiftool",
                                "-quiet",
                                "-binary",
                                "-tagOut!",
                                jpegname,
                                "-PreviewImage",
                                filename,
                            ]
                        )
                        # JpgFromRaw tends to have higher resolution, so overwrite PreviewImage if it is present
                        subprocess.run(
                            [
                                "exiftool",
                                "-quiet",
                                "-binary",
                                "-tagOut!",
                                jpegname,
                                "-JpgFromRaw",
                                filename,
                            ]
                        )
                        self.jpegname = jpegname
                        rotate_preview(jpegname, self.exif_tag)
                        have_thumbnail.pop(self.jpegname, None)
                    except FileNotFoundError:
                        pass

        if args.with_detail_page and 0:
            self.average_color = im.resize((1, 1)).getpixel((0, 0))
            self.luminance = im.convert("L").getpixel((0, 0))

        self.html = ImageHTML()

        self._get_caption()
        self._get_datetime()
        self._get_focus()
        self._get_makemodel()
        self._get_details()

        if group_key_template == "decade" and self.exif_dt:
            year = self.exif_dt.strftime("%Y")[:3]
            self.group_key = f"{year}0 – {year}9"
        elif group_key_template == "year" and self.exif_dt:
            self.group_key = self.exif_dt.strftime("%Y")
        elif group_key_template == "year-month" and self.exif_dt:
            self.group_key = self.exif_dt.strftime("%B %Y")
        elif group_key_template == "day" and self.exif_dt:
            self.group_key = self.exif_dt.strftime("%a, %d. %B %Y")

        if file_key_template == "decade" and self.exif_dt:
            year = self.exif_dt.strftime("%Y")[:3]
            self.file_key = f"{year}x"
        elif file_key_template == "year" and self.exif_dt:
            self.file_key = self.exif_dt.strftime("%Y")
        elif file_key_template == "year-month" and self.exif_dt:
            self.file_key = self.exif_dt.strftime("%Y-%m")

        if with_gps:
            self._get_gps()

    def _get_caption(self):
        try:
            with open(f".captions/{filename}.txt", "r") as f:
                self.html.set_caption(f.read())
        except FileNotFoundError:
            pass

    def _get_datetime(self):
        dt = None

        try:
            dt = datetime.strptime(
                self.exif_tag["EXIF DateTimeOriginal"].values, "%Y:%m:%d %H:%M:%S"
            )
        except (KeyError, ValueError):
            try:
                dt = datetime.strptime(
                    self.exif_tag["Image DateTimeOriginal"].values, "%Y:%m:%d %H:%M:%S"
                )
            except (KeyError, ValueError):
                try:
                    dt = datetime.strptime(
                        self.exif_tag["Image DateTime"].values, "%Y:%m:%d %H:%M:%S"
                    )
                except (KeyError, ValueError):
                    dt = datetime.fromtimestamp(os.path.getmtime(self.filename))

        if dt:
            self.exif_dt = dt
            self.html.set_datetime(dt)

    def _get_details(self):
        try:
            self.html.set_flash(self.exif_tag["EXIF Flash"])
        except KeyError:
            pass

        try:
            self.html.set_subject_distance(
                float(self.exif_tag["EXIF SubjectDistance"].values[0])
            )
        except (KeyError, ZeroDivisionError):
            pass

        try:
            self.html.set_focus_distance(
                self.exiftool["MakerNotes:FocusDistanceLower"],
                self.exiftool["MakerNotes:FocusDistanceUpper"],
            )
        except KeyError:
            pass

        try:
            self.html.set_software(self.exif_tag["Image Software"])
        except KeyError:
            pass

        try:
            self.html.set_focus_mode(self.exiftool["MakerNotes:FocusMode"])
        except KeyError:
            pass

        try:
            self.html.set_focus_mode(self.exiftool["MakerNotes:FocusMode"])
        except KeyError:
            pass

        try:
            self.html.set_ev(self.exiftool["MakerNotes:MeasuredEV"])
        except KeyError:
            pass

        try:
            self.html.set_lv(self.exiftool["Composite:LightValue"])
        except KeyError:
            pass

    def _get_focus(self):
        entries = list()

        f_num = None
        exposure = None
        focal_length = None
        focal_length35 = None
        iso = None

        try:
            f_num = float(self.exif_tag["EXIF FNumber"].values[0])
        except (KeyError, ZeroDivisionError):
            pass

        try:
            exposure = float(self.exif_tag["EXIF ExposureTime"].values[0])
        except (KeyError, ZeroDivisionError):
            pass

        try:
            focal_length = float(self.exif_tag["EXIF FocalLength"].values[0])
            focal_length35 = float(
                self.exif_tag["EXIF FocalLengthIn35mmFilm"].values[0]
            )
        except (KeyError, ZeroDivisionError):
            pass

        try:
            iso = self.exif_tag["EXIF ISOSpeedRatings"].values[0]
        except KeyError:
            pass

        crop_factor = self.exiftool.get("Composite:ScaleFactor35efl", None)

        self.html.set_focus(
            f_num, exposure, focal_length, focal_length35, crop_factor, iso
        )

        try:
            self.html.set_exposure_mode(self.exif_tag["EXIF ExposureMode"])
        except KeyError:
            pass

        try:
            self.html.set_exposure_program(self.exif_tag["EXIF ExposureProgram"])
        except KeyError:
            pass

    def _get_gps(self):
        try:
            lat = self.exif_tag["GPS GPSLatitude"]
            latref = self.exif_tag["GPS GPSLatitudeRef"].values[0]
            lon = self.exif_tag["GPS GPSLongitude"]
            lonref = self.exif_tag["GPS GPSLongitudeRef"].values[0]
        except (KeyError, IndexError):
            return

        try:
            lat = (
                float(lat.values[0])
                + float(lat.values[1]) / 60
                + float(lat.values[2]) / 3600
            )
            lon = (
                float(lon.values[0])
                + float(lon.values[1]) / 60
                + float(lon.values[2]) / 3600
            )
        except (IndexError, ZeroDivisionError):
            return

        if abs(lat) < 0.01 and abs(lon) < 0.01:
            return

        if latref == "S":
            lat = -lat

        if lonref == "W":
            lon = -lon

        global location_cache
        global geocoder

        latlon = f"{lat:.3f}/{lon:.3f}"

        if latlon in location_cache:
            self.gps = GPSData(lat, lon, location_cache[latlon])
            self.html.set_gps(self.gps)
            return

        if geocoder is None:
            from geopy.geocoders import Nominatim

            geocoder = Nominatim(user_agent="pyggle +https://github.com/derf/pyggle")

        # zoom level: 12/13 -> city, 14/15 -> district, 16/17 -> street, 18 -> house no
        try:
            res = geocoder.reverse((lat, lon), zoom=args.nominatim_zoom)
            location = res.address.split(",")[0]
            location_cache[latlon] = location
        except TypeError as e:
            location = latlon

        self.gps = GPSData(lat, lon, location)
        self.html.set_gps(self.gps)

    def _get_makemodel(self):
        try:
            make = self.exif_tag["Image Make"].values
            model = self.exif_tag["Image Model"].values
        except KeyError:
            return

        if model.startswith(make):
            model = model[len(make) :]
            if model[0] == " ":
                model = model[1:]

        try:
            lens = self.exif_tag["EXIF LensModel"]
            if lens:
                model += f" + {lens}"
        except KeyError:
            # Unknown or built-in lens
            pass

        self.html.set_makemodel(make, model)

    def to_html(self, index, with_detail_page=False):
        return self.html.to_thumbnail_html(
            index,
            self.filename,
            self.thumbname,
            with_detail_page,
            jpegfile=self.jpegname,
        )

    def to_detail_html(self, html_prefix, html_postfix):
        with open(f"{self.filename}.html", "w") as f:
            f.write(html_prefix.replace("<!-- $title -->", self.filename))
            f.write(self.html.to_detail_html(self.filename))
            f.write(html_postfix)


def copy_files(base_dir):
    for directory in ".data/css .data/js".split():
        os.makedirs(directory, exist_ok=True)

    boxwidth = f"{args.size * args.spacing}px"
    boxheight = f"{args.size * args.spacing}px"
    limgwidth = f"{args.size}px"
    limgheight = f"{args.size}px"
    mimgwidth = f"{args.size/2}px"
    mimgheight = f"{args.size/2}px"
    simgwidth = f"{args.size/3}px"
    simgheight = f"{args.size/3}px"

    css_files = ["glightbox.min.css", "light.css", "dark.css"]
    js_files = ["glightbox.min.js"]

    for css_file in css_files:
        shutil.copy(f"{base_dir}/css/{css_file}", f".data/css/{css_file}")

    for js_file in js_files:
        shutil.copy(f"{base_dir}/js/{js_file}", f".data/js/{js_file}")

    with open(f"{base_dir}/css/main.css", "r") as f:
        main_css = f.read()

    main_css = main_css.replace("/* $boxwidth */", boxwidth)
    main_css = main_css.replace("/* $boxheight */", boxheight)
    main_css = main_css.replace("/* $limgwidth */", limgwidth)
    main_css = main_css.replace("/* $limgheight */", limgheight)
    main_css = main_css.replace("/* $mimgwidth */", mimgwidth)
    main_css = main_css.replace("/* $mimgheight */", mimgheight)
    main_css = main_css.replace("/* $simgwidth */", simgwidth)
    main_css = main_css.replace("/* $simgheight */", simgheight)

    with open(".data/css/main.css", "w") as f:
        f.write(main_css)


def write_gallery(
    file_buf, filename, thumbnails, group=None, files=list(), this_file=None
):

    if files:
        nav_buf = '<div class="nav">'
        for link_target in files:
            link_class = ""
            if link_target == this_file:
                link_class = "this-file"
            nav_buf += (
                f'<a class="{link_class}" href="{link_target}.html">{link_target}</a>\n'
            )
        nav_buf += "</div>"
        file_buf += nav_buf

    prev_heading = None
    for i, thumbnail in enumerate(thumbnails):
        if group and thumbnail.group_key != prev_heading:
            file_buf += f"<h1>{thumbnail.group_key}</h1>"
            prev_heading = thumbnail.group_key
        file_buf += thumbnail.to_html(i, args.with_detail_page)

    if files:
        file_buf += nav_buf

    with open(f"{base_dir}/share/html_end", "r") as f:
        file_buf += f.read()

    with open(filename, "w") as f:
        f.write(file_buf)


if __name__ == "__main__":

    parser = argparse.ArgumentParser(
        formatter_class=argparse.RawDescriptionHelpFormatter, description=__doc__
    )
    parser.add_argument(
        "--caption-to-exif",
        action="store_true",
        help="Store captions as EXIF comments (IN-PLACE EDIT)",
    )
    parser.add_argument(
        "--cdn", metavar="URL", type=str, help="Load JS and CSS from URL/{css,js}"
    )
    parser.add_argument(
        "--edit-in-place",
        action="store_true",
        help="Enable options that alter the image files passed on the command line. The original can NOT be restored.",
    )
    parser.add_argument(
        "--exif-copyright",
        metavar="STRING",
        type=str,
        help="Set EXIF copyright (IN-PLACE EDIT)",
    )
    parser.add_argument(
        "--group",
        metavar="SEP",
        choices=["none", "day", "year-month", "year", "decade"],
        default="none",
        help="Add captions to separate images by SEP",
    )
    parser.add_argument(
        "--group-files",
        metavar="SEP",
        choices=["none", "year-month", "year", "decade"],
        default="none",
        help="Generate one gallery file per SEP group",
    )
    parser.add_argument(
        "--html-include",
        metavar="FILE",
        type=str,
        help="file with HTML to include before thumbnail list",
    )
    parser.add_argument(
        "--nominatim-zoom",
        type=int,
        default=16,
        help="Zoom Level for reverse geocoding",
    )
    parser.add_argument(
        "--resize",
        metavar="N",
        type=int,
        help="resize large images to no more than NxN pixels (IN-PLACE EDIT)",
    )
    parser.add_argument(
        "--reverse", action="store_true", help="Sort from most to least recent"
    )
    parser.add_argument(
        "--scrub-metadata",
        action="store_true",
        help="Scrub EXIF metadata from images (IN-PLACE EDIT)",
    )
    parser.add_argument("--size", type=int, default=250, help="Thumbnail height [px]")
    parser.add_argument(
        "--sort",
        metavar="MODE",
        choices=["none", "time"],
        default="none",
        help="Sort images",
    )
    parser.add_argument(
        "--spacing", type=float, default=1.02, help="Thumbnail spacing ratio"
    )
    parser.add_argument("--title", type=str, help="HTML title", default="")
    parser.add_argument("--with-detail-page", action="store_true")
    parser.add_argument("--with-nominatim", action="store_true")
    parser.add_argument("images", type=str, nargs="+")

    args = parser.parse_args()

    if (
        args.caption_to_exif
        or args.exif_copyright
        or args.resize
        or args.scrub_metadata
    ) and not args.edit_in_place:
        print(
            "in-place edit option used without --edit-in-place, aborting",
            file=sys.stderr,
        )
        sys.exit(1)

    base_dir = "/".join(os.path.realpath(sys.argv[0]).split("/")[:-2])

    os.makedirs(".thumbnails", exist_ok=True)

    rm_thumbnail = dict(
        map(lambda k: (".thumbnails/" + k, 1), os.listdir(".thumbnails"))
    )

    if not args.cdn:
        copy_files(f"{base_dir}/share")

    with open(f"{base_dir}/share/html_start", "r") as f:
        html_buf = f.read().replace("<!-- $title -->", args.title)

    if args.cdn:
        html_buf = html_buf.replace('href=".data/css/', f'href="{args.cdn}/css/')
        html_buf = html_buf.replace('src=".data/js/', f'src="{args.cdn}/js/')
        html_buf = html_buf.replace("path = '.data/css/'", f"path = '{args.cdn}/css/'")

    if args.html_include:
        with open(args.html_include, "r") as f:
            html_buf += f.read()

    filenames = args.images
    thumbnails = list()

    for i, filename in enumerate(ProgressBar(max=len(filenames)).iter(filenames)):
        try:
            im = Image.open(filename)
        except PIL.UnidentifiedImageError:
            try:
                im = Image.open(f".thumbnail.for.{filename}")
            except FileNotFoundError:
                im = None
            except PIL.UnidentifiedImageError:
                # perhaps raise a warning?
                im = None

        if not im:
            try:
                _, jpegname = tempfile.mkstemp(suffix="jpg")
                subprocess.run(
                    [
                        "exiftool",
                        "-quiet",
                        "-binary",
                        "-tagOut!",
                        jpegname,
                        "-PreviewImage",
                        filename,
                    ]
                )
                # JpgFromRaw tends to have higher resolution, so overwrite PreviewImage if it is present
                subprocess.run(
                    [
                        "exiftool",
                        "-quiet",
                        "-binary",
                        "-tagOut!",
                        jpegname,
                        "-JpgFromRaw",
                        filename,
                    ]
                )

                im = Image.open(jpegname)
                os.remove(jpegname)
            except FileNotFoundError:
                im = None
            except PIL.UnidentifiedImageError:
                # perhaps raise a warning?
                os.remove(jpegname)
                im = None

        if not im:
            continue

        try:
            im_copy = im.copy()
        except Exception as e:
            print(f"Cannot load image '{filename}': {e}", file=sys.stderr)
            continue

        thumbnail = Thumbnail(
            filename,
            im_copy,
            size=args.size,
            with_gps=args.with_nominatim,
            group_key_template=args.group,
            file_key_template=args.group_files,
            have_thumbnail=rm_thumbnail,
        )
        thumbnails.append(thumbnail)

        if (
            args.edit_in_place
            and args.resize
            and (im.size[0] > args.resize or im.size[1] > args.resize)
        ):
            subprocess.run(
                [
                    "mogrify",
                    "-resize",
                    f"{args.resize}x{args.resize}",
                    filename,
                ]
            )

        exiftool_args = list()

        if args.caption_to_exif and thumbnail.html.caption:
            exiftool_args.append(f"-File:Comment={thumbnail.html.caption}")

        if args.exif_copyright:
            exiftool_args.append(f"-EXIF:Copyright={args.exif_copyright}")

        if args.scrub_metadata:
            exiftool_args.extend(
                [
                    "-EXIF:SerialNumber=",
                    "-EXIF:LensSerialNumber=",
                    "-Makernotes:all=",
                    "-geotag=",
                    "-ThumbnailImage=",
                ]
            )

        if args.edit_in_place and exiftool_args:
            subprocess.run(
                [
                    "exiftool",
                    "-q",
                    "-overwrite_original",
                ]
                + exiftool_args
                + [filename]
            )

    for rm_file in rm_thumbnail.keys():
        os.remove(rm_file)

    if args.sort == "time":
        thumbnails = list(
            sorted(thumbnails, key=lambda t: t.exif_dt, reverse=args.reverse)
        )

    if args.with_detail_page:
        for thumbnail in thumbnails:
            with open(f"{base_dir}/share/html_detail_start", "r") as f:
                detail_html_start = f.read()
            with open(f"{base_dir}/share/html_detail_end", "r") as f:
                detail_html_end = f.read()
            for thumbnail in thumbnails:
                thumbnail.to_detail_html(detail_html_start, detail_html_end)

    write_gallery(html_buf, "index.html", thumbnails, group=args.group)

    if args.group_files != "none":
        thumbnail_keys = list(sorted(set(map(lambda t: t.file_key, thumbnails))))
        for thumbnail_key in thumbnail_keys:
            write_gallery(
                html_buf,
                f"{thumbnail_key}.html",
                list(filter(lambda t: t.file_key == thumbnail_key, thumbnails)),
                group=args.group,
                files=thumbnail_keys,
                this_file=thumbnail_key,
            )