Map Versioning

Merge scans of the same space captured at different times, without breaking the content layer.

Overview

MultiSet Map Versioning lets developers merge scans captured at different intervals into a single coordinate system. Unlike traditional scan merging, which relies on algorithms like ICP and weak visual features, MultiSet Map Versioning is powered by the MultiSet VPS under the hood. This means it can merge scans taken months apart, even when there are significant visual and geometric changes between them.

With Map Versions, a developer's content layer coordinates don't need to be updated when a map is updated, even if a different local coordinate system is used, MultiSet handles the transformation automatically.

How it works

A Map Version groups two or more scans of the same physical space:

• One scan is the base map, its coordinate frame is the version's coordinate frame and the one your content layer is authored against.

• Every other scan added to the version is aligned to that base by the MultiSet VPS, which computes a rigid transform (relativePose) between the two scans.

• At any time, one map in the version is active. When you query the base map, the VPS silently re-routes the query to the active map and transforms the returned pose back into the base map's coordinate frame.

Why MultiSet VPS instead of ICP?

Traditional scan-merging techniques, such as ICP (Iterative Closest Point) and matchers built on low-level geometric or visual features, work well only when the two scans look almost identical. They fail in the cases that matter most in the real world:

• Furniture rearranged, walls repainted, fixtures swapped out

• Different hardware, so different coordinate systems: LHS, RHS Y Up, RHS Z Up, etc

• Different sensor or different point density (e.g. iPhone LiDAR vs. Matterport vs. Leica)

• Different lighting conditions or season

• Months between captures, with cumulative change to the space

MultiSet Map Versioning uses the same VPS pipeline that powers MultiSet localization. Because the VPS reasons about the scene at the level of recognizable structure rather than raw geometry, it stays robust under drastic change between captures. The output is a clean rigid transform between the new scan and the base map, even when ICP would have given up.

Content layer stays put

The biggest practical benefit: your content layer never has to move.

Anchors, navigation paths, instruction overlays, and any other authored content live in the base map's coordinate frame. When you scan the space again, possibly with a different device that uses a different local coordinate system, you add the new scan as a version and activate it. MultiSet's VPS computes the transform once; from then on every query against the base map is transparently translated to the active map.

The content you authored in your app (navigation paths, AR instructions, anchors) does not need to be re-authored when you re-scan the space, even if the new scan uses a completely different local coordinate system.

Versioning an individual Map

The simplest case: a single base map, scanned again later.

1. Create a Map Version with the original map as sourceMapCode (it becomes the base) and the newer scan as targetMapCode.

2. The MultiSet VPS computes the transform between the two scans. The new map's status moves through pending → computing → ready as the job progresses.

3. Activate the newer scan with the Activate Map in Version API. From this point on, queries against the original map's code are routed to the newer scan, and the response is transformed back, so your content layer is unaffected.

4. When you scan again next quarter, add it as another version. The transform is computed against the currently active map, not against the original base, which keeps quality high as the space drifts further from the original scan over time.

See the Map Version REST API page for the full request/response shapes.

Versioning a Map that is part of a MapSet

Map Versions and MapSets compose cleanly:

• A MapSet groups maps that cover different physical areas of a venue (e.g. several floors, or several rooms).

• A Map Version groups scans that cover the same physical area at different points in time, or from different hardware.

To re-scan one map inside a MapSet, create a Map Version on that individual map. The MapSet keeps pointing at the same mapCode, the version layer transparently swaps in the newer scan. The relative pose between maps in the MapSet does not need to be re-computed, only the transform between the old and new scan of the one updated map.

You don't version the MapSet itself. You version the individual maps that compose it. This keeps each capture session isolated: re-scanning Floor 2 doesn't affect Floor 1's alignment.

Mix hardware between versions

You don't have to use the same scanning hardware for every version of a map. Add versions captured with:

• MultiSet Mapping App (iPhone / iPad with LiDAR)

• Matterport (E57 / MatterPak)

• Insta360 and other 360° cameras

• Leica, NavVis, Faro, Xgrids scanners

The VPS computes the alignment regardless of which device produced either scan. This lets you start with a quick phone capture, then upgrade to a higher-fidelity professional scan later, without losing the content layer you already built.

See Third Party Scans for supported formats and upload flows.

Lifecycle

Status	Meaning
computing	VPS is actively computing the transform between this scan and the version's source map.
ready	Transform is computed; this map can be set as active.
failed	VPS could not align this scan to the source. failureReason will be populated.

A version always has exactly one base map (its coordinate frame is the version's frame) and exactly one active map (the scan VPS queries run against). The base and active map are the same when the version is first created; activating a different map changes only the active pointer.