Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,177 @@
+# CUSTOM
+.gradio
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

README.md

@@ -1,12 +1,6 @@
 ---
-title: Radar Image Quality
-emoji: 🔥
-colorFrom: yellow
-colorTo: green
+title: radar_image_quality
+app_file: app_gradio.py
 sdk: gradio
-sdk_version: 5.25.2
-app_file: app.py
-pinned: false
+sdk_version: 5.23.3
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app_backend.py

@@ -0,0 +1,567 @@
+"""
+Модуль для расчета параметров РЛС по модели бистатической РЛС
+Автор кода: Владислав Калинников
+"""
+
+import math as mt
+from typing import List
+
+# скорость света в вакууме, м|с
+C = 299792458
+# постоянная Больцмана, Дж/К
+BOLTZMANN = 1.38 * 10 ** (-23)
+# температура предатчика/приемника, К
+RADAR_TEMPERATURE = 290
+
+# ширина антенны, м
+# ANTENNA_WIDTH = 0.08
+# длина антенны, м
+# ANTENNA_LENGTH = 0.25
+# коэффициент усиления антенны, дБ
+# ANTENNA_GAIN = 14
+# длина волны, м
+# WAVELENGTH = 0.032
+# пиковая мощность, ВТ
+# PEAK_POWER = 10
+# полоса пропускания, МГц
+# BANDWIDTH = 1000
+# шум-фактор, дБ
+# NOISE_FACTOR = 3
+
+# коэффициент заполнения
+# q_fill = 0.08
+# угол поляризации, град. 0 - горизонтальная поляризация, 90 - вертикальная поляризация
+# POLATIZATION_TILT_ANGLE = 0
+
+
+# функция определяет координаты углов области пересечения проекций на земную поверхность главных лепестков
+# point_name - имя точки (A,B,C,D), по умолчанию равно A
+# h - высота полета в м, uav_interval - размер базы между РЛС, м
+# psi_t - угол курса оси главного лепестка ДНА на излучение (по часовой стрелке>0, против часовой <0), град
+# psi_r - угол курса оси главного лепестка ДНА на прием (по часовой стрелке>0, против часовой <0), град
+def footprint_corner_crd(
+    point_name: str,
+    h: float,
+    uav_interval: float,
+    psi_t: float,
+    psi_r: float,
+    wavelength: float,
+    antenna_length: float,
+):
+    # угловой размер главного главного лепестка по азимуту
+    theta = wavelength / antenna_length
+    # угол курса главного лепестка ДНА на излучение в радианах
+    psi_t = psi_t * mt.pi / 180
+    # угол курса главного лепестка ДНА на прием в радианах
+    psi_r = psi_r * mt.pi / 180
+    if psi_r - psi_t > theta:
+        # начальные значения поправок угла курса точки относительно РЛС1 и РЛС2
+        dpsi_1 = 0.1
+        dpsi_2 = 0.1
+        # начальные обновленные значения поправок угла курса точки относительно РЛС1 и РЛС2
+        dpsi_1upd = 0
+        dpsi_2upd = 0
+        # коэффициенты для расчета углов места и углов курса точки относительно РЛС1 и РЛС2
+        k1 = 1
+        k2 = 1
+        if point_name == "B":
+            k1 = 1
+            k2 = -1
+        elif point_name == "C":
+            k1 = -1
+            k2 = -1
+        elif point_name == "D":
+            k1 = -1
+            k2 = 1
+        # определение углов места и углов курса точки относительно РЛС1 и РЛС2 методом последовательных приближений
+        while abs(dpsi_1upd - dpsi_1) > 0.01 or abs(dpsi_2upd - dpsi_2) > 0.01:
+            dpsi_1 = dpsi_1upd
+            dpsi_2 = dpsi_2upd
+            psi_1 = psi_t + dpsi_1
+            psi_2 = psi_r + dpsi_2
+            phi_1 = mt.atan(uav_interval / h * mt.cos(psi_2) / mt.sin(psi_2 - psi_1))
+            phi_2 = mt.atan(uav_interval / h * mt.cos(psi_1) / mt.sin(psi_2 - psi_1))
+            if (
+                abs(mt.sin(theta / 2) / mt.sin(phi_1)) > 1
+                or abs(mt.sin(theta / 2) / mt.sin(phi_2)) > 1
+            ):
+                return "none"
+            dpsi_1upd = k1 * mt.asin(mt.sin(theta / 2) / mt.sin(phi_1))
+            dpsi_2upd = k2 * mt.asin(mt.sin(theta / 2) / mt.sin(phi_2))
+        # итоговые значения углов места и углов курса точки относительно РЛС1 и РЛС2
+        dpsi_1 = dpsi_1upd
+        dpsi_2 = dpsi_2upd
+        psi_1 = psi_t + dpsi_1
+        psi_2 = psi_r + dpsi_2
+        phi_1 = mt.atan(uav_interval / h * mt.cos(psi_2) / mt.sin(psi_2 - psi_1))
+        phi_2 = mt.atan(uav_interval / h * mt.cos(psi_1) / mt.sin(psi_2 - psi_1))
+        # координаты точки
+        x = h * mt.tan(phi_2) * mt.cos(psi_2)
+        y = h * mt.tan(phi_2) * mt.sin(psi_2)
+        return [x, y]
+    else:
+        return "none"
+
+
+# функция определяет водность облаков, г|м3
+# cloud_thickness - толщина облаков
+def cloud_liquid_water_content(cloud_thickness: float) -> float:
+    if cloud_thickness != 0:
+        W = 0.132574 * (cloud_thickness / 1000) ** 2.30215
+        return W / cloud_thickness * 1000
+    else:
+        return 0
+
+
+# функция определяет ординтаты точек пересечения выпуклого многоугольника (polygon) с лучом, имеющем ординату x
+def polygon_cross_points(polygon: List[float], x: float) -> List[float]:
+    y1 = "none"
+    y2 = "none"
+    for i in range(0, len(polygon[0])):
+        if i < len(polygon[0]) - 1:
+            k = i + 1
+        else:
+            k = 0
+        if x >= min(polygon[0][i], polygon[0][k]) and x <= max(
+            polygon[0][i], polygon[0][k]
+        ):
+            if polygon[0][i] != polygon[0][k]:
+                if y1 == "none":
+                    y1 = (polygon[1][k] - polygon[1][i]) / (
+                        polygon[0][k] - polygon[0][i]
+                    ) * (x - polygon[0][i]) + polygon[1][i]
+                else:
+                    y2 = (polygon[1][k] - polygon[1][i]) / (
+                        polygon[0][k] - polygon[0][i]
+                    ) * (x - polygon[0][i]) + polygon[1][i]
+            else:
+                y1 = polygon[1][i]
+                y2 = polygon[1][k]
+    return [min(y1, y2), max(y1, y2)]
+
+
+# функция определяет координаты углов РЛИ
+# h - высота полета в м, uav_interval - размер базы между РЛС, м
+# psi_t - угол курса оси главного лепестка ДНА на излучение (по часовой стрелке>0, против часовой <0), град
+# psi_r - угол курса оси главного лепестка ДНА на прием (по часовой стрелке>0, против часовой <0), град
+def frame_corner_crd(
+    h: float,
+    uav_interval: float,
+    psi_t: float,
+    psi_r: float,
+    wavelength: float,
+    antenna_length: float,
+):
+    # координаты области пересечения проекций на земную поверхность главных лепестков
+    crd_A = footprint_corner_crd(
+        point_name="A",
+        h=h,
+        uav_interval=uav_interval,
+        psi_t=psi_t,
+        psi_r=psi_r,
+        wavelength=wavelength,
+        antenna_length=antenna_length,
+    )
+    crd_B = footprint_corner_crd(
+        point_name="B",
+        h=h,
+        uav_interval=uav_interval,
+        psi_t=psi_t,
+        psi_r=psi_r,
+        wavelength=wavelength,
+        antenna_length=antenna_length,
+    )
+    crd_C = footprint_corner_crd(
+        point_name="C",
+        h=h,
+        uav_interval=uav_interval,
+        psi_t=psi_t,
+        psi_r=psi_r,
+        wavelength=wavelength,
+        antenna_length=antenna_length,
+    )
+    crd_D = footprint_corner_crd(
+        point_name="D",
+        h=h,
+        uav_interval=uav_interval,
+        psi_t=psi_t,
+        psi_r=psi_r,
+        wavelength=wavelength,
+        antenna_length=antenna_length,
+    )
+    if crd_A != "none" and crd_B != "none" and crd_C != "none" and crd_D != "none":
+        polygon = [
+            [crd_A[0], crd_B[0], crd_C[0], crd_D[0]],
+            [crd_A[1], crd_B[1], crd_C[1], crd_D[1]],
+        ]
+        # максимальное и минимальное значение абсциисы области пересечения проекций на земную поверхность главных лепестков
+        x_min = min(polygon[0])
+        x_max = max(polygon[0])
+        # точность оценики координат углов РЛИ
+        accuracy = 20
+        # число итераций для поиска максимальной площади РЛИ
+        N = 1 + int((x_max - x_min) / accuracy)
+        # шаг по оси абсцисс при поиске максимальной плоащади РЛИ
+        dx = (x_max - x_min) / N
+        # начальные значения коориднат углов и площади РЛИ
+        s_upd = 0
+        # dq_upd = 100
+        x1_upd = "none"
+        x2_upd = "none"
+        y1_upd = "none"
+        y2_upd = "none"
+        # поиск макисальной площади и углов РЛИ
+        for i in range(0, N - 1):
+            x1 = x_min + i * dx
+            for j in range(i + 1, N):
+                x2 = x_min + j * dx
+                y11 = polygon_cross_points(polygon, x1)[0]
+                y12 = polygon_cross_points(polygon, x1)[1]
+                y21 = polygon_cross_points(polygon, x2)[0]
+                y22 = polygon_cross_points(polygon, x2)[1]
+                if y11 >= y21 and y12 <= y22:
+                    y1 = y11
+                    y2 = y12
+                elif y11 <= y21 and y12 >= y21 and y12 <= y22:
+                    y1 = y21
+                    y2 = y12
+                elif y11 <= y22 and y11 >= y21 and y12 >= y22:
+                    y1 = y11
+                    y2 = y22
+                elif y11 <= y21 and y12 >= y22:
+                    y1 = y21
+                    y2 = y22
+                else:
+                    y1 = "none"
+                    y2 = "none"
+                if y1 != "none" and y2 != "none":
+                    s = (x2 - x1) * (y2 - y1)
+                    # dq = abs((y2-y1)/(x2-x1)-q)
+                    if s > s_upd:  # dq < dq_upd:
+                        s_upd = s
+                        # dq_upd = dq
+                        x1_upd = x1
+                        x2_upd = x2
+                        y1_upd = y1
+                        y2_upd = y2
+        # возврат массива координат углов РЛК (точек T1,T2,T3,T4)
+        return [[x1_upd, x1_upd, x2_upd, x2_upd], [y1_upd, y2_upd, y2_upd, y1_upd]]
+    else:
+        return "none"
+
+
+# параметры a1, a2, a3 модели Кулемина для расчета УЭПР разных типов подстилающих поверхностей, дБ
+kulemin_parameters = {
+    "лес летом": [-20, 10, 6],
+    "лес зимой": [-40, 10, 6],
+    "луг высокотравный": [-21, 10, 6],
+    "луг низкотравный": [-28, 10, 6],
+    "пашня": [-37, 18, 15],
+    "снег": [-34, 25, 15],
+}
+
+
+# функция определеяет УЭПР поверхности в дБ согласно модели Кулемина
+# surface_type - тип подстилающей поверхности (пашня, снег и т.д.), phi - угол падения, град
+# если задан неизвестный тип подстилающей поверхности, функция вернет значение -20 дБ
+def kulemin_specific_rcs(surface_type, phi, wavelength):
+    # частота зондирования в ГГц
+    f = C / wavelength * 10 ** (-9)
+    # угол скольжения в град
+    slip = 90 - phi
+    if kulemin_parameters.get(surface_type) != None:
+        a1, a2, a3 = kulemin_parameters[surface_type]
+        return a1 + a2 * mt.log(slip / 20, 10) + a3 * mt.log(f / 10, 10)
+    else:
+        return -20
+
+
+# функция определяет коэффициент погонного ослабления в облаке, дБ/км/(г/м3)
+def itu_cloud_attenuation(wavelength):
+    # частота зондирования в ГГц
+    f = C / wavelength * 10 ** (-9)
+    theta = 300 / 273.15
+    eps0 = 77.66 + 103.3 * (theta - 1)
+    eps1 = 0.0671 * eps0
+    eps2 = 3.52
+    fp = 20.20 - 146 * (theta - 1) + 316 * (theta - 1) ** 2
+    fs = 39.8 * fp
+    eps_prime = f * (eps0 - eps1) / fp / (1 + (f / fp) ** 2) + f * (
+        eps1 - eps2
+    ) / fs / (1 + (f / fs) ** 2)
+    eps_double_prime = (
+        (eps0 - eps1) / (1 + (f / fp) ** 2) + (eps1 - eps2) / (1 + (f / fs) ** 2) + eps2
+    )
+    nabla = (2 + eps_prime) / eps_double_prime
+    return 0.819 * f / eps_double_prime / (1 + nabla**2)
+
+
+# параметры kh, ah, kv, av модели погонного ослабления в дожде МСЭ-R P.838-3 для частот 7 - 12 ГГц
+itu_rain_parameters = {
+    7: [0.001915, 1.4810, 0.001425, 1.4745],
+    8: [0.004115, 1.3905, 0.003450, 1.3797],
+    9: [0.007535, 1.3155, 0.006691, 1.2895],
+    10: [0.012170, 1.2571, 0.011290, 1.2156],
+    11: [0.017720, 1.2140, 0.017310, 1.1617],
+    12: [0.023860, 1.1825, 0.024550, 1.1216],
+}
+
+# классификация погодных условий по интенсивности осадков, мм/ч
+rain_rate_classes = {
+    "ясно": 0,
+    "слабый дождь": 5,
+    "умеренный дождь": 12,
+    "сильный дождь": 30,
+    "ливень": 40,
+}
+
+
+# функция определяет коэффициент погонного ослабления в дожде в дБ/км для диапазона X согласно модели МСЭ-R P.838-3
+# rain_rate - интенсивность дождя в мм/ч, phi- угол падения, град
+# если длина волны зондирования лежит не в диапазоне X, функция вернет 0
+def itu_rain_attenuation(
+    rain_rate: float, phi: float, wavelength: float, polarization_tilt_angle: float
+) -> float:
+    # частота зондирования в ГГц
+    f = C / wavelength * 10 ** (-9)
+    # угол скольжения в радианах
+    slip = (90 - phi) * mt.pi / 180
+    # угол поляризации в радианах
+    tilt = polarization_tilt_angle * mt.pi / 180
+    # целочисленные значения частот вокруг частоты зондирования
+    f1 = int(f)
+    f2 = int(f) + 1
+    if (itu_rain_parameters.get(f1) != None) and (itu_rain_parameters.get(f2) != None):
+        # параметры модели для частоты f1
+        kh1 = itu_rain_parameters[f1][0]
+        ah1 = itu_rain_parameters[f1][1]
+        kv1 = itu_rain_parameters[f1][2]
+        av1 = itu_rain_parameters[f1][3]
+        # ��араметры модели для частоты f2
+        kh2 = itu_rain_parameters[f2][0]
+        ah2 = itu_rain_parameters[f2][1]
+        kv2 = itu_rain_parameters[f2][2]
+        av2 = itu_rain_parameters[f2][3]
+        # интерполяция параметров модели на частоту зондирования f
+        kh = kh1 + (kh2 - kh1) / (f2 - f1) * (f - f1)
+        ah = ah1 + (ah2 - ah1) / (f2 - f1) * (f - f1)
+        kv = kv1 + (kv2 - kv1) / (f2 - f1) * (f - f1)
+        av = av1 + (av2 - av1) / (f2 - f1) * (f - f1)
+        # параметры модели для заданной поляризации
+        k = (kh + kv + (kh - kv) * (mt.cos(slip)) ** 2 * mt.cos(2 * tilt)) / 2
+        a = (
+            (
+                kh * ah
+                + kv * av
+                + (kh * ah - kv * av) * (mt.cos(slip)) ** 2 * mt.cos(2 * tilt)
+            )
+            / 2
+            / k
+        )
+        return k * (rain_rate) ** a
+    else:
+        return 0
+
+
+# входные параметры модели:
+# v - скорость полета, м/с
+# h - высота полета, м
+# uav_interval - размер базы между РЛС, м
+# psi_t - угол курса оси главного лепестка ДНА на излучение (по часовой стрелке>0, против часовой <0), град
+# psi_r - угол курса оси главного лепестка ДНА на прием (по часовой стрелке>0, против часовой <0), град
+# srcs - УЭПР фона, дБ или тип поверхности по модели Кулемина
+# cloud_base - высота нижней границы облаков, м
+# cloud_thickness - толщина облаков, м
+# rain_rate - интенсивность дождя, мм/ч
+
+# выходные параметры модели:
+# dx - предельное разрешение по горизонтальной дальности в центре РЛК, м
+# dy - предельное разрешение по азимуту в центре РЛК, м
+# snr - отношение сигнал/шум фона в центре РЛК, дБ
+# tau - длина импульса, с
+# tau_echo - длина эхо-сигнала, с
+# t_repeat - период повторения импульсов, с
+# t_synthesis_max - максимальное время синтеза апертуры, с
+
+
+def bistatic_radar_model(
+    v: float,
+    h: float,
+    uav_interval: float,
+    psi_t: float,
+    psi_r: float,
+    srcs: str | float,
+    cloud_base: float,
+    cloud_thickness: float,
+    rain_rate: float,
+    q_fill: float,
+    bandwidth: float,
+    wavelength: float,
+    antenna_gain: float,
+    antenna_length: float,
+    noise_factor: float,
+    peak_power: float,
+    polarization_tilt_angle: float,
+):
+    # координаты РЛС1
+    x1 = 0
+    y1 = uav_interval
+    # координаты РЛС2
+    x2 = 0
+    y2 = 0
+    # коодинаты точки T1
+    frame_crd = frame_corner_crd(
+        h=h,
+        uav_interval=uav_interval,
+        psi_t=psi_t,
+        psi_r=psi_r,
+        wavelength=wavelength,
+        antenna_length=antenna_length,
+    )
+    if frame_crd != "none":
+        x_t1 = frame_crd[0][0]
+        y_t1 = frame_crd[1][0]
+        # коодинаты точки T2
+        x_t2 = frame_crd[0][1]
+        y_t2 = frame_crd[1][1]
+        # коодинаты точки T3
+        x_t3 = frame_crd[0][2]
+        y_t3 = frame_crd[1][2]
+        # коодинаты точки T4
+        x_t4 = frame_crd[0][3]
+        y_t4 = frame_crd[1][3]
+        # коодинаты центра РЛК
+        xo = (x_t2 + x_t3) / 2
+        yo = (y_t1 + y_t2) / 2
+        # наклонные дальности от РЛС1 до углов и центра РЛК
+        r1_t1 = mt.sqrt((x_t1 - x1) ** 2 + (y_t1 - y1) ** 2 + h**2)
+        r1_t2 = mt.sqrt((x_t2 - x1) ** 2 + (y_t1 - y1) ** 2 + h**2)
+        r1_t3 = mt.sqrt((x_t3 - x1) ** 2 + (y_t1 - y1) ** 2 + h**2)
+        r1_t4 = mt.sqrt((x_t4 - x1) ** 2 + (y_t1 - y1) ** 2 + h**2)
+        r1_o = mt.sqrt((xo - x1) ** 2 + (yo - y1) ** 2 + h**2)
+        # наклонные дальности от РЛС2 до углов и центра РЛК
+        r2_t1 = mt.sqrt((x_t1 - x2) ** 2 + (y_t1 - y2) ** 2 + h**2)
+        r2_t2 = mt.sqrt((x_t2 - x2) ** 2 + (y_t1 - y2) ** 2 + h**2)
+        r2_t3 = mt.sqrt((x_t3 - x2) ** 2 + (y_t1 - y2) ** 2 + h**2)
+        r2_t4 = mt.sqrt((x_t4 - x2) ** 2 + (y_t1 - y2) ** 2 + h**2)
+        r2_o = mt.sqrt((xo - x2) ** 2 + (yo - y2) ** 2 + h**2)
+        # угол падения импульса от РЛС1 в центр РЛК
+        phi1_o = mt.atan(h / r1_o) * 180 / mt.pi
+        # угол отражения импульса от центра РЛК к РЛС2
+        phi2_o = mt.atan(h / r2_o) * 180 / mt.pi
+        # модуль градиента от суммы наклонных дальностей от РЛС1 �� РЛС2 до центра РЛК
+        grad_r = mt.sqrt((xo / r1_o + xo / r2_o) ** 2 + (yo / r1_o + yo / r2_o) ** 2)
+        # модуль градиента от суммы доплеровских частот на трассах от РЛС1 до центра РЛК и от центра РЛК до РЛС2
+        grad_f = (
+            v
+            / wavelength
+            * mt.sqrt(
+                (1 / r1_o + 1 / r2_o - xo**2 / r1_o**3 - xo**2 / r2_o**3) ** 2
+                + (xo * yo / r1_o**3 + xo * yo / r2_o**3) ** 2
+            )
+        )
+        # длина импульса
+        tau = min(r1_t1 + r2_t1, r1_t2 + r2_t2) / C
+        # длина эхо-сигнала
+        tau_echo = (
+            tau
+            + max(r1_t3 + r2_t3, r1_t4 + r2_t4) / C
+            - min(r1_t1 + r2_t1, r1_t2 + r2_t2) / C
+        )
+        # период повторения импульсов
+        t_repeat = tau / q_fill
+        # максимальный коэффициент сжатия
+        k_compression_max = bandwidth * 1000000 * tau
+        # максимальное время синтеза апертуры
+        t_synthesis_max = 2 * (x_t3 - x_t2) / v
+        # максимальное число когерентных импульсов
+        n_coh_max = 1 + int(t_synthesis_max / t_repeat)
+        # разрешение по горизонтальной дальности
+        dx = C * tau / k_compression_max / grad_r
+        # разрешение по азимуту
+        dy = 1 / t_synthesis_max / grad_f
+        # УЭПР фона
+        if type(srcs) == str:
+            srcs = kulemin_specific_rcs(surface_type=srcs, phi=(phi1_o + phi2_o) / 2, wavelength=wavelength)
+        # ЭПР точечного отражателя фона
+        sigma = 10 ** (srcs / 10) * dx * dy
+        # эффективная площадь антенны
+        antenna_area = 10 ** (antenna_gain / 10) * wavelength**2 / 4 / mt.pi
+        # мощность эхо-сигнала от центра РЛК
+        p_echo = (
+            peak_power
+            * 10 ** (antenna_gain / 10)
+            * antenna_area
+            / (4 * mt.pi * r1_o * r2_o) ** 2
+            * sigma
+            * k_compression_max
+            * n_coh_max
+        )
+        # мощность шума
+        p_noise = (
+            BOLTZMANN
+            * 10 ** (noise_factor / 10)
+            * RADAR_TEMPERATURE
+            * bandwidth
+            * 1000000
+        )
+        # отношение сигнал/шум без учета погоды
+        snr = 10 * mt.log(p_echo / p_noise, 10)
+        # протяженность наклонных дальностей в облаках и дожде, км
+        if cloud_thickness != 0:
+            cloud_path1 = (
+                r1_o
+                / 1000
+                * (min(h, cloud_base + cloud_thickness) - min(h, cloud_base))
+                / h
+            )
+            cloud_path2 = (
+                r2_o
+                / 1000
+                * (min(h, cloud_base + cloud_thickness) - min(h, cloud_base))
+                / h
+            )
+            rain_path1 = r1_o / 1000 * min(h, cloud_base) / h
+            rain_path2 = r2_o / 1000 * min(h, cloud_base) / h
+        else:
+            cloud_path1 = 0
+            cloud_path2 = 0
+            rain_path1 = 0
+            rain_path2 = 0
+        # водность облаков
+        w = cloud_liquid_water_content(cloud_thickness=cloud_thickness)
+        # ослабление в облаках по модели МСЭ-R P.840-7
+        cloud_att1 = itu_cloud_attenuation(wavelength=wavelength) * w * cloud_path1
+        cloud_att2 = itu_cloud_attenuation(wavelength=wavelength) * w * cloud_path2
+        # ослабление в дожде по модели МСЭ-R P.838-3
+        rain_att1 = (
+            itu_rain_attenuation(
+                rain_rate=rain_rate,
+                phi=phi1_o,
+                wavelength=wavelength,
+                polarization_tilt_angle=polarization_tilt_angle,
+            )
+            * rain_path1
+        )
+        rain_att2 = (
+            itu_rain_attenuation(
+                rain_rate=rain_rate,
+                phi=phi2_o,
+                wavelength=wavelength,
+                polarization_tilt_angle=polarization_tilt_angle,
+            )
+            * rain_path2
+        )
+        # отношение сигнал/шум с учетом погодных условий
+        snr = snr - cloud_att1 - cloud_att2 - rain_att1 - rain_att2
+        return {
+            "dx": dx,
+            "dy": dy,
+            "snr": snr,
+            "tau": tau,
+            "tau_echo": tau_echo,
+            "t_repeat": t_repeat,
+            "t_synthesis_max": t_synthesis_max,
+        }
+    else:
+        return "none"

app_gradio.py

@@ -0,0 +1,223 @@
+import gradio as gr
+import app_backend
+
+BG_CHOICES = ("Задать значение", "Из модели Кулемина")
+KULEMIN = {
+    "лес летом": [-20, 10, 6],
+    "лес зимой": [-40, 10, 6],
+    "луг высокотравный": [-21, 10, 6],
+    "луг низкотравный": [-28, 10, 6],
+    "пашня": [-37, 18, 15],
+    "снег": [-34, 25, 15],
+}
+
+def main(i):
+    out = app_backend.bistatic_radar_model(
+        v=i[speed],
+        h=i[height],
+        uav_interval=i[uav_interval],
+        psi_t=i[psit],
+        psi_r=i[psir],
+        srcs=i[bg_type] if i[bg_mode] == BG_CHOICES[1] else i[bg_value],
+        cloud_base=i[cloud_base],
+        cloud_thickness=i[cloud_thickness],
+        rain_rate=i[rain_intensivity],
+        q_fill=i[q_fill],
+        bandwidth=i[bandwidth],
+        wavelength=i[wavelength],
+        antenna_gain=i[antenna_gain],
+        antenna_length=i[antenna_length],
+        noise_factor=i[noise_factor],
+        peak_power=i[peak_power],
+        polarization_tilt_angle=0 if i[polar_type] == "H" else 90,
+    )
+    return out["dx"], out["dy"], out["snr"]
+
+
+
+
+def update_visibility(radio):
+    if radio == BG_CHOICES[0]:
+        return gr.update(visible=True), gr.update(visible=False)
+    return gr.update(visible=False), gr.update(visible=True)
+
+
+input_set = set()
+# Create the Gradio pyinterface
+with gr.Blocks(
+    title="РЛС-калькулятор"
+) as demo:  # css="footer{display:none !important}"
+    gr.Markdown(
+        "# Оценка параметров качества радиолокационного изображения двухпозиционной РЛС"
+    )
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown(
+                """
+                Калькулятор позволяет рассчитать параметры качества радиолокационного изображения (РЛИ), формируемого в передней зоне обзора двухпозиционной полуактивной радиолокационной станции (РЛС) авиационного базирования.
+                
+                В рассматриваемой схеме главный лепесток диаграммы направленности антенны (ДНА) на излучение активной компоненты РЛС подсвечивает область в передней зоне обзора, тогда как главный лепесток ДНА на приём направлен так, чтобы существовала возможность фиксации отраженного эхо-сигнала. Формирование РЛИ происходит на пересечении областей земной поверхности в пределах главных лепестков ДНА на излучение и на приём.
+                
+                Каждая одиночная РЛС использует одинаковую передающую и приёмную антенны, вследствие чего равны угловые размеры главных лепестков на излучение и на приём.
+                """
+            )
+        with gr.Column():
+            gr.HTML(
+                "<img src='gradio_api/file=./Bistatic_radar.jpg' alt='Схема БВС и РЛС' width=640>"
+            )
+    # v - скорость полета, h - высота полета, dl - размер базы между РЛС, psir - угол курса оси главного лепестка ДНА на приём
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("## Параметры бортовой РЛС")
+            psir = gr.Slider(
+                minimum=10,
+                maximum=60,
+                value=30,
+                step=0.1,
+                label="Угол курса оси главного лепестка ДНА на приём, град",
+            )
+            input_set.add(psir)
+            psit = gr.Slider(
+                minimum=-60,
+                maximum=-10,
+                value=-30,
+                step=0.1,
+                label="Угол курса оси главного лепестка ДНА на излучение, град",
+            )
+            input_set.add(psit)
+            antenna_length = gr.Slider(
+                minimum=0.05,
+                maximum=0.3,
+                value=0.1,
+                step=0.01,
+                label="Длина антенны, м",
+            )
+            input_set.add(antenna_length)
+            antenna_gain = gr.Slider(
+                minimum=5,
+                maximum=20,
+                value=10,
+                step=0.1,
+                label="Коэффициент усиления антенны, дБ",
+            )
+            input_set.add(antenna_gain)
+            wavelength = gr.Slider(
+                minimum=0.02,
+                maximum=0.04,
+                value=0.03,
+                step=0.001,
+                label="Длина волны, м",
+            )
+            input_set.add(wavelength)
+            peak_power = gr.Slider(
+                minimum=1,
+                maximum=10,
+                value=5,
+                step=0.1,
+                label="Пиковая мощность, ВТ",
+            )
+            input_set.add(peak_power)
+            bandwidth = gr.Slider(
+                minimum=500,
+                maximum=2000,
+                value=1000,
+                step=1,
+                label="Полоса пропускания, МГц",
+            )
+            input_set.add(bandwidth)
+            noise_factor = gr.Slider(
+                minimum=1,
+                maximum=3,
+                value=2,
+                step=0.01,
+                label="Шум-фактор, дБ",
+            )
+            input_set.add(noise_factor)
+
+            gr.Markdown("## Параметры режима работы РЛС")
+            with gr.Row():
+                q_fill = gr.Slider(
+                    minimum=0.05,
+                    maximum=0.25,
+                    value=0.1,
+                    step=0.001,
+                    label="Коэффициент заполнения",
+                )
+                input_set.add(q_fill)
+                polar_type = gr.Radio(
+                    choices=["H", "V"], label="Тип поляризации", value="H"
+                )
+                input_set.add(polar_type)
+        with gr.Column():
+            gr.Markdown("## Траекторные параметры")
+            speed = gr.Slider(
+                minimum=5,
+                maximum=30,
+                value=20,
+                step=0.1,
+                label="Скорость полёта, м/с",
+            )
+            input_set.add(speed)
+            height = gr.Slider(
+                minimum=200,
+                maximum=2000,
+                value=1000,
+                step=1,
+                label="Высота полёта, м",
+            )
+            input_set.add(height)
+            uav_interval = gr.Slider(
+                minimum=200,
+                maximum=2000,
+                value=1000,
+                step=1,
+                label="Длина базы между РЛС, м",
+            )
+            input_set.add(uav_interval)
+            gr.Markdown("## Параметры условий местности")
+            cloud_base = gr.Slider(
+                minimum=0,
+                maximum=1500,
+                value=750,
+                step=1,
+                label="Высота нижней границы облаков, м",
+            )
+            input_set.add(cloud_base)
+            cloud_thickness = gr.Slider(
+                minimum=0, maximum=6000, value=3000, step=1, label="Толщина облаков, м"
+            )
+            input_set.add(cloud_thickness)
+            rain_intensivity = gr.Slider(
+                minimum=0,
+                maximum=80,
+                value=40,
+                step=1,
+                label="Интенсивность дождя, мм/ч",
+            )
+            input_set.add(rain_intensivity)
+            bg_mode = gr.Radio(choices=BG_CHOICES, label="УЭПР фона поверхности")
+            input_set.add(bg_mode)
+            bg_value = gr.Slider(
+                minimum=-30, maximum=10, value=0, step=0.1, label="", visible=False
+            )
+            input_set.add(bg_value)
+            bg_type = gr.Dropdown(choices=KULEMIN.keys(), visible=False, label="")
+            input_set.add(bg_type)
+
+        with gr.Column():
+            gr.Markdown("## Предельные параметры качества РЛИ")
+            # Output displays
+            output_hr = gr.Number(
+                label="Разрешение по горизонтальной дальности, м",
+                precision=3,
+            )
+            output_ar = gr.Number(label="Разрешение по азимуту, м", precision=3)
+            output_snr = gr.Number(label="Отношение сигнал/шум, дБ", precision=1)
+
+    # Set up the event listeners for real-time updates
+    output_list = [output_hr, output_ar, output_snr]
+    bg_mode.change(update_visibility, inputs=bg_mode, outputs=[bg_value, bg_type])
+    for inp in input_set:
+        inp.change(fn=main, inputs=input_set, outputs=output_list)
+if __name__ == "__main__":
+    demo.launch(share=True, allowed_paths=["."])

requirements.txt

@@ -0,0 +1 @@
+gradio