Skip to content

Chapter 2: Topographic Identifier (TOID)#

Welcome back! In Chapter 1, we learned about the Unique Property Reference Number (UPRN) – that persistent ID for addressable locations. We saw how it helps link external data to a specific point on the map where a property exists.

But what if you're interested in the physical objects on the ground, not just their address points? Imagine your BIM model represents a building. You have its walls, roof, and floors. You might want to know about the outline of that specific building as shown on a detailed map, or find information linked directly to that shape – like planning restrictions that apply to the building's footprint, or which structural lines define it.

This is where the Topographic Identifier (TOID) becomes essential.

What is a TOID?#

Think of the TOID as a unique, permanent serial number for features you see on a map. While a UPRN identifies an addressable point, a TOID identifies a specific geographic feature itself.

Ordnance Survey (OS), the national mapping agency, assigns a TOID to things like:

  • Buildings (their footprints)
  • Roads and paths
  • Rivers, lakes, and coastlines
  • Areas of land
  • Fences, walls, and other boundary lines

Each TOID is:

  • Unique: No two features have the same TOID.
  • Persistent: Like a UPRN, once a TOID is assigned to a feature, it stays with that feature. Even if the feature changes shape slightly over time (and its geometry data is updated), its TOID will usually remain the same. If the feature is removed (e.g., a building demolished), its TOID might be marked as retired but isn't typically reused for something else.

You'll find TOIDs in many detailed OS datasets, most notably OS MasterMap products like the Topography Layer and the new OS National Geographic Database (NGD). As the OS Open TOID Overview Summary explains, TOIDs come from these detailed sources.

Why is the TOID Important for Linking Data?#

Just like UPRNs link data based on addressable location, TOIDs link data based on the physical feature's geometry.

Consider our BIM model again. Your model represents a physical structure. You want to link this model to information about the actual building outline on the ground, or regulations tied to that specific footprint.

  1. OS datasets like OS NGD – Building Feature provide the detailed geographic shape (the polygon footprint) of buildings. Crucially, each of these geometric features has a unique toid attribute.
  2. By finding the TOID associated with the building footprint that matches your BIM project's location, you get the persistent ID for that specific physical shape.
  3. You can then use this TOID to look up information in other datasets that are also linked by TOID or related to OS geometry.

Datasets that use TOIDs for linking include:

  • Other OS datasets providing different levels of detail for the same feature (e.g., OS NGD – Building Part for components of a building, or OS NGD – Building Line for walls/edges – these share the same base geometry and often the same TOID as the main building feature).
  • External datasets that have incorporated OS data or linked to OS features. For instance, heritage registers like NHLE – Historic England sometimes reference OS features, potentially using TOIDs or linking geographically.
  • The key dataset for bridging the gap: OS Open Linked Identifiers Dataset, which explicitly links TOIDs to UPRNs and other identifiers.

Using the TOID allows you to connect your BIM geometry (or any other spatial data) to external information about the specific physical object it represents, not just its address point.

How Do You "Use" a TOID?#

Using a TOID often starts with finding the feature's geometry.

  1. Find the TOID: Typically, you get the TOID from a spatial dataset that contains the feature's geometry. You load data like the OS NGD – Building Feature dataset into a GIS or data tool, find the building footprint you're interested in (e.g., by looking at its location on a map or querying near a UPRN you already have), and read its toid attribute.
    • Example Input: A building footprint polygon on a map.
    • Process: Select the polygon feature in a GIS/data tool. Read its attributes.
    • Example Output: TOID: osgb1000001234567890
  2. Use the TOID to Link: Once you have the TOID, you use it to query other datasets that contain information indexed by TOID.
    • Example Input: TOID: osgb1000001234567890
    • Process: Search a heritage dataset (if it includes TOIDs) for this ID.
    • Example Output: Information confirming this building is a Listed Building.

Let's look at the basic structure of data containing TOIDs. Datasets like OS NGD – Building Feature or OS Open TOID (as per OS Open TOID bSDD Data Dictionary and OS NGD BuildingFeature bSDD Data Dictionary) include the TOID and geometry:

| Object Class    | Property Name   | Description                      | Data Type | Unit |
|-----------------|-----------------|----------------------------------|-----------|------|
| BuildingFeature | `toid`          | Topographic Identifier           | String    | none |
| BuildingFeature | `geometry`      | Polygonal building footprint     | Geometry  | m²   |
| BuildingFeature | `description`   | Type of building                 | String    | none |
| ... (other attributes)

The key fields here are toid and geometry. You use the geometry to find the feature on the map, and then extract the toid value.

Behind the Scenes: A Simple Workflow#

How does using the TOID connect things? Here's a simplified look at finding data using a TOID:

sequenceDiagram
    participant YourSystem as Your BIM/GIS System
    participant OSFeatureData as OS Building Footprint Data
    participant ExternalData as External Heritage Data

    YourSystem->>OSFeatureData: Load building footprint data.
    YourSystem->>YourSystem: Display geometry on map. User selects a building.
    YourSystem->>OSFeatureData: Read attributes for selected building.
    OSFeatureData-->>YourSystem: Return TOID (e.g., osgb1000001234567890) and other attributes.
    YourSystem->>ExternalData: I have TOID osgb1000001234567890. Give me related records.
    ExternalData-->>YourSystem: Finds matching records by TOID.
    ExternalData->>YourSystem: Here is the heritage status for TOID osgb1000001234567890.

This diagram shows how the TOID, obtained from the geometric feature data, acts as the key to unlock related information in another dataset.

Let's look at a very simplified example of the data structure and lookup in concept.

Imagine you have a GeoPackage file (building_footprints.gpkg) containing building footprints from OS data, with a toid column. You also have a simple CSV file (heritage_status.csv) listing TOIDs and a is_listed status:

TOID,is_listed
osgb1000001234567890,True
osgb1000009876543210,False
...

In a data analysis tool (like using Python with libraries geopandas for geometry and pandas for CSV), you might do this:

# This is example conceptual code
import geopandas as gpd
import pandas as pd

# --- Step 1: Find the TOID from geometry ---

# Imagine this loads the building footprint data
# It would contain 'toid' and 'geometry' columns
building_data = gpd.read_file('building_footprints.gpkg')

# In a real tool, you'd select a feature on a map.
# Here, let's pick the first building to show the concept:
first_building_toid = building_data.iloc[0]['toid']

print(f"The TOID of the first building is: {first_building_toid}")

# --- Step 2: Use the TOID to Link ---

# Imagine this loads the heritage status data
heritage_data = pd.read_csv('heritage_status.csv')

# Find the heritage status for the specific TOID
heritage_status = heritage_data[heritage_data['TOID'] == first_building_toid]

print("\nHeritage status for this TOID:")
print(heritage_status)

This minimal example shows finding a TOID from one dataset (the building_data which has geometry) and then using that TOID to query another dataset (heritage_data) that contains information linked by TOID.

TOID vs UPRN: What's the Difference?#

It's crucial to understand the distinction between a TOID and a UPRN:

  • UPRN: Identifies an addressable location or property point. A single building might have multiple UPRNs (one for each flat, each entrance, an associated garage, etc.). A plot of land might have a UPRN if it's an addressable bare land unit.
  • TOID: Identifies a physical geographic feature. A single building footprint usually has one TOID. A road network is made up of many RoadLink and RoadNode TOIDs. A large park is one Area TOID.

A building footprint feature (with one TOID) might contain or be associated with multiple UPRN points within its boundary. Conversely, a single UPRN might relate to a property that sits on a specific land parcel with its own TOID, and whose building has its own Building Feature TOID.

This is why both identifiers are important and often used together. The OS Open Linked Identifiers Dataset is specifically designed to provide mappings between UPRNs and TOIDs, allowing you to move between the address-based world and the feature-based world.

Conclusion#

The Topographic Identifier (TOID) is your key to referencing specific physical features on the ground, as depicted in detailed mapping data. By providing a unique and persistent ID for geometric objects like building footprints, roads, and land parcels, it enables you to link information directly to the shapes you see on a map.

Understanding and using TOIDs is vital for working with detailed OS geometry and connecting it to external datasets that describe attributes or regulations tied to those specific geographic features.

While UPRNs identify addressable locations, TOIDs identify the physical features themselves. Often, you'll need to use both.

In the next chapter, we'll look at the dataset that helps bridge the gap between these two crucial identifiers: the OS Open Linked Identifiers Dataset.

Generated by AI Codebase Knowledge Builder