Implement connection aware wall L-joints

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"])
+        intersect, connection = mathutils.geometry.intersect_point_line(target.to_2d(), *axis1["reference"])
-        which_end = "ATEND" if which_end > 0.5 else "ATSTART"
+        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()
+        axis = axis1["reference"].copy()
-        self.body = axis1["reference"].copy()
+        body = axis1["reference"].copy()
-        height = self.get_height(tool.Ifc.get().by_id(wall1.data.BIMMeshProperties.ifc_definition_id))
+        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
+        for rel in element.ConnectedTo:
-        self.body[1 if which_end == "ATEND" else 0] = intersect
+            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:
+        new_matrix = obj.matrix_world.copy()
-            self.join(wall1, tool.Ifc.get_object(rel.RelatingElement))
+        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))
+        length = (self.body[1] - self.body[0]).length
-        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
         new_representation = ifcopenshell.api.run(
             "geometry.add_wall_representation",
             tool.Ifc.get(),
             context=self.body_context,
             length=length,
             height=height,
-            offset=offset,
+            offset=layers["offset"],
-            thickness=thickness,
+            thickness=layers["thickness"],
-            clippings=clippings or [],
+            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):
+    def join(self, wall1, wall2, connection, is_relating=True):
-        element1 = tool.Ifc.get_entity(wall1)
+        print('going to join', wall1, wall2, connection, is_relating)
-        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):
         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 connection == "ATEND" else 0] = intersect
-        self.axis[1 if which_end == "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 connection == "ATEND":
-
+            if is_relating:
-        if which_end == "ATEND":
+                base_target = tool.Cad.furthest_vector(axis1["base"][0], (intersect1, intersect2))
-            base_target = tool.Cad.closest_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()
+                    self.clippings.append(self.create_matrix(clip, x_axis, y_axis, z_axis))
-                    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))
                 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()
+                    self.clippings.append(self.create_matrix(clip, x_axis, y_axis, z_axis))
-                    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))
         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()
+                    self.clippings.append(self.create_matrix(clip, x_axis, y_axis, z_axis))
-                    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))
                 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()
+                    self.clippings.append(self.create_matrix(clip, x_axis, y_axis, z_axis))
-                    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))
 
 
 def get_material_layer_parameters(element):

src/blenderbim/blenderbim/tool/cad.py

@@ -145,8 +145,7 @@ class Cad:
         """
         > pt:       vector
         > e:        2 vector tuple
-        < returns:
+        < returns either v1 or v2 in e, whichever is closest to pt
-        pt, 2 vector tuple: returns closest vector 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):

src/ifcopenshell-python/ifcopenshell/api/geometry/connect_path.py

@@ -33,27 +33,42 @@ class Usecase:
             self.settings[key] = value
 
     def execute(self):
-        existing_connection = [
+        incompatible_connections = []
-            r
+        for rel in self.settings["relating_element"].ConnectedTo:
-            for r in self.settings["relating_element"].ConnectedTo
+            if rel.RelatedElement == self.settings["related_element"]:
-            if r.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:
+        for rel in self.settings["relating_element"].ConnectedFrom:
-            existing_connection = existing_connection[0]
+            if (
-            if existing_connection.RelatingConnectionType != self.settings["relating_connection"]:
+                rel.RelatedConnectionType in ["ATSTART", "ATEND"]
-                existing_connection.RelatingConnectionType = self.settings["relating_connection"]
+                and rel.RelatedConnectionType == self.settings["relating_connection"]
-            if existing_connection.RelatedConnectionType != self.settings["related_connection"]:
+            ):
-                existing_connection.RelatedConnectionType = self.settings["related_connection"]
+                incompatible_connections.append(rel)
-            return existing_connection[0]
 
-        if [
+        for rel in self.settings["related_element"].ConnectedFrom:
-            r
+            if (
-            for r in self.settings["related_element"].ConnectedTo
+                rel.RelatedConnectionType in ["ATSTART", "ATEND"]
-            if r.RelatedElement == self.settings["relating_element"]
+                and rel.RelatedConnectionType == self.settings["related_connection"]
-        ]:
+            ):
-            # No cyclical connections allowed, I assume
+                incompatible_connections.append(rel)
-            return
+
+        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(),

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 = [
+        if self.settings["connection_type"] and self.settings["element"]:
-            r
+            connections = [
-            for r in self.settings["relating_element"].ConnectedTo
+                r
-            if r.RelatedElement == self.settings["related_element"]
+                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:
+        for connection in set(connections):
-            self.file.remove(existing_connection[0])
+            self.file.remove(connection)

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(
+        rel = self.connect_path(wall1, wall2, "ATSTART", "ATEND")
-            "geometry.connect_path",
-            self.file,
-            relating_element=wall1,
-            related_element=wall2,
-            relating_connection="ATSTART",
-            related_connection="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)
+        rel = self.connect_path(wall1, wall2, "ATSTART")
-        assert len([e for e in self.file]) == total_elements
+        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,
+        )

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")