pymammotion 0.5.34__py3-none-any.whl → 0.5.53__py3-none-any.whl

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}°")

pymammotion/utility/mur_mur_hash.py

@@ -2,113 +2,158 @@ import struct
 
 
 class MurMurHashUtil:
+    MASK_32 = 0xFFFFFFFF
+    MULTIPLIER = 1540483477
+
     @staticmethod
-    def get_unsigned_int(i):
-        return i & 0xFFFFFFFF
+    def get_unsigned_int(i: int) -> int:
+        """Convert signed int to unsigned (32-bit)"""
+        return i & MurMurHashUtil.MASK_32
 
     @staticmethod
-    def hash(byte_arr: bytes):
-        # Create a bytearray view with little endian order
-        position = 0
-        remaining_bytes = len(byte_arr)
+    def hash(data: bytes) -> int:
+        """MurmurHash2 64-bit implementation"""
+        pos = 0
+        data_len = len(data)
 
-        # Initial values
-        remaining = remaining_bytes ^ 97
+        remaining = data_len ^ 97
         j = 0
 
         # Process 8 bytes at a time
-        while remaining_bytes >= 8:
-            multiplier = 1540483477
-
-            # First 4 bytes
-            unsigned_int = struct.unpack_from("<I", byte_arr, position)[0]
-            position += 4
-            unsigned_int = (MurMurHashUtil.get_unsigned_int(unsigned_int) * multiplier) & 0xFFFFFFFF
-            remaining = (
-                ((remaining * multiplier) & 0xFFFFFFFF)
-                ^ (((unsigned_int ^ (unsigned_int >> 24)) & 0xFFFFFFFF) * multiplier) & 0xFFFFFFFF
-            ) & 0xFFFFFFFF
-
-            # Next 4 bytes
-            unsigned_int2 = struct.unpack_from("<I", byte_arr, position)[0]
-            position += 4
-            unsigned_int2 = (MurMurHashUtil.get_unsigned_int(unsigned_int2) * multiplier) & 0xFFFFFFFF
-            j = (
-                ((j * multiplier) & 0xFFFFFFFF)
-                ^ ((((unsigned_int2 ^ (unsigned_int2 >> 24)) & 0xFFFFFFFF) * multiplier) & 0xFFFFFFFF)
-            ) & 0xFFFFFFFF
-
-            remaining_bytes -= 8
+        while (data_len - pos) >= 8:
+            val1 = struct.unpack_from("<i", data, pos)[0]
+            pos += 4
+
+            unsigned_int_1 = MurMurHashUtil.get_unsigned_int(val1)
+            temp1 = (unsigned_int_1 * MurMurHashUtil.MULTIPLIER) & MurMurHashUtil.MASK_32
+            temp2 = (temp1 ^ (temp1 >> 24)) & MurMurHashUtil.MASK_32
+            temp3 = (temp2 * MurMurHashUtil.MULTIPLIER) & MurMurHashUtil.MASK_32
+
+            remaining = ((remaining * MurMurHashUtil.MULTIPLIER) & MurMurHashUtil.MASK_32) ^ temp3
+            remaining = remaining & MurMurHashUtil.MASK_32
+
+            val2 = struct.unpack_from("<i", data, pos)[0]
+            pos += 4
+
+            unsigned_int_2 = MurMurHashUtil.get_unsigned_int(val2)
+            temp1 = (unsigned_int_2 * MurMurHashUtil.MULTIPLIER) & MurMurHashUtil.MASK_32
+            temp2 = (temp1 ^ (temp1 >> 24)) & MurMurHashUtil.MASK_32
+            temp3 = (temp2 * MurMurHashUtil.MULTIPLIER) & MurMurHashUtil.MASK_32
+
+            j = ((j * MurMurHashUtil.MULTIPLIER) & MurMurHashUtil.MASK_32) ^ temp3
+            j = j & MurMurHashUtil.MASK_32
 
         # Process remaining 4 bytes if available
-        if remaining_bytes >= 4:
-            multiplier = 1540483477
-            unsigned_int3 = struct.unpack_from("<I", byte_arr, position)[0]
-            position += 4
-            unsigned_int3 = (MurMurHashUtil.get_unsigned_int(unsigned_int3) * multiplier) & 0xFFFFFFFF
-            remaining = (
-                ((remaining * multiplier) & 0xFFFFFFFF)
-                ^ ((((unsigned_int3 ^ (unsigned_int3 >> 24)) & 0xFFFFFFFF) * multiplier) & 0xFFFFFFFF)
-            ) & 0xFFFFFFFF
-            remaining_bytes -= 4
-
-        # Process final 1-3 bytes if available
-        if remaining_bytes == 1:
-            j = (
-                ((j ^ (MurMurHashUtil.get_unsigned_int(byte_arr[position]) & 0xFF)) & 0xFFFFFFFF) * 1540483477
-            ) & 0xFFFFFFFF
-        elif remaining_bytes == 2:
-            j = (j ^ ((MurMurHashUtil.get_unsigned_int(byte_arr[position + 1]) & 0xFF) << 8)) & 0xFFFFFFFF
-            j = (
-                ((j ^ (MurMurHashUtil.get_unsigned_int(byte_arr[position]) & 0xFF)) & 0xFFFFFFFF) * 1540483477
-            ) & 0xFFFFFFFF
-        elif remaining_bytes == 3:
-            j = (j ^ ((MurMurHashUtil.get_unsigned_int(byte_arr[position + 2]) & 0xFF) << 16)) & 0xFFFFFFFF
-            j = (j ^ ((MurMurHashUtil.get_unsigned_int(byte_arr[position + 1]) & 0xFF) << 8)) & 0xFFFFFFFF
-            j = (
-                ((j ^ (MurMurHashUtil.get_unsigned_int(byte_arr[position]) & 0xFF)) & 0xFFFFFFFF) * 1540483477
-            ) & 0xFFFFFFFF
-
-        # Final mixing
-        multiplier = 1540483477
-        j5 = (((remaining ^ (j >> 18)) & 0xFFFFFFFF) * multiplier) & 0xFFFFFFFF
-        j6 = (((j ^ (j5 >> 22)) & 0xFFFFFFFF) * multiplier) & 0xFFFFFFFF
-        j7 = (((j5 ^ (j6 >> 17)) & 0xFFFFFFFF) * multiplier) & 0xFFFFFFFF
+        if (data_len - pos) >= 4:
+            val = struct.unpack_from("<i", data, pos)[0]
+            pos += 4
+
+            unsigned_int_3 = MurMurHashUtil.get_unsigned_int(val)
+            temp1 = (unsigned_int_3 * MurMurHashUtil.MULTIPLIER) & MurMurHashUtil.MASK_32
+            temp2 = (temp1 ^ (temp1 >> 24)) & MurMurHashUtil.MASK_32
+            temp3 = (temp2 * MurMurHashUtil.MULTIPLIER) & MurMurHashUtil.MASK_32
+
+            remaining = ((remaining * MurMurHashUtil.MULTIPLIER) & MurMurHashUtil.MASK_32) ^ temp3
+            remaining = remaining & MurMurHashUtil.MASK_32
+
+        # Process tail bytes (1-3 bytes)
+        bytes_remaining = data_len - pos
+
+        if bytes_remaining == 1:
+            byte_val = data[pos] if data[pos] < 128 else data[pos] - 256
+            j = (j ^ (MurMurHashUtil.get_unsigned_int(byte_val) & 255)) & MurMurHashUtil.MASK_32
+            j = (j * MurMurHashUtil.MULTIPLIER) & MurMurHashUtil.MASK_32
+
+        elif bytes_remaining == 2:
+            byte_val1 = data[pos + 1] if data[pos + 1] < 128 else data[pos + 1] - 256
+            j = (j ^ ((MurMurHashUtil.get_unsigned_int(byte_val1) & 255) << 8)) & MurMurHashUtil.MASK_32
+
+            byte_val0 = data[pos] if data[pos] < 128 else data[pos] - 256
+            j = (j ^ (MurMurHashUtil.get_unsigned_int(byte_val0) & 255)) & MurMurHashUtil.MASK_32
+            j = (j * MurMurHashUtil.MULTIPLIER) & MurMurHashUtil.MASK_32
+
+        elif bytes_remaining == 3:
+            byte_val2 = data[pos + 2] if data[pos + 2] < 128 else data[pos + 2] - 256
+            j = (j ^ ((MurMurHashUtil.get_unsigned_int(byte_val2) & 255) << 16)) & MurMurHashUtil.MASK_32
+
+            byte_val1 = data[pos + 1] if data[pos + 1] < 128 else data[pos + 1] - 256
+            j = (j ^ ((MurMurHashUtil.get_unsigned_int(byte_val1) & 255) << 8)) & MurMurHashUtil.MASK_32
+
+            byte_val0 = data[pos] if data[pos] < 128 else data[pos] - 256
+            j = (j ^ (MurMurHashUtil.get_unsigned_int(byte_val0) & 255)) & MurMurHashUtil.MASK_32
+            j = (j * MurMurHashUtil.MULTIPLIER) & MurMurHashUtil.MASK_32
+
+        # Final avalanche
+        j4 = MurMurHashUtil.MULTIPLIER
+
+        j5 = remaining ^ (j >> 18)
+        j5 = (j5 & MurMurHashUtil.MASK_32) * j4
+        j5 = j5 & MurMurHashUtil.MASK_32
+
+        j6 = j ^ (j5 >> 22)
+        j6 = (j6 & MurMurHashUtil.MASK_32) * j4
+        j6 = j6 & MurMurHashUtil.MASK_32
+
+        j7 = j5 ^ (j6 >> 17)
+        j7 = (j7 & MurMurHashUtil.MASK_32) * j4
+        j7 = j7 & MurMurHashUtil.MASK_32
+
+        # Combine high and low parts
         j8 = j7 << 32
 
-        return j8 | ((((j6 ^ (j7 >> 19)) & 0xFFFFFFFF) * multiplier) & 0xFFFFFFFF)
+        low = j6 ^ (j7 >> 19)
+        low = (low & MurMurHashUtil.MASK_32) * j4
+        low = low & MurMurHashUtil.MASK_32
 
-    @staticmethod
-    def hash_unsigned(s: str | bytes) -> None:
-        if isinstance(s, str):
-            return MurMurHashUtil.read_unsigned_long(MurMurHashUtil.hash(s.encode()))
-        elif isinstance(s, bytes) or isinstance(s, bytearray):
-            return MurMurHashUtil.read_unsigned_long(MurMurHashUtil.hash(s))
-        return None
+        result = j8 | low
+
+        # Convert to signed 64-bit
+        if result > 0x7FFFFFFFFFFFFFFF:
+            result = result - 0x10000000000000000
+
+        return result
 
     @staticmethod
-    def long2bytes(value: int) -> bytes:
-        # Convert long to 8 bytes in little-endian order
-        result = bytearray(8)
-        for i in range(8):
-            result[7 - i] = (value >> (i * 8)) & 0xFF
-        return bytes(result)
+    def hash_string(s: str) -> int:
+        """Hash a string using UTF-8 encoding"""
+        return MurMurHashUtil.hash(s.encode("utf-8"))
 
     @staticmethod
     def read_unsigned_long(value: int) -> int:
+        """Convert to unsigned by masking with Long.MAX_VALUE"""
         return value & 0x7FFFFFFFFFFFFFFF
 
     @staticmethod
-    def hash_unsigned_list(long_list: list[int]):
-        byte_arr = b""
-        for i in range(len(long_list)):
-            if i == 0:
-                byte_arr = MurMurHashUtil.long2bytes(long_list[i])
-            else:
-                byte_arr += MurMurHashUtil.long2bytes(long_list[i])
+    def hash_unsigned(data: str | bytes) -> int:
+        """Get unsigned hash value
+        Can accept bytes or string
+        """
+        if isinstance(data, str):
+            hash_val = MurMurHashUtil.hash_string(data)
+        else:
+            hash_val = MurMurHashUtil.hash(data)
 
-        return MurMurHashUtil.read_unsigned_long(MurMurHashUtil.hash(byte_arr))
+        return MurMurHashUtil.read_unsigned_long(hash_val)
 
     @staticmethod
-    def hash_string(s: str):
-        return MurMurHashUtil.hash(s.encode())
+    def long_to_bytes(value: int) -> bytes:
+        """Convert long to bytes exactly as Java does:
+        1. Pack as big-endian (ByteBuffer default)
+        2. Reverse all bytes
+        """
+        if value < 0:
+            value = value & 0xFFFFFFFFFFFFFFFF
+
+        big_endian = struct.pack(">Q", value)
+        return big_endian[::-1]
+
+    @staticmethod
+    def hash_unsigned_list(values: list[int]) -> int:
+        """Hash a list of long values"""
+        data = b""
+
+        for val in values:
+            data += MurMurHashUtil.long_to_bytes(val)
+
+        hash_val = MurMurHashUtil.hash(data)
+        return MurMurHashUtil.read_unsigned_long(hash_val)

{pymammotion-0.5.34.dist-info → pymammotion-0.5.53.dist-info}/METADATA

@@ -1,34 +1,30 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pymammotion
-Version: 0.5.34
-Summary: 
-License: GPL-3.0
-Author: Michael Arthur
-Author-email: michael@jumblesoft.co.nz
-Requires-Python: >=3.10
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: aiohttp (>=3.9.1)
-Requires-Dist: alibabacloud-apigateway-util (>=0.0.2,<0.0.3)
-Requires-Dist: alibabacloud-iot-api-gateway (>=0.0.4,<0.0.5)
-Requires-Dist: alicloud-gateway-iot (>=1.0.0,<2.0.0)
-Requires-Dist: async-timeout (>=4.0.3,<5.0.0)
-Requires-Dist: betterproto2 (>=0.8.0,<0.9.0)
-Requires-Dist: bleak (>=0.21.0)
-Requires-Dist: bleak-retry-connector (>=3.5.0)
-Requires-Dist: crcmod (>=1.7,<2.0)
-Requires-Dist: cryptography (>=43.0.1)
-Requires-Dist: grpclib (>=0.4.8,<0.5.0)
-Requires-Dist: jsonic (>=1.0.0,<2.0.0)
-Requires-Dist: mashumaro (>=3.13,<4.0)
-Requires-Dist: numpy (>=1.26.0)
-Requires-Dist: orjson (>=3.9.15,<4.0.0)
-Requires-Dist: paho-mqtt (>=2.1.0,<3.0.0)
-Requires-Dist: protobuf (>=4.23.1)
-Requires-Dist: py-jsonic (>=0.0.2,<0.0.3)
+Version: 0.5.53
+Author: jLynx
+Author-email: Michael Arthur <michael@jumblesoft.co.nz>
+License-Expression: GPL-3.0
+License-File: LICENSE
+Requires-Python: <4.0,>=3.12
+Requires-Dist: aiohttp>=3.9.1
+Requires-Dist: alibabacloud-apigateway-util<0.0.3,>=0.0.2
+Requires-Dist: alibabacloud-iot-api-gateway<0.0.5,>=0.0.4
+Requires-Dist: alicloud-gateway-iot<2,>=1.0.0
+Requires-Dist: async-timeout<5,>=4.0.3
+Requires-Dist: betterproto2>=0.9.1
+Requires-Dist: bleak-retry-connector>=3.5.0
+Requires-Dist: bleak>=0.21.0
+Requires-Dist: crcmod~=1.7
+Requires-Dist: cryptography>=43.0.1
+Requires-Dist: jsonic<2,>=1.0.0
+Requires-Dist: mashumaro~=3.13
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: orjson<4,>=3.9.15
+Requires-Dist: paho-mqtt<3,>=2.1.0
+Requires-Dist: protobuf>=4.23.1
+Requires-Dist: py-jsonic<0.0.3,>=0.0.2
+Requires-Dist: pyjwt>=2.10.1
+Requires-Dist: shapely>=2.1.2
 Description-Content-Type: text/markdown
 
 # PyMammotion - Python API for Mammotion Mowers [![Discord](https://img.shields.io/discord/1247286396297678879)](https://discord.gg/vpZdWhJX8x)
@@ -97,4 +93,3 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 The trademarks "Mammotion," "Luba," and "Yuka" referenced herein are registered trademarks of their respective owners. The author of this software repository is not affiliated with, endorsed by, or connected to these trademark owners in any way.
 
-