test_gis_utils.py

# imports

# standard

from ast import literal_eval
import random

# local, external

from geopandas import GeoDataFrame
from pandas import concat, MultiIndex, Series
import networkx as nx
import osmnx as ox
from shapely.geometry import Point, LineString

# local, internal

import src.topupopt.data.gis.identify as gis_iden
import src.topupopt.data.gis.utils as gis_utils
import src.topupopt.data.gis.osm as _osm

ox.settings.use_cache = True

# *****************************************************************************
# *****************************************************************************


class TestGisUtils:
    # *************************************************************************
    # *************************************************************************

    def test_examples(self):
        # test io

        self.example_io_geodataframe(preserve_original_gdf=True, identify_columns=False)

        self.example_io_geodataframe(
            preserve_original_gdf=False, identify_columns=False
        )

        # example_io_geodataframe(
        #     preserve_original_gdf=True, identify_columns=True
        #     )

        # example_io_geodataframe(
        #     preserve_original_gdf=False, identify_columns=True
        #     )

        # TODO: handle GeoJSON files

        # example_io_geodataframe(preserve_original_gdf=True,
        #                         file_extension='.json')

        # example_io_geodataframe(preserve_original_gdf=False,
        #                         file_extension='.json')

    # *************************************************************************
    # *************************************************************************

    def test_identifying_entrances_simple_no_driveway(self):
        # no driveway, all nodes

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=False,
            focus_on_node_P_only=False,
        )

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=False,
            create_reversed_edges=False,
            focus_on_node_P_only=False,
        )

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=True,
            focus_on_node_P_only=False,
        )

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=False,
            create_reversed_edges=True,
            focus_on_node_P_only=False,
        )

        # no driveway, all nodes, multiple addresses per edge

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=False,
            focus_on_node_P_only=False,
            use_multiple_addresses=True,
        )

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=False,
            create_reversed_edges=False,
            focus_on_node_P_only=False,
            use_multiple_addresses=True,
        )

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=True,
            focus_on_node_P_only=False,
            use_multiple_addresses=True,
        )

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=False,
            create_reversed_edges=True,
            focus_on_node_P_only=False,
            use_multiple_addresses=True,
        )

        # no driveway, all nodes, revert projection

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=False,
            create_reversed_edges=True,
            focus_on_node_P_only=False,
            revert_to_original_crs=True,
        )

        # no driveway, limited selection of nodes

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=False,
            focus_on_node_P_only=True,
        )

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=False,
            create_reversed_edges=False,
            focus_on_node_P_only=True,
        )

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=True,
            focus_on_node_P_only=True,
        )

        self.example_identify_entrances_simple_no_driveway(
            AB_right_BC_wrong=False,
            create_reversed_edges=True,
            focus_on_node_P_only=True,
        )

        # driveway, all nodes

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=True, create_reversed_edges=False
        )

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=False, create_reversed_edges=False
        )

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=True, create_reversed_edges=True
        )

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=False, create_reversed_edges=True
        )

        # driveway, all nodes, multiple addresses per edge

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=False,
            use_multiple_addresses=True,
        )

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=False,
            create_reversed_edges=False,
            use_multiple_addresses=True,
        )

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=True,
            use_multiple_addresses=True,
        )

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=False,
            create_reversed_edges=True,
            use_multiple_addresses=True,
        )

        # driveway, limited selection

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=False,
            focus_on_node_P_only=True,
        )

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=False,
            create_reversed_edges=False,
            focus_on_node_P_only=True,
        )

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=True,
            focus_on_node_P_only=True,
        )

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=False,
            create_reversed_edges=True,
            focus_on_node_P_only=True,
        )

        # driveway variation

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=False,
            focus_on_node_P_only=False,
            BD_with_name=False,
            BD_right_address=False,
        )

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=False,
            focus_on_node_P_only=False,
            BD_with_name=True,
            BD_right_address=False,
        )

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=False,
            create_reversed_edges=False,
            focus_on_node_P_only=False,
            BD_with_name=True,
            BD_right_address=False,
        )

        self.example_identify_entrances_simple_driveway(
            AB_right_BC_wrong=True,
            create_reversed_edges=False,
            focus_on_node_P_only=False,
            BD_with_name=True,
            BD_right_address=True,
        )

        # special cases

        self.example_identify_entrances_simple_special(
            create_reversed_edges=False,
            revert_to_original_crs=False,
            focus_on_node_P_only=False,
        )

        self.example_identify_entrances_simple_special(
            create_reversed_edges=True,
            revert_to_original_crs=False,
            focus_on_node_P_only=False,
        )

        self.example_identify_entrances_simple_special(
            create_reversed_edges=False,
            revert_to_original_crs=False,
            focus_on_node_P_only=True,
        )

        self.example_identify_entrances_simple_special(
            create_reversed_edges=True,
            revert_to_original_crs=False,
            focus_on_node_P_only=True,
        )

        # no matching street name in the entire network

        self.example_identify_entrances_simple_special(
            create_reversed_edges=False,
            revert_to_original_crs=False,
            focus_on_node_P_only=False,
            CE_wrong=True,
        )

        # TODO: test a case with multiple parallel edges

    # *************************************************************************
    # *************************************************************************

    def test_generating_node_containers(self):
        # test generating containers

        self.example_generate_node_container(False, False)

        self.example_generate_node_container(True, False)

        self.example_generate_node_container(False, True)

        self.example_generate_node_container(True, True)

        self.example_generate_node_container(False, False, True)

    # *************************************************************************
    # *************************************************************************

    def get_node_gdf_A(
        self,
        right_address: str = "right",
        wrong_address: str = "wrong",
        country_code: str = _osm.KEY_COUNTRY_DK,
    ):
        # 4 nodes: A, B, C and P

        # node A

        osmid_A = "A"

        xy_A = (0, 0)

        geo_A = Point(xy_A)

        node_uid_A = 5123

        address_A = None

        # node B

        osmid_B = "B"

        xy_B = (1, 0)

        geo_B = Point(xy_B)

        node_uid_B = 1844

        address_B = None

        # node C

        osmid_C = "C"

        xy_C = (2, 0)

        geo_C = Point(xy_C)

        node_uid_C = 1845

        address_C = None

        # node P

        osmid_P = "P"

        xy_P = (0.5, 1)

        geo_P = Point(xy_P)

        node_uid_P = 9475

        address_P = right_address

        # **************************************************************************

        # geodataframe: should have 'addr:street', 'osak:identifier' and index

        gdf = GeoDataFrame(
            data={
                _osm.KEY_OSM_STREET: [
                    address_A,  # A
                    address_B,  # B
                    address_C,  # C
                    address_P,
                ],  # P
                _osm.KEY_OSM_BUILDING_ENTRANCE_ID[country_code]: [
                    node_uid_A,  # A
                    node_uid_B,  # B
                    node_uid_C,  # C
                    node_uid_P,
                ],  # P
                _osm.KEY_OSMNX_ELEMENT_TYPE: ["node", "node", "node", "node"],
                _osm.KEY_OSMNX_OSMID: [osmid_A, osmid_B, osmid_C, osmid_P],
            },
            geometry=[geo_A, geo_B, geo_C, geo_P],
        )

        gdf.set_index(
            [_osm.KEY_OSMNX_ELEMENT_TYPE, _osm.KEY_OSMNX_OSMID], drop=True, inplace=True
        )

        return gdf

        # **************************************************************************

    # *****************************************************************************
    # *****************************************************************************

    def get_node_gdf_B(
        self,
        right_address: str = "right",
        wrong_address: str = "wrong",
        country_code: str = _osm.KEY_COUNTRY_DK,
    ):
        # **************************************************************************

        gdf = self.get_node_gdf_A(
            right_address=right_address,
            wrong_address=wrong_address,
            country_code=country_code,
        )

        # add another node D closer to P than A, B and C

        osmid_D = "D"

        xy_D = (0.75, 1)

        geo_D = Point(xy_D)

        node_uid_D = 8842

        # address_D = None

        gdf_node_D = GeoDataFrame(
            {
                _osm.KEY_OSMNX_GEOMETRY: [geo_D],
                _osm.KEY_OSM_BUILDING_ENTRANCE_ID[country_code]: [node_uid_D],
                # _osm.KEY_OSM_STREET: [address_D],# P
                # _osm.KEY_OSMNX_ELEMENT_TYPE: ['node'],
                # _osm.KEY_OSMNX_OSMID: [osmid_D]
            },
            # index=[('node', osmid_D)],
            index=MultiIndex.from_tuples(
                [("node", osmid_D)],
                names=[_osm.KEY_OSMNX_ELEMENT_TYPE, _osm.KEY_OSMNX_OSMID],
            ),
        )

        # **************************************************************************

        gdf = concat([gdf, gdf_node_D])

        return gdf

        # **************************************************************************

    # *****************************************************************************
    # *****************************************************************************

    def get_node_gdf_C(
        self,
        right_address: str = "right",
        wrong_address: str = "wrong",
        country_code: str = _osm.KEY_COUNTRY_DK,
    ):
        # **************************************************************************

        gdf = self.get_node_gdf_B(
            right_address=right_address,
            wrong_address=wrong_address,
            country_code=country_code,
        )

        # add another node E, east of C

        osmid_E = "E"

        xy_E = (3, 0)

        geo_E = Point(xy_E)

        node_uid_E = 9173

        # address_E = right_address

        gdf_node_E = GeoDataFrame(
            {
                _osm.KEY_OSMNX_GEOMETRY: [geo_E],
                _osm.KEY_OSM_BUILDING_ENTRANCE_ID[country_code]: [node_uid_E],
                # _osm.KEY_OSM_STREET: [address_E],
            },
            # index=[('node', osmid_E)]
            index=MultiIndex.from_tuples(
                [("node", osmid_E)],
                names=[_osm.KEY_OSMNX_ELEMENT_TYPE, _osm.KEY_OSMNX_OSMID],
            ),
        )

        # **************************************************************************

        gdf = concat([gdf, gdf_node_E])

        return gdf

        # **************************************************************************

    # *****************************************************************************
    # *****************************************************************************

    def get_network_A(
        self,
        gdf: GeoDataFrame,
        right_address: str = "right",
        wrong_address: str = "wrong",
        AB_right_BC_wrong: bool = True,
        country_code: str = _osm.KEY_COUNTRY_DK,
        use_multiple_addresses: bool = False,
    ):
        # **************************************************************************

        # create network

        (
            node_keys,
            node_data_container,
            node_key_to_gdf_index_dict,
        ) = gis_utils.prepare_node_data_from_geodataframe(
            include_geometry=True, gdf=gdf
        )

        network = nx.MultiDiGraph()

        network.graph["crs"] = "EPSG:4326"

        network.add_nodes_from(node_data_container)

        # **************************************************************************

        # two edges: AB and BC

        node_key_A = "A"
        node_key_B = "B"
        node_key_C = "C"

        # edge AB

        geo_AB = LineString(
            [
                (
                    network.nodes[node_key_A][_osm.KEY_OSMNX_X],
                    network.nodes[node_key_A][_osm.KEY_OSMNX_Y],
                ),
                (
                    network.nodes[node_key_B][_osm.KEY_OSMNX_X],
                    network.nodes[node_key_B][_osm.KEY_OSMNX_Y],
                ),
            ]
        )

        length_AB = network.nodes[node_key_A][_osm.KEY_OSMNX_GEOMETRY].distance(
            network.nodes[node_key_B][_osm.KEY_OSMNX_GEOMETRY]
        )

        network.add_edge(
            node_key_A,
            node_key_B,
            **{
                _osm.KEY_OSMNX_GEOMETRY: geo_AB,
                _osm.KEY_OSMNX_LENGTH: length_AB,
                _osm.KEY_OSMNX_NAME: (
                    ["HZ", (right_address if AB_right_BC_wrong else wrong_address)]
                    if use_multiple_addresses
                    else (right_address if AB_right_BC_wrong else wrong_address)
                ),
            }
        )

        # edge BC

        geo_BC = LineString(
            [
                (
                    network.nodes[node_key_B][_osm.KEY_OSMNX_X],
                    network.nodes[node_key_B][_osm.KEY_OSMNX_Y],
                ),
                (
                    network.nodes[node_key_C][_osm.KEY_OSMNX_X],
                    network.nodes[node_key_C][_osm.KEY_OSMNX_Y],
                ),
            ]
        )

        length_BC = network.nodes[node_key_B][_osm.KEY_OSMNX_GEOMETRY].distance(
            network.nodes[node_key_C][_osm.KEY_OSMNX_GEOMETRY]
        )

        network.add_edge(
            node_key_B,
            node_key_C,
            **{
                _osm.KEY_OSMNX_GEOMETRY: geo_BC,
                _osm.KEY_OSMNX_LENGTH: length_BC,
                _osm.KEY_OSMNX_NAME: (
                    [(wrong_address if AB_right_BC_wrong else right_address), "UQ"]
                    if use_multiple_addresses
                    else (wrong_address if AB_right_BC_wrong else right_address)
                ),
            }
        )

        # **************************************************************************

        return network, node_keys, node_key_to_gdf_index_dict

        # **************************************************************************

    # *****************************************************************************
    # *****************************************************************************

    def get_network_B(
        self,
        gdf: GeoDataFrame,
        right_address: str = "right",
        wrong_address: str = "wrong",
        AB_right_BC_wrong: bool = True,
        BD_with_name: bool = False,
        BD_right_address: bool = False,
        country_code: str = _osm.KEY_COUNTRY_DK,
        use_multiple_addresses: bool = False,
    ):
        # **************************************************************************

        # create network

        network, node_keys, node_key_to_gdf_index_dict = self.get_network_A(
            gdf=gdf,
            right_address=right_address,
            wrong_address=wrong_address,
            country_code=country_code,
            AB_right_BC_wrong=AB_right_BC_wrong,
            use_multiple_addresses=use_multiple_addresses,
        )

        # add nameless BD edge

        node_key_B = "B"
        node_key_D = "D"

        # edge AB

        geo_BD = LineString(
            [
                (
                    network.nodes[node_key_B][_osm.KEY_OSMNX_X],
                    network.nodes[node_key_B][_osm.KEY_OSMNX_Y],
                ),
                (
                    network.nodes[node_key_D][_osm.KEY_OSMNX_X],
                    network.nodes[node_key_D][_osm.KEY_OSMNX_Y],
                ),
            ]
        )

        length_BD = network.nodes[node_key_B][_osm.KEY_OSMNX_GEOMETRY].distance(
            network.nodes[node_key_D][_osm.KEY_OSMNX_GEOMETRY]
        )

        BD_dict = {
            _osm.KEY_OSMNX_GEOMETRY: geo_BD,
            _osm.KEY_OSMNX_LENGTH: length_BD,
            # _osm.KEY_OSMNX_NAME: ( # no name for BD
            #    right_address if AB_right_BC_wrong else
            #    wrong_address)
        }

        if BD_with_name:
            BD_dict[_osm.KEY_OSMNX_NAME] = (
                right_address if BD_right_address else wrong_address
            )

        network.add_edge(node_key_B, node_key_D, **BD_dict)

        # **************************************************************************

        return network, node_keys, node_key_to_gdf_index_dict

        # **************************************************************************

    # *****************************************************************************
    # *****************************************************************************

    def get_network_C(
        self,
        gdf: GeoDataFrame,
        right_address: str = "right",
        wrong_address: str = "wrong",
        country_code: str = _osm.KEY_COUNTRY_DK,
        CE_wrong: bool = False,
        use_multiple_addresses: bool = False,
    ):
        # **************************************************************************

        # create network

        network, node_keys, node_key_to_gdf_index_dict = self.get_network_B(
            gdf=gdf,
            right_address=wrong_address,
            wrong_address=wrong_address,
            country_code=country_code,
            AB_right_BC_wrong=True,
        )

        # add a CE edge with the right name

        node_key_C = "C"
        node_key_E = "E"

        # edge AB

        geo_CE = LineString(
            [
                (
                    network.nodes[node_key_C][_osm.KEY_OSMNX_X],
                    network.nodes[node_key_C][_osm.KEY_OSMNX_Y],
                ),
                (
                    network.nodes[node_key_E][_osm.KEY_OSMNX_X],
                    network.nodes[node_key_E][_osm.KEY_OSMNX_Y],
                ),
            ]
        )

        length_CE = network.nodes[node_key_C][_osm.KEY_OSMNX_GEOMETRY].distance(
            network.nodes[node_key_E][_osm.KEY_OSMNX_GEOMETRY]
        )

        network.add_edge(
            node_key_C,
            node_key_E,
            **{
                _osm.KEY_OSMNX_GEOMETRY: geo_CE,
                _osm.KEY_OSMNX_LENGTH: length_CE,
                _osm.KEY_OSMNX_NAME: (wrong_address if CE_wrong else right_address),
            }
        )

        # **************************************************************************

        return network, node_keys, node_key_to_gdf_index_dict

        # **************************************************************************

    # *****************************************************************************
    # *****************************************************************************

    def example_identify_entrances_simple_special(
        self,
        create_reversed_edges: bool = False,
        revert_to_original_crs: bool = False,
        focus_on_node_P_only: bool = False,
        CE_wrong: bool = False,
    ):
        # get problem details

        country_code = _osm.KEY_COUNTRY_DK

        gdf = self.get_node_gdf_C(country_code=country_code)

        network, node_keys, node_key_to_gdf_index_dict = self.get_network_C(
            gdf=gdf, country_code=country_code, CE_wrong=CE_wrong
        )

        # create reverse edges

        if create_reversed_edges:
            previous_edge_keys = list(edge_key for edge_key in network.edges(keys=True))

            for edge_key in previous_edge_keys:
                edge_dict = network.get_edge_data(
                    u=edge_key[0], v=edge_key[1], key=edge_key[2]
                )

                network.add_edge(
                    u_for_edge=edge_key[1], v_for_edge=edge_key[0], **edge_dict
                )

        # find out which is the closest edge

        if focus_on_node_P_only:
            nearest_edge_keys, _, _ = gis_utils.identify_building_entrance_edges(
                gdf=gdf,
                gdf_street_column=_osm.KEY_OSM_STREET,
                network=network,
                node_key_to_gdf_index_dict={"P": node_key_to_gdf_index_dict["P"]},
                crs=None,
                revert_to_original_crs=revert_to_original_crs,
            )

        else:
            nearest_edge_keys, _, _ = gis_utils.identify_building_entrance_edges(
                gdf=gdf,
                gdf_street_column=_osm.KEY_OSM_STREET,
                network=network,
                node_key_to_gdf_index_dict=node_key_to_gdf_index_dict,
                crs=None,
                revert_to_original_crs=revert_to_original_crs,
            )

        # validate the outcome

        if CE_wrong:
            # no edges with the right address, the closest edge should be selected

            assert ("B", "D", 0) == nearest_edge_keys["P"] or (
                "D",
                "B",
                0,
            ) == nearest_edge_keys["P"]

        else:
            # CE has the right address, it should be selected

            assert ("C", "E", 0) == nearest_edge_keys["P"] or (
                "E",
                "C",
                0,
            ) == nearest_edge_keys["P"]

        # **************************************************************************

    # *****************************************************************************
    # *****************************************************************************

    def example_identify_entrances_simple_driveway(
        self,
        AB_right_BC_wrong: bool = True,
        create_reversed_edges: bool = False,
        revert_to_original_crs: bool = False,
        focus_on_node_P_only: bool = False,
        BD_with_name: bool = False,
        BD_right_address: bool = False,
        use_multiple_addresses: bool = False,
    ):
        # get problem details

        country_code = _osm.KEY_COUNTRY_DK

        gdf = self.get_node_gdf_B(country_code=country_code)

        network, node_keys, node_key_to_gdf_index_dict = self.get_network_B(
            gdf=gdf,
            country_code=country_code,
            BD_with_name=BD_with_name,
            BD_right_address=BD_right_address,
            AB_right_BC_wrong=AB_right_BC_wrong,
            use_multiple_addresses=use_multiple_addresses,
        )

        # create reverse edges

        if create_reversed_edges:
            previous_edge_keys = list(edge_key for edge_key in network.edges(keys=True))

            for edge_key in previous_edge_keys:
                edge_dict = network.get_edge_data(
                    u=edge_key[0], v=edge_key[1], key=edge_key[2]
                )

                network.add_edge(
                    u_for_edge=edge_key[1], v_for_edge=edge_key[0], **edge_dict
                )

        # find out which is the closest edge

        if focus_on_node_P_only:
            nearest_edge_keys, _, _ = gis_utils.identify_building_entrance_edges(
                gdf=gdf,
                gdf_street_column=_osm.KEY_OSM_STREET,
                network=network,
                node_key_to_gdf_index_dict={"P": node_key_to_gdf_index_dict["P"]},
                crs=None,
                revert_to_original_crs=revert_to_original_crs,
            )

        else:
            nearest_edge_keys, _, _ = gis_utils.identify_building_entrance_edges(
                gdf=gdf,
                gdf_street_column=_osm.KEY_OSM_STREET,
                network=network,
                node_key_to_gdf_index_dict=node_key_to_gdf_index_dict,
                crs=None,
                revert_to_original_crs=revert_to_original_crs,
            )

        # validate the outcome

        if BD_with_name and not BD_right_address:
            if AB_right_BC_wrong:
                assert ("A", "B", 0) == nearest_edge_keys["P"] or (
                    "B",
                    "A",
                    0,
                ) == nearest_edge_keys["P"]

            else:
                assert ("B", "C", 0) == nearest_edge_keys["P"] or (
                    "C",
                    "B",
                    0,
                ) == nearest_edge_keys["P"]

        # elif BD_with_name and BD_right_address:

        #     assert (('B','D', 0) == nearest_edge_keys['P'] or
        #             ('D','B', 0) == nearest_edge_keys['P'])

        else:
            assert ("B", "D", 0) == nearest_edge_keys["P"] or (
                "D",
                "B",
                0,
            ) == nearest_edge_keys["P"]

        # **************************************************************************

    # *****************************************************************************
    # *****************************************************************************

    def example_identify_entrances_simple_no_driveway(
        self,
        AB_right_BC_wrong: bool = True,
        create_reversed_edges: bool = False,
        focus_on_node_P_only: bool = False,
        revert_to_original_crs: bool = False,
        use_multiple_addresses: bool = False,
    ):
        # get problem details

        country_code = _osm.KEY_COUNTRY_DK

        gdf = self.get_node_gdf_A(country_code=country_code)

        network, node_keys, node_key_to_gdf_index_dict = self.get_network_A(
            gdf=gdf,
            country_code=country_code,
            AB_right_BC_wrong=AB_right_BC_wrong,
            use_multiple_addresses=use_multiple_addresses,
        )

        # create reverse edges

        if create_reversed_edges:
            previous_edge_keys = list(edge_key for edge_key in network.edges(keys=True))

            for edge_key in previous_edge_keys:
                edge_dict = network.get_edge_data(
                    u=edge_key[0], v=edge_key[1], key=edge_key[2]
                )

                network.add_edge(
                    u_for_edge=edge_key[1], v_for_edge=edge_key[0], **edge_dict
                )

        # find out which is the closest edge

        if focus_on_node_P_only:
            nearest_edge_keys, _, _ = gis_utils.identify_building_entrance_edges(
                gdf=gdf,
                gdf_street_column=_osm.KEY_OSM_STREET,
                network=network,
                node_key_to_gdf_index_dict={"P": node_key_to_gdf_index_dict["P"]},
                crs=None,
                revert_to_original_crs=revert_to_original_crs,
            )

        else:
            nearest_edge_keys, _, _ = gis_utils.identify_building_entrance_edges(
                gdf=gdf,
                gdf_street_column=_osm.KEY_OSM_STREET,
                network=network,
                node_key_to_gdf_index_dict=node_key_to_gdf_index_dict,
                crs=None,
                revert_to_original_crs=revert_to_original_crs,
            )

        # validate the outcome

        if AB_right_BC_wrong:
            # the closest edge should be AB

            assert ("A", "B", 0) == nearest_edge_keys["P"]

        else:
            # the closest edge should be BC

            assert ("B", "C", 0) == nearest_edge_keys["P"]

    # *************************************************************************
    # *************************************************************************

    def test_identify_entrances_simple_no_driveway_closest(self):
        # get problem details

        country_code = _osm.KEY_COUNTRY_DK