pysurveytools 0.1.0__tar.gz

pysurveytools-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Stefan Printz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pysurveytools-0.1.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: pysurveytools
+Version: 0.1.0
+Summary: Geodetic classes for managing and calculating (Angle, Coordinate, Measurement, …)
+Home-page: https://gitlab-ce.hs-bochum.de/fachbereich-geodaesie/pypi/pysurveytools
+Author: Stefan Printz
+Author-email: Stefan Printz <stefan.printz@hs-bochum.de>
+License: MIT
+Project-URL: Homepage, https://gitlab-ce.hs-bochum.de/fachbereich-geodaesie/pypi/pysurveytools
+Project-URL: Issue Tracker, https://gitlab-ce.hs-bochum.de/fachbereich-geodaesie/pypi/pysurveytools/-/issues
+Project-URL: Source, https://gitlab-ce.hs-bochum.de/fachbereich-geodaesie/pypi/pysurveytools.git
+Keywords: geodesy,surveying,coordinates,angles,measurement
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+
+# pySurveytools
+
+**Geodetic classes for managing and calculating**
+
+## Overview
+
+`surveytools` is a Python library providing essential geodetic classes and utilities to support surveying calculations and coordinate management. It offers robust implementations for angles, coordinates, measurements, and other related geospatial operations, enabling precise and efficient geodetic data processing.
+
+## Features
+
+- Angle representation and conversion
+- Coordinate handling in multiple formats
+- Measurement encapsulation with metadata
+- Easy integration with surveying instruments and software
+
+## Installation
+
+You can install `surveytools` via pip:
+
+```bash
+pip install pysurveytools

pysurveytools-0.1.0/README.md

@@ -0,0 +1,21 @@
+# pySurveytools
+
+**Geodetic classes for managing and calculating**
+
+## Overview
+
+`surveytools` is a Python library providing essential geodetic classes and utilities to support surveying calculations and coordinate management. It offers robust implementations for angles, coordinates, measurements, and other related geospatial operations, enabling precise and efficient geodetic data processing.
+
+## Features
+
+- Angle representation and conversion
+- Coordinate handling in multiple formats
+- Measurement encapsulation with metadata
+- Easy integration with surveying instruments and software
+
+## Installation
+
+You can install `surveytools` via pip:
+
+```bash
+pip install pysurveytools

pysurveytools-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pysurveytools"
+version = "0.1.0"
+description = "Geodetic classes for managing and calculating (Angle, Coordinate, Measurement, …)"
+readme = "README.md"
+authors = [
+  { name = "Stefan Printz", email = "stefan.printz@hs-bochum.de" }
+]
+license = { text = "MIT" }
+urls = {"Homepage" = "https://gitlab-ce.hs-bochum.de/fachbereich-geodaesie/pypi/pysurveytools", "Issue Tracker" = "https://gitlab-ce.hs-bochum.de/fachbereich-geodaesie/pypi/pysurveytools/-/issues",  "Source" = "https://gitlab-ce.hs-bochum.de/fachbereich-geodaesie/pypi/pysurveytools.git"}
+keywords = ["geodesy", "surveying", "coordinates", "angles", "measurement"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent"
+]
+dependencies = [
+  "numpy >= 1.20"
+]
+
+[project.optional-dependencies]
+test = [
+  "pytest >= 7.0"
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.scripts]
+surveytools-cli = "surveytools.surveytools:main"

pysurveytools-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pysurveytools-0.1.0/setup.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+import setuptools
+
+if __name__ == "__main__":
+    setuptools.setup(
+        name="pysurveytools",
+        version="0.1.0",
+        author="Stefan Printz",
+        author_email="stefan.printz@hs-bochum.de",
+        description="Geodetic classes for managing and calculating (Angle, Coordinate, Measurement, …)",
+        long_description=open("README.md", encoding="utf-8").read(),
+        long_description_content_type="text/markdown",
+        url="https://gitlab-ce.hs-bochum.de/fachbereich-geodaesie/pypi/pysurveytools",
+        packages=setuptools.find_packages(where="src"),
+        package_dir={"": "src"},
+        install_requires=[
+            "numpy>=1.20",
+        ],
+        extras_require={
+            "test": ["pytest>=7.0"],
+        },
+        classifiers=[
+            "Programming Language :: Python :: 3",
+            "License :: OSI Approved :: MIT License",
+            "Operating System :: OS Independent",
+        ],
+        entry_points={
+            "console_scripts": [
+                "surveytools-cli=surveytools.surveytools:main",
+            ],
+        },
+    )

pysurveytools-0.1.0/src/pysurveytools.egg-info/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: pysurveytools
+Version: 0.1.0
+Summary: Geodetic classes for managing and calculating (Angle, Coordinate, Measurement, …)
+Home-page: https://gitlab-ce.hs-bochum.de/fachbereich-geodaesie/pypi/pysurveytools
+Author: Stefan Printz
+Author-email: Stefan Printz <stefan.printz@hs-bochum.de>
+License: MIT
+Project-URL: Homepage, https://gitlab-ce.hs-bochum.de/fachbereich-geodaesie/pypi/pysurveytools
+Project-URL: Issue Tracker, https://gitlab-ce.hs-bochum.de/fachbereich-geodaesie/pypi/pysurveytools/-/issues
+Project-URL: Source, https://gitlab-ce.hs-bochum.de/fachbereich-geodaesie/pypi/pysurveytools.git
+Keywords: geodesy,surveying,coordinates,angles,measurement
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+
+# pySurveytools
+
+**Geodetic classes for managing and calculating**
+
+## Overview
+
+`surveytools` is a Python library providing essential geodetic classes and utilities to support surveying calculations and coordinate management. It offers robust implementations for angles, coordinates, measurements, and other related geospatial operations, enabling precise and efficient geodetic data processing.
+
+## Features
+
+- Angle representation and conversion
+- Coordinate handling in multiple formats
+- Measurement encapsulation with metadata
+- Easy integration with surveying instruments and software
+
+## Installation
+
+You can install `surveytools` via pip:
+
+```bash
+pip install pysurveytools

pysurveytools-0.1.0/src/pysurveytools.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/pysurveytools.egg-info/PKG-INFO
+src/pysurveytools.egg-info/SOURCES.txt
+src/pysurveytools.egg-info/dependency_links.txt
+src/pysurveytools.egg-info/entry_points.txt
+src/pysurveytools.egg-info/requires.txt
+src/pysurveytools.egg-info/top_level.txt
+src/surveytools/__init__.py
+src/surveytools/angle.py
+src/surveytools/coordinate.py
+src/surveytools/full_angle_measurement.py
+src/surveytools/instrument_station.py
+src/surveytools/measurement.py
+src/surveytools/measurement_target.py
+src/surveytools/surveytools.py
+tests/test_angle.py
+tests/test_coordinate.py
+tests/test_measurement.py
+tests/test_measurement_target.py

pysurveytools-0.1.0/src/pysurveytools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pysurveytools-0.1.0/src/pysurveytools.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+surveytools-cli = surveytools.surveytools:main

pysurveytools-0.1.0/src/pysurveytools.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy>=1.20
+
+[test]
+pytest>=7.0

pysurveytools-0.1.0/src/pysurveytools.egg-info/top_level.txt

@@ -0,0 +1 @@
+surveytools

pysurveytools-0.1.0/src/surveytools/__init__.py

@@ -0,0 +1,13 @@
+# src/surveytools/__init__.py
+from .surveytools import SWVersion
+from .coordinate import Coordinate
+from .angle import Angle, RHO
+from .measurement import Measurement
+from .measurement_target import MeasurementTarget
+from .full_angle_measurement import FullAngleMeasurement
+
+__all__ = [
+    "Angle", "RHO",
+    "Coordinate", "Measurement",
+    "SWVersion", "FullAngleMeasurement", "MeasurementTarget"
+]

pysurveytools-0.1.0/src/surveytools/angle.py

@@ -0,0 +1,92 @@
+import math
+from functools import total_ordering
+
+RHO = 200 / math.pi
+
+@total_ordering
+class Angle(object):
+
+    def __init__(self, rad: int = 0):
+        self.value_rad = rad
+
+    @staticmethod
+    def from_gon(gon_value):
+        r = Angle()
+        r.set_gon(gon_value)
+        return r
+
+    @staticmethod
+    def from_rad(rad_value):
+        r = Angle(rad_value)
+        return r
+
+    def set_gon(self, gon):
+        self.value_rad = gon / RHO
+        return
+
+    def get_gon(self):
+        return self.value_rad * RHO
+
+
+    def __abs__(self):
+        r = Angle()
+        r.value_rad = abs(self.value_rad)
+        return r
+
+    def __add__(self, o):
+        if isinstance(o, Angle):
+            r = Angle()
+            r.value_rad = self.value_rad + o.value_rad
+            return r
+        else:
+            raise TypeError("unsupported operand type(s) for +: 'Angle' and '" + str(type(o).__name__) + "'")
+
+    def __sub__(self, o):
+        if isinstance(o, Angle):
+            r = Angle()
+            r.value_rad = self.value_rad - o.value_rad
+            return r
+        else:
+            raise TypeError("unsupported operand type(s) for -: 'Angle' and '" + type(o).__name__ + "'")
+
+    def __truediv__(self, o):
+        if isinstance(o, (int, float)):
+            r = Angle()
+            r.value_rad = self.value_rad / o
+        else:
+            raise TypeError("unsupported operand type(s) for /: 'Angle' and '" + type(o).__name__ + "'")
+        return r
+
+    def __eq__(self, other):
+        if not isinstance(other, Angle):
+            return NotImplemented
+        return self.value_rad == other.value_rad
+
+    def __lt__(self, other):
+        if not isinstance(other, Angle):
+            return NotImplemented
+        return self.value_rad < other.value_rad
+
+    def __str__(self):
+        return '{0:.7} gon'.format(self.get_gon())
+
+    def normalise(self):
+        self.value_rad %= 2 * math.pi
+        return self
+
+    def add_half_circle(self):
+        r = Angle()
+        r.value_rad = self.value_rad + math.pi
+        r.normalise()
+        return r
+
+    def supplementary_angle(self):
+        r = Angle()
+        r.value_rad = 2 * math.pi - self.value_rad
+        return r
+
+    def sin(self):
+        return math.sin(self.value_rad)
+
+    def cos(self):
+        return math.cos(self.value_rad)

pysurveytools-0.1.0/src/surveytools/coordinate.py

@@ -0,0 +1,47 @@
+import math
+
+from surveytools.angle import Angle
+
+
+class Coordinate(object):
+
+    def __init__(self, pkt_nr : str, x: float, y: float, z: float):
+        self.value_rad = None
+        self.pkt_nr = pkt_nr
+        self.x = x
+        self.y = y
+        self.z = z
+
+    def __add__(self, o):
+        if isinstance(o, Coordinate):
+            return Coordinate(self.pkt_nr, self.x + o.x, self.y + o.y, self.z + o.z)
+        else:
+            raise TypeError("unsupported operand type(s) for +: 'Coordinate' and '" + type(o).__name__ + "'")
+
+    def __sub__(self, o):
+        if isinstance(o, Coordinate):
+            return Coordinate(self.pkt_nr, self.x - o.x, self.y - o.y, self.z - o.z)
+        else:
+            raise TypeError("unsupported operand type(s) for -: 'Coordinate' and '" + type(o).__name__ + "'")
+
+    def direction_to(self, o):
+        dc = o - self
+        theta_rad = math.atan2(dc.x, dc.y)
+        return Angle.from_rad(theta_rad)
+
+    def distance_to(self, o):
+        dc = o - self
+        return math.sqrt(dc.x * dc.x + dc.y * dc.y + dc.z * dc.z)
+
+    def get_array(self):
+        return [self.y, self.x, self.z]
+
+    def get_homogene_array(self):
+        return [self.y, self.x, self.z, 1]
+
+    def get_normalized_vector(self):
+        norm = math.sqrt(self.x * self.x + self.y * self.y + self.z * self.z)
+        return [self.x / norm, self.y / norm, self.z / norm]
+
+    def __str__(self):
+        return f"[Pkt: {self.pkt_nr}, x: {self.x:.4f}, y: {self.y:.4f}, z: {self.z:.4f}]"

pysurveytools-0.1.0/src/surveytools/full_angle_measurement.py

@@ -0,0 +1,20 @@
+from surveytools.angle import Angle
+
+
+class FullAngleMeasurement(object):
+
+    def __init__(self):
+        self.hz: Angle = Angle()
+        self.v: Angle = Angle()
+        self.angle_accuracy: Angle = Angle()
+        self.angle_time: int = 0
+        self.cross_incline: Angle = Angle()
+        self.length_incline: Angle = Angle()
+        self.accuracy_incline: Angle = Angle()
+        self.incline_time: int = 0
+        self.face_def: int = 0
+
+    def __str__(self):
+        return "[hz: " + str(self.hz) + ", v: " + str(self.v) + " , angle_accuracy: " + str(self.angle_accuracy) + \
+               ", angle_time: " + str(self.angle_time) + ", cross_incline: " + str(self.cross_incline) +\
+               ", length_incline: " + str(self.length_incline) + ", accuracy_incline: " + str(self.accuracy_incline) + "]"

pysurveytools-0.1.0/src/surveytools/instrument_station.py

@@ -0,0 +1,18 @@
+from typing import List
+
+from surveytools import MeasurementTarget, Measurement, Angle
+
+
+class InstrumentStation:
+
+    def __init__(self, station_name: str):
+        self.station_name = station_name
+        self.targets : dict[str, MeasurementTarget]  = dict()
+        self.orientation : Angle = Angle.from_rad(0)
+
+    def add_measurement_target(self, target : MeasurementTarget):
+        self.targets[target.target_number] = target
+
+    def evaluation(self) -> List[Measurement]:
+        return [x.evaluation(self.orientation) for x in self.targets.values()]
+

pysurveytools-0.1.0/src/surveytools/measurement.py

@@ -0,0 +1,34 @@
+from surveytools.coordinate import Coordinate
+from surveytools.angle import Angle
+
+
+class Measurement(object):
+
+    def __init__(self, target : str, direction: Angle, zenith: Angle, sd : float, atmospheric_data, measure_time):
+        self.target_number = target
+        self.direction = direction
+        self.zenith = zenith
+        self.slope_distances = sd
+        self.atmospheric_data = atmospheric_data
+        self.measure_time = measure_time
+
+    def __str__(self):
+        return "[target: " + str(self.target_number) + ", direction: " + str(self.direction) + " , zenith: " \
+               + str(self.zenith) + ", slope_distances: " + str(self.slope_distances) + ", atmospheric_data: "\
+               + str(self.atmospheric_data) + ", Measure Time: " + str(self.measure_time) + "]"
+
+    def get_horizontal_distances(self):
+        return self.slope_distances * self.zenith.sin()
+
+    def get_delta_height(self):
+        return self.slope_distances * self.zenith.cos()
+
+    def get_local_coordinate(self):
+        hd = self.get_horizontal_distances()
+        y = hd * self.direction.sin()
+        x = hd * self.direction.cos()
+        z = self.get_delta_height()
+        return Coordinate(self.target_number, x, y, z)
+
+    def get_arra(self):
+        return [self.target_number, self.direction.get_gon(), self.zenith.get_gon(), self.slope_distances ]

pysurveytools-0.1.0/src/surveytools/measurement_target.py

@@ -0,0 +1,36 @@
+from surveytools.angle import Angle
+from surveytools.measurement import Measurement
+
+
+class MeasurementTarget(object):
+    def __init__(self, target: str, direction: Angle, zenith: Angle, distance: float):
+        self.target_number = target
+        self.direction = direction
+        self.distance = distance
+        self.zenith = zenith
+        self.face1 = []
+        self.face2 = []
+
+    def evaluation(self, zero_direction: Angle = Angle.from_rad(0)) -> Measurement:
+        return Measurement(self.target_number, self.direction_evaluation(zero_direction), self.zenith_evaluation(), self.distance_evaluation(), self.face1[0].atmospheric_data, self.face1[0].measure_time)
+
+    def direction_evaluation(self, zero_direction : Angle) -> Angle:
+        sum_r = Angle()
+        for i in range(len(self.face1)):
+            sum_r += ((self.face1[i].direction + self.face2[i].direction.add_half_circle())/2.0 - zero_direction).normalise()
+        return sum_r/len(self.face1)
+
+    def zenith_evaluation(self) -> Angle:
+        sum_z = Angle()
+        for i in range(len(self.face1)):
+            sum_z += (((self.face1[i].zenith - self.face2[i].zenith).normalise()) / 2.0)
+        return sum_z / len(self.face1)
+
+    def distance_evaluation(self) -> float:
+        sum_d = 0
+        for i in range(len(self.face1)):
+            sum_d += (self.face1[i].slope_distances + self.face2[i].slope_distances) / 2.0
+        return sum_d / len(self.face1)
+
+    def __str__(self):
+        return "Target: " +  str(self.target_number) + " hz: " + str(self.direction) + " vz: " + str(self.zenith) + " s: " + str(self.distance)

pysurveytools-0.1.0/src/surveytools/surveytools.py

@@ -0,0 +1,10 @@
+
+class SWVersion(object):
+
+    def __init__(self, release: int, version: int, sub_version: int):
+        self.release = release
+        self.version = version
+        self.sub_version = sub_version
+
+    def __str__(self):
+        return "Version {0:02d}.{1:02d}.{2:02d}".format(self.release, self.version, self.sub_version)

pysurveytools-0.1.0/tests/test_angle.py

@@ -0,0 +1,126 @@
+import math
+import pytest
+from surveytools import RHO, Angle
+
+
+@pytest.mark.parametrize("gon", [0, 50, 200])
+def test_from_and_to_gon(gon):
+    a = Angle.from_gon(gon)
+    assert pytest.approx(a.get_gon(), rel=1e-9) == gon
+
+def test_conversion_rad_gon():
+    rad = math.pi
+    a = Angle.from_rad(rad)
+    assert pytest.approx(a.get_gon(), rel=1e-9) == rad * RHO
+
+def test_normalise_wraps():
+    a = Angle.from_rad(3 * math.pi)
+    a.normalise()
+    assert pytest.approx(a.value_rad, rel=1e-9) == math.pi
+
+@pytest.mark.parametrize("a_gon,b_gon,expected", [
+    (100, 100, True),
+    ( 50,100, False),
+])
+def test_eq(a_gon, b_gon, expected):
+    a = Angle.from_gon(a_gon)
+    b = Angle.from_gon(b_gon)
+    assert (a == b) is expected
+    assert (a != b) is (not expected)
+
+@pytest.mark.parametrize("a_rad,b_rad,expected", [
+    (1.0, 2.0, True),
+    (2.0, 1.0, False),
+    ( math.pi, math.pi, False),
+])
+def test_lt(a_rad, b_rad, expected):
+    a = Angle.from_rad(a_rad)
+    b = Angle.from_rad(b_rad)
+    assert (a < b) is expected
+    assert (b > a) is expected  # test __gt__
+
+@pytest.mark.parametrize("a_rad,b_rad,expected", [
+    (1.0, 1.0, True),
+    (1.0, 2.0, True),
+    (2.0, 1.0, False),
+])
+def test_le(a_rad, b_rad, expected):
+    a = Angle.from_rad(a_rad)
+    b = Angle.from_rad(b_rad)
+    assert (a <= b) is expected
+    assert (b >= a) is expected  # test __ge__
+
+def test_sin_cos():
+    # sin und cos für 30° (π/6)
+    a = Angle.from_rad(math.pi / 6)
+    assert pytest.approx(a.sin(), rel=1e-9) == 0.5
+    assert pytest.approx(a.cos(), rel=1e-9) == math.sqrt(3) / 2
+
+def test_supplementary_angle():
+    # 2π – π/2 = 3π/2
+    a = Angle.from_rad(math.pi / 2)
+    sup = a.supplementary_angle()
+    assert pytest.approx(sup.value_rad, rel=1e-9) == 2 * math.pi - math.pi / 2
+
+def test_add_half():
+    a = Angle.from_rad(1.0)
+    half = a.add_half_circle()
+    # prüfe reinen Wert
+    assert pytest.approx(half.value_rad, rel=1e-9) == 1.0 + math.pi
+
+
+def test_add_and_subtract_angles():
+    a = Angle.from_rad(1.5)
+    b = Angle.from_rad(2.5)
+    c = a + b
+    d = b - a
+
+    assert pytest.approx(c.value_rad, rel=1e-9) == 4.0
+    assert pytest.approx(d.value_rad, rel=1e-9) == 1.0
+
+def test_division_by_scalar():
+    a = Angle.from_rad(2.0)
+    half = a / 2
+    assert pytest.approx(half.value_rad, rel=1e-9) == 1.0
+
+def test_arithmetic_type_errors():
+    a = Angle.from_gon(50)
+    with pytest.raises(TypeError):
+        _ = a + 5
+    with pytest.raises(TypeError):
+        _ = a - "string"
+    with pytest.raises(TypeError):
+        _ = a / Angle.from_rad(1.0)
+
+@pytest.mark.parametrize("rad, expected", [
+    ( 1.0, 1.0),
+    (-1.0, 1.0),
+    ( 3*math.pi, 3*math.pi),   # Betrag vor Normalisierung
+    (-3*math.pi, 3*math.pi),
+])
+def test_abs_without_normalise(rad, expected):
+    """
+    abs() soll den ungeklärten Betrag liefern,
+    also abs(value_rad), ohne automatisch zu normieren.
+    """
+    a = Angle.from_rad(rad)
+    b = abs(a)
+    assert pytest.approx(b.value_rad, rel=1e-9) == expected
+
+def test_abs_and_normalise_chain():
+    """
+    Wenn man danach normalisiert, verhält es sich erwartbar:
+    """
+    a = Angle.from_rad(-1.0)
+    b = abs(a)
+    b.normalise()
+    # -1rad → Betrag 1rad → normalize bleibt 1rad
+    assert pytest.approx(b.value_rad, rel=1e-9) == 1.0
+
+def test_abs_type_error():
+    """
+    abs() auf Nicht-Angle-Objekt ist nicht relevant – Python ruft nur __abs__ auf Angle-Instanzen.
+    """
+    with pytest.raises(TypeError):
+        # falls jemand fälschlich versucht, abs mit einem anderen Typ zu tricksen
+        _ = Angle.from_rad(1.0).__abs__("invalid")

pysurveytools-0.1.0/tests/test_coordinate.py

@@ -0,0 +1,66 @@
+# tests/test_coordinate.py
+
+import math
+import pytest
+from surveytools import Angle, Coordinate
+
+
+def test_add_and_subtract_coordinates():
+    a = Coordinate("A", 1.0, 2.0, 3.0)
+    b = Coordinate("B", 4.0, 5.0, 6.0)
+    # Addition
+    c = a + b
+    assert isinstance(c, Coordinate)
+    assert c.pkt_nr == "A"
+    assert c.x == pytest.approx(5.0)
+    assert c.y == pytest.approx(7.0)
+    assert c.z == pytest.approx(9.0)
+    # Subtraktion
+    d = b - a
+    assert isinstance(d, Coordinate)
+    assert d.pkt_nr == "B"
+    assert d.x == pytest.approx(3.0)
+    assert d.y == pytest.approx(3.0)
+    assert d.z == pytest.approx(3.0)
+    # Falsche Operanden-Typen werfen TypeError
+    with pytest.raises(TypeError):
+        _ = a + 123
+    with pytest.raises(TypeError):
+        _ = b - "foo"
+
+def test_direction_to_and_distance_to():
+    origin = Coordinate("O", 0.0, 0.0, 0.0)
+    # Punkt auf der X-Achse
+    p1 = Coordinate("P1", 1.0, 0.0, 0.0)
+    ang = origin.direction_to(p1)
+    # math.atan2(dc.x, dc.y) für dc=(1,0,0) ergibt π/2
+    assert isinstance(ang, Angle)
+    assert ang.value_rad == pytest.approx(math.pi/2)
+    # Abstand sollte 1.0 sein
+    assert origin.distance_to(p1) == pytest.approx(1.0)
+    # 3–4–12–Triangle: sqrt(9+16+144) = 13
+    p2 = Coordinate("P2", 3.0, 4.0, 12.0)
+    assert origin.distance_to(p2) == pytest.approx(13.0)
+
+def test_array_methods_and_normalized_vector():
+    p = Coordinate("P", 1.1, 2.2, 3.3)
+    # get_array gibt [y, x, z]
+    assert p.get_array() == [2.2, 1.1, 3.3]
+    # homogene Koordinaten
+    assert p.get_homogene_array() == [2.2, 1.1, 3.3, 1]
+    # Normalisierter Vektor
+    norm = math.sqrt(1.1**2 + 2.2**2 + 3.3**2)
+    vec = p.get_normalized_vector()
+    assert vec[0] == pytest.approx(1.1 / norm)
+    assert vec[1] == pytest.approx(2.2 / norm)
+    assert vec[2] == pytest.approx(3.3 / norm)
+
+def test_str_representation():
+    # Die __str__-Methode solltePkt-Nummer und gerundete Werte anzeigen
+    p = Coordinate("X1", 1.23456, 2.34567, 3.45678)
+    s = str(p)
+    assert s.startswith("[Pkt: X1")
+    # Je nach implementiertem Format auf 4 Dezimalstellen gerundet
+    assert "x: 1.2346" in s
+    assert "y: 2.3457" in s
+    assert "z: 3.4568" in s

pysurveytools-0.1.0/tests/test_measurement.py

@@ -0,0 +1,72 @@
+# tests/test_measurement.py
+
+import math
+import pytest
+from surveytools import Angle, Coordinate, Measurement
+
+
+def test_init_and_attributes():
+    atm = {"pressure": 1013.25, "temp": 20.0}
+    mt = "2025-05-26T12:00:00"
+    m = Measurement(42, Angle.from_gon(100), Angle.from_rad(math.pi / 4), 123.45, atm, mt)
+
+    # Attribute wurden korrekt gesetzt
+    assert m.target_number == 42
+    assert m.direction.get_gon() == pytest.approx(100)  # Gauge aus Gon :contentReference[oaicite:0]{index=0}
+    assert m.zenith.value_rad == pytest.approx(
+        math.pi / 4)  # Radiant direkt aus from_rad :contentReference[oaicite:1]{index=1}
+    assert m.slope_distances == pytest.approx(123.45)
+    assert m.atmospheric_data is atm
+    assert m.measure_time == mt
+
+
+def test_get_horizontal_distances():
+    # hd = slope_distances * sin(zenith)
+    zen = Angle.from_rad(math.pi / 6)
+    m = Measurement(0, Angle.from_rad(0), zen, 10.0, None, None)
+    expected = 10.0 * math.sin(math.pi / 6)
+    assert m.get_horizontal_distances() == pytest.approx(
+        expected)  # get_horizontal_distances :contentReference[oaicite:2]{index=2}
+
+
+def test_get_delta_height():
+    # dh = slope_distances * cos(zenith)
+    zen = Angle.from_rad(math.pi / 3)
+    m = Measurement(0, Angle.from_rad(0), zen, 20.0, None, None)
+    expected = 20.0 * math.cos(math.pi / 3)
+    assert m.get_delta_height() == pytest.approx(expected)  # get_delta_height :contentReference[oaicite:3]{index=3}
+
+
+def test_get_local_coordinate():
+    # hd = sd * sin(zenith) = 5 * 1 = 5
+    # direction = 45° → x = hd*cos(45°), y = hd*sin(45°), z = sd*cos(zenith) = 0
+    dir_ang = Angle.from_rad(math.pi / 4)
+    zen = Angle.from_rad(math.pi / 2)
+    m = Measurement(7, dir_ang, zen, 5.0, None, None)
+    coord = m.get_local_coordinate()
+
+    assert isinstance(coord, Coordinate)
+    assert coord.pkt_nr == 7
+    assert coord.x == pytest.approx(
+        5.0 * math.cos(math.pi / 4))  # get_local_coordinate :contentReference[oaicite:4]{index=4}
+    assert coord.y == pytest.approx(5.0 * math.sin(math.pi / 4))
+    assert coord.z == pytest.approx(5.0 * math.cos(math.pi / 2))
+
+
+def test_get_arra_and_str():
+    # get_arra liefert [target_number, direction_gon, zenith_gon, slope_distances]
+    dir_ang = Angle.from_gon(150)
+    zen = Angle.from_gon(75)
+    m = Measurement(8, dir_ang, zen, 12.3, "ATM_DATA", "TIME_STAMP")
+    arr = m.get_arra()
+    assert arr == [8, pytest.approx(dir_ang.get_gon()), pytest.approx(zen.get_gon()),
+                   pytest.approx(12.3)]  # get_arra :contentReference[oaicite:5]{index=5}
+
+    # __str__ enthält alle Informationen
+    s = str(m)
+    assert "target: 8" in s
+    assert "direction:" in s and "gon" in s
+    assert "zenith:" in s and "gon" in s
+    assert "slope_distances: 12.3" in s
+    assert "atmospheric_data: ATM_DATA" in s
+    assert "Measure Time: TIME_STAMP" in s  # __str__ :contentReference[oaicite:6]{index=6}

pysurveytools-0.1.0/tests/test_measurement_target.py

@@ -0,0 +1,66 @@
+import pytest
+
+from surveytools import MeasurementTarget, Measurement, Angle
+
+# 1. Erstelle jeweils zwei Measurement-Instanzen für face1
+m1_f1 = Measurement(
+    target=1,
+    direction=Angle.from_gon(172.1609),    # Horizontalwinkel in Gon
+    zenith=Angle.from_gon(97.1722),        # Zenitwinkel in Gon
+    sd=12.287,                          # Schrägentfernung
+    atmospheric_data={"pressure": 1013.25},
+    measure_time="2025-05-26T10:00:00"
+)
+m2_f1 = Measurement(
+    target=1,
+    direction=Angle.from_gon(172.1659),
+    zenith=Angle.from_gon(97.1682),
+    sd=12.29,
+    atmospheric_data={"pressure": 1013.25},
+    measure_time="2025-05-26T10:01:00"
+)
+
+# 2. Erstelle jeweils zwei Measurement-Instanzen für face2
+m1_f2 = Measurement(
+    target=1,
+    direction=Angle.from_gon(372.1589),
+    zenith=Angle.from_gon(302.8283),
+    sd=12.292,
+    atmospheric_data={"pressure": 1013.25},
+    measure_time="2025-05-26T10:02:00"
+)
+m2_f2 = Measurement(
+    target=1,
+    direction=Angle.from_gon(372.1589),
+    zenith=Angle.from_gon(302.8322),
+    sd=12.285,
+    atmospheric_data={"pressure": 1013.25},
+    measure_time="2025-05-26T10:03:00"
+)
+
+# 3. Instanziiere das MeasurementTarget
+target = MeasurementTarget(
+    target=1,
+    direction=Angle.from_gon(172),   # Referenzrichtung
+    zenith=Angle.from_gon(97),       # Referenzzenit
+    distance=12.3                    # Referenzentfernung
+)  # face1 und face2 sind zunächst leere Listen
+
+# 4. Fülle face1 und face2
+target.face1.extend([m1_f1, m2_f1])
+target.face2.extend([m1_f2, m2_f2])
+
+# 5. Optional: Auswertung durchführen
+result = target.evaluation(zero_direction=Angle.from_rad(0))
+
+
+def test_measurement_target_evaluation_practical():
+    # 4) Auswertung prüfen
+    #    Direction: (172.1609 + 172.1659 + (372.1589-200)*2) / 4 ≈ 172.1612 gon
+    assert result.direction.get_gon() == pytest.approx(172.1612, abs=1e-4)
+
+    #    Zenith: (97.1722 + 97.1682 + (400-302.8283) + (400-302.8322)) / 4 ≈ 97.1700 gon
+    assert result.zenith.get_gon() == pytest.approx(97.1700, abs=1e-4)
+
+    #    Slope distance: (12.287 + 12.290 + 12.292 + 12.285) / 4 ≈ 12.2885
+    assert result.slope_distances == pytest.approx(12.2885, abs=1e-4)