Upload 12 files

geospacy.py

@@ -0,0 +1,256 @@
+from spacy.tokens import Span
+from spacy.tokens import Doc
+from spacy.tokens import Token
+import regex_spatial
+from spacy.language import Language
+import re
+from utils import llm_ent_extract
+
+id =""
+rse_id = "rse_id"
+def set_extension():
+     Span.set_extension(rse_id, default = "",force = True)
+     Doc.set_extension(rse_id, default = "",force = True)
+     Token.set_extension(rse_id, default = "",force = True)
+     
+def get_level1(doc, sentence, ent):
+    return find_ent_by_regex(doc, sentence, ent, regex_spatial.get_level1_regex())
+
+def get_level2(doc, sentence, ent):
+  return find_ent_by_regex(doc, sentence, ent, regex_spatial.get_level2_regex()) 
+
+def get_level3(doc, sentence, ent):
+  return find_ent_by_regex(doc, sentence, ent, regex_spatial.get_level3_regex())
+
+
+def find_ent_by_regex(doc, sentence, ent, regex):
+  global id
+
+  if id == "":
+      id = ent.text
+  for match in re.finditer(regex, doc.text):
+        start, end = match.span()
+        if(start>= sentence.start_char and start<= sentence.end_char):
+          span = doc.char_span(start, end)
+          if span is not None:
+            id = span.text +"_"+ id
+            if(start > ent.end_char):
+              ent.end_char = end
+            else:
+              ent.start_char = start         
+
+          return ent
+
+  return ent
+
+
+def update_entities(doc, entity_texts, replace=True):
+    """
+    根据给定的文本内容标注实体，并直接修改 doc.ents。
+
+    :param doc: spaCy 解析后的 Doc 对象
+    :param entity_texts: 字典，键是要标注的实体文本，值是对应的实体类别
+    :param replace: 布尔值，True 则替换现有实体，False 则保留现有实体并添加新的
+    """
+    new_ents = list(doc.ents) if not replace else []  # 如果 replace=False，保留已有实体
+
+    for ent_text, ent_label in entity_texts.items():
+        start = doc.text.find(ent_text)  # 在全文中查找文本位置
+        if start != -1:
+            start_token = len(doc.text[:start].split())  # 计算起始 token 索引
+            end_token = start_token + len(ent_text.split())  # 计算结束 token 索引
+
+            if start_token < len(doc) and end_token <= len(doc):  # 确保索引不越界
+                new_ent = Span(doc, start_token, end_token, label=ent_label)
+                new_ents.append(new_ent)
+
+    doc.set_ents(new_ents)  # 更新 doc.ents
+
+
+def get_relative_entity(doc, sentence, ent):
+  global id
+
+  id = ""
+  rel_entity = get_level1(doc, sentence, ent)
+  # print(1111 ,rel_entity)
+  rel_entity = get_level2(doc, sentence, rel_entity)
+  # print(2222 ,rel_entity)
+  rel_entity = get_level3(doc, sentence, rel_entity)
+  # print(3333 ,rel_entity)
+
+  if("_" in id):
+    rel_entity = doc.char_span(rel_entity.start_char, rel_entity.end_char, "RSE")
+    rel_entity._.rse_id = id
+
+    # print(id, 'idid')
+    # print(rel_entity._.rse_id, '._._')
+
+    return rel_entity
+  rel_entity = doc.char_span(ent.start_char, ent.end_char, ent.label_)
+  rel_entity._.rse_id = id
+  # print(4444 ,rel_entity)
+  return rel_entity
+
+@Language.component("spatial_pipeline")
+def get_spatial_ent(doc):
+  set_extension()
+  new_ents = []
+  # ents = [ent for ent in doc.ents if ent.label_ == "GPE" or ent.label_ == "LOC"]        # 筛选出ase
+
+
+  # LLM 输出
+  # GPE = '[###Pyrmont###, ###Glebe###]'                       # LLM 输出的实体
+  GPE = llm_ent_extract.extract_GPE(doc.text)                       # LLM 输出的实体
+  print(doc.text, 'llmin')
+  print(GPE, 'llout')
+
+  GPE = llm_ent_extract.extract(GPE, 'GPE')
+  print(GPE, 'llmout2')
+  update_entities(doc, GPE, True)
+  ents = doc.ents
+  print(ents, 'eee')
+  # print(doc, 'ddd')
+  # print(ents, 'ddd')
+  # GPE = llm_ent_extract.extract(llm_ent_extract.extract_GPE(doc.text), 'gpe')
+  # update_entities(doc, GPE)
+  # LLM 输出完毕
+
+
+  # print(doc.ents, 111)
+  # print(doc.ents[2], 222)
+  # print(type(doc.ents[2]), 222)
+  # print(doc.ents[2].label_, 333)
+  # print('----------')
+  # doc.ents[2] = 'pp'
+  # print(doc.ents[2], 111)
+  # print(doc.ents[2].label_, 222)
+  # print(type(doc.ents), 333)
+  end = None
+  for ent in ents:
+
+    if ent.end != len(doc):
+        next_token = doc[ent.end]
+        if end is not None:
+          start = end
+        else:
+          start = ent.sent.start
+        if next_token.text.lower() in regex_spatial.get_keywords():
+          end = next_token.i
+        else:
+          end = ent.end
+
+    else:
+        start = ent.sent.start
+        end = ent.end
+
+    # print(doc, '//',start, '//', end, 999888)
+    # print(doc[start],'//', doc[end])
+    # print(ents, 999)
+
+
+    rsi_ent = get_relative_entity(doc,Span(doc, start, end), ent)
+    # print(doc.ents[0]._.rse_id, '._._2')
+
+
+    # print(rsi_ent.text, rsi_ent.label_, rsi_ent._.rse_id)
+    new_ents.append(rsi_ent)
+
+  doc.ents = new_ents
+  return doc
+
+# def update_doc_ents(doc, new_dict):
+#     """
+#     更新 doc.ents, 将新的实体文本和标签添加到 doc 中。
+#
+#     参数:
+#     - doc: spaCy 的 Doc 对象
+#     - new_dict: 一个字典，键是实体文本，值是标签
+#     """
+#     modified_ents = []
+#
+#     # 遍历字典中的实体文本和标签
+#     for ent_text, label in new_dict.items():
+#         # 将实体文本拆分成单词
+#         ent_words = ent_text.split()
+#
+#         # 遍历 doc 中的 token 来查找第一个单词
+#         start = None
+#         for i in range(len(doc)):
+#             # 如果当前 token 和实体的第一个单词匹配，确定 start
+#             if doc[i].text == ent_words[0]:
+#                 start = i
+#                 # 然后检查后续的单词是否都匹配
+#                 end = start + len(ent_words)  # 计算 end 为 start + 单词数
+#                 if all(doc[start + j].text == ent_words[j] for j in range(len(ent_words))):
+#                     # 创建 Span 对象
+#                     new_ent = Span(doc, start, end, label=label)
+#                     modified_ents.append(new_ent)
+#                     break  # 找到匹配后跳出循环
+#
+#     # 使用 doc.set_ents() 更新 doc.ents
+#     doc.set_ents(modified_ents)
+#
+#
+# # def llm_extract(doc, model):
+#
+# def split_doc_into_sentences(doc):
+#     """
+#     将 doc 的文本按句子分割，并返回每个句子的字符串列表。
+#     """
+#     sentence_list = [sent.text.strip() for sent in doc.sents]
+#     return sentence_list
+#
+#
+# @Language.component("spatial_pipeline")
+# def get_spatial_ent(doc):
+#
+#     set_extension()
+#
+#     split_sent = split_doc_into_sentences(doc)
+#     for i in range(len(split_sent)):
+#         gpe_dict = llm_ent_extract.extract_GPE(split_sent[i])
+#         loc_dict = llm_ent_extract.extract_LOC(split_sent[i])
+#         new_dict = gpe_dict|loc_dict
+#
+#
+#     print(gpe_dict, '111')
+#     print(loc_dict)
+#     print(new_dict)
+#     # new_dict = {'pp': 'ORG', 'France': 'GPE', 'Paris': 'GPE'}
+#
+#
+#     # 调用新的函数更新 doc 的实体
+#     update_doc_ents(doc, new_dict)
+#
+#     # 继续处理 doc.ents
+#     ents = [ent for ent in doc.ents if ent.label_ == "GPE" or ent.label_ == "LOC"]
+#     print(ents[1].label_)
+#
+#     end = None
+#     new_ents = []
+#
+#     for ent in ents:
+#         if ent.end != len(doc):
+#             next_token = doc[ent.end + 1]
+#             if end is not None:
+#                 start = end
+#             else:
+#                 start = ent.sent.start
+#             if next_token.text.lower() in regex_spatial.get_keywords():
+#                 end = next_token.i
+#             else:
+#                 end = ent.end
+#         else:
+#             start = ent.sent.start
+#             end = ent.end
+#
+#         # 调用 get_relative_entity 来获得新的实体信息
+#         rsi_ent = get_relative_entity(doc, Span(doc, start, end), ent)
+#
+#         # 将处理后的实体添加到新的实体列表中
+#         new_ents.append(rsi_ent)
+#
+#     doc.ents = new_ents  # 更新 doc.ents
+#     print(new_ents, '111222')
+#
+#     return doc

regex_spatial.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jul 26 14:57:18 2022
+
+@author: syed
+"""
+
+from quantities import units as u
+from quantities import Quantity
+
+one_plus = "+"
+zero_plus = "*"
+
+
+def get_quantities_regex():
+  # myList = [unit for unit in dir(u.length)
+  #           if type(getattr(u.length, unit)) is u.length ]
+  myList = [unit for unit in dir(u.length) if isinstance(getattr(u.length, unit), Quantity)]
+
+  units = [ x for x in myList if "_" not in x ]
+  units_regex = '|'.join(units)
+  return "["+units_regex+"]"
+def get_number_regex():
+  regex = "[0-9]"
+  return regex
+def get_space_regex():
+  regex = "\s"
+  return regex
+
+def get_directional_regex():
+  cardinals_kwds = "north|south|east|west"
+  ordinals_kwds = "north-east|north-west|south-east|south-west|north east|north west|south east|south west|northeast|northwest|southeast|southwest"
+  symbols_kwds = "N'|S'|E'|W'|NE'|NW'|SE'|SW'"
+  return ordinals_kwds+"|"+symbols_kwds+"|"+cardinals_kwds
+
+def get_center_regex():
+  center_kwds = "center|central|downtown|midtown"
+  return center_kwds
+
+def get_near_regex():
+  near_kwds = "nearby|near|vicinity|close|beside|next|adjacent|immediate|border"
+  return near_kwds
+
+def get_surrounding_regex():
+  surrounding_kwds = "surrounding|neigbourhood|proximity|territory|locality"
+  return surrounding_kwds
+def get_level1_regex():
+  level_1_regex = "(?i)("+get_directional_regex()+"|"+get_center_regex()+")"
+  return level_1_regex
+
+def get_level2_regex():
+  level_2_regex = "(?i)("+get_near_regex()+"|"+get_surrounding_regex()+")"
+  return level_2_regex
+
+def get_level3_regex():
+  level_3_regex = "(?i)("+get_number_regex()+one_plus+get_space_regex()+zero_plus+get_quantities_regex()+one_plus+")"
+  return level_3_regex
+
+
+
+def get_keywords():
+   keywords = []
+   keywords = get_directional_regex().split("|")
+   keywords.extend(get_near_regex().split("|"))
+   keywords.extend(get_surrounding_regex().split("|"))
+   keywords.extend(get_center_regex().split("|"))
+   keywords.append(",")
+   keywords.append("and")
+   keywords.append(".")
+   
+   return keywords

utils/config.py

@@ -0,0 +1 @@
+api_key = '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'

utils/geoutil.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Aug  2 12:45:21 2022
+
+@author: syed
+"""
+
+import math
+import re
+import regex_spatial
+import quantities as pq
+from math import radians, cos, sin, asin, sqrt
+import quantities as pq
+
+
+
+def get_kilometers(d, unit):
+    q = float(d) * pq.CompoundUnit(unit)
+    q.units = pq.km
+    return q.magnitude
+
+def ConvertToRadian(input):
+    return input * math.pi / 180
+
+def get_level1(ent):
+    level_1 = re.search(regex_spatial.get_level1_regex(), ent)
+    if level_1 is not None:
+        return level_1.group()
+    return None
+def get_level2(ent):
+    level_2 = re.search(regex_spatial.get_level2_regex(), ent)
+    if level_2 is not None:
+        return level_2.group()
+    return None
+def get_level3(ent):
+    level_3 = re.search(regex_spatial.get_level3_regex(), ent)
+    if level_3 is not None:
+        return level_3.group()
+    return None
+
+def get_ase(ent):
+    abs_sp = ent.split("_")
+    return abs_sp[len(abs_sp)-1]
+
+def get_ent(ent):
+    return get_ase(ent), get_level1(ent), get_level2(ent), get_level3(ent)
+
+def get_centroid(coordinates, centroid, mini, maxi):
+    average = (mini + maxi)/2
+    diff = []
+    ind = 0
+    for p in coordinates:
+        diff.append(abs( p[2] - average))
+   
+    ind = diff.index(min(diff))    
+   
+    return midpoint(centroid[0], centroid[1], coordinates[ind][0], coordinates[ind][1], average)
+
+
+def calculateArea(coordinates):
+    area = 0
+    if (len(coordinates) > 2):
+        i = 0
+        for i in range(len(coordinates) - 1):
+            p1 = coordinates[i]
+            p2 = coordinates[i + 1]
+            area += math.radians(p2[0] - p1[0]) * (2 + math.sin(ConvertToRadian(p1[1])) + math.sin(math.radians(p2[0])))
+        
+        
+        area = area * 6378137 * 6378137 / 1000000
+    
+    area = abs(round(area, 2)) + 2
+    
+    return area
+
+def get_midmid_point(centroid, point1, point2, is_midmid):
+    mid1 = midpoint(centroid[0], centroid[1], 
+                            point1[0], point1[1]
+                            , point1[2])
+    mid2 = midpoint(centroid[0], centroid[1], 
+                            point2[0], point2[1],
+                            point2[2])
+    midmid1 = midpoint(centroid[0], centroid[1], 
+                            mid1[0], mid1[1]
+                            , mid1[2])
+    midmid2 = midpoint(centroid[0], centroid[1], 
+                            mid2[0], mid2[1],
+                            mid2[2])
+    if is_midmid:
+        return midmid1, midmid2
+    else:
+        return mid1, mid2
+
+def getPointByDistanceAngle(lat, ln, angle, distanceInKm):
+
+    R = 6378.1 #Radius of the Earth
+    brng = angle * math.pi /180 #Bearing is 90 degrees converted to radians.
+    d = distanceInKm #Distance in km
+    
+    #lat2  52.20444 - the lat result I'm hoping for
+    #lon2  0.36056 - the long result I'm hoping for.
+    
+    lat1 = math.radians(lat) #Current lat point converted to radians
+    lon1 = math.radians(ln) #Current long point converted to radians
+    
+    lat2 = math.asin( math.sin(lat1)*math.cos(d/R) +
+         math.cos(lat1)*math.sin(d/R)*math.cos(brng))
+    
+    lon2 = lon1 + math.atan2(math.sin(brng)*math.sin(d/R)*math.cos(lat1),
+                 math.cos(d/R)-math.sin(lat1)*math.sin(lat2))
+    
+    lat2 = math.degrees(lat2)
+    lon2 = math.degrees(lon2)
+    
+    return [lon2, lat2, angle]
+
+def midpoint(x1, y1, x2, y2, angle):
+
+    lonA = math.radians(y1)
+    lonB = math.radians(y2)
+    latA = math.radians(x1)
+    latB = math.radians(x2)
+
+    dLon = lonB - lonA
+
+    Bx = math.cos(latB) * math.cos(dLon)
+    By = math.cos(latB) * math.sin(dLon)
+
+    latC = math.atan2(math.sin(latA) + math.sin(latB),
+                  math.sqrt((math.cos(latA) + Bx) * (math.cos(latA) + Bx) + By * By))
+    lonC = lonA + math.atan2(By, math.cos(latA) + Bx)
+    lonC = (lonC + 3 * math.pi) % (2 * math.pi) - math.pi
+    latitude = round(math.degrees(latC), 8)
+    longitude = round(math.degrees(lonC),8)
+    return [latitude, longitude, angle]
+
+def midpoint(y1, x1, y2, x2, angle):
+
+    lonA = math.radians(y1)
+    lonB = math.radians(y2)
+    latA = math.radians(x1)
+    latB = math.radians(x2)
+
+    dLon = lonB - lonA
+
+    Bx = math.cos(latB) * math.cos(dLon)
+    By = math.cos(latB) * math.sin(dLon)
+
+    latC = math.atan2(math.sin(latA) + math.sin(latB),
+                      math.sqrt((math.cos(latA) + Bx) * (math.cos(latA) + Bx) + By * By))
+    lonC = lonA + math.atan2(By, math.cos(latA) + Bx)
+    lonC = (lonC + 3 * math.pi) % (2 * math.pi) - math.pi
+    latitude = round(math.degrees(latC), 8)
+    longitude = round(math.degrees(lonC) ,8)
+    print([longitude, latitude, angle], 'midmid')
+    return [longitude, latitude, angle
+
+    ]
+
+def calculate_bearing(pointA, pointB):
+  
+    if (type(pointA) != tuple) or (type(pointB) != tuple):
+        return 400
+    if (type(pointB[0]) != float) or (type(pointB[0]) != float):
+        return 400
+    
+    lat1 = math.radians(pointA[0])
+    lat2 = math.radians(pointB[0])
+
+    diffLong = math.radians(pointB[1] - pointA[1])
+
+    x = math.sin(diffLong) * math.cos(lat2)
+    y = math.cos(lat1) * math.sin(lat2) - (math.sin(lat1)
+            * math.cos(lat2) * math.cos(diffLong))
+
+    initial_bearing = math.atan2(x, y)
+
+  
+    initial_bearing = math.degrees(initial_bearing)
+    compass_bearing = (initial_bearing + 360) % 360
+
+    return compass_bearing
+
+def getPointByDistanceAngle(lat, ln, angle, distance, unit):
+    
+    #distanceInKm = distance
+    R = 6378.1 #Radius of the Earth
+    brng = float(angle) * math.pi /180 #Bearing is 90 degrees converted to radians.
+    d = get_kilometers(distance, unit) #Distance in km
+    
+    
+    lat1 = math.radians(lat) #Current lat point converted to radians
+    lon1 = math.radians(ln) #Current long point converted to radians
+    
+    lat2 = math.asin( math.sin(lat1)*math.cos(d/R) +
+         math.cos(lat1)*math.sin(d/R)*math.cos(brng))
+    
+    lon2 = lon1 + math.atan2(math.sin(brng)*math.sin(d/R)*math.cos(lat1),
+                 math.cos(d/R)-math.sin(lat1)*math.sin(lat2))
+    
+    lat2 = math.degrees(lat2)
+    lon2 = math.degrees(lon2)
+    
+    return (round(lon2,8), round(lat2,8), angle)
+
+
+def calculatePointByDistance(lat, ln, angle, distance, unit):
+    coff = 100/(6378*1.56)
+    kms = get_kilometers(distance, unit)
+    
+    d = kms * coff
+    
+    angle_x = math.cos( angle ) # * math.pi/180
+    angle_y = math.sin( angle) # * math.pi/180
+    lat_new =  lat + (d * angle_x) 
+    ln_new =  ln + (d * angle_y) 
+
+    return (round(ln_new,8), round(lat_new,8), angle)
+
+
+
+def pointByAngle(lat, ln, angle, distance, unit):
+
+    R = 6378.1 #Radius of the Earth
+    brng = angle * math.pi /180 #Bearing is 90 degrees converted to radians.
+    d = get_kilometers(distance, unit) #Distance in km
+    
+    #lat2  52.20444 - the lat result I'm hoping for
+    #lon2  0.36056 - the long result I'm hoping for.
+    
+    lat1 = math.radians(lat) #Current lat point converted to radians
+    lon1 = math.radians(ln) #Current long point converted to radians
+    
+    lat2 = math.asin( math.sin(lat1)*math.cos(d/R) +
+         math.cos(lat1)*math.sin(d/R)*math.cos(brng))
+    
+    lon2 = lon1 + math.atan2(math.sin(brng)*math.sin(d/R)*math.cos(lat1),
+                 math.cos(d/R)-math.sin(lat1)*math.sin(lat2))
+    
+    lat2 = math.degrees(lat2)
+    lon2 = math.degrees(lon2)
+    
+    return (lon2, lat2, angle)
+
+
+def getPointByDistance(lat, ln, angle, distance, unit):
+    kms = get_kilometers(distance, unit)
+    coef = kms / 111.32
+    new_lat = lat + coef
+    new_long = ln + coef / math.cos(lat * 0.01745)
+    return (round(new_lat,8), round(new_long,8), angle)
+
+def haversine(lon1, lat1, lon2, lat2):
+    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
+    dlon = lon2 - lon1 
+    dlat = lat2 - lat1 
+    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
+    c = 2 * asin(sqrt(a)) 
+    km = 6371* c
+    return km
+    

utils/llm_coding.py

@@ -0,0 +1,582 @@
+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
+from utils.config import 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:
+        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"]}
+    ]
+
+    # 执行步骤
+    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)
+
+

utils/llm_ent_extract.py

@@ -0,0 +1,145 @@
+from openai import OpenAI
+import re
+from utils.config import api_key
+
+client = OpenAI(
+    api_key=api_key
+)
+
+model = "gpt-3.5-turbo"
+model = "gpt-4o"
+
+def extract_GPE(text):
+    system_prompt = '''You are a professional geographer. Your task is to extract all geopolitical entities from a given text. Geopolitical entities can include countries, regions, cities, autonomous regions, or other administrative divisions. For each geopolitical entity, wrap the name in a unique character sequence, such as [###ENTITY###]. If there are multiple entities, output them in the following format:\n[###ENTITY1###, ###ENTITY2###, ###ENTITY3###]\nHere is an example:\n Example:\n\nText:\n"China and India are two of the most populous countries in Asia."\n\nExpected Output:\n[###China###, ###India###]'''
+    sent = 'Where is France?'
+
+    math_bot_messages = [
+        {"role": "system",
+         "content": system_prompt},
+        {"role": "user", "content": text},
+    ]
+
+    chat_completion = client.chat.completions.create(
+        messages=math_bot_messages,
+        model=model,
+    )
+
+    result = chat_completion.choices[0].message.content
+    return result
+
+
+def extract_LOC(text):
+    system_prompt = '''You are a professional geographer. Your task is to extract all location entities (LOC) from a given text. Location entities can include physical locations such as landmarks, geographical features, mountains, rivers, oceans, and places, but do not include political or administrative divisions such as countries or cities (these are considered geopolitical entities). For each location entity, wrap the name in a unique character sequence, such as [###ENTITY###]. If there are multiple entities, output them in the following format:\n[###ENTITY1###, ###ENTITY2###, ###ENTITY3###]\nHere is an example:\n Example:\n\nText:\n"China and India are two of the most populous countries in Asia."\n\nExpected Output:\n[###China###, ###India###]'''
+    sent = 'The Grand Canyon is one of the most spectacular natural wonders in the world, located in the state of Arizona. Nearby, the Colorado River flows through the canyon, carving its way through the rugged terrain. In the north, the Rocky Mountains stretch across several states, including Colorado and Wyoming.'
+
+    math_bot_messages = [
+        {"role": "system",
+         "content": system_prompt},
+        {"role": "user", "content": text},
+    ]
+
+    chat_completion = client.chat.completions.create(
+        messages=math_bot_messages,
+        model=model,
+    )
+
+    result = chat_completion.choices[0].message.content
+    return result
+
+
+def extract_RSE_1(text):
+    system_prompt = '''You are a professional geographer. Your task is to extract all spatial entities (directional keywords) from a given text. Spatial entities can include directional keywords such as north, south, east, west, and more specific terms like northeast, northwest, southeast, southwest, as well as terms indicating locations like center, central, downtown, and midtown. For each spatial entity, wrap the name in a unique character sequence, such as [###ENTITY###]. If there are multiple entities, output them in the following format:\n[###ENTITY1###, ###ENTITY2###, ###ENTITY3###]\nHere is an example:\n Example:\n\nText:\n"The hotel is located in the downtown area of New York, just south of Central Park, with a beautiful view of the southeast corner."\n\nExpected Output:\n[###downtown###, ###south###, ###southeast###]'''
+    sent = 'The train station is situated in the central part of the city, just north of the river and east of the main square.'
+
+    math_bot_messages = [
+        {"role": "system",
+         "content": system_prompt},
+        {"role": "user", "content": text},
+    ]
+
+    chat_completion = client.chat.completions.create(
+        messages=math_bot_messages,
+        model=model,
+    )
+
+    result = chat_completion.choices[0].message.content
+    return result
+
+
+def extract_RSE_2(text):
+    system_prompt = '''You are a professional geographer. Your task is to extract all fuzzy spatial entities (keywords) from a given text. Fuzzy spatial keywords can include terms like nearby, near, vicinity, close, beside, next, adjacent, immediate, border, surrounding, neighbourhood, proximity, territory, locality, and similar terms. For each fuzzy spatial keyword, wrap the name in a unique character sequence, such as [###ENTITY###]. If there are multiple entities, output them in the following format:\n[###ENTITY1###, ###ENTITY2###, ###ENTITY3###]\nHere is an example:\n Example:\n\nText:\n"The park is located nearby the lake, with several cafes close to the walking paths, and a small garden adjacent to the main entrance."\n\nExpected Output:\n[###nearby###, ###close###, ###adjacent###]'''
+    sent = 'The village is situated in the vicinity of the mountain range, with a small river flowing beside the houses and several farms next to the road.'
+
+    math_bot_messages = [
+        {"role": "system",
+         "content": system_prompt},
+        {"role": "user", "content": text},
+    ]
+
+    chat_completion = client.chat.completions.create(
+        messages=math_bot_messages,
+        model=model,
+    )
+
+    result = chat_completion.choices[0].message.content
+    return result
+
+
+def extract_RSE_3(text):
+    system_prompt = '''You are a professional geographer. Your task is to extract all fuzzy distance keywords from a given text. Fuzzy distance keywords include numeric values followed by distance units such as kilometer, mile, meter, foot, inch, centimeter, and other related units. The distance units can be in different formats, such as km, m, mi, ft, yd, cm, mm, or even in full words like kilometer, mile, or inch. For each fuzzy distance keyword, wrap the entire expression (number and unit) in a unique character sequence, such as [###ENTITY###]. If there are multiple entities, output them in the following format:\n[###ENTITY1###, ###ENTITY2###, ###ENTITY3###]\nHere is an example:\n Example:\n\nText:\n"The park is located 3 km away from the city center, while the nearest supermarket is only 500 meters from here, and the lake is about 1 mile further down the road."\n\nExpected Output:\n[###3 km###, ###500 meters###, ###1 mile###]'''
+    sent = 'The school is located approximately 2 miles from the station, while the nearest bus stop is 200 meters away. The hiking trail is about 5 kilometers east of the town center.'
+
+    math_bot_messages = [
+        {"role": "system",
+         "content": system_prompt},
+        {"role": "user", "content": text},
+    ]
+
+    chat_completion = client.chat.completions.create(
+        messages=math_bot_messages,
+        model=model,
+    )
+
+    result = chat_completion.choices[0].message.content
+    return result
+
+
+def extract(respond, entity_type):
+    """
+    从输入字符串中提取被 ### 包裹的实体，并将其映射到给定的实体类型。
+
+    :param respond: 包含实体的字符串，例如 '[###2 miles###, ###200 meters###, ###5 kilometers###]'
+    :param entity_type: 给所有提取的实体赋予的类型（字符串）
+    :return: 一个字典，键是提取出的实体，值是相同的 entity_type
+    """
+    # 提取被 ### 包裹的内容
+    extracted_entities = re.findall(r'###(.*?)###', respond)
+
+    # 生成字典，将所有实体映射到同一个类型
+    entity_dict = {entity.strip(): entity_type for entity in extracted_entities}
+
+    return entity_dict
+
+
+def llmapi(text):
+    system_prompt = '请你填入需要的提示'
+    math_bot_messages = [
+        {"role": "system",
+         "content": system_prompt},
+        {"role": "user", "content": text},
+    ]
+
+    chat_completion = client.chat.completions.create(
+        messages=math_bot_messages,
+        model=model,
+    )
+
+    result = chat_completion.choices[0].message.content
+    return result
+
+
+# print(extract('[###2 miles###, ###200 meters###, ###5 kilometers###]', 'rse'))
+# print(extract(extract_GPE('Between Burwood and Glebe.'), 'gpe'))
+
+
+