ObjectNat 0.1.5__py3-none-any.whl → 0.2.0__py3-none-any.whl

objectnat/methods/provision/city_provision.py

@@ -0,0 +1,291 @@
+# 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 CityProvision:
+    """
+    Represents the logic for city provision calculations using a gravity or linear model.
+
+    Args:
+        services (InstanceOf[gpd.GeoDataFrame]): GeoDataFrame representing the services available in the city.
+        demanded_buildings (InstanceOf[gpd.GeoDataFrame]): GeoDataFrame representing the buildings with demands for services.
+        adjacency_matrix (InstanceOf[pd.DataFrame]): DataFrame representing the adjacency matrix between buildings.
+        threshold (int): Threshold value for the provision calculations.
+        calculation_type (str, optional): Type of calculation ("gravity" or "linear"). Defaults to "gravity".
+
+    Returns:
+        CityProvision: 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)
+        self.demanded_buildings = self.ensure_buildings(demanded_buildings)
+        self.adjacency_matrix = adjacency_matrix
+        self.threshold = threshold
+        self.check_crs(self.demanded_buildings, self.services)
+        self.delete_useless_matrix_rows(self.adjacency_matrix, self.demanded_buildings)
+
+    @staticmethod
+    def ensure_buildings(v: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+        if "demand" not in v.columns:
+            raise DemandKeyError
+        v = v.copy()
+        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 = v.copy()
+        v["capacity_left"] = v["capacity"]
+        return v
+
+    @staticmethod
+    def check_crs(demanded_buildings, services):
+        assert (
+            demanded_buildings.crs == services.crs
+        ), f"\nThe CRS in the provided geodataframes are different.\nBuildings CRS:{demanded_buildings.crs}\nServices CRS:{services.crs} \n"
+
+    @staticmethod
+    def delete_useless_matrix_rows(adjacency_matrix, demanded_buildings):
+        adjacency_matrix.index = adjacency_matrix.index.astype(int)
+        indexes = set(demanded_buildings.index.astype(int).tolist())
+        rows = set(adjacency_matrix.index.astype(int).tolist())
+        dif = rows ^ indexes
+        adjacency_matrix.drop(index=(list(dif)), axis=0, inplace=True)
+
+    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._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,
+        )
+
+        # self.demanded_buildings['provision_value'] = self.demanded_buildings['provision_value'].fillna(0)
+        # self.services = self.services.fillna(0)
+
+        return (
+            self.demanded_buildings,
+            self.services,
+            _calc_links(
+                self._destination_matrix,
+                self.services,
+                self.demanded_buildings,
+                self.adjacency_matrix,
+            ),
+        )
+
+    def _provision_loop_gravity(
+        self,
+        houses_table: gpd.GeoDataFrame,
+        services_table: gpd.GeoDataFrame,
+        distance_matrix: pd.DataFrame,
+        selection_range,
+        destination_matrix: pd.DataFrame,
+        temp_destination_matrix=None,
+    ):
+        def _calculate_flows_y(loc):
+            c = services_table.loc[loc.name]["capacity_left"]
+            p = 1 / loc / loc
+            p = p / p.sum()
+            threshold = p.quantile(0.9)
+            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
+
+        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)
+        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 = 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",
+        )
+        selection_range += selection_range
+
+        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,
+                temp_destination_matrix,
+            )
+        return destination_matrix
+
+
+def _calc_links(
+    destination_matrix: pd.DataFrame,
+    services: gpd.GeoDataFrame,
+    buildings: gpd.GeoDataFrame,
+    distance_matrix: pd.DataFrame,
+):
+    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"]],
+            )
+        )
+
+    buildings_ = buildings.copy()
+    services_ = services.copy()
+    buildings_.geometry = buildings_.representative_point()
+    services_.geometry = services_.representative_point()
+    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])
+
+    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["supplyed_demands_within"] = 0
+    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]
+        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["supplyed_demands_within"] = buildings["supplyed_demands_within"].add(within, fill_value=0)
+        buildings["supplyed_demands_without"] = buildings["supplyed_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["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["provison_value"] = (buildings["supplyed_demands_within"] / buildings["demand"]).astype(float).round(2)
+    services["service_load"] = (services["capacity"] - services["capacity_left"]).astype(np.uint16)
+    buildings["supplyed_demands_within"] = buildings["supplyed_demands_within"].astype(np.uint16)
+    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)

objectnat/methods/provision/provision.py

@@ -0,0 +1,90 @@
+from typing import Tuple
+
+import geopandas as gpd
+import numpy as np
+import pandas as pd
+
+from .city_provision import CityProvision
+
+
+def get_service_provision(
+    buildings: gpd.GeoDataFrame,
+    adjacency_matrix: pd.DataFrame,
+    services: gpd.GeoDataFrame,
+    threshold: int,
+) -> Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
+    """Calculate load from buildings with demands on the given services using the distances matrix between them.
+
+    Args:
+        services (gpd.GeoDataFrame): GeoDataFrame of services
+        adjacency_matrix (pd.DataFrame): DataFrame representing the adjacency matrix
+        buildings (gpd.GeoDataFrame): GeoDataFrame of demanded buildings
+        threshold (int): Threshold value
+    Returns:
+        Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]: Tuple of GeoDataFrames representing provision
+        buildings, provision services, and provision links
+    """
+    provision_buildings, provision_services, provision_links = CityProvision(
+        services=services,
+        demanded_buildings=buildings,
+        adjacency_matrix=adjacency_matrix,
+        threshold=threshold,
+    ).get_provisions()
+    return provision_buildings, provision_services, provision_links
+
+
+def clip_provision(
+    buildings: gpd.GeoDataFrame, services: gpd.GeoDataFrame, links: gpd.GeoDataFrame, selection_zone: gpd.GeoDataFrame
+) -> Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
+
+    assert (
+        selection_zone.crs == buildings.crs == services.crs == links.crs
+    ), f"CRS mismatch: buildings_crs:{buildings.crs}, links_crs:{links.crs} , services_crs:{services.crs}, selection_zone_crs:{selection_zone.crs}"
+
+    s = buildings.intersects(selection_zone.unary_union)
+    buildings = buildings.loc[s[s].index]
+    links = links[links["building_index"].isin(buildings.index.tolist())]
+    services_to_keep = set(links["service_index"].tolist())
+    services.drop(list(set(services.index.tolist()) - services_to_keep), inplace=True)
+    return buildings, services, links
+
+
+def recalculate_links(
+    buildings: gpd.GeoDataFrame, services: gpd.GeoDataFrame, links: gpd.GeoDataFrame, new_max_dist: float
+) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
+    buildings = buildings.copy()
+    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]
+
+    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
+    )
+    free_demand["demand"] = free_demand["demand"].apply(sum)
+    free_demand = free_demand.reindex(buildings.index, fill_value=0)
+    new_sum_time = (buildings["supplyed_demands_within"] + buildings["supplyed_demands_without"]) * buildings[
+        "avg_dist"
+    ] - free_demand["distance"]
+
+    buildings["demand_left"] = buildings["demand_left"] + free_demand["demand"]
+    buildings["supplyed_demands_without"] = buildings["supplyed_demands_without"] - free_demand["demand"]
+    buildings["avg_dist"] = new_sum_time / (
+        buildings["supplyed_demands_without"] + buildings["supplyed_demands_within"]
+    )
+    buildings["avg_dist"] = buildings.apply(
+        lambda x: np.nan if (x["demand"] == x["demand_left"]) else round(x["avg_dist"], 2), axis=1
+    )
+
+    free_capacity = links_to_recalculate.groupby("service_index").agg({"demand": "sum"})
+    free_capacity = free_capacity.reindex(services.index, fill_value=0)
+    services["capacity_left"] = services["capacity_left"] + free_capacity["demand"]
+    services["carried_capacity_without"] = services["carried_capacity_without"] - free_capacity["demand"]
+    services["service_load"] = services["service_load"] - free_capacity["demand"]
+
+    return buildings, services, links_to_keep

objectnat/methods/provision/provision_exceptions.py

@@ -0,0 +1,59 @@
+class CapacityKeyError(KeyError):
+    def __init__(self, *args):
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return "CapacityKeyError, {0} ".format(self.message)
+
+        return (
+            "Column 'capacity' was not found in provided 'services' GeoDataFrame. This attribute "
+            "corresponds to the total capacity for each service."
+        )
+
+
+class CapacityValueError(ValueError):
+    def __init__(self, *args):
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return "CapacityValueError, {0} ".format(self.message)
+
+        return "Column 'capacity' in 'services' GeoDataFrame  has no valid value."
+
+
+class DemandKeyError(KeyError):
+    def __init__(self, *args):
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return "DemandKeyError, {0} ".format(self.message)
+
+        return (
+            "The column 'demand' was not found in the provided 'demanded_buildings' GeoDataFrame. "
+            "This attribute corresponds to the number of demands for the selected service in each building."
+        )
+
+
+class DemandValueError(ValueError):
+    def __init__(self, *args):
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        if self.message:
+            return "DemandValueError, {0} ".format(self.message)
+        return "Column 'demand' in 'demanded_buildings' GeoDataFrame  has no valid value."

objectnat/methods/visibility_analysis.py

@@ -4,12 +4,15 @@ from multiprocessing import cpu_count
 import geopandas as gpd
 import numpy as np
 import pandas as pd
-from loguru import logger
 from pandarallel import pandarallel
 from shapely import LineString, MultiPolygon, Point, Polygon
 from shapely.ops import polygonize, unary_union
 from tqdm.contrib.concurrent import process_map
 
+from objectnat import config
+
+logger = config.logger
+
 
 def get_visibility_accurate(point_from: Point, obstacles: gpd.GeoDataFrame, view_distance) -> Polygon:
     """

{objectnat-0.1.5.dist-info → objectnat-0.2.0.dist-info}/METADATA

@@ -1,18 +1,18 @@
 Metadata-Version: 2.1
 Name: ObjectNat
-Version: 0.1.5
+Version: 0.2.0
 Summary: ObjectNat is an open-source library created for geospatial analysis created by IDU team
 License: BSD-3-Clause
-Author: Danila
+Author: DDonnyy
 Author-email: 63115678+DDonnyy@users.noreply.github.com
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.10,<3.13
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: dongraphio (>=0.3.13,<0.4.0)
 Requires-Dist: geopandas (>=0.14.3,<0.15.0)
+Requires-Dist: iduedu (>=0.1.3,<0.2.0)
 Requires-Dist: joblib (>=1.4.2,<2.0.0)
 Requires-Dist: networkit (>=11.0,<12.0)
 Requires-Dist: networkx (>=3.2.1,<4.0.0)
@@ -20,7 +20,7 @@ Requires-Dist: numpy (>=1.23.5,<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: provisio (>=0.1.7,<0.2.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
@@ -28,58 +28,58 @@ Description-Content-Type: text/markdown
 # ObjectNat - Meta Library
 
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![PyPI version](https://img.shields.io/pypi/v/objectnat.svg)](https://pypi.org/project/objectnat/)
 
 <p align="center">
-<img src="https://i.ibb.co/FWtHNQv/logo.png" alt="logo" width="400">
+<img src="https://github.com/user-attachments/assets/d3878cce-8eba-4f96-8458-9a798d436120" alt="logo" width="400">
 </p>
 
 #### **ObjectNat** is an open-source library created for geospatial analysis created by **IDU team**
 
 ## ObjectNat Components
 
-- [dongraphio](https://github.com/DDonnyy/dongraphio) : `dongraphio` provides graph functions
-- [provisio](https://github.com/DDonnyy/provisio) : `provisio` provides main provisio fuctions
+- [IduEdu](https://github.com/DDonnyy/IduEdu) : `IduEdu` provides graph functions
 - [population-restorator](https://github.com/kanootoko/population-restorator) : `restorator` provides city resettlement
 
 ## Features and how to use
 
-1. **[City graph from OSM](./examples/graph_generator.ipynb)** - Function to assemble a road, pedestrian, and public
-   transport graph from OpenStreetMap (OSM) and creating Intermodal graph.
+1. **[City graph from OSM (IduEdu)](https://github.com/DDonnyy/IduEdu/blob/main/examples/get_any_graph.ipynb)** - Functions to assemble a road, pedestrian,
+   and public transport graph from OpenStreetMap (OSM) and creating Intermodal graph. 
 
-   <img src="https://i.ibb.co/VpsPgL1/Graph-generator-v1.webp" alt="Graph-generator-v1" height="250">
+   <img src="https://github.com/user-attachments/assets/8dc98da9-8462-415e-8cc8-bdfca788e206" alt="IntermodalGraph" height="250">
 
 2. **[Adjacency matrix](./examples/calculate_adjacency_matrix.ipynb)** - Calculate adjacency matrix based on the provided
    graph and edge weight type (time or distance). The intermodal graph can be obtained using the previous example.
+
 3. **[Isochrones,transport accessibility](./examples/isochrone_generator.ipynb)** - Function for generating isochrones to
    analyze transportation accessibility from specified starting coordinates. Isochrones can be constructed based on
    pedestrian, automobile, or public transport graphs, or a combination thereof.
 
-   <img src="https://i.ibb.co/QM0tmZ2/isochrones-from-2-points.webp" alt="isochrones-from-2-points" height="250">
+   <img src="https://github.com/user-attachments/assets/37f308a5-db56-497d-b080-4edef3584fe5" alt="isochrones" height="250">
 
 4. **[Population restoration](./examples/restore_population.ipynb)** - Function for resettling population into the provided
    layer of residential buildings. This function distributes people among dwellings based on the total city population
    and the living area of each house.
 5. **[Service provision](./examples/calculate_provision.ipynb)** - Function for calculating the provision of residential
-   buildings and population with services. In case of missing data, this function utilizes previously described
-   functionality to retrieve the necessary information.
+   buildings and population with services. 
+
+   <img src="https://github.com/user-attachments/assets/5f2b3c55-9a02-4d70-80f4-503b77023eda" alt="ProvisionSchools" height="250">
 
-   <img src="https://i.ibb.co/CW7Xj5F/Burger-Provision5min.webp" alt="Burger-Provision5min" height="250">
-   
 6. **[Visibility analysis](./examples/visibility_analysis.ipynb)** - Function to get a quick estimate of visibility from a
    given point(s) to buildings within a given distance. Also, there is a visibility catchment area calculator for a
    large
    urban area. This function is designed to work with at least 1000 points spaced 10-20 meters apart for optimal
    results. Points can be generated using a road graph and random point distribution along edges.
 
-   <img src="https://i.ibb.co/LxcGTfN/visibility-from-point.webp" alt="visibility-from-point" height="250"> 
-
-   <img src="https://i.ibb.co/zNRzXc5/visibility-catchment-area.webp" alt="visibility-catchment-area" height="250">
+   <img src="https://github.com/user-attachments/assets/2927ac86-01e8-4b0e-9ea8-72ad81c13cf5" alt="visibility-from-point" height="250"> 
 
+   <img src="https://github.com/user-attachments/assets/b5b0d4b3-a02f-4ade-8772-475703cd6435" alt="visibility-catchment-area" height="250">
+   
 7. **[Point clusterization](./examples/point_clusterization.ipynb)** - Function to generate cluster polygons for given
    points based on a specified minimum distance and minimum points per cluster. Optionally, calculate the relative ratio
    between types of services within the clusters.
 
-   <img src="https://i.ibb.co/fF3c4YC/service-clusterization.webp" alt="service-clusterization" height="250">
+   <img src="https://github.com/user-attachments/assets/2a9ad722-87d2-4954-9612-5ac3765aa824" alt="service-clusterization" height="250">
 
 ## Installation
 
@@ -88,7 +88,16 @@ Description-Content-Type: text/markdown
 ```
 pip install ObjectNat
 ```
+### Configuration changes
+
+```python
+from objectnat import config
 
+config.set_timeout(10)  # Timeout for overpass queries
+config.change_logger_lvl('INFO')  # To mute all debug msgs
+config.set_enable_tqdm(False)  # To mute all tqdm's progress bars
+config.set_overpass_url('http://your.overpass-api.de/interpreter/URL')
+```
 ## Contacts
 
 - [NCCR](https://actcognitive.org/) - National

objectnat-0.2.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+objectnat/__init__.py,sha256=OnDvrLPLEeYIE_9qOVYgMc-PkRzIqShtGxirguEXiRU,260
+objectnat/_api.py,sha256=oiEO2P-tv6AMDdNoT8d0BWMmgeUJa4bhzGDTU2BWTXI,704
+objectnat/_config.py,sha256=t4nv83Tj4fwYjdzwUh0bA8b_12DqL-GlEVfKaG_hccg,2107
+objectnat/_version.py,sha256=w9Iw7QVvd8lme2wKwEbCo5IgetVjSfFBOOYAcA_Q0Ns,18
+objectnat/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+objectnat/methods/balanced_buildings.py,sha256=hLT2QgmGWpROtnL8SJQIujeP6q9ou15yIdHpv66CfMs,2892
+objectnat/methods/cluster_points_in_polygons.py,sha256=2oHK-_CauEz8dZX6r-UGEopkqdUENLGaJPpMTuVV_o8,4678
+objectnat/methods/coverage_zones.py,sha256=yMeK1DjneMAxxKv9busEKdAsP25xiJMcPCixlJCDI4s,2835
+objectnat/methods/isochrones.py,sha256=CeNTVpUnlITaacamB5mJQjnbphXckC1FJ0L1EThswhU,6111
+objectnat/methods/living_buildings_osm.py,sha256=pHyeDSKhs4j05Wr3Z_QBxLfLbiZpbwdj_SXz7qQ7V2M,6041
+objectnat/methods/provision/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+objectnat/methods/provision/city_provision.py,sha256=Ireg4AGoMdDvf9Fa7ILIOzLJcbqTtpeIHAKp_rqvTAE,11876
+objectnat/methods/provision/provision.py,sha256=BrwfKcGoRwNcLL9fZ6mU9m6kMuGnAIgxGHfXdgHA39o,4057
+objectnat/methods/provision/provision_exceptions.py,sha256=-TK4A-vacUuzlPJGSt2YyawRwKDLCZFlAbuIvIf1FnY,1723
+objectnat/methods/visibility_analysis.py,sha256=__S01m4YcIZbUcr6Umzvr4NpaCsajXxKNcfJm3zquVY,20690
+objectnat/utils/__init__.py,sha256=w8R5V_Ws_GUt4hLwpudMgjXvocG4vCxWSzVw_jTReQ4,44
+objectnat/utils/utils.py,sha256=_vbCW-XTHwZOR3yNlzf_vgNwbYwonhGlduSznGufEgs,638
+objectnat-0.2.0.dist-info/LICENSE.txt,sha256=yPEioMfTd7JAQgAU6J13inS1BSjwd82HFlRSoIb4My8,1498
+objectnat-0.2.0.dist-info/METADATA,sha256=5rwXA6qcLxRoUftmD2yoZP3715ghrA1v-7g_MmeLYXI,5354
+objectnat-0.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+objectnat-0.2.0.dist-info/RECORD,,

{objectnat-0.1.5.dist-info → objectnat-0.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any

objectnat/methods/adjacency_matrix.py

@@ -1,39 +0,0 @@
-import geopandas as gpd
-import networkx as nx
-import pandas as pd
-from dongraphio import DonGraphio
-from loguru import logger
-from pydantic import ValidationError
-
-
-def get_adjacency_matrix(
-    buildings_from: gpd.GeoDataFrame,
-    services_to: gpd.GeoDataFrame,
-    weight: str,
-    city_crs: int | None = None,
-    nx_graph: nx.MultiDiGraph | None = None,
-    dongraphio: DonGraphio | None = None,
-    graph_type=None,
-) -> pd.DataFrame:
-    """
-    Get the adjacency matrix for the specified city graph, buildings, and services.
-
-    Args:
-        nx_graph (nx.Graph): The networkx graph.
-        buildings_from (gpd.GeoDataFrame): GeoDataFrame representing buildings to build matrix from.
-        services_to (gpd.GeoDataFrame): GeoDataFrame representing services to build matrix to.
-        weight (str): The weight attribute, could be only "time_min" or "length_meter".
-
-    Returns:
-        pd.DataFrame: The adjacency matrix.
-    """
-    try:
-        if dongraphio:
-            return dongraphio.get_adjacency_matrix(buildings_from, services_to, weight, graph_type=graph_type)
-
-        dongraphio = DonGraphio(city_crs)
-        dongraphio.set_graph(nx_graph)
-        return dongraphio.get_adjacency_matrix(buildings_from, services_to, weight, graph_type=graph_type)
-    except ValidationError as e:
-        logger.error("Function get_adjacency_matrix() missing 'weight' argument")
-        raise e