pymammotion 0.2.62__py3-none-any.whl → 0.5.51__py3-none-any.whl

pymammotion/utility/device_type.py

@@ -1,5 +1,53 @@
 from enum import Enum
 
+LubaProductKey = [
+    "a1UBFdq6nNz",
+    "a1x0zHD3Xop",
+    "a1pvCnb3PPu",
+    "a1kweSOPylG",
+    "a1JFpmAV5Ur",
+    "a1BmXWlsdbA",
+    "a1jOhAYOIG8",
+    "a1K4Ki2L5rK",
+    "a1ae1QnXZGf",
+    "a1nf9kRBWoH",
+    "a1ZU6bdGjaM",
+]
+
+LubaVProductKey = ["a1iMygIwxFC", "a1LLmy1zc0j", "a1LLmy1zc0j"]
+
+LubaVProProductKey = ["a1mb8v6tnAa", "a1pHsTqyoPR"]
+
+Luba2MiniProductKey = ["a1L5ZfJIxGl", "a1dCWYFLROK"]
+
+YukaProductKey = ["a1kT0TlYEza", "a1IQV0BrnXb"]
+
+YukaPlusProductKey = ["a1lNESu9VST", "a1zAEzmvWDa"]
+
+YukaMiniProductKey = ["a1BqmEWMRbX", "a1biqVGvxrE"]
+
+RTKProductKey = ["a1qXkZ5P39W", "a1Nc68bGZzX"]
+
+YukaMVProductKey = ["a1jFe8HzcDb", "a16cz0iXgUJ", "USpE46bNTC7", "pdA6uJrBfjz"]
+
+LubaLDProductKey = ["a1jDMfG2Fgj", "a1vtZq9LUFS"]
+
+LubaVAProductKey = ["a1Ce85210Be", "a1BBOJnnjb9"]
+
+YukaMLProductKey = ["a1OWGO8WXbh", "a1s6znKxGvI"]
+
+LubaMDProductKey = ["a1T6VTFTc0C", "a14iRDqMepW"]
+
+LubaMBProductKey = ["a1pb9toor70"]
+
+RTKNBProductKey = ["a1NfZqdSREf", "a1ZuQVL7UiN"]
+
+LubaLAProductKey = ["CDYuKXTYrSP"]
+
+YukaMN100ProductKey = ["NnbeYtaEUGE"]
+
+Cm900ProductKey = ["zkRuTK9KsXG", "6DbgVh2Qs5m"]
+
 
 class DeviceType(Enum):
     UNKNOWN = (-1, "UNKNOWN", "Unknown")
@@ -10,6 +58,24 @@ class DeviceType(Enum):
     YUKA_MINI = (4, "Yuka-MN", "Yuka Mini")
     YUKA_MINI2 = (5, "Yuka-YM", "Yuka Mini 2")
     LUBA_VP = (6, "Luba-VP", "Luba VP")
+    LUBA_MN = (7, "Luba-MN", "HM430")
+    YUKA_VP = (8, "Yuka-VP", "MN241")
+    SPINO = (9, "Spino", "Spino")
+    RTK3A1 = (10, "RBSA1", "RBS03A1")
+    LUBA_LD = (11, "Luba-LD", "HM431")
+    RTK3A0 = (12, "RBSA0", "RBS03A0")
+    RTK3A2 = (13, "RBSA2", "RBS03A2")
+    YUKA_MINIV = (14, "Yuka-MV", "MN231")
+    LUBA_VA = (15, "Luba-VA", "HM442")
+    YUKA_ML = (16, "Yuka-ML", "MN232")
+    LUBA_MD = (17, "Luba-MD", "HM433")
+    LUBA_LA = (18, "Luba-LA", "HM432")
+    SWIMMINGPOOL_S1 = (19, "Spino-S1", "Spino-S1")
+    SWIMMINGPOOL_E1 = (20, "Spino-E1", "Spino-E1")
+    YUKA_MN100 = (21, "Ezy-VT", "MN100")
+    RTKNB = (22, "NB", "NB")
+    LUBA_MB = (23, "Luba-MB", "HM434")
+    CM900 = (24, "Kumar-MK", "KM01")
 
     def __init__(self, value: int, name: str, model: str) -> None:
         self._value = value
@@ -58,6 +124,44 @@ class DeviceType(Enum):
             return DeviceType.YUKA_MINI
         elif value == 5:
             return DeviceType.YUKA_MINI2
+        elif value == 6:
+            return DeviceType.LUBA_VP
+        elif value == 7:
+            return DeviceType.LUBA_MN
+        elif value == 8:
+            return DeviceType.YUKA_VP
+        elif value == 9:
+            return DeviceType.SPINO
+        elif value == 10:
+            return DeviceType.RTK3A1
+        elif value == 11:
+            return DeviceType.LUBA_LD
+        elif value == 12:
+            return DeviceType.RTK3A0
+        elif value == 13:
+            return DeviceType.RTK3A2
+        elif value == 14:
+            return DeviceType.YUKA_MINIV
+        elif value == 15:
+            return DeviceType.LUBA_VA
+        elif value == 16:
+            return DeviceType.YUKA_ML
+        elif value == 17:
+            return DeviceType.LUBA_MD
+        elif value == 18:
+            return DeviceType.LUBA_LA
+        elif value == 19:
+            return DeviceType.SWIMMINGPOOL_S1
+        elif value == 20:
+            return DeviceType.SWIMMINGPOOL_E1
+        elif value == 21:
+            return DeviceType.YUKA_MN100
+        elif value == 22:
+            return DeviceType.RTKNB
+        elif value == 23:
+            return DeviceType.LUBA_MB
+        elif value == 24:
+            return DeviceType.CM900
         else:
             return DeviceType.UNKNOWN
 
@@ -86,14 +190,52 @@ class DeviceType(Enum):
                 return DeviceType.RTK
             elif DeviceType.LUBA_2.get_name() in substring2 or DeviceType.contain_luba_2_product_key(product_key):
                 return DeviceType.LUBA_2
-            elif DeviceType.LUBA_YUKA.get_name() in substring2:
-                return DeviceType.LUBA_YUKA
+            elif DeviceType.LUBA_LD.get_name() in substring2:
+                return DeviceType.LUBA_LD
+            elif DeviceType.LUBA_VP.get_name() in substring2:
+                return DeviceType.LUBA_VP
+            elif DeviceType.LUBA_MN.get_name() in substring2:
+                return DeviceType.LUBA_MN
+            elif DeviceType.YUKA_VP.get_name() in substring2:
+                return DeviceType.YUKA_VP
             elif DeviceType.YUKA_MINI.get_name() in substring2:
                 return DeviceType.YUKA_MINI
             elif DeviceType.YUKA_MINI2.get_name() in substring2:
                 return DeviceType.YUKA_MINI2
+            elif DeviceType.LUBA_YUKA.get_name() in substring2:
+                return DeviceType.LUBA_YUKA
             elif DeviceType.LUBA.get_name() in substring2 or DeviceType.contain_luba_product_key(product_key):
                 return DeviceType.LUBA
+            elif DeviceType.SPINO.get_name() in substring2:
+                return DeviceType.SPINO
+            elif DeviceType.RTK3A1.get_name() in substring2:
+                return DeviceType.RTK3A1
+            elif DeviceType.RTK3A0.get_name() in substring2:
+                return DeviceType.RTK3A0
+            elif DeviceType.RTK3A2.get_name() in substring2:
+                return DeviceType.RTK3A2
+            elif DeviceType.YUKA_MINIV.get_name() in substring2:
+                return DeviceType.YUKA_MINIV
+            elif DeviceType.LUBA_VA.get_name() in substring2:
+                return DeviceType.LUBA_VA
+            elif DeviceType.YUKA_ML.get_name() in substring2:
+                return DeviceType.YUKA_ML
+            elif DeviceType.LUBA_MD.get_name() in substring2:
+                return DeviceType.LUBA_MD
+            elif DeviceType.LUBA_LA.get_name() in substring2:
+                return DeviceType.LUBA_LA
+            elif DeviceType.SWIMMINGPOOL_S1.get_name() in substring2:
+                return DeviceType.SWIMMINGPOOL_S1
+            elif DeviceType.SWIMMINGPOOL_E1.get_name() in substring2:
+                return DeviceType.SWIMMINGPOOL_E1
+            elif DeviceType.YUKA_MN100.get_name() in substring2:
+                return DeviceType.YUKA_MN100
+            elif DeviceType.RTKNB.get_name() in substring2:
+                return DeviceType.RTKNB
+            elif DeviceType.LUBA_MB.get_name() in substring2:
+                return DeviceType.LUBA_MB
+            elif DeviceType.CM900.get_name() in substring2:
+                return DeviceType.CM900
             else:
                 return DeviceType.UNKNOWN
         except Exception:
@@ -149,7 +291,7 @@ class DeviceType(Enum):
         return device_type.get_value() == DeviceType.LUBA.get_value()
 
     @staticmethod
-    def is_luba_2(device_name: str, product_key: str = ""):
+    def is_luba_pro(device_name: str, product_key: str = ""):
         """Check if the device type is LUBA 2 or higher based on the device name
         and optional product key.
 
@@ -167,7 +309,11 @@ class DeviceType(Enum):
         else:
             device_type = DeviceType.value_of_str(device_name, product_key)
 
-        return device_type.get_value() >= DeviceType.LUBA_2.get_value()
+        return (
+            device_type.get_value() >= DeviceType.LUBA_2.get_value()
+            and device_type.get_value() != DeviceType.SPINO.get_value()
+            and not DeviceType.is_rtk(device_name, product_key)
+        )
 
     @staticmethod
     def is_yuka(device_name: str):
@@ -183,8 +329,33 @@ class DeviceType(Enum):
 
         return (
             DeviceType.value_of_str(device_name).get_value() == DeviceType.LUBA_YUKA.get_value()
+            or DeviceType.value_of_str(device_name).get_value() == DeviceType.YUKA_VP.get_value()
             or DeviceType.value_of_str(device_name).get_value() == DeviceType.YUKA_MINI.get_value()
             or DeviceType.value_of_str(device_name).get_value() == DeviceType.YUKA_MINI2.get_value()
+            or DeviceType.value_of_str(device_name).get_value() == DeviceType.YUKA_MINIV.get_value()
+            or DeviceType.value_of_str(device_name).get_value() == DeviceType.YUKA_ML.get_value()
+            or DeviceType.value_of_str(device_name).get_value() == DeviceType.YUKA_MN100.get_value()
+        )
+
+    @staticmethod
+    def is_yuka_mini(device_name: str):
+        return (
+            DeviceType.value_of_str(device_name).get_value() == DeviceType.YUKA_MINI.get_value()
+            or DeviceType.value_of_str(device_name).get_value() == DeviceType.YUKA_MINI2.get_value()
+        )
+
+    @staticmethod
+    def is_mini_or_x_series(device_name: str):
+        """IsNewDeviceType returns if a device is part of the x or mini series."""
+
+        return (
+            DeviceType.value_of_str(device_name).get_value() == DeviceType.YUKA_MINI.get_value()
+            or DeviceType.value_of_str(device_name).get_value() == DeviceType.YUKA_MINI2.get_value()
+            or DeviceType.value_of_str(device_name).get_value() == DeviceType.YUKA_MINIV.get_value()
+            or DeviceType.value_of_str(device_name).get_value() == DeviceType.YUKA_VP.get_value()
+            or DeviceType.value_of_str(device_name).get_value() == DeviceType.LUBA_MN.get_value()
+            or DeviceType.value_of_str(device_name).get_value() == DeviceType.LUBA_VP.get_value()
+            or DeviceType.value_of_str(device_name).get_value() == DeviceType.LUBA_LD.get_value()
         )
 
     @staticmethod
@@ -209,7 +380,13 @@ class DeviceType(Enum):
         else:
             device_type = DeviceType.value_of_str(device_name, product_key)
 
-        return DeviceType.RTK.get_value() <= device_type.get_value() < DeviceType.LUBA.get_value()
+        return (
+            DeviceType.RTK.get_value() == device_type.get_value()
+            or DeviceType.RTK3A0.get_value() == device_type.get_value()
+            or DeviceType.RTK3A1.get_value() == device_type.get_value()
+            or DeviceType.RTK3A2.get_value() == device_type.get_value()
+            or DeviceType.RTKNB.get_value() == device_type.get_value()
+        )
 
     @staticmethod
     def contain_rtk_product_key(product_key) -> bool:
@@ -226,7 +403,7 @@ class DeviceType(Enum):
 
         if not product_key:
             return False
-        return product_key in ["a1qXkZ5P39W", "a1Nc68bGZzX"]
+        return product_key in RTKProductKey
 
     @staticmethod
     def contain_luba_product_key(product_key) -> bool:
@@ -242,19 +419,7 @@ class DeviceType(Enum):
 
         if not product_key:
             return False
-        return product_key in [
-            "a1UBFdq6nNz",
-            "a1x0zHD3Xop",
-            "a1pvCnb3PPu",
-            "a1kweSOPylG",
-            "a1JFpmAV5Ur",
-            "a1BmXWlsdbA",
-            "a1jOhAYOIG8",
-            "a1K4Ki2L5rK",
-            "a1ae1QnXZGf",
-            "a1nf9kRBWoH",
-            "a1ZU6bdGjaM",
-        ]
+        return product_key in LubaProductKey
 
     @staticmethod
     def contain_luba_2_product_key(product_key) -> bool:
@@ -270,7 +435,7 @@ class DeviceType(Enum):
 
         if not product_key:
             return False
-        return product_key in ["a1iMygIwxFC", "a1LLmy1zc0j", "a1LLmy1zc0j"]
+        return product_key in LubaVProductKey
 
     @staticmethod
     def contain_yuka_product_key(product_key) -> bool:
@@ -286,7 +451,39 @@ class DeviceType(Enum):
 
         if not product_key:
             return False
-        return product_key in ["a1IQV0BrnXb"]
+        return product_key in YukaProductKey
+
+    @staticmethod
+    def contain_yuka_mini_product_key(product_key) -> bool:
+        """Check if the given product key is present in a predefined list.
+
+        Args:
+            product_key (str): The product key to be checked.
+
+        Returns:
+            bool: True if the product key is in the predefined list, False otherwise.
+
+        """
+
+        if not product_key:
+            return False
+        return product_key in YukaMiniProductKey
+
+    @staticmethod
+    def contain_yuka_plus_product_key(product_key) -> bool:
+        """Check if the given product key is present in a predefined list.
+
+        Args:
+            product_key (str): The product key to be checked.
+
+        Returns:
+            bool: True if the product key is in the predefined list, False otherwise.
+
+        """
+
+        if not product_key:
+            return False
+        return product_key in YukaPlusProductKey
 
     def is_support_video(self):
         return self != DeviceType.LUBA

pymammotion/utility/map.py

@@ -1,72 +1,259 @@
 import math
 
 import numpy as np
+from numpy.typing import NDArray
 
-from pymammotion.data.model.location import Point
+from pymammotion.data.model.location import LocationPoint
 
 
 class CoordinateConverter:
-    def __init__(self, latitude_rad: float, longitude_rad: float) -> None:
-        # Initialize constants
-        self.WGS84A = 6378137.0
-        self.f_ = 3.3528106647474805e-21
-        self.b_ = (1.0 - self.f_) * self.WGS84A
-        self.e2_ = (2.0 - self.f_) * self.f_
-        self.e2m_ = (1.0 - self.f_) * (1.0 - self.f_)
-        self.ep2_ = ((self.WGS84A**2) - (self.b_**2)) / (self.b_**2)
-
-        # Initialize rotation matrix
-        self.R_ = np.zeros((3, 3))
-
-        # Variables to store initial LLA
-        self.x0_ = 0.0
-        self.y0_ = 0.0
-        self.z0_ = 0.0
-
-        # Call set_init_lla with provided lat/lon
-        self.set_init_lla(latitude_rad, longitude_rad)
-
-    def set_init_lla(self, lat_rad, lon_rad) -> None:
+    """Converts between ENU (East-North-Up) and LLA (Latitude-Longitude-Altitude) coordinate systems.
+
+    Uses WGS84 ellipsoid model for Earth coordinate transformations.
+    """
+
+    # WGS84 ellipsoid constants
+    WGS84A: float = 6378137.0  # Semi-major axis (equatorial radius) in meters
+    FLATTENING: float = 0.0033528106647474805  # WGS84 flattening factor
+
+    def __init__(self, latitude_rad: float, longitude_rad: float, yaw_rad: float = 0.0) -> None:
+        """Initialize the coordinate converter.
+
+        Args:
+            latitude_rad: Reference latitude in radians
+            longitude_rad: Reference longitude in radians
+            yaw_rad: Reference yaw angle in radians (default: 0.0)
+
+        """
+        # WGS84 ellipsoid parameters
+        self.semi_major_axis: float = self.WGS84A
+        self.flattening: float = self.FLATTENING
+        self.semi_minor_axis: float = (1.0 - self.flattening) * self.WGS84A
+
+        # Eccentricity parameters
+        self.first_eccentricity_squared: float = (2.0 - self.flattening) * self.flattening
+        self.eccentricity_ratio_squared: float = (1.0 - self.flattening) * (1.0 - self.flattening)
+        self.second_eccentricity_squared: float = (self.semi_major_axis**2 - self.semi_minor_axis**2) / (
+            self.semi_minor_axis**2
+        )
+
+        # Rotation matrix for coordinate transformation
+        self.rotation_matrix: NDArray[np.float64] = np.zeros((3, 3), dtype=np.float64)
+
+        # ECEF origin coordinates
+        self.x0: float = 0.0
+        self.y0: float = 0.0
+        self.z0: float = 0.0
+
+        # Yaw angle
+        self.yaw: float = yaw_rad
+
+        # Initialize with provided reference point
+        self.set_init_lla(latitude_rad, longitude_rad, yaw_rad)
+
+    def set_init_lla(self, latitude_rad: float, longitude_rad: float, yaw_rad: float = 0.0) -> None:
+        """Set the initial LLA reference point and yaw angle.
+
+        Args:
+            latitude_rad: Reference latitude in radians
+            longitude_rad: Reference longitude in radians
+            yaw_rad: Reference yaw angle in radians (default: 0.0)
+
+        """
+        self.yaw = yaw_rad
+
+        sin_lat = math.sin(latitude_rad)
+        cos_lat = math.cos(latitude_rad)
+        sin_lon = math.sin(longitude_rad)
+        cos_lon = math.cos(longitude_rad)
+
+        # Radius of curvature in the prime vertical
+        N = self.semi_major_axis / math.sqrt(1.0 - self.first_eccentricity_squared * (sin_lat**2))
+
+        # Calculate ECEF origin coordinates (altitude = 0)
+        horizontal_distance = N * cos_lat
+        self.x0 = horizontal_distance * cos_lon
+        self.y0 = horizontal_distance * sin_lon
+        self.z0 = self.eccentricity_ratio_squared * N * sin_lat
+
+        # Build rotation matrix (ECEF to ENU)
+        self.rotation_matrix[0, 0] = -sin_lon
+        self.rotation_matrix[0, 1] = cos_lon
+        self.rotation_matrix[0, 2] = 0.0
+
+        self.rotation_matrix[1, 0] = -cos_lon * sin_lat
+        self.rotation_matrix[1, 1] = -sin_lon * sin_lat
+        self.rotation_matrix[1, 2] = cos_lat
+
+        self.rotation_matrix[2, 0] = cos_lon * cos_lat
+        self.rotation_matrix[2, 1] = sin_lon * cos_lat
+        self.rotation_matrix[2, 2] = sin_lat
+
+    def enu_to_lla(self, east: float, north: float) -> LocationPoint:
+        """Convert ENU (East-North-Up) coordinates to LLA (Latitude-Longitude-Altitude).
+
+        Args:
+            east: East coordinate in meters
+            north: North coordinate in meters
+
+        Returns:
+            Point with latitude and longitude in degrees
+
+        """
+        # Transform ENU to ECEF (Earth-Centered, Earth-Fixed) coordinates
+        # using rotation matrix and origin offset
+        ecef_x = self.rotation_matrix[0, 0] * north + self.rotation_matrix[1, 0] * east + self.x0
+        ecef_y = self.rotation_matrix[0, 1] * north + self.rotation_matrix[1, 1] * east + self.y0
+        ecef_z = self.rotation_matrix[0, 2] * north + self.rotation_matrix[1, 2] * east + self.z0
+
+        # Calculate horizontal distance from Earth's axis
+        horizontal_distance = math.hypot(ecef_x, ecef_y)
+
+        # Initial latitude estimate using simplified formula
+        initial_latitude = math.atan2(self.semi_major_axis * ecef_z, self.semi_minor_axis * horizontal_distance)
+
+        sin_initial_lat = math.sin(initial_latitude)
+        cos_initial_lat = math.cos(initial_latitude)
+
+        # Calculate longitude (straightforward conversion from ECEF)
+        longitude_deg = math.degrees(math.atan2(ecef_y, ecef_x))
+
+        # Calculate precise latitude using iterative correction
+        # This accounts for Earth's ellipsoidal shape
+        latitude_rad = math.atan2(
+            ecef_z + self.second_eccentricity_squared * self.semi_minor_axis * (sin_initial_lat**3),
+            horizontal_distance - self.first_eccentricity_squared * self.semi_major_axis * (cos_initial_lat**3),
+        )
+        latitude_deg = math.degrees(latitude_rad)
+
+        return LocationPoint(latitude=latitude_deg, longitude=longitude_deg)
+
+    def lla_to_enu(self, longitude_deg: float, latitude_deg: float) -> list[float]:
+        """Convert LLA (Latitude-Longitude-Altitude) to ENU (East-North-Up) coordinates.
+
+        Args:
+            longitude_deg: Longitude in degrees
+            latitude_deg: Latitude in degrees
+
+        Returns:
+            List of [east, north] coordinates in meters
+
+        """
+        # Convert to radians
+        lat_rad = math.radians(latitude_deg)
+        lon_rad = math.radians(longitude_deg)
+
         sin_lat = math.sin(lat_rad)
         cos_lat = math.cos(lat_rad)
         sin_lon = math.sin(lon_rad)
         cos_lon = math.cos(lon_rad)
 
-        sqrt = self.WGS84A / math.sqrt(1.0 - (self.e2_ * (sin_lat**2)))
-        d3 = sqrt * cos_lat
+        # Calculate radius of curvature
+        N = self.semi_major_axis / math.sqrt(1.0 - self.first_eccentricity_squared * (sin_lat**2))
 
-        self.x0_ = d3 * cos_lon
-        self.y0_ = d3 * sin_lon
-        self.z0_ = self.e2m_ * sqrt * sin_lat
+        # Convert to ECEF (altitude = 0)
+        horizontal = N * cos_lat
+        ecef_x = horizontal * cos_lon
+        ecef_y = horizontal * sin_lon
+        ecef_z = self.eccentricity_ratio_squared * N * sin_lat
 
-        self.R_[0][0] = -sin_lon
-        self.R_[0][1] = cos_lon
-        self.R_[0][2] = 0.0
+        # Translate to origin
+        dx = ecef_x - self.x0
+        dy = ecef_y - self.y0
+        dz = ecef_z - self.z0
 
-        self.R_[1][0] = -cos_lon * sin_lat
-        self.R_[1][1] = -sin_lon * sin_lat
-        self.R_[1][2] = cos_lat
+        # Rotate to ENU frame
+        east = self.rotation_matrix[0, 0] * dx + self.rotation_matrix[0, 1] * dy + self.rotation_matrix[0, 2] * dz
+        north = self.rotation_matrix[1, 0] * dx + self.rotation_matrix[1, 1] * dy + self.rotation_matrix[1, 2] * dz
 
-        self.R_[2][0] = cos_lon * cos_lat
-        self.R_[2][1] = sin_lon * cos_lat
-        self.R_[2][2] = sin_lat
+        # Apply yaw rotation (inverse)
+        rotated_east = math.cos(-self.yaw) * east - math.sin(-self.yaw) * north
+        rotated_north = math.sin(-self.yaw) * east + math.cos(-self.yaw) * north
 
-    def enu_to_lla(self, e, n) -> Point:
-        d3 = self.R_[0][0] * n + self.R_[1][0] * e + self.x0_
-        d4 = self.R_[0][1] * n + self.R_[1][1] * e + self.y0_
-        d5 = self.R_[0][2] * n + self.R_[1][2] * e + self.z0_
+        return [round(rotated_east, 3), round(rotated_north, 3)]
 
-        hypot = math.hypot(d3, d4)
-        atan2_lat = math.atan2(self.WGS84A * d5, self.b_ * hypot)
+    def get_transform_yaw_with_yaw(self, yaw_degrees: float) -> float:
+        """Transform a yaw angle from global coordinates to local coordinates.
 
-        sin_lat = math.sin(atan2_lat)
-        cos_lat = math.cos(atan2_lat)
+        This applies the inverse of the reference yaw rotation to convert a global
+        heading angle into the local coordinate frame.
 
-        lon = math.atan2(d4, d3) * 180.0 / math.pi
-        lat = (
-            math.atan2(d5 + self.ep2_ * self.b_ * (sin_lat**3), hypot - self.e2_ * self.WGS84A * (cos_lat**3))
-            * 180.0
-            / math.pi
-        )
+        Args:
+            yaw_degrees: Input yaw angle in degrees
+
+        Returns:
+            Transformed yaw angle in degrees
+
+        """
+        # Convert input angle to radians
+        yaw_rad = math.radians(yaw_degrees)
+
+        # Apply inverse rotation: -self.yaw
+        inverse_yaw = -self.yaw
+
+        # Using angle addition formula: atan2(sin(a+b), cos(a+b))
+        # where a = inverse_yaw, b = yaw_rad
+        sin_sum = math.sin(inverse_yaw) * math.cos(yaw_rad) + math.cos(inverse_yaw) * math.sin(yaw_rad)
+        cos_sum = math.cos(inverse_yaw) * math.cos(yaw_rad) - math.sin(inverse_yaw) * math.sin(yaw_rad)
+
+        # Calculate resulting angle and convert back to degrees
+        result_rad = math.atan2(sin_sum, cos_sum)
+        result_degrees = math.degrees(result_rad)
+
+        return result_degrees
+
+    def get_angle_yaw(self) -> float:
+        """Get the current yaw angle in degrees.
+
+        Returns:
+            Yaw angle in degrees
+
+        """
+        return math.degrees(self.yaw)
+
+    def get_yaw(self) -> float:
+        """Get the current yaw angle in radians.
+
+        Returns:
+            Yaw angle in radians
+
+        """
+        return self.yaw
+
+    def set_yaw(self, yaw_rad: float) -> None:
+        """Set the yaw angle.
+
+        Args:
+            yaw_rad: Yaw angle in radians
+
+        """
+        self.yaw = yaw_rad
+
+    def set_yaw_degrees(self, yaw_degrees: float) -> None:
+        """Set the yaw angle from degrees.
+
+        Args:
+            yaw_degrees: Yaw angle in degrees
+
+        """
+        self.yaw = math.radians(yaw_degrees)
+
+
+# Usage example
+if __name__ == "__main__":
+    # Initialize converter with reference point
+    converter = CoordinateConverter(
+        latitude_rad=math.radians(40.0), longitude_rad=math.radians(-105.0), yaw_rad=math.radians(45.0)
+    )
+
+    # Convert ENU to LLA
+    point = converter.enu_to_lla(east=100.0, north=200.0)
+    print(f"Latitude: {point.latitude}, Longitude: {point.longitude}")
+
+    # Convert LLA to ENU
+    enu = converter.lla_to_enu(longitude_deg=-105.0, latitude_deg=40.0)
+    print(f"East: {enu[0]}, North: {enu[1]}")
 
-        return Point(latitude=lat, longitude=lon)
+    # Transform yaw angle
+    transformed_yaw = converter.get_transform_yaw_with_yaw(90.0)
+    print(f"Transformed yaw: {transformed_yaw}°")