First try

Map.py

@@ -0,0 +1,493 @@
+import cv2
+import numpy as np
+import pandas as pd
+import random
+from functools import singledispatchmethod
+import math
+import os
+
+from sympy import false
+import config
+
+class MapIn:
+    # thickness configs
+    tree_safe_dist = config.TREE_SAFE_DIST
+    facility_safe_dist = config.FACILITY_SAFE_DIST
+    # parcel min area
+    parcel_minimum_area = config.AXIS_MIN_AREA
+    # ratio of access to boundry to stop halving
+    access_ratio = config.ACCESS_RATIO
+
+    """
+        map class to handle raw inputs
+        RGB (round access, green factor, boundary)
+        Background is white by deafult
+        Black shows fixed facilities
+    """
+    @singledispatchmethod
+    def __init__(self) -> None:
+        assert False, 'bad input'
+    @__init__.register(str)
+    def _first__(self,src:str,src_block:str,src_ff:str,parcel_cnt:int,arch_choice:config.ArchStyles,map_id:int) -> None:
+        self.roud_thickness = config.ROAD_SIZE_MAX
+        self.map_id = map_id
+        self.frame = cv2.imread(src)
+        self.frame_shape = self.frame.shape
+        self.arch_choice = arch_choice
+        self.parcel_cnt = parcel_cnt
+        self.centers = (int(self.frame_shape[0]/2),int(self.frame_shape[1]/2))
+        self.trees_mask, self.fixed_f_mask,self.access_mask, self.boundry_mask = self.create_masks()
+        self.trees_binary_mask = cv2.threshold(self.trees_mask, 127, 255, cv2.THRESH_BINARY)[1]
+        # read block mask
+        self.block_mask = cv2.imread(src_block)
+        self.block_mask = cv2.cvtColor(self.block_mask,cv2.COLOR_BGR2GRAY)
+        # read facility filled mask
+        self.facility_filled_mask = cv2.imread(src_ff)
+        self.facility_filled_mask = cv2.cvtColor(self.facility_filled_mask,cv2.COLOR_BGR2GRAY)
+        self.print_report()
+        
+    # Axis maps initialization
+    @__init__.register(np.ndarray)
+    def _second__(self,split_mask:np.ndarray,parent_map,line_mask:np.ndarray,map_id:int,dir:int,line_p) -> None:
+        self.line_p = line_p
+        # self.axis_center = parent_map.axis_center
+        self.split_mask = split_mask
+        self.dir = dir # 0 up 1 down
+        self.roud_thickness = config.ROAD_SIZE_MAX - config.ROAD_STEP*int(math.log(map_id+1,2))
+        if self.roud_thickness <= config.ROAD_STEP: self.roud_thickness=config.ROAD_SIZE_MIN
+        config.log(f"roud thickness:{self.roud_thickness} map_id:{map_id}")
+        self.map_id = map_id
+        # split_mask_3d = np.zeros((self.frame_shape))
+        # self.frame = parent_map.frame & split_mask
+        split_3d_mask = np.zeros(parent_map.frame_shape, dtype=np.uint8)
+        split_3d_mask[:,:,:] = split_mask[:,:,np.newaxis]
+        self.frame = parent_map.frame & split_3d_mask
+        self.frame_shape = self.frame.shape
+        self.arch_choice = parent_map.arch_choice
+        self.centers = (int(self.frame_shape[0]/2),int(self.frame_shape[1]/2))
+        self.trees_mask = parent_map.trees_mask & split_mask
+        self.trees_binary_mask = parent_map.trees_binary_mask & split_mask
+        self.fixed_f_mask = parent_map.fixed_f_mask & split_mask
+        self.boundry_mask = parent_map.boundry_mask & split_mask
+        self.old_boundry_mask = parent_map.boundry_mask & split_mask
+        self.block_mask = parent_map.block_mask & split_mask
+        self.facility_filled_mask = parent_map.facility_filled_mask & split_mask
+        # add new line to access
+        new_access_line = self.block_mask & line_mask
+        self.access_mask = parent_map.access_mask & split_mask
+        self.access_mask = self.access_mask | new_access_line
+        # add new line to boundries
+        self.boundry_mask = self.boundry_mask | new_access_line
+        self.new_access_line = new_access_line
+        if map_id > 2:
+            self.parent_access_line = parent_map.new_access_line
+            self.parent_line_p = parent_map.line_p
+        else:
+            self.parent_access_line = self.new_access_line
+            self.parent_line_p = self.line_p
+        self.save_map()
+        self.print_report()
+    
+    # Parcels initilization
+    @__init__.register(int)
+    def _third__(self,parcel_id:int,split_mask:np.ndarray,parent_map,parcel_area,lines_points_tup,parcel_type) -> None:
+        self.dir = parent_map.dir
+        self.parent_line_p = parent_map.parent_line_p
+        self.line_p = parent_map.line_p
+        self.parent_access_line = parent_map.parent_access_line & split_mask
+        self.access_line = parent_map.new_access_line & split_mask
+        self.parcel_id = parcel_id
+        self.curr_size = parcel_area
+        self.bounding_lines = lines_points_tup
+        self.parcel_type = parcel_type
+        self.map_id = parent_map.map_id
+        split_3d_mask = np.zeros(parent_map.frame_shape, dtype=np.uint8)
+        split_3d_mask[:,:,:] = split_mask[:,:,np.newaxis]
+        self.frame = parent_map.frame & split_3d_mask
+        self.frame_shape = self.frame.shape
+        self.arch_choice = parent_map.arch_choice
+        self.trees_mask = parent_map.trees_mask & split_mask
+        self.trees_binary_mask = parent_map.trees_binary_mask & split_mask
+        self.fixed_f_mask = parent_map.fixed_f_mask & split_mask
+        self.boundry_mask = parent_map.boundry_mask & split_mask
+        self.block_mask = parent_map.block_mask & split_mask
+        self.facility_filled_mask = parent_map.facility_filled_mask & split_mask
+        # make center of new parcel
+        block_mask = self.block_mask.astype(np.uint8)
+        contours, _ = cv2.findContours(block_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+        cnts = sorted(contours, key=cv2.contourArea, reverse=True)
+        M = cv2.moments(cnts[0])
+        cX = int(M["m10"] / M["m00"])
+        cY = int(M["m01"] / M["m00"])
+        self.parcel_center = (cY,cX)
+        # self.save_map()
+        self.print_report()
+
+    def print_report(self):
+        config.log(f"Map {self.map_id} Area : {np.sum(self.block_mask)/255}")
+        config.log(f"Map {self.map_id} Tree Area : {np.sum(self.trees_binary_mask)/255}")
+        config.log(f"Map {self.map_id} Fixed-Facility Area : {np.sum(self.facility_filled_mask)/255}")
+        config.log(f"Map {self.map_id} Sparse Area : {np.sum(self.block_mask & np.bitwise_not(self.facility_filled_mask) & np.bitwise_not(self.trees_binary_mask))/255}")
+
+    def set_map_axis_center(self,point):
+        self.axis_center = point
+    def set_line_point(self,point:tuple):
+        self.line_points = point
+
+    def save_map(self) -> None:
+        if config.WRITE_UNNECESSARY:
+            cv2.imwrite(f'outputs/map{self.map_id}.bmp',self.frame)
+            cv2.imwrite(f'outputs/access_mask{self.map_id}.bmp',self.access_mask)
+            cv2.imwrite(f'outputs/boundry_mask{self.map_id}.bmp',self.boundry_mask)
+
+    def create_masks(self) -> tuple:
+        res = []
+        img_re = self.frame.reshape(-1,3)
+        df = pd.DataFrame(img_re,columns=['b','g','r'])
+        df['r'].astype(np.uint8)
+        df['g'].astype(np.uint8)
+        df['b'].astype(np.uint8)
+
+        indx_trees = df.apply(lambda x: x.b==0 and 0<x.g<=255 and x.r==0, axis=1)
+        df_trees = df.copy()
+        df_trees[np.logical_not(indx_trees)] = [0,0,0]
+        # df_trees[indx_trees] = [255,255,255]
+        out = df_trees.values.reshape(self.frame_shape)
+        out = out.astype(np.uint8)
+        out[:,:,0] = 0
+        out[:,:,2] = 0
+        out = cv2.threshold(out, 127, 255, cv2.THRESH_BINARY)[1][:,:,1]
+        res.append(out)
+        cv2.imwrite('outputs/tree_mask.bmp',out)
+
+        indx_fixed_fac = df.apply(lambda x: x.b==0 and x.g==0 and x.r==0, axis=1)
+        df_ff = df.copy()
+        df_ff[np.logical_not(indx_fixed_fac)] = [0,0,0]
+        df_ff[indx_fixed_fac] = [255,255,255]
+        out = df_ff.values.reshape(self.frame_shape)
+        out = out.astype(np.uint8)
+        out = cv2.cvtColor(out,cv2.COLOR_BGR2GRAY)
+        res.append(out)
+        cv2.imwrite('outputs/facility_mask.bmp',out)
+
+        indx_access = df.apply(lambda x: x.g==0 and x.r==255, axis=1)
+        df_ac = df.copy()
+        df_ac[np.logical_not(indx_access)] = [0,0,0]
+        df_ac[indx_access] = [255,255,255]
+        out = df_ac.values.reshape(self.frame_shape)
+        out = out.astype(np.uint8)
+        out = cv2.cvtColor(out,cv2.COLOR_BGR2GRAY)
+        res.append(out)
+        cv2.imwrite('outputs/access_mask.bmp',out)
+
+        indx_boundry = df.apply(lambda x: x.b==255 and x.g==0, axis=1)
+        df_b = df.copy()
+        df_b[np.logical_not(indx_boundry)] = [0,0,0]
+        df_b[indx_boundry] = [255,255,255]
+        out = df_b.values.reshape(self.frame_shape)
+        out = out.astype(np.uint8)
+        out = cv2.cvtColor(out,cv2.COLOR_BGR2GRAY)
+        res.append(out)
+        cv2.imwrite('outputs/boundary_mask.bmp',out)
+        return tuple(res)
+
+    def correct_input(self) -> None:
+        img_re = self.frame.reshape(-1,3)
+        df = pd.DataFrame(img_re,columns=['b','g','r'])
+        df['r'].astype(np.uint8)
+        df['g'].astype(np.uint8)
+        df['b'].astype(np.uint8)
+        # ----set tree values to random
+        random.seed(13)
+        df = df.apply(lambda x: [0,random.randint(1,255),0] if x['b']==0 and x['g']==255 and x['r']==0 else x,axis=1)
+        # ----convert white to black
+        # indx = df.apply(lambda x: x['b']==255 and x['g']==255 and x['r']==255,axis=1)
+        # df[indx] = [0,0,0]
+        # ----set rgb(0,255,255) to rgb(255,0,255)
+        # indx = df.apply(lambda x: x['b']==255 and x['g']==255 and x['r']==0,axis=1)
+        # df[indx] = [255,0,255]
+        # ----save output
+        out = df.values.reshape(self.frame_shape)
+        out = out.astype(np.uint8)
+        cv2.imwrite('outputs/kan_pre.bmp',out)
+        self.frame = out
+        # ----print
+        # cv2.imshow("kan_pre_out", out)
+        # cv2.waitKey(0)
+        # cv2.destroyAllWindows()
+
+    """
+        returns above the line mask and below the line mask
+    """
+    def line_split_mask_maker(self,p0:tuple,p1:tuple):
+        # points are (y,x) oriented
+        img_pixels = self.frame_shape[0]*self.frame_shape[1]
+        img_x = self.frame_shape[1]
+        # numpy image is (y*x*3)
+        # !! unit16 may not be enough
+        y_index = (np.arange(img_pixels).reshape(self.frame_shape[:2])/img_x).astype(np.uint32)
+        x_index = np.arange(img_pixels).reshape(self.frame_shape[:2])%img_x
+        if p1[1] == p0[1]:
+            up_down_line = x_index - p0[1]
+        else:
+            slope = (p1[0]-p0[0])/(p1[1]-p0[1]) 
+            intercept = p0[0] - (slope*p0[1])
+            up_down_line = x_index*slope + intercept - y_index
+        # down part (becareful about center)
+        down_mask = np.where(up_down_line>=0,255,0).reshape(self.frame_shape[:2])
+        up_mask = np.where(up_down_line>=0,0,255).reshape(self.frame_shape[:2])
+        return (up_mask,down_mask)
+    """
+        returns only line mask on main image
+    """
+    def line_mask_maker(self,p0:tuple,p1:tuple):
+        plain = np.zeros((self.block_mask.shape))
+        plain = cv2.line(plain,(p0[1],p0[0]),(p1[1],p1[0]),255,2)
+        return plain.astype(np.uint8)
+
+    
+    """
+        check whether the half map has a feasible condition 
+        or supports the finishing condtion.
+    """
+    def isfeasible(self):
+        # check if the part has more than 60% access
+        access = np.sum(self.access_mask)/255
+        boundry = np.sum(self.boundry_mask)/255
+        access_ratio = access/boundry
+        access_cond = access_ratio<self.access_ratio
+        # area of part not smaller than standard
+        block_size = np.sum(self.block_mask)/255
+        size_cond = block_size>self.parcel_minimum_area
+        config.log(f'block size:{block_size} access_ratio:{access_ratio} map_id:{self.map_id}')
+        self.curr_access = access_ratio
+        self.curr_size = block_size
+        return access_cond and size_cond
+
+class CVLineThickness:
+    """
+        method selects cv2line arg 
+        depending on the pixel width
+    """
+    @staticmethod
+    def thickness_solver(desired_thickness):
+        if desired_thickness == 1:
+            return 1
+        if desired_thickness == 2:
+            # assert false, f"change road size or road step to odd number: {desired_thickness}"
+            return 2
+        if desired_thickness == 3:
+            return 2
+        if desired_thickness % 2 == 0:
+            # assert false, f"change road size or road step to odd number: {desired_thickness}"
+            return desired_thickness - 1
+        
+        return desired_thickness - 2
+
+
+class MapOut:
+    def __init__(self,src:str,lines_axis:list) -> None:
+        self.img = cv2.imread(src)
+        self.img_axised = self.img.copy()
+        self.img_partitioned = None
+        self.img_built = None
+        self.img_last = None
+        self.axis_lines = lines_axis
+        self.partitioning_lines = None
+        self.parcels_dic = {}
+        self.building_masks = None
+        # export details
+        self.total_carbon = 0
+        self.total_trees = 0
+        self.total_carbon_loss = 0
+        self.total_cut_tree = 0
+        self.total_axis_length = 0
+        self.total_axis_per_block_pr = 0
+        self.total_num_parcels = 0
+        self.total_num_parcels_types = {p_type:0 for p_type in config.ParcelType._member_names_}
+        self.total_sum_ff = 0
+    
+    def reset_map_for_partitioning(self):
+        self.total_num_parcels = 0
+        self.total_num_parcels_types = {p_type:0 for p_type in config.ParcelType._member_names_}
+        self.total_sum_ff = 0
+        self.partitioning_lines = None
+        if self.img_partitioned is not None:
+            self.img_partitioned = None    
+        self.img_last = self.img_axised.copy()
+
+    def reset_map_for_location_finding(self):
+        self.total_sum_ff = 0
+        self.building_masks = None
+        if self.img_built is not None:
+            self.img_built = None
+        self.img_last = self.img_partitioned.copy()
+    
+    def add_partition_report(self,report):
+        self.total_num_parcels += report['cnt']
+        report.pop('cnt')
+        for p_type in report.keys():
+            self.total_num_parcels_types[p_type] += report[p_type]
+
+    def report(self):
+        self.block_mask = cv2.imread(config.MAIN_MAP_FILLED_BLOCK_MASK)
+        self.tree_mask = cv2.imread('outputs/tree_mask.bmp')
+        self.binary_tree_mask = cv2.threshold(self.tree_mask, 127, 255, cv2.THRESH_BINARY)[1]
+        self.facility_filled_mask = cv2.imread(config.MAIN_MAP_FILLED_F_F_MASK)
+        # total trees carbon
+        self.total_carbon = np.sum(self.tree_mask)/3
+        self.total_trees = np.sum(self.binary_tree_mask)/(255*3)
+        # calculate tree cut and carbon
+        self.img_last = self.img_last & self.block_mask
+        self.img_last = self.img_last.astype(np.uint8)
+        self.img_mask = cv2.threshold(self.img_last, 127, 255, cv2.THRESH_BINARY)[1]
+        # omit roads mask and building mask from it
+        self.roads_mask = cv2.imread('outputs/roads_mask.bmp')
+        collision3dmask = self.roads_mask
+        if os.path.exists('outputs/buildings_mask.bmp'):
+            collision3dmask = collision3dmask | cv2.imread('outputs/buildings_mask.bmp')
+        if os.path.exists('outputs/partitioning_mask.bmp'):
+            collision3dmask = collision3dmask | cv2.imread('outputs/partitioning_mask.bmp')
+        cv2.imwrite('outputs/constructed_mask.bmp', collision3dmask)
+        self.total_carbon_loss = np.sum(collision3dmask & self.tree_mask)/3
+        self.total_cut_tree = np.sum(collision3dmask & self.binary_tree_mask)/(255*3)
+        config.log(f"Total Trees:{self.total_trees} Total Carbon Values:{self.total_carbon}")
+        config.log(f"Total Cut Trees:{self.total_cut_tree} Total Carbon Loss:{self.total_carbon_loss}")
+        config.log(f"Total Cut Precentage:{self.total_cut_tree/self.total_trees}")
+        # calculate axis reports
+        img_re = self.img_last.reshape(-1,3)
+        df = pd.DataFrame(img_re,columns=['b','g','r'])
+        df['r'].astype(np.uint8)
+        df['g'].astype(np.uint8)
+        df['b'].astype(np.uint8)
+        indx_axis = df.apply(lambda x:x.g == 0 and 0<x.r<=255 and x.b == 0, axis=1)
+        df_axis = df.copy()
+        df_axis[np.logical_not(indx_axis)] = [0,0,0]
+        out = df_axis.values.reshape(self.img_last.shape)
+        out = out.astype(np.uint8)
+        out = cv2.cvtColor(out,cv2.COLOR_BGR2GRAY)
+        out = cv2.threshold(out, 1, 255, cv2.THRESH_BINARY)[1]
+        self.total_axis_length = np.sum(out)/255
+        self.total_axis_per_block_pr = self.total_axis_length / (np.sum(self.block_mask)/(255*3))
+        sparse_area = np.sum(self.block_mask & np.bitwise_not(self.facility_filled_mask) & np.bitwise_not(self.binary_tree_mask))/(255*3)
+        self.total_axis_per_sparse_pr = self.total_axis_length / sparse_area
+        config.log(f"Total Axis Area:{self.total_axis_length}")
+        config.log(f"Total Block Area:{np.sum(self.block_mask)/(255*3)}")
+        config.log(f"Total Sparse Area:{sparse_area}")
+        config.log(f"Total Axis Per Block Precentage:{self.total_axis_per_block_pr}")
+        config.log(f"Total Axis Per Sparse Precentage:{self.total_axis_per_sparse_pr}")
+        # Parcels number plus types
+        config.log(f"Total Parcels:{self.total_num_parcels}")
+        config.log(f"Total Parcel types:{self.total_num_parcels_types}")
+        config.log(f"Total Parcels With FF:{self.total_sum_ff}")
+
+
+        
+    def draw_axis(self):
+        for line in self.axis_lines:
+            p0=line[0][0]
+            p1=line[0][1]
+            thickness=config.ROAD_SIZE_MAX - config.ROAD_STEP*int(math.log(line[1]+1,2))
+            if thickness <= config.ROAD_SIZE_MIN:
+                thickness=config.ROAD_SIZE_MIN
+            # draw line of axis
+            self.img_axised = cv2.line(self.img_axised,(p0[1],p0[0]),(p1[1],p1[0]),(0,0,127),CVLineThickness.thickness_solver(thickness+2))
+            # rotate points
+            self.img_axised = cv2.line(self.img_axised,(p0[1],p0[0]),(p1[1],p1[0]),(0,0,255),CVLineThickness.thickness_solver(thickness))
+        cv2.imwrite('outputs/final_axis.bmp',self.img_axised)
+        # save road lines mask
+        img_re = self.img_axised.reshape(-1,3).copy()
+        df = pd.DataFrame(img_re,columns=['b','g','r'])
+        df['r'].astype(np.uint8)
+        df['g'].astype(np.uint8)
+        df['b'].astype(np.uint8)
+        indx_axis = df.apply(lambda x:x.g == 0 and 0<x.r<=255 and x.b == 0, axis=1)
+        df[np.logical_not(indx_axis)] = [0,0,0]
+        out = df.values.reshape(self.img_axised.shape)
+        out = out.astype(np.uint8)
+        out = cv2.cvtColor(out,cv2.COLOR_BGR2GRAY)
+        out = cv2.threshold(out, 1, 255, cv2.THRESH_BINARY)[1]
+        self.img_last = self.img_axised.copy()
+        cv2.imwrite('outputs/roads_mask.bmp', out)
+    
+    def draw_partitions(self,iteration:int,map:MapIn,lines_parcels:list):
+        map_id = map.map_id
+        if lines_parcels is not None:
+            self.parcels_dic[map_id] = lines_parcels
+            lines_mask = np.zeros(self.img_last.shape, dtype=np.uint8)
+            for line in lines_parcels:
+                p0=line[0]
+                p1=line[1]
+                # rotate points
+                lines_mask = cv2.line(lines_mask,(p0[1],p0[0]),(p1[1],p1[0]),(120,120,120),1)
+            split_3d_mask = np.zeros(self.img_last.shape, dtype=np.uint8)
+            split_3d_mask[:,:,:] = map.block_mask[:,:,np.newaxis]
+            lines_mask = lines_mask & split_3d_mask
+            self.img_partitioned = self.img_last.astype(np.uint8) & np.bitwise_not(lines_mask)
+            # write partitioning mask
+            lines_mask = np.where(lines_mask>0,(255,255,255), (0,0,0))
+            if self.partitioning_lines is not None:
+                self.partitioning_lines |= lines_mask
+            else:
+                self.partitioning_lines = lines_mask
+        if config.WRITE_UNNECESSARY:
+            cv2.imwrite(f'outputs/final_map_{iteration}_{map_id}.bmp',self.img_partitioned)
+        self.img_last = self.img_partitioned.copy()
+    
+    def draw_partitioning_results(self):
+        cv2.imwrite(f'outputs/partitioning_mask.bmp',self.partitioning_lines)
+        cv2.imwrite(f'outputs/final_map_partitioning.bmp',self.img_partitioned)
+
+
+    def draw_building(self,building_mask,iteration,map_id,parcel_id,has_building,parcel_type,block_mask):
+        color3d_mask = np.zeros(self.img_last.shape, dtype=np.uint8)
+        color3d_mask[:,:,:] = block_mask[:,:,np.newaxis]
+        if has_building:
+            self.total_sum_ff += 1
+            color3d_mask = np.where(color3d_mask>0,(100,100,100),(255,255,255))
+        elif parcel_type == config.ParcelType.O:
+            color3d_mask = np.where(color3d_mask>0,(0,255,255),(255,255,255))
+        elif parcel_type == config.ParcelType.A:
+            color3d_mask = np.where(color3d_mask>0,(51,255,255),(255,255,255))
+        elif parcel_type == config.ParcelType.B:
+            color3d_mask = np.where(color3d_mask>0,(102,255,255),(255,255,255))
+        elif parcel_type == config.ParcelType.C:
+            color3d_mask = np.where(color3d_mask>0,(153,255,255),(255,255,255))
+        elif parcel_type == config.ParcelType.U:
+            color3d_mask = np.where(color3d_mask>0,(40,0,255),(255,255,255))
+
+        build3d_mask = np.zeros(self.img.shape, dtype=np.uint8)
+        build3d_mask[:,:,:] = building_mask[:,:,np.newaxis]
+        if self.building_masks is not None:
+            self.building_masks &= build3d_mask
+            self.img_last &= self.img_partitioned & build3d_mask
+            self.img_built &= self.img_partitioned & build3d_mask & color3d_mask
+        else:
+            self.building_masks = build3d_mask
+            self.img_last = self.img_partitioned & build3d_mask
+            self.img_built = self.img_partitioned & build3d_mask & color3d_mask
+        if config.WRITE_UNNECESSARY:
+            cv2.imwrite(f'outputs/final_map_{iteration}_{map_id}_{parcel_id}.bmp',self.img_built)
+        
+    def draw_building_results(self):
+        cv2.imwrite(f'outputs/buildings_mask.bmp',np.bitwise_not(self.building_masks))
+        cv2.imwrite(f'outputs/final_map_location_finding.bmp',self.img_built)
+
+
+    def draw_collision(self):
+        trees_mask = cv2.imread('outputs/tree_mask.bmp')
+        fixed_facility_mask = cv2.imread('outputs/facility_mask.bmp')
+        roads_mask = cv2.imread('outputs/roads_mask.bmp')
+        collide_mask = roads_mask
+        if os.path.exists('outputs/buildings_mask.bmp'):
+            collide_mask |= cv2.imread('outputs/buildings_mask.bmp')
+        if os.path.exists('outputs/partitioning_mask.bmp'):
+            collide_mask |= cv2.imread('outputs/partitioning_mask.bmp')
+        # change here when building mask is av
+        collision3dmask = trees_mask | fixed_facility_mask
+        collision3dmask = collide_mask & collision3dmask
+        img = self.img_last.copy()
+        pixels = [100,50,100]*int(len(img[collision3dmask>0])/3)
+        img[collision3dmask>0] = pixels
+
+        cv2.imwrite(f'outputs/collision_map.bmp',img)

app.py

@@ -0,0 +1,12 @@
+import gradio as gr
+from axis_finder import gradio_inference
+
+def run_axis_finder(input_str):
+    input_str = input_str.split(' ')
+    return gradio_inference(input_str[0], input_str[1], input_str[2])
+
+demo = gr.Interface(
+    run_axis_finder,
+    gr.Textbox(value="Road Access[0.1:0.9], Starting Point(y,x), Carbon Prefix[0:7], \n exp:0.7 (44, 119) 2"),
+    "image")
+demo.launch()

axis_finder.py

@@ -0,0 +1,142 @@
+from Map import MapIn,MapOut
+from Axis import AxisFinder
+import cv2
+import pickle
+import config
+import time
+
+def run_axis_finder(total_execution_time):
+    maps_list = []
+    lines_list = []
+    axis_division_cond = True
+    maps_processing_queue = []
+    map_id = 0
+    iteration = 0
+    # axis finding process (1.1)
+    config.log_axis_finding_settings()
+    config.log(f"------Axis Finder------")
+    start_time = time.time()
+    while axis_division_cond:
+        config.log(f"----Step {iteration}----")
+        if (map_id == 0):
+            # read map and make masks
+            mymap = MapIn(config.MAIN_MAP_ADDR,config.MAIN_MAP_FILLED_BLOCK_MASK,config.MAIN_MAP_FILLED_F_F_MASK,
+                            config.PARCELS_COUNT,config.ARCH,map_id=map_id)
+            # set random values for carbon
+            # mymap.correct_input()
+        else:
+            mymap = maps_processing_queue.pop(0)
+        
+        # makes axis_finder object to split
+        myaxis = AxisFinder(mymap)
+        # Arch Selection on start division is the same
+        if mymap.arch_choice == config.ArchStyles.Customized:
+            # axis_center = myaxis.get_center(mymap.block_mask)
+            # mymap.set_map_axis_center(axis_center)
+            cv2.imshow(f'Map{mymap.map_id}', mymap.frame)
+            cv2.setMouseCallback(f'Map{mymap.map_id}', AxisFinder.click_callback)
+            cv2.waitKey(0)
+            cv2.destroyAllWindows()
+            p_f = AxisFinder.clicked_points.pop(0)
+            p_s = AxisFinder.clicked_points.pop(0)
+            points=[]
+            points.append((1,p_f,p_s,p_f,p_s))
+        elif map_id == 0 and mymap.arch_choice == config.ArchStyles.Human_Centered_AI:
+            p_f = ()
+            if config.ARCH_FIRST_INPUT == None:
+                cv2.imshow(f'Map{mymap.map_id}', mymap.frame)
+                cv2.setMouseCallback(f'Map{mymap.map_id}', AxisFinder.click_callback)
+                cv2.waitKey(0)
+                cv2.destroyAllWindows()
+                p_f = AxisFinder.clicked_points.pop(0)
+            else:
+                p_f = config.ARCH_FIRST_INPUT
+            points = myaxis.iterate_throughall(mymap,p_f)
+        elif map_id == 0:
+            points = myaxis.iterate_throughall(mymap)
+        else:
+            points = myaxis.iterate_old_boundries_new_york()
+        
+        # dump axis if hit fixed_facility
+        if points[-1][0] == -1:
+            if not maps_processing_queue:
+                axis_division_cond = False
+            continue
+
+        # draw the found line carbon_fitness
+        config.log(f"Map div best score:{points[-1][0]} map_id:{mymap.map_id}")
+        config.log(f"Map div best access split fitness:{points[-1][5][0]}")
+        config.log(f"Map div best area split fitness:{points[-1][5][1]}")
+        config.log(f"Map div best fixed facilities fitness:{points[-1][5][2]}")
+        config.log(f"Map div best carbon fitness:{points[-1][5][3]}")
+
+        lines_list.append((points[-1][3:5],mymap.map_id))
+        # make map for split two parts (add line as access)
+        split_mask_u,split_mask_d = mymap.line_split_mask_maker(points[-1][1],points[-1][2])
+        line_mask = mymap.line_mask_maker(points[-1][1],points[-1][2])
+        up_map = MapIn(split_mask_u,mymap,line_mask,map_id+1,0,points[-1][1:3])
+        down_map = MapIn(split_mask_d,mymap,line_mask,map_id+2,1,points[-1][1:3])
+        parcels = AxisFinder.cal_split_parcels(up_map,down_map,mymap.parcel_cnt)
+        up_map.parcel_cnt,down_map.parcel_cnt = parcels
+        config.log(f"Map:{map_id+1} Parcels:{up_map.parcel_cnt}")
+        config.log(f"Map:{map_id+2} Parcels:{down_map.parcel_cnt}")
+        # check finishing condition
+        up_feasibility, down_feasibility = (up_map.isfeasible(), down_map.isfeasible())
+        # add new maps to processing queue
+        if up_feasibility:
+            config.log(f"Map:{map_id+1} Added!")
+            up_map.set_line_point(points[-1][1:])
+            maps_processing_queue.append(up_map)
+        # was the last axis so add axis to final answer
+        else:
+            config.log(f"Map:{map_id+1} Added As Answer")
+            up_map.set_line_point(points[-1][1:])
+            maps_list.append(up_map)
+        if down_feasibility:
+            config.log(f"Map:{map_id+2} Added!")
+            down_map.set_line_point(points[-1][1:])
+            maps_processing_queue.append(down_map)   
+        else:
+            config.log(f"Map:{map_id+2} Added As Answer")
+            down_map.set_line_point(points[-1][1:])
+            maps_list.append(down_map)  
+            
+        if not maps_processing_queue:
+            axis_division_cond = False
+        map_id += 2
+        iteration+=1
+        config.log('-'*8)
+
+    # 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------")
+    export_map = MapOut(config.MAIN_MAP_ADDR,lines_list)
+    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
+    return total_execution_time
+
+def gradio_inference(access_ratio,start_point,carbon_weight):
+    config.ACCESS_RATIO = float(access_ratio)
+    config.ARCH_FIRST_INPUT = tuple(start_point)
+    config.A_CARBON_WEIGHT = int(carbon_weight)
+    run_axis_finder(0)
+    image = cv2.imread(f'outputs/collision_map.bmp')
+    return image
+
+if __name__ == "__main__":
+    run_axis_finder(0)

config.py

@@ -0,0 +1,124 @@
+import enum
+import datetime
+# enum classes
+class ArchStyles(enum.Enum):
+    New_York = 1
+    Human_Centered_AI = 2
+    Customized = 3
+class ParcelType(enum.Enum):
+    O = 0 # oversize
+    A = 1
+    B = 2
+    C = 3
+    U = 4 # undersize
+
+# main run input args
+MAIN_MAP_ADDR = 'inputs/Sample_test120-70_total_map_fringe.bmp'
+MAIN_MAP_FILLED_BLOCK_MASK = 'inputs/Sample_test120-70_boundry_mask_fringe.bmp'
+MAIN_MAP_FILLED_F_F_MASK = 'inputs/Sample_test120-70_FiFa_mask_fringe.bmp'
+PARCELS_COUNT = 12
+ARCH = ArchStyles.Human_Centered_AI
+ARCH_FIRST_INPUT = (44, 119) #(70, 120) #(Y,X) or None
+
+# Axis finding args
+VALID_POINT_DISTANCE = 10
+ROAD_SIZE_MAX = 3 # can be: 1,3,5,7,...
+ROAD_SIZE_MIN = 1 # can be: 1,3,5,...
+ROAD_STEP = 2 # can be multiplication of 2
+
+ACCESS_RATIO = 0.6 # 0.55 for newyork # 0.7 for star
+
+AXIS_MIN_AREA = 1000 # 12000 for newyork # 75000 for star
+
+FACILITY_SAFE_DIST = 2
+TREE_SAFE_DIST = 1
+
+# axis finder fitness weights
+A_ACCESS_SPLIT_WEIGHT  = 1
+A_AREA_SPLIT_WEIGHT = 1
+A_FIXED_FACILITIES_WEIGHT = 1
+A_CARBON_WEIGHT = 1
+
+# Partitioning args
+PROCESSING_CORES = 8
+
+P_GA_LOSS_THOLD = 0.3
+
+TYPE_A_AREA = 700
+TYPE_B_AREA = 500
+TYPE_C_AREA = 400
+
+TYPE_AREA_STEP = 100
+
+# partiotioning fitness weights
+P_FF_WEIGHT = 2
+P_AREA_WEIGHT = 2
+P_TREE_WEIGHT = 1
+
+# location finding args
+BUILDING_ADDR = ['inputs/rectangle_6-15.bmp','inputs/rectangle_6-15.bmp','inputs/rectangle_6-15.bmp','inputs/white.bmp']
+BUILDING_BORDER_GAP = 10
+
+# location finding fitness weights
+L_DIST_WEIGHT = 1
+L_OUT_BORDER_WEIGHT = 2
+L_CARBON_WEIGHT = 1
+L_ON_ROAD_WEIGHT = 2
+
+def building_sel(p_type:ParcelType):
+    if p_type == ParcelType.O: return BUILDING_ADDR[0]
+    if p_type == ParcelType.A: return BUILDING_ADDR[0]
+    if p_type == ParcelType.B: return BUILDING_ADDR[1]
+    if p_type == ParcelType.C: return BUILDING_ADDR[2]
+    if p_type == ParcelType.U: return BUILDING_ADDR[3]
+
+# output args and loggers
+WRITE_UNNECESSARY = False
+WRITE_LOGS = True
+def log_axis_finding_settings():
+    log(f'====== Axis Finding inputs ======')
+    log(f'PARCELS_COUNT : {PARCELS_COUNT}')
+    log(f'ARCH : {ARCH}')
+    log(f'ARCH_FIRST_INPUT : {ARCH_FIRST_INPUT}')
+    log(f'VALID_POINT_DISTANCE : {VALID_POINT_DISTANCE}')
+    log(f'ROAD_SIZE_MAX : {ROAD_SIZE_MAX}')
+    log(f'ROAD_SIZE_MIN : {ROAD_SIZE_MIN}')
+    log(f'ROAD_STEP : {ROAD_STEP}')
+    log(f'ACCESS_RATIO : {ACCESS_RATIO}')
+    log(f'AXIS_MIN_AREA : {AXIS_MIN_AREA}')
+    log(f'FACILITY_SAFE_DIST : {FACILITY_SAFE_DIST}')
+    log(f'TREE_SAFE_DIST : {TREE_SAFE_DIST}')
+    log(f'A_ACCESS_SPLIT_WEIGHT : {A_ACCESS_SPLIT_WEIGHT}')
+    log(f'A_AREA_SPLIT_WEIGHT : {A_AREA_SPLIT_WEIGHT}')
+    log(f'A_FIXED_FACILITIES_WEIGHT : {A_FIXED_FACILITIES_WEIGHT}')
+    log(f'A_CARBON_WEIGHT : {A_CARBON_WEIGHT}')
+def log_partitioning_settings():
+    log(f'====== Partitioning inputs ======')
+    log(f'PARCELS_COUNT : {PARCELS_COUNT}')
+    log(f'PROCESSING_CORES : {PROCESSING_CORES}')
+    log(f'P_GA_LOSS_THOLD : {P_GA_LOSS_THOLD}')
+    log(f'TYPE_A_AREA : {TYPE_A_AREA}')
+    log(f'TYPE_B_AREA : {TYPE_B_AREA}')
+    log(f'TYPE_C_AREA : {TYPE_C_AREA}')
+    log(f'TYPE_AREA_STEP : {TYPE_AREA_STEP}')
+    log(f'P_FF_WEIGHT : {P_FF_WEIGHT}')
+    log(f'P_AREA_WEIGHT : {P_AREA_WEIGHT}')
+    log(f'P_TREE_WEIGHT : {P_TREE_WEIGHT}')
+def log_location_finding_settings():
+    log(f'====== Location Finding inputs ======')
+    log(f'PARCELS_COUNT : {PARCELS_COUNT}')
+    log(f'BUILDING_ADDR : {BUILDING_ADDR}')
+    log(f'BUILDING_BORDER_GAP : {BUILDING_BORDER_GAP}')
+    log(f'TYPE_A_AREA : {TYPE_A_AREA}')
+    log(f'TYPE_B_AREA : {TYPE_B_AREA}')
+    log(f'TYPE_C_AREA : {TYPE_C_AREA}')
+    log(f'TYPE_AREA_STEP : {TYPE_AREA_STEP}')
+    log(f'L_DIST_WEIGHT : {L_DIST_WEIGHT}')
+    log(f'L_OUT_BORDER_WEIGHT : {L_OUT_BORDER_WEIGHT}')
+    log(f'L_CARBON_WEIGHT : {L_CARBON_WEIGHT}')
+    log(f'L_ON_ROAD_WEIGHT : {L_ON_ROAD_WEIGHT}')
+def log(msg):
+    if WRITE_LOGS:
+        with open('./outputs/logs.txt', 'a') as f:
+            f.writelines(f'{datetime.datetime.now()} : {str(msg)}\n')
+    print(str(msg))