Magazine.py

import os
import pathlib
import xml.etree.ElementTree as ET
from dataclasses import asdict, dataclass
from typing import Any, Dict, List, TypedDict

from PIL import Image
from PIL.Image import Image as PilImage

import datasets as ds
from datasets.utils.logging import get_logger

logger = get_logger(__name__)

JsonDict = Dict[str, Any]

_DESCRIPTION = "A large-scale magazine layout dataset with fine-grained layout annotations and keyword labeling"

_CITATION = """\
@article{zheng2019content,
  title={Content-aware generative modeling of graphic design layouts},
  author={Zheng, Xinru and Qiao, Xiaotian and Cao, Ying and Lau, Rynson WH},
  journal={ACM Transactions on Graphics (TOG)},
  volume={38},
  number={4},
  pages={1--15},
  year={2019},
  publisher={ACM New York, NY, USA}
}
"""

_HOMEPAGE = "https://xtqiao.com/projects/content_aware_layout/"

_LICENSE = """\
Copyright (c) 2019, Xiaotian Qiao
All rights reserved.

This code is copyrighted by the authors and is for non-commercial research
purposes only.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""


class URLs(TypedDict):
    image: str
    layout: str


_URLS: URLs = {
    # The author of this loading script has uploaded the image and layout annotation files to the HuggingFace's private repository to facilitate testing.
    # If you are using this loading script, please download the annotations from the appropriate channels, such as the OneDrive link provided by the Magazine dataset's author.
    # (To the author of Magazine dataset, if there are any issues regarding this matter, please contact us. We will address it promptly.)
    "image": "https://huggingface.co/datasets/shunk031/Magazine-private/resolve/main/MagImage.zip",
    "layout": "https://huggingface.co/datasets/shunk031/Magazine-private/resolve/main/MagLayout.zip",
}


@dataclass
class LayoutSize(object):
    width: int
    height: int


@dataclass
class LayoutElement(object):
    label: str
    polygon_x: List[int]
    polygon_y: List[int]

    @classmethod
    def parse_polygon(cls, polygon_str: str) -> List[float]:
        return list(map(lambda x: float(x), polygon_str.split()))

    @classmethod
    def parse_polygons(cls, json_dict: JsonDict) -> JsonDict:
        json_dict["polygon_x"] = cls.parse_polygon(json_dict["polygon_x"])
        json_dict["polygon_y"] = cls.parse_polygon(json_dict["polygon_y"])
        return json_dict

    @classmethod
    def from_dict(cls, json_dict: JsonDict) -> "LayoutElement":
        json_dict = cls.parse_polygons(json_dict)
        return cls(**json_dict)


def get_filename(annotation: ET.Element) -> str:
    filename = annotation.find("filename")
    assert filename is not None
    return filename.text


def get_layout_category(annotation: ET.Element) -> str:
    elem = annotation.find("category")
    assert elem is not None
    return elem.text


def get_layout_size(annotation: ET.Element) -> LayoutSize:
    size = annotation.find("size")
    assert size is not None

    h_elem = size.find("height")
    assert h_elem is not None

    w_elem = size.find("width")
    assert w_elem is not None

    return LayoutSize(width=int(w_elem.text), height=int(h_elem.text))


def get_layout_elements(annotation: ET.Element) -> List[LayoutElement]:
    layouts = annotation.find("layout")
    assert layouts is not None

    elements = layouts.findall("element")
    layout_elements = [LayoutElement.from_dict(element.attrib) for element in elements]
    return layout_elements


def get_keywords(annotation: ET.Element) -> List[str]:
    texts = annotation.find("text")
    assert texts is not None
    keywords = texts.findall("keyword")
    return [keyword.text for keyword in keywords]


def load_image(file_path: pathlib.Path) -> PilImage:
    return Image.open(file_path)


def load_images(
    image_base_dir: pathlib.Path, category: str, filename: str
) -> List[PilImage]:
    image_files = (image_base_dir / category).glob(f"{filename}_*")
    return [load_image(file_path) for file_path in image_files]


@dataclass
class LayoutAnnotation(object):
    filename: str
    category: str
    size: LayoutSize
    elements: List[LayoutElement]
    keywords: List[str]
    images: List[PilImage]

    @classmethod
    def get_annotation_from_xml(cls, xml_file: pathlib.Path) -> ET.Element:
        tree = ET.parse(xml_file)
        return tree.getroot()

    @classmethod
    def from_xml(
        cls, xml_file: pathlib.Path, image_base_dir: pathlib.Path
    ) -> "LayoutAnnotation":
        annotation = cls.get_annotation_from_xml(xml_file)
        filename = get_filename(
            annotation=annotation,
        )
        category = get_layout_category(
            annotation=annotation,
        )
        layout_size = get_layout_size(
            annotation=annotation,
        )
        layout_elements = get_layout_elements(
            annotation=annotation,
        )
        keywords = get_keywords(
            annotation=annotation,
        )
        images = load_images(
            image_base_dir=image_base_dir,
            category=category,
            filename=filename,
        )
        return cls(
            filename=filename,
            category=category,
            size=layout_size,
            elements=layout_elements,
            keywords=keywords,
            images=images,
        )


class MagazineDataset(ds.GeneratorBasedBuilder):
    VERSION = ds.Version("1.0.0")
    BUILDER_CONFIGS = [ds.BuilderConfig(version=VERSION, description=_DESCRIPTION)]

    @property
    def _manual_download_instructions(self) -> str:
        return (
            "To use Magazine dataset, you need to download the annotations "
            "from the OneDrive in the official webpage "
            "(https://portland-my.sharepoint.com/:f:/g/personal/xqiao6-c_my_cityu_edu_hk/EhmRh5SFoQ9Hjl_aRjCOltkBKFYefiSagR6QLJ7pWvs3Ww?e=y8HO5Q)."
        )

    def _info(self) -> ds.DatasetInfo:
        features = ds.Features(
            {
                "filename": ds.Value("string"),
                "category": ds.ClassLabel(
                    num_classes=6,
                    names=["fashion", "food", "news", "science", "travel", "wedding"],
                ),
                "size": {
                    "width": ds.Value("int64"),
                    "height": ds.Value("int64"),
                },
                "elements": ds.Sequence(
                    {
                        "label": ds.ClassLabel(
                            num_classes=5,
                            names=[
                                "text",
                                "image",
                                "headline",
                                "text-over-image",
                                "headline-over-image",
                            ],
                        ),
                        "polygon_x": ds.Sequence(ds.Value("float32")),
                        "polygon_y": ds.Sequence(ds.Value("float32")),
                    }
                ),
                "keywords": ds.Sequence(ds.Value("string")),
                "images": ds.Sequence(ds.Image()),
            }
        )
        return ds.DatasetInfo(
            description=_DESCRIPTION,
            citation=_CITATION,
            homepage=_HOMEPAGE,
            license=_LICENSE,
            features=features,
        )

    def _download_from_hf(self, dl_manager: ds.DownloadManager) -> URLs:
        return dl_manager.download_and_extract(_URLS)

    def _download_from_local(self, dl_manager: ds.DownloadManager) -> URLs:
        assert dl_manager.manual_dir is not None, dl_manager.manual_dir
        dir_path = os.path.expanduser(dl_manager.manual_dir)

        image_zip_path = os.path.join(dir_path, "MagImage.zip")
        layout_zip_path = os.path.join(dir_path, "MagLayout.zip")

        if (
            not os.path.exists(dir_path)
            or not os.path.exists(image_zip_path)
            or not os.path.exists(layout_zip_path)
        ):
            raise FileNotFoundError(
                "Make sure you have downloaded and placed the `MagImage.zip` and `MagLayout.zip` correctly. "
                'Furthermore, you should check that a manual dir via `datasets.load_dataset("shunk031/Magazine", data_dir=...)` '
                "that includes zip files from the downloaded files. "
                f"Manual downloaded instructions: {self._manual_download_instructions}"
            )
        return dl_manager.extract(
            path_or_paths={
                "image": image_zip_path,
                "layout": layout_zip_path,
            }
        )

    def _split_generators(self, dl_manager: ds.DownloadManager):
        file_paths = (
            self._download_from_hf(dl_manager)
            if dl_manager.download_config.token
            else self._download_from_local(dl_manager)
        )
        layout_xml_dir = (
            pathlib.Path(file_paths["layout"]) / "layoutdata" / "annotations"
        )
        image_base_dir = pathlib.Path(file_paths["image"]) / "images"

        return [
            ds.SplitGenerator(
                name=ds.Split.TRAIN,
                gen_kwargs={
                    "layout_xml_dir": layout_xml_dir,
                    "image_base_dir": image_base_dir,
                },
            )
        ]

    def _generate_examples(
        self, layout_xml_dir: pathlib.Path, image_base_dir: pathlib.Path
    ):
        xml_files = [f for f in layout_xml_dir.iterdir() if f.suffix == ".xml"]
        for i, xml_file in enumerate(xml_files):
            layout_annotation = LayoutAnnotation.from_xml(
                xml_file=xml_file,
                image_base_dir=image_base_dir,
            )
            yield i, asdict(layout_annotation)