Merge pull request #4 from stocc/moving-v0

Moving v0

Author: stocc

.gitignore

@@ -90,4 +90,5 @@ ENV/
 
 .idea/
 
-.venv/
+.venv/
+.vl/

app.py

@@ -13,7 +13,7 @@
 
 from lookaround.lookaround.auth import Authenticator
 from lookaround.lookaround.geo import wgs84_to_tile_coord
-from lookaround.lookaround import get_coverage_tile, fetch_pano_segment, get_pano_segment_url
+from lookaround.lookaround import _get_coverage_tile_raw_json, get_coverage_tile, fetch_pano_segment, get_pano_segment_url
 
 from util import CustomJSONEncoder
 from geo import haversine_distance
@@ -70,7 +70,7 @@ def relay_road_tile(tint, z, x, y):
         url = auth.authenticate_url(
             f"https://cdn3.apple-mapkit.com/ti/tile?style=0&size=1&x={x}&y={y}&z={z}&scale=1&lang=en"
             f"&poi=1&tint={tint_param}&emphasis=standard")
-        print(url)
+        #print(url)
         response = requests.get(url)
         return send_file(
             io.BytesIO(response.content),
@@ -91,7 +91,32 @@ def closest_pano_to_coord(lat, lon):
             if distance < smallest_distance:
                 smallest_distance = distance
                 closest = pano
-        return jsonify(closest)
+                #print(x,y)
+        return jsonify(date=closest.date,lat = closest.lat, lon = closest.lon, panoid = str(closest.panoid), region_id = str(closest.region_id), unknown10 = closest.unknown10, unknown11 = closest.unknown11, heading = closest.heading)
+
+
+
+    @app.route("/tile/<float(signed=True):lat>/<float(signed=True):lon>/")
+    def tile_of_coord(lat, lon):
+        x, y = wgs84_to_tile_coord(lat, lon, 17)
+        
+        return jsonify(x=x,y=y)
+
+    @app.route("/rawtile/<int:x>/<int:y>/")
+    def rawtile(x, y):
+        panos = _get_coverage_tile_raw_json(x, y)
+        
+        return panos
+
+    @app.route("/fullTileInfo/<int:x>/<int:y>/")
+    def full_tile_coverage_incl_neighbors(x, y):
+        panos = get_coverage_tile(x, y)
+        #print(panos)
+        if len(panos) == 0:
+            return jsonify(None)
+
+        return jsonify(panos)
+
 
     @app.route("/pano/<int:panoid>/<int:region_id>/<int:zoom>/")
     def relay_full_pano(panoid, region_id, zoom):
@@ -104,7 +129,6 @@ def relay_full_pano(panoid, region_id, zoom):
                 image = None
 
         TILE_SIZE = round(heic_array[0].width * (256 / 5632))
-        print("TILE_SIZE:", TILE_SIZE)
         WIDTH_SIZE = round(heic_array[0].width * (1024 / 5632))
         widths, heights = zip(*(i.size for i in heic_array))
         total_width, max_height = (sum(widths)-WIDTH_SIZE), max(heights)
@@ -128,7 +152,6 @@ def relay_full_pano(panoid, region_id, zoom):
 
     @app.route("/panodbg/<int:panoid>/<int:region_id>/<int:zoom>/")
     def relay_pano_dbg(panoid, region_id, zoom):
-        print("Starting")
         heic_array = []
         for i in range(4):
             heic_bytes = fetch_pano_segment(panoid, region_id, i, zoom, auth)

lookaround/lookaround/__init__.py

@@ -2,39 +2,57 @@
 import requests
 
 from .proto import MapTile_pb2
-from .geo import wgs84_to_tile_coord
+from .geo import wgs84_to_tile_coord, heading_from_unkown10_unknown11
 from .panorama import LookaroundPanorama
 
+from google.protobuf.json_format import MessageToJson
 
-def get_coverage_tile_by_latlon(lat, lon):
-    x, y = wgs84_to_tile_coord(lat, lon, 17)
+
+def get_coverage_tile_by_latlon(lat, lon, tile_z = 17):
+    x, y = wgs84_to_tile_coord(lat, lon, tile_z)
     return get_coverage_tile(x, y)
 
 
-def get_coverage_tile(tile_x, tile_y):
-    tile = _get_coverage_tile_raw(tile_x, tile_y)
+def get_coverage_tile(tile_x, tile_y, tile_z = 17):
+    tile = _get_coverage_tile_raw(tile_x, tile_y, tile_z)
     panos = []
     for pano in tile.pano:
         lat, lon = geo.protobuf_tile_offset_to_wgs84(
             pano.unknown4.longitude_offset,
             pano.unknown4.latitude_offset,
             tile_x,
-            tile_y)
+            tile_y,
+            tile_z
+            )
         pano_obj = LookaroundPanorama(
             pano.panoid,
             tile.unknown13[pano.region_id_idx].region_id,
-            lat, lon)
+            lat, lon, pano.unknown4.unknown10, pano.unknown4.unknown11, heading_from_unkown10_unknown11(pano.unknown4.unknown10, pano.unknown4.unknown11))
         pano_obj.date = datetime.fromtimestamp(int(pano.timestamp) / 1000.0)
         panos.append(pano_obj)
     return panos
 
 
-def _get_coverage_tile_raw(tile_x, tile_y):
+def _get_coverage_tile_raw_json(tile_x, tile_y, tile_z = 17):
+    headers = {
+        "maps-tile-style": "style=57&size=2&scale=0&v=0&preflight=2",
+        "maps-tile-x": str(tile_x),
+        "maps-tile-y": str(tile_y),
+        "maps-tile-z": str(tile_z),
+        "maps-auth-token": "w31CPGRO/n7BsFPh8X7kZnFG0LDj9pAuR8nTtH3xhH8=",
+    }
+    response = requests.get("https://gspe76-ssl.ls.apple.com/api/tile?", headers=headers)
+    tile = MapTile_pb2.MapTile()
+    tile.ParseFromString(response.content)
+    json_obj = MessageToJson(tile)
+    return json_obj
+    
+def _get_coverage_tile_raw(tile_x, tile_y, tile_z = 17):
     headers = {
         "maps-tile-style": "style=57&size=2&scale=0&v=0&preflight=2",
         "maps-tile-x": str(tile_x),
         "maps-tile-y": str(tile_y),
-        "maps-tile-z": "17",
+        "maps-tile-z": str(tile_z),
         "maps-auth-token": "w31CPGRO/n7BsFPh8X7kZnFG0LDj9pAuR8nTtH3xhH8=",
     }
     response = requests.get("https://gspe76-ssl.ls.apple.com/api/tile?", headers=headers)
@@ -63,7 +81,7 @@ def get_pano_segment_url(panoid, region_id, segment, zoom, auth):
 
     url = endpoint + f"{panoid_url}/{region_id_padded}/t/{segment}/{zoom}"
     url = auth.authenticate_url(url)
-    print(url)
+    #print(url)
     return url
 
 

lookaround/lookaround/geo.py

@@ -4,7 +4,7 @@
 TILE_SIZE = 256
 
 
-def protobuf_tile_offset_to_wgs84(x_offset, y_offset, tile_x, tile_y):
+def protobuf_tile_offset_to_wgs84(x_offset, y_offset, tile_x, tile_y, tile_z = 17):
     """
     Calculates the absolute position of a pano from the tile offsets returned by the API.
     :param x_offset: The X coordinate of the raw tile offset returned by the API.
@@ -15,7 +15,7 @@ def protobuf_tile_offset_to_wgs84(x_offset, y_offset, tile_x, tile_y):
     """
     pano_x = tile_x + (x_offset / 64.0) / (TILE_SIZE - 1)
     pano_y = tile_y + (255 - (y_offset / 64.0)) / (TILE_SIZE - 1)
-    lat, lon = tile_coord_to_wgs84(pano_x, pano_y, 17)
+    lat, lon = tile_coord_to_wgs84(pano_x, pano_y, tile_z)
     return lat, lon
 
 
@@ -48,3 +48,52 @@ def tile_coord_to_wgs84(x, y, zoom):
     world_coord = (pixel_coord[0] / scale, pixel_coord[1] / scale)
     lat_lon = mercator_to_wgs84(world_coord[0], world_coord[1])
     return lat_lon
+
+
+
+'''
+Approximate heading of the panorama, assuming the POV is facing 
+to the left of the Apple Car in cthe direction of driving.
+'''
+def heading_from_unkown10_unknown11(unknown10, unknown11):
+    # Whatever is the logic behind this? 
+    # Who at Apple thought of these values? 
+
+    # unknown10
+    # These are the extreme values of unkown10 I have observed in a random selection of about 1000 tiles.
+    # The values are in two clusters. 
+    # In the range [1,2159] you're looking more west than east.
+    # In the range [14318,16383] you're looking more east than west.
+    westmin = 1
+    westmax = 2159
+    eastmin = 16383 # looking (north/south) and very slightly east
+    eastmax = 14318 # looking slightly (north/south) directly east
+
+    # unknown11
+    # This is slightly more speculative
+    northmin = 8204 # this is likely lower
+    northmax = 6054
+    southmin = 8204 # this is likely lower
+    southmax = 10173
+
+
+    ew=0
+    if unknown10 < westmax:
+        # Looking west
+        ew = -(float(unknown10 - westmin) / float(westmax - westmin))
+    elif unknown10 > eastmax:
+        # Looking east
+        ew = (float(unknown10 - eastmin) / float(eastmax - eastmin))
+
+    ns=0
+    if unknown11 <= northmin:
+        # Looking north
+        ns = (float(unknown11 - northmin) / float(northmax - northmin))
+    else:
+        ns = -(float(unknown11 - southmin) / float(southmax - southmin))
+
+
+    r =  math.degrees(math.atan2(ew,ns))
+    if r < 0:
+        r += 360
+    return r

lookaround/lookaround/panorama.py

@@ -1,15 +1,19 @@
 class LookaroundPanorama:
-    def __init__(self, panoid, region_id, lat, lon):
+    def __init__(self, panoid, region_id, lat, lon, unknown10, unknown11, heading):
         self.panoid = panoid
         self.region_id = region_id
         self.lat = lat
         self.lon = lon
-
+        self.unknown10 = unknown10
+        self.unknown11 = unknown11
         self.date = None
+        self.heading = heading
+
+
 
     def __repr__(self):
         return str(self)
 
     def __str__(self):
-        return f"{self.panoid}/{self.region_id} ({self.lat:.6}, {self.lon:.6}) " \
+        return f"{self.panoid}/{self.region_id} ({self.lat:.6}, {self.lon:.6}) {self.heading}" \
                f"[{self.date.strftime('%Y-%m-%d')}]"

reverse_engineering/analyzeheading.py

@@ -0,0 +1,48 @@
+import json, numpy
+from matplotlib import pyplot as plt
+
+unknown_10s = {}
+unknown_11s = {}
+
+for fn in ["eastwestAutobahn.json"]: #, "eow.json"]:
+
+    with open(fn, "r") as f:
+        # import as json
+        panos = json.load(f)["pano"]
+
+    u10 = []
+    u11 = []
+    for p in panos:
+        try:
+            u10.append(p["unknown4"]["unknown10"])
+            u11.append(p["unknown4"]["unknown11"])
+        except:
+            print(p)
+    unknown_10s[fn] = u10
+    unknown_11s[fn] = u11
+
+
+#print(min(unknown_10s["random.json"]), max(unknown_10s["random.json"]))
+#print(min(unknown_11s["random.json"]), max(unknown_11s["random.json"]))
+
+plt.figure(figsize=(20,10))
+plt.subplot(2,1,1)
+plt.title("unknown10")
+#plt.hlines(1,1,20)  # Draw a horizontal line
+colors=["red", "blue", "green", "black"]
+i = 0
+for k,v in unknown_10s.items():
+    plt.eventplot(v, label=k, orientation='horizontal', colors=colors[i], linewidths=0.1)
+    i += 1
+plt.legend()
+#plt.axis('off')
+plt.subplot(2,1,2)
+plt.title("unknown11")
+#plt.hlines(1,1,20)  # Draw a horizontal line
+i = 0
+for k,v in unknown_11s.items():
+    plt.eventplot(v, label=k, orientation='horizontal', colors=colors[i], linewidths=0.1)
+    i += 1
+plt.legend()
+#plt.axis('off')
+plt.show()

reverse_engineering/analyzerandom.py

@@ -0,0 +1,49 @@
+import json, numpy
+from matplotlib import pyplot as plt
+
+unknown_10s = {}
+unknown_11s = {}
+
+for fn in ["random.json"]: #, "eow.json"]:
+
+    with open(fn, "r") as f:
+        # import as json
+        panos = json.load(f)#["pano"]
+
+    u10 = []
+    u11 = []
+    for p in panos:
+        try:
+            u10.append(p["unknown4"]["unknown10"])
+            u11.append(p["unknown4"]["unknown11"])
+        except:
+            print(p)
+    unknown_10s[fn] = u10
+    unknown_11s[fn] = u11
+
+
+print(min(unknown_10s["random.json"]), max(unknown_10s["random.json"]))
+print(min(unknown_11s["random.json"]), max(unknown_11s["random.json"]))
+
+plt.figure(figsize=(20,10))
+plt.subplot(2,1,1)
+plt.title("unknown10")
+#plt.hlines(1,1,20)  # Draw a horizontal line
+colors=["red", "blue", "green", "black"]
+i = 0
+for k,v in unknown_10s.items():
+    plt.eventplot(v, label=k, orientation='horizontal', colors=colors[i], linewidths=0.1)
+    i += 1
+plt.legend()
+#plt.axis('off')
+plt.subplot(2,1,2)
+plt.title("unknown11")
+#plt.hlines(1,1,20)  # Draw a horizontal line
+i = 0
+for k,v in unknown_11s.items():
+    plt.eventplot(v, label=k, orientation='horizontal', colors=colors[i], linewidths=0.1)
+    i += 1
+plt.legend()
+#plt.axis('off')
+plt.show()
+print(numpy.average(unknown_10s["random.json"]))