diff --git a/src/blenderbim/blenderbim/bim/module/model/wall.py b/src/blenderbim/blenderbim/bim/module/model/wall.py index d75c2feb69..8f55ea18c1 100644 --- a/src/blenderbim/blenderbim/bim/module/model/wall.py +++ b/src/blenderbim/blenderbim/bim/module/model/wall.py @@ -1045,6 +1045,8 @@ class WallPrototypeVTX(bpy.types.Operator): selected_objects = [o for o in context.selected_objects if tool.Ifc.get_entity(o)] if len(selected_objects) == 1: self.join_E(context.active_object, context.scene.cursor.location) + elif len(selected_objects) == 2: + self.join_L([o for o in selected_objects if o != context.active_object][0], context.active_object) elif len(selected_objects) >= 2: for obj in selected_objects: if obj == context.active_object: @@ -1055,47 +1057,98 @@ class WallPrototypeVTX(bpy.types.Operator): self.join_T(obj, context.active_object) return {"FINISHED"} + def join_L(self, wall1, wall2): + element1 = tool.Ifc.get_entity(wall1) + element2 = tool.Ifc.get_entity(wall2) + axis1 = self.get_wall_axis(wall1) + axis2 = self.get_wall_axis(wall2) + intersect, _ = tool.Cad.intersect_edges(axis1["reference"], axis2["reference"]) + wall1_end = "ATEND" if tool.Cad.edge_percent(intersect, axis1["reference"]) > 0.5 else "ATSTART" + wall2_end = "ATEND" if tool.Cad.edge_percent(intersect, axis2["reference"]) > 0.5 else "ATSTART" + + ifcopenshell.api.run( + "geometry.connect_path", + tool.Ifc.get(), + relating_element=element1, + related_element=element2, + relating_connection=wall1_end, + related_connection=wall2_end, + ) + + self.recreate_wall(element1, wall1, axis1["reference"], axis1["reference"]) + self.recreate_wall(element2, wall2, axis2["reference"], axis2["reference"]) + def join_E(self, wall1, target): element1 = tool.Ifc.get_entity(wall1) if not element1: return axis1 = self.get_wall_axis(wall1) - intersect, which_end = mathutils.geometry.intersect_point_line(target.to_2d(), *axis1["reference"]) - which_end = "ATEND" if which_end > 0.5 else "ATSTART" + intersect, connection = mathutils.geometry.intersect_point_line(target.to_2d(), *axis1["reference"]) + connection = "ATEND" if connection > 0.5 else "ATSTART" ifcopenshell.api.run( - "geometry.disconnect_path", tool.Ifc.get(), related_element=element1, connection_type=which_end + "geometry.disconnect_path", tool.Ifc.get(), element=element1, connection_type=connection ) - self.axis = axis1["reference"].copy() - self.body = axis1["reference"].copy() - height = self.get_height(tool.Ifc.get().by_id(wall1.data.BIMMeshProperties.ifc_definition_id)) + axis = axis1["reference"].copy() + body = axis1["reference"].copy() + axis[1 if connection == "ATEND" else 0] = intersect + body[1 if connection == "ATEND" else 0] = intersect + self.recreate_wall(element1, wall1, axis, body) + + def join_T(self, wall1, wall2): + element1 = tool.Ifc.get_entity(wall1) + element2 = tool.Ifc.get_entity(wall2) + axis1 = self.get_wall_axis(wall1) + axis2 = self.get_wall_axis(wall2) + intersect, _ = tool.Cad.intersect_edges(axis1["reference"], axis2["reference"]) + connection = "ATEND" if tool.Cad.edge_percent(intersect, axis1["reference"]) > 0.5 else "ATSTART" + + ifcopenshell.api.run( + "geometry.connect_path", + tool.Ifc.get(), + related_element=element1, + relating_element=element2, + relating_connection="ATPATH", + related_connection=connection, + ) + + self.recreate_wall(element1, wall1, axis1["reference"], axis1["reference"]) + + def recreate_wall(self, element, obj, axis, body): + self.axis = axis.copy() + self.body = body.copy() + height = self.get_height(tool.Ifc.get().by_id(obj.data.BIMMeshProperties.ifc_definition_id)) self.clippings = [] - layers1 = get_material_layer_parameters(element1) + layers = get_material_layer_parameters(element) - self.axis[1 if which_end == "ATEND" else 0] = intersect - self.body[1 if which_end == "ATEND" else 0] = intersect + for rel in element.ConnectedTo: + connection = rel.RelatingConnectionType + other = tool.Ifc.get_object(rel.RelatedElement) + if connection not in ["ATPATH", "NOTDEFINED"]: + self.join(obj, other, connection, is_relating=True) + for rel in element.ConnectedFrom: + connection = rel.RelatedConnectionType + other = tool.Ifc.get_object(rel.RelatingElement) + if connection not in ["ATPATH", "NOTDEFINED"]: + self.join(obj, other, connection, is_relating=False) - for rel in element1.ConnectedFrom: - self.join(wall1, tool.Ifc.get_object(rel.RelatingElement)) + new_matrix = obj.matrix_world.copy() + new_matrix.col[3] = self.body[0].to_4d() + new_matrix.invert() + self.clippings = [new_matrix @ c for c in self.clippings] - height = self.get_height(tool.Ifc.get().by_id(wall1.data.BIMMeshProperties.ifc_definition_id)) - self.recreate_wall( - wall1, self.body[0], self.body[1], height, layers1["thickness"], layers1["offset"], self.clippings - ) - - def recreate_wall(self, obj, start, end, height, thickness, offset=0, clippings=None): - length = (end - start).length + length = (self.body[1] - self.body[0]).length new_representation = ifcopenshell.api.run( "geometry.add_wall_representation", tool.Ifc.get(), context=self.body_context, length=length, height=height, - offset=offset, - thickness=thickness, - clippings=clippings or [], + offset=layers["offset"], + thickness=layers["thickness"], + clippings=self.clippings, ) old_representation = tool.Ifc.get().by_id(obj.data.BIMMeshProperties.ifc_definition_id) @@ -1116,7 +1169,7 @@ class WallPrototypeVTX(bpy.types.Operator): is_global=True, should_sync_changes_first=False, ) - obj.location[0], obj.location[1] = start + obj.location[0], obj.location[1] = self.body[0] def create_matrix(self, p, x, y, z): return Matrix( @@ -1163,35 +1216,8 @@ class WallPrototypeVTX(bpy.types.Operator): break return height - def join_T(self, wall1, wall2): - element1 = tool.Ifc.get_entity(wall1) - element2 = tool.Ifc.get_entity(wall2) - axis1 = self.get_wall_axis(wall1) - axis2 = self.get_wall_axis(wall2) - intersect, _ = tool.Cad.intersect_edges(axis1["reference"], axis2["reference"]) - which_end = "ATEND" if tool.Cad.edge_percent(intersect, axis1["reference"]) > 0.5 else "ATSTART" - - ifcopenshell.api.run( - "geometry.connect_path", - tool.Ifc.get(), - related_element=element1, - relating_element=element2, - relating_connection="ATPATH", - related_connection=which_end, - ) - - self.axis = axis1["reference"].copy() - self.body = axis1["reference"].copy() - height = self.get_height(tool.Ifc.get().by_id(wall1.data.BIMMeshProperties.ifc_definition_id)) - self.clippings = [] - layers1 = get_material_layer_parameters(element1) - for rel in element1.ConnectedFrom: - self.join(wall1, tool.Ifc.get_object(rel.RelatingElement)) - self.recreate_wall( - wall1, self.body[0], self.body[1], height, layers1["thickness"], layers1["offset"], self.clippings - ) - - def join(self, wall1, wall2): + def join(self, wall1, wall2, connection, is_relating=True): + print('going to join', wall1, wall2, connection, is_relating) element1 = tool.Ifc.get_entity(wall1) element2 = tool.Ifc.get_entity(wall2) layers1 = get_material_layer_parameters(element1) @@ -1205,8 +1231,7 @@ class WallPrototypeVTX(bpy.types.Operator): # Work out axis line intersect, _ = tool.Cad.intersect_edges(axis1["reference"], axis2["reference"]) - which_end = "ATEND" if tool.Cad.edge_percent(intersect, axis1["reference"]) > 0.5 else "ATSTART" - self.axis[1 if which_end == "ATEND" else 0] = intersect + self.axis[1 if connection == "ATEND" else 0] = intersect # Work out body extents intersect1, _ = tool.Cad.intersect_edges(axis1["base"], axis2["base"]) @@ -1217,14 +1242,18 @@ class WallPrototypeVTX(bpy.types.Operator): intersect12 = intersect1.lerp(intersect2, 0.5) intersect34 = intersect3.lerp(intersect4, 0.5) - which_end = "ATEND" if tool.Cad.edge_percent(intersect12, axis1["base"]) > 0.5 else "ATSTART" - - if which_end == "ATEND": - base_target = tool.Cad.closest_vector(axis1["base"][0], (intersect1, intersect2)) + if connection == "ATEND": + if is_relating: + base_target = tool.Cad.furthest_vector(axis1["base"][0], (intersect1, intersect2)) + else: + base_target = tool.Cad.closest_vector(axis1["base"][0], (intersect1, intersect2)) if tool.Cad.is_x(angle, 90): self.body[1] = tool.Cad.point_on_edge(base_target, axis1["reference"]) else: - side_target = tool.Cad.closest_vector(axis1["side"][0], (intersect3, intersect4)) + if is_relating: + side_target = tool.Cad.furthest_vector(axis1["side"][0], (intersect3, intersect4)) + else: + side_target = tool.Cad.closest_vector(axis1["side"][0], (intersect3, intersect4)) base_percent = tool.Cad.edge_percent(base_target, axis1["base"]) side_percent = tool.Cad.edge_percent(side_target, axis1["side"]) if base_percent > side_percent: @@ -1233,24 +1262,26 @@ class WallPrototypeVTX(bpy.types.Operator): x_axis = (side_target - base_target).normalized().to_3d() y_axis = Vector((0, 0, 1)) z_axis = x_axis.cross(y_axis) - new_matrix = wall1.matrix_world.copy() - new_matrix.col[3] = self.body[0].to_4d() - self.clippings.append(new_matrix.inverted() @ self.create_matrix(clip, x_axis, y_axis, z_axis)) + self.clippings.append(self.create_matrix(clip, x_axis, y_axis, z_axis)) else: self.body[1] = tool.Cad.point_on_edge(side_target, axis1["reference"]) clip = base_target.to_3d() x_axis = (side_target - base_target).normalized().to_3d() y_axis = Vector((0, 0, 1)) z_axis = x_axis.cross(y_axis) - new_matrix = wall1.matrix_world.copy() - new_matrix.col[3] = self.body[0].to_4d() - self.clippings.append(new_matrix.inverted() @ self.create_matrix(clip, x_axis, y_axis, z_axis)) + self.clippings.append(self.create_matrix(clip, x_axis, y_axis, z_axis)) else: - base_target = tool.Cad.closest_vector(axis1["base"][1], (intersect1, intersect2)) + if is_relating: + base_target = tool.Cad.furthest_vector(axis1["base"][1], (intersect1, intersect2)) + else: + base_target = tool.Cad.closest_vector(axis1["base"][1], (intersect1, intersect2)) if tool.Cad.is_x(angle, 90): self.body[0] = tool.Cad.point_on_edge(base_target, axis1["reference"]) else: - side_target = tool.Cad.closest_vector(axis1["side"][1], (intersect3, intersect4)) + if is_relating: + side_target = tool.Cad.furthest_vector(axis1["side"][1], (intersect3, intersect4)) + else: + side_target = tool.Cad.closest_vector(axis1["side"][1], (intersect3, intersect4)) base_percent = tool.Cad.edge_percent(base_target, axis1["base"]) side_percent = tool.Cad.edge_percent(side_target, axis1["side"]) if base_percent < side_percent: @@ -1259,18 +1290,14 @@ class WallPrototypeVTX(bpy.types.Operator): x_axis = (side_target - base_target).normalized().to_3d() y_axis = Vector((0, 0, 1)) z_axis = y_axis.cross(x_axis) - new_matrix = wall1.matrix_world.copy() - new_matrix.col[3] = self.body[0].to_4d() - self.clippings.append(new_matrix.inverted() @ self.create_matrix(clip, x_axis, y_axis, z_axis)) + self.clippings.append(self.create_matrix(clip, x_axis, y_axis, z_axis)) else: self.body[0] = tool.Cad.point_on_edge(side_target, axis1["reference"]) clip = base_target.to_3d() x_axis = (side_target - base_target).normalized().to_3d() y_axis = Vector((0, 0, 1)) z_axis = y_axis.cross(x_axis) - new_matrix = wall1.matrix_world.copy() - new_matrix.col[3] = self.body[0].to_4d() - self.clippings.append(new_matrix.inverted() @ self.create_matrix(clip, x_axis, y_axis, z_axis)) + self.clippings.append(self.create_matrix(clip, x_axis, y_axis, z_axis)) def get_material_layer_parameters(element): diff --git a/src/blenderbim/blenderbim/tool/cad.py b/src/blenderbim/blenderbim/tool/cad.py index dc03a4c13b..d33300fe6c 100644 --- a/src/blenderbim/blenderbim/tool/cad.py +++ b/src/blenderbim/blenderbim/tool/cad.py @@ -145,8 +145,7 @@ class Cad: """ > pt: vector > e: 2 vector tuple - < returns: - pt, 2 vector tuple: returns closest vector to pt + < returns either v1 or v2 in e, whichever is closest to pt if both points in e are equally far from pt, then v1 is returned. """ @@ -155,7 +154,19 @@ class Cad: distance_test = (v1 - pt).length <= (v2 - pt).length return v1 if distance_test else v2 - print("received {0}, check expected input in docstring ".format(e)) + @classmethod + def furthest_vector(cls, pt, e): + """ + > pt: vector + > e: 2 vector tuple + < returns either v1 or v2 in e, whichever is furthest from pt + + if both points in e are equally far from pt, then v1 is returned. + """ + if isinstance(e, tuple) and all([isinstance(co, Vector) for co in e]): + v1, v2 = e + distance_test = (v1 - pt).length >= (v2 - pt).length + return v1 if distance_test else v2 @classmethod def coords_tuple_from_edge_idx(cls, bm, idx): diff --git a/src/ifcopenshell-python/ifcopenshell/api/geometry/connect_path.py b/src/ifcopenshell-python/ifcopenshell/api/geometry/connect_path.py index 05028ee4cd..8450ab8e96 100644 --- a/src/ifcopenshell-python/ifcopenshell/api/geometry/connect_path.py +++ b/src/ifcopenshell-python/ifcopenshell/api/geometry/connect_path.py @@ -33,27 +33,42 @@ class Usecase: self.settings[key] = value def execute(self): - existing_connection = [ - r - for r in self.settings["relating_element"].ConnectedTo - if r.RelatedElement == self.settings["related_element"] - ] + incompatible_connections = [] + for rel in self.settings["relating_element"].ConnectedTo: + if rel.RelatedElement == self.settings["related_element"]: + incompatible_connections.append(rel) + elif ( + rel.RelatingConnectionType in ["ATSTART", "ATEND"] + and rel.RelatingConnectionType == self.settings["relating_connection"] + ): + incompatible_connections.append(rel) - if existing_connection: - existing_connection = existing_connection[0] - if existing_connection.RelatingConnectionType != self.settings["relating_connection"]: - existing_connection.RelatingConnectionType = self.settings["relating_connection"] - if existing_connection.RelatedConnectionType != self.settings["related_connection"]: - existing_connection.RelatedConnectionType = self.settings["related_connection"] - return existing_connection[0] + for rel in self.settings["relating_element"].ConnectedFrom: + if ( + rel.RelatedConnectionType in ["ATSTART", "ATEND"] + and rel.RelatedConnectionType == self.settings["relating_connection"] + ): + incompatible_connections.append(rel) - if [ - r - for r in self.settings["related_element"].ConnectedTo - if r.RelatedElement == self.settings["relating_element"] - ]: - # No cyclical connections allowed, I assume - return + for rel in self.settings["related_element"].ConnectedFrom: + if ( + rel.RelatedConnectionType in ["ATSTART", "ATEND"] + and rel.RelatedConnectionType == self.settings["related_connection"] + ): + incompatible_connections.append(rel) + + for rel in self.settings["related_element"].ConnectedTo: + if rel.RelatedElement == self.settings["relating_element"]: + incompatible_connections.append(rel) + elif ( + rel.RelatingConnectionType in ["ATSTART", "ATEND"] + and rel.RelatingConnectionType == self.settings["related_connection"] + ): + incompatible_connections.append(rel) + + if incompatible_connections: + for connection in set(incompatible_connections): + self.file.remove(connection) return self.file.createIfcRelConnectsPathElements( ifcopenshell.guid.new(), diff --git a/src/ifcopenshell-python/ifcopenshell/api/geometry/disconnect_path.py b/src/ifcopenshell-python/ifcopenshell/api/geometry/disconnect_path.py index d6b05f6132..d1b629ea5d 100644 --- a/src/ifcopenshell-python/ifcopenshell/api/geometry/disconnect_path.py +++ b/src/ifcopenshell-python/ifcopenshell/api/geometry/disconnect_path.py @@ -26,16 +26,29 @@ class Usecase: self.settings = { "relating_element": None, "related_element": None, + "element": None, + "connection_type": None, } for key, value in settings.items(): self.settings[key] = value def execute(self): - existing_connection = [ - r - for r in self.settings["relating_element"].ConnectedTo - if r.RelatedElement == self.settings["related_element"] - ] + if self.settings["connection_type"] and self.settings["element"]: + connections = [ + r + for r in self.settings["element"].ConnectedTo + if r.RelatingConnectionType == self.settings["connection_type"] + ] + [ + r + for r in self.settings["element"].ConnectedFrom + if r.RelatedConnectionType == self.settings["connection_type"] + ] + else: + connections = [ + r + for r in self.settings["relating_element"].ConnectedTo + if r.RelatedElement == self.settings["related_element"] + ] - if existing_connection: - self.file.remove(existing_connection[0]) + for connection in set(connections): + self.file.remove(connection) diff --git a/src/ifcopenshell-python/test/api/geometry/test_connect_path.py b/src/ifcopenshell-python/test/api/geometry/test_connect_path.py index e47121969d..440c407e89 100644 --- a/src/ifcopenshell-python/test/api/geometry/test_connect_path.py +++ b/src/ifcopenshell-python/test/api/geometry/test_connect_path.py @@ -24,14 +24,7 @@ class TestConnectPath(test.bootstrap.IFC4): def test_connecting_a_path(self): wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") - rel = ifcopenshell.api.run( - "geometry.connect_path", - self.file, - relating_element=wall1, - related_element=wall2, - relating_connection="ATSTART", - related_connection="ATEND", - ) + rel = self.connect_path(wall1, wall2, "ATSTART", "ATEND") assert rel.is_a("IfcRelConnectsPathElements") assert rel.RelatingElement == wall1 assert rel.RelatedElement == wall2 @@ -39,12 +32,21 @@ class TestConnectPath(test.bootstrap.IFC4): assert rel.RelatedConnectionType == "ATEND" def test_doing_nothing_if_the_element_is_already_connected(self): + wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + self.connect_path(wall1, wall2) + total_elements = len([e for e in self.file]) + self.connect_path(wall1, wall2) + assert len([e for e in self.file]) == total_elements + + def test_updating_the_connection_type_if_already_connected(self): wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") ifcopenshell.api.run("geometry.connect_path", self.file, relating_element=wall1, related_element=wall2) total_elements = len([e for e in self.file]) - ifcopenshell.api.run("geometry.connect_path", self.file, relating_element=wall1, related_element=wall2) - assert len([e for e in self.file]) == total_elements + rel = self.connect_path(wall1, wall2, "ATSTART") + assert rel.RelatingConnectionType == "ATSTART" + assert rel.RelatedConnectionType == "NOTDEFINED" def test_preventing_cyclical_connections(self): wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") @@ -53,3 +55,87 @@ class TestConnectPath(test.bootstrap.IFC4): total_elements = len([e for e in self.file]) ifcopenshell.api.run("geometry.connect_path", self.file, relating_element=wall2, related_element=wall1) assert len([e for e in self.file]) == total_elements + + def test_a_relating_element_can_have_multiple_path_connections(self): + wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall3 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + rel1 = self.connect_path(wall1, wall2, "ATPATH", "ATEND") + rel2 = self.connect_path(wall1, wall3, "ATPATH", "ATSTART") + assert len(self.file.by_type("IfcRelConnectsPathElements")) == 2 + assert rel1.RelatingElement == wall1 + assert rel1.RelatedElement == wall2 + assert rel1.RelatingConnectionType == "ATPATH" + assert rel1.RelatedConnectionType == "ATEND" + assert rel2.RelatingElement == wall1 + assert rel2.RelatedElement == wall3 + assert rel2.RelatingConnectionType == "ATPATH" + assert rel2.RelatedConnectionType == "ATSTART" + + def test_a_element_can_only_have_up_to_one_start_or_end_connections(self): + wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall3 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + rel1 = self.connect_path(wall1, wall2, "ATSTART", "ATEND") + rel2 = self.connect_path(wall1, wall3, "ATEND", "ATSTART") + assert len(self.file.by_type("IfcRelConnectsPathElements")) == 2 + + self.file = ifcopenshell.file() + wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall3 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + rel1 = self.connect_path(wall1, wall2, "ATSTART", "ATEND") + rel2 = self.connect_path(wall1, wall3, "ATSTART", "ATSTART") + assert len(self.file.by_type("IfcRelConnectsPathElements")) == 1 + + self.file = ifcopenshell.file() + wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall3 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + rel1 = self.connect_path(wall1, wall2, "ATEND", "ATEND") + rel2 = self.connect_path(wall1, wall3, "ATEND", "ATSTART") + assert len(self.file.by_type("IfcRelConnectsPathElements")) == 1 + + self.file = ifcopenshell.file() + wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall3 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + rel1 = self.connect_path(wall1, wall2, "ATPATH", "ATEND") + rel2 = self.connect_path(wall1, wall3, "ATPATH", "ATSTART") + assert len(self.file.by_type("IfcRelConnectsPathElements")) == 2 + + self.file = ifcopenshell.file() + wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall3 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + rel1 = self.connect_path(wall2, wall1, "ATPATH", "ATEND") + rel2 = self.connect_path(wall3, wall1, "ATPATH", "ATSTART") + assert len(self.file.by_type("IfcRelConnectsPathElements")) == 2 + + self.file = ifcopenshell.file() + wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall3 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + rel1 = self.connect_path(wall2, wall1, "ATPATH", "ATSTART") + rel2 = self.connect_path(wall3, wall1, "ATPATH", "ATSTART") + assert len(self.file.by_type("IfcRelConnectsPathElements")) == 1 + + self.file = ifcopenshell.file() + wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall3 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + rel1 = self.connect_path(wall2, wall1, "ATPATH", "ATEND") + rel2 = self.connect_path(wall3, wall1, "ATPATH", "ATEND") + assert len(self.file.by_type("IfcRelConnectsPathElements")) == 1 + + def connect_path( + self, relating_element, related_element, relating_connection="NOTDEFINED", related_connection="NOTDEFINED" + ): + return ifcopenshell.api.run( + "geometry.connect_path", + self.file, + relating_element=relating_element, + related_element=related_element, + relating_connection=relating_connection, + related_connection=related_connection, + ) diff --git a/src/ifcopenshell-python/test/api/geometry/test_disconnect_path.py b/src/ifcopenshell-python/test/api/geometry/test_disconnect_path.py index e6927f9cc4..9c0aacbd31 100644 --- a/src/ifcopenshell-python/test/api/geometry/test_disconnect_path.py +++ b/src/ifcopenshell-python/test/api/geometry/test_disconnect_path.py @@ -28,6 +28,32 @@ class TestDisconnectPath(test.bootstrap.IFC4): ifcopenshell.api.run("geometry.disconnect_path", self.file, relating_element=wall1, related_element=wall2) assert not self.file.by_type("IfcRelConnectsPathElements") + def test_disconnecting_by_connection_type(self): + wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") + ifcopenshell.api.run( + "geometry.connect_path", + self.file, + relating_element=wall1, + related_element=wall2, + relating_connection="ATSTART", + related_connection="ATEND", + ) + ifcopenshell.api.run("geometry.disconnect_path", self.file, element=wall1, connection_type="ATEND") + assert self.file.by_type("IfcRelConnectsPathElements") + ifcopenshell.api.run("geometry.disconnect_path", self.file, element=wall1, connection_type="ATSTART") + assert not self.file.by_type("IfcRelConnectsPathElements") + ifcopenshell.api.run( + "geometry.connect_path", + self.file, + relating_element=wall1, + related_element=wall2, + relating_connection="ATSTART", + related_connection="ATEND", + ) + ifcopenshell.api.run("geometry.disconnect_path", self.file, element=wall2, connection_type="ATEND") + assert not self.file.by_type("IfcRelConnectsPathElements") + def test_doing_nothing_if_there_is_no_connection(self): wall1 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall") wall2 = ifcopenshell.api.run("root.create_entity", self.file, ifc_class="IfcWall")