he2851/Masterprojekt
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Kleinere Anpassungen

Browse Source
This commit is contained in:
Tammo.Weber
2026-01-13 20:46:15 +01:00
parent 048b6979d8
commit 505aee6de7
1 changed files with 192 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

281
dashboard.py
View File

@@ -1,5 +1,4 @@
from dash import Dash, html, dcc, Input, Output, State, no_update from dash import Dash, html, dcc, Input, Output, State, no_update
import dash
import plotly.graph_objects as go import plotly.graph_objects as go
import numpy as np import numpy as np
@@ -14,13 +13,13 @@ from GHA_triaxial.approx_gha1 import gha1_approx
from GHA_triaxial.panou_2013_2GHA_num import gha2_num from GHA_triaxial.panou_2013_2GHA_num import gha2_num
from GHA_triaxial.ES_gha2 import gha2_ES from GHA_triaxial.ES_gha2 import gha2_ES
from GHA_triaxial.approx_gha2 import gha2_approx from GHA_triaxial.approx_gha2 import gha2
app = Dash(__name__, suppress_callback_exceptions=True) app = Dash(__name__, suppress_callback_exceptions=True)
app.title = "Geodätische Hauptaufgaben" app.title = "Geodätische Hauptaufgaben"
def inputfeld(left_text, input_id, right_text="", width=200, min=None, max=None): def inputfeld(left_text, input_id, right_text="", width=200, min=None, max=None):
return html.Div( return html.Div(
[ [
@@ -221,14 +220,18 @@ app.layout = html.Div(
dcc.Loading(html.Div(id="output-gha1-ana")), dcc.Loading(html.Div(id="output-gha1-ana")),
dcc.Loading(html.Div(id="output-gha1-num")), dcc.Loading(html.Div(id="output-gha1-num")),
dcc.Loading(html.Div(id="output-gha1-stoch")), dcc.Loading(html.Div(id="output-gha1-stoch")),
dcc.Loading(html.Div(id="output-gha1-approx")),
dcc.Loading(html.Div(id="output-gha2-num")), dcc.Loading(html.Div(id="output-gha2-num")),
dcc.Loading(html.Div(id="output-gha2-stoch")), dcc.Loading(html.Div(id="output-gha2-stoch")),
dcc.Loading(html.Div(id="output-gha2-approx")),
dcc.Store(id="store-gha1-ana"), dcc.Store(id="store-gha1-ana"),
dcc.Store(id="store-gha1-num"), dcc.Store(id="store-gha1-num"),
dcc.Store(id="store-gha1-stoch"), dcc.Store(id="store-gha1-stoch"),
dcc.Store(id="store-gha1-approx"),
dcc.Store(id="store-gha2-num"), dcc.Store(id="store-gha2-num"),
dcc.Store(id="store-gha2-stoch"), dcc.Store(id="store-gha2-stoch"),
dcc.Store(id="store-gha2-approx"),
], ],
), ),
@@ -251,7 +254,7 @@ app.layout = html.Div(
], ],
), ),
html.P("© 2026", style={"fontSize": "10px", "color": "gray", "textAlign": "center", "marginTop": "16px"}), #html.P("© 2026", style={"fontSize": "10px", "color": "gray", "textAlign": "center", "marginTop": "16px"}),
], ],
) )
@@ -284,8 +287,8 @@ def render_content(tab):
pane_gha1 = html.Div( pane_gha1 = html.Div(
[ [
inputfeld("β₀", "input-GHA1-beta1", "°", min=-90, max=90), inputfeld("β₀", "input-GHA1-beta0", "°", min=-90, max=90),
inputfeld("λ₀", "input-GHA1-lamb1", "°", min=-180, max=180), inputfeld("λ₀", "input-GHA1-lamb0", "°", min=-180, max=180),
inputfeld("s", "input-GHA1-s", "m", min=0), inputfeld("s", "input-GHA1-s", "m", min=0),
inputfeld("α₀", "input-GHA1-a", "°", min=0, max=360), inputfeld("α₀", "input-GHA1-a", "°", min=0, max=360),
@@ -318,10 +321,10 @@ def render_content(tab):
pane_gha2 = html.Div( pane_gha2 = html.Div(
[ [
inputfeld("β₀", "input-GHA2-beta1", "°", min=-90, max=90), inputfeld("β₀", "input-GHA2-beta0", "°", min=-90, max=90),
inputfeld("λ₀", "input-GHA2-lamb1", "°", min=-180, max=180), inputfeld("λ₀", "input-GHA2-lamb0", "°", min=-180, max=180),
inputfeld("β₁", "input-GHA2-beta2", "°", min=-90, max=90), inputfeld("β₁", "input-GHA2-beta1", "°", min=-90, max=90),
inputfeld("λ₁", "input-GHA2-lamb2", "°", min=-180, max=180), inputfeld("λ₁", "input-GHA2-lamb1", "°", min=-180, max=180),
dcc.Checklist( dcc.Checklist(
id="method-checklist-2", id="method-checklist-2",
@@ -357,8 +360,8 @@ def render_content(tab):
Output("output-gha1-ana", "children"), Output("output-gha1-ana", "children"),
Output("store-gha1-ana", "data"), Output("store-gha1-ana", "data"),
Input("button-calc-gha1", "n_clicks"), Input("button-calc-gha1", "n_clicks"),
State("input-GHA1-beta1", "value"), State("input-GHA1-beta0", "value"),
State("input-GHA1-lamb1", "value"), State("input-GHA1-lamb0", "value"),
State("input-GHA1-s", "value"), State("input-GHA1-s", "value"),
State("input-GHA1-a", "value"), State("input-GHA1-a", "value"),
State("input-ax", "value"), State("input-ax", "value"),
@@ -367,7 +370,7 @@ def render_content(tab):
State("method-checklist-1", "value"), State("method-checklist-1", "value"),
prevent_initial_call=True, prevent_initial_call=True,
) )
def compute_gha1_ana(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1): def compute_gha1_ana(n1, beta0, lamb0, s, a0, ax, ay, b, method1):
out = html.Div([ out = html.Div([
html.H4("Erste Hauptaufgabe"), html.H4("Erste Hauptaufgabe"),
]) ])
@@ -375,7 +378,7 @@ def compute_gha1_ana(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1):
return no_update, no_update return no_update, no_update
if None in (ax, ay, b): if None in (ax, ay, b):
return html.Span("Bitte Ellipsoid wählen.", style={"color": "red"}), None return html.Span("Bitte Ellipsoid wählen.", style={"color": "red"}), None
if None in (beta11, lamb11, s, a_deg): if None in (beta0, lamb0, s, a0):
return html.Span("Bitte β₀, λ₀, s und α₀ eingeben.", style={"color": "red"}), None return html.Span("Bitte β₀, λ₀, s und α₀ eingeben.", style={"color": "red"}), None
if not method1: if not method1:
return html.Span("Bitte Berechnungsverfahren wählen.", style={"color": "red"}), None return html.Span("Bitte Berechnungsverfahren wählen.", style={"color": "red"}), None
@@ -384,28 +387,27 @@ def compute_gha1_ana(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1):
ell = EllipsoidTriaxial(ax, ay, b) ell = EllipsoidTriaxial(ax, ay, b)
beta_rad = wu.deg2rad(float(beta11)) beta_rad = wu.deg2rad(float(beta0))
lamb_rad = wu.deg2rad(float(lamb11)) lamb_rad = wu.deg2rad(float(lamb0))
alpha_rad = wu.deg2rad(float(a_deg)) alpha_rad = wu.deg2rad(float(a0))
s_val = float(s) s_val = float(s)
p1 = ell.ell2cart(beta_rad, lamb_rad) P0 = ell.ell2cart(beta_rad, lamb_rad)
p2_ana, alpha2 = gha1_ana(ell, p1, alpha_rad, s_val, 70) P1_ana, alpha2 = gha1_ana(ell, P0, alpha_rad, s_val, 70)
x2, y2, z2 = p2_ana beta2_ana, lamb2_ana = ell.cart2ell(P1_ana)
beta2, lamb2 = ell.cart2ell(p2_ana)
out = html.Div([ out = html.Div([
html.H4("Erste Hauptaufgabe"), html.H4("Erste Hauptaufgabe"),
html.Strong("Analytisch: "), html.Strong("Analytisch: "),
html.Br(), html.Br(),
html.Span(f"kartesisch: x₁={x2:.4f} m, y₁={y2:.4f} m, z₁={z2:.4f} m"), html.Span(f"kartesisch: x₁={P1_ana[0]:.4f} m, y₁={P1_ana[1]:.4f} m, z₁={P1_ana[2]:.4f} m"),
html.Br(), html.Br(),
html.Span(f"elliptisch: {aus.gms('β₁', beta2, 4)}, {aus.gms('λ₁', lamb2, 4)}"), html.Span(f"elliptisch: {aus.gms('β₁', beta2_ana, 4)}, {aus.gms('λ₁', lamb2_ana, 4)}"),
html.Br(), html.Br(),
]) ])
store = { store = {
"points": [("P1", p1, "black"), ("P2", p2_ana, "red")], "points": [("P0", P0, "black"), ("P1", P1_ana, "red")],
"polyline": None, "polyline": None,
"color": "#d62728" "color": "#d62728"
} }
@@ -415,8 +417,8 @@ def compute_gha1_ana(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1):
Output("output-gha1-num", "children"), Output("output-gha1-num", "children"),
Output("store-gha1-num", "data"), Output("store-gha1-num", "data"),
Input("button-calc-gha1", "n_clicks"), Input("button-calc-gha1", "n_clicks"),
State("input-GHA1-beta1", "value"), State("input-GHA1-beta0", "value"),
State("input-GHA1-lamb1", "value"), State("input-GHA1-lamb0", "value"),
State("input-GHA1-s", "value"), State("input-GHA1-s", "value"),
State("input-GHA1-a", "value"), State("input-GHA1-a", "value"),
State("input-ax", "value"), State("input-ax", "value"),
@@ -425,27 +427,27 @@ def compute_gha1_ana(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1):
State("method-checklist-1", "value"), State("method-checklist-1", "value"),
prevent_initial_call=True, prevent_initial_call=True,
) )
def compute_gha1_num(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1): def compute_gha1_num(n1, beta0, lamb0, s, a0, ax, ay, b, method1):
if not n1: if not n1:
return no_update, no_update return no_update, no_update
if "numerisch" not in (method1 or []): if "numerisch" not in (method1 or []):
return no_update, no_update return no_update, no_update
ell = EllipsoidTriaxial(ax, ay, b) ell = EllipsoidTriaxial(ax, ay, b)
beta_rad = wu.deg2rad(float(beta11)) beta_rad = wu.deg2rad(float(beta0))
lamb_rad = wu.deg2rad(float(lamb11)) lamb_rad = wu.deg2rad(float(lamb0))
alpha_rad = wu.deg2rad(float(a_deg)) alpha_rad = wu.deg2rad(float(a0))
s_val = float(s) s_val = float(s)
p1 = ell.ell2cart(beta_rad, lamb_rad) P0 = ell.ell2cart(beta_rad, lamb_rad)
p2_num, alpha1, werte = gha1_num(ell, p1, alpha_rad, s_val, 10000, all_points=True) P1_num, alpha1, werte = gha1_num(ell, P0, alpha_rad, s_val, 10000, all_points=True)
beta2_num, lamb2_num = ell.cart2ell(p2_num) beta2_num, lamb2_num = ell.cart2ell(P1_num)
out = html.Div([ out = html.Div([
html.Strong("Numerisch: "), html.Strong("Numerisch: "),
html.Br(), 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.Span(f"kartesisch: x₁={P1_num[0]:.4f} m, y₁={P1_num[1]:.4f} m, z₁={P1_num[2]:.4f} m"),
html.Br(), html.Br(),
html.Span(f"elliptisch: {aus.gms('β₁', beta2_num, 4)}, {aus.gms('λ₁', lamb2_num, 4)}"), html.Span(f"elliptisch: {aus.gms('β₁', beta2_num, 4)}, {aus.gms('λ₁', lamb2_num, 4)}"),
html.Br(), html.Br(),
@@ -454,7 +456,7 @@ def compute_gha1_num(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1):
polyline = [[x1, y1, z1] for x1, _, y1, _, z1, _ in werte] polyline = [[x1, y1, z1] for x1, _, y1, _, z1, _ in werte]
store = { store = {
"points": [("P1", p1, "black"), ("P2", p2_num, "#ff8c00")], "points": [("P0", P0, "black"), ("P1", P1_num, "#ff8c00")],
"polyline": polyline, "polyline": polyline,
"color": "#ff8c00" "color": "#ff8c00"
} }
@@ -464,8 +466,8 @@ def compute_gha1_num(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1):
Output("output-gha1-stoch", "children"), Output("output-gha1-stoch", "children"),
Output("store-gha1-stoch", "data"), Output("store-gha1-stoch", "data"),
Input("button-calc-gha1", "n_clicks"), Input("button-calc-gha1", "n_clicks"),
State("input-GHA1-beta1", "value"), State("input-GHA1-beta0", "value"),
State("input-GHA1-lamb1", "value"), State("input-GHA1-lamb0", "value"),
State("input-GHA1-s", "value"), State("input-GHA1-s", "value"),
State("input-GHA1-a", "value"), State("input-GHA1-a", "value"),
State("input-ax", "value"), State("input-ax", "value"),
@@ -474,16 +476,16 @@ def compute_gha1_num(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1):
State("method-checklist-1", "value"), State("method-checklist-1", "value"),
prevent_initial_call=True, prevent_initial_call=True,
) )
def compute_gha1_stoch(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1): def compute_gha1_stoch(n1, beta0, lamb0, s, a0, ax, ay, b, method1):
if not n1: if not n1:
return no_update, no_update return no_update, no_update
if "stochastisch" not in (method1 or []): if "stochastisch" not in (method1 or []):
return no_update, no_update return no_update, no_update
ell = EllipsoidTriaxial(ax, ay, b) ell = EllipsoidTriaxial(ax, ay, b)
beta_rad = wu.deg2rad(float(beta11)) beta_rad = wu.deg2rad(float(beta0))
lamb_rad = wu.deg2rad(float(lamb11)) lamb_rad = wu.deg2rad(float(lamb0))
alpha_rad = wu.deg2rad(float(a_deg)) alpha_rad = wu.deg2rad(float(a0))
s_val = float(s) s_val = float(s)
betas, lambs, alphas, S_real = gha1_es( betas, lambs, alphas, S_real = gha1_es(
@@ -492,24 +494,68 @@ def compute_gha1_stoch(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1):
10000, 10000,
ell ell
) )
beta2 = betas[-1] beta1_stoch = betas[-1]
lamb2 = lambs[-1] lamb1_stoch = lambs[-1]
alpha2 = alphas[-1]
p1 = ell.ell2cart(beta_rad, lamb_rad) P0 = ell.ell2cart(beta_rad, lamb_rad)
p2 = ell.ell2cart(beta2, lamb2) P1_stoch = ell.ell2cart(beta1_stoch, lamb1_stoch)
x2, y2, z2 = p2[0], p2[1], p2[2]
out = html.Div([ out = html.Div([
html.Strong("Stochastisch: "), html.Strong("Stochastisch: "),
html.Br(), html.Br(),
html.Span(f"kartesisch: x₁={x2:.4f} m, y₁={y2:.4f} m, z₁={z2:.4f} m"), html.Span(f"kartesisch: x₁={P1_stoch[0]:.4f} m, y₁={P1_stoch[1]:.4f} m, z₁={P1_stoch[2]:.4f} m"),
html.Br(), html.Br(),
html.Span(f"elliptisch: {aus.gms('β₁', beta2, 4)}, {aus.gms('λ₁', lamb2, 4)}"), html.Span(f"elliptisch: {aus.gms('β₁', beta1_stoch, 4)}, {aus.gms('λ₁', lamb1_stoch, 4)}"),
]) ])
store = { store = {
"points": [("P1", p1, "black"), ("P2", p2, "red")], "points": [("P0", P0, "black"), ("P1", P1_stoch, "red")],
"polyline": None,
"color": "#d62728"
}
return out, store
@app.callback(
Output("output-gha1-approx", "children"),
Output("store-gha1-approx", "data"),
Input("button-calc-gha1", "n_clicks"),
State("input-GHA1-beta0", "value"),
State("input-GHA1-lamb0", "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_approx(n1, beta0, lamb0, s, a0, ax, ay, b, method1):
if not n1:
return no_update, no_update
if "approx" not in (method1 or []):
return no_update, no_update
ell = EllipsoidTriaxial(ax, ay, b)
beta_rad = wu.deg2rad(float(beta0))
lamb_rad = wu.deg2rad(float(lamb0))
alpha_rad = wu.deg2rad(float(a0))
s_val = float(s)
P0 = ell.ell2cart(beta_rad, lamb_rad)
P1_app, alpha1_app, points = gha1_approx(ell, P0, alpha_rad, s_val, ds=5000, all_points=True)
beta1_app, lamb1_app = ell.cart2ell(P1_app)
out = html.Div([
html.Strong("Approximiert: "),
html.Br(),
html.Span(f"kartesisch: x₁={P1_app[0]:.4f} m, y₁={P1_app[1]:.4f} m, z₁={P1_app[2]:.4f} m"),
html.Br(),
html.Span(f"elliptisch: {aus.gms('β₁', beta1_app, 4)}, {aus.gms('λ₁', lamb1_app, 4)}"),
])
store = {
"points": [("P0", P0, "black"), ("P1", P1_app, "red")],
"polyline": None, "polyline": None,
"color": "#d62728" "color": "#d62728"
} }
@@ -521,17 +567,17 @@ def compute_gha1_stoch(n1, beta11, lamb11, s, a_deg, ax, ay, b, method1):
Output("output-gha2-num", "children"), Output("output-gha2-num", "children"),
Output("store-gha2-num", "data"), Output("store-gha2-num", "data"),
Input("button-calc-gha2", "n_clicks"), Input("button-calc-gha2", "n_clicks"),
State("input-GHA2-beta0", "value"),
State("input-GHA2-lamb0", "value"),
State("input-GHA2-beta1", "value"), State("input-GHA2-beta1", "value"),
State("input-GHA2-lamb1", "value"), State("input-GHA2-lamb1", "value"),
State("input-GHA2-beta2", "value"),
State("input-GHA2-lamb2", "value"),
State("input-ax", "value"), State("input-ax", "value"),
State("input-ay", "value"), State("input-ay", "value"),
State("input-b", "value"), State("input-b", "value"),
State("method-checklist-2", "value"), State("method-checklist-2", "value"),
prevent_initial_call=True, prevent_initial_call=True,
) )
def compute_gha2_num(n2, beta1, lamb1, beta2, lamb2, ax, ay, b, method2): def compute_gha2_num(n2, beta0, lamb0, beta1, lamb1, ax, ay, b, method2):
out = html.Div([ out = html.Div([
html.H4("Zweite Hauptaufgabe"), html.H4("Zweite Hauptaufgabe"),
]) ])
@@ -539,7 +585,7 @@ def compute_gha2_num(n2, beta1, lamb1, beta2, lamb2, ax, ay, b, method2):
return no_update, no_update return no_update, no_update
if None in (ax, ay, b): if None in (ax, ay, b):
return html.Span("Bitte Ellipsoid wählen.", style={"color": "red"}), None return html.Span("Bitte Ellipsoid wählen.", style={"color": "red"}), None
if None in (beta1, lamb1, beta2, lamb2): if None in (beta0, lamb0, beta1, lamb1):
return html.Span("Bitte β₀, λ₀, β₁ und λ₁ eingeben.", style={"color": "red"}), None return html.Span("Bitte β₀, λ₀, β₁ und λ₁ eingeben.", style={"color": "red"}), None
if not method2: if not method2:
return html.Span("Bitte Berechnungsverfahren wählen.", style={"color": "red"}), None return html.Span("Bitte Berechnungsverfahren wählen.", style={"color": "red"}), None
@@ -548,13 +594,15 @@ def compute_gha2_num(n2, beta1, lamb1, beta2, lamb2, ax, ay, b, method2):
ell = EllipsoidTriaxial(ax, ay, b) ell = EllipsoidTriaxial(ax, ay, b)
b1 = wu.deg2rad(float(beta1)); l1 = wu.deg2rad(float(lamb1)) beta0_rad = wu.deg2rad(float(beta0))
b2 = wu.deg2rad(float(beta2)); l2 = wu.deg2rad(float(lamb2)) lamb0_rad = wu.deg2rad(float(lamb0))
beta1_rad = wu.deg2rad(float(beta1))
lamb1_rad = wu.deg2rad(float(lamb1))
p1 = tuple(map(float, ell.ell2cart(b1, l1))) P0 = ell.ell2cart(beta0_rad, lamb0_rad)
p2 = tuple(map(float, ell.ell2cart(b2, l2))) P1 = ell.ell2cart(beta1_rad, lamb1_rad)
alpha_1, alpha_2, s12, beta_arr, lamb_arr = gha2_num(ell, b1, l1, b2, l2) a0_num, a1_num, s_num, beta_arr, lamb_arr = gha2_num(ell, beta0_rad, lamb0_rad, beta1_rad, lamb1_rad, all_points=True)
polyline = [] polyline = []
for b_rad, l_rad in zip(beta_arr, lamb_arr): for b_rad, l_rad in zip(beta_arr, lamb_arr):
@@ -564,43 +612,95 @@ def compute_gha2_num(n2, beta1, lamb1, beta2, lamb2, ax, ay, b, method2):
out = html.Div([ out = html.Div([
html.H4("Zweite Hauptaufgabe"), html.H4("Zweite Hauptaufgabe"),
html.Strong("Numerisch: "), html.Strong("Numerisch: "),
html.Span(f"{aus.gms('α₀', alpha_1, 4)}, {aus.gms('α₁', alpha_2, 4)}, s = {s12:.4f} m"), html.Span(f"{aus.gms('α₀', a0_num, 4)}, {aus.gms('α₁', a1_num, 4)}, s = {s_num:.4f} m"),
]) ])
store = { store = {
"points": [("P1", p1, "black"), ("P2", p2, "#1f77b4")], "points": [("P0", P0, "black"), ("P1", P1, "#1f77b4")],
"polyline": polyline, "polyline": polyline,
"color": "#1f77b4", "color": "#1f77b4",
} }
return out, store return out, store
# @app.callback( @app.callback(
# Output("output-gha2-stoch", "children"), Output("output-gha2-stoch", "children"),
# Output("store-gha2-stoch", "data"), Output("store-gha2-stoch", "data"),
# Input("button-calc-gha2", "n_clicks"), Input("button-calc-gha2", "n_clicks"),
# State("input-GHA2-beta1", "value"), State("input-GHA2-beta0", "value"),
# State("input-GHA2-lamb1", "value"), State("input-GHA2-lamb0", "value"),
# State("input-GHA2-beta2", "value"), State("input-GHA2-beta1", "value"),
# State("input-GHA2-lamb2", "value"), State("input-GHA2-lamb1", "value"),
# State("input-ax", "value"), State("input-ax", "value"),
# State("input-ay", "value"), State("input-ay", "value"),
# State("input-b", "value"), State("input-b", "value"),
# State("method-checklist-2", "value"), State("method-checklist-2", "value"),
# prevent_initial_call=True, prevent_initial_call=True,
# ) )
# def compute_gha2_stoch(n2, beta1, lamb1, beta2, lamb2, ax, ay, b, method2): def compute_gha2_stoch(n2, beta0, lamb0, beta1, lamb1, ax, ay, b, method2):
# if not n2: if not n2:
# return no_update, no_update return no_update, no_update
# if "numerisch" not in (method2 or []): if "stochastisch" not in (method2 or []):
# return no_update, no_update return no_update, no_update
#
# out = html.Div([
# html.Strong("Stochastisch (ES): "),
# html.Span("noch nicht implementiert...")
# ])
#
# return out, {"points": None, "polyline": None, "color": "#9467bd"}
ell = EllipsoidTriaxial(ax, ay, b)
beta0_rad = wu.deg2rad(float(beta0))
lamb0_rad = wu.deg2rad(float(lamb0))
beta1_rad = wu.deg2rad(float(beta1))
lamb1_rad = wu.deg2rad(float(lamb1))
P0 = ell.ell2cart(beta0_rad, lamb0_rad)
P1 = ell.ell2cart(beta1_rad, lamb1_rad)
a0_stoch, a1_stoch, s_stoch, points = gha2_ES(ell, P0, P1, all_points=True, sigmaStep=1e-5)
out = html.Div([
html.Strong("Stochastisch (ES): "),
html.Span(f"{aus.gms('α₀', a0_stoch, 4)}, α₁ = {a1_stoch}, s = {s_stoch:.4f} m"),
])
return out, {"points": None, "polyline": None, "color": "#9467bd"}
@app.callback(
Output("output-gha2-approx", "children"),
Output("store-gha2-approx", "data"),
Input("button-calc-gha2", "n_clicks"),
State("input-GHA2-beta0", "value"),
State("input-GHA2-lamb0", "value"),
State("input-GHA2-beta1", "value"),
State("input-GHA2-lamb1", "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_approx(n2, beta0, lamb0, beta1, lamb1, ax, ay, b, method2):
if not n2:
return no_update, no_update
if "approx" not in (method2 or []):
return no_update, no_update
ell = EllipsoidTriaxial(ax, ay, b)
beta0_rad = wu.deg2rad(float(beta0))
lamb0_rad = wu.deg2rad(float(lamb0))
beta1_rad = wu.deg2rad(float(beta1))
lamb1_rad = wu.deg2rad(float(lamb1))
P0 = ell.ell2cart(beta0_rad, lamb0_rad)
P1 = ell.ell2cart(beta1_rad, lamb1_rad)
a0_app, a1_app, s_app, points = gha2(ell, P0, P1, ds=1e-4, all_points=True)
out = html.Div([
html.Strong("Approximiert: "),
html.Span(f"{aus.gms('α₀', a0_app, 4)}, {aus.gms('α₁', a1_app, 4)}, s = {s_app:.4f} m"),
])
return out, {"points": None, "polyline": None, "color": "#94cccc"}
# --- Plot ---
@app.callback( @app.callback(
Output("ellipsoid-plot", "figure"), Output("ellipsoid-plot", "figure"),
Input("input-ax", "value"), Input("input-ax", "value"),
@@ -608,10 +708,13 @@ def compute_gha2_num(n2, beta1, lamb1, beta2, lamb2, ax, ay, b, method2):
Input("input-b", "value"), Input("input-b", "value"),
Input("store-gha1-ana", "data"), Input("store-gha1-ana", "data"),
Input("store-gha1-num", "data"), Input("store-gha1-num", "data"),
Input("store-gha1-stoch", "data"),
Input("store-gha1-approx", "data"),
Input("store-gha2-num", "data"), Input("store-gha2-num", "data"),
Input("store-gha2-stoch", "data"), Input("store-gha2-stoch", "data"),
Input("store-gha2-approx", "data"),
) )
def render_all(ax, ay, b, store_gha1_ana, store_gha1_num, store_gha2_num, store_gha2_stoch): def render_all(ax, ay, b, store_gha1_ana, store_gha1_num, store_gha1_stoch, store_gha1_approx, store_gha2_num, store_gha2_stoch, store_gha2_approx):
if None in (ax, ay, b): if None in (ax, ay, b):
return go.Figure() return go.Figure()
@@ -630,7 +733,7 @@ def render_all(ax, ay, b, store_gha1_ana, store_gha1_num, store_gha2_num, store_
fig = figure_lines(fig, line, store.get("color", "#ff8c00")) fig = figure_lines(fig, line, store.get("color", "#ff8c00"))
return fig return fig
for st in (store_gha1_ana, store_gha1_num, store_gha2_num, store_gha2_stoch): for st in (store_gha1_ana, store_gha1_num, store_gha1_stoch, store_gha1_approx, store_gha2_num, store_gha2_stoch, store_gha2_approx):
fig = add_from_store(fig, st) fig = add_from_store(fig, st)
return fig return fig