added axis

Axis.py

@@ -0,0 +1,191 @@
+import cv2
+import numpy as np
+from Map import MapIn, CVLineThickness
+import random
+import config
+
+class AxisFinder:
+    clicked_points = []
+    def __init__(self,map:MapIn) -> None:
+        self.map = map
+        self.axis_res = []
+        
+    """
+        opencv click callback for customized axis drawing
+    """
+    def click_callback(event, x, y, flags, params):
+        if event == cv2.EVENT_LBUTTONDOWN:
+            config.log(f"Clicked Y:{y}, X:{x}")
+            AxisFinder.clicked_points.append((y,x))
+
+    """
+        parts parcel number divider based on area of
+        parts. omits fixed facility areas
+    """
+    def cal_split_parcels(u_map:MapIn,d_map:MapIn,parcels_cnt:int):
+        u_ff_area = np.sum(u_map.facility_filled_mask)/255
+        u_block_area = np.sum(u_map.block_mask)/255
+        u_area = u_block_area - u_ff_area
+        d_ff_area = np.sum(d_map.facility_filled_mask)/255
+        d_block_area = np.sum(d_map.block_mask)/255
+        d_area = d_block_area - d_ff_area
+        t_area = u_area+d_area
+
+        precnt = u_area/t_area
+        u_parcels = int(parcels_cnt*precnt)
+        d_parcels = parcels_cnt - u_parcels
+        return (u_parcels,d_parcels)
+    """
+        sort results by best fitness
+    """
+    def sort_fitness(self,sub_li):
+            return sub_li.sort(key = lambda x: x[0])
+
+    """
+        calculates access balance ratio with the provided up&down masks
+        max value of fitness is 1
+    """
+    def cal_access_split_fitness(self,access_mask:np.ndarray,up_mask:np.ndarray,down_mask:np.ndarray):
+        img = access_mask
+        # calculate access ratio
+        up_sum_mask = up_mask & img
+        down_sum_mask = down_mask & img
+
+        sum_up_access = np.sum(up_sum_mask)/255
+        sum_down_access = np.sum(down_sum_mask)/255
+        return 1 - (abs(sum_up_access-sum_down_access)/(np.sum(img)/255))
+    """
+        calculates area balance ratio with provided up&down masks
+        max value of fitness is 1
+    """
+    def cal_area_split_fitness(self,block_mask:np.ndarray,up_mask:np.ndarray,down_mask:np.ndarray):
+        imgray = block_mask
+        up_area = up_mask & imgray
+        down_area = down_mask & imgray
+        sum_up_area = np.sum(up_area)/255
+        sum_down_area = np.sum(down_area)/255
+        return 1 - (abs(sum_up_area-sum_down_area)/(np.sum(imgray)/255))
+    """
+        calculates fixed facility hit
+        best answer is 1
+    """
+    def cal_fixed_facilities_fitness(self,facility_mask:np.ndarray,p0:tuple,p1:tuple):
+        imgray = facility_mask
+        plain = np.zeros((imgray.shape))
+        thickness = self.map.roud_thickness + self.map.facility_safe_dist
+        # input points are (y,x)->(x,y)
+        plain = cv2.line(plain,(p0[1],p0[0]),(p1[1],p1[0]),255,CVLineThickness.thickness_solver(thickness))
+        collision = plain.astype(np.uint8) & imgray
+        max_collision = np.sum(imgray)/255
+        if max_collision == 0: return 1
+        collision = np.sum(collision)/255
+        return 1 - (collision/max_collision)
+    """
+        calculates cut trees with given points
+        no cut tree = 1
+    """
+    def cal_carbon_fitness(self,tree_mask:np.ndarray,p0:tuple,p1:tuple):
+        mask = tree_mask
+        plain = np.zeros((mask.shape))
+        thickness = self.map.roud_thickness + self.map.tree_safe_dist
+        # input points are (y,x)->(x,y)
+        plain = cv2.line(plain,(p0[1],p0[0]),(p1[1],p1[0]),255,CVLineThickness.thickness_solver(thickness))
+        collision = plain.astype(np.uint8) & mask
+        # frame must be preprocessed
+        max_carbon = np.sum(mask)
+        if max_carbon == 0: return (1,0)
+        return (1-(np.sum(mask[collision>0])/max_carbon),len(mask[collision>0]))
+    """
+        axis finding fitness function
+    """
+    def fitness_axis(self,solution:tuple,mymap:MapIn,center:tuple):
+        # solution is y,x of one point
+        # other point is the center
+        y_max = mymap.frame_shape[0]-1
+        x_max = mymap.frame_shape[1]-1
+        # slope = inf, x=const
+        if solution[1]==center[1]:
+            point0 = (0,center[1])
+            point1 = (y_max,center[1])
+        # slope = zero, y=const
+        elif solution[0]==center[0]:
+            point0 = (center[0],0)
+            point1 = (center[0],x_max)
+        # normal line
+        else:
+            slope = (solution[0]-center[0])/(solution[1]-center[1]) 
+            intercept = center[0] - (slope*center[1])
+            point0 = (int(intercept),0)
+            point1 = (int((slope*x_max)+intercept),x_max)
+
+        # config.log(point1,point0)
+        up_mask,down_mask = mymap.line_split_mask_maker(point0,point1)
+        access_split_fitness = self.cal_access_split_fitness(mymap.access_mask,up_mask,down_mask)
+        area_split_fitness = self.cal_area_split_fitness(mymap.block_mask,up_mask,down_mask)
+        fixed_facilities_fitness = self.cal_fixed_facilities_fitness(mymap.fixed_f_mask,point0,point1)
+        carbon_fitness = self.cal_carbon_fitness(mymap.trees_mask,point0,point1)
+
+        # config.log(solution,slope,intercept,point0,point1)
+        weights = config.A_ACCESS_SPLIT_WEIGHT + config.A_AREA_SPLIT_WEIGHT + config.A_FIXED_FACILITIES_WEIGHT + config.A_CARBON_WEIGHT
+        score = (config.A_ACCESS_SPLIT_WEIGHT * access_split_fitness + config.A_AREA_SPLIT_WEIGHT * area_split_fitness + 
+         config.A_FIXED_FACILITIES_WEIGHT * fixed_facilities_fitness + config.A_CARBON_WEIGHT * carbon_fitness[0])
+
+        # scale score between (0,1]
+        if fixed_facilities_fitness != 1:
+            return (-1,point0,point1)
+        return (score/weights,point0,point1,solution,center,[access_split_fitness,area_split_fitness,fixed_facilities_fitness,carbon_fitness])
+    """
+        iterate through all border pixels and
+        draw line on start_point to border
+        finding best line (for the first step of axis finding only)
+    """
+    def iterate_throughall(self,mymap:MapIn, start_point=None):
+        borders_access = []
+        if start_point != None:
+            borders_access = [start_point]
+        else:
+            borders_access = mymap.access_mask
+            borders_access = np.asarray(np.where(borders_access==255))
+            borders_access = list(zip(borders_access[0], borders_access[1]))
+        
+        borders_random = mymap.boundry_mask
+        borders_random = np.asarray(np.where(borders_random==255))
+        borders_random = list(zip(borders_random[0], borders_random[1]))
+        borders_random = random.sample(borders_random, int(len(borders_random)*0.4))
+
+        res = []
+        for pixel in borders_access:
+            for second_point in borders_random:
+                if np.linalg.norm(np.asarray(pixel)-np.asarray(second_point)) > config.VALID_POINT_DISTANCE:
+                    res.append(self.fitness_axis(pixel,mymap,second_point))
+        self.sort_fitness(res)
+        self.axis_res = res[-10:]
+        return res[-10:]
+    
+    """
+        iterate over old boundries (without division line)
+        and find best line for New York design
+    """
+    def iterate_old_boundries_new_york(self):
+        res = []
+        last_axis_points = self.map.line_points
+        boundary = self.map.old_boundry_mask
+        boundary = np.asarray(np.where(boundary==255))
+        boundary = list(zip(boundary[0], boundary[1]))
+        # cal perpendicular center (pixelhit line)
+        for pixel in boundary:
+            y1, x1 = last_axis_points[0]
+            y2, x2 = last_axis_points[1] 
+            y3, x3 = pixel
+            px, py = (x2-x1,y2-y1)
+            dAB = px*px + py*py
+            u = ((x3 - x1) * px + (y3 - y1) * py) / dAB
+            # (y,x)
+            ppcenter = (int(y1 + u * py),int(x1 + u * px))
+            
+            if np.linalg.norm(np.asarray(pixel)-np.asarray(ppcenter)) > config.VALID_POINT_DISTANCE:
+                res.append(self.fitness_axis(pixel,self.map,ppcenter))
+        
+        self.sort_fitness(res)
+        self.axis_res = res[-10:]
+        return res[-10:]

axis_finder.py

@@ -1,7 +1,6 @@
 from Map import MapIn,MapOut
 from Axis import AxisFinder
 import cv2
-import pickle
 import config
 import time
 
@@ -110,11 +109,6 @@ def run_axis_finder(total_execution_time):
     # sort maps by size
     maps_list.sort(key=lambda x: x.curr_size,reverse=True)
     cv2.destroyAllWindows()
-    # save maps
-    with open('outputs/maps_list.pickle', 'wb') as f:
-        pickle.dump(maps_list, f)
-    with open('outputs/lines_list.pickle', 'wb') as f:
-        pickle.dump(lines_list, f)
 
     # export split result
     config.log(f"------Axis Result------")
@@ -122,9 +116,6 @@ def run_axis_finder(total_execution_time):
     export_map.draw_axis()
     export_map.draw_collision()
     export_map.report()
-    # save
-    with open('outputs/export_map.pickle', 'wb') as f:
-        pickle.dump(export_map, f)
 
     config.log("--- Axis Finder Finished In %s seconds ---" % (time.time() - start_time))
     total_execution_time += time.time() - start_time

requirements.txt

@@ -1,6 +1,5 @@
 numpy
 pandas
 opencv-python
-pickle
 pygad
 sympy