ObjectNat 0.0.3__tar.gz → 0.1.1__tar.gz

objectnat-0.1.1/LICENSE.txt

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, iduprojects
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

objectnat-0.1.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.1
+Name: ObjectNat
+Version: 0.1.1
+Summary: ObjectNat is an open-source library created for geospatial analysis created by IDU team
+License: BSD-3-Clause
+Author: Danila
+Author-email: 63115678+DDonnyy@users.noreply.github.com
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: dongraphio (>=0.3.9,<0.4.0)
+Requires-Dist: geopandas (>=0.14.3,<0.15.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)
+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: scikit-learn (>=1.4.0,<2.0.0)
+Requires-Dist: tqdm (>=4.66.2,<5.0.0)
+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)
+
+<p align="center">
+<img src="https://i.ibb.co/FWtHNQv/logo.png" 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
+- [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.
+
+   <img src="https://i.ibb.co/VpsPgL1/Graph-generator-v1.webp" alt="Graph-generator-v1" 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">
+
+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.
+
+   <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">
+
+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">
+
+## Installation
+
+**ObjectNat** can be installed with ``pip``:
+
+```
+pip install ObjectNat
+```
+
+## 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-0.1.1/README.md

@@ -0,0 +1,74 @@
+# ObjectNat - Meta Library
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+<p align="center">
+<img src="https://i.ibb.co/FWtHNQv/logo.png" 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
+- [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.
+
+   <img src="https://i.ibb.co/VpsPgL1/Graph-generator-v1.webp" alt="Graph-generator-v1" 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">
+
+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.
+
+   <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">
+
+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">
+
+## Installation
+
+**ObjectNat** can be installed with ``pip``:
+
+```
+pip install ObjectNat
+```
+
+## 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-0.0.3 → objectnat-0.1.1}/pyproject.toml

@@ -1,30 +1,27 @@
 [tool.poetry]
 name = "ObjectNat"
-version = "0.0.3"
-description = ""
+version = "0.1.1"
+description = "ObjectNat is an open-source library created for geospatial analysis created by IDU team"
+license = "BSD-3-Clause"
 authors = ["Danila <63115678+DDonnyy@users.noreply.github.com>"]
 readme = "README.md"
 
 packages = [{ include = "objectnat", from = "src" }]
 
 [tool.poetry.dependencies]
-python = "^3.10"
+python = "^3.9"
 geopandas = "^0.14.3"
-osmnx = "^1.9.1"
 tqdm = "^4.66.2"
-osm2geojson = "^0.2.4"
-pydantic = "^2.6.1"
-momepy = "^0.7.0"
 networkit = "^11.0"
 numpy = "^1.23.5"
 pandas = "^2.2.0"
 networkx = "^3.2.1"
 population-restorator = "^0.2.3"
-dongraphio = "^0.2.5"
-provisio = "^0.1.5"
-
-
-
+dongraphio = "^0.3.9"
+provisio = "^0.1.7"
+joblib = "^1.4.2"
+pandarallel = "^1.6.5"
+scikit-learn = "^1.4.0"
 
 [tool.poetry.group.dev.dependencies]
 black = "^24.2.0"

{objectnat-0.0.3 → objectnat-0.1.1}/src/objectnat/__init__.py

@@ -1,9 +1,18 @@
-__version__ = "0.0.3"
+__version__ = "0.1.1"
 
 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-0.0.3 → objectnat-0.1.1}/src/objectnat/methods/adjacency_matrix.py

@@ -13,6 +13,7 @@ def get_adjacency_matrix(
     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.
@@ -28,11 +29,11 @@ def get_adjacency_matrix(
     """
     try:
         if dongraphio:
-            return dongraphio.get_adjacency_matrix(buildings_from, services_to, weight)
+            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)
+        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

objectnat-0.1.1/src/objectnat/methods/cluster_points_in_polygons.py

@@ -0,0 +1,113 @@
+from typing import Literal
+
+import geopandas as gpd
+import pandas as pd
+from loguru import logger
+from sklearn.cluster import DBSCAN, HDBSCAN
+
+
+def _get_cluster(services_select, min_dist, min_point, method):
+    services_coords = pd.DataFrame(
+        {"x": services_select.geometry.representative_point().x, "y": services_select.geometry.representative_point().y}
+    )
+    if method == "DBSCAN":
+        db = DBSCAN(eps=min_dist, min_samples=min_point).fit(services_coords.to_numpy())
+    else:
+        db = HDBSCAN(min_cluster_size=min_point, cluster_selection_epsilon=min_dist).fit(services_coords.to_numpy())
+    services_select["cluster"] = db.labels_
+    return services_select
+
+
+def _get_service_ratio(loc):
+    all_services = loc.shape[0]
+    loc["service_code"] = loc["service_code"].astype(str)
+    services_count = loc.groupby("service_code").size()
+    return (services_count / all_services).round(2)
+
+
+def get_clusters_polygon(
+    points: gpd.GeoDataFrame,
+    min_dist: float | int = 100,
+    min_point: int = 5,
+    method: Literal["DBSCAN", "HDBSCAN"] = "HDBSCAN",
+) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame]:
+    """
+    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.
+
+    Parameters
+    ----------
+    points : gpd.GeoDataFrame
+        GeoDataFrame containing the points to be clustered.
+        Must include a 'service_code' column for service ratio calculations.
+    min_dist : float | int, optional
+        Minimum distance between points to be considered part of the same cluster. Defaults to 100.
+    min_point : int, optional
+        Minimum number of points required to form a cluster. Defaults to 5.
+    method : Literal["DBSCAN", "HDBSCAN"], optional
+        The clustering method to use. Must be either "DBSCAN" or "HDBSCAN". Defaults to "HDBSCAN".
+
+    Returns
+    -------
+    tuple[gpd.GeoDataFrame, gpd.GeoDataFrame]
+        A tuple containing the clustered polygons GeoDataFrame and the original points GeoDataFrame with cluster labels.
+
+    Examples
+    --------
+    >>> import geopandas as gpd
+    >>> from shapely.geometry import Point
+
+    >>> points = gpd.GeoDataFrame({
+    ...     'geometry': [Point(0, 0), Point(1, 1), Point(2, 2)],
+    ...     'service_code': [1, 1, 2]
+    ... }, crs=4326)
+
+    >>> clusters, services = get_clusters_polygon(points, min_dist=50, min_point=2)
+    """
+    if method not in ["DBSCAN", "HDBSCAN"]:
+        raise ValueError("Method must be either 'DBSCAN' or 'HDBSCAN'")
+
+    services_select = _get_cluster(points, min_dist, min_point, method)
+
+    if "service_code" not in points.columns:
+        logger.warning(
+            "No 'service_code' column in provided GeoDataFrame, cluster polygons will be without relative ratio."
+        )
+        points["service_code"] = 1
+
+    services_normal = services_select[services_select["cluster"] != -1]
+    services_outlier = services_select[services_select["cluster"] == -1]
+
+    if len(services_normal) > 0:
+        cluster_service = services_normal.groupby("cluster", group_keys=True).apply(_get_service_ratio)
+        if isinstance(cluster_service, pd.Series):
+            cluster_service = cluster_service.unstack(level=1, fill_value=0)
+
+        polygons_normal = services_normal.dissolve("cluster").concave_hull(ratio=0.7, allow_holes=False)
+        df_clusters_normal = pd.concat([cluster_service, polygons_normal.rename("geometry")], axis=1)
+        cluster_normal = df_clusters_normal.index.max()
+    else:
+        df_clusters_normal = None
+        cluster_normal = 0
+
+    if len(services_outlier) > 0:
+        clusters_outlier = cluster_normal + 1
+        new_clusters = list(range(clusters_outlier, clusters_outlier + len(services_outlier)))
+        services_outlier.loc[:, "cluster"] = new_clusters
+
+        cluster_service = services_outlier.groupby("cluster", group_keys=True).apply(_get_service_ratio)
+        if isinstance(cluster_service, pd.Series):
+            cluster_service = cluster_service.unstack(level=1, fill_value=0)
+
+        df_clusters_outlier = cluster_service.join(services_outlier.set_index("cluster")["geometry"])
+    else:
+        services_outlier = None
+        df_clusters_outlier = None
+
+    df_clusters = pd.concat([df_clusters_normal, df_clusters_outlier]).fillna(0).set_geometry("geometry")
+    df_clusters["geometry"] = df_clusters["geometry"].buffer(min_dist / 2)
+    df_clusters = df_clusters.rename(columns={"index": "cluster_id"})
+
+    services = pd.concat([services_normal, services_outlier])
+
+    return df_clusters, services

objectnat-0.1.1/src/objectnat/methods/coverage_zones.py

@@ -0,0 +1,100 @@
+from typing import Literal
+
+import geopandas as gpd
+import networkx as nx
+from dongraphio import GraphType
+
+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,
+    graph_type: list[GraphType],
+) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]:
+    """
+    Create isochrones for each service location based on travel time/distance.
+
+    Parameters
+    ----------
+    services : gpd.GeoDataFrame
+        GeoDataFrame 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
+    -------
+    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 dongraphio import GraphType
+
+    >>> # Create a sample city graph or download it from osm with get_intermodal_graph_from_osm()
+    >>> city_graph = nx.MultiDiGraph()
+
+    >>> # Create a sample GeoDataFrame for services
+    >>> services = gpd.read_file('services.geojson')
+
+    >>> # 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
+    """
+    assert services.crs == city_graph.graph["crs"], "CRS not match"
+    points = services.geometry.representative_point()
+    isochrone_res = get_accessibility_isochrones(
+        points, graph_type, weight_value, weight_type, city_graph, points.crs.to_epsg()
+    )
+    return isochrone_res

objectnat-0.1.1/src/objectnat/methods/isochrones.py

@@ -0,0 +1,66 @@
+import geopandas as gpd
+import networkx as nx
+from dongraphio import DonGraphio, GraphType
+from shapely import Point
+
+
+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,
+) -> 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).
+
+    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.
+
+    Returns
+    -------
+    tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]
+        A tuple containing the accessibility isochrones, and optionally the routes and stops.
+
+    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)
+    """
+    dongraphio = DonGraphio(city_crs)
+    dongraphio.set_graph(city_graph)
+    return dongraphio.get_accessibility_isochrones(graph_type, points, weight_value, weight_type)

{objectnat-0.0.3 → objectnat-0.1.1}/src/objectnat/methods/provision.py

@@ -126,4 +126,10 @@ def get_provision(
     if calculate_matrix:
         adjacency_matrix = dngraph.get_adjacency_matrix(buildings, services, weight_adjacency_matrix)
 
-    return get_service_provision(services, adjacency_matrix, buildings, threshold, calculation_type)
+    return get_service_provision(
+        services=services,
+        adjacency_matrix=adjacency_matrix,
+        demanded_buildings=buildings,
+        threshold=threshold,
+        calculation_type=calculation_type,
+    )

objectnat-0.1.1/src/objectnat/methods/visibility_analysis.py

@@ -0,0 +1,529 @@
+import math
+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
+
+
+def get_visibility_accurate(point_from: Point, obstacles: gpd.GeoDataFrame, view_distance) -> Polygon:
+    """
+    Function to get accurate visibility from a given point to buildings within a given distance.
+
+    Parameters
+    ----------
+    point_from : Point
+        The point from which the line of sight is drawn.
+    obstacles : gpd.GeoDataFrame
+        A GeoDataFrame containing the geometry of the obstacles.
+    view_distance : float
+        The distance of view from the point.
+
+    Returns
+    -------
+    Polygon
+        A polygon representing the area of visibility from the given point.
+
+    Notes
+    -----
+    If a quick result is important, consider using the `get_visibility_result()` function instead.
+    However, please note that `get_visibility_result()` may provide less accurate results.
+
+    Examples
+    --------
+    >>> point_from = Point(1, 1)
+    >>> buildings = gpd.read_file('buildings.shp')
+    >>> view_distance = 1000
+    >>> visibility = get_visibility_accurate(point_from, obstacles, view_distance)
+    """
+
+    def get_point_from_a_thorough_b(a: Point, b: Point, dist):
+        """
+        Func to get Point from point a thorough point b on dist
+        """
+        direction = math.atan2(b.y - a.y, b.x - a.x)
+        c_x = a.x + dist * math.cos(direction)
+        c_y = a.y + dist * math.sin(direction)
+        return Point(c_x, c_y)
+
+    def polygon_to_linestring(geometry: Polygon):
+        """A function to return all segments of a polygon as a list of linestrings"""
+        coords_ext = geometry.exterior.coords  # Create a list of all line node coordinates
+        polygons_inter = [Polygon(x) for x in geometry.interiors]
+        result = [LineString(part) for part in zip(coords_ext, coords_ext[1:])]
+        for poly in polygons_inter:
+            poly_coords = poly.exterior.coords
+            result.extend([LineString(part) for part in zip(poly_coords, poly_coords[1:])])
+        return result
+
+    point_buffer = point_from.buffer(view_distance, resolution=32)
+    s = obstacles.intersects(point_buffer)
+    buildings_in_buffer = obstacles.loc[s[s].index]
+    # TODO kick all geoms except Polygons/MultiPolygons
+    buildings_in_buffer = buildings_in_buffer.geometry.apply(
+        lambda x: list(x.geoms) if isinstance(x, MultiPolygon) else x
+    ).explode()
+
+    buildings_lines_in_buffer = gpd.GeoSeries(buildings_in_buffer.apply(polygon_to_linestring).explode())
+    buildings_lines_in_buffer = buildings_lines_in_buffer.loc[buildings_lines_in_buffer.intersects(point_buffer)]
+
+    buildings_in_buffer_points = gpd.GeoSeries(
+        [Point(line.coords[0]) for line in buildings_lines_in_buffer.geometry]
+        + [Point(line.coords[-1]) for line in buildings_lines_in_buffer.geometry]
+    )
+
+    max_dist = max(view_distance, buildings_in_buffer_points.distance(point_from).max())
+    polygons = []
+    buildings_lines_in_buffer = gpd.GeoDataFrame(geometry=buildings_lines_in_buffer, crs=obstacles.crs).reset_index(
+        drop=True
+    )
+    iteration = 0
+    while not buildings_lines_in_buffer.empty:
+        iteration += 1
+        gdf_sindex = buildings_lines_in_buffer.sindex
+        # TODO check if 2 walls are nearest and use the widest angle between points
+        nearest_wall_sind = gdf_sindex.nearest(point_from, return_all=False)
+        nearest_wall = buildings_lines_in_buffer.loc[nearest_wall_sind[1]].iloc[0]
+        wall_points = [Point(coords) for coords in nearest_wall.geometry.coords]
+
+        # Calculate angles and sort by angle
+        points_with_angle = sorted(
+            [(pt, math.atan2(pt.y - point_from.y, pt.x - point_from.x)) for pt in wall_points], key=lambda x: x[1]
+        )
+
+        delta_angle = 2 * math.pi + points_with_angle[0][1] - points_with_angle[-1][1]
+        if delta_angle > math.pi:
+            delta_angle = 2 * math.pi - delta_angle
+        a = math.sqrt((max_dist**2) * (1 + (math.tan(delta_angle / 2) ** 2)))
+        p1 = get_point_from_a_thorough_b(point_from, points_with_angle[0][0], a)
+        p2 = get_point_from_a_thorough_b(point_from, points_with_angle[1][0], a)
+        polygon = Polygon([points_with_angle[0][0], p1, p2, points_with_angle[1][0]])
+
+        polygons.append(polygon)
+
+        buildings_lines_in_buffer.drop(nearest_wall_sind[1], inplace=True)
+
+        lines_to_kick = buildings_lines_in_buffer.within(polygon)
+        buildings_lines_in_buffer = buildings_lines_in_buffer.loc[~lines_to_kick]
+        buildings_lines_in_buffer.reset_index(drop=True, inplace=True)
+    res = point_buffer.difference(unary_union(polygons))
+    if isinstance(res, Polygon):
+        return res
+    res = list(res.geoms)
+    polygon_containing_point = None
+    for polygon in res:
+        if polygon.contains(point_from):
+            polygon_containing_point = polygon
+            break
+    return polygon_containing_point
+
+
+def get_visibility(point: Point, obstacles: gpd.GeoDataFrame, view_distance: float, resolution: int = 32) -> Polygon:
+    """
+    Function to get a quick estimate of visibility from a given point to buildings within a given distance.
+
+    Parameters
+    ----------
+    point : Point
+        The point from which the line of sight is drawn.
+    obstacles : gpd.GeoDataFrame
+        A GeoDataFrame containing the geometry of the buildings.
+    view_distance : float
+        The distance of view from the point.
+    resolution: int
+        Buffer resolution for more accuracy (may give result slower)
+
+    Returns
+    -------
+    Polygon
+        A polygon representing the estimated area of visibility from the given point.
+
+    Notes
+    -----
+    This function provides a quicker but less accurate result compared to `get_visibility_accurate()`.
+    If accuracy is important, consider using `get_visibility_accurate()` instead.
+
+    Examples
+    --------
+    >>> point = Point(1, 1)
+    >>> buildings = gpd.read_file('buildings.shp')
+    >>> view_distance = 1000
+    >>> visibility = get_visibility(point, obstacles, view_distance)
+    """
+
+    point_buffer = point.buffer(view_distance, resolution=resolution)
+    s = obstacles.within(point_buffer)
+    buildings_in_buffer = obstacles.loc[s[s].index].reset_index(drop=True)
+    buffer_exterior_ = list(point_buffer.exterior.coords)
+    line_geometry = [LineString([point, ext]) for ext in buffer_exterior_]
+    buffer_lines_gdf = gpd.GeoDataFrame(geometry=line_geometry)
+    united_buildings = buildings_in_buffer.unary_union
+    if united_buildings:
+        splited_lines = buffer_lines_gdf["geometry"].apply(lambda x: x.difference(united_buildings))
+    else:
+        splited_lines = buffer_lines_gdf["geometry"]
+
+    splited_lines_gdf = gpd.GeoDataFrame(geometry=splited_lines).explode(index_parts=True)
+    splited_lines_list = []
+
+    for _, v in splited_lines_gdf.groupby(level=0):
+        splited_lines_list.append(v.iloc[0]["geometry"].coords[-1])
+    circuit = Polygon(splited_lines_list)
+    if united_buildings:
+        circuit = circuit.difference(united_buildings)
+    return circuit
+
+
+def _multiprocess_get_vis(args):
+    point, buildings, view_distance, sectors_n = args
+    result = get_visibility_accurate(point, buildings, view_distance)
+
+    if sectors_n is not None:
+        sectors = []
+
+        cx, cy = point.x, point.y
+
+        angle_increment = 2 * math.pi / sectors_n
+        view_distance = math.sqrt((view_distance**2) * (1 + (math.tan(angle_increment / 2) ** 2)))
+        for i in range(sectors_n):
+            angle1 = i * angle_increment
+            angle2 = (i + 1) * angle_increment
+
+            x1, y1 = cx + view_distance * math.cos(angle1), cy + view_distance * math.sin(angle1)
+            x2, y2 = cx + view_distance * math.cos(angle2), cy + view_distance * math.sin(angle2)
+
+            sector_triangle = Polygon([point, (x1, y1), (x2, y2)])
+            sector = result.intersection(sector_triangle)
+
+            if not sector.is_empty:
+                sectors.append(sector)
+        result = sectors
+    return result
+
+
+def _polygons_to_linestring(geom):
+    # pylint: disable-next=redefined-outer-name,reimported,import-outside-toplevel
+    from shapely import LineString, MultiLineString, MultiPolygon
+
+    def convert_polygon(polygon: Polygon):
+        lines = []
+        exterior = LineString(polygon.exterior.coords)
+        lines.append(exterior)
+        interior = [LineString(p.coords) for p in polygon.interiors]
+        lines = lines + interior
+        return lines
+
+    def convert_multipolygon(polygon: MultiPolygon):
+        return MultiLineString(sum([convert_polygon(p) for p in polygon.geoms], []))
+
+    if geom.geom_type == "Polygon":
+        return MultiLineString(convert_polygon(geom))
+    if geom.geom_type == "MultiPolygon":
+        return convert_multipolygon(geom)
+    return geom
+
+
+def _combine_geometry(gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    """
+    Combine geometry of intersecting layers into a single GeoDataFrame.
+    Parameters
+    ----------
+    gdf: gpd.GeoDataFrame
+        A GeoPandas GeoDataFrame
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        The combined GeoDataFrame with aggregated in lists columns.
+
+    Examples
+    --------
+    >>> gdf = gpd.read_file('path_to_your_file.geojson')
+    >>> result = _combine_geometry(gdf)
+    """
+
+    crs = gdf.crs
+    polygons = polygonize(gdf["geometry"].apply(_polygons_to_linestring).unary_union)
+    enclosures = gpd.GeoSeries(list(polygons), crs=crs)
+    enclosures_points = gpd.GeoDataFrame(enclosures.representative_point(), columns=["geometry"], crs=crs)
+    joined = gpd.sjoin(enclosures_points, gdf, how="inner", predicate="within").reset_index()
+    cols = joined.columns.tolist()
+    cols.remove("geometry")
+    joined = joined.groupby("index").agg({column: list for column in cols})
+    joined["geometry"] = enclosures
+    joined = gpd.GeoDataFrame(joined, geometry="geometry", crs=crs)
+    return joined
+
+
+def _min_max_normalization(data, new_min=0, new_max=1):
+    """
+    Min-max normalization for a given array of data.
+
+    Parameters
+    ----------
+    data: numpy.ndarray
+        Input data to be normalized.
+    new_min: float, optional
+        New minimum value for normalization. Defaults to 0.
+    new_max: float, optional
+        New maximum value for normalization. Defaults to 1.
+
+    Returns
+    -------
+    numpy.ndarray
+        Normalized data.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> data = np.array([1, 2, 3, 4, 5])
+    >>> normalized_data = min_max_normalization(data, new_min=0, new_max=1)
+    """
+
+    min_value = np.min(data)
+    max_value = np.max(data)
+    normalized_data = (data - min_value) / (max_value - min_value) * (new_max - new_min) + new_min
+    return normalized_data
+
+
+def _process_group(group):
+    geom = group
+    combined_geometry = _combine_geometry(geom)
+    combined_geometry.drop(columns=["index", "index_right"], inplace=True)
+    combined_geometry["count_n"] = combined_geometry["ratio"].apply(len)
+    combined_geometry["new_ratio"] = combined_geometry.apply(
+        lambda x: np.power(np.prod(x.ratio), 1 / x.count_n) * x.count_n, axis=1
+    )
+
+    threshold = combined_geometry["new_ratio"].quantile(0.25)
+    combined_geometry = combined_geometry[combined_geometry["new_ratio"] > threshold]
+
+    combined_geometry["new_ratio_normalized"] = _min_max_normalization(
+        combined_geometry["new_ratio"].values, new_min=1, new_max=10
+    )
+
+    combined_geometry["new_ratio_normalized"] = np.round(combined_geometry["new_ratio_normalized"]).astype(int)
+
+    result_union = (
+        combined_geometry.groupby("new_ratio_normalized")
+        .agg({"geometry": lambda x: unary_union(MultiPolygon(list(x)).buffer(0))})
+        .reset_index(drop=True)
+    )
+    result_union.set_geometry("geometry", inplace=True)
+    result_union.set_crs(geom.crs, inplace=True)
+
+    result_union = result_union.explode("geometry", index_parts=False).reset_index(drop=True)
+
+    representative_points = combined_geometry.copy()
+    representative_points["geometry"] = representative_points["geometry"].representative_point()
+
+    joined = gpd.sjoin(result_union, representative_points, how="inner", predicate="contains").reset_index()
+    joined = joined.groupby("index").agg({"geometry": "first", "new_ratio": lambda x: np.mean(list(x))})
+
+    joined.set_geometry("geometry", inplace=True)
+    joined.set_crs(geom.crs, inplace=True)
+    return joined
+
+
+def get_visibilities_from_points(
+    points: gpd.GeoDataFrame,
+    obstacles: gpd.GeoDataFrame,
+    view_distance: int,
+    sectors_n=None,
+    max_workers: int = cpu_count(),
+) -> list[Polygon]:
+    """
+    Calculate visibility polygons from a set of points considering obstacles within a specified view distance.
+
+    Parameters
+    ----------
+    points : gpd.GeoDataFrame
+        GeoDataFrame containing the points from which visibility is calculated.
+    obstacles : gpd.GeoDataFrame
+        GeoDataFrame containing the obstacles that block visibility.
+    view_distance : int
+        The maximum distance from each point within which visibility is calculated.
+    sectors_n : int, optional
+        Number of sectors to divide the view into for more detailed visibility calculations. Defaults to None.
+    max_workers: int, optional
+        Maximum workers in multiproccesing, multipocessing.cpu_count() by default.
+
+    Returns
+    -------
+    list[Polygon]
+        A list of visibility polygons for each input point.
+
+    Notes
+    -----
+    This function uses `get_visibility_accurate()` in multiprocessing way.
+
+    Examples
+    --------
+    >>> import geopandas as gpd
+    >>> from shapely.geometry import Point, Polygon
+    >>> points = gpd.GeoDataFrame({'geometry': [Point(0, 0), Point(1, 1)]}, crs='epsg:4326')
+    >>> obstacles = gpd.GeoDataFrame({'geometry': [Polygon([(0, 0), (0, 1), (1, 1), (1, 0)])]}, crs='epsg:4326')
+    >>> view_distance = 100
+
+    >>> visibilities = get_visibilities_from_points(points, obstacles, view_distance)
+    >>> visibilities
+    """
+    # remove points inside polygons
+    joined = gpd.sjoin(points, obstacles, how="left", predicate="intersects")
+    points = joined[joined.index_right.isnull()]
+
+    # remove unused obstacles
+    points_view = points.geometry.buffer(view_distance).unary_union
+    s = obstacles.intersects(points_view)
+    buildings_in_buffer = obstacles.loc[s[s].index].reset_index(drop=True)
+
+    buildings_in_buffer.geometry = buildings_in_buffer.geometry.apply(
+        lambda geom: MultiPolygon([geom]) if isinstance(geom, Polygon) else geom
+    )
+    args = [(point, buildings_in_buffer, view_distance, sectors_n) for point in points.geometry]
+    all_visions = process_map(
+        _multiprocess_get_vis,
+        args,
+        chunksize=5,
+        desc="Calculating Visibility Catchment Area from each Point, it might take a while for a "
+        "big amount of points",
+        max_workers=max_workers,
+    )
+    # could return sectorized visions if sectors_n is set
+    return all_visions
+
+
+def calculate_visibility_catchment_area(
+    points: gpd.GeoDataFrame, obstacles: gpd.GeoDataFrame, view_distance: int | float, max_workers: int = cpu_count()
+) -> gpd.GeoDataFrame:
+    """
+    Calculate visibility catchment areas for a large urban area based on given points and obstacles.
+    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.
+
+    Parameters
+    ----------
+    points : gpd.GeoDataFrame
+        GeoDataFrame containing the points from which visibility is calculated.
+    obstacles : gpd.GeoDataFrame
+        GeoDataFrame containing the obstacles that block visibility.
+    view_distance : int
+        The maximum distance from each point within which visibility is calculated.
+    max_workers: int
+        Maximum workers in multiproccesing, multipocessing.cpu_count() by default.
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        GeoDataFrame containing the calculated visibility catchment areas.
+
+    Examples
+    --------
+    >>> import geopandas as gpd
+    >>> from shapely.geometry import Point, Polygon
+    >>> points = gpd.read_file('points.shp')
+    >>> obstacles = gpd.read_file('obstacles.shp')
+    >>> view_distance = 1000
+
+    >>> visibility_areas = calculate_visibility_catchment_area(points, obstacles, view_distance)
+    >>> visibility_areas
+    """
+
+    def filter_geoms(x):
+        if x.geom_type == "GeometryCollection":
+            return MultiPolygon([y for y in x.geoms if y.geom_type in ["Polygon", "MultiPolygon"]])
+        return x
+
+    def calc_group_factor(x):
+        # pylint: disable-next=redefined-outer-name,reimported,import-outside-toplevel
+        import numpy as np
+
+        return np.mean(x.new_ratio) * x.count_n
+
+    def unary_union_groups(x):
+        # pylint: disable-next=redefined-outer-name,reimported,import-outside-toplevel
+        from shapely import MultiPolygon
+
+        # pylint: disable-next=redefined-outer-name,reimported,import-outside-toplevel
+        from shapely.ops import unary_union
+
+        return unary_union(MultiPolygon(list(x["geometry"])).buffer(0))
+
+    pandarallel.initialize(progress_bar=True, verbose=0)
+
+    assert points.crs == obstacles.crs
+    crs = obstacles.crs
+    sectors_n = 12
+    logger.info("Calculating Visibility Catchment Area from each point")
+    all_visions_sectorized = get_visibilities_from_points(points, obstacles, view_distance, sectors_n, max_workers)
+    all_visions_sectorized = gpd.GeoDataFrame(
+        geometry=[item for sublist in all_visions_sectorized for item in sublist], crs=crs
+    )
+    logger.info("Calculating non-vision part...")
+    all_visions_unary = all_visions_sectorized.unary_union
+    convex = all_visions_unary.convex_hull
+    dif = convex.difference(all_visions_unary)
+
+    del convex, all_visions_unary
+
+    buf_area = (math.pi * view_distance**2) / sectors_n
+    all_visions_sectorized["ratio"] = all_visions_sectorized.area / buf_area
+    all_visions_sectorized["ratio"] = _min_max_normalization(
+        all_visions_sectorized["ratio"].values, new_min=1, new_max=10
+    )
+    groups = all_visions_sectorized.sample(frac=1).groupby(all_visions_sectorized.index // 6000)
+    groups = [group for _, group in groups]
+
+    del all_visions_sectorized
+
+    groups_result = process_map(
+        _process_group,
+        groups,
+        desc="Counting intersections in each group...",
+        max_workers=max_workers,
+    )
+    logger.info("Calculating all groups intersection...")
+    all_in = _combine_geometry(gpd.GeoDataFrame(data=pd.concat(groups_result), geometry="geometry", crs=crs))
+
+    del groups_result
+
+    all_in["count_n"] = all_in["index_right"].apply(len)
+
+    logger.info("Calculating intersection's parameters")
+    all_in["factor"] = all_in.parallel_apply(calc_group_factor, axis=1)
+    threshold = all_in["factor"].quantile(0.3)
+    all_in = all_in[all_in["factor"] > threshold]
+
+    all_in["factor_normalized"] = np.round(
+        _min_max_normalization(np.sqrt(all_in["factor"].values), new_min=1, new_max=5)
+    ).astype(int)
+    logger.info("Calculating normalized groups geometry...")
+    all_in = all_in.groupby("factor_normalized").parallel_apply(unary_union_groups).reset_index()
+    all_in = gpd.GeoDataFrame(data=all_in.rename(columns={0: "geometry"}), geometry="geometry", crs=32636)
+
+    all_in = all_in.explode(index_parts=True).reset_index(drop=True)
+    all_in["area"] = all_in.area
+    threshold = all_in["area"].quantile(0.9)
+    all_in = all_in[all_in["area"] > threshold]
+    all_in = all_in.groupby("factor_normalized").apply(unary_union_groups).reset_index()
+    all_in = gpd.GeoDataFrame(data=all_in.rename(columns={0: "geometry"}), geometry="geometry", crs=32636)
+
+    all_in.geometry = all_in.geometry.buffer(20).buffer(-20).difference(dif)
+
+    all_in.sort_values(by="factor_normalized", ascending=False, inplace=True)
+    all_in.reset_index(drop=True, inplace=True)
+    logger.info("Smoothing normalized groups geometry...")
+    for ind, row in all_in.iloc[:-1].iterrows():
+        for ind2 in range(ind + 1, len(all_in)):
+            current_geometry = all_in.at[ind2, "geometry"]
+            all_in.at[ind2, "geometry"] = current_geometry.difference(row.geometry)
+            all_in["geometry"] = all_in["geometry"].apply(filter_geoms)
+
+    all_in = all_in.explode(index_parts=True)
+    logger.info("Done!")
+    return all_in

objectnat-0.0.3/PKG-INFO

@@ -1,79 +0,0 @@
-Metadata-Version: 2.1
-Name: ObjectNat
-Version: 0.0.3
-Summary: 
-Author: Danila
-Author-email: 63115678+DDonnyy@users.noreply.github.com
-Requires-Python: >=3.10,<4.0
-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.2.5,<0.3.0)
-Requires-Dist: geopandas (>=0.14.3,<0.15.0)
-Requires-Dist: momepy (>=0.7.0,<0.8.0)
-Requires-Dist: networkit (>=11.0,<12.0)
-Requires-Dist: networkx (>=3.2.1,<4.0.0)
-Requires-Dist: numpy (>=1.23.5,<2.0.0)
-Requires-Dist: osm2geojson (>=0.2.4,<0.3.0)
-Requires-Dist: osmnx (>=1.9.1,<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.5,<0.2.0)
-Requires-Dist: pydantic (>=2.6.1,<3.0.0)
-Requires-Dist: tqdm (>=4.66.2,<5.0.0)
-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)
-
-
-<p align="center">
-<img src="./docs/img/logo.png" alt="test-logo" width="400"></a>
-</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
-- [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.
-
-   <img src="./docs/img/graphTara.png" alt="city_graph" width="300"></a>
-   
-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="./docs/img/isochronesTara.png" alt="isochrones" width="300"></a>
-
-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.
-
-   <img src="./docs/img/provisioTara.png" alt="isochrones" width="300"></a>
-
-## Installation
-
-**ObjectNat** soon ~~can be installed with~~ ``pip``:
-
-```
-pip install ObjectNat
-```
-
-## Contacts
-
-## Publications
-

objectnat-0.0.3/README.md

@@ -1,52 +0,0 @@
-# ObjectNat - Meta Library
-
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-
-
-<p align="center">
-<img src="./docs/img/logo.png" alt="test-logo" width="400"></a>
-</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
-- [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.
-
-   <img src="./docs/img/graphTara.png" alt="city_graph" width="300"></a>
-   
-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="./docs/img/isochronesTara.png" alt="isochrones" width="300"></a>
-
-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.
-
-   <img src="./docs/img/provisioTara.png" alt="isochrones" width="300"></a>
-
-## Installation
-
-**ObjectNat** soon ~~can be installed with~~ ``pip``:
-
-```
-pip install ObjectNat
-```
-
-## Contacts
-
-## Publications

objectnat-0.0.3/src/objectnat/methods/isochrones.py

@@ -1,34 +0,0 @@
-import geopandas as gpd
-import networkx as nx
-from dongraphio import DonGraphio, GraphType
-
-
-def get_accessibility_isochrones(
-    graph_type: list[GraphType],
-    x_from: float,
-    y_from: float,
-    weight_value: int,
-    weight_type: str,
-    city_graph: nx.MultiDiGraph,
-    city_crs: int,
-) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]:
-    """
-    Calculate accessibility isochrones based on provided city graph for selected graph_type enum
-
-    Args:
-        graph_type (List[GraphType]): List of graph types to calculate isochrones for.
-        x_from (float): X coordinate of the starting point in the corresponding coordinate system.
-        y_from (float): Y coordinate of the starting point in the corresponding coordinate system.
-        weight_value (int): Weight value for the accessibility calculations.
-        weight_type (str): The type of the weight, could be only "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.
-
-    Returns:
-        Tuple[gpd.GeoDataFrame, Optional[gpd.GeoDataFrame], Optional[gpd.GeoDataFrame]]:
-        The accessibility isochrones, optional routes and stops.
-
-    """
-    dongraphio = DonGraphio(city_crs)
-    dongraphio.set_graph(city_graph)
-    return dongraphio.get_accessibility_isochrones(graph_type, x_from, y_from, weight_value, weight_type)