Dataset: COCO-Formatted Object Detection Dataset

Overview

This dataset is designed for object detection tasks and follows the COCO format. It contains 300 images and corresponding annotation files in JSON format. The dataset is split into training, validation, and test sets, ensuring a balanced distribution for model evaluation.

Dataset Structure

The dataset is organized into three main folders:

train/ (70% - 210 images)

valid/ (15% - 45 images)

test/ (15% - 45 images)

Each folder contains:

Images in JPEG/PNG format.

A corresponding _annotations.coco.json file that includes bounding box annotations.

Preprocessing & Augmentations

The dataset has undergone several preprocessing and augmentation steps to enhance model generalization:

Image Preprocessing:

Auto-orientation applied

Resized to 640x640 pixels (stretched)

Augmentation Techniques:

Flip: Horizontal flipping

Crop: 0% minimum zoom, 5% maximum zoom

Rotation: Between -5° and +5°

Saturation: Adjusted between -4% and +4%

Brightness: Adjusted between -10% and +10%

Blur: Up to 0px

Noise: Up to 0.1% of pixels

Bounding Box Augmentations:

Flipping, cropping, rotation, brightness adjustments, blur, and noise applied accordingly to maintain annotation consistency.

Annotation Format

The dataset follows the COCO (Common Objects in Context) format, which includes:

images section: Contains image metadata such as filename, width, and height.

annotations section: Includes bounding boxes, category IDs, and segmentation masks (if applicable).

categories section: Defines class labels.

Vehicles Coco

## Overview

Vehicles Coco is a dataset for object detection tasks - it contains Vehicles annotations for 18,998 images.

## Getting Started

You can download this dataset for use within your own projects, or fork it into a workspace on Roboflow to create your own model.

  ## License

  This dataset is available under the [CC BY 4.0 license](https://creativecommons.org/licenses/CC BY 4.0).

Dataset Description

This dataset has been converted to COCO format and contains bounding box annotations for content detection.

  Dataset Structure

The dataset is split into training and validation sets:

Training set: 583 images Validation set: 146 images

  Format

The dataset follows the COCO format with the following structure:

images: Contains the image files annotations.json: Contains the COCO format annotations dataset.yaml: Configuration file for training… See the full description on the dataset page: https://huggingface.co/datasets/zigg-ai/content-regions-1k-coco.

This dataset provides annotated very-high-resolution satellite RGB images extracted from Google Earth to train deep learning models to perform instance segmentation of Juniperus communis L. and Juniperus sabina L. shrubs. All images are from the high mountain of Sierra Nevada in Spain. The dataset contains 810 images (.jpg) of size 224x224 pixels. We also provide partitioning of the data into Train (567 images), Test (162 images), and Validation (81 images) subsets. Their annotations are provided in three different .json files following the COCO annotation format.

Context

The dataset contains car images with one or more damaged parts. The img/ folder has all 80 images in the dataset. There are three more folders train/, val/ and test/ for training, validation and testing purposes respectively.

Folders

train/: - Contains 59 images. - COCO_train_annos.json: Train annotation file for damages where damage is the one and only category. - COCO_mul_train_annos.json: Train annotation file for parts having damages. There are five categories of parts based on which part the damage has happened. The parts can be namely, headlamp, front_bumper, hood, door, rear_bumper.

val/: - Contains 11 images. - COCO_val_annos.json: Validation annotation file for damages where damage is the one and only category. - COCO_mul_val_annos.json: Validation annotation file for parts having damages. There are five categories of parts based on which part the damage has happened. The parts can be namely, headlamp, front_bumper, hood, door, rear_bumper.

test/: - Contains 8 images.

Annotation files have the following keys:

• "annotations": Contains the bounding box and segmentation array.
• "categories": Contains the list of categories in the annotation.
• "images": Details of each image used in the annotation.
• "info": Creator information
• "licenses": License information

The IMPTOX project has received funding from the EU's H2020 framework programme for research and innovation under grant agreement n. 965173. Imptox is part of the European MNP cluster on human health.

More information about the project here.

Description: This repository includes the trained weights and a custom COCO-formatted dataset used for developing and testing a Faster R-CNN R_50_FPN_3x object detector, specifically designed to identify particles in micro-FTIR filter images.

Contents:

Weights File (neuralNetWeights_V3.pth):

Format: .pth

Description: This file contains the trained weights for a Faster R-CNN model with a ResNet-50 backbone and a Feature Pyramid Network (FPN), trained for 3x schedule. These weights are specifically tuned for detecting particles in micro-FTIR filter images.

Custom COCO Dataset (uFTIR_curated_square.v5-uftir_curated_square_2024-03-14.coco-segmentation.zip):

Format: .zip

Description: This zip archive contains a custom COCO-formatted dataset, including JPEG images and their corresponding annotation file. The dataset consists of images of micro-FTIR filters with annotated particles.

Contents:

Images: JPEG format images of micro-FTIR filters.

Annotations: A JSON file in COCO format providing detailed annotations of the particles in the images.

Management: The dataset can be managed and manipulated using the Pycocotools library, facilitating easy integration with existing COCO tools and workflows.

Applications: The provided weights and dataset are intended for researchers and practitioners in the field of microscopy and particle detection. The dataset and model can be used for further training, validation, and fine-tuning of object detection models in similar domains.

Usage Notes:

The neuralNetWeights_V3.pth file should be loaded into a PyTorch model compatible with the Faster R-CNN architecture, such as Detectron2.

The contents of uFTIR_curated_square.v5-uftir_curated_square_2024-03-14.coco-segmentation.zip should be extracted and can be used with any COCO-compatible object detection framework for training and evaluation purposes.

Code can be found on the related Github repository.

Data abstract: The YogDATA dataset contains images from an industrial laboratory production line when it is functioned to quality yogurts. The case-study for the recognition of yogurt cups requires training of Mask R-CNN and YOLO v5.0 models with a set of corresponding images. Thus, it is important to collect the corresponding images to train and evaluate the class. Specifically, the YogDATA dataset includes the same labeled data for Mask R-CNN (coco format) and YOLO models. For the YOLO architecture, training and validation datsets include sets of images in jpg format and their annotations in txt file format. For the Mask R-CNN architecture, the annotation of the same sets of images are included in json file format (80% of images and annotations of each subset are in training set and 20% of images of each subset are in test set.) Paper abstract: The explosion of the digitisation of the traditional industrial processes and procedures is consolidating a positive impact on modern society by offering a critical contribution to its economic development. In particular, the dairy sector consists of various processes, which are very demanding and thorough. It is crucial to leverage modern automation tools and through-engineering solutions to increase their efficiency and continuously meet challenging standards. Towards this end, in this work, an intelligent algorithm based on machine vision and artificial intelligence, which identifies dairy products within production lines, is presented. Furthermore, in order to train and validate the model, the YogDATA dataset was created that includes yogurt cups within a production line. Specifically, we evaluate two deep learning models (Mask R-CNN and YOLO v5.0) to recognise and detect each yogurt cup in a production line, in order to automate the packaging processes of the products. According to our results, the performance precision of the two models is similar, estimating its at 99\%.

The dataset includes 8857 images. Mushroom are annotated in COCO format.

The following pre-processing was applied to each image: * Auto-orientation of pixel data (with EXIF-orientation stripping) * Resize to 640x640 (Stretch)

The following augmentation was applied to create 3 versions of each source image: * 50% probability of horizontal flip * 50% probability of vertical flip

The structure:

dataset-directory/
├─ README.dataset.txt
├─ README.roboflow.txt
├─ train
│ ├─ train-image-1.jpg
│ ├─ train-image-1.jpg
│ ├─ ...
│ └─ _annotations.coco.json
├─ test
│ ├─ test-image-1.jpg
│ ├─ test-image-1.jpg
│ ├─ ...
│ └─ _annotations.coco.json
└─ valid
  ├─ valid-image-1.jpg
  ├─ valid-image-1.jpg
  ├─ ...
  └─ _annotations.coco.json

To convert the format to YOLO annotations, go to roboflow.

This projects combines the Dollar Bill Detection project from Alex Hyams (v13 of the project was exported in COCO JSON format for import to this project) and the Final Counter, or Coin Counter, project from Dawson Mcgee (v6 of the project was exported in COCO JSON format for import to this project).

v1 contains the original imported images, without augmentations. This is the version to download and import to your own project if you'd like to add your own augmentations.

This dataset can be used to create computer vision applications in the banking and finance industry for use cases like detecting and counting US currency.

Dataset

The Man OverBoard Drone (MOBDrone) dataset is a large-scale collection of aerial footage images. It contains 126,170 frames extracted from 66 video clips gathered from one UAV flying at an altitude of 10 to 60 meters above the mean sea level. Images are manually annotated with more than 180K bounding boxes localizing objects belonging to 5 categories --- person, boat, lifebuoy, surfboard, wood. More than 113K of these bounding boxes belong to the person category and localize people in the water simulating the need to be rescued.

In this repository, we provide:

• 66 Full HD video clips (total size: 5.5 GB)

• 126,170 images extracted from the videos at a rate of 30 FPS (total size: 243 GB)

• 3 annotation files for the extracted images that follow the MS COCO data format (for more info see https://cocodataset.org/#format-data):

  • annotations_5_custom_classes.json: this file contains annotations concerning all five categories; please note that class ids do not correspond with the ones provided by the MS COCO standard since we account for two new classes not previously considered in the MS COCO dataset --- lifebuoy and wood

  • annotations_3_coco_classes.json: this file contains annotations concerning the three classes also accounted by the MS COCO dataset --- person, boat, surfboard. Class ids correspond with the ones provided by the MS COCO standard.

  • annotations_person_coco_classes.json: this file contains annotations concerning only the 'person' class. Class id corresponds to the one provided by the MS COCO standard.

The MOBDrone dataset is intended as a test data benchmark. However, for researchers interested in using our data also for training purposes, we provide training and test splits:

• Test set: All the images whose filename starts with "DJI_0804" (total: 37,604 images)
• Training set: All the images whose filename starts with "DJI_0915" (total: 88,568 images)

More details about data generation and the evaluation protocol can be found at our MOBDrone paper: https://arxiv.org/abs/2203.07973
The code to reproduce our results is available at this GitHub Repository: https://github.com/ciampluca/MOBDrone_eval
See also http://aimh.isti.cnr.it/dataset/MOBDrone

Citing the MOBDrone

The MOBDrone is released under a Creative Commons Attribution license, so please cite the MOBDrone if it is used in your work in any form.
Published academic papers should use the academic paper citation for our MOBDrone paper, where we evaluated several pre-trained state-of-the-art object detectors focusing on the detection of the overboard people

@inproceedings{MOBDrone2021,
title={MOBDrone: a Drone Video Dataset for Man OverBoard Rescue},
author={Donato Cafarelli and Luca Ciampi and Lucia Vadicamo and Claudio Gennaro and Andrea Berton and Marco Paterni and Chiara Benvenuti and Mirko Passera and Fabrizio Falchi},
booktitle={ICIAP2021: 21th International Conference on Image Analysis and Processing},
year={2021}
}

and this Zenodo Dataset

@dataset{donato_cafarelli_2022_5996890,
author={Donato Cafarelli and Luca Ciampi and Lucia Vadicamo and Claudio Gennaro and Andrea Berton and Marco Paterni and Chiara Benvenuti and Mirko Passera and Fabrizio Falchi},
 title    = {{MOBDrone: a large-scale drone-view dataset for man overboard detection}},
 month    = feb,
 year     = 2022,
 publisher  = {Zenodo},
 version   = {1.0.0},
 doi     = {10.5281/zenodo.5996890},
 url     = {https://doi.org/10.5281/zenodo.5996890}
}

Personal works, such as machine learning projects/blog posts, should provide a URL to the MOBDrone Zenodo page (https://doi.org/10.5281/zenodo.5996890), though a reference to our MOBDrone paper would also be appreciated.

Contact Information

If you would like further information about the MOBDrone or if you experience any issues downloading files, please contact us at mobdrone[at]isti.cnr.it

Acknowledgements

This work was partially supported by NAUSICAA - "NAUtical Safety by means of Integrated Computer-Assistance Appliances 4.0" project funded by the Tuscany region (CUP D44E20003410009). The data collection was carried out with the collaboration of the Fly&Sense Service of the CNR of Pisa - for the flight operations of remotely piloted aerial systems - and of the Institute of Clinical Physiology (IFC) of the CNR - for the water immersion operations.

Data used for our paper "WormSwin: Instance Segmentation of C. elegans using Vision Transformer".This publication is divided into three parts:

CSB-1 Dataset

Synthetic Images Dataset

MD Dataset

The CSB-1 Dataset consists of frames extracted from videos of Caenorhabditis elegans (C. elegans) annotated with binary masks. Each C. elegans is separately annotated, providing accurate annotations even for overlapping instances. All annotations are provided in binary mask format and as COCO Annotation JSON files (see COCO website).

The videos are named after the following pattern:

<"worm age in hours"_"mutation"_"irradiated (binary)"_"video index (zero based)">

For mutation the following values are possible:

wild type

csb-1 mutant

csb-1 with rescue mutation

An example video name would be 24_1_1_2 meaning it shows C. elegans with csb-1 mutation, being 24h old which got irradiated.

Video data was provided by M. Rieckher; Instance Segmentation Annotations were created under supervision of K. Bozek and M. Deserno.The Synthetic Images Dataset was created by cutting out C. elegans (foreground objects) from the CSB-1 Dataset and placing them randomly on background images also taken from the CSB-1 Dataset. Foreground objects were flipped, rotated and slightly blurred before placed on the background images.The same was done with the binary mask annotations taken from CSB-1 Dataset so that they match the foreground objects in the synthetic images. Additionally, we added rings of random color, size, thickness and position to the background images to simulate petri-dish edges.

This synthetic dataset was generated by M. Deserno.The Mating Dataset (MD) consists of 450 grayscale image patches of 1,012 x 1,012 px showing C. elegans with high overlap, crawling on a petri-dish.We took the patches from a 10 min. long video of size 3,036 x 3,036 px. The video was downsampled from 25 fps to 5 fps before selecting 50 random frames for annotating and patching.Like the other datasets, worms were annotated with binary masks and annotations are provided as COCO Annotation JSON files.

The video data was provided by X.-L. Chu; Instance Segmentation Annotations were created under supervision of K. Bozek and M. Deserno.

Further details about the datasets can be found in our paper.

The Object Detection for Olfactory References (ODOR) Dataset

Real-world applications of computer vision in the humanities require algorithms to be robust against artistic abstraction, peripheral objects, and subtle differences between fine-grained target classes.

Existing datasets provide instance-level annotations on artworks but are generally biased towards the image centre and limited with regard to detailed object classes. The ODOR dataset fills this gap, offering 38,116 object-level annotations across 4,712 images, spanning an extensive set of 139 fine-grained categories.

It has challenging dataset properties, such as a detailed set of categories, dense and overlapping objects, and spatial distribution over the whole image canvas.

Inspiring further research on artwork object detection and broader visual cultural heritage studies, the dataset challenges researchers to explore the intersection of object recognition and smell perception.

How to use

The annotations are provided in COCO JSON format. To represent the two-level hierarchy of the object classes, we make use of the supercategory field in the categories array as defined by COCO. In addition to the object-level annotations, we provide an additional CSV file with image-level metadata, which includes content-related fields, such as Iconclass codes or image descriptions, as well as formal annotations, such as artist, license, or creation year.

In addition to a zip containing the dataset images, we provide links to their source collections in the metadata file and a Python script to conveniently download the artwork images (`download_imgs.py`).

The mapping between the `images` array of the `annotations.json` and the `metadata.csv` file can be accomplished via the `file_name` attribute of the elements of the `images` array and the unique `File Name` column of the `metadata.csv` file, respectively.

This file contains the annotations for the ConfLab dataset, including actions (speaking status), pose, and F-formations.

------------------

./actions/speaking_status:

./processed: the processed speaking status files, aggregated into a single data frame per segment. Skipped rows in the raw data (see https://josedvq.github.io/covfee/docs/output for details) have been imputed using the code at: https://github.com/TUDelft-SPC-Lab/conflab/tree/master/preprocessing/speaking_status

The processed annotations consist of:

./speaking: The first row contains person IDs matching the sensor IDs,

The rest of the row contains binary speaking status annotations at 60fps for the corresponding 2 min video segment (7200 frames).

./confidence: Same as above. These annotations reflect the continuous-valued rating of confidence of the annotators in their speaking annotation.

To load these files with pandas: pd.read_csv(p, index_col=False)

./raw.zip: the raw outputs from speaking status annotation for each of the eight annotated 2-min video segments. These were were output by the covfee annotation tool (https://github.com/josedvq/covfee)

Annotations were done at 60 fps.

--------------------

./pose:

./coco: the processed pose files in coco JSON format, aggregated into a single data frame per video segment. These files have been generated from the raw files using the code at: https://github.com/TUDelft-SPC-Lab/conflab-keypoints

To load in Python: f = json.load(open('/path/to/cam2_vid3_seg1_coco.json'))

The skeleton structure (limbs) is contained within each file in:

f['categories'][0]['skeleton']

and keypoint names at:

f['categories'][0]['keypoints']

./raw.zip: the raw outputs from continuous pose annotation. These were were output by the covfee annotation tool (https://github.com/josedvq/covfee)

Annotations were done at 60 fps.

---------------------

./f_formations:

seg 2: 14:00 onwards, for videos of the form x2xxx.MP4 in /video/raw/ for the relevant cameras (2,4,6,8,10).

seg 3: for videos of the form x3xxx.MP4 in /video/raw/ for the relevant cameras (2,4,6,8,10).

Note that camera 10 doesn't include meaningful subject information/body parts that are not already covered in camera 8.

First column: time stamp

Second column: "()" delineates groups, "<>" delineates subjects, cam X indicates the best camera view for which a particular group exists.

phone.csv: time stamp (pertaining to seg3), corresponding group, ID of person using the phone

This contains instances_train2014.t7 and instances_val2014.t7, converted from JSON for loading by Torch's COCO API as described here: https://gist.github.com/ryanfb/13bd5cf3d89d6b5e8acbd553256507f2#out-of-memory-loading-annotations-during-th-trainlua

SpeechCoco

Introduction

Our corpus is an extension of the MS COCO image recognition and captioning dataset. MS COCO comprises images paired with a set of five captions. Yet, it does not include any speech. Therefore, we used Voxygen's text-to-speech system to synthesise the available captions.

The addition of speech as a new modality enables MSCOCO to be used for researches in the field of language acquisition, unsupervised term discovery, keyword spotting, or semantic embedding using speech and vision.

Our corpus is licensed under a Creative Commons Attribution 4.0 License.

Data Set

• This corpus contains 616,767 spoken captions from MSCOCO's val2014 and train2014 subsets (respectively 414,113 for train2014 and 202,654 for val2014).

• We used 8 different voices. 4 of them have a British accent (Paul, Bronwen, Judith, and Elizabeth) and the 4 others have an American accent (Phil, Bruce, Amanda, Jenny).

• In order to make the captions sound more natural, we used SOX tempo command, enabling us to change the speed without changing the pitch. 1/3 of the captions are 10% slower than the original pace, 1/3 are 10% faster. The last third of the captions was kept untouched.

• We also modified approximately 30% of the original captions and added disfluencies such as "um", "uh", "er" so that the captions would sound more natural.

• Each WAV file is paired with a JSON file containing various information: timecode of each word in the caption, name of the speaker, name of the WAV file, etc. The JSON files have the following data structure:

{
  "duration": float,
  "speaker": string,
  "synthesisedCaption": string,
  "timecode": list,
  "speed": float,
  "wavFilename": string,
  "captionID": int,
  "imgID": int,
  "disfluency": list
}

• On average, each caption comprises 10.79 tokens, disfluencies included. The WAV files are on average 3.52 seconds long.

Repository

The repository is organized as follows:

• CORPUS-MSCOCO (~75GB once decompressed)

  • train2014/ : folder contains 413,915 captions

    • json/

    • wav/

    • translations/

      • train_en_ja.txt

      • train_translate.sqlite3

    • train_2014.sqlite3

  • val2014/ : folder contains 202,520 captions

    • json/

    • wav/

    • translations/

      • train_en_ja.txt

      • train_translate.sqlite3

    • val_2014.sqlite3

  • speechcoco_API/

    • speechcoco/

      • _init_.py

      • speechcoco.py

    • setup.py

Filenames

.wav files contain the spoken version of a caption

.json files contain all the metadata of a given WAV file

.sqlite3 files are SQLite databases containing all the information contained in the JSON files

We adopted the following naming convention for both the WAV and JSON files:

imageID_captionID_Speaker_DisfluencyPosition_Speed[.wav/.json]

Script

We created a script called speechcoco.py in order to handle the metadata and allow the user to easily find captions according to specific filters. The script uses the *.db files.

Features:

• Aggregate all the information in the JSON files into a single SQLite database

• Find captions according to specific filters (name, gender and nationality of the speaker, disfluency position, speed, duration, and words in the caption). The script automatically builds the SQLite query. The user can also provide his own SQLite query.

The following Python code returns all the captions spoken by a male with an American accent for which the speed was slowed down by 10% and that contain "keys" at any position

# create SpeechCoco object
db = SpeechCoco(train_2014.sqlite3, train_translate.sqlite3, verbose=True)

# filter captions (returns Caption Objects)
captions = db.filterCaptions(gender="Male", nationality="US", speed=0.9, text='%keys%')
for caption in captions:
  print('
{}\t{}\t{}\t{}\t{}\t{}\t\t{}'.format(caption.imageID,
                         caption.captionID,
                         caption.speaker.name,
                         caption.speaker.nationality,
                         caption.speed,
                         caption.filename,
                         caption.text))

...
298817   26763  Phil  0.9   298817_26763_Phil_None_0-9.wav     A group of turkeys with bushes in the background.
108505   147972 Phil  0.9   108505_147972_Phil_Middle_0-9.wav        Person using a, um, slider cell phone with blue backlit keys.
258289   154380 Bruce  0.9   258289_154380_Bruce_None_0-9.wav        Some donkeys and sheep are in their green pens .
545312   201303 Phil  0.9   545312_201303_Phil_None_0-9.wav     A man walking next to a couple of donkeys.
...

• Find all the captions belonging to a specific image

captions = db.getImgCaptions(298817)
for caption in captions:
  print('
{}'.format(caption.text))

Birds wondering through grassy ground next to bushes.
A flock of turkeys are making their way up a hill.
Um, ah. Two wild turkeys in a field walking around.
Four wild turkeys and some bushes trees and weeds.
A group of turkeys with bushes in the background.

• Parse the timecodes and have them structured

input:

...
[1926.3068, "SYL", ""],
[1926.3068, "SEPR", " "],
[1926.3068, "WORD", "white"],
[1926.3068, "PHO", "w"],
[2050.7955, "PHO", "ai"],
[2144.6591, "PHO", "t"],
[2179.3182, "SYL", ""],
[2179.3182, "SEPR", " "]
...

output:

print(caption.timecode.parse())

...
{
'begin': 1926.3068,
'end': 2179.3182,
'syllable': [{'begin': 1926.3068,
       'end': 2179.3182,
       'phoneme': [{'begin': 1926.3068,
              'end': 2050.7955,
              'value': 'w'},
             {'begin': 2050.7955,
              'end': 2144.6591,
              'value': 'ai'},
             {'begin': 2144.6591,
              'end': 2179.3182,
              'value': 't'}],
       'value': 'wait'}],
'value': 'white'
},
...

• Convert the timecodes to Praat TextGrid files

caption.timecode.toTextgrid(outputDir, level=3)

• Get the words, syllables and phonemes between n seconds/milliseconds

The following Python code returns all the words between 0.2 and 0.6 seconds for which at least 50% of the word's total length is within the specified interval

pprint(caption.getWords(0.20, 0.60, seconds=True, level=1, olapthr=50))

...
404537   827239 Bruce  US   0.9   404537_827239_Bruce_None_0-9.wav        Eyeglasses, a cellphone, some keys and other pocket items are all laid out on the cloth. .
[
  {
    'begin': 0.0,
    'end': 0.7202778,
    'overlapPercentage': 55.53412863758955,
    'word': 'eyeglasses'
  }
]
 ...

• Get the translations of the selected captions

As for now, only japanese translations are available. We also used Kytea to tokenize and tag the captions translated with Google Translate

captions = db.getImgCaptions(298817)
for caption in captions:
  print('
{}'.format(caption.text))

  # Get translations and POS
  print('\tja_google: {}'.format(db.getTranslation(caption.captionID, "ja_google")))
  print('\t\tja_google_tokens: {}'.format(db.getTokens(caption.captionID, "ja_google")))
  print('\t\tja_google_pos: {}'.format(db.getPOS(caption.captionID, "ja_google")))
  print('\tja_excite: {}'.format(db.getTranslation(caption.captionID, "ja_excite")))

  Birds wondering through grassy ground next to bushes.
  ja_google: 鳥は茂みの下に茂った地面を抱えています。
    ja_google_tokens: 鳥 は 茂み の 下 に 茂 っ た 地面 を 抱え て い ま す 。
    ja_google_pos: 鳥/名詞/とり は/助詞/は 茂み/名詞/しげみ の/助詞/の 下/名詞/した に/助詞/に

A dataset containing 3,346 synthetically generated RGB images of road segments with cracks. Road segments and crack formations created in Blender, data collected in Microsoft AirSim. Data is split into train (~70%), test (~15%), and validation (~15%) folders. Contains ground truth bounding boxes labelling cracks in both YOLO and COCO JSON format.

TexBiG (from the German Text-Bild-Gefüge, meaning Text-Image-Structure) is a document layout analysis dataset for historical documents in the late 19th and early 20th century. The dataset provides instance segmentation (bounding boxes and polygons/masks) annotations for 19 different classes with more then 52.000 instances. Annotations are manually annotated by experts and evaluated with Krippendorff's Alpha, for each document image are least two different annotators have labeled the document. The dataset uses the common COCO-JSON format.

The dataset has been prepared for use in machine vision-based mango fruit and branch localisation for detection of fruit-branch occlusion. Images are from Honey Gold and Keitt mango varieties. The dataset contains: - 250 RGB images (200 training + 50 test images) of mango tree canopies acquired using Azure Kinect Camera under artificial lighting condition. - COCO JSON format label files with multi class (mango+branch), single classes (mango only and branch only) polygon annotations. - Labels converted to txt format to use for YOLOv8-seg + other models training. Annotation: The annotation tool - VGG Image Annotator (VIA) was used for ground truth labeling of images using polygon labelling tool.

The Dataset

A collection of images of parking lots for vehicle detection, segmentation, and counting. Each image is manually labeled with pixel-wise masks and bounding boxes localizing vehicle instances. The dataset includes about 250 images depicting several parking areas describing most of the problematic situations that we can find in a real scenario: seven different cameras capture the images under various weather conditions and viewing angles. Another challenging aspect is the presence of partial occlusion patterns in many scenes such as obstacles (trees, lampposts, other cars) and shadowed cars. The main peculiarity is that images are taken during the day and the night, showing utterly different lighting conditions.

We suggest a three-way split (train-validation-test). The train split contains images taken during the daytime while validation and test splits include images gathered at night. In line with these splits we provide some annotation files:

train_coco_annotations.json and val_coco_annotations.json --> JSON files that follow the golden standard MS COCO data format (for more info see https://cocodataset.org/#format-data) for the training and the validation splits, respectively. All the vehicles are labeled with the COCO category 'car'. They are suitable for vehicle detection and instance segmentation.

train_dot_annotations.csv and val_dot_annotations.csv --> CSV files that contain xy coordinates of the centroids of the vehicles for the training and the validation splits, respectively. Dot annotation is commonly used for the visual counting task.

ground_truth_test_counting.csv --> CSV file that contains the number of vehicles present in each image. It is only suitable for testing vehicle counting solutions.

Citing our work

If you found this dataset useful, please cite the following paper

@inproceedings{Ciampi_visapp_2021, doi = {10.5220/0010303401850195}, url = {https://doi.org/10.5220%2F0010303401850195}, year = 2021, publisher = {{SCITEPRESS} - Science and Technology Publications}, author = {Luca Ciampi and Carlos Santiago and Joao Costeira and Claudio Gennaro and Giuseppe Amato}, title = {Domain Adaptation for Traffic Density Estimation}, booktitle = {Proceedings of the 16th International Joint Conference on Computer Vision, Imaging and Computer Graphics Theory and Applications} }

and this Zenodo Dataset

@dataset{ciampi_ndispark_6560823, author = {Luca Ciampi and Carlos Santiago and Joao Costeira and Claudio Gennaro and Giuseppe Amato}, title = {{Night and Day Instance Segmented Park (NDISPark) Dataset: a Collection of Images taken by Day and by Night for Vehicle Detection, Segmentation and Counting in Parking Areas}}, month = may, year = 2022, publisher = {Zenodo}, version = {1.0.0}, doi = {10.5281/zenodo.6560823}, url = {https://doi.org/10.5281/zenodo.6560823} }

Contact Information

If you would like further information about the dataset or if you experience any issues downloading files, please contact us at luca.ciampi@isti.cnr.it

This dataset contains figure bounding boxes corresponding to the bioRxiv 10k dataset.

It provides annotations in two formats:

COCO format (JSON)

JATS XML with GROBID's "coords" attribute

The COCO format contains bounding boxes in rendered pixel units, as well as PDF user units. The latter uses field names with the "pt_" prefix.

The "coords" attribute uses the PDF user units.

The dataset was generated by using an algorithm to find the figure images within the rendered PDF pages. The main algorithm used for that purpose is SIFT. As a fallback, OpenCV's Template Matching (with multi scaling) was used. There may be some error cases in the document. Very few documents were excluded, were neither algorithm was able to find any match for one of the figure images (six documents in the train subset, two documents in the test subset).

Figure images may appear next to a figure description, but they may also appear as "attachments". The latter usually appears at the end of the document (but not always) and often on pages with dimensions different to the regular page size (but not always).

This dataset itself doesn't contain any images. The PDF to render pages can be found in the bioRxiv 10k dataset.

The dataset is intended for training or evaluation purposes of the semantic Figure extraction. The evaluation score would be calculated by comparing the extracted bounding boxes with the one from this purpose. (example implementation ScienceBeam Judge)

The dataset was created as part of eLife's ScienceBeam project.