ИНОЕ ЗРЕНИЕ

ТЕХНИЧЕСКОЕ ЗАДАНИЕ (ТЗ)

на разработку СС-сканера (Сканера Стоячего Слоя) – анализатора когерентно-энергетической информации (КЭИ)

Разработчик: Resonance Group

Марков М. Приходько С.

1. ОБЩИЕ ПОЛОЖЕНИЯ

1.1. Настоящее ТЗ определяет требования к программному продукту «СС-сканер», предназначенному для визуализации и количественного анализа пространственного распределения когерентно-энергетической информации (КЭИ) в исследуемых объектах.

1.2. СС-сканер работает на основе принципов резонансной физики и использует фундаментальную частоту стоячего слоя f0=400/7≈57,142857 Гц. Постоянная тонкой структуры α−1=137,036 и ядерная О-длина LO=0,036 фм применяются как калибровочные коэффициенты.

1.3. Область применения: контроль качества материалов, микроэлектроники, геологии, археологии, а также научные исследования в области резонансных взаимодействий.

2. ТЕРМИНЫ И ОПРЕДЕЛЕНИЯ

2.1. КЭИ (когерентно-энергетическая информация) – совокупность точек пространства, в которых локальная плотность поля и фаза удовлетворяют условию конструктивной интерференции стоячего слоя.

2.2. Энтропия – локальная характеристика поля, вычисляемая как усреднённая интенсивность (яркость) пикселей изображения, отражающая степень хаотичности распределения энергии в данной точке.

2.3. Когерентность – мера упорядоченности поля, определяемая через нелинейную комбинацию гармоник, связанных с частотой f0​ и числом узлов 49. Высокие значения когерентности соответствуют зонам с выраженной структурой.

2.4. Узлы КЭИ – связные области пикселей, в которых значение когерентности превышает адаптивный порог (метод Оцу). Узлы отображаются в виде центров масс кластеров.

2.5. Стоячий слой – физическая модель пространства, в котором интерференция волн образует стационарную структуру узлов и пучностей.

3. ФУНКЦИОНАЛЬНЫЕ ТРЕБОВАНИЯ

3.1. СС-сканер должен обеспечивать:

• захват видеопотока с веб-камеры или загрузку статичных изображений;
• предварительную обработку кадра (масштабирование до размера 256×256 пикселей);
• вычисление энтропии по каналу яркости;
• вычисление когерентности на основе фильтра Габора и формулы, связывающей энтропию с гармониками (31, 49, 57,14);
• применение адаптивного порога (метод Оцу) для бинаризации;
• кластеризацию связных компонент с минимальным размером кластера 5 пикселей;
• определение количества узлов КЭИ и вычисление индекса КЭИ (процент узлов от общего количества пикселей);
• формирование итогового вердикта по шкале от «диссонанс» до «исключительная когерентность»;
• отображение исходного кадра и карты узлов в графическом интерфейсе.

3.2. Режимы работы: «Чипы», «Камни», «Багаж». Режимы влияют только на интерпретацию вердикта (пороги количества узлов), алгоритм обработки не изменяется.

4. ТЕХНИЧЕСКИЕ ТРЕБОВАНИЯ

4.1. Программная платформа: Python 3.10 или новее.

4.2. Используемые библиотеки: OpenCV, NumPy, Pillow, SciPy (для кластеризации).

4.3. Размер рабочего кадра: 256×256 пикселей.

4.4. Время обработки одного кадра на центральном процессоре: не более 200 мс.

4.5. Поддерживаемые форматы изображений: JPG, PNG, BMP, GIF.

4.6. Интерфейс пользователя: графическое окно с двумя панелями (исходное изображение и карта узлов), кнопками управления, переключателем режимов, полем вывода отчёта.

5. АЛГОРИТМ ОБРАБОТКИ (ПОСЛЕДОВАТЕЛЬНОСТЬ ОПЕРАЦИЙ)

5.1. Получение кадра (из камеры или файла) и приведение к размеру 256×256.

5.2. Перевод кадра в оттенки серого.

5.3. Применение фильтра Габора с параметрами: размер ядра = 31, сигма = 5,0, длина волны = 256/7 ≈ 36,57, угол = 0. Результат – карта отклика, нормализованная к диапазону [0,1].

5.4. Вычисление энтропии (нормализованной интенсивности) путём усреднения по каналам и деления на 255.

5.5. Расчёт когерентности по формуле:

C=∣sin⁡(31⋅E)⋅cos⁡(49⋅E)⋅sin⁡(400/7⋅E)∣+LO⋅cos⁡(137,036⋅E) где E – энтропия, LO=0,036. Полученное значение нормализуется.

5.6. Пороговая обработка методом Оцу: значения когерентности преобразуются в 8-битный диапазон и бинаризуются.

5.7. Кластеризация бинарной маски: выделение связных компонент (8-связность). Исключение кластеров размером менее 5 пикселей.

5.8. Для каждого значимого кластера вычисляется центр масс, который отображается белым кругом радиусом 3 пикселя на карте узлов.

5.9. Вычисление индекса КЭИ: отношение числа значимых кластеров к общему числу пикселей, умноженное на 100.

5.10. Формирование вердикта:

• менее 2 кластеров – «Диссонанс»;
• от 2 до 4 – «Слабый резонанс»;
• от 5 до 14 – «Умеренный резонанс»;
• от 15 до 29 – «Высокий резонанс»;
• 30 и более – «Исключительная когерентность».

6. ТРЕБОВАНИЯ К ИНТЕРФЕЙСУ

6.1. Окно приложения должно содержать:

• заголовок «СС-сканер — КЭИ анализатор»;
• левую панель с исходным изображением;
• правую панель с картой узлов;
• кнопку «Камера» для включения/выключения видеозахвата;
• кнопку «Загрузить» для выбора файла;
• переключатели режимов «Чипы», «Камни», «Багаж»;
• кнопку «Анализировать» для ручного запуска обработки;
• текстовое поле отчёта с количеством узлов, индексом КЭИ и вердиктом.

6.2. При работе с камерой обработка кадров должна выполняться в отдельном потоке, чтобы интерфейс оставался отзывчивым.

7. ТРЕБОВАНИЯ К СБОРКЕ И РАЗВЁРТЫВАНИЮ

7.1. Исходный код должен быть предоставлен в виде Python-скрипта.

7.2. Для инженеров должна быть предусмотрена возможность сборки в единый исполняемый файл (Windows .exe) с помощью PyInstaller:

text

pyinstaller --onefile --windowed --name "СС-сканер" ss_scanner.py

7.3. Приложение должно работать автономно после сборки, без необходимости установки Python.

8. ПЕРЕЧЕНЬ КОНСТАНТ, ИСПОЛЬЗУЕМЫХ В АЛГОРИТМЕ

• f0=400/7≈57,142857 Гц – частота стоячего слоя;
• α−1=137,036 – обратная постоянная тонкой структуры;
• LO=0,036 – ядерная О-длина;
• Размер кадра: 256×256;
• Минимальный размер кластера: 5 пикселей;
• Радиус отображения узла: 3 пикселя.

СИМУЛЯЦИЯ

python

import cv2

import numpy as np

import tkinter as tk

from tkinter import filedialog, Label, Button, Frame, StringVar

from PIL import Image, ImageTk

import threading

import time

from scipy import ndimage

ALPHA_INV = 137.036

LO = 0.036

FREF = 400 / 7

SIZE = 256

class SSScanner:

def __init__(self, root):

self.root = root

self.root.title("СС-сканер — Фазовые кластеры стоячего слоя")

self.root.configure(bg='#0a0a0a')

self.current_mode = 'chips'

self.is_camera_active = False

self.cap = None

self.img_data = None

self.video_thread = None

self.running = False

self.create_widgets()

self.update_report("Ожидание снимка или включения камеры...")

def create_widgets(self):

title = tk.Label(self.root, text="СС-сканер — Фазовые кластеры стоячего слоя",

fg='#0ff', bg='#0a0a0a', font=('monospace', 16, 'bold'))

title.pack(pady=10)

subtitle = tk.Label(self.root, text="Тройственность: резонанс · связь · материя",

fg='#0ff', bg='#0a0a0a', font=('monospace', 10))

subtitle.pack()

container = tk.Frame(self.root, bg='#0a0a0a')

container.pack(pady=10)

left_panel = tk.Frame(container, bg='#111', relief='solid', bd=1)

left_panel.pack(side='left', padx=10)

tk.Label(left_panel, text="Исходный поток", fg='#0ff', bg='#111', font=('monospace', 10)).pack(pady=5)

self.input_canvas = tk.Canvas(left_panel, width=SIZE, height=SIZE, bg='#000', highlightthickness=1, highlightcolor='#555')

self.input_canvas.pack(padx=5, pady=5)

right_panel = tk.Frame(container, bg='#111', relief='solid', bd=1)

right_panel.pack(side='left', padx=10)

tk.Label(right_panel, text="Фазовые кластеры", fg='#0ff', bg='#111', font=('monospace', 10)).pack(pady=5)

self.output_canvas = tk.Canvas(right_panel, width=SIZE, height=SIZE, bg='#000', highlightthickness=1, highlightcolor='#555')

self.output_canvas.pack(padx=5, pady=5)

controls = tk.Frame(self.root, bg='#0a0a0a')

controls.pack(pady=10)

self.camera_btn = tk.Button(controls, text="Камера", command=self.toggle_camera,

bg='#ff00ff', fg='#fff', font=('monospace', 10, 'bold'))

self.camera_btn.pack(side='left', padx=5)

self.load_btn = tk.Button(controls, text="Загрузить", command=self.load_image,

bg='#333', fg='#aaa', font=('monospace', 10))

self.load_btn.pack(side='left', padx=5)

self.mode_buttons = {}

for mode, label in [('chips', 'Чипы'), ('stones', 'Камни'), ('cargo', 'Багаж')]:

btn = tk.Button(controls, text=label, command=lambda m=mode: self.set_mode(m),

bg='#333' if mode != 'chips' else '#00ddff',

fg='#aaa' if mode != 'chips' else '#000', font=('monospace', 10))

btn.pack(side='left', padx=2)

self.mode_buttons[mode] = btn

self.analyze_btn = tk.Button(controls, text="Анализировать", command=self.process_current_frame,

bg='#0ff', fg='#000', font=('monospace', 10, 'bold'))

self.analyze_btn.pack(side='left', padx=5)

self.report_var = tk.StringVar()

self.report_label = tk.Label(self.root, textvariable=self.report_var,

fg='#0ff', bg='#000', font=('monospace', 10),

justify='left', relief='solid', bd=1, padx=15, pady=10)

self.report_label.pack(pady=10, ipadx=10)

self.set_mode('chips')

def toggle_camera(self):

if not self.is_camera_active:

self.start_camera()

else:

self.stop_camera()

def start_camera(self):

self.cap = cv2.VideoCapture(0)

if not self.cap.isOpened():

self.update_report("Ошибка доступа к камере.")

return

self.is_camera_active = True

self.camera_btn.config(text="Стоп", bg='#00ff00', fg='#000')

self.running = True

self.video_thread = threading.Thread(target=self.process_video)

self.video_thread.daemon = True

self.video_thread.start()

self.update_report("Камера включена. Обработка...")

def stop_camera(self):

self.running = False

if self.video_thread:

self.video_thread.join(timeout=0.5)

if self.cap:

self.cap.release()

self.cap = None

self.is_camera_active = False

self.camera_btn.config(text="Камера", bg='#ff00ff', fg='#fff')

self.clear_canvas(self.output_canvas)

self.update_report("Камера остановлена.")

def process_video(self):

while self.running and self.cap and self.cap.isOpened():

ret, frame = self.cap.read()

if not ret:

break

frame = cv2.resize(frame, (SIZE, SIZE))

frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

self.img_data = frame_rgb

self.display_image(self.input_canvas, frame_rgb)

self.process_current_frame()

time.sleep(0.1)

def load_image(self):

if self.is_camera_active:

self.stop_camera()

path = filedialog.askopenfilename(filetypes=[("Images", "*.jpg *.jpeg *.png *.bmp *.gif")])

if path:

img = cv2.imread(path)

if img is not None:

img = cv2.resize(img, (SIZE, SIZE))

img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

self.img_data = img_rgb

self.display_image(self.input_canvas, img_rgb)

self.process_current_frame()

else:

self.update_report("Не удалось загрузить изображение.")

def display_image(self, canvas, img):

if img is None:

return

img = (img * 255).astype(np.uint8) if img.dtype != np.uint8 else img

pil_img = Image.fromarray(img)

tk_img = ImageTk.PhotoImage(pil_img)

canvas.create_image(0, 0, anchor='nw', image=tk_img)

canvas.image = tk_img

def clear_canvas(self, canvas):

canvas.delete("all")

def process_current_frame(self):

if self.img_data is None:

return

h, w = self.img_data.shape[:2]

gray = cv2.cvtColor(self.img_data, cv2.COLOR_RGB2GRAY).astype(np.float32)

ksize, sigma, theta, lam, gamma, psi = 31, 5.0, 0, SIZE / 7, 0.5, 0

kernel = cv2.getGaborKernel((ksize, ksize), sigma, theta, lam, gamma, psi, ktype=cv2.CV_32F)

response = cv2.filter2D(gray, cv2.CV_32F, kernel)

field_density = np.abs(response)

field_density = field_density / (np.max(field_density) + 1e-9)

wave = np.sin(field_density * 31) * np.cos(field_density * 49) * np.sin(field_density * FREF)

resonance_purity = np.abs(wave) + LO * np.cos(ALPHA_INV * field_density)

resonance_purity = resonance_purity / (np.max(resonance_purity) + 1e-9)

purity_8u = (resonance_purity * 255).astype(np.uint8)

_, binary_mask = cv2.threshold(purity_8u, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

mask_bool = binary_mask > 0

labeled, num_clusters = ndimage.label(mask_bool, structure=np.ones((3, 3)))

cluster_sizes = np.bincount(labeled.ravel())

if len(cluster_sizes) > 1:

cluster_sizes = cluster_sizes[1:]

else:

cluster_sizes = np.array([])

min_size = 5

large_clusters = cluster_sizes[cluster_sizes >= min_size]

num_real_nodes = len(large_clusters)

output = np.zeros((h, w, 3), dtype=np.uint8)

for label_id in range(1, num_clusters + 1):

mask_cluster = (labeled == label_id)

if np.sum(mask_cluster) < min_size:

continue

y_coords, x_coords = np.where(mask_cluster)

cy, cx = int(np.mean(y_coords)), int(np.mean(x_coords))

cv2.circle(output, (cx, cy), 3, (255, 255, 255), -1)

self.display_image(self.output_canvas, output)

purity_index = (num_real_nodes / (h * w)) * 100

mode_names = {'chips': 'Чипы', 'stones': 'Камни', 'cargo': 'Багаж'}

mode_name = mode_names.get(self.current_mode, 'Объект')

if num_real_nodes < 2:

verdict = "Диссонанс (шум)"

elif num_real_nodes < 5:

verdict = "Слабый резонанс"

elif num_real_nodes < 15:

verdict = "Умеренный резонанс"

elif num_real_nodes < 30:

verdict = "Высокий резонанс"

else:

verdict = "Исключительная когерентность"

self.update_report(f"Режим: {mode_name}\nКластеров: {num_real_nodes}\nИндекс резонансной чистоты: {purity_index:.2f}%\nВердикт: {verdict}")

def update_report(self, text):

self.report_var.set(text)

def set_mode(self, mode):

self.current_mode = mode

for m, btn in self.mode_buttons.items():

btn.config(bg='#00ddff' if m == mode else '#333', fg='#000' if m == mode else '#aaa')

if self.img_data is not None:

self.process_current_frame()

def on_closing(self):

self.running = False

if self.cap:

self.cap.release()

self.root.quit()

self.root.destroy()

if __name__ == "__main__":

root = tk.Tk()

app = SSScanner(root)

root.protocol("WM_DELETE_WINDOW", app.on_closing)

root.mainloop()

ЗАКЛЮЧЕНИЕ

Данное ТЗ устанавливает необходимый минимум требований для разработки и поставки СС-сканера. Программа должна быть реализована в соответствии с описанным алгоритмом и удовлетворять всем функциональным и техническим требованиям, изложенным выше.Рабочий прототип по запросу.