gotrackit 0.2.2__tar.gz → 0.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gotrackit
-Version: 0.2.2
+Version: 0.2.4
 Summary: A Python Package for Map Matching Algorithm Based on Hidden Markov Model
 Author-email: Kai Tang <794568794@qq.com>
 License: LICENCE
@@ -38,50 +38,61 @@ 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小幅度提升
+
+- 地图匹配接口报错机制优化
+
+- 地图匹配接口移除html_fldr参数, 使用out_fldr替代
+
+- 地图匹配接口增加即时输出开关instant_output, 打开后, 每匹配完一条轨迹马上进行结果存储
+
+- 路网构建: crs判断BUG修复、境外路网构建失败BUG修复
+
+- 增加 环路 处理功能
+
+
+**不要下载GitHub仓库上的代码来使用!!!  直接pip安装gotrackit为第三方库即可使用**
 
-- BUG修复
 
 <br>
 
 <div align=center>
-~ v0.2.2效率将大幅度提升 ~
+~ v0.2.4(相较于0.2.1)效率将大幅度提升, 最高可以提升10倍的性能 !~
 </div>
 
 <br>
 
 与上一版本对比:
 
-| 样例数据           | 有效的GPS点数 | top_k(k邻近候选参数) | gps_buffer(临域半径) | 候选路段条数 | 状态转移次数  | v0.2.1版解算时间 | v0.2.2版解算时间 |
-|----------------|----------|----------------|------------------|---------|------------|-------------|-----------|
-| 1辆车,深圳稀疏轨迹点样例1 | 190      | 60             | 500m             | 10615 | 629788次 | 28秒         | **3.3秒**  |
-| 1辆车,深圳稀疏轨迹点样例2 | 400      | 20             | 120m             | 5137 | 82006次  | 7.8秒        | **1.7秒**    |
+| 样例数据           | 有效的GPS点数 | top_k(k邻近候选参数) | gps_buffer(临域半径) | 候选路段条数 | 状态转移次数  | v0.2.1版解算时间 | v0.2.4版解算时间 |
+|----------------|----------|----------------|------------------|---------|------------|-------------|-------------|
+| 1辆车,深圳稀疏轨迹点样例1 | 190      | 60             | 500m             | 10615 | 629788次 | 28秒         | **1.87秒**   |
+| 1辆车,深圳稀疏轨迹点样例2 | 400      | 20             | 120m             | 5137 | 82006次  | 7.8秒        | **0.89秒**   |
 
 
-v0.2.2多核效率对比:
+v0.2.4多核效率对比:
 
-基于上表深圳稀疏轨迹点样例2，我们将他复制150份，进行多核测试，可以看到到6核时, 效率已经不再提升，最快96s解算完150条轨迹，平均每条轨迹0.64s，相较于1.7s再次提升了60%，在车辆数较多时，多核的效率提升很明显。
+基于上表深圳稀疏轨迹点样例2，我们将他复制150份，进行多核测试，可以看到到6核时, 效率已经不再提升，最快89s解算完150条轨迹，平均每条轨迹0.59s，相较于0.89s再次提升了30%，在车辆数较多时，多核的效率提升很明显。
 
-| 样例数据                                      | 有效的GPS点数 | top_k | gps_buffer | 候选路段条数 | 状态转移次数 | v0.2.2解算时间 |
+| 样例数据                                      | 有效的GPS点数 | top_k | gps_buffer | 候选路段条数 | 状态转移次数 | v0.2.4解算时间 |
 |-------------------------------------------|----------|----------------|------------------|-----|--------|------------|
-| 150辆车的GPS轨迹(单核串行,子图搜索,有构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 300.0秒     | 
-| 150辆车的GPS轨迹(3核并行,子图搜索,有构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 139.6秒     |
-| 150辆车的GPS轨迹(3核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 120.3秒     |
-| 150辆车的GPS轨迹(4核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 104.9秒     | 
-| 150辆车的GPS轨迹(5核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 96.4秒      | 
-| 150辆车的GPS轨迹(6核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 97.5秒      | 
+| 150辆车的GPS轨迹(单核串行,子图搜索,有构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 290.0秒     | 
+| 150辆车的GPS轨迹(3核并行,子图搜索,有构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 130.6秒     |
+| 150辆车的GPS轨迹(3核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 113.3秒     |
+| 150辆车的GPS轨迹(4核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 97.3秒      | 
+| 150辆车的GPS轨迹(5核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 89.4秒      | 
+| 150辆车的GPS轨迹(6核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 91.5秒      | 
 
 
 <br>
@@ -155,7 +166,7 @@ v0.2.2多核效率对比:
 - 算法原理讲解部分不涉及复杂的公式推导，使用动画形式剖析算法原理,简洁明了。
 
 **匹配结果自动优化**
-- 对基于HMM匹配的初步路径进行了优化，对于不连通的位置会自动补路，对于实际路网不连通的位置会输出警告，方便用户检查路网。
+- 对基于HMM匹配的初步路径进行了优化，对于不连通的位置会自动搜路补全，对于实际路网不连通的位置会输出警告信息，方便用户回溯问题。
 
 
 

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

@@ -16,50 +16,61 @@
 
 ~ 一个包搞定：路网获取、路网优化、宏微观地图匹配、匹配可视化、问题路段快速定位 ~
 
-唐铠, 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小幅度提升
+
+- 地图匹配接口报错机制优化
+
+- 地图匹配接口移除html_fldr参数, 使用out_fldr替代
+
+- 地图匹配接口增加即时输出开关instant_output, 打开后, 每匹配完一条轨迹马上进行结果存储
+
+- 路网构建: crs判断BUG修复、境外路网构建失败BUG修复
+
+- 增加 环路 处理功能
+
+
+**不要下载GitHub仓库上的代码来使用!!!  直接pip安装gotrackit为第三方库即可使用**
 
-- BUG修复
 
 <br>
 
 <div align=center>
-~ v0.2.2效率将大幅度提升 ~
+~ v0.2.4(相较于0.2.1)效率将大幅度提升, 最高可以提升10倍的性能 !~
 </div>
 
 <br>
 
 与上一版本对比:
 
-| 样例数据           | 有效的GPS点数 | top_k(k邻近候选参数) | gps_buffer(临域半径) | 候选路段条数 | 状态转移次数  | v0.2.1版解算时间 | v0.2.2版解算时间 |
-|----------------|----------|----------------|------------------|---------|------------|-------------|-----------|
-| 1辆车,深圳稀疏轨迹点样例1 | 190      | 60             | 500m             | 10615 | 629788次 | 28秒         | **3.3秒**  |
-| 1辆车,深圳稀疏轨迹点样例2 | 400      | 20             | 120m             | 5137 | 82006次  | 7.8秒        | **1.7秒**    |
+| 样例数据           | 有效的GPS点数 | top_k(k邻近候选参数) | gps_buffer(临域半径) | 候选路段条数 | 状态转移次数  | v0.2.1版解算时间 | v0.2.4版解算时间 |
+|----------------|----------|----------------|------------------|---------|------------|-------------|-------------|
+| 1辆车,深圳稀疏轨迹点样例1 | 190      | 60             | 500m             | 10615 | 629788次 | 28秒         | **1.87秒**   |
+| 1辆车,深圳稀疏轨迹点样例2 | 400      | 20             | 120m             | 5137 | 82006次  | 7.8秒        | **0.89秒**   |
 
 
-v0.2.2多核效率对比:
+v0.2.4多核效率对比:
 
-基于上表深圳稀疏轨迹点样例2，我们将他复制150份，进行多核测试，可以看到到6核时, 效率已经不再提升，最快96s解算完150条轨迹，平均每条轨迹0.64s，相较于1.7s再次提升了60%，在车辆数较多时，多核的效率提升很明显。
+基于上表深圳稀疏轨迹点样例2，我们将他复制150份，进行多核测试，可以看到到6核时, 效率已经不再提升，最快89s解算完150条轨迹，平均每条轨迹0.59s，相较于0.89s再次提升了30%，在车辆数较多时，多核的效率提升很明显。
 
-| 样例数据                                      | 有效的GPS点数 | top_k | gps_buffer | 候选路段条数 | 状态转移次数 | v0.2.2解算时间 |
+| 样例数据                                      | 有效的GPS点数 | top_k | gps_buffer | 候选路段条数 | 状态转移次数 | v0.2.4解算时间 |
 |-------------------------------------------|----------|----------------|------------------|-----|--------|------------|
-| 150辆车的GPS轨迹(单核串行,子图搜索,有构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 300.0秒     | 
-| 150辆车的GPS轨迹(3核并行,子图搜索,有构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 139.6秒     |
-| 150辆车的GPS轨迹(3核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 120.3秒     |
-| 150辆车的GPS轨迹(4核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 104.9秒     | 
-| 150辆车的GPS轨迹(5核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 96.4秒      | 
-| 150辆车的GPS轨迹(6核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 97.5秒      | 
+| 150辆车的GPS轨迹(单核串行,子图搜索,有构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 290.0秒     | 
+| 150辆车的GPS轨迹(3核并行,子图搜索,有构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 130.6秒     |
+| 150辆车的GPS轨迹(3核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 113.3秒     |
+| 150辆车的GPS轨迹(4核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 97.3秒      | 
+| 150辆车的GPS轨迹(5核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 89.4秒      | 
+| 150辆车的GPS轨迹(6核并行,全图搜索,无构建子图的额外开销,提前预计算路径) | 6w       | 20             | 120m             | 75W | 1200W次 | 91.5秒      | 
 
 
 <br>
@@ -133,7 +144,7 @@ v0.2.2多核效率对比:
 - 算法原理讲解部分不涉及复杂的公式推导，使用动画形式剖析算法原理,简洁明了。
 
 **匹配结果自动优化**
-- 对基于HMM匹配的初步路径进行了优化，对于不连通的位置会自动补路，对于实际路网不连通的位置会输出警告，方便用户检查路网。
+- 对基于HMM匹配的初步路径进行了优化，对于不连通的位置会自动搜路补全，对于实际路网不连通的位置会输出警告信息，方便用户回溯问题。
 
 
 

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

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

{gotrackit-0.2.2 → gotrackit-0.2.4}/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.4}/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.4}/src/gotrackit/gps/GpsTrip.py

@@ -57,10 +57,13 @@ class GpsTrip(GpsArray):
             # 时间差和距离差
             group_gps_gdf[next_time_field] = group_gps_gdf[time_field].shift(-1).fillna(group_gps_gdf[time_field])
             group_gps_gdf[next_p_field] = group_gps_gdf[geometry_field].shift(-1).fillna(group_gps_gdf[geometry_field])
-            group_gps_gdf[time_gap_field] = group_gps_gdf.apply(
-                lambda row: (row[next_time_field] - row[time_field]).seconds, axis=1)
-            group_gps_gdf[dis_gap_field] = group_gps_gdf.apply(
-                lambda row: row[next_p_field].distance(row[geometry_field]), axis=1)
+            group_gps_gdf[time_gap_field] = group_gps_gdf[next_time_field] - group_gps_gdf[time_field]
+            group_gps_gdf[time_gap_field] = group_gps_gdf[time_gap_field].apply(lambda t: t.seconds)
+            group_gps_gdf[dis_gap_field] = group_gps_gdf[next_p_field].distance(group_gps_gdf[geometry_field])
+            # group_gps_gdf[time_gap_field] = group_gps_gdf.apply(
+            #     lambda row: (row[next_time_field] - row[time_field]).seconds, axis=1)
+            # group_gps_gdf[dis_gap_field] = group_gps_gdf.apply(
+            #     lambda row: row[next_p_field].distance(row[geometry_field]), axis=1)
 
             # 切分主行程
             group_gps_gdf['main_label'] = (group_gps_gdf[time_gap_field] > self.group_gap_threshold).astype(int)

{gotrackit-0.2.2 → gotrackit-0.2.4}/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.4}/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: