BERATools 0.1.0__py3-none-any.whl

beratools/core/algo_merge_lines.py

@@ -0,0 +1,255 @@
+"""
+Copyright (C) 2025 Applied Geospatial Research Group.
+
+This script is licensed under the GNU General Public License v3.0.
+See <https://gnu.org/licenses/gpl-3.0> for full license details.
+
+Author: Richard Zeng
+
+Description:
+    This script is part of the BERA Tools.
+    Webpage: https://github.com/appliedgrg/beratools
+
+    This file is intended to be hosting algorithms and utility functions/classes
+    for merging lines.
+"""
+
+from itertools import pairwise
+from operator import itemgetter
+
+import networkit as nk
+import shapely.geometry as sh_geom
+from shapely.geometry import GeometryCollection, LineString, MultiLineString
+from shapely.ops import linemerge
+
+import beratools.core.algo_common as algo_common
+import beratools.core.constants as bt_const
+
+
+def safe_linemerge(geom):
+    if isinstance(geom, (MultiLineString, GeometryCollection)):
+        return linemerge(geom)
+    elif isinstance(geom, LineString):
+        return geom
+    else:
+        return geom
+
+def custom_line_merge(geom):
+    if geom.geom_type == "MultiLineString":
+        # First try shapely's linemerge (fast)
+        merged = linemerge(geom)
+        # If still MultiLineString, use MergeLines for complex cases
+        if isinstance(merged, sh_geom.MultiLineString):
+            worker = MergeLines(merged)
+            merged = worker.merge_all_lines()
+            return merged if merged else geom
+        else:
+            return merged
+    elif geom.geom_type == "LineString":
+        return geom
+    else:
+        return geom
+
+
+def run_line_merge(in_line_gdf, merge_group):
+    out_line_gdf = in_line_gdf
+    if merge_group:
+        if bt_const.BT_GROUP not in in_line_gdf.columns:
+            in_line_gdf = in_line_gdf.copy()
+            in_line_gdf[bt_const.BT_GROUP] = range(1, len(in_line_gdf) + 1)
+        out_line_gdf = in_line_gdf.dissolve(by=bt_const.BT_GROUP, as_index=False)
+
+    import time
+    print(f"[{time.time()}] Starting line_merge on {len(out_line_gdf)} geometries")
+    out_line_gdf.geometry = out_line_gdf.geometry.apply(safe_linemerge)
+    print(f"[{time.time()}] Finished line_merge")
+
+    print(f"[{time.time()}] Starting loop over {len(out_line_gdf)} rows")
+    for i, row in enumerate(out_line_gdf.itertuples()):
+        if isinstance(row.geometry, sh_geom.MultiLineString):
+            print(f"[{time.time()}] Processing row {i}: MultiLineString with {len(row.geometry.geoms)} parts")
+            worker = MergeLines(row.geometry)
+            merged_line = worker.merge_all_lines()
+            if merged_line:
+                out_line_gdf.at[row.Index, "geometry"] = merged_line
+        if i % 100 == 0:
+            print(f"[{time.time()}] Processed {i} rows")
+    print(f"[{time.time()}] Finished loop")
+
+    out_line_gdf = algo_common.clean_line_geometries(out_line_gdf)
+    out_line_gdf.reset_index(inplace=True, drop=True)
+    out_line_gdf["length"] = out_line_gdf.geometry.length
+    return out_line_gdf
+
+
+class MergeLines:
+    """Merge line segments in MultiLineString."""
+
+    def __init__(self, multi_line):
+        self.G = None
+        self.line_segs = None
+        self.multi_line = multi_line
+        self.node_poly = None
+        self.end = None
+
+        self.create_graph()
+
+    def create_graph(self):
+        self.line_segs = list(self.multi_line.geoms)
+
+        # TODO: check empty line and null geoms
+        self.line_segs = [line for line in self.line_segs if line.length > 1e-3]
+        self.multi_line = sh_geom.MultiLineString(self.line_segs)
+        m = sh_geom.mapping(self.multi_line)
+        self.end = [(i[0], i[-1]) for i in m["coordinates"]]
+
+        self.G = nk.Graph(edgesIndexed=True)
+        self.G.addNodes(2)
+        self.G.addEdge(0, 1)
+
+        self.node_poly = [
+            sh_geom.Point(self.end[0][0]).buffer(1),
+            sh_geom.Point(self.end[0][1]).buffer(1),
+        ]
+
+        for i, line in enumerate(self.end[1:]):
+            node_exists = False
+            pt = sh_geom.Point(line[0])
+            pt_buffer = pt.buffer(1)
+
+            for node in self.G.iterNodes():
+                if self.node_poly[node].contains(pt):
+                    node_exists = True
+                    node_start = node
+            if not node_exists:
+                node_start = self.G.addNode()
+                self.node_poly.append(pt_buffer)
+
+            node_exists = False
+            pt = sh_geom.Point(line[1])
+            pt_buffer = pt.buffer(1)
+            for node in self.G.iterNodes():
+                if self.node_poly[node].contains(pt):
+                    node_exists = True
+                    node_end = node
+            if not node_exists:
+                node_end = self.G.addNode()
+                self.node_poly.append(pt_buffer)
+
+            self.G.addEdge(node_start, node_end)
+
+    def get_components(self):
+        cc = nk.components.ConnectedComponents(self.G)
+        cc.run()
+        components = cc.getComponents()
+        return components
+
+    def is_single_path(self, component):
+        single_path = True
+        for node in component:
+            neighbors = list(self.G.iterNeighbors(node))
+            if len(neighbors) > 2:
+                single_path = False
+
+        return single_path
+
+    def get_merged_line_for_component(self, component):
+        sub = nk.graphtools.subgraphFromNodes(self.G, component)
+        lines = None
+        if nk.graphtools.maxDegree(sub) >= 3:  # not simple path
+            edges = [self.G.edgeId(i[0], i[1]) for i in list(sub.iterEdges())]
+            lines = itemgetter(*edges)(self.line_segs)
+        elif nk.graphtools.maxDegree(sub) == 2:
+            lines = self.merge_single_line(component)
+
+        return lines
+
+    def find_path_for_component(self, component):
+        neighbors = list(self.G.iterNeighbors(component[0]))
+        path = [component[0]]
+        right = neighbors[0]
+        path.append(right)
+
+        left = None
+        if len(neighbors) == 2:
+            left = neighbors[1]
+            path.insert(0, left)
+
+        neighbors = list(self.G.iterNeighbors(right))
+        while len(neighbors) > 1:
+            if neighbors[0] not in path:
+                path.append(neighbors[0])
+                right = neighbors[0]
+            else:
+                path.append(neighbors[1])
+                right = neighbors[1]
+
+            neighbors = list(self.G.iterNeighbors(right))
+
+        # last node
+        if neighbors[0] not in path:
+            path.append(neighbors[0])
+
+        # process left side
+        if left:
+            neighbors = list(self.G.iterNeighbors(left))
+            while len(neighbors) > 1:
+                if neighbors[0] not in path:
+                    path.insert(0, neighbors[0])
+                    left = neighbors[0]
+                else:
+                    path.insert(0, neighbors[1])
+                    left = neighbors[1]
+
+                neighbors = list(self.G.iterNeighbors(left))
+
+            # last node
+            if neighbors[0] not in path:
+                path.insert(0, neighbors[0])
+
+        return path
+
+    def merge_single_line(self, component):
+        path = self.find_path_for_component(component)
+
+        pairs = list(pairwise(path))
+        line_list = [self.G.edgeId(i[0], i[1]) for i in pairs]
+
+        vertices = []
+
+        for i, id in enumerate(line_list):
+            pair = pairs[i]
+            poly_t = self.node_poly[pair[0]]
+            point_t = sh_geom.Point(self.end[id][0])
+            if poly_t.contains(point_t):
+                line = self.line_segs[id]
+            else:
+                # line = reverse(self.line_segs[id])
+                line = self.line_segs[id].reverse()
+
+            vertices.extend(list(line.coords))
+            last_vertex = vertices.pop()
+
+        vertices.append(last_vertex)
+        merged_line = sh_geom.LineString(vertices)
+
+        return [merged_line]
+
+    def merge_all_lines(self):
+        components = self.get_components()
+        lines = []
+        for c in components:
+            line = self.get_merged_line_for_component(c)
+            if line:
+                lines.extend(self.get_merged_line_for_component(c))
+            else:  # TODO: check line
+                print(f"merge_all_lines: failed to merge: {self.multi_line.bounds}")
+
+        # print('Merge lines done.')
+
+        if len(lines) > 1:
+            return sh_geom.MultiLineString(lines)
+        elif len(lines) == 1:
+            return lines[0]
+        else:
+            return None

beratools/core/algo_split_with_lines.py

@@ -0,0 +1,296 @@
+"""Split lines at intersections using a class-based approach."""
+
+from itertools import combinations
+
+import geopandas as gpd
+from shapely import STRtree, snap
+from shapely.geometry import LineString, MultiPoint, Point
+
+import beratools.core.algo_common as algo_common
+
+EPSILON = 1e-5
+INTER_STATUS_COL = "INTER_STATUS"
+
+
+def min_distance_in_multipoint(multipoint):
+    points = list(multipoint.geoms)
+    min_dist = float("inf")
+    for p1, p2 in combinations(points, 2):
+        dist = p1.distance(p2)
+        if dist < min_dist:
+            min_dist = dist
+    return min_dist
+
+
+class LineSplitter:
+    """Split lines at intersections."""
+
+    def __init__(self, line_gdf):
+        """
+        Initialize the LineSplitter with the input GeoPackage and layer name.
+
+        Args:
+        input_gpkg (str): Path to the input GeoPackage file.
+        layer_name (str): Name of the layer to read from the GeoPackage.
+
+        """
+        # Explode if needed for multi-part geometries
+        self.line_gdf = line_gdf.explode()
+        self.line_gdf[INTER_STATUS_COL] = 1  # record line intersection status
+        self.inter_status = {}
+        self.sindex = self.line_gdf.sindex  # Spatial index for faster operations
+
+        self.intersection_gdf = []
+        self.split_lines_gdf = None
+
+    def cut_line_by_points(self, line, points):
+        """
+        Cuts a LineString into segments based on the given points.
+
+        Args:
+        line: A shapely LineString to be cut.
+        points: A list of Point objects where the LineString needs to be cut.
+
+        Return:
+        A list of LineString segments after the cuts.
+
+        """
+        # Create a spatial index for the coordinates of the LineString
+        line_coords = [Point(x, y) for x, y in line.coords]
+        sindex = STRtree(line_coords)
+
+        # Sort points based on their projected position along the line
+        sorted_points = sorted(points, key=lambda p: line.project(p))
+        segments = []
+
+        # Process each point, inserting it into the correct location
+        start_idx = 0
+        start_pt = None
+        end_pt = None
+
+        for point in sorted_points:
+            # Find the closest segment on the line using the spatial index
+            nearest_pt_idx = sindex.nearest(point)
+            end_idx = nearest_pt_idx
+            end_pt = point
+
+            dist1 = line.project(point)
+            dist2 = line.project(line_coords[nearest_pt_idx])
+
+            if dist1 > dist2:
+                end_idx = nearest_pt_idx + 1
+
+            # Create a new segment
+            new_coords = line_coords[start_idx:end_idx]
+            if start_pt:  # Append start point
+                new_coords = [start_pt] + new_coords
+
+            if end_pt:  # Append end point
+                new_coords = new_coords + [end_pt]
+
+            nearest_segment = LineString(new_coords)
+            start_idx = end_idx
+            start_pt = end_pt
+
+            segments.append(nearest_segment)
+
+        # Add remaining part of the line after the last point
+        if start_idx < len(line_coords):
+            # If last point is not close to end point of line
+            if start_pt.distance(line_coords[-1]) > EPSILON:
+                remaining_part = LineString([start_pt] + line_coords[end_idx:])
+                segments.append(remaining_part)
+
+        return segments
+
+    def find_intersections(self):
+        """
+        Find intersections between lines in the GeoDataFrame.
+
+        Return:
+        List of Point geometries where the lines intersect.
+
+        """
+        visited_pairs = set()
+        intersection_points = []
+
+        # Iterate through each line geometry to find intersections
+        for idx, line1 in enumerate(self.line_gdf.geometry):
+            # Use spatial index to find candidates for intersection
+            indices = list(self.sindex.intersection(line1.bounds))
+            indices.remove(idx)  # Remove the current index from the list
+
+            for match_idx in indices:
+                line2 = self.line_gdf.iloc[match_idx].geometry
+
+                # Create an index pair where the smaller index comes first
+                pair = tuple(sorted([idx, match_idx]))
+
+                # Skip if this pair has already been visited
+                if pair in visited_pairs:
+                    continue
+
+                # Mark the pair as visited
+                visited_pairs.add(pair)
+
+                # Only check lines that are different and intersect
+                line1 = snap(line1, line2, tolerance=EPSILON)
+                if line1.intersects(line2):
+                    # Find intersection points (can be multiple)
+                    intersections = line1.intersection(line2)
+
+                    if intersections.is_empty:
+                        continue
+
+                    # Intersection can be Point, MultiPoint, LineString
+                    # or GeometryCollection
+                    if isinstance(intersections, Point):
+                        intersection_points.append(intersections)
+                    else:
+                        # record for further inspection
+                        # GeometryCollection, MultiLineString
+                        if isinstance(intersections, MultiPoint):
+                            intersection_points.extend(intersections.geoms)
+                        elif isinstance(intersections, LineString):
+                            intersection_points.append(intersections.interpolate(0.5, normalized=True))
+
+                        # if minimum distance between points is greater than threshold
+                        # mark line as valid
+                        if isinstance(intersections, MultiPoint):
+                            if min_distance_in_multipoint(intersections) > algo_common.DISTANCE_THRESHOLD:
+                                continue
+                        # if intersection is a line, mark line as valid
+                        if isinstance(intersections, LineString):
+                            continue
+
+                        for item in pair:
+                            self.inter_status[item] = 0
+
+        self.intersection_gdf = gpd.GeoDataFrame(geometry=intersection_points, crs=self.line_gdf.crs)
+
+    def split_lines_at_intersections(self):
+        """
+        Split lines at the given intersection points.
+
+        Args:
+        intersection_points: List of Point geometries where the lines should be split.
+
+        Returns:
+        A GeoDataFrame with the split lines.
+
+        """
+        # Create a spatial index for faster point-line intersection checks
+        sindex = self.intersection_gdf.sindex
+
+        # List to hold the new split line segments
+        new_rows = []
+
+        # Iterate through each intersection point to split lines at that point
+        for row in self.line_gdf.itertuples():
+            if not isinstance(row.geometry, LineString):
+                continue
+
+            # Use spatial index to find possible line candidates for intersection
+            possible_matches = sindex.query(row.geometry.buffer(EPSILON))
+            end_pts = MultiPoint([row.geometry.coords[0], row.geometry.coords[-1]])
+
+            pt_list = []
+            new_segments = [row.geometry]
+
+            for idx in possible_matches:
+                point = self.intersection_gdf.loc[idx].geometry
+                # Check if the point is on the line
+                if row.geometry.distance(point) < EPSILON:
+                    if end_pts.distance(point) < EPSILON:
+                        continue
+                    else:
+                        pt_list.append(point)
+
+            if len(pt_list) > 0:
+                # Split the line at the intersection
+                new_segments = self.cut_line_by_points(row.geometry, pt_list)
+
+            # If the line was split into multiple segments, create new rows
+            for segment in new_segments:
+                new_row = row._asdict()  # Convert the original row into a dictionary
+                new_row["geometry"] = segment  # Update the geometry with the split one
+                new_rows.append(new_row)
+
+        self.split_lines_gdf = gpd.GeoDataFrame(
+            new_rows, columns=self.line_gdf.columns, crs=self.line_gdf.crs
+        )
+
+        self.split_lines_gdf = algo_common.clean_line_geometries(self.split_lines_gdf)
+
+        # Debugging: print how many segments were created
+        print(f"Total new line segments created: {len(new_rows)}")
+
+    def save_to_geopackage(
+        self,
+        input_gpkg,
+        line_layer="split_lines",
+        intersection_layer=None,
+        invalid_layer=None,
+    ):
+        """
+        Save the split lines and intersection points to the GeoPackage.
+
+        Args:
+        line_layer: split lines layer name in the GeoPackage.
+        intersection_layer: layer name for intersection points in the GeoPackage.
+
+        """
+        # Save intersection points and split lines to the GeoPackage
+        if self.split_lines_gdf is not None and intersection_layer:
+            if len(self.intersection_gdf) > 0:
+                self.intersection_gdf.to_file(input_gpkg, layer=intersection_layer, driver="GPKG")
+
+        if self.split_lines_gdf is not None and line_layer:
+            if len(self.split_lines_gdf) > 0:
+                self.split_lines_gdf["length"] = self.split_lines_gdf.geometry.length
+                self.split_lines_gdf.to_file(input_gpkg, layer=line_layer, driver="GPKG")
+
+        # save invalid splits
+        invalid_splits = self.line_gdf.loc[self.line_gdf[INTER_STATUS_COL] == 0]
+        if not invalid_splits.empty and invalid_layer:
+            if len(invalid_splits) > 0:
+                invalid_splits.to_file(input_gpkg, layer=invalid_layer, driver="GPKG")
+
+    def process(self, intersection_gdf=None):
+        """
+        Find intersection points, split lines at intersections.
+
+        Args:
+        intersection_gdf: external GeoDataFrame with intersection points.
+
+        """
+        if intersection_gdf is not None:
+            self.intersection_gdf = intersection_gdf
+        else:
+            self.find_intersections()
+
+        if self.inter_status:
+            for idx in self.inter_status.keys():
+                self.line_gdf.loc[idx, INTER_STATUS_COL] = self.inter_status[idx]
+
+        if not self.intersection_gdf.empty:
+            # Split the lines at intersection points
+            self.split_lines_at_intersections()
+        else:
+            print("No intersection points found, no lines to split.")
+
+
+def split_with_lines(input_gpkg, layer_name):
+    splitter = LineSplitter(input_gpkg, layer_name)
+    splitter.process()
+    splitter.save_to_geopackage()
+
+
+if __name__ == "__main__":
+    input_gpkg = r"I:\Temp\footprint_final.gpkg"
+    layer_name = "merged_lines_original"
+
+    gdf = gpd.read_file(input_gpkg, layer=layer_name)
+    splitter = LineSplitter(gdf)
+    splitter.process()
+    splitter.save_to_geopackage(input_gpkg)