Axis.py

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:]