Update utils/llm_coding.py

utils/llm_coding.py

@@ -1,583 +1,583 @@
-import requests
-import urllib3
-import json
-from utils import geoutil
-import regex_spatial
-from shapely.geometry import Polygon, MultiPoint, LineString, Point, mapping
-import re
-import geopandas as gpd
-from geocoder import geo_level1
-from openai import OpenAI
-
-import os
-api_key = os.getenv('api_key')
-client = OpenAI(
-    api_key=api_key
-)
-
-
-model = "gpt-4o"
-
-north = ["north", "N'", "North", "NORTH"]
-south = ["south", "S'", "South", "SOUTH"]
-east = ["east", "E'", "East", "EAST"]
-west = ["west", "W'", "West", "WEST"]
-northeast = ["north-east", "NE'", "north east", "NORTH-EAST", "North East", "NORTH EAST"]
-southeast = ["south-east", "SE'", "south east", "SOUTH-EAST", "South East", "SOUTH EAST"]
-northwest = ["north-west", "NW'", "north west", "NORTH-WEST", "North West", "NORTH WEST"]
-southwest = ["south-west", "SW'", "south west", "SOUTH-WEST", "South West", "SOUTH WEST"]
-center = ["center","central", "downtown","midtown"]
-#
-#
-# def get_directional_coordinates(coordinates, direction, centroid, minimum, maximum, is_midmid):
-#     direction_coordinates = get_directional_coordinates_by_angle(coordinates, direction, minimum, maximum)
-#     midmid1, midmid2 = geoutil.get_midmid_point(centroid, direction_coordinates[0], direction_coordinates[-1],
-#                                                 is_midmid)
-#     if direction in west:
-#         maxi = max(p[2] for p in direction_coordinates)
-#         mini = min(p[2] for p in direction_coordinates)
-#         index_mini = 0
-#         index_maxi = 0
-#         for idx, p in enumerate(direction_coordinates):
-#             if p[2] == mini:
-#                 index_mini = idx
-#             if p[2] == maxi:
-#                 index_maxi = idx
-#
-#         direction_coordinates.insert(index_maxi + 1, midmid2)
-#         direction_coordinates.insert(index_mini + 1, midmid1)
+# import requests
+# import urllib3
+# import json
+# from utils import geoutil
+# import regex_spatial
+# from shapely.geometry import Polygon, MultiPoint, LineString, Point, mapping
+# import re
+# import geopandas as gpd
+# from geocoder import geo_level1
+# from openai import OpenAI
+
+# import os
+# api_key = os.getenv('api_key')
+# client = OpenAI(
+#     api_key=api_key
+# )
+
+
+# model = "gpt-4o"
+
+# north = ["north", "N'", "North", "NORTH"]
+# south = ["south", "S'", "South", "SOUTH"]
+# east = ["east", "E'", "East", "EAST"]
+# west = ["west", "W'", "West", "WEST"]
+# northeast = ["north-east", "NE'", "north east", "NORTH-EAST", "North East", "NORTH EAST"]
+# southeast = ["south-east", "SE'", "south east", "SOUTH-EAST", "South East", "SOUTH EAST"]
+# northwest = ["north-west", "NW'", "north west", "NORTH-WEST", "North West", "NORTH WEST"]
+# southwest = ["south-west", "SW'", "south west", "SOUTH-WEST", "South West", "SOUTH WEST"]
+# center = ["center","central", "downtown","midtown"]
+# #
+# #
+# # def get_directional_coordinates(coordinates, direction, centroid, minimum, maximum, is_midmid):
+# #     direction_coordinates = get_directional_coordinates_by_angle(coordinates, direction, minimum, maximum)
+# #     midmid1, midmid2 = geoutil.get_midmid_point(centroid, direction_coordinates[0], direction_coordinates[-1],
+# #                                                 is_midmid)
+# #     if direction in west:
+# #         maxi = max(p[2] for p in direction_coordinates)
+# #         mini = min(p[2] for p in direction_coordinates)
+# #         index_mini = 0
+# #         index_maxi = 0
+# #         for idx, p in enumerate(direction_coordinates):
+# #             if p[2] == mini:
+# #                 index_mini = idx
+# #             if p[2] == maxi:
+# #                 index_maxi = idx
+# #
+# #         direction_coordinates.insert(index_maxi + 1, midmid2)
+# #         direction_coordinates.insert(index_mini + 1, midmid1)
+# #     else:
+# #         direction_coordinates.append(midmid2)
+# #         direction_coordinates.append(midmid1)
+# #
+# #     return direction_coordinates, midmid1, midmid2
+# #
+# #
+# # def get_directional_coordinates_by_angle(coordinates, direction, minimum, maximum):
+# #     direction_coordinates = []
+# #     for p in coordinates:
+# #         if direction in east:
+# #             if p[2] >= minimum or p[2] <= maximum:
+# #                 direction_coordinates.append(p)
+# #
+# #         else:
+# #             if p[2] >= minimum and p[2] <= maximum:
+# #                 direction_coordinates.append(p)
+# #     return direction_coordinates
+# #
+# #
+# # def get_directional_coordinates_by_angle(coordinates, direction, minimum, maximum):
+# #     direction_coordinates = []
+# #     for p in coordinates:
+# #         if direction in east:
+# #             if p[2] >= minimum or p[2] <= maximum:
+# #                 direction_coordinates.append(p)
+# #
+# #         else:
+# #             if p[2] >= minimum and p[2] <= maximum:
+# #                 direction_coordinates.append(p)
+# #     return direction_coordinates
+# #
+# #
+# # def get_central(coordinates, centroid, direction, is_midmid):
+# #     n_min_max = get_min_max("north")
+# #     n_coordinates = get_directional_coordinates_by_angle(coordinates, "north", n_min_max[0], n_min_max[1])
+# #     n_mid1, n_mid2 = geoutil.get_midmid_point(centroid, n_coordinates[0], n_coordinates[-1], is_midmid)
+# #
+# #     ne_min_max = get_min_max("north east")
+# #     ne_coordinates = get_directional_coordinates_by_angle(coordinates, "north east", ne_min_max[0], ne_min_max[1])
+# #     ne_mid1, ne_mid2 = geoutil.get_midmid_point(centroid, ne_coordinates[0], ne_coordinates[-1], is_midmid)
+# #
+# #     e_min_max = get_min_max("east")
+# #     e_coordinates = get_directional_coordinates_by_angle(coordinates, "east", e_min_max[0], e_min_max[1])
+# #     e_mid1, e_mid2 = geoutil.get_midmid_point(centroid, e_coordinates[0], e_coordinates[-1], is_midmid)
+# #
+# #     se_min_max = get_min_max("south east")
+# #     se_coordinates = get_directional_coordinates_by_angle(coordinates, "south east", se_min_max[0], se_min_max[1])
+# #     se_mid1, se_mid2 = geoutil.get_midmid_point(centroid, se_coordinates[0], se_coordinates[-1], is_midmid)
+# #
+# #     s_min_max = get_min_max("south")
+# #     s_coordinates = get_directional_coordinates_by_angle(coordinates, "south", s_min_max[0], s_min_max[1])
+# #     s_mid1, s_mid2 = geoutil.get_midmid_point(centroid, s_coordinates[0], s_coordinates[-1], is_midmid)
+# #
+# #     sw_min_max = get_min_max("south west")
+# #     sw_coordinates = get_directional_coordinates_by_angle(coordinates, "south west", sw_min_max[0], sw_min_max[1])
+# #     sw_mid1, sw_mid2 = geoutil.get_midmid_point(centroid, sw_coordinates[0], sw_coordinates[-1], is_midmid)
+# #
+# #     w_min_max = get_min_max("west")
+# #     w_coordinates = get_directional_coordinates_by_angle(coordinates, "west", w_min_max[0], w_min_max[1])
+# #     w_mid1, w_mid2 = geoutil.get_midmid_point(centroid, w_coordinates[0], w_coordinates[-1], is_midmid)
+# #
+# #     nw_min_max = get_min_max("north west")
+# #     nw_coordinates = get_directional_coordinates_by_angle(coordinates, "north west", nw_min_max[0], nw_min_max[1])
+# #     nw_mid1, nw_mid2 = geoutil.get_midmid_point(centroid, nw_coordinates[0], nw_coordinates[-1], is_midmid)
+# #
+# #     central_coordindates = [e_mid1, e_mid2, ne_mid1, ne_mid2, n_mid1, n_mid2,
+# #                             nw_mid1, nw_mid2, w_mid1, w_mid2, sw_mid1, sw_mid2,
+# #                             s_mid1, s_mid2, se_mid1, se_mid2]
+# #     return central_coordindates
+# #
+# #
+# # def get_min_max(direction):
+# #     regex = regex_spatial.get_directional_regex()
+# #     direction_list = regex.split("|")
+# #     if direction in direction_list:
+# #         if direction in east:
+# #             return (337, 22)
+# #         if direction in northeast:
+# #             return (22, 67)
+# #         if direction in north:
+# #             return (67, 112)
+# #         if direction in northwest:
+# #             return (112, 157)
+# #         if direction in west:
+# #             return (157, 202)
+# #         if direction in southwest:
+# #             return (202, 247)
+# #         if direction in south:
+# #             return (247, 292)
+# #         if direction in southeast:
+# #             return (292, 337)
+# #
+# #     return None
+# # def get_level1_coordinates(coordinates, centroid, direction, is_midmid):
+# #     min_max = get_min_max(direction)
+# #     if min_max is not None:
+# #         coordinates, mid1, mid2 = get_directional_coordinates(coordinates, direction, centroid, min_max[0], min_max[1], is_midmid)
+# #         return coordinates, centroid, mid1, mid2
+# #     elif direction.lower() in center:
+# #         return get_central(coordinates, centroid, direction, is_midmid), centroid, None, None
+# #     else:
+# #         return coordinates, centroid, None, None
+# def to_standard_2d_list(data):
+#     arr = np.array(data)
+
+#     # 强制变成一维后 reshape，前提是元素总数是2的倍数
+#     flat = arr.flatten()
+#     if flat.size % 2 != 0:
+#         raise ValueError("元素个数不是2的倍数，不能 reshape 成 [N, 2] 格式")
+
+#     return flat.reshape(-1, 2).tolist()
+
+
+# def get_geojson(ent, arr, centroid):
+#     poly_json = {}
+#     poly_json['type'] = 'FeatureCollection'
+#     poly_json['features'] = []
+#     coordinates= []
+#     coordinates.append(arr)
+#     poly_json['features'].append({
+#     'type':'Feature',
+#     'id': ent,
+#     'properties': {
+#         'centroid': centroid
+#         },
+#     'geometry': {
+#         'type':'Polygon',
+#         'coordinates': coordinates
+#         }
+#     })
+#     return poly_json
+
+
+# def get_coordinates(ent):
+#     request_url = 'https://nominatim.openstreetmap.org/search.php?q= ' +ent +'&polygon_geojson=1&accept-language=en&format=jsonv2'
+#     headers = {
+#         "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15"
+#     }
+#     page = requests.get(request_url, headers=headers, verify=False)
+#     json_content = json.loads(page.content)
+#     all_coordinates = json_content[0]['geojson']['coordinates'][0]
+#     centroid = (float(json_content[0]['lon']), float(json_content[0]['lat']))
+#     for p in all_coordinates:
+#         p2 = (p[0], p[1])
+#         angle = geoutil.calculate_bearing(centroid, p2)
+#         p.append(angle)
+
+#     geojson = get_geojson(ent, all_coordinates, centroid)
+
+#     return geojson['features'][0]['geometry']['coordinates'][0], geojson['features'][0]['properties']['centroid']
+
+# def get_coordinates(location):
+#     request_url = f'https://nominatim.openstreetmap.org/search.php?q={location}&polygon_geojson=1&accept-language=en&format=jsonv2'
+
+#     print(request_url)
+#     headers = {"User-Agent": "Mozilla/5.0"}
+#     response = requests.get(request_url, headers=headers, verify=False)
+#     json_content = json.loads(response.content)
+#     # print(json_content)
+#     if json_content[0]['geojson']['type'] == 'Polygon':
+#         coordinates = json_content[0]['geojson']['coordinates'][0]
+#     elif json_content[0]['geojson']['type'] == 'Point':
+#         coordinates = json_content[0]['geojson']['coordinates']
 #     else:
-#         direction_coordinates.append(midmid2)
-#         direction_coordinates.append(midmid1)
-#
-#     return direction_coordinates, midmid1, midmid2
-#
-#
-# def get_directional_coordinates_by_angle(coordinates, direction, minimum, maximum):
-#     direction_coordinates = []
-#     for p in coordinates:
-#         if direction in east:
-#             if p[2] >= minimum or p[2] <= maximum:
-#                 direction_coordinates.append(p)
-#
-#         else:
-#             if p[2] >= minimum and p[2] <= maximum:
-#                 direction_coordinates.append(p)
-#     return direction_coordinates
-#
-#
-# def get_directional_coordinates_by_angle(coordinates, direction, minimum, maximum):
+#         print(json_content[0]['geojson']['type'])
+#     centroid = (float(json_content[0]['lon']), float(json_content[0]['lat']))
+#     return (coordinates, centroid)
+
+
+# # level3
+# def get_directional_coordinates_by_angle(coordinates, centroid, direction, minimum, maximum):
+#     # minimum = 157
+#     # maximum = 202
+
 #     direction_coordinates = []
 #     for p in coordinates:
-#         if direction in east:
-#             if p[2] >= minimum or p[2] <= maximum:
-#                 direction_coordinates.append(p)
-#
+#         angle = geoutil.calculate_bearing(centroid, p)
+#         p2 = (p[0], p[1], angle)
+#         if direction in geo_level1.east:
+#             if angle >= minimum or angle <= maximum:
+#                 direction_coordinates.append(p2)
+
 #         else:
-#             if p[2] >= minimum and p[2] <= maximum:
-#                 direction_coordinates.append(p)
+#             if angle >= minimum and angle <= maximum:
+#                 direction_coordinates.append(p2)
+#     # print(type(direction_coordinates[0]))
+#     # if(direction in geo_level1.west):
+#     #    direction_coordinates.sort(key=lambda k: k[2], reverse=True)
+
 #     return direction_coordinates
-#
-#
-# def get_central(coordinates, centroid, direction, is_midmid):
-#     n_min_max = get_min_max("north")
-#     n_coordinates = get_directional_coordinates_by_angle(coordinates, "north", n_min_max[0], n_min_max[1])
-#     n_mid1, n_mid2 = geoutil.get_midmid_point(centroid, n_coordinates[0], n_coordinates[-1], is_midmid)
-#
-#     ne_min_max = get_min_max("north east")
-#     ne_coordinates = get_directional_coordinates_by_angle(coordinates, "north east", ne_min_max[0], ne_min_max[1])
-#     ne_mid1, ne_mid2 = geoutil.get_midmid_point(centroid, ne_coordinates[0], ne_coordinates[-1], is_midmid)
-#
-#     e_min_max = get_min_max("east")
-#     e_coordinates = get_directional_coordinates_by_angle(coordinates, "east", e_min_max[0], e_min_max[1])
-#     e_mid1, e_mid2 = geoutil.get_midmid_point(centroid, e_coordinates[0], e_coordinates[-1], is_midmid)
-#
-#     se_min_max = get_min_max("south east")
-#     se_coordinates = get_directional_coordinates_by_angle(coordinates, "south east", se_min_max[0], se_min_max[1])
-#     se_mid1, se_mid2 = geoutil.get_midmid_point(centroid, se_coordinates[0], se_coordinates[-1], is_midmid)
-#
-#     s_min_max = get_min_max("south")
-#     s_coordinates = get_directional_coordinates_by_angle(coordinates, "south", s_min_max[0], s_min_max[1])
-#     s_mid1, s_mid2 = geoutil.get_midmid_point(centroid, s_coordinates[0], s_coordinates[-1], is_midmid)
-#
-#     sw_min_max = get_min_max("south west")
-#     sw_coordinates = get_directional_coordinates_by_angle(coordinates, "south west", sw_min_max[0], sw_min_max[1])
-#     sw_mid1, sw_mid2 = geoutil.get_midmid_point(centroid, sw_coordinates[0], sw_coordinates[-1], is_midmid)
-#
-#     w_min_max = get_min_max("west")
-#     w_coordinates = get_directional_coordinates_by_angle(coordinates, "west", w_min_max[0], w_min_max[1])
-#     w_mid1, w_mid2 = geoutil.get_midmid_point(centroid, w_coordinates[0], w_coordinates[-1], is_midmid)
-#
-#     nw_min_max = get_min_max("north west")
-#     nw_coordinates = get_directional_coordinates_by_angle(coordinates, "north west", nw_min_max[0], nw_min_max[1])
-#     nw_mid1, nw_mid2 = geoutil.get_midmid_point(centroid, nw_coordinates[0], nw_coordinates[-1], is_midmid)
-#
-#     central_coordindates = [e_mid1, e_mid2, ne_mid1, ne_mid2, n_mid1, n_mid2,
-#                             nw_mid1, nw_mid2, w_mid1, w_mid2, sw_mid1, sw_mid2,
-#                             s_mid1, s_mid2, se_mid1, se_mid2]
-#     return central_coordindates
-#
-#
-# def get_min_max(direction):
-#     regex = regex_spatial.get_directional_regex()
-#     direction_list = regex.split("|")
-#     if direction in direction_list:
-#         if direction in east:
-#             return (337, 22)
-#         if direction in northeast:
-#             return (22, 67)
-#         if direction in north:
-#             return (67, 112)
-#         if direction in northwest:
-#             return (112, 157)
-#         if direction in west:
-#             return (157, 202)
-#         if direction in southwest:
-#             return (202, 247)
-#         if direction in south:
-#             return (247, 292)
-#         if direction in southeast:
-#             return (292, 337)
-#
-#     return None
-# def get_level1_coordinates(coordinates, centroid, direction, is_midmid):
-#     min_max = get_min_max(direction)
+# def get_level3(level3):
+#     digits = re.findall('[0-9]+', level3)[0]
+#     unit = re.findall('[A-Za-z]+', level3)[0]
+#     return digits, unit
+
+# def get_direction_coordinates(coordinates, centroid, level1):
+#     min_max = geo_level1.get_min_max(level1)
 #     if min_max is not None:
-#         coordinates, mid1, mid2 = get_directional_coordinates(coordinates, direction, centroid, min_max[0], min_max[1], is_midmid)
-#         return coordinates, centroid, mid1, mid2
-#     elif direction.lower() in center:
-#         return get_central(coordinates, centroid, direction, is_midmid), centroid, None, None
+#         coord = get_directional_coordinates_by_angle(coordinates, centroid, level1, min_max[0], min_max[1])
+#         return coord
+#     return coordinates
+# def sort_west(poly1, poly2, centroid):
+#     coords1 = mapping(poly1)["features"][0]["geometry"]["coordinates"]
+#     coords2 = mapping(poly2)["features"][0]["geometry"]["coordinates"]
+#     coord1 = []
+#     coord2 = []
+#     coord = []
+#     for c in coords1:
+#         pol = list(c[::-1])
+#         coord1.extend(pol)
+#     for c in coords2:
+#         pol = list(c[::-1])
+#         coord2.extend(pol)
+#     coo1 = []
+#     coo2 = []
+#     for p in coord1:
+#         angle = geoutil.calculate_bearing(centroid, p)
+#         if angle >= 157 and angle <= 202:
+#             coo1.append((p[0], p[1], angle))
+#     for p in coord2:
+#         angle = geoutil.calculate_bearing(centroid, p)
+#         if angle >= 157 and angle <= 202:
+#             coo2.append((p[0], p[1], angle))
+#     coo1.extend(coo2)
+#     return coo1
+
+
+# def get_level3_coordinates(coordinates, level_3, level1):
+#     distance, unit = get_level3(level_3)
+#     kms = geoutil.get_kilometers(distance, unit)
+#     coord = []
+
+#     coords0, center = coordinates
+
+#     if not isinstance(coords0, list) or len(coords0) < 3:
+
+#         # 从原始点出发，根据方向移动距离 kms 得到新圆心
+#         lat_km = 111.32
+#         lon_km = 111.32 * np.cos(np.radians(center[1]))
+
+#         dx = dy = 0
+
+#         if level1 is not None:
+#             if level1 in geo_level1.east:
+#                 dx = kms / lon_km
+#             elif level1 in geo_level1.west:
+#                 dx = -kms / lon_km
+#             elif level1 in geo_level1.north:
+#                 dy = kms / lat_km
+#             elif level1 in geo_level1.south:
+#                 dy = -kms / lat_km
+#             # 你也可以支持 northeast、southwest 等复合方向
+
+#         new_center = (center[0] + dx, center[1] + dy)
+
+#         # 用固定半径画个圆（例如半径2km）
+#         r_km = 1  # 半径设为1km，你也可以设为其他值
+
+#         circle_points = []
+#         for theta in np.linspace(0, 360, num=100):
+#             theta_rad = np.radians(theta)
+#             d_lat = (np.sin(theta_rad) * r_km) / lat_km
+#             d_lon = (np.cos(theta_rad) * r_km) / lon_km
+#             circle_points.append((new_center[0] + d_lon, new_center[1] + d_lat))
+
+#         # 输出中心（使用新圆心）
+#         if circle_points:
+#             center_point = MultiPoint(circle_points).centroid
+#             center = (center_point.x, center_point.y)
+#         else:
+#             center = new_center
+
+#         return circle_points, center
+
+#     # 正常 polygon 流程
+#     poly1 = Polygon(coords0)
+#     polygon1 = gpd.GeoSeries(poly1)
+
+#     # 生成环形区域
+#     poly2 = polygon1.buffer(0.0095 * kms, join_style=2)
+#     poly3 = polygon1.buffer(0.013 * kms, join_style=2)
+#     poly = poly3.difference(poly2)
+
+#     # 获取坐标
+#     coords = mapping(poly)["features"][0]["geometry"]["coordinates"]
+#     for c in coords:
+#         pol = list(c[::-1])
+#         coord.extend(pol)
+
+#     # 方向裁剪
+#     if level1 is not None:
+#         coord = get_direction_coordinates(coord, coordinates[1], level1)
+#         if level1 in geo_level1.west:
+#             coord = sort_west(poly3, poly2, coordinates[1])
+
+#     # 计算质心
+#     if coord:
+#         center_point = MultiPoint(coord).centroid
+#         center = (center_point.x, center_point.y)
 #     else:
-#         return coordinates, centroid, None, None
-def to_standard_2d_list(data):
-    arr = np.array(data)
-
-    # 强制变成一维后 reshape，前提是元素总数是2的倍数
-    flat = arr.flatten()
-    if flat.size % 2 != 0:
-        raise ValueError("元素个数不是2的倍数，不能 reshape 成 [N, 2] 格式")
-
-    return flat.reshape(-1, 2).tolist()
-
-
-def get_geojson(ent, arr, centroid):
-    poly_json = {}
-    poly_json['type'] = 'FeatureCollection'
-    poly_json['features'] = []
-    coordinates= []
-    coordinates.append(arr)
-    poly_json['features'].append({
-    'type':'Feature',
-    'id': ent,
-    'properties': {
-        'centroid': centroid
-        },
-    'geometry': {
-        'type':'Polygon',
-        'coordinates': coordinates
-        }
-    })
-    return poly_json
-
-
-def get_coordinates(ent):
-    request_url = 'https://nominatim.openstreetmap.org/search.php?q= ' +ent +'&polygon_geojson=1&accept-language=en&format=jsonv2'
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15"
-    }
-    page = requests.get(request_url, headers=headers, verify=False)
-    json_content = json.loads(page.content)
-    all_coordinates = json_content[0]['geojson']['coordinates'][0]
-    centroid = (float(json_content[0]['lon']), float(json_content[0]['lat']))
-    for p in all_coordinates:
-        p2 = (p[0], p[1])
-        angle = geoutil.calculate_bearing(centroid, p2)
-        p.append(angle)
-
-    geojson = get_geojson(ent, all_coordinates, centroid)
-
-    return geojson['features'][0]['geometry']['coordinates'][0], geojson['features'][0]['properties']['centroid']
-
-def get_coordinates(location):
-    request_url = f'https://nominatim.openstreetmap.org/search.php?q={location}&polygon_geojson=1&accept-language=en&format=jsonv2'
-
-    print(request_url)
-    headers = {"User-Agent": "Mozilla/5.0"}
-    response = requests.get(request_url, headers=headers, verify=False)
-    json_content = json.loads(response.content)
-    # print(json_content)
-    if json_content[0]['geojson']['type'] == 'Polygon':
-        coordinates = json_content[0]['geojson']['coordinates'][0]
-    elif json_content[0]['geojson']['type'] == 'Point':
-        coordinates = json_content[0]['geojson']['coordinates']
-    else:
-        print(json_content[0]['geojson']['type'])
-    centroid = (float(json_content[0]['lon']), float(json_content[0]['lat']))
-    return (coordinates, centroid)
-
-
-# level3
-def get_directional_coordinates_by_angle(coordinates, centroid, direction, minimum, maximum):
-    # minimum = 157
-    # maximum = 202
-
-    direction_coordinates = []
-    for p in coordinates:
-        angle = geoutil.calculate_bearing(centroid, p)
-        p2 = (p[0], p[1], angle)
-        if direction in geo_level1.east:
-            if angle >= minimum or angle <= maximum:
-                direction_coordinates.append(p2)
-
-        else:
-            if angle >= minimum and angle <= maximum:
-                direction_coordinates.append(p2)
-    # print(type(direction_coordinates[0]))
-    # if(direction in geo_level1.west):
-    #    direction_coordinates.sort(key=lambda k: k[2], reverse=True)
-
-    return direction_coordinates
-def get_level3(level3):
-    digits = re.findall('[0-9]+', level3)[0]
-    unit = re.findall('[A-Za-z]+', level3)[0]
-    return digits, unit
-
-def get_direction_coordinates(coordinates, centroid, level1):
-    min_max = geo_level1.get_min_max(level1)
-    if min_max is not None:
-        coord = get_directional_coordinates_by_angle(coordinates, centroid, level1, min_max[0], min_max[1])
-        return coord
-    return coordinates
-def sort_west(poly1, poly2, centroid):
-    coords1 = mapping(poly1)["features"][0]["geometry"]["coordinates"]
-    coords2 = mapping(poly2)["features"][0]["geometry"]["coordinates"]
-    coord1 = []
-    coord2 = []
-    coord = []
-    for c in coords1:
-        pol = list(c[::-1])
-        coord1.extend(pol)
-    for c in coords2:
-        pol = list(c[::-1])
-        coord2.extend(pol)
-    coo1 = []
-    coo2 = []
-    for p in coord1:
-        angle = geoutil.calculate_bearing(centroid, p)
-        if angle >= 157 and angle <= 202:
-            coo1.append((p[0], p[1], angle))
-    for p in coord2:
-        angle = geoutil.calculate_bearing(centroid, p)
-        if angle >= 157 and angle <= 202:
-            coo2.append((p[0], p[1], angle))
-    coo1.extend(coo2)
-    return coo1
-
-
-def get_level3_coordinates(coordinates, level_3, level1):
-    distance, unit = get_level3(level_3)
-    kms = geoutil.get_kilometers(distance, unit)
-    coord = []
-
-    coords0, center = coordinates
-
-    if not isinstance(coords0, list) or len(coords0) < 3:
-
-        # 从原始点出发，根据方向移动距离 kms 得到新圆心
-        lat_km = 111.32
-        lon_km = 111.32 * np.cos(np.radians(center[1]))
-
-        dx = dy = 0
-
-        if level1 is not None:
-            if level1 in geo_level1.east:
-                dx = kms / lon_km
-            elif level1 in geo_level1.west:
-                dx = -kms / lon_km
-            elif level1 in geo_level1.north:
-                dy = kms / lat_km
-            elif level1 in geo_level1.south:
-                dy = -kms / lat_km
-            # 你也可以支持 northeast、southwest 等复合方向
-
-        new_center = (center[0] + dx, center[1] + dy)
-
-        # 用固定半径画个圆（例如半径2km）
-        r_km = 1  # 半径设为1km，你也可以设为其他值
-
-        circle_points = []
-        for theta in np.linspace(0, 360, num=100):
-            theta_rad = np.radians(theta)
-            d_lat = (np.sin(theta_rad) * r_km) / lat_km
-            d_lon = (np.cos(theta_rad) * r_km) / lon_km
-            circle_points.append((new_center[0] + d_lon, new_center[1] + d_lat))
-
-        # 输出中心（使用新圆心）
-        if circle_points:
-            center_point = MultiPoint(circle_points).centroid
-            center = (center_point.x, center_point.y)
-        else:
-            center = new_center
-
-        return circle_points, center
-
-    # 正常 polygon 流程
-    poly1 = Polygon(coords0)
-    polygon1 = gpd.GeoSeries(poly1)
-
-    # 生成环形区域
-    poly2 = polygon1.buffer(0.0095 * kms, join_style=2)
-    poly3 = polygon1.buffer(0.013 * kms, join_style=2)
-    poly = poly3.difference(poly2)
-
-    # 获取坐标
-    coords = mapping(poly)["features"][0]["geometry"]["coordinates"]
-    for c in coords:
-        pol = list(c[::-1])
-        coord.extend(pol)
-
-    # 方向裁剪
-    if level1 is not None:
-        coord = get_direction_coordinates(coord, coordinates[1], level1)
-        if level1 in geo_level1.west:
-            coord = sort_west(poly3, poly2, coordinates[1])
-
-    # 计算质心
-    if coord:
-        center_point = MultiPoint(coord).centroid
-        center = (center_point.x, center_point.y)
-    else:
-        center = coordinates[1]
-
-    return coord, center
-# level 3 end
-
-# between
-def get_between_coordinates(coordinates1, coordinates2):
-    """
-    计算两个区域之间的中间点，并生成一个等面积的圆形区域。
-    如果某个输入仅为点（坐标长度 < 3），则其面积设为 0；
-    如果两个输入都是点，则默认半径为 2km。
-    :param coordinates1: 第一个区域的边界坐标和中心点
-    :param coordinates2: 第二个区域的边界坐标和中心点
-    :return: 圆形区域的坐标集和圆心
-    """
-
-    def is_valid_polygon(coords):
-        return isinstance(coords, list) and len(coords) >= 3
-
-    coords1, center1 = coordinates1
-    coords2, center2 = coordinates2
-
-    # 判断输入是否为合法多边形（>=3个点）
-    if is_valid_polygon(coords1):
-        poly1 = Polygon(coords1)
-        area1 = poly1.area
-    else:
-        area1 = 0
-
-    if is_valid_polygon(coords2):
-        poly2 = Polygon(coords2)
-        area2 = poly2.area
-    else:
-        area2 = 0
-
-    # 计算中心点（两个中心的中点）
-    midpoint = (
-        (center1[0] + center2[0]) / 2,
-        (center1[1] + center2[1]) / 2
-    )
-
-    # 如果两个区域都是点，则使用默认半径 2km
-    if area1 == 0 and area2 == 0:
-        r_km = 2
-    else:
-        avg_area = (area1 + area2) / 2
-        r_km = np.sqrt(avg_area / np.pi) * 111.32  # 近似 km 半径
-
-    # 经纬度距离换算因子
-    lat_km = 111.32
-    lon_km = 111.32 * np.cos(np.radians(midpoint[1]))
-
-    # 生成圆形区域坐标（100个点）
-    circle_points = []
-    for theta in np.linspace(0, 360, num=100):
-        theta_rad = np.radians(theta)
-        d_lat = (np.sin(theta_rad) * r_km) / lat_km
-        d_lon = (np.cos(theta_rad) * r_km) / lon_km
-        circle_points.append((midpoint[0] + d_lon, midpoint[1] + d_lat))
-
-    return circle_points, midpoint
-# between end
-
-
-def llmapi(text):
-    system_prompt = (
-        "你是一个资深的地理学家，你的任务是通过给定的一段自然语言，来选择正确的定位函数顺序以及他们的输入。\n"
-        "你能选择的定位函数有：\n"
-        "1. 相对定位（Relative Positioning）：输入为地点坐标，方位，距离。输出为距离‘距离’输入的地点坐标的‘方位’的坐标。\n"
-        "2. 中间定位（Between Positioning）：输入为两个地点的坐标，输出为两个地点坐标的中点。\n"
-        "请先进行思维链（CoT）推理，并最终用 JSON 格式输出你的答案，用 `<<<JSON>>>` 和 `<<<END>>>` 包裹起来。\n"
-        "请确保所有输入仅包含：地点名称（字符串）、索引（整数）、方位（字符串，必须是英文）或距离（字符串，带单位），不允许返���诸如 'Chatswood 南4 km的坐标' 这样的内容。\n"
-        "每个步骤编号都有 id 记录，然后如果某个输入是之前步骤的输出，那么输入对应步骤的 id。\n"
-        "所有方向必须使用英文（如 south, west, northeast, etc.）。\n"
-        "示例输出：\n"
-        "<<<JSON>>>\n"
-        "[{\"id\": 1, \"function\": \"Relative\", \"inputs\": [\"Chatswood\", \"south\", \"4 km\"]},"
-        "{\"id\": 2, \"function\": \"Relative\", \"inputs\": [\"North Sydney\", \"west\", \"2 km\"]},"
-        "{\"id\": 3, \"function\": \"Between\", \"inputs\": [1, 2]},"
-        "{\"id\": 4, \"function\": \"Relative\", \"inputs\": [3, \"southwest\", \"5 km\"]}]\n"
-        "<<<END>>>")
-
-    messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": text},
-    ]
-
-    chat_completion = client.chat.completions.create(
-        messages=messages,
-        model=model,
-    )
-
-    result = chat_completion.choices[0].message.content
-    json_match = re.search(r'<<<JSON>>>\n(.*?)\n<<<END>>>', result, re.DOTALL)
-
-    if json_match:
-        # print(json.loads(json_match.group(1)))
-        return json.loads(json_match.group(1))
-    else:
-        raise ValueError("LLM 输出未包含预期的 JSON 格式数据。")
-def llmapi(text):
-    system_prompt = (
-        "You are an experienced geographer. Your task is to determine the correct sequence of positioning functions and their inputs based on a given piece of natural language.\n"
-        "The positioning functions you can choose from are:\n"
-        "1. Relative Positioning: Inputs is (location coordinate or location name, direction, and distance). Outputs the coordinates that are in the given 'direction' and 'distance' from the input location.\n"
-        "2. Between Positioning: Inputs is (location 1 coordinates or location 1 name, location 2 coordinates or location 2 name). Outputs the midpoint coordinate between the two locations.\n"
-        "You can only use the given functions, and the inputs to the functions must obey the above properties. The given functions can be combined to solve complex situations."
-        "First, perform chain-of-thought (CoT) reasoning, and finally output your answer in JSON format, wrapped between `<<<JSON>>>` and `<<<END>>>`.\n"
-        "Make sure all inputs only include: location names (strings), step indices (integers), directions (strings, must be in English), or distances (strings with units). Do not return expressions like 'the coordinate 4 km south of Chatswood'.\n"
-        "Each step must have an 'id'. If the input of a step is the output of a previous step, use that step’s 'id' as the input.\n"
-        "All directions must be in English (e.g., south, west, northeast, etc.).\n"
-        "Example output:\n"
-        "<<<JSON>>>\n"
-        "[{\"id\": 1, \"function\": \"Relative\", \"inputs\": [\"Chatswood\", \"south\", \"4 km\"]},"
-        "{\"id\": 2, \"function\": \"Relative\", \"inputs\": [\"North Sydney\", \"west\", \"2 km\"]},"
-        "{\"id\": 3, \"function\": \"Between\", \"inputs\": [1, 2]},"
-        "{\"id\": 4, \"function\": \"Relative\", \"inputs\": [3, \"southwest\", \"5 km\"]}]\n"
-        "<<<END>>>")
-
-    messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": text},
-    ]
-
-    chat_completion = client.chat.completions.create(
-        messages=messages,
-        model=model,
-    )
-
-    result = chat_completion.choices[0].message.content
-    print(result)
-    json_match = re.search(r'<<<JSON>>>\n(.*?)\n<<<END>>>', result, re.DOTALL)
-
-    if json_match:
-        return json.loads(json_match.group(1))
-    else:
-        raise ValueError("LLM 输出未包含预期的 JSON 格式数据。")
-
-
-
-
-
-def execute_steps(steps):
-    data = {}
-
-    for step in steps:
-        step_id = step['id']
-        function = step['function']
-        inputs = step['inputs']
-        # print('-' * 50)
-        # print(function)
-        # print(inputs)
-
-
-        resolved_inputs = []
-        for inp in inputs:
-            if isinstance(inp, int):
-                resolved_inputs.append(data[inp])
-            else:
-                resolved_inputs.append(inp)
-        if function == "Relative":
-            location, direction, distance = resolved_inputs
-            if isinstance(location, str):
-                location = get_coordinates(location)
-
-            location = [to_standard_2d_list(location[0])] + list(location[1:])
-            location = [[[151.214901,-33.859175]], (151.214901,-33.859175)]
-            result = get_level3_coordinates(location, distance, direction)
-            data[step_id] = result
-
-        elif function == "Between":
-
-
-            location1, location2 = resolved_inputs
-            # print(location1)
-            # print(111)
-            # print(location2)
-            if isinstance(location1, str):
-                location1 = get_coordinates(location1)
-
-                location1 = [to_standard_2d_list(location1[0])] + list(location1[1:])
-            if isinstance(location2, str):
-
-                location2 = get_coordinates(location2)
-                location2 = [to_standard_2d_list(location2[0])] + list(location2[1:])
-            result = get_between_coordinates(location1, location2)
-
-            data[step_id] = result
-
-    return data
-
-
-
-if __name__ == '__main__':
-    # a = get_coordinates('Burwood')
-    # a2 = get_coordinates('Glebe')
-    # b = get_level3_coordinates(a, '5 km', 'east')
-    # c = get_between_coordinates(a, a2)
-
-    # 完整通道
-    # 默认输入
-    # default_input_text = "在Chatswood南边4公里与North Sydney 东边2公里的中间的西南5公里。"
-    # default_input_text = "你是一位规划师，正在为华盛顿州的一项新森林监测站选址。两个潜在的参考位置分别是雷尼尔山国家公园（Mount Rainier National Park）和北喀斯喀特国家公园（North Cascades National Park）。首先，你想在这两个国家公园之间找到一个中间点。接着，你希望在这个中间点与北喀斯喀特国家公园之间，再取一个中间位置，以便确定最终的建设候选地。"
-    # default_input_text = "在Chatswood和North Sydney的中间靠近North Sydney的四分之一位置"
-    # default_input_text = "Plan a trip that involves determining the midpoint between Paris and London, and then finding another midpoint between this location and Paris to identify potential stopovers during travel."
-    # default_input_text = "5km southwest of Chatswood, 4km south of Chatswood and 2km north of North Sydney."
-
-
-
-    # 解析 LLM 结果
-    # parsed_steps = llmapi(default_input_text)
-    # parsed_steps = [{'id': 1, 'function': 'Relative', 'inputs': ['Chatswood', 'south', '4 km']}, {'id': 2, 'function': 'Relative', 'inputs': ['North Sydney', 'east', '2 km']}, {'id': 3, 'function': 'Between', 'inputs': [1, 2]}, {'id': 4, 'function': 'Relative', 'inputs': [3, 'south west', '5 km']}]
-    # parsed_steps = [{"id": 1, "function": "Between", "inputs": ["Chatswood", "North Sydney"]},{"id": 2, "function": "Between", "inputs": [1, "North Sydney"]}]
-    # parsed_steps = [{"id": 1, "function": "Relative", "inputs": ["Katoomba", "southeast", "3 km"]}, {"id": 2, "function": "Between", "inputs": [1, "Echo Point"]}]
-    # parsed_steps = [{'id': 1, 'function': 'Relative', 'inputs': ['Scafell Pike', 'east', '9 km']}]
-    # parsed_steps = [{'id': 1, 'function': 'Relative', 'inputs': ['Colosseum', 'northeast', '8 km']}, {'id': 2, 'function': 'Relative', 'inputs': [1, 'northeast', '2 km']}]
-    parsed_steps = [
-      {"id": 1, "function": "Between", "inputs": ["Statue of Liberty", "Eiffel Tower"]},
-      {"id": 2, "function": "Relative", "inputs": [1, "west", "8 km"]}
-    ]
+#         center = coordinates[1]
+
+#     return coord, center
+# # level 3 end
+
+# # between
+# def get_between_coordinates(coordinates1, coordinates2):
+#     """
+#     计算两个区域之间的中间点，并生成一个等面积的圆形区域。
+#     如果某个输入仅为点（坐标长度 < 3），则其面积设为 0；
+#     如果两个输入都是点，则默认半径为 2km。
+#     :param coordinates1: 第一个区域的边界坐标和中心点
+#     :param coordinates2: 第二个区域的边界坐标和中心点
+#     :return: 圆形区域的坐标集和圆心
+#     """
+
+#     def is_valid_polygon(coords):
+#         return isinstance(coords, list) and len(coords) >= 3
+
+#     coords1, center1 = coordinates1
+#     coords2, center2 = coordinates2
+
+#     # 判断输入是否为合法多边形（>=3个点）
+#     if is_valid_polygon(coords1):
+#         poly1 = Polygon(coords1)
+#         area1 = poly1.area
+#     else:
+#         area1 = 0
+
+#     if is_valid_polygon(coords2):
+#         poly2 = Polygon(coords2)
+#         area2 = poly2.area
+#     else:
+#         area2 = 0
+
+#     # 计算中心点（两个中心的中点）
+#     midpoint = (
+#         (center1[0] + center2[0]) / 2,
+#         (center1[1] + center2[1]) / 2
+#     )
+
+#     # 如果两个区域都是点，则使用默认半径 2km
+#     if area1 == 0 and area2 == 0:
+#         r_km = 2
+#     else:
+#         avg_area = (area1 + area2) / 2
+#         r_km = np.sqrt(avg_area / np.pi) * 111.32  # 近似 km 半径
+
+#     # 经纬度距离换算因子
+#     lat_km = 111.32
+#     lon_km = 111.32 * np.cos(np.radians(midpoint[1]))
+
+#     # 生成圆形区域坐标（100个点）
+#     circle_points = []
+#     for theta in np.linspace(0, 360, num=100):
+#         theta_rad = np.radians(theta)
+#         d_lat = (np.sin(theta_rad) * r_km) / lat_km
+#         d_lon = (np.cos(theta_rad) * r_km) / lon_km
+#         circle_points.append((midpoint[0] + d_lon, midpoint[1] + d_lat))
+
+#     return circle_points, midpoint
+# # between end
+
+
+# def llmapi(text):
+#     system_prompt = (
+#         "你是一个资深的地理学家，你的任务是通过给定的一段自然语言，来选择正确的定位函数顺序以及他们的输入。\n"
+#         "你能选择的定位函数有：\n"
+#         "1. 相对定位（Relative Positioning）：输入为地点坐标，方位，距离。输出为距离‘距离’输入的地点坐标的‘方位’的坐标。\n"
+#         "2. 中间定位（Between Positioning）：输入为两个地点的坐标，输出为两个地点坐标的中点。\n"
+#         "请先进行思维链（CoT）推理，并最终用 JSON 格式输出你的答案，用 `<<<JSON>>>` 和 `<<<END>>>` 包裹起来。\n"
+#         "请确保所有输入仅包含：地点名称（字符串）、索引（整数）、方位（字符串，必须是英文）或距离（字符串，带单位），不允许返回诸如 'Chatswood 南4 km的坐标' 这样的内容。\n"
+#         "每个步骤编号都有 id 记录，然后如果某个输入是之前步骤的输出，那么输入对应步骤的 id。\n"
+#         "所有方向必须使用英文（如 south, west, northeast, etc.）。\n"
+#         "示例输出：\n"
+#         "<<<JSON>>>\n"
+#         "[{\"id\": 1, \"function\": \"Relative\", \"inputs\": [\"Chatswood\", \"south\", \"4 km\"]},"
+#         "{\"id\": 2, \"function\": \"Relative\", \"inputs\": [\"North Sydney\", \"west\", \"2 km\"]},"
+#         "{\"id\": 3, \"function\": \"Between\", \"inputs\": [1, 2]},"
+#         "{\"id\": 4, \"function\": \"Relative\", \"inputs\": [3, \"southwest\", \"5 km\"]}]\n"
+#         "<<<END>>>")
+
+#     messages = [
+#         {"role": "system", "content": system_prompt},
+#         {"role": "user", "content": text},
+#     ]
+
+#     chat_completion = client.chat.completions.create(
+#         messages=messages,
+#         model=model,
+#     )
+
+#     result = chat_completion.choices[0].message.content
+#     json_match = re.search(r'<<<JSON>>>\n(.*?)\n<<<END>>>', result, re.DOTALL)
+
+#     if json_match:
+#         # print(json.loads(json_match.group(1)))
+#         return json.loads(json_match.group(1))
+#     else:
+#         raise ValueError("LLM 输出未包含预期的 JSON 格式数据。")
+# def llmapi(text):
+#     system_prompt = (
+#         "You are an experienced geographer. Your task is to determine the correct sequence of positioning functions and their inputs based on a given piece of natural language.\n"
+#         "The positioning functions you can choose from are:\n"
+#         "1. Relative Positioning: Inputs is (location coordinate or location name, direction, and distance). Outputs the coordinates that are in the given 'direction' and 'distance' from the input location.\n"
+#         "2. Between Positioning: Inputs is (location 1 coordinates or location 1 name, location 2 coordinates or location 2 name). Outputs the midpoint coordinate between the two locations.\n"
+#         "You can only use the given functions, and the inputs to the functions must obey the above properties. The given functions can be combined to solve complex situations."
+#         "First, perform chain-of-thought (CoT) reasoning, and finally output your answer in JSON format, wrapped between `<<<JSON>>>` and `<<<END>>>`.\n"
+#         "Make sure all inputs only include: location names (strings), step indices (integers), directions (strings, must be in English), or distances (strings with units). Do not return expressions like 'the coordinate 4 km south of Chatswood'.\n"
+#         "Each step must have an 'id'. If the input of a step is the output of a previous step, use that step’s 'id' as the input.\n"
+#         "All directions must be in English (e.g., south, west, northeast, etc.).\n"
+#         "Example output:\n"
+#         "<<<JSON>>>\n"
+#         "[{\"id\": 1, \"function\": \"Relative\", \"inputs\": [\"Chatswood\", \"south\", \"4 km\"]},"
+#         "{\"id\": 2, \"function\": \"Relative\", \"inputs\": [\"North Sydney\", \"west\", \"2 km\"]},"
+#         "{\"id\": 3, \"function\": \"Between\", \"inputs\": [1, 2]},"
+#         "{\"id\": 4, \"function\": \"Relative\", \"inputs\": [3, \"southwest\", \"5 km\"]}]\n"
+#         "<<<END>>>")
+
+#     messages = [
+#         {"role": "system", "content": system_prompt},
+#         {"role": "user", "content": text},
+#     ]
+
+#     chat_completion = client.chat.completions.create(
+#         messages=messages,
+#         model=model,
+#     )
+
+#     result = chat_completion.choices[0].message.content
+#     print(result)
+#     json_match = re.search(r'<<<JSON>>>\n(.*?)\n<<<END>>>', result, re.DOTALL)
+
+#     if json_match:
+#         return json.loads(json_match.group(1))
+#     else:
+#         raise ValueError("LLM 输出未包含预期的 JSON 格式数据。")
+
+
+
+
+
+# def execute_steps(steps):
+#     data = {}
+
+#     for step in steps:
+#         step_id = step['id']
+#         function = step['function']
+#         inputs = step['inputs']
+#         # print('-' * 50)
+#         # print(function)
+#         # print(inputs)
+
+
+#         resolved_inputs = []
+#         for inp in inputs:
+#             if isinstance(inp, int):
+#                 resolved_inputs.append(data[inp])
+#             else:
+#                 resolved_inputs.append(inp)
+#         if function == "Relative":
+#             location, direction, distance = resolved_inputs
+#             if isinstance(location, str):
+#                 location = get_coordinates(location)
+
+#             location = [to_standard_2d_list(location[0])] + list(location[1:])
+#             location = [[[151.214901,-33.859175]], (151.214901,-33.859175)]
+#             result = get_level3_coordinates(location, distance, direction)
+#             data[step_id] = result
+
+#         elif function == "Between":
+
+
+#             location1, location2 = resolved_inputs
+#             # print(location1)
+#             # print(111)
+#             # print(location2)
+#             if isinstance(location1, str):
+#                 location1 = get_coordinates(location1)
+
+#                 location1 = [to_standard_2d_list(location1[0])] + list(location1[1:])
+#             if isinstance(location2, str):
+
+#                 location2 = get_coordinates(location2)
+#                 location2 = [to_standard_2d_list(location2[0])] + list(location2[1:])
+#             result = get_between_coordinates(location1, location2)
+
+#             data[step_id] = result
+
+#     return data
+
+
+
+# if __name__ == '__main__':
+#     # a = get_coordinates('Burwood')
+#     # a2 = get_coordinates('Glebe')
+#     # b = get_level3_coordinates(a, '5 km', 'east')
+#     # c = get_between_coordinates(a, a2)
+
+#     # 完整通道
+#     # 默认输入
+#     # default_input_text = "在Chatswood南边4公里与North Sydney 东边2公里的中间的西南5公里。"
+#     # default_input_text = "你是一位规划师，正在为华盛顿州的一项新森林监测站选址。两个潜在的参考位置分别是雷尼尔山国家公园（Mount Rainier National Park）和北喀斯喀特国家公园（North Cascades National Park）。首先，你想在这两个国家公园之间找到一个中间点。接着，你希望在这个中间点与北喀斯喀特国家公园之间，再取一个中间位置，以便确定最终的建设候选地。"
+#     # default_input_text = "在Chatswood和North Sydney的中间靠近North Sydney的四分之一位置"
+#     # default_input_text = "Plan a trip that involves determining the midpoint between Paris and London, and then finding another midpoint between this location and Paris to identify potential stopovers during travel."
+#     # default_input_text = "5km southwest of Chatswood, 4km south of Chatswood and 2km north of North Sydney."
+
+
+
+#     # 解析 LLM 结果
+#     # parsed_steps = llmapi(default_input_text)
+#     # parsed_steps = [{'id': 1, 'function': 'Relative', 'inputs': ['Chatswood', 'south', '4 km']}, {'id': 2, 'function': 'Relative', 'inputs': ['North Sydney', 'east', '2 km']}, {'id': 3, 'function': 'Between', 'inputs': [1, 2]}, {'id': 4, 'function': 'Relative', 'inputs': [3, 'south west', '5 km']}]
+#     # parsed_steps = [{"id": 1, "function": "Between", "inputs": ["Chatswood", "North Sydney"]},{"id": 2, "function": "Between", "inputs": [1, "North Sydney"]}]
+#     # parsed_steps = [{"id": 1, "function": "Relative", "inputs": ["Katoomba", "southeast", "3 km"]}, {"id": 2, "function": "Between", "inputs": [1, "Echo Point"]}]
+#     # parsed_steps = [{'id': 1, 'function': 'Relative', 'inputs': ['Scafell Pike', 'east', '9 km']}]
+#     # parsed_steps = [{'id': 1, 'function': 'Relative', 'inputs': ['Colosseum', 'northeast', '8 km']}, {'id': 2, 'function': 'Relative', 'inputs': [1, 'northeast', '2 km']}]
+#     parsed_steps = [
+#       {"id": 1, "function": "Between", "inputs": ["Statue of Liberty", "Eiffel Tower"]},
+#       {"id": 2, "function": "Relative", "inputs": [1, "west", "8 km"]}
+#     ]
 
-    # 执行步骤
-    result = execute_steps(parsed_steps)
-    # 输出最终计算结果
-    print(result)
-    print('-' * 100)
-    print(result[(max(result.keys()))][0])
-    # 通道结束
+#     # 执行步骤
+#     result = execute_steps(parsed_steps)
+#     # 输出最终计算结果
+#     print(result)
+#     print('-' * 100)
+#     print(result[(max(result.keys()))][0])
+#     # 通道结束
 
-    # location = get_coordinates('Chatswood')
-    # result = get_level3_coordinates(location, '4 km', 'north west')
-    # print(result)
+#     # location = get_coordinates('Chatswood')
+#     # result = get_level3_coordinates(location, '4 km', 'north west')
+#     # print(result)