diff --git a/README.md b/README.md
index edf4aec..dd9dda5 100644
--- a/README.md
+++ b/README.md
@@ -44,6 +44,14 @@ Ein vollständiges Python-Programm mit grafischer Benutzeroberfläche (GUI) für
- Residuen
- Qualitätsparametern (Sigma-0, Chi-Quadrat, RMSE)
+### 6. Referenzpunkt-Anpassung (NEU)
+- Anpassung des Referenzpunktes 5001 (bei Referenzlinien-Stationierung)
+- Eingabe neuer Koordinaten (X, Y, Z) für den Referenzpunkt
+- Automatische Neuberechnung aller abhängigen Punkte
+- Vorschau der Transformation mit allen betroffenen Punkten
+- Export der transformierten JXL-Datei
+- Validierung der Eingaben mit Warnungen bei problematischen Werten
+
## Installation
### Voraussetzungen
@@ -54,6 +62,14 @@ Ein vollständiges Python-Programm mit grafischer Benutzeroberfläche (GUI) für
- lxml
### Installation der Abhängigkeiten
+
+**Option 1: Mit requirements.txt (empfohlen)**
+```bash
+cd /home/ubuntu/trimble_geodesy
+pip install -r requirements.txt
+```
+
+**Option 2: Manuelle Installation**
```bash
pip install PyQt5 numpy scipy lxml
```
@@ -72,20 +88,23 @@ python3 main.py
3. **Transformation Tab**: Koordinatensystem rotieren/verschieben
4. **Georeferenzierung Tab**: Mit Passpunkten transformieren
5. **Netzausgleichung Tab**: Netzausgleichung durchführen
+6. **Referenzpunkt anpassen Tab**: Referenzpunkt 5001 ändern und JXL neu berechnen
## Dateistruktur
```
trimble_geodesy/
-├── main.py # Hauptprogramm mit GUI
+├── main.py # Hauptprogramm mit GUI
+├── requirements.txt # Python-Abhängigkeiten
├── modules/
│ ├── __init__.py
-│ ├── jxl_parser.py # JXL-Datei Parser
-│ ├── cor_generator.py # COR-Datei Generator
-│ ├── transformation.py # Koordinatentransformation
-│ ├── georeferencing.py # Georeferenzierung
-│ └── network_adjustment.py # Netzausgleichung
-├── output/ # Ausgabeverzeichnis
+│ ├── jxl_parser.py # JXL-Datei Parser
+│ ├── cor_generator.py # COR-Datei Generator
+│ ├── transformation.py # Koordinatentransformation
+│ ├── georeferencing.py # Georeferenzierung
+│ ├── network_adjustment.py # Netzausgleichung
+│ └── reference_point_adjuster.py # Referenzpunkt-Anpassung (NEU)
+├── output/ # Ausgabeverzeichnis
└── README.md
```
diff --git a/main.py b/main.py
index 60e7a0f..f55bffe 100644
--- a/main.py
+++ b/main.py
@@ -28,6 +28,7 @@ from modules.cor_generator import CORGenerator, CORPoint
from modules.transformation import CoordinateTransformer, LocalSystemTransformer
from modules.georeferencing import Georeferencer, ControlPoint
from modules.network_adjustment import NetworkAdjustment
+from modules.reference_point_adjuster import ReferencePointAdjuster, TransformationResult
class JXLAnalysisTab(QWidget):
@@ -948,6 +949,280 @@ class NetworkAdjustmentTab(QWidget):
QMessageBox.information(self, "Erfolg", f"Koordinaten gespeichert: {file_path}")
+class ReferencePointAdjusterTab(QWidget):
+ """Tab für Referenzpunkt-Anpassung"""
+
+ def __init__(self, parent=None):
+ super().__init__(parent)
+ self.main_window = parent
+ self.adjuster = ReferencePointAdjuster()
+ self.setup_ui()
+
+ def setup_ui(self):
+ layout = QVBoxLayout(self)
+
+ # Info-Gruppe
+ info_group = QGroupBox("Aktueller Referenzpunkt")
+ info_layout = QFormLayout(info_group)
+
+ self.ref_point_name = QLabel("Nicht geladen")
+ self.ref_point_name.setStyleSheet("font-weight: bold; font-size: 14px;")
+ info_layout.addRow("Punktname:", self.ref_point_name)
+
+ self.current_east = QLabel("0.000")
+ self.current_north = QLabel("0.000")
+ self.current_elev = QLabel("0.000")
+
+ info_layout.addRow("East (X):", self.current_east)
+ info_layout.addRow("North (Y):", self.current_north)
+ info_layout.addRow("Elevation (Z):", self.current_elev)
+
+ refresh_btn = QPushButton("Referenzpunkt aktualisieren")
+ refresh_btn.clicked.connect(self.load_reference_point)
+ info_layout.addRow("", refresh_btn)
+
+ layout.addWidget(info_group)
+
+ # Neue Koordinaten Gruppe
+ new_coords_group = QGroupBox("Neue Koordinaten für Referenzpunkt")
+ new_coords_layout = QGridLayout(new_coords_group)
+
+ new_coords_layout.addWidget(QLabel("East (X):"), 0, 0)
+ self.new_east_spin = QDoubleSpinBox()
+ self.new_east_spin.setRange(-10000000, 10000000)
+ self.new_east_spin.setDecimals(4)
+ self.new_east_spin.setSuffix(" m")
+ new_coords_layout.addWidget(self.new_east_spin, 0, 1)
+
+ new_coords_layout.addWidget(QLabel("North (Y):"), 1, 0)
+ self.new_north_spin = QDoubleSpinBox()
+ self.new_north_spin.setRange(-10000000, 10000000)
+ self.new_north_spin.setDecimals(4)
+ self.new_north_spin.setSuffix(" m")
+ new_coords_layout.addWidget(self.new_north_spin, 1, 1)
+
+ new_coords_layout.addWidget(QLabel("Elevation (Z):"), 2, 0)
+ self.new_elev_spin = QDoubleSpinBox()
+ self.new_elev_spin.setRange(-10000, 10000)
+ self.new_elev_spin.setDecimals(4)
+ self.new_elev_spin.setSuffix(" m")
+ new_coords_layout.addWidget(self.new_elev_spin, 2, 1)
+
+ # Translation anzeigen
+ new_coords_layout.addWidget(QLabel(""), 3, 0)
+ self.delta_label = QLabel("ΔX: 0.000 m | ΔY: 0.000 m | ΔZ: 0.000 m")
+ self.delta_label.setStyleSheet("color: blue;")
+ new_coords_layout.addWidget(self.delta_label, 4, 0, 1, 2)
+
+ # Koordinaten-Änderungen live berechnen
+ self.new_east_spin.valueChanged.connect(self.update_delta)
+ self.new_north_spin.valueChanged.connect(self.update_delta)
+ self.new_elev_spin.valueChanged.connect(self.update_delta)
+
+ layout.addWidget(new_coords_group)
+
+ # Aktionen
+ actions_group = QGroupBox("Aktionen")
+ actions_layout = QHBoxLayout(actions_group)
+
+ preview_btn = QPushButton("Vorschau berechnen")
+ preview_btn.clicked.connect(self.preview_transformation)
+ preview_btn.setStyleSheet("background-color: #4CAF50; color: white;")
+ actions_layout.addWidget(preview_btn)
+
+ apply_btn = QPushButton("Transformation anwenden")
+ apply_btn.clicked.connect(self.apply_transformation)
+ apply_btn.setStyleSheet("background-color: #2196F3; color: white;")
+ actions_layout.addWidget(apply_btn)
+
+ export_btn = QPushButton("Neue JXL exportieren")
+ export_btn.clicked.connect(self.export_jxl)
+ export_btn.setStyleSheet("background-color: #FF9800; color: white;")
+ actions_layout.addWidget(export_btn)
+
+ layout.addWidget(actions_group)
+
+ # Vorschau-Tabelle
+ preview_group = QGroupBox("Vorschau der betroffenen Punkte")
+ preview_layout = QVBoxLayout(preview_group)
+
+ self.preview_table = QTableWidget()
+ self.preview_table.setColumnCount(7)
+ self.preview_table.setHorizontalHeaderLabels(
+ ["Punkt", "Alt X", "Alt Y", "Alt Z", "Neu X", "Neu Y", "Neu Z"])
+ self.preview_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+ preview_layout.addWidget(self.preview_table)
+
+ layout.addWidget(preview_group)
+
+ # Bericht
+ report_group = QGroupBox("Transformationsbericht")
+ report_layout = QVBoxLayout(report_group)
+
+ self.report_text = QTextEdit()
+ self.report_text.setReadOnly(True)
+ self.report_text.setFont(QFont("Courier", 9))
+ report_layout.addWidget(self.report_text)
+
+ layout.addWidget(report_group)
+
+ def load_reference_point(self):
+ """Lädt die Informationen zum Referenzpunkt"""
+ if not self.main_window.parser:
+ QMessageBox.warning(self, "Fehler",
+ "Bitte zuerst eine JXL-Datei im 'JXL-Analyse' Tab laden!")
+ return
+
+ self.adjuster.set_parser(self.main_window.parser)
+ info = self.adjuster.get_reference_point_info()
+
+ if not info["found"]:
+ QMessageBox.warning(self, "Fehler",
+ f"Referenzpunkt nicht gefunden: {info['message']}")
+ return
+
+ self.ref_point_name.setText(info["name"])
+ self.current_east.setText(f"{info['east']:.4f} m")
+ self.current_north.setText(f"{info['north']:.4f} m")
+ self.current_elev.setText(f"{info['elevation']:.4f} m")
+
+ # Setze aktuelle Werte als Standard für neue Koordinaten
+ self.new_east_spin.setValue(info['east'])
+ self.new_north_spin.setValue(info['north'])
+ self.new_elev_spin.setValue(info['elevation'])
+
+ self.main_window.statusBar().showMessage(
+ f"Referenzpunkt '{info['name']}' geladen")
+
+ def update_delta(self):
+ """Aktualisiert die Anzeige der Verschiebung"""
+ if not self.adjuster.parser:
+ return
+
+ dx = self.new_east_spin.value() - self.adjuster.original_coords[0]
+ dy = self.new_north_spin.value() - self.adjuster.original_coords[1]
+ dz = self.new_elev_spin.value() - self.adjuster.original_coords[2]
+
+ self.delta_label.setText(
+ f"ΔX: {dx:+.4f} m | ΔY: {dy:+.4f} m | ΔZ: {dz:+.4f} m")
+
+ def preview_transformation(self):
+ """Zeigt eine Vorschau der Transformation"""
+ if not self.main_window.parser:
+ QMessageBox.warning(self, "Fehler",
+ "Bitte zuerst eine JXL-Datei laden!")
+ return
+
+ # Validierung
+ valid, message = self.adjuster.validate_input(
+ self.new_east_spin.value(),
+ self.new_north_spin.value(),
+ self.new_elev_spin.value()
+ )
+
+ if not valid:
+ reply = QMessageBox.warning(self, "Warnung",
+ f"Mögliche Probleme erkannt:\n\n{message}\n\nTrotzdem fortfahren?",
+ QMessageBox.Yes | QMessageBox.No)
+ if reply == QMessageBox.No:
+ return
+
+ self.adjuster.set_new_coordinates(
+ self.new_east_spin.value(),
+ self.new_north_spin.value(),
+ self.new_elev_spin.value()
+ )
+
+ results = self.adjuster.preview_transformation()
+
+ # Tabelle aktualisieren
+ self.preview_table.setRowCount(len(results))
+ for i, result in enumerate(results):
+ self.preview_table.setItem(i, 0, QTableWidgetItem(result.original_point))
+ self.preview_table.setItem(i, 1, QTableWidgetItem(f"{result.original_coords[0]:.4f}"))
+ self.preview_table.setItem(i, 2, QTableWidgetItem(f"{result.original_coords[1]:.4f}"))
+ self.preview_table.setItem(i, 3, QTableWidgetItem(f"{result.original_coords[2]:.4f}"))
+ self.preview_table.setItem(i, 4, QTableWidgetItem(f"{result.new_coords[0]:.4f}"))
+ self.preview_table.setItem(i, 5, QTableWidgetItem(f"{result.new_coords[1]:.4f}"))
+ self.preview_table.setItem(i, 6, QTableWidgetItem(f"{result.new_coords[2]:.4f}"))
+
+ # Bericht aktualisieren
+ self.report_text.setText(self.adjuster.get_summary_report())
+
+ self.main_window.statusBar().showMessage(
+ f"Vorschau berechnet: {len(results)} Punkte betroffen")
+
+ def apply_transformation(self):
+ """Wendet die Transformation auf die JXL-Datei an"""
+ if not self.main_window.parser:
+ QMessageBox.warning(self, "Fehler",
+ "Bitte zuerst eine JXL-Datei laden!")
+ return
+
+ if not self.adjuster.affected_points:
+ QMessageBox.warning(self, "Fehler",
+ "Bitte zuerst eine Vorschau berechnen!")
+ return
+
+ reply = QMessageBox.question(self, "Bestätigung",
+ f"Soll die Transformation auf {len(self.adjuster.affected_points)} Punkte angewendet werden?\n\n"
+ "Die Änderungen werden in der geladenen JXL-Datei gespeichert.",
+ QMessageBox.Yes | QMessageBox.No)
+
+ if reply == QMessageBox.No:
+ return
+
+ if self.adjuster.apply_transformation():
+ # Bericht aktualisieren
+ self.report_text.setText(self.adjuster.get_summary_report())
+
+ QMessageBox.information(self, "Erfolg",
+ "Transformation erfolgreich angewendet!\n\n"
+ "Die Koordinaten wurden aktualisiert.\n"
+ "Verwenden Sie 'Neue JXL exportieren' zum Speichern.")
+
+ self.main_window.statusBar().showMessage("Transformation angewendet")
+ else:
+ QMessageBox.critical(self, "Fehler",
+ "Transformation konnte nicht angewendet werden!")
+
+ def export_jxl(self):
+ """Exportiert die modifizierte JXL-Datei"""
+ if not self.main_window.parser:
+ QMessageBox.warning(self, "Fehler",
+ "Bitte zuerst eine JXL-Datei laden!")
+ return
+
+ if not self.adjuster.transformation_applied:
+ reply = QMessageBox.warning(self, "Warnung",
+ "Die Transformation wurde noch nicht angewendet.\n"
+ "Möchten Sie die Originaldatei exportieren?",
+ QMessageBox.Yes | QMessageBox.No)
+ if reply == QMessageBox.No:
+ return
+
+ # Standard-Dateiname vorschlagen
+ original_path = self.main_window.parser.file_path
+ if original_path:
+ import os
+ base, ext = os.path.splitext(original_path)
+ default_name = f"{base}_transformed{ext}"
+ else:
+ default_name = "transformed.jxl"
+
+ file_path, _ = QFileDialog.getSaveFileName(
+ self, "JXL-Datei exportieren", default_name, "JXL Files (*.jxl)")
+
+ if file_path:
+ if self.adjuster.export_jxl(file_path):
+ QMessageBox.information(self, "Erfolg",
+ f"JXL-Datei exportiert:\n{file_path}")
+ self.main_window.statusBar().showMessage(f"Exportiert: {file_path}")
+ else:
+ QMessageBox.critical(self, "Fehler",
+ "Fehler beim Exportieren der JXL-Datei!")
+
+
class MainWindow(QMainWindow):
"""Hauptfenster der Anwendung"""
@@ -990,6 +1265,9 @@ class MainWindow(QMainWindow):
self.adjust_tab = NetworkAdjustmentTab(self)
self.tabs.addTab(self.adjust_tab, "📐 Netzausgleichung")
+ self.refpoint_tab = ReferencePointAdjusterTab(self)
+ self.tabs.addTab(self.refpoint_tab, "📍 Referenzpunkt anpassen")
+
layout.addWidget(self.tabs)
def setup_menu(self):
diff --git a/modules/reference_point_adjuster.py b/modules/reference_point_adjuster.py
new file mode 100644
index 0000000..e01f375
--- /dev/null
+++ b/modules/reference_point_adjuster.py
@@ -0,0 +1,323 @@
+"""
+Reference Point Adjuster Module - Referenzpunkt-Anpassung für JXL-Dateien
+Ermöglicht die Änderung des Referenzpunktes 5001 und Neuberechnung aller Koordinaten
+"""
+
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Tuple
+import math
+import copy
+import os
+
+from modules.jxl_parser import JXLParser, Point, Station
+
+
+@dataclass
+class TransformationResult:
+ """Ergebnis der Koordinatentransformation"""
+ original_point: str
+ original_coords: Tuple[float, float, float]
+ new_coords: Tuple[float, float, float]
+ delta: Tuple[float, float, float]
+
+
+class ReferencePointAdjuster:
+ """Klasse zur Anpassung des Referenzpunktes und Neuberechnung der JXL-Datei"""
+
+ def __init__(self, parser: JXLParser = None):
+ self.parser = parser
+ self.reference_point_name = "5001"
+ self.original_coords: Tuple[float, float, float] = (0.0, 0.0, 0.0)
+ self.new_coords: Tuple[float, float, float] = (0.0, 0.0, 0.0)
+ self.affected_points: List[TransformationResult] = []
+ self.transformation_applied = False
+
+ def set_parser(self, parser: JXLParser):
+ """Setzt den Parser für die JXL-Datei"""
+ self.parser = parser
+ self.find_reference_point()
+
+ def find_reference_point(self) -> Optional[Point]:
+ """Findet den Referenzpunkt 5001 in der JXL-Datei"""
+ if not self.parser:
+ return None
+
+ # Suche nach dem Punkt mit Name "5001"
+ for name, point in self.parser.points.items():
+ if name == self.reference_point_name or name == "5001":
+ self.reference_point_name = name
+ self.original_coords = (
+ point.east if point.east is not None else 0.0,
+ point.north if point.north is not None else 0.0,
+ point.elevation if point.elevation is not None else 0.0
+ )
+ return point
+
+ # Falls 5001 nicht gefunden, suche nach dem ersten Punkt mit Coordinates/KeyedIn
+ for name, point in self.parser.points.items():
+ if point.method == "Coordinates" and point.survey_method == "KeyedIn":
+ self.reference_point_name = name
+ self.original_coords = (
+ point.east if point.east is not None else 0.0,
+ point.north if point.north is not None else 0.0,
+ point.elevation if point.elevation is not None else 0.0
+ )
+ return point
+
+ return None
+
+ def get_reference_point_info(self) -> Dict:
+ """Gibt Informationen zum Referenzpunkt zurück"""
+ if not self.parser:
+ return {"found": False, "message": "Kein Parser geladen"}
+
+ point = self.find_reference_point()
+ if not point:
+ return {"found": False, "message": "Referenzpunkt nicht gefunden"}
+
+ return {
+ "found": True,
+ "name": self.reference_point_name,
+ "east": self.original_coords[0],
+ "north": self.original_coords[1],
+ "elevation": self.original_coords[2],
+ "method": point.method,
+ "survey_method": point.survey_method
+ }
+
+ def set_new_coordinates(self, east: float, north: float, elevation: float):
+ """Setzt neue Koordinaten für den Referenzpunkt"""
+ self.new_coords = (east, north, elevation)
+
+ def calculate_translation(self) -> Tuple[float, float, float]:
+ """Berechnet die Translation zwischen alten und neuen Koordinaten"""
+ delta_x = self.new_coords[0] - self.original_coords[0]
+ delta_y = self.new_coords[1] - self.original_coords[1]
+ delta_z = self.new_coords[2] - self.original_coords[2]
+ return (delta_x, delta_y, delta_z)
+
+ def preview_transformation(self) -> List[TransformationResult]:
+ """Zeigt eine Vorschau der Transformation für alle betroffenen Punkte"""
+ if not self.parser:
+ return []
+
+ delta = self.calculate_translation()
+ results = []
+
+ for name, point in self.parser.points.items():
+ if point.east is None or point.north is None:
+ continue
+
+ original = (
+ point.east,
+ point.north,
+ point.elevation if point.elevation is not None else 0.0
+ )
+
+ new = (
+ original[0] + delta[0],
+ original[1] + delta[1],
+ original[2] + delta[2]
+ )
+
+ results.append(TransformationResult(
+ original_point=name,
+ original_coords=original,
+ new_coords=new,
+ delta=delta
+ ))
+
+ self.affected_points = results
+ return results
+
+ def apply_transformation(self) -> bool:
+ """Wendet die Transformation auf alle Punkte in der JXL-Datei an"""
+ if not self.parser or not self.parser.raw_xml:
+ return False
+
+ delta = self.calculate_translation()
+ root = self.parser.raw_xml.getroot()
+ fieldbook = root.find('FieldBook')
+
+ if fieldbook is None:
+ return False
+
+ modified_count = 0
+
+ # Durchsuche alle PointRecords und aktualisiere die Koordinaten
+ for element in fieldbook:
+ if element.tag == 'PointRecord':
+ modified = self._update_point_coordinates(element, delta)
+ if modified:
+ modified_count += 1
+
+ # Aktualisiere auch die internen Parser-Daten
+ for name, point in self.parser.points.items():
+ if point.east is not None:
+ point.east += delta[0]
+ if point.north is not None:
+ point.north += delta[1]
+ if point.elevation is not None:
+ point.elevation += delta[2]
+
+ self.transformation_applied = True
+ return modified_count > 0
+
+ def _update_point_coordinates(self, element: ET.Element, delta: Tuple[float, float, float]) -> bool:
+ """Aktualisiert die Koordinaten eines einzelnen Punktes im XML"""
+ modified = False
+
+ # Grid-Koordinaten aktualisieren
+ grid = element.find('Grid')
+ if grid is not None:
+ modified |= self._update_grid_element(grid, delta)
+
+ # ComputedGrid-Koordinaten aktualisieren
+ computed_grid = element.find('ComputedGrid')
+ if computed_grid is not None:
+ modified |= self._update_grid_element(computed_grid, delta)
+
+ return modified
+
+ def _update_grid_element(self, grid: ET.Element, delta: Tuple[float, float, float]) -> bool:
+ """Aktualisiert ein Grid oder ComputedGrid Element"""
+ modified = False
+
+ east = grid.find('East')
+ if east is not None and east.text:
+ try:
+ old_value = float(east.text)
+ new_value = old_value + delta[0]
+ east.text = str(new_value)
+ modified = True
+ except ValueError:
+ pass
+
+ north = grid.find('North')
+ if north is not None and north.text:
+ try:
+ old_value = float(north.text)
+ new_value = old_value + delta[1]
+ north.text = str(new_value)
+ modified = True
+ except ValueError:
+ pass
+
+ elevation = grid.find('Elevation')
+ if elevation is not None and elevation.text:
+ try:
+ old_value = float(elevation.text)
+ new_value = old_value + delta[2]
+ elevation.text = str(new_value)
+ modified = True
+ except ValueError:
+ pass
+
+ return modified
+
+ def export_jxl(self, output_path: str) -> bool:
+ """Exportiert die modifizierte JXL-Datei"""
+ if not self.parser or not self.parser.raw_xml:
+ return False
+
+ try:
+ # XML mit Deklaration schreiben
+ tree = self.parser.raw_xml
+ tree.write(output_path, encoding='UTF-8', xml_declaration=True)
+ return True
+ except Exception as e:
+ print(f"Fehler beim Exportieren: {e}")
+ return False
+
+ def get_summary_report(self) -> str:
+ """Erstellt einen zusammenfassenden Bericht der Transformation"""
+ delta = self.calculate_translation()
+
+ report = []
+ report.append("=" * 60)
+ report.append("REFERENZPUNKT-ANPASSUNG - ZUSAMMENFASSUNG")
+ report.append("=" * 60)
+ report.append("")
+ report.append(f"Referenzpunkt: {self.reference_point_name}")
+ report.append("")
+ report.append("Ursprüngliche Koordinaten:")
+ report.append(f" East (X): {self.original_coords[0]:12.4f} m")
+ report.append(f" North (Y): {self.original_coords[1]:12.4f} m")
+ report.append(f" Elevation (Z):{self.original_coords[2]:12.4f} m")
+ report.append("")
+ report.append("Neue Koordinaten:")
+ report.append(f" East (X): {self.new_coords[0]:12.4f} m")
+ report.append(f" North (Y): {self.new_coords[1]:12.4f} m")
+ report.append(f" Elevation (Z):{self.new_coords[2]:12.4f} m")
+ report.append("")
+ report.append("Translation (Delta):")
+ report.append(f" ΔX: {delta[0]:+12.4f} m")
+ report.append(f" ΔY: {delta[1]:+12.4f} m")
+ report.append(f" ΔZ: {delta[2]:+12.4f} m")
+ report.append("")
+ report.append("-" * 60)
+ report.append(f"Anzahl betroffener Punkte: {len(self.affected_points)}")
+ report.append("-" * 60)
+
+ if self.affected_points:
+ report.append("")
+ report.append(f"{'Punkt':<10} {'Alt X':>12} {'Alt Y':>12} {'Alt Z':>10} -> {'Neu X':>12} {'Neu Y':>12} {'Neu Z':>10}")
+ report.append("-" * 90)
+
+ for result in self.affected_points[:20]: # Max 20 Punkte anzeigen
+ report.append(
+ f"{result.original_point:<10} "
+ f"{result.original_coords[0]:>12.4f} "
+ f"{result.original_coords[1]:>12.4f} "
+ f"{result.original_coords[2]:>10.4f} -> "
+ f"{result.new_coords[0]:>12.4f} "
+ f"{result.new_coords[1]:>12.4f} "
+ f"{result.new_coords[2]:>10.4f}"
+ )
+
+ if len(self.affected_points) > 20:
+ report.append(f"... und {len(self.affected_points) - 20} weitere Punkte")
+
+ report.append("")
+ report.append("=" * 60)
+
+ if self.transformation_applied:
+ report.append("✓ Transformation wurde angewendet")
+ else:
+ report.append("⚠ Transformation noch nicht angewendet")
+
+ report.append("=" * 60)
+
+ return "\n".join(report)
+
+ def validate_input(self, east: float, north: float, elevation: float) -> Tuple[bool, str]:
+ """Validiert die eingegebenen Koordinaten"""
+ warnings = []
+
+ # Prüfe auf extrem große Werte (möglicher Eingabefehler)
+ if abs(east) > 1000000:
+ warnings.append(f"East-Koordinate ({east}) ist sehr groß - bitte überprüfen")
+ if abs(north) > 1000000:
+ warnings.append(f"North-Koordinate ({north}) ist sehr groß - bitte überprüfen")
+ if abs(elevation) > 10000:
+ warnings.append(f"Elevation ({elevation}) ist sehr groß - bitte überprüfen")
+
+ # Berechne Translation
+ delta = (
+ east - self.original_coords[0],
+ north - self.original_coords[1],
+ elevation - self.original_coords[2]
+ )
+
+ # Warnung bei sehr großer Translation
+ total_shift = math.sqrt(delta[0]**2 + delta[1]**2)
+ if total_shift > 100000:
+ warnings.append(f"Horizontale Verschiebung ({total_shift:.1f} m) ist sehr groß")
+
+ if abs(delta[2]) > 1000:
+ warnings.append(f"Höhenverschiebung ({delta[2]:.1f} m) ist sehr groß")
+
+ if warnings:
+ return (False, "\n".join(warnings))
+ return (True, "Koordinaten sind plausibel")
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..e14a175
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,15 @@
+# Trimble Geodesy Tool - Python Dependencies
+# Installation: pip install -r requirements.txt
+
+# GUI Framework
+PyQt5>=5.15.0
+
+# Numerische Berechnungen
+numpy>=1.21.0
+scipy>=1.7.0
+
+# XML Processing
+lxml>=4.6.0
+
+# Optional: für erweiterte Funktionen
+matplotlib>=3.4.0 # Für Diagramme und Visualisierungen (optional)
diff --git a/tests/Baumschulenstr_93.cor b/tests/Baumschulenstr_93.cor
new file mode 100644
index 0000000..77361cc
--- /dev/null
+++ b/tests/Baumschulenstr_93.cor
@@ -0,0 +1,84 @@
+5001,0.000,0.000,0.000
+5002,0.000,11.407,-0.035
+1001,22.788,13.565,-1.952
+2001,0.014,11.747,-1.361
+2002,20.214,30.965,-1.663
+2003,33.782,13.097,-2.616
+2004,20.490,-15.429,-1.438
+3001,33.838,13.220,-2.575
+3002,26.308,30.140,-1.903
+3003,26.357,-3.293,-2.115
+3004,0.048,-0.530,-3.021
+3005,-0.038,6.789,-3.414
+6001,-18.196,13.913,-2.176
+6002,-15.677,12.648,-2.286
+6003,-26.318,12.550,-2.274
+6004,-24.723,13.845,-1.559
+3006,1.182,13.131,1.845
+3007,0.867,16.745,1.841
+1002,-20.883,13.008,-1.742
+2005,-13.138,18.366,-1.730
+2006,-19.762,10.592,-1.668
+2007,-29.788,15.304,-1.497
+2008,-20.421,22.326,-1.798
+3008,-13.174,11.080,-0.280
+3009,-13.168,10.756,3.783
+3010,-14.042,4.481,1.836
+3011,-13.166,13.790,5.689
+3012,-13.164,11.191,7.558
+3013,-13.164,10.602,10.922
+2009,-13.144,12.601,-1.895
+7002,-7.487,13.193,-3.675
+7001,-13.134,19.746,-0.424
+3014,-10.454,12.968,-3.593
+3015,-5.752,14.319,-3.597
+3016,-2.168,12.842,-3.598
+3017,-16.960,9.871,-1.307
+3018,-13.143,8.257,-1.713
+3019,-21.129,4.481,-1.106
+3020,-31.198,9.253,-2.128
+3021,-29.609,16.923,-2.185
+3022,-30.145,21.896,-3.368
+3023,-20.860,18.943,-3.376
+6005,-25.633,20.878,-2.243
+1003,23.070,14.027,-1.969
+3024,1.188,12.854,5.607
+3025,1.213,3.983,5.615
+3026,-0.029,17.401,9.376
+3027,0.002,9.449,13.119
+3028,-0.915,16.758,13.728
+3029,1.096,3.374,9.955
+1004,-22.696,19.765,-1.966
+6006,-48.153,24.806,-2.092
+6007,-48.551,23.493,-1.983
+6008,-42.900,22.586,-2.096
+1005,-46.031,23.575,-1.951
+2010,-40.871,25.207,-1.886
+2011,-42.736,16.007,-1.438
+2012,-51.007,10.054,-1.947
+2013,-46.596,26.451,-1.927
+3030,-41.629,20.671,-2.199
+3031,-42.358,17.069,-2.207
+3032,-43.915,9.539,-2.218
+3033,-39.002,22.932,-3.451
+1006,22.923,13.878,-1.904
+3034,-2.259,19.010,16.788
+3035,-2.039,11.679,17.155
+3036,-2.401,0.498,16.947
+1007,-21.634,18.968,-1.815
+3037,-29.302,18.141,1.265
+3038,-30.284,13.473,-0.502
+3039,-30.223,13.843,2.923
+3040,-30.164,14.114,6.326
+3041,-30.261,13.648,9.537
+1008,-46.567,23.450,-1.900
+3042,-43.596,11.396,4.659
+3043,-41.019,23.777,4.663
+1009,-17.132,16.548,-1.900
+3044,-31.755,22.820,14.965
+3045,-33.719,12.836,14.653
+3046,-34.899,6.876,14.549
+3047,-31.140,9.336,8.091
+3048,-29.550,17.086,8.072
+3049,-28.629,21.467,8.076
+3050,-30.750,11.180,1.169
diff --git a/tests/Baumschulenstr_93.jxl b/tests/Baumschulenstr_93.jxl
new file mode 100644
index 0000000..f78e3f3
--- /dev/null
+++ b/tests/Baumschulenstr_93.jxl
@@ -0,0 +1,10095 @@
+
+
+
+
+
+
+
+ 0
+ false
+
+
+
+ NoAdjustment
+
+
+
+ NoAdjustment
+
+
+
+
+
+
+
+ Unknown
+ false
+
+
+
+
+
+
+
+
+
+ Germany
+ ETRS89_UTM32
+ ETRS89
+
+
+
+ false
+ IncreasingNorthEast
+ 0
+ GroundDistance
+ false
+
+ false
+ 0.5
+
+ 0
+
+
+
+
+
+
+
+
+
+ ScaleOnly
+ 1
+
+
+ Grid
+
+
+
+
+
+
+
+ NoDatum
+
+
+
+
+
+
+
+
+
+ Metres
+ Metres
+ Gons
+ Azimuth
+ DMSDegrees
+ East-North-Elevation
+ Celsius
+ MilliBar
+ Percentage
+ SquareMetres
+ CubicMetres
+ 1000.0
+
+ DRMS
+ 3
+ 3
+ 3
+ 3
+ 4
+ Inclination
+ Local
+
+
+
+
+ Converted from GS v3.20 to GS v2018.10
+
+
+
+
+
+ Converted from GS v2018.10 to GS v2018.20
+
+
+
+
+
+ Converted from GS v2018.20 to GS v2019.00
+
+
+
+
+
+ Converted from v2019.00.7 to v2020.10.4
+
+
+
+
+
+ Converted from GS v2020.10 to GS v2022.00
+
+
+
+
+
+ Converted from GS v2022.00 to GS v2022.10
+
+
+
+
+
+ Converted from v2022.10.19 to v2023.00.12
+
+
+
+
+
+ Converted from v2023.00.12 to v2023.10.16
+
+
+
+
+
+ Converted from v2023.10.16 to v2024.10.2
+
+
+
+
+ Mitteleuropäische Zeit
+ -1
+
+
+
+ true
+
+
+
+ TrimbleSX10
+ 269.89888962766
+ 78.08621711754
+ Fine
+ SetToAzimuth
+ HorizontalAndVerticalAngle
+ 0
+ false
+ 3
+ 0.00027788453064
+ 0.00027788453064
+ 0.001
+ 1.5
+ FromInstrument
+ 0
+ 0.003
+ SX12
+ 30710160
+ S2.8.5
+ TRIMBLE-SX12-30710160
+ 0
+ 0
+ 0
+ 0
+ 0
+ 0
+
+
+
+
+ TrimbleSX10
+ 269.89888962766
+ 78.08621711754
+ Fine
+ SetToAzimuth
+ HorizontalAndVerticalAngle
+ 0
+ false
+ 3
+ 0.00027788453064
+ 0.00027788453064
+ 0.001
+ 1.5
+ FromInstrument
+ 0
+ 0.003
+ SX12
+ 30710160
+ S2.8.5
+ TRIMBLE-SX12-30710160
+ 0
+ 0
+ 0
+ 0
+ 0
+ 0
+
+
+
+
+ 5001
+