app.py

# Hugging Face Hack

import subprocess
import os

dotnet_check_command = "dotnet --list-sdks"
dotnet_install_commands = [
    "wget https://dot.net/v1/dotnet-install.sh -O dotnet-install.sh",
    "chmod +x ./dotnet-install.sh",
    "./dotnet-install.sh --version latest"
]

try:
    print(subprocess.check_output(dotnet_check_command, shell=True))
except:
    print(os.environ["PATH"])

    print("Try to install .net dependency")

    for command in dotnet_install_commands:
        os.system(command)

    os.environ["PATH"] += os.pathsep + "/home/user/.dotnet"
    
    print(os.environ["PATH"])

    os.system(dotnet_check_command)
    # print(subprocess.check_output("dotnet -list-sdk"))

import gradio as gr

# Setup Python.Net

from pythonnet import load

load("coreclr", runtime_config="lib/JTSParser.runtimeconfig.json")

import clr
from System import Reflection

import os

lib_path = os.path.abspath("lib/JTSParser.dll")

Reflection.Assembly.LoadFile(lib_path)
from YYZ import JTS

# App

import numpy as np
import plotly.graph_objects as go
import plotly
print(f"plotly_version={plotly.__version__}")
import math

def dock(x, limit):
    x1 = math.floor(x)
    yield x1
    x2 = min(math.ceil(x), limit)
    if x2 != x1:
        yield x2

default_path = "JTS_assets/ridge.map"

road_names_map = {
    "NB": ["Path", "Road", "Pike", "Rail"],
    "CWB": ["Trail", "Road", "Pike", "Rail"],
    "PZC": ["Trail", "Secondary", "Primary", "Rail"]
}

with gr.Blocks(analytics_enabled=False) as demo:
    with gr.Row():
        with gr.Column(scale=1):
            plot_button = gr.Button("Plot")
            with gr.Row():
                file_input = gr.File(default_path, label="Map File (NB/CWB/PZC)", file_types=[".map"])
                sub_file_input = gr.File(label="Sub Map File (optional)", file_types=[".map"])
            code_dropdown = gr.Dropdown(choices=["NB", "CWB", "PZC"], value="NB", label="Series")
            labels_checkbox = gr.Checkbox(True, label="Labels")
            labels_size_threshold_number = gr.Number(0, label="Label Size Threshold", info="1 => Tactical, 2 => Normal, 3 => Important")
            # with gr.Row():
            with gr.Accordion("Roads"):
                with gr.Row():
                    path_checkbox = gr.Checkbox(label="Path/Trail")
                    road_checkbox = gr.Checkbox(label="Road/Secondary")
                    pike_checkbox = gr.Checkbox(True, label="Pike/Primary")
                    railway_checkbox = gr.Checkbox(True, label="Rail")
            with gr.Row():
                road_offset_number = gr.Number(0.3, label="Road Offset")
                elevation_scale_number = gr.Number(0.1, label="Elevation Scale")
        with gr.Column(scale=2):
            output_plot = gr.Plot()
    
    def plot(data):
        with open(data[file_input].name) as f:
            map_str = f.read()

        code = data[code_dropdown]
        map_file = JTS.JTSParser.FromCode(code).ParseMap(map_str, False)

        if data[sub_file_input]:
            with open(data[sub_file_input].name) as f:
                sub_map_str = f.read()
            sub_map_file = JTS.SubMapFile()
            sub_map_file.Extract(sub_map_str)
            sub_map_file.ApplyTo(map_file)

        network = JTS.HexNetwork.FromMapFile(map_file)
        
        height_mat = np.empty([map_file.Height, map_file.Width])
        for i in range(map_file.Height):
            for j in range(map_file.Width):
                height_mat[i,j] = network.HexMat[i, j].Height

        surface = go.Surface(
            x = np.arange(map_file.Width),
            y = np.arange(map_file.Height),
            z = height_mat
        )

        gl = []

        road_offset = data[road_offset_number]

        road_items = [
            (path_checkbox, 'gray'),
            (road_checkbox, 'green'),
            (pike_checkbox, 'pink'),
            (railway_checkbox, 'black')
        ]

        for road_idx, (checkbox, color) in enumerate(road_items):
            road_name = road_names_map[code][road_idx]
            road_type = map_file.CurrentTerrainSystem.Road.GetValue(road_name)

            if data[checkbox]:
                for road in network.SimplifyRoad(road_type):
                    x_line = []
                    y_line = []
                    z_line = []

                    for node in road:
                        x_line.append(node.X)
                        y_line.append(node.Y)
                        z_line.append(node.Height + road_offset)
                        
                    g = go.Scatter3d(
                        x=x_line, y=y_line, z=z_line,
                        line=dict(
                            color=color,
                            width=2
                        )
                    )
                    
                    gl.append(g)

        fig = go.Figure([surface] + gl)


        scene = {
            "aspectratio": {"x": 1, "y": 1, "z": data[elevation_scale_number]},
            'yaxis': {'autorange': 'reversed'},
        }

        if data[labels_checkbox]:

            labels_x = []
            labels_y = []
            labels_z = []
            labels_text = []

            for label in map_file.Labels:
                if label.Size >= data[labels_size_threshold_number]:
                    max_height = -1
                    x = label.X
                    y = label.Y
                    for dx in dock(x, map_file.Width-1):
                        for dy in dock(y, map_file.Height-1):
                            max_height = max(max_height, map_file.HeightMap[dy, dx])
                    labels_x.append(x)
                    labels_y.append(y)
                    labels_z.append(max_height)
                    labels_text.append(label.Name)

            scene["annotations"] = [
                dict(
                    showarrow=False,
                    x=x,
                    y=y,
                    z=z,
                    text=text,
                    xanchor="left",
                    xshift=10,
                    opacity=0.7,
                    bgcolor="white"
                )
                for x, y, z, text in zip(labels_x, labels_y, labels_z, labels_text)
            ]

        fig.update_layout(scene=scene, showlegend=False)

        return {output_plot: fig}

    plot_button.click(plot, {file_input, sub_file_input, code_dropdown,
                             labels_checkbox, labels_size_threshold_number, 
                             path_checkbox, road_checkbox, pike_checkbox, railway_checkbox,
                             elevation_scale_number, road_offset_number}, {output_plot})
    # plot_button.click(lambda data: {output_img: test()}, {file_input, path_checkbox, road_checkbox, pike_checkbox, plot_button}, {output_img})

if __name__ == "__main__":
    demo.launch()