Spaces:
Runtime error
Runtime error
| 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:] | |