Doc-Strings und Type-Hinting

ellipsoide.py

@@ -154,8 +154,8 @@ class EllipsoidTriaxial:
             return cls(ax, ay, b)
         elif name == "Fiction":
             ax = 6000000
-            ay = 5000000
-            b = 4000000
+            ay = 4000000
+            b = 2000000
             return cls(ax, ay, b)
         elif name == "KarneyTest2024":
             ax = sqrt(2)
@@ -294,9 +294,9 @@ class EllipsoidTriaxial:
     def ell2cart_bektas(self, beta: float | NDArray, omega: float | NDArray) -> NDArray:
         """
         Bektas 2015
-        :param beta:
-        :param omega:
-        :return:
+        :param beta: elliptische Breite [rad]
+        :param omega: elliptische Länge [rad]
+        :return: Punkt in kartesischen Koordinaten
         """
         x = self.ax * cos(omega) * sqrt((self.ax**2 - self.ay**2 * sin(beta)**2 - self.b**2 * cos(beta)**2) / (self.ax**2 - self.b**2))
         y = self.ay * cos(beta) * sin(omega)
@@ -307,9 +307,9 @@ class EllipsoidTriaxial:
     def ell2cart_karney(self, beta: float | NDArray, lamb: float | NDArray) -> NDArray:
         """
         Karney 2025 Geographic Lib
-        :param beta:
-        :param lamb:
-        :return:
+        :param beta: elliptische Breite [rad]
+        :param lamb: elliptische Länge [rad]
+        :return: Punkt in kartesischen Koordinaten
         """
         k = sqrt(self.ay**2 - self.b**2) / sqrt(self.ax**2 - self.b**2)
         k_ = sqrt(self.ax**2 - self.ay**2) / sqrt(self.ax**2 - self.b**2)
@@ -321,10 +321,10 @@ class EllipsoidTriaxial:
     def cart2ell(self, point: NDArray, eps: float = 1e-12, maxI: int = 100) -> Tuple[float, float]:
         """
         Panou, Korakitis 2019 3f. (num)
-        :param point:
-        :param eps:
-        :param maxI:
-        :return:
+        :param point:  Punkt in kartesischen Koordinaten
+        :param eps: zu erreichende Genauigkeit
+        :param maxI: maximale Anzahl Iterationen
+        :return: elliptische Breite und Länge [rad]
         """
         x, y, z = point
         beta, lamb = self.cart2ell_panou(point)
@@ -427,10 +427,10 @@ class EllipsoidTriaxial:
     def cart2ell_bektas(self, point: NDArray, eps: float = 1e-12, maxI: int = 100) -> Tuple[float, float]:
         """
         Bektas 2015
-        :param point:
-        :param eps:
-        :param maxI:
-        :return:
+        :param point:  Punkt in kartesischen Koordinaten
+        :param eps: zu erreichende Genauigkeit
+        :param maxI: maximale Anzahl Iterationen
+        :return: elliptische Breite und Länge [rad]
         """
         x, y, z = point
         phi, lamb = self.cart2para(point)
@@ -575,26 +575,70 @@ class EllipsoidTriaxial:
         return u, v
 
     def ell2para(self, beta: float, lamb: float) -> Tuple[float, float]:
+        """
+        Umrechung von elliptischen in parametrische Koordinaten (über kartesische Koordinaten)
+        :param beta: elliptische Breite
+        :param lamb: elliptische Länge
+        :return: parametrische Koordinaten
+        """
         cart = self.ell2cart(beta, lamb)
         return self.cart2para(cart)
 
     def para2ell(self, u: float, v: float) -> Tuple[float, float]:
+        """
+        Umrechung von parametrischen in elliptische Koordinaten (über kartesische Koordinaten)
+        :param u: u
+        :param v: v
+        :return: elliptische Koordinaten
+        """
         cart = self.para2cart(u, v)
         return self.cart2ell(cart)
 
     def para2geod(self, u: float, v: float, mode: str = "ligas3", maxIter: int = 30, maxLoa: float = 0.005) -> Tuple[float, float, float]:
+        """
+        Umrechung von parametrischen in geodätische Koordinaten (über kartesische Koordinaten)
+        :param u: u
+        :param v: v
+        :param mode: ligas1, ligas2, oder ligas3
+        :param maxIter: maximale Anzahl Iterationen
+        :param maxLoa: Level of Accuracy, das erreicht werden soll
+        :return: geodätische Koordinaten
+        """
         cart = self.para2cart(u, v)
         return self.cart2geod(cart, mode, maxIter, maxLoa)
 
     def geod2para(self, phi: float, lamb: float, h: float) -> Tuple[float, float]:
+        """
+        Umrechung von geodätischen in parametrische Koordinaten (über kartesische Koordinaten)
+        :param phi: u
+        :param lamb: v
+        :param h: geodätische Höhe
+        :return: parametrische Koordinaten
+        """
         cart = self.geod2cart(phi, lamb, h)
         return self.cart2para(cart)
 
     def ell2geod(self, beta: float, lamb: float, mode: str = "ligas3", maxIter: int = 30, maxLoa: float = 0.005) -> Tuple[float, float, float]:
+        """
+        Umrechung von elliptischen in geodätische Koordinaten (über kartesische Koordinaten)
+        :param beta: elliptische Breite
+        :param lamb: eliptische Länge
+        :param mode: ligas1, ligas2, oder ligas3
+        :param maxIter: maximale Anzahl Iterationen
+        :param maxLoa: Level of Accuracy, das erreicht werden soll
+        :return: geodätische Koordinaten
+        """
         cart = self.ell2cart(beta, lamb)
         return self.cart2geod(cart, mode, maxIter, maxLoa)
 
     def geod2ell(self, phi: float, lamb: float, h: float) -> Tuple[float, float]:
+        """
+        Umrechung von geodätischen in elliptische Koordinaten (über kartesische Koordinaten)
+        :param phi: u
+        :param lamb: v
+        :param h: geodätische Höhe
+        :return: elliptische Koordinaten
+        """
         cart = self.geod2cart(phi, lamb, h)
         return self.cart2ell(cart)
 
@@ -610,9 +654,9 @@ class EllipsoidTriaxial:
         else:
             return False
 
-    def cartonell(self, point: NDArray) -> NDArray:
+    def point_onto_ellipsoid(self, point: NDArray) -> NDArray:
         """
-        Berechnung des Lotpunktes auf einem Ellipsoiden
+        Berechnung des Lotpunktes entlang der Normalkrümmung auf einem Ellipsoiden
         :param point: Punkt in kartesischen Koordinaten, der gelotet werden soll
         :return: Lotpunkt in kartesischen Koordinaten
         """
@@ -620,7 +664,7 @@ class EllipsoidTriaxial:
         p = self. geod2cart(phi, lamb, 0)
         return p
 
-    def cartellh(self, point: NDArray, h: float) -> NDArray:
+    def cart_ellh(self, point: NDArray, h: float) -> NDArray:
         """
         Punkt auf Ellipsoid hoch loten
         :param point: Punkt auf dem Ellipsoid