ObjectNat 0.2.4__tar.gz → 0.2.6__tar.gz

{objectnat-0.2.4 → objectnat-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ObjectNat
-Version: 0.2.4
+Version: 0.2.6
 Summary: ObjectNat is an open-source library created for geospatial analysis created by IDU team
 License: BSD-3-Clause
 Author: DDonnyy
@@ -12,15 +12,12 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: geopandas (>=0.14.3,<0.15.0)
-Requires-Dist: iduedu (>=0.2.0,<0.3.0)
-Requires-Dist: joblib (>=1.4.2,<2.0.0)
-Requires-Dist: jupyter (>=1.1.1,<2.0.0)
-Requires-Dist: networkx (>=3.2.1,<4.0.0)
-Requires-Dist: numpy (>=1.23.5,<2.0.0)
+Requires-Dist: iduedu (>=0.2.2,<0.3.0)
+Requires-Dist: networkx (>=3.3,<4.0)
+Requires-Dist: numpy (>=1.26.4,<2.0.0)
 Requires-Dist: pandarallel (>=1.6.5,<2.0.0)
 Requires-Dist: pandas (>=2.2.0,<3.0.0)
 Requires-Dist: population-restorator (>=0.2.3,<0.3.0)
-Requires-Dist: pulp (>=2.8.0,<3.0.0)
 Requires-Dist: scikit-learn (>=1.4.0,<2.0.0)
 Requires-Dist: tqdm (>=4.66.2,<5.0.0)
 Description-Content-Type: text/markdown

{objectnat-0.2.4 → objectnat-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ObjectNat"
-version = "0.2.4"
+version = "0.2.6"
 description = "ObjectNat is an open-source library created for geospatial analysis created by IDU team"
 license = "BSD-3-Clause"
 authors = ["DDonnyy <63115678+DDonnyy@users.noreply.github.com>"]
@@ -10,18 +10,15 @@ packages = [{ include = "objectnat", from = "src" }]
 
 [tool.poetry.dependencies]
 python = ">=3.10,<3.13"
-numpy = "^1.23.5"
+numpy = "^1.26.4"
 pandas = "^2.2.0"
 geopandas = "^0.14.3"
 tqdm = "^4.66.2"
 pandarallel = "^1.6.5"
-networkx = "^3.2.1"
-pulp = "^2.8.0"
+networkx = "^3.3"
 population-restorator = "^0.2.3"
-iduedu = "^0.2.0"
-joblib = "^1.4.2"
+iduedu = "^0.2.2"
 scikit-learn = "^1.4.0"
-jupyter = "^1.1.1"
 
 
 [tool.poetry.group.dev.dependencies]

objectnat-0.2.6/src/objectnat/_version.py

@@ -0,0 +1 @@
+VERSION = "0.2.6"

{objectnat-0.2.4 → objectnat-0.2.6}/src/objectnat/methods/living_buildings_osm.py

@@ -7,8 +7,6 @@ from shapely import MultiPolygon, Polygon
 
 from objectnat import config
 
-from ..utils import get_utm_crs_for_4326_gdf
-
 logger = config.logger
 
 
@@ -75,8 +73,8 @@ def eval_population(source: gpd.GeoDataFrame, population_column: str, area_per_p
     if "building:levels" not in source.columns:
         raise RuntimeError("No 'building:levels' column in provided GeoDataFrame")
     df = source.copy()
-    local_utm_crs = get_utm_crs_for_4326_gdf(source.to_crs(4326))
-    df["area"] = df.to_crs(local_utm_crs.to_epsg()).geometry.area.astype(float)
+    local_crs = source.estimate_utm_crs()
+    df["area"] = df.to_crs(local_crs).geometry.area.astype(float)
     df["building:levels_is_real"] = df["building:levels"].apply(lambda x: False if pd.isna(x) else True)
     df["building:levels"] = df["building:levels"].fillna(1)
     df["building:levels"] = pd.to_numeric(df["building:levels"], errors="coerce")

{objectnat-0.2.4 → objectnat-0.2.6}/src/objectnat/methods/provision/provision.py

@@ -4,8 +4,12 @@ import geopandas as gpd
 import numpy as np
 import pandas as pd
 
+from objectnat import config
+
 from .provision_model import Provision
 
+logger = config.logger
+
 
 def get_service_provision(
     buildings: gpd.GeoDataFrame,
@@ -39,7 +43,7 @@ def get_service_provision(
         demanded_buildings=buildings,
         adjacency_matrix=adjacency_matrix,
         threshold=threshold,
-    ).get_provisions()
+    ).run()
     return provision_buildings, provision_services, provision_links
 
 
@@ -69,12 +73,12 @@ def recalculate_links(
     services = services.copy()
     links = links.copy()
 
-    max_dist = links["distance"].max()
-    assert new_max_dist <= max_dist, "New distance exceeds max links distance"
-
     links_to_recalculate = links[links["distance"] > new_max_dist]
-    links_to_keep = links[links["distance"] <= new_max_dist]
+    if len(links_to_recalculate) == 0:
+        logger.warning("To clip distance exceeds max links distance, returning full provision")
+        return buildings, services, links
 
+    links_to_keep = links[links["distance"] <= new_max_dist]
     free_demand = links_to_recalculate.groupby("building_index").agg({"demand": list, "distance": list})
     free_demand["distance"] = free_demand.apply(
         lambda x: sum((x1 * x2) for x1, x2 in zip(x.demand, x.distance)), axis=1

{objectnat-0.2.4 → objectnat-0.2.6}/src/objectnat/methods/provision/provision_model.py

@@ -33,7 +33,7 @@ class Provision:
     column in 'services' or 'demand' column  'demanded_buildings' GeoDataFrame has no valid value.
     """
 
-    _destination_matrix = None
+    destination_matrix = None
 
     def __init__(
         self,
@@ -42,12 +42,13 @@ class Provision:
         adjacency_matrix: pd.DataFrame,
         threshold: int,
     ):
-        self.services = self.ensure_services(services)
-        self.demanded_buildings = self.ensure_buildings(demanded_buildings)
-        self.adjacency_matrix = self.delete_useless_matrix_rows_columns(adjacency_matrix, demanded_buildings, services)
+        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.check_crs(self.demanded_buildings, self.services)
-        print(config.pandarallel_use_file_system)
         pandarallel.initialize(progress_bar=False, verbose=0, use_memory_fs=config.pandarallel_use_file_system)
 
     @staticmethod
@@ -83,63 +84,16 @@ class Provision:
         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
+        return adjacency_matrix.transpose()
 
-    def get_provisions(self) -> Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
-        self._destination_matrix = pd.DataFrame(
-            0,
-            index=self.adjacency_matrix.columns,
-            columns=self.adjacency_matrix.index,
-        )
-        self.adjacency_matrix = self.adjacency_matrix.transpose()
-        logger.debug(
-            "Calculating provision from {} services to {} buildings.",
-            len(self.services),
-            len(self.demanded_buildings),
-        )
-        self.adjacency_matrix = self.adjacency_matrix.where(self.adjacency_matrix <= self.threshold * 3, np.inf)
-
-        self._destination_matrix = self._provision_loop_gravity(
-            self.demanded_buildings.copy(),
-            self.services.copy(),
-            self.adjacency_matrix.copy() + 1,
-            self.threshold,
-            self._destination_matrix.copy(),
-        )
-        _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 run(self) -> Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
 
-    def _provision_loop_gravity(
-        self,
-        houses_table: gpd.GeoDataFrame,
-        services_table: gpd.GeoDataFrame,
-        distance_matrix: pd.DataFrame,
-        selection_range,
-        destination_matrix: pd.DataFrame,
-        best_houses=0.9,
-    ):
-        def apply_function_based_on_size(df, func, axis, threshold=500):
+        def apply_function_based_on_size(df, func, axis, threshold=100):
             if len(df) > threshold:
                 return df.parallel_apply(func, axis=axis)
             return df.apply(func, axis=axis)
 
-        def _calculate_flows_y(loc):
+        def calculate_flows_y(loc):
             import numpy as np  # pylint: disable=redefined-outer-name,reimported,import-outside-toplevel
             import pandas as pd  # pylint: disable=redefined-outer-name,reimported,import-outside-toplevel
 
@@ -158,7 +112,7 @@ class Provision:
 
             return choice
 
-        def _balance_flows_to_demands(loc):
+        def balance_flows_to_demands(loc):
             import numpy as np  # pylint: disable=redefined-outer-name,reimported,import-outside-toplevel
             import pandas as pd  # pylint: disable=redefined-outer-name,reimported,import-outside-toplevel
 
@@ -177,43 +131,104 @@ class Provision:
                 return choice
             return loc
 
-        temp_destination_matrix = apply_function_based_on_size(
-            distance_matrix, lambda x: _calculate_flows_y(x[x <= selection_range]), 1
+        logger.debug(
+            f"Calculating provision from {len(self.services)} services to {len(self.demanded_buildings)} buildings."
         )
 
-        temp_destination_matrix = temp_destination_matrix.fillna(0)
-
-        temp_destination_matrix = apply_function_based_on_size(temp_destination_matrix, _balance_flows_to_demands, 0)
-
-        temp_destination_matrix = temp_destination_matrix.fillna(0)
-        destination_matrix = destination_matrix.add(temp_destination_matrix, fill_value=0)
-
-        axis_1 = destination_matrix.sum(axis=1)
-        axis_0 = destination_matrix.sum(axis=0)
-
-        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)
+        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)]
 
-        selection_range += selection_range
+        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 = apply_function_based_on_size(
+                distance_matrix, lambda x: calculate_flows_y(x[x <= selection_range]), 1
+            )
 
-        if best_houses > 0.1:
-            best_houses -= 0.1
+            temp_destination_matrix = temp_destination_matrix.fillna(0)
+            temp_destination_matrix = apply_function_based_on_size(temp_destination_matrix, balance_flows_to_demands, 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
-        if len(distance_matrix.columns) > 0 and len(distance_matrix.index) > 0:
-            return self._provision_loop_gravity(
-                houses_table, services_table, distance_matrix, selection_range, destination_matrix, best_houses
-            )
-        return destination_matrix
+            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(
@@ -279,8 +294,7 @@ def _additional_options(
     buildings["supplyed_demands_without"] = 0
     services["carried_capacity_within"] = 0
     services["carried_capacity_without"] = 0
-    for i in range(len(destination_matrix)):
-        loc = destination_matrix.iloc[i]
+    for i, 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
@@ -306,6 +320,7 @@ def _additional_options(
         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
     )
@@ -318,3 +333,4 @@ def _additional_options(
     buildings["supplyed_demands_without"] = buildings["supplyed_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-0.2.4/src/objectnat/_version.py

@@ -1 +0,0 @@
-VERSION = "0.2.4"

objectnat-0.2.4/src/objectnat/utils/__init__.py

@@ -1 +0,0 @@
-from .utils import get_utm_crs_for_4326_gdf

objectnat-0.2.4/src/objectnat/utils/utils.py

@@ -1,19 +0,0 @@
-import geopandas as gpd
-from pyproj import CRS
-from pyproj.aoi import AreaOfInterest
-from pyproj.database import query_utm_crs_info
-
-
-def get_utm_crs_for_4326_gdf(gdf: gpd.GeoDataFrame) -> CRS:
-    assert gdf.crs == CRS.from_epsg(4326), "provided GeoDataFrame is not in EPSG 4326"
-    minx, miny, maxx, maxy = gdf.total_bounds
-    utm_crs_list = query_utm_crs_info(
-        datum_name="WGS 84",
-        area_of_interest=AreaOfInterest(
-            west_lon_degree=minx,
-            south_lat_degree=miny,
-            east_lon_degree=maxx,
-            north_lat_degree=maxy,
-        ),
-    )
-    return CRS.from_epsg(utm_crs_list[0].code)