ObjectNat 0.2.6__py3-none-any.whl → 1.0.0__py3-none-any.whl

objectnat-1.0.0.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.1
+Name: ObjectNat
+Version: 1.0.0
+Summary: ObjectNat is an open-source library created for geospatial analysis created by IDU team
+License: BSD-3-Clause
+Author: DDonnyy
+Author-email: 63115678+DDonnyy@users.noreply.github.com
+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: geopandas (>=1.0.1,<2.0.0)
+Requires-Dist: networkx (>=3.4.2,<4.0.0)
+Requires-Dist: numpy (>=2.1.3,<3.0.0)
+Requires-Dist: pandarallel (>=1.6.5,<2.0.0)
+Requires-Dist: pandas (>=2.2.0,<3.0.0)
+Requires-Dist: pytest (>=8.3.5,<9.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
+
+[![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/)
+[![CI](https://github.com/DDonnyy/ObjectNat/actions/workflows/ci_pipeline.yml/badge.svg)](https://github.com/DDonnyy/ObjecNat/actions/workflows/ci_pipeline.yml)
+[![codecov](https://codecov.io/gh/DDonnyy/ObjectNat/graph/badge.svg?token=K6JFSJ02GU)](https://codecov.io/gh/DDonnyy/ObjectNat)
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](https://opensource.org/licenses/MIT)
+
+- [РИДМИ (Russian)](README_ru.md)
+<p align="center">
+<img src="https://github.com/user-attachments/assets/ed0f226e-1728-4659-9e21-b4d499e703cd" alt="logo" width="400">
+</p>
+
+#### **ObjectNat** is an open-source library created for geospatial analysis created by **IDU team**
+
+## Features and how to use
+
+1. **[Isochrones and Transport Accessibility](./examples/isochrone_generator.ipynb)** — Isochrones represent areas reachable from a starting point within a given time limit along a transport network. This function enables analysis of transport accessibility using pedestrian, automobile, public transport graphs, or their combination.
+
+   The library offers multiple isochrone generation methods:
+   - **Baseline isochrones**: show a single area reachable within a specified time.
+   - **Stepped isochrones**: show accessibility ranges divided into time intervals (e.g., 5, 10, 15 minutes).
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/b1787430-63e1-4907-9198-a6171d546599" alt="isochrone_ways_15_min" width="300">
+     <img src="https://github.com/user-attachments/assets/64fce6bf-6509-490c-928c-dbd8daf9f570" alt="isochrone_radius_15_min" width="300">
+   </p>
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/ac9f8840-a867-4eb5-aec8-91a411d4e545" alt="stepped_isochrone_stepped_ways_15_min" width="300">
+     <img src="https://github.com/user-attachments/assets/b5429aa1-4625-44d1-982f-8bd4264148fb" alt="stepped_isochrone_stepped_radius_15_min" width="300">
+     <img src="https://github.com/user-attachments/assets/042c7362-70e1-45df-b2e1-02fc76bf638c" alt="stepped_isochrone_stepped_separate_15_min" width="300">
+   </p>
+
+
+2. **[Coverage Zones](./examples/graph_coverage.ipynb)** — Function for generating **coverage zones** from a set of source points using a transport network. It calculates the area each point can reach based on **travel time** or **distance**, then builds polygons via **Voronoi diagrams** and clips them to a custom boundary if provided.
+
+   <p align="center">
+		<img src="https://github.com/user-attachments/assets/fa8057d7-77aa-48a2-aa10-ea3e292a918d" alt="coverage_zones_time_10min" width="350">
+   	<img src="https://github.com/user-attachments/assets/44362dde-c3b0-4321-9a0a-aa547f0f2e04" alt="coverage_zones_distance_600m" width="350">
+   </p>
+ 
+3. **[Service Provision Analysis](./examples/calculate_provision.ipynb)** — Function for evaluating the provision of residential buildings and their population with services (e.g., schools, clinics)
+    that have limited **capacity** and a defined **accessibility threshold** (in minutes or distance). The function models **demand-supply balance**, estimating how well services meet the needs of nearby buildings within the allowed time.
+
+   The library also supports:
+   - **Recalculation** of existing provision results using a new time threshold.
+   - **Clipping** of provision results to a custom analysis area (e.g., administrative boundaries).
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/ff1ed08d-9a35-4035-9e1f-9a7fdae5b0e0" alt="service_provision_initial" width="300">
+     <img src="https://github.com/user-attachments/assets/a0c0a6b0-f83f-4982-bfb3-4a476b2153ea" alt="service_provision_recalculated" width="300">
+     <img src="https://github.com/user-attachments/assets/f57dc1c6-21a0-458d-85f4-fe1b17c77695" alt="service_provision_clipped" width="300">
+   </p>
+
+4. **[Visibility Analysis](./examples/visibility_analysis.ipynb)** — Function for estimating visibility from a given point or multiple points to nearby buildings within a certain distance.
+   This can be used to assess visual accessibility in urban environments.
+   The library also includes a **catchment area calculator** for large-scale visibility analysis based on a dense grid of observer points (recommended: ~1000 points spaced 10–20 meters apart).
+   Points can be generated using a road network and distributed along edges.
+
+   The module includes:
+   - A **fast approximate method** for large datasets.
+   - A **accurate method** for detailed local analysis.
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/aa139d29-07d4-4560-b835-9646c8802fe1" alt="visibility_comparison_methods" height="250">
+     <img src="https://github.com/user-attachments/assets/b5b0d4b3-a02f-4ade-8772-475703cd6435" alt="visibility-catchment-area" height="250">
+   </p>
+
+5. **[Noise Simulation](./examples/noise_simulation.ipynb)** — Simulates noise propagation from a set of source points, taking into account **obstacles**, **vegetation**, and **environmental factors**.
+
+   🔗 **[See detailed explanation in the Wiki](https://github.com/DDonnyy/ObjectNat/wiki/Noise-simulation)**
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/b3a41962-6220-49c4-90d4-2e756f9706cf" alt="noise_simulation_test_result" width="400">
+   </p>
+
+
+6. **[Point Clusterization](./examples/point_clusterization.ipynb)** — Function to generate **cluster polygons** from a set of input points based on:
+   - Minimum **distance** between points.
+   - Minimum **number of points** per cluster.
+
+   Additionally, the function can calculate the **relative ratio** of different service types within each cluster, enabling spatial analysis of service composition.
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/f86aac61-497a-4330-b4cf-68f4fc47fd34" alt="building_clusters" width="400">
+   </p>
+
+## City graphs
+
+To ensure optimal performance of ObjectNat's geospatial analysis functions, it's recommended to utilize urban graphs sourced from the [IduEdu](https://github.com/DDonnyy/IduEdu) library.
+**IduEdu** is an open-source Python library designed for the creation and manipulation of complex city networks derived from OpenStreetMap data. 
+
+**IduEdu** can be installed with ``pip``:
+```
+pip install IduEdu
+```
+## Installation
+
+**ObjectNat** can be installed with ``pip``:
+
+```
+pip install ObjectNat
+```
+### Configuration changes
+
+```python
+from objectnat import config
+
+config.change_logger_lvl('INFO')  # To mute all debug msgs
+config.set_enable_tqdm(False)  # To mute all tqdm's progress bars
+```
+## Contacts
+
+- [NCCR](https://actcognitive.org/) - National Center for Cognitive Research
+- [IDU](https://idu.itmo.ru/) - Institute of Design and Urban Studies
+- [Natalya Chichkova](https://t.me/nancy_nat) - project manager
+- [Danila Oleynikov (Donny)](https://t.me/ddonny_dd) - lead software engineer
+
+## Publications
+

objectnat-1.0.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+objectnat/__init__.py,sha256=OnDvrLPLEeYIE_9qOVYgMc-PkRzIqShtGxirguEXiRU,260
+objectnat/_api.py,sha256=5TvsMjWjiR7kFIWnfRJxngWOrC_eKQ7Pt-TSMpjqzI0,595
+objectnat/_config.py,sha256=fGPsMZqA8FVBBOINxRiTFkOOZsNLyablM5G0tdKeQB4,1306
+objectnat/_version.py,sha256=lzGFsymf0DtA_1oAZcPbeQ557iY-1BRkekhfA2qaFh8,18
+objectnat/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+objectnat/methods/coverage_zones/__init__.py,sha256=cdXjW041ysfIlr4sGQ_Xa2nok4tHfMJTEf8pem-0m-U,95
+objectnat/methods/coverage_zones/graph_coverage.py,sha256=3nVZekDAmbz2ZzxsayX9KIgudlSZF3OnZ9g5kFmVt8o,4797
+objectnat/methods/coverage_zones/radius_voronoi.py,sha256=H4_lvSc770TO6-xq6EzgWuUf00N5vYCMO3X6UJhZYAQ,1735
+objectnat/methods/isochrones/__init__.py,sha256=bDfUZPbS3_PuTEB2QcRTYjvyJtUvjbDhAw6QJvD_ih4,90
+objectnat/methods/isochrones/isochrone_utils.py,sha256=KubqeysYetj1dbWJ_WGrewfM_jWYmRFjj8AWz8aEc1I,4825
+objectnat/methods/isochrones/isochrones.py,sha256=GoaFGiLSsG-RRXA5jtij3zsrwxH5ThKDh8XexZ3rD3k,14046
+objectnat/methods/noise/__init__.py,sha256=6JV586JdOqE0OUFUyxsrCoGuDxRuB-6ItSA5CRuFdsE,152
+objectnat/methods/noise/noise_exceptions.py,sha256=nTav5kp6RNpi0kxD9cMULTApOuvAu9wEiX28fkLAnOc,634
+objectnat/methods/noise/noise_init_data.py,sha256=Vp-R_yH7CgYqZEtbGAdr1iiIbgauReniLQ_a2TcszhY,503
+objectnat/methods/noise/noise_reduce.py,sha256=B85ifAN_mHiBKJso-cZiSkj7588w2sA-ugGvEal4CBw,6885
+objectnat/methods/noise/noise_sim.py,sha256=qb0C2CD-sIEcdUWO3xSwCGjuR94xPgU81FC94TeXHBo,20278
+objectnat/methods/point_clustering/__init__.py,sha256=pX2qDUCvs9LJI36mr65vbdRml6AE8hIYYxIJLdQZQxs,61
+objectnat/methods/point_clustering/cluster_points_in_polygons.py,sha256=kwiZHY3TCUCE-nN5IdhCwDESWJvSCZUfrUJU3yC1csc,5042
+objectnat/methods/provision/__init__.py,sha256=0Uy66n2xH0Y45JyhIYHEVfC2rig6bMYp6PV2KkNhbK8,80
+objectnat/methods/provision/provision.py,sha256=g00mN6RGFZcLg0PIMgywnO3TWiFqx3sTYqTeG3Kl33s,4749
+objectnat/methods/provision/provision_exceptions.py,sha256=lznEmlmZDzGIOtapZVqZDMutIi5eGbFuVCYeVa7VZWk,1687
+objectnat/methods/provision/provision_model.py,sha256=_IKS3pe_i7gLcA56baB0g3mH77T9pPP_4FzjuK_FZ5Y,14529
+objectnat/methods/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+objectnat/methods/utils/geom_utils.py,sha256=6tt7gKztDYOTqaZ1sLO4vN2sNPV9qeFyKK1BbvwwD18,4582
+objectnat/methods/utils/graph_utils.py,sha256=M983Hy1CXRIGg_q71tW0HVB8ZS4ZpDK5I2J3imyznUQ,4799
+objectnat/methods/utils/math_utils.py,sha256=Vc8U15LtFOwgIt1YSOSKWYOIiW_1XLuMGOa6ejBpEUk,839
+objectnat/methods/visibility/__init__.py,sha256=Mx1kaoV-yfQUxlMkgNF4AhjSweFEJMEx3NBis5OM3mA,161
+objectnat/methods/visibility/visibility_analysis.py,sha256=fDIZ5S7oR-5ZEsjZPFexb7oFw-1X6uj0A4xuP3pX354,21183
+objectnat-1.0.0.dist-info/LICENSE.txt,sha256=yPEioMfTd7JAQgAU6J13inS1BSjwd82HFlRSoIb4My8,1498
+objectnat-1.0.0.dist-info/METADATA,sha256=ybm0Wwz002c0AWq9qJw6g6ZTveQB4yZJLekYC3kB70I,8079
+objectnat-1.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+objectnat-1.0.0.dist-info/RECORD,,

objectnat/methods/balanced_buildings.py

@@ -1,69 +0,0 @@
-import geopandas as gpd
-import population_restorator.balancer.houses as b_build
-import population_restorator.balancer.territories as b_terr
-
-from objectnat import config
-
-logger = config.logger
-
-
-def get_balanced_buildings(
-    living_buildings: gpd.GeoDataFrame,
-    population: int,
-    territories: gpd.GeoDataFrame | None = None,
-) -> gpd.GeoDataFrame:
-    """
-    Balance city population into living buildings according to their spot area * `storeys_count`.
-
-    Args:
-        living_buildings (gpd.GeoDataFrame): (multi)polygons of buildings where people live. Must contain either
-            "storeys_count" or "living_area" attributes.
-
-        population (int): Total city population
-
-        territories (gpd.GeoDataFrame, optional): If more detailed population is known, it can be set via this parameter
-            in "population" field. In case territories are given, only buildings inside them will be populated.
-
-    Returns:
-        gpd.GeoDataFrame: The balanced living buildings.
-
-    Raises:
-        ValueError: If population is missing, or if living buildings are not set,
-            or if living buildings are missing the `storeys_count` attribute, or if buildings contain no valid value.
-    """
-
-    if population is None:
-        raise ValueError("Population value is missing")
-    if living_buildings.shape[0] == 0:
-        raise ValueError("Living buildings are not set")
-    if "living_area" not in living_buildings.columns and "storeys_count" not in living_buildings.columns:
-        raise ValueError("Living buildings are missing `storeys_count` attribute")
-    logger.debug(f"Evacuating {population} residents into the provided building")
-    indexes = living_buildings.index
-    living_buildings = living_buildings.copy()
-    living_buildings.reset_index(drop=True, inplace=True)
-    if "living_area" not in living_buildings.columns:
-        living_buildings["living_area"] = living_buildings.area * living_buildings["storeys_count"]
-    living_buildings = living_buildings[living_buildings["living_area"].notna()]
-    if living_buildings.shape[0] == 0:
-        raise ValueError("Buildings contain no valid value")
-    if territories is None:
-        city_territory = b_terr.Territory("city", population, None, living_buildings)
-    else:
-        inner_territories = [
-            b_terr.Territory(
-                f"terr_{i}",
-                terr.get("population"),
-                None,
-                living_buildings[terr.contains(living_buildings.centroid)].copy(),
-            )
-            for i, (_, terr) in enumerate(territories.iterrows())
-        ]
-        city_territory = b_terr.Territory("city", population, inner_territories, None)
-
-    b_terr.balance_territories(city_territory)
-    b_build.balance_houses(city_territory)
-
-    houses = city_territory.get_all_houses()
-    houses.set_index(indexes, drop=True, inplace=True)
-    return houses

objectnat/methods/coverage_zones.py

@@ -1,90 +0,0 @@
-from typing import Literal
-
-import geopandas as gpd
-import networkx as nx
-
-from .isochrones import get_accessibility_isochrones
-
-
-def get_radius_zone_coverage(services: gpd.GeoDataFrame, radius: int) -> gpd.GeoDataFrame:
-    """
-    Create a buffer zone with a defined radius around each service location.
-
-    Parameters
-    ----------
-    services : gpd.GeoDataFrame
-        GeoDataFrame containing the service locations.
-    radius : int
-        The radius for the buffer in meters.
-
-    Returns
-    -------
-    gpd.GeoDataFrame
-        GeoDataFrame with the buffer zones around each service location.
-
-    Examples
-    --------
-    >>> import geopandas as gpd
-    >>> from shapely.geometry import Point
-
-    >>> # Create a sample GeoDataFrame for services
-    >>> services = gpd.read_file('services.geojson')
-
-    >>> # Define the radius
-    >>> radius = 50
-
-    >>> # Get radius zone coverage
-    >>> radius_zones = get_radius_zone_coverage(services, radius)
-    >>> print(radius_zones)
-    """
-    services["geometry"] = services["geometry"].buffer(radius)
-    return services
-
-
-def get_isochrone_zone_coverage(
-    services: gpd.GeoDataFrame,
-    weight_type: Literal["time_min", "length_meter"],
-    weight_value: int,
-    city_graph: nx.Graph,
-) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]:
-    """
-    Create isochrones for each service location based on travel time/distance.
-
-    Parameters
-    ----------
-    services : gpd.GeoDataFrame
-        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.
-
-    Returns
-    -------
-    tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]
-        The calculated isochrone zones, optionally including routes and stops.
-
-    Examples
-    --------
-    >>> import networkx as nx
-    >>> import geopandas as gpd
-    >>> from shapely.geometry import Point
-     >>> from iduedu import get_intermodal_graph
-
-    >>> # 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')
-
-    >>> # Define parameters
-    >>> weight_type = "time_min"
-    >>> weight_value = 10
-
-    >>> # Get isochrone zone coverage
-    >>> isochrones, pt_stops, pt_routes = get_isochrone_zone_coverage(services, weight_type, weight_value, city_graph)
-    """
-    iso, routes, stops = get_accessibility_isochrones(services, weight_value, weight_type, city_graph)
-    return iso, routes, stops

objectnat/methods/isochrones.py

@@ -1,143 +0,0 @@
-from typing import Literal
-
-import geopandas as gpd
-import networkx as nx
-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: 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 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 : 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:
-        - 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
-    --------
-    >>> 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)
-
-    """
-
-    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

@@ -1,168 +0,0 @@
-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
-
-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)
-    """
-    return row["building"] in (
-        "apartments",
-        "house",
-        "residential",
-        "detached",
-        "dormitory",
-        "semidetached_house",
-        "bungalow",
-        "cabin",
-        "farm",
-    )
-
-
-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_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")
-    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("There are no buildings in the specified territory. Output GeoDataFrame is empty.")
-        return buildings
-
-    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",
-        ]
-    ]