CataNET-Meridian-v1.0-Small

A YOLO26-Small pose model that detects the hexagonal terrain tiles on a physical Settlers of Catan board and localizes each tile's 6 corner vertices from a photo — the first stage of the CataNET pipeline, which reconstructs a full structured board state (terrain, resource tokens, roads, settlements, cities) from a single image.

This is the flagship pose model in the CataNET-Meridian family — it's the variant actually wired into the production inference pipeline, in exchange for slightly slower inference than CataNET-Meridian-v1.0-Nano.

Table of Contents

• Model Details
• Uses
• Limitations
• Training Details
• Evaluation
• How to Get Started with the Model
• Citation
• Model Card Contact

Model Details

Model Description

CataNET-Meridian-v1.0-Small is a single-class, 6-keypoint pose estimation model fine-tuned from Ultralytics YOLO26 (small). Given an image patch containing one or more hex tiles, it outputs a bounding box and 6 ordered keypoints (the tile's corners, clockwise from the top) per detected terrain_hex instance.

This model only localizes hex geometry — it does not classify terrain type, resource number, or player pieces. That's handled downstream by the companion CataNET-Terrain (MobileNetV3) and Lynx MicroCNN (piece color) classifiers in the full CataNET pipeline.

• Developed by: nithinmanoj10
• Model type: Keypoint / pose estimation (single class, 6 keypoints per instance)
• License: MIT
• Finetuned from model: Ultralytics/YOLO26 (small variant, yolo26s-pose)

Uses

Direct Use

The model expects a roughly-square image patch at (or resized to) 640×640 where hex tiles occupy a similar visual scale to training data — see Limitations below, this matters more than it sounds. Direct output is per-instance boxes + 6 keypoints; see How to Get Started for a minimal example.

Downstream Use

For a full board photo (which is much larger than 640×640 and where hexes are far smaller relative to the frame than a single patch), this model is meant to be used inside a sliding-window pipeline: tile the image into overlapping physical crops sized proportionally to the photo's resolution, run this model per tile, then merge detections across tiles (NMS + vertex clustering) into a single reconstructed board graph. A reference implementation of this full pipeline (tiling → NMS → vertex merging → homography → patch extraction → downstream classification) is maintained alongside this model's training code.

Out-of-Scope Use

• Not intended for board layouts other than the standard 19-hex Settlers of Catan base game board.
• Not a general-purpose hexagon or board-game detector — it was trained exclusively on Catan tile imagery (synthetic) and has not been evaluated on other games or generic hexagonal objects.
• Does not detect or classify pieces (settlements, cities, roads, robber) or tile contents (terrain type, resource number) — see the companion models above for those.

Limitations

• Input scale is critical, and easy to get wrong. This is the single most impactful practical finding from evaluating this model on real photos: feeding it a literal 640×640-pixel native crop of a real photo (i.e., physically cropping a small 640px square directly from a high-resolution image) performs far worse than feeding it a larger physical crop (proportional to the source photo's resolution) that Ultralytics then internally resizes down to 640. The model was trained on synthetic images where the whole board is in frame; a native-resolution 640px crop of a real photo is effectively far more "zoomed in" than anything seen in training, and detection quality degrades sharply as a result. If you're getting no/poor detections on a real photo, check your input scale before assuming the model is broken.
• Box localization is excellent; exact keypoint (vertex) localization is the weaker link. In evaluation, Box mAP is near-perfect (0.96-0.997) while Pose mAP (OKS-based) sits around 0.61 — the model reliably finds that a hex is there, but is less precise about the exact sub-pixel position of its corners. Downstream consumers should expect on the order of ~100px of per-vertex error on a 2000×2000-resolution input (see Evaluation) and should not assume pixel-perfect keypoints.
• Trained entirely on synthetic data. No real photographs were used in training (see Training Data). It generalizes to real photos reasonably well in practice (per the evaluation below), but a sim-to-real gap should be assumed, especially under unusual lighting, extreme viewing angles, or partial occlusion.

Training Details

Training Data

Trained exclusively on nithinmanoj10/CatanSynth-Meridian-v1-50K — 50,000 procedurally-generated synthetic Catan board images (40,000 train / 5,000 validation / 5,000 test), rendered by a custom synthetic data engine that composites terrain/token/road/settlement/city/robber assets over randomized table backgrounds with camera-style augmentation (lighting, perspective, blur, noise). Labels follow the standard YOLO pose format: 1 class (terrain_hex), 6 keypoints per instance (kpt_shape: [6, 3]), ordered clockwise from the tile's top vertex.

Training Procedure

Fine-tuned from the yolo26s-pose architecture using Ultralytics' training loop, with hyperparameters tuned specifically for this task's geometry:

Setting	Value
Base architecture	yolo26s-pose.yaml (small)
Epochs	150 (early stopping patience: 30)
Image size	640×640
Batch size	32
Optimizer	MuSGD, lr0=0.01, cosine LR schedule
Loss weights	pose: 20.0, box: 5.0, cls: 0.5
Mosaic augmentation	disabled for the final 20 epochs (close_mosaic=20)
Geometric augmentation	rotation disabled, no vertical/horizontal flip, minor translate (0.1) and scale (0.2) jitter only
Mixed precision (AMP)	disabled

Rotation and flip augmentations were deliberately minimized/disabled — since keypoint order is geometrically meaningful (clockwise from a canonical top vertex), aggressive augmentation risks corrupting that ordering rather than just adding beneficial variance. Exported to ONNX (imgsz=640) after training for deployment alongside the native PyTorch checkpoint.

Evaluation

Testing Data

Evaluated on 12 hand-selected real (non-synthetic) Catan board photographs, sliced into physically-large tiles and manually keypoint-labeled in Roboflow — 120 terrain_hex instances total, ground truth verified against the raw images. See CatanNET-Meridian-Val-1.0 (linked in this card's metadata) for the labeled evaluation set.

Metrics

• Box mAP@0.5 and Box mAP@0.5:0.95 — standard COCO-style detection metrics (via pycocotools), measuring how well predicted boxes localize each hex tile.
• Pose mAP@0.5 (OKS) — COCO-style keypoint mAP using Object Keypoint Similarity. No calibrated per-keypoint sigma exists for this custom 6-point hex skeleton (COCO's own sigmas are for human pose joints), so a flat σ=0.05 was used uniformly across all 6 points.
• Vertex RMSE (px) — a custom metric: ground-truth and predicted instances are matched by bounding-box IoU per image, then the root-mean-squared Euclidean pixel distance is computed over all matched, labeled keypoints. Reported in raw pixels on 2000×2000-resolution input images.

Results

Metric	Value
Box mAP@0.5	0.997
Box mAP@0.5:0.95	0.962
Pose mAP@0.5 (OKS, σ=0.05 assumed)	0.610
Vertex RMSE (px, 2000×2000 input)	102.7

Summary

Detection (finding hex tiles) is essentially solved on this real-photo test set. Precise vertex localization is meaningfully weaker than detection, consistent with what's typically the harder sub-problem in pose estimation. Performance is nearly identical to the Nano variant on this evaluation set, with a marginal edge in Pose mAP; the practical case for Small over Nano is that it's the variant validated end-to-end in the production pipeline, not a large accuracy gap on this sample. N=12 images / 120 instances, selected for clean/unoccluded detections rather than drawn at random — sufficient to characterize behavior, not a large-scale benchmark. Performance on heavily occluded, poorly lit, or extreme-angle photos has not been separately evaluated.

How to Get Started with the Model

from huggingface_hub import hf_hub_download
from ultralytics import YOLO
import cv2

weights_path = hf_hub_download(
    repo_id="nithinmanoj10/CataNET-Meridian-v1.0-Small",
    filename="best.pt",
)
model = YOLO(weights_path)

img = cv2.imread("hex_patch.jpg")  # see Limitations: use a large enough physical crop, not a tight 640px one
results = model(img, imgsz=640, conf=0.5)[0]

boxes = results.boxes.xyxy       # (N, 4)
keypoints = results.keypoints.data  # (N, 6, 3) -- x, y, confidence per corner

For full board reconstruction from a real photo (tiling, multi-hex NMS, vertex merging, and downstream terrain/token/piece classification), see the CataNET inference pipeline maintained alongside this model's training code.

Citation

No formal paper accompanies this model. If referencing it, please cite the repository directly:

@misc{catanet-meridian-small,
  author = {nithinmanoj10},
  title = {CataNET-Meridian-v1.0-Small},
  year = {2026},
  publisher = {Hugging Face},
  howpublished = {\url{https://huggingface.co/nithinmanoj10/CataNET-Meridian-v1.0-Small}}
}

Model Card Contact

nithinmanoj10 via Hugging Face.