diff --git a/dashboard.py b/dashboard.py index 9f354ea..aa94ed2 100644 --- a/dashboard.py +++ b/dashboard.py @@ -3,13 +3,16 @@ import dash import plotly.graph_objects as go import numpy as np -from GHA_triaxial.panou import gha1_ana -from GHA_triaxial.panou import gha1_num -from GHA_triaxial.panou_2013_2GHA_num import gha2_num from ellipsoide import EllipsoidTriaxial import winkelumrechnungen as wu import ausgaben as aus +from GHA_triaxial.panou import gha1_ana +from GHA_triaxial.panou import gha1_num +from es_cma_gha1 import gha1_es + +from GHA_triaxial.panou_2013_2GHA_num import gha2_num + app = Dash(__name__, suppress_callback_exceptions=True) app.title = "Geodätische Hauptaufgaben" @@ -150,13 +153,15 @@ def figure_lines(fig, line, color): return fig - +# HTML-Elemente app.layout = html.Div( style={"fontFamily": "Arial", "padding": "5px", "width": "70%", "margin-left": "auto"}, children=[ html.H1("Geodätische Hauptaufgaben"), html.H2("für dreiachsige Ellipsoide"), + + # Dropdown und Eingabefelder Ellipsoid html.Label("Ellipsoid wählen:"), dcc.Dropdown( id="dropdown-ellipsoid", @@ -205,8 +210,10 @@ app.layout = html.Div( style={"marginRight": "10px", "marginBottom": "20px"}, ), + # Ausgabebereich für Ellipsoid-Berechnung html.Div(id="output-area", style={"marginBottom": "20px"}), + # Tabs für beide Hauptaufgaben - Inhalt wird per Funktion generiert s.u. dcc.Tabs( id="tabs-GHA", value="tab-GHA1", @@ -222,15 +229,28 @@ app.layout = html.Div( style={"marginRight": "10px", "marginBottom": "20px", "width": "50%"}, ), - html.Div(id="output-gha1", style={"marginBottom": "20px"}), + dcc.Loading(html.Div(id="output-gha1-ana")), + dcc.Loading(html.Div(id="output-gha1-num")), + dcc.Loading(html.Div(id="output-gha1-stoch")), - html.Div(id="output-gha2", style={"marginBottom": "20px"}), + dcc.Store(id="store-gha1-ana"), + dcc.Store(id="store-gha1-num"), + dcc.Store(id="store-gha1-stoch"), + dcc.Loading(html.Div(id="output-gha2-num")), + dcc.Loading(html.Div(id="output-gha2-stoch")), + + dcc.Store(id="store-gha2-num"), + dcc.Store(id="store-gha2-stoch"), + + + # Ausgabebereich für den Plot dcc.Graph( id="ellipsoid-plot", style={"height": "500px", "width": "700px"}, ), + # Fussleiste html.P( "© 2025", style={ @@ -242,7 +262,7 @@ app.layout = html.Div( ], ) - +# Funktion zur Wahl der Halbachsen @app.callback( Output("input-ax", "value"), Output("input-ay", "value"), @@ -260,7 +280,7 @@ def fill_inputs_from_dropdown(selected_ell): b = ell.b return ax, ay, b - +# Funktion zur Berechnung der Ellipsoid-Parameter @app.callback( Output("output-area", "children"), Input("calc-ell", "n_clicks"), @@ -276,8 +296,16 @@ def update_output(n_clicks, ax, ay, b): if ay >= ax or b >= ay or ax <= 0 or ay <= 0 or b <= 0: return html.Span("Eingabe inkorrekt.", style={"color": "red"}) ell = EllipsoidTriaxial(ax, ay, b) - return f"eₓ = {round(ell.ex, 6)}, ", f"eᵧ = {round(ell.ey, 6)}, ", f"eₑ = {round(ell.ee, 6)}" + out_ell = [] + out_ell.append( + html.Div([ + html.P(f"eₓ = {round(ell.ex, 6)}, eᵧ = {round(ell.ey, 6)}, eₑ = {round(ell.ee, 6)}"), + #html.Br(), + html.P(f"Eₓ = {round(ell.Ex, 3)}, Eᵧ = {round(ell.Ey, 3)}, Eₑ = {round(ell.Ee, 3)}"), + ])) + return out_ell +# Funktion zur Generierung der Tab-Inhalte @app.callback( Output("tabs-GHA-out", "children"), Input("tabs-GHA", "value"), @@ -318,6 +346,7 @@ def render_content(tab): ], style={"marginBottom": "20px"}, ), + html.H4("Erste Hauptaufgabe"), ], id="pane-gha1", style=show1, @@ -354,6 +383,7 @@ def render_content(tab): ], style={"marginBottom": "20px"}, ), + html.H4("Zweite Hauptaufgabe"), ], id="pane-gha2", style=show2, @@ -361,17 +391,341 @@ def render_content(tab): return html.Div([pane_gha1, pane_gha2]) +# Funktion zur Berechnung der Hauptaufgaben +# @app.callback( +# Output("output-gha1", "children"), +# Output("output-gha2", "children"), +# Output("ellipsoid-plot", "figure"), +# Input("button-calc-gha1", "n_clicks"), +# Input("button-calc-gha2", "n_clicks"), +# State("input-GHA1-beta1", "value"), +# State("input-GHA1-lamb1", "value"), +# State("input-GHA1-s", "value"), +# State("input-GHA1-a", "value"), +# State("input-GHA2-beta1", "value"), +# State("input-GHA2-lamb1", "value"), +# State("input-GHA2-beta2", "value"), +# State("input-GHA2-lamb2", "value"), +# State("input-ax", "value"), +# State("input-ay", "value"), +# State("input-b", "value"), +# State("method-checklist-1", "value"), +# State("method-checklist-2", "value"), +# +# prevent_initial_call=True, +# ) +# +# def calc_and_plot(n1, n2, +# beta11, lamb11, s, a_deg, +# beta21, lamb21, beta22, lamb22, +# ax, ay, b, method1, method2): +# +# if not (n1 or n2): +# return no_update, no_update, no_update +# +# if not ax or not ay or not b: +# return html.Span("Bitte Ellipsoid auswählen!", style={"color": "red"}), "", go.Figure() +# +# ell = EllipsoidTriaxial(ax, ay, b) +# +# if dash.ctx.triggered_id == "button-calc-gha1": +# if None in (beta11, lamb11, s, a_deg): +# +# return html.Span("Bitte β₁, λ₁, s und α eingeben.", style={"color": "red"}), "", go.Figure() +# +# beta_rad = wu.deg2rad(float(beta11)) +# lamb_rad = wu.deg2rad(float(lamb11)) +# alpha_rad = wu.deg2rad(float(a_deg)) +# s_val = float(s) +# +# p1 = tuple(map(float, ell.ell2cart(beta_rad, lamb_rad))) +# out1 = [] +# +# if "analytisch" in method1: +# # ana +# x2, y2, z2 = gha1_ana(ell, p1, alpha_rad, s_val, 70) +# p2_ana = (float(x2), float(y2), float(z2)) +# beta2, lamb2 = ell.cart2ell([x2, y2, z2]) +# +# #out1 += f"kartesisch: x₂={p2[0]:.5f} m, y₂={p2[1]:.5f} m, z₂={p2[2]:.5f} m; ellipsoidisch: {aus.gms("β₂", beta2, 5)}, {aus.gms("λ₂", lamb2, 5)}," +# out1.append( +# html.Div([ +# html.Strong("Analytisch: "), +# html.Br(), +# html.Span(f"kartesisch: x₂={x2:.4f} m, y₂={y2:.4f} m, z₂={z2:.4f} m"), +# html.Br(), +# html.Span(f"ellipsoidisch: {aus.gms('β₂', beta2, 4)}, {aus.gms('λ₂', lamb2, 4)}") +# ]) +# ) +# +# if "numerisch" in method1: +# # num +# x1, y1, z1, werte = gha1_num(ell, p1, alpha_rad, s_val, 10000) +# p2_num = x1, y1, z1 +# beta2_num, lamb2_num = ell.cart2ell(p2_num) +# +# out1.append( +# html.Div([ +# html.Strong("Numerisch: "), +# html.Br(), +# html.Span(f"kartesisch: x₂={p2_num[0]:.4f} m, y₂={p2_num[1]:.4f} m, z₂={p2_num[2]:.4f} m"), +# html.Br(), +# html.Span(f"ellipsoidisch: {aus.gms('β₂', beta2_num, 4)}, {aus.gms('λ₂', lamb2_num, 4)}") +# ]) +# ) +# +# geo_line_num1 = [] +# for x1, _, y1, _, z1, _ in werte: +# geo_line_num1.append([x1, y1, z1]) +# +# +# if "stochastisch" in method1: +# # stoch +# p2_stoch = "noch nicht implementiert.." +# +# out1.append( +# html.Div([ +# html.Strong("Stochastisch (ES): "), +# html.Span(f"{p2_stoch}") +# ]) +# ) +# +# if not method1: +# return html.Span("Bitte Berechnungsverfahren auswählen!", style={"color": "red"}), "", go.Figure() +# +# fig = ellipsoid_figure(ell, title="Erste Hauptaufgabe - analytisch") +# #fig = figure_constant_lines(fig, ell, "geod") +# fig = figure_constant_lines(fig, ell, "ell") +# #fig = figure_constant_lines(fig, ell, "para") +# if "analytisch" in method1: +# fig = figure_points(fig, [("P1", p1, "black"), ("P2", p2_ana, "red")]) +# if "numerisch" in method1: +# fig = figure_lines(fig, geo_line_num1, "#ff8c00") +# +# #out1 = f"kartesisch: x₂={p2[0]:.5f} m, y₂={p2[1]:.5f} m, z₂={p2[2]:.5f} m; ellipsoidisch: {aus.gms("β₂", beta2, 5)}, {aus.gms("λ₂", lamb2, 5)}, {p2_num}" +# return out1, "", fig +# +# if dash.ctx.triggered_id == "button-calc-gha2": +# if None in (beta21, lamb21, beta22, lamb22): +# return html.Span("Bitte β₁, λ₁, β₂, λ₂ eingeben.", style={"color": "red"}), "", go.Figure() +# +# p1 = tuple(ell.ell2cart(np.deg2rad(float(beta21)), np.deg2rad(float(lamb21)))) +# p2 = tuple(ell.ell2cart(np.deg2rad(float(beta22)), np.deg2rad(float(lamb22)))) +# +# out2 = [] +# +# if "numerisch" in method2: +# alpha_1, alpha_2, s12, beta_arr, lamb_arr = gha2_num( +# ell, +# np.deg2rad(float(beta21)), np.deg2rad(float(lamb21)), +# np.deg2rad(float(beta22)), np.deg2rad(float(lamb22)) +# ) +# geo_line_num = [] +# for beta, lamb in zip(beta_arr, lamb_arr): +# point = ell.ell2cart(beta, lamb) +# geo_line_num.append(point) +# +# out2.append( +# html.Div([ +# html.Strong("Numerisch: "), +# html.Span(f"{aus.gms('α₁₂', alpha_1, 4)}, {aus.gms('α₂₁', alpha_2, 4)}, s = {s12:.4f} m"), +# ]) +# ) +# +# +# if "stochastisch" in method2: +# # stoch +# a_stoch = "noch nicht implementiert.." +# +# out2.append( +# html.Div([ +# html.Strong("Stochastisch (ES): "), +# html.Span(f"{a_stoch}") +# ]) +# ) +# +# if not method2: +# return html.Span("Bitte Berechnungsverfahren auswählen!", style={"color": "red"}), "", go.Figure() +# +# fig = ellipsoid_figure(ell, title="Zweite Hauptaufgabe") +# fig = figure_constant_lines(fig, ell, "ell") +# if "numerisch" in method2: +# fig = figure_lines(fig, geo_line_num, "#ff8c00") +# fig = figure_points(fig, [("P1", p1, "black"), ("P2", p2, "red")]) +# +# +# +# return "", out2, fig +# +# return no_update, no_update, no_update +# -- GHA 1 --- @app.callback( - Output("output-gha1", "children"), - Output("output-gha2", "children"), - Output("ellipsoid-plot", "figure"), + Output("output-gha1-ana", "children"), + Output("store-gha1-ana", "data"), Input("button-calc-gha1", "n_clicks"), - Input("button-calc-gha2", "n_clicks"), State("input-GHA1-beta1", "value"), State("input-GHA1-lamb1", "value"), State("input-GHA1-s", "value"), State("input-GHA1-a", "value"), + State("input-ax", "value"), + State("input-ay", "value"), + State("input-b", "value"), + State("method-checklist-1", "value"), + prevent_initial_call=True, +) +def compute_gha1_ana(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1): + if not n1: + return no_update, no_update + if None in (ax, ay, b): + return html.Span("Bitte Ellipsoid wählen.", style={"color": "red"}), None + if None in (beta11, lamb11, s, a_deg): + return html.Span("Bitte β₁, λ₁, s und α eingeben.", style={"color": "red"}), None + if not method1: + return html.Span("Bitte Berechnungsverfahren wählen.", style={"color": "red"}), None + if "analytisch" not in (method1 or []): + return no_update, no_update + + + ell = EllipsoidTriaxial(ax, ay, b) + beta_rad = wu.deg2rad(float(beta11)) + lamb_rad = wu.deg2rad(float(lamb11)) + alpha_rad = wu.deg2rad(float(a_deg)) + s_val = float(s) + + p1 = tuple(map(float, ell.ell2cart(beta_rad, lamb_rad))) + x2, y2, z2 = gha1_ana(ell, p1, alpha_rad, s_val, 70) + p2 = (float(x2), float(y2), float(z2)) + beta2, lamb2 = ell.cart2ell([x2, y2, z2]) + + out = html.Div([ + html.Strong("Analytisch: "), + html.Br(), + html.Span(f"kartesisch: x₂={x2:.4f} m, y₂={y2:.4f} m, z₂={z2:.4f} m"), + html.Br(), + html.Span(f"ellipsoidisch: {aus.gms('β₂', beta2, 4)}, {aus.gms('λ₂', lamb2, 4)}"), + html.Br(), + ]) + + store = { + "points": [("P1", p1, "black"), ("P2", p2, "red")], + "polyline": None, + "color": "#d62728" + } + return out, store + +@app.callback( + Output("output-gha1-num", "children"), + Output("store-gha1-num", "data"), + Input("button-calc-gha1", "n_clicks"), + State("input-GHA1-beta1", "value"), + State("input-GHA1-lamb1", "value"), + State("input-GHA1-s", "value"), + State("input-GHA1-a", "value"), + State("input-ax", "value"), + State("input-ay", "value"), + State("input-b", "value"), + State("method-checklist-1", "value"), + prevent_initial_call=True, +) +def compute_gha1_num(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1): + if not n1: + return no_update, no_update + if "numerisch" not in (method1 or []): + return no_update, no_update + + ell = EllipsoidTriaxial(ax, ay, b) + beta_rad = wu.deg2rad(float(beta11)) + lamb_rad = wu.deg2rad(float(lamb11)) + alpha_rad = wu.deg2rad(float(a_deg)) + s_val = float(s) + + p1 = tuple(map(float, ell.ell2cart(beta_rad, lamb_rad))) + + xN, yN, zN, werte = gha1_num(ell, p1, alpha_rad, s_val, 10000) + p2 = (xN, yN, zN) + beta2_num, lamb2_num = ell.cart2ell(p2) + + out = html.Div([ + html.Strong("Numerisch: "), + html.Br(), + html.Span(f"kartesisch: x₂={p2[0]:.4f} m, y₂={p2[1]:.4f} m, z₂={p2[2]:.4f} m"), + html.Br(), + html.Span(f"ellipsoidisch: {aus.gms('β₂', beta2_num, 4)}, {aus.gms('λ₂', lamb2_num, 4)}"), + html.Br(), + ]) + + polyline = [[x1, y1, z1] for x1, _, y1, _, z1, _ in werte] + + store = { + "points": [("P1", p1, "black"), ("P2", p2, "#ff8c00")], + "polyline": polyline, + "color": "#ff8c00" + } + return out, store + +@app.callback( + Output("output-gha1-stoch", "children"), + Output("store-gha1-stoch", "data"), + Input("button-calc-gha1", "n_clicks"), + State("input-GHA1-beta1", "value"), + State("input-GHA1-lamb1", "value"), + State("input-GHA1-s", "value"), + State("input-GHA1-a", "value"), + State("input-ax", "value"), + State("input-ay", "value"), + State("input-b", "value"), + State("method-checklist-1", "value"), + prevent_initial_call=True, +) +def compute_gha1_stoch(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1): + if not n1: + return no_update, no_update + if "stochastisch" not in (method1 or []): + return no_update, no_update + + ell = EllipsoidTriaxial(ax, ay, b) + beta_rad = wu.deg2rad(float(beta11)) + lamb_rad = wu.deg2rad(float(lamb11)) + alpha_rad = wu.deg2rad(float(a_deg)) + s_val = float(s) + + betas, lambs, alphas, S_real = gha1_es( + beta_rad, lamb_rad, alpha_rad, + s_val, + 10000, + ell, + sigma0=1e-10 + ) + beta2 = betas[-1] + lamb2 = lambs[-1] + alpha2 = alphas[-1] + + p1 = ell.ell2cart(beta_rad, lamb_rad) + p2 = ell.ell2cart(beta2, lamb2) + x2, y2, z2 = p2[0], p2[1], p2[2] + + out = html.Div([ + html.Strong("Stochastisch: "), + html.Br(), + html.Span(f"kartesisch: x₂={x2:.4f} m, y₂={y2:.4f} m, z₂={z2:.4f} m"), + html.Br(), + html.Span(f"ellipsoidisch: {aus.gms('β₂', beta2, 4)}, {aus.gms('λ₂', lamb2, 4)}"), + ]) + + store = { + "points": [("P1", p1, "black"), ("P2", p2, "red")], + "polyline": None, + "color": "#d62728" + } + return out, store + + +# --- GHA 2 --- +@app.callback( + Output("output-gha2-num", "children"), + Output("store-gha2-num", "data"), + Input("button-calc-gha2", "n_clicks"), State("input-GHA2-beta1", "value"), State("input-GHA2-lamb1", "value"), State("input-GHA2-beta2", "value"), @@ -379,156 +733,112 @@ def render_content(tab): State("input-ax", "value"), State("input-ay", "value"), State("input-b", "value"), - State("method-checklist-1", "value"), State("method-checklist-2", "value"), - prevent_initial_call=True, ) -def calc_and_plot(n1, n2, - beta11, lamb11, s, a_deg, - beta21, lamb21, beta22, lamb22, - ax, ay, b, method1, method2): - - if not (n1 or n2): - return no_update, no_update, no_update - - if not ax or not ay or not b: - return html.Span("Bitte Ellipsoid auswählen!", style={"color": "red"}), "", go.Figure() +def compute_gha2_num(n2, beta1, lamb1, beta2, lamb2, ax, ay, b, method2): + if not n2: + return no_update, no_update + if None in (ax, ay, b): + return html.Span("Bitte Ellipsoid wählen.", style={"color": "red"}), None + if None in (beta1, lamb1, beta2, lamb2): + return html.Span("Bitte β₁, λ₁, β₂ und λ₂ eingeben.", style={"color": "red"}), None + if not method2: + return html.Span("Bitte Berechnungsverfahren wählen.", style={"color": "red"}), None + if "numerisch" not in (method2 or []): + return no_update, no_update ell = EllipsoidTriaxial(ax, ay, b) - if dash.ctx.triggered_id == "button-calc-gha1": - if None in (beta11, lamb11, s, a_deg): + b1 = wu.deg2rad(float(beta1)); l1 = wu.deg2rad(float(lamb1)) + b2 = wu.deg2rad(float(beta2)); l2 = wu.deg2rad(float(lamb2)) - return html.Span("Bitte β₁, λ₁, s und α eingeben.", style={"color": "red"}), "", go.Figure() + p1 = tuple(map(float, ell.ell2cart(b1, l1))) + p2 = tuple(map(float, ell.ell2cart(b2, l2))) - beta_rad = wu.deg2rad(float(beta11)) - lamb_rad = wu.deg2rad(float(lamb11)) - alpha_rad = wu.deg2rad(float(a_deg)) - s_val = float(s) + alpha_1, alpha_2, s12, beta_arr, lamb_arr = gha2_num(ell, b1, l1, b2, l2) - p1 = tuple(map(float, ell.ell2cart(beta_rad, lamb_rad))) - out1 = [] + # Polyline der Geodäte: [[x,y,z], ...] + polyline = [] + for b_rad, l_rad in zip(beta_arr, lamb_arr): + x, y, z = ell.ell2cart(b_rad, l_rad) + polyline.append([float(x), float(y), float(z)]) - if "analytisch" in method1: - # ana - x2, y2, z2 = gha1_ana(ell, p1, alpha_rad, s_val, 70) - p2_ana = (float(x2), float(y2), float(z2)) - beta2, lamb2 = ell.cart2ell([x2, y2, z2]) + out = html.Div([ + html.Strong("Zweite Hauptaufgabe – Numerisch: "), + html.Span(f"{aus.gms('α₁₂', alpha_1, 4)}, {aus.gms('α₂₁', alpha_2, 4)}, s = {s12:.4f} m"), + ]) - #out1 += f"kartesisch: x₂={p2[0]:.5f} m, y₂={p2[1]:.5f} m, z₂={p2[2]:.5f} m; ellipsoidisch: {aus.gms("β₂", beta2, 5)}, {aus.gms("λ₂", lamb2, 5)}," - out1.append( - html.Div([ - html.Strong("Analytisch: "), - html.Br(), - html.Span(f"kartesisch: x₂={x2:.4f} m, y₂={y2:.4f} m, z₂={z2:.4f} m"), - html.Br(), - html.Span(f"ellipsoidisch: {aus.gms('β₂', beta2, 4)}, {aus.gms('λ₂', lamb2, 4)}") - ]) - ) + store = { + "points": [("P1", p1, "black"), ("P2", p2, "#1f77b4")], + "polyline": polyline, + "color": "#1f77b4", + } + return out, store - if "numerisch" in method1: - # num - x1, y1, z1, werte = gha1_num(ell, p1, alpha_rad, s_val, 10000) - p2_num = x1, y1, z1 - beta2_num, lamb2_num = ell.cart2ell(p2_num) +# @app.callback( +# Output("output-gha2-stoch", "children"), +# Output("store-gha2-stoch", "data"), +# Input("button-calc-gha2", "n_clicks"), +# State("input-GHA2-beta1", "value"), +# State("input-GHA2-lamb1", "value"), +# State("input-GHA2-beta2", "value"), +# State("input-GHA2-lamb2", "value"), +# State("input-ax", "value"), +# State("input-ay", "value"), +# State("input-b", "value"), +# State("method-checklist-2", "value"), +# prevent_initial_call=True, +# ) +# def compute_gha2_stoch(n2, beta1, lamb1, beta2, lamb2, ax, ay, b, method2): +# if not n2: +# return no_update, no_update +# if "numerisch" not in (method2 or []): +# return no_update, no_update +# +# out = html.Div([ +# html.Strong("Zweite Hauptaufgabe – Stochastisch (ES): "), +# html.Span("noch nicht implementiert...") +# ]) +# +# return out, {"points": None, "polyline": None, "color": "#9467bd"} - out1.append( - html.Div([ - html.Strong("Numerisch: "), - html.Br(), - html.Span(f"kartesisch: x₂={p2_num[0]:.4f} m, y₂={p2_num[1]:.4f} m, z₂={p2_num[2]:.4f} m"), - html.Br(), - html.Span(f"ellipsoidisch: {aus.gms('β₂', beta2_num, 4)}, {aus.gms('λ₂', lamb2_num, 4)}") - ]) - ) +@app.callback( + Output("ellipsoid-plot", "figure"), + Input("input-ax", "value"), + Input("input-ay", "value"), + Input("input-b", "value"), + Input("store-gha1-ana", "data"), + Input("store-gha1-num", "data"), + Input("store-gha2-num", "data"), + Input("store-gha2-stoch", "data"), +) +def render_all(ax, ay, b, store_gha1_ana, store_gha1_num, store_gha2_num, store_gha2_stoch): + if None in (ax, ay, b): + return go.Figure() - geo_line_num1 = [] - for x1, _, y1, _, z1, _ in werte: - geo_line_num1.append([x1, y1, z1]) + ell = EllipsoidTriaxial(ax, ay, b) + fig = ellipsoid_figure(ell, title="") + fig = figure_constant_lines(fig, ell, "ell") + def add_from_store(store): + if not store: + return + pts = store.get("points") + if pts: + fig = figure_points(fig, pts) + line = store.get("polyline") + if line: + fig = figure_lines(fig, line, store.get("color", "#ff8c00")) + return fig - if "stochastisch" in method1: - # stoch - p2_stoch = "noch nicht implementiert.." + for st in (store_gha1_ana, store_gha1_num, store_gha2_num, store_gha2_stoch): + res = add_from_store(st) + if res is not None: + fig = res - out1.append( - html.Div([ - html.Strong("Stochastisch (ES): "), - html.Span(f"{p2_stoch}") - ]) - ) + return fig - if not method1: - return html.Span("Bitte Berechnungsverfahren auswählen!", style={"color": "red"}), "", go.Figure() - - fig = ellipsoid_figure(ell, title="Erste Hauptaufgabe - analystisch") - #fig = figure_constant_lines(fig, ell, "geod") - fig = figure_constant_lines(fig, ell, "ell") - #fig = figure_constant_lines(fig, ell, "para") - if "analytisch" in method1: - fig = figure_points(fig, [("P1", p1, "black"), ("P2", p2_ana, "red")]) - if "numerisch" in method1: - fig = figure_lines(fig, geo_line_num1, "#ff8c00") - - #out1 = f"kartesisch: x₂={p2[0]:.5f} m, y₂={p2[1]:.5f} m, z₂={p2[2]:.5f} m; ellipsoidisch: {aus.gms("β₂", beta2, 5)}, {aus.gms("λ₂", lamb2, 5)}, {p2_num}" - return out1, "", fig - - if dash.ctx.triggered_id == "button-calc-gha2": - if None in (beta21, lamb21, beta22, lamb22): - return html.Span("Bitte β₁, λ₁, β₂, λ₂ eingeben.", style={"color": "red"}), "", go.Figure() - - p1 = tuple(ell.ell2cart(np.deg2rad(float(beta21)), np.deg2rad(float(lamb21)))) - p2 = tuple(ell.ell2cart(np.deg2rad(float(beta22)), np.deg2rad(float(lamb22)))) - - out2 = [] - - if "numerisch" in method2: - alpha_1, alpha_2, s12, beta_arr, lamb_arr = gha2_num( - ell, - np.deg2rad(float(beta21)), np.deg2rad(float(lamb21)), - np.deg2rad(float(beta22)), np.deg2rad(float(lamb22)) - ) - geo_line_num = [] - for beta, lamb in zip(beta_arr, lamb_arr): - point = ell.ell2cart(beta, lamb) - geo_line_num.append(point) - - - - out2.append( - html.Div([ - html.Strong("Numerisch: "), - html.Span(f"{aus.gms('α₁₂', alpha_1, 4)}, {aus.gms('α₂₁', alpha_2, 4)}, s = {s12:.4f} m"), - ]) - ) - - - if "stochastisch" in method2: - # stoch - a_stoch = "noch nicht implementiert.." - - out2.append( - html.Div([ - html.Strong("Stochastisch (ES): "), - html.Span(f"{a_stoch}") - ]) - ) - - if not method2: - return html.Span("Bitte Berechnungsverfahren auswählen!", style={"color": "red"}), "", go.Figure() - - fig = ellipsoid_figure(ell, title="Zweite Hauptaufgabe") - fig = figure_constant_lines(fig, ell, "ell") - if "numerisch" in method2: - fig = figure_lines(fig, geo_line_num, "#ff8c00") - fig = figure_points(fig, [("P1", p1, "black"), ("P2", p2, "red")]) - - - - return "", out2, fig - - return no_update, no_update, no_update if __name__ == "__main__":