|
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 = { |
|
|
|
|
|
|
|
"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) |
|
|
