| |
| import math |
| import re |
| from pathlib import Path |
|
|
| import ifcopenshell |
| import ifcopenshell.geom |
| import ifcopenshell.util.element |
| import ifcopenshell.util.unit |
|
|
|
|
| DESKTOP = Path("/home/user/Desktop") |
| SPEC = { |
| "required_output": "result.ifc", |
| "schema": "IFC4", |
| "counts": { |
| "IfcProject": 1, |
| "IfcSite": 1, |
| "IfcBuilding": 1, |
| "IfcBuildingStorey": 1, |
| "IfcSpace": 1, |
| "IfcWall": 4, |
| "IfcSlab": 1, |
| "IfcDoor": 1, |
| "IfcWindow": 1, |
| "IfcOpeningElement": 2, |
| "IfcWallType": 1, |
| "IfcSlabType": 1, |
| }, |
| "forbidden": { |
| "IfcBuildingElementProxy": 0, |
| "IfcFurniture": 0, |
| "IfcRoof": 0, |
| "IfcColumn": 0, |
| "IfcBeam": 0, |
| "IfcStair": 0, |
| "IfcFlowTerminal": 0, |
| }, |
| "storey_name": "00_GROUND", |
| "space_name": "AUTOMATION OFFICE", |
| "space_reference": "OFF-001", |
| "occupancy": "Office", |
| "wall_names": {"WALL-SOUTH", "WALL-EAST", "WALL-NORTH", "WALL-WEST"}, |
| "slab_name": "OFFICE FLOOR SLAB", |
| "wall_type": "OfficeWallType", |
| "slab_type": "OfficeSlabType", |
| "wall_layer_set": "OfficeWall-200mm", |
| "slab_layer_set": "OfficeSlab-200mm", |
| "automation": { |
| "TaskCode": "BONSAI-CLI-01", |
| "AutomationStatus": "CLI_UPDATED", |
| }, |
| "room_dims": (6.0, 4.0), |
| "wall_height": 3.0, |
| "wall_thickness": 0.20, |
| "slab_thickness": 0.20, |
| "tol": 0.06, |
| "thickness_tol": 0.035, |
| "min_file_bytes": 1000, |
| } |
|
|
|
|
| def finish(ok): |
| print("True" if ok else "False") |
| raise SystemExit(0) |
|
|
|
|
| def norm(value): |
| return re.sub(r"\s+", " ", str(value or "").strip()).lower() |
|
|
|
|
| def text_equal(actual, expected): |
| return norm(actual) == norm(expected) |
|
|
|
|
| def approx(actual, expected, tol): |
| return actual is not None and abs(float(actual) - float(expected)) <= float(tol) |
|
|
|
|
| def unit_scale(model): |
| try: |
| return float(ifcopenshell.util.unit.calculate_unit_scale(model)) |
| except Exception: |
| return 1.0 |
|
|
|
|
| def entity_count(model, ifc_class): |
| return len(model.by_type(ifc_class)) |
|
|
|
|
| def check_schema(model): |
| return str(getattr(model, "schema", "")).upper().startswith(SPEC["schema"]) |
|
|
|
|
| def check_counts(model): |
| for ifc_class, expected in SPEC["counts"].items(): |
| if entity_count(model, ifc_class) != expected: |
| return False |
| for ifc_class, expected in SPEC["forbidden"].items(): |
| if entity_count(model, ifc_class) != expected: |
| return False |
| return True |
|
|
|
|
| def unique_global_ids(model): |
| gids = [e.GlobalId for e in model.by_type("IfcRoot") if getattr(e, "GlobalId", None)] |
| return len(gids) == len(set(gids)) |
|
|
|
|
| def psets(entity): |
| try: |
| return ifcopenshell.util.element.get_psets(entity, should_inherit=True) |
| except Exception: |
| return {} |
|
|
|
|
| def prop(entity, name): |
| wanted = norm(name) |
| for values in psets(entity).values(): |
| for key, value in values.items(): |
| if key == "id": |
| continue |
| if norm(key) == wanted: |
| return value |
| return None |
|
|
|
|
| def has_properties(entity, expected): |
| return all(text_equal(prop(entity, key), value) for key, value in expected.items()) |
|
|
|
|
| def container(entity): |
| if entity.is_a("IfcSpace"): |
| for rel in getattr(entity, "Decomposes", None) or []: |
| parent = getattr(rel, "RelatingObject", None) |
| if parent and parent.is_a("IfcBuildingStorey"): |
| return parent |
| try: |
| return ifcopenshell.util.element.get_container(entity, should_get_direct=True) |
| except Exception: |
| return None |
|
|
|
|
| def type_of(entity): |
| try: |
| return ifcopenshell.util.element.get_type(entity) |
| except Exception: |
| return None |
|
|
|
|
| def material_of(entity): |
| try: |
| return ifcopenshell.util.element.get_material(entity, should_skip_usage=True, should_inherit=True) |
| except Exception: |
| return None |
|
|
|
|
| def material_name(material): |
| return norm(getattr(material, "Name", "")) |
|
|
|
|
| def layer_set_matches(material, expected_name, expected_layers): |
| if material is None: |
| return False |
| if material.is_a("IfcMaterialLayerSetUsage"): |
| material = material.ForLayerSet |
| if not material.is_a("IfcMaterialLayerSet"): |
| return False |
| if not text_equal(getattr(material, "LayerSetName", None) or getattr(material, "Name", None), expected_name): |
| return False |
| layers = list(getattr(material, "MaterialLayers", None) or []) |
| if len(layers) != len(expected_layers): |
| return False |
| remaining = [(norm(name), float(thickness)) for name, thickness in expected_layers] |
| for layer in layers: |
| mat = getattr(layer, "Material", None) |
| lname = material_name(mat) |
| thickness = getattr(layer, "LayerThickness", None) |
| matched = None |
| for i, (expected_mat, expected_thickness) in enumerate(remaining): |
| if expected_mat in lname and approx(thickness, expected_thickness, SPEC["thickness_tol"]): |
| matched = i |
| break |
| if matched is None: |
| return False |
| remaining.pop(matched) |
| return not remaining |
|
|
|
|
| def shape_bbox(entity): |
| settings = ifcopenshell.geom.settings() |
| try: |
| settings.set(settings.USE_WORLD_COORDS, True) |
| except Exception: |
| pass |
| shape = ifcopenshell.geom.create_shape(settings, entity) |
| verts = list(shape.geometry.verts) |
| if not verts: |
| return None |
| xs = verts[0::3] |
| ys = verts[1::3] |
| zs = verts[2::3] |
| return min(xs), min(ys), min(zs), max(xs), max(ys), max(zs) |
|
|
|
|
| def span(bbox): |
| minx, miny, minz, maxx, maxy, maxz = bbox |
| return maxx - minx, maxy - miny, maxz - minz |
|
|
|
|
| def check_geometry_preserved(model): |
| tol = SPEC["tol"] |
| space = model.by_type("IfcSpace")[0] |
| slab = model.by_type("IfcSlab")[0] |
| walls = model.by_type("IfcWall") |
| bboxes = [shape_bbox(e) for e in [space, slab] + walls] |
| if any(b is None for b in bboxes): |
| return False |
| sx, sy, _ = span(bboxes[0]) |
| if sorted(round(v, 2) for v in (sx, sy)) != sorted(round(v, 2) for v in SPEC["room_dims"]): |
| if not (approx(sorted([sx, sy])[0], min(SPEC["room_dims"]), tol) and approx(sorted([sx, sy])[1], max(SPEC["room_dims"]), tol)): |
| return False |
| if not approx(span(bboxes[1])[2], SPEC["slab_thickness"], tol): |
| return False |
| for bbox in bboxes[2:]: |
| wx, wy, wz = span(bbox) |
| if not approx(wz, SPEC["wall_height"], tol): |
| return False |
| if not approx(min(wx, wy), SPEC["wall_thickness"], SPEC["thickness_tol"]): |
| return False |
| return True |
|
|
|
|
| def check_hierarchy_and_names(model): |
| storey = model.by_type("IfcBuildingStorey")[0] |
| space = model.by_type("IfcSpace")[0] |
| slab = model.by_type("IfcSlab")[0] |
| walls = model.by_type("IfcWall") |
| products = [space, slab] + walls + model.by_type("IfcDoor") + model.by_type("IfcWindow") |
| if not text_equal(storey.Name, SPEC["storey_name"]): |
| return False |
| if not text_equal(space.Name, SPEC["space_name"]): |
| return False |
| if not text_equal(slab.Name, SPEC["slab_name"]): |
| return False |
| if {str(w.Name or "") for w in walls} != SPEC["wall_names"]: |
| return False |
| for product in products: |
| parent = container(product) |
| if parent is None or parent.id() != storey.id(): |
| return False |
| return True |
|
|
|
|
| def check_properties(model): |
| space = model.by_type("IfcSpace")[0] |
| walls = model.by_type("IfcWall") |
| if not text_equal(prop(space, "Reference"), SPEC["space_reference"]): |
| return False |
| if not text_equal(prop(space, "OccupancyType"), SPEC["occupancy"]): |
| return False |
| if not has_properties(space, SPEC["automation"]): |
| return False |
| for wall in walls: |
| if not has_properties(wall, SPEC["automation"]): |
| return False |
| return True |
|
|
|
|
| def check_types_and_materials(model): |
| walls = model.by_type("IfcWall") |
| slab = model.by_type("IfcSlab")[0] |
| wall_types = {type_of(w).id() if type_of(w) else None for w in walls} |
| if len(wall_types) != 1 or None in wall_types: |
| return False |
| wall_type = model.by_id(next(iter(wall_types))) |
| slab_type = type_of(slab) |
| if slab_type is None: |
| return False |
| if not wall_type.is_a("IfcWallType") or not text_equal(wall_type.Name, SPEC["wall_type"]): |
| return False |
| if not slab_type.is_a("IfcSlabType") or not text_equal(slab_type.Name, SPEC["slab_type"]): |
| return False |
| if not has_properties(wall_type, SPEC["automation"]) or not has_properties(slab_type, SPEC["automation"]): |
| return False |
| if not layer_set_matches( |
| material_of(wall_type), |
| SPEC["wall_layer_set"], |
| [("brick", 0.15), ("gypsum board", 0.05)], |
| ): |
| return False |
| if not layer_set_matches( |
| material_of(slab_type), |
| SPEC["slab_layer_set"], |
| [("concrete", 0.20)], |
| ): |
| return False |
| return True |
|
|
|
|
| def evaluate(): |
| ifc_path = DESKTOP / SPEC["required_output"] |
| if not ifc_path.is_file() or ifc_path.stat().st_size < SPEC["min_file_bytes"]: |
| return False |
| model = ifcopenshell.open(str(ifc_path)) |
| return ( |
| check_schema(model) |
| and unique_global_ids(model) |
| and check_counts(model) |
| and check_hierarchy_and_names(model) |
| and check_properties(model) |
| and check_types_and_materials(model) |
| and check_geometry_preserved(model) |
| ) |
|
|
|
|
| def main(): |
| try: |
| finish(evaluate()) |
| except SystemExit: |
| raise |
| except Exception: |
| finish(False) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
