Fix matplotlib.cm.get_cmap removal (use plt.get_cmap); pin exact angles, tighten landmarks 2dvis; pump osm->96% and visibility3d->89% coverage

Author: g-filomena

cityImage/plotting/static.py

@@ -946,7 +946,7 @@ def _generate_legend_fig(ax, plot, gdf, unique_categories=None, cmap=None):
         labels = []
         geometry_type = gdf.iloc[0].geometry.geom_type
         for i, cat in enumerate(unique_categories):
-            color = cm.get_cmap(cmap)(i / len(unique_categories))
+            color = plt.get_cmap(cmap)(i / len(unique_categories))
             if geometry_type in ["Polygon", "MultiPolygon"]:
                 patch = mpatches.Patch(color=color, label=str(cat))
             elif geometry_type in ["LineString", "MultiLineString"]:

tests/test_angles_orientations.py

@@ -27,16 +27,19 @@
 @pytest.mark.parametrize("calc", ["vectors", "angular_change", "deflection"])
 @pytest.mark.parametrize("name", list(ORIENTATIONS))
 def test_angle_line_geometries_handles_every_endpoint_orientation(name, calc):
+    # LINE_A is vertical and every B geometry is horizontal, so the two lines are
+    # perpendicular in every orientation and calculation type: the exact answer is 90 degrees.
     angle = ci.angle_line_geometries(LINE_A, ORIENTATIONS[name], degree=True, calculation_type=calc)
-    assert 0.0 <= angle < 360.0
+    assert angle == pytest.approx(90.0)
 
 
-def test_angle_line_geometries_perpendicular_is_90_degrees():
-    # A points up, B points right; they meet at (0, 0).
-    angle = ci.angle_line_geometries(
-        LINE_A, ORIENTATIONS["end_a_eq_start_b"], degree=True, calculation_type="vectors"
-    )
-    assert angle == pytest.approx(90.0)
+def test_angle_line_geometries_collinear_lines_are_180_degrees():
+    # Two straight, co-linear segments meeting end-to-start read as a 180-degree (straight) turn,
+    # proving the function is not simply returning 90 for everything.
+    up_a = LineString([(0, 0), (0, 10)])
+    up_b = LineString([(0, 10), (0, 20)])
+    angle = ci.angle_line_geometries(up_a, up_b, degree=True, calculation_type="vectors")
+    assert angle == pytest.approx(180.0)
 
 
 def test_angle_line_geometries_rejects_non_linestrings():

tests/test_landmarks_scores.py

@@ -69,7 +69,7 @@ def test_structural_score_computes_distance_visibility_and_neighbours():
     out = ci.structural_score(buildings, obstructions_gdf=None, edges_gdf=edges)
     assert (out["road"] > 0).all()  # all buildings sit above the street line
     assert (out["neigh"] >= 1).all()  # a building is its own neighbour at minimum
-    assert out["2dvis"].notna().all()
+    assert (out["2dvis"] > 0).all()  # each building has a non-degenerate advance-visibility area
 
 
 def test_visibility_score_uses_sight_lines_and_height():

tests/test_osm_mocked.py

@@ -10,8 +10,9 @@
 import types
 
 import geopandas as gpd
+import pandas as pd
 import pytest
-from shapely.geometry import Polygon
+from shapely.geometry import LineString, Point, Polygon
 
 import cityImage.osm as osm
 from cityImage.osm import (
@@ -156,3 +157,102 @@ def test_network_from_osm_validates_arguments(monkeypatch):
         network_from_osm("X", download_method="bogus")
     with pytest.raises(ValueError, match="distance is required"):
         network_from_osm("X", download_method="distance_from_address")
+
+
+# --------------------------------------------------------------------------- graph conversion
+
+
+def _fake_network_ox():
+    """Fake OSMnx exposing a graph pipeline over a tiny 3-node / 2-edge network."""
+    nodes = gpd.GeoDataFrame(
+        {"x": [0.0, 10.0, 20.0], "y": [0.0, 0.0, 10.0]},
+        geometry=[Point(0, 0), Point(10, 0), Point(20, 10)],
+        index=[10, 20, 30],  # OSM node ids
+        crs=UTM,
+    )
+    edge_idx = pd.MultiIndex.from_tuples([(10, 20, 0), (20, 30, 0)], names=["u", "v", "key"])
+    edges = gpd.GeoDataFrame(
+        {"length": [10.0, 14.14], "highway": ["residential", "primary"], "name": ["A", "B"]},
+        geometry=[LineString([(0, 0), (10, 0)]), LineString([(10, 0), (20, 10)])],
+        index=edge_idx,
+        crs=UTM,
+    )
+    graph = types.SimpleNamespace(graph={"crs": UTM})
+
+    def graph_to_gdfs(g, nodes=False, edges=False, **_):
+        return nodes_frame.copy() if nodes else edges_frame.copy()
+
+    nodes_frame, edges_frame = nodes, edges
+
+    def graph_from(*_a, **_k):
+        return graph
+
+    return types.SimpleNamespace(
+        graph_from_place=graph_from,
+        graph_from_address=graph_from,
+        graph_from_point=graph_from,
+        graph_from_polygon=graph_from,
+        project_graph=lambda g, to_crs=None: g,
+        graph_to_gdfs=graph_to_gdfs,
+        projection=types.SimpleNamespace(project_gdf=lambda gdf, **_: gdf),
+        features_from_place=lambda q, tags=None: _building_features(tags),
+    )
+
+
+def test_network_from_osm_converts_graph_to_cityimage_schema(monkeypatch):
+    monkeypatch.setattr(osm, "ox", _fake_network_ox())
+    nodes, edges = network_from_osm("Place", crs=UTM, dict_columns={"road_type": "highway"})
+
+    assert {"nodeID", "x", "y", "geometry"}.issubset(nodes.columns)
+    assert {"u", "v", "edgeID", "length", "road_type"}.issubset(edges.columns)
+    node_ids = set(nodes["nodeID"])
+    assert set(edges["u"]).issubset(node_ids) and set(edges["v"]).issubset(node_ids)
+    assert edges["road_type"].tolist() == ["residential", "primary"]  # dict_columns mapping applied
+
+
+@pytest.mark.parametrize(
+    "download_method,query,distance",
+    [
+        ("distance_from_address", "Addr", 500),
+        ("distance_from_point", (0.0, 0.0), 500),
+        ("polygon", Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]), None),
+    ],
+)
+def test_network_from_osm_dispatches_each_graph_method(
+    monkeypatch, download_method, query, distance
+):
+    monkeypatch.setattr(osm, "ox", _fake_network_ox())
+    nodes, edges = network_from_osm(
+        query, crs=UTM, download_method=download_method, distance=distance
+    )
+    assert not nodes.empty and not edges.empty
+
+
+def test_network_from_osm_dict_columns_missing_column_raises(monkeypatch):
+    monkeypatch.setattr(osm, "ox", _fake_network_ox())
+    with pytest.raises(ValueError, match="missing column"):
+        network_from_osm("Place", crs=UTM, dict_columns={"road_type": "does_not_exist"})
+
+
+def test_buildings_from_osm_projects_when_crs_is_none(monkeypatch):
+    monkeypatch.setattr(osm, "ox", _fake_network_ox())
+    buildings = buildings_from_osm(
+        "Place", crs=None, min_area=200
+    )  # triggers projection.project_gdf
+    assert "buildingID" in buildings.columns and len(buildings) == 1
+
+
+def test_buildings_from_osm_drops_below_min_area(monkeypatch):
+    def _two_buildings(tags=None, **_):
+        return gpd.GeoDataFrame(
+            {"building": ["yes", "yes"]},
+            geometry=[
+                Polygon([(0, 0), (20, 0), (20, 20), (0, 20)]),  # 400 m^2 -> kept
+                Polygon([(100, 100), (101, 100), (101, 101), (100, 101)]),  # 1 m^2 -> dropped
+            ],
+            crs=UTM,
+        )
+
+    monkeypatch.setattr(osm, "ox", _fake_ox(_two_buildings))
+    buildings = buildings_from_osm("Place", crs=UTM, min_area=200)
+    assert len(buildings) == 1  # the 1 m^2 footprint is filtered out

tests/test_visibility3d_pipeline.py

@@ -99,6 +99,35 @@ def test_compute_3d_sight_lines_with_consolidation(monkeypatch, tmp_path):
     assert out.geometry.iloc[0].has_z
 
 
+def test_compute_3d_sight_lines_with_simplified_targets(monkeypatch, tmp_path):
+    monkeypatch.chdir(tmp_path)
+    buildings = _buildings()
+    # A single simplified outline enclosing both detailed target buildings, which routes the
+    # pipeline through _use_simplified_buildings (detailed targets mapped onto simplified geometry).
+    simplified = gpd.GeoDataFrame(
+        {"simplifiedID": [1]},
+        geometry=[Polygon([(-1, -1), (11, -1), (11, 31), (-1, 31)])],
+        crs=CRS,
+    )
+
+    out = ci.compute_3d_sight_lines(
+        nodes_gdf=_nodes(),
+        target_buildings_gdf=buildings.copy(),
+        obstructions_buildings_gdf=buildings.copy(),
+        simplified_target_buildings=simplified,
+        edges_gdf=_edges(),
+        city_name="TestSimplified",
+        distance_along=5,
+        min_observer_target_distance=100,
+        num_workers=1,
+    )
+
+    assert isinstance(out, gpd.GeoDataFrame)
+    assert len(out) > 0
+    assert (out.geometry.geom_type == "LineString").all()
+    assert out.geometry.iloc[0].has_z
+
+
 def test_compute_3d_sight_lines_no_visible_returns_empty(monkeypatch, tmp_path):
     monkeypatch.chdir(tmp_path)
     buildings = _buildings()