Mapping IFC Properties to GeoJSON Attributes with Python

# Requires: ifcopenshell>=0.8.0, pyproj>=3.0, geojson>=3.0
import ifcopenshell
import json
from typing import Any, Dict, List
from pathlib import Path


def normalize_ifc_value(val: Any) -> Any:
    """Recursively unwrap IFC EXPRESS typed wrappers to JSON-safe primitives."""
    if val is None:
        return None
    # Unwrap single-level and nested EXPRESS typed values (IfcLabel, IfcReal, etc.)
    if hasattr(val, "wrappedValue"):
        return normalize_ifc_value(val.wrappedValue)
    if isinstance(val, (str, int, float, bool)):
        return val
    # IfcPropertyEnumeratedValue returns a tuple — flatten to list
    if hasattr(val, "__iter__") and not isinstance(val, str):
        return [normalize_ifc_value(v) for v in val]
    return str(val)


def extract_properties(element) -> Dict[str, Any]:
    """
    Flatten all IfcPropertySet and IfcElementQuantity data attached to an element.
    Keys are prefixed with their parent set name to prevent cross-set collisions:
    e.g., 'Pset_WallCommon__FireRating' rather than a bare 'FireRating'.
    """
    props: Dict[str, Any] = {
        "ifc_guid": element.GlobalId,
        "ifc_type": element.is_a(),
        "ifc_name": getattr(element, "Name", None),
    }

    if not hasattr(element, "IsDefinedBy"):
        return props

    for rel in element.IsDefinedBy:
        if not rel.is_a("IfcRelDefinesByProperties"):
            continue

        pset_def = rel.RelatingPropertyDefinition
        pset_name = getattr(pset_def, "Name", "Unknown")

        if pset_def.is_a("IfcPropertySet"):
            for prop in pset_def.HasProperties:
                if prop.is_a("IfcPropertySingleValue"):
                    key = f"{pset_name}__{prop.Name}"
                    props[key] = normalize_ifc_value(prop.NominalValue)
                elif prop.is_a("IfcPropertyEnumeratedValue"):
                    key = f"{pset_name}__{prop.Name}"
                    props[key] = normalize_ifc_value(prop.EnumerationValues)

        elif pset_def.is_a("IfcElementQuantity"):
            for qty in pset_def.Quantities:
                if qty.is_a("IfcQuantityLength"):
                    props[f"QTY_{pset_name}__{qty.Name}"] = normalize_ifc_value(
                        qty.LengthValue
                    )
                elif qty.is_a("IfcQuantityArea"):
                    props[f"QTY_{pset_name}__{qty.Name}"] = normalize_ifc_value(
                        qty.AreaValue
                    )
                elif qty.is_a("IfcQuantityVolume"):
                    props[f"QTY_{pset_name}__{qty.Name}"] = normalize_ifc_value(
                        qty.VolumeValue
                    )
                elif qty.is_a("IfcQuantityCount"):
                    props[f"QTY_{pset_name}__{qty.Name}"] = normalize_ifc_value(
                        qty.CountValue
                    )

    return props


def get_element_centroid_wgs84(element, transformer) -> list | None:
    """
    Return [longitude, latitude] for the element's local placement origin,
    reprojected to EPSG:4326 via pyproj.Transformer.

    In a full pipeline, replace this stub with triangulated geometry extraction
    using ifcopenshell.geom.create_shape() or ifcopenshell.util.placement.
    """
    try:
        import ifcopenshell.util.placement
        m = ifcopenshell.util.placement.get_local_placement(element.ObjectPlacement)
        # m is a 4x4 numpy array; column 3 holds the translation vector
        local_x, local_y, local_z = float(m[0][3]), float(m[1][3]), float(m[2][3])
        lon, lat = transformer.transform(local_x, local_y)
        return [lon, lat]
    except Exception:
        return None


def build_feature_collection(
    ifc_path: str,
    source_epsg: int,
    output_path: str,
    element_types: list[str] | None = None,
) -> None:
    """
    Parse an IFC file, map properties for each spatial element,
    reproject geometry to EPSG:4326, and write a GeoJSON FeatureCollection.

    Args:
        ifc_path:     Path to the .ifc file.
        source_epsg:  EPSG code of the IFC project's coordinate system.
        output_path:  Destination .geojson file path.
        element_types: IFC entity type names to include; defaults to common types.
    """
    from pyproj import Transformer  # pyproj>=3.0

    if element_types is None:
        element_types = [
            "IfcBuildingElement",
            "IfcCivilElement",
            "IfcTransportElement",
            "IfcFacilitiesPart",
        ]

    ifc_file = ifcopenshell.open(ifc_path)
    transformer = Transformer.from_crs(
        f"EPSG:{source_epsg}", "EPSG:4326", always_xy=True
    )

    features: List[Dict] = []

    for elem_type in element_types:
        for element in ifc_file.by_type(elem_type):
            props = extract_properties(element)

            coords = None
            if hasattr(element, "ObjectPlacement") and element.ObjectPlacement:
                coords = get_element_centroid_wgs84(element, transformer)

            geometry = (
                {"type": "Point", "coordinates": coords} if coords else None
            )

            features.append(
                {
                    "type": "Feature",
                    "id": element.GlobalId,
                    "geometry": geometry,
                    "properties": props,
                }
            )

    fc = {"type": "FeatureCollection", "features": features}
    Path(output_path).write_text(
        json.dumps(fc, indent=2, ensure_ascii=False), encoding="utf-8"
    )
    print(f"Wrote {len(features)} features to {output_path}")


# --- Entry point ---
# build_feature_collection(
#     ifc_path="infrastructure_model.ifc",
#     source_epsg=27700,          # e.g. British National Grid
#     output_path="output.geojson"
# )

import ifcopenshell.util.element

def extract_properties_merged(element) -> dict:
    # Returns {pset_name: {prop_name: value, ...}, ...} merged from instance + type
    raw = ifcopenshell.util.element.get_psets(element, psets_only=False)
    flat = {"ifc_guid": element.GlobalId, "ifc_type": element.is_a()}
    for pset_name, prop_dict in raw.items():
        for prop_name, val in prop_dict.items():
            flat[f"{pset_name}__{prop_name}"] = val
    return flat

from pyproj import CRS, Transformer

source_crs = CRS.from_user_input("OSGB 1936 / British National Grid")
transformer = Transformer.from_crs(source_crs, "EPSG:4326", always_xy=True)

import ijson  # pip install ijson — for streaming large JSON; here used for output only

def stream_feature_collection(ifc_path: str, elem_types: list, transformer, out_path: str):
    ifc_file = ifcopenshell.open(ifc_path)
    with open(out_path, "w", encoding="utf-8") as f:
        f.write('{"type":"FeatureCollection","features":[\n')
        first = True
        for etype in elem_types:
            for element in ifc_file.by_type(etype):
                props = extract_properties(element)
                feature = {"type": "Feature", "id": element.GlobalId,
                           "geometry": None, "properties": props}
                if not first:
                    f.write(",\n")
                json.dump(feature, f, ensure_ascii=False)
                first = False
        f.write("\n]}")