utility-route-planner/main.py at main · alliander-opensource/utility-route-planner · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
# SPDX-FileCopyrightText: Contributors to the utility-route-project and Alliander N.V.
#
# SPDX-License-Identifier: Apache-2.0

import pathlib
import time

import shapely
import structlog

from utility_route_planner.models.lcpa.lcpa_engine import LcpaUtilityRouteEngine
from settings import Config
from utility_route_planner.models.mcda.mcda_engine import McdaCostSurfaceEngine
from utility_route_planner.models.route_evaluation_metrics import RouteEvaluationMetrics
from utility_route_planner.util.geo_utilities import get_first_last_point_from_linestring
from utility_route_planner.util.write import reset_geopackage
import geopandas as gpd

logger = structlog.get_logger(__name__)


def run_mcda_lcpa(
    preset: str,
    path_geopackage_mcda_input: pathlib.Path,
    project_area_geometry: shapely.Polygon,
    start_mid_end_points: tuple,
    human_designed_route: shapely.LineString,
    raster_name_prefix: str,
    compute_rasters_in_parallel: bool,
):
    reset_geopackage(Config.PATH_GEOPACKAGE_MCDA_OUTPUT, truncate=False)

    start_cpu_time = time.process_time_ns()

    mcda_engine = McdaCostSurfaceEngine(preset, path_geopackage_mcda_input, project_area_geometry, raster_name_prefix)
    mcda_engine.preprocess_vectors()
    path_suitability_raster = mcda_engine.preprocess_rasters(
        mcda_engine.processed_vectors,
        cell_size=Config.RASTER_CELL_SIZE,
        max_block_size=Config.MAX_BLOCK_SIZE,
        run_in_parallel=compute_rasters_in_parallel,
    )

    lcpa_engine = LcpaUtilityRouteEngine()
    lcpa_engine.get_lcpa_route(
        path_suitability_raster,
        shapely.LineString(start_mid_end_points),
        mcda_engine.raster_preset.general.project_area_geometry,
    )

    logger.info(f"Route CPU time: {(time.process_time_ns() - start_cpu_time) / 1e9:.2f} seconds.")
    route_evaluation_metrics = RouteEvaluationMetrics(
        lcpa_engine.lcpa_result,
        path_suitability_raster,
        human_designed_route,
        project_area_geometry,
        mcda_engine.processed_vector_metrics,
    )
    route_evaluation_metrics.get_route_evaluation_metrics()


if __name__ == "__main__":
    cases = [
        (
            Config.PATH_GEOPACKAGE_CASE_01,
            Config.LAYER_NAME_PROJECT_AREA_CASE_01,
            Config.LAYER_NAME_HUMAN_DESIGNED_ROUTE_CASE_01,
            "route_1_",
            [],
        ),
        (
            Config.PATH_GEOPACKAGE_CASE_02,
            Config.LAYER_NAME_PROJECT_AREA_CASE_02,
            Config.LAYER_NAME_HUMAN_DESIGNED_ROUTE_CASE_02,
            "route_2_",
            [],
        ),
        (
            Config.PATH_GEOPACKAGE_CASE_03,
            Config.LAYER_NAME_PROJECT_AREA_CASE_03,
            Config.LAYER_NAME_HUMAN_DESIGNED_ROUTE_CASE_03,
            "route_3_",
            [],
        ),
        (
            Config.PATH_GEOPACKAGE_CASE_04,
            Config.LAYER_NAME_PROJECT_AREA_CASE_04,
            Config.LAYER_NAME_HUMAN_DESIGNED_ROUTE_CASE_04,
            "route_4_",
            [],
        ),
        (
            Config.PATH_GEOPACKAGE_CASE_05,
            Config.LAYER_NAME_PROJECT_AREA_CASE_05,
            Config.LAYER_NAME_HUMAN_DESIGNED_ROUTE_CASE_05,
            "route_5_",
            [[121462.8, 487153.4]],
        ),
    ]

    reset_geopackage(Config.PATH_GEOPACKAGE_LCPA_OUTPUT, truncate=True)

    cases_to_run = [0, 1, 2, 3, 4]  # 0/1/2/3/4
    for case in cases_to_run:
        geopackage, layer_project_area, human_designed_route_name, raster_name_prefix, stops = cases[case]
        human_designed_route = gpd.read_file(geopackage, layer=human_designed_route_name).iloc[0].geometry
        route_stops = get_first_last_point_from_linestring(human_designed_route)
        if stops:
            route_stops = list(route_stops)[:1] + [shapely.Point(i) for i in stops] + list(route_stops)[1:]  # type: ignore

        run_mcda_lcpa(
            "preset_benchmark_raw",
            geopackage,
            gpd.read_file(geopackage, layer=layer_project_area).iloc[0].geometry,
            route_stops,
            human_designed_route,
            raster_name_prefix,
            compute_rasters_in_parallel=True,
        )