ObjectNat 1.3.0__tar.gz → 1.3.2__tar.gz

{objectnat-1.3.0 → objectnat-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ObjectNat
-Version: 1.3.0
+Version: 1.3.2
 Summary: ObjectNat is an open-source library created for geospatial analysis created by IDU team
 License: BSD-3-Clause
 Author: DDonnyy
@@ -51,9 +51,9 @@ Object-oriented Network Analysis Tools
 
 |badge-black| |badge-pypi| |badge-ci| |badge-codecov| |badge-license| |badge-docs|
 
-`РИДМИ (Russian) <https://github.com/IDUclub/ObjectNat/blob/main/README_RU.rst>`__
+`РИДМИ (Russian) <https://github.com/IDUclub/ObjectNat/blob/master/README_RU.rst>`__
 
-.. image:: https://raw.githubusercontent.com/IDUclub/ObjectNat/main/docs/_static/ONlogo.svg
+.. image:: https://raw.githubusercontent.com/IDUclub/ObjectNat/master/docs/_static/ONlogo.svg
    :align: center
    :width: 400
    :alt: ObjectNat logo

{objectnat-1.3.0 → objectnat-1.3.2}/README.rst

@@ -30,9 +30,9 @@ Object-oriented Network Analysis Tools
 
 |badge-black| |badge-pypi| |badge-ci| |badge-codecov| |badge-license| |badge-docs|
 
-`РИДМИ (Russian) <https://github.com/IDUclub/ObjectNat/blob/main/README_RU.rst>`__
+`РИДМИ (Russian) <https://github.com/IDUclub/ObjectNat/blob/master/README_RU.rst>`__
 
-.. image:: https://raw.githubusercontent.com/IDUclub/ObjectNat/main/docs/_static/ONlogo.svg
+.. image:: https://raw.githubusercontent.com/IDUclub/ObjectNat/master/docs/_static/ONlogo.svg
    :align: center
    :width: 400
    :alt: ObjectNat logo

{objectnat-1.3.0 → objectnat-1.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ObjectNat"
-version = "1.3.0"
+version = "1.3.2"
 description = "ObjectNat is an open-source library created for geospatial analysis created by IDU team"
 license = "BSD-3-Clause"
 authors = ["DDonnyy <63115678+DDonnyy@users.noreply.github.com>"]

objectnat-1.3.2/src/objectnat/_version.py

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

{objectnat-1.3.0 → objectnat-1.3.2}/src/objectnat/methods/noise/noise_simulation.py

@@ -145,9 +145,9 @@ def simulate_noise(
     source_points = source_points.copy()
     if len(obstacles) > 0:
         obstacles = obstacles.copy()
-        obstacles.geometry = obstacles.geometry.simplify(tolerance=1)
         local_crs = obstacles.estimate_utm_crs()
         obstacles.to_crs(local_crs, inplace=True)
+        obstacles.geometry = obstacles.geometry.simplify(tolerance=1)
         source_points.to_crs(local_crs, inplace=True)
     else:
         local_crs = source_points.estimate_utm_crs()

{objectnat-1.3.0 → objectnat-1.3.2}/src/objectnat/methods/visibility/visibility_analysis.py

@@ -21,6 +21,44 @@ from objectnat.methods.utils.math_utils import min_max_normalization
 logger = config.logger
 
 
+def _ensure_crs(point_from, obstacles):
+    if isinstance(point_from, gpd.GeoDataFrame):
+        if point_from.empty:
+            raise ValueError("GeoDataFrame 'point_from' is empty.")
+        return_gdf = True
+        original_crs = point_from.crs
+        local_crs = point_from.estimate_utm_crs()
+        point_from = point_from.to_crs(local_crs)
+        if len(point_from) > 1:
+            logger.warning(
+                "This method processes only a single point. "
+                f"The GeoDataFrame contains {len(point_from)} points – "
+                "only the first geometry will be used for visibility calculation."
+            )
+        point_geom = point_from.iloc[0].geometry
+        if len(obstacles) > 0:
+            obstacles = obstacles.to_crs(local_crs)
+
+    else:
+        return_gdf = False
+
+        if len(obstacles) > 0:
+            original_crs = obstacles.crs
+            local_crs = obstacles.estimate_utm_crs()
+            obstacles = obstacles.to_crs(local_crs)
+            point_geom = gpd.GeoDataFrame(geometry=[point_from], crs=original_crs).to_crs(local_crs).iloc[0].geometry
+        else:
+            original_crs = 4326
+            logger.warning("No information about CRS was found, accepting everything in 4326")
+            point_gdf = gpd.GeoDataFrame(geometry=[point_from], crs=original_crs)
+            local_crs = point_gdf.estimate_utm_crs()
+
+            point_gdf = point_gdf.to_crs(local_crs)
+            point_geom = point_gdf.geometry.iloc[0]
+
+    return point_geom, obstacles, original_crs, local_crs, return_gdf
+
+
 def get_visibility_accurate(
     point_from: Point | gpd.GeoDataFrame, obstacles: gpd.GeoDataFrame, view_distance, return_max_view_dist=False
 ) -> Polygon | gpd.GeoDataFrame | tuple[Polygon | gpd.GeoDataFrame, float]:
@@ -56,31 +94,21 @@ def get_visibility_accurate(
             raise e
         return res
 
-    local_crs = None
-    original_crs = None
-    return_gdf = False
-    if isinstance(point_from, gpd.GeoDataFrame):
-        original_crs = point_from.crs
-        return_gdf = True
-        if len(obstacles) > 0:
-            local_crs = obstacles.estimate_utm_crs()
-        else:
-            local_crs = point_from.estimate_utm_crs()
-        obstacles = obstacles.to_crs(local_crs)
-        point_from = point_from.to_crs(local_crs)
-        if len(point_from) > 1:
-            logger.warning(
-                f"This method processes only single point. The GeoDataFrame contains {len(point_from)} points - "
-                "only the first geometry will be used for isochrone calculation. "
-            )
-        point_from = point_from.iloc[0].geometry
-    else:
-        obstacles = obstacles.copy()
-    if obstacles.contains(point_from).any():
+    point_geom, obstacles, original_crs, local_crs, return_gdf = _ensure_crs(point_from, obstacles)
+
+    if len(obstacles) > 0 and obstacles.contains(point_geom).any():
         return Polygon()
+
+    point_buffer = point_geom.buffer(view_distance, resolution=32)
+
+    if len(obstacles) == 0:
+        full_vision_gdf = gpd.GeoDataFrame(geometry=[point_buffer], crs=local_crs).to_crs(original_crs)
+        return full_vision_gdf if return_gdf else full_vision_gdf.iloc[0].geometry
+
     obstacles.reset_index(inplace=True, drop=True)
-    point_buffer = point_from.buffer(view_distance, resolution=32)
+
     allowed_geom_types = ["MultiPolygon", "Polygon", "LineString", "MultiLineString"]
+
     obstacles = obstacles[obstacles.geom_type.isin(allowed_geom_types)]
     s = obstacles.intersects(point_buffer)
     obstacles_in_buffer = obstacles.loc[s[s].index].geometry
@@ -98,26 +126,26 @@ def get_visibility_accurate(
         + [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())
+    max_dist = max(view_distance, buildings_in_buffer_points.distance(point_geom).max())
     polygons = []
     buildings_lines_in_buffer = gpd.GeoDataFrame(geometry=buildings_lines_in_buffer, crs=obstacles.crs).reset_index()
     logger.debug("Calculation vis polygon")
     while not buildings_lines_in_buffer.empty:
         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, max_distance=max_dist)
+        nearest_wall_sind = gdf_sindex.nearest(point_geom, return_all=False, max_distance=max_dist)
         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]
+            [(pt, math.atan2(pt.y - point_geom.y, pt.x - point_geom.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 round(delta_angle, 10) == round(math.pi, 10):
             wall_b_centroid = obstacles_in_buffer.loc[nearest_wall["index"]].centroid
-            p1 = get_point_from_a_thorough_b(point_from, points_with_angle[0][0], max_dist)
-            p2 = get_point_from_a_thorough_b(point_from, points_with_angle[1][0], max_dist)
+            p1 = get_point_from_a_thorough_b(point_geom, points_with_angle[0][0], max_dist)
+            p2 = get_point_from_a_thorough_b(point_geom, points_with_angle[1][0], max_dist)
             polygon = LineString([p1, p2])
             polygon = polygon.buffer(
                 distance=max_dist * point_side_of_line(polygon, wall_b_centroid), single_sided=True
@@ -126,8 +154,8 @@ def get_visibility_accurate(
             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)
+            p1 = get_point_from_a_thorough_b(point_geom, points_with_angle[0][0], a)
+            p2 = get_point_from_a_thorough_b(point_geom, points_with_angle[-1][0], a)
             polygon = Polygon([points_with_angle[0][0], p1, p2, points_with_angle[1][0]])
 
         polygons.append(polygon)
@@ -146,15 +174,16 @@ def get_visibility_accurate(
     if isinstance(res, MultiPolygon):
         res = list(res.geoms)
         for polygon in res:
-            if polygon.intersects(point_from):
+            if polygon.intersects(point_geom):
                 res = polygon
                 break
 
+    result_gdf = gpd.GeoDataFrame(geometry=[res], crs=local_crs).to_crs(original_crs)
     if return_gdf:
-        res = gpd.GeoDataFrame(geometry=[res], crs=local_crs).to_crs(original_crs)
-
+        return result_gdf
+    res = result_gdf.to_crs(original_crs).iloc[0].geometry
     if return_max_view_dist:
-        return res, find_furthest_point(point_from, res)
+        return res, find_furthest_point(point_geom, res)
     return res
 
 
@@ -184,29 +213,24 @@ def get_visibility(
         This function provides a quicker but less accurate result compared to `get_visibility_accurate()`.
         If accuracy is important, consider using `get_visibility_accurate()` instead.
     """
-    return_gdf = False
-    if isinstance(point_from, gpd.GeoDataFrame):
-        original_crs = point_from.crs
-        return_gdf = True
-        if len(obstacles) > 0:
-            local_crs = obstacles.estimate_utm_crs()
-        else:
-            local_crs = point_from.estimate_utm_crs()
-        obstacles = obstacles.to_crs(local_crs)
-        point_from = point_from.to_crs(local_crs)
-        if len(point_from) > 1:
-            logger.warning(
-                f"This method processes only single point. The GeoDataFrame contains {len(point_from)} points - "
-                "only the first geometry will be used for isochrone calculation. "
-            )
-        point_from = point_from.iloc[0].geometry
-    else:
-        obstacles = obstacles.copy()
-    point_buffer = point_from.buffer(view_distance, resolution=resolution)
+
+    obstacles = obstacles.copy()
+
+    point_geom, obstacles, original_crs, local_crs, return_gdf = _ensure_crs(point_from, obstacles)
+    print(return_gdf)
+    if len(obstacles) > 0 and obstacles.contains(point_geom).any():
+        return Polygon()
+
+    point_buffer = point_geom.buffer(view_distance, resolution=resolution)
+
+    if len(obstacles) == 0:
+        full_vision_gdf = gpd.GeoDataFrame(geometry=[point_buffer], crs=local_crs).to_crs(original_crs)
+        return full_vision_gdf if return_gdf else full_vision_gdf.iloc[0].geometry
+
     s = obstacles.intersects(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_from, ext]) for ext in buffer_exterior_]
+    line_geometry = [LineString([point_geom, ext]) for ext in buffer_exterior_]
     buffer_lines_gdf = gpd.GeoDataFrame(geometry=line_geometry)
     united_buildings = buildings_in_buffer.union_all()
     if united_buildings:
@@ -223,9 +247,8 @@ def get_visibility(
     if united_buildings:
         circuit = circuit.difference(united_buildings)
 
-    if return_gdf:
-        circuit = gpd.GeoDataFrame(geometry=[circuit], crs=local_crs).to_crs(original_crs)
-    return circuit
+    result_gdf = gpd.GeoDataFrame(geometry=[circuit], crs=local_crs).to_crs(original_crs)
+    return result_gdf if return_gdf else result_gdf.iloc[0].geometry
 
 
 def get_visibilities_from_points(

objectnat-1.3.0/src/objectnat/_version.py

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