mirror of
https://github.com/IfcOpenShell/IfcOpenShell.git
synced 2026-08-13 19:07:57 +00:00
Andrej730
728 lines
29 KiB
Python
728 lines
29 KiB
Python
# Bonsai - OpenBIM Blender Add-on
|
|
# Copyright (C) 2021 Dion Moult <dion@thinkmoult.com>
|
|
#
|
|
# This file is part of Bonsai.
|
|
#
|
|
# Bonsai is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# Bonsai is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with Bonsai. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import bpy
|
|
import math
|
|
import numpy as np
|
|
import ifcopenshell
|
|
import ifcopenshell.api.geometry
|
|
import ifcopenshell.api.root
|
|
import ifcopenshell.api.type
|
|
import bonsai.core.tool
|
|
import bonsai.tool as tool
|
|
from mathutils import Vector
|
|
from test.bim.bootstrap import NewFile
|
|
from bonsai.tool.geometry import Geometry as subject
|
|
from typing import Union
|
|
|
|
|
|
class TestImplementsTool(NewFile):
|
|
def test_run(self):
|
|
assert isinstance(subject(), bonsai.core.tool.Geometry)
|
|
|
|
|
|
class TestChangeObjectData(NewFile):
|
|
def test_change_single_object_data(self):
|
|
data1 = bpy.data.meshes.new("Mesh")
|
|
data2 = bpy.data.meshes.new("Mesh")
|
|
obj1 = bpy.data.objects.new("Object", data1)
|
|
obj2 = bpy.data.objects.new("Object", data1)
|
|
subject.change_object_data(obj1, data2, is_global=False)
|
|
assert obj1.data == data2
|
|
assert obj2.data == data1
|
|
|
|
def test_change_object_data_globally(self):
|
|
data1 = bpy.data.meshes.new("Mesh")
|
|
data2 = bpy.data.meshes.new("Mesh")
|
|
obj1 = bpy.data.objects.new("Object", data1)
|
|
obj2 = bpy.data.objects.new("Object", data1)
|
|
subject.change_object_data(obj1, data2, is_global=True)
|
|
assert obj1.data == data2
|
|
assert obj2.data == data2
|
|
|
|
|
|
class TestClearCache(NewFile):
|
|
def test_nothing(self):
|
|
pass # TODO I don't know how to test this
|
|
|
|
|
|
class TestClearModifiers(NewFile):
|
|
def test_run(self):
|
|
obj = bpy.data.objects.new("Object", bpy.data.meshes.new("Mesh"))
|
|
obj.modifiers.new("IfcOpeningElement", "BOOLEAN")
|
|
subject.clear_modifiers(obj)
|
|
assert len(obj.modifiers) == 0
|
|
|
|
|
|
class TestClearScale(NewFile):
|
|
def test_run(self):
|
|
obj = bpy.data.objects.new("Object", bpy.data.meshes.new("Mesh"))
|
|
obj.scale[0] = 2
|
|
subject.clear_scale(obj)
|
|
assert list(obj.scale) == [1, 1, 1]
|
|
|
|
|
|
class TestDeleteData(NewFile):
|
|
def test_run(self):
|
|
data = bpy.data.meshes.new("Mesh")
|
|
subject.delete_data(data)
|
|
assert not bpy.data.meshes.get("Mesh")
|
|
|
|
|
|
class TestDoesRepresentationIdExist(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
representation = ifc.createIfcShapeRepresentation()
|
|
assert subject.does_representation_id_exist(representation.id()) is True
|
|
assert subject.does_representation_id_exist(12345) is False
|
|
|
|
|
|
class TestDuplicateObjectData(NewFile):
|
|
def test_run(self):
|
|
data = bpy.data.meshes.new("Mesh")
|
|
obj = bpy.data.objects.new("Object", data)
|
|
new_data = subject.duplicate_object_data(obj)
|
|
assert obj.data == data
|
|
assert isinstance(new_data, bpy.types.Mesh)
|
|
|
|
|
|
class TestGetObjectData(NewFile):
|
|
def test_run(self):
|
|
data = bpy.data.meshes.new("Mesh")
|
|
obj = bpy.data.objects.new("Object", data)
|
|
assert subject.get_object_data(obj) == obj.data
|
|
|
|
|
|
class TestGetObjectMaterialsWithoutStyles(NewFile):
|
|
def test_run(self):
|
|
material1 = bpy.data.materials.new("Material")
|
|
material2 = bpy.data.materials.new("Material")
|
|
material3 = bpy.data.materials.new("Material")
|
|
props = tool.Style.get_material_style_props(material3)
|
|
props.ifc_definition_id = 1
|
|
obj = bpy.data.objects.new("Object", bpy.data.meshes.new("Mesh"))
|
|
obj.data.materials.append(material1)
|
|
obj.data.materials.append(material2)
|
|
obj.data.materials.append(material3)
|
|
assert subject.get_object_materials_without_styles(obj) == [material1, material2]
|
|
|
|
|
|
class TestGetRepresentationData(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
context = ifc.createIfcGeometricRepresentationContext()
|
|
representation = ifc.createIfcShapeRepresentation()
|
|
representation.ContextOfItems = context
|
|
data = bpy.data.meshes.new("1/2")
|
|
assert subject.get_representation_data(representation) == data
|
|
|
|
|
|
class TestGetRepresentationId(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
representation = ifc.createIfcShapeRepresentation()
|
|
assert subject.get_representation_id(representation) == representation.id()
|
|
|
|
|
|
class TestGetRepresentationName(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
context = ifc.createIfcGeometricRepresentationContext()
|
|
representation = ifc.createIfcShapeRepresentation()
|
|
representation.ContextOfItems = context
|
|
assert subject.get_representation_name(representation) == f"{context.id()}/{representation.id()}"
|
|
|
|
|
|
class TestGetStyles(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
style = ifc.createIfcSurfaceStyle()
|
|
material = bpy.data.materials.new("Material")
|
|
tool.Ifc.link(style, material)
|
|
obj = bpy.data.objects.new("Object", bpy.data.meshes.new("Mesh"))
|
|
obj.data.materials.append(material)
|
|
assert subject.get_styles(obj) == [style]
|
|
|
|
|
|
class TestGetTextLiteral(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
item = ifc.createIfcTextLiteralWithExtent()
|
|
representation = ifc.createIfcShapeRepresentation(Items=[item])
|
|
assert subject.get_text_literal(representation) == item
|
|
|
|
|
|
class TestGetCartesianPointCoordinateOffset(NewFile):
|
|
def test_run(self):
|
|
obj = bpy.data.objects.new("Object", None)
|
|
oprops = tool.Blender.get_object_bim_props(obj)
|
|
oprops.blender_offset_type = "CARTESIAN_POINT"
|
|
props = tool.Georeference.get_georeference_props()
|
|
props.has_blender_offset = True
|
|
oprops.cartesian_point_offset = "1,2,3"
|
|
assert np.allclose(subject.get_cartesian_point_offset(obj), np.array((1.0, 2.0, 3.0)))
|
|
|
|
def test_get_null_if_not_a_cartesian_point_offset_type(self):
|
|
obj = bpy.data.objects.new("Object", None)
|
|
props = tool.Georeference.get_georeference_props()
|
|
props.has_blender_offset = True
|
|
oprops = tool.Blender.get_object_bim_props(obj)
|
|
oprops.cartesian_point_offset = "1,2,3"
|
|
assert subject.get_cartesian_point_offset(obj) is None
|
|
|
|
def test_get_null_if_no_blender_offset(self):
|
|
obj = bpy.data.objects.new("Object", None)
|
|
oprops = tool.Blender.get_object_bim_props(obj)
|
|
oprops.blender_offset_type = "CARTESIAN_POINT"
|
|
props = tool.Georeference.get_georeference_props()
|
|
props.has_blender_offset = False
|
|
assert subject.get_cartesian_point_offset(obj) is None
|
|
|
|
|
|
class TestGetElementType(NewFile):
|
|
def test_run(self):
|
|
bpy.ops.bim.create_project()
|
|
ifc = tool.Ifc.get()
|
|
element = ifc.createIfcWall()
|
|
type = ifc.createIfcWallType()
|
|
ifcopenshell.api.type.assign_type(ifc, related_objects=[element], relating_type=type)
|
|
assert subject.get_element_type(element) == type
|
|
|
|
|
|
class TestGetElementsOfType(NewFile):
|
|
def test_run(self):
|
|
bpy.ops.bim.create_project()
|
|
ifc = tool.Ifc.get()
|
|
element = ifc.createIfcWall()
|
|
type = ifc.createIfcWallType()
|
|
ifcopenshell.api.type.assign_type(ifc, related_objects=[element], relating_type=type)
|
|
assert subject.get_elements_of_type(type) == (element,)
|
|
|
|
|
|
class TestGetTotalRepresentationItems(NewFile):
|
|
def test_run(self):
|
|
material1 = bpy.data.materials.new("Material")
|
|
material2 = bpy.data.materials.new("Material")
|
|
obj = bpy.data.objects.new("Object", bpy.data.meshes.new("Mesh"))
|
|
obj.data.materials.append(material1)
|
|
obj.data.materials.append(material2)
|
|
assert subject.get_total_representation_items(obj) == 2
|
|
|
|
|
|
class TestHasDataUsers(NewFile):
|
|
def test_run(self):
|
|
data = bpy.data.meshes.new("Mesh")
|
|
assert subject.has_data_users(data) is False
|
|
bpy.data.objects.new("Object", data)
|
|
assert subject.has_data_users(data) is True
|
|
|
|
|
|
class TestImportRepresentationParameters(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
swept_area = ifc.createIfcCircleProfileDef(Radius=1)
|
|
item = ifc.createIfcExtrudedAreaSolid(SweptArea=swept_area, Depth=2)
|
|
representation = ifc.createIfcShapeRepresentation(Items=[item])
|
|
data = bpy.data.meshes.new("Mesh")
|
|
mprops = tool.Geometry.get_mesh_props(data)
|
|
mprops.ifc_definition_id = representation.id()
|
|
subject.import_representation_parameters(data)
|
|
assert mprops.ifc_parameters[0].name == "IfcExtrudedAreaSolid/Depth"
|
|
assert mprops.ifc_parameters[0].step_id == item.id()
|
|
assert mprops.ifc_parameters[0].index == 3
|
|
assert mprops.ifc_parameters[1].name == "IfcCircleProfileDef/Radius"
|
|
assert mprops.ifc_parameters[1].step_id == swept_area.id()
|
|
assert mprops.ifc_parameters[1].index == 3
|
|
|
|
|
|
class TestIsBodyRepresentation(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
context = ifc.createIfcGeometricRepresentationContext()
|
|
representation = ifc.createIfcShapeRepresentation()
|
|
representation.ContextOfItems = context
|
|
context.ContextIdentifier = "Body"
|
|
assert subject.is_body_representation(representation) is True
|
|
context.ContextIdentifier = "Clearance"
|
|
assert subject.is_body_representation(representation) is False
|
|
|
|
|
|
class TestIsBoxRepresentation(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
context = ifc.createIfcGeometricRepresentationContext()
|
|
representation = ifc.createIfcShapeRepresentation()
|
|
representation.ContextOfItems = context
|
|
context.ContextIdentifier = "Box"
|
|
assert subject.is_box_representation(representation) is True
|
|
context.ContextIdentifier = "Clearance"
|
|
assert subject.is_box_representation(representation) is False
|
|
|
|
|
|
class TestIsMappedRepresentation(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
representation = ifc.createIfcShapeRepresentation()
|
|
assert subject.is_mapped_representation(representation) is False
|
|
representation.RepresentationType = "MappedRepresentation"
|
|
assert subject.is_mapped_representation(representation) is True
|
|
|
|
|
|
class TestIsTypeProduct(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
assert subject.is_type_product(ifc.createIfcWall()) is False
|
|
assert subject.is_type_product(ifc.createIfcWallType()) is True
|
|
|
|
|
|
class TestLink(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
element = ifc.createIfcShapeRepresentation()
|
|
obj = bpy.data.meshes.new("Mesh")
|
|
subject.link(element, obj)
|
|
assert tool.Geometry.get_mesh_props(obj).ifc_definition_id == element.id()
|
|
|
|
|
|
class TestRecordObjectMaterials(NewFile):
|
|
def test_run(self):
|
|
obj = bpy.data.objects.new("Object", bpy.data.meshes.new("Mesh"))
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
style = ifc.createIfcSurfaceStyle()
|
|
material = bpy.data.materials.new("Material")
|
|
tool.Ifc.link(style, material)
|
|
obj.data.materials.append(material)
|
|
subject.record_object_materials(obj)
|
|
assert tool.Geometry.get_mesh_props(obj.data).material_checksum == str([style.id()])
|
|
|
|
|
|
class TestRecordObjectPosition(NewFile):
|
|
def test_run(self):
|
|
obj = bpy.data.objects.new("Object", None)
|
|
props = tool.Blender.get_object_bim_props(obj)
|
|
subject.record_object_position(obj)
|
|
assert props.location_checksum == repr(np.array(obj.matrix_world.translation).tobytes())
|
|
assert props.rotation_checksum == repr(np.array(obj.matrix_world.to_3x3()).tobytes())
|
|
|
|
|
|
class TestRemoveConnection(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc().set(ifc)
|
|
element1 = ifcopenshell.api.root.create_entity(ifc, ifc_class="IfcWall")
|
|
element2 = ifcopenshell.api.root.create_entity(ifc, ifc_class="IfcWall")
|
|
rel = ifcopenshell.api.geometry.connect_path(ifc, relating_element=element1, related_element=element2)
|
|
subject.remove_connection(rel)
|
|
assert not tool.Ifc.get().by_type("IfcRelConnectsPathElements")
|
|
|
|
|
|
class TestRenameObject(NewFile):
|
|
def test_run(self):
|
|
obj = bpy.data.meshes.new("Mesh")
|
|
subject.rename_object(obj, "name")
|
|
assert obj.name == "name"
|
|
|
|
|
|
class TestReplaceObjectWithEmpty(NewFile):
|
|
def validate(
|
|
self,
|
|
element: ifcopenshell.entity_instance,
|
|
obj: bpy.types.Object,
|
|
new_obj: bpy.types.Object,
|
|
new_data: Union[bpy.types.Mesh, None],
|
|
) -> None:
|
|
assert not tool.Blender.is_valid_data_block(obj)
|
|
assert new_obj.users_collection[0] == bpy.context.scene.collection
|
|
assert tool.Ifc.get_entity(new_obj) == element
|
|
assert tool.Ifc.get_object(element) == new_obj
|
|
assert new_obj.data is new_data
|
|
assert new_obj.matrix_world.translation.x == 1
|
|
|
|
def create_object(
|
|
self, name: str, data: Union[bpy.types.Mesh, None], ifc_class: str
|
|
) -> tuple[bpy.types.Object, ifcopenshell.entity_instance]:
|
|
ifc = tool.Ifc.get()
|
|
obj = bpy.data.objects.new(name, data)
|
|
obj.matrix_world.translation.x = 1
|
|
bpy.context.scene.collection.objects.link(obj)
|
|
element = ifc.create_entity(ifc_class)
|
|
tool.Ifc.link(element, obj)
|
|
return obj, element
|
|
|
|
def run_test_replace_non_global(
|
|
self, from_data: Union[bpy.types.Mesh, None], to_data: Union[bpy.types.Mesh, None]
|
|
) -> None:
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
|
|
obj, element = self.create_object("Object", from_data, "IfcWall")
|
|
new_obj = subject.recreate_object_with_data(obj, to_data)
|
|
if from_data:
|
|
assert tool.Blender.is_valid_data_block(from_data)
|
|
self.validate(element, obj, new_obj, to_data)
|
|
|
|
def test_replace_mesh_with_empty(self) -> None:
|
|
self.run_test_replace_non_global(bpy.data.meshes.new("Mesh"), None)
|
|
|
|
def test_replace_empty_with_mesh(self) -> None:
|
|
self.run_test_replace_non_global(None, bpy.data.meshes.new("New Mesh"))
|
|
|
|
def run_test_for_global_argument(
|
|
self, from_data: Union[bpy.types.Mesh, None], to_data: Union[bpy.types.Mesh, None]
|
|
) -> None:
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
|
|
type_obj, element_type = self.create_object("IfcWallType", from_data, "IfcWallType")
|
|
obj1, element1 = self.create_object("IfcWall1", from_data, "IfcWall")
|
|
obj2, element2 = self.create_object("IfcWall2", from_data, "IfcWall")
|
|
ifcopenshell.api.type.assign_type(ifc, related_objects=[element1, element2], relating_type=element_type)
|
|
|
|
to_data = to_data
|
|
new_obj = subject.recreate_object_with_data(type_obj, to_data, is_global=True)
|
|
if from_data:
|
|
assert tool.Blender.is_valid_data_block(from_data)
|
|
|
|
self.validate(element_type, type_obj, new_obj, to_data)
|
|
self.validate(element1, obj1, bpy.data.objects["IfcWall1"], to_data)
|
|
self.validate(element2, obj2, bpy.data.objects["IfcWall2"], to_data)
|
|
|
|
def test_replace_mesh_with_empty_global(self) -> None:
|
|
self.run_test_for_global_argument(bpy.data.meshes.new("Mesh"), None)
|
|
|
|
def test_replace_empty_with_mesh_global(self) -> None:
|
|
self.run_test_for_global_argument(None, bpy.data.meshes.new("New Mesh"))
|
|
|
|
|
|
class TestResolveMappedRepresentation(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
mapped_representation = ifc.createIfcShapeRepresentation()
|
|
representation = ifc.createIfcShapeRepresentation()
|
|
mapped_representation.RepresentationType = "MappedRepresentation"
|
|
mapped_representation.Items = [
|
|
ifc.createIfcMappedItem(MappingSource=ifc.createIfcRepresentationMap(MappedRepresentation=representation))
|
|
]
|
|
assert subject.resolve_mapped_representation(mapped_representation) == representation
|
|
|
|
def test_return_a_representation_if_not_mapped(self):
|
|
ifc = ifcopenshell.file()
|
|
representation = ifc.createIfcShapeRepresentation()
|
|
assert subject.resolve_mapped_representation(representation) == representation
|
|
|
|
|
|
class TestRunGeometryUpdateRepresentation(NewFile):
|
|
def test_nothing(self):
|
|
pass
|
|
|
|
|
|
class TestRunStyleAddStyle(NewFile):
|
|
def test_nothing(self):
|
|
pass
|
|
|
|
|
|
class TestSelectConnection(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc().set(ifc)
|
|
|
|
element1 = ifcopenshell.api.root.create_entity(ifc, ifc_class="IfcWall")
|
|
obj1 = bpy.data.objects.new("Object", None)
|
|
bpy.context.scene.collection.objects.link(obj1)
|
|
tool.Ifc.link(element1, obj1)
|
|
|
|
element2 = ifcopenshell.api.root.create_entity(ifc, ifc_class="IfcWall")
|
|
obj2 = bpy.data.objects.new("Object", None)
|
|
bpy.context.scene.collection.objects.link(obj2)
|
|
tool.Ifc.link(element2, obj2)
|
|
|
|
rel = ifcopenshell.api.geometry.connect_path(ifc, relating_element=element1, related_element=element2)
|
|
|
|
subject.select_connection(rel)
|
|
assert obj1 in bpy.context.selected_objects
|
|
assert obj2 in bpy.context.selected_objects
|
|
|
|
|
|
class TestShouldForceFacetedBrep(NewFile):
|
|
def test_run(self):
|
|
result = tool.Geometry.get_geometry_props().should_force_faceted_brep
|
|
assert subject.should_force_faceted_brep() is result
|
|
|
|
|
|
class TestShouldForceTriangulation(NewFile):
|
|
def test_run(self):
|
|
result = tool.Geometry.get_geometry_props().should_force_triangulation
|
|
assert subject.should_force_triangulation() is result
|
|
|
|
|
|
class TestShouldGenerateUVs(NewFile):
|
|
def test_needs_mesh_data(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
obj = bpy.data.objects.new("Object", None)
|
|
assert subject.should_generate_uvs(obj) is False
|
|
|
|
def test_needs_nodes(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
obj = bpy.data.objects.new("Object", bpy.data.meshes.new("Mesh"))
|
|
material = bpy.data.materials.new("Material")
|
|
obj.data.materials.append(material)
|
|
material.use_nodes = False
|
|
assert subject.should_generate_uvs(obj) is False
|
|
|
|
def test_needs_texture_coordinates_with_a_uv_output(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
obj = bpy.data.objects.new("Object", bpy.data.meshes.new("Mesh"))
|
|
material = bpy.data.materials.new("Material")
|
|
obj.data.materials.append(material)
|
|
material.use_nodes = True
|
|
|
|
bsdf = tool.Blender.get_material_node(material, "BSDF_PRINCIPLED")
|
|
node = material.node_tree.nodes.new(type="ShaderNodeTexImage")
|
|
material.node_tree.links.new(bsdf.inputs["Base Color"], node.outputs["Color"])
|
|
|
|
coords = material.node_tree.nodes.new(type="ShaderNodeTexCoord")
|
|
material.node_tree.links.new(node.inputs["Vector"], coords.outputs["UV"])
|
|
assert subject.should_generate_uvs(obj) is True
|
|
|
|
def test_accepts_a_uv_map_node(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
obj = bpy.data.objects.new("Object", bpy.data.meshes.new("Mesh"))
|
|
material = bpy.data.materials.new("Material")
|
|
obj.data.materials.append(material)
|
|
material.use_nodes = True
|
|
|
|
bsdf = tool.Blender.get_material_node(material, "BSDF_PRINCIPLED")
|
|
node = material.node_tree.nodes.new(type="ShaderNodeTexImage")
|
|
material.node_tree.links.new(bsdf.inputs["Base Color"], node.outputs["Color"])
|
|
|
|
coords = material.node_tree.nodes.new(type="ShaderNodeUVMap")
|
|
coords.uv_map = "UVMap"
|
|
material.node_tree.links.new(node.inputs["Vector"], coords.outputs["UV"])
|
|
assert subject.should_generate_uvs(obj) is True
|
|
|
|
|
|
class TestShouldUsePresentationStyleAssignment(NewFile):
|
|
def test_run(self):
|
|
result = tool.Geometry.get_geometry_props().should_use_presentation_style_assignment
|
|
assert subject.should_use_presentation_style_assignment() is result
|
|
|
|
|
|
class TestGetProfileSetUsage(NewFile):
|
|
def test_getting_a_profile_set_usage(self):
|
|
ifc = ifcopenshell.file()
|
|
element = ifc.createIfcColumn()
|
|
assert subject.get_profile_set_usage(element) is None
|
|
usage = ifc.createIfcMaterialProfileSetUsage()
|
|
ifc.createIfcRelAssociatesMaterial(RelatingMaterial=usage, RelatedObjects=[element])
|
|
assert subject.get_profile_set_usage(element) == usage
|
|
|
|
|
|
class TestGetIfcRepresentationClass(NewFile):
|
|
def test_detecting_profile_set_representations(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
element = ifc.createIfcColumn()
|
|
ifc.createIfcRelAssociatesMaterial(
|
|
RelatingMaterial=ifc.createIfcMaterialProfileSetUsage(), RelatedObjects=[element]
|
|
)
|
|
representation = ifc.createIfcShapeRepresentation()
|
|
assert (
|
|
subject.get_ifc_representation_class(element, representation)
|
|
== "IfcExtrudedAreaSolid/IfcMaterialProfileSetUsage"
|
|
)
|
|
|
|
def test_detecting_rectangular_extrusions(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
element = ifc.createIfcColumn()
|
|
representation = ifc.createIfcShapeRepresentation(
|
|
Items=[ifc.createIfcExtrudedAreaSolid(SweptArea=ifc.createIfcRectangleProfileDef())]
|
|
)
|
|
assert (
|
|
subject.get_ifc_representation_class(element, representation)
|
|
== "IfcExtrudedAreaSolid/IfcRectangleProfileDef"
|
|
)
|
|
|
|
def test_detecting_circle_extrusions(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
element = ifc.createIfcColumn()
|
|
representation = ifc.createIfcShapeRepresentation(
|
|
Items=[ifc.createIfcExtrudedAreaSolid(SweptArea=ifc.createIfcCircleProfileDef())]
|
|
)
|
|
assert (
|
|
subject.get_ifc_representation_class(element, representation) == "IfcExtrudedAreaSolid/IfcCircleProfileDef"
|
|
)
|
|
|
|
def test_detecting_text_representations(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
element = ifc.createIfcAnnotation()
|
|
element.ObjectType = "TEXT"
|
|
assert subject.get_ifc_representation_class(element, None) == "IfcTextLiteral"
|
|
|
|
def test_detecting_text_and_geometric_representations(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
element = ifc.createIfcAnnotation()
|
|
element.ObjectType = "TEXT_LEADER"
|
|
assert subject.get_ifc_representation_class(element, None) == "IfcGeometricCurveSet/IfcTextLiteral"
|
|
|
|
def test_returning_null_for_non_parametric_representations(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
assert subject.get_ifc_representation_class(ifc.createIfcColumn(), ifc.createIfcShapeRepresentation()) is None
|
|
|
|
|
|
class TestRemoveRepresentationItem(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
|
|
context = ifc.createIfcGeometricRepresentationContext()
|
|
element = ifc.createIfcWall()
|
|
|
|
items = [ifc.createIfcExtrudedAreaSolid(), ifc.createIfcExtrudedAreaSolid()]
|
|
representation = ifc.createIfcShapeRepresentation(Items=items, ContextOfItems=context)
|
|
ifcopenshell.api.geometry.assign_representation(ifc, product=element, representation=representation)
|
|
|
|
product_shape = element.Representation
|
|
shape_aspect = subject.create_shape_aspect(product_shape, representation, items[:1], None)
|
|
shape_aspect_id = shape_aspect.id()
|
|
|
|
subject.remove_representation_item(items[0], element)
|
|
assert tool.Ifc.get_entity_by_id(shape_aspect_id) is None
|
|
assert set(representation.Items) == {items[1]}
|
|
|
|
|
|
class TestCreateShapeAspect(NewFile):
|
|
def test_run(self):
|
|
self.create_shape_aspect(use_element_type=False)
|
|
self.create_shape_aspect(use_element_type=True)
|
|
|
|
def create_shape_aspect(self, use_element_type):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
|
|
context = ifc.createIfcGeometricRepresentationContext()
|
|
element = ifc.createIfcWallType() if use_element_type else ifc.createIfcWall()
|
|
|
|
item = ifc.createIfcExtrudedAreaSolid()
|
|
items = [item]
|
|
representation = ifc.createIfcShapeRepresentation(Items=items, ContextOfItems=context)
|
|
ifcopenshell.api.geometry.assign_representation(ifc, product=element, representation=representation)
|
|
|
|
product_shape = element.RepresentationMaps[0] if use_element_type else element.Representation
|
|
subject.create_shape_aspect(product_shape, representation, items, None)
|
|
assert len(product_shape.HasShapeAspects) == 1
|
|
representation = product_shape.HasShapeAspects[0].ShapeRepresentations[0]
|
|
assert set(representation.Items) == set(items)
|
|
|
|
|
|
class TestAddRepresentationItemToShapeAspect(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
|
|
context = ifc.createIfcGeometricRepresentationContext()
|
|
element = ifc.createIfcWall()
|
|
|
|
items = [ifc.createIfcExtrudedAreaSolid(), ifc.createIfcExtrudedAreaSolid()]
|
|
representation = ifc.createIfcShapeRepresentation(Items=items, ContextOfItems=context)
|
|
ifcopenshell.api.geometry.assign_representation(ifc, product=element, representation=representation)
|
|
product_shape = element.Representation
|
|
shape_aspect0 = subject.create_shape_aspect(product_shape, representation, [items[0]], None)
|
|
previous_shape_aspect_id = shape_aspect0.id()
|
|
shape_aspect1 = subject.create_shape_aspect(product_shape, representation, [items[1]], None)
|
|
|
|
subject.add_representation_item_to_shape_aspect([items[0]], shape_aspect1)
|
|
# previous shape aspect removed as there won't be any items in it
|
|
assert tool.Ifc.get_entity_by_id(previous_shape_aspect_id) is None
|
|
representation = shape_aspect1.ShapeRepresentations[0]
|
|
assert set(representation.Items) == set(items)
|
|
|
|
|
|
class TestRemoveRepresentationItemFromShapeAspect(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
|
|
context = ifc.createIfcGeometricRepresentationContext()
|
|
element = ifc.createIfcWall()
|
|
|
|
items = [ifc.createIfcExtrudedAreaSolid(), ifc.createIfcExtrudedAreaSolid()]
|
|
representation = ifc.createIfcShapeRepresentation(Items=items, ContextOfItems=context)
|
|
ifcopenshell.api.geometry.assign_representation(ifc, product=element, representation=representation)
|
|
product_shape = element.Representation
|
|
shape_aspect0 = subject.create_shape_aspect(product_shape, representation, [items[0]], None)
|
|
previous_shape_aspect_id = shape_aspect0.id()
|
|
previous_shape_aspect_rep_id = shape_aspect0.ShapeRepresentations[0].id()
|
|
shape_aspect1 = subject.create_shape_aspect(product_shape, representation, [items[1]], None)
|
|
|
|
subject.remove_representation_items_from_shape_aspect([items[0]], shape_aspect0)
|
|
# previous shape aspect and representation are removed as there won't be any items in them
|
|
assert tool.Ifc.get_entity_by_id(previous_shape_aspect_id) is None
|
|
assert tool.Ifc.get_entity_by_id(previous_shape_aspect_rep_id) is None
|
|
|
|
# items is removed from the representaiton
|
|
subject.add_representation_item_to_shape_aspect([items[0]], shape_aspect1)
|
|
subject.remove_representation_items_from_shape_aspect([items[1]], shape_aspect1)
|
|
representation = shape_aspect1.ShapeRepresentations[0]
|
|
assert set(representation.Items) == {items[0]}
|
|
|
|
|
|
class TestApplyItemIdsAsVertexGroups(NewFile):
|
|
def test_run(self):
|
|
bpy.ops.mesh.primitive_cube_add(size=10, location=(0, 0, 4))
|
|
obj = bpy.data.objects["Cube"]
|
|
bpy.ops.object.editmode_toggle()
|
|
bpy.ops.mesh.quads_convert_to_tris()
|
|
bpy.ops.mesh.duplicate_move()
|
|
bpy.ops.object.editmode_toggle()
|
|
|
|
mesh = obj.data
|
|
assert isinstance(mesh, bpy.types.Mesh)
|
|
assert len(mesh.polygons) == 24
|
|
|
|
mesh["ios_edges"] = [] # Method requirement.
|
|
ios_item_ids = (95,) * 12 + (45,) * 12
|
|
mesh["ios_item_ids"] = ios_item_ids
|
|
unique = tuple(dict.fromkeys(ios_item_ids))
|
|
ios_item_ids_unique = [unique.index(i) for i in ios_item_ids]
|
|
|
|
tool.Geometry.apply_item_ids_as_vertex_groups(obj)
|
|
|
|
vertex_group_names = [vg.name for vg in obj.vertex_groups]
|
|
assert vertex_group_names == [f"ios_item_id_{i}" for i in unique]
|
|
|
|
verts = mesh.vertices
|
|
for i, polygon in enumerate(mesh.polygons):
|
|
for vi in polygon.vertices:
|
|
vert = verts[vi]
|
|
groups = [g.group for g in vert.groups]
|
|
assert groups == [ios_item_ids_unique[i]]
|