Upload 9 files

.gitattributes

@@ -53,3 +53,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+train.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,43 @@
 ---
 license: cc
+language:
+- en
+size_categories:
+- 1K<n<10K
 ---
+
+This is the dataset repository of a paper ''SciPostLayout: A Dataset for Layout Analysis and Layout Generation of Scientific Posters''.
+This dataset includes 7,755 poster images in train set, 50 poster images in dev/test sets, respectively.
+The file structure is as follows.
+
+- train.zip
+  - 7,755 poster images of train set.
+- dev.zip
+  - 50 poster images of dev set.
+- test.zip
+  - 50 poster images of test set.
+- train.json
+  - annotation data of train set.
+- dev.json
+  - annotation data of valid set.
+- test.json
+  - annotation data of test set.
+- load_dataset.py
+  - example script to load the dataset.
+- poster_pdf.zip
+  - poster pdf files (optional)
+ 
+After downloading the data set, place each file as follows to run load_dataset.py
+
+- load_dataset.py
+- scipostlayout
+  - raw
+    - train
+      - train png files 
+    - dev
+      - dev png files
+    - test
+      - test png files
+    - train.json
+    - dev.json
+    - test.json 

dev.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:600922983bee703da3dedda0c782fe4edd66afb19795718956799604e6b4c070
+size 135972578

load_dataset.py

@@ -0,0 +1,241 @@
+import os
+import errno
+import os.path as osp
+from typing import List, Set, Union
+
+import json
+from pathlib import Path
+from typing import List, Set, Union, Dict
+
+import torch
+from torch.utils.data import Dataset
+import seaborn as sns
+from pycocotools.coco import COCO
+"""
+load raw data
+"""
+
+
+def makedirs(path):
+    try:
+        os.makedirs(osp.expanduser(osp.normpath(path)))
+    except OSError as e:
+        if e.errno != errno.EEXIST and osp.isdir(path):
+            raise e
+
+
+def files_exist(files):
+    return all([osp.exists(f) for f in files])
+
+
+
+def load_scipostlayout_data(raw_dir: str, max_num_elements: int,
+                        label_set: Union[List, Set], label2index: Dict):
+
+    def is_valid(element):
+        label = coco.cats[element['category_id']]['name']
+        if label not in set(label_set):
+            return False
+        x1, y1, width, height = element['bbox']
+        x2, y2 = x1 + width, y1 + height
+
+        if x1 < 0 or y1 < 0 or W < x2 or H < y2:
+            return False
+        if x2 <= x1 or y2 <= y1:
+            return False
+
+        return True
+
+    train_list, dev_list = None, None
+    # raw_dir = osp.join(Path(raw_dir), 'scipostlayout')
+    for split in ['train', 'dev', 'test']:
+        dataset = []
+        coco = COCO(osp.join(raw_dir, f'{split}.json'))
+        for img_id in sorted(coco.getImgIds()):
+            ann_img = coco.loadImgs(img_id)
+            W = float(ann_img[0]['width'])
+            H = float(ann_img[0]['height'])
+            name = ann_img[0]['file_name']
+            # if H < W:
+            #     continue
+
+            elements = coco.loadAnns(coco.getAnnIds(imgIds=[img_id]))
+            _elements = list(filter(is_valid, elements))
+            filtered = len(elements) != len(_elements)
+            elements = _elements
+
+            N = len(elements)
+            if N == 0 or max_num_elements < N:
+                continue
+
+            bboxes = []
+            labels = []
+
+            for element in elements:
+                # bbox
+                x1, y1, width, height = element['bbox']
+                b = [x1 / W, y1 / H,  width / W, height / H]  # bbox format: ltwh
+                bboxes.append(b)
+
+                # label
+                label = coco.cats[element['category_id']]['name']
+                labels.append(label2index[label])
+
+            bboxes = torch.tensor(bboxes, dtype=torch.float)
+            labels = torch.tensor(labels, dtype=torch.long)
+
+            data = {
+                'name': name,
+                'bboxes': bboxes,
+                'labels': labels,
+                'canvas_size': [W, H],
+                'filtered': filtered,
+            }
+            dataset.append(data)
+
+        if split == 'train':
+            train_list = dataset
+        elif split == 'dev':
+            dev_list = dataset
+        else:
+            test_list = dataset
+
+    # shuffle train with seed
+    generator = torch.Generator().manual_seed(0)
+    indices = torch.randperm(len(train_list), generator=generator)
+    train_list = [train_list[i] for i in indices]
+
+    train_set = train_list
+    dev_set = dev_list
+    test_set = test_list
+    split_dataset = [train_set, dev_set, test_set]
+    return split_dataset
+
+
+class LayoutDataset(Dataset):
+
+    _label2index = None
+    _index2label = None
+    _colors = None
+
+    split_file_names = ['train.pt', 'dev.pt', 'test.pt']
+
+    def __init__(self,
+                 root: str,
+                 data_name: str,
+                 split: str,
+                 max_num_elements: int,
+                 label_set: Union[List, Set],
+                 online_process: bool = True):
+
+        self.root = f'{root}/{data_name}/'
+        self.raw_dir = osp.join(self.root, 'raw')
+        self.max_num_elements = max_num_elements
+        self.label_set = label_set
+        self.pre_processed_dir = osp.join(
+            self.root, 'pre_processed_{}_{}'.format(self.max_num_elements, len(self.label_set)))
+        assert split in ['train', 'dev', 'test']
+
+        if files_exist(self.pre_processed_paths):
+            idx = self.split_file_names.index('{}.pt'.format(split))
+            print(f'Loading {split}...')
+            self.data = torch.load(self.pre_processed_paths[idx])
+        else:
+            print(f'Pre-processing and loading {split}...')
+            makedirs(self.pre_processed_dir)
+            split_dataset = self.load_raw_data()
+            self.save_split_dataset(split_dataset)
+            idx = self.split_file_names.index('{}.pt'.format(split))
+            self.data = torch.load(self.pre_processed_paths[idx])
+
+        self.online_process = online_process
+        if not self.online_process:
+            self.data = [self.process(item) for item in self.data]
+
+    @property
+    def pre_processed_paths(self):
+        return [
+            osp.join(self.pre_processed_dir, f) for f in self.split_file_names
+        ]
+
+    @classmethod
+    def label2index(self, label_set):
+        if self._label2index is None:
+            self._label2index = dict()
+            for idx, label in enumerate(label_set):
+                self._label2index[label] = idx # HACK idx + 1
+        return self._label2index
+
+    @classmethod
+    def index2label(self, label_set):
+        if self._index2label is None:
+            self._index2label = dict()
+            for idx, label in enumerate(label_set):
+                self._index2label[idx] = label # HACK idx + 1
+        return self._index2label
+
+    @property
+    def colors(self):
+        if self._colors is None:
+            n_colors = len(self.label_set) + 1
+            colors = sns.color_palette('husl', n_colors=n_colors)
+            self._colors = [
+                tuple(map(lambda x: int(x * 255), c)) for c in colors
+            ]
+        return self._colors
+
+    def save_split_dataset(self, split_dataset):
+        torch.save(split_dataset[0], self.pre_processed_paths[0])
+        torch.save(split_dataset[1], self.pre_processed_paths[1])
+        torch.save(split_dataset[2], self.pre_processed_paths[2])
+
+    def load_raw_data(self) -> list:
+        raise NotImplementedError
+
+    def process(self, data) -> dict:
+        raise NotImplementedError
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        if self.online_process:
+            sample = self.process(self.data[idx])
+        else:
+            sample = self.data[idx]
+        return sample
+
+
+class SciPostLayoutDataset(LayoutDataset):
+    labels = [
+        'Title',
+        'Author Info',
+        'Section',
+        'List',
+        'Text',
+        'Caption',
+        'Figure',
+        'Table',
+        'Unknown'
+    ]
+
+    def __init__(self,
+                 root: str,
+                 split: str,
+                 max_num_elements: int,
+                 online_process: bool = True):
+        data_name = 'scipostlayout'
+        super().__init__(root,
+                         data_name,
+                         split,
+                         max_num_elements,
+                         label_set=self.labels,
+                         online_process=online_process)
+
+    def load_raw_data(self) -> list:
+        return load_scipostlayout_data(self.raw_dir, self.max_num_elements,
+                                   self.label_set, self.label2index(self.label_set))
+
+
+if __name__ == "__main__":
+    dataset = SciPostLayoutDataset(root="./", split="dev", max_num_elements=50)

poster_pdf.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63f86a43b8c75d451102709e12c8c417ef91c3e4c3092d6f76c9ef8b31453128
+size 8774293867

test.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d18be440d37dd86ef4e46690757a9f672593ee3fcdb99b93f293cb3a19ae4c55
+size 143442481

train.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:357cc415d0d89ec1427ce3cdf5342b38df082e0761621d2ffa0f254f100253f8
+size 142449053

train.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c588fa06fdd47e97b7d02039c9fd1b94d079d2875c6ba1586b6afc083c219039
+size 22211140890