428 lines
16 KiB
Python
Executable File
428 lines
16 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Create a semantic IFC proof-of-concept from building_spec.json."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import math
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import showcase_schema
|
|
|
|
|
|
def parse_args() -> argparse.Namespace:
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--spec", required=True, help="Path to building_spec.json")
|
|
parser.add_argument("--out-ifc", required=True, help="Output IFC file")
|
|
parser.add_argument("--out-report", help="Output validation report JSON")
|
|
parser.add_argument("--out-notes", help="Output Markdown notes")
|
|
parser.add_argument("--vendor-dir", default="work/vendor")
|
|
parser.add_argument("--project-name", default="CAD to IFC POC")
|
|
parser.add_argument("--max-walls-per-floor", type=int, default=0, help="0 means no limit")
|
|
parser.add_argument("--max-columns-per-floor", type=int, default=0, help="0 means no limit")
|
|
parser.add_argument("--max-beams-per-floor", type=int, default=0, help="0 means no limit")
|
|
parser.add_argument("--validate-geometry", action="store_true")
|
|
return parser.parse_args()
|
|
|
|
|
|
def import_deps(vendor_dir: Path):
|
|
if vendor_dir.exists():
|
|
sys.path.insert(0, str(vendor_dir.resolve()))
|
|
try:
|
|
import numpy as np # type: ignore
|
|
import ifcopenshell # type: ignore
|
|
import ifcopenshell.api.aggregate # type: ignore
|
|
import ifcopenshell.api.context # type: ignore
|
|
import ifcopenshell.api.geometry # type: ignore
|
|
import ifcopenshell.api.project # type: ignore
|
|
import ifcopenshell.api.pset # type: ignore
|
|
import ifcopenshell.api.root # type: ignore
|
|
import ifcopenshell.api.spatial # type: ignore
|
|
import ifcopenshell.api.unit # type: ignore
|
|
except ImportError as exc:
|
|
raise SystemExit(
|
|
"Missing dependency: ifcopenshell and/or numpy. Install locally with:\n"
|
|
f" python3 -m pip install --target {vendor_dir} ifcopenshell numpy"
|
|
) from exc
|
|
return np, ifcopenshell
|
|
|
|
|
|
def placement_matrix(np, x=0.0, y=0.0, z=0.0, angle=0.0):
|
|
c = math.cos(angle)
|
|
s = math.sin(angle)
|
|
return np.array(
|
|
[
|
|
[c, -s, 0.0, x],
|
|
[s, c, 0.0, y],
|
|
[0.0, 0.0, 1.0, z],
|
|
[0.0, 0.0, 0.0, 1.0],
|
|
]
|
|
)
|
|
|
|
|
|
def make_model(np, ifcopenshell, spec: dict, project_name: str):
|
|
model = ifcopenshell.api.project.create_file(version="IFC4")
|
|
project = ifcopenshell.api.root.create_entity(model, ifc_class="IfcProject", name=project_name)
|
|
ifcopenshell.api.unit.assign_unit(model, length={"is_metric": True, "raw": "METERS"})
|
|
model_context = ifcopenshell.api.context.add_context(model, context_type="Model")
|
|
body_context = ifcopenshell.api.context.add_context(
|
|
model,
|
|
context_type="Model",
|
|
context_identifier="Body",
|
|
target_view="MODEL_VIEW",
|
|
parent=model_context,
|
|
)
|
|
site = ifcopenshell.api.root.create_entity(model, ifc_class="IfcSite", name="CAD Site")
|
|
building = ifcopenshell.api.root.create_entity(
|
|
model,
|
|
ifc_class="IfcBuilding",
|
|
name=spec.get("project", {}).get("name", "CAD Building"),
|
|
)
|
|
ifcopenshell.api.aggregate.assign_object(model, products=[site], relating_object=project)
|
|
ifcopenshell.api.aggregate.assign_object(model, products=[building], relating_object=site)
|
|
for obj in (project, site, building):
|
|
ifcopenshell.api.geometry.edit_object_placement(model, product=obj)
|
|
|
|
pset = ifcopenshell.api.pset.add_pset(model, product=project, name="CAD2BIM_Project")
|
|
ifcopenshell.api.pset.edit_pset(
|
|
model,
|
|
pset=pset,
|
|
properties={
|
|
"Source": json.dumps(spec.get("source", {}), ensure_ascii=False)[:1200],
|
|
"Method": "CAD/DXF -> building_spec.json -> IfcOpenShell",
|
|
"Purpose": "BIM replacement feasibility proof",
|
|
},
|
|
)
|
|
return model, body_context, building
|
|
|
|
|
|
def add_storey(np, ifcopenshell, model, building, floor_key: str, floor: dict):
|
|
storey = ifcopenshell.api.root.create_entity(
|
|
model,
|
|
ifc_class="IfcBuildingStorey",
|
|
name=floor.get("name", floor_key),
|
|
)
|
|
storey.Elevation = float(floor.get("z", 0.0))
|
|
ifcopenshell.api.aggregate.assign_object(model, products=[storey], relating_object=building)
|
|
ifcopenshell.api.geometry.edit_object_placement(
|
|
model,
|
|
product=storey,
|
|
matrix=placement_matrix(np, z=float(floor.get("z", 0.0))),
|
|
)
|
|
return storey
|
|
|
|
|
|
def segment_length(segment: dict) -> float:
|
|
sx, sy = segment["start"]
|
|
ex, ey = segment["end"]
|
|
return math.hypot(ex - sx, ey - sy)
|
|
|
|
|
|
def add_cad_pset(
|
|
ifcopenshell,
|
|
model,
|
|
element,
|
|
floor_key: str,
|
|
category: str,
|
|
segment: dict | None = None,
|
|
source_index: int | None = None,
|
|
):
|
|
pset = ifcopenshell.api.pset.add_pset(model, product=element, name="CAD2BIM_Source")
|
|
props = {
|
|
"FloorKey": floor_key,
|
|
"Category": category,
|
|
"GeneratedFrom": "building_spec.json",
|
|
}
|
|
if segment:
|
|
props.update(
|
|
{
|
|
"SourceLayer": segment.get("layer", ""),
|
|
"SourceType": segment.get("source_type", ""),
|
|
"SourceIndex": int(source_index or 0),
|
|
"LengthMeters": round(segment_length(segment), 4),
|
|
}
|
|
)
|
|
ifcopenshell.api.pset.edit_pset(model, pset=pset, properties=props)
|
|
|
|
|
|
def add_slab(np, ifcopenshell, model, body_context, storey, floor_key: str, floor: dict):
|
|
min_x, min_y, max_x, max_y = floor["bounds"]
|
|
margin = float(floor.get("slab_margin", 1.2))
|
|
thickness = float(floor.get("slab_thickness", 0.25))
|
|
min_x -= margin
|
|
min_y -= margin
|
|
max_x += margin
|
|
max_y += margin
|
|
width = max_x - min_x
|
|
depth = max_y - min_y
|
|
polyline = [(0.0, 0.0), (width, 0.0), (width, depth), (0.0, depth), (0.0, 0.0)]
|
|
slab = ifcopenshell.api.root.create_entity(
|
|
model,
|
|
ifc_class="IfcSlab",
|
|
predefined_type="FLOOR",
|
|
name=f"{floor_key} Slab",
|
|
)
|
|
representation = ifcopenshell.api.geometry.add_slab_representation(
|
|
model,
|
|
context=body_context,
|
|
depth=thickness,
|
|
direction_sense="POSITIVE",
|
|
polyline=polyline,
|
|
)
|
|
ifcopenshell.api.geometry.assign_representation(model, product=slab, representation=representation)
|
|
ifcopenshell.api.geometry.edit_object_placement(
|
|
model,
|
|
product=slab,
|
|
matrix=placement_matrix(np, min_x, min_y, -thickness),
|
|
)
|
|
ifcopenshell.api.spatial.assign_container(model, products=[slab], relating_structure=storey)
|
|
add_cad_pset(ifcopenshell, model, slab, floor_key, "slab")
|
|
return slab
|
|
|
|
|
|
def add_segment_element(
|
|
ifcopenshell,
|
|
model,
|
|
body_context,
|
|
storey,
|
|
floor_key: str,
|
|
floor: dict,
|
|
category: str,
|
|
segment: dict,
|
|
source_index: int,
|
|
):
|
|
length = segment_length(segment)
|
|
if length < 0.05:
|
|
return None
|
|
floor_height = float(floor.get("height", 4.2))
|
|
if category == "walls":
|
|
ifc_class = "IfcWall"
|
|
name = f"{floor_key} Wall {source_index:04d}"
|
|
height = max(0.5, floor_height - 0.1)
|
|
elevation = 0.0
|
|
thickness = max(0.08, min(0.45, float(segment.get("width", 0.20))))
|
|
elif category == "columns":
|
|
ifc_class = "IfcColumn"
|
|
name = f"{floor_key} Column {source_index:04d}"
|
|
height = max(0.5, floor_height)
|
|
elevation = 0.0
|
|
thickness = max(0.10, min(0.60, float(segment.get("width", 0.30))))
|
|
elif category == "beams":
|
|
ifc_class = "IfcBeam"
|
|
name = f"{floor_key} Beam {source_index:04d}"
|
|
height = min(0.65, max(0.25, floor_height * 0.10))
|
|
elevation = max(0.0, floor_height - height)
|
|
thickness = max(0.08, min(0.60, float(segment.get("width", 0.25))))
|
|
else:
|
|
return None
|
|
|
|
sx, sy = segment["start"]
|
|
ex, ey = segment["end"]
|
|
element = ifcopenshell.api.root.create_entity(model, ifc_class=ifc_class, name=name)
|
|
representation = ifcopenshell.api.geometry.create_2pt_wall(
|
|
model,
|
|
element=element,
|
|
context=body_context,
|
|
p1=(sx, sy),
|
|
p2=(ex, ey),
|
|
elevation=elevation,
|
|
height=height,
|
|
thickness=thickness,
|
|
is_si=True,
|
|
)
|
|
ifcopenshell.api.geometry.assign_representation(model, product=element, representation=representation)
|
|
ifcopenshell.api.spatial.assign_container(model, products=[element], relating_structure=storey)
|
|
add_cad_pset(ifcopenshell, model, element, floor_key, category, segment=segment, source_index=source_index)
|
|
return element
|
|
|
|
|
|
def select_segments(segments: list[dict], limit: int) -> list[tuple[int, dict]]:
|
|
if limit <= 0 or len(segments) <= limit:
|
|
return list(enumerate(segments, start=1))
|
|
step = len(segments) / limit
|
|
result = []
|
|
used: set[int] = set()
|
|
for i in range(limit):
|
|
idx = min(len(segments) - 1, int(i * step))
|
|
if idx in used:
|
|
continue
|
|
used.add(idx)
|
|
result.append((idx + 1, segments[idx]))
|
|
return result
|
|
|
|
|
|
def validate_ifc(ifcopenshell, path: Path, validate_geometry: bool) -> dict:
|
|
model = ifcopenshell.open(str(path))
|
|
counts = {
|
|
"IfcProject": len(model.by_type("IfcProject")),
|
|
"IfcSite": len(model.by_type("IfcSite")),
|
|
"IfcBuilding": len(model.by_type("IfcBuilding")),
|
|
"IfcBuildingStorey": len(model.by_type("IfcBuildingStorey")),
|
|
"IfcSlab": len(model.by_type("IfcSlab")),
|
|
"IfcWall": len(model.by_type("IfcWall")),
|
|
"IfcColumn": len(model.by_type("IfcColumn")),
|
|
"IfcBeam": len(model.by_type("IfcBeam")),
|
|
"IfcRelContainedInSpatialStructure": len(model.by_type("IfcRelContainedInSpatialStructure")),
|
|
"IfcPropertySet": len(model.by_type("IfcPropertySet")),
|
|
"IfcExtrudedAreaSolid": len(model.by_type("IfcExtrudedAreaSolid")),
|
|
}
|
|
storeys = []
|
|
for storey in model.by_type("IfcBuildingStorey"):
|
|
contained = []
|
|
for rel in storey.ContainsElements or []:
|
|
contained.extend(rel.RelatedElements or [])
|
|
storeys.append(
|
|
{
|
|
"name": storey.Name,
|
|
"elevation": storey.Elevation,
|
|
"contained_count": len(contained),
|
|
"contained_types": {
|
|
ifc_type: len([e for e in contained if e.is_a(ifc_type)])
|
|
for ifc_type in ("IfcSlab", "IfcWall", "IfcColumn", "IfcBeam")
|
|
},
|
|
}
|
|
)
|
|
|
|
geometry_failures = []
|
|
if validate_geometry:
|
|
import ifcopenshell.geom as geom # type: ignore
|
|
|
|
settings = geom.settings()
|
|
settings.set(settings.USE_WORLD_COORDS, True)
|
|
for ifc_type in ("IfcSlab", "IfcWall", "IfcColumn", "IfcBeam"):
|
|
for element in model.by_type(ifc_type):
|
|
try:
|
|
geom.create_shape(settings, element)
|
|
except Exception as exc:
|
|
geometry_failures.append({"ifc_type": ifc_type, "name": element.Name, "error": str(exc)})
|
|
|
|
return {
|
|
"ifc_path": str(path),
|
|
"schema": model.schema,
|
|
"entity_counts": counts,
|
|
"storeys": storeys,
|
|
"geometry_validation": {
|
|
"enabled": validate_geometry,
|
|
"failure_count": len(geometry_failures),
|
|
"failures": geometry_failures[:50],
|
|
},
|
|
"file_size_bytes": path.stat().st_size,
|
|
}
|
|
|
|
|
|
def make_notes(report: dict) -> str:
|
|
counts = report["entity_counts"]
|
|
lines = [
|
|
"# IFC BIM Proof Notes",
|
|
"",
|
|
"This IFC is a feasibility proof generated from CAD-derived linework. It contains semantic IFC entities, but it is not automatically a production BIM replacement.",
|
|
"",
|
|
"## IFC Output",
|
|
"",
|
|
f"- File: `{report['ifc_path']}`",
|
|
f"- Schema: `{report['schema']}`",
|
|
f"- Size: `{report['file_size_bytes']}` bytes",
|
|
"",
|
|
"## Entity Counts",
|
|
"",
|
|
]
|
|
for key in (
|
|
"IfcBuildingStorey",
|
|
"IfcSlab",
|
|
"IfcWall",
|
|
"IfcColumn",
|
|
"IfcBeam",
|
|
"IfcPropertySet",
|
|
"IfcExtrudedAreaSolid",
|
|
):
|
|
lines.append(f"- `{key}`: {counts.get(key, 0)}")
|
|
lines.extend(["", "## Storey Containment", ""])
|
|
for storey in report["storeys"]:
|
|
lines.append(f"- `{storey['name']}` at elevation `{storey['elevation']}`: {storey['contained_count']} elements")
|
|
for key, value in storey["contained_types"].items():
|
|
lines.append(f" - `{key}`: {value}")
|
|
gv = report["geometry_validation"]
|
|
lines.extend(
|
|
[
|
|
"",
|
|
"## Geometry Validation",
|
|
"",
|
|
f"- Enabled: `{gv['enabled']}`",
|
|
f"- Failures: `{gv['failure_count']}`",
|
|
"",
|
|
"## BIM Replacement Gaps",
|
|
"",
|
|
"- Add/validate openings, doors, windows, rooms/spaces, materials, quantities, classifications, georeferencing, discipline coordination, and object naming before calling this a BIM replacement.",
|
|
]
|
|
)
|
|
return "\n".join(lines)
|
|
|
|
|
|
def main() -> int:
|
|
args = parse_args()
|
|
np, ifcopenshell = import_deps(Path(args.vendor_dir))
|
|
spec = showcase_schema.normalize_spec(json.loads(Path(args.spec).read_text(encoding="utf-8")))
|
|
try:
|
|
showcase_schema.validate_spec(spec)
|
|
except showcase_schema.ValidationFailure as exc:
|
|
raise SystemExit(str(exc)) from exc
|
|
model, body_context, building = make_model(np, ifcopenshell, spec, args.project_name)
|
|
created = {"IfcSlab": 0, "IfcWall": 0, "IfcColumn": 0, "IfcBeam": 0}
|
|
limits = {
|
|
"walls": args.max_walls_per_floor,
|
|
"columns": args.max_columns_per_floor,
|
|
"beams": args.max_beams_per_floor,
|
|
}
|
|
source_counts = {}
|
|
|
|
for floor_key, floor in spec.get("floors", {}).items():
|
|
storey = add_storey(np, ifcopenshell, model, building, floor_key, floor)
|
|
add_slab(np, ifcopenshell, model, body_context, storey, floor_key, floor)
|
|
created["IfcSlab"] += 1
|
|
source_counts[floor_key] = {}
|
|
for category in ("walls", "columns", "beams"):
|
|
segments = floor.get("segments", {}).get(category, [])
|
|
source_counts[floor_key][category] = len(segments)
|
|
for source_index, segment in select_segments(segments, limits[category]):
|
|
element = add_segment_element(
|
|
ifcopenshell,
|
|
model,
|
|
body_context,
|
|
storey,
|
|
floor_key,
|
|
floor,
|
|
category,
|
|
segment,
|
|
source_index,
|
|
)
|
|
if element:
|
|
created[element.is_a()] += 1
|
|
|
|
out_ifc = Path(args.out_ifc)
|
|
out_ifc.parent.mkdir(parents=True, exist_ok=True)
|
|
model.write(str(out_ifc))
|
|
report = validate_ifc(ifcopenshell, out_ifc, args.validate_geometry)
|
|
report["created_from_script"] = created
|
|
report["source_segment_counts"] = source_counts
|
|
report["limits_per_floor"] = limits
|
|
|
|
out_report = Path(args.out_report) if args.out_report else out_ifc.with_suffix(".report.json")
|
|
out_notes = Path(args.out_notes) if args.out_notes else out_ifc.with_suffix(".notes.md")
|
|
out_report.parent.mkdir(parents=True, exist_ok=True)
|
|
out_notes.parent.mkdir(parents=True, exist_ok=True)
|
|
out_report.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
|
|
out_notes.write_text(make_notes(report), encoding="utf-8")
|
|
print(
|
|
json.dumps(
|
|
{"ifc": str(out_ifc), "report": str(out_report), "notes": str(out_notes), "created": created},
|
|
ensure_ascii=False,
|
|
)
|
|
)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|