Umbenennung, Umstrukturierung, Doc-Strings

ellipsoide.py

@@ -59,6 +59,14 @@ class EllipsoidBiaxial:
     phi2p = lambda self, phi: self.N(phi) * cos(phi)
 
     def bi_cart2ell(self, point: NDArrayself, Eh: float = 0.001, Ephi: float = wu.gms2rad([0, 0, 0.001])) -> Tuple[float, float, float]:
+        """
+        Umrechnung von kartesischen in ellipsoidische Koordinaten auf einem Rotationsellipsoid
+        # TODO: Quelle
+        :param point: Punkt in kartesischen Koordinaten
+        :param Eh: Grenzwert für die Höhe
+        :param Ephi: Grenzwert für die Breite
+        :return: ellipsoidische Breite, Länge, geodätische Höhe
+        """
         x, y, z = point
 
         lamb = arctan2(y, x)
@@ -87,6 +95,14 @@ class EllipsoidBiaxial:
         return phi, lamb, h
 
     def bi_ell2cart(self, phi: float, lamb: float, h: float) -> NDArray:
+        """
+        Umrechnung von ellipsoidischen in kartesische Koordinaten auf einem Rotationsellipsoid
+        # TODO: Quelle
+        :param phi: ellipsoidische Breite
+        :param lamb: ellipsoidische Länge
+        :param h: geodätische Höhe
+        :return: Punkt in kartesischen Koordinaten
+        """
         W = sqrt(1 - self.e**2 * sin(phi)**2)
         N = self.a / W
         x = (N+h) * cos(phi) * cos(lamb)
@@ -112,7 +128,8 @@ class EllipsoidTriaxial:
     @classmethod
     def init_name(cls, name: str):
         """
-        Mögliche Ellipsoide: BursaFialova1993, BursaSima1980, Eitschberger1978, Bursa1972, Bursa1970, BesselBiaxial
+        Mögliche Ellipsoide: BursaFialova1993, BursaSima1980, BursaSima1980round, Eitschberger1978, Bursa1972,
+        Bursa1970, BesselBiaxial, Fiction, KarneyTest2024
         Panou et al (2020)
         :param name: Name des dreiachsigen Ellipsoids
         """
@@ -213,12 +230,9 @@ class EllipsoidTriaxial:
     def ellu2cart(self, beta: float, lamb: float, u: float) -> NDArray:
         """
         Panou 2014 12ff.
-        Elliptische Breite+Länge sind nicht gleich der geodätischen
-        Verhältnisse des Ellipsoids bekannt, Größe verändern bis Punkt erreicht,
-           dann ist u die Größe entlang der z-Achse
-        :param beta: ellipsoidische Breite [rad]
-        :param lamb: ellipsoidische Länge [rad]
-        :param u: Größe entlang der z-Achse
+        :param beta: ellipsoidische Breite
+        :param lamb: ellipsoidische Länge
+        :param u: radiale Koordinate entlang der kleinen Halbachse
         :return: Punkt in kartesischen Koordinaten
         """
         x = sqrt(u**2 + self.Ex**2) * sqrt(cos(beta)**2 + self.Ee**2/self.Ex**2 * sin(beta)**2) * cos(lamb)
@@ -231,7 +245,7 @@ class EllipsoidTriaxial:
         """
         Panou 2014 15ff.
         :param point: Punkt in kartesischen Koordinaten
-        :return: elliptische Breite, elliptische Länge, Größe entlang der z-Achse
+        :return: ellipsoidische Breite, ellipsoidische Länge, radiale Koordinate entlang der kleinen Halbachse
         """
         x, y, z = point
         c2 = self.ax**2 + self.ay**2 + self.b**2 - x**2 - y**2 - z**2
@@ -261,8 +275,8 @@ class EllipsoidTriaxial:
     def ell2cart(self, beta: float | NDArray, lamb: float | NDArray) -> NDArray:
         """
         Panou, Korakitis 2019 2
-        :param beta: elliptische Breite [rad]
-        :param lamb: elliptische Länge [rad]
+        :param beta: ellipsoidische Breite
+        :param lamb: ellipsoidische Länge
         :return: Punkt in kartesischen Koordinaten
         """
         beta = np.asarray(beta, dtype=float)
@@ -297,8 +311,8 @@ class EllipsoidTriaxial:
     def ell2cart_bektas(self, beta: float | NDArray, omega: float | NDArray) -> NDArray:
         """
         Bektas 2015
-        :param beta: elliptische Breite [rad]
-        :param omega: elliptische Länge [rad]
+        :param beta: ellipsoidische Breite
+        :param omega: ellipsoidische Länge
         :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))
@@ -310,8 +324,8 @@ class EllipsoidTriaxial:
     def ell2cart_karney(self, beta: float | NDArray, lamb: float | NDArray) -> NDArray:
         """
         Karney 2025 Geographic Lib
-        :param beta: elliptische Breite [rad]
-        :param lamb: elliptische Länge [rad]
+        :param beta: ellipsoidische Breite
+        :param lamb: ellipsoidische Länge
         :return: Punkt in kartesischen Koordinaten
         """
         k = sqrt(self.ay**2 - self.b**2) / sqrt(self.ax**2 - self.b**2)
@@ -321,11 +335,11 @@ class EllipsoidTriaxial:
         Z = self.b * sin(beta) * sqrt(k**2 + k_**2 * sin(lamb)**2)
         return np.array([X, Y, Z])
 
-    def cart2ell_yFake(self, point: NDArray, start_delta) -> Tuple[float, float]:
+    def cart2ell_yFake(self, point: NDArray) -> Tuple[float, float]:
         """
-
-        :param point:
-        :return:
+        Bei Fehlschlagen von cart2ell
+        :param point: Punkt in kartesischen Koordinaten
+        :return: ellipsoidische Breite und Länge
         """
         x, y, z = point
         delta_y = 1e-4
@@ -363,8 +377,8 @@ class EllipsoidTriaxial:
         :param point:  Punkt in kartesischen Koordinaten
         :param eps: zu erreichende Genauigkeit
         :param maxI: maximale Anzahl Iterationen
-        :param noFake:
-        :return: elliptische Breite und Länge [rad]
+        :param noFake: y numerisch anpassen?
+        :return: ellipsoidische Breite und Länge
         """
         x, y, z = point
         beta, lamb = self.cart2ell_panou(point)
@@ -408,6 +422,7 @@ class EllipsoidTriaxial:
             return beta, lamb
 
         except Exception as e:
+            # Wenn die Berechnung fehlschlägt auf Grund von sehr kleinem y, solange anpassen, bis Umrechnung ohne Fehler
             delta_y = 10 ** math.floor(math.log10(abs(self.ay/1000)))
             if abs(y) < delta_y and not noFake:
                 return self.cart2ell_yFake(point, delta_y)
@@ -418,7 +433,7 @@ class EllipsoidTriaxial:
         """
         Panou, Korakitis 2019 2f. (analytisch -> Näherung)
         :param point: Punkt in kartesischen Koordinaten
-        :return: elliptische Breite, elliptische Länge
+        :return: ellipsoidische Breite und Länge
         """
         x, y, z = point
 
@@ -477,7 +492,7 @@ class EllipsoidTriaxial:
         :param point:  Punkt in kartesischen Koordinaten
         :param eps: zu erreichende Genauigkeit
         :param maxI: maximale Anzahl Iterationen
-        :return: elliptische Breite und Länge [rad]
+        :return: ellipsoidische Breite und Länge
         """
         x, y, z = point
         phi, lamb = self.cart2para(point)
@@ -503,9 +518,9 @@ class EllipsoidTriaxial:
     def geod2cart(self, phi: float | NDArray, lamb: float | NDArray, h: float) -> NDArray:
         """
         Ligas 2012, 250
-        :param phi: geodätische Breite [rad]
-        :param lamb: geodätische Länge [rad]
-        :param h: Höhe über dem Ellipsoid
+        :param phi: geodätische Breite
+        :param lamb: geodätische Länge
+        :param h: geodätische Höhe
         :return: kartesische Koordinaten
         """
         v = self.ax / sqrt(1 - self.ex**2*sin(phi)**2-self.ee**2*cos(phi)**2*sin(lamb)**2)
@@ -521,7 +536,7 @@ class EllipsoidTriaxial:
         :param point: Punkt in kartesischen Koordinaten
         :param maxIter: maximale Anzahl Iterationen
         :param maxLoa: Level of Accuracy, das erreicht werden soll
-        :return: phi, lambda, h
+        :return: geodätische Breite, Länge, Höhe
         """
         xG, yG, zG = point
 
@@ -596,8 +611,8 @@ class EllipsoidTriaxial:
     def para2cart(self, u: float | NDArray, v: float | NDArray) -> NDArray:
         """
         Panou, Korakitits 2020, 4
-        :param u: Parameter u
-        :param v: Parameter v
+        :param u: parametrische Breite
+        :param v: parametrische Länge
         :return: Punkt in kartesischen Koordinaten
         """
         x = self.ax * cos(u) * cos(v)
@@ -610,7 +625,7 @@ class EllipsoidTriaxial:
         """
         Panou, Korakitits 2020, 4
         :param point: Punkt in kartesischen Koordinaten
-        :return: parametrische Koordinaten
+        :return: parametrische Breite, Länge
         """
         x, y, z = point
 
@@ -633,20 +648,20 @@ class EllipsoidTriaxial:
 
     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
+        Umrechung von ellipsoidischen in parametrische Koordinaten (über kartesische Koordinaten)
+        :param beta: ellipsoidische Breite
+        :param lamb: ellipsoidische Länge
+        :return: parametrische Breite, Länge
         """
         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
+        Umrechung von parametrischen in ellipsoidische Koordinaten (über kartesische Koordinaten)
+        :param u: parametrische Breite
+        :param v: parametrische Länge
+        :return: ellipsoidische Breite, Länge
         """
         cart = self.para2cart(u, v)
         return self.cart2ell(cart)
@@ -654,12 +669,12 @@ class EllipsoidTriaxial:
     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 u: parametrische Breite
+        :param v: parametrische 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
+        :return: geodätische Breite, Länge, Höhe
         """
         cart = self.para2cart(u, v)
         return self.cart2geod(cart, mode, maxIter, maxLoa)
@@ -667,41 +682,41 @@ class EllipsoidTriaxial:
     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 phi: geodätische Breite
+        :param lamb: geodätische Länge
         :param h: geodätische Höhe
-        :return: parametrische Koordinaten
+        :return: parametrische Breite, Länge
         """
         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
+        Umrechung von ellipsoidischen in geodätische Koordinaten (über kartesische Koordinaten)
+        :param beta: ellipsoidische Breite
+        :param lamb: ellipsoidische 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
+        :return: geodätische Breite, Länge, Höhe
         """
         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
+        Umrechung von geodätischen in ellipsoidische Koordinaten (über kartesische Koordinaten)
+        :param phi: geodätische Breite
+        :param lamb: geodätische Länge
         :param h: geodätische Höhe
-        :return: elliptische Koordinaten
+        :return: ellipsoidische Breite, Länge
         """
         cart = self.geod2cart(phi, lamb, h)
         return self.cart2ell(cart)
 
     def point_on(self, point: NDArray) -> bool:
         """
-        Test, ob ein Punkt auf dem Ellipsoid liegt.
+        Test, ob ein Punkt auf dem Ellipsoid liegt
         :param point: kartesische 3D-Koordinaten
         :return: Punkt auf dem Ellispoid?
         """