mirror of
https://github.com/IfcOpenShell/IfcOpenShell.git
synced 2026-08-15 18:14:08 +00:00
Andrej730
782 lines
31 KiB
Python
782 lines
31 KiB
Python
# BlenderBIM Add-on - OpenBIM Blender Add-on
|
|
# Copyright (C) 2021 Dion Moult <dion@thinkmoult.com>
|
|
#
|
|
# This file is part of BlenderBIM Add-on.
|
|
#
|
|
# BlenderBIM Add-on 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.
|
|
#
|
|
# BlenderBIM Add-on 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 BlenderBIM Add-on. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import os
|
|
from pathlib import Path
|
|
import bpy
|
|
import mathutils
|
|
import ifcopenshell
|
|
import blenderbim.core.tool
|
|
import blenderbim.tool as tool
|
|
from test.bim.bootstrap import NewFile
|
|
from blenderbim.tool.drawing import Drawing as subject
|
|
from blenderbim.bim.ifc import IfcStore
|
|
from blenderbim.bim.module.drawing.data import DecoratorData
|
|
|
|
import xml.etree.ElementTree as ET
|
|
|
|
|
|
class TestImplementsTool(NewFile):
|
|
def test_run(self):
|
|
assert isinstance(subject(), blenderbim.core.tool.Drawing)
|
|
|
|
|
|
class TestCopyRepresentation(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
source = ifc.createIfcAnnotation(Representation=ifc.createIfcProductDefinitionShape())
|
|
dest = ifc.createIfcAnnotation()
|
|
subject.copy_representation(source, dest)
|
|
assert dest.Representation.is_a("IfcProductDefinitionShape")
|
|
|
|
|
|
class TestCreateAnnotationObject(NewFile):
|
|
def test_nothing(self):
|
|
pass
|
|
|
|
|
|
class TestCreateCamera(NewFile):
|
|
def test_run(self):
|
|
obj = subject.create_camera("Name", mathutils.Matrix())
|
|
assert obj.name == "Name"
|
|
assert obj.matrix_world == mathutils.Matrix()
|
|
assert obj.data.type == "ORTHO"
|
|
assert obj.data.ortho_scale == 50
|
|
assert obj.data.clip_end == 10
|
|
assert obj.users_collection[0] == bpy.context.scene.collection
|
|
|
|
|
|
class TestCreateSvgSheet(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcProject")
|
|
tool.Ifc.set(ifc)
|
|
document = ifc.createIfcDocumentInformation(
|
|
Identification="X",
|
|
Name="FOOBAR",
|
|
Scope="DOCUMENTATION",
|
|
Location=os.path.join(bpy.context.scene.BIMProperties.data_dir, "cache", "X - FOOBAR.svg"),
|
|
)
|
|
uri = subject.create_svg_sheet(document, "A1")
|
|
assert uri.endswith(".svg")
|
|
assert os.path.isfile(uri)
|
|
|
|
|
|
class TestDeleteCollection(NewFile):
|
|
def test_run(self):
|
|
collection = bpy.data.collections.new("Foobar")
|
|
subject.delete_collection(collection)
|
|
assert not bpy.data.collections.get("Foobar")
|
|
|
|
|
|
class TestDeleteDrawingElements(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
obj = bpy.data.objects.new("Object", bpy.data.meshes.new("Mesh"))
|
|
collection = bpy.data.collections.new("Collection")
|
|
bpy.context.scene.collection.children.link(collection)
|
|
collection.objects.link(obj)
|
|
element = ifc.createIfcAnnotation(GlobalId=ifcopenshell.guid.new())
|
|
tool.Ifc.link(element, obj)
|
|
|
|
element_id = element.id()
|
|
subject.delete_drawing_elements([element])
|
|
try:
|
|
ifc.by_id(element_id)
|
|
assert False
|
|
except:
|
|
pass
|
|
assert not bpy.data.objects.get("Object")
|
|
|
|
|
|
class TestDisableEditingDrawings(NewFile):
|
|
def test_run(self):
|
|
bpy.context.scene.DocProperties.is_editing_drawings = True
|
|
subject.disable_editing_drawings()
|
|
assert bpy.context.scene.DocProperties.is_editing_drawings == False
|
|
|
|
|
|
class TestDisableEditingSchedules(NewFile):
|
|
def test_run(self):
|
|
bpy.context.scene.DocProperties.is_editing_schedules = True
|
|
subject.disable_editing_schedules()
|
|
assert bpy.context.scene.DocProperties.is_editing_schedules == False
|
|
|
|
|
|
class TestDisableEditingSheets(NewFile):
|
|
def test_run(self):
|
|
bpy.context.scene.DocProperties.is_editing_sheets = True
|
|
subject.disable_editing_sheets()
|
|
assert bpy.context.scene.DocProperties.is_editing_sheets == False
|
|
|
|
|
|
class TestDisableEditingText(NewFile):
|
|
def test_run(self):
|
|
obj = bpy.data.objects.new("Object", None)
|
|
obj.BIMTextProperties.is_editing = True
|
|
subject.disable_editing_text(obj)
|
|
assert obj.BIMTextProperties.is_editing == False
|
|
|
|
|
|
class TestDisableEditingAssignedProduct(NewFile):
|
|
def test_run(self):
|
|
obj = bpy.data.objects.new("Object", None)
|
|
obj.BIMAssignedProductProperties.is_editing_product = True
|
|
subject.disable_editing_assigned_product(obj)
|
|
assert obj.BIMAssignedProductProperties.is_editing_product == False
|
|
|
|
|
|
class TestEnableEditing(NewFile):
|
|
def test_run(self):
|
|
obj = bpy.data.objects.new("Object", None)
|
|
bpy.context.scene.collection.objects.link(obj)
|
|
subject.enable_editing(obj)
|
|
assert obj in bpy.context.selected_objects
|
|
|
|
|
|
class TestEnableEditingDrawings(NewFile):
|
|
def test_run(self):
|
|
bpy.context.scene.DocProperties.is_editing_drawings = False
|
|
subject.enable_editing_drawings()
|
|
assert bpy.context.scene.DocProperties.is_editing_drawings == True
|
|
|
|
|
|
class TestEnableEditingSchedules(NewFile):
|
|
def test_run(self):
|
|
bpy.context.scene.DocProperties.is_editing_schedules = False
|
|
subject.enable_editing_schedules()
|
|
assert bpy.context.scene.DocProperties.is_editing_schedules == True
|
|
|
|
|
|
class TestEnableEditingSheets(NewFile):
|
|
def test_run(self):
|
|
bpy.context.scene.DocProperties.is_editing_sheets = False
|
|
subject.enable_editing_sheets()
|
|
assert bpy.context.scene.DocProperties.is_editing_sheets == True
|
|
|
|
|
|
class TestEnableEditingText(NewFile):
|
|
def test_run(self):
|
|
obj = bpy.data.objects.new("Object", None)
|
|
subject.enable_editing_text(obj)
|
|
assert obj.BIMTextProperties.is_editing == True
|
|
|
|
|
|
class TestEnableEditingAssignedProduct(NewFile):
|
|
def test_run(self):
|
|
obj = bpy.data.objects.new("Object", None)
|
|
subject.enable_editing_assigned_product(obj)
|
|
assert obj.BIMAssignedProductProperties.is_editing_product == True
|
|
|
|
|
|
class TestEnsureUniqueDrawingName(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
assert subject.ensure_unique_drawing_name("FOOBAR") == "FOOBAR"
|
|
ifc.createIfcAnnotation(Name="FOOBAR", ObjectType="DRAWING")
|
|
assert subject.ensure_unique_drawing_name("FOOBAR") == "FOOBAR-X"
|
|
ifc.createIfcAnnotation(Name="FOOBAR-X", ObjectType="DRAWING")
|
|
assert subject.ensure_unique_drawing_name("FOOBAR") == "FOOBAR-X-X"
|
|
|
|
|
|
class TestEnsureUniqueIdentification(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
assert subject.ensure_unique_identification("FOOBAR") == "FOOBAR"
|
|
ifc.createIfcDocumentInformation(Identification="FOOBAR", Scope="DOCUMENTATION")
|
|
assert subject.ensure_unique_identification("FOOBAR") == "FOOBAR-X"
|
|
ifc.createIfcDocumentInformation(Identification="FOOBAR-X", Scope="DOCUMENTATION")
|
|
assert subject.ensure_unique_identification("FOOBAR") == "FOOBAR-X-X"
|
|
|
|
def test_unique_document_id_ifc2x3(self):
|
|
ifc = ifcopenshell.file(schema="IFC2X3")
|
|
tool.Ifc.set(ifc)
|
|
assert subject.ensure_unique_identification("FOOBAR") == "FOOBAR"
|
|
ifc.createIfcDocumentInformation(DocumentId="FOOBAR", Scope="DOCUMENTATION")
|
|
assert subject.ensure_unique_identification("FOOBAR") == "FOOBAR-X"
|
|
ifc.createIfcDocumentInformation(DocumentId="FOOBAR-X", Scope="DOCUMENTATION")
|
|
assert subject.ensure_unique_identification("FOOBAR") == "FOOBAR-X-X"
|
|
|
|
|
|
class TestExportTextLiteralAttributes(NewFile):
|
|
def test_run(self):
|
|
TestImportTextAttributes().test_run()
|
|
assert subject.export_text_literal_attributes(bpy.data.objects.get("Object")) == [
|
|
{
|
|
"Literal": "Literal",
|
|
"Path": "RIGHT",
|
|
"BoxAlignment": "bottom-left",
|
|
}
|
|
]
|
|
|
|
|
|
class TestGetAnnotationContext(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
context = ifc.createIfcGeometricRepresentationSubContext(
|
|
ContextType="Plan", ContextIdentifier="Annotation", TargetView="PLAN_VIEW"
|
|
)
|
|
context2 = ifc.createIfcGeometricRepresentationSubContext(
|
|
ContextType="Model", ContextIdentifier="Annotation", TargetView="ELEVATION_VIEW"
|
|
)
|
|
context3 = ifc.createIfcGeometricRepresentationSubContext(
|
|
ContextType="Model", ContextIdentifier="Annotation", TargetView="PLAN_VIEW"
|
|
)
|
|
tool.Ifc.set(ifc)
|
|
assert subject.get_annotation_context("PLAN_VIEW") == context
|
|
assert subject.get_annotation_context("ELEVATION_VIEW") == context2
|
|
assert subject.get_annotation_context("PLAN_VIEW", "FALL") == context3
|
|
|
|
|
|
class TestGetBodyContext(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
context = ifc.createIfcGeometricRepresentationSubContext(
|
|
ContextType="Model", ContextIdentifier="Body", TargetView="MODEL_VIEW"
|
|
)
|
|
tool.Ifc.set(ifc)
|
|
assert subject.get_body_context() == context
|
|
|
|
|
|
class TestGetDocumentUri(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
document = ifc.createIfcDocumentInformation(
|
|
Identification="X", Name="FOOBAR", Scope="SHEET", Location="Location"
|
|
)
|
|
assert subject.get_document_uri(document) == os.path.abspath(os.path.join(tool.Ifc.get_path(), "Location"))
|
|
|
|
def test_get_indirect_locations(self):
|
|
ifc = ifcopenshell.file()
|
|
document = ifc.createIfcDocumentInformation(Identification="X", Name="FOOBAR", Scope="SHEET")
|
|
reference = ifc.createIfcDocumentReference(Location="Location", ReferencedDocument=document)
|
|
assert subject.get_document_uri(document) == os.path.abspath(os.path.join(tool.Ifc.get_path(), "Location"))
|
|
assert subject.get_document_uri(reference) == os.path.abspath(os.path.join(tool.Ifc.get_path(), "Location"))
|
|
|
|
def test_run_ifc2x3(self):
|
|
ifc = ifcopenshell.file(schema="IFC2X3")
|
|
tool.Ifc.set(ifc)
|
|
reference = ifc.createIfcDocumentReference(Location="Location")
|
|
document = ifc.createIfcDocumentInformation(
|
|
DocumentId="X", Name="FOOBAR", Scope="SHEET", DocumentReferences=[reference]
|
|
)
|
|
assert subject.get_document_uri(document) == os.path.abspath(os.path.join(tool.Ifc.get_path(), "Location"))
|
|
assert subject.get_document_uri(reference) == os.path.abspath(os.path.join(tool.Ifc.get_path(), "Location"))
|
|
|
|
|
|
class TestGetDrawingCollection(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
obj = bpy.data.objects.new("Object", None)
|
|
collection = bpy.data.collections.new("Collection")
|
|
bpy.context.scene.collection.children.link(collection)
|
|
collection.objects.link(obj)
|
|
element = ifc.createIfcAnnotation()
|
|
tool.Ifc.link(element, obj)
|
|
assert subject.get_drawing_collection(element) == collection
|
|
|
|
|
|
class TestGetDrawingGroup(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
element = ifc.createIfcAnnotation()
|
|
group = ifcopenshell.api.run("group.add_group", ifc)
|
|
ifcopenshell.api.run("group.assign_group", ifc, products=[element], group=group)
|
|
assert subject.get_drawing_group(element) == group
|
|
|
|
|
|
class TestGetDrawingTargetView(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
element = ifc.createIfcAnnotation()
|
|
pset = ifcopenshell.api.run("pset.add_pset", ifc, product=element, name="EPset_Drawing")
|
|
ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"TargetView": "PLAN_VIEW"})
|
|
assert subject.get_drawing_target_view(element) == "PLAN_VIEW"
|
|
|
|
|
|
class TestGetGroupElements(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
element = ifc.createIfcAnnotation()
|
|
group = ifcopenshell.api.run("group.add_group", ifc)
|
|
ifcopenshell.api.run("group.assign_group", ifc, products=[element], group=group)
|
|
assert subject.get_group_elements(group) == (element,)
|
|
|
|
|
|
class TestGetIfcRepresentationClass(NewFile):
|
|
def test_run(self):
|
|
assert subject.get_ifc_representation_class("TEXT") == "IfcTextLiteral"
|
|
assert subject.get_ifc_representation_class("TEXT_LEADER") == "IfcGeometricCurveSet/IfcTextLiteral"
|
|
assert subject.get_ifc_representation_class("FOOBAR") == ""
|
|
|
|
|
|
class TestGetName(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
assert subject.get_name(ifc.createIfcWall(Name="Foobar")) == "Foobar"
|
|
|
|
|
|
class TestGenerateDrawingMatrix(NewFile):
|
|
def test_returning_the_origin_as_a_fallback(self):
|
|
assert subject.generate_drawing_matrix("PLAN_VIEW", None) == mathutils.Matrix()
|
|
|
|
def test_creating_a_plan_view_at_the_cursor_at_a_storey(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
obj = bpy.data.objects.new("Object", None)
|
|
element = ifc.createIfcBuildingStorey()
|
|
tool.Ifc.link(element, obj)
|
|
bpy.context.scene.collection.objects.link(obj)
|
|
obj.matrix_world[2][3] = 3
|
|
bpy.context.scene.cursor.location = (1.0, 2.0, 0.0)
|
|
m = subject.generate_drawing_matrix("PLAN_VIEW", element.id())
|
|
assert round(m[0][3], 3) == 1
|
|
assert round(m[1][3], 3) == 2
|
|
assert round(m[2][3], 3) == 4.6
|
|
|
|
def test_creating_an_rcp_at_the_origin(self):
|
|
assert subject.generate_drawing_matrix("REFLECTED_PLAN_VIEW", None) == mathutils.Matrix(
|
|
((-1, 0, 0, 0), (0, 1, 0, 0), (0, 0, -1, 0), (0, 0, 0, 1))
|
|
)
|
|
|
|
def test_creating_an_rcp_at_the_cursor_at_a_storey(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
obj = bpy.data.objects.new("Object", None)
|
|
element = ifc.createIfcBuildingStorey()
|
|
tool.Ifc.link(element, obj)
|
|
bpy.context.scene.collection.objects.link(obj)
|
|
obj.matrix_world[2][3] = 3
|
|
bpy.context.scene.cursor.location = (1.0, 2.0, 0.0)
|
|
assert subject.generate_drawing_matrix("REFLECTED_PLAN_VIEW", element.id()) == mathutils.Matrix(
|
|
((-1, 0, 0, 1), (0, 1, 0, 2), (0, 0, -1, 3 + 1.6), (0, 0, 0, 1))
|
|
)
|
|
|
|
def test_creating_a_north_elevation_at_the_cursor(self):
|
|
bpy.context.scene.cursor.location = (1.0, 2.0, 3.0)
|
|
assert subject.generate_drawing_matrix("ELEVATION_VIEW", "NORTH") == mathutils.Matrix(
|
|
((-1, 0, 0, 1), (0, 0, 1, 2), (0, 1, 0, 3), (0, 0, 0, 1))
|
|
)
|
|
|
|
def test_creating_a_south_elevation_at_the_cursor(self):
|
|
bpy.context.scene.cursor.location = (1.0, 2.0, 3.0)
|
|
assert subject.generate_drawing_matrix("ELEVATION_VIEW", "SOUTH") == mathutils.Matrix(
|
|
((1, 0, 0, 1), (0, 0, -1, 2), (0, 1, 0, 3), (0, 0, 0, 1))
|
|
)
|
|
|
|
def test_creating_an_east_elevation_at_the_cursor(self):
|
|
bpy.context.scene.cursor.location = (1.0, 2.0, 3.0)
|
|
assert subject.generate_drawing_matrix("ELEVATION_VIEW", "EAST") == mathutils.Matrix(
|
|
((0, 0, 1, 1), (1, 0, 0, 2), (0, 1, 0, 3), (0, 0, 0, 1))
|
|
)
|
|
|
|
def test_creating_a_west_elevation_at_the_cursor(self):
|
|
bpy.context.scene.cursor.location = (1.0, 2.0, 3.0)
|
|
assert subject.generate_drawing_matrix("ELEVATION_VIEW", "WEST") == mathutils.Matrix(
|
|
((0, 0, -1, 1), (-1, 0, 0, 2), (0, 1, 0, 3), (0, 0, 0, 1))
|
|
)
|
|
|
|
def test_creating_a_north_section_at_the_cursor(self):
|
|
bpy.context.scene.cursor.location = (1.0, 2.0, 3.0)
|
|
assert subject.generate_drawing_matrix("SECTION_VIEW", "NORTH") == mathutils.Matrix(
|
|
((1, 0, 0, 1), (0, 0, -1, 2), (0, 1, 0, 3), (0, 0, 0, 1))
|
|
)
|
|
|
|
def test_creating_a_south_section_at_the_cursor(self):
|
|
bpy.context.scene.cursor.location = (1.0, 2.0, 3.0)
|
|
assert subject.generate_drawing_matrix("SECTION_VIEW", "SOUTH") == mathutils.Matrix(
|
|
((-1, 0, 0, 1), (0, 0, 1, 2), (0, 1, 0, 3), (0, 0, 0, 1))
|
|
)
|
|
|
|
def test_creating_an_east_section_at_the_cursor(self):
|
|
bpy.context.scene.cursor.location = (1.0, 2.0, 3.0)
|
|
assert subject.generate_drawing_matrix("SECTION_VIEW", "EAST") == mathutils.Matrix(
|
|
((0, 0, -1, 1), (-1, 0, 0, 2), (0, 1, 0, 3), (0, 0, 0, 1))
|
|
)
|
|
|
|
def test_creating_a_west_section_at_the_cursor(self):
|
|
bpy.context.scene.cursor.location = (1.0, 2.0, 3.0)
|
|
assert subject.generate_drawing_matrix("SECTION_VIEW", "WEST") == mathutils.Matrix(
|
|
((0, 0, 1, 1), (1, 0, 0, 2), (0, 1, 0, 3), (0, 0, 0, 1))
|
|
)
|
|
|
|
|
|
class TestGenerateSheetIdentification(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
subject.generate_sheet_identification() == "A01"
|
|
document = ifc.createIfcDocumentInformation()
|
|
subject.generate_sheet_identification() == "A02"
|
|
|
|
|
|
class TestGetTextLiteral(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
obj = bpy.data.objects.new("Object", None)
|
|
element = ifc.createIfcAnnotation()
|
|
element.Representation = ifc.createIfcProductDefinitionShape()
|
|
context = ifc.createIfcGeometricRepresentationSubContext(ContextType="Plan", ContextIdentifier="Annotation")
|
|
item = ifc.createIfcTextLiteralWithExtent(Literal="Literal", Path="RIGHT", BoxAlignment="bottom-left")
|
|
representation = ifc.createIfcShapeRepresentation(ContextOfItems=context, Items=[item])
|
|
element.Representation.Representations = [representation]
|
|
element.ObjectType = "TEXT" # TODO: double check if it's valid to set this
|
|
tool.Ifc.link(element, obj)
|
|
assert subject.get_text_literal(obj) == item
|
|
|
|
|
|
class TestGetAssignedProduct(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
wall = ifc.createIfcWall()
|
|
label = ifc.createIfcAnnotation()
|
|
ifcopenshell.api.run("drawing.assign_product", ifc, relating_product=wall, related_object=label)
|
|
assert subject.get_assigned_product(label) == wall
|
|
|
|
|
|
class TestImportDrawings(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
drawing = ifc.createIfcAnnotation(Name="FOOBAR", ObjectType="DRAWING")
|
|
pset = ifcopenshell.api.run("pset.add_pset", ifc, product=drawing, name="EPset_Drawing")
|
|
ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"TargetView": "PLAN_VIEW"})
|
|
subject.import_drawings()
|
|
props = bpy.context.scene.DocProperties
|
|
assert props.drawings[0].ifc_definition_id == drawing.id()
|
|
assert props.drawings[0].name == "FOOBAR"
|
|
assert props.drawings[0].target_view == "PLAN_VIEW"
|
|
|
|
|
|
class TestImportSchedules(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
ifc.createIfcDocumentInformation(Identification="Y", Name="FOOBAZ")
|
|
document = ifc.createIfcDocumentInformation(Identification="X", Name="FOOBAR", Scope="SCHEDULE")
|
|
subject.import_schedules()
|
|
props = bpy.context.scene.DocProperties
|
|
assert props.schedules[0].ifc_definition_id == document.id()
|
|
assert props.schedules[0].identification == "X"
|
|
assert props.schedules[0].name == "FOOBAR"
|
|
|
|
def test_run_ifc2x3(self):
|
|
ifc = ifcopenshell.file(schema="IFC2X3")
|
|
tool.Ifc.set(ifc)
|
|
ifc.createIfcDocumentInformation(DocumentId="Y", Name="FOOBAZ")
|
|
document = ifc.createIfcDocumentInformation(DocumentId="X", Name="FOOBAR", Scope="SCHEDULE")
|
|
subject.import_schedules()
|
|
props = bpy.context.scene.DocProperties
|
|
assert props.schedules[0].ifc_definition_id == document.id()
|
|
assert props.schedules[0].identification == "X"
|
|
assert props.schedules[0].name == "FOOBAR"
|
|
|
|
|
|
class TestImportSheets(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
ifc.createIfcDocumentInformation(Identification="Y", Name="FOOBAZ")
|
|
document = ifc.createIfcDocumentInformation(Identification="X", Name="FOOBAR", Scope="SHEET")
|
|
subject.import_sheets()
|
|
props = bpy.context.scene.DocProperties
|
|
assert props.sheets[0].ifc_definition_id == document.id()
|
|
assert props.sheets[0].identification == "X"
|
|
assert props.sheets[0].name == "FOOBAR"
|
|
|
|
def test_run_ifc2x3(self):
|
|
ifc = ifcopenshell.file(schema="IFC2X3")
|
|
tool.Ifc.set(ifc)
|
|
ifc.createIfcDocumentInformation(DocumentId="Y", Name="FOOBAZ")
|
|
document = ifc.createIfcDocumentInformation(DocumentId="X", Name="FOOBAR", Scope="SHEET")
|
|
subject.import_sheets()
|
|
props = bpy.context.scene.DocProperties
|
|
assert props.sheets[0].ifc_definition_id == document.id()
|
|
assert props.sheets[0].identification == "X"
|
|
assert props.sheets[0].name == "FOOBAR"
|
|
|
|
|
|
class TestImportTextAttributes(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
obj = bpy.data.objects.new("Object", None)
|
|
element = ifc.createIfcAnnotation()
|
|
element.Representation = ifc.createIfcProductDefinitionShape()
|
|
context = ifc.createIfcGeometricRepresentationSubContext(ContextType="Plan", ContextIdentifier="Annotation")
|
|
item = ifc.createIfcTextLiteralWithExtent(Literal="Literal", Path="RIGHT", BoxAlignment="bottom-left")
|
|
representation = ifc.createIfcShapeRepresentation(ContextOfItems=context, Items=[item])
|
|
element.Representation.Representations = [representation]
|
|
element.ObjectType = "TEXT" # TODO: double check if it's valid to set this
|
|
tool.Ifc.link(element, obj)
|
|
subject.import_text_attributes(obj)
|
|
literal_props = obj.BIMTextProperties.literals[0]
|
|
assert literal_props.attributes.get("Literal").string_value == "Literal"
|
|
assert literal_props.attributes.get("Path").enum_value == "RIGHT"
|
|
assert literal_props.attributes.get("BoxAlignment").string_value == "bottom-left"
|
|
|
|
|
|
class TestImportAssignedProduct(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
wall = ifc.createIfcWall()
|
|
label = ifc.createIfcAnnotation()
|
|
ifcopenshell.api.run("drawing.assign_product", ifc, relating_product=wall, related_object=label)
|
|
wall_obj = bpy.data.objects.new("Object", None)
|
|
label_obj = bpy.data.objects.new("Object", None)
|
|
tool.Ifc.link(wall, wall_obj)
|
|
tool.Ifc.link(label, label_obj)
|
|
subject.import_assigned_product(label_obj)
|
|
assert label_obj.BIMAssignedProductProperties.relating_product == wall_obj
|
|
|
|
def test_doing_nothing_if_no_product_to_import(self):
|
|
ifc = ifcopenshell.file()
|
|
tool.Ifc.set(ifc)
|
|
label = ifc.createIfcAnnotation()
|
|
label_obj = bpy.data.objects.new("Object", None)
|
|
tool.Ifc.link(label, label_obj)
|
|
subject.import_assigned_product(label_obj)
|
|
assert label_obj.BIMAssignedProductProperties.relating_product is None
|
|
|
|
|
|
class TestOpenSchedule(NewFile):
|
|
def open_spreadsheet(self):
|
|
pass
|
|
|
|
|
|
class TestOpenSvg(NewFile):
|
|
def test_nothing(self):
|
|
pass
|
|
|
|
|
|
class TestRunRootAssignClassOperator(NewFile):
|
|
def test_nothing(self):
|
|
pass
|
|
|
|
|
|
class TestSetDrawingCollectionName(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
group = ifc.createIfcGroup(Name="Foobaz")
|
|
collection = bpy.data.collections.new("Foobar")
|
|
subject.set_drawing_collection_name(group, collection)
|
|
assert collection.name == "IfcGroup/Foobaz"
|
|
|
|
|
|
class TestSetName(NewFile):
|
|
def test_run(self):
|
|
ifc = ifcopenshell.file()
|
|
drawing = ifc.createIfcAnnotation()
|
|
subject.set_name(drawing, "Name")
|
|
assert drawing.Name == "Name"
|
|
|
|
|
|
class TestShowDecorations(NewFile):
|
|
def test_run(self):
|
|
bpy.context.scene.DocProperties.should_draw_decorations = False
|
|
subject.show_decorations()
|
|
assert bpy.context.scene.DocProperties.should_draw_decorations is True
|
|
|
|
|
|
class TestDrawingMaintainingSheetPosition(NewFile):
|
|
def get_sheet_drawing_data(self, layout_path):
|
|
SVG = "{http://www.w3.org/2000/svg}"
|
|
ET.register_namespace("", SVG)
|
|
layout_tree = ET.parse(layout_path)
|
|
layout_root = layout_tree.getroot()
|
|
|
|
drawing_view = layout_root.findall(f'{SVG}g[@data-type="drawing"]')[0]
|
|
|
|
drawing_data = {}
|
|
for image in drawing_view.findall(f"{SVG}image"):
|
|
attribs = ["x", "y", "width", "height"]
|
|
image_type = image.attrib["data-type"]
|
|
drawing_data[image_type] = tuple([round(float(image.attrib[attr]), 2) for attr in attribs])
|
|
|
|
return drawing_data
|
|
|
|
def test_run(self):
|
|
bpy.ops.bim.create_project()
|
|
ifc = tool.Ifc.get()
|
|
sheet_path = Path.cwd() / "layouts" / "A00 - UNTITLED.svg"
|
|
|
|
bpy.ops.bim.load_sheets()
|
|
bpy.ops.bim.add_sheet()
|
|
|
|
bpy.ops.bim.load_drawings()
|
|
bpy.ops.bim.add_drawing()
|
|
|
|
drawing = ifc.by_type("IfcAnnotation")[0]
|
|
bpy.ops.bim.activate_drawing(drawing=drawing.id())
|
|
bpy.ops.bim.create_drawing()
|
|
bpy.ops.bim.add_drawing_to_sheet()
|
|
bpy.ops.bim.open_sheet()
|
|
|
|
# check drawing default position
|
|
drawing_data = self.get_sheet_drawing_data(sheet_path)
|
|
assert drawing_data["foreground"] == (30.0, 30.0, 500.0, 500.0)
|
|
assert drawing_data["view-title"] == (30.0, 535.0, 50.22, 10.0)
|
|
|
|
bpy.context.scene.camera.data.BIMCameraProperties.raster_x = 1200
|
|
bpy.ops.bim.create_drawing()
|
|
bpy.ops.bim.open_sheet()
|
|
|
|
assert sheet_path.is_file(), f"Sheet path {sheet_path} doesn't exist"
|
|
|
|
# check drawing position on the sheet
|
|
drawing_data = self.get_sheet_drawing_data(sheet_path)
|
|
assert drawing_data["foreground"] == (30.0, 71.67, 500.0, 416.67)
|
|
assert drawing_data["view-title"] == (30.0, 493.33, 50.22, 10.0)
|
|
|
|
|
|
class TestUpdateTextValue(NewFile):
|
|
def test_updating_arbitrary_strings(self):
|
|
TestGetTextLiteral().test_run()
|
|
ifc = tool.Ifc.get()
|
|
|
|
obj = bpy.data.objects.get("Object")
|
|
subject.update_text_value(obj)
|
|
literal = obj.BIMTextProperties.literals[0]
|
|
|
|
assert obj.BIMTextProperties.font_size == "2.5"
|
|
assert literal.value == "Literal"
|
|
assert literal.box_alignment[:] == tuple([False] * 6 + [True] + [False] * 2)
|
|
assert literal.ifc_definition_id == ifc.by_type("IfcTextLiteralWithExtent")[0].id()
|
|
|
|
def test_using_attribute_variables(self):
|
|
TestGetTextLiteral().test_run()
|
|
|
|
obj = bpy.data.objects.get("Object")
|
|
ifc = tool.Ifc.get()
|
|
wall = ifc.createIfcWall(Name="Baz")
|
|
label = ifc.by_type("IfcAnnotation")[0]
|
|
ifcopenshell.api.run("drawing.assign_product", ifc, relating_product=wall, related_object=label)
|
|
|
|
ifc.by_type("IfcTextLiteralWithExtent")[0].Literal = "Foo {{Name}} Bar"
|
|
|
|
subject.update_text_value(obj)
|
|
assert obj.BIMTextProperties.literals[0].value == "Foo Baz Bar"
|
|
|
|
def test_using_property_variables(self):
|
|
TestGetTextLiteral().test_run()
|
|
|
|
obj = bpy.data.objects.get("Object")
|
|
ifc = tool.Ifc.get()
|
|
wall = ifc.createIfcWall()
|
|
pset = ifcopenshell.api.run("pset.add_pset", ifc, name="Custom_Pset", product=wall)
|
|
ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Key": "Baz"})
|
|
label = ifc.by_type("IfcAnnotation")[0]
|
|
ifcopenshell.api.run("drawing.assign_product", ifc, relating_product=wall, related_object=label)
|
|
|
|
ifc.by_type("IfcTextLiteralWithExtent")[0].Literal = "Foo {{Custom_Pset.Key}} Bar"
|
|
|
|
subject.update_text_value(obj)
|
|
assert obj.BIMTextProperties.literals[0].value == "Foo Baz Bar"
|
|
|
|
def test_update_text_font_size(self):
|
|
TestGetTextLiteral().test_run()
|
|
obj = bpy.data.objects.get("Object")
|
|
with bpy.context.temp_override(active_object=obj):
|
|
bpy.ops.bim.enable_editing_text()
|
|
obj.BIMTextProperties.font_size = "7.0"
|
|
bpy.ops.bim.edit_text()
|
|
annotation_classes = ifcopenshell.util.element.get_pset(tool.Ifc.get_entity(obj), "EPset_Annotation", "Classes")
|
|
assert "title" in annotation_classes
|
|
assert DecoratorData.get_ifc_text_data(obj)["FontSize"] == 7.0
|
|
|
|
def test_add_second_literal(self, setup=True):
|
|
if setup:
|
|
TestGetTextLiteral().test_run()
|
|
obj = bpy.data.objects.get("Object")
|
|
with bpy.context.temp_override(active_object=obj):
|
|
bpy.ops.bim.enable_editing_text()
|
|
bpy.ops.bim.add_text_literal()
|
|
literal = obj.BIMTextProperties.literals[1]
|
|
literal.attributes["Literal"].string_value = "test_value"
|
|
bpy.ops.bim.edit_text()
|
|
|
|
ifc = tool.Ifc.get()
|
|
assert ifc.by_type("IfcTextLiteralWithExtent")[1].Literal == "test_value"
|
|
|
|
def test_disable_text_editing(self):
|
|
# add second literal and change font size to test changing them
|
|
self.test_update_text_font_size() # sets font size to "7.0"
|
|
self.test_add_second_literal(setup=False)
|
|
|
|
obj = bpy.data.objects.get("Object")
|
|
props = obj.BIMTextProperties
|
|
assert obj is not None, obj
|
|
with bpy.context.temp_override(active_object=obj):
|
|
bpy.ops.bim.enable_editing_text()
|
|
bpy.ops.bim.remove_text_literal(1)
|
|
props.literals[0].attributes["Literal"].string_value = "changed_value"
|
|
props.font_size = "2.5"
|
|
bpy.ops.bim.disable_editing_text()
|
|
|
|
ifc = tool.Ifc.get()
|
|
# test font size
|
|
annotation_classes = ifcopenshell.util.element.get_pset(tool.Ifc.get_entity(obj), "EPset_Annotation", "Classes")
|
|
assert props.font_size == "7.0"
|
|
assert "title" in annotation_classes
|
|
assert DecoratorData.get_ifc_text_data(obj)["FontSize"] == 7.0
|
|
|
|
# test second literal is present
|
|
assert props.literals[1].attributes["Literal"].string_value == "test_value"
|
|
assert ifc.by_type("IfcTextLiteralWithExtent")[1].Literal == "test_value"
|
|
|
|
# test first literal value is unchanged
|
|
assert props.literals[0].attributes["Literal"].string_value == "Literal"
|
|
assert ifc.by_type("IfcTextLiteralWithExtent")[0].Literal == "Literal"
|
|
|
|
|
|
class TestDrawingStyles(NewFile):
|
|
def setup_project_with_drawing(self):
|
|
bpy.ops.bim.create_project()
|
|
bpy.ops.bim.load_drawings()
|
|
bpy.ops.bim.add_drawing()
|
|
ifc = tool.Ifc.get()
|
|
drawing = ifc.by_type("IfcAnnotation")[0]
|
|
bpy.ops.bim.activate_drawing(drawing=drawing.id())
|
|
self.drawing_styles = bpy.context.scene.DocProperties.drawing_styles
|
|
|
|
def test_drawing_styles_not_loaded_if_underlay_is_inactive(self):
|
|
self.setup_project_with_drawing()
|
|
assert len(self.drawing_styles) == 0
|
|
|
|
def test_drawing_styles_loaded_on_underlay_enabled(self):
|
|
self.setup_project_with_drawing()
|
|
bpy.context.scene.camera.data.BIMCameraProperties.has_underlay = True
|
|
assert len(self.drawing_styles) == 3
|
|
|
|
def test_drawing_styles_reload(self):
|
|
self.setup_project_with_drawing()
|
|
bpy.ops.bim.reload_drawing_styles()
|
|
assert len(self.drawing_styles) == 3
|
|
|
|
|