Spaces:
Sleeping
Sleeping
| import pandas as pd | |
| import numpy as np | |
| import math | |
| from statistics import mean, stdev | |
| from collections import defaultdict | |
| import shapely | |
| import shapely.wkt | |
| from shapely.geometry import Point, MultiPoint, LineString, MultiLineString, Polygon, LinearRing | |
| from shapely.ops import voronoi_diagram, substring, unary_union, nearest_points | |
| from shapely import affinity | |
| from shapely.prepared import prep | |
| import cv2 as cv | |
| def segments(polyline): | |
| return list(map(LineString, zip(polyline.coords[:-1], polyline.coords[1:]))) | |
| def scale_move_x(x, xmin_abs, scale): | |
| xn = (x / scale) - 1 - xmin_abs | |
| return xn | |
| def scale_move_y(y, ymin_abs, scale): | |
| yn = (y / scale) - 1 - ymin_abs | |
| return yn | |
| def scale_area(a, scale): | |
| a = a / (scale**2) | |
| return a | |
| def scale_perimeter(p, scale): | |
| p = p / scale | |
| return p | |
| def wall_segment_cosine(direction, apa_line_seg): | |
| seg_s = list(apa_line_seg.coords)[0] | |
| seg_e = list(apa_line_seg.coords)[1] | |
| normal_x = seg_e[0] - seg_s[0] | |
| normal_y = seg_e[1] - seg_s[1] | |
| normal_s = (-normal_y, normal_x) | |
| normal_e = (normal_y, -normal_x) | |
| o = np.array([-normal_y, normal_x]) | |
| w = np.array([normal_y, -normal_x]) | |
| if direction == "south": | |
| d = np.array([-normal_y, normal_x-1]) | |
| if direction == "east": | |
| d = np.array([-normal_y+1, normal_x]) | |
| if direction == "north": | |
| d = np.array([-normal_y, normal_x+1]) | |
| if direction == "west": | |
| d = np.array([-normal_y-1, normal_x]) | |
| od = d - o | |
| ow = w - o | |
| cosine = np.dot(od, ow) / (np.linalg.norm(od) * np.linalg.norm(ow)) | |
| return cosine | |
| # Dir_S_longestedge, Dir_N_longestedge, Dir_W_longestedge, Dir_E_longestedge, Dir_S_max, Dir_N_max, Dir_W_max, Dir_E_max, Facade_length, Facade_ratio | |
| def wall_direction_ratio(apa_line, apa_wall): | |
| apa_wall_O = [i for indx,i in enumerate(segments(apa_line)) if apa_wall[indx] == "O"] | |
| apa_wall_O = MultiLineString(apa_wall_O) | |
| wall_O_length = [] | |
| wall_O_south = [] | |
| wall_O_east = [] | |
| wall_O_north = [] | |
| wall_O_west = [] | |
| apa_wall_O_num = len(apa_wall_O.geoms) | |
| if apa_wall_O_num > 0: | |
| for i in range(apa_wall_O_num): | |
| wall_seg = apa_wall_O.geoms[i] | |
| wall_length = wall_seg.length | |
| south_cos = wall_segment_cosine("south", wall_seg) | |
| east_cos = wall_segment_cosine("east", wall_seg) | |
| north_cos = wall_segment_cosine("north", wall_seg) | |
| west_cos = wall_segment_cosine("west", wall_seg) | |
| if south_cos < 0: | |
| south_cos = 0 | |
| if east_cos < 0: | |
| east_cos = 0 | |
| if north_cos < 0: | |
| north_cos = 0 | |
| if west_cos < 0: | |
| west_cos = 0 | |
| wall_O_length.append(wall_length) | |
| wall_O_south.append(south_cos) | |
| wall_O_east.append(east_cos) | |
| wall_O_north.append(north_cos) | |
| wall_O_west.append(west_cos) | |
| max_length_index = np.array(wall_O_length).argmax() | |
| Dir_S_longestedge = wall_O_south[max_length_index] | |
| Dir_N_longestedge = wall_O_north[max_length_index] | |
| Dir_W_longestedge = wall_O_west[max_length_index] | |
| Dir_E_longestedge = wall_O_east[max_length_index] | |
| Dir_S_max = max(wall_O_south) | |
| Dir_N_max = max(wall_O_north) | |
| Dir_W_max = max(wall_O_west) | |
| Dir_E_max = max(wall_O_east) | |
| Facade_length = apa_wall_O.length | |
| apa_line_length = apa_line.length | |
| Facade_ratio = Facade_length / apa_line_length | |
| else: | |
| Dir_S_longestedge = 0 | |
| Dir_N_longestedge = 0 | |
| Dir_W_longestedge = 0 | |
| Dir_E_longestedge = 0 | |
| Dir_S_max = 0 | |
| Dir_N_max = 0 | |
| Dir_W_max = 0 | |
| Dir_E_max = 0 | |
| Facade_length = 0 | |
| Facade_ratio = 0 | |
| return Dir_S_longestedge, Dir_N_longestedge, Dir_W_longestedge, Dir_E_longestedge, Dir_S_max, Dir_N_max, Dir_W_max, Dir_E_max, Facade_length, Facade_ratio | |
| # apa_geo | |
| def apartment_perimeter(apa_geo): | |
| perimeter =apa_geo.length | |
| return perimeter | |
| def apartment_area(apa_geo): | |
| area =apa_geo.area | |
| return area | |
| def boundingbox(apa_geo): | |
| boundingbox = apa_geo.bounds | |
| return boundingbox | |
| # BBox_width_x, BBox_height_y, Aspect_ratio, Extent, ULC_x, ULC_y, LRC_x, LRC_y | |
| def boundingbox_features(apa_geo): | |
| # [Aspect_ratio, Extent] ---> https://docs.opencv.org/3.4/d1/d32/tutorial_py_contour_properties.html | |
| bbox_xy = boundingbox(apa_geo) | |
| bbox_geo = Polygon([(bbox_xy[0], bbox_xy[1]), (bbox_xy[2], bbox_xy[1]), (bbox_xy[2], bbox_xy[3]), (bbox_xy[0], bbox_xy[3])]) | |
| BBox_width_x = bbox_xy[2] - bbox_xy[0] | |
| BBox_height_y = bbox_xy[3] - bbox_xy[1] | |
| Aspect_ratio = BBox_width_x / BBox_height_y | |
| bbox_geo_area = bbox_geo.area | |
| Area = apartment_area(apa_geo) | |
| Extent = Area / bbox_geo_area | |
| ULC_x = bbox_xy[0] | |
| ULC_y = bbox_xy[3] | |
| LRC_x = bbox_xy[2] | |
| LRC_y = bbox_xy[1] | |
| return BBox_width_x, BBox_height_y, Aspect_ratio, Extent, ULC_x, ULC_y, LRC_x, LRC_y | |
| # Max_diameter | |
| def max_diameter(apa_geo): | |
| # [Max_diameter] ---> https://www.mvtec.com/doc/halcon/12/en/diameter_region.html | |
| apa_coor = list(apa_geo.exterior.coords) | |
| pp_dis_lst = [] | |
| for i in apa_coor: | |
| for j in apa_coor: | |
| pp_dis = Point(i).distance(Point(j)) | |
| pp_dis_lst.append(pp_dis) | |
| max_diameter = max(pp_dis_lst) | |
| return max_diameter | |
| def fractality(apa_geo): | |
| # [Fractality] ---> https://onlinelibrary.wiley.com/doi/epdf/10.1111/j.1538-4632.2000.tb00419.x | |
| # Basaraner, M. and Cetinkaya, S. (2017) ‘Performance of shape indices and classification schemes for characterising perceptual shape complexity of building footprints in GIS’, International Journal of Geographical Information Science, 31(10), pp. 1952–1977. doi:10.1080/13658816.2017.1346257. | |
| Area = apartment_area(apa_geo) | |
| Perimeter = apartment_perimeter(apa_geo) | |
| fractality = 1 - ((math.log(Area) / (2 * math.log(Perimeter)))) | |
| return fractality | |
| def circularity(apa_geo): | |
| # [Circularity] ---> https://www.mvtec.com/doc/halcon/12/en/circularity.html | |
| apa_coor = list(apa_geo.exterior.coords) | |
| op_dis_lst = [] | |
| for i in apa_coor: | |
| op_dis = Point((0, 0)).distance(Point(i)) | |
| op_dis_lst.append(op_dis) | |
| Max_radius = max(op_dis_lst) | |
| Area = apartment_area(apa_geo) | |
| circularity = Area / ((math.pi) * (Max_radius**2)) | |
| return circularity | |
| def outer_radius(p_4_cv, xmin_abs, ymin_abs, scale): | |
| # [Outer_radius] ---> https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga8ce13c24081bbc7151e9326f412190f1 | |
| (xmin,ymin),radius = cv.minEnclosingCircle(p_4_cv) | |
| mini_Enclosing_Cir_x = scale_move_x(xmin, xmin_abs, scale) | |
| mini_Enclosing_Cir_y = scale_move_y(ymin, ymin_abs, scale) | |
| mini_Enclosing_Cir_radius = scale_perimeter(radius, scale) | |
| outer_radius = mini_Enclosing_Cir_radius | |
| return outer_radius | |
| def inner_radius(apa_geo, apa_line): | |
| # [Inner_radius] ---> https://www.sthu.org/blog/14-skeleton-offset-topology/index.html | |
| dis_p = [] | |
| for i in np.arange(0, apa_line.length, 0.1): | |
| s = substring(apa_line, i, i+0.1) | |
| dis_p.append(s.boundary.geoms[0]) | |
| mp = MultiPoint(dis_p) | |
| regions = voronoi_diagram(mp) | |
| vo_p = [] | |
| for i in range(len(regions.geoms)): | |
| vo = regions.geoms[i] | |
| b = list(vo.exterior.coords) | |
| for j in range(len(b)): | |
| p = Point(b[j]) | |
| vo_p.append(p) | |
| vo_p = MultiPoint(vo_p) | |
| vo_p = unary_union(vo_p) | |
| vo_p_b = [] | |
| for i in range(len(vo_p.geoms)): | |
| t_c_p = vo_p.geoms[i] | |
| pc = apa_geo.contains(t_c_p) | |
| vo_p_b.append(pc) | |
| vo_filtered_p = [i for indx,i in enumerate(vo_p.geoms) if vo_p_b[indx] == True] | |
| vo_d = [] | |
| for i in range(len(vo_filtered_p)): | |
| c = Point(vo_filtered_p[i]) | |
| d_min = c.distance(apa_line) | |
| vo_d.append(d_min) | |
| vo_r_max = max(vo_d) | |
| vo_r_max_index = vo_d.index(vo_r_max) | |
| vo_c_max = vo_filtered_p[vo_r_max_index] | |
| vo_c_max = list(vo_c_max.coords) | |
| max_Inner_Circle_x = vo_c_max[0][0] | |
| max_Inner_Circle_y = vo_c_max[0][1] | |
| max_Inner_Circle_r = vo_r_max | |
| inner_radius = max_Inner_Circle_r | |
| return inner_radius | |
| def roundness_features(apa_line): | |
| # [Dist_mean, Dist_sigma, Roundness] ---> https://www.mvtec.com/doc/halcon/12/en/roundness.html | |
| rou_p = [] | |
| for i in np.arange(0, apa_line.length, 0.5): | |
| s = substring(apa_line, i, i+0.5) | |
| rou_p.append(s.boundary.geoms[0]) | |
| rp = MultiPoint(rou_p) | |
| ro_dis = [] | |
| for i in range(len(rp.geoms)): | |
| rpp = rp.geoms[i] | |
| ro = Point(rpp).distance(Point((0, 0))) | |
| ro_dis.append(ro) | |
| dist_mean = mean(ro_dis) | |
| # dist_sigma = stdev(ro_dis) | |
| dev_lst = [] | |
| for i in ro_dis: | |
| dev = (i - dist_mean)**2 | |
| dev_lst.append(dev) | |
| dist_sigma = mean(dev_lst) | |
| dist_sigma = math.sqrt(dist_sigma) | |
| roundness = 1 - (dist_sigma/dist_mean) | |
| return dist_mean, dist_sigma, roundness | |
| def compactness(apa_geo): | |
| # [Compactness] ---> https://fisherzachary.github.io/public/r-output.html | |
| Area = apartment_area(apa_geo) | |
| Perimeter = apartment_perimeter(apa_geo) | |
| compactness = (4*(math.pi)) * (Area / (Perimeter**2)) | |
| return compactness | |
| def equivalent_diameter(apa_geo): | |
| # https://docs.opencv.org/4.x/d1/d32/tutorial_py_contour_properties.html | |
| Area = apartment_area(apa_geo) | |
| equivalent_diameter = math.sqrt((4 * Area) / math.pi) | |
| return equivalent_diameter | |
| def shape_membership_index(apa_line): | |
| # [Shape_membership_index] ---> Basaraner, M. and Cetinkaya, S. (2017) ‘Performance of shape indices and classification schemes for characterising perceptual shape complexity of building footprints in GIS’, International Journal of Geographical Information Science, 31(10), pp. 1952–1977. doi:10.1080/13658816.2017.1346257. | |
| line_smi = LineString([(0, 0), (30, 0)]) | |
| numl = 30 | |
| line_rot_degree = 360 / numl | |
| line_rot = [] | |
| for an in range(numl): | |
| ang = an*line_rot_degree | |
| lr = affinity.rotate(line_smi, ang, (0, 0)) | |
| line_rot.append(lr) | |
| line_rot = MultiLineString(line_rot) | |
| smip = shapely.intersection(apa_line, line_rot) | |
| simo_dis = [] | |
| for i in range(len(smip.geoms)): | |
| sim_p = smip.geoms[i] | |
| simo = Point(sim_p).distance(Point((0, 0))) | |
| simo_dis.append(simo) | |
| sim_r_max = max(simo_dis) | |
| simo_maxd = [] | |
| for j in simo_dis: | |
| rmax_d = j / sim_r_max | |
| simo_maxd.append(rmax_d) | |
| simo_maxd_mean = mean(simo_maxd) | |
| simo_rad = [] | |
| for j in range(len(simo_dis)): | |
| s = simo_dis[j] | |
| if j == (len(simo_dis) - 1): | |
| nu = 0 | |
| else: | |
| nu = j+1 | |
| e = simo_dis[nu] | |
| if s <= e: | |
| a = np.array([1,s]) | |
| b = np.array([0,s]) | |
| c = np.array([1,e]) | |
| else: | |
| a = np.array([1,e]) | |
| b = np.array([0,e]) | |
| c = np.array([1,s]) | |
| ba = a - b | |
| bc = c - b | |
| cosine_angle = np.dot(ba, bc) / (np.linalg.norm(ba) * np.linalg.norm(bc)) | |
| angle_rad = np.arccos(cosine_angle) | |
| simo_rad.append(angle_rad) | |
| simo_rad_min = min(simo_rad) | |
| simo_rad_max = max(simo_rad) | |
| simo_cos = math.cos(simo_rad_max - simo_rad_min) | |
| shape_membership_index = simo_cos * simo_maxd_mean | |
| return shape_membership_index | |
| def convexity(p_4_cv, apa_geo, xmin_abs, ymin_abs, scale): | |
| # [Convexity] ---> Basaraner, M. and Cetinkaya, S. (2017) ‘Performance of shape indices and classification schemes for characterising perceptual shape complexity of building footprints in GIS’, International Journal of Geographical Information Science, 31(10), pp. 1952–1977. doi:10.1080/13658816.2017.1346257. | |
| hull = cv.convexHull(p_4_cv) | |
| hull_x = [] | |
| hull_y = [] | |
| for h in range(len(hull)): | |
| h_x = hull[h][0][0] | |
| h_x = scale_move_x(h_x, xmin_abs, scale) | |
| hull_x.append(h_x) | |
| h_y = hull[h][0][1] | |
| h_y = scale_move_y(h_y, ymin_abs, scale) | |
| hull_y.append(h_y) | |
| hull_xy = [] | |
| for i in range(len(hull_x)): | |
| hx = hull_x[i] | |
| hy = hull_y[i] | |
| hull_xy.append((hx, hy)) | |
| hull_geo = Polygon(hull_xy) | |
| Hull_area = hull_geo.area | |
| Area = apartment_area(apa_geo) | |
| convexity = Area / Hull_area | |
| return convexity, hull_geo | |
| def rectangle_features(p_4_cv, apa_geo, xmin_abs, ymin_abs, scale): | |
| # [Rectangularity] ---> Basaraner, M. and Cetinkaya, S. (2017) ‘Performance of shape indices and classification schemes for characterising perceptual shape complexity of building footprints in GIS’, International Journal of Geographical Information Science, 31(10), pp. 1952–1977. doi:10.1080/13658816.2017.1346257. | |
| rect = cv.minAreaRect(p_4_cv) | |
| miniRect_rotation_angle = rect[2] | |
| box = cv.boxPoints(rect) | |
| box = np.intp(box) | |
| miniRect_x = [] | |
| miniRect_y = [] | |
| for b in range(len(box)): | |
| b_x = box[b][0] | |
| b_x = scale_move_x(b_x, xmin_abs, scale) | |
| miniRect_x.append(b_x) | |
| b_y = box[b][1] | |
| b_y = scale_move_y(b_y, ymin_abs, scale) | |
| miniRect_y.append(b_y) | |
| miniRec_xy = [] | |
| for i in range(len(miniRect_x)): | |
| minirecx = miniRect_x[i] | |
| minirecy = miniRect_y[i] | |
| miniRec_xy.append((minirecx, minirecy)) | |
| miniRect_geo = Polygon(miniRec_xy) | |
| miniRect_area = miniRect_geo.area | |
| Area = apartment_area(apa_geo) | |
| rectangularity = Area / miniRect_area | |
| rect_phi = (miniRect_rotation_angle * math.pi) / 180 | |
| miniRect_line = miniRect_geo.boundary | |
| miniRect_segments = segments(miniRect_line) | |
| seg_len = [] | |
| for s in miniRect_segments: | |
| seg_len.append(s.length) | |
| rect_width = max(seg_len) | |
| rect_height = min(seg_len) | |
| return rectangularity, rect_phi, rect_width, rect_height | |
| def squareness(apa_geo): | |
| # [Squareness] ---> Basaraner, M. and Cetinkaya, S. (2017) ‘Performance of shape indices and classification schemes for characterising perceptual shape complexity of building footprints in GIS’, International Journal of Geographical Information Science, 31(10), pp. 1952–1977. doi:10.1080/13658816.2017.1346257. | |
| Area = apartment_area(apa_geo) | |
| Perimeter = apartment_perimeter(apa_geo) | |
| squareness = (4*(math.sqrt(Area))) / Perimeter | |
| return squareness | |
| def moments(apa_geo): | |
| # https://leancrew.com/all-this/2018/01/python-module-for-section-properties/ | |
| pts = list(apa_geo.exterior.coords) | |
| if pts[0] != pts[-1]: | |
| pts = pts + pts[:1] | |
| x = [ c[0] for c in pts ] | |
| y = [ c[1] for c in pts ] | |
| sxx = syy = sxy = 0 | |
| a = apartment_area(apa_geo) | |
| cx = apa_geo.centroid.x | |
| cy = apa_geo.centroid.y | |
| for i in range(len(pts) - 1): | |
| sxx += (y[i]**2 + y[i]*y[i+1] + y[i+1]**2)*(x[i]*y[i+1] - x[i+1]*y[i]) | |
| syy += (x[i]**2 + x[i]*x[i+1] + x[i+1]**2)*(x[i]*y[i+1] - x[i+1]*y[i]) | |
| sxy += (x[i]*y[i+1] + 2*x[i]*y[i] + 2*x[i+1]*y[i+1] + x[i+1]*y[i])*(x[i]*y[i+1] - x[i+1]*y[i]) | |
| return sxx/12 - a*cy**2, syy/12 - a*cx**2, sxy/24 - a*cx*cy | |
| def moment_index(apa_geo, Convexity, Compactness): | |
| # https://www.researchgate.net/publication/228557311_A_COMBINED_AUTOMATED_GENERALIZATION_MODEL_BASED_ON_THE_RELATIVE_FORCES_BETWEEN_SPATIAL_OBJECTS | |
| Ixx, Iyy, Ixy = moments(apa_geo) | |
| ratio = max(Ixx, Iyy) / min(Ixx, Iyy) | |
| # Convexity, Hull_geo = convexity(p_4_cv) | |
| # Compactness = compactness(apa_geo) | |
| moment_index = (Convexity * Compactness) / ratio | |
| return moment_index | |
| def ndetour_index(apa_geo, Hull_geo): | |
| # [nDetour_index] ---> Basaraner, M. and Cetinkaya, S. (2017) ‘Performance of shape indices and classification schemes for characterising perceptual shape complexity of building footprints in GIS’, International Journal of Geographical Information Science, 31(10), pp. 1952–1977. doi:10.1080/13658816.2017.1346257. | |
| Hull_line = Hull_geo.boundary | |
| Hull_length = Hull_line.length | |
| Area = apartment_area(apa_geo) | |
| ndetour_index = (2 * math.sqrt(Area * math.pi)) / Hull_length | |
| return ndetour_index | |
| def ncohesion_index(apa_geo, grid_points): | |
| # [nCohesion_index] ---> Basaraner, M. and Cetinkaya, S. (2017) ‘Performance of shape indices and classification schemes for characterising perceptual shape complexity of building footprints in GIS’, International Journal of Geographical Information Science, 31(10), pp. 1952–1977. doi:10.1080/13658816.2017.1346257. | |
| grid_p = grid_points.geoms | |
| grid_n = len(grid_p) | |
| gg_dis_lst = [] | |
| for i in grid_p: | |
| for j in grid_p: | |
| gg_dis = Point(i).distance(Point(j)) | |
| gg_dis_lst.append(gg_dis) | |
| Area = apartment_area(apa_geo) | |
| ncohesion_index = (0.9054 * math.sqrt(Area / math.pi)) / (sum(gg_dis_lst) / (grid_n * (grid_n-1))) | |
| return ncohesion_index | |
| def nproximity_nspin_index(apa_geo, grid_points): | |
| grid_p = grid_points.geoms | |
| go_dis_lst = [] | |
| for i in grid_p: | |
| go_dis = Point(i).distance(Point(0,0)) | |
| go_dis_lst.append(go_dis) | |
| go_dis_mean = mean(go_dis_lst) | |
| Area = apartment_area(apa_geo) | |
| nproximity_index = ((2 / 3) * math.sqrt(Area / math.pi)) / go_dis_mean | |
| nspin_index = (0.5 * (Area / math.pi)) / (go_dis_mean**2) | |
| return nproximity_index, nspin_index | |
| def nexchange_index(apa_geo): | |
| Area = apartment_area(apa_geo) | |
| eac_r = math.sqrt(Area / math.pi) | |
| eac = Point(0,0).buffer(eac_r) | |
| eac_inter = apa_geo.intersection(eac) | |
| if eac_inter.geom_type == "Polygon": | |
| eac_area = eac_inter.area | |
| else: | |
| eacga_lst = [] | |
| for i in range(len(eac_inter.geoms)): | |
| eacg = eac_inter.geoms[i] | |
| eacga = eacg.area | |
| eacga_lst.append(eacga) | |
| eac_area = sum(eacga_lst) | |
| nexchange_index = eac_area / Area | |
| return nexchange_index | |
| def nperimeter_index(apa_geo): | |
| Area = apartment_area(apa_geo) | |
| Perimeter = apartment_perimeter(apa_geo) | |
| nperimeter_index = (2 * math.sqrt(math.pi * Area)) / Perimeter | |
| return nperimeter_index | |
| def ndepth_index(apa_geo, apa_line, grid_points): | |
| moved_apa_line = apa_line | |
| grid_p = grid_points.geoms | |
| nea_len_lst = [] | |
| for i in grid_p: | |
| nea_line = LineString(nearest_points(moved_apa_line, i)) | |
| nea_len = nea_line.length | |
| nea_len_lst.append(nea_len) | |
| nea_len_mean = mean(nea_len_lst) | |
| Area = apartment_area(apa_geo) | |
| ndepth_index = (3 * nea_len_mean) / math.sqrt(Area / math.pi) | |
| return ndepth_index | |
| def ngirth_index(apa_geo, Inner_radius): | |
| Area = apartment_area(apa_geo) | |
| ngirth_index = Inner_radius / math.sqrt(Area / math.pi) | |
| return ngirth_index | |
| def nrange_index(apa_geo, Outer_radius): | |
| Area = apartment_area(apa_geo) | |
| nrange_index = math.sqrt(Area / math.pi) / Outer_radius | |
| return nrange_index | |
| def ntraversal_index(apa_geo, apa_line): | |
| rou_p = [] | |
| for i in np.arange(0, apa_line.length, 0.5): | |
| s = substring(apa_line, i, i+0.5) | |
| rou_p.append(s.boundary.geoms[0]) | |
| rp = MultiPoint(rou_p) | |
| rp_n = len(rp.geoms) | |
| bb_dis_lst = [] | |
| for i in rp.geoms: | |
| for j in rp.geoms: | |
| bb_dis = Point(i).distance(Point(j)) | |
| bb_dis_lst.append(bb_dis) | |
| bb_dis_mean = sum(bb_dis_lst) / (rp_n * (rp_n-1)) | |
| Area = apartment_area(apa_geo) | |
| ntraversal_index = (4 * (math.sqrt(Area / math.pi) / math.pi)) / bb_dis_mean | |
| return ntraversal_index | |