COCOA.py

import json
import logging
import os
from collections import defaultdict
from dataclasses import asdict, dataclass
from typing import Any, Dict, List, Literal, Optional, Tuple, Type, TypedDict, Union

import datasets as ds
import numpy as np
from PIL import Image
from PIL.Image import Image as PilImage
from tqdm.auto import tqdm

logger = logging.getLogger(__name__)
JsonDict = Dict[str, Any]

ImageId = int
AnnotationId = int
LicenseId = int


_CITATION = """\
@inproceedings{zhu2017semantic,
  title={Semantic amodal segmentation},
  author={Zhu, Yan and Tian, Yuandong and Metaxas, Dimitris and Doll{\'a}r, Piotr},
  booktitle={Proceedings of the IEEE conference on computer vision and pattern recognition},
  pages={1464--1472},
  year={2017}
}
@inproceedings{lin2014microsoft,
  title={Microsoft coco: Common objects in context},
  author={Lin, Tsung-Yi and Maire, Michael and Belongie, Serge and Hays, James and Perona, Pietro and Ramanan, Deva and Doll{\'a}r, Piotr and Zitnick, C Lawrence},
  booktitle={Computer Vision--ECCV 2014: 13th European Conference, Zurich, Switzerland, September 6-12, 2014, Proceedings, Part V 13},
  pages={740--755},
  year={2014},
  organization={Springer}
}
@article{arbelaez2010contour,
  title={Contour detection and hierarchical image segmentation},
  author={Arbelaez, Pablo and Maire, Michael and Fowlkes, Charless and Malik, Jitendra},
  journal={IEEE transactions on pattern analysis and machine intelligence},
  volume={33},
  number={5},
  pages={898--916},
  year={2010},
  publisher={IEEE}
}
"""

_DESCRIPTION = """\
COCOA dataset targets amodal segmentation, which aims to recognize and segment objects beyond their visible parts. \
This dataset includes labels not only for the visible parts of objects, but also for their occluded parts hidden \
by other objects. This enables learning to understand the full shape and position of objects. 
"""

_HOMEPAGE = "https://github.com/Wakeupbuddy/amodalAPI"

_LICENSE = """\
The annotations in the COCO dataset along with this website belong to the COCO Consortium and are licensed under a Creative Commons Attribution 4.0 License.
"""

_URLS = {
    "COCO": {
        "images": {
            "train": "http://images.cocodataset.org/zips/train2014.zip",
            "validation": "http://images.cocodataset.org/zips/val2014.zip",
            "test": "http://images.cocodataset.org/zips/test2014.zip",
        },
    },
    "BSDS": {
        "images": "http://www.eecs.berkeley.edu/Research/Projects/CS/vision/grouping/BSR/BSR_bsds500.tgz",
    },
    # The author of this loading script has uploaded the 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 Google Drive link provided by the COCOA's author.
    # (To the author of COCOA, if there are any issues regarding this matter, please contact us. We will address it promptly.)
    "annotations": "https://huggingface.co/datasets/shunk031/COCOA-annotation/resolve/main/annotations.tar.gz",
}


def _load_image(image_path: str) -> PilImage:
    return Image.open(image_path)


@dataclass
class ImageData(object):
    image_id: ImageId
    license_id: LicenseId
    file_name: str
    height: int
    width: int
    date_captured: str
    flickr_url: str

    @classmethod
    def get_date_captured(cls, json_dict: JsonDict) -> str:
        date_captured = json_dict.get("date_captured")
        if date_captured is None:
            date_captured = json_dict["data_captured"]  # typo?
        return date_captured

    @classmethod
    def get_license_id(cls, json_dict: JsonDict) -> int:
        license_id = json_dict["license"]
        if license_id == "?":
            # Since the test data in BSDS has a license id of `?`,
            # convert it to -100 instead.
            return -100
        else:
            return int(license_id)

    @classmethod
    def to_base_dict(cls, json_dict: JsonDict) -> JsonDict:
        return {
            "image_id": json_dict["id"],
            "file_name": json_dict["file_name"],
            "height": json_dict["height"],
            "width": json_dict["width"],
            "flickr_url": json_dict["flickr_url"],
            "license_id": cls.get_license_id(json_dict),
            "date_captured": cls.get_date_captured(json_dict),
        }

    @property
    def shape(self) -> Tuple[int, int]:
        return (self.height, self.width)


@dataclass
class CocoImageData(ImageData):
    coco_url: str

    @classmethod
    def from_dict(cls, json_dict: JsonDict) -> "CocoImageData":
        return cls(
            **cls.to_base_dict(json_dict),
            coco_url=json_dict["coco_url"],
        )


@dataclass
class BsDsImageData(ImageData):
    bsds_url: str

    @classmethod
    def from_dict(cls, json_dict: JsonDict) -> "BsDsImageData":
        return cls(
            **cls.to_base_dict(json_dict),
            bsds_url=json_dict["bsds_url"],
        )


class RunLengthEncoding(TypedDict):
    counts: str
    size: Tuple[int, int]


@dataclass
class RegionAnnotationData(object):
    segmentation: Union[List[float], np.ndarray]
    name: str
    area: float
    is_stuff: bool
    occlude_rate: float
    order: int
    visible_mask: Optional[Union[np.ndarray, RunLengthEncoding]] = None
    invisible_mask: Optional[Union[np.ndarray, RunLengthEncoding]] = None

    @classmethod
    def rle_segmentation_to_binary_mask(
        cls, segmentation, height: int, width: int
    ) -> np.ndarray:
        from pycocotools import mask as cocomask

        if isinstance(segmentation, list):
            rles = cocomask.frPyObjects([segmentation], h=height, w=width)
            rle = cocomask.merge(rles)
        else:
            raise NotImplementedError

        return cocomask.decode(rle)

    @classmethod
    def rle_segmentation_to_mask(
        cls, segmentation, height: int, width: int
    ) -> np.ndarray:
        binary_mask = cls.rle_segmentation_to_binary_mask(
            segmentation=segmentation, height=height, width=width
        )
        return binary_mask * 255

    @classmethod
    def get_visible_binary_mask(cls, rle_visible_mask=None) -> Optional[np.ndarray]:
        from pycocotools import mask as cocomask

        if rle_visible_mask is None:
            return None
        return cocomask.decode(rle_visible_mask)

    @classmethod
    def get_invisible_binary_mask(cls, rle_invisible_mask=None) -> Optional[np.ndarray]:
        return cls.get_visible_binary_mask(rle_invisible_mask)

    @classmethod
    def get_visible_mask(cls, rle_visible_mask=None) -> Optional[np.ndarray]:
        visible_mask = cls.get_visible_binary_mask(rle_visible_mask=rle_visible_mask)
        return visible_mask * 255 if visible_mask is not None else None

    @classmethod
    def get_invisible_mask(cls, rle_invisible_mask=None) -> Optional[np.ndarray]:
        return cls.get_visible_mask(rle_invisible_mask)

    @classmethod
    def from_dict(
        cls,
        json_dict: JsonDict,
        image_data: ImageData,
        decode_rle: bool,
    ) -> "RegionAnnotationData":
        if decode_rle:
            segmentation_mask = cls.rle_segmentation_to_mask(
                segmentation=json_dict["segmentation"],
                height=image_data.height,
                width=image_data.width,
            )
            visible_mask = cls.get_visible_mask(
                rle_visible_mask=json_dict.get("visible_mask")
            )
            invisible_mask = cls.get_invisible_mask(
                rle_invisible_mask=json_dict.get("invisible_mask")
            )
        else:
            segmentation_mask = json_dict["segmentation"]
            visible_mask = json_dict.get("visible_mask")
            invisible_mask = json_dict.get("invisible_mask")

        return cls(
            segmentation=segmentation_mask,
            visible_mask=visible_mask,
            invisible_mask=invisible_mask,
            name=json_dict["name"],
            area=json_dict["area"],
            is_stuff=json_dict["isStuff"],
            occlude_rate=json_dict["occlude_rate"],
            order=json_dict["order"],
        )


@dataclass
class CocoaAnnotationData(object):
    author: str
    url: str
    regions: List[RegionAnnotationData]
    image_id: ImageId
    depth_constraint: str
    size: int

    @classmethod
    def from_dict(
        cls, json_dict: JsonDict, images: Dict[ImageId, ImageData], decode_rle: bool
    ) -> "CocoaAnnotationData":
        image_id = json_dict["image_id"]

        regions = [
            RegionAnnotationData.from_dict(
                json_dict=region_dict,
                image_data=images[image_id],
                decode_rle=decode_rle,
            )
            for region_dict in json_dict["regions"]
        ]

        return cls(
            author=json_dict["author"],
            url=json_dict["url"],
            regions=regions,
            image_id=image_id,
            depth_constraint=json_dict["depth_constraint"],
            size=json_dict["size"],
        )


def _load_images_data(
    image_dicts: List[JsonDict],
    dataset_name: Literal["COCO", "BSDS"],
    tqdm_desc: str = "Load images",
) -> Dict[ImageId, ImageData]:
    ImageDataClass: Union[Type[CocoImageData], Type[BsDsImageData]]

    if dataset_name == "COCO":
        ImageDataClass = CocoImageData
    elif dataset_name == "BSDS":
        ImageDataClass = BsDsImageData
    else:
        raise ValueError(f"Invalid dataset name: {dataset_name}")

    images: Dict[ImageId, Union[CocoImageData, BsDsImageData]] = {}
    for image_dict in tqdm(image_dicts, desc=tqdm_desc):
        image_data = ImageDataClass.from_dict(image_dict)
        images[image_data.image_id] = image_data
    return images  # type: ignore


def _load_cocoa_data(
    ann_dicts: List[JsonDict],
    images: Dict[ImageId, ImageData],
    decode_rle: bool,
    tqdm_desc: str = "Load COCOA annotations",
) -> Dict[ImageId, List[CocoaAnnotationData]]:
    annotations = defaultdict(list)
    ann_dicts = sorted(ann_dicts, key=lambda d: d["image_id"])

    for ann_dict in tqdm(ann_dicts, desc=tqdm_desc):
        cocoa_data = CocoaAnnotationData.from_dict(
            ann_dict, images=images, decode_rle=decode_rle
        )
        annotations[cocoa_data.image_id].append(cocoa_data)

    return annotations


@dataclass
class CocoaConfig(ds.BuilderConfig):
    decode_rle: bool = False


class CocoaDataset(ds.GeneratorBasedBuilder):
    VERSION = ds.Version("1.0.0")
    BUILDER_CONFIG_CLASS = CocoaConfig
    BUILDER_CONFIGS = [
        CocoaConfig(name="COCO", version=VERSION, decode_rle=False),
        CocoaConfig(name="BSDS", version=VERSION, decode_rle=False),
    ]

    def load_amodal_annotation(self, ann_json_path: str) -> JsonDict:
        logger.info(f"Load from {ann_json_path}")
        with open(ann_json_path, "r") as rf:
            ann_json = json.load(rf)
        return ann_json

    @property
    def _manual_download_instructions(self) -> str:
        return (
            "To use COCOA, you need to download the annotations "
            "from the google drive in the official repositories "
            "(https://github.com/Wakeupbuddy/amodalAPI#setup)."
            "Downloading of annotations currently appears to be restricted, "
            "but the author will allow us to download them if we request access privileges."
        )

    def _info(self) -> ds.DatasetInfo:
        features_dict = {
            "image_id": ds.Value("int64"),
            "license_id": ds.Value("int32"),
            "file_name": ds.Value("string"),
            "height": ds.Value("int32"),
            "width": ds.Value("int32"),
            "date_captured": ds.Value("string"),
            "flickr_url": ds.Value("string"),
            "image": ds.Image(),
        }

        if self.config.name == "COCO":
            features_dict["coco_url"] = ds.Value("string")
        elif self.config.name == "BSDS":
            features_dict["bsds_url"] = ds.Value("string")
        else:
            raise ValueError(f"Invalid dataset name: {self.config.name}")

        if self.config.decode_rle:  # type: ignore
            segmentation_feature = ds.Image()
            visible_mask_feature = ds.Image()
            invisible_mask_feature = ds.Image()
        else:
            segmentation_feature = ds.Sequence(ds.Value("float32"))
            visible_mask_feature = {
                "counts": ds.Value("string"),
                "size": ds.Sequence(ds.Value("int32")),
            }
            invisible_mask_feature = {
                "counts": ds.Value("string"),
                "size": ds.Sequence(ds.Value("int32")),
            }

        features_dict["annotations"] = ds.Sequence(
            {
                "author": ds.Value("string"),
                "url": ds.Value("string"),
                "regions": ds.Sequence(
                    {
                        "segmentation": segmentation_feature,
                        "name": ds.Value("string"),
                        "area": ds.Value("float32"),
                        "is_stuff": ds.Value("bool"),
                        "occlude_rate": ds.Value("float32"),
                        "order": ds.Value("int32"),
                        "visible_mask": visible_mask_feature,
                        "invisible_mask": invisible_mask_feature,
                    }
                ),
                "image_id": ds.Value("int64"),
                "depth_constraint": ds.Value("string"),
                "size": ds.Value("int32"),
            }
        )
        features = ds.Features(features_dict)

        return ds.DatasetInfo(
            description=_DESCRIPTION,
            citation=_CITATION,
            homepage=_HOMEPAGE,
            license=_LICENSE,
            features=features,
        )

    def _split_generators_coco(self, ann_dir: str, image_dirs: Dict[str, str]):
        tng_ann_path = os.path.join(
            ann_dir,
            f"{self.config.name}_amodal_train2014.json",
        )
        val_ann_path = os.path.join(
            ann_dir,
            f"{self.config.name}_amodal_val2014.json",
        )
        tst_ann_path = os.path.join(
            ann_dir,
            f"{self.config.name}_amodal_test2014.json",
        )
        return [
            ds.SplitGenerator(
                name=ds.Split.TRAIN,  # type: ignore
                gen_kwargs={
                    "base_image_dir": image_dirs["train"],
                    "amodal_annotation_path": tng_ann_path,
                    "split": "train",
                },
            ),
            ds.SplitGenerator(
                name=ds.Split.VALIDATION,  # type: ignore
                gen_kwargs={
                    "base_image_dir": image_dirs["validation"],
                    "amodal_annotation_path": val_ann_path,
                    "split": "val",
                },
            ),
            ds.SplitGenerator(
                name=ds.Split.TEST,  # type: ignore
                gen_kwargs={
                    "base_image_dir": image_dirs["test"],
                    "amodal_annotation_path": tst_ann_path,
                    "split": "test",
                },
            ),
        ]

    def _split_generators_bsds(self, ann_dir: str, image_dir: str):
        tng_ann_path = os.path.join(
            ann_dir,
            f"{self.config.name}_amodal_train.json",
        )
        val_ann_path = os.path.join(
            ann_dir,
            f"{self.config.name}_amodal_val.json",
        )
        tst_ann_path = os.path.join(
            ann_dir,
            f"{self.config.name}_amodal_test.json",
        )
        image_dir = os.path.join(image_dir, "BSR", "BSDS500", "data", "images")
        return [
            ds.SplitGenerator(
                name=ds.Split.TRAIN,  # type: ignore
                gen_kwargs={
                    "base_image_dir": os.path.join(image_dir, "train"),
                    "amodal_annotation_path": tng_ann_path,
                    "split": "train",
                },
            ),
            ds.SplitGenerator(
                name=ds.Split.VALIDATION,  # type: ignore
                gen_kwargs={
                    "base_image_dir": os.path.join(image_dir, "val"),
                    "amodal_annotation_path": val_ann_path,
                    "split": "validation",
                },
            ),
            ds.SplitGenerator(
                name=ds.Split.TEST,  # type: ignore
                gen_kwargs={
                    "base_image_dir": os.path.join(image_dir, "test"),
                    "amodal_annotation_path": tst_ann_path,
                    "split": "test",
                },
            ),
        ]

    def _download_annotation_from_hf(self, dl_manager: ds.DownloadManager) -> str:
        data_path = dl_manager.download_and_extract(_URLS["annotations"])
        return data_path  # type: ignore

    def _download_annotation_from_local(self, dl_manager: ds.DownloadManager) -> str:
        assert dl_manager.manual_dir is not None, dl_manager.manual_dir
        data_path = os.path.expanduser(dl_manager.manual_dir)

        if not os.path.exists(data_path):
            raise FileNotFoundError(
                f"{data_path} does not exists. Make sure you insert a manual dir "
                'via `datasets.load_dataset("shunk031/COCOA", data_dir=...)` '
                "that includes tar/untar files from the COCOA annotation tar.gz. "
                f"Manual download instructions: {self._manual_download_instructions}"
            )
        else:
            data_path = (
                dl_manager.extract(data_path)
                if not os.path.isdir(data_path)
                else data_path
            )
        return data_path  # type: ignore

    def _split_generators(self, dl_manager: ds.DownloadManager):
        urls = _URLS[self.config.name]
        image_dirs = dl_manager.download_and_extract(urls["images"])  # type: ignore

        if dl_manager.download_config.token:
            data_path = self._download_annotation_from_hf(dl_manager)
        else:
            data_path = self._download_annotation_from_local(dl_manager)

        assert isinstance(data_path, str)
        ann_dir = os.path.join(data_path, "annotations")

        if self.config.name == "COCO":
            return self._split_generators_coco(
                ann_dir=ann_dir,
                image_dirs=image_dirs,  # type: ignore
            )
        elif self.config.name == "BSDS":
            return self._split_generators_bsds(
                ann_dir=ann_dir,
                image_dir=image_dirs,  # type: ignore
            )
        else:
            raise ValueError(f"Invalid name: {self.config.name}")

    def _generate_examples(
        self,
        split: str,
        base_image_dir: str,
        amodal_annotation_path: str,
    ):
        if self.config.name == "COCO":
            image_dir = os.path.join(base_image_dir, f"{split}2014")
        elif self.config.name == "BSDS":
            image_dir = base_image_dir
        else:
            raise ValueError(f"Invalid task: {self.config.name}")

        ann_json = self.load_amodal_annotation(amodal_annotation_path)

        images = _load_images_data(
            image_dicts=ann_json["images"],
            dataset_name=self.config.name,
        )
        annotations = _load_cocoa_data(
            ann_dicts=ann_json["annotations"],
            images=images,
            decode_rle=self.config.decode_rle,  # type: ignore
        )

        for idx, image_id in enumerate(images.keys()):
            image_data = images[image_id]
            image_anns = annotations[image_id]

            if len(image_anns) < 1:
                # The original COCO and BSDS datasets may not have amodal annotations.
                continue

            image = _load_image(
                image_path=os.path.join(image_dir, image_data.file_name)
            )
            example = asdict(image_data)
            example["image"] = image
            example["annotations"] = []
            for ann in image_anns:
                ann_dict = asdict(ann)
                example["annotations"].append(ann_dict)

            yield idx, example