|
|
import json |
|
|
import os |
|
|
import pathlib |
|
|
from dataclasses import asdict, dataclass |
|
|
from typing import Any, Dict, List, Optional, Tuple |
|
|
|
|
|
import datasets as ds |
|
|
import pandas as pd |
|
|
from datasets.utils.logging import get_logger |
|
|
from PIL import Image |
|
|
from PIL.Image import Image as PilImage |
|
|
|
|
|
logger = get_logger(__name__) |
|
|
|
|
|
JsonDict = Dict[str, Any] |
|
|
|
|
|
|
|
|
_DESCRIPTION = """\ |
|
|
PosterErase is a new dataset, which contains 60K high-resolution posters with texts and is more challenging for the text erasing task. |
|
|
""" |
|
|
|
|
|
_CITATION = """ |
|
|
@inproceedings{jiang2022self, |
|
|
title={Self-supervised text erasing with controllable image synthesis}, |
|
|
author={Jiang, Gangwei and Wang, Shiyao and Ge, Tiezheng and Jiang, Yuning and Wei, Ying and Lian, Defu}, |
|
|
booktitle={Proceedings of the 30th ACM International Conference on Multimedia}, |
|
|
pages={1973--1983}, |
|
|
year={2022} |
|
|
} |
|
|
""" |
|
|
|
|
|
_HOMEPAGE = "https://github.com/alimama-creative/Self-supervised-Text-Erasing" |
|
|
|
|
|
_LICENSE = """\ |
|
|
The dataset is distributed under the CC BY-SA 4.0 license. |
|
|
""" |
|
|
|
|
|
_URL_BASE = ( |
|
|
"https://huggingface.co/datasets/shunk031/PosterErase-private/resolve/main/{}" |
|
|
) |
|
|
_ZIP_FILES = [f"erase_{i}.zip" for i in range(1, 7)] |
|
|
_URLS = [_URL_BASE.format(zip_file) for zip_file in _ZIP_FILES] |
|
|
|
|
|
|
|
|
def load_image(file_path: pathlib.Path) -> PilImage: |
|
|
return Image.open(file_path) |
|
|
|
|
|
|
|
|
@dataclass |
|
|
class ColorData(object): |
|
|
c1: Optional[int] |
|
|
c2: Optional[int] |
|
|
c3: Optional[int] |
|
|
|
|
|
@classmethod |
|
|
def from_string(cls, s: str) -> "ColorData": |
|
|
assert isinstance(s, str) |
|
|
cs = s.split(",") |
|
|
if len(cs) == 3: |
|
|
return ColorData(*list(map(lambda s: int(s), cs))) |
|
|
elif len(cs) == 1: |
|
|
return ColorData(*[None] * 3) |
|
|
else: |
|
|
raise ValueError(f"Invalid value: {cs}") |
|
|
|
|
|
|
|
|
@dataclass |
|
|
class TextData(object): |
|
|
x: int |
|
|
y: int |
|
|
cs: List[ColorData] |
|
|
|
|
|
@classmethod |
|
|
def from_text_tuple(cls, text_tuple: Tuple[int, int, List[str]]) -> "TextData": |
|
|
x, y, cs = text_tuple |
|
|
assert isinstance(x, int) and isinstance(y, int) |
|
|
return cls(x=x, y=y, cs=[ColorData.from_string(c) for c in cs]) |
|
|
|
|
|
|
|
|
@dataclass |
|
|
class ObjectData(object): |
|
|
text: Optional[str] |
|
|
size: Optional[int] |
|
|
direction: Optional[int] |
|
|
|
|
|
@classmethod |
|
|
def from_string(cls, s: str) -> "ObjectData": |
|
|
assert isinstance(s, str) |
|
|
ss = s.split(",") |
|
|
if len(ss) == 3: |
|
|
return cls(text=ss[0], size=int(ss[1]), direction=int(ss[2])) |
|
|
elif len(ss) == 1: |
|
|
return cls(*[None] * 3) |
|
|
else: |
|
|
raise ValueError(f"Invalid value: {ss}") |
|
|
|
|
|
|
|
|
@dataclass |
|
|
class PlaceData(object): |
|
|
objs: List[ObjectData] |
|
|
texts: List[List[TextData]] |
|
|
|
|
|
@classmethod |
|
|
def from_dict(cls, json_dict: JsonDict) -> "PlaceData": |
|
|
objs = [ |
|
|
ObjectData.from_string(s) for s in json_dict["obj"].strip(";").split(";") |
|
|
] |
|
|
texts = [ |
|
|
[TextData.from_text_tuple(tt) for tt in tts] for tts in json_dict["text"] |
|
|
] |
|
|
return cls(objs=objs, texts=texts) |
|
|
|
|
|
|
|
|
@dataclass |
|
|
class MaskData(object): |
|
|
x1: Optional[int] |
|
|
x2: Optional[int] |
|
|
y1: Optional[int] |
|
|
y2: Optional[int] |
|
|
|
|
|
@classmethod |
|
|
def from_string(cls, s: str) -> "MaskData": |
|
|
assert isinstance(s, str) |
|
|
ss = s.split(",") |
|
|
|
|
|
if len(ss) == 4: |
|
|
return cls(*list(map(lambda s: int(s), ss))) |
|
|
elif len(ss) == 1: |
|
|
return cls(*[None] * 4) |
|
|
else: |
|
|
raise ValueError(f"Invalid value: {ss}") |
|
|
|
|
|
|
|
|
@dataclass |
|
|
class Annotation(object): |
|
|
masks: List[MaskData] |
|
|
place: Optional[PlaceData] |
|
|
|
|
|
@classmethod |
|
|
def from_dict(cls, json_dict: JsonDict) -> "Annotation": |
|
|
masks = [ |
|
|
MaskData.from_string(s) for s in json_dict["mask"].strip(";").split(";") |
|
|
] |
|
|
|
|
|
place_json = json_dict.get("place") |
|
|
place = ( |
|
|
PlaceData.from_dict(json_dict["place"]) if place_json is not None else None |
|
|
) |
|
|
return cls(masks=masks, place=place) |
|
|
|
|
|
|
|
|
@dataclass |
|
|
class EraseData(object): |
|
|
number: int |
|
|
path: str |
|
|
annotation: Annotation |
|
|
|
|
|
@classmethod |
|
|
def from_dict(cls, json_dict: JsonDict) -> "EraseData": |
|
|
number = int(json_dict["number"]) |
|
|
path = json_dict["path"] |
|
|
annotation = Annotation.from_dict(json_dict["json"]) |
|
|
return cls(number=number, path=path, annotation=annotation) |
|
|
|
|
|
|
|
|
def _load_annotation(file_path: pathlib.Path, columns: List[str]) -> pd.DataFrame: |
|
|
df = pd.read_csv(file_path, delimiter="\t", names=columns) |
|
|
df["json"] = df["json"].apply(json.loads) |
|
|
return df |
|
|
|
|
|
|
|
|
def _load_tng_annotation(file_path: pathlib.Path) -> pd.DataFrame: |
|
|
return _load_annotation(file_path=file_path, columns=["number", "path", "json"]) |
|
|
|
|
|
|
|
|
def _load_val_annotation(file_path: pathlib.Path) -> pd.DataFrame: |
|
|
return _load_annotation( |
|
|
file_path=file_path, columns=["number", "path", "json", "gt_path"] |
|
|
) |
|
|
|
|
|
|
|
|
def _load_tst_annotation(file_path: pathlib.Path) -> pd.DataFrame: |
|
|
return _load_val_annotation(file_path=file_path) |
|
|
|
|
|
|
|
|
class PosterEraseDataset(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 PosterErase dataset, you need to download the dataset " |
|
|
"via [Alibaba Cloud](https://tianchi.aliyun.com/dataset/134810)." |
|
|
) |
|
|
|
|
|
def _info(self) -> ds.DatasetInfo: |
|
|
masks = ds.Sequence( |
|
|
{ |
|
|
"x1": ds.Value("int32"), |
|
|
"x2": ds.Value("int32"), |
|
|
"y1": ds.Value("int32"), |
|
|
"y2": ds.Value("int32"), |
|
|
} |
|
|
) |
|
|
objs = ds.Sequence( |
|
|
{ |
|
|
"text": ds.Value("string"), |
|
|
"size": ds.Value("int32"), |
|
|
"direction": ds.Value("int8"), |
|
|
} |
|
|
) |
|
|
color = { |
|
|
"c1": ds.Value("int32"), |
|
|
"c2": ds.Value("int32"), |
|
|
"c3": ds.Value("int32"), |
|
|
} |
|
|
text_feature = { |
|
|
"x": ds.Value("int32"), |
|
|
"y": ds.Value("int32"), |
|
|
"cs": ds.Sequence(color), |
|
|
} |
|
|
texts = ds.Sequence(ds.Sequence(text_feature)) |
|
|
place = {"objs": objs, "texts": texts} |
|
|
annotation = {"masks": masks, "place": place} |
|
|
features = ds.Features( |
|
|
{ |
|
|
"number": ds.Value("int32"), |
|
|
"path": ds.Value("string"), |
|
|
"image": ds.Image(), |
|
|
"gt_image": ds.Image(), |
|
|
"annotation": annotation, |
|
|
} |
|
|
) |
|
|
return ds.DatasetInfo( |
|
|
description=_DESCRIPTION, |
|
|
citation=_CITATION, |
|
|
homepage=_HOMEPAGE, |
|
|
license=_LICENSE, |
|
|
features=features, |
|
|
) |
|
|
|
|
|
def _download_from_hf(self, dl_manager: ds.DownloadManager) -> List[str]: |
|
|
return dl_manager.download_and_extract(_URLS) |
|
|
|
|
|
def _download_from_local(self, dl_manager: ds.DownloadManager) -> List[str]: |
|
|
assert dl_manager.manual_dir is not None, dl_manager.manual_dir |
|
|
dir_path = os.path.expanduser(dl_manager.manual_dir) |
|
|
|
|
|
if not os.path.exists(dir_path): |
|
|
raise FileNotFoundError( |
|
|
"Make sure you have downloaded and placed the PosterErase dataset correctly. " |
|
|
'Furthermore, you shoud check that a manual dir via `datasets.load_dataset("shunk031/PosterErase", data_dir=...)` ' |
|
|
"that include zip files from the downloaded files. " |
|
|
f"Manual downloaded instructions: {self._manual_download_instructions}" |
|
|
) |
|
|
|
|
|
return dl_manager.extract( |
|
|
path_or_paths=[os.path.join(dir_path, zip_file) for zip_file in _ZIP_FILES] |
|
|
) |
|
|
|
|
|
def _split_generators( |
|
|
self, dl_manager: ds.DownloadManager |
|
|
) -> List[ds.SplitGenerator]: |
|
|
base_dir_paths = ( |
|
|
self._download_from_hf(dl_manager) |
|
|
if dl_manager.download_config.token |
|
|
else self._download_from_local(dl_manager) |
|
|
) |
|
|
dir_paths = [pathlib.Path(dir_path) for dir_path in base_dir_paths] |
|
|
dir_paths = [dir_path / f"erase_{i+1}" for i, dir_path in enumerate(dir_paths)] |
|
|
dir_path, *sub_dir_paths = dir_paths |
|
|
|
|
|
tng_df = _load_tng_annotation(dir_path / "train.txt") |
|
|
val_df = _load_val_annotation(dir_path / "ps_valid.txt") |
|
|
tst_df = _load_tst_annotation(dir_path / "ps_test.txt") |
|
|
|
|
|
tng_image_files = { |
|
|
f"{f.parent.name}/{f.name}": f for f in dir_path.glob("train/*.png") |
|
|
} |
|
|
val_image_files = { |
|
|
f"{f.parent.name}/{f.name}": f for f in dir_path.glob("valid/*.png") |
|
|
} |
|
|
val_gt_image_files = { |
|
|
f"{f.parent.name}/{f.name}": f for f in dir_path.glob("valid/*_gt.png") |
|
|
} |
|
|
tst_image_files = { |
|
|
f"{f.parent.name}/{f.name}": f for f in dir_path.glob("test/*.png") |
|
|
} |
|
|
tst_gt_image_files = { |
|
|
f"{f.parent.name}/{f.name}": f for f in dir_path.glob("test/*_gt.png") |
|
|
} |
|
|
for sub_dir_path in sub_dir_paths: |
|
|
tng_image_files.update( |
|
|
{ |
|
|
f"{f.parent.name}/{f.name}": f |
|
|
for f in sub_dir_path.glob("train/*.png") |
|
|
} |
|
|
) |
|
|
return [ |
|
|
ds.SplitGenerator( |
|
|
name=ds.Split.TRAIN, |
|
|
gen_kwargs={ |
|
|
"annotation_df": tng_df, |
|
|
"image_files": tng_image_files, |
|
|
}, |
|
|
), |
|
|
ds.SplitGenerator( |
|
|
name=ds.Split.VALIDATION, |
|
|
gen_kwargs={ |
|
|
"annotation_df": val_df, |
|
|
"image_files": val_image_files, |
|
|
"gt_image_files": val_gt_image_files, |
|
|
}, |
|
|
), |
|
|
ds.SplitGenerator( |
|
|
name=ds.Split.TEST, |
|
|
gen_kwargs={ |
|
|
"annotation_df": tst_df, |
|
|
"image_files": tst_image_files, |
|
|
"gt_image_files": tst_gt_image_files, |
|
|
}, |
|
|
), |
|
|
] |
|
|
|
|
|
def _generate_examples( |
|
|
self, |
|
|
annotation_df: pd.DataFrame, |
|
|
image_files: Dict[str, pathlib.Path], |
|
|
gt_image_files: Optional[Dict[str, pathlib.Path]] = None, |
|
|
): |
|
|
ann_dicts = annotation_df.to_dict(orient="records") |
|
|
for i, ann_dict in enumerate(ann_dicts): |
|
|
image_path = image_files[ann_dict["path"]] |
|
|
image = load_image(image_path) |
|
|
erase_data = EraseData.from_dict(json_dict=ann_dict) |
|
|
|
|
|
example = asdict(erase_data) |
|
|
example["image"] = image |
|
|
|
|
|
if gt_image_files is not None and "gt_path" in ann_dict: |
|
|
gt_image_path = gt_image_files[ann_dict["gt_path"]] |
|
|
gt_image = load_image(gt_image_path) |
|
|
example["gt_image"] = gt_image |
|
|
else: |
|
|
example["gt_image"] = None |
|
|
|
|
|
yield i, example |
|
|
|
