coco.py

from builtins import isinstance
import os
import glob
import json
import logging
import zipfile
import functools
import collections

import datasets

logger = logging.getLogger(__name__)

_VERSION = datasets.Version("1.0.0", "")

_URL = "https://cocodataset.org/#home"

# Copied from https://github.com/tensorflow/datasets/blob/master/tensorflow_datasets/object_detection/coco.py
_CITATION = """\
@article{DBLP:journals/corr/LinMBHPRDZ14,
  author    = {Tsung{-}Yi Lin and
               Michael Maire and
               Serge J. Belongie and
               Lubomir D. Bourdev and
               Ross B. Girshick and
               James Hays and
               Pietro Perona and
               Deva Ramanan and
               Piotr Doll{\'{a}}r and
               C. Lawrence Zitnick},
  title     = {Microsoft {COCO:} Common Objects in Context},
  journal   = {CoRR},
  volume    = {abs/1405.0312},
  year      = {2014},
  url       = {http://arxiv.org/abs/1405.0312},
  archivePrefix = {arXiv},
  eprint    = {1405.0312},
  timestamp = {Mon, 13 Aug 2018 16:48:13 +0200},
  biburl    = {https://dblp.org/rec/bib/journals/corr/LinMBHPRDZ14},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}
"""

# Copied from https://github.com/tensorflow/datasets/blob/master/tensorflow_datasets/object_detection/coco.py
_DESCRIPTION = """COCO is a large-scale object detection, segmentation, and
captioning dataset.
Note:
 * Some images from the train and validation sets don't have annotations.
 * Coco 2014 and 2017 uses the same images, but different train/val/test splits
 * The test split don't have any annotations (only images).
 * Coco defines 91 classes but the data only uses 80 classes.
 * Panotptic annotations defines defines 200 classes but only uses 133.
"""

# Copied from https://github.com/tensorflow/datasets/blob/master/tensorflow_datasets/object_detection/coco.py
_CONFIG_DESCRIPTION = """
This version contains images, bounding boxes and labels for the {year} version.
"""

Split = collections.namedtuple(
    'Split', ['name', 'images', 'annotations', 'annotation_type']
)

# stuffing class 'none' for index 0
CAT = [
    "none",
    "person",
    "bicycle",
    "car",
    "motorcycle",
    "airplane",
    "bus",
    "train",
    "truck",
    "boat",
    "traffic light",
    "fire hydrant",
    "street sign",
    "stop sign",
    "parking meter",
    "bench",
    "bird",
    "cat",
    "dog",
    "horse",
    "sheep",
    "cow",
    "elephant",
    "bear",
    "zebra",
    "giraffe",
    "hat",
    "backpack",
    "umbrella",
    "shoe",
    "eye glasses",
    "handbag",
    "tie",
    "suitcase",
    "frisbee",
    "skis",
    "snowboard",
    "sports ball",
    "kite",
    "baseball bat",
    "baseball glove",
    "skateboard",
    "surfboard",
    "tennis racket",
    "bottle",
    "plate",
    "wine glass",
    "cup",
    "fork",
    "knife",
    "spoon",
    "bowl",
    "banana",
    "apple",
    "sandwich",
    "orange",
    "broccoli",
    "carrot",
    "hot dog",
    "pizza",
    "donut",
    "cake",
    "chair",
    "couch",
    "potted plant",
    "bed",
    "mirror",
    "dining table",
    "window",
    "desk",
    "toilet",
    "door",
    "tv",
    "laptop",
    "mouse",
    "remote",
    "keyboard",
    "cell phone",
    "microwave",
    "oven",
    "toaster",
    "sink",
    "refrigerator",
    "blender",
    "book",
    "clock",
    "vase",
    "scissors",
    "teddy bear",
    "hair drier",
    "toothbrush",
    "hair brush",
]

SUPER_CAT = [
    "none",
    "person",
    "vehicle",
    "outdoor",
    "animal",
    "accessory",
    "sports",
    "kitchen",
    "food",
    "furniture",
    "electronic",
    "appliance",
    "indoor",
]

CAT2SUPER_CAT = [
    "none",
    "person",
    "vehicle",
    "vehicle",
    "vehicle",
    "vehicle",
    "vehicle",
    "vehicle",
    "vehicle",
    "vehicle",
    "outdoor",
    "outdoor",
    "outdoor",
    "outdoor",
    "outdoor",
    "outdoor",
    "animal",
    "animal",
    "animal",
    "animal",
    "animal",
    "animal",
    "animal",
    "animal",
    "animal",
    "animal",
    "accessory",
    "accessory",
    "accessory",
    "accessory",
    "accessory",
    "accessory",
    "accessory",
    "accessory",
    "sports",
    "sports",
    "sports",
    "sports",
    "sports",
    "sports",
    "sports",
    "sports",
    "sports",
    "sports",
    "kitchen",
    "kitchen",
    "kitchen",
    "kitchen",
    "kitchen",
    "kitchen",
    "kitchen",
    "kitchen",
    "food",
    "food",
    "food",
    "food",
    "food",
    "food",
    "food",
    "food",
    "food",
    "food",
    "furniture",
    "furniture",
    "furniture",
    "furniture",
    "furniture",
    "furniture",
    "furniture",
    "furniture",
    "furniture",
    "furniture",
    "electronic",
    "electronic",
    "electronic",
    "electronic",
    "electronic",
    "electronic",
    "appliance",
    "appliance",
    "appliance",
    "appliance",
    "appliance",
    "appliance",
    "indoor",
    "indoor",
    "indoor",
    "indoor",
    "indoor",
    "indoor",
    "indoor",
    "indoor",
]






class AnnotationType(object):
    """Enum of the annotation format types.
    Splits are annotated with different formats.
    """

    BBOXES = 'bboxes'
    PANOPTIC = 'panoptic'
    NONE = 'none'



DETECTION_FEATURE = datasets.Features(
    {
        "image": datasets.Image(),
        "image/filename": datasets.Value("string"),
        "image/id": datasets.Value("int64"),
        "objects": datasets.Sequence(feature=datasets.Features({
            "id": datasets.Value("int64"),
            "area": datasets.Value("float32"),
            "bbox": datasets.Sequence(
                feature=datasets.Value("float32")
            ),
            "label": datasets.ClassLabel(names=CAT),
            "super_cat_label": datasets.ClassLabel(names=SUPER_CAT),
            "is_crowd": datasets.Value("bool"),
        })),
    }
)

PANOPTIC_FEATURE = datasets.Features(
    {
        "image": datasets.Image(),
        "image/filename": datasets.Value("string"),
        "image/id": datasets.Value("int64"),
        "panoptic_objects": datasets.Sequence(feature=datasets.Features({
            "id": datasets.Value("int64"),
            "area": datasets.Value("float32"),
            "bbox": datasets.Sequence(
                feature=datasets.Value("float32")
            ),
            "label": datasets.ClassLabel(names=CAT),
            "super_cat_label": datasets.ClassLabel(names=SUPER_CAT),
            "is_crowd": datasets.Value("bool"),
        })),
        "panoptic_image": datasets.Image(),
        "panoptic_image/filename": datasets.Value("string"),
    }
)
# More info could be added, like segmentation (as png mask), captions,
# person key-points, more metadata (original flickr url,...).



# Copied from https://github.com/tensorflow/datasets/blob/master/tensorflow_datasets/object_detection/coco.py
class CocoConfig(datasets.BuilderConfig):
  """BuilderConfig for CocoConfig."""

  def __init__(self, features, splits=None, has_panoptic=False, **kwargs):
    super(CocoConfig, self).__init__(
        **kwargs
    )
    self.features = features
    self.splits = splits
    self.has_panoptic = has_panoptic


# Copied from https://github.com/tensorflow/datasets/blob/master/tensorflow_datasets/object_detection/coco.py
class Coco(datasets.GeneratorBasedBuilder):
    """Base MS Coco dataset."""

    BUILDER_CONFIGS = [
      CocoConfig(
          name='2014',
          features=DETECTION_FEATURE,
          description=_CONFIG_DESCRIPTION.format(year=2014),
          version=_VERSION,
          splits=[
              Split(
                  name=datasets.Split.TRAIN,
                  images='train2014',
                  annotations='annotations_trainval2014',
                  annotation_type=AnnotationType.BBOXES,
              ),
              Split(
                  name=datasets.Split.VALIDATION,
                  images='val2014',
                  annotations='annotations_trainval2014',
                  annotation_type=AnnotationType.BBOXES,
              ),
              Split(
                  name=datasets.Split.TEST,
                  images='test2014',
                  annotations='image_info_test2014',
                  annotation_type=AnnotationType.NONE,
              ),
              # Coco2014 contains an extra test split
              Split(
                  name='test2015',
                  images='test2015',
                  annotations='image_info_test2015',
                  annotation_type=AnnotationType.NONE,
              ),
          ],
      ),
      CocoConfig(
          name='2017',
          features=DETECTION_FEATURE,
          description=_CONFIG_DESCRIPTION.format(year=2017),
          version=_VERSION,
          splits=[
              Split(
                  name=datasets.Split.TRAIN,
                  images='train2017',
                  annotations='annotations_trainval2017',
                  annotation_type=AnnotationType.BBOXES,
              ),
              Split(
                  name=datasets.Split.VALIDATION,
                  images='val2017',
                  annotations='annotations_trainval2017',
                  annotation_type=AnnotationType.BBOXES,
              ),
              Split(
                  name=datasets.Split.TEST,
                  images='test2017',
                  annotations='image_info_test2017',
                  annotation_type=AnnotationType.NONE,
              ),
          ],
      ),
      CocoConfig(
          name='2017_panoptic',
          features=PANOPTIC_FEATURE,
          description=_CONFIG_DESCRIPTION.format(year=2017),
          version=_VERSION,
          has_panoptic=True,
          splits=[
              Split(
                  name=datasets.Split.TRAIN,
                  images='train2017',
                  annotations='panoptic_annotations_trainval2017',
                  annotation_type=AnnotationType.PANOPTIC,
              ),
              Split(
                  name=datasets.Split.VALIDATION,
                  images='val2017',
                  annotations='panoptic_annotations_trainval2017',
                  annotation_type=AnnotationType.PANOPTIC,
              ),
          ],
      ),
  ]

    DEFAULT_CONFIG_NAME = "2017"

    def _info(self):
        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=self.config.features,
            supervised_keys=None,  # Probably needs to be fixed.
            homepage=_URL,
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager: datasets.DownloadManager):

        # DownloadManager memoize the url, so duplicate urls will only be downloaded
        # once.
        if dl_manager.manual_dir is None:
            # Merge urls from all splits together
            urls = {}
            for split in self.config.splits:
                urls['{}_images'.format(split.name)] = 'zips/{}.zip'.format(split.images)
                urls['{}_annotations'.format(split.name)] = 'annotations/{}.zip'.format(
                    split.annotations
                )
            
            logging.info("download and extract coco dataset")
            root_url = 'http://images.cocodataset.org/'
            extracted_paths = dl_manager.download_and_extract(
                {key: root_url + url for key, url in urls.items()}
            )
        else:
            logging.info(f"use manual directory: {dl_manager.manual_dir}")
            extracted_paths = {}
            for split in self.config.splits:
                extracted_paths['{}_images'.format(split.name)] = dl_manager.manual_dir
                extracted_paths['{}_annotations'.format(split.name)] = dl_manager.manual_dir

        splits = []
        for split in self.config.splits:
            image_dir = extracted_paths['{}_images'.format(split.name)]
            annotations_dir = extracted_paths['{}_annotations'.format(split.name)]
            if self.config.has_panoptic:
                if dl_manager.manual_dir is None:
                    logging.info("extract panoptic data")
                    panoptic_image_zip_path = os.path.join(
                        annotations_dir,
                        'annotations',
                        'panoptic_{}.zip'.format(split.images),
                    )
                    panoptic_dir = dl_manager.extract(panoptic_image_zip_path)
                    panoptic_dir = os.path.join(
                        panoptic_dir, 'panoptic_{}'.format(split.images)
                    )
                else:
                    logging.info("use extracted data")
                    panoptic_dir = os.path.join(annotations_dir, 'annotations', 'panoptic_{}.zip'.format(split.images))
            else:
                panoptic_dir = None
            splits.append(
                datasets.SplitGenerator(
                    name=split.name, 
                    gen_kwargs={
                        'image_dir': image_dir,
                        'annotation_dir': annotations_dir,
                        'split_name': split.images,
                        'annotation_type': split.annotation_type,
                        'panoptic_dir': panoptic_dir,
                    }
                )
            )
        return splits

    def _generate_examples(self, image_dir, annotation_dir, split_name, annotation_type, panoptic_dir):
        """Generate examples as dicts.
        Args:
        image_dir: `str`, directory containing the images
        annotation_dir: `str`, directory containing annotations
        split_name: `str`, <split_name><year> (ex: train2014, val2017)
        annotation_type: `AnnotationType`, the annotation format (NONE, BBOXES,
            PANOPTIC)
        panoptic_dir: If annotation_type is PANOPTIC, contains the panoptic image
            directory
        Yields:
        example key and data
        """

        if annotation_type == AnnotationType.BBOXES:
            instance_filename = 'instances_{}.json'
        elif annotation_type == AnnotationType.PANOPTIC:
            instance_filename = 'panoptic_{}.json'
        elif annotation_type == AnnotationType.NONE:  # No annotation for test sets
            instance_filename = 'image_info_{}.json'

        # Load the annotations (label names, images metadata,...)
        instance_path = os.path.join(
            annotation_dir,
            'annotations',
            instance_filename.format(split_name),
        )
        coco_annotation = ANNOTATION_CLS[annotation_type](instance_path)
        # Each category is a dict:
        # {
        #    'id': 51,  # From 1-91, some entry missing
        #    'name': 'bowl',
        #    'supercategory': 'kitchen',
        # }
        categories = coco_annotation.categories
        # Each image is a dict:
        # {
        #     'id': 262145,
        #     'file_name': 'COCO_train2017_000000262145.jpg'
        #     'flickr_url': 'http://farm8.staticflickr.com/7187/xyz.jpg',
        #     'coco_url': 'http://images.cocodataset.org/train2017/xyz.jpg',
        #     'license': 2,
        #     'date_captured': '2013-11-20 02:07:55',
        #     'height': 427,
        #     'width': 640,
        # }
        images = coco_annotation.images

        # TODO(b/121375022): ClassLabel names should also contains 'id' and
        # and 'supercategory' (in addition to 'name')
        # Warning: As Coco only use 80 out of the 91 labels, the c['id'] and
        # dataset names ids won't match.
        if self.config.has_panoptic:
            objects_key = 'panoptic_objects'
        else:
            objects_key = 'objects'
        # self.info.features[objects_key]['label'].names = [
        #     c['name'] for c in categories
        # ]
        
        # TODO(b/121375022): Conversion should be done by ClassLabel
        # categories_id2name = {c['id']: c['name'] for c in categories}

        # Iterate over all images
        annotation_skipped = 0
        for image_info in sorted(images, key=lambda x: x['id']):
            if annotation_type == AnnotationType.BBOXES:
                # Each instance annotation is a dict:
                # {
                #     'iscrowd': 0,
                #     'bbox': [116.95, 305.86, 285.3, 266.03],
                #     'image_id': 480023,
                #     'segmentation': [[312.29, 562.89, 402.25, ...]],
                #     'category_id': 58,
                #     'area': 54652.9556,
                #     'id': 86,
                # }
                instances = coco_annotation.get_annotations(img_id=image_info['id'])
            elif annotation_type == AnnotationType.PANOPTIC:
                # Each panoptic annotation is a dict:
                # {
                #     'file_name': '000000037777.png',
                #     'image_id': 37777,
                #     'segments_info': [
                #         {
                #             'area': 353,
                #             'category_id': 52,
                #             'iscrowd': 0,
                #             'id': 6202563,
                #             'bbox': [221, 179, 37, 27],
                #         },
                #         ...
                #     ]
                # }
                panoptic_annotation = coco_annotation.get_annotations(
                    img_id=image_info['id']
                )
                instances = panoptic_annotation['segments_info']
            else:
                instances = []  # No annotations

            if not instances:
                annotation_skipped += 1

            def build_bbox(x, y, width, height):
                # pylint: disable=cell-var-from-loop
                # build_bbox is only used within the loop so it is ok to use image_info
                return [
                    y,
                    x,
                    (y + height),
                    (x + width),
                ]
                # pylint: enable=cell-var-from-loop

            example = {
                'image': os.path.abspath(os.path.join(image_dir, split_name, image_info['file_name'])),
                'image/filename': image_info['file_name'],
                'image/id': image_info['id'],
                objects_key: [
                    {  # pylint: disable=g-complex-comprehension
                        'id': instance['id'],
                        'area': instance['area'],
                        'bbox': build_bbox(*instance['bbox']),
                        'label': instance['category_id'],
                        'super_cat_label': SUPER_CAT.index(CAT2SUPER_CAT[instance['category_id']]),
                        'is_crowd': bool(instance['iscrowd']),
                    }
                    for instance in instances
                ],
            }
            if self.config.has_panoptic:
                panoptic_filename = panoptic_annotation['file_name']
                panoptic_image_path = os.path.join(panoptic_dir, panoptic_filename)
                example['panoptic_image'] = panoptic_image_path
                example['panoptic_image/filename'] = panoptic_filename

            yield image_info['file_name'], example

        logging.info(
            '%d/%d images do not contains any annotations',
            annotation_skipped,
            len(images),
        )


class CocoAnnotation(object):
  """Coco annotation helper class."""

  def __init__(self, annotation_path):
    with open(annotation_path, "r") as f:
      data = json.load(f)
    self._data = data

  @property
  def categories(self):
    """Return the category dicts, as sorted in the file."""
    return self._data['categories']

  @property
  def images(self):
    """Return the image dicts, as sorted in the file."""
    return self._data['images']

  def get_annotations(self, img_id):
    """Return all annotations associated with the image id string."""
    raise NotImplementedError  # AnotationType.NONE don't have annotations


class CocoAnnotationBBoxes(CocoAnnotation):
  """Coco annotation helper class."""

  def __init__(self, annotation_path):
    super(CocoAnnotationBBoxes, self).__init__(annotation_path)

    img_id2annotations = collections.defaultdict(list)
    for a in self._data['annotations']:
      img_id2annotations[a['image_id']].append(a)
    self._img_id2annotations = {
        k: list(sorted(v, key=lambda a: a['id']))
        for k, v in img_id2annotations.items()
    }

  def get_annotations(self, img_id):
    """Return all annotations associated with the image id string."""
    # Some images don't have any annotations. Return empty list instead.
    return self._img_id2annotations.get(img_id, [])


class CocoAnnotationPanoptic(CocoAnnotation):
  """Coco annotation helper class."""

  def __init__(self, annotation_path):
    super(CocoAnnotationPanoptic, self).__init__(annotation_path)
    self._img_id2annotations = {
        a['image_id']: a for a in self._data['annotations']
    }

  def get_annotations(self, img_id):
    """Return all annotations associated with the image id string."""
    return self._img_id2annotations[img_id]


ANNOTATION_CLS = {
    AnnotationType.NONE: CocoAnnotation,
    AnnotationType.BBOXES: CocoAnnotationBBoxes,
    AnnotationType.PANOPTIC: CocoAnnotationPanoptic,
}