Indoor Maps and BIM¶

python ifc_rooms_to_geojson.py model.ifc rooms.geojson

"""Export an IFC model's rooms (IfcSpace) as GeoJSON floor plans with a level field.

Usage: python ifc_rooms_to_geojson.py model.ifc rooms.geojson
"""
import json
import math
import sys

import ifcopenshell
import ifcopenshell.geom
import ifcopenshell.util.element
import ifcopenshell.util.placement
import ifcopenshell.util.unit
from shapely.geometry import MultiPolygon, Polygon, mapping
from shapely.ops import unary_union


def dms(angle):
    """IFC compound angle (deg, min, sec, millionths) to decimal degrees."""
    sign = -1 if any(v < 0 for v in angle) else 1
    d, m, s, *rest = (abs(v) for v in angle)
    return sign * (d + m / 60 + (s + (rest[0] if rest else 0) / 1e6) / 3600)


def storey_of(space):
    """The storey a room belongs to, through any rooms it is nested in."""
    node = space
    while node is not None:
        # Rooms are usually aggregated into their storey (IfcRelAggregates),
        # sometimes contained in it (IfcRelContainedInSpatialStructure), and
        # sometimes nested in a larger room.
        parent = ifcopenshell.util.element.get_aggregate(node) or ifcopenshell.util.element.get_container(node)
        if parent is None or parent.is_a("IfcBuildingStorey"):
            return parent
        node = parent if parent.is_a("IfcSpace") else None
    return None


def placement_origin(element):
    """The origin of an element's placement, in project units."""
    if not element.ObjectPlacement:
        return (0.0, 0.0, 0.0)
    matrix = ifcopenshell.util.placement.get_local_placement(element.ObjectPlacement)
    return (matrix[0][3], matrix[1][3], matrix[2][3])


def to_lnglat(geom, origin):
    """Shapely geometry in metres east/north of the site origin to lon/lat."""
    lon0, lat0, m_per_deg_lon, m_per_deg_lat = origin

    def ring(coords):
        return [(lon0 + x / m_per_deg_lon, lat0 + y / m_per_deg_lat) for x, y in coords]

    polys = geom.geoms if isinstance(geom, MultiPolygon) else [geom]
    out = [Polygon(ring(p.exterior.coords), [ring(r.coords) for r in p.interiors]) for p in polys]
    return out[0] if len(out) == 1 else MultiPolygon(out)


def main(src, dst):
    model = ifcopenshell.open(src)
    site = model.by_type("IfcSite")[0]
    if site.RefLatitude is None or site.RefLongitude is None:
        sys.exit("The IfcSite has no RefLatitude/RefLongitude, so the model cannot be placed on the map.")
    lat0, lon0 = dms(site.RefLatitude), dms(site.RefLongitude)
    # Metres east/north to degrees, around the site's reference point.
    origin = (lon0, lat0, 111_319.488 * math.cos(math.radians(lat0)), 111_132.954)
    # The geometry comes in metres from the project origin, but the reference
    # latitude/longitude locate the site's own placement, so measure from that.
    scale = ifcopenshell.util.unit.calculate_unit_scale(model)
    site_x, site_y, _ = (v * scale for v in placement_origin(site))

    # Lowest storey first; a storey with no Elevation is placed by its placement.
    storeys = sorted(
        model.by_type("IfcBuildingStorey"),
        key=lambda s: s.Elevation if s.Elevation is not None else placement_origin(s)[2],
    )
    level_of = {storey.id(): index for index, storey in enumerate(storeys)}
    settings = ifcopenshell.geom.settings()
    settings.set("use-world-coords", True)

    features = []
    for space in model.by_type("IfcSpace"):
        try:
            shape = ifcopenshell.geom.create_shape(settings, space)
        except RuntimeError:
            continue  # a room with no usable geometry
        verts = shape.geometry.verts
        faces = shape.geometry.faces
        triangles = []
        for i in range(0, len(faces), 3):
            pts = [(verts[3 * j] - site_x, verts[3 * j + 1] - site_y) for j in faces[i : i + 3]]
            tri = Polygon(pts)
            if tri.area > 1e-6:
                triangles.append(tri)
        if not triangles:
            continue
        footprint = unary_union(triangles).buffer(0)
        storey = storey_of(space)
        features.append({
            "type": "Feature",
            "properties": {
                "name": space.LongName or space.Name,
                "number": space.Name,
                "storey": storey.Name if storey else None,
                "level": level_of.get(storey.id()) if storey else None,
                "elevation": storey.Elevation if storey else None,
                "global_id": space.GlobalId,
            },
            "geometry": mapping(to_lnglat(footprint, origin)),
        })
    with open(dst, "w") as out:
        json.dump({"type": "FeatureCollection", "features": features}, out)
    print(f"{len(features)} rooms on {len(storeys)} storeys -> {dst}")


if __name__ == "__main__":
    main(sys.argv[1], sys.argv[2])