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

objectnat/methods/provision/provision.py

@@ -4,8 +4,12 @@ import geopandas as gpd
 import numpy as np
 import pandas as pd
 
+from objectnat import config
+
 from .provision_model import Provision
 
+logger = config.logger
+
 
 def get_service_provision(
     buildings: gpd.GeoDataFrame,
@@ -39,7 +43,7 @@ def get_service_provision(
         demanded_buildings=buildings,
         adjacency_matrix=adjacency_matrix,
         threshold=threshold,
-    ).get_provisions()
+    ).run()
     return provision_buildings, provision_services, provision_links
 
 
@@ -47,9 +51,12 @@ def clip_provision(
     buildings: gpd.GeoDataFrame, services: gpd.GeoDataFrame, links: gpd.GeoDataFrame, selection_zone: gpd.GeoDataFrame
 ) -> Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
 
-    assert (
-        selection_zone.crs == buildings.crs == services.crs == links.crs
-    ), f"CRS mismatch: buildings_crs:{buildings.crs}, links_crs:{links.crs} , services_crs:{services.crs}, selection_zone_crs:{selection_zone.crs}"
+    assert selection_zone.crs == buildings.crs == services.crs == links.crs, (
+        f"CRS mismatch: buildings_crs:{buildings.crs}, "
+        f"links_crs:{links.crs} , "
+        f"services_crs:{services.crs}, "
+        f"selection_zone_crs:{selection_zone.crs}"
+    )
     buildings = buildings.copy()
     links = links.copy()
     services = services.copy()
@@ -69,12 +76,12 @@ def recalculate_links(
     services = services.copy()
     links = links.copy()
 
-    max_dist = links["distance"].max()
-    assert new_max_dist <= max_dist, "New distance exceeds max links distance"
-
     links_to_recalculate = links[links["distance"] > new_max_dist]
-    links_to_keep = links[links["distance"] <= new_max_dist]
+    if len(links_to_recalculate) == 0:
+        logger.warning("To clip distance exceeds max links distance, returning full provision")
+        return buildings, services, links
 
+    links_to_keep = links[links["distance"] <= new_max_dist]
     free_demand = links_to_recalculate.groupby("building_index").agg({"demand": list, "distance": list})
     free_demand["distance"] = free_demand.apply(
         lambda x: sum((x1 * x2) for x1, x2 in zip(x.demand, x.distance)), axis=1

objectnat/methods/provision/provision_exceptions.py

@@ -7,7 +7,7 @@ class CapacityKeyError(KeyError):
 
     def __str__(self):
         if self.message:
-            return "CapacityKeyError, {0} ".format(self.message)
+            return f"CapacityKeyError, {self.message} "
 
         return (
             "Column 'capacity' was not found in provided 'services' GeoDataFrame. This attribute "
@@ -24,7 +24,7 @@ class CapacityValueError(ValueError):
 
     def __str__(self):
         if self.message:
-            return "CapacityValueError, {0} ".format(self.message)
+            return f"CapacityValueError, {self.message} "
 
         return "Column 'capacity' in 'services' GeoDataFrame  has no valid value."
 
@@ -38,7 +38,7 @@ class DemandKeyError(KeyError):
 
     def __str__(self):
         if self.message:
-            return "DemandKeyError, {0} ".format(self.message)
+            return f"DemandKeyError, {self.message} "
 
         return (
             "The column 'demand' was not found in the provided 'demanded_buildings' GeoDataFrame. "
@@ -55,5 +55,5 @@ class DemandValueError(ValueError):
 
     def __str__(self):
         if self.message:
-            return "DemandValueError, {0} ".format(self.message)
+            return f"DemandValueError, {self.message} "
         return "Column 'demand' in 'demanded_buildings' GeoDataFrame  has no valid value."

objectnat/methods/provision/provision_model.py

@@ -19,9 +19,9 @@ class Provision:
     Represents the logic for city provision calculations using a gravity or linear model.
 
     Args:
-        services (InstanceOf[gpd.GeoDataFrame]): GeoDataFrame representing the services available in the city.
-        demanded_buildings (InstanceOf[gpd.GeoDataFrame]): GeoDataFrame representing the buildings with demands for services.
-        adjacency_matrix (InstanceOf[pd.DataFrame]): DataFrame representing the adjacency matrix between buildings.
+        services (gpd.GeoDataFrame): GeoDataFrame representing the services available in the city.
+        demanded_buildings (gpd.GeoDataFrame): GeoDataFrame representing the buildings with demands for services.
+        adjacency_matrix (pd.DataFrame): DataFrame representing the adjacency matrix between buildings.
         threshold (int): Threshold value for the provision calculations.
         calculation_type (str, optional): Type of calculation ("gravity" or "linear"). Defaults to "gravity".
 
@@ -33,7 +33,7 @@ class Provision:
     column in 'services' or 'demand' column  'demanded_buildings' GeoDataFrame has no valid value.
     """
 
-    _destination_matrix = None
+    destination_matrix = None
 
     def __init__(
         self,
@@ -42,12 +42,13 @@ class Provision:
         adjacency_matrix: pd.DataFrame,
         threshold: int,
     ):
-        self.services = self.ensure_services(services)
-        self.demanded_buildings = self.ensure_buildings(demanded_buildings)
-        self.adjacency_matrix = self.delete_useless_matrix_rows_columns(adjacency_matrix, demanded_buildings, services)
+        self.services = self.ensure_services(services.copy())
+        self.demanded_buildings = self.ensure_buildings(demanded_buildings.copy())
+        self.adjacency_matrix = self.delete_useless_matrix_rows_columns(
+            adjacency_matrix.copy(), demanded_buildings, services
+        ).copy()
         self.threshold = threshold
         self.check_crs(self.demanded_buildings, self.services)
-        print(config.pandarallel_use_file_system)
         pandarallel.initialize(progress_bar=False, verbose=0, use_memory_fs=config.pandarallel_use_file_system)
 
     @staticmethod
@@ -66,9 +67,11 @@ class Provision:
 
     @staticmethod
     def check_crs(demanded_buildings, services):
-        assert (
-            demanded_buildings.crs == services.crs
-        ), f"\nThe CRS in the provided geodataframes are different.\nBuildings CRS:{demanded_buildings.crs}\nServices CRS:{services.crs} \n"
+        assert demanded_buildings.crs == services.crs, (
+            f"\nThe CRS in the provided geodataframes are different."
+            f"\nBuildings CRS:{demanded_buildings.crs}"
+            f"\nServices CRS:{services.crs}"
+        )
 
     @staticmethod
     def delete_useless_matrix_rows_columns(adjacency_matrix, demanded_buildings, services):
@@ -83,63 +86,16 @@ class Provision:
         columns = set(adjacency_matrix.columns.astype(int).tolist())
         dif = columns ^ service_indexes
         adjacency_matrix.drop(columns=(list(dif)), axis=0, inplace=True)
-        return adjacency_matrix
-
-    def get_provisions(self) -> Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
-        self._destination_matrix = pd.DataFrame(
-            0,
-            index=self.adjacency_matrix.columns,
-            columns=self.adjacency_matrix.index,
-        )
-        self.adjacency_matrix = self.adjacency_matrix.transpose()
-        logger.debug(
-            "Calculating provision from {} services to {} buildings.",
-            len(self.services),
-            len(self.demanded_buildings),
-        )
-        self.adjacency_matrix = self.adjacency_matrix.where(self.adjacency_matrix <= self.threshold * 3, np.inf)
-
-        self._destination_matrix = self._provision_loop_gravity(
-            self.demanded_buildings.copy(),
-            self.services.copy(),
-            self.adjacency_matrix.copy() + 1,
-            self.threshold,
-            self._destination_matrix.copy(),
-        )
-        _additional_options(
-            self.demanded_buildings,
-            self.services,
-            self.adjacency_matrix,
-            self._destination_matrix,
-            self.threshold,
-        )
+        return adjacency_matrix.transpose()
 
-        return (
-            self.demanded_buildings,
-            self.services,
-            _calc_links(
-                self._destination_matrix,
-                self.services,
-                self.demanded_buildings,
-                self.adjacency_matrix,
-            ),
-        )
+    def run(self) -> Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
 
-    def _provision_loop_gravity(
-        self,
-        houses_table: gpd.GeoDataFrame,
-        services_table: gpd.GeoDataFrame,
-        distance_matrix: pd.DataFrame,
-        selection_range,
-        destination_matrix: pd.DataFrame,
-        best_houses=0.9,
-    ):
-        def apply_function_based_on_size(df, func, axis, threshold=500):
+        def apply_function_based_on_size(df, func, axis, threshold=100):
             if len(df) > threshold:
                 return df.parallel_apply(func, axis=axis)
             return df.apply(func, axis=axis)
 
-        def _calculate_flows_y(loc):
+        def calculate_flows_y(loc):
             import numpy as np  # pylint: disable=redefined-outer-name,reimported,import-outside-toplevel
             import pandas as pd  # pylint: disable=redefined-outer-name,reimported,import-outside-toplevel
 
@@ -158,7 +114,7 @@ class Provision:
 
             return choice
 
-        def _balance_flows_to_demands(loc):
+        def balance_flows_to_demands(loc):
             import numpy as np  # pylint: disable=redefined-outer-name,reimported,import-outside-toplevel
             import pandas as pd  # pylint: disable=redefined-outer-name,reimported,import-outside-toplevel
 
@@ -177,43 +133,104 @@ class Provision:
                 return choice
             return loc
 
-        temp_destination_matrix = apply_function_based_on_size(
-            distance_matrix, lambda x: _calculate_flows_y(x[x <= selection_range]), 1
+        logger.debug(
+            f"Calculating provision from {len(self.services)} services to {len(self.demanded_buildings)} buildings."
         )
 
-        temp_destination_matrix = temp_destination_matrix.fillna(0)
-
-        temp_destination_matrix = apply_function_based_on_size(temp_destination_matrix, _balance_flows_to_demands, 0)
-
-        temp_destination_matrix = temp_destination_matrix.fillna(0)
-        destination_matrix = destination_matrix.add(temp_destination_matrix, fill_value=0)
-
-        axis_1 = destination_matrix.sum(axis=1)
-        axis_0 = destination_matrix.sum(axis=0)
-
-        services_table["capacity_left"] = services_table["capacity"].subtract(axis_1, fill_value=0)
-        houses_table["demand_left"] = houses_table["demand"].subtract(axis_0, fill_value=0)
+        distance_matrix = self.adjacency_matrix
+        destination_matrix = pd.DataFrame(
+            0,
+            index=distance_matrix.index,
+            columns=distance_matrix.columns,
+            dtype=int,
+        )
+        distance_matrix = distance_matrix.where(distance_matrix <= self.threshold * 3, np.inf)
 
+        houses_table = self.demanded_buildings[["demand", "demand_left"]].copy()
+        services_table = self.services[["capacity", "capacity_left"]].copy()
         distance_matrix = distance_matrix.drop(
             index=services_table[services_table["capacity_left"] == 0].index.values,
             columns=houses_table[houses_table["demand_left"] == 0].index.values,
             errors="ignore",
         )
-
         distance_matrix = distance_matrix.loc[~(distance_matrix == np.inf).all(axis=1)]
         distance_matrix = distance_matrix.loc[:, ~(distance_matrix == np.inf).all(axis=0)]
 
-        selection_range += selection_range
+        distance_matrix = distance_matrix + 1
+        selection_range = (self.threshold + 1) / 2
+        best_houses = 0.9
+        while len(distance_matrix.columns) > 0 and len(distance_matrix.index) > 0:
+            objects_n = sum(distance_matrix.shape)
+            logger.debug(
+                f"Matrix shape: {distance_matrix.shape},"
+                f" Total objects: {objects_n},"
+                f" Selection range: {selection_range},"
+                f" Best houses: {best_houses}"
+            )
+
+            temp_destination_matrix = apply_function_based_on_size(
+                distance_matrix, lambda x: calculate_flows_y(x[x <= selection_range]), 1
+            )
 
-        if best_houses > 0.1:
-            best_houses -= 0.1
+            temp_destination_matrix = temp_destination_matrix.fillna(0)
+            temp_destination_matrix = apply_function_based_on_size(temp_destination_matrix, balance_flows_to_demands, 0)
+            temp_destination_matrix = temp_destination_matrix.fillna(0)
+            temp_destination_matrix_aligned = temp_destination_matrix.reindex(
+                index=destination_matrix.index, columns=destination_matrix.columns, fill_value=0
+            )
+            del temp_destination_matrix
+            destination_matrix_np = destination_matrix.to_numpy()
+            temp_destination_matrix_np = temp_destination_matrix_aligned.to_numpy()
+            del temp_destination_matrix_aligned
+            destination_matrix = pd.DataFrame(
+                destination_matrix_np + temp_destination_matrix_np,
+                index=destination_matrix.index,
+                columns=destination_matrix.columns,
+            )
+            del destination_matrix_np, temp_destination_matrix_np
+            axis_1 = destination_matrix.sum(axis=1).astype(int)
+            axis_0 = destination_matrix.sum(axis=0).astype(int)
+
+            services_table["capacity_left"] = services_table["capacity"].subtract(axis_1, fill_value=0)
+            houses_table["demand_left"] = houses_table["demand"].subtract(axis_0, fill_value=0)
+            del axis_1, axis_0
+            distance_matrix = distance_matrix.drop(
+                index=services_table[services_table["capacity_left"] == 0].index.values,
+                columns=houses_table[houses_table["demand_left"] == 0].index.values,
+                errors="ignore",
+            )
+            distance_matrix = distance_matrix.loc[~(distance_matrix == np.inf).all(axis=1)]
+            distance_matrix = distance_matrix.loc[:, ~(distance_matrix == np.inf).all(axis=0)]
+
+            selection_range *= 1.5
             if best_houses <= 0.1:
                 best_houses = 0
-        if len(distance_matrix.columns) > 0 and len(distance_matrix.index) > 0:
-            return self._provision_loop_gravity(
-                houses_table, services_table, distance_matrix, selection_range, destination_matrix, best_houses
-            )
-        return destination_matrix
+            else:
+                objects_n_new = sum(distance_matrix.shape)
+                best_houses = objects_n_new / (objects_n / best_houses)
+
+        logger.debug("Done!")
+        del distance_matrix, houses_table, services_table
+        self.destination_matrix = destination_matrix
+
+        _additional_options(
+            self.demanded_buildings,
+            self.services,
+            self.adjacency_matrix,
+            self.destination_matrix,
+            self.threshold,
+        )
+
+        return (
+            self.demanded_buildings,
+            self.services,
+            _calc_links(
+                self.destination_matrix,
+                self.services,
+                self.demanded_buildings,
+                self.adjacency_matrix,
+            ),
+        )
 
 
 def _calc_links(
@@ -279,8 +296,7 @@ def _additional_options(
     buildings["supplyed_demands_without"] = 0
     services["carried_capacity_within"] = 0
     services["carried_capacity_without"] = 0
-    for i in range(len(destination_matrix)):
-        loc = destination_matrix.iloc[i]
+    for _, loc in destination_matrix.iterrows():
         distances_all = matrix.loc[loc.name]
         distances = distances_all[distances_all <= normative_distance]
         s = matrix.loc[loc.name] <= normative_distance
@@ -306,6 +322,7 @@ def _additional_options(
         services.at[loc.name, "carried_capacity_without"] = (
             services.at[loc.name, "carried_capacity_without"] + without.sum()
         )
+    buildings["min_dist"] = matrix.min(axis=0).replace(np.inf, None)
     buildings["avg_dist"] = (buildings["avg_dist"] / (buildings["demand"] - buildings["demand_left"])).astype(
         np.float32
     )
@@ -318,3 +335,4 @@ def _additional_options(
     buildings["supplyed_demands_without"] = buildings["supplyed_demands_without"].astype(np.uint16)
     services["carried_capacity_within"] = services["carried_capacity_within"].astype(np.uint16)
     services["carried_capacity_without"] = services["carried_capacity_without"].astype(np.uint16)
+    logger.debug("Done adding additional options")

objectnat/methods/utils/geom_utils.py

@@ -0,0 +1,79 @@
+import math
+
+import geopandas as gpd
+from shapely import LineString, MultiLineString, MultiPolygon, Point, Polygon
+from shapely.ops import polygonize, unary_union
+
+from objectnat import config
+
+logger = config.logger
+
+
+def polygons_to_multilinestring(geom: Polygon | 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))
+    return convert_multipolygon(geom)
+
+
+def explode_linestring(geometry: LineString) -> list[LineString]:
+    """A function to return all segments of a linestring as a list of linestrings"""
+    coords_ext = geometry.coords  # Create a list of all line node coordinates
+    result = [LineString(part) for part in zip(coords_ext, coords_ext[1:])]
+    return result
+
+
+def point_side_of_line(line: LineString, point: Point) -> int:
+    """A positive indicates the left-hand side a negative indicates the right-hand side"""
+    x1, y1 = line.coords[0]
+    x2, y2 = line.coords[-1]
+    x, y = point.coords[0]
+    cross_product = (x2 - x1) * (y - y1) - (y2 - y1) * (x - x1)
+    if cross_product > 0:
+        return 1
+    return -1
+
+
+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 gdf_to_circle_zones_from_point(
+    gdf: gpd.GeoDataFrame, point_from: Point, zone_radius, resolution=4, explode_multigeom=True
+) -> gpd.GeoDataFrame:
+    """n_segments = 4*resolution,e.g. if resolution = 4 that means there will be 16 segments"""
+    crs = gdf.crs
+    buffer = point_from.buffer(zone_radius, resolution=resolution)
+    gdf_unary = gdf.clip(buffer, keep_geom_type=True).unary_union
+    gdf_geometry = (
+        gpd.GeoDataFrame(geometry=[gdf_unary], crs=crs)
+        .explode(index_parts=True)
+        .geometry.apply(polygons_to_multilinestring)
+        .unary_union
+    )
+    zones_lines = [LineString([Point(coords1), Point(point_from)]) for coords1 in buffer.exterior.coords[:-1]]
+    if explode_multigeom:
+        return (
+            gpd.GeoDataFrame(geometry=list(polygonize(unary_union([gdf_geometry] + zones_lines))), crs=crs)
+            .clip(gdf_unary, keep_geom_type=True)
+            .explode(index_parts=False)
+        )
+    return gpd.GeoDataFrame(geometry=list(polygonize(unary_union([gdf_geometry] + zones_lines))), crs=crs).clip(
+        gdf_unary, keep_geom_type=True
+    )

objectnat/methods/visibility_analysis.py

@@ -10,11 +10,19 @@ from shapely.ops import polygonize, unary_union
 from tqdm.contrib.concurrent import process_map
 
 from objectnat import config
+from objectnat.methods.utils.geom_utils import (
+    explode_linestring,
+    get_point_from_a_thorough_b,
+    point_side_of_line,
+    polygons_to_multilinestring,
+)
 
 logger = config.logger
 
 
-def get_visibility_accurate(point_from: Point, obstacles: gpd.GeoDataFrame, view_distance) -> Polygon:
+def get_visibility_accurate(
+    point_from: Point, obstacles: gpd.GeoDataFrame, view_distance, return_max_view_dist=False
+) -> Polygon | tuple[Polygon, float]:
     """
     Function to get accurate visibility from a given point to buildings within a given distance.
 
@@ -26,11 +34,13 @@ def get_visibility_accurate(point_from: Point, obstacles: gpd.GeoDataFrame, view
         A GeoDataFrame containing the geometry of the obstacles.
     view_distance : float
         The distance of view from the point.
+    return_max_view_dist
+        If True, the max view distance is returned with view polygon in tuple.
 
     Returns
     -------
-    Polygon
-        A polygon representing the area of visibility from the given point.
+    Polygon | tuple[Polygon, float]
+        A polygon representing the area of visibility from the given point or polygon with max view distance.
 
     Notes
     -----
@@ -45,34 +55,29 @@ def get_visibility_accurate(point_from: Point, obstacles: gpd.GeoDataFrame, view
     >>> 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
+    def find_furthest_point(point_from, view_polygon):
+        try:
+            res = round(max(Point(coords).distance(point_from) for coords in view_polygon.exterior.coords), 1)
+        except Exception as e:
+            print(view_polygon)
+            raise e
+        return res
+
+    obstacles = obstacles.copy()
+    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)
-    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()
+    obstacles_in_buffer = obstacles.loc[s[s].index].geometry
+
+    buildings_lines_in_buffer = gpd.GeoSeries(
+        pd.Series(
+            obstacles_in_buffer.apply(polygons_to_multilinestring).explode(index_parts=False).apply(explode_linestring)
+        ).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(
@@ -82,15 +87,12 @@ def get_visibility_accurate(point_from: Point, obstacles: gpd.GeoDataFrame, view
 
     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
+    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:
-        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_sind = gdf_sindex.nearest(point_from, 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]
 
@@ -98,31 +100,49 @@ def get_visibility_accurate(point_from: Point, obstacles: gpd.GeoDataFrame, view
         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]])
+        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)
+            polygon = LineString([p1, p2])
+            polygon = polygon.buffer(
+                distance=max_dist * point_side_of_line(polygon, wall_b_centroid), single_sided=True
+            )
+        else:
+            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)
 
+        if not polygon.is_valid or polygon.area < 1:
+            buildings_lines_in_buffer.reset_index(drop=True, inplace=True)
+            continue
+
         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))
+    logger.debug("Done calculating!")
+    res = point_buffer.difference(unary_union(polygons + obstacles_in_buffer.to_list()))
+
     if isinstance(res, Polygon):
+        if return_max_view_dist:
+            return res, find_furthest_point(point_from, res)
         return res
     res = list(res.geoms)
     polygon_containing_point = None
+
     for polygon in res:
-        if polygon.contains(point_from):
+        if polygon.intersects(point_from):
             polygon_containing_point = polygon
             break
+    if return_max_view_dist:
+        return polygon_containing_point, find_furthest_point(point_from, polygon_containing_point)
     return polygon_containing_point