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

objectnat/__init__.py

@@ -1,18 +1,13 @@
-__version__ = "0.1.4"
+"""
+ObjectNat
+========
 
-from dongraphio.enums import GraphType
 
-from .methods.adjacency_matrix import get_adjacency_matrix
-from .methods.balanced_buildings import get_balanced_buildings
-from .methods.cluster_points_in_polygons import get_clusters_polygon
-from .methods.coverage_zones import get_isochrone_zone_coverage, get_radius_zone_coverage
-from .methods.demands import get_demands
-from .methods.isochrones import get_accessibility_isochrones
-from .methods.osm_graph import get_intermodal_graph_from_osm
-from .methods.provision import NoOsmIdException, NoWeightAdjacencyException, get_provision
-from .methods.visibility_analysis import (
-    calculate_visibility_catchment_area,
-    get_visibilities_from_points,
-    get_visibility,
-    get_visibility_accurate,
-)
+ObjectNat is an open-source library created for geospatial analysis created by IDU team.
+
+Homepage https://github.com/DDonnyy/ObjectNat.
+"""
+
+from ._config import config
+from ._api import *
+from ._version import VERSION as __version__

objectnat/_api.py

@@ -0,0 +1,15 @@
+# pylint: disable=unused-import,wildcard-import,unused-wildcard-import
+from iduedu import *
+
+from .methods.balanced_buildings import get_balanced_buildings
+from .methods.cluster_points_in_polygons import get_clusters_polygon
+from .methods.coverage_zones import get_isochrone_zone_coverage, get_radius_zone_coverage
+from .methods.isochrones import get_accessibility_isochrones
+from .methods.living_buildings_osm import download_buildings
+from .methods.provision.provision import clip_provision, get_service_provision, recalculate_links
+from .methods.visibility_analysis import (
+    calculate_visibility_catchment_area,
+    get_visibilities_from_points,
+    get_visibility,
+    get_visibility_accurate,
+)

objectnat/_config.py

@@ -0,0 +1,67 @@
+import sys
+from typing import Literal
+
+from iduedu import config as iduedu_config
+from loguru import logger
+
+
+class Config:
+    """
+    A configuration class to manage global settings for the application, such as Overpass API URL,
+    timeouts, and logging options.
+
+    Attributes
+    ----------
+    overpass_url : str
+        URL for accessing the Overpass API. Defaults to "http://lz4.overpass-api.de/api/interpreter".
+    timeout : int or None
+        Timeout in seconds for API requests. If None, no timeout is applied.
+    enable_tqdm_bar : bool
+        Enables or disables progress bars (via tqdm). Defaults to True.
+    logger : Logger
+        Logging instance to handle application logging.
+
+    Methods
+    -------
+    change_logger_lvl(lvl: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR"])
+        Changes the logging level to the specified value.
+    set_overpass_url(url: str)
+        Sets a new Overpass API URL.
+    set_timeout(timeout: int)
+        Sets the timeout for API requests.
+    set_enable_tqdm(enable: bool)
+        Enables or disables progress bars in the application.
+    """
+
+    def __init__(
+        self,
+        overpass_url="http://lz4.overpass-api.de/api/interpreter",
+        timeout=None,
+        enable_tqdm_bar=True,
+    ):
+        self.overpass_url = overpass_url
+        self.timeout = timeout
+        self.enable_tqdm_bar = enable_tqdm_bar
+        self.logger = logger
+        self.iduedu_config = iduedu_config
+
+    def change_logger_lvl(self, lvl: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR"]):
+        self.logger.remove()
+        self.logger.add(sys.stderr, level=lvl)
+        self.iduedu_config.change_logger_lvl(lvl)
+
+    def set_overpass_url(self, url: str):
+        self.overpass_url = url
+        self.iduedu_config.set_overpass_url(url)
+
+    def set_timeout(self, timeout: int):
+        self.timeout = timeout
+        self.iduedu_config.set_timeout(timeout)
+
+    def set_enable_tqdm(self, enable: bool):
+        self.enable_tqdm_bar = enable
+        self.iduedu_config.set_enable_tqdm(enable)
+
+
+config = Config()
+config.change_logger_lvl("INFO")

objectnat/_version.py

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

objectnat/methods/balanced_buildings.py

@@ -1,7 +1,10 @@
 import geopandas as gpd
 import population_restorator.balancer.houses as b_build
 import population_restorator.balancer.territories as b_terr
-from loguru import logger
+
+from objectnat import config
+
+logger = config.logger
 
 
 def get_balanced_buildings(

objectnat/methods/cluster_points_in_polygons.py

@@ -2,9 +2,12 @@ from typing import Literal
 
 import geopandas as gpd
 import pandas as pd
-from loguru import logger
 from sklearn.cluster import DBSCAN, HDBSCAN
 
+from objectnat import config
+
+logger = config.logger
+
 
 def _get_cluster(services_select, min_dist, min_point, method):
     services_coords = pd.DataFrame(

objectnat/methods/coverage_zones.py

@@ -2,8 +2,6 @@ from typing import Literal
 
 import geopandas as gpd
 import networkx as nx
-import pandas as pd
-from dongraphio import GraphType
 
 from .isochrones import get_accessibility_isochrones
 
@@ -48,7 +46,6 @@ def get_isochrone_zone_coverage(
     weight_type: Literal["time_min", "length_meter"],
     weight_value: int,
     city_graph: nx.Graph,
-    graph_type: list[GraphType],
 ) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]:
     """
     Create isochrones for each service location based on travel time/distance.
@@ -56,15 +53,13 @@ def get_isochrone_zone_coverage(
     Parameters
     ----------
     services : gpd.GeoDataFrame
-        GeoDataFrame containing the service locations.
+        Layer containing the service locations.
     weight_type : str
         Type of weight used for calculating isochrones, either "time_min" or "length_meter".
     weight_value : int
         The value of the weight, representing time in minutes or distance in meters.
     city_graph : nx.Graph
         The graph representing the city's transportation network.
-    graph_type : list[GraphType]
-        List of graph types to be used for isochrone calculations.
 
     Returns
     -------
@@ -76,10 +71,10 @@ def get_isochrone_zone_coverage(
     >>> import networkx as nx
     >>> import geopandas as gpd
     >>> from shapely.geometry import Point
-    >>> from dongraphio import GraphType
+     >>> from iduedu import get_intermodal_graph
 
-    >>> # Create a sample city graph or download it from osm with get_intermodal_graph_from_osm()
-    >>> city_graph = nx.MultiDiGraph()
+    >>> # Create a sample city graph with get_intermodal_graph()
+    >>> graph = get_intermodal_graph(polygon=my_territory_polygon)
 
     >>> # Create a sample GeoDataFrame for services
     >>> services = gpd.read_file('services.geojson')
@@ -87,19 +82,9 @@ def get_isochrone_zone_coverage(
     >>> # Define parameters
     >>> weight_type = "time_min"
     >>> weight_value = 10
-    >>> graph_type = [GraphType.PUBLIC_TRANSPORT, GraphType.WALK]
 
     >>> # Get isochrone zone coverage
-    >>> isochrone_zones = get_isochrone_zone_coverage(services, weight_type, weight_value, city_graph, graph_type)
-    >>> isochrone_zones[0] # represent isochrones geodataframe
+    >>> isochrones, pt_stops, pt_routes = get_isochrone_zone_coverage(services, weight_type, weight_value, city_graph)
     """
-    assert services.crs == city_graph.graph["crs"], "CRS not match"
-    points = services.geometry.representative_point()
-    iso, routes, stops = get_accessibility_isochrones(
-        points, graph_type, weight_value, weight_type, city_graph, points.crs.to_epsg()
-    )
-    services_ = services.copy()
-    iso = gpd.GeoDataFrame(
-        pd.concat([iso.drop(columns=["point", "point_number"]), services_.drop(columns=["geometry"])], axis=1)
-    )
+    iso, routes, stops = get_accessibility_isochrones(services, weight_value, weight_type, city_graph)
     return iso, routes, stops

objectnat/methods/isochrones.py

@@ -1,66 +1,140 @@
+from typing import Literal
+
 import geopandas as gpd
 import networkx as nx
-from dongraphio import DonGraphio, GraphType
+import numpy as np
+import pandas as pd
+from osmnx import graph_to_gdfs
+from pyproj import CRS
+from scipy.spatial import KDTree
 from shapely import Point
+from shapely.ops import unary_union
+
+from objectnat import config
+
+logger = config.logger
 
 
 def get_accessibility_isochrones(
-    points: Point | gpd.GeoSeries,
-    graph_type: list[GraphType],
-    weight_value: int,
-    weight_type: str,
-    city_graph: nx.MultiDiGraph,
-    city_crs: int,
+    points: gpd.GeoDataFrame,
+    weight_value: float,
+    weight_type: Literal["time_min", "length_meter"],
+    graph_nx: nx.Graph,
 ) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]:
     """
-    Calculate accessibility isochrones based on the provided city graph for the selected graph_type from point(s).
+    Calculate accessibility isochrones from a gpd.GeoDataFrame based on the provided city graph.
+
+    Isochrones represent areas that can be reached from a given point within a specific time or distance,
+    using a graph that contains road and transport network data.
 
     Parameters
     ----------
-    points : Point or gpd.GeoSeries
-        Points from which the isochrones will be calculated.
-    graph_type : list[GraphType]
-        List of graph types to calculate isochrones for.
-    weight_value : int
-        Weight value for the accessibility calculations.
-    weight_type : str
-        The type of the weight, could be either "time_min" or "length_meter".
-    city_graph : nx.MultiDiGraph
-        The graph representing the city.
-    city_crs : int
-        The CRS (Coordinate Reference System) for the city.
+    points : gpd.GeoDataFrame
+        A GeoDataFrame containing the geometry from which accessibility isochrones should be calculated.
+        The CRS of this GeoDataFrame must match the CRS of the provided graph.
+    weight_value : float
+        The maximum distance or time threshold for calculating isochrones.
+    weight_type : Literal["time_min", "length_meter"]
+        The type of weight to use for distance calculations. Either time in minutes ("time_min") or distance
+        in meters ("length_meter").
+    graph_nx : nx.Graph
+        A NetworkX graph representing the city network.
+        The graph must contain the appropriate CRS and, for time-based isochrones, a speed attribute.
 
     Returns
     -------
     tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]
-        A tuple containing the accessibility isochrones, and optionally the routes and stops.
+        A tuple containing:
+        - isochrones : GeoDataFrame with the calculated isochrone geometries.
+        - public transport stops (if applicable) : GeoDataFrame with public transport stops within the isochrone, or None if not applicable.
+        - public transport routes (if applicable) : GeoDataFrame with public transport routes within the isochrone, or None if not applicable.
 
     Examples
     --------
-    >>> import networkx as nx
-    >>> import geopandas as gpd
-    >>> from shapely.geometry import Point
-    >>> from dongraphio import GraphType
-
-    >>> # Create a sample city graph or download it from osm with get_intermodal_graph_from_osm()
-    >>> city_graph = nx.MultiDiGraph()
-
-    >>> # Define parameters
-    >>> graph_type = [GraphType.PUBLIC_TRANSPORT, GraphType.WALK]
-    >>> points = gpd.GeoSeries([Point(0, 0)])
-    >>> weight_value = 15
-    >>> weight_type = "time_min"
-    >>> city_crs = 4326 # Should be the same with CRS of the city graph
-
-    >>> # Calculate isochrones
-    >>> isochrones, routes, stops = get_accessibility_isochrones(
-    ...     graph_type, points, weight_value, weight_type, city_graph, city_crs
-    ... )
-
-    >>> print(isochrones)
-    >>> print(routes)
-    >>> print(stops)
+    >>> from iduedu import get_intermodal_graph
+    >>> graph = get_intermodal_graph(polygon=my_territory_polygon)
+    >>> points = gpd.GeoDataFrame(geometry=[Point(30.33, 59.95)], crs=4326).to_crs(graph.graph['crs'])
+    >>> isochrones, pt_stops, pt_routes = get_accessibility_isochrones(points, weight_value=15, weight_type="time_min", graph_nx=my_graph)
+
     """
-    dongraphio = DonGraphio(city_crs)
-    dongraphio.set_graph(city_graph)
-    return dongraphio.get_accessibility_isochrones(graph_type, points, weight_value, weight_type)
+
+    assert points.crs == CRS.from_epsg(
+        graph_nx.graph["crs"]
+    ), f'CRS mismatch , points.crs = {points.crs.to_epsg()}, graph["crs"] = {graph_nx.graph["crs"]}'
+
+    nodes_with_data = list(graph_nx.nodes(data=True))
+    logger.info("Calculating isochrones distances...")
+    coordinates = np.array([(data["x"], data["y"]) for node, data in nodes_with_data])
+    tree = KDTree(coordinates)
+
+    target_coord = [(p.x, p.y) for p in points.representative_point()]
+    distances, indices = tree.query(target_coord)
+
+    nearest_nodes = [nodes_with_data[idx][0] for idx in indices]
+    del nodes_with_data
+    dist_nearest = pd.DataFrame(data=distances, index=nearest_nodes, columns=["dist"])
+    speed = 0
+    if graph_nx.graph["type"] in ["walk", "intermodal"] and weight_type == "time_min":
+        try:
+            speed = graph_nx.graph["walk_speed"]
+        except KeyError:
+            logger.warning("There is no walk_speed in graph, set to the default speed - 83.33 m/min")
+            speed = 83.33
+        dist_nearest = dist_nearest / speed
+    elif weight_type == "time_min":
+        speed = 20 * 1000 / 60
+        dist_nearest = dist_nearest / speed
+
+    if (dist_nearest > weight_value).all().all():
+        raise RuntimeError(
+            "The point(s) lie further from the graph than weight_value, it's impossible to "
+            "construct isochrones. Check the coordinates of the point(s)/their projection"
+        )
+
+    data = []
+    for source in nearest_nodes:
+        dist, path = nx.single_source_dijkstra(graph_nx, source, weight=weight_type, cutoff=weight_value)
+        for target_node, way in path.items():
+            source = way[0]
+            distance = dist.get(target_node, np.nan)
+            data.append((source, target_node, distance))
+    del dist
+    dist_matrix = pd.DataFrame(data, columns=["source", "destination", "distance"])
+    del data
+    dist_matrix = dist_matrix.pivot_table(index="source", columns="destination", values="distance", sort=False)
+
+    dist_matrix = dist_matrix.add(dist_nearest.dist, axis=0)
+    dist_matrix = dist_matrix.mask(dist_matrix >= weight_value, np.nan)
+    dist_matrix.dropna(how="all", inplace=True)
+
+    results = []
+    logger.info("Building isochrones geometry...")
+    for _, row in dist_matrix.iterrows():
+        geometry = []
+        for node_to, value in row.items():
+            if not pd.isna(value):
+                node = graph_nx.nodes[node_to]
+                point = Point(node["x"], node["y"])
+                geometry.append(
+                    point.buffer(round((weight_value - value) * speed * 0.8, 2))
+                    if weight_type == "time_min"
+                    else point.buffer(round((weight_value - value) * 0.8, 2))
+                )
+        geometry = unary_union(geometry)
+        results.append(geometry)
+
+    isochrones = gpd.GeoDataFrame(data=points, geometry=results, crs=graph_nx.graph["crs"])
+    isochrones["weight_type"] = weight_type
+    isochrones["weight_value"] = weight_value
+
+    isochrones_subgraph = graph_nx.subgraph(dist_matrix.columns)
+    nodes = pd.DataFrame.from_dict(dict(isochrones_subgraph.nodes(data=True)), orient="index")
+    if "desc" in nodes.columns and "stop" in nodes["desc"].unique():
+        pt_nodes = nodes[nodes["desc"] == "stop"]
+        nodes, edges = graph_to_gdfs(isochrones_subgraph.subgraph(pt_nodes.index))
+        nodes.reset_index(drop=True, inplace=True)
+        nodes = nodes[["desc", "route", "geometry"]]
+        edges.reset_index(drop=True, inplace=True)
+        edges = edges[["type", "route", "geometry"]]
+        return isochrones, nodes, edges
+    return isochrones, None, None

objectnat/methods/living_buildings_osm.py

@@ -0,0 +1,172 @@
+import geopandas as gpd
+import numpy as np
+import osmnx as ox
+import pandas as pd
+from iduedu import get_boundary
+from shapely import MultiPolygon, Polygon
+
+from objectnat import config
+
+from ..utils import get_utm_crs_for_4326_gdf
+
+logger = config.logger
+
+
+def eval_is_living(row: gpd.GeoSeries):
+    """
+    Determine if a building is used for residential purposes based on its attributes.
+
+    Parameters
+    ----------
+    row : gpd.GeoSeries
+        A GeoSeries representing a row in a GeoDataFrame, containing building attributes.
+
+    Returns
+    -------
+    bool
+        A boolean indicating whether the building is used for residential purposes.
+
+    Examples
+    --------
+    >>> buildings = download_buildings(osm_territory_id=421007)
+    >>> buildings['is_living'] = buildings.apply(eval_is_living, axis=1)
+    """
+    if row["building"] in (
+        "apartments",
+        "house",
+        "residential",
+        "detached",
+        "dormitory",
+        "semidetached_house",
+        "bungalow",
+        "cabin",
+        "farm",
+    ):
+        return True
+    else:
+        return False
+
+
+def eval_population(source: gpd.GeoDataFrame, population_column: str, area_per_person: float = 33):
+    """
+    Estimate the population of buildings in a GeoDataFrame based on their attributes.
+
+    Parameters
+    ----------
+    source : gpd.GeoDataFrame
+        A GeoDataFrame containing building geometries and attributes.
+    population_column : str
+        The name of the column where the estimated population will be stored.
+    area_per_person : float
+        The standart living space per person im m², (default is 33)
+    Returns
+    -------
+    gpd.GeoDataFrame
+        A GeoDataFrame with an added column for estimated population.
+
+    Raises
+    ------
+    RuntimeError
+        If the 'building:levels' column is not present in the provided GeoDataFrame.
+
+    Examples
+    --------
+    >>> source = gpd.read_file('buildings.shp')
+    >>> source['is_living'] = source.apply(eval_is_living, axis=1)
+    >>> population_df = eval_population(source, 'approximate_pop')
+    """
+    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)
+    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")
+    df = df.dropna(subset=["building:levels"])
+    df["building:levels"] = df["building:levels"].astype(int)
+    df[population_column] = np.nan
+    df.loc[df["is_living"] == 1, population_column] = (
+        df[df["is_living"] == 1]
+        .apply(
+            lambda row: (
+                3
+                if ((row["area"] <= 400) & (row["building:levels"] <= 2))
+                else (row["building:levels"] * row["area"] * 0.8 / area_per_person)
+            ),
+            axis=1,
+        )
+        .round(0)
+        .astype(int)
+    )
+    return df
+
+
+def download_buildings(
+    osm_territory_id: int | None = None,
+    osm_territory_name: str | None = None,
+    terr_polygon: Polygon | MultiPolygon | None = None,
+    is_living_column: str = "is_living",
+    population_column: str = "approximate_pop",
+    area_per_person: float = 33,
+) -> gpd.GeoDataFrame | None:
+    """
+    Download building geometries and evaluate 'is_living' and 'population' attributes for a specified territory from OpenStreetMap.
+
+    Parameters
+    ----------
+    osm_territory_id : int, optional
+        The OpenStreetMap ID of the territory to download buildings for.
+    osm_territory_name : str, optional
+        The name of the territory to download buildings for.
+    terr_polygon : Polygon or MultiPolygon, optional
+        A Polygon or MultiPolygon geometry defining the territory to download buildings for.
+    is_living_column : str, optional
+        The name of the column indicating whether a building is residential (default is "is_living").
+    population_column : str, optional
+        The name of the column for storing estimated population (default is "approximate_pop").
+    area_per_person : float
+        The standart living space per person im m², (default is 33)
+    Returns
+    -------
+    gpd.GeoDataFrame or None
+        A GeoDataFrame containing building geometries and attributes, or None if no buildings are found or an error occurs.
+
+    Examples
+    --------
+    >>> buildings_df = download_buildings(osm_territory_name="Saint-Petersburg, Russia")
+    >>> buildings_df.head()
+    """
+    polygon = get_boundary(osm_territory_id, osm_territory_name, terr_polygon)
+
+    logger.debug("Downloading buildings from OpenStreetMap and counting population...")
+    buildings = ox.features_from_polygon(polygon, tags={"building": True})
+    if not buildings.empty:
+        buildings = buildings.loc[
+            (buildings["geometry"].geom_type == "Polygon") | (buildings["geometry"].geom_type == "MultiPolygon")
+        ]
+    if buildings.empty:
+        logger.warning(f"There are no buildings in the specified territory. Output GeoDataFrame is empty.")
+        return buildings
+    else:
+        buildings[is_living_column] = buildings.apply(eval_is_living, axis=1)
+        buildings = eval_population(buildings, population_column, area_per_person)
+        buildings.reset_index(drop=True, inplace=True)
+        logger.debug("Done!")
+        return buildings[
+            [
+                "building",
+                "addr:street",
+                "addr:housenumber",
+                "amenity",
+                "area",
+                "name",
+                "building:levels",
+                "leisure",
+                "design:year",
+                is_living_column,
+                "building:levels_is_real",
+                population_column,
+                "geometry",
+            ]
+        ]