gotrackit 0.2.2__tar.gz → 0.2.3__tar.gz

{gotrackit-0.2.2/src/gotrackit.egg-info → gotrackit-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gotrackit
-Version: 0.2.2
+Version: 0.2.3
 Summary: A Python Package for Map Matching Algorithm Based on Hidden Markov Model
 Author-email: Kai Tang <794568794@qq.com>
 License: LICENCE
@@ -38,26 +38,34 @@ Requires-Dist: geopy
 
 ~ 一个包搞定：路网获取、路网优化、宏微观地图匹配、匹配可视化、问题路段快速定位 ~
 
-唐铠, 794568794@qq.com, tangkai@zhechengdata.com
+Developed by Tang Kai, Email: 794568794@qq.com & tangkai@zhechengdata.com
 </div>
 <br>
 
 
 
-**版本状态：04.27即将更新更新: v0.2.2**
+**版本状态：05.07已经更新: v0.2.3**
 
 更新命令：pip install --upgrade  -i https://pypi.org/simple/ gotrackit
 
-- 向量化改造, 且引入FMM(Fast Map Matching)路径预存储机制, 大规模路网匹配效率大幅度提升
 
-- 完善报错机制, 遇到GPS脏数据不再报错停止, 而是跳过, 并且在所有的agents计算完毕后输出有问题的agent编号
+- 效率优化, 相较于v0.2.2小幅度提升
+
+- crs判断BUG修复、境外路网构建失败BUG修复
+
+- 报错机制优化
+
+- 输出文件目录指定参数html_fldr废除, 改为out_fldr
+
+- 增加环路处理功能
+    
+- 增加匹配结果即时输出参数, 每匹配完一条轨迹可马上进行结果存储
 
-- BUG修复
 
 <br>
 
 <div align=center>
-~ v0.2.2效率将大幅度提升 ~
+~ v0.2.2效率将大幅度提升, 最高可以提升10倍的性能 !~
 </div>
 
 <br>
@@ -155,7 +163,7 @@ v0.2.2多核效率对比:
 - 算法原理讲解部分不涉及复杂的公式推导，使用动画形式剖析算法原理,简洁明了。
 
 **匹配结果自动优化**
-- 对基于HMM匹配的初步路径进行了优化，对于不连通的位置会自动补路，对于实际路网不连通的位置会输出警告，方便用户检查路网。
+- 对基于HMM匹配的初步路径进行了优化，对于不连通的位置会自动搜路补全，对于实际路网不连通的位置会输出警告信息，方便用户回溯问题。
 
 
 

{gotrackit-0.2.2 → gotrackit-0.2.3}/README.md

@@ -16,26 +16,34 @@
 
 ~ 一个包搞定：路网获取、路网优化、宏微观地图匹配、匹配可视化、问题路段快速定位 ~
 
-唐铠, 794568794@qq.com, tangkai@zhechengdata.com
+Developed by Tang Kai, Email: 794568794@qq.com & tangkai@zhechengdata.com
 </div>
 <br>
 
 
 
-**版本状态：04.27即将更新更新: v0.2.2**
+**版本状态：05.07已经更新: v0.2.3**
 
 更新命令：pip install --upgrade  -i https://pypi.org/simple/ gotrackit
 
-- 向量化改造, 且引入FMM(Fast Map Matching)路径预存储机制, 大规模路网匹配效率大幅度提升
 
-- 完善报错机制, 遇到GPS脏数据不再报错停止, 而是跳过, 并且在所有的agents计算完毕后输出有问题的agent编号
+- 效率优化, 相较于v0.2.2小幅度提升
+
+- crs判断BUG修复、境外路网构建失败BUG修复
+
+- 报错机制优化
+
+- 输出文件目录指定参数html_fldr废除, 改为out_fldr
+
+- 增加环路处理功能
+    
+- 增加匹配结果即时输出参数, 每匹配完一条轨迹可马上进行结果存储
 
-- BUG修复
 
 <br>
 
 <div align=center>
-~ v0.2.2效率将大幅度提升 ~
+~ v0.2.2效率将大幅度提升, 最高可以提升10倍的性能 !~
 </div>
 
 <br>
@@ -133,7 +141,7 @@ v0.2.2多核效率对比:
 - 算法原理讲解部分不涉及复杂的公式推导，使用动画形式剖析算法原理,简洁明了。
 
 **匹配结果自动优化**
-- 对基于HMM匹配的初步路径进行了优化，对于不连通的位置会自动补路，对于实际路网不连通的位置会输出警告，方便用户检查路网。
+- 对基于HMM匹配的初步路径进行了优化，对于不连通的位置会自动搜路补全，对于实际路网不连通的位置会输出警告信息，方便用户回溯问题。
 
 
 

{gotrackit-0.2.2 → gotrackit-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gotrackit"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = ["geopandas>=0.14.1", "shapely", "networkx", "pandas", "numpy", "keplergl", "geopy"]
 requires-python = ">=3.8"
 authors = [

{gotrackit-0.2.2 → gotrackit-0.2.3}/src/gotrackit/MapMatch.py

@@ -26,19 +26,19 @@ class MapMatch(object):
                  time_format: str = "%Y-%m-%d %H:%M:%S", time_unit: str = 's',
                  gps_buffer: float = 200.0, gps_route_buffer_gap: float = 15.0,
                  max_increment_times: int = 2, increment_buffer: float = 15.0,
-                 beta: float = 20.0, gps_sigma: float = 20.0, dis_para: float = 0.1,
+                 beta: float = 6.0, gps_sigma: float = 30.0, dis_para: float = 0.1,
                  is_lower_f: bool = False, lower_n: int = 2,
                  use_heading_inf: bool = False, heading_para_array: np.ndarray = None,
                  dense_gps: bool = True, dense_interval: float = 80.0,
                  dwell_l_length: float = 10.0, dwell_n: int = 2, del_dwell: bool = True,
                  dup_threshold: float = 10.0,
                  is_rolling_average: bool = False, window: int = 2,
-                 export_html: bool = False, use_gps_source: bool = False, html_fldr: str = None,
+                 export_html: bool = False, use_gps_source: bool = False, out_fldr: str = None,
                  export_geo_res: bool = False,
                  node_num_threshold: int = 2000, top_k: int = 20, omitted_l: float = 6.0,
                  link_width: float = 1.5, node_radius: float = 1.5,
                  match_link_width: float = 5.0, gps_radius: float = 6.0, export_all_agents: bool = False,
-                 visualization_cache_times: int = 50, multi_core_save: bool = False):
+                 visualization_cache_times: int = 50, multi_core_save: bool = False, instant_output: bool = False):
         """
         :param flag_name: 标记字符名称, 会用于标记输出的可视化文件, 默认"test"
         :param net: gotrackit路网对象, 必须指定
@@ -64,14 +64,15 @@ class MapMatch(object):
         :param window: 滑动窗口大小, 默认2
         :param export_html: 是否输出网页可视化结果html文件, 默认True
         :param use_gps_source: 是否在可视化结果中使用GPS源数据进行展示, 默认False
-        :param html_fldr: 保存网页可视化结果的文件目录, 默认当前目录
+        :param out_fldr: 保存匹配结果的文件目录, 默认当前目录
         :param export_geo_res: 是否输出匹配结果的几何可视化文件, 默认False
         :param node_num_threshold: 默认2000
         :param omitted_l: 当某GPS点与前后GPS点的平均距离小于该距离(m)时, 该GPS点的方向限制作用被取消
         :param gps_radius: HTML可视化中GPS点的半径大小，单位米，默认8米
         :param export_all_agents: 是否将所有agent的可视化存储于一个html文件中
-        :param visualization_cache_times: 每匹配完几辆车再进行结果的统一存储, 默认50
+        :param visualization_cache_times: 每匹配完几辆车再进行(html or geojson文件)结果的统一存储, 默认50
         :param multi_core_save: 是否启用多进程进行结果存储
+        :param instant_output: 是否每匹配完一条轨迹就存储csv匹配结果
         """
         # 坐标系投影
         self.plain_crs = net.planar_crs
@@ -115,7 +116,7 @@ class MapMatch(object):
 
         self.export_html = export_html
         self.export_geo_res = export_geo_res
-        self.html_fldr = html_fldr
+        self.out_fldr = r'./' if out_fldr is None else out_fldr
 
         self.may_error_list = dict()
         self.error_list = list()
@@ -134,6 +135,7 @@ class MapMatch(object):
         self.visualization_cache_times = visualization_cache_times
         self.multi_core_save = multi_core_save
         self.sub_net_buffer = self.gps_buffer + self.gps_route_buffer_gap + max_increment_times * increment_buffer
+        self.instant_output = instant_output
 
     def execute(self) -> tuple[pd.DataFrame, dict, list]:
         match_res_df = pd.DataFrame()
@@ -152,29 +154,49 @@ class MapMatch(object):
         for agent_id, _gps_df in self.gps_df.groupby(gps_field.AGENT_ID_FIELD):
             agent_count += 1
             print(rf'- gotrackit ------> No.{agent_count}: agent: {agent_id} ')
-            gps_obj = GpsPointsGdf(gps_points_df=_gps_df, time_format=self.time_format,
-                                   buffer=self.gps_buffer, time_unit=self.time_unit,
-                                   plane_crs=self.plain_crs,
-                                   max_increment_times=self.max_increment_times, increment_buffer=self.increment_buffer,
-                                   dense_gps=self.dense_gps, dense_interval=self.dense_interval,
-                                   dwell_l_length=self.dwell_l_length, dwell_n=self.dwell_n)
+            try:
+                gps_obj = GpsPointsGdf(gps_points_df=_gps_df, time_format=self.time_format,
+                                       buffer=self.gps_buffer, time_unit=self.time_unit,
+                                       plane_crs=self.plain_crs,
+                                       max_increment_times=self.max_increment_times,
+                                       increment_buffer=self.increment_buffer,
+                                       dense_gps=self.dense_gps, dense_interval=self.dense_interval,
+                                       dwell_l_length=self.dwell_l_length, dwell_n=self.dwell_n)
+            except Exception as e:
+                print('构建按GPS对象出错...')
+                print(repr(e))
+                self.error_list.append(agent_id)
+                continue
+
             del _gps_df
 
-            if self.del_dwell:
-                gps_obj.del_dwell_points()
+            # gps-process
+            try:
+                if self.del_dwell:
+                    print(rf'gps-preprocessing: del dwell')
+                    gps_obj.del_dwell_points()
+
+                # 降频处理
+                if self.is_lower_f:
+                    print(rf'gps-preprocessing: lower frequency, size: {self.lower_n}')
+                    gps_obj.lower_frequency(n=self.lower_n)
 
-            # 降频处理
-            if self.is_lower_f:
-                print(rf'lower {self.lower_n} - frequency')
-                gps_obj.lower_frequency(n=self.lower_n)
+                if self.is_rolling_average:
+                    print(rf'gps-preprocessing: rolling average, window size: {self.rolling_window}')
+                    gps_obj.rolling_average(window=self.rolling_window)
 
-            if self.is_rolling_average:
-                print(rf'rolling average by window size - {self.rolling_window}')
-                gps_obj.rolling_average(window=self.rolling_window)
+                if self.dense_gps:
+                    print(rf'gps-preprocessing: dense gps by interval: {self.dense_interval}m')
+                    gps_obj.dense()
+            except Exception as e:
+                print(rf'gps数据预处理出错:{repr(e)}')
+                self.error_list.append(agent_id)
+                continue
 
-            if self.dense_gps:
-                print(rf'dense gps by interval - {self.dense_interval}m')
-                gps_obj.dense()
+            if len(gps_obj.gps_gdf) <= 1:
+                print(r'经过数据预处理后GPS观测点数据不足2个')
+                self.error_list.append(agent_id)
+                continue
 
             # 依据当前的GPS数据(源数据)做一个子网络
             if self.use_sub_net:
@@ -199,15 +221,39 @@ class MapMatch(object):
                                    top_k=self.top_k, omitted_l=self.omitted_l)
 
             # 求解参数
-            is_success = hmm_obj.generate_markov_para(add_single_ft)
+            try:
+                is_success = hmm_obj.generate_markov_para(add_single_ft)
+            except Exception as e:
+                print(rf'解算HMM参数出错:{repr(e)}')
+                is_success = False
             if not is_success:
+                self.error_list.append(agent_id)
                 continue
-            hmm_obj.solve()
-            _match_res_df = hmm_obj.acquire_res()
+
+            # 求解模型
+            try:
+                hmm_obj.solve()
+            except Exception as e:
+                print(rf'求解HMM模型出错:{repr(e)}')
+                self.error_list.append(agent_id)
+                continue
+
+            # 获取结果
+            try:
+                _match_res_df = hmm_obj.acquire_res()
+            except Exception as e:
+                print(rf'获取匹配结果出错:{repr(e)}')
+                self.error_list.append(agent_id)
+                continue
+            if self.instant_output:
+                _match_res_df.to_csv(os.path.join(self.out_fldr, rf'{agent_id}_match_res.csv'),
+                                     encoding='utf_8_sig', index=False)
+            else:
+                match_res_df = pd.concat([match_res_df, _match_res_df])
+
             hmm_obj.format_war_info()
             if hmm_obj.is_warn:
                 self.may_error_list[agent_id] = hmm_obj.format_warn_info
-            match_res_df = pd.concat([match_res_df, _match_res_df])
 
             # if export files
             if self.export_html or self.export_geo_res:
@@ -216,8 +262,9 @@ class MapMatch(object):
                     export_visualization(hmm_obj_list=hmm_res_list, use_gps_source=self.use_gps_source,
                                          export_geo=self.export_geo_res, export_html=self.export_html,
                                          gps_radius=self.gps_radius, export_all_agents=self.export_all_agents,
-                                         out_fldr=self.html_fldr, flag_name=self.flag_name,
-                                         multi_core_save=self.multi_core_save)
+                                         out_fldr=self.out_fldr, flag_name=self.flag_name,
+                                         multi_core_save=self.multi_core_save, sub_net_buffer=self.sub_net_buffer,
+                                         dup_threshold=self.dup_threshold)
                     del hmm_res_list
                     hmm_res_list = []
 
@@ -232,11 +279,11 @@ class MapMatch(object):
         pool = multiprocessing.Pool(processes=n)
         result_list = []
         for i in range(0, n):
-            core_html_fldr = os.path.join(self.html_fldr, rf'core{i}')
-            if os.path.exists(core_html_fldr):
+            core_out_fldr = os.path.join(self.out_fldr, rf'core{i}')
+            if os.path.exists(core_out_fldr):
                 pass
             else:
-                os.makedirs(core_html_fldr)
+                os.makedirs(core_out_fldr)
 
             agent_id_list = agent_group[i]
             gps_df = self.gps_df[self.gps_df[gps_field.AGENT_ID_FIELD].isin(agent_id_list)]
@@ -254,7 +301,7 @@ class MapMatch(object):
                            dup_threshold=self.dup_threshold, is_rolling_average=self.is_rolling_average,
                            window=self.rolling_window,
                            export_html=self.export_html,
-                           use_gps_source=self.use_gps_source, html_fldr=core_html_fldr,
+                           use_gps_source=self.use_gps_source, out_fldr=core_out_fldr,
                            export_geo_res=self.export_geo_res,
                            node_num_threshold=self.node_num_threshold,
                            top_k=self.top_k, omitted_l=self.omitted_l, link_width=self.link_width,
@@ -262,7 +309,7 @@ class MapMatch(object):
                            match_link_width=self.match_link_width, gps_radius=self.gps_radius,
                            export_all_agents=self.export_all_agents,
                            visualization_cache_times=self.visualization_cache_times,
-                           multi_core_save=False)
+                           multi_core_save=False, instant_output=self.instant_output)
             result = pool.apply_async(mmp.execute,
                                       args=())
             result_list.append(result)

{gotrackit-0.2.2 → gotrackit-0.2.3}/src/gotrackit/gps/GpsArray.py

@@ -70,7 +70,7 @@ class GpsArray(object):
         return self.__crs
 
     def to_plane_prj(self) -> None:
-        if self.gps_points_gdf.crs.srs == self.plane_crs:
+        if self.gps_points_gdf.crs.srs.upper() == self.plane_crs:
             self.__crs = self.plane_crs
             pass
         else:
@@ -78,7 +78,7 @@ class GpsArray(object):
             self.__crs = self.plane_crs
 
     def to_geo_prj(self) -> None:
-        if self.gps_points_gdf.crs.srs == self.geo_crs:
+        if self.gps_points_gdf.crs.srs.upper() == self.geo_crs:
             self.__crs = self.geo_crs
             pass
         else:

{gotrackit-0.2.2 → gotrackit-0.2.3}/src/gotrackit/gps/GpsXfer.py

@@ -35,7 +35,7 @@ class Route2Gps(object):
         :return:
         """
 
-        assert path_gdf.crs.srs == 'EPSG:4326'
+        assert path_gdf.crs.srs.upper() == 'EPSG:4326'
         assert len(path_o_time_df) >= 1
         assert {path_id_field, seq_field, time_cost_field, geometry_field}.issubset(set(path_gdf.columns))
         assert {path_id_field, o_time_field}.issubset(set(path_o_time_df.columns))

{gotrackit-0.2.2 → gotrackit-0.2.3}/src/gotrackit/gps/LocGps.py

@@ -87,6 +87,7 @@ class GpsPointsGdf(object):
         except ValueError:
             self.__gps_points_gdf[gps_field.TIME_FIELD] = \
                 pd.to_datetime(self.__gps_points_gdf[gps_field.TIME_FIELD], unit=time_unit)
+
         self.__gps_points_gdf.sort_values(by=[gps_field.TIME_FIELD], ascending=[True], inplace=True)
         self.__gps_points_gdf[gps_field.POINT_SEQ_FIELD] = [i for i in range(len(self.__gps_points_gdf))]
         self.__gps_points_gdf[gps_field.ORIGIN_POINT_SEQ_FIELD] = self.__gps_points_gdf[gps_field.POINT_SEQ_FIELD]
@@ -152,15 +153,20 @@ class GpsPointsGdf(object):
         # 距离差
         self.__gps_points_gdf[next_p_field] = self.__gps_points_gdf[geometry_field].shift(-1).fillna(
             self.__gps_points_gdf[geometry_field])
-        self.__gps_points_gdf[dis_gap_field] = self.__gps_points_gdf.apply(
-            lambda row: row[next_p_field].distance(row[geometry_field]), axis=1)
+        # self.__gps_points_gdf[dis_gap_field] = self.__gps_points_gdf.apply(
+        #     lambda row: row[next_p_field].distance(row[geometry_field]), axis=1)
+        self.__gps_points_gdf[dis_gap_field] = self.__gps_points_gdf[next_p_field].distance(
+            self.__gps_points_gdf[geometry_field])
 
     def calc_adj_time_gap(self) -> None:
         # 时间差
         self.__gps_points_gdf[next_time_field] = self.__gps_points_gdf[time_field].shift(-1).fillna(
             self.__gps_points_gdf[time_field])
-        self.__gps_points_gdf[time_gap_field] = self.__gps_points_gdf.apply(
-            lambda row: (row[next_time_field] - row[time_field]).seconds, axis=1)
+        # self.__gps_points_gdf[time_gap_field] = self.__gps_points_gdf.apply(
+        #     lambda row: (row[next_time_field] - row[time_field]).seconds, axis=1)
+        self.__gps_points_gdf[time_gap_field] = self.__gps_points_gdf[next_time_field] - self.__gps_points_gdf[
+            time_field]
+        self.__gps_points_gdf[time_gap_field] = self.__gps_points_gdf[time_gap_field].apply(lambda x: x.seconds)
 
     def calc_pre_next_dis(self) -> pd.DataFrame():
         self.calc_adj_dis_gap()
@@ -289,14 +295,10 @@ class GpsPointsGdf(object):
 
     def get_gps_array_buffer(self, buffer: float = 200.0, dup_threshold: float = 10.0) -> Polygon or None:
         """输出gps路径的buffer范围面域"""
-        if len(self.__gps_points_gdf) <= 1:
-            print(r'经过数据预处理后GPS观测点数据不足2个')
-            return None
-        else:
-            gps_route_l = gpd.GeoSeries(LineString(self.__gps_points_gdf[gps_field.GEOMETRY_FIELD].to_list()))
-            simplify_gps_route_l = gps_route_l.remove_repeated_points(dup_threshold)
-            gps_array_buffer = simplify_gps_route_l[0].buffer(buffer)
-            return gps_array_buffer
+        gps_route_l = gpd.GeoSeries(LineString(self.__gps_points_gdf[gps_field.GEOMETRY_FIELD].to_list()))
+        simplify_gps_route_l = gps_route_l.remove_repeated_points(dup_threshold)
+        gps_array_buffer = simplify_gps_route_l[0].buffer(buffer)
+        return gps_array_buffer
 
     def generate_candidate_link(self, net: Net = None) -> tuple[pd.DataFrame, list[int]]:
         """
@@ -305,7 +307,7 @@ class GpsPointsGdf(object):
         :return: GPS候选路段信息, 未匹配到候选路段的gps点id
         """
         gps_buffer_gdf = self.__gps_points_gdf[[gps_field.POINT_SEQ_FIELD, gps_field.GEOMETRY_FIELD]].copy()
-        if gps_buffer_gdf.crs.srs != self.plane_crs:
+        if gps_buffer_gdf.crs.srs.upper() != self.plane_crs:
             gps_buffer_gdf = gps_buffer_gdf.to_crs(self.plane_crs)
 
         single_link_gdf = net.get_link_data()[[net_field.SINGLE_LINK_ID_FIELD, net_field.FROM_NODE_FIELD,
@@ -344,7 +346,7 @@ class GpsPointsGdf(object):
         return candidate_link, remain_gps_list
 
     def to_plane_prj(self) -> None:
-        if self.__gps_points_gdf.crs.srs == self.plane_crs:
+        if self.__gps_points_gdf.crs.srs.upper() == self.plane_crs:
             self.__crs = self.plane_crs
             pass
         else:
@@ -352,7 +354,7 @@ class GpsPointsGdf(object):
             self.__crs = self.plane_crs
 
     def to_geo_prj(self) -> None:
-        if self.__gps_points_gdf.crs.srs == self.geo_crs:
+        if self.__gps_points_gdf.crs.srs.upper() == self.geo_crs:
             self.__crs = self.geo_crs
             pass
         else:

{gotrackit-0.2.2 → gotrackit-0.2.3}/src/gotrackit/map/Link.py

@@ -7,7 +7,6 @@
 路网线层存储与相关方法
 """
 
-import warnings
 import numpy as np
 import pandas as pd
 import networkx as nx
@@ -20,7 +19,6 @@ from ..netreverse.RoadNet.Tools.process import merge_double_link
 net_field = NetField()
 prj_const = PrjConst()
 
-
 geo_crs = prj_const.PRJ_CRS
 link_id_field = net_field.LINK_ID_FIELD
 dir_field = net_field.DIRECTION_FIELD
@@ -34,7 +32,7 @@ link_vec_field = net_field.LINK_VEC_FIELD
 class Link(object):
     def __init__(self, link_gdf: gpd.GeoDataFrame = None, planar_crs: str = None,
                  weight_field: str = None, is_check: bool = True, not_conn_cost: float = 999.0,
-                 init_available_link: bool = True):
+                 init_available_link: bool = True, delete_circle: bool = True):
 
         self.not_conn_cost = not_conn_cost
         self.geo_crs = geo_crs
@@ -43,6 +41,7 @@ class Link(object):
         self.link_gdf.index = self.link_gdf[link_id_field]
         self.weight_field = weight_field
         self.__available_link_id = []
+        self.delete_circle = delete_circle
         if is_check:
             self.check()
         self.max_link_id = 999
@@ -59,7 +58,8 @@ class Link(object):
         self.done_link_vec = False
 
     def check(self):
-        assert self.link_gdf.crs.srs == self.geo_crs, rf'Link层数据必须为WGS84 - EPSG:4326, 实际输入: {self.link_gdf.crs.srs}'
+        assert self.link_gdf.crs.srs.upper() == self.geo_crs, \
+            rf'Link层数据必须为WGS84 - EPSG:4326, 实际输入: {self.link_gdf.crs.srs}'
         gap_set = {net_field.LINK_ID_FIELD, net_field.FROM_NODE_FIELD,
                    net_field.TO_NODE_FIELD, net_field.DIRECTION_FIELD, self.weight_field,
                    net_field.GEOMETRY_FIELD} - set(self.link_gdf.columns)
@@ -73,6 +73,13 @@ class Link(object):
             assert len(self.link_gdf[self.link_gdf[col].isna()]) == 0, rf'线层Link字段{col}有空值...'
             self.link_gdf[col] = self.link_gdf[col].astype(int)
 
+        # 环路检测
+        if self.delete_circle:
+            circle_idx = self.link_gdf[from_node_field] == self.link_gdf[to_node_field]
+            if not self.link_gdf[circle_idx].empty:
+                print(rf'检测到线层数据有环路, 自动删除...')
+                self.link_gdf.drop(index=self.link_gdf[circle_idx].index, inplace=True, axis=0)
+
     def init_link(self):
         """
         初始化Link, 这里会创建一个single层的link, 并将single_link设置为索引
@@ -111,7 +118,9 @@ class Link(object):
             neg_link[net_field.GEOMETRY_FIELD] = neg_link[net_field.GEOMETRY_FIELD].apply(
                 lambda line_geo: LineString(list(line_geo.coords)[::-1]))
             self.__single_link_gdf = pd.concat([link_gdf, neg_link])
-            self.__single_link_gdf.reset_index(inplace=True, drop=True)
+            # self.__single_link_gdf.reset_index(inplace=True, drop=True)
+        self.__single_link_gdf.drop_duplicates(subset=[from_node_field, to_node_field], keep='first', inplace=True)
+        self.__single_link_gdf.reset_index(inplace=True, drop=True)
         self.__single_link_gdf[net_field.SINGLE_LINK_ID_FIELD] = [i for i in range(1, len(self.__single_link_gdf) + 1)]
         self.__single_link_gdf['path'] = self.__single_link_gdf.apply(
             lambda row: [row[net_field.FROM_NODE_FIELD], row[net_field.TO_NODE_FIELD]], axis=1)
@@ -199,7 +208,7 @@ class Link(object):
         self.link_gdf.index = self.link_gdf[link_id_field]
 
     def append_link_gdf(self, link_gdf: gpd.GeoDataFrame = None) -> None:
-        assert link_gdf.crs.srs == self.crs
+        assert link_gdf.crs.srs.upper() == self.crs
         assert set(link_gdf[link_id_field]) & set(self.link_gdf[link_id_field]) == set()
         self.link_gdf = pd.concat(
             [self.link_gdf, link_gdf])
@@ -313,7 +322,7 @@ class Link(object):
         return self.__ft_link_mapping
 
     def to_plane_prj(self) -> None:
-        if self.link_gdf.crs.srs == self.planar_crs:
+        if self.check_same_crs(self.link_gdf,  self.planar_crs):
             pass
         else:
             if self.__single_link_gdf is None or self.__single_link_gdf.empty:
@@ -323,7 +332,7 @@ class Link(object):
             self.link_gdf = self.link_gdf.to_crs(self.planar_crs)
 
     def to_geo_prj(self) -> None:
-        if self.link_gdf.crs.srs == self.geo_crs:
+        if self.check_same_crs(self.link_gdf, self.geo_crs):
             pass
         else:
             if self.__single_link_gdf is None or self.__single_link_gdf.empty:
@@ -332,6 +341,10 @@ class Link(object):
                 self.__single_link_gdf = self.__single_link_gdf.to_crs(self.geo_crs)
             self.link_gdf = self.link_gdf.to_crs(self.geo_crs)
 
+    @staticmethod
+    def check_same_crs(gdf: gpd.GeoDataFrame = None, format_crs: str = None) -> bool:
+        return gdf.crs.srs.upper() == format_crs
+
     @property
     def crs(self):
         return self.link_gdf.crs.srs