Cache starmap

Author: befl3

promis/gui/main.py

@@ -315,90 +315,90 @@ def calculate_star_map(req: RunRequest, hash_val: int):
 
     star_map_hash_val = create_hash_starmap(req, dynamic_layer, hash_val)
 
-    # load the cache info
-    #try:
-    #    with open(f"./cache/starmap_{star_map_hash_val}.pickle", 'rb') as f:
-    #        print("found cache star map in starmap")
-    #except FileNotFoundError:
-    # create polar map
+    # Check if StaRMap available
+    try:
+       with open(f"./cache/starmap_{star_map_hash_val}.pickle", 'rb') as f:
+           print(f"found cached StaRMap in file starmap_{star_map_hash_val}.pickle")
+           app.star_map = f
+    except FileNotFoundError:
 
-    # apply uncertainty to all osm fetched map feature
-    loc_type_table = _get_location_type_table()
-    loc_to_uncertainty = dict()
-    for entry in loc_type_table:
-        if entry.std_dev != 0:
-            loc_to_uncertainty[entry.location_type] = (entry.std_dev**2) * eye(2)
+        # apply uncertainty to all osm fetched map feature
+        loc_type_table = _get_location_type_table()
+        loc_to_uncertainty = dict()
+        for entry in loc_type_table:
+            if entry.std_dev != 0:
+                loc_to_uncertainty[entry.location_type] = (entry.std_dev**2) * eye(2)
 
-    carte_map = polar_map.to_cartesian()
-    carte_map.apply_covariance(loc_to_uncertainty)
+        carte_map = polar_map.to_cartesian()
+        carte_map.apply_covariance(loc_to_uncertainty)
 
-    polar_map = carte_map.to_polar()
+        polar_map = carte_map.to_polar()
 
-    # create all markers, lines and polygons to uam
-    for marker in markers:
-        if marker.location_type == "":
-            continue
+        # create all markers, lines and polygons to uam
+        for marker in markers:
+            if marker.location_type == "":
+                continue
 
-        polar_marker = PolarLocation(marker.latlng[1],
-                                        marker.latlng[0],
-                                        location_type=marker.location_type)
-        if marker.std_dev != 0:
-            cartesian_marker = polar_marker.to_cartesian(origin)
-            cartesian_marker.covariance = (marker.std_dev**2) * eye(2)
-            polar_marker = cartesian_marker.to_polar(origin)
+            polar_marker = PolarLocation(marker.latlng[1],
+                                            marker.latlng[0],
+                                            location_type=marker.location_type)
+            if marker.std_dev != 0:
+                cartesian_marker = polar_marker.to_cartesian(origin)
+                cartesian_marker.covariance = (marker.std_dev**2) * eye(2)
+                polar_marker = cartesian_marker.to_polar(origin)
 
-        polar_map.features.append(polar_marker)
+            polar_map.features.append(polar_marker)
 
-    for polyline in polylines:
-        if polyline.location_type == "":
-            continue
-        locations = []
-        for location in polyline.latlngs:
-            locations.append(PolarLocation(location[1], location[0]))
+        for polyline in polylines:
+            if polyline.location_type == "":
+                continue
+            locations = []
+            for location in polyline.latlngs:
+                locations.append(PolarLocation(location[1], location[0]))
 
-        polyline_feature = PolarPolyLine(locations, location_type=polyline.location_type)
+            polyline_feature = PolarPolyLine(locations, location_type=polyline.location_type)
 
-        if polyline.std_dev != 0:
-            cartesian_polyline = polyline_feature.to_cartesian(origin)
-            cartesian_polyline.covariance = (polyline.std_dev**2) * eye(2)
-            polyline_feature = cartesian_polyline.to_polar(origin)
+            if polyline.std_dev != 0:
+                cartesian_polyline = polyline_feature.to_cartesian(origin)
+                cartesian_polyline.covariance = (polyline.std_dev**2) * eye(2)
+                polyline_feature = cartesian_polyline.to_polar(origin)
 
-        polar_map.features.append(polyline_feature)
+            polar_map.features.append(polyline_feature)
 
-    for polygon in polygons:
-        if polygon.location_type == "":
-            continue
-        locations = []
-        for location in polygon.latlngs:
-            locations.append(PolarLocation(location[1], location[0]))
+        for polygon in polygons:
+            if polygon.location_type == "":
+                continue
+            locations = []
+            for location in polygon.latlngs:
+                locations.append(PolarLocation(location[1], location[0]))
 
-        polygon_feature = PolarPolygon(locations, location_type=polygon.location_type)
+            polygon_feature = PolarPolygon(locations, location_type=polygon.location_type)
 
-        if polygon.std_dev != 0:
-            cartesian_polygon = polygon_feature.to_cartesian(origin)
-            cartesian_polygon.covariance = (polygon.std_dev**2) * eye(2)
-            polygon_feature = cartesian_polygon.to_polar(origin)
+            if polygon.std_dev != 0:
+                cartesian_polygon = polygon_feature.to_cartesian(origin)
+                cartesian_polygon.covariance = (polygon.std_dev**2) * eye(2)
+                polygon_feature = cartesian_polygon.to_polar(origin)
 
-        polar_map.features.append(polygon_feature)
+            polar_map.features.append(polygon_feature)
 
 
-    uam = polar_map.to_cartesian()
+        uam = polar_map.to_cartesian()
 
-    # Setting up the probabilistic spatial relations from the UAM
-    star_map = StaRMap(uam)
+        # Setting up the probabilistic spatial relations from the UAM
+        star_map = StaRMap(uam)
 
-    # Initializing the StaR Map on a raster of points evenly spaced out across the mission area,
-    # sampling 25 random variants of the UAM for estimating the spatial relation parameters
-    support_resolutions = req.support_resolutions
-    evaluation_points = CartesianRasterBand(origin, support_resolutions, width, height)
+        # Initializing the StaR Map on a raster of points evenly spaced out across the mission area,
+        # sampling 25 random variants of the UAM for estimating the spatial relation parameters
+        support_resolutions = req.support_resolutions
+        evaluation_points = CartesianRasterBand(origin, support_resolutions, width, height)
 
-    star_map.initialize(evaluation_points, sample_size, logic)
+        star_map.initialize(evaluation_points, sample_size, logic)
 
-    # origin, width, height, num_iteration, num_improvement
+        # origin, width, height, num_iteration, num_improvement
 
-    #star_map.save(f"./cache/starmap_{star_map_hash_val}.pickle")
+        star_map.save(f"./cache/starmap_{star_map_hash_val}.pickle")
 
-    app.star_map = star_map
+        app.star_map = star_map
 
     return star_map_hash_val