Поменял усреднение

dbapp/mainapp/utils.py

@@ -1413,27 +1413,28 @@ def kub_report(data_in: io.StringIO) -> pd.DataFrame:
 from pyproj import CRS, Transformer
 
 
-def get_gauss_kruger_zone(longitude: float) -> int:
+def get_gauss_kruger_zone(longitude: float) -> int | None:
     """
     Определяет номер зоны Гаусса-Крюгера по долготе.
     
-    Зоны ГК нумеруются от 1 до 60, каждая зона охватывает 6° долготы.
+    Зоны ГК (Пулково 1942) имеют EPSG коды 28404-28432 (зоны 4-32).
-    Центральный меридиан зоны N: (6*N - 3)°
+    Каждая зона охватывает 6° долготы.
     
     Args:
         longitude: Долгота в градусах (от -180 до 180)
         
     Returns:
-        int: Номер зоны ГК (1-60)
+        int | None: Номер зоны ГК (4-32) или None если координаты вне зон ГК
     """
     # Нормализуем долготу к диапазону 0-360
     lon_normalized = longitude if longitude >= 0 else longitude + 360
     # Вычисляем номер зоны (1-60)
     zone = int((lon_normalized + 6) / 6)
-    if zone > 60:
+    
-        zone = 60
+    # EPSG коды Пулково 1942 существуют только для зон 4-32
-    if zone < 1:
+    if zone < 4 or zone > 32:
-        zone = 1
+        return None
+    
     return zone
 
 
@@ -1441,14 +1442,8 @@ def get_gauss_kruger_epsg(zone: int) -> int:
     """
     Возвращает EPSG код для зоны Гаусса-Крюгера (Pulkovo 1942 / Gauss-Kruger).
     
-    EPSG коды для Pulkovo 1942 GK зон:
-    - Зона 4: EPSG:28404
-    - Зона 5: EPSG:28405
-    - ...
-    - Зона N: EPSG:28400 + N
-    
     Args:
-        zone: Номер зоны ГК (1-60)
+        zone: Номер зоны ГК (4-32)
         
     Returns:
         int: EPSG код проекции
@@ -1456,13 +1451,50 @@ def get_gauss_kruger_epsg(zone: int) -> int:
     return 28400 + zone
 
 
+def get_utm_zone(longitude: float) -> int:
+    """
+    Определяет номер зоны UTM по долготе.
+    
+    UTM зоны нумеруются от 1 до 60, каждая зона охватывает 6° долготы.
+    
+    Args:
+        longitude: Долгота в градусах (от -180 до 180)
+        
+    Returns:
+        int: Номер зоны UTM (1-60)
+    """
+    zone = int((longitude + 180) / 6) + 1
+    if zone > 60:
+        zone = 60
+    if zone < 1:
+        zone = 1
+    return zone
+
+
+def get_utm_epsg(zone: int, is_northern: bool = True) -> int:
+    """
+    Возвращает EPSG код для зоны UTM (WGS 84 / UTM).
+    
+    Args:
+        zone: Номер зоны UTM (1-60)
+        is_northern: True для северного полушария, False для южного
+        
+    Returns:
+        int: EPSG код проекции
+    """
+    if is_northern:
+        return 32600 + zone
+    else:
+        return 32700 + zone
+
+
 def transform_wgs84_to_gk(coord: tuple, zone: int = None) -> tuple:
     """
-    Преобразует координаты из WGS84 (EPSG:4326) в проекцию Гаусса-Крюгера.
+    Преобразует координаты из WGS84 в проекцию Гаусса-Крюгера.
     
     Args:
         coord: Координаты в формате (longitude, latitude) в WGS84
-        zone: Номер зоны ГК (если None, определяется автоматически по долготе)
+        zone: Номер зоны ГК (если None, определяется автоматически)
         
     Returns:
         tuple: Координаты (x, y) в метрах в проекции ГК
@@ -1472,9 +1504,11 @@ def transform_wgs84_to_gk(coord: tuple, zone: int = None) -> tuple:
     if zone is None:
         zone = get_gauss_kruger_zone(lon)
     
+    if zone is None:
+        raise ValueError(f"Координаты ({lon}, {lat}) вне зон Гаусса-Крюгера (4-32)")
+    
     epsg_gk = get_gauss_kruger_epsg(zone)
     
-    # Создаём трансформер WGS84 -> GK
     transformer = Transformer.from_crs(
         CRS.from_epsg(4326),
         CRS.from_epsg(epsg_gk),
@@ -1487,7 +1521,7 @@ def transform_wgs84_to_gk(coord: tuple, zone: int = None) -> tuple:
 
 def transform_gk_to_wgs84(coord: tuple, zone: int) -> tuple:
     """
-    Преобразует координаты из проекции Гаусса-Крюгера в WGS84 (EPSG:4326).
+    Преобразует координаты из проекции Гаусса-Крюгера в WGS84.
     
     Args:
         coord: Координаты (x, y) в метрах в проекции ГК
@@ -1499,7 +1533,6 @@ def transform_gk_to_wgs84(coord: tuple, zone: int) -> tuple:
     x, y = coord
     epsg_gk = get_gauss_kruger_epsg(zone)
     
-    # Создаём трансформер GK -> WGS84
     transformer = Transformer.from_crs(
         CRS.from_epsg(epsg_gk),
         CRS.from_epsg(4326),
@@ -1510,37 +1543,126 @@ def transform_gk_to_wgs84(coord: tuple, zone: int) -> tuple:
     return (lon, lat)
 
 
-def calculate_distance_gk(coord1_gk: tuple, coord2_gk: tuple) -> float:
+def transform_wgs84_to_utm(coord: tuple, zone: int = None, is_northern: bool = None) -> tuple:
     """
-    Вычисляет расстояние между двумя точками в проекции ГК (в километрах).
+    Преобразует координаты из WGS84 в проекцию UTM.
     
     Args:
-        coord1_gk: Первая точка (x, y) в метрах
+        coord: Координаты в формате (longitude, latitude) в WGS84
-        coord2_gk: Вторая точка (x, y) в метрах
+        zone: Номер зоны UTM (если None, определяется автоматически)
+        is_northern: Северное полушарие (если None, определяется по широте)
         
     Returns:
-        float: Расстояние в километрах
+        tuple: Координаты (x, y) в метрах в проекции UTM
     """
-    import math
+    lon, lat = coord
-    x1, y1 = coord1_gk
+    
-    x2, y2 = coord2_gk
+    if zone is None:
-    distance_m = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+        zone = get_utm_zone(lon)
-    return distance_m / 1000
+    
+    if is_northern is None:
+        is_northern = lat >= 0
+    
+    epsg_utm = get_utm_epsg(zone, is_northern)
+    
+    transformer = Transformer.from_crs(
+        CRS.from_epsg(4326),
+        CRS.from_epsg(epsg_utm),
+        always_xy=True
+    )
+    
+    x, y = transformer.transform(lon, lat)
+    return (x, y)
 
 
-def average_coords_in_gk(coords: list[tuple], zone: int = None) -> tuple:
+def transform_utm_to_wgs84(coord: tuple, zone: int, is_northern: bool = True) -> tuple:
     """
-    Вычисляет среднее арифметическое координат в проекции Гаусса-Крюгера.
+    Преобразует координаты из проекции UTM в WGS84.
     
-    Алгоритм:
+    Args:
-    1. Определяет зону ГК по первой точке (если не указана)
+        coord: Координаты (x, y) в метрах в проекции UTM
-    2. Преобразует все координаты в проекцию ГК
+        zone: Номер зоны UTM
-    3. Вычисляет среднее арифметическое X и Y
+        is_northern: Северное полушарие
-    4. Преобразует результат обратно в WGS84
+        
+    Returns:
+        tuple: Координаты (longitude, latitude) в WGS84
+    """
+    x, y = coord
+    epsg_utm = get_utm_epsg(zone, is_northern)
+    
+    transformer = Transformer.from_crs(
+        CRS.from_epsg(epsg_utm),
+        CRS.from_epsg(4326),
+        always_xy=True
+    )
+    
+    lon, lat = transformer.transform(x, y)
+    return (lon, lat)
+
+
+def average_coords_in_gk(coords: list[tuple], zone: int = None) -> tuple[tuple, str]:
+    """
+    Вычисляет среднее арифметическое координат в проекции.
+    
+    Приоритет:
+    1. Гаусс-Крюгер (Пулково 1942) для зон 4-32
+    2. UTM для координат вне зон ГК
+    3. Геодезическое усреднение как последний fallback
+    
+    Args:
+        coords: Список координат в формате [(lon1, lat1), (lon2, lat2), ...]
+        zone: Номер зоны (если None, определяется по первой точке)
+        
+    Returns:
+        tuple: (координаты (lon, lat), тип_усреднения)
+               тип_усреднения: "ГК" | "UTM" | "Геод"
+    """
+    if not coords:
+        return (0, 0), "ГК"
+    
+    if len(coords) == 1:
+        return coords[0], "ГК"
+    
+    first_lon, first_lat = coords[0]
+    
+    # Пытаемся использовать Гаусс-Крюгер
+    if zone is None:
+        gk_zone = get_gauss_kruger_zone(first_lon)
+    else:
+        gk_zone = zone if 4 <= zone <= 32 else None
+    
+    # Если координаты в зонах ГК (4-32), используем ГК
+    if gk_zone is not None:
+        try:
+            coords_projected = [transform_wgs84_to_gk(c, gk_zone) for c in coords]
+            avg_x = sum(c[0] for c in coords_projected) / len(coords_projected)
+            avg_y = sum(c[1] for c in coords_projected) / len(coords_projected)
+            return transform_gk_to_wgs84((avg_x, avg_y), gk_zone), "ГК"
+        except Exception:
+            pass  # Fallback на UTM
+    
+    # Fallback на UTM для координат вне зон ГК
+    try:
+        utm_zone = get_utm_zone(first_lon)
+        is_northern = first_lat >= 0
+        
+        coords_utm = [transform_wgs84_to_utm(c, utm_zone, is_northern) for c in coords]
+        avg_x = sum(c[0] for c in coords_utm) / len(coords_utm)
+        avg_y = sum(c[1] for c in coords_utm) / len(coords_utm)
+        return transform_utm_to_wgs84((avg_x, avg_y), utm_zone, is_northern), "UTM"
+    except Exception:
+        # Последний fallback - геодезическое усреднение
+        return _average_coords_geodesic(coords), "Геод"
+
+
+def _average_coords_geodesic(coords: list[tuple]) -> tuple:
+    """
+    Вычисляет среднее координат через последовательное геодезическое усреднение.
+    
+    Используется как fallback при ошибках проекции.
     
     Args:
         coords: Список координат в формате [(lon1, lat1), (lon2, lat2), ...]
-        zone: Номер зоны ГК (если None, определяется по первой точке)
         
     Returns:
         tuple: Средние координаты (longitude, latitude) в WGS84
@@ -1551,19 +1673,12 @@ def average_coords_in_gk(coords: list[tuple], zone: int = None) -> tuple:
     if len(coords) == 1:
         return coords[0]
     
-    # Определяем зону по первой точке
+    # Последовательно усредняем точки
-    if zone is None:
+    result = coords[0]
-        zone = get_gauss_kruger_zone(coords[0][0])
+    for i in range(1, len(coords)):
+        result, _ = calculate_mean_coords(result, coords[i])
     
-    # Преобразуем все координаты в ГК
+    return result
-    coords_gk = [transform_wgs84_to_gk(c, zone) for c in coords]
-    
-    # Вычисляем среднее арифметическое
-    avg_x = sum(c[0] for c in coords_gk) / len(coords_gk)
-    avg_y = sum(c[1] for c in coords_gk) / len(coords_gk)
-    
-    # Преобразуем обратно в WGS84
-    return transform_gk_to_wgs84((avg_x, avg_y), zone)
 
 
 def calculate_mean_coords(coord1: tuple, coord2: tuple) -> tuple[tuple, float]:

dbapp/mainapp/views/points_averaging.py

@@ -317,7 +317,7 @@ class PointsAveragingAPIView(LoginRequiredMixin, View):
             })
         
         # Apply clustering algorithm
-        avg_coord, valid_indices = self._find_cluster_center(points_data)
+        avg_coord, valid_indices, avg_type = self._find_cluster_center(points_data)
         
         # Mark outliers and calculate distances
         outliers = []
@@ -391,6 +391,7 @@ class PointsAveragingAPIView(LoginRequiredMixin, View):
             'has_outliers': len(outliers) > 0,
             'avg_coordinates': avg_coords_str,
             'avg_coord_tuple': avg_coord,
+            'avg_type': avg_type,
             'avg_time': median_time_str,
             'frequency': first_point.get('frequency', '-'),
             'freq_range': first_point.get('freq_range', '-'),
@@ -414,13 +415,13 @@ class PointsAveragingAPIView(LoginRequiredMixin, View):
         If only 1 point, return it as center.
         
         Returns:
-            tuple: (avg_coord, set of valid point indices)
+            tuple: (avg_coord, set of valid point indices, avg_type)
         """
         if len(points_data) == 0:
-            return (0, 0), set()
+            return (0, 0), set(), "ГК"
         
         if len(points_data) == 1:
-            return points_data[0]['coord_tuple'], {0}
+            return points_data[0]['coord_tuple'], {0}, "ГК"
         
         # Step 1: Take first point as reference
         first_coord = points_data[0]['coord_tuple']
@@ -435,35 +436,32 @@ class PointsAveragingAPIView(LoginRequiredMixin, View):
                 valid_indices.add(i)
         
         # Step 3: Calculate average of all valid points using Gauss-Kruger projection
-        avg_coord = self._calculate_average_from_indices(points_data, valid_indices)
+        avg_coord, avg_type = self._calculate_average_from_indices(points_data, valid_indices)
         
-        return avg_coord, valid_indices
+        return avg_coord, valid_indices, avg_type
     
     def _calculate_average_from_indices(self, points_data, indices):
         """
         Calculate average coordinate from points at given indices.
-        Uses arithmetic averaging in Gauss-Kruger projection.
+        Uses arithmetic averaging in Gauss-Kruger or UTM projection.
         
-        Algorithm:
+        Returns:
-        1. Determine GK zone from the first point
+            tuple: (avg_coord, avg_type) where avg_type is "ГК", "UTM" or "Геод"
-        2. Transform all coordinates to GK projection
-        3. Calculate arithmetic mean of X and Y
-        4. Transform result back to WGS84
         """
         indices_list = sorted(indices)
         if not indices_list:
-            return (0, 0)
+            return (0, 0), "ГК"
         
         if len(indices_list) == 1:
-            return points_data[indices_list[0]]['coord_tuple']
+            return points_data[indices_list[0]]['coord_tuple'], "ГК"
         
         # Collect coordinates for averaging
         coords = [points_data[idx]['coord_tuple'] for idx in indices_list]
         
-        # Use Gauss-Kruger projection for averaging
+        # Use Gauss-Kruger/UTM projection for averaging
-        avg_coord = average_coords_in_gk(coords)
+        avg_coord, avg_type = average_coords_in_gk(coords)
         
-        return avg_coord
+        return avg_coord, avg_type
 
 
 class RecalculateGroupAPIView(LoginRequiredMixin, View):
@@ -489,7 +487,7 @@ class RecalculateGroupAPIView(LoginRequiredMixin, View):
         # If include_all is False, use only non-outlier points and apply clustering
         if include_all:
             # Average all points - no outliers, all points are valid
-            avg_coord = self._calculate_average_from_indices(points, set(range(len(points))))
+            avg_coord, avg_type = self._calculate_average_from_indices(points, set(range(len(points))))
             valid_indices = set(range(len(points)))
         else:
             # Filter out outliers first
@@ -499,7 +497,7 @@ class RecalculateGroupAPIView(LoginRequiredMixin, View):
                 return JsonResponse({'error': 'No valid points after filtering'}, status=400)
             
             # Apply clustering algorithm
-            avg_coord, valid_indices = self._find_cluster_center(points)
+            avg_coord, valid_indices, avg_type = self._find_cluster_center(points)
         
         # Mark outliers and calculate distances
         for i, point in enumerate(points):
@@ -560,6 +558,7 @@ class RecalculateGroupAPIView(LoginRequiredMixin, View):
             'success': True,
             'avg_coordinates': avg_coords_str,
             'avg_coord_tuple': avg_coord,
+            'avg_type': avg_type,
             'total_points': len(points),
             'valid_points_count': len(valid_points),
             'outliers_count': len(outliers),
@@ -575,13 +574,13 @@ class RecalculateGroupAPIView(LoginRequiredMixin, View):
         1. Take the first point as reference
         2. Find all points within 56 km of the first point
         3. Calculate average of all found points using Gauss-Kruger projection
-        4. Return final average and indices of valid points
+        4. Return final average, indices of valid points, and averaging type
         """
         if len(points) == 0:
-            return (0, 0), set()
+            return (0, 0), set(), "ГК"
         
         if len(points) == 1:
-            return tuple(points[0]['coord_tuple']), {0}
+            return tuple(points[0]['coord_tuple']), {0}, "ГК"
         
         # Step 1: Take first point as reference
         first_coord = tuple(points[0]['coord_tuple'])
@@ -595,27 +594,30 @@ class RecalculateGroupAPIView(LoginRequiredMixin, View):
             if distance <= RANGE_DISTANCE:
                 valid_indices.add(i)
         
-        # Step 3: Calculate average of all valid points using Gauss-Kruger projection
+        # Step 3: Calculate average of all valid points
-        avg_coord = self._calculate_average_from_indices(points, valid_indices)
+        avg_coord, avg_type = self._calculate_average_from_indices(points, valid_indices)
         
-        return avg_coord, valid_indices
+        return avg_coord, valid_indices, avg_type
     
     def _calculate_average_from_indices(self, points, indices):
         """
         Calculate average coordinate from points at given indices.
-        Uses arithmetic averaging in Gauss-Kruger projection.
+        Uses arithmetic averaging in Gauss-Kruger or UTM projection.
+        
+        Returns:
+            tuple: (avg_coord, avg_type)
         """
         indices_list = sorted(indices)
         if not indices_list:
-            return (0, 0)
+            return (0, 0), "ГК"
         
         if len(indices_list) == 1:
-            return tuple(points[indices_list[0]]['coord_tuple'])
+            return tuple(points[indices_list[0]]['coord_tuple']), "ГК"
         
         # Collect coordinates for averaging
         coords = [tuple(points[idx]['coord_tuple']) for idx in indices_list]
         
-        # Use Gauss-Kruger projection for averaging
+        # Use Gauss-Kruger/UTM projection for averaging
-        avg_coord = average_coords_in_gk(coords)
+        avg_coord, avg_type = average_coords_in_gk(coords)
         
-        return avg_coord
+        return avg_coord, avg_type