Update app.py

app.py

@@ -152,11 +152,14 @@ import asyncio
 
 app = FastAPI()
 
+# Размеры дисплея
 DISP_W = 96
 DISP_H = 96
-GRID_SIZE = 2          # 4 части 48x48
-PART_W = DISP_W // GRID_SIZE
-PART_H = DISP_H // GRID_SIZE
+
+# Разбиение на 4 части (2x2)
+GRID_SIZE = 2
+PART_W = DISP_W // GRID_SIZE   # 48
+PART_H = DISP_H // GRID_SIZE   # 48
 ROWS = GRID_SIZE
 COLS = GRID_SIZE
 
@@ -164,39 +167,55 @@ PIXEL_CHAR = "█"
 ADMIN_KEY = "supersecret123"
 current_streamer = None
 
-parts = {}
-full_text = None
+# Хранилище: для каждой части сохраняем сырой numpy-массив (48,48,3)
+parts_raw = {}
+full_text = None          # весь кадр (опционально)
 text_lock = asyncio.Lock()
 
 # ----------------------------------------------------------------
 def rgb_to_hex_amp(r, g, b):
+    """RGB (0-255) → &#RRGGBB"""
     return f"&#{r:02X}{g:02X}{b:02X}"
 
-def compress_tile(tile_rgb):
+def compress_tile(tile_rgb, use_rle=False):
+    """
+    Преобразует прямоугольный фрагмент в строку.
+    use_rle=False → каждый пиксель отдельно (фиксированная длина строки).
+    use_rle=True  → сжатие RLE (длина плавает).
+    """
     h, w, _ = tile_rgb.shape
     lines = []
     for y in range(h):
-        parts_line = []
-        prev_color = None
-        run = 0
-        for x in range(w):
-            r, g, b = tile_rgb[y, x]
-            current = (r, g, b)
-            if current == prev_color:
-                run += 1
-            else:
-                if prev_color is not None and run > 0:
-                    parts_line.append(rgb_to_hex_amp(*prev_color))
-                    parts_line.append(PIXEL_CHAR * run)
-                prev_color = current
-                run = 1
-        if prev_color is not None and run > 0:
-            parts_line.append(rgb_to_hex_amp(*prev_color))
-            parts_line.append(PIXEL_CHAR * run)
-        lines.append("".join(parts_line))
+        if not use_rle:
+            # Каждый пиксель: &#RRGGBB + символ, ровно 10 символов
+            row_str = "".join(
+                rgb_to_hex_amp(tile_rgb[y, x, 0], tile_rgb[y, x, 1], tile_rgb[y, x, 2]) + PIXEL_CHAR
+                for x in range(w)
+            )
+            lines.append(row_str)
+        else:
+            parts_line = []
+            prev_color = None
+            run = 0
+            for x in range(w):
+                r, g, b = tile_rgb[y, x]
+                current = (r, g, b)
+                if current == prev_color:
+                    run += 1
+                else:
+                    if prev_color is not None and run > 0:
+                        parts_line.append(rgb_to_hex_amp(*prev_color))
+                        parts_line.append(PIXEL_CHAR * run)
+                    prev_color = current
+                    run = 1
+            if prev_color is not None and run > 0:
+                parts_line.append(rgb_to_hex_amp(*prev_color))
+                parts_line.append(PIXEL_CHAR * run)
+            lines.append("".join(parts_line))
     return "\n".join(lines)
 
 # ----------------------------------------------------------------
+# HTML-интерфейс стримера (без изменений)
 @app.get("/", response_class=HTMLResponse)
 def home(nick: str = "Unknown"):
     return f"""
@@ -279,31 +298,31 @@ def force_stop(key: str):
 # ----------------------------------------------------------------
 @app.post("/frame_upload")
 async def frame_upload(file: UploadFile):
-    global parts, full_text
+    global parts_raw, full_text
     data = await file.read()
     nparr = np.frombuffer(data, np.uint8)
     frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
     frame = cv2.resize(frame, (DISP_W, DISP_H))
     frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
 
-    new_parts = {}
+    new_parts_raw = {}
     for row in range(ROWS):
         for col in range(COLS):
             y1 = row * PART_H
             y2 = y1 + PART_H
             x1 = col * PART_W
             x2 = x1 + PART_W
-            tile = frame_rgb[y1:y2, x1:x2]
-            compressed = compress_tile(tile)
-            new_parts[(row, col)] = compressed
+            tile = frame_rgb[y1:y2, x1:x2].copy()
+            new_parts_raw[(row, col)] = tile
 
-    full_compressed = compress_tile(frame_rgb)
+    # Полный кадр сохраняем в сжатом виде (для /pixels_full)
+    full_compressed = compress_tile(frame_rgb, use_rle=False)
 
     async with text_lock:
-        parts = new_parts
+        parts_raw = new_parts_raw
         full_text = full_compressed
 
-    return {"ok": True, "parts": len(new_parts), "full_length": len(full_compressed)}
+    return {"ok": True, "parts": len(new_parts_raw), "full_length": len(full_compressed)}
 
 @app.get("/info")
 async def get_info():
@@ -318,12 +337,22 @@ async def get_info():
     }
 
 @app.get("/pixels_part")
-async def get_pixels_part(row: int, col: int, format: str = "text"):
+async def get_pixels_part(row: int, col: int, rle: int = 0, format: str = "text"):
+    """
+    Возвращает часть изображения.
+    rle=0 (по умолчанию) – фиксированная длина строки, без сжатия.
+    rle=1 – RLE-сжатие (длина строки плавает).
+    format=json – JSON с длиной и текстом.
+    format=text (по умолчанию) – чистый текст.
+    """
     async with text_lock:
-        text = parts.get((row, col))
-        if text is None:
+        tile = parts_raw.get((row, col))
+        if tile is None:
             return JSONResponse({"error": "Part not found"}, status_code=404)
 
+        # Кодируем на лету в зависимости от rle
+        text = compress_tile(tile, use_rle=bool(rle))
+
         if format == "json":
             return {
                 "row": row,
@@ -336,6 +365,7 @@ async def get_pixels_part(row: int, col: int, format: str = "text"):
 
 @app.get("/pixels_full")
 async def get_pixels_full():
+    """Весь кадр одной строкой (может быть большим, используй с осторожностью)"""
     async with text_lock:
         if full_text is None:
             return JSONResponse({"error": "Нет кадра"}, status_code=404)
@@ -357,6 +387,7 @@ async def get_pixels_full():
 
 
 
+
 # =========================
 # 🚀 RUN
 # =========================