Update app.py

app.py

@@ -1,14 +1,30 @@
 import math
 import re
-from flask import Flask, render_template, request
+import tempfile
+
+
+from flask import Flask, render_template, request, send_file, Response
+from PIL import Image, ImageOps, ImageDraw, ImageColor
+import numpy as np
+
+# Проверка наличия MoviePy
+
+try:
+    from moviepy.editor import VideoFileClip
+    MOVIEPY_AVAILABLE = True
+except ImportError:
+    MOVIEPY_AVAILABLE = False
+
+
+
+
 
 app = Flask(__name__)
 
-# --- КОНФИГУРАЦИЯ ХОЛСТА (16:9) ---
-CANVAS_W = 1600
-CANVAS_H = 900
+# --- Вспомогательные функции ---
 
-def prepare_svg_symbol(file_storage):
+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)
@@ -18,97 +34,211 @@ def prepare_svg_symbol(file_storage):
         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>'
-            
+        # Удаляем явные заливки, чтобы управлять цветом через группу
+        # (Опционально, но помогает для монохромных иконок)
+        # inner = re.sub(r'fill="[^"]*"', '', inner) 
+        
         return inner, vbox
     except:
-        return '<rect width="100" height="100" fill="black"/>', "0 0 100 100"
+        return '<rect width="100" height="100" />', "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)
+    
+    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
+
+            # Логика искажения (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():
     return render_template('index.html')
-
-@app.route('/generate', methods=['POST'])
-def generate():
+@app.route('/download_svg', methods=['POST'])
+def download_svg():
     try:
-        density = int(request.form.get('density', 10))
+        # Параметры
+        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_stagger = float(request.form.get('shift_stagger', 0))
-        shift_wave = float(request.form.get('shift_wave', 0))
         base_scale = float(request.form.get('base_scale', 1.0))
-        rotation = float(request.form.get('rotation', 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', '#ffffff')
+        fill_color = request.form.get('fill_color', '#000000')
+        
+        canvas_w, canvas_h = 1400, 900
         
+        # SVG Symbol
         svg_file = request.files.get('shape_svg')
-        symbol_content, v_box = prepare_svg_symbol(svg_file) if (svg_file and svg_file.filename != '') else ('<rect width="100" height="100" fill="black"/>', "0 0 100 100")
-
+        if svg_file and svg_file.filename != '':
+            symbol_content, v_box = prepare_svg_content(svg_file)
         vb_parts = [float(x) for x in v_box.split()]
         vb_w, vb_h = vb_parts[2], vb_parts[3]
 
-        # Расчет сетки на весь холст без отступов
-        step_x = CANVAS_W / density
-        # Чтобы сетка была равномерной (квадратные ячейки по пропорциям),
-        # мы рассчитываем step_y исходя из step_x, но заполняем всю высоту.
-        # Однако, если вы хотите именно сетку рядов:
-        step_y = CANVAS_H / density 
-        # Примечание: если density = 10, будет 10 колонок и 10 рядов. 
-        # Так как холст прямоугольный, ячейки будут прямоугольными.
-        # Если нужны квадратные ячейки, нужно менять логику density для Y.
-        # Оставим прямоугольные ячейки, растянутые по экрану.
-
-        cell_w_max = step_x * (1.0 - gap_x)
-        cell_h_max = step_y * (1.0 - gap_y)
-        
-        offset_x_base = (step_x - cell_w_max) / 2
-        offset_y_base = (step_y - cell_h_max) / 2
+        # 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)
+        
         body = []
-        for r in range(density):
-            row_wave = math.sin(r * 0.5) * shift_wave * step_x
-            row_shift = (r * shift_stagger * step_x) + row_wave
+        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}" fill="{fill_color}">{symbol_content}</g>')
             
-            for c in range(density):
-                grid_x_rel = (c * step_x + row_shift) % CANVAS_W
-                grid_y_rel = r * step_y
-                
-                abs_x = grid_x_rel + offset_x_base
-                abs_y = grid_y_rel + offset_y_base
-                
-                wave_norm = 0
-                if growth_type == 'sine':
-                    wave_norm = (math.sin(c * 0.3 + r * 0.3) + 1) / 2 
-                elif growth_type == 'linear':
-                    wave_norm = c / (density - 1) if density > 1 else 0
-                elif growth_type == 'steps':
-                    num_steps = 5
-                    wave_norm = math.floor(c / (density / num_steps)) / (num_steps - 1) if density > 1 else 0
-
-                mod_w = max(0, 1.0 - (wave_norm * growth))
-                content_w = cell_w_max * base_scale * mod_w
-                content_h = cell_h_max * base_scale
-                
-                scale_x = content_w / vb_w
-                scale_y = content_h / vb_h
-                
-                # Центрирование -> Вращение -> Масштаб -> Возврат origin
-                transform = f'translate({cell_w_max/2:.2f} {cell_h_max/2:.2f}) rotate({rotation}) scale({scale_x:.4f} {scale_y:.4f}) translate({-vb_w/2:.2f} {-vb_h/2:.2f})'
-                
-                # Clipping через вложенный SVG
-                cell = f'''
-                <svg x="{abs_x:.2f}" y="{abs_y:.2f}" width="{cell_w_max:.2f}" height="{cell_h_max:.2f}" viewBox="0 0 {cell_w_max:.2f} {cell_h_max:.2f}">
-                    <g transform="{transform}">
-                        {symbol_content}
-                    </g>
-                </svg>
-                '''
-                body.append(cell)
-
-        return f'<svg xmlns="http://www.w3.org/2000/svg" width="{CANVAS_W}" height="{CANVAS_H}" viewBox="0 0 {CANVAS_W} {CANVAS_H}">{ "".join(body) }</svg>'
+        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:{bg_color};">{"".join(body)}</svg>'
+        
+        return Response(svg_str, mimetype="image/svg+xml", headers={"Content-disposition": "attachment; filename=pattern.svg"})
+
+    except Exception as e:
+        return str(e), 500
+
+@app.route('/process_video', methods=['POST'])
+def process_video():
+    if not MOVIEPY_AVAILABLE:
+        return "MoviePy not installed on server", 500
+
+    temp_dir = tempfile.mkdtemp()
+    try:
+        density = int(request.form.get('density', 40))
+        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', '#ffffff')
+        fill_color = request.form.get('fill_color', '#000000')
+
+        video_file = request.files.get('video_file')
+        if not video_file:
+            return "No video uploaded", 400
+        
+        input_path = os.path.join(temp_dir, 'input.mp4')
+        video_file.save(input_path)
+
+        def process_frame(get_frame, t):
+            frame = get_frame(t)
+            img_pil = Image.fromarray(frame).convert("L")
+            w, h = img_pil.size
+            
+            # Рендеринг кадра с цветом фона
+            canvas = Image.new("RGB", (w, h), bg_color)
+            draw = ImageDraw.Draw(canvas)
+            
+            # Используем ту же логику расчета
+            items, _ = calculate_grid_items(w, h, density, gap_x, gap_y, shift, base_scale, growth, growth_type, invert, img_pil)
+            
+            for item in items:
+                x0 = item['cx'] - item['w']/2
+                y0 = item['cy'] - item['h']/2
+                # Рисуем прямоугольники с цветом паттерна
+                draw.rectangle([x0, y0, x0 + item['w'], y0 + item['h']], fill=fill_color)
+
+            return np.array(canvas)
+
+        clip = VideoFileClip(input_path)
+        # clip = clip.set_fps(24) 
+        
+        new_clip = clip.fl(process_frame)
+        
+        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:
-        return f'<text y="50" fill="red">Error: {str(e)}</text>', 200
+        return f"Error processing video: {str(e)}", 500
 
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=7860)