Globally redesigned user interface, abandonment of gr.ImageEditor. Improved logic for working with gr.Examples. Added preliminary compression of large images.

Author: rybakov-ks

particleanalyzer/assets/instruction.mp4

@@ -2,7 +2,6 @@
 import pandas as pd
 import cv2
 import numpy as np
-import math
 from tqdm import tqdm
 import gradio as gr
 from datetime import datetime
@@ -32,6 +31,7 @@ def _get_translation(self, text):
     def preprocess_image(
         self,
         image: np.ndarray,
+        scale: float,
         scale_selector: dict,
         solution: str,
         request: gr.Request,
@@ -45,16 +45,13 @@ def preprocess_image(
         pbar.set_description(self._get_translation("Загрузка изображения..."))
         pr(0.25, desc=self._get_translation("Загрузка изображения..."))
         try:
-            # Обработка шкалы прибора
-            scale = None
-            if scale_selector["scale"]:
-                scale = self._determine_pixel_scale(image)
-                if scale is None:
-                    return None, None, None, None
-                image = image["background"]
-                image = self._convert_image_channels(image)
-            else:
-                image = np.array(image)
+            if scale_selector["scale"] and scale is None:
+                gr.Info(
+                    self._get_translation(
+                        "Обозначьте на изображении масштабную шкалу при помощи двух точек."
+                    )
+                )
+                return None, None, None, None, None
 
             # Сохранение метаданных
             self._save_image_metadata(image, request)
@@ -72,14 +69,6 @@ def preprocess_image(
             print(f"Ошибка при обработке изображения: {e}")
             return None, None, None, None, None
 
-    def _convert_image_channels(self, image: np.ndarray) -> np.ndarray:
-        """Конвертирует изображение в RGB при необходимости."""
-        if image.shape[-1] == 4:  # RGBA → RGB
-            return cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)
-        elif image.shape[-1] == 1:  # Grayscale → RGB
-            return cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
-        return image
-
     @staticmethod
     def resize_image(
         image: np.ndarray,
@@ -147,81 +136,3 @@ def _save_image_metadata(self, image: np.ndarray, request: gr.Request) -> None:
         except Exception:
             pass
             # print(f"Ошибка при сохранении метаданных: {e}")
-
-    def get_error_response(self) -> tuple:
-        """Возвращает кортеж с None для обработки ошибок."""
-        return (None,) * 13
-
-    def _determine_pixel_scale(self, data):
-        """Определяет размер пикселя в реальных единицах (μm/px)"""
-        layers = data.get("layers", [])
-        if layers:
-            layer = layers[0]
-            if layer.shape[-1] == 4:
-                layer = cv2.cvtColor(layer, cv2.COLOR_RGBA2RGB)
-
-            # Создаем маски для разных цветов (зеленый, красный, синий, желтый)
-            lower_green = np.array([0, 128, 0])
-            upper_green = np.array([100, 255, 100])
-
-            lower_red = np.array([0, 0, 128])
-            upper_red = np.array([100, 100, 255])
-
-            lower_blue = np.array([0, 0, 128])
-            upper_blue = np.array([100, 100, 255])
-
-            lower_yellow = np.array([128, 128, 0])
-            upper_yellow = np.array([255, 255, 100])
-
-            # Создаем маску для всех цветов
-            mask_green = cv2.inRange(layer, lower_green, upper_green)
-            mask_red = cv2.inRange(layer, lower_red, upper_red)
-            mask_blue = cv2.inRange(layer, lower_blue, upper_blue)
-            mask_yellow = cv2.inRange(layer, lower_yellow, upper_yellow)
-
-            # Объединяем все маски
-            mask = cv2.bitwise_or(
-                mask_green,
-                cv2.bitwise_or(mask_red, cv2.bitwise_or(mask_blue, mask_yellow)),
-            )
-
-            # Находим контуры на маске
-            contours, _ = cv2.findContours(
-                mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
-            )
-
-            if len(contours) == 2:
-                # Рассчитываем центроиды для первых двух контуров
-                moments1 = cv2.moments(contours[0])
-                moments2 = cv2.moments(contours[1])
-
-                if moments1["m00"] != 0 and moments2["m00"] != 0:
-                    cx1 = int(moments1["m10"] / moments1["m00"])
-                    cy1 = int(moments1["m01"] / moments1["m00"])
-                    cx2 = int(moments2["m10"] / moments2["m00"])
-                    cy2 = int(moments2["m01"] / moments2["m00"])
-
-                    # Рассчитываем расстояние между центрами масс двух контуров
-                    distance = math.sqrt((cx2 - cx1) ** 2 + (cy2 - cy1) ** 2)
-                else:
-                    gr.Info(self._get_translation("Ошибка в вычислении центроида."))
-            elif len(contours) > 2:
-                distance = False
-                gr.Info(self._get_translation("Найдено больше двух точек."))
-            else:
-                distance = False
-                gr.Info(
-                    self._get_translation(
-                        "Обозначьте на изображении масштабную шкалу при помощи двух точек."
-                    )
-                )
-            # Возвращаем расстояние
-            return distance
-        else:
-            # Если слоев нет, возвращаем False
-            gr.Info(
-                self._get_translation(
-                    "Обозначьте на изображении масштабную шкалу при помощи двух точек."
-                )
-            )
-            return False

particleanalyzer/core/ImagePreprocessor.py

@@ -27,9 +27,12 @@
 from particleanalyzer.core.StatisticsBuilder import StatisticsBuilder
 from particleanalyzer.core.languages import translations
 from particleanalyzer.core.language_context import LanguageContext
+from particleanalyzer.core.PointManager import PointManager
 
 lang = "en"
 
+point_manager = PointManager()
+
 
 class ParticleAnalyzer:
     SCALE_OPTIONS = {
@@ -133,12 +136,14 @@ def _create_error_return(self) -> Tuple:
             None,
             None,
             gr.update(visible=False),
+            gr.update(visible=False),
         )
 
     def analyze_image(
         self,
-        image: np.ndarray,
         image2: Optional[np.ndarray],
+        scale: float,
+        points_scale: tuple,
         scale_input: float,
         confidence_threshold: float,
         scale_selector: str,
@@ -178,24 +183,16 @@ def analyze_image(
                 bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}{postfix}]",
             )
             pr(0, desc=self._get_translation("Подготовка..."))
-            selected_image = image if scale_selector["scale"] else image2
-            if scale_selector["scale"]:
-                if (
-                    image.get("background") is None
-                    and image.get("composite") is None
-                    and not image.get("layers")
-                ):
-                    gr.Warning(
-                        self._get_translation("Ошибка: изображение отсутствует...")
-                    )
-                    return self._create_error_return()
-            elif image2 is None:
+            selected_image = image2
+
+            if selected_image is None:
                 gr.Warning(self._get_translation("Ошибка: изображение отсутствует..."))
                 return self._create_error_return()
 
             image, orig_image, gray_image, scale, scale_factor_glob = (
                 self.preprocessor.preprocess_image(
                     image=selected_image,
+                    scale=scale,
                     scale_selector=scale_selector,
                     solution=solution,
                     request=request,
@@ -244,6 +241,11 @@ def analyze_image(
                 return self._create_error_return()
 
             output_image = cv2.cvtColor(output_image, cv2.COLOR_BGR2RGB)
+            if scale_selector["scale"]:
+                output_image = point_manager.draw_scale_on_image(
+                    output_image, scale_factor_glob, scale, *points_scale
+                )
+
             df = pd.DataFrame(particle_data)
             points_df = pd.DataFrame(df["points"])
             df = df.drop(columns=["points"])
@@ -322,6 +324,7 @@ def analyze_image(
                     value=(limits["I_min"], limits["I_max"]),
                 ),
                 gr.update(visible=True),
+                gr.update(visible=True),
             )
         except Exception as e:
             self._handle_error(e)

particleanalyzer/core/ParticleAnalyzer.py

@@ -0,0 +1,101 @@
+import numpy as np
+import gradio as gr
+from PIL import Image, ImageDraw, ImageFont
+from particleanalyzer.core.languages import translations
+from particleanalyzer.core.language_context import LanguageContext
+
+
+class PointManager:
+    def __init__(self, lang="ru"):
+        self.points = []
+        self.lang = lang
+
+    def _get_translation(self, text):
+        return translations.get(self.lang, {}).get(text, text)
+
+    def add_point(self, point):
+        if len(self.points) >= 2:
+            self.points = [point]
+        else:
+            self.points.append(point)
+        return self.points
+
+    def clear_points(self):
+        self.points = []
+        return self.points
+
+    def handle_select(self, evt: gr.SelectData):
+        self.lang = LanguageContext.get_language()
+        self.add_point(evt.index)
+        if len(self.points) == 2:
+            point1, point2 = self.points[0], self.points[1]
+            distance = np.sqrt(
+                (point2[0] - point1[0]) ** 2 + (point2[1] - point1[1]) ** 2
+            )
+            return (
+                f"{self._get_translation('Расстояние равно')}: {distance:.0f} {self._get_translation('пикселей')}",
+                distance,
+                (point1, point2),
+            )
+        else:
+            return (
+                f"{self._get_translation('Выбрано точек')}: {len(self.points)}/2",
+                None,
+                None,
+            )
+
+    def draw_scale_on_image(self, image, scale_factor, distance, point1, point2):
+        pil_image = Image.fromarray(image)
+        draw = ImageDraw.Draw(pil_image)
+
+        scaled_line_width = max(1, int(3))
+        scaled_font_size = max(10, int(20))
+        scaled_circle_radius = max(2, int(5))
+        scaled_padding = max(2, int(5))
+
+        LINE_COLOR = (255, 0, 0)
+        TEXT_COLOR = (255, 255, 255)
+        BG_COLOR = (0, 0, 0)
+
+        try:
+            font = ImageFont.truetype("arial.ttf", scaled_font_size)
+        except IOError:
+            font = ImageFont.load_default()
+
+        scaled_point1 = (int(point1[0] / scale_factor), int(point1[1] / scale_factor))
+        scaled_point2 = (int(point2[0] / scale_factor), int(point2[1] / scale_factor))
+
+        draw.line(
+            [scaled_point1, scaled_point2], fill=LINE_COLOR, width=scaled_line_width
+        )
+
+        def draw_circle(center, radius):
+            x, y = center
+            draw.ellipse(
+                [x - radius, y - radius, x + radius, y + radius], fill=LINE_COLOR
+            )
+
+        draw_circle(scaled_point1, scaled_circle_radius)
+        draw_circle(scaled_point2, scaled_circle_radius)
+
+        mid_x = (scaled_point1[0] + scaled_point2[0]) // 2
+        mid_y = (scaled_point1[1] + scaled_point2[1]) // 2
+
+        text = f"{distance:.0f} px"
+        bbox = draw.textbbox((0, 0), text, font=font)
+        text_width, text_height = bbox[2] - bbox[0], bbox[3] - bbox[1]
+
+        bg_x1 = mid_x - text_width // 2 - scaled_padding
+        bg_y1 = mid_y - text_height // 2 - scaled_padding
+        bg_x2 = mid_x + text_width // 2 + scaled_padding
+        bg_y2 = mid_y + text_height // 2 + scaled_padding
+
+        draw.rectangle([bg_x1, bg_y1, bg_x2, bg_y2], fill=BG_COLOR)
+        draw.text(
+            (bg_x1 + scaled_padding, bg_y1 + scaled_padding),
+            text,
+            fill=TEXT_COLOR,
+            font=font,
+        )
+
+        return np.array(pil_image)

particleanalyzer/core/PointManager.py

@@ -26,6 +26,7 @@
         "Достигнут предел количества обнаружений. Увеличьте максимальное количество обнаружений в настройках.": "Достигнут предел количества обнаружений. Увеличьте максимальное количество обнаружений в настройках.",
         "Обработка частиц...": "Обработка частиц...",
         "мкм": "мкм",
+        "нм": "нм",
         "пикс": "пикс",
         "ед.": "ед.",
         "Диаметр": "Диаметр",
@@ -140,6 +141,11 @@
         "Удалить частицы": "Удалить частицы",
         "Сбросить таблицу": "Сбросить таблицу",
         "Загрузить изображение СЭМ": "Загрузить изображение СЭМ",
+        "Статус калибровки масштаба": "Статус калибровки масштаба",
+        "Выберите две крайние точки на шкале": "Выберите две крайние точки на шкале",
+        "Расстояние равно": "Расстояние равно",
+        "пикселей": "пикселей",
+        "Выбрано точек": "Выбрано точек",
     },
     "en": {
         "Подготовка...": "Initializing...",
@@ -155,6 +161,7 @@
         "Обработка частиц...": "Processing particles...",
         "ед.": "units",
         "мкм": "µm",
+        "нм": "nm",
         "пикс": "px",
         "Диаметр": "Diameter",
         "Средний диаметр": "Average diameter",
@@ -268,6 +275,11 @@
         "Удалить частицы": "Remove particles",
         "Сбросить таблицу": "Reset table",
         "Загрузить изображение СЭМ": "Upload SEM image",
+        "Статус калибровки масштаба": "Scale calibration status",
+        "Выберите две крайние точки на шкале": "Select the two extreme points of the scale.",
+        "Расстояние равно": "Distance is",
+        "пикселей": "pixels",
+        "Выбрано точек": "Points selected",
     },
     "zh-cn": {
         "Подготовка...": "初始化中...",
@@ -282,6 +294,7 @@
         "Достигнут предел количества обнаружений. Увеличьте максимальное количество обнаружений в настройках.": "达到检测数量上限。请在设置中增加最大检测数量",
         "Обработка частиц...": "正在处理粒子...",
         "мкм": "微米",
+        "нм": "纳米",
         "пикс": "像素",
         "ед.": "单位",
         "Диаметр": "直径",
@@ -396,6 +409,11 @@
         "Удалить частицы": "去除颗粒",
         "Сбросить таблицу": "重置表",
         "Загрузить изображение СЭМ": "上传扫描电镜图像",
+        "Статус калибровки масштаба": "秤校准状态",
+        "Выберите две крайние точки на шкале": "选择尺度的两个极值点。",
+        "Расстояние равно": "距离",
+        "пикселей": "像素",
+        "Выбрано точек": "已选点",
     },
     "zh-tw": {
         "Подготовка...": "初始化中...",
@@ -410,6 +428,7 @@
         "Достигнут предел количества обнаружений. Увеличьте максимальное количество обнаружений в настройках.": "達到檢測數量上限。請在設定中增加最大檢測數量",
         "Обработка частиц...": "正在處理粒子...",
         "мкм": "微米",
+        "нм": "奈米",
         "пикс": "像素",
         "ед.": "單位",
         "Диаметр": "直徑",
@@ -531,6 +550,11 @@
         "Удалить частицы": "去除顆粒",
         "Сбросить таблицу": "重設表",
         "Загрузить изображение СЭМ": "上傳掃描電子顯微鏡影像",
+        "Статус калибровки масштаба": "秤校準狀態",
+        "Выберите две крайние точки на шкале": "選擇尺度的兩個極值點。",
+        "Расстояние равно": "距離",
+        "пикселей": "像素",
+        "Выбрано точек": "已選點",
     },
 }