How to Annotate a Floor Plan for Computer Vision

Annotating a floor plan is fundamentally different from annotating training images. You’re not labelling objects for a model to learn — you’re building a spatial configuration document for a deployed system. The polygons you draw become the zones your system uses to understand where events occur, which areas to monitor, and which to ignore.

This guide covers the complete workflow: preparing the floor plan image, drawing annotations in RegionKit, and exporting coordinates for downstream use.

What you need before you start

The floor plan image — A raster image works best: a PNG or JPEG exported from a CAD tool, a scanned building plan, or a PDF converted to an image. High resolution is helpful — you want enough detail to draw accurate zone boundaries. A 2000×1500 pixel image is comfortable to work with.

Zone requirements — Know in advance which types of zones you need to draw. A typical set for a security deployment:

• Room boundaries (for event localisation)
• Camera coverage areas (field-of-view polygons for each camera)
• Monitored zones (areas where detections should trigger alerts)
• Exclusion zones (corridors visible through windows, private spaces)

Setting up layers

Before drawing anything, create a layer for each zone type in the Layers panel. Using layers separates zone types visually and makes the exported JSON easier to filter in code.

Example layer setup:

Assign a distinct colour to each layer. In RegionKit, click the colour swatch next to a layer to choose a custom colour.

Drawing room boundaries

Select the Rooms layer, activate the Polygon tool (P), and trace each room outline:

1. Click the first corner of the room
2. Click each subsequent corner
3. When you reach the last corner before the start, click near the first vertex — the snap-to-vertex indicator appears within 12 screen pixels, and the polygon closes automatically on click

For large floor plans, zoom in with the scroll wheel to place vertices precisely. Use F to fit the plan back to the window.

Handling shared walls — Two adjacent rooms share a wall. RegionKit’s shared vertex system keeps these consistent: when you draw the second room and click near an existing vertex on the first room’s polygon, the cursor snaps to it and the two polygons share that control point. Dragging the shared vertex later updates both polygons simultaneously.

Drawing camera coverage areas

Camera coverage polygons document the actual field of view of each installed camera. These are useful for:

• Verifying that all critical areas are covered
• Identifying blind spots before installation
• Including in audit and compliance documentation

Switch to the Camera Coverage layer. For each camera:

1. Draw a polygon representing its field of view — typically a wedge or trapezoid shape
2. Label it with the camera ID (e.g. CAM_01, ENTRANCE_CAM)
3. Add a tag for location (e.g. floor: 1, area: lobby)

Coverage polygons often overlap. Toggle layer visibility to check each camera’s zone independently.

Measurement tools for scale verification

If your floor plan has a known scale (e.g. 1 pixel = 5 cm), use RegionKit’s measurement tools to verify:

Distance ruler (M key) — Click two points to annotate the pixel distance between them. Compare against a known dimension on the plan.

Area measurement — Draw a polygon around a known area (e.g. a room with a stated square footage) and compare the pixel² result against the known value to derive your scale factor.

Once you have the pixel-to-real-world scale, you can apply it in downstream code to convert zone areas and distances into real-world units.

Exporting floor plan annotations

Native JSON — The most complete export. Each annotation includes:

• type — "polygon" or "rectangle"
• data.points — flat [x0, y0, x1, y1, …] array in image pixels
• label — the zone name
• layerId — the layer the annotation belongs to
• tags — any metadata tags you added
• visibility — whether the zone is currently visible

In Python:

import json

with open('floor_plan_scene.json') as f:
    scene = json.load(f)

# Build a map of layer ID to layer name
layer_map = {layer['id']: layer['name'] for layer in scene.get('layers', [])}

# Group zones by layer
zones_by_layer = {}
for ann in scene['annotations']:
    if not ann.get('visibility', True):
        continue
    layer_name = layer_map.get(ann.get('layerId', ''), 'default')
    zones_by_layer.setdefault(layer_name, []).append(ann)

for layer, anns in zones_by_layer.items():
    print(f"Layer '{layer}': {len(anns)} zone(s)")

PNG export — A flat composite of the floor plan with all zone annotations rendered. Useful for documentation, slide decks, and handover packages. Include in a report to show coverage visually.

Publish and share — Click Publish to upload the scene to a URL. Share the link for team review — no file attachment needed. Version history lets reviewers compare annotation states over time.

Tips for complex floor plans

• Multi-floor buildings — Use a separate RegionKit scene per floor. Name them consistently (e.g. Building_A_Floor_1, Building_A_Floor_2).
• Large plans with many rooms — Use the Annotations panel (right panel) to see all annotations in a list, filter by layer, and click any entry to jump the canvas to that annotation.
• Iterating on zones — Lock layers you’re not editing to prevent accidental modification. Toggle layer visibility to check for overlaps.

Related: How to Define Regions of Interest for Computer Vision · Floor Plan Annotation Tool