Datasets:

vichetkao
/

table_layout_dataset_v1

dataset_info:
  features:
    - name: image_name
      dtype: string
    - name: image
      dtype: Image
    - name: yolo_obb
      dtype: string
    - name: labelme
      dtype: string
  splits:
    - name: train
      num_bytes: 562178036
      num_examples: 8000
    - name: validation
      num_bytes: 140633367
      num_examples: 2000
  download_size: 702811403
  dataset_size: 702811403
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/train.parquet
      - split: validation
        path: data/val.parquet
license: cc-by-4.0
task_categories:
  - object-detection
  - image-classification
language:
  - km
size_categories:
  - 10K<n<100K

Table Dataset - Image & LabelMe & OBB Annotation (Train/Val Split)

Dataset Overview

Comprehensive table detection dataset with ground truth LabelMe polygon annotations and OBB (Oriented Bounding Box) data, split into training and validation sets.

Total examples: 10,000 image-annotation pairs
- Train: 8,000 (80.0%)
- Validation: 2,000 (20.0%)
Total size: 670.25 MB
Language: km
Document types: Table/Chart documents
Ground truth: LabelMe polygon annotations

Dataset Statistics

Split Information

Split	Examples	Size (MB)
Train	8,000	536.13
Validation	2,000	134.12
Total	10,000	670.25

Train/Val Ratio

Train: 80.0%
Validation: 20.0%
Random Seed: 42 (for reproducibility)

Features

Feature	Type	Description
`image_name`	string	Document image filename (without extension)
`image`	image (bytes)	PNG image binary data
`labelme`	string	LabelMe JSON annotations (polygons)
`yolo_obb`	string	OBB (Oriented Bounding Box) annotations

Data Format

Image (bytes)

PNG binary data - convert to PIL Image for processing:

from PIL import Image
from io import BytesIO

image_bytes = row['image']
image = Image.open(BytesIO(image_bytes))

LabelMe JSON (strings)

Annotations are stored as JSON strings. Parse with json.loads():

import json

labelme_dict = json.loads(row['labelme'])
# Structure: {
#   "version": "5.5.0",
#   "imagePath": "filename.png",
#   "imageHeight": <height>,
#   "imageWidth": <width>,
#   "shapes": [
#     {
#       "label": "table_element",
#       "points": [[x1, y1], [x2, y2], ...],
#       "shape_type": "polygon",
#       ...
#     }
#   ]
# }

OBB JSON (strings)

OBB annotations are stored as JSON strings:

import json

# Parse OBB content
obb_data = json.loads(row['yolo_obb'])
# Each item: {"class_id": <int>, "polygon": [x1, y1, x2, y2, ..., x8, y8]}
for obj in obb_data:
    class_id = obj['class_id']
    polygon = obj['polygon']  # 8 coordinates for oriented bounding box

Usage Examples

Load Dataset

import pandas as pd
import json
from PIL import Image
from io import BytesIO

# Load train split
df_train = pd.read_parquet('train.parquet')

# Load validation split
df_val = pd.read_parquet('val.parquet')

print(f"Train samples: {len(df_train)}")
print(f"Validation samples: {len(df_val)}")

Access Single Row

row = df_train.iloc[0]

# Get image name
image_name = row['image_name']  # str

# Get image
image_bytes = row['image']  # bytes
image = Image.open(BytesIO(image_bytes))
print(f"Image: {image.size} (width x height)")

# Get LabelMe annotations
labelme_data = json.loads(row['labelme'])
print(f"Shapes: {len(labelme_data['shapes'])}")
for shape in labelme_data['shapes']:
    points = shape['points']
    label = shape.get('label', 'unknown')
    print(f"  - {label}: {len(points)} points")

# Get OBB annotations
obb_data = json.loads(row['yolo_obb'])
print(f"OBB objects: {len(obb_data)}")
for obj in obb_data:
    print(f"  - Class {obj['class_id']}: {obj['polygon']}")

Iterate Through Dataset

import json
from PIL import Image
from io import BytesIO

# Train split
for idx, row in df_train.iterrows():
    image_name = row['image_name']
    image = Image.open(BytesIO(row['image']))

    # Get annotations
    labelme_data = json.loads(row['labelme'])
    obb_data = json.loads(row['yolo_obb'])
    num_shapes = len(labelme_data['shapes'])
    num_obb = len(obb_data)

    print(f"{image_name}: {num_shapes} LabelMe shapes, {num_obb} OBB objects")

Export Annotations as Files

import json
import os
from PIL import Image
from io import BytesIO

output_dir = 'exported_data'
os.makedirs(output_dir, exist_ok=True)

# Export train set
for idx, row in df_train.iterrows():
    image_name = row['image_name']

    # Save image
    image = Image.open(BytesIO(row['image']))
    image.save(f'{output_dir}/train_{image_name}.png')

    # Save labelme annotation
    labelme = json.loads(row['labelme'])
    with open(f'{output_dir}/train_{image_name}_labelme.json', 'w') as f:
        json.dump(labelme, f, indent=2, ensure_ascii=False)
    
    # Save OBB annotation
    obb = json.loads(row['yolo_obb'])
    with open(f'{output_dir}/train_{image_name}_obb.json', 'w') as f:
        json.dump(obb, f, indent=2, ensure_ascii=False)

# Export validation set
for idx, row in df_val.iterrows():
    image_name = row['image_name']

    # Save image
    image = Image.open(BytesIO(row['image']))
    image.save(f'{output_dir}/val_{image_name}.png')

    # Save labelme annotation
    labelme = json.loads(row['labelme'])
    with open(f'{output_dir}/val_{image_name}_labelme.json', 'w') as f:
        json.dump(labelme, f, indent=2, ensure_ascii=False)
    
    # Save OBB annotation
    obb = json.loads(row['yolo_obb'])
    with open(f'{output_dir}/val_{image_name}_obb.json', 'w') as f:
        json.dump(obb, f, indent=2, ensure_ascii=False)

Loading with Hugging Face Datasets

from datasets import load_dataset

# Load both train and validation splits
dataset = load_dataset('parquet', 
                       data_files={
                           'train': 'train.parquet',
                           'validation': 'val.parquet'
                       })

# Access splits
train_split = dataset['train']
val_split = dataset['validation']

# Iterate
for example in train_split:
    print(example.keys())

Training Loop Example

from datasets import load_dataset
import json
from PIL import Image
from io import BytesIO

dataset = load_dataset('parquet', 
                       data_files={
                           'train': 'train.parquet',
                           'validation': 'val.parquet'
                       })

# Training
for epoch in range(num_epochs):
    for batch in dataset['train'].batch(batch_size=32):
        images = [Image.open(BytesIO(img)) for img in batch['image']]
        labelme_labels = [json.loads(lm) for lm in batch['labelme']]
        obb_labels = [json.loads(obb) for obb in batch['yolo_obb']]
        # Train model...
    
    # Validation
    for batch in dataset['validation'].batch(batch_size=32):
        images = [Image.open(BytesIO(img)) for img in batch['image']]
        labelme_labels = [json.loads(lm) for lm in batch['labelme']]
        obb_labels = [json.loads(obb) for obb in batch['yolo_obb']]
        # Evaluate model...

File Summary

File	Type	Size (MB)	Samples
train.parquet	Parquet	536.13	8,000
val.parquet	Parquet	134.12	2,000

Citation

@dataset{table_dataset_obb_2026,
  title={Table Dataset - Image & LabelMe & OBB Annotations (Train/Val Split)},
  author={Dataset Creator},
  year={2026},
  note={Table detection dataset with LabelMe and OBB annotations, split into train/val}
}

License

cc-by-4.0

Contact & Support

For questions or issues with the dataset, please refer to the dataset repository.

Last Updated: 2026-05-21 Dataset Version: 1.0 Total Examples: 10,000 Total Size: 670.25 MB Train/Val Split: 80.0/20.0% Annotations: LabelMe + OBB