新版地图

core/group.py

@@ -1306,9 +1306,12 @@ class GoThroughDispatcher:
             closer_area_backtrack_node_id = closer_entrance_node_id
             self.closer_area_backtrack_lanes = []
 
+            map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
+
             for i in range(30):
                 # 查询回溯路段对象
-                item = session_postgre.query(Lane).filter_by(EndNodeId=closer_area_backtrack_node_id).first()
+                item = session_postgre.query(Lane).filter_by(EndNodeId=closer_area_backtrack_node_id,
+                                                             MapVersion=map_version).first()
                 logger.info(f"查询到路段{str(item.Id)}")
                 if item is None:
                     break
@@ -1327,9 +1330,11 @@ class GoThroughDispatcher:
         try:
             further_area_backtrack_node_id = further_entrance_node_id
             self.further_area_backtrack_lanes = []
+            map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
             for i in range(30):
                 # 查询回溯路段对象
-                item = session_postgre.query(Lane).filter_by(EndNodeId=further_area_backtrack_node_id).first()
+                item = session_postgre.query(Lane).filter_by(EndNodeId=further_area_backtrack_node_id,
+                                                             MapVersion=map_version).first()
                 if item is None:
                     break
                 # 若查询到共同祖先

core/util.py

@@ -62,11 +62,13 @@ def get_cross_next_lanes(truck_locate):
     """
     next_lane_list = []
     startNodeId = session_postgre.query(Lane).filter_by(Id=truck_locate).first().EndNodeId
-    for item in session_postgre.query(Lane).filter_by(StartNodeId=startNodeId).all():
+    map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
+    for item in session_postgre.query(Lane).filter_by(StartNodeId=startNodeId, MapVersion=map_version).all():
         next_lane_list.append(str(item.Id))
         next_lane_end_node = item.EndNodeId
         if item.Length < 100:
-            for next_item in session_postgre.query(Lane).filter_by(StartNodeId=next_lane_end_node).all():
+            for next_item in session_postgre.query(Lane).filter_by(StartNodeId=next_lane_end_node,
+                                                                   MapVersion=map_version).all():
                 next_lane_list.append(str(next_item.Id))
     print("next_lane_list")
     print(next_lane_list)

gothrough/gothrough_digging.py

@@ -343,6 +343,8 @@ def truck_pass_first_area(truck_id, lane_id, closer_entrance_node_id, further_en
         from collections import deque
         que = deque([root_node])
 
+        map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
+
         while que:
             size = len(que)
             for _ in range(size):
@@ -356,7 +358,7 @@ def truck_pass_first_area(truck_id, lane_id, closer_entrance_node_id, further_en
                 if cur_node == further_entrance_node_id:
                     logger.info("further_entrance_node")
                     return 1
-                for item in session_postgre.query(Lane).filter_by(StartNodeId=cur_node).all():
+                for item in session_postgre.query(Lane).filter_by(StartNodeId=cur_node, MapVersion=map_version).all():
                     if item:
                         que.append(item.EndNodeId)
 
@@ -458,11 +460,12 @@ def get_lanes_between_entrances(closer_node_id, further_node_id):
     :return: lane set
     """
     try:
+        map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
         max_find_it = 100
         next_node_id = closer_node_id
         lane_set = []
         while max_find_it > 0 and next_node_id != further_node_id:
-            item = session_postgre.query(Lane).filter_by(StartNodeId=next_node_id, Type=2).first()
+            item = session_postgre.query(Lane).filter_by(StartNodeId=next_node_id, Type=2, MapVersion=map_version).first()
             if item:
                 next_lane_id = item.Id
                 next_node_id = item.EndNodeId

graph/topo_graph.py

@@ -174,7 +174,8 @@ class Topo():
                                               float(session_postgre.query(Lane).filter_by(Id=lane_id).first().Length),
                                               lane_id])
                     # son_lane_num = sum(1 for truck_id in session_postgre.query(Lane).filter_by(StartNodeId = lane_endpoint).all())
-                    son_lane_num = len(session_postgre.query(Lane).filter_by(StartNodeId=lane_endpoint).all())
+                    map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
+                    son_lane_num = len(session_postgre.query(Lane).filter_by(StartNodeId=lane_endpoint, MapVersion=map_version).all())
 
                     # 可以添加的节点：分叉口或终点
                     if son_lane_num > 1 or lane_endpoint in self.unload_G_dump_nodes:
@@ -247,7 +248,8 @@ class Topo():
                                             float(session_postgre.query(Lane).filter_by(Id=lane_id).first().Length),
                                             lane_id])
                     # son_lane_num = sum(1 for truck_id in session_postgre.query(Lane).filter_by(StartNodeId = lane_endpoint).all())
-                    son_lane_num = len(session_postgre.query(Lane).filter_by(StartNodeId=lane_endpoint).all())
+                    map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
+                    son_lane_num = len(session_postgre.query(Lane).filter_by(StartNodeId=lane_endpoint, MapVersion=map_version).all())
 
                     logger.info(f'load route lane id: %s' % lane_id)
 
@@ -300,7 +302,8 @@ class Topo():
                     load_saved_lane.append([str(load_i_startpoint), str(load_i_endpoint),
                                             float(session_postgre.query(Lane).filter_by(Id=i).first().Length), i])
                     # son_lane_num = sum(1 for truck_id in session_postgre.query(Lane).filter_by(StartNodeId = load_i_endpoint).all())
-                    son_lane_num = len(session_postgre.query(Lane).filter_by(StartNodeId=load_i_endpoint).all())
+                    map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
+                    son_lane_num = len(session_postgre.query(Lane).filter_by(StartNodeId=load_i_endpoint, MapVersion=map_version).all())
 
                     logger.info(f'park route lane id: %s' % i)
 
@@ -404,7 +407,8 @@ class Topo():
         # return the target area's entrance point and target area
         min_dis_path = path_length_map[sorted(list(path_length_map.keys()))[0]]
         entrance_point = min_dis_path[-1]
-        target_dump_area = str(session_postgre.query(DumpArea).filter_by(EntranceNodeId=entrance_point).first().Id)
+        map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
+        target_dump_area = str(session_postgre.query(DumpArea).filter_by(EntranceNodeId=entrance_point, MapVersion=map_version).first().Id)
         # target_dump_area_name = str(session_postgre.query(DumpArea).filter_by(EntranceNodeId=entrance_point).first().Name)
 
         return min_dis_path, entrance_point, target_dump_area
@@ -474,6 +478,8 @@ class Topo():
         source_node, end_node = self.get_load_edge_node(truck_location_lane)
         distance_source_node, distance_end_node = self.relative_distance(truck_location_lane, graph_type=0)
 
+        map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
+
         # update target_list
         pre_destination_node = str(
             session_postgre.query(DiggingWorkArea).filter_by(Id=pre_target).first().EntranceNodeId)
@@ -500,7 +506,7 @@ class Topo():
                 distance, path = nx.single_source_dijkstra(self.load_G, source=source_node, target=i,
                                                            weight="real_distance")
 
-                load_area_id = session_postgre.query(DiggingWorkArea).filter_by(EntranceNodeId=i).first().Id
+                load_area_id = session_postgre.query(DiggingWorkArea).filter_by(EntranceNodeId=i, MapVersion=map_version).first().Id
                 load_area_lane_dict[str(load_area_id)] = []
                 for j in range(len(path) - 1):
                     load_area_lane_dict[str(load_area_id)] += self.load_G[path[j]][path[j + 1]]['lane']
@@ -516,7 +522,7 @@ class Topo():
         for k, v in path_length_map.items():
             entrance_point = v[-1]
             target_digging_area = str(
-                session_postgre.query(DiggingWorkArea).filter_by(EntranceNodeId=entrance_point).first().Id)
+                session_postgre.query(DiggingWorkArea).filter_by(EntranceNodeId=entrance_point, MapVersion=map_version).first().Id)
             if end_node not in v:
                 reachable_destinations[target_digging_area] = [k + distance_source_node, 0]
             else:
@@ -539,18 +545,19 @@ class Topo():
         get cross lanes.
         :return:
         """
+        map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
         self.cross_bf_lanes = []
         for node_id, Type in self.load_G.nodes.data('name'):
             if Type is None or Type == 'None':
                 try:
-                    lane = session_postgre.query(Lane).filter_by(EndNodeId=node_id).first()
+                    lane = session_postgre.query(Lane).filter_by(EndNodeId=node_id, MapVersion=map_version).first()
                     if lane is not None:
                         self.cross_bf_lanes.append(str(lane.Id))
                 except Exception as es:
                     logger.error(es)
 
                 try:
-                    next_lane = session_postgre.query(Lane).filter_by(EndNodeId=lane.StartNodeId).first()
+                    next_lane = session_postgre.query(Lane).filter_by(EndNodeId=lane.StartNodeId, MapVersion=map_version).first()
                     if next_lane is not None:
                         self.cross_bf_lanes.append(str(next_lane.Id))
                 except Exception as es:

tables.py

@@ -79,11 +79,6 @@ session_mysql.expire_on_commit = False
 session_postgre = DBsession_postgre()
 
 session_postgre.expire_on_commit = False
-# except Exception as es:
-#     # logger.error("数据库连接失败")
-#     # logger.error(es)
-#     pass
-
 
 # 定义对象:
 
@@ -146,24 +141,32 @@ class Lane(Base):
     StartNodeId = Column(VARCHAR(36))
     EndNodeId = Column(VARCHAR(36))
     Type = Column(Integer)
+    FeatureId = Column(VARCHAR(36))
+    MapVersion = Column(VARCHAR(36))
 
-    def __init__(self, Id, Length, MaxSpeed, StartNodeId, EndNodeId, Type):
+    def __init__(self, Id, Length, MaxSpeed, StartNodeId, EndNodeId, Type, FeatureId, MapVersion):
         self.Id = Id
         self.Length = Length
         self.MaxSpeed = MaxSpeed
         self.StartNodeId = StartNodeId
         self.EndNodeId = EndNodeId
         self.Type = Type
+        self.FeatureId = FeatureId
+        self.MapVersion = MapVersion
 
 
 class Node(Base):
     __tablename__ = 'Geo_Node'
     Id = Column(VARCHAR(36), primary_key=True)
     geom = Column(Geography("Point"))
+    FeatureId = Column(VARCHAR(36))
+    MapVersion = Column(VARCHAR(36))
 
-    def __init__(self, Id, geom):
+    def __init__(self, Id, geom, FeatureId, MapVersion):
         self.Id = Id
         self.geom = geom
+        self.FeatureId = FeatureId
+        self.MapVersion = MapVersion
 
 
 class Dispatch(Base):
@@ -209,6 +212,7 @@ class Dispatch(Base):
         self.deletor = deletor
         self.deletetime = deletetime
 
+
 class DispatchSetting(Base):
     __tablename__ = 'sys_dispatch_setting_v'
 
@@ -269,7 +273,6 @@ class WalkTimePark(Base):
         self.park_load_lanes = park_load_lanes
 
 
-
 class Equipment(Base):
     __tablename__ = 'sys_equipment'
 
@@ -382,9 +385,11 @@ class DumpArea(Base):
     DumpEquipmentId = Column(VARCHAR(36))
     EntranceNodeId = Column(VARCHAR(50))
     ExitNodeId = Column(VARCHAR(50))
-    Name = Column(VARCHAR(36))
+    FeatureId = Column(VARCHAR(36))
+    MapVersion = Column(VARCHAR(36))
 
-    def __init__(self, Id, Name, BindList, UnloadAbililty, Disabled, Materials, Priority, DumpEquipmentId, EntranceNodeId,ExitNodeId):
+    def __init__(self, Id, Name, BindList, UnloadAbililty, Disabled, Materials, Priority, DumpEquipmentId,
+                 EntranceNodeId, ExitNodeId, FeatureId, MapVersion):
         self.Id = Id
         self.Name = Name
         self.BindList = BindList
@@ -395,6 +400,8 @@ class DumpArea(Base):
         self.DumpEquipmentId = DumpEquipmentId
         self.EntranceNodeId = EntranceNodeId
         self.ExitNodeId = ExitNodeId
+        self.FeatureId = FeatureId
+        self.MapVersion = MapVersion
 
 
 class DiggingWorkArea(Base):
@@ -407,8 +414,10 @@ class DiggingWorkArea(Base):
     ExactorUuid = Column(VARCHAR(50))
     EntranceNodeId = Column(VARCHAR(50))
     ExitNodeId = Column(VARCHAR(50))
+    FeatureId = Column(VARCHAR(36))
+    MapVersion = Column(VARCHAR(36))
 
-    def __init__(self, Id, Name, Material, ExactorId, ExactorUuid, EntranceNodeId, ExitNodeId):
+    def __init__(self, Id, Name, Material, ExactorId, ExactorUuid, EntranceNodeId, ExitNodeId, FeatureId, MapVersion):
         self.Id = Id
         self.Name = Name
         self.Material = Material
@@ -416,6 +425,8 @@ class DiggingWorkArea(Base):
         self.ExactorUuid = ExactorUuid
         self.EntranceNodeId = EntranceNodeId
         self.ExitNodeId = ExitNodeId
+        self.FeatureId = FeatureId
+        self.MapVersion = MapVersion
 
 
 class DispatchRule(Base):
@@ -540,4 +551,17 @@ class RecordTruckOutput(Base):
     def __init__(self, id, unload_area_id, end_time ):
         self.id = id
         self.unload_area_id = unload_area_id
-        self.end_time = end_time
+        self.end_time = end_time
\ No newline at end of file
+
+
+class Distribute_Library(Base):
+    __tablename__ = 'Geo_Distribute_Library'
+
+    Id = Column(VARCHAR(36), primary_key=True)
+    Version = Column(VARCHAR(36))
+    Status = Column(VARCHAR(10))
+
+    def __init__(self, Id, Version, Status):
+        self.Id = Id
+        self.Version = Version
+        self.Status = Status

util/area_analysis.py

@@ -196,6 +196,8 @@ def truck_pass_first_area(truck_id, lane_id, closer_entrance_node_id, further_en
 
     def backtracking(root_node):
 
+        map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
+
         from collections import deque
         que = deque([root_node])
 
@@ -212,7 +214,7 @@ def truck_pass_first_area(truck_id, lane_id, closer_entrance_node_id, further_en
                 if cur_node == further_entrance_node_id:
                     logger.info("further_entrance_node")
                     return 1
-                for item in session_postgre.query(Lane).filter_by(StartNodeId=cur_node).all():
+                for item in session_postgre.query(Lane).filter_by(StartNodeId=cur_node, MapVersion=map_version).all():
                     if item:
                         que.append(item.EndNodeId)
 
@@ -321,11 +323,13 @@ def get_lanes_between_entrances(closer_node_id, further_node_id):
     :return: lane set
     """
     try:
+        map_version = session_postgre.query(Distribute_Library).filter_by(Status="1").first().Version
+
         max_find_it = 100
         next_node_id = closer_node_id
         lane_set = []
         while max_find_it > 0 and next_node_id != further_node_id:
-            item = session_postgre.query(Lane).filter_by(StartNodeId=next_node_id, Type=2).first()
+            item = session_postgre.query(Lane).filter_by(StartNodeId=next_node_id, Type=2, MapVersion=map_version).first()
             if item:
                 next_lane_id = item.Id
                 next_node_id = item.EndNodeId