fa2338/Masterprojekt-Campusnetz
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/main'

Browse Source
This commit is contained in:
mi2847
2025-12-13 13:47:54 +01:00
parent dfe31970b4 38eb77d91f
commit 4db713b2da
6 changed files with 3049 additions and 542 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
Campusnetz.db
View File

Binary file not shown.

601
Campusnetz.ipynb
View File

@@ -4,11 +4,7 @@
"cell_type": "code",
"id": "initial_id",
"metadata": {
"collapsed": true,
"ExecuteTime": {
"end_time": "2025-12-10T17:56:08.191585Z",
"start_time": "2025-12-10T17:56:07.832678Z"
}
"collapsed": true
},
"source": [
"# Hier werden alle verwendeten Pythonmodule importiert\n",
@@ -16,18 +12,14 @@
"import Import\n",
"import importlib\n",
"import Koordinatentransformationen\n",
"import sqlite3"
"import sqlite3\n",
"import Funktionales_Modell"
],
"outputs": [],
"execution_count": 1
"execution_count": null
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-12-10T17:56:08.274538Z",
"start_time": "2025-12-10T17:56:08.235850Z"
}
},
"metadata": {},
"cell_type": "code",
"source": [
"importlib.reload(Datenbank)\n",
@@ -42,15 +34,10 @@
],
"id": "82d514cd426db78b",
"outputs": [],
"execution_count": 2
"execution_count": null
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-12-10T17:56:08.297943Z",
"start_time": "2025-12-10T17:56:08.279765Z"
}
},
"metadata": {},
"cell_type": "code",
"source": [
"# Import der Koordinatendatei(en) vom Tachymeter\n",
@@ -58,24 +45,11 @@
"imp.import_koordinaten_lh_tachymeter(pfad_datei)"
],
"id": "d3bce3991a8962dc",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Der Import der Näherungskoordinaten wurde erfolgreich abgeschlossen\n"
]
}
],
"execution_count": 3
"outputs": [],
"execution_count": null
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-12-10T17:56:08.314677Z",
"start_time": "2025-12-10T17:56:08.304360Z"
}
},
"metadata": {},
"cell_type": "code",
"source": [
"importlib.reload(Datenbank)\n",
@@ -84,201 +58,11 @@
"print(db_zugriff.get_koordinaten(\"naeherung_lh\"))"
],
"id": "196ff0c8f8b5aea1",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'10009': Matrix([\n",
"[1000.0],\n",
"[2000.0],\n",
"[ 100.0]]), '10006': Matrix([\n",
"[ 1000.0],\n",
"[2032.6863],\n",
"[ 99.5825]]), '10010': Matrix([\n",
"[1011.8143],\n",
"[1973.3252],\n",
"[ 99.9259]]), '10018': Matrix([\n",
"[1008.5759],\n",
"[ 1942.762],\n",
"[ 100.2553]]), '10008': Matrix([\n",
"[979.7022],\n",
"[1991.401],\n",
"[ 99.732]]), '10005': Matrix([\n",
"[ 966.5154],\n",
"[2014.6496],\n",
"[ 99.72]]), '10003': Matrix([\n",
"[ 908.4312],\n",
"[1996.1248],\n",
"[ 99.7403]]), '10004': Matrix([\n",
"[ 954.1536],\n",
"[2021.6822],\n",
"[ 99.4916]]), '10007': Matrix([\n",
"[ 921.7481],\n",
"[1973.6201],\n",
"[ 99.9176]]), '10001': Matrix([\n",
"[ 833.9439],\n",
"[1978.3737],\n",
"[ 99.8946]]), '10002': Matrix([\n",
"[ 875.9684],\n",
"[1998.5174],\n",
"[ 99.5867]]), '10016': Matrix([\n",
"[ 928.2783],\n",
"[1944.0082],\n",
"[ 100.0459]]), '10011': Matrix([\n",
"[844.9567],\n",
"[1891.157],\n",
"[ 99.8117]]), '10026': Matrix([\n",
"[1020.0059],\n",
"[1913.8703],\n",
"[ 100.3059]]), '10027': Matrix([\n",
"[1016.9451],\n",
"[1866.2914],\n",
"[ 100.3251]]), '10043': Matrix([\n",
"[1031.2077],\n",
"[1822.4739],\n",
"[ 100.3035]]), '10044': Matrix([\n",
"[ 1025.976],\n",
"[1782.4835],\n",
"[ 100.5461]]), '10021': Matrix([\n",
"[ 992.7607],\n",
"[1904.8854],\n",
"[ 100.3533]]), '10020': Matrix([\n",
"[ 984.6187],\n",
"[1903.3601],\n",
"[ 100.3423]]), '10024': Matrix([\n",
"[ 997.4831],\n",
"[1881.7862],\n",
"[ 100.3032]]), '10025': Matrix([\n",
"[996.3241],\n",
"[1866.844],\n",
"[100.4102]]), '10022': Matrix([\n",
"[990.0679],\n",
"[1896.536],\n",
"[100.2194]]), '10023': Matrix([\n",
"[ 987.3223],\n",
"[1889.8762],\n",
"[ 100.343]]), '10019': Matrix([\n",
"[ 962.6387],\n",
"[1902.3565],\n",
"[ 99.9772]]), '10033': Matrix([\n",
"[ 964.0191],\n",
"[1860.8023],\n",
"[ 99.8551]]), '10017': Matrix([\n",
"[ 931.6761],\n",
"[1900.9945],\n",
"[ 99.9572]]), '10052': Matrix([\n",
"[ 1037.875],\n",
"[1757.2999],\n",
"[ 100.2737]]), '10042': Matrix([\n",
"[1017.3489],\n",
"[1803.0742],\n",
"[ 100.3441]]), '10053': Matrix([\n",
"[1033.3758],\n",
"[1723.4258],\n",
"[ 100.2774]]), '10037': Matrix([\n",
"[ 966.2253],\n",
"[1774.2051],\n",
"[ 99.9957]]), '10040': Matrix([\n",
"[ 990.8832],\n",
"[1780.9678],\n",
"[ 100.1677]]), '10041': Matrix([\n",
"[993.2769],\n",
"[1812.031],\n",
"[100.4749]]), '10038': Matrix([\n",
"[ 958.1899],\n",
"[1804.7135],\n",
"[ 100.0741]]), '10051': Matrix([\n",
"[1008.9811],\n",
"[1750.1838],\n",
"[ 100.288]]), '10036': Matrix([\n",
"[ 948.6403],\n",
"[1763.5807],\n",
"[ 100.0063]]), '10035': Matrix([\n",
"[ 910.1265],\n",
"[1768.0099],\n",
"[ 100.0781]]), '10039': Matrix([\n",
"[ 960.3884],\n",
"[1820.0543],\n",
"[ 100.0983]]), '10059': Matrix([\n",
"[1049.2587],\n",
"[1662.5451],\n",
"[ 100.0148]]), '10050': Matrix([\n",
"[1010.0246],\n",
"[1726.2445],\n",
"[ 100.1493]]), '10013': Matrix([\n",
"[900.9076],\n",
"[1902.873],\n",
"[ 99.7911]]), '10028': Matrix([\n",
"[ 853.9608],\n",
"[1815.7417],\n",
"[ 99.7793]]), '10012': Matrix([\n",
"[ 895.3032],\n",
"[1924.1523],\n",
"[ 99.8758]]), '10014': Matrix([\n",
"[ 913.9706],\n",
"[1918.7731],\n",
"[ 99.8872]]), '10031': Matrix([\n",
"[ 937.1557],\n",
"[1855.2805],\n",
"[ 99.8479]]), '10015': Matrix([\n",
"[ 912.5157],\n",
"[1937.6471],\n",
"[ 99.9834]]), '10032': Matrix([\n",
"[ 954.6732],\n",
"[1845.9356],\n",
"[ 99.724]]), '10030': Matrix([\n",
"[ 908.4749],\n",
"[1828.8008],\n",
"[ 99.5581]]), '10029': Matrix([\n",
"[ 909.3343],\n",
"[1814.8767],\n",
"[ 99.5486]]), '10034': Matrix([\n",
"[ 860.2357],\n",
"[1758.9282],\n",
"[ 99.737]]), '10045': Matrix([\n",
"[867.2324],\n",
"[1705.063],\n",
"[ 99.7214]]), '10049': Matrix([\n",
"[ 985.2561],\n",
"[1715.2109],\n",
"[ 99.9965]]), '10048': Matrix([\n",
"[ 957.3889],\n",
"[1716.2949],\n",
"[ 99.7212]]), '10047': Matrix([\n",
"[ 929.5334],\n",
"[1712.6429],\n",
"[ 99.6076]]), '10046': Matrix([\n",
"[ 910.663],\n",
"[1716.0969],\n",
"[ 99.5459]]), '10057': Matrix([\n",
"[969.6876],\n",
"[1655.597],\n",
"[ 99.7039]]), '10055': Matrix([\n",
"[ 922.4731],\n",
"[1647.7452],\n",
"[ 99.4658]]), '10054': Matrix([\n",
"[ 860.4481],\n",
"[1636.6722],\n",
"[ 99.7093]]), '10058': Matrix([\n",
"[1013.2592],\n",
"[1646.6356],\n",
"[ 99.8513]]), '10056': Matrix([\n",
"[ 939.9763],\n",
"[1636.4179],\n",
"[ 99.4027]])}\n"
]
}
],
"execution_count": 4
"outputs": [],
"execution_count": null
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-12-10T17:56:08.325087Z",
"start_time": "2025-12-10T17:56:08.319929Z"
}
},
"metadata": {},
"cell_type": "code",
"source": [
"importlib.reload(Datenbank)\n",
@@ -287,24 +71,11 @@
"print(db_zugriff.get_koordinaten(\"naeherung_us\"))"
],
"id": "3989b7b41874c16a",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{}\n"
]
}
],
"execution_count": 5
"outputs": [],
"execution_count": null
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-12-10T17:56:08.355544Z",
"start_time": "2025-12-10T17:56:08.333320Z"
}
},
"metadata": {},
"cell_type": "code",
"source": [
"# ToDo: Sobald GNSS vorliegend Koordinaten im ETRS89 / DREF 91 (2025) daraus berechnen!\n",
@@ -357,15 +128,10 @@
],
"id": "f64d9c01318b40f1",
"outputs": [],
"execution_count": 6
"execution_count": null
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-12-10T17:56:10.662819Z",
"start_time": "2025-12-10T17:56:08.361074Z"
}
},
"metadata": {},
"cell_type": "code",
"source": [
"# ToDo: Sobald GNSS-Daten vorliegen und die Berechnungen richtig sind, aufräumen!!!\n",
@@ -456,89 +222,11 @@
"transformationsparameter = trafos.Helmerttransformation_Euler_Transformationsparameter_berechne()"
],
"id": "21d60465e432c649",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"d(p2,p1)= 46.60388451996242\n",
"d(P2,P1)= 54.462720048072995\n",
"m0 ~ 1.1686304823956102\n",
"Anzahl Ratios: 6\n",
"min/mean/max: 0.9679784506116116 1.0266943302085056 1.1686304823956102\n",
"std: 0.07473161831852519\n",
"S_loc: Matrix([[925.528400000000], [1883.39492500000], [100.005775000000]])\n",
"S_ecef: Matrix([[3794804.36275000], [546844.659750000], [5080056.51350000]])\n",
"Delta: Matrix([[3.79388e+6], [544961.], [5.07996e+6]])\n",
"10001 0.0936\n",
"10002 0.0873\n",
"10044 0.0527\n",
"10037 0.0477\n",
"Anzahl gemeinsame Punkte: 4\n",
"\n",
"Erste Zielpunkte:\n",
"10001 [3794874.984, 546741.752, 5080029.99]\n",
"10002 [3794842.533, 546726.907, 5080071.133]\n",
"10037 [3794774.148, 546955.423, 5080040.52]\n",
"10044 [3794725.786, 546954.557, 5080084.411]\n",
"\n",
"Erste Ausgangspunkte:\n",
"10001 [833.9439, 1978.3737, 99.8946]\n",
"10002 [875.9684, 1998.5174, 99.5867]\n",
"10037 [966.2253, 1774.2051, 99.9957]\n",
"10044 [1025.976, 1782.4835, 100.5461]\n",
"min/mean/max: 0.9679784506116116 1.0266943302085056 1.1686304823956102\n",
"R ist Orthonormal!\n",
"Iteration Nr.1 abgeschlossen\n",
"Matrix([[-85.7], [-61.5], [188.], [-0.246], [-0.821], [0.00489], [0.406]])\n",
"Iteration Nr.2 abgeschlossen\n",
"Matrix([[241.], [-94.3], [-151.], [0.191], [-0.153], [-0.109], [0.120]])\n",
"Iteration Nr.3 abgeschlossen\n",
"Matrix([[5.71], [5.03], [0.723], [0.00670], [0.0401], [0.0180], [-0.0355]])\n",
"Iteration Nr.4 abgeschlossen\n",
"Matrix([[-2.83], [-1.48], [-2.88], [0.000657], [-0.00186], [0.00135], [0.00102]])\n",
"Iteration Nr.5 abgeschlossen\n",
"Matrix([[0.441], [0.196], [0.417], [6.90e-8], [0.000310], [-0.000257], [-0.000169]])\n",
"Iteration Nr.6 abgeschlossen\n",
"Matrix([[-0.0781], [-0.0348], [-0.0729], [1.91e-9], [-5.48e-5], [4.49e-5], [3.00e-5]])\n",
"Iteration Nr.7 abgeschlossen\n",
"Matrix([[0.0137], [0.00611], [0.0128], [5.92e-11], [9.61e-6], [-7.89e-6], [-5.25e-6]])\n",
"Iteration Nr.8 abgeschlossen\n",
"Matrix([[-0.00241], [-0.00107], [-0.00225], [1.35e-12], [-1.69e-6], [1.39e-6], [9.23e-7]])\n",
"Iteration Nr.9 abgeschlossen\n",
"Matrix([[0.000423], [0.000188], [0.000395], [-4.72e-13], [2.96e-7], [-2.43e-7], [-1.62e-7]])\n",
"Iteration Nr.10 abgeschlossen\n",
"Matrix([[-7.42e-5], [-3.31e-5], [-6.95e-5], [1.10e-12], [-5.21e-8], [4.27e-8], [2.85e-8]])\n",
"Iteration Nr.11 abgeschlossen\n",
"Matrix([[1.30e-5], [5.82e-6], [1.22e-5], [-3.48e-13], [9.15e-9], [-7.51e-9], [-5.00e-9]])\n",
"Matrix([[3.79e+6], [5.47e+5], [5.08e+6], [3.79e+6], [5.47e+5], [5.08e+6], [3.79e+6], [5.47e+5], [5.08e+6], [3.79e+6], [5.47e+5], [5.08e+6]])\n",
"Matrix([[3.79e+6], [5.46e+5], [5.08e+6], [3.79e+6], [5.46e+5], [5.08e+6], [3.79e+6], [5.47e+5], [5.08e+6], [3.79e+6], [5.47e+5], [5.08e+6]])\n",
"x = Matrix([[3.80e+6], [5.48e+5], [5.08e+6], [0.979], [-0.481], [0.677], [3.42]])\n",
"\n",
"l_berechnet_final:\n",
"10001: 3794874.637, 546738.682, 5080033.793\n",
"10002: 3794844.297, 546729.060, 5080066.484\n",
"10037: 3794770.848, 546952.857, 5080042.910\n",
"10044: 3794727.668, 546958.039, 5080082.867\n",
"Streckendifferenzen:\n",
"[4.899982, 5.418896, 4.814927, 4.248968]\n",
"\n",
"Differenz Schwerpunkt (Vektor):\n",
"Matrix([[-4.66e-10], [-2.91e-11], [-4.66e-10]])\n",
"Betrag der Schwerpunkt-Differenz:\n",
"0.000m\n"
]
}
],
"execution_count": 7
"outputs": [],
"execution_count": null
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-12-10T17:56:10.844846Z",
"start_time": "2025-12-10T17:56:10.809175Z"
}
},
"metadata": {},
"cell_type": "code",
"source": [
"importlib.reload(Koordinatentransformationen)\n",
@@ -548,189 +236,11 @@
"print(koordinaten_transformiert)"
],
"id": "df0dcccb73299fcf",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'10003': Matrix([\n",
"[3794820.51175889],\n",
"[546738.121545569],\n",
"[5080085.66027136]]), '10004': Matrix([\n",
"[3794787.68039096],\n",
"[546724.355539902],\n",
"[5080122.57197924]]), '10005': Matrix([\n",
"[3794778.52744143],\n",
"[546733.440239574],\n",
"[5080127.82709672]]), '10006': Matrix([\n",
"[3794754.48961774],\n",
"[546723.992131817],\n",
"[ 5080154.6491784]]), '10007': Matrix([\n",
"[ 3794810.10603],\n",
"[546761.510609237],\n",
"[ 5080086.0020765]]), '10008': Matrix([\n",
"[3794768.08506589],\n",
"[546757.433496855],\n",
"[ 5080127.7145515]]), '10009': Matrix([\n",
"[3794753.66298807],\n",
"[546753.936763795],\n",
"[ 5080143.3866772]]), '10010': Matrix([\n",
"[3794744.05628981],\n",
"[546780.742811981],\n",
"[ 5080141.1636738]]), '10011': Matrix([\n",
"[3794863.58049222],\n",
"[546820.559672293],\n",
"[5080009.68904121]]), '10012': Matrix([\n",
"[3794827.81056398],\n",
"[ 546801.06957277],\n",
"[ 5080052.2764653]]), '10013': Matrix([\n",
"[3794822.93179095],\n",
"[ 546821.6420314],\n",
"[5080048.14190298]]), '10014': Matrix([\n",
"[3794813.94866435],\n",
"[546809.911071387],\n",
"[5080061.83762516]]), '10015': Matrix([\n",
"[3794815.71134214],\n",
"[ 546792.41022388],\n",
"[5080067.67633712]]), '10016': Matrix([\n",
"[3794804.40667566],\n",
"[546789.942078133],\n",
"[5080079.63649543]]), '10017': Matrix([\n",
"[ 3794800.4139096],\n",
"[546829.880936662],\n",
"[5080066.46875977]]), '10018': Matrix([\n",
"[3794745.61855632],\n",
"[546808.043262064],\n",
"[5080128.60455588]]), '10019': Matrix([\n",
"[3794777.76781701],\n",
"[546835.162107796],\n",
"[5080085.96045632]]), '10020': Matrix([\n",
"[3794761.92015664],\n",
"[546838.977847251],\n",
"[5080100.04765691]]), '10021': Matrix([\n",
"[3794756.00797839],\n",
"[546839.303246531],\n",
"[5080105.58935921]]), '10022': Matrix([\n",
"[3794757.61562001],\n",
"[546846.316729031],\n",
"[5080100.89762826]]), '10023': Matrix([\n",
"[3794759.48549621],\n",
"[546851.850918009],\n",
"[5080096.94440005]]), '10024': Matrix([\n",
"[3794751.73730327],\n",
"[546861.360519194],\n",
"[ 5080100.294253]]), '10025': Matrix([\n",
"[3794752.15498749],\n",
"[546874.781453645],\n",
"[5080094.37790759]]), '10026': Matrix([\n",
"[3794736.30003562],\n",
"[546836.826883513],\n",
"[5080125.44708045]]), '10027': Matrix([\n",
"[3794736.96000806],\n",
"[546879.602518143],\n",
"[5080106.77720197]]), '10028': Matrix([\n",
"[3794854.42558972],\n",
"[546891.260466949],\n",
"[5079988.55485218]]), '10029': Matrix([\n",
"[3794813.64192358],\n",
"[546903.641106338],\n",
"[5080022.06775364]]), '10030': Matrix([\n",
"[3794814.74562118],\n",
"[546890.757518605],\n",
"[5080026.46489654]]), '10031': Matrix([\n",
"[3794794.79058969],\n",
"[ 546872.71612651],\n",
"[5080053.61063449]]), '10032': Matrix([\n",
"[3794781.55115635],\n",
"[546884.895506778],\n",
"[5080060.97408994]]), '10033': Matrix([\n",
"[3794775.28175346],\n",
"[546873.334968714],\n",
"[5080072.04785473]]), '10034': Matrix([\n",
"[3794847.88993759],\n",
"[546944.410223245],\n",
"[5079972.30963836]]), '10035': Matrix([\n",
"[3794811.83097489],\n",
"[546946.723835994],\n",
"[5080006.35848061]]), '10036': Matrix([\n",
"[3794783.39377131],\n",
"[546958.852789368],\n",
"[5080028.37568321]]), '10038': Matrix([\n",
"[3794777.81558632],\n",
"[546923.349922253],\n",
"[5080048.80883121]]), '10039': Matrix([\n",
"[3794776.73400961],\n",
"[546909.821579998],\n",
"[5080055.59246981]]), '10040': Matrix([\n",
"[3794753.10534012],\n",
"[546951.926584076],\n",
"[5080060.54410929]]), '10041': Matrix([\n",
"[3794752.59165627],\n",
"[546924.173873934],\n",
"[5080073.19205182]]), '10042': Matrix([\n",
"[ 3794734.5543882],\n",
"[546937.377006367],\n",
"[ 5080084.7094339]]), '10043': Matrix([\n",
"[3794725.01661161],\n",
"[546922.581244633],\n",
"[5080100.03703997]]), '10045': Matrix([\n",
"[3794840.94124498],\n",
"[546995.029310828],\n",
"[5079957.56668261]]), '10046': Matrix([\n",
"[3794809.35039725],\n",
"[546994.054056815],\n",
"[5079987.99204381]]), '10047': Matrix([\n",
"[ 3794795.4368399],\n",
"[547001.195960895],\n",
"[5079998.39175117]]), '10048': Matrix([\n",
"[3794775.20666754],\n",
"[ 547003.76019026],\n",
"[5080016.84921095]]), '10049': Matrix([\n",
"[3794754.91370463],\n",
"[ 547010.69453884],\n",
"[5080033.75043702]]), '10050': Matrix([\n",
"[3794737.22036781],\n",
"[547005.884569236],\n",
"[ 5080052.9475627]]), '10051': Matrix([\n",
"[3794738.87891047],\n",
"[546983.860512271],\n",
"[5080060.85649738]]), '10052': Matrix([\n",
"[3794717.92069948],\n",
"[ 546983.44591806],\n",
"[5080081.08810058]]), '10053': Matrix([\n",
"[3794720.08539271],\n",
"[547013.409039769],\n",
"[ 5080066.3657566]]), '10054': Matrix([\n",
"[3794843.61283972],\n",
"[547056.002453676],\n",
"[5079929.24030295]]), '10055': Matrix([\n",
"[ 3794798.3440481],\n",
"[547058.886596772],\n",
"[5079971.04209003]]), '10056': Matrix([\n",
"[3794785.08794943],\n",
"[547072.889218702],\n",
"[5079977.73770134]]), '10057': Matrix([\n",
"[3794764.13960343],\n",
"[ 547061.72963122],\n",
"[5080002.94483388]]), '10058': Matrix([\n",
"[3794731.98341087],\n",
"[547079.121468109],\n",
"[5080026.61270465]]), '10059': Matrix([\n",
"[3794706.22500851],\n",
"[547072.229773112],\n",
"[5080054.43002136]])}\n"
]
}
],
"execution_count": 8
"outputs": [],
"execution_count": null
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-12-10T17:56:10.872837Z",
"start_time": "2025-12-10T17:56:10.853910Z"
}
},
"metadata": {},
"cell_type": "code",
"source": [
"importlib.reload(Datenbank)\n",
@@ -740,15 +250,10 @@
],
"id": "f6993d81c8a145dd",
"outputs": [],
"execution_count": 9
"execution_count": null
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-12-10T17:56:10.904556Z",
"start_time": "2025-12-10T17:56:10.882418Z"
}
},
"metadata": {},
"cell_type": "code",
"source": [
"# Importieren der tachymetrischen Beobachtungen\n",
@@ -760,26 +265,42 @@
"db_zugriff.get_instrument(\"Tachymeter\")"
],
"id": "e376b4534297016c",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Das Instrument Trimble S9 wurde erfolgreich hinzugefügt.\n"
]
},
{
"data": {
"text/plain": [
"[(1, 'Tachymeter', 'Trimble S9')]"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Importieren der tachymetrischen Beobachtungen\n",
"importlib.reload(Import)\n",
"imp = Import.Import(pfad_datenbank)\n",
"\n",
"pfad_datei_tachymeterbeobachtungen = r\"Daten\\campsnetz_beobachtungen_bereinigt.csv\"\n",
"\n",
"imp.import_beobachtungen_tachymeter(pfad_datei_tachymeterbeobachtungen, 1)"
],
"execution_count": 10
"id": "509e462917e98145",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Jacobimatrix aufstellen\n",
"importlib.reload(Datenbank)\n",
"db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
"\n",
"importlib.reload(Funktionales_Modell)\n",
"fm = Funktionales_Modell.FunktionalesModell(pfad_datenbank)\n",
"\n",
"#db_zugriff.get_beobachtungen_id_standpunkt_zielpunkt(\"tachymeter_distanz\")\n",
"fm.jacobi_matrix_symbolisch()"
],
"id": "d38939f7108e1788",
"outputs": [],
"execution_count": null
}
],
"metadata": {

10
Datenbank.py
View File

@@ -123,4 +123,12 @@ class Datenbankzugriff:
con.close()
if liste_instrumente == []:
liste_instrumente = f"Kein Instrument vom Typ {typ} gefunden. Folgende Typen stehen aktuell zur Auswahl: {liste_typen}"
return liste_instrumente
return liste_instrumente
def get_beobachtungen_id_beobachtungsgruppe_standpunkt_zielpunkt(self, beobachtungsart):
con = sqlite3.connect(self.pfad_datenbank)
cursor = con.cursor()
liste_beobachtungen = cursor.execute(f"SELECT beobachtungenID, beobachtungsgruppeID, punktnummer_sp, punktnummer_zp FROM Beobachtungen WHERE {beobachtungsart} IS NOT NULL").fetchall()
cursor.close()
con.close()
return liste_beobachtungen

185
Funktionales_Modell.py
View File

@@ -0,0 +1,185 @@
from Datenbank import *
import sympy as sp
import csv
class FunktionalesModell:
def __init__(self, pfad_datenbank):
self.pfad_datenbank = pfad_datenbank
def jacobi_matrix_symbolisch(self):
liste_beobachtungsarten = ["tachymeter_distanz", "tachymeter_richtung", "tachymeter_zenitwinkel"]
db_zugriff = Datenbankzugriff(self.pfad_datenbank)
liste_beobachtungen_rohdaten = []
liste_punktnummern =[]
liste_beobachtungen_jacobian = []
liste_orientierungsunbekannte = []
liste_beobachtungsgleichungen_jacobian = []
liste_beobachtungsgleichungen_abgeleitet = []
liste_beobachtungen_abgeleitet = []
liste_zeilenbeschriftungen_jacobian = []
liste_zeilenbeschriftungen_abgeleitet = []
for beobachtungsart in liste_beobachtungsarten:
liste_id_standpunkt_zielpunkt = db_zugriff.get_beobachtungen_id_beobachtungsgruppe_standpunkt_zielpunkt(beobachtungsart)
for beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt in liste_id_standpunkt_zielpunkt:
liste_beobachtungen_rohdaten.append(
(beobachtungsart, beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt)
)
if standpunkt not in liste_punktnummern:
liste_punktnummern.append(standpunkt)
if zielpunkt not in liste_punktnummern:
liste_punktnummern.append(zielpunkt)
if beobachtungsart == "tachymeter_richtung":
if beobachtungsgruppeID not in liste_orientierungsunbekannte:
liste_orientierungsunbekannte.append(beobachtungsgruppeID)
if liste_beobachtungen_rohdaten == []:
return None
dict_punkt_symbole = {}
liste_unbekannte = []
for punkt in liste_punktnummern:
X, Y, Z = sp.symbols(f"X{punkt} Y{punkt} Z{punkt}")
dict_punkt_symbole[punkt] = (X, Y, Z)
liste_unbekannte.append(X)
liste_unbekannte.append(Y)
liste_unbekannte.append(Z)
dict_orientierung_symbole = {}
for orientierungsunbekannte in liste_orientierungsunbekannte:
O = sp.symbols(f"O{orientierungsunbekannte}")
dict_orientierung_symbole[orientierungsunbekannte] = O
liste_unbekannte.append(O)
liste_beobachtungsgleichungen_distanz =[]
liste_zeilenbeschriftungen_distanz = []
liste_A_richtung_zeilen = []
liste_zeilenbeschriftungen_richtung = []
for beobachtungsart, beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt in liste_beobachtungen_rohdaten:
X_sp, Y_sp, Z_sp = dict_punkt_symbole[standpunkt]
X_zp, Y_zp, Z_zp = dict_punkt_symbole[zielpunkt]
B_sp, L_sp = sp.symbols(f"B{standpunkt} L{standpunkt}")
alpha = sp.symbols(f"alpha{standpunkt}_{zielpunkt}")
zw = sp.symbols(f"zw{standpunkt}_{zielpunkt}")
s = sp.symbols(f"s{standpunkt}_{zielpunkt}")
if beobachtungsart == "tachymeter_distanz":
beobachtungsgleichung = sp.sqrt(
(X_zp - X_sp) ** 2
+ (Y_zp - Y_sp) ** 2
+ (Z_zp - Z_sp) ** 2
)
liste_beobachtungsgleichungen_distanz.append(beobachtungsgleichung)
liste_zeilenbeschriftungen_distanz.append(f"SD {beobachtungsgruppeID} {standpunkt}-{zielpunkt}")
if beobachtungsart == "tachymeter_richtung":
#for beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt in liste_id_standpunkt_zielpunkt:
d_r_dX_zp = ((sp.sin(B_sp)*sp.cos(L_sp)*sp.sin(alpha) - sp.sin(L_sp)*sp.cos(alpha)) / (s * sp.sin(zw)))
d_r_dX_sp = - d_r_dX_zp
d_r_dY_zp = ((sp.sin(B_sp)*sp.sin(L_sp)*sp.sin(alpha) + sp.cos(L_sp)*sp.cos(alpha)) / (s * sp.sin(zw)))
d_r_dY_sp = - d_r_dY_zp
d_r_dZ_zp = ((-sp.cos(B_sp) * sp.sin(alpha) / (s * sp.sin(zw))))
d_r_dZ_sp = - d_r_dZ_zp
d_r_dO_sp = -1
zeile_A_Matrix = []
for punkt in liste_punktnummern:
if punkt == standpunkt:
zeile_A_Matrix.extend([d_r_dX_sp, d_r_dY_sp, d_r_dZ_sp])
elif punkt == zielpunkt:
zeile_A_Matrix.extend([d_r_dX_zp, d_r_dY_zp, d_r_dZ_zp])
else:
zeile_A_Matrix.extend([0, 0, 0])
for orientierung in liste_orientierungsunbekannte:
if orientierung == beobachtungsgruppeID:
zeile_A_Matrix.append(d_r_dO_sp)
else:
zeile_A_Matrix.append(0)
liste_A_richtung_zeilen.append(zeile_A_Matrix)
liste_zeilenbeschriftungen_richtung.append(
f"R {beobachtungsgruppeID} {standpunkt}-{zielpunkt}"
)
if beobachtungsart == "tachymeter_zenitwinkel":
d_r_dX_zp = ((X_zp - X_sp) * sp.cos(zw) - s * sp.cos(B_sp) * sp.cos(L_sp)) / (s ** 2 * sp.sin(zw))
d_r_dX_sp = - d_r_dX_zp
d_r_dY_zp = ((Y_zp - Y_sp) * sp.cos(zw) - s * sp.cos(B_sp) * sp.sin(L_sp)) / (s ** 2 * sp.sin(zw))
d_r_dY_sp = - d_r_dY_zp
d_r_dZ_zp = ((Z_zp - Z_sp) * sp.cos(zw) - s * sp.sin(B_sp)) / (s ** 2 * sp.sin(zw))
d_r_dZ_sp = - d_r_dZ_zp
zeile_A_Matrix = []
for punkt in liste_punktnummern:
if punkt == standpunkt:
zeile_A_Matrix.extend([d_r_dX_sp, d_r_dY_sp, d_r_dZ_sp])
elif punkt == zielpunkt:
zeile_A_Matrix.extend([d_r_dX_zp, d_r_dY_zp, d_r_dZ_zp])
else:
zeile_A_Matrix.extend([0, 0, 0])
for orientierung in liste_orientierungsunbekannte:
zeile_A_Matrix.append(0)
liste_A_richtung_zeilen.append(zeile_A_Matrix)
liste_zeilenbeschriftungen_richtung.append(
f"ZW {beobachtungsgruppeID} {standpunkt}-{zielpunkt}"
)
if liste_beobachtungsgleichungen_distanz:
f_matrix_dist = sp.Matrix(liste_beobachtungsgleichungen_distanz)
unbekanntenvektor = sp.Matrix(liste_unbekannte)
A_dist = f_matrix_dist.jacobian(unbekanntenvektor)
else:
A_dist = None
if liste_A_richtung_zeilen:
A_richtung = sp.Matrix(liste_A_richtung_zeilen)
else:
A_richtung = None
if A_dist is not None and A_richtung is not None:
A_gesamt = A_dist.col_join(A_richtung)
liste_zeilenbeschriftungen_gesamt = (
liste_zeilenbeschriftungen_distanz + liste_zeilenbeschriftungen_richtung
)
elif A_dist is not None:
A_gesamt = A_dist
liste_zeilenbeschriftungen_gesamt = liste_zeilenbeschriftungen_distanz
elif A_richtung is not None:
A_gesamt = A_richtung
liste_zeilenbeschriftungen_gesamt = liste_zeilenbeschriftungen_richtung
else:
return None
# --- Export der A_jacobian-Matrix in eine CSV-Datei ---
dateiname_export = "Jacobi_Matrix.csv"
with open(dateiname_export, "w", newline="", encoding="utf-8") as csvfile:
writer = csv.writer(csvfile, delimiter=";")
# Kopfzeile: leere Ecke + Namen der Unbekannten
kopfzeile = ["Beobachtung"]
for unbekannte in liste_unbekannte:
kopfzeile.append(str(unbekannte))
writer.writerow(kopfzeile)
# Zeilen: Standpunkt-Zielpunkt + Jacobimatrix-Zeile
for zeilenbeschriftung, zeile in zip(liste_zeilenbeschriftungen_gesamt, A_gesamt.tolist()):
zeile_als_text = [zeilenbeschriftung] + [str(eintrag) for eintrag in zeile]
writer.writerow(zeile_als_text)
return A_gesamt

166
Import.py
View File

@@ -1,5 +1,6 @@
import csv
import sqlite3
from decimal import Decimal
class Import:
def __init__(self, pfad_datenbank):
@@ -10,6 +11,10 @@ class Import:
zahl = zahl.replace(',', '.')
return float(zahl)
def string_to_decimal(self, zahl):
zahl = zahl.replace(',', '.')
return Decimal(zahl)
def import_koordinaten_lh_tachymeter(self, pfad_datei):
liste_punktnummern = []
liste_punktnummern_vorher = []
@@ -54,4 +59,163 @@ class Import:
con.commit()
cursor.close()
con.close()
print("Der Import der Näherungskoordinaten wurde erfolgreich abgeschlossen")
print("Der Import der Näherungskoordinaten wurde erfolgreich abgeschlossen")
def import_beobachtungen_tachymeter(self, pfad_datei, instrumentenID):
# Prüfen, ob Bereits Daten aus der Datei in der Datenbank vorhanden sind
con = sqlite3.connect(self.pfad_datenbank)
cursor = con.cursor()
liste_dateinamen_in_db = [r[0] for r in cursor.execute(
"SELECT DISTINCT dateiname FROM Beobachtungen"
).fetchall()]
liste_beobachtungsgruppeID = [r[0] for r in cursor.execute("""SELECT DISTINCT beobachtungsgruppeID
FROM Beobachtungen""").fetchall()]
liste_instrumentenid = [r[0] for r in cursor.execute("SELECT instrumenteID FROM Instrumente").fetchall()]
con.close()
cursor.close
Import_fortsetzen = True
if pfad_datei in liste_dateinamen_in_db:
Import_fortsetzen = False
if Import_fortsetzen:
nummer_zielpunkt = 0
try:
nummer_beobachtungsgruppeID = max(liste_beobachtungsgruppeID)
except:
nummer_beobachtungsgruppeID = 0
with (open(pfad_datei, "r", encoding="utf-8") as f):
liste_fehlerhafte_zeile = []
liste_beobachtungen_vorbereitung = []
for i, zeile in enumerate(f):
if i < 3:
continue
zeile = zeile.strip().split(";")
if zeile[1] == "" and zeile[2] == "" and zeile[3] == "":
nummer_beobachtungsgruppeID += 1
# print("Standpunkt: ",nummer_beobachtungsgruppeID ,zeile[0])
standpunkt = zeile[0]
if nummer_zielpunkt % 6 != 0:
liste_fehlerhafte_zeile.append(i)
nummer_zielpunkt = 0
liste_zielpunkte_hs = []
liste_zielpunkte_vs2 = []
liste_zielpunkte_vs3 = []
else:
nummer_zielpunkt += 1
if zeile[0] not in liste_zielpunkte_hs:
liste_zielpunkte_hs.append(zeile[0])
if zeile[0] in liste_zielpunkte_vs3:
# print(f"{nummer_zielpunkt} VS3 HS1 {zeile}")
liste_beobachtungen_vorbereitung.append(
[nummer_beobachtungsgruppeID, "VS3", "HS1", standpunkt, zeile[0], zeile[1],
zeile[2], zeile[3]])
elif zeile[0] in liste_zielpunkte_vs2:
# print(f"{nummer_zielpunkt} VS2 HS1 {zeile}")
liste_beobachtungen_vorbereitung.append(
[nummer_beobachtungsgruppeID, "VS2", "HS1", standpunkt, zeile[0], zeile[1],
zeile[2], zeile[3]])
else:
# print(f"{nummer_zielpunkt} VS1 HS1 {zeile}")
liste_beobachtungen_vorbereitung.append(
[nummer_beobachtungsgruppeID, "VS1", "HS1", standpunkt, zeile[0], zeile[1],
zeile[2],
zeile[3]])
else:
liste_zielpunkte_hs.remove(zeile[0])
if zeile[0] in liste_zielpunkte_vs3:
# print(f"{nummer_zielpunkt} VS3 HS2 {zeile}")
liste_beobachtungen_vorbereitung.append(
[nummer_beobachtungsgruppeID, "VS3", "HS2", standpunkt, zeile[0], zeile[1],
zeile[2],
zeile[3]])
elif zeile[0] in liste_zielpunkte_vs2:
if zeile[0] not in liste_zielpunkte_vs3:
liste_zielpunkte_vs3.append(zeile[0])
# print(f"{nummer_zielpunkt} VS2 HS2 {zeile}")
liste_beobachtungen_vorbereitung.append(
[nummer_beobachtungsgruppeID, "VS2", "HS2", standpunkt, zeile[0], zeile[1],
zeile[2],
zeile[3]])
else:
if zeile[0] not in liste_zielpunkte_vs2:
liste_zielpunkte_vs2.append(zeile[0])
# print(f"{nummer_zielpunkt} VS1 HS2 {zeile}")
liste_beobachtungen_vorbereitung.append(
[nummer_beobachtungsgruppeID, "VS1", "HS2", standpunkt, zeile[0], zeile[1],
zeile[2],
zeile[3]])
if liste_fehlerhafte_zeile == []:
# print(f"Einlesen der Datei {pfad_datei} erfolgreich beendet.")
pass
else:
print(
f"Das Einlesen der Datei {pfad_datei} wurde abgebrochen.\nBitte bearbeiten Sie die Zeilen rund um: {", ".join(map(str, liste_fehlerhafte_zeile))} in der csv-Datei und wiederholen Sie den Import.")
Import_fortsetzen = False
else:
print(
f"Der Import wurde abgebrochen, weil die Beobachtungen aus der Datei {pfad_datei} bereits in der Datenbank vorhanden sind.")
if Import_fortsetzen:
liste_beobachtungen_import = []
while len(liste_beobachtungen_vorbereitung) > 0:
liste_aktueller_zielpunkt = liste_beobachtungen_vorbereitung[0]
aktueller_zielpunkt = liste_aktueller_zielpunkt[4]
# print(liste_beobachtungen_vorbereitung[0])
for index in range(1, len(liste_beobachtungen_vorbereitung)):
liste = liste_beobachtungen_vorbereitung[index]
if liste[4] == aktueller_zielpunkt:
# print(liste)
richtung1 = self.string_to_decimal(liste_aktueller_zielpunkt[5])
richtung2 = self.string_to_decimal(liste[5]) - Decimal(200)
zenitwinkel_vollsatz = (self.string_to_decimal(liste_aktueller_zielpunkt[6]) - self.string_to_decimal(
liste[6]) + 400) / 2
distanz_vollsatz = (self.string_to_decimal(liste_aktueller_zielpunkt[7]) + self.string_to_decimal(
liste[7])) / 2
if richtung2 < 0:
richtung2 += Decimal(400)
elif richtung2 > 400:
richtung2 -= Decimal(400)
richtung_vollsatz = (richtung1 + richtung2) / 2
# print(richtung_vollsatz)
# print(zenitwinkel_vollsatz)
# print(distanz_vollsatz)
liste_beobachtungen_import.append(
[liste[0], liste[3], liste[4], richtung_vollsatz, zenitwinkel_vollsatz, distanz_vollsatz])
del liste_beobachtungen_vorbereitung[index]
del liste_beobachtungen_vorbereitung[0]
break
if instrumentenID not in liste_instrumentenid:
Import_fortsetzen = False
print(
"Der Import wurde abgebrochen. Bitte eine gültige InstrumentenID eingeben. Bei Bedarf ist das Instrument neu anzulegen.")
if Import_fortsetzen:
con = sqlite3.connect(self.pfad_datenbank)
cursor = con.cursor()
for beobachtung_import in liste_beobachtungen_import:
cursor.execute(
"INSERT INTO Beobachtungen (punktnummer_sp, punktnummer_zp, instrumenteID, beobachtungsgruppeID, tachymeter_richtung, tachymeter_zenitwinkel, tachymeter_distanz, dateiname) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
(beobachtung_import[1], beobachtung_import[2], instrumentenID, beobachtung_import[0],
float(beobachtung_import[3]), float(beobachtung_import[4]), float(beobachtung_import[5]),
pfad_datei))
con.commit()
cursor.close()
con.close()
print(f"Der Import der Datei {pfad_datei} wurde erfolgreich abgeschlossen.")

2629
Jacobi_Matrix.csv Normal file
View File

File diff suppressed because it is too large Load Diff