Added parameters for grid size & resolution

Author: daniel-stoneuk

TapWork.py

@@ -30,7 +30,7 @@ def get_taps_demand(taps,houses):
                 lowest_distance = tap_dist
                 house_tap = taps.index(tap)
         # weight the distance^2 by the size to give a score
-        houses_tap.append((house_tap,(lowest_distance**4)*(house[0]**2)))
+        houses_tap.append((house_tap,((lowest_distance**4)*(house[0]**2))/ 10000))
 
     for tap in houses_tap:
         tap_demand[tap[0]]+=tap[1]
@@ -51,7 +51,7 @@ def total_demand(tap_demands):
         total+=tap
     return total
 
-def draw_network(houses,taps,image, display = True):
+def draw_network(houses,taps, size, image, meters_squared_per_pixel):
 
     plt.clf()
 
@@ -73,7 +73,7 @@ def draw_network(houses,taps,image, display = True):
         pos[i]=(taps[i][0],taps[i][1])
         names[i]= str((i + 1))
 
-    nx.draw_networkx(g, pos=pos, names=names, node_color='b',node_size=120, font_size=10, font_color='w')
+    nx.draw_networkx(g, pos=pos, labels=names, node_color='b',node_size=120, font_size=10, font_color='w')
 
     image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
     fig1 = plt.gcf()
@@ -89,7 +89,6 @@ def draw_network(houses,taps,image, display = True):
     img = cv2.cvtColor(img,cv2.COLOR_RGB2BGR)
 
     crop_img = img[5:455, 94:544]
-    # cv2.imwrite("figureTaps.png",crop_img)
     return crop_img
 
 def total(demands):
@@ -100,9 +99,7 @@ def total(demands):
 
 def greedy_brute(houses,amount_of_taps,grid_size, downscale):
     total_tick = (amount_of_taps*grid_size[0]*grid_size[1]) / (downscale**2)
-    happy_taps = []
     stored_taps = []
-    possible_coords = []
 
     with tqdm(total=total_tick) as t:
         for tap_placed in range(amount_of_taps):
@@ -111,7 +108,7 @@ def greedy_brute(houses,amount_of_taps,grid_size, downscale):
             for x in range(grid_size[0] + 1):
                 for y in range(grid_size[1] + 1):
                     if (x % downscale == 0 and y % downscale == 0):
-                        coord = (x, y);
+                        coord = (x, y)
                         t.update(1)
                         taps = list(copy.copy(stored_taps))
                         taps.append(coord)
@@ -126,4 +123,5 @@ def greedy_brute(houses,amount_of_taps,grid_size, downscale):
                             best_tap = coord
                             min_total_differnces = total_differnce
             stored_taps.append(best_tap)
+    print(stored_taps)
     return stored_taps

api.py

@@ -15,14 +15,13 @@ def toBase64(image):
     png_as_text = base64.b64encode(buffer).decode('utf-8')
     return png_as_text
 
-def process(image, max_size=200,taps=3, downscale=10):
-    resized_image = resize.resize(image,max_size)
-    height, width, _ = resized_image.shape
-    recoloured_image = recolour.find_silver(resized_image)
-    houses, percentage, housearea = contours.get_contour_nodes(recoloured_image)
-    print(downscale)
+def process(image, meters_squared_per_pixel, size ,taps=3, grid=20):
+    downscale = int(size / grid)
+    height, width, _ = image.shape
+    recoloured_image = recolour.find_silver(image)
+    houses, percentage, housearea = contours.get_contour_nodes(recoloured_image, meters_squared_per_pixel)
     tap_locations = TapWork.greedy_brute(houses,taps,(height,width), downscale)
-    image = TapWork.draw_network(houses,tap_locations,resized_image, (height,width)) 
+    image = TapWork.draw_network(houses,tap_locations, size, image, meters_squared_per_pixel) 
     population = round(housearea / 7)
     recommendation = round(population / 250)
     if recommendation == 0:
@@ -33,9 +32,9 @@ def process(image, max_size=200,taps=3, downscale=10):
 def giveLocation():
     lon = request.args.get('long')
     lat = request.args.get('lat')
-    max_size = request.args.get('size')
+    size = request.args.get('size')
     taps = request.args.get('taps')
-    downscale = request.args.get('downscale')
+    grid = request.args.get('grid')
     zoom = request.args.get('zoom')
     print(lon,lat)
     if lon is None or lat is None:
@@ -44,19 +43,16 @@ def giveLocation():
         return response
     if zoom is None:
         zoom = 19
-    image = map_downloader.download_patch((lat,lon), credentials.API_KEY, zoom=int(zoom))
-    image_array = numpy.asarray(bytearray(image.content), dtype=numpy.uint8)
-    map_image = cv2.imdecode(image_array, -1)
-    if max_size is not None and taps is not None and downscale is not None:
-        result = process(map_image, max_size=int(max_size),taps=int(taps), downscale=int(downscale))
-    elif max_size is not None and taps is not None:
-        result = process(map_image, max_size=int(max_size),taps=int(taps))
-    elif max_size is not None: 
-        result = process(map_image, max_size=int(max_size))
+    if size is None:
+        size = 1000
+
+    map_image, meters_squared_per_pixel = map_downloader.download_patch((lat,lon), credentials.API_KEY, size, zoom=int(zoom))
+    if size is not None and taps is not None and grid is not None:
+        result = process(map_image, meters_squared_per_pixel, int(size),taps=int(taps), grid=int(grid))
     elif taps is not None:
-        result = process(map_image, taps=taps)
+        result = process(map_image, meters_squared_per_pixel, int(size), taps=int(taps))
     else:
-        result = process(map_image)
+        result = process(map_image, meters_squared_per_pixel, int(size))
 
     return jsonify(result)
 

contours.py

@@ -3,15 +3,13 @@
 import cv2
 
 # construct the argument parse and parse the arguments
-def get_contour_nodes(image):
+def get_contour_nodes(image, meters_squared_per_pixel):
     # Total area is 83,321 m^2
     height, width = image.shape
     totalpixels = height * width
 
     print(height, width)
 
-    areaperpixel = 83321 / totalpixels
-
     # gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
     # blurred = cv2.GaussianBlur(gray, (5, 5), 0)
     # thresh = cv2.threshold(blurred, 60, 255, cv2.THRESH_BINARY)[1]
@@ -30,15 +28,15 @@ def get_contour_nodes(image):
         # compute the center of the contour
         try:
             # consider buildings greater than 8m^2
-            if cv2.contourArea(c) * areaperpixel > 8:
+            if cv2.contourArea(c) * meters_squared_per_pixel >10:
                 M = cv2.moments(c)
                 cX = round(M["m10"] / M["m00"])
                 cY = round(M["m01"] / M["m00"])
-                totalarea += cv2.contourArea(c) * areaperpixel
-                nodes.append([cv2.contourArea(c) * areaperpixel, [cX, cY]])
+                totalarea += cv2.contourArea(c) * meters_squared_per_pixel
+                nodes.append([cv2.contourArea(c) * meters_squared_per_pixel, [cX, cY]])
         except:
             pass
 
     print("average {}".format(totalarea / len(cnts)))
-    percentage = round((totalarea / (totalpixels * areaperpixel)) * 100)
+    percentage = round((totalarea / (totalpixels * meters_squared_per_pixel)) * 100)
     return nodes, percentage, totalarea

map_downloader.py

@@ -1,13 +1,26 @@
 import requests
+import math
+import numpy
+import cv2
 
-def download_patch(lat_long,api_key,zoom=19,dimensions=(1000,1000),file_format='png'):
+def download_patch(lat_long,api_key, size, zoom=19,file_format='png'):
     latitude, longitude = lat_long
-    x, y = dimensions
+    extra = 100
+    x, y = size, str((int(size) + extra))
     URL = ('https://dev.virtualearth.net/REST/v1/Imagery/Map/Aerial/{},{}/'
             '{}?mapSize={},{}&format={}').format(latitude,longitude,zoom,x,y,file_format)
-    print("Downloading the map from {}".format(URL))
+    print("Downloading the map from {}&key={}".format(URL, api_key))
     image = requests.get(("{}&key={}").format(URL, api_key))
+
+    meters_squared_per_pixel = (156543.04 * math.cos(math.radians(float(latitude))) / (2**zoom))**2
+    print("Meters squared per pixel: {} ".format(str(meters_squared_per_pixel)))
     # metadata = requests.get(("{}&mapMetadata=1&key={}").format(URL, api_key))
 #     boundingbox = metadata.json()["resourceSets"][0]["resources"][0]["bbox"]
     # print(metadata.text);
-    return image
+
+    image_array = numpy.asarray(bytearray(image.content), dtype=numpy.uint8)
+    map_image = cv2.imdecode(image_array, -1)
+
+    # Crop
+    map_image = map_image[0:int(size), 0:int(size)]
+    return map_image, meters_squared_per_pixel