first commit

filter/cluster_filter.py

@@ -0,0 +1,77 @@
+from sklearn.cluster import DBSCAN
+from sklearn.preprocessing import StandardScaler
+import os
+import logging
+
+
+class GPSCluster:
+    def __init__(self, gps_points, eps=0.01, min_samples=3):
+        """
+        初始化GPS聚类器
+
+        参数:
+            eps: DBSCAN的邻域半径参数
+            min_samples: DBSCAN的最小样本数参数
+        """
+        self.eps = eps
+        self.min_samples = min_samples
+        self.dbscan = DBSCAN(eps=eps, min_samples=min_samples)
+        self.scaler = StandardScaler()
+        self.gps_points = gps_points
+        self.logger = logging.getLogger('UAV_Preprocess.GPSCluster')
+
+    def fit(self):
+        """
+        对GPS点进行聚类，只保留最大的类
+
+        参数:
+            gps_points: 包含'lat'和'lon'列的DataFrame
+
+        返回:
+            带有聚类标签的DataFrame，其中最大类标记为1，其他点标记为-1
+        """
+        self.logger.info("开始聚类")
+        # 提取经纬度数据
+        X = self.gps_points[["lon", "lat"]].values
+
+        # # 数据标准化
+        # X_scaled = self.scaler.fit_transform(X)
+
+        # 执行DBSCAN聚类
+        labels = self.dbscan.fit_predict(X)
+
+        # 找出最大类的标签（排除噪声点-1）
+        unique_labels = [l for l in set(labels) if l != -1]
+        if unique_labels:  # 如果有聚类
+            label_counts = [(l, sum(labels == l)) for l in unique_labels]
+            largest_label = max(label_counts, key=lambda x: x[1])[0]
+
+            # 将最大类标记为1，其他都标记为-1
+            new_labels = (labels == largest_label).astype(int)
+            new_labels[new_labels == 0] = -1
+        else:  # 如果没有聚类，全部标记为-1
+            new_labels = labels
+
+        # 将聚类结果添加到原始数据中
+        result_df = self.gps_points.copy()
+        result_df["cluster"] = new_labels
+
+        return result_df
+
+    def get_cluster_stats(self, clustered_points):
+        """
+        获取聚类统计信息
+
+        参数:
+            clustered_points: 带有聚类标签的DataFrame
+
+        返回:
+            聚类统计信息的字典
+        """
+        main_cluster = clustered_points[clustered_points["cluster"] == 1]
+        noise_cluster = clustered_points[clustered_points["cluster"] == -1]
+
+        self.logger.info(f"聚类完成：主要类别包含 {len(main_cluster)} 个点，"
+                         f"噪声点 {len(noise_cluster)} 个")
+
+        return main_cluster

main.py

@@ -0,0 +1,249 @@
+import os
+import shutil
+from datetime import timedelta
+from dataclasses import dataclass
+from typing import Dict, Tuple
+import psutil
+import pandas as pd
+from pathlib import Path
+
+from filter.cluster_filter import GPSCluster
+from utils.gps_extractor import GPSExtractor
+from utils.grid_divider import GridDivider
+from utils.logger import setup_logger
+from utils.visualizer import FilterVisualizer
+from utils.docker_runner import DockerRunner
+from post_pro.conv_obj import ConvertOBJ
+
+
+@dataclass
+class ProcessConfig:
+    """配置类"""
+
+    image_dir: str
+    output_dir: str
+    # 聚类过滤参数
+    cluster_eps: float = 0.01
+    cluster_min_samples: int = 5
+    # 时间组重叠过滤参数
+    time_group_overlap_threshold: float = 0.7
+    time_group_interval: timedelta = timedelta(minutes=5)
+    # 孤立点过滤参数
+    filter_distance_threshold: float = 0.001  # 经纬度距离
+    filter_min_neighbors: int = 6
+    # 密集点过滤参数
+    filter_grid_size: float = 0.001
+    filter_dense_distance_threshold: float = 10  # 普通距离，单位：米
+    filter_time_threshold: timedelta = timedelta(minutes=5)
+    # 网格划分参数
+    grid_overlap: float = 0.05
+    grid_size: float = 500
+    # 几个pipline过程是否开启
+    mode: str = "快拼模式"
+    accuracy: str = "medium"
+    produce_dem: bool = False
+
+
+class ODM_Plugin:
+    def __init__(self, config: ProcessConfig):
+        self.config = config
+
+        # 检查磁盘空间
+        # TODO 现在输入目录的磁盘空间也需要检查
+        self._check_disk_space()
+
+        # 清理并重建输出目录
+        if os.path.exists(config.output_dir):
+            self._clean_output_dir()
+        self._setup_output_dirs()
+
+        # 修改输入目录，符合ODM要求，从这里开始，image_dir就是project_path
+        self._rename_input_dir()
+        self.project_path = self.config.image_dir
+
+        # 初始化其他组件
+        self.logger = setup_logger(config.output_dir)
+        self.gps_points = None
+        self.grid_points = None
+        self.visualizer = FilterVisualizer(config.output_dir)
+
+    def _clean_output_dir(self):
+        """清理输出目录"""
+        try:
+            shutil.rmtree(self.config.output_dir)
+            print(f"已清理输出目录: {self.config.output_dir}")
+        except Exception as e:
+            print(f"清理输出目录时发生错误: {str(e)}")
+            raise
+
+    def _setup_output_dirs(self):
+        """创建必要的输出目录结构"""
+        try:
+            # 创建主输出目录
+            os.makedirs(self.config.output_dir)
+
+            # 创建过滤图像保存目录
+            os.makedirs(os.path.join(self.config.output_dir, 'filter_imgs'))
+
+            # 创建日志目录
+            os.makedirs(os.path.join(self.config.output_dir, 'logs'))
+
+            print(f"已创建输出目录结构: {self.config.output_dir}")
+        except Exception as e:
+            print(f"创建输出目录时发生错误: {str(e)}")
+            raise
+
+    def _get_directory_size(self, path):
+        """获取目录的总大小（字节）"""
+        total_size = 0
+        for dirpath, dirnames, filenames in os.walk(path):
+            for filename in filenames:
+                file_path = os.path.join(dirpath, filename)
+                try:
+                    total_size += os.path.getsize(file_path)
+                except (OSError, FileNotFoundError):
+                    continue
+        return total_size
+
+    def _check_disk_space(self):
+        """检查磁盘空间是否足够"""
+        # 获取输入目录大小
+        input_size = self._get_directory_size(self.config.image_dir)
+
+        # 获取输出目录所在磁盘的剩余空间
+        output_drive = os.path.splitdrive(
+            os.path.abspath(self.config.output_dir))[0]
+        if not output_drive:  # 处理Linux/Unix路径
+            output_drive = '/home'
+
+        disk_usage = psutil.disk_usage(output_drive)
+        free_space = disk_usage.free
+
+        # 计算所需空间（输入大小的1.5倍）
+        required_space = input_size * 12
+
+        if free_space < required_space:
+            error_msg = (
+                f"磁盘空间不足!\n"
+                f"输入目录大小: {input_size / (1024**3):.2f} GB\n"
+                f"所需空间: {required_space / (1024**3):.2f} GB\n"
+                f"可用空间: {free_space / (1024**3):.2f} GB\n"
+                f"在驱动器 {output_drive}"
+            )
+            raise RuntimeError(error_msg)
+
+    def _rename_input_dir(self):
+        image_dir = Path(self.config.image_dir).resolve()
+
+        if not image_dir.exists() or not image_dir.is_dir():
+            raise ValueError(
+                f"Provided path '{image_dir}' is not a valid directory.")
+
+        # 原目录名和父路径
+        parent_dir = image_dir.parent
+        original_name = image_dir.name
+
+        # 新的 images 路径（原目录重命名为 images）
+        images_path = parent_dir / "images"
+
+        # 重命名原目录为 images
+        image_dir.rename(images_path)
+
+        # 创建一个新的、和原目录同名的文件夹
+        new_root = parent_dir / original_name
+        new_root.mkdir(exist_ok=False)
+
+        # 创建 project 子文件夹
+        project_dir = new_root / "project"
+        project_dir.mkdir()
+
+        # 把 images 文件夹移动到 project 下
+        final_images_path = project_dir / "images"
+        shutil.move(str(images_path), str(final_images_path))
+
+        print(f"符合标准输入的文件夹结构已经创建好了，{final_images_path}")
+
+        return final_images_path
+
+    def extract_gps(self) -> pd.DataFrame:
+        """提取GPS数据"""
+        self.logger.info("开始提取GPS数据")
+        extractor = GPSExtractor(self.project_path)
+        self.gps_points = extractor.extract_all_gps()
+        self.logger.info(f"成功提取 {len(self.gps_points)} 个GPS点")
+
+    def cluster(self):
+        """使用DBSCAN对GPS点进行聚类，只保留最大的类"""
+        previous_points = self.gps_points.copy()
+        clusterer = GPSCluster(
+            self.gps_points,
+            eps=self.config.cluster_eps,
+            min_samples=self.config.cluster_min_samples
+        )
+
+        self.clustered_points = clusterer.fit()
+        self.gps_points = clusterer.get_cluster_stats(self.clustered_points)
+
+        self.visualizer.visualize_filter_step(
+            self.gps_points, previous_points, "1-Clustering")
+
+    def divide_grids(self):
+        """划分网格
+        Returns:
+            tuple: (grid_points, translations)
+                - grid_points: 网格点数据字典
+                - translations: 网格平移量字典
+        """
+        grid_divider = GridDivider(
+            overlap=self.config.grid_overlap,
+            grid_size=self.config.grid_size,
+            project_path=self.project_path,
+            output_dir=self.config.output_dir
+        )
+        grids, self.grid_points = grid_divider.adjust_grid_size_and_overlap(
+            self.gps_points
+        )
+        grid_divider.visualize_grids(self.gps_points, grids)
+        grid_divider.save_image_groups(self.grid_points)
+        if len(grids) >= 20:
+            self.logger.warning("网格数量已超过20, 需要人工调整分区")
+
+    def odm_docker_runner(self):
+        """"运行OMD docker容器"""
+        self.logger.info("开始运行Docker容器")
+        # TODO：加一些容错处理
+        docker_runner = DockerRunner(self.project_path)
+        docker_runner.run_odm_container()
+
+    def convert_obj(self):
+        """转换OBJ模型"""
+        self.logger.info("开始转换OBJ模型")
+        converter = ConvertOBJ(self.config.output_dir)
+        converter.convert_grid_obj(self.grid_points)
+
+    def post_process(self):
+        """后处理：合并或复制处理结果"""
+        self.logger.info("开始后处理")
+
+        self.logger.info("拷贝正射影像至输出目录")
+        orthophoto_tif_path = os.path.join(
+            self.project_path, "odm_orthophoto", "odm_orthophoto.tif")
+        shutil.copy(orthophoto_tif_path, self.config.output_dir)
+        # if self.config.mode == "三维模式":
+        #     self.convert_obj()
+        # else:
+        #     pass
+
+    def process(self):
+        """执行完整的预处理流程"""
+        try:
+            self.extract_gps()
+            self.cluster()
+            self.divide_grids()
+            self.logger.info("==========预处理任务完成==========")
+            self.odm_docker_runner()
+            self.post_process()
+
+        except Exception as e:
+            self.logger.error(f"处理过程中发生错误: {str(e)}", exc_info=True)
+            raise

post_pro/conv_obj.py

@@ -0,0 +1,253 @@
+import os
+import subprocess
+import json
+import shutil
+import logging
+from pyproj import Transformer
+import cv2
+
+
+class ConvertOBJ:
+    def __init__(self, output_dir: str):
+        self.output_dir = output_dir
+        # 用于存储所有grid的UTM范围
+        self.ref_east = float('inf')
+        self.ref_north = float('inf')
+        # 初始化UTM到WGS84的转换器
+        self.transformer = Transformer.from_crs(
+            "EPSG:32649", "EPSG:4326", always_xy=True)
+        self.logger = logging.getLogger('UAV_Preprocess.ConvertOBJ')
+
+    def convert_grid_obj(self, grid_points):
+        """转换每个网格的OBJ文件为OSGB格式"""
+        os.makedirs(os.path.join(self.output_dir,
+                    "osgb", "Data"), exist_ok=True)
+
+        # 以第一个grid的UTM坐标作为参照系
+        first_grid_id = list(grid_points.keys())[0]
+        first_grid_dir = os.path.join(
+            self.output_dir,
+            f"grid_{first_grid_id[0]}_{first_grid_id[1]}",
+            "project"
+        )
+        log_file = os.path.join(
+            first_grid_dir, "odm_orthophoto", "odm_orthophoto_log.txt")
+        self.ref_east, self.ref_north = self.read_utm_offset(log_file)
+
+        for grid_id in grid_points.keys():
+            try:
+                self._convert_single_grid(grid_id, grid_points)
+            except Exception as e:
+                self.logger.error(f"网格 {grid_id} 转换失败: {str(e)}")
+
+        self._create_merged_metadata()
+
+    def _convert_single_grid(self, grid_id, grid_points):
+        """转换单个网格的OBJ文件"""
+        # 构建相关路径
+        grid_name = f"grid_{grid_id[0]}_{grid_id[1]}"
+        project_dir = os.path.join(self.output_dir, grid_name, "project")
+        texturing_dir = os.path.join(project_dir, "odm_texturing")
+        texturing_dst_dir = os.path.join(project_dir, "odm_texturing_dst")
+        opensfm_dir = os.path.join(project_dir, "opensfm")
+        log_file = os.path.join(
+            project_dir, "odm_orthophoto", "odm_orthophoto_log.txt")
+        os.makedirs(texturing_dst_dir, exist_ok=True)
+
+        # 修改obj文件z坐标的值
+        min_25d_z = self.get_min_z_from_obj(os.path.join(
+            project_dir, 'odm_texturing_25d', 'odm_textured_model_geo.obj'))
+        self.modify_z_in_obj(texturing_dir, min_25d_z)
+
+        # 在新文件夹下，利用UTM偏移量，修改obj文件顶点坐标，纹理文件下采样
+        utm_offset = self.read_utm_offset(log_file)
+        modified_obj = self.modify_obj_coordinates(
+            texturing_dir, texturing_dst_dir, utm_offset)
+        self.downsample_texture(texturing_dir, texturing_dst_dir)
+
+        # 执行格式转换，Linux下osgconv有问题，记得注释掉
+        self.logger.info(f"开始转换网格 {grid_id} 的OBJ文件")
+        output_osgb = os.path.join(texturing_dst_dir, "Tile.osgb")
+        cmd = (
+            f"osgconv {modified_obj} {output_osgb} "
+            f"--compressed --smooth --fix-transparency "
+        )
+        self.logger.info(f"执行osgconv命令：{cmd}")
+
+        try:
+            subprocess.run(cmd, shell=True, check=True, cwd=texturing_dir)
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"OSGB转换失败: {str(e)}")
+
+        # 创建OSGB目录结构，复制文件
+        osgb_base_dir = os.path.join(self.output_dir, "osgb")
+        data_dir = os.path.join(osgb_base_dir, "Data")
+        tile_dir = os.path.join(data_dir, f"Tile_{grid_id[0]}_{grid_id[1]}")
+        os.makedirs(tile_dir, exist_ok=True)
+        target_osgb = os.path.join(
+            tile_dir, f"Tile_{grid_id[0]}_{grid_id[1]}.osgb")
+        shutil.copy2(output_osgb, target_osgb)
+
+    def _create_merged_metadata(self):
+        """创建合并后的metadata.xml文件"""
+        # 转换为WGS84经纬度
+        center_lon, center_lat = self.transformer.transform(
+            self.ref_east, self.ref_north)
+        metadata_content = f"""<?xml version="1.0" encoding="utf-8"?>
+<ModelMetadata version="1">
+    <SRS>EPSG:4326</SRS>
+    <SRSOrigin>{center_lon},{center_lat},0</SRSOrigin>
+        <Texture>
+            <ColorSource>Visible</ColorSource>
+        </Texture>
+    </ModelMetadata>"""
+
+        metadata_file = os.path.join(self.output_dir, "osgb", "metadata.xml")
+        with open(metadata_file, 'w', encoding='utf-8') as f:
+            f.write(metadata_content)
+
+    def read_utm_offset(self, log_file: str) -> tuple:
+        """读取UTM偏移量"""
+        try:
+            east_offset = None
+            north_offset = None
+
+            with open(log_file, 'r') as f:
+                lines = f.readlines()
+                for i, line in enumerate(lines):
+                    if 'utm_north_offset' in line and i + 1 < len(lines):
+                        north_offset = float(lines[i + 1].strip())
+                    elif 'utm_east_offset' in line and i + 1 < len(lines):
+                        east_offset = float(lines[i + 1].strip())
+
+            if east_offset is None or north_offset is None:
+                raise ValueError("未找到UTM偏移量")
+
+            return east_offset, north_offset
+        except Exception as e:
+            self.logger.error(f"读取UTM偏移量时发生错误: {str(e)}")
+            raise
+
+    def modify_obj_coordinates(self, texturing_dir: str, texturing_dst_dir: str, utm_offset: tuple) -> str:
+        """修改obj文件中的顶点坐标，使用相对坐标系"""
+        obj_file = os.path.join(
+            texturing_dir, "odm_textured_model_modified.obj")
+        obj_dst_file = os.path.join(
+            texturing_dst_dir, "odm_textured_model_geo_utm.obj")
+        if not os.path.exists(obj_file):
+            raise FileNotFoundError(f"找不到OBJ文件: {obj_file}")
+        shutil.copy2(os.path.join(texturing_dir, "odm_textured_model_geo.mtl"),
+                     os.path.join(texturing_dst_dir, "odm_textured_model_geo.mtl"))
+        east_offset, north_offset = utm_offset
+        self.logger.info(
+            f"UTM坐标偏移：{east_offset - self.ref_east}, {north_offset - self.ref_north}")
+
+        try:
+            with open(obj_file, 'r') as f_in, open(obj_dst_file, 'w') as f_out:
+                for line in f_in:
+                    if line.startswith('v '):
+                        # 处理顶点坐标行
+                        parts = line.strip().split()
+                        # 使用相对于整体最小UTM坐标的偏移
+                        x = float(parts[1]) + (east_offset - self.ref_east)
+                        y = float(parts[2]) + (north_offset - self.ref_north)
+                        z = float(parts[3])
+                        f_out.write(f'v {x:.6f} {z:.6f} {-y:.6f}\n')
+                    elif line.startswith('vn '):  # 处理法线向量
+                        parts = line.split()
+                        nx = float(parts[1])
+                        ny = float(parts[2])
+                        nz = float(parts[3])
+                        # 同步反转法线的 Y 轴
+                        new_line = f"vn {nx} {nz} {-ny}\n"
+                        f_out.write(new_line)
+                    else:
+                        # 其他行直接写入
+                        f_out.write(line)
+
+            return obj_dst_file
+        except Exception as e:
+            self.logger.error(f"修改obj坐标时发生错误: {str(e)}")
+            raise
+
+    def downsample_texture(self, src_dir: str, dst_dir: str):
+        """复制并重命名纹理文件，对大于100MB的文件进行多次下采样，直到文件小于100MB
+        Args:
+            src_dir: 源纹理目录
+            dst_dir: 目标纹理目录
+        """
+        for file in os.listdir(src_dir):
+            if file.lower().endswith(('.png')):
+                src_path = os.path.join(src_dir, file)
+                dst_path = os.path.join(dst_dir, file)
+
+                # 检查文件大小（以字节为单位）
+                file_size = os.path.getsize(src_path)
+                if file_size <= 100 * 1024 * 1024:  # 如果文件小于等于100MB，直接复制
+                    shutil.copy2(src_path, dst_path)
+                else:
+                    # 文件大于100MB，进行下采样
+                    img = cv2.imread(src_path, cv2.IMREAD_UNCHANGED)
+                    if_first_ds = True
+                    while file_size > 100 * 1024 * 1024:  # 大于100MB
+                        self.logger.info(f"纹理文件 {file} 大于100MB，进行下采样")
+
+                        if if_first_ds:
+                            # 计算新的尺寸（长宽各变为1/4）
+                            new_size = (img.shape[1] // 4,
+                                        img.shape[0] // 4)  # 逐步减小尺寸
+                            # 使用双三次插值进行下采样
+                            resized_img = cv2.resize(
+                                img, new_size, interpolation=cv2.INTER_CUBIC)
+                            if_first_ds = False
+                        else:
+                            # 计算新的尺寸（长宽各变为1/2）
+                            new_size = (img.shape[1] // 2,
+                                        img.shape[0] // 2)  # 逐步减小尺寸
+                            # 使用双三次插值进行下采样
+                            resized_img = cv2.resize(
+                                img, new_size, interpolation=cv2.INTER_CUBIC)
+
+                        # 更新文件路径为下采样后的路径
+                        cv2.imwrite(dst_path, resized_img, [
+                                    cv2.IMWRITE_PNG_COMPRESSION, 9])
+
+                        # 更新文件大小和图像
+                        file_size = os.path.getsize(dst_path)
+                        img = cv2.imread(dst_path, cv2.IMREAD_UNCHANGED)
+                        self.logger.info(
+                            f"下采样后文件大小: {file_size / (1024 * 1024):.2f} MB")
+
+    def get_min_z_from_obj(self, file_path):
+        min_z = float('inf')  # 初始值设为无穷大
+        with open(file_path, 'r') as obj_file:
+            for line in obj_file:
+                # 检查每一行是否是顶点定义（以 'v ' 开头）
+                if line.startswith('v '):
+                    # 获取顶点坐标
+                    parts = line.split()
+                    # 将z值转换为浮动数字
+                    z = float(parts[3])
+                    # 更新最小z值
+                    if z < min_z:
+                        min_z = z
+        return min_z
+
+    def modify_z_in_obj(self, texturing_dir, min_25d_z):
+        obj_file = os.path.join(texturing_dir, 'odm_textured_model_geo.obj')
+        output_file = os.path.join(
+            texturing_dir, 'odm_textured_model_modified.obj')
+        with open(obj_file, 'r') as f_in, open(output_file, 'w') as f_out:
+            for line in f_in:
+                if line.startswith('v '):  # 顶点坐标行
+                    parts = line.strip().split()
+                    x = float(parts[1])
+                    y = float(parts[2])
+                    z = float(parts[3])
+
+                    if z < min_25d_z:
+                        z = min_25d_z
+
+                    f_out.write(f"v {x} {y} {z}\n")
+                else:
+                    f_out.write(line)

post_pro/conv_obj2.py

@@ -0,0 +1,263 @@
+import os
+import subprocess
+import json
+import shutil
+import logging
+from pyproj import Transformer
+import cv2
+
+
+class ConvertOBJ:
+    def __init__(self, output_dir: str):
+        self.output_dir = output_dir
+        # 用于存储所有grid的UTM范围
+        self.ref_east = float('inf')
+        self.ref_north = float('inf')
+        # 初始化UTM到WGS84的转换器
+        self.transformer = Transformer.from_crs(
+            "EPSG:32649", "EPSG:4326", always_xy=True)
+        self.logger = logging.getLogger('UAV_Preprocess.ConvertOBJ')
+
+    def convert_grid_obj(self, grid_points):
+        """转换每个网格的OBJ文件为OSGB格式"""
+        os.makedirs(os.path.join(self.output_dir,
+                    "osgb", "Data"), exist_ok=True)
+
+        # 以第一个grid的UTM坐标作为参照系
+        first_grid_id = list(grid_points.keys())[0]
+        first_grid_dir = os.path.join(
+            self.output_dir,
+            f"grid_{first_grid_id[0]}_{first_grid_id[1]}",
+            "project"
+        )
+        log_file = os.path.join(
+            first_grid_dir, "odm_orthophoto", "odm_orthophoto_log.txt")
+        self.ref_east, self.ref_north = self.read_utm_offset(log_file)
+
+        for grid_id in grid_points.keys():
+            try:
+                self._convert_single_grid(grid_id, grid_points)
+            except Exception as e:
+                self.logger.error(f"网格 {grid_id} 转换失败: {str(e)}")
+
+        self._create_merged_metadata()
+
+    def _convert_single_grid(self, grid_id, grid_points):
+        """转换单个网格的OBJ文件"""
+        # 构建相关路径
+        grid_name = f"grid_{grid_id[0]}_{grid_id[1]}"
+        project_dir = os.path.join(self.output_dir, grid_name, "project")
+        texturing_dir = os.path.join(project_dir, "odm_texturing")
+        texturing_dst_dir = os.path.join(project_dir, "odm_texturing_dst")
+        split_obj_dir = os.path.join(texturing_dst_dir, "split_obj")
+        opensfm_dir = os.path.join(project_dir, "opensfm")
+        log_file = os.path.join(
+            project_dir, "odm_orthophoto", "odm_orthophoto_log.txt")
+        os.makedirs(texturing_dst_dir, exist_ok=True)
+
+        # 修改obj文件z坐标的值
+        min_25d_z = self.get_min_z_from_obj(os.path.join(
+            project_dir, 'odm_texturing_25d', 'odm_textured_model_geo.obj'))
+        self.modify_z_in_obj(texturing_dir, min_25d_z)
+
+        # 在新文件夹下，利用UTM偏移量，修改obj文件顶点坐标，纹理文件下采样
+        utm_offset = self.read_utm_offset(log_file)
+        modified_obj = self.modify_obj_coordinates(
+            texturing_dir, texturing_dst_dir, utm_offset)
+        self.downsample_texture(texturing_dir, texturing_dst_dir)
+
+        # 将obj文件进行切片
+        self.logger.info(f"开始切片网格 {grid_id} 的OBJ文件")
+        os.makedirs(split_obj_dir)
+        cmd = (
+            f"D:\software\Obj2Tiles\Obj2Tiles.exe --stage Splitting --lods 1 --divisions 3 "
+            f"{modified_obj} {split_obj_dir}"
+        )
+        subprocess.run(cmd, check=True)
+
+        # 执行格式转换，Linux下osgconv有问题，记得注释掉
+        self.logger.info(f"开始转换网格 {grid_id} 的OBJ文件")
+        # 先获取split_obj_dir下的所有obj文件
+        obj_lod_dir = os.path.join(split_obj_dir, "LOD-0")
+        obj_files = [f for f in os.listdir(
+            obj_lod_dir) if f.endswith('.obj')]
+        for obj_file in obj_files:
+            obj_path = os.path.join(obj_lod_dir, obj_file)
+            osgb_file = os.path.splitext(obj_file)[0] + '.osgb'
+            osgb_path = os.path.join(split_obj_dir, osgb_file)
+            # 执行 osgconv 命令
+            subprocess.run(['osgconv', obj_path, osgb_path], check=True)
+
+        # 创建OSGB目录结构，复制文件
+        osgb_base_dir = os.path.join(self.output_dir, "osgb")
+        data_dir = os.path.join(osgb_base_dir, "Data")
+        for obj_file in obj_files:
+            obj_file_name = os.path.splitext(obj_file)[0]
+            tile_dirs = os.path.join(data_dir, f"{obj_file_name}")
+            os.makedirs(tile_dirs, exist_ok=True)
+            shutil.copy2(os.path.join(
+                split_obj_dir, obj_file_name+".osgb"), tile_dirs)
+
+    def _create_merged_metadata(self):
+        """创建合并后的metadata.xml文件"""
+        # 转换为WGS84经纬度
+        center_lon, center_lat = self.transformer.transform(
+            self.ref_east, self.ref_north)
+        metadata_content = f"""<?xml version="1.0" encoding="utf-8"?>
+<ModelMetadata version="1">
+    <SRS>EPSG:4326</SRS>
+    <SRSOrigin>{center_lon},{center_lat},0</SRSOrigin>
+        <Texture>
+            <ColorSource>Visible</ColorSource>
+        </Texture>
+    </ModelMetadata>"""
+
+        metadata_file = os.path.join(self.output_dir, "osgb", "metadata.xml")
+        with open(metadata_file, 'w', encoding='utf-8') as f:
+            f.write(metadata_content)
+
+    def read_utm_offset(self, log_file: str) -> tuple:
+        """读取UTM偏移量"""
+        try:
+            east_offset = None
+            north_offset = None
+
+            with open(log_file, 'r') as f:
+                lines = f.readlines()
+                for i, line in enumerate(lines):
+                    if 'utm_north_offset' in line and i + 1 < len(lines):
+                        north_offset = float(lines[i + 1].strip())
+                    elif 'utm_east_offset' in line and i + 1 < len(lines):
+                        east_offset = float(lines[i + 1].strip())
+
+            if east_offset is None or north_offset is None:
+                raise ValueError("未找到UTM偏移量")
+
+            return east_offset, north_offset
+        except Exception as e:
+            self.logger.error(f"读取UTM偏移量时发生错误: {str(e)}")
+            raise
+
+    def modify_obj_coordinates(self, texturing_dir: str, texturing_dst_dir: str, utm_offset: tuple) -> str:
+        """修改obj文件中的顶点坐标，使用相对坐标系"""
+        obj_file = os.path.join(
+            texturing_dir, "odm_textured_model_modified.obj")
+        obj_dst_file = os.path.join(
+            texturing_dst_dir, "odm_textured_model_geo_utm.obj")
+        if not os.path.exists(obj_file):
+            raise FileNotFoundError(f"找不到OBJ文件: {obj_file}")
+        shutil.copy2(os.path.join(texturing_dir, "odm_textured_model_geo.mtl"),
+                     os.path.join(texturing_dst_dir, "odm_textured_model_geo.mtl"))
+        east_offset, north_offset = utm_offset
+        self.logger.info(
+            f"UTM坐标偏移：{east_offset - self.ref_east}, {north_offset - self.ref_north}")
+
+        try:
+            with open(obj_file, 'r') as f_in, open(obj_dst_file, 'w') as f_out:
+                for line in f_in:
+                    if line.startswith('v '):
+                        # 处理顶点坐标行
+                        parts = line.strip().split()
+                        # 使用相对于整体最小UTM坐标的偏移
+                        x = float(parts[1]) + (east_offset - self.ref_east)
+                        y = float(parts[2]) + (north_offset - self.ref_north)
+                        z = float(parts[3])
+                        f_out.write(f'v {x:.6f} {z:.6f} {-y:.6f}\n')
+                    elif line.startswith('vn '):  # 处理法线向量
+                        parts = line.split()
+                        nx = float(parts[1])
+                        ny = float(parts[2])
+                        nz = float(parts[3])
+                        # 同步反转法线的 Y 轴
+                        new_line = f"vn {nx} {nz} {-ny}\n"
+                        f_out.write(new_line)
+                    else:
+                        # 其他行直接写入
+                        f_out.write(line)
+
+            return obj_dst_file
+        except Exception as e:
+            self.logger.error(f"修改obj坐标时发生错误: {str(e)}")
+            raise
+
+    def downsample_texture(self, src_dir: str, dst_dir: str):
+        """复制并重命名纹理文件，对大于100MB的文件进行多次下采样，直到文件小于100MB
+        Args:
+            src_dir: 源纹理目录
+            dst_dir: 目标纹理目录
+        """
+        for file in os.listdir(src_dir):
+            if file.lower().endswith(('.png')):
+                src_path = os.path.join(src_dir, file)
+                dst_path = os.path.join(dst_dir, file)
+
+                # 检查文件大小（以字节为单位）
+                file_size = os.path.getsize(src_path)
+                if file_size <= 100 * 1024 * 1024:  # 如果文件小于等于100MB，直接复制
+                    shutil.copy2(src_path, dst_path)
+                else:
+                    # 文件大于100MB，进行下采样
+                    img = cv2.imread(src_path, cv2.IMREAD_UNCHANGED)
+                    if_first_ds = True
+                    while file_size > 100 * 1024 * 1024:  # 大于100MB
+                        self.logger.info(f"纹理文件 {file} 大于100MB，进行下采样")
+
+                        if if_first_ds:
+                            # 计算新的尺寸（长宽各变为1/4）
+                            new_size = (img.shape[1] // 4,
+                                        img.shape[0] // 4)  # 逐步减小尺寸
+                            # 使用双三次插值进行下采样
+                            resized_img = cv2.resize(
+                                img, new_size, interpolation=cv2.INTER_CUBIC)
+                            if_first_ds = False
+                        else:
+                            # 计算新的尺寸（长宽各变为1/2）
+                            new_size = (img.shape[1] // 2,
+                                        img.shape[0] // 2)  # 逐步减小尺寸
+                            # 使用双三次插值进行下采样
+                            resized_img = cv2.resize(
+                                img, new_size, interpolation=cv2.INTER_CUBIC)
+
+                        # 更新文件路径为下采样后的路径
+                        cv2.imwrite(dst_path, resized_img, [
+                                    cv2.IMWRITE_PNG_COMPRESSION, 9])
+
+                        # 更新文件大小和图像
+                        file_size = os.path.getsize(dst_path)
+                        img = cv2.imread(dst_path, cv2.IMREAD_UNCHANGED)
+                        self.logger.info(
+                            f"下采样后文件大小: {file_size / (1024 * 1024):.2f} MB")
+
+    def get_min_z_from_obj(self, file_path):
+        min_z = float('inf')  # 初始值设为无穷大
+        with open(file_path, 'r') as obj_file:
+            for line in obj_file:
+                # 检查每一行是否是顶点定义（以 'v ' 开头）
+                if line.startswith('v '):
+                    # 获取顶点坐标
+                    parts = line.split()
+                    # 将z值转换为浮动数字
+                    z = float(parts[3])
+                    # 更新最小z值
+                    if z < min_z:
+                        min_z = z
+        return min_z
+
+    def modify_z_in_obj(self, texturing_dir, min_25d_z):
+        obj_file = os.path.join(texturing_dir, 'odm_textured_model_geo.obj')
+        output_file = os.path.join(
+            texturing_dir, 'odm_textured_model_modified.obj')
+        with open(obj_file, 'r') as f_in, open(output_file, 'w') as f_out:
+            for line in f_in:
+                if line.startswith('v '):  # 顶点坐标行
+                    parts = line.strip().split()
+                    x = float(parts[1])
+                    y = float(parts[2])
+                    z = float(parts[3])
+
+                    if z < min_25d_z:
+                        z = min_25d_z
+
+                    f_out.write(f"v {x} {y} {z}\n")
+                else:
+                    f_out.write(line)

run.py

@@ -0,0 +1,59 @@
+import argparse
+from datetime import timedelta
+from main import ProcessConfig, ODM_Plugin
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='ODM预处理工具')
+
+    # 必需参数
+    # parser.add_argument('--image_dir',  required=True, help='输入图片目录路径')
+    # parser.add_argument('--output_dir', required=True, help='输出目录路径')
+    parser.add_argument(
+        '--image_dir', default=r'E:\datasets\UAV\199', help='输入图片目录路径')
+    parser.add_argument(
+        '--output_dir', default=r'G:\ODM_output\test2', help='输出目录路径')
+    # 可选参数
+    parser.add_argument('--mode', default='三维模式',
+                        choices=['快拼模式', '三维模式'], help='处理模式')
+    parser.add_argument('--accuracy', default='medium',
+                        choices=['high', 'medium', 'low'], help='精度')
+    parser.add_argument('--grid_size', type=float, default=800, help='网格大小(米)')
+    parser.add_argument('--grid_overlap', type=float,
+                        default=0.05, help='网格重叠率')
+
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+
+    # 创建配置
+    config = ProcessConfig(
+        image_dir=args.image_dir,
+        output_dir=args.output_dir,
+        mode=args.mode,
+        accuracy=args.accuracy,
+        grid_size=args.grid_size,
+        grid_overlap=args.grid_overlap,
+
+        # 其他参数使用默认值
+        cluster_eps=0.01,
+        cluster_min_samples=5,
+        time_group_overlap_threshold=0.7,
+        time_group_interval=timedelta(minutes=5),
+        filter_distance_threshold=0.001,
+        filter_min_neighbors=6,
+        filter_grid_size=0.001,
+        filter_dense_distance_threshold=10,
+        filter_time_threshold=timedelta(minutes=5),
+    )
+
+    # 创建处理器并执行
+    processor = ODM_Plugin(config)
+    processor.process()
+
+
+if __name__ == '__main__':
+    main()

utils/docker_runner.py

@@ -0,0 +1,89 @@
+import docker
+import os
+import logging
+from collections import deque
+
+
+class DockerRunner:
+    def __init__(self, project_path: str):
+        """
+        初始化 DockerRunner
+
+        Args:
+            project_path (str): 项目路径，将挂载到 Docker 容器中
+        """
+        self.project_path = project_path
+        self.logger = logging.getLogger("DockerRunner")
+        self.docker_client = docker.from_env()
+
+    def run_odm_container(self):
+        """
+        使用 Docker SDK 运行 OpenDroneMap 容器
+        """
+        try:
+            self.logger.info("开始运行docker run指令")
+            # 挂载路径
+            volume_mapping = {
+                self.project_path: {
+                    'bind': '/datasets',
+                    'mode': 'rw'
+                }
+            }
+
+            # Docker 命令参数
+            command = [
+                "--project-path", "/datasets",
+                "project",
+                "--max-concurrency", "15",
+                "--force-gps",
+                "--split-overlap", "0",
+            ]
+
+            # 运行容器
+            container = self.docker_client.containers.run(
+                image="opendronemap/odm:gpu",
+                command=command,
+                volumes=volume_mapping,
+                device_requests=[
+                    docker.types.DeviceRequest(
+                        count=-1, capabilities=[["gpu"]])
+                ],  # 添加 GPU 支持
+                remove=False,  # 容器运行结束后不自动删除，便于获取日志
+                tty=True,
+                detach=True  # 后台运行
+            )
+
+            # 等待容器运行完成
+            exit_status = container.wait()
+            if exit_status["StatusCode"] != 0:
+                self.logger.error(f"容器运行失败，退出状态码: {exit_status['StatusCode']}")
+
+                # 获取容器的错误日志
+                error_logs = container.logs(
+                    stderr=True).decode("utf-8").splitlines()
+                self.logger.error("容器运行失败的详细错误日志：")
+                for line in error_logs:
+                    self.logger.error(line)
+
+            else:
+                # 获取所有日志
+                logs = container.logs().decode("utf-8").splitlines()
+
+                # 输出最后 50 行日志
+                self.logger.info("容器运行完成，以下是最后 50 行日志：")
+                for line in logs[-50:]:
+                    self.logger.info(line)
+
+            # 删除容器
+            container.remove()
+
+        except Exception as e:
+            self.logger.error(f"运行 Docker 容器时发生错误: {str(e)}", exc_info=True)
+            raise
+
+
+if __name__ == "__main__":
+    # 示例用法
+    project_path = r"E:\datasets\UAV\199"
+    docker_runner = DockerRunner(project_path)
+    docker_runner.run_odm_container()

utils/gps_extractor.py

@@ -0,0 +1,96 @@
+import os
+from PIL import Image
+import piexif
+import logging
+import pandas as pd
+from datetime import datetime
+
+
+class GPSExtractor:
+    """从图像文件提取GPS坐标和拍摄日期"""
+
+    def __init__(self, project_path):
+        self.image_dir = os.path.join(project_path, 'project', 'images')
+        self.logger = logging.getLogger('UAV_Preprocess.GPSExtractor')
+
+    @staticmethod
+    def _dms_to_decimal(dms):
+        """将DMS格式转换为十进制度"""
+        return dms[0][0] / dms[0][1] + (dms[1][0] / dms[1][1]) / 60 + (dms[2][0] / dms[2][1]) / 3600
+
+    @staticmethod
+    def _parse_datetime(datetime_str):
+        """解析EXIF中的日期时间字符串"""
+        try:
+            # EXIF日期格式通常为 'YYYY:MM:DD HH:MM:SS'
+            return datetime.strptime(datetime_str.decode(), '%Y:%m:%d %H:%M:%S')
+        except Exception:
+            return None
+
+    def get_gps_and_date(self, image_path):
+        """提取单张图片的GPS坐标和拍摄日期"""
+        try:
+            image = Image.open(image_path)
+            exif_data = piexif.load(image.info['exif'])
+
+            # 提取GPS信息
+            gps_info = exif_data.get("GPS", {})
+            lat = lon = None
+            if gps_info:
+                lat = self._dms_to_decimal(gps_info.get(2, []))
+                lon = self._dms_to_decimal(gps_info.get(4, []))
+                self.logger.debug(
+                    f"成功提取图片GPS坐标: {image_path} - 纬度: {lat}, 经度: {lon}")
+
+            # 提取拍摄日期
+            date_info = None
+            if "Exif" in exif_data:
+                # 优先使用DateTimeOriginal
+                date_str = exif_data["Exif"].get(36867)  # DateTimeOriginal
+                if not date_str:
+                    # 备选DateTime
+                    date_str = exif_data["Exif"].get(
+                        36868)  # DateTimeDigitized
+                if not date_str:
+                    # 最后使用基本DateTime
+                    date_str = exif_data["0th"].get(306)  # DateTime
+
+                if date_str:
+                    date_info = self._parse_datetime(date_str)
+                    self.logger.debug(
+                        f"成功提取图片拍摄日期: {image_path} - {date_info}")
+
+            if not gps_info:
+                self.logger.warning(f"图片无GPS信息: {image_path}")
+            if not date_info:
+                self.logger.warning(f"图片无拍摄日期信息: {image_path}")
+
+            return lat, lon, date_info
+
+        except Exception as e:
+            self.logger.error(f"提取图片信息时发生错误: {image_path} - {str(e)}")
+            return None, None, None
+
+    def extract_all_gps(self):
+        """提取所有图片的GPS坐标和拍摄日期"""
+        self.logger.info(f"开始从目录提取GPS坐标和拍摄日期: {self.image_dir}")
+        gps_data = []
+        total_images = 0
+        successful_extractions = 0
+
+        for image_file in os.listdir(self.image_dir):
+            total_images += 1
+            image_path = os.path.join(self.image_dir, image_file)
+            lat, lon, date = self.get_gps_and_date(image_path)
+            if lat and lon:  # 仍然以GPS信息作为主要判断依据
+                successful_extractions += 1
+                gps_data.append({
+                    'file': image_file,
+                    'lat': lat,
+                    'lon': lon,
+                    'date': date
+                })
+
+        self.logger.info(
+            f"GPS坐标和拍摄日期提取完成 - 总图片数: {total_images}, 成功提取: {successful_extractions}, 失败: {total_images - successful_extractions}")
+        return pd.DataFrame(gps_data)

utils/grid_divider.py

@@ -0,0 +1,249 @@
+import logging
+from geopy.distance import geodesic
+import matplotlib.pyplot as plt
+import os
+
+
+class GridDivider:
+    """划分网格，并将图片分配到对应网格"""
+
+    def __init__(self, overlap, grid_size, project_path, output_dir):
+        self.overlap = overlap
+        self.grid_size = grid_size
+        self.project_path = project_path
+        self.output_dir = output_dir
+        self.logger = logging.getLogger('UAV_Preprocess.GridDivider')
+        self.logger.info(f"初始化网格划分器，重叠率: {overlap}")
+        self.num_grids_width = 0  # 添加网格数量属性
+        self.num_grids_height = 0
+
+    def adjust_grid_size_and_overlap(self, points_df):
+        """动态调整网格重叠率"""
+        grids = self.adjust_grid_size(points_df)
+        self.logger.info(f"开始动态调整网格重叠率，初始重叠率: {self.overlap}")
+        while True:
+            # 使用调整好的网格大小划分网格
+            grids = self.divide_grids(points_df)
+            grid_points, multiple_grid_points = self.assign_to_grids(
+                points_df, grids)
+
+            if len(grids) == 1:
+                self.logger.info(f"网格数量为1，跳过重叠率调整")
+                break
+            elif multiple_grid_points < 0.1*len(points_df):
+                self.overlap += 0.02
+                self.logger.info(f"重叠率增加到: {self.overlap}")
+            else:
+                self.logger.info(
+                    f"找到合适的重叠率: {self.overlap}, 有{multiple_grid_points}个点被分配到多个网格")
+                break
+        return grids, grid_points
+
+    def adjust_grid_size(self, points_df):
+        """动态调整网格大小
+
+        Args:
+            points_df: 包含GPS点的DataFrame
+
+        Returns:
+            tuple: (grids, translations, grid_points, final_grid_size)
+        """
+        self.logger.info(f"开始动态调整网格大小，初始大小: {self.grid_size}米")
+
+        while True:
+            # 使用当前grid_size划分网格
+            grids = self.divide_grids(points_df)
+            grid_points, multiple_grid_points = self.assign_to_grids(
+                points_df, grids)
+
+            # 检查每个网格中的点数
+            max_points = 0
+            for grid_id, points in grid_points.items():
+                max_points = max(max_points, len(points))
+
+            self.logger.info(
+                f"当前网格大小: {self.grid_size}米, 单个网格最大点数: {max_points}")
+
+            # 如果最大点数超过1600，减小网格大小
+            if max_points > 1600:
+                self.grid_size -= 100
+                self.logger.info(f"点数超过1500，减小网格大小至: {self.grid_size}米")
+                if self.grid_size < 500:  # 设置一个最小网格大小限制
+                    self.logger.warning("网格大小已达到最小值500米，停止调整")
+                    break
+            else:
+                self.logger.info(f"找到合适的网格大小: {self.grid_size}米")
+                break
+        return grids
+
+    def divide_grids(self, points_df):
+        """计算边界框并划分网格
+        Returns:
+            tuple: (grids, translations)
+                - grids: 网格边界列表
+                - translations: 网格平移量字典
+        """
+        self.logger.info("开始划分网格")
+
+        min_lat, max_lat = points_df['lat'].min(), points_df['lat'].max()
+        min_lon, max_lon = points_df['lon'].min(), points_df['lon'].max()
+
+        # 计算区域的实际距离（米）
+        width = geodesic((min_lat, min_lon), (min_lat, max_lon)).meters
+        height = geodesic((min_lat, min_lon), (max_lat, min_lon)).meters
+
+        self.logger.info(f"区域宽度: {width:.2f}米, 高度: {height:.2f}米")
+
+        # 精细调整网格的长宽，避免出现2*grid_size-1的情况的影响
+        grid_size_lt = [self.grid_size - 200, self.grid_size - 100,
+                        self.grid_size, self.grid_size + 100, self.grid_size + 200]
+
+        width_modulus_lt = [width % grid_size for grid_size in grid_size_lt]
+        grid_width = grid_size_lt[width_modulus_lt.index(
+            min(width_modulus_lt))]
+        height_modulus_lt = [height % grid_size for grid_size in grid_size_lt]
+        grid_height = grid_size_lt[height_modulus_lt.index(
+            min(height_modulus_lt))]
+        self.logger.info(f"网格宽度: {grid_width:.2f}米, 网格高度: {grid_height:.2f}米")
+
+        # 计算需要划分的网格数量
+        self.num_grids_width = max(int(width / grid_width), 1)
+        self.num_grids_height = max(int(height / grid_height), 1)
+
+        # 计算每个网格对应的经纬度步长
+        lat_step = (max_lat - min_lat) / self.num_grids_height
+        lon_step = (max_lon - min_lon) / self.num_grids_width
+
+        grids = []
+
+        # 先创建所有网格
+        for i in range(self.num_grids_height):
+            for j in range(self.num_grids_width):
+                grid_min_lat = min_lat + i * lat_step - self.overlap * lat_step
+                grid_max_lat = min_lat + \
+                    (i + 1) * lat_step + self.overlap * lat_step
+                grid_min_lon = min_lon + j * lon_step - self.overlap * lon_step
+                grid_max_lon = min_lon + \
+                    (j + 1) * lon_step + self.overlap * lon_step
+
+                grid_bounds = (grid_min_lat, grid_max_lat,
+                               grid_min_lon, grid_max_lon)
+                grids.append(grid_bounds)
+
+                self.logger.debug(
+                    f"网格[{i},{j}]: 纬度[{grid_min_lat:.6f}, {grid_max_lat:.6f}], "
+                    f"经度[{grid_min_lon:.6f}, {grid_max_lon:.6f}]"
+                )
+
+        self.logger.info(
+            f"成功划分为 {len(grids)} 个网格 ({self.num_grids_width}x{self.num_grids_height})")
+
+        return grids
+
+    def assign_to_grids(self, points_df, grids):
+        """将点分配到对应网格"""
+        self.logger.info(f"开始将 {len(points_df)} 个点分配到网格中")
+
+        grid_points = {}  # 使用字典存储每个网格的点
+        points_assigned = 0
+        multiple_grid_points = 0
+
+        for i in range(self.num_grids_height):
+            for j in range(self.num_grids_width):
+                grid_points[(i, j)] = []  # 使用(i,j)元组
+
+        for _, point in points_df.iterrows():
+            point_assigned = False
+            for i in range(self.num_grids_height):
+                for j in range(self.num_grids_width):
+                    grid_idx = i * self.num_grids_width + j
+                    min_lat, max_lat, min_lon, max_lon = grids[grid_idx]
+
+                    if min_lat <= point['lat'] <= max_lat and min_lon <= point['lon'] <= max_lon:
+                        grid_points[(i, j)].append(point.to_dict())
+                        if point_assigned:
+                            multiple_grid_points += 1
+                        else:
+                            points_assigned += 1
+                            point_assigned = True
+
+        # 记录每个网格的点数
+        for grid_id, points in grid_points.items():
+            self.logger.info(f"网格 {grid_id} 包含 {len(points)} 个点")
+
+        self.logger.info(
+            f"点分配完成: 总点数 {len(points_df)}, "
+            f"成功分配 {points_assigned} 个点, "
+            f"{multiple_grid_points} 个点被分配到多个网格"
+        )
+
+        return grid_points, multiple_grid_points
+
+    def visualize_grids(self, points_df, grids):
+        """可视化网格划分和GPS点的分布"""
+        self.logger.info("开始可视化网格划分")
+
+        plt.figure(figsize=(12, 8))
+
+        # 绘制GPS点
+        plt.scatter(points_df['lon'], points_df['lat'],
+                    c='blue', s=10, alpha=0.6, label='GPS points')
+
+        # 绘制网格
+        for i in range(self.num_grids_height):
+            for j in range(self.num_grids_width):
+                grid_idx = i * self.num_grids_width + j
+                min_lat, max_lat, min_lon, max_lon = grids[grid_idx]
+
+                # 计算网格的实际长度和宽度（米）
+                width = geodesic((min_lat, min_lon), (min_lat, max_lon)).meters
+                height = geodesic((min_lat, min_lon),
+                                  (max_lat, min_lon)).meters
+
+                plt.plot([min_lon, max_lon, max_lon, min_lon, min_lon],
+                         [min_lat, min_lat, max_lat, max_lat, min_lat],
+                         'r-', alpha=0.5)
+                # 在网格中心添加网格编号和尺寸信息
+                center_lon = (min_lon + max_lon) / 2
+                center_lat = (min_lat + max_lat) / 2
+                plt.text(center_lon, center_lat,
+                         f"({i},{j})\n{width:.0f}m×{height:.0f}m",  # 显示(i,j)和尺寸
+                         horizontalalignment='center',
+                         verticalalignment='center',
+                         fontsize=8)
+
+        plt.title('Grid Division and GPS Point Distribution')
+        plt.xlabel('Longitude')
+        plt.ylabel('Latitude')
+        plt.legend()
+        plt.grid(True)
+
+        # 如果提供了输出目录，保存图像
+        if self.output_dir:
+            save_path = os.path.join(
+                self.output_dir, 'filter_imgs', 'grid_division.png')
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+            self.logger.info(f"网格划分可视化图已保存至: {save_path}")
+
+        plt.close()
+
+    def save_image_groups(self, grid_points, output_file_name="image_groups.txt"):
+        """保存图像分组信息到文件
+
+        Args:
+            grid_points (dict): 每个网格的点信息，键为(i, j)，值为点的列表
+            output_file (str): 输出文件路径
+        """
+        self.logger.info(f"开始保存图像分组信息到 {output_file_name}")
+
+        output_file = os.path.join(
+            self.project_path, 'project', output_file_name)
+        with open(output_file, 'w') as f:
+            for (i, j), points in grid_points.items():
+                # 计算组编号（按行展开的顺序）
+                group_id = i * self.num_grids_width + j + 1
+                for point in points:
+                    image_name = point.get('file', 'unknown')
+                    f.write(f"{image_name} {group_id}\n")
+
+        self.logger.info(f"图像分组信息已保存到 {output_file}")

utils/logger.py

@@ -0,0 +1,36 @@
+import logging
+import os
+from datetime import datetime
+
+
+def setup_logger(output_dir):
+    # 创建logs目录
+    log_dir = os.path.join(output_dir, 'logs')
+
+    # 创建日志文件名（包含时间戳）
+    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+    log_file = os.path.join(log_dir, f'preprocess_{timestamp}.log')
+
+    # 配置日志格式
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+
+    # 配置文件处理器
+    file_handler = logging.FileHandler(log_file, encoding='utf-8')
+    file_handler.setFormatter(formatter)
+
+    # 配置控制台处理器
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+
+    # 获取根日志记录器
+    logger = logging.getLogger('UAV_Preprocess')
+    logger.setLevel(logging.INFO)
+
+    # 添加处理器
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+
+    return logger

utils/visualizer.py

@@ -0,0 +1,152 @@
+import os
+import matplotlib.pyplot as plt
+import pandas as pd
+import logging
+from typing import Optional
+from pyproj import Transformer
+
+
+class FilterVisualizer:
+    """过滤结果可视化器"""
+
+    def __init__(self, output_dir: str):
+        """
+        初始化可视化器
+
+        Args:
+            output_dir: 输出目录路径
+        """
+        self.output_dir = output_dir
+        self.logger = logging.getLogger('UAV_Preprocess.Visualizer')
+        # 创建坐标转换器
+        self.transformer = Transformer.from_crs(
+            "EPSG:4326",  # WGS84经纬度坐标系
+            "EPSG:32649",  # UTM49N
+            always_xy=True
+        )
+
+    def _convert_to_utm(self, lon: pd.Series, lat: pd.Series) -> tuple:
+        """
+        将经纬度坐标转换为UTM坐标
+
+        Args:
+            lon: 经度序列
+            lat: 纬度序列
+
+        Returns:
+            tuple: (x坐标, y坐标)
+        """
+        return self.transformer.transform(lon, lat)
+
+    def visualize_filter_step(self,
+                              current_points: pd.DataFrame,
+                              previous_points: pd.DataFrame,
+                              step_name: str,
+                              save_name: Optional[str] = None):
+        """
+        可视化单个过滤步骤的结果
+
+        Args:
+            current_points: 当前步骤后的点
+            previous_points: 上一步骤的点
+            step_name: 步骤名称
+            save_name: 保存文件名，默认为step_name
+        """
+        self.logger.info(f"开始生成{step_name}的可视化结果")
+
+        # 找出被过滤掉的点
+        filtered_files = set(
+            previous_points['file']) - set(current_points['file'])
+        filtered_points = previous_points[previous_points['file'].isin(
+            filtered_files)]
+
+        # 转换坐标到UTM
+        current_x, current_y = self._convert_to_utm(
+            current_points['lon'], current_points['lat'])
+        filtered_x, filtered_y = self._convert_to_utm(
+            filtered_points['lon'], filtered_points['lat'])
+
+        # 创建图形
+        plt.rcParams['font.sans-serif'] = ['SimHei']  # 黑体
+        plt.rcParams['axes.unicode_minus'] = False
+        plt.figure(figsize=(20, 16))
+
+        # 绘制保留的点
+        plt.scatter(current_x, current_y,
+                    color='blue', label='保留的点',
+                    alpha=0.6, s=50)
+
+        # 绘制被过滤的点
+        if not filtered_points.empty:
+            plt.scatter(filtered_x, filtered_y,
+                        color='red', marker='x', label='过滤的点',
+                        alpha=0.6, s=100)
+
+        # 设置图形属性
+        plt.title(f"{step_name}后的GPS点\n"
+                  f"(过滤: {len(filtered_points)}, 保留: {len(current_points)})",
+                  fontsize=14)
+        plt.xlabel("东向坐标 (米)", fontsize=12)
+        plt.ylabel("北向坐标 (米)", fontsize=12)
+        plt.grid(True)
+
+        # 添加统计信息
+        stats_text = (
+            f"原始点数: {len(previous_points)}\n"
+            f"过滤点数: {len(filtered_points)}\n"
+            f"保留点数: {len(current_points)}\n"
+            f"过滤率: {len(filtered_points)/len(previous_points)*100:.1f}%"
+        )
+        plt.figtext(0.02, 0.02, stats_text, fontsize=10,
+                    bbox=dict(facecolor='white', alpha=0.8))
+
+        # 添加图例
+        plt.legend(loc='upper right', fontsize=10)
+
+        # 调整布局
+        plt.tight_layout()
+
+        # 保存图形
+        save_name = save_name or step_name.lower().replace(' ', '_')
+        save_path = os.path.join(
+            self.output_dir, 'filter_imgs', f'filter_{save_name}.png')
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        plt.close()
+
+        self.logger.info(
+            f"{step_name}过滤可视化结果已保存至 {save_path}\n"
+            f"过滤掉 {len(filtered_points)} 个点，"
+            f"保留 {len(current_points)} 个点，"
+            f"过滤率 {len(filtered_points)/len(previous_points)*100:.1f}%"
+        )
+
+
+if __name__ == '__main__':
+    # 测试代码
+    import numpy as np
+    from datetime import datetime
+
+    # 创建测试数据
+    np.random.seed(42)
+    n_points = 1000
+
+    # 生成随机点
+    test_data = pd.DataFrame({
+        'lon': np.random.uniform(120, 121, n_points),
+        'lat': np.random.uniform(30, 31, n_points),
+        'file': [f'img_{i}.jpg' for i in range(n_points)],
+        'date': [datetime.now() for _ in range(n_points)]
+    })
+
+    # 随机选择点作为过滤后的结果
+    filtered_data = test_data.sample(n=800)
+
+    # 测试可视化
+    visualizer = FilterVisualizer('test_output')
+    os.makedirs('test_output', exist_ok=True)
+
+    visualizer.visualize_filter_step(
+        filtered_data,
+        test_data,
+        "Test Filter"
+    )