ObjectNat 1.3.3__py3-none-any.whl

objectnat/methods/provision/provision_model.py

@@ -0,0 +1,323 @@
+# pylint: disable=singleton-comparison
+from typing import Tuple
+
+import geopandas as gpd
+import numpy as np
+import pandas as pd
+from shapely import LineString
+
+from objectnat import config
+
+from .provision_exceptions import CapacityKeyError, DemandKeyError
+
+logger = config.logger
+
+
+class Provision:
+    """
+    Represents the logic for city provision calculations using a gravity or linear model.
+
+    Args:
+        services (gpd.GeoDataFrame): GeoDataFrame representing the services available in the city.
+        demanded_buildings (gpd.GeoDataFrame): GeoDataFrame representing the buildings with demands for services.
+        adjacency_matrix (pd.DataFrame): DataFrame representing the adjacency matrix between buildings.
+        threshold (int): Threshold value for the provision calculations.
+
+    Returns:
+        Provision: The CityProvision object.
+
+    Raises: KeyError: If the 'demand' column is missing in the provided 'demanded_buildings' GeoDataFrame,
+    or if the 'capacity' column is missing in the provided 'services' GeoDataFrame. ValueError: If the 'capacity'
+    column in 'services' or 'demand' column  'demanded_buildings' GeoDataFrame has no valid value.
+    """
+
+    destination_matrix = None
+
+    def __init__(
+        self,
+        services: gpd.GeoDataFrame,
+        demanded_buildings: gpd.GeoDataFrame,
+        adjacency_matrix: pd.DataFrame,
+        threshold: int,
+    ):
+        self.services = self.ensure_services(services.copy())
+        self.demanded_buildings = self.ensure_buildings(demanded_buildings.copy())
+        self.adjacency_matrix = self.delete_useless_matrix_rows_columns(
+            adjacency_matrix.copy(), demanded_buildings, services
+        ).copy()
+        self.threshold = threshold
+        self.services.to_crs(self.demanded_buildings.crs, inplace=True)
+
+    @staticmethod
+    def ensure_buildings(v: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+        if "demand" not in v.columns:
+            raise DemandKeyError
+        v["demand_left"] = v["demand"]
+        return v
+
+    @staticmethod
+    def ensure_services(v: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+        if "capacity" not in v.columns:
+            raise CapacityKeyError
+        v["capacity_left"] = v["capacity"]
+        return v
+
+    @staticmethod
+    def delete_useless_matrix_rows_columns(adjacency_matrix, demanded_buildings, services):
+        adjacency_matrix.index = adjacency_matrix.index.astype(int)
+
+        builds_indexes = set(demanded_buildings.index.astype(int).tolist())
+        rows = set(adjacency_matrix.index.astype(int).tolist())
+        dif = rows ^ builds_indexes
+        adjacency_matrix.drop(index=(list(dif)), axis=0, inplace=True)
+
+        service_indexes = set(services.index.astype(int).tolist())
+        columns = set(adjacency_matrix.columns.astype(int).tolist())
+        dif = columns ^ service_indexes
+        adjacency_matrix.drop(columns=(list(dif)), axis=0, inplace=True)
+        return adjacency_matrix.transpose()
+
+    def run(self) -> Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
+
+        def calculate_flows_y(loc):
+            c = services_table.loc[loc.name]["capacity_left"]
+            p = 1 / loc / loc
+            p = p / p.sum()
+            threshold = p.quantile(best_houses)
+            p = p[p >= threshold]
+            p = p / p.sum()
+            if p.sum() == 0:
+                return loc
+            rng = np.random.default_rng(seed=0)
+            r = pd.Series(0, p.index)
+            choice = np.unique(rng.choice(p.index, int(c), p=p.values), return_counts=True)
+            choice = r.add(pd.Series(choice[1], choice[0]), fill_value=0)
+
+            return choice
+
+        def balance_flows_to_demands(loc):
+            d = houses_table.loc[loc.name]["demand_left"]
+            loc = loc[loc > 0]
+            if loc.sum() > 0:
+                p = loc / loc.sum()
+                rng = np.random.default_rng(seed=0)
+                r = pd.Series(0, p.index)
+                choice = np.unique(rng.choice(p.index, int(d), p=p.values), return_counts=True)
+                choice = r.add(pd.Series(choice[1], choice[0]), fill_value=0)
+                choice = pd.Series(
+                    data=np.minimum(loc.sort_index().values, choice.sort_index().values),
+                    index=loc.sort_index().index,
+                )
+                return choice
+            return loc
+
+        logger.debug(
+            f"Calculating provision from {len(self.services)} services to {len(self.demanded_buildings)} buildings."
+        )
+
+        distance_matrix = self.adjacency_matrix
+        destination_matrix = pd.DataFrame(
+            0,
+            index=distance_matrix.index,
+            columns=distance_matrix.columns,
+            dtype=int,
+        )
+        distance_matrix = distance_matrix.where(distance_matrix <= self.threshold * 3, np.inf)
+
+        houses_table = self.demanded_buildings[["demand", "demand_left"]].copy()
+        services_table = self.services[["capacity", "capacity_left"]].copy()
+        distance_matrix = distance_matrix.drop(
+            index=services_table[services_table["capacity_left"] == 0].index.values,
+            columns=houses_table[houses_table["demand_left"] == 0].index.values,
+            errors="ignore",
+        )
+        distance_matrix = distance_matrix.loc[~(distance_matrix == np.inf).all(axis=1)]
+        distance_matrix = distance_matrix.loc[:, ~(distance_matrix == np.inf).all(axis=0)]
+
+        distance_matrix = distance_matrix + 1
+        selection_range = (self.threshold + 1) / 2
+        best_houses = 0.9
+        while len(distance_matrix.columns) > 0 and len(distance_matrix.index) > 0:
+            objects_n = sum(distance_matrix.shape)
+            logger.debug(
+                f"Matrix shape: {distance_matrix.shape},"
+                f" Total objects: {objects_n},"
+                f" Selection range: {selection_range},"
+                f" Best houses: {best_houses}"
+            )
+
+            temp_destination_matrix = distance_matrix.apply(
+                lambda x: calculate_flows_y(x[x <= selection_range]), axis=1
+            )
+            temp_destination_matrix = temp_destination_matrix.fillna(0)
+            temp_destination_matrix = temp_destination_matrix.apply(balance_flows_to_demands, axis=0)
+            temp_destination_matrix = temp_destination_matrix.fillna(0)
+            temp_destination_matrix_aligned = temp_destination_matrix.reindex(
+                index=destination_matrix.index, columns=destination_matrix.columns, fill_value=0
+            )
+            del temp_destination_matrix
+            destination_matrix_np = destination_matrix.to_numpy()
+            temp_destination_matrix_np = temp_destination_matrix_aligned.to_numpy()
+            del temp_destination_matrix_aligned
+            destination_matrix = pd.DataFrame(
+                destination_matrix_np + temp_destination_matrix_np,
+                index=destination_matrix.index,
+                columns=destination_matrix.columns,
+            )
+            del destination_matrix_np, temp_destination_matrix_np
+            axis_1 = destination_matrix.sum(axis=1).astype(int)
+            axis_0 = destination_matrix.sum(axis=0).astype(int)
+
+            services_table["capacity_left"] = services_table["capacity"].subtract(axis_1, fill_value=0)
+            houses_table["demand_left"] = houses_table["demand"].subtract(axis_0, fill_value=0)
+            del axis_1, axis_0
+            distance_matrix = distance_matrix.drop(
+                index=services_table[services_table["capacity_left"] == 0].index.values,
+                columns=houses_table[houses_table["demand_left"] == 0].index.values,
+                errors="ignore",
+            )
+            distance_matrix = distance_matrix.loc[~(distance_matrix == np.inf).all(axis=1)]
+            distance_matrix = distance_matrix.loc[:, ~(distance_matrix == np.inf).all(axis=0)]
+
+            selection_range *= 1.5
+            if best_houses <= 0.1:
+                best_houses = 0
+            else:
+                objects_n_new = sum(distance_matrix.shape)
+                best_houses = objects_n_new / (objects_n / best_houses)
+
+        logger.debug("Done!")
+        del distance_matrix, houses_table, services_table
+        self.destination_matrix = destination_matrix
+
+        _additional_options(
+            self.demanded_buildings,
+            self.services,
+            self.adjacency_matrix,
+            self.destination_matrix,
+            self.threshold,
+        )
+
+        return (
+            self.demanded_buildings,
+            self.services,
+            _calc_links(
+                self.destination_matrix,
+                self.services,
+                self.demanded_buildings,
+                self.adjacency_matrix,
+            ),
+        )
+
+
+def _calc_links(
+    destination_matrix: pd.DataFrame,
+    services: gpd.GeoDataFrame,
+    buildings: gpd.GeoDataFrame,
+    distance_matrix: pd.DataFrame,
+):
+    buildings_ = buildings.copy()
+    services_ = services.copy()
+    buildings_.geometry = buildings_.representative_point()
+    services_.geometry = services_.representative_point()
+
+    def subfunc(loc):
+        try:
+            return [
+                {
+                    "building_index": int(k),
+                    "demand": int(v),
+                    "service_index": int(loc.name),
+                }
+                for k, v in loc.to_dict().items()
+            ]
+        except:
+            return np.NaN
+
+    def subfunc_geom(loc):
+        return LineString(
+            (
+                buildings_.geometry[loc["building_index"]],
+                services_.geometry[loc["service_index"]],
+            )
+        )
+
+    flat_matrix = destination_matrix.transpose().apply(lambda x: subfunc(x[x > 0]), result_type="reduce")
+
+    distribution_links = gpd.GeoDataFrame(data=[item for sublist in list(flat_matrix) for item in sublist])
+    if distribution_links.empty:
+        logger.warning(
+            "Unable to create distribution links - no demand could be matched with service locations. "
+            "This is likely because either: "
+            "1) The demand column in buildings contains zero values, or "
+            "2) The capacity column in services contains zero values, or "
+            "3) There are no service locations within the maximum allowed distance"
+        )
+        return distribution_links
+    distribution_links["distance"] = distribution_links.apply(
+        lambda x: distance_matrix.loc[x["service_index"]][x["building_index"]],
+        axis=1,
+        result_type="reduce",
+    )
+
+    sel = distribution_links["building_index"].isin(buildings_.index.values) & distribution_links["service_index"].isin(
+        services_.index.values
+    )
+    sel = distribution_links.loc[sel[sel].index.values]
+    distribution_links = distribution_links.set_geometry(sel.apply(subfunc_geom, axis=1)).set_crs(buildings_.crs)
+    distribution_links["distance"] = distribution_links["distance"].astype(float).round(2)
+    return distribution_links
+
+
+def _additional_options(
+    buildings,
+    services,
+    matrix,
+    destination_matrix,
+    normative_distance,
+):
+    buildings["avg_dist"] = 0
+    buildings["supplied_demands_within"] = 0
+    buildings["supplied_demands_without"] = 0
+    services["carried_capacity_within"] = 0
+    services["carried_capacity_without"] = 0
+    for _, loc in destination_matrix.iterrows():
+        distances_all = matrix.loc[loc.name]
+        distances = distances_all[distances_all <= normative_distance]
+        s = matrix.loc[loc.name] <= normative_distance
+        within = loc[s]
+        without = loc[~s]
+        within = within[within > 0]
+        without = without[without > 0]
+        buildings["avg_dist"] = (
+            buildings["avg_dist"]
+            .add(distances.multiply(within, fill_value=0), fill_value=0)
+            .add(distances_all.multiply(without, fill_value=0), fill_value=0)
+        )
+        buildings["demand_left"] = buildings["demand_left"].sub(within.add(without, fill_value=0), fill_value=0)
+        buildings["supplied_demands_within"] = buildings["supplied_demands_within"].add(within, fill_value=0)
+        buildings["supplied_demands_without"] = buildings["supplied_demands_without"].add(without, fill_value=0)
+
+        services.at[loc.name, "capacity_left"] = (
+            services.at[loc.name, "capacity_left"] - within.add(without, fill_value=0).sum()
+        )
+        services.at[loc.name, "carried_capacity_within"] = (
+            services.at[loc.name, "carried_capacity_within"] + within.sum()
+        )
+        services.at[loc.name, "carried_capacity_without"] = (
+            services.at[loc.name, "carried_capacity_without"] + without.sum()
+        )
+    buildings["min_dist"] = matrix.min(axis=0).replace(np.inf, None)
+    buildings["avg_dist"] = (buildings["avg_dist"] / (buildings["demand"] - buildings["demand_left"])).astype(
+        np.float32
+    )
+    buildings["avg_dist"] = buildings.apply(
+        lambda x: np.nan if (x["demand"] == x["demand_left"]) else round(x["avg_dist"], 2), axis=1
+    )
+    buildings["provision_value"] = (buildings["supplied_demands_within"] / buildings["demand"]).astype(float).round(2)
+    services["service_load"] = (services["capacity"] - services["capacity_left"]).astype(np.uint16)
+    buildings["supplied_demands_within"] = buildings["supplied_demands_within"].astype(np.uint16)
+    buildings["supplied_demands_without"] = buildings["supplied_demands_without"].astype(np.uint16)
+    services["carried_capacity_within"] = services["carried_capacity_within"].astype(np.uint16)
+    services["carried_capacity_without"] = services["carried_capacity_without"].astype(np.uint16)
+    logger.debug("Done adding additional options")

objectnat/methods/utils/__init__.py

@@ -0,0 +1 @@
+from .graph_utils import gdf_to_graph, graph_to_gdf

objectnat/methods/utils/geom_utils.py

@@ -0,0 +1,173 @@
+import math
+
+import geopandas as gpd
+from shapely import LineString, MultiPolygon, Point, Polygon
+from shapely.ops import polygonize, unary_union
+
+from objectnat import config
+
+logger = config.logger
+
+
+def polygons_to_multilinestring(geom: Polygon | MultiPolygon):
+    # pylint: disable-next=redefined-outer-name,reimported,import-outside-toplevel
+    from shapely import LineString, MultiLineString, MultiPolygon
+
+    def convert_polygon(polygon: Polygon):
+        lines = []
+        exterior = LineString(polygon.exterior)
+        lines.append(exterior)
+        interior = [LineString(p) for p in polygon.interiors]
+        lines = lines + interior
+        return lines
+
+    def convert_multipolygon(polygon: MultiPolygon):
+        return MultiLineString(sum([convert_polygon(p) for p in polygon.geoms], []))
+
+    if geom.geom_type == "Polygon":
+        return MultiLineString(convert_polygon(geom))
+    return convert_multipolygon(geom)
+
+
+def explode_linestring(geometry: LineString) -> list[LineString]:
+    """A function to return all segments of a linestring as a list of linestrings"""
+    coords_ext = geometry.coords  # Create a list of all line node coordinates
+    result = [LineString(part) for part in zip(coords_ext, coords_ext[1:])]
+    return result
+
+
+def point_side_of_line(line: LineString, point: Point) -> int:
+    """A positive indicates the left-hand side a negative indicates the right-hand side"""
+    x1, y1 = line.coords[0]
+    x2, y2 = line.coords[-1]
+    x, y = point.coords[0]
+    cross_product = (x2 - x1) * (y - y1) - (y2 - y1) * (x - x1)
+    if cross_product > 0:
+        return 1
+    return -1
+
+
+def get_point_from_a_thorough_b(a: Point, b: Point, dist):
+    """
+    Func to get Point from point a thorough point b on dist
+    """
+    direction = math.atan2(b.y - a.y, b.x - a.x)
+    c_x = a.x + dist * math.cos(direction)
+    c_y = a.y + dist * math.sin(direction)
+    return Point(c_x, c_y)
+
+
+def gdf_to_circle_zones_from_point(
+    gdf: gpd.GeoDataFrame, point_from: Point, zone_radius, resolution=4, explode_multigeom=True
+) -> gpd.GeoDataFrame:
+    """n_segments = 4*resolution,e.g. if resolution = 4 that means there will be 16 segments"""
+    crs = gdf.crs
+    buffer = point_from.buffer(zone_radius, resolution=resolution)
+    gdf_unary = gdf.clip(buffer, keep_geom_type=True).union_all()
+    gdf_geometry = (
+        gpd.GeoDataFrame(geometry=[gdf_unary], crs=crs)
+        .explode(index_parts=True)
+        .geometry.apply(polygons_to_multilinestring)
+        .union_all()
+    )
+    zones_lines = [LineString([Point(coords1), Point(point_from)]) for coords1 in buffer.exterior.coords[:-1]]
+    if explode_multigeom:
+        return (
+            gpd.GeoDataFrame(geometry=list(polygonize(unary_union([gdf_geometry] + zones_lines))), crs=crs)
+            .clip(gdf_unary, keep_geom_type=True)
+            .explode(index_parts=False)
+        )
+    return gpd.GeoDataFrame(geometry=list(polygonize(unary_union([gdf_geometry] + zones_lines))), crs=crs).clip(
+        gdf_unary, keep_geom_type=True
+    )
+
+
+def remove_inner_geom(polygon: Polygon | MultiPolygon):
+    """function to get rid of inner polygons"""
+    if isinstance(polygon, Polygon):
+        return Polygon(polygon.exterior.coords)
+    if isinstance(polygon, MultiPolygon):
+        polys = []
+        for poly in polygon.geoms:
+            polys.append(Polygon(poly.exterior.coords))
+        return MultiPolygon(polys)
+    else:
+        return Polygon()
+
+
+def combine_geometry(gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    """
+    Combine geometry of intersecting layers into a single GeoDataFrame.
+    Parameters
+    ----------
+    gdf: gpd.GeoDataFrame
+        A GeoPandas GeoDataFrame
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        The combined GeoDataFrame with aggregated in lists columns.
+
+    Examples
+    --------
+    >>> gdf = gpd.read_file('path_to_your_file.geojson')
+    >>> result = combine_geometry(gdf)
+    """
+
+    crs = gdf.crs
+
+    enclosures = gpd.GeoDataFrame(
+        geometry=list(polygonize(gdf["geometry"].apply(polygons_to_multilinestring).union_all())), crs=crs
+    )
+    enclosures_points = enclosures.copy()
+    enclosures_points.geometry = enclosures.representative_point()
+    joined = gpd.sjoin(enclosures_points, gdf, how="inner", predicate="within").reset_index()
+    cols = joined.columns.tolist()
+    cols.remove("geometry")
+    joined = joined.groupby("index").agg({column: list for column in cols})
+    joined["geometry"] = enclosures
+    joined = gpd.GeoDataFrame(joined, geometry="geometry", crs=crs)
+    return joined
+
+
+def distribute_points_on_linestrings(lines: gpd.GeoDataFrame, radius, lloyd_relax_n=2) -> gpd.GeoDataFrame:
+    lines = lines.copy()
+    lines = lines.explode(ignore_index=True)
+    lines = lines[lines.geom_type == "LineString"]
+    original_crs = lines.crs
+    lines = lines.to_crs(crs=lines.estimate_utm_crs())
+    lines = lines.reset_index(drop=True)
+    lines = lines[["geometry"]]
+    radius = radius * 1.1
+    segmentized = lines.geometry.apply(lambda x: x.simplify(radius).segmentize(radius))
+    points = [Point(pt) for line in segmentized for pt in line.coords]
+
+    points = gpd.GeoDataFrame(geometry=points, crs=lines.crs)
+    lines["lines"] = lines.geometry
+    geom_concave = lines.buffer(5, resolution=1).union_all()
+
+    for i in range(lloyd_relax_n):
+        points.geometry = points.voronoi_polygons().clip(geom_concave).centroid
+        points = points.sjoin_nearest(lines, how="left")
+        points = points[~points.index.duplicated(keep="first")]
+        points["geometry"] = points["lines"].interpolate(points["lines"].project(points.geometry))
+        points.drop(columns=["lines", "index_right"], inplace=True)
+
+    return points.dropna().to_crs(original_crs)
+
+
+def distribute_points_on_polygons(
+    polygons: gpd.GeoDataFrame, radius, only_exterior=True, lloyd_relax_n=2
+) -> gpd.GeoDataFrame:
+    polygons = polygons.copy()
+    polygons = polygons.explode(ignore_index=True)
+    polygons = polygons[polygons.geom_type == "Polygon"]
+
+    if only_exterior:
+        polygons.geometry = polygons.geometry.apply(lambda x: LineString(x.exterior))
+    else:
+        polygons = gpd.GeoDataFrame(
+            geometry=list(polygons.geometry.apply(polygons_to_multilinestring)), crs=polygons.crs
+        )
+
+    return distribute_points_on_linestrings(polygons, radius, lloyd_relax_n=lloyd_relax_n)