script/crop_patch_from_pickle_parallel.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""

并行版路网裁剪脚本（不修改原有实现文件，作为独立脚本提供）



目标：

- 保持与原有 `GraphPatchCropper` 一致的裁剪逻辑与输出（rgb、mask、graph），

  但在实现层面做两点优化：

  1) 避免在构图流程中产生孤立节点，从而无需在每个patch末尾再次做“孤立点过滤”开销；

  2) 使用多线程对多个patch并行裁剪与保存（CPU核较多时可加速）。



说明：

- 为保证线程安全，本脚本实现一个“无共享可变状态”的裁剪器，所有中间结果都在局部变量中构建，

  不复用实例字段，避免不同patch之间的写入冲突。

- PIL裁剪操作加锁，以回避潜在的线程不安全读。

"""

import argparse
import math
import os
import pickle
import threading
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import Dict, List, Tuple, Optional

import numpy as np
from PIL import Image
from shapely.geometry import LineString, box
from skimage.draw import line as bresenham_line


Point = Tuple[float, float]
PatchRect = List[int]  # [left, top, right, bottom]
Adjacency = Dict[Point, List[Point]]


def is_in_patch(point: Point, patch: PatchRect) -> bool:
    row, col = point
    return (patch[0] <= col <= patch[2]) and (patch[1] <= row <= patch[3])


def calculate_intersection(point1: Point, point2: Point, patch: PatchRect) -> List[Tuple[float, float, str]]:
    l = LineString([(point1[1], point1[0]), (point2[1], point2[0])])
    patch_box = box(patch[0], patch[1], patch[2], patch[3])
    if not l.intersects(patch_box.boundary):
        return []

    left_bound = LineString([(patch[0], patch[1]), (patch[0], patch[3])])
    right_bound = LineString([(patch[2], patch[1]), (patch[2], patch[3])])
    top_bound = LineString([(patch[0], patch[1]), (patch[2], patch[1])])
    bottom_bound = LineString([(patch[0], patch[3]), (patch[2], patch[3])])
    boundaries = [
        (left_bound, 'left'),
        (right_bound, 'right'),
        (top_bound, 'top'),
        (bottom_bound, 'bottom'),
    ]

    intersection_points: List[Tuple[float, float, str]] = []
    for boundary, btype in boundaries:
        if l.intersects(boundary):
            inter = l.intersection(boundary)
            if not inter.is_empty:
                if inter.geom_type == 'Point':
                    intersection_points.append((float(inter.y), float(inter.x), btype))
                elif inter.geom_type == 'MultiPoint':
                    for p in inter.geoms:
                        intersection_points.append((float(p.y), float(p.x), btype))
    return intersection_points


def create_offset_point(intersection: Tuple[float, float, str], inner_offset: float) -> Point:
    row, col, btype = intersection
    if btype == 'left':
        return (float(row), float(col + inner_offset))
    if btype == 'right':
        return (float(row), float(col - inner_offset))
    if btype == 'top':
        return (float(row + inner_offset), float(col))
    if btype == 'bottom':
        return (float(row - inner_offset), float(col))
    return (float(row), float(col))


def euclidean_distance(a: Point, b: Point) -> float:
    return math.hypot(a[0] - b[0], a[1] - b[1])


class ParallelGraphPatchCropper:
    def __init__(self, rgb_path: str, graph_path: str, edge_width: int = 4, inner_offset: int = 5,

                 min_edge_length_ratio: float = 0.08) -> None:
        self.rgb_path = rgb_path
        self.graph_path = graph_path
        self.edge_width = int(edge_width)
        self.inner_offset = float(inner_offset)
        self.min_edge_length_ratio = float(min_edge_length_ratio)

        # Load once, share for threads (read-only)
        self.rgb_image = Image.open(rgb_path)
        with open(graph_path, 'rb') as f:
            self.graph: Adjacency = pickle.load(f)

        # PIL image read lock
        self._pil_lock = threading.Lock()

    def crop_patch(self, patch: PatchRect):
        # Local containers; do not touch instance fields (thread-safe)
        left, top, right, bottom = patch
        width, height = right - left, bottom - top

        # Crop RGB safely
        with self._pil_lock:
            cropped_image = self.rgb_image.crop((left, top, right, bottom))

        # Build edges first, then adjacency, to avoid isolated nodes
        edges: List[Tuple[Point, Point]] = []
        boundary_points: List[Tuple[Point, Point]] = []  # (boundary_new_point_rel, neighbor_rel)

        # 1) nodes inside patch
        for node, neighbors in self.graph.items():
            if not is_in_patch(node, patch):
                continue
            node_rel = (float(node[0] - top), float(node[1] - left))
            for nb in neighbors:
                if is_in_patch(nb, patch):
                    nb_rel = (float(nb[0] - top), float(nb[1] - left))
                    edges.append((node_rel, nb_rel))
                else:
                    # one inside, one outside → find intersection; ensure min length
                    intersections = calculate_intersection(node, nb, patch)
                    if not intersections:
                        continue
                    inter = intersections[0]
                    if euclidean_distance(node, (inter[0], inter[1])) < self.min_edge_length_ratio * width:
                        continue
                    new_pt = create_offset_point(inter, self.inner_offset)
                    new_pt_rel = (float(new_pt[0] - top), float(new_pt[1] - left))
                    edges.append((node_rel, new_pt_rel))
                    boundary_points.append((new_pt_rel, node_rel))

        # 2) both endpoints outside but crossing patch
        processed_edges = set()
        for node, neighbors in self.graph.items():
            if is_in_patch(node, patch):
                continue
            for nb in neighbors:
                if is_in_patch(nb, patch):
                    continue
                key = tuple(sorted([node, nb]))
                if key in processed_edges:
                    continue
                processed_edges.add(key)

                inters = calculate_intersection(node, nb, patch)
                if len(inters) < 2:
                    continue
                int1, int2 = inters[:2]
                dist = euclidean_distance((int1[0], int1[1]), (int2[0], int2[1]))
                if dist < self.min_edge_length_ratio * width:
                    continue
                p1 = create_offset_point(int1, self.inner_offset)
                p2 = create_offset_point(int2, self.inner_offset)
                p1_rel = (float(p1[0] - top), float(p1[1] - left))
                p2_rel = (float(p2[0] - top), float(p2[1] - left))
                edges.append((p1_rel, p2_rel))
                boundary_points.append((p1_rel, p2_rel))
                boundary_points.append((p2_rel, p1_rel))

        # Build adjacency from unique undirected edges
        adjacency: Adjacency = {}
        seen = set()
        for a, b in edges:
            if a == b:
                continue
            key = (a, b) if a <= b else (b, a)
            if key in seen:
                continue
            seen.add(key)
            adjacency.setdefault(a, []).append(b)
            adjacency.setdefault(b, []).append(a)

        # Create road mask
        road_mask = np.zeros((height, width), dtype=np.uint8)
        for a, nbrs in adjacency.items():
            for b in nbrs:
                r0, c0 = map(int, a)
                r1, c1 = map(int, b)
                rr, cc = bresenham_line(r0, c0, r1, c1)
                if self.edge_width > 1:
                    y = np.clip(rr, 0, road_mask.shape[0] - 1)
                    x = np.clip(cc, 0, road_mask.shape[1] - 1)
                    half = int(self.edge_width // 2)
                    for dy in range(-half, half + 1):
                        for dx in range(-half, half + 1):
                            ny = np.clip(y + dy, 0, road_mask.shape[0] - 1)
                            nx = np.clip(x + dx, 0, road_mask.shape[1] - 1)
                            road_mask[ny, nx] = 1
                else:
                    rr = np.clip(rr, 0, road_mask.shape[0] - 1)
                    cc = np.clip(cc, 0, road_mask.shape[1] - 1)
                    road_mask[rr, cc] = 1

        # 返回全部局部结果
        return cropped_image, adjacency, road_mask

    @staticmethod
    def save_results(output_dir: str, patch: PatchRect, cropped_image: Image.Image,

                     adjacency: Adjacency, road_mask: np.ndarray) -> None:
        if not os.path.exists(output_dir):
            os.makedirs(output_dir)
        name_prefix = f"cropped_{patch[0]}_{patch[1]}_{patch[2]}_{patch[3]}"
        cropped_image.save(os.path.join(output_dir, name_prefix + '_rgb.png'))
        Image.fromarray(road_mask * 255).save(os.path.join(output_dir, name_prefix + '_mask.png'))
        with open(os.path.join(output_dir, name_prefix + '_graph.pickle'), 'wb') as f:
            pickle.dump(adjacency, f)


def generate_patches(left: int, top: int, right: int, bottom: int, patch_size: int,

                     num_patches_rows: Optional[int] = None, num_patches_cols: Optional[int] = None) -> List[PatchRect]:
    patches: List[PatchRect] = []
    region_width = right - left
    region_height = bottom - top
    if num_patches_rows is None:
        num_patches_rows = (region_height + patch_size - 1) // patch_size
    if num_patches_cols is None:
        num_patches_cols = (region_width + patch_size - 1) // patch_size
    row_stride = 0 if num_patches_rows == 1 else (region_height - patch_size) / (num_patches_rows - 1)
    col_stride = 0 if num_patches_cols == 1 else (region_width - patch_size) / (num_patches_cols - 1)
    for i in range(num_patches_rows):
        for j in range(num_patches_cols):
            patch_left = min(int(left + j * col_stride), right - patch_size)
            patch_top = min(int(top + i * row_stride), bottom - patch_size)
            patch_right = min(patch_left + patch_size, right)
            patch_bottom = min(patch_top + patch_size, bottom)
            patches.append([patch_left, patch_top, patch_right, patch_bottom])
    return patches


def parse_args() -> argparse.Namespace:
    p = argparse.ArgumentParser(description='并行裁剪路网与RGB图像（保持原有逻辑，线程安全实现）')
    p.add_argument('rgb_path', help='RGB图像路径')
    p.add_argument('graph_path', help='路网图pickle路径')
    p.add_argument('--output', '-o', default='./output_parallel', help='输出目录')
    p.add_argument('--patch', nargs=4, type=int, help='剪裁区域 [left top right bottom]')
    p.add_argument('--region', nargs=4, type=int, help='生成patch的区域范围 [left top right bottom]')
    p.add_argument('--patch_size', type=int, help='每个patch的大小（正方形）')
    p.add_argument('--num_patches_rows', type=int, help='行方向上的patch数量')
    p.add_argument('--num_patches_cols', type=int, help='列方向上的patch数量')
    p.add_argument('--edge_width', type=int, default=4, help='道路宽度')
    p.add_argument('--inner_offset', type=int, default=5, help='边界点向内偏移距离')
    p.add_argument('--min_edge_ratio', type=float, default=0.08, help='最小边长度比例')
    p.add_argument('--workers', type=int, default=max(1, (os.cpu_count() or 4) - 1), help='线程数（默认CPU核数-1）')
    return p.parse_args()


def main() -> int:
    args = parse_args()

    # Prepare patch list
    patches: List[PatchRect] = []
    if args.patch:
        patches = [args.patch]
    elif args.patch_size and args.region:
        patches = generate_patches(args.region[0], args.region[1], args.region[2], args.region[3],
                                   args.patch_size, args.num_patches_rows, args.num_patches_cols)
        print(f"在区域 {args.region} 内生成了 {len(patches)} 个patch")
    elif args.patch_size:
        with Image.open(args.rgb_path) as im:
            W, H = im.size
        patches = generate_patches(0, 0, W, H, args.patch_size, args.num_patches_rows, args.num_patches_cols)
        print(f"在整张图像内生成了 {len(patches)} 个patch")
    else:
        with Image.open(args.rgb_path) as im:
            W, H = im.size
        patches = [[0, 0, W, H]]

    cropper = ParallelGraphPatchCropper(
        args.rgb_path,
        args.graph_path,
        edge_width=args.edge_width,
        inner_offset=args.inner_offset,
        min_edge_length_ratio=args.min_edge_ratio,
    )

    os.makedirs(args.output, exist_ok=True)

    # Parallel processing
    futures = []
    with ThreadPoolExecutor(max_workers=args.workers) as ex:
        for patch in patches:
            futures.append(ex.submit(cropper.crop_patch, patch))

        for i, fut in enumerate(as_completed(futures), 1):
            try:
                cropped_image, adjacency, road_mask = fut.result()
                # We need the patch that corresponds to this future: re-submit with index
                # Simplify: index mapping by position in list
                idx = futures.index(fut)
                patch = patches[idx]
                ParallelGraphPatchCropper.save_results(
                    args.output, patch, cropped_image, adjacency, road_mask)
            except Exception as e:
                print(f"处理patch时出错: {e}")
            if i % 20 == 0 or i == len(futures):
                print(f"已完成 {i}/{len(futures)} 个patch")

    print(f"✓ 处理完成，结果已保存到 {args.output}")
    return 0


if __name__ == '__main__':
    raise SystemExit(main())