fa2338/Masterprojekt_V3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Push

Browse Source
This commit is contained in:
fa2338
2026-02-05 14:45:27 +01:00
parent e0796deec6
commit 65b390bf2d
8 changed files with 868 additions and 59323 deletions
Download Patch File Download Diff File Expand all files Collapse all files

853
Ausgleichungsprogramm.ipynb Normal file
View File

@@ -0,0 +1,853 @@
{
"cells": [
{
"cell_type": "code",
"id": "2bc687b1b4adb7bd",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:09.512813Z",
"start_time": "2026-02-05T12:24:07.910581Z"
}
},
"source": [
"# Zelle 1: Import von Python-Modulen und Bibliotheken\n",
"\n",
"from datetime import datetime\n",
"import importlib\n",
"from IPython.display import HTML\n",
"from IPython.display import display\n",
"import numpy as np\n",
"import pandas as pd\n",
"\n",
"import Berechnungen\n",
"import Datenbank\n",
"import Export\n",
"import Funktionales_Modell\n",
"import Import\n",
"import Koordinatentransformationen\n",
"import Netzqualitaet_Genauigkeit\n",
"import Netzqualitaet_Zuverlaessigkeit\n",
"from Parameterschaetzung import Iterationen\n",
"import Proben\n",
"import Varianzkomponentenschaetzung"
],
"outputs": [],
"execution_count": 1
},
{
"cell_type": "code",
"id": "4f7efd7ba6ec18f9",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:09.522346Z",
"start_time": "2026-02-05T12:24:09.520187Z"
}
},
"source": [
"# Zelle 2: Allgemeine Einstellungen\n",
"\n",
"# Auswahl der Datumsdefinition (Aktuell ist lediglich die weiche Lagerung implementiert)\n",
"datumfestlegung = \"weiche Lagerung\"\n",
"\n",
"# Übergabe der großen und kleinen Halbachse des Referenzellipsoids (aktuell GRS80)\n",
"a = 6378137.0 #m\n",
"b = 6356752.314 #m\n",
"\n",
"# Pfad zur SQLite-Datenbank (wird angelegt, falls nicht vorhanden)\n",
"pfad_datenbank = r\"Campusnetz.db\"\n",
"\n",
"# Pfad zum Quasigeoid-Modell GCG 2016 des BKG\n",
"pfad_tif_quasigeoidundolation = r\"Daten\\GCG2016v2023.tif\"\n",
"\n",
"# Alle während jeder Iteration der Parameterschätzung erstellten Vektoren und Matrizenin einer CSV-Datei im Ordner Zwischenergebnisse speichern (Auf True setzen, wenn gewünscht)\n",
"speichern_in_csv = False"
],
"outputs": [],
"execution_count": 2
},
{
"cell_type": "code",
"id": "57fcd841405b7866",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:09.763148Z",
"start_time": "2026-02-05T12:24:09.708149Z"
}
},
"source": [
"# Zelle 3: SQLite-Datenbank initialisieren und Klassen laden\n",
"\n",
"# Datenbank anlegen (falls nicht vorhanden)\n",
"Datenbank.Datenbank_anlegen(pfad_datenbank)\n",
"\n",
"# Klassen aus eigenen Pythondateien initialisieren\n",
"db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
"fm = Funktionales_Modell.FunktionalesModell(pfad_datenbank, a, b, pfad_tif_quasigeoidundolation)\n",
"imp = Import.Import(pfad_datenbank, a, b)\n",
"iterat = Iterationen(pfad_datenbank, pfad_tif_quasigeoidundolation, a, b)\n",
"trafos = Koordinatentransformationen.Transformationen(pfad_datenbank)\n",
"vks = Varianzkomponentenschaetzung.VKS(pfad_datenbank)"
],
"outputs": [],
"execution_count": 3
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:10.248982Z",
"start_time": "2026-02-05T12:24:10.242901Z"
}
},
"cell_type": "code",
"source": [
"# Zelle 4: Ausgabe der bereits vorhandenen Instrumente\n",
"\n",
"db_zugriff.tabelle_instrumente_aus_db()"
],
"id": "2cf681b8ca7f268",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Es wurden noch keine Instrumente angelegt. Bitte in der folgenden Zelle nachholen und diese Zelle erneut ausführen!\n"
]
}
],
"execution_count": 4
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:10.710361Z",
"start_time": "2026-02-05T12:24:10.684088Z"
}
},
"cell_type": "code",
"source": [
"# Zelle 5: Instrumente anlegen\n",
"\n",
"# Syntax: db_zugriff.set_instrument(Instrumententyp, Bezeichnung, [Beobachtungsgruppen])\n",
"# Hinweis: Alle GNSS-Rover sind als ein Instrument anzulegen!\n",
"# Sind Instrumente bereits in der Datenbank vorhanden, wird der Import übersprungen.\n",
"# Änderungen an bestehenden Instrumenten sind nicht möglich. In diesem Fall ist ein neues Instrument anlegen.\n",
"\n",
"db_zugriff.set_instrument(\n",
" \"Tachymeter\", \"Trimble S9\", [\"Tachymeter_Streckenbeobachtungen\", \"Tachymeter_Richtungsbeobachtungen\", \"Tachymeter_Zenitwinkelbeobachtungen\"\n",
" ])\n",
"db_zugriff.set_instrument(\n",
" \"Nivellier\", \"Trimble DiNi 0.3\", [\"Nivellier_Hoehendifferenzbeobachtungen\"\n",
" ])\n",
"db_zugriff.set_instrument(\n",
" \"GNSS\", \"GNSS-Rover\", [\"GNSS-Rover_Basislinienbeobachtungen\"\n",
" ])"
],
"id": "990c372312c1d8f9",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Das Instrument Trimble S9 wurde erfolgreich hinzugefügt.\n",
"Das Instrument Trimble DiNi 0.3 wurde erfolgreich hinzugefügt.\n",
"Das Instrument GNSS-Rover wurde erfolgreich hinzugefügt.\n"
]
}
],
"execution_count": 5
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:11.161918Z",
"start_time": "2026-02-05T12:24:11.156510Z"
}
},
"cell_type": "code",
"source": [
"# Zelle 6: Ausgabe der bereits vorhandenen Genauigkeitsangaben a-priori\n",
"\n",
"db_zugriff.tabelle_genauigkeiten_aus_db()"
],
"id": "3a90f746c44a1ebb",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Es wurden noch keine apriori Genauigkeiten zu den Beobachtungsgruppen erfasst. Bitte in der folgenden Zelle nachholen und diese Zelle erneut ausführen.\n"
]
}
],
"execution_count": 6
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:11.784546Z",
"start_time": "2026-02-05T12:24:11.763928Z"
}
},
"cell_type": "code",
"source": [
"# Zelle 7: Genauigkeiten a-priori zu den Instrumenten erfassen\n",
"\n",
"# Syntax: db_zugriff.set_genauigkeiten(InstrumentenID, Beobachtungsgruppe, Standardabweichung_konstant, Standardabweichung_streckenproportional)\n",
"\n",
"# Einheit der Eingaben:\n",
"# - stabw_konstant:\n",
"# - Winkelbeobachtungen (Richtung, Zenitwinkel): Standardabweichung in mgon\n",
"# - Strecken: Standardabweichung in m (auf die Strecke bezogener absoluter Anteil)\n",
"# - Nivellement: Standardabweichung in m pro 1 km Doppelnivellement\n",
"# - stabw_streckenproportional (optional): streckenproportionaler Anteil in ppm\n",
"\n",
"# Sind Genauigkeitsangaben bereits in der Datenbank vorhanden, wird der Import übersprungen.\n",
"# Änderungen sind möglich.\n",
"\n",
"db_zugriff.set_genauigkeiten(1, \"Tachymeter_Richtung\", 0.15)\n",
"db_zugriff.set_genauigkeiten(1, \"Tachymeter_Strecke\", 0.8, 1)\n",
"db_zugriff.set_genauigkeiten(1, \"Tachymeter_Zenitwinkel\", 0.15)\n",
"db_zugriff.set_genauigkeiten(3, \"Geometrisches_Nivellement\", 0.1, 0.3)"
],
"id": "107d51b8dd3b82cf",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Die Genauigkeitsangabe für Tachymeter_Richtung (Instrument: Trimble S9) wurde erfolgreich hinzugefügt.\n",
"Die Genauigkeitsangabe für Tachymeter_Strecke (Instrument: Trimble S9) wurde erfolgreich hinzugefügt.\n",
"Die Genauigkeitsangabe für Tachymeter_Zenitwinkel (Instrument: Trimble S9) wurde erfolgreich hinzugefügt.\n",
"Die Genauigkeitsangabe für Geometrisches_Nivellement (Instrument: Trimble DiNi 0.3) wurde erfolgreich hinzugefügt.\n"
]
}
],
"execution_count": 7
},
{
"cell_type": "code",
"id": "b28afe0c64aa59d6",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:12.490480Z",
"start_time": "2026-02-05T12:24:12.356523Z"
}
},
"source": [
"# Zelle 8: Import Tachymeter-Datensätze\n",
"# Hinweis: Sind die Dateien bereits für den Import verwendet worden, wird der Import abgebrochen.\n",
"\n",
"# CSV-Datei mit den Koordinaten im Lokalen-Horizontsystem aus dem Tachymeterexport\n",
"pfad_datei_tachymeter_koordinaten = r\"Daten\\campsnetz_koordinaten_plus_nachmessungen.csv\"\n",
"\n",
"# CSV-Datei mit den Beobachtungen aus dem Tachymeterexport\n",
"pfad_datei_tachymeter_beobachtungen_csv = r\"Daten\\campsnetz_beobachtungen_plus_nachmessungen.csv\"\n",
"\n",
"# JXL-Datei mit den Beobachtungen aus dem Tachymeterexport (für die Korrektur der gerundeten Daten in der CSV-Datei)\n",
"pfad_datei_tachymeter_beobachtungen_jxl = r\"Daten\\campusnetz_bereinigt_plus_nachmessung_neu.jxl\"\n",
"\n",
"# Dateiname der korrigierten und erweiterten CSV-Datei mit den Tachymeterbeobachtungen\n",
"pfad_datei_tachymeterbeobachtungen_korrigiert = r\"Daten\\campsnetz_beobachtungen_plus_nachmessungen_korrigiert.csv\"\n",
"\n",
"# InstrumentenID des Tachymeters (siehe Zelle 4)\n",
"instrumentenID_Tachymeter = 1\n",
"\n",
"# Verarbeitung und Import der Tachymeterdatensätze\n",
"imp.import_koordinaten_lh_tachymeter(pfad_datei_tachymeter_koordinaten)\n",
"imp.korrigiere_beobachtungen_tachymeter_csv_mit_jxl(pfad_datei_tachymeter_beobachtungen_csv, pfad_datei_tachymeter_beobachtungen_jxl, pfad_datei_tachymeterbeobachtungen_korrigiert)\n",
"imp.import_beobachtungen_tachymeter(pfad_datei_tachymeterbeobachtungen_korrigiert, instrumentenID_Tachymeter)"
],
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Der Import der Näherungskoordinaten wurde erfolgreich abgeschlossen\n",
"Korrektur erfolgreich abgeschlossen. Ausgabe: Daten\\campsnetz_beobachtungen_plus_nachmessungen_korrigiert.csv\n",
"Ersetzungen in der CSV-Datei (Rundung -> JXL volle Nachkommastellen): {'Hz': 1639, 'Z': 1838, 'SD': 747}\n",
"Der Import der Datei Daten\\campsnetz_beobachtungen_plus_nachmessungen_korrigiert.csv wurde erfolgreich abgeschlossen.\n"
]
}
],
"execution_count": 8
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:12.916365Z",
"start_time": "2026-02-05T12:24:12.899749Z"
}
},
"cell_type": "code",
"source": [
"# Zelle 9: Import GNSS-Datensätze\n",
"# Hinweis: Sind die Dateien bereits importiert, wird der Import übersprungen.\n",
"\n",
"# CSV-Datei mit den Koordinaten der statischen GNSS-Messung als export aus LeicaGeoOffice\n",
"pfad_koordinaten_gnss = r\"Daten\\Koordinaten_ohne0648und10002.csv\"\n",
"\n",
"# TXT-Datei mit den Basislinien und den Kovarianzen als Export aus LeicaGeoOffice\n",
"pfad_basislinien_gnss = r\"Daten\\Basislinien_ohne0648und10002.asc.txt\"\n",
"\n",
"# Standardabweichung a priori der Koordinaten der SAPOS-Referenzstationen in X, Y und Z für die weiche Lagerung\n",
"genauigkeit_sapos_referenzstationen = [0.005, 0.005, 0.008]\n",
"\n",
"# InstrumentenID aller GNSS-Empfänger (siehe Zelle 4)\n",
"instrumentenID_GNSS_Empfaenger = 4\n",
"\n",
"# Import ausführen\n",
"imp.import_koordinaten_gnss(pfad_koordinaten_gnss, genauigkeit_sapos_referenzstationen)\n",
"imp.import_basislinien_gnss(pfad_basislinien_gnss, instrumentenID_GNSS_Empfaenger)"
],
"id": "75d9d9edbbbc7bb7",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Der Import der Datei Daten\\Basislinien_ohne0648und10002.asc.txt wurde erfolgreich abgeschlossen.\n"
]
}
],
"execution_count": 9
},
{
"cell_type": "code",
"id": "2d8a0533726304a8",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:14.974452Z",
"start_time": "2026-02-05T12:24:13.540713Z"
}
},
"source": [
"# Zelle 10: Helmerttransformation\n",
"\n",
"# Transformationsparameter zwischen lokalem-Horizontsystem aus dem Tachymeterexport und ETRS89 / DREF 91 (Realisierung 2025) berechnen\n",
"transformationsparameter = trafos.Helmerttransformation_Euler_Transformationsparameter_berechnen()\n",
"\n",
"# Transformationsparameter anwenden und Koordinaten im Zielsystem berechnen\n",
"koordinaten_transformiert = trafos.Helmerttransformation(transformationsparameter)\n",
"\n",
"# Koordinaten als Näherungen für die Ausgleichung in die Datenbank speichern\n",
"db_zugriff.set_koordinaten(koordinaten_transformiert, \"naeherung_us\")"
],
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Anzahl verwendete Punkte für die Helmerttransformation: 9\n",
"Iteration Nr.1 abgeschlossen\n",
"Iteration Nr.2 abgeschlossen\n",
"Iteration Nr.3 abgeschlossen\n",
"Iteration Nr.4 abgeschlossen\n",
"Iteration Nr.5 abgeschlossen\n",
"Iteration Nr.6 abgeschlossen\n",
"Koordinaten berechnet aus Helmerttransformation:\n",
"10001: 3794901.521, 546745.584, 5080065.755\n",
"10008: 3794783.870, 546746.646, 5080152.758\n",
"10014: 3794838.746, 546812.367, 5080105.181\n",
"10026: 3794753.858, 546827.445, 5080167.092\n",
"10028: 3794889.671, 546908.764, 5080056.920\n",
"10037: 3794800.626, 546960.749, 5080117.709\n",
"10044: 3794752.686, 546958.324, 5080154.237\n",
"10054: 3794889.163, 547086.949, 5080038.116\n",
"10059: 3794736.830, 547079.447, 5080152.362\n",
"Streckendifferenzen zwischen Näherungskoordinate aus statischer GNSS-Messung und ergebnis der Helmerttransformation:\n",
"[0.027793, 0.025879, 0.016527, 0.01604, 0.066139, 0.07164, 0.025138, 0.125881, 0.142477]\n",
"\n",
"Differenz Schwerpunkt zwischen Näherungskoordinate aus statischer GNSS-Messung und ergebnis der Helmerttransformation::\n",
"Matrix([[3.10e-10], [1.16e-10], [1.03e-10]])\n",
"Betrag der Schwerpunkt-Differenz zwischen Näherungskoordinate aus statischer GNSS-Messung und ergebnis der Helmerttransformation::\n",
"0.000m\n"
]
}
],
"execution_count": 10
},
{
"cell_type": "code",
"id": "ed9be38e35cfc619",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:15.067892Z",
"start_time": "2026-02-05T12:24:15.058891Z"
}
},
"source": [
"# Zelle 11: Anschlusspunkte für die weiche Lagerung festlegen\n",
"# Definieren Sie hier die Punktnummern, die als Anschlusspunkte für die weiche Lagerung verwendet werden sollen.\n",
"\n",
"# X-Koordinate der Punkte verwenden\n",
"liste_koordinaten_x = []\n",
"\n",
"# Y-Koordinate der Punkte verwenden\n",
"liste_koordinaten_y = []\n",
"\n",
"# Z-Koordinate der Punkte verwenden\n",
"liste_koordinaten_z = []\n",
"\n",
"# X, Y und Z-Koordinate der Punkte verwenden\n",
"liste_koordinaten_x_y_z = [\"0645\", \"0656\", \"0995\", \"1675\", \"ESTE\", \"GNA2\"]\n",
"\n",
"# Änderungen der zu verwendenden Anschlusspunkte in die Datenbank übernehmen\n",
"db_zugriff.set_datumskoordinaten(liste_koordinaten_x, liste_koordinaten_y, liste_koordinaten_z, liste_koordinaten_x_y_z)"
],
"outputs": [],
"execution_count": 11
},
{
"cell_type": "code",
"id": "2d2156381d974d94",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:15.151220Z",
"start_time": "2026-02-05T12:24:15.146192Z"
}
},
"source": [
"# Zelle 12: Anschlusspunkte für die weiche Lagerung entfernen\n",
"# Definieren Sie hier die Punktnummern, die aus den Anschlusspunkten entfernt werden sollen.\n",
"\n",
"# X-Koordinate der Punkte entfernen\n",
"liste_koordinaten_x = []\n",
"\n",
"# Y-Koordinate der Punkte verwenden\n",
"liste_koordinaten_y = []\n",
"\n",
"# Z-Koordinate der Punkte verwenden\n",
"liste_koordinaten_z = []\n",
"\n",
"# X, Y und Z-Koordinate der Punkte verwenden\n",
"liste_koordinaten_x_y_z = []\n",
"\n",
"# Änderungen der zu verwendenden Anschlusspunkte in die Datenbank übernehmen\n",
"db_zugriff.set_datumskoordinaten_to_neupunkte(liste_koordinaten_x, liste_koordinaten_y, liste_koordinaten_z, liste_koordinaten_x_y_z)"
],
"outputs": [],
"execution_count": 12
},
{
"cell_type": "code",
"id": "c2db29680c53f8c4",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:15.928494Z",
"start_time": "2026-02-05T12:24:15.908077Z"
}
},
"source": [
"# Zelle 13: Nivellement-Beobachtungen importieren\n",
"# Hinweis: Ist die Datei bereits importiert, wird der Import übersprungen.\n",
"\n",
"# CSV-Datei mit den Beobachtungen des geometrischen Nivellements\n",
"pfad_datei_nivellement = r\"Daten\\Niv_bereinigt.DAT.csv\"\n",
"\n",
"# InstrumentenID des Nivelliers (siehe Zelle 4)\n",
"instrumentenID_Nivellier = 3\n",
"\n",
"# Datenvorverarbeitung und Import in die Datenbank ausführen\n",
"dict_punkthoehen_naeherung_niv, liste_punkte_in_db = imp.vorbereitung_import_beobachtungen_nivellement_naeherung_punkthoehen(pfad_datei_nivellement, instrumentenID_Nivellier)\n",
"imp.import_beobachtungen_nivellement_RVVR(pfad_datei_nivellement, instrumentenID_Nivellier)"
],
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Folgende Stand- und Zielpunkte des geometrischen Nivellements werden für die Beobachtungsgruppe ausgeglichen: ['812', '10047', '10046', '10045', '10034', 'FH14', 'FH11', '10035', '10029', '10030', '10031', '10017', '10013', '10012', '10014', '10015', '10016', '10007', 'FH13', '666', '10054', '10056', '10058', '10052', '10043', '10026', '10010', '10006', '816', '10048', 'FH3', '10049', '10053', '10050', '10051', 'FH4', '10040', '10037', '10038', '10039', '10032', 'FH15', '10033', '10025', '10024', '10023', '10022', '10021', '10020', '10019', '10036', '10028', '10011', '10001', '10003', '10008', '10005', '10004', '10002', '10055', '10057', '10059', '10044', '10041', '10042', '10027', '10018', '10009']\n",
"Für folgende Punkte wird aktuell keine Höhe in der Ausgleichung berechnet: ['80001', '80002', '90001', '90002', '90003', '90004', '90005', '90006', '90007', '90008', '90009', '90010', '90011', '90012', '90013', '90014', '70001', '70002', '60001', 'FH5', '60002', '60003', '60004', '60005', '60006', '60007', '60008', '60009', '60010', '30001', '30002', '30003', '30004', '30005', '30006', '30007', '30008']. Bei Bedarf im folgenden Schritt ändern!\n"
]
},
{
"data": {
"text/plain": [
"'Die Beobachtungen aus der Datei Daten\\\\Niv_bereinigt.DAT.csv wurden erfolgreich importiert.'"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"execution_count": 13
},
{
"metadata": {
"jupyter": {
"is_executing": true
},
"ExecuteTime": {
"start_time": "2026-02-05T12:24:17.017690Z"
}
},
"cell_type": "code",
"source": [
"# Zelle 14: Parameterschätzung iterativ berechnen\n",
"# Hinweis: Die Ausführung dauert je nach Rechenkapazität zwischen 13 und 20 Minuten.\n",
"\n",
"# Berechnung durchführen\n",
"A_matrix_numerisch, Jacobimatrix_symbolisch_liste_unbekannte, Jacobimatrix_symbolisch_liste_beobachtungsvektor, x, dx, dl_k, ausgabe_parameterschaetzung = iterat.iterationen(datumfestlegung, speichern_in_csv)\n",
"\n",
"# Koordinaten der letzten Iteration speichern\n",
"dict_koordinaten_ausgleichungsergebnis = fm.unbekanntenvektor_numerisch_to_dict_unbekanntenvektor(Jacobimatrix_symbolisch_liste_unbekannte, x)"
],
"id": "7d025ca293d73188",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Zelle 15: Proben\n",
"\n",
"# Rechenprobe (ATPV-Probe)\n",
"Proben.atpv_probe(A_matrix_numerisch, ausgabe_parameterschaetzung[\"P\"], ausgabe_parameterschaetzung[\"v\"])\n",
"\n",
"# Hauptprobe\n",
"Proben.hauptprobe(A_matrix_numerisch, dx, dl_k, ausgabe_parameterschaetzung[\"v\"])"
],
"id": "de8f624059005fdd",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": "# ------------------------------- Netzqualitätsmaße -------------------------------",
"id": "7d53274224166103",
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "84075bea1f2c44d7",
"metadata": {},
"source": [
"# Zelle 16: Gesamtredundanz r\n",
"\n",
"r_gesamt = Netzqualitaet_Zuverlaessigkeit.Zuverlaessigkeit.gesamtredundanz(A_matrix_numerisch.shape[0], A_matrix_numerisch.shape[1])"
],
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "1797726c5b3af9bf",
"metadata": {},
"source": [
"# Zelle 17: s0 a posteriori\n",
"\n",
"s0_aposteriori = Netzqualitaet_Genauigkeit.Genauigkeitsmaße.berechne_s0apost(ausgabe_parameterschaetzung[\"v\"], ausgabe_parameterschaetzung[\"P\"], r_gesamt)"
],
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "a2fe23d9a19ac2f9",
"metadata": {},
"source": [
"# Zelle 18: Redundanzanteile ri\n",
"\n",
"R, ri, EVi, Redundanzanteile = Netzqualitaet_Zuverlaessigkeit.Zuverlaessigkeit.redundanzanteile_ri(ausgabe_parameterschaetzung[\"Q_vv\"], ausgabe_parameterschaetzung[\"P\"], Jacobimatrix_symbolisch_liste_beobachtungsvektor)"
],
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "14db90a3d4d9118b",
"metadata": {},
"source": [
"# Zelle 19: Globaltest des Ausgleichungsmodells\n",
"\n",
"globaltest = Netzqualitaet_Zuverlaessigkeit.Zuverlaessigkeit.globaltest(r_gesamt=r_gesamt, sigma0_apost=s0_aposteriori, sigma0_apriori=1)"
],
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "1a84fbfb3db101c9",
"metadata": {},
"source": [
"# Zelle 20: Lokaltest und innere Zuverlässigkeit\n",
"# Bei der Auswahl einer GNSS-Komponente, wie z.B. bx werden automatisch die anderen beiden Kompontenen aus-, bzw. abgewählt. Bitte warten, bis dies automatisch durchführt wurde.\n",
"\n",
"lokaltest, beta = Netzqualitaet_Zuverlaessigkeit.Zuverlaessigkeit.aufruf_lokaltest(Jacobimatrix_symbolisch_liste_beobachtungsvektor, globaltest[\"alpha\"], ausgabe_parameterschaetzung, ri, s0_aposteriori)\n"
],
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "ebf2c9ef0a1899dc",
"metadata": {},
"source": [
"# Zelle 21: Ausgewählte Beobachtungen für weitere Iterationen ausschalten\n",
"\n",
"db_zugriff.set_beobachtung_ausschalten(lokaltest)"
],
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Zelle 22: Varianzkomponentenschätzung\n",
"\n",
"vks.varianzkomponten_berechnen(Jacobimatrix_symbolisch_liste_beobachtungsvektor, ausgabe_parameterschaetzung, R)"
],
"id": "dd7bfa4df762a4a7",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Zelle 23: Varianzkomponten anpassen\n",
"\n",
"vks.vks_ausfuehren()\n",
"vks.zeige_vks_tabelle()"
],
"id": "edb14958ee00130c",
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "256f4a0805b69e14",
"metadata": {},
"source": [
"# Zelle 24: Äußere Zuverlässigkeit\n",
"importlib.reload(Netzqualitaet_Zuverlaessigkeit)\n",
"\n",
"bezeichnungen = [str(s) for s in Jacobimatrix_symbolisch_liste_beobachtungsvektor]\n",
"\n",
"bezeichnungen = [str(s) for s in Jacobimatrix_symbolisch_liste_beobachtungsvektor]\n",
"\n",
"lokaltest_ergebnisse = Netzqualitaet_Zuverlaessigkeit.Zuverlaessigkeit.lokaltest_innere_Zuverlaessigkeit(\n",
" ausgabe_parameterschaetzung[\"v\"],\n",
" ausgabe_parameterschaetzung[\"Q_vv\"],\n",
" ri,\n",
" bezeichnungen,\n",
" s0_aposteriori,\n",
" globaltest[\"alpha\"],\n",
" beta\n",
")\n",
"\n",
"Aussen = Netzqualitaet_Zuverlaessigkeit.Zuverlaessigkeit.aeussere_zuverlaessigkeit(\n",
" Lokaltest=lokaltest_ergebnisse,\n",
" bezeichnung=bezeichnungen,\n",
" Qxx=ausgabe_parameterschaetzung[\"Q_xx\"],\n",
" A=A_matrix_numerisch,\n",
" P=ausgabe_parameterschaetzung[\"P\"],\n",
" s0_apost=s0_aposteriori,\n",
" unbekannten_liste=Jacobimatrix_symbolisch_liste_unbekannte,\n",
" x=x,\n",
" ausschliessen=\"lA\"\n",
")\n",
"\n",
"display(HTML(Aussen.to_html(index=False)))\n",
"Aussen.to_excel(r\"Zwischenergebnisse\\Aeussere_Zuverlaessigkeit.xlsx\", index=False)"
],
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Zelle 25: Standardabweichungen der einzelnen Punkte und Helmert'scher Punktfehler (3D)\n",
"\n",
"Helmertscher_Punktfehler = Netzqualitaet_Genauigkeit.Genauigkeitsmaße.helmert_punktfehler(ausgabe_parameterschaetzung[\"Q_xx\"], s0_aposteriori,Jacobimatrix_symbolisch_liste_unbekannte)"
],
"id": "9e6624251a23847d",
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "89fbcfe85fb6e4bb",
"metadata": {},
"source": [
"# Zelle 26: Standardellipse bzw. Helmert'sche Fehlerellipsen\n",
"\n",
"Standardellipse = Netzqualitaet_Genauigkeit.Genauigkeitsmaße.standardellipse(ausgabe_parameterschaetzung[\"Q_xx\"], s0_aposteriori, Jacobimatrix_symbolisch_liste_unbekannte)\n"
],
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "7de561d7eaebb1c2",
"metadata": {},
"source": [
"# Zelle 27: Konfidenzellipsen\n",
"\n",
"Konfidenzellipse = Netzqualitaet_Genauigkeit.Genauigkeitsmaße.konfidenzellipse(ausgabe_parameterschaetzung[\"Q_xx\"], s0_aposteriori, Jacobimatrix_symbolisch_liste_unbekannte, r_gesamt, False)"
],
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Zelle 28: Konfidenzellipsen im ENU-System\n",
"\n",
"Konfidenzellipse_ENU, R0 = Netzqualitaet_Genauigkeit.Genauigkeitsmaße.konfidenzellipsen_enu(a, b, ausgabe_parameterschaetzung, Jacobimatrix_symbolisch_liste_unbekannte, dict_koordinaten_ausgleichungsergebnis, s0_aposteriori, r_gesamt)"
],
"id": "ddc157c0ff21c93e",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Zelle 29: Netzplot mit Konfidenzellipsen (im ENU-System)\n",
"\n",
"Koord_ENU = Berechnungen.ENU.transform_Koord_zu_KoordENU(dict_koordinaten_ausgleichungsergebnis, R0)\n",
"\n",
"Netzqualitaet_Genauigkeit.Plot.netzplot_ellipsen(\n",
" Koord_ENU=Koord_ENU,\n",
" unbekannten_labels=Jacobimatrix_symbolisch_liste_unbekannte,\n",
" beobachtungs_labels=Jacobimatrix_symbolisch_liste_beobachtungsvektor,\n",
" df_konf_ellipsen_enu=Konfidenzellipse_ENU,\n",
" skalierung=1000\n",
")"
],
"id": "94a42bd0a62875ea",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"from Koordinatentransformationen import Transformationen\n",
"trafos = Transformationen(pfad_datenbank)\n",
"\n",
"dict_koordinaten_utm = trafos.ecef_to_utm(\n",
" dict_koordinaten_ausgleichungsergebnis,\n",
" pfad_tif_quasigeoidundolation)\n",
"koordinaten_utm = (dict_koordinaten_utm)\n",
"print(koordinaten_utm)"
],
"id": "844b818e7a3db233",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# 1. Wir nutzen dein existierendes 'dict_koordinaten'\n",
"# Da stehen nur die echten Punkte drin (74 Stück)\n",
"namen = list(dict_koordinaten_ausgleichungsergebnis.keys())\n",
"\n",
"# Die SymPy-Matrizen aus dem Dictionary in flache Listen umwandeln\n",
"koordinaten_liste = []\n",
"for k in namen:\n",
" matrix_werte = dict_koordinaten_ausgleichungsergebnis[k]\n",
" # Umwandlung von SymPy Matrix zu einfachen Floats\n",
" koordinaten_liste.append([float(matrix_werte[0]), float(matrix_werte[1]), float(matrix_werte[2])])\n",
"\n",
"# 2. DataFrame direkt aus der gefilterten Liste erstellen\n",
"# Hier passen index (74) und Daten (74 Zeilen) nun perfekt zusammen!\n",
"df_x_final = pd.DataFrame(koordinaten_liste, columns=['X [m]', 'Y [m]', 'Z [m]'], index=namen)\n",
"df_x_final.index.name = 'Punktnummer'\n",
"\n",
"# 3. UTM-Daten aufbereiten (wie gehabt)\n",
"# Wir stellen sicher, dass wir die Werte aus koordinaten_utm flachklopfen\n",
"utm_flach = {k: np.array(v).flatten().tolist() for k, v in koordinaten_utm.items()}\n",
"df_utm_final = pd.DataFrame.from_dict(utm_flach, orient='index', columns=['Rechtswert [m]', 'Hochwert [m]', 'Höhe [m]'])\n",
"df_utm_final.index.name = 'Punktnummer'\n",
"\n",
"# 4. Zahlenformatierung (Wissenschaftliche Notation unterdrücken)\n",
"df_x_final = df_x_final.map(lambda val: f\"{val:.4f}\")\n",
"df_utm_final = df_utm_final.map(lambda val: f\"{val:.4f}\")\n",
"\n",
"# 5. Export-Dictionary\n",
"ergebnisse = {\n",
" \"df_globaltest\": globaltest,\n",
" \"df_redundanz\": Redundanzanteile,\n",
" \"df_ellipsen\": Standardellipse,\n",
" \"df_konfidenzellipsen\": Konfidenzellipse,\n",
" \"df_koordinaten_geozentrisch_kartesisch\": df_x_final,\n",
" \"df_koordinaten_utm\": df_utm_final\n",
"}\n",
"\n",
"# Für die geozentrischen Koordinaten\n",
"df_x_final.index.name = 'Punktnummer'\n",
"\n",
"# Für die UTM-Koordinaten\n",
"df_utm_final.index.name = 'Punktnummer'"
],
"id": "343b70a659e335f8",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"importlib.reload(Export)\n",
"# Zelle XX: Erzeugung eines Protokolls der hybriden Netzausgleichung\n",
"\n",
"# Input (später: an den Anfang des Notebooks schieben)\n",
"bearbeiter = input(\"Bearbeiter: \")\n",
"projekt = input(\"Projektname: \")\n",
"\n",
"metadaten = {\n",
" \"bearbeiter\": bearbeiter,\n",
" \"projekt\": projekt,\n",
" \"datum\": datetime.now().strftime(\"%d.%m.%Y\")\n",
"}\n",
"\n",
"\n",
"ergebnisse = {\n",
" \"df_globaltest\": globaltest,\n",
" \"df_redundanz\": Redundanzanteile,\n",
" \"df_ellipsen\": Standardellipse,\n",
" \"df_konfidenzellipsen\": Konfidenzellipse,\n",
" \"df_koordinaten_geozentrisch_kartesisch\": df_x_final,\n",
" \"df_koordinaten_utm\": df_utm_final\n",
"\n",
"}\n",
"\n",
"Export.Export.speichere_html_protokoll(metadaten, ergebnisse)"
],
"id": "23aa13721f563c90",
"outputs": [],
"execution_count": null
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.14.0"
}
},
"nbformat": 4,
"nbformat_minor": 5
}