Update app.py

app.py

@@ -1,33 +1,106 @@
 import os
-import io
+import math
 import re
+import tempfile
+from flask import Flask, render_template, request, send_file, Response
+from PIL import Image, ImageOps, ImageDraw
 import numpy as np
-from flask import Flask, render_template, request, send_file
-from PIL import Image
-import xml.etree.ElementTree as ET
 
+# Проверка наличия MoviePy
 try:
     from moviepy.editor import VideoFileClip
-    HAS_MOVIEPY = True
+    MOVIEPY_AVAILABLE = True
 except ImportError:
-    HAS_MOVIEPY = False
+    MOVIEPY_AVAILABLE = False
 
 app = Flask(__name__)
 
-# Рекурсивная функция для удаления жестко заданных цветов внутри SVG-файлов
-def strip_fill_colors(elem):
-    # Удаляем fill если он не "none" (none обычно используется для обводки)
-    if 'fill' in elem.attrib and elem.attrib['fill'].lower() != 'none':
-        del elem.attrib['fill']
+# --- Вспомогательные функции ---
+
+def prepare_svg_content(file_storage):
+    """Читает SVG и готовит его для вставки"""
+    try:
+        raw_data = file_storage.read().decode('utf-8')
+        vb_match = re.search(r'viewBox=["\']([^"\']+)["\']', raw_data, re.I)
+        vbox = vb_match.group(1) if vb_match else "0 0 100 100"
+        
+        inner = re.sub(r'<svg[^>]*>', '', raw_data, flags=re.I)
+        inner = re.sub(r'</svg>', '', inner, flags=re.I)
+        inner = re.sub(r'<\?xml[^>]*\?>|<!DOCTYPE[^>]*>', '', inner, flags=re.I)
+        
+        if 'fill=' not in inner:
+            inner = f'<g fill="black">{inner}</g>'
+        return inner, vbox
+    except:
+        return '<rect width="100" height="100" fill="black"/>', "0 0 100 100"
+
+def calculate_grid_items(width, height, density, gap_x, gap_y, shift, base_scale, growth, growth_type, invert, pixel_data=None):
+    """Математическое ядро расчета сетки"""
+    step = width / density
+    rows = math.ceil(height / step)
     
-    # Удаляем fill из инлайн-стилей (style="fill: #000; ...")
-    if 'style' in elem.attrib:
-        style_str = elem.attrib['style']
-        style_str = re.sub(r'fill:\s*(?!none)[^;]+;?', '', style_str, flags=re.IGNORECASE)
-        elem.attrib['style'] = style_str
+    cell_w_max = step * (1.0 - gap_x)
+    cell_h_max = step * (1.0 - gap_y)
+    
+    items = []
+    
+    for r in range(rows):
+        row_shift = (r * shift * step)
+        # Оптимизация цикла по колонкам
+        start_c = -int(density * 0.5)
+        end_c = int(density * 1.5)
+        
+        for c in range(start_c, end_c):
+            grid_x = c * step + row_shift
+            grid_y = r * step
+            
+            if grid_x < -step or grid_x > width:
+                continue
+
+            # Логика яркости
+            is_visible = True
+            
+            if pixel_data is not None:
+                # pixel_data должен быть PIL Image (Grayscale)
+                sx = max(0, min(int(grid_x + step/2), width - 1))
+                sy = max(0, min(int(grid_y + step/2), height - 1))
+                try:
+                    val = pixel_data.getpixel((sx, sy))
+                    brightness = val / 255.0
+                    limit = 0.5
+                    is_visible = brightness > limit if invert else brightness < limit
+                except:
+                    pass
+
+            if not is_visible:
+                continue
 
-    for child in elem:
-        strip_fill_colors(child)
+            # Логика искажения (Growth)
+            wave = 0
+            if growth_type == 'sine':
+                wave = (math.sin(c * 0.3 + r * 0.3) + 1) / 2 
+            elif growth_type == 'linear':
+                wave = (c % density) / density
+            elif growth_type == 'steps':
+                wave = (r % 5) / 5.0
+            
+            mod_w = 1.0 - (wave * growth)
+            mod_w = max(0.01, min(1.0, mod_w))
+
+            content_w = cell_w_max * base_scale * mod_w
+            content_h = cell_h_max * base_scale
+            
+            cx = grid_x + step / 2
+            cy = grid_y + step / 2
+            
+            items.append({
+                'cx': cx, 'cy': cy, 
+                'w': content_w, 'h': content_h
+            })
+            
+    return items, step
+
+# --- Роуты ---
 
 @app.route('/')
 def index():
@@ -36,176 +109,110 @@ def index():
 @app.route('/download_svg', methods=['POST'])
 def download_svg():
     try:
-        density = int(request.form.get('density', 76))
-        gap_x = float(request.form.get('gap_x', 0.2))
+        # Параметры
+        density = int(request.form.get('density', 40))
+        gap_x = float(request.form.get('gap_x', 0))
+        gap_y = float(request.form.get('gap_y', 0))
+        shift = float(request.form.get('shift_stagger', 0))
         base_scale = float(request.form.get('base_scale', 1.0))
+        growth = float(request.form.get('growth', 0))
+        growth_type = request.form.get('growth_type', 'sine')
         invert = request.form.get('invert') == 'true'
-        bg_color = request.form.get('bg_color', '#000000')
         
-        canvas_w = float(request.form.get('canvas_w', 1400))
-        canvas_h = float(request.form.get('canvas_h', 900))
+        canvas_w, canvas_h = 1400, 900
         
-        fill_colors = request.form.getlist('fill_colors[]')
-        svg_files = request.files.getlist('shape_svg[]')
-        raster = request.files.get('raster_image')
+        # SVG Symbol
+        svg_file = request.files.get('shape_svg')
+        if svg_file and svg_file.filename != '':
+            symbol_content, v_box = prepare_svg_content(svg_file)
+        else:
+            symbol_content, v_box = ('<rect width="100" height="100" fill="black"/>', "0 0 100 100")
+            
+        vb_parts = [float(x) for x in v_box.split()]
+        vb_w, vb_h = vb_parts[2], vb_parts[3]
+
+        # Raster Image для маски
+        raster_file = request.files.get('raster_image')
+        pixel_img = None
+        if raster_file and raster_file.filename != '':
+            img = Image.open(raster_file)
+            img = ImageOps.fit(img, (canvas_w, canvas_h), method=Image.Resampling.LANCZOS)
+            img = ImageOps.grayscale(img)
+            pixel_img = img
+
+        items, _ = calculate_grid_items(canvas_w, canvas_h, density, gap_x, gap_y, shift, base_scale, growth, growth_type, invert, pixel_img)
         
-        img_data = None
-        if raster:
-            img = Image.open(raster).convert('L').resize((density, int(canvas_h / (canvas_w / density))))
-            img_data = np.array(img)
-
-        dwg = ET.Element('svg', {
-            'xmlns': 'http://www.w3.org/2000/svg',
-            'width': str(canvas_w),
-            'height': str(canvas_h),
-            'viewBox': f'0 0 {canvas_w} {canvas_h}'
-        })
+        body = []
+        for item in items:
+            sx = item['w'] / vb_w
+            sy = item['h'] / vb_h
+            transform = f'translate({item["cx"]:.2f} {item["cy"]:.2f}) scale({sx:.4f} {sy:.4f}) translate({-vb_w/2:.2f} {-vb_h/2:.2f})'
+            body.append(f'<g transform="{transform}">{symbol_content}</g>')
+            
+        svg_str = f'<svg xmlns="http://www.w3.org/2000/svg" width="{canvas_w}" height="{canvas_h}" viewBox="0 0 {canvas_w} {canvas_h}" style="background:white;">{"".join(body)}</svg>'
         
-        ET.SubElement(dwg, 'rect', {'width': '100%', 'height': '100%', 'fill': bg_color})
-
-        parsed_patterns = []
-        for i, f in enumerate(svg_files):
-            try:
-                # Читаем файл, убираем теги неймспейсов для корректной работы
-                content = f.read().decode('utf-8')
-                content = re.sub(r'\sxmlns="[^"]+"', '', content, count=1)
-                svg_root = ET.fromstring(content)
-                
-                # ОЧИЩАЕМ ИСХОДНЫЕ ЦВЕТА ПАТТЕРНА
-                strip_fill_colors(svg_root)
-                
-                parsed_patterns.append({
-                    'elements': list(svg_root),
-                    'color': fill_colors[i] if i < len(fill_colors) else '#ffffff'
-                })
-            except Exception as e:
-                print("SVG Parse Error:", e)
-                continue
+        return Response(svg_str, mimetype="image/svg+xml", headers={"Content-disposition": "attachment; filename=pattern.svg"})
 
-        step = canvas_w / density
-        rows = int(canvas_h / step)
-        num_p = len(parsed_patterns)
-
-        for r in range(rows):
-            for c in range(density):
-                x = c * step + step/2
-                y = r * step + step/2
-                
-                bright = 1.0
-                if img_data is not None:
-                    py, px = min(r, img_data.shape[0]-1), min(c, img_data.shape[1]-1)
-                    bright = img_data[py, px] / 255.0
-                
-                if invert: bright = 1.0 - bright
-                if bright > 0.96: continue
-
-                size = step * (1 - gap_x) * base_scale
-                
-                if num_p > 0:
-                    p_idx = int(np.floor(bright * num_p))
-                    p_idx = max(0, min(num_p - 1, p_idx))
-                    target = parsed_patterns[p_idx]
-                    
-                    group = ET.SubElement(dwg, 'g', {
-                        'transform': f'translate({x - size/2}, {y - size/2}) scale({size/100})',
-                        'fill': target['color']
-                    })
-                    for elem in target['elements']:
-                        group.append(elem)
-                else:
-                    ET.SubElement(dwg, 'rect', {
-                        'x': str(x - size/2), 'y': str(y - size/2),
-                        'width': str(size), 'height': str(size), 'fill': fill_colors[0] if fill_colors else '#000'
-                    })
-
-        svg_io = io.BytesIO(ET.tostring(dwg))
-        return send_file(svg_io, mimetype='image/svg+xml', as_attachment=True, download_name='cell_clipper_export.svg')
-    
     except Exception as e:
         return str(e), 500
 
-
 @app.route('/process_video', methods=['POST'])
 def process_video():
-    if not HAS_MOVIEPY:
-        return "MoviePy not installed", 400
-        
+    if not MOVIEPY_AVAILABLE:
+        return "MoviePy not installed on server", 500
+
+    temp_dir = tempfile.mkdtemp()
     try:
-        density = int(request.form.get('density', 76))
-        gap_x = float(request.form.get('gap_x', 0.2))
+        density = int(request.form.get('density', 40))
+        gap_x = float(request.form.get('gap_x', 0))
+        gap_y = float(request.form.get('gap_y', 0))
+        shift = float(request.form.get('shift_stagger', 0))
         base_scale = float(request.form.get('base_scale', 1.0))
+        growth = float(request.form.get('growth', 0))
+        growth_type = request.form.get('growth_type', 'sine')
         invert = request.form.get('invert') == 'true'
-        bg_color = request.form.get('bg_color', '#000000')
-        fallback_fill = request.form.get('fallback_fill', '#000000')
-        
-        # Получаем готовые цветные PNG паттерны с фронтенда!
-        png_files = request.files.getlist('pattern_pngs')
-        pil_patterns = [Image.open(p).convert("RGBA") for p in png_files]
-        num_p = len(pil_patterns)
 
         video_file = request.files.get('video_file')
         if not video_file:
-            return "No video file", 400
-
-        in_path = "temp_in.mp4"
-        out_path = "temp_out.mp4"
-        video_file.save(in_path)
-        clip = VideoFileClip(in_path)
+            return "No video uploaded", 400
         
-        w, h = clip.size
-        step = w / density
-        rows = int(h / step)
-        cell_size = int(step * (1 - gap_x) * base_scale)
-
-        # Ресайзим паттерны заранее под размер ячейки для скорости рендера
-        resized_patterns = [p.resize((cell_size, cell_size), Image.Resampling.LANCZOS) for p in pil_patterns]
+        input_path = os.path.join(temp_dir, 'input.mp4')
+        video_file.save(input_path)
 
-        def make_frame(get_frame, t):
+        def process_frame(get_frame, t):
             frame = get_frame(t)
-            # Переводим кадр в ЧБ для анализа яркости
-            gray = Image.fromarray(frame).convert("L")
-            # Сжимаем кадр до размера сетки для ультра-быстрого анализа
-            gray_small = np.array(gray.resize((density, rows)))
+            img_pil = Image.fromarray(frame).convert("L")
+            w, h = img_pil.size
             
-            # Создаем чистый кадр с цветом фона
-            canvas_img = Image.new("RGB", (w, h), bg_color)
+            # Рендеринг кадра
+            canvas = Image.new("RGB", (w, h), "white")
+            draw = ImageDraw.Draw(canvas)
             
-            from PIL import ImageDraw
-            draw = ImageDraw.Draw(canvas_img)
-
-            for r in range(rows):
-                for c in range(density):
-                    bright = gray_small[r, c] / 255.0
-                    if invert: bright = 1.0 - bright
-                    if bright > 0.96: continue
-                    
-                    x = int(c * step + step/2 - cell_size/2)
-                    y = int(r * step + step/2 - cell_size/2)
-                    
-                    if num_p > 0:
-                        p_idx = int(np.floor(bright * num_p))
-                        p_idx = max(0, min(num_p - 1, p_idx))
-                        pat = resized_patterns[p_idx]
-                        # Накладываем цветной PNG паттерн с поддержкой прозрачности
-                        canvas_img.paste(pat, (x, y), mask=pat)
-                    else:
-                        draw.rectangle([x, y, x + cell_size, y + cell_size], fill=fallback_fill)
+            # Используем ту же логику расчета
+            items, _ = calculate_grid_items(w, h, density, gap_x, gap_y, shift, base_scale, growth, growth_type, invert, img_pil)
             
-            return np.array(canvas_img)
-
-        new_clip = clip.fl(make_frame)
-        new_clip.write_videofile(out_path, codec="libx264", audio=False)
+            for item in items:
+                # Рисуем прямоугольники (быстро для видео)
+                # Если нужно SVG в видео, это сильно замедлит процесс
+                x0 = item['cx'] - item['w']/2
+                y0 = item['cy'] - item['h']/2
+                draw.rectangle([x0, y0, x0 + item['w'], y0 + item['h']], fill="black")
+
+            return np.array(canvas)
+
+        clip = VideoFileClip(input_path)
+        # Ограничение FPS для ускорения, если видео большое
+        # clip = clip.set_fps(24) 
         
-        clip.close()
-        new_clip.close()
-        os.remove(in_path)
+        new_clip = clip.fl(process_frame)
         
-        return send_file(out_path, mimetype='video/mp4', as_attachment=True, download_name='cell_clipper_render.mp4')
+        output_path = os.path.join(temp_dir, 'output.mp4')
+        new_clip.write_videofile(output_path, codec='libx264', audio_codec='aac', fps=clip.fps)
         
+        return send_file(output_path, as_attachment=True, download_name="processed_video.mp4")
+
     except Exception as e:
-        import traceback
-        traceback.print_exc()
-        return str(e), 500
+        return f"Error processing video: {str(e)}", 500
 
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860, debug=True)
+    app.run(host='0.0.0.0', port=7860)