Upload 18 files

disambiguation/disambiguate.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Aug  1 13:11:36 2022
+
+@author: syed
+"""
+import requests
+import urllib3
+import json
+from geocoder import geo_level1
+from geocoder import geo_level2
+from geocoder import geo_level3
+
+from utils import geoutil
+import re
+import regex_spatial
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+
+
+
+def dismabiguate_entities(doc, ent, ase, level_1, level_2, level_3, midmid):
+    return get_coordinates(ent, ase, level_1, level_2, level_3, midmid)
+def get_coordinates(ent, ase, level_1, level_2, level_3, midmid):
+    request_url = 'https://nominatim.openstreetmap.org/search.php?q='+ase+'&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)
+    # page = requests.get(request_url, verify=False)
+    # print(request_url, '++++++')
+    # print(ent, '++++++')
+    # print(ase, '++++++')
+    # print(level_1, '++++++')
+    # print(level_2, '++++++')
+    # print(level_3, '++++++')
+    # print(midmid, '++++++')
+
+
+    json_content = json.loads(page.content)
+    # json_content = json.loads(aa)
+    print(json_content, 'jjjjj')
+    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)
+    mid1 = None
+    mid2 = None
+    coordinates = all_coordinates
+    # if level_1 is not None:
+    #
+    #     all_coordinates, centroid, mid1, mid2 = geo_level1.get_level1_coordinates(all_coordinates, centroid, level_1, midmid)
+        
+    # if level_2 is not None:
+    #     if level_1 is not None and level_1.lower() not in geo_level1.center:
+    #         all_coordinates, centroid = geo_level2.get_level2_coordinates(coordinates, centroid, level_2, level_1)
+    #     else:
+    #         print ("Else executed")
+    #         all_coordinates, centroid = geo_level2.get_level2_coordinates(all_coordinates, centroid, level_2, level_1)
+
+    if level_3 is not None:
+        all_coordinates, centroid = geo_level3.get_level3_coordinates(coordinates, centroid, level_3, level_1)
+    
+    geojson = get_geojson(ent, all_coordinates, centroid)
+    
+    return geojson
+
+
+def dismabiguate_entities_between(doc, ent, ase, level_1, level_2, level_3, midmid):
+    return get_coordinates_between(doc, ent, ase, level_1, level_2, level_3, midmid)
+
+
+def get_coordinates_between(doc, ent, ase, level_1, level_2, level_3, midmid):
+
+    # first ase
+    request_url = 'https://nominatim.openstreetmap.org/search.php?q=' + doc.ents[0].text + '&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"
+    }
+    page1 = requests.get(request_url, headers=headers, verify=False)
+
+    # second ase
+    request_url = 'https://nominatim.openstreetmap.org/search.php?q=' + doc.ents[1].text + '&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)
+
+
+    request_url = 'https://nominatim.openstreetmap.org/search.php?q=' + ase + '&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)
+    print('bebe')
+    print(ase)
+    print(doc.ents)
+
+    json_content = json.loads(page.content)
+    # json_content = json.loads(aa)
+    # print(json_content, 'jjj')
+    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)
+    mid1 = None
+    mid2 = None
+    coordinates = all_coordinates
+    if level_1 is not None:
+
+        all_coordinates, centroid, mid1, mid2 = geo_level1.get_level1_coordinates(all_coordinates, centroid, level_1, midmid)
+
+    if level_2 is not None:
+        if level_1 is not None and level_1.lower() not in geo_level1.center:
+            all_coordinates, centroid = geo_level2.get_level2_coordinates(coordinates, centroid, level_2, level_1)
+        else:
+            print ("Else executed")
+            all_coordinates, centroid = geo_level2.get_level2_coordinates(all_coordinates, centroid, level_2, level_1)
+
+    if level_3 is not None:
+        all_coordinates, centroid = geo_level3.get_level3_coordinates(coordinates, centroid, level_3, level_1)
+
+    geojson = get_geojson(ent, all_coordinates, centroid)
+
+    return geojson
+
+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 export(ent, poly_json):
+    with open(ent+'.geojson', 'w') as outfile:
+        json.dump(poly_json, outfile)
+    
+    

geocoder/geo_level1.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Aug  2 12:38:31 2022
+
+@author: syed
+"""
+import regex_spatial
+from utils import geoutil
+
+
+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", 'northeast']
+southeast = ["south-east", "SE'", "south east", "SOUTH-EAST", "South East", "SOUTH EAST", 'southeast']
+northwest = ["north-west", "NW'", "north west", "NORTH-WEST", "North West", "NORTH WEST", 'northwest']
+southwest = ["south-west", "SW'", "south west", "SOUTH-WEST", "South West", "SOUTH WEST", 'southwest']
+center = ["center","central", "downtown","midtown"]
+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_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 (292, 337)
+        if direction in north:
+            return (247, 292)
+        if direction in northwest:
+            return (202, 247)
+        if direction in west:
+            return (157, 202)
+        if direction in southwest:
+            return (112, 157)
+        if direction in south:
+            return (67, 112)
+        if direction in southeast:
+            return (22, 67)
+
+    return None
+
+# def get_min_max(direction):
+#     regex = regex_spatial.get_directional_regex()
+#     direction_list = regex.split("|")
+#     if direction in direction_list:
+#         if direction in north:
+#             return (337, 22)
+#         if direction in northeast:
+#             return (22, 67)
+#         if direction in east:
+#             return (67, 112)
+#         if direction in southeast:
+#             return (112, 157)
+#         if direction in south:
+#             return (157, 202)
+#         if direction in southwest:
+#             return (202, 247)
+#         if direction in west:
+#             return (247, 292)
+#         if direction in northwest:
+#             return (292, 337)
+#
+#     return None
+
+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(coordinates, direction, centroid , minimum, maximum, is_midmid):
+    direction_coordinates = get_directional_coordinates_by_angle(coordinates, direction, minimum, maximum)
+    print(direction_coordinates, 'ddddd')
+    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)
+          print(index_maxi+1, midmid2, 'imim')
+          print(index_mini+1, midmid1, 'imim')
+    else:
+        direction_coordinates.append(midmid2)
+        direction_coordinates.append(midmid1)
+    
+    return direction_coordinates, midmid1, midmid2
+
+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)
+           # print(mid1, 'min_max')
+           # print(mid2, 'min_max')
+           print(coordinates, 'min_max')
+           print("Level 1 Coordinates///")
+           for idx, p in enumerate(coordinates):
+               print(idx, p)
+           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 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        
+    
+    

geocoder/geo_level11.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Aug  2 12:38:31 2022
+
+@author: syed
+"""
+import regex_spatial
+from utils import geoutil
+
+
+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_min_max(direction):
+    regex = regex_spatial.get_directional_regex()
+    direction_list = regex.split("|")
+    if direction in direction_list:
+        if direction in north:
+            return (337, 22)
+        if direction in northeast:
+            return (22, 67)
+        if direction in east:
+            return (67, 112)
+        if direction in southeast:
+            return (112, 157)
+        if direction in south:
+            return (157, 202)
+        if direction in southwest:
+            return (202, 247)
+        if direction in west:
+            return (247, 292)
+        if direction in northwest:
+            return (292, 337)
+        
+    return None   
+        
+
+def get_directional_coordinates_by_angle(coordinates, direction, minimum, maximum):
+    direction_coordinates = []
+    for p in coordinates:
+        if direction in north:
+            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(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 south:
+          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_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) 
+           #centroid = geoutil.get_centroid(coordinates, centroid,min_max[0], min_max[1])
+           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 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 =[n_mid1, n_mid2, ne_mid1, ne_mid2, e_mid1, e_mid2,
+                           se_mid1, se_mid2, s_mid1, s_mid2, sw_mid1, sw_mid2,
+                           w_mid1, w_mid2, nw_mid1, nw_mid2]
+    return central_coordindates        
+    
+    

geocoder/geo_level2.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Aug  2 12:38:31 2022
+
+@author: syed
+"""
+import regex_spatial
+from utils import geoutil
+import geopandas as gpd
+import pandas as pd
+import re
+from shapely.geometry import Polygon,mapping
+import numpy as np
+from shapely.geometry import Polygon, MultiPoint
+from shapely.geometry.base import geom_factory
+from shapely.geos import lgeos
+from geocoder import geo_level1
+
+#def get_common_coordinates(coordinates, level2):
+    #gdp.
+
+def get_near(level2):
+    near = re.search(regex_spatial.get_near_regex(), level2)
+    if near is not None:
+        return near.group()
+    return None 
+
+def get_surrounding(level2):
+    surrounding = re.search(regex_spatial.get_surrounding_regex(), level2)
+    if surrounding is not None:
+        return surrounding.group()
+    return None 
+
+    
+def sort_west(coords1, 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_directional_coordinates_by_angle(coordinates, centroid, direction, minimum, maximum):
+    direction_coordinates = []
+    for p in coordinates:
+        angle = geoutil.calculate_bearing(centroid, p)
+        if direction in geo_level1.east:
+            if angle >= minimum or angle <= maximum:
+                direction_coordinates.append(p)
+                
+        else:
+             if angle >= minimum and angle <= maximum:
+                direction_coordinates.append(p)
+    #if(direction in geo_level1.west):
+    #    direction_coordinates.sort(key=lambda k: k[2], reverse=True)
+   
+    return direction_coordinates 
+
+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 get_level2_coordinates(coordinates, centroid, level_2, level_1):
+    near = get_near(level_2)   
+    surrounding = get_surrounding(level_2)
+    
+    
+    poly1 = Polygon(coordinates)
+    polygon1 = gpd.GeoSeries(poly1)
+    if near is not None:
+        poly2 = polygon1.buffer(0.0095, join_style=2)
+    if surrounding is not None:
+        poly2 = polygon1.buffer(0.012, join_style=2)
+    
+    poly = poly2.difference(polygon1)
+    coords = mapping(poly)["features"][0]["geometry"]["coordinates"]
+    
+    coord = []
+    for c in coords:
+        pol = list(c[::-1])
+        coord.extend(pol)
+        
+    if level_1 is not None and level_1.lower() not in geo_level1.center:
+        coord = get_direction_coordinates(coord, centroid, level_1)
+        if level_1 in geo_level1.west:
+            coord = sort_west(coordinates,poly2, centroid)
+    
+    print("Level 2 Coordinates")
+    for idx, p in enumerate(coord):
+        print(idx, p)
+    
+    return coord, centroid
+
+
+      

geocoder/geo_level3.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Aug  2 12:38:31 2022
+
+@author: syed
+"""
+import regex_spatial
+from utils import geoutil
+import geopandas as gpd
+import pandas as pd
+import re
+from shapely.geometry import Polygon,mapping
+import numpy as np
+from shapely.geometry import Polygon, MultiPoint, LineString, Point
+from shapely.geometry.base import geom_factory
+from shapely.geos import lgeos
+from geocoder import geo_level1
+
+
+
+def get_level3(level3):
+    digits = re.findall('[0-9]+', level3)[0]
+    unit = re.findall('[A-Za-z]+', level3)[0]
+    return digits, unit
+
+
+def get_directional_coordinates_by_angle(coordinates, centroid, direction, minimum, maximum):
+    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 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_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 get_level3_coordinates(coordinates, centroid, level_3, level1):
+    distance, unit = get_level3(level_3)
+    
+    kms = geoutil.get_kilometers(distance, unit)
+    print(distance, unit, kms, 'duk')
+    
+    coord = []
+    
+    poly1 = Polygon(coordinates)
+    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"]        # 改为坐标格式
+    # print(mapping(poly2)["features"][0]["geometry"]["coordinates"], 'cmcm')
+    # print(mapping(poly3)["features"][0]["geometry"]["coordinates"], 'cmcm')
+    # print(coords, 'cmcm')
+
+    
+    for c in coords:
+        pol = list(c[::-1])
+        coord.extend(pol)
+    if level1 is not None:
+        coord = get_direction_coordinates(coord, centroid, level1)
+        if level1 in geo_level1.west:
+            coord = sort_west(poly3, poly2, centroid)
+    print("Level 3 Coordinates")
+    for idx, p in enumerate(coord):
+        print(idx, p)
+    return coord, centroid
+
+
+def get_between_coordinates(coordinates1, coordinates2, centroid1, centroid2):
+    # 创建多边形对象
+    poly1 = Polygon(coordinates1)
+    poly2 = Polygon(coordinates2)
+
+    # 计算中心点连线
+    center_line = LineString([centroid1, centroid2])
+
+    def max_perpendicular_distance(poly, line):
+        max_dist = 0
+        farthest_points = None
+
+        for point in poly.exterior.coords:
+            p = Point(point)
+            # 计算点到中心线的垂直距离
+            dist = p.distance(line)
+            if dist > max_dist:
+                max_dist = dist
+                farthest_points = p
+
+        return max_dist * 2  # 计算直径（双倍最大垂直距离）
+
+    # 计算两个区域的最大垂线距离
+    diameter1 = max_perpendicular_distance(poly1, center_line)
+    diameter2 = max_perpendicular_distance(poly2, center_line)
+
+    # 计算平均直径 R
+    R = (diameter1 + diameter2) / 2
+
+    # 计算圆心（两个中心点的中点）
+    midpoint = ((centroid1[0] + centroid2[0]) / 2, (centroid1[1] + centroid2[1]) / 2)
+
+    # 生成圆形区域
+    circle = Point(midpoint).buffer(R / 2, resolution=100)
+
+    # 获取圆的坐标
+    circle_coords = list(circle.exterior.coords)
+
+    return [circle_coords], midpoint
+
+

geocoder/llm_coding.py

@@ -0,0 +1,46 @@
+import requests
+import urllib3
+import json
+from utils import geoutil
+
+
+
+
+def get_coordinates(ent, ase, level_1, level_2, level_3, midmid):
+    request_url = 'https://nominatim.openstreetmap.org/search.php?q= ' +ase +'&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)
+    # json_content = json.loads(aa)
+    print(json_content, 'jjjjj')
+    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)
+    mid1 = None
+    mid2 = None
+    coordinates = all_coordinates
+    # if level_1 is not None:
+    #
+    #     all_coordinates, centroid, mid1, mid2 = geo_level1.get_level1_coordinates(all_coordinates, centroid, level_1, midmid)
+
+    # if level_2 is not None:
+    #     if level_1 is not None and level_1.lower() not in geo_level1.center:
+    #         all_coordinates, centroid = geo_level2.get_level2_coordinates(coordinates, centroid, level_2, level_1)
+    #     else:
+    #         print ("Else executed")
+    #         all_coordinates, centroid = geo_level2.get_level2_coordinates(all_coordinates, centroid, level_2, level_1)
+
+    if level_3 is not None:
+        all_coordinates, centroid = geo_level3.get_level3_coordinates(coordinates, centroid, level_3, level_1)
+
+    geojson = get_geojson(ent, all_coordinates, centroid)
+
+    return geojson

geocoder/locate_function.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Aug  2 12:38:31 2022
+
+@author: syed
+"""
+import regex_spatial
+from utils import geoutil
+import geopandas as gpd
+import pandas as pd
+import re
+from shapely.geometry import Polygon,mapping
+import numpy as np
+from shapely.geometry import Polygon, MultiPoint, LineString, Point
+from shapely.geometry.base import geom_factory
+from shapely.geos import lgeos
+from geocoder import geo_level1
+
+
+
+
+
+def get_between_coordinates(coordinates1, coordinates2, centroid1, centroid2):
+    # 创建多边形对象
+    poly1 = Polygon(coordinates1)
+    poly2 = Polygon(coordinates2)
+
+    # 计算中心点连线
+    center_line = LineString([centroid1, centroid2])
+
+    def max_perpendicular_distance(poly, line):
+        max_dist = 0
+        farthest_points = None
+
+        for point in poly.exterior.coords:
+            p = Point(point)
+            # 计算点到中心线的垂直距离
+            dist = p.distance(line)
+            if dist > max_dist:
+                max_dist = dist
+                farthest_points = p
+
+        return max_dist * 2  # 计算直径（双倍最大垂直距离）
+
+    # 计算两个区域的最大垂线距离
+    diameter1 = max_perpendicular_distance(poly1, center_line)
+    diameter2 = max_perpendicular_distance(poly2, center_line)
+
+    # 计算平均直径 R
+    R = (diameter1 + diameter2) / 2
+
+    # 计算圆心（两个中心点的中点）
+    midpoint = ((centroid1[0] + centroid2[0]) / 2, (centroid1[1] + centroid2[1]) / 2)
+
+    # 生成圆形区域
+    circle = Point(midpoint).buffer(R / 2, resolution=100)
+
+    # 获取圆的坐标
+    circle_coords = list(circle.exterior.coords)
+
+    return [circle_coords], midpoint
+
+
+
+
+def get_angular_coordinates(coordinates, angle, distance):
+    """
+    计算基于输入地点坐标、方向角度和距离的目标点，并返回以该点为圆心的等面积圆形坐标集。
+    :param coordinates: 地点的边界坐标列表
+    :param angle: 方向角度（以正北为 0 度，顺时针方向）
+    :param distance: 目标点距离（单位：公里）
+    :return: 以目标点为圆心，等面积半径的圆形坐标集
+    """
+    # 计算输入地点的几何中心
+    poly = Polygon(coordinates)
+    poly_center = poly.centroid
+    lat, lon = poly_center.y, poly_center.x  # 纬度在前，经度在后
+
+    # 计算地球上的 1 度经纬度距离（近似值）
+    lat_km = 111.32  # 1 度纬度 ≈ 111.32 km
+    lon_km = 111.32 * np.cos(np.radians(lat))  # 1 度经度 ≈ 111.32 × cos(纬度)
+
+    # 计算输入区域的面积（近似 km²，需进一步优化投影转换）
+    area_degrees = poly.area  # 原始经纬度面积
+    area_km2 = area_degrees * (lat_km * lon_km)  # 近似转换为 km²
+
+    # 计算等面积圆的半径 r（单位 km）
+    r_km = np.sqrt(area_km2 / np.pi)  # 使得 πr² ≈ area_km2
+
+    # 计算方向向量（基于输入角度）
+    angle_rad = np.radians(angle)  # 转换为弧度
+    d_lat = (np.sin(angle_rad) * distance) / lat_km
+    d_lon = (np.cos(angle_rad) * distance) / lon_km
+
+    # 计算目标点
+    target_point = (lon + d_lon, lat + d_lat)
+
+    # 计算以目标点为圆心，半径 r_km 的圆形坐标集
+    circle_points = []
+    for theta in np.linspace(0, 360, num=100):  # 生成 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((target_point[0] + d_lon, target_point[1] + d_lat))
+
+    return circle_points
+
+
+
+
+

geocoder/untitled0.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Sep 21 21:44:47 2022
+
+@author: syed
+"""
+import sys
+
+
+
+
+loc_dict = {"east":"This is east", "west": "This is west", "north":"This is north",
+            "south":"This is south","up":"This is up","down":"This is down",
+            "look":"This is the description", "quit": "To end the game"}
+
+user_input = input("Enter your desired location")
+
+def findLocation(input, loc_dict):
+    if input == "quit":
+        sys.exit(f"End of the game with code{input}!")
+    else:
+        print(loc_dict[input])
+    
+    
+