Upload folder using huggingface_hub

.gitignore

@@ -1,177 +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
+# 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

Dockerfile

@@ -0,0 +1,21 @@
+# Use an official Python runtime as a parent image
+FROM python:3.12-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the application code and assets
+COPY src/ ./src/
+COPY img/ ./img/
+
+# Make port 7860 available to the world outside this container
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "src/app_gradio.py"]

README.md

@@ -1,6 +1,67 @@
----
-title: radar_image_quality
-app_file: app_gradio.py
-sdk: gradio
-sdk_version: 5.23.3
----
+---
+title: radar_image_quality
+app_file: src/app_gradio.py
+sdk: gradio
+sdk_version: 5.25.2
+---
+# Radar Image Quality Gradio App
+
+## Overview
+The Radar Image Quality Gradio App is designed to evaluate the parameters of radar image quality generated by a bistatic radar system. This application provides an interactive interface for users to input various parameters and visualize the results.
+
+## Project Structure
+```
+radar-image-quality
+├── src
+│   ├── app_backend.py       # Backend logic for calculations and data processing
+│   ├── app_gradio.py        # Gradio interface setup
+│   └── test_backend.py       # Unit tests for backend functions
+├── img
+│   ├── ai_day.png           # Image for daytime representation
+│   ├── ai_night.png         # Image for nighttime representation
+│   ├── bistatic_radar.jpg    # Image representing bistatic radar
+│   ├── iu_day.png           # Image for daytime representation of the university
+│   └── iu_night.png         # Image for nighttime representation of the university
+├── Dockerfile                # Docker instructions for building the image
+├── requirements.txt          # Python dependencies
+└── README.md                 # Project documentation
+```
+
+## Setup Instructions
+1. **Clone the repository:**
+   ```bash
+   git clone <repository-url>
+   cd radar_image_quality
+   ```
+
+2. **Install dependencies:**
+   It is recommended to use a virtual environment. You can create one using:
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows use `venv\Scripts\activate`
+   ```
+   Then install the required packages:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Run the application:**
+   You can run the Gradio app directly using:
+   ```bash
+   python src/app_gradio.py
+   ```
+
+## Docker Instructions
+To build and run the Docker container, use the following commands:
+1. **Build the Docker image:**
+   ```bash
+   docker build -t radar-image-quality .
+   ```
+
+2. **Run the Docker container:**
+   ```bash
+   docker run -p 7860:7860 radar-image-quality
+   ```
+
+## Usage
+Once the application is running, open your web browser and navigate to `http://localhost:7860` to access the Gradio interface. You can input various parameters related to the radar system and visualize the results.

docker_build.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+IMAGE_NAME="radar-quality-calculator"
+function docker_build {
+    # Image name
+    # Check if Docker is installed
+    if ! command -v docker &>/dev/null; then
+        echo "Docker could not be found. Please install Docker to proceed."
+        return
+    fi
+    # Check if Docker daemon is running
+    if ! docker info &>/dev/null; then
+        echo "Docker daemon is not running. Please start Docker to proceed."
+        return
+    fi
+    # Check if Dockerfile exists
+    if [ ! -f Dockerfile ]; then
+        echo "Dockerfile not found in the current directory. Please ensure you are in the correct directory."
+        return
+    fi
+
+    # Remove existing image if it exists
+    echo "Removing existing image if it exists..."
+    docker rmi -f $IMAGE_NAME 2>/dev/null || true
+
+    # Build new image
+    echo "Building new image..."
+    docker build -t $IMAGE_NAME .
+
+    echo "Build complete!"
+}
+
+docker_build

docker_run.sh

@@ -0,0 +1 @@
+docker run -p 7860:7860 radar-quality-calculator

requirements.txt

@@ -1 +1 @@
-gradio
+gradio>=5.25.2

src/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"

src/app_gradio.py

@@ -0,0 +1,265 @@
+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],
+}
+LOGOS_HEADER = """
+<style>
+  .logo-container {
+    display: flex;
+    gap: 20px; /* расстояние между логотипами */
+    align-items: center;
+  }
+  /* По умолчанию (светлая тема) показываем дневные варианты */
+  #iu-day, #ai-day {
+    display: block;
+  }
+  #iu-night, #ai-night {
+    display: none;
+  }
+  /* Для тёмной темы — наоборот, показываем ночные варианты */
+  @media (prefers-color-scheme: dark) {
+    #iu-day, #ai-day {
+      display: none;
+    }
+    #iu-night, #ai-night {
+      display: block;
+    }   
+  }
+</style>
+
+<div class="logo-container">
+    <img id="iu-day" src='gradio_api/file=./img/iu_day.png' alt='УНИВЕРСИТЕТ ИННОПОЛИС' width=200>
+    <img id="iu-night" src='gradio_api/file=./img/iu_night.png' alt='УНИВЕРСИТЕТ ИННОПОЛИС' width=200>
+    
+    <img id="ai-day" src='gradio_api/file=./img/ai_day.png' alt='ЦЕНТР ИСКУССТВЕННОГО ИНТЕЛЛЕКТА' width=200>
+    <img id="ai-night" src='gradio_api/file=./img/ai_night.png' alt='ЦЕНТР ИСКУССТВЕННОГО ИНТЕЛЛЕКТА' width=200>
+</div>
+"""
+
+
+def main(i):
+    try:
+        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 f"{out["dx"]:.3f}", f"{out["dy"]:.3f}", f"{out["snr"]:.1f}"
+    except:
+        return ["ОШИБКА: недопустимая комбинация входных параметров"] * 3
+
+
+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="РЛС-калькулятор",
+    # css="footer{display:none !important}",
+    # theme=gr.themes.Ocean(),
+) as demo:
+    gr.HTML(LOGOS_HEADER)
+    gr.Markdown(
+        "# Калькулятор оценки параметров качества радиолокационного изображения двухпозиционной РЛС"
+    )
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown(
+                """
+                Калькулятор позволяет рассчитать параметры качества радиолокационного изображения (РЛИ), формируемого в передней зоне обзора двухпозиционной полуактивной радиолокационной станции (РЛС) авиационного базирования.
+                
+                В рассматриваемой схеме главный лепесток диаграммы направленности антенны (ДНА) на излучение активной компоненты РЛС подсвечивает область в передней зоне обзора, тогда как главный лепесток ДНА на прием направлен так, чтобы существовала возможность фиксации отраженного эхо-сигнала. Формирование РЛИ происходит на пересечении областей земной поверхности в пределах главных лепестков ДНА на излучение и на прием.
+                
+                Каждая одиночная РЛС использует одинаковую передающую и приемную антенны, вследствие чего равны угловые размеры главных лепестков на излучение и на прием.
+                """
+            )
+        with gr.Column():
+            gr.HTML(
+                "<img src='gradio_api/file=./img/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="УЭПР фона поверхности", value=BG_CHOICES[0]
+            )
+            input_set.add(bg_mode)
+            bg_value = gr.Slider(
+                minimum=-30, maximum=10, value=0, step=0.1, label="", visible=True
+            )
+            input_set.add(bg_value)
+            bg_type = gr.Dropdown(
+                choices=KULEMIN.keys(), visible=False, label="", filterable=False
+            )
+            input_set.add(bg_type)
+
+        with gr.Column():
+            gr.Markdown("## Предельные параметры качества РЛИ")
+            # Output displays
+            output_hr = gr.Text(label="Разрешение по горизонтальной дальности, м")
+            output_ar = gr.Text(label="Разрешение по азимуту, м")
+            output_snr = gr.Text(label="Отношение сигнал/шум, дБ")
+    with gr.Row():
+        gr.Markdown(
+            "*Калькулятор оценки параметров качества радиолокационного изображения двухпозиционной РЛС подготовлен за счет средств гранта, предоставленного по договору от 30.10.2024 № 70-2024-001319, заключенному АНО ВО «Университет Иннополис» с Фондом поддержки проектов Национальной технологической инициативы*"
+        )
+    # Set up the event listeners for real-time updates
+    output_list = [output_hr, output_ar, output_snr]
+    bg_mode.change(fn=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=False, allowed_paths=["."], server_name="0.0.0.0")

test_backend.py

@@ -0,0 +1,83 @@
+"""Backend functions test suite.
+This module contains unit tests for the backend functions of the application.
+This module is designed to ensure the correctness and reliability of the backend logic
+"""
+
+import unittest
+
+from src.app_backend import (
+    footprint_corner_crd,
+    cloud_liquid_water_content,
+    polygon_cross_points,
+    frame_corner_crd,
+    kulemin_specific_rcs,
+    itu_cloud_attenuation,
+    itu_rain_attenuation,
+    bistatic_radar_model
+)
+
+class TestBackendFunctions(unittest.TestCase):
+
+    def test_footprint_corner_crd(self):
+        result = footprint_corner_crd('A', 1000, 500, 30, 60)
+        self.assertNotEqual(result, 'none')
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 2)
+
+    def test_cloud_liquid_water_content(self):
+        self.assertAlmostEqual(cloud_liquid_water_content(1000), 0.132574, places=5)
+        self.assertEqual(cloud_liquid_water_content(0), 0)
+
+    def test_polygon_cross_points(self):
+        polygon = [[0, 1, 1, 0], [0, 0, 1, 1]]
+        result = polygon_cross_points(polygon, 0.5)
+        self.assertEqual(result, [0.0, 1.0])
+
+    def test_frame_corner_crd(self):
+        result = frame_corner_crd(1000, 500, 30, 60)
+        self.assertNotEqual(result, 'none')
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 2)
+
+    def test_kulemin_specific_rcs(self):
+        result = kulemin_specific_rcs('лес летом', 45)
+        self.assertIsInstance(result, float)
+        self.assertNotEqual(result, -20)
+
+        unknown_surface = kulemin_specific_rcs('unknown', 45)
+        self.assertEqual(unknown_surface, -20)
+
+    def test_itu_cloud_attenuation(self):
+        result = itu_cloud_attenuation()
+        self.assertIsInstance(result, float)
+        self.assertGreater(result, 0)
+
+    def test_itu_rain_attenuation(self):
+        result = itu_rain_attenuation(10, 45)
+        self.assertIsInstance(result, float)
+        self.assertGreaterEqual(result, 0)
+
+    def test_bistatic_radar_model(self):
+        result = bistatic_radar_model(
+            v=200,
+            h=1000,
+            uav_interval=500,
+            psi_t=30,
+            psi_r=60,
+            srcs='лес летом',
+            cloud_base=500,
+            cloud_thickness=1000,
+            rain_rate=10
+        )
+        self.assertNotEqual(result, 'none')
+        self.assertIsInstance(result, dict)
+        self.assertIn('dx', result)
+        self.assertIn('dy', result)
+        self.assertIn('snr', result)
+        self.assertIn('tau', result)
+        self.assertIn('tau_echo', result)
+        self.assertIn('t_repeat', result)
+        self.assertIn('t_synthesis_max', result)
+
+if __name__ == '__main__':
+    unittest.main()