# This file was generated with the assistance of an AI coding tool.

import os

import subprocess

import sys

import tempfile

import ifcopenshell

import ifcopenshell.api.aggregate

import ifcopenshell.api.context

import ifcopenshell.api.geometry

import ifcopenshell.api.owner.settings

import ifcopenshell.api.project

import ifcopenshell.api.root

import ifcopenshell.api.spatial

import ifcopenshell.api.unit

import ifcopenshell.guid

import numpy as np

import pytest

from ifcquery.render import _make_profile_occurrence, _make_type_occurrence, render

try:

import pyvista # noqa: F401

HAS_PYVISTA = True

except ImportError:

HAS_PYVISTA = False

pytestmark = pytest.mark.skipif(not HAS_PYVISTA, reason="pyvista not installed")

PNG_MAGIC = b"\x89PNG"

@pytest.fixture

def model_with_geometry():

"""Create an IFC4 model with walls that have geometric representations."""

f = ifcopenshell.api.project.create_file()

ifcopenshell.api.owner.settings.get_user = lambda ifc: (ifc.by_type("IfcPersonAndOrganization") or [None])[0]

ifcopenshell.api.owner.settings.get_application = lambda ifc: (ifc.by_type("IfcApplication") or [None])[0]

project = ifcopenshell.api.root.create_entity(f, ifc_class="IfcProject", name="TestProject")

ifcopenshell.api.unit.assign_unit(f)

site = ifcopenshell.api.root.create_entity(f, ifc_class="IfcSite", name="TestSite")

building = ifcopenshell.api.root.create_entity(f, ifc_class="IfcBuilding", name="TestBuilding")

storey = ifcopenshell.api.root.create_entity(f, ifc_class="IfcBuildingStorey", name="Ground Floor")

ifcopenshell.api.aggregate.assign_object(f, products=[site], relating_object=project)

ifcopenshell.api.aggregate.assign_object(f, products=[building], relating_object=site)

ifcopenshell.api.aggregate.assign_object(f, products=[storey], relating_object=building)

model_ctx = ifcopenshell.api.context.add_context(f, context_type="Model")

body = ifcopenshell.api.context.add_context(

f, context_type="Model", context_identifier="Body", target_view="MODEL_VIEW", parent=model_ctx

)

wall1 = ifcopenshell.api.root.create_entity(f, ifc_class="IfcWall", name="Wall001")

rep1 = ifcopenshell.api.geometry.add_wall_representation(f, context=body, length=5, height=3, thickness=0.2)

ifcopenshell.api.geometry.assign_representation(f, product=wall1, representation=rep1)

ifcopenshell.api.spatial.assign_container(f, products=[wall1], relating_structure=storey)

wall2 = ifcopenshell.api.root.create_entity(f, ifc_class="IfcWall", name="Wall002")

rep2 = ifcopenshell.api.geometry.add_wall_representation(f, context=body, length=4, height=3, thickness=0.2)

ifcopenshell.api.geometry.assign_representation(f, product=wall2, representation=rep2)

ifcopenshell.api.spatial.assign_container(f, products=[wall2], relating_structure=storey)

matrix2 = np.eye(4)

matrix2[1, 3] = 3.0

ifcopenshell.api.geometry.edit_object_placement(f, product=wall2, matrix=matrix2)

return f

@pytest.fixture

def library_with_type():

"""IFC4 library file: a WallType with a RepresentationMap but no instances."""

f = ifcopenshell.api.project.create_file()

ifcopenshell.api.owner.settings.get_user = lambda ifc: (ifc.by_type("IfcPersonAndOrganization") or [None])[0]

ifcopenshell.api.owner.settings.get_application = lambda ifc: (ifc.by_type("IfcApplication") or [None])[0]

project = ifcopenshell.api.root.create_entity(f, ifc_class="IfcProject", name="LibProject")

ifcopenshell.api.unit.assign_unit(f)

model_ctx = ifcopenshell.api.context.add_context(f, context_type="Model")

body = ifcopenshell.api.context.add_context(

f, context_type="Model", context_identifier="Body", target_view="MODEL_VIEW", parent=model_ctx

)

# Build the shape representation and wrap it in an IfcRepresentationMap.

shape_rep = ifcopenshell.api.geometry.add_wall_representation(f, context=body, length=3, height=2.5, thickness=0.2)

origin = f.create_entity("IfcCartesianPoint", Coordinates=(0.0, 0.0, 0.0))

z_dir = f.create_entity("IfcDirection", DirectionRatios=(0.0, 0.0, 1.0))

x_dir = f.create_entity("IfcDirection", DirectionRatios=(1.0, 0.0, 0.0))

map_origin = f.create_entity("IfcAxis2Placement3D", Location=origin, Axis=z_dir, RefDirection=x_dir)

rep_map = f.create_entity("IfcRepresentationMap", MappingOrigin=map_origin, MappedRepresentation=shape_rep)

wall_type = ifcopenshell.api.root.create_entity(f, ifc_class="IfcWallType", name="LibWallType")

wall_type.RepresentationMaps = [rep_map]

return f, wall_type

@pytest.fixture

def library_with_profile_type():

"""IFC4 library: a BeamType with an IfcMaterialProfileSet but no RepresentationMaps."""

f = ifcopenshell.api.project.create_file()

ifcopenshell.api.owner.settings.get_user = lambda ifc: (ifc.by_type("IfcPersonAndOrganization") or [None])[0]

ifcopenshell.api.owner.settings.get_application = lambda ifc: (ifc.by_type("IfcApplication") or [None])[0]

project = ifcopenshell.api.root.create_entity(f, ifc_class="IfcProject", name="ProfileLibProject")

ifcopenshell.api.unit.assign_unit(f)

model_ctx = ifcopenshell.api.context.add_context(f, context_type="Model")

ifcopenshell.api.context.add_context(

f, context_type="Model", context_identifier="Body", target_view="MODEL_VIEW", parent=model_ctx

)

# Rectangular profile 0.2m x 0.3m

profile = f.create_entity(

"IfcRectangleProfileDef",

ProfileType="AREA",

ProfileName="200x300",

XDim=0.2,

YDim=0.3,

)

material = f.create_entity("IfcMaterial", Name="Steel")

mat_profile = f.create_entity("IfcMaterialProfile", Material=material, Profile=profile)

profile_set = f.create_entity("IfcMaterialProfileSet", MaterialProfiles=[mat_profile])

beam_type = ifcopenshell.api.root.create_entity(f, ifc_class="IfcBeamType", name="200x300 Steel Beam")

rel = f.create_entity(

"IfcRelAssociatesMaterial",

GlobalId=ifcopenshell.guid.new(),

RelatedObjects=[beam_type],

RelatingMaterial=profile_set,

)

return f, beam_type

class TestRenderBasic:

def test_returns_png_bytes(self, model_with_geometry):

result = render(model_with_geometry)

assert isinstance(result, bytes)

assert result[:4] == PNG_MAGIC

def test_iso_view(self, model_with_geometry):

result = render(model_with_geometry, view="iso")

assert result[:4] == PNG_MAGIC

def test_top_view(self, model_with_geometry):

result = render(model_with_geometry, view="top")

assert result[:4] == PNG_MAGIC

def test_south_view(self, model_with_geometry):

result = render(model_with_geometry, view="south")

assert result[:4] == PNG_MAGIC

def test_unknown_view_falls_back_to_iso(self, model_with_geometry):

# Unknown view strings fall through to isometric

result = render(model_with_geometry, view="diagonal")

assert result[:4] == PNG_MAGIC

class TestRenderSelector:

def test_selector_restricts_elements(self, model_with_geometry):

result = render(model_with_geometry, selector="IfcWall")

assert result[:4] == PNG_MAGIC

def test_selector_no_match_raises(self, model_with_geometry):

with pytest.raises(ValueError, match="matched no elements"):

render(model_with_geometry, selector="IfcDoor")

class TestRenderHighlight:

def test_highlight_single_element(self, model_with_geometry):

wall = model_with_geometry.by_type("IfcWall")[0]

result = render(model_with_geometry, element_ids=[wall.id()])

assert result[:4] == PNG_MAGIC

def test_highlight_multiple_elements(self, model_with_geometry):

walls = model_with_geometry.by_type("IfcWall")

result = render(model_with_geometry, element_ids=[w.id() for w in walls])

assert result[:4] == PNG_MAGIC

class TestRenderTypes:

def test_render_type_by_selector(self, library_with_type):

"""Selecting a type class renders its RepresentationMap geometry."""

model, wall_type = library_with_type

result = render(model, selector="IfcWallType")

assert result[:4] == PNG_MAGIC

def test_render_type_by_element_id(self, library_with_type):

"""Passing a type step-ID via element_ids renders it highlighted."""

model, wall_type = library_with_type

result = render(model, element_ids=[wall_type.id()])

assert result[:4] == PNG_MAGIC

def test_original_model_unmodified(self, library_with_type):

"""Rendering a type must not add entities to the original model."""

model, wall_type = library_with_type

entity_count_before = len(list(model))

render(model, selector="IfcWallType")

assert len(list(model)) == entity_count_before

def test_make_type_occurrence_no_rep_maps(self, library_with_type):

"""_make_type_occurrence returns None for a type with no RepresentationMaps."""

model, _ = library_with_type

bare_type = ifcopenshell.api.root.create_entity(model, ifc_class="IfcWallType", name="Bare")

assert _make_type_occurrence(model, bare_type) is None

def test_type_without_rep_maps_raises(self):

"""Selecting a type that has no RepresentationMaps raises ValueError."""

f = ifcopenshell.api.project.create_file()

ifcopenshell.api.owner.settings.get_user = lambda ifc: (ifc.by_type("IfcPersonAndOrganization") or [None])[0]

ifcopenshell.api.owner.settings.get_application = lambda ifc: (ifc.by_type("IfcApplication") or [None])[0]

ifcopenshell.api.root.create_entity(f, ifc_class="IfcProject", name="P")

ifcopenshell.api.unit.assign_unit(f)

ifcopenshell.api.root.create_entity(f, ifc_class="IfcWallType", name="Bare")

with pytest.raises(ValueError):

render(f, selector="IfcWallType")

class TestRenderProfileTypes:

def test_render_profile_type_by_element_id(self, library_with_profile_type):

"""A type with only a material profile set renders via temporary extrusion."""

model, beam_type = library_with_profile_type

result = render(model, element_ids=[beam_type.id()])

assert result[:4] == PNG_MAGIC

def test_make_profile_occurrence_creates_occurrence(self, library_with_profile_type):

"""_make_profile_occurrence returns an occurrence entity for a profile-set type."""

model, beam_type = library_with_profile_type

occ = _make_profile_occurrence(model, beam_type)

assert occ is not None

def test_make_profile_occurrence_no_profile_returns_none(self, library_with_type):

"""_make_profile_occurrence returns None when type has no material profile set."""

model, wall_type = library_with_type

# wall_type has RepresentationMaps but no material profile set

occ = _make_profile_occurrence(model, wall_type)

assert occ is None

def test_original_model_unmodified_for_profile_type(self, library_with_profile_type):

"""Rendering a profile-based type does not modify the original model."""

model, beam_type = library_with_profile_type

entity_count_before = len(list(model))

render(model, element_ids=[beam_type.id()])

assert len(list(model)) == entity_count_before

class TestRenderNoGeometry:

def test_no_geometry_raises(self):

"""A model without geometry representations raises ValueError."""

f = ifcopenshell.api.project.create_file()

ifcopenshell.api.owner.settings.get_user = lambda ifc: (ifc.by_type("IfcPersonAndOrganization") or [None])[0]

ifcopenshell.api.owner.settings.get_application = lambda ifc: (ifc.by_type("IfcApplication") or [None])[0]

project = ifcopenshell.api.root.create_entity(f, ifc_class="IfcProject", name="P")

ifcopenshell.api.unit.assign_unit(f)

site = ifcopenshell.api.root.create_entity(f, ifc_class="IfcSite", name="S")

building = ifcopenshell.api.root.create_entity(f, ifc_class="IfcBuilding", name="B")

storey = ifcopenshell.api.root.create_entity(f, ifc_class="IfcBuildingStorey", name="GF")

ifcopenshell.api.aggregate.assign_object(f, products=[site], relating_object=project)

ifcopenshell.api.aggregate.assign_object(f, products=[building], relating_object=site)

ifcopenshell.api.aggregate.assign_object(f, products=[storey], relating_object=building)

wall = ifcopenshell.api.root.create_entity(f, ifc_class="IfcWall", name="Wallless")

ifcopenshell.api.spatial.assign_container(f, products=[wall], relating_structure=storey)

with pytest.raises(ValueError, match="No renderable geometry"):

render(f)

class TestCLI:

@staticmethod

def _ifc_path(model):

f = tempfile.NamedTemporaryFile(suffix=".ifc", delete=False)

model.write(f.name)

f.close()

return f.name

def test_render_writes_png(self, model_with_geometry):

ifc_path = self._ifc_path(model_with_geometry)

out_path = ifc_path.replace(".ifc", "_out.png")

try:

result = subprocess.run(

[sys.executable, "-m", "ifcquery", ifc_path, "render", "-o", out_path],

capture_output=True,

text=True,

)

assert result.returncode == 0, result.stderr

assert os.path.exists(out_path)

with open(out_path, "rb") as f:

assert f.read(4) == PNG_MAGIC

finally:

for path in (ifc_path, out_path):

try:

os.unlink(path)

except OSError:

pass

def test_render_default_output_path(self, model_with_geometry):

ifc_path = self._ifc_path(model_with_geometry)

expected_png = ifc_path.replace(".ifc", ".png")

try:

result = subprocess.run(

[sys.executable, "-m", "ifcquery", ifc_path, "render"],

capture_output=True,

text=True,

)

assert result.returncode == 0, result.stderr

assert os.path.exists(expected_png)

finally:

for path in (ifc_path, expected_png):

try:

os.unlink(path)

except OSError:

pass

def test_render_with_selector(self, model_with_geometry):

ifc_path = self._ifc_path(model_with_geometry)

out_path = ifc_path.replace(".ifc", "_sel.png")

try:

result = subprocess.run(

[sys.executable, "-m", "ifcquery", ifc_path, "render", "-o", out_path, "--selector", "IfcWall"],

capture_output=True,

text=True,

)

assert result.returncode == 0, result.stderr

with open(out_path, "rb") as f:

assert f.read(4) == PNG_MAGIC

finally:

for path in (ifc_path, out_path):

try:

os.unlink(path)

except OSError:

pass

def test_render_with_view(self, model_with_geometry):

ifc_path = self._ifc_path(model_with_geometry)

out_path = ifc_path.replace(".ifc", "_top.png")

try:

result = subprocess.run(

[sys.executable, "-m", "ifcquery", ifc_path, "render", "-o", out_path, "--view", "top"],

capture_output=True,

text=True,

)

assert result.returncode == 0, result.stderr

with open(out_path, "rb") as f:

assert f.read(4) == PNG_MAGIC

finally:

for path in (ifc_path, out_path):

try:

os.unlink(path)

except OSError:

pass