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

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, stops, routes = get_accessibility_isochrones(points,15,weight_type="time_min", graph_nx=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: not pd.isna(x))
-    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.
-
-    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",
-        ]
-    ]

objectnat-0.2.7.dist-info/METADATA

@@ -1,118 +0,0 @@
-Metadata-Version: 2.1
-Name: ObjectNat
-Version: 0.2.7
-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 (>=0.14.3,<0.15.0)
-Requires-Dist: iduedu (>=0.2.2,<0.3.0)
-Requires-Dist: networkx (>=3.3,<4.0)
-Requires-Dist: numpy (>=1.26.4,<2.0.0)
-Requires-Dist: pandarallel (>=1.6.5,<2.0.0)
-Requires-Dist: pandas (>=2.2.0,<3.0.0)
-Requires-Dist: population-restorator (>=0.2.3,<0.3.0)
-Requires-Dist: 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)
-[![PyPI version](https://img.shields.io/pypi/v/objectnat.svg)](https://pypi.org/project/objectnat/)
-
-- [РИДМИ (Russian)](README_ru.md)
-<p align="center">
-<img src="https://github.com/user-attachments/assets/d3878cce-8eba-4f96-8458-9a798d436120" alt="logo" width="400">
-</p>
-
-#### **ObjectNat** is an open-source library created for geospatial analysis created by **IDU team**
-
-## ObjectNat Components
-
-- [IduEdu](https://github.com/DDonnyy/IduEdu) : `IduEdu` provides graph functions
-- [population-restorator](https://github.com/kanootoko/population-restorator) : `restorator` provides city resettlement
-
-## Features and how to use
-
-1. **[City graph from OSM (IduEdu)](./examples/get_any_graph.ipynb)** - Functions to assemble a road, pedestrian, and public transport graph
-from OpenStreetMap (OSM) and creating Intermodal graph. 
-
-   <img src="https://github.com/user-attachments/assets/8dc98da9-8462-415e-8cc8-bdfca788e206" alt="IntermodalGraph" height="250">
-
-2. **[Adjacency matrix](./examples/calculate_adjacency_matrix.ipynb)** - Calculate adjacency matrix based on the provided graph and edge weight type
-(time or distance). The intermodal graph can be obtained using the previous example.
-
-3. **[Isochrones,transport accessibility](./examples/isochrone_generator.ipynb)** - Function for generating isochrones to
-analyze transportation accessibility from specified starting coordinates. Isochrones can be constructed based on
-pedestrian, automobile, or public transport graphs, or a combination thereof.
-
-   <img src="https://github.com/user-attachments/assets/37f308a5-db56-497d-b080-4edef3584fe5" alt="isochrones" height="250">
-
-4. **[Population restoration](./examples/restore_population.ipynb)** - Function for resettling population into the provided
-layer of residential buildings. This function distributes people among dwellings based on the total city population
-and the living area of each house.
-5. **[Service provision](./examples/calculate_provision.ipynb)** - Function for calculating the provision of residential buildings and population
-with services. 
-
-   <img src="https://github.com/user-attachments/assets/5f2b3c55-9a02-4d70-80f4-503b77023eda" alt="ProvisionSchools" 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://github.com/user-attachments/assets/2927ac86-01e8-4b0e-9ea8-72ad81c13cf5" alt="visibility-from-point" height="250"> 
-
-   <img src="https://github.com/user-attachments/assets/b5b0d4b3-a02f-4ade-8772-475703cd6435" alt="visibility-catchment-area" height="250">
-
-7. **[Noise simulation](./examples/noise_simulation.ipynb)** - Simulates noise propagation from a set of source points
-considering obstacles, trees, and environmental factors.
-**[Detailed information in Wiki](https://github.com/DDonnyy/ObjectNat/wiki/Noise-simulation)**
-
-   <img src="https://github.com/user-attachments/assets/dd185867-67c4-4d03-8905-d06dd1d36fb3" alt="noise_sim" height="250">
-
-8. **[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://github.com/user-attachments/assets/2a9ad722-87d2-4954-9612-5ac3765aa824" alt="service-clusterization" height="250">
-   
-9. **[Living buildings from OSM](./examples/download_buildings_from_osm.ipynb)** - This function downloads building geometries from OpenStreetMap (OSM)
-for a specified territory and assigns attributes to each building. Specifically, it determines whether a building
-is residential (`is_living` attribute) and estimates the approximate number of inhabitants (`approximate_pop` attribute).
-   
-   <img src="https://github.com/user-attachments/assets/d60dcd85-1a2e-4342-aae4-561aeda18858" alt="Living buildings" height="250">
-   
-## Installation
-
-**ObjectNat** can be installed with ``pip``:
-
-```
-pip install ObjectNat
-```
-### Configuration changes
-
-```python
-from objectnat import config
-
-config.set_timeout(10)  # Timeout for overpass queries
-config.change_logger_lvl('INFO')  # To mute all debug msgs
-config.set_enable_tqdm(False)  # To mute all tqdm's progress bars
-config.set_overpass_url('http://your.overpass-api.de/interpreter/URL')
-```
-## Contacts
-
-- [NCCR](https://actcognitive.org/) - National 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.2.7.dist-info/RECORD

@@ -1,26 +0,0 @@
-objectnat/__init__.py,sha256=OnDvrLPLEeYIE_9qOVYgMc-PkRzIqShtGxirguEXiRU,260
-objectnat/_api.py,sha256=UX9XwHzpXbkPZksovT33kn5_g9r0qm_cGVbGLsBLoZg,746
-objectnat/_config.py,sha256=sv13J3yMw1cmmkgPMf08zinLwPKYwXHJGfchqmurSg8,2268
-objectnat/_version.py,sha256=ZQLNbaBb3Roa6Z5LEm--iZickCQhYJVSrDpqf4YBbzc,18
-objectnat/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-objectnat/methods/balanced_buildings.py,sha256=hLT2QgmGWpROtnL8SJQIujeP6q9ou15yIdHpv66CfMs,2892
-objectnat/methods/cluster_points_in_polygons.py,sha256=ANoPHB89Ih6SYUTs0VoYqW7zi9GVIytSOGySoQ3vby4,5073
-objectnat/methods/coverage_zones.py,sha256=yMeK1DjneMAxxKv9busEKdAsP25xiJMcPCixlJCDI4s,2835
-objectnat/methods/isochrones.py,sha256=EbcTMCz9W9_QzvL7Of_nXWVEMv_3CqqiEvLX0Z_pagY,6123
-objectnat/methods/living_buildings_osm.py,sha256=DW7k-SWJA3Ot8qoE1FEsEH8PkB_uLQwd7KGVwfYFanE,5786
-objectnat/methods/noise/__init__.py,sha256=7B05RT3g9NXzTBC9OLKkzlHF7EOdZfVs_QZJibTfusU,150
-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=YWTzFnwIamsb9qlIZTWPNh26Z1S29uoS54ImHWYH8qg,20109
-objectnat/methods/provision/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-objectnat/methods/provision/provision.py,sha256=YDhEbGQksfaLPmqt0GOl7zsBdOlCxXesznZQ40vODjY,4749
-objectnat/methods/provision/provision_exceptions.py,sha256=lznEmlmZDzGIOtapZVqZDMutIi5eGbFuVCYeVa7VZWk,1687
-objectnat/methods/provision/provision_model.py,sha256=lL-Oynm_0Z0PXbw2bnQ1gB1kmZmSR4pBmVtqWD_JQo4,14452
-objectnat/methods/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-objectnat/methods/utils/geom_utils.py,sha256=HxC5xSDHFaTZW2HgUuXeRabGfDuz0J009hLVM60rLE4,2923
-objectnat/methods/visibility_analysis.py,sha256=PolNPU9Qyc6DrOWUwZDY_ErODxrCsfrn-zfg1pIt7Po,21618
-objectnat-0.2.7.dist-info/LICENSE.txt,sha256=yPEioMfTd7JAQgAU6J13inS1BSjwd82HFlRSoIb4My8,1498
-objectnat-0.2.7.dist-info/METADATA,sha256=FRTcsM3_rR577RnhGAfRTb0g9A9rC1A0-15QwD6JUYY,6112
-objectnat-0.2.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-objectnat-0.2.7.dist-info/RECORD,,