Spaces:
Sleeping
Sleeping
| """ | |
| 🎨 Studio Artistico PRO - Streamlit Version | |
| Tab 1: Video Sketch Converter PRO (con opzione 9:16 Shorts) | |
| Tab 2: Matita & Carboncino (20 effetti foto) | |
| Tab 3: Video Canny Edge Detection | |
| Compatible with Python 3.13 | |
| """ | |
| import streamlit as st | |
| import cv2 | |
| import numpy as np | |
| import tempfile | |
| import time | |
| import os | |
| import io | |
| from PIL import Image | |
| from scipy import ndimage | |
| st.set_page_config( | |
| page_title="🎨 Studio Artistico PRO", | |
| page_icon="🎨", | |
| layout="wide" | |
| ) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # VIDEO SKETCH CONVERTER | |
| # ═══════════════════════════════════════════════════════════════ | |
| class VideoSketchConverter: | |
| STILI = { | |
| "sketch": "✏️ Sketch Classico - Linee pulite e definite", | |
| "pencil": "📝 Pencil Drawing - Effetto matita con texture", | |
| "ink": "🖊️ Ink Drawing - Linee nere marcate", | |
| "charcoal": "🎨 Charcoal - Effetto carboncino morbido", | |
| "comic": "💥 Comic Style - Stile fumetto" | |
| } | |
| def applica_effetto_sketch(frame, style, intensity, detail, contrast): | |
| try: | |
| if detail % 2 == 0: | |
| detail += 1 | |
| gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) | |
| if style == "sketch": | |
| inverted = cv2.bitwise_not(gray) | |
| blurred = cv2.GaussianBlur(inverted, (detail, detail), 0) | |
| sketch = cv2.divide(gray, 255 - blurred, scale=256.0) | |
| sketch = cv2.convertScaleAbs(sketch, alpha=contrast, beta=0) | |
| _, sketch = cv2.threshold(sketch, int(intensity), 255, cv2.THRESH_BINARY) | |
| return sketch | |
| elif style == "pencil": | |
| sketch_gray, _ = cv2.pencilSketch(frame, sigma_s=60, sigma_r=0.07, shade_factor=0.05) | |
| sketch_gray = cv2.convertScaleAbs(sketch_gray, alpha=contrast, beta=0) | |
| _, sketch_gray = cv2.threshold(sketch_gray, int(intensity), 255, cv2.THRESH_BINARY) | |
| return sketch_gray | |
| elif style == "ink": | |
| bilateral = cv2.bilateralFilter(gray, 9, 75, 75) | |
| edges = cv2.Canny(bilateral, 50, 150) | |
| ink = cv2.bitwise_not(edges) | |
| kernel = np.ones((2, 2), np.uint8) | |
| ink = cv2.erode(ink, kernel, iterations=1) | |
| return ink | |
| elif style == "charcoal": | |
| inverted = cv2.bitwise_not(gray) | |
| blur_size = max(3, detail * 2 + 1) | |
| if blur_size % 2 == 0: | |
| blur_size += 1 | |
| blurred = cv2.GaussianBlur(inverted, (blur_size, blur_size), 0) | |
| charcoal = cv2.divide(gray, 255 - blurred, scale=256.0) | |
| charcoal = cv2.GaussianBlur(charcoal, (3, 3), 0) | |
| return charcoal | |
| elif style == "comic": | |
| bilateral = cv2.bilateralFilter(gray, 9, 75, 75) | |
| edges = cv2.adaptiveThreshold( | |
| bilateral, 255, cv2.ADAPTIVE_THRESH_MEAN_C, | |
| cv2.THRESH_BINARY, 9, 2) | |
| return edges | |
| return gray | |
| except Exception as e: | |
| st.error(f"Errore: {e}") | |
| return gray | |
| # ═══════════════════════════════════════════════════════════════ | |
| # CONVERSIONE 9:16 — zoom + crop centrale | |
| # Input: frame orizzontale 16:9 (es. 1920x1080) | |
| # Output: frame verticale 9:16 (es. 1080x1920) | |
| # Come: scala l'altezza a out_h, poi ritaglia il centro | |
| # → niente bande nere, immagine più stretta e alta | |
| # ═══════════════════════════════════════════════════════════════ | |
| def converti_9_16(frame_bgr, out_w=1080, out_h=1920): | |
| src_h, src_w = frame_bgr.shape[:2] | |
| # Scala in modo che l'altezza riempia out_h esattamente | |
| scale = out_h / src_h | |
| new_w = int(src_w * scale) # per un 16:9 → molto più largo di out_w | |
| resized = cv2.resize(frame_bgr, (new_w, out_h), interpolation=cv2.INTER_LANCZOS4) | |
| # Ritaglia al centro orizzontalmente | |
| if new_w >= out_w: | |
| x = (new_w - out_w) // 2 | |
| return resized[:, x:x + out_w] | |
| else: | |
| # Caso raro (video già molto stretto): pad nero laterale | |
| pad = (out_w - new_w) // 2 | |
| return cv2.copyMakeBorder(resized, 0, 0, pad, out_w - new_w - pad, | |
| cv2.BORDER_CONSTANT, value=[0, 0, 0]) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # MATITA & CARBONCINO — 20 effetti su foto | |
| # ═══════════════════════════════════════════════════════════════ | |
| def _gray(img): | |
| return cv2.cvtColor(np.array(img.convert("RGB")), cv2.COLOR_RGB2GRAY) | |
| def _to_cv(img): | |
| return cv2.cvtColor(np.array(img.convert("RGB")), cv2.COLOR_RGB2BGR) | |
| def matita_classica(img, v=21): | |
| v = max(3, int(v) | 1); g = _gray(img) | |
| b = cv2.GaussianBlur(255 - g, (v, v), 0) | |
| return Image.fromarray(cv2.divide(g, 255 - b, scale=256)) | |
| def matita_morbida(img, v=51): | |
| v = max(3, int(v) | 1); g = _gray(img) | |
| b = cv2.GaussianBlur(255 - g, (v, v), 0) | |
| return Image.fromarray(cv2.GaussianBlur(cv2.divide(g, 255 - b, scale=256), (3,3), 0)) | |
| def matita_dura(img, v=7): | |
| v = max(3, int(v) | 1); g = _gray(img) | |
| b = cv2.GaussianBlur(255 - g, (v, v), 0) | |
| s = cv2.divide(g, 255 - b, scale=256) | |
| _, s = cv2.threshold(s, 200, 255, cv2.THRESH_BINARY) | |
| return Image.fromarray(s) | |
| def linee_canny(img, v=150): | |
| g = _gray(img) | |
| return Image.fromarray(255 - cv2.Canny(cv2.GaussianBlur(g,(5,5),0), int(v)//3, int(v))) | |
| def linee_laplacian(img, v=3): | |
| g = _gray(img) | |
| return Image.fromarray(255 - np.uint8(np.clip(np.abs(cv2.Laplacian(g, cv2.CV_64F, ksize=3)), 0, 255))) | |
| def carboncino_leggero(img, v=21): | |
| v = max(3, int(v) | 1); g = _gray(img) | |
| b = cv2.GaussianBlur(255 - g, (v, v), 0) | |
| s = cv2.equalizeHist(cv2.divide(g, 255 - b, scale=256)) | |
| return Image.fromarray(np.clip(s.astype(np.int32) - 30, 0, 255).astype(np.uint8)) | |
| def carboncino_intenso(img, v=15): | |
| v = max(3, int(v) | 1); g = _gray(img) | |
| b = cv2.GaussianBlur(255 - g, (v, v), 0) | |
| s = np.clip(cv2.divide(g, 255 - b, scale=256).astype(np.int32) - 60, 0, 255).astype(np.uint8) | |
| return Image.fromarray(cv2.createCLAHE(3.0, (8,8)).apply(s)) | |
| def carboncino_sfumato(img, v=31): | |
| v = max(3, int(v) | 1); g = _gray(img) | |
| b = cv2.GaussianBlur(255 - g, (v, v), 0) | |
| s = cv2.GaussianBlur(cv2.divide(g, 255 - b, scale=256), (7,7), 0) | |
| return Image.fromarray(np.clip(s.astype(np.int32) - 20, 0, 255).astype(np.uint8)) | |
| def effetto_grafite(img, v=25): | |
| v = max(3, int(v) | 1); g = _gray(img) | |
| b = cv2.GaussianBlur(255 - g, (v, v), 0) | |
| s = cv2.divide(g, 255 - b, scale=256) | |
| return Image.fromarray(np.clip(s.astype(np.int16) + np.random.normal(0,5,s.shape).astype(np.int16), 0, 255).astype(np.uint8)) | |
| def cross_hatching(img, v=21): | |
| v = max(3, int(v) | 1); g = _gray(img) | |
| b1 = cv2.GaussianBlur(255 - g, (v, v), 0); s1 = cv2.divide(g, 255 - b1, scale=256) | |
| rot = ndimage.rotate(g, 45, reshape=False, mode='nearest') | |
| b2 = cv2.GaussianBlur(255 - rot, (v, v), 0) | |
| s2 = ndimage.rotate(cv2.divide(rot, 255 - b2, scale=256), -45, reshape=False, mode='nearest').astype(np.uint8) | |
| return Image.fromarray((s1.astype(np.float32)/255 * s2.astype(np.float32)/255 * 255).astype(np.uint8)) | |
| def schizzo_rapido(img, v=8): | |
| g = _gray(img) | |
| return Image.fromarray(255 - np.clip(cv2.filter2D(g, -1, np.array([[-1,-1,-1],[-1,8,-1],[-1,-1,-1]])), 0, 255).astype(np.uint8)) | |
| def matita_artistica(img, v=21): | |
| v = max(3, int(v) | 1) | |
| g = cv2.cvtColor(cv2.bilateralFilter(_to_cv(img), 9, 75, 75), cv2.COLOR_BGR2GRAY) | |
| b = cv2.GaussianBlur(255 - g, (v, v), 0) | |
| return Image.fromarray(cv2.divide(g, 255 - b, scale=256)) | |
| def matita_carta(img, v=21): | |
| v = max(3, int(v) | 1); g = _gray(img) | |
| b = cv2.GaussianBlur(255 - g, (v, v), 0); s = cv2.divide(g, 255 - b, scale=256) | |
| h, w = s.shape; noise = np.random.randint(200, 256, (h, w), dtype=np.uint8) | |
| return Image.fromarray((s.astype(np.float32)/255 * noise.astype(np.float32)/255 * 255).astype(np.uint8)) | |
| def matita_colorata(img, v=21): | |
| v = max(3, int(v) | 1); cv_img = _to_cv(img); sketches = [] | |
| for ch in cv2.split(cv_img): | |
| b = cv2.GaussianBlur(255 - ch, (v, v), 0); sketches.append(cv2.divide(ch, 255 - b, scale=256)) | |
| return Image.fromarray(cv2.cvtColor(cv2.merge(sketches), cv2.COLOR_BGR2RGB)) | |
| def effetto_inchiostro(img, v=127): | |
| g = _gray(img); blur = cv2.GaussianBlur(g, (5,5), 0) | |
| _, binary = cv2.threshold(blur, int(v), 255, cv2.THRESH_BINARY) | |
| return Image.fromarray(cv2.morphologyEx(binary, cv2.MORPH_CLOSE, np.ones((2,2), np.uint8))) | |
| def matita_xdog(img, v=10): | |
| g = _gray(img).astype(np.float32) / 255.0 | |
| diff = cv2.GaussianBlur(g,(0,0),0.4) - 0.99 * cv2.GaussianBlur(g,(0,0),80.0) | |
| xdog = np.where(diff > -0.1, 1.0, 1.0 + np.tanh(float(v) * diff)) | |
| return Image.fromarray((np.clip(xdog, 0, 1) * 255).astype(np.uint8)) | |
| def carboncino_vignetta(img, v=21): | |
| v = max(3, int(v) | 1); g = _gray(img) | |
| b = cv2.GaussianBlur(255 - g, (v, v), 0) | |
| s = np.clip(cv2.divide(g, 255 - b, scale=256).astype(np.int32) - 40, 0, 255).astype(np.uint8) | |
| h, w = s.shape; Y, X = np.ogrid[:h, :w]; cx, cy = w/2, h/2 | |
| mask = 1 - np.clip(((X-cx)**2/cx**2 + (Y-cy)**2/cy**2), 0, 1) * 0.5 | |
| return Image.fromarray((s * mask).astype(np.uint8)) | |
| def schizzo_sobel(img, v=1): | |
| g = _gray(img) | |
| sx = cv2.Sobel(g, cv2.CV_64F, 1, 0, ksize=3); sy = cv2.Sobel(g, cv2.CV_64F, 0, 1, ksize=3) | |
| return Image.fromarray(255 - np.clip(np.sqrt(sx**2+sy**2), 0, 255).astype(np.uint8)) | |
| def matita_stilizzata(img, v=5): | |
| shade = max(1, min(20, int(v))) / 100 | |
| gray_sketch, _ = cv2.pencilSketch(_to_cv(img), sigma_s=60, sigma_r=0.07, shade_factor=shade) | |
| return Image.fromarray(gray_sketch) | |
| def carboncino_drammatico(img, v=15): | |
| v = max(3, int(v) | 1) | |
| g = cv2.createCLAHE(4.0, (8,8)).apply(_gray(img)) | |
| b = cv2.GaussianBlur(255 - g, (v, v), 0) | |
| s = np.clip(cv2.divide(g, 255 - b, scale=256).astype(np.int32) - 80, 0, 255).astype(np.uint8) | |
| _, s = cv2.threshold(s, 10, 255, cv2.THRESH_TOZERO) | |
| return Image.fromarray(s) | |
| EFFETTI = { | |
| "1. Matita Classica": (matita_classica, 3, 101, 21), | |
| "2. Matita Morbida": (matita_morbida, 3, 101, 51), | |
| "3. Matita Dura / Tecnica": (matita_dura, 3, 51, 7), | |
| "4. Linee Pulite (Canny)": (linee_canny, 10, 300,150), | |
| "5. Linee Fini (Laplacian)": (linee_laplacian, 1, 10, 3), | |
| "6. Carboncino Leggero": (carboncino_leggero, 3, 101, 21), | |
| "7. Carboncino Intenso": (carboncino_intenso, 3, 51, 15), | |
| "8. Carboncino Sfumato": (carboncino_sfumato, 3, 101, 31), | |
| "9. Effetto Grafite": (effetto_grafite, 3, 101, 25), | |
| "10. Cross-Hatching": (cross_hatching, 3, 51, 21), | |
| "11. Schizzo Rapido": (schizzo_rapido, 1, 20, 8), | |
| "12. Matita Artistica": (matita_artistica, 3, 101, 21), | |
| "13. Matita + Texture Carta": (matita_carta, 3, 101, 21), | |
| "14. Matita Colorata": (matita_colorata, 3, 101, 21), | |
| "15. Effetto Inchiostro": (effetto_inchiostro,50, 250,127), | |
| "16. Matita XDoG (Fumetto)": (matita_xdog, 1, 50, 10), | |
| "17. Carboncino + Vignetta": (carboncino_vignetta,3, 101, 21), | |
| "18. Schizzo Sobel": (schizzo_sobel, 1, 5, 1), | |
| "19. Matita Stilizzata (CV2)": (matita_stilizzata, 1, 20, 5), | |
| "20. Carboncino Drammatico": (carboncino_drammatico,3, 51, 15), | |
| } | |
| # ═══════════════════════════════════════════════════════════════ | |
| # VIDEO CANNY — funzioni core | |
| # ═══════════════════════════════════════════════════════════════ | |
| def canny_applica_frame(frame, low, high, blur_k): | |
| gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) | |
| return cv2.Canny(cv2.GaussianBlur(gray, (blur_k, blur_k), 0), low, high) | |
| def canny_genera_anteprima(video_path, low, high, blur_k, posizione=0.3): | |
| cap = cv2.VideoCapture(video_path) | |
| total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) | |
| cap.set(cv2.CAP_PROP_POS_FRAMES, int(total * posizione)) | |
| ret, frame = cap.read() | |
| cap.release() | |
| if not ret: | |
| return None | |
| return Image.fromarray(canny_applica_frame(frame, low, high, blur_k)) | |
| def canny_processa_video(video_path, low, high, blur_k, converti_916, | |
| progress_bar, status_text): | |
| cap = cv2.VideoCapture(video_path) | |
| fps = cap.get(cv2.CAP_PROP_FPS) or 25.0 | |
| total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) | |
| orig_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) | |
| orig_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) | |
| if converti_916: | |
| out_w, out_h, suffix = 1080, 1920, "canny_916" | |
| else: | |
| out_w, out_h, suffix = orig_w, orig_h, "canny" | |
| with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp_out: | |
| tmp_out_path = tmp_out.name | |
| out = cv2.VideoWriter(tmp_out_path, cv2.VideoWriter_fourcc(*"mp4v"), | |
| fps, (out_w, out_h), isColor=False) | |
| frame_count = 0 | |
| status_text.text("⏳ Elaborazione in corso…") | |
| while True: | |
| ret, frame = cap.read() | |
| if not ret: | |
| break | |
| if converti_916: | |
| frame = converti_9_16(frame, out_w, out_h) | |
| out.write(canny_applica_frame(frame, low, high, blur_k)) | |
| frame_count += 1 | |
| if total_frames > 0: | |
| progress_bar.progress(min(frame_count / total_frames, 1.0)) | |
| cap.release(); out.release() | |
| with open(tmp_out_path, "rb") as f: | |
| video_bytes = f.read() | |
| os.unlink(tmp_out_path) | |
| status_text.text("✅ Completato!") | |
| return video_bytes, f"{suffix}_output.mp4" | |
| # ═══════════════════════════════════════════════════════════════ | |
| # MAIN — tre tabs | |
| # ═══════════════════════════════════════════════════════════════ | |
| def main(): | |
| st.markdown("# 🎨 Studio Artistico PRO") | |
| tab1, tab2, tab3 = st.tabs([ | |
| "🎬 Video Sketch Converter", | |
| "✏️ Matita & Carboncino (Foto)", | |
| "⚡ Video Canny Edge" | |
| ]) | |
| # ── TAB 1: Video Sketch Converter ─────────────────────────────────── | |
| with tab1: | |
| st.markdown("### Trasforma i tuoi video in opere d'arte") | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| st.subheader("🎬 Input") | |
| uploaded_file = st.file_uploader("Carica Video", | |
| type=['mp4', 'avi', 'mov', 'mkv']) | |
| style = st.selectbox( | |
| "🎨 Stile Artistico", | |
| options=list(VideoSketchConverter.STILI.keys()), | |
| format_func=lambda x: VideoSketchConverter.STILI[x] | |
| ) | |
| # ── FORMATO OUTPUT ────────────────────────────────────────── | |
| st.markdown("#### 📐 Formato output") | |
| formato = st.radio( | |
| "Scegli il formato", | |
| ["originale", "9:16"], | |
| format_func=lambda x: { | |
| "originale": "🔲 Originale (mantieni dimensioni)", | |
| "9:16": "📱 9:16 verticale — Shorts / Reels / TikTok", | |
| }[x], | |
| horizontal=False, | |
| key="fmt_sketch" | |
| ) | |
| if formato == "9:16": | |
| st.info("✂️ Zoom + crop centrale: l'altezza riempie lo schermo, i lati vengono tagliati. Niente bande nere.") | |
| res_916 = st.radio("Risoluzione verticale", | |
| ["1080x1920", "720x1280"], | |
| horizontal=True, key="res_sketch_916") | |
| out_w_sk, out_h_sk = map(int, res_916.split("x")) | |
| else: | |
| out_w_sk, out_h_sk = None, None | |
| with st.expander("⚙️ Parametri Avanzati"): | |
| intensity = st.slider("Intensità", 50, 255, 150) | |
| detail = st.slider("Dettaglio", 1, 15, 5, step=2) | |
| contrast = st.slider("Contrasto", 1.0, 3.0, 1.5, step=0.1) | |
| process_btn = st.button("🚀 CONVERTI VIDEO", type="primary", | |
| use_container_width=True, key="btn_video") | |
| with col2: | |
| st.subheader("🎥 Output") | |
| st.empty() | |
| if uploaded_file and process_btn: | |
| with st.spinner("Elaborazione in corso..."): | |
| with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_input: | |
| tmp_input.write(uploaded_file.read()) | |
| input_path = tmp_input.name | |
| cap = cv2.VideoCapture(input_path) | |
| orig_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) | |
| orig_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) | |
| fps = cap.get(cv2.CAP_PROP_FPS) | |
| total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) | |
| width_out = out_w_sk if formato == "9:16" else orig_width | |
| height_out = out_h_sk if formato == "9:16" else orig_height | |
| output_path = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4').name | |
| out = cv2.VideoWriter(output_path, cv2.VideoWriter_fourcc(*'mp4v'), | |
| fps, (width_out, height_out), False) | |
| progress_bar = st.progress(0) | |
| status_text = st.empty() | |
| frame_count = 0 | |
| start_time = time.time() | |
| while True: | |
| ret, frame = cap.read() | |
| if not ret: | |
| break | |
| # Conversione 9:16 prima dello sketch | |
| if formato == "9:16": | |
| frame = converti_9_16(frame, width_out, height_out) | |
| sketch = VideoSketchConverter.applica_effetto_sketch( | |
| frame, style, intensity, detail, contrast) | |
| out.write(sketch) | |
| frame_count += 1 | |
| if frame_count % 10 == 0: | |
| progress = frame_count / total_frames | |
| progress_bar.progress(progress) | |
| elapsed = time.time() - start_time | |
| fps_proc = frame_count / elapsed if elapsed > 0 else 0 | |
| eta = (total_frames - frame_count) / fps_proc if fps_proc > 0 else 0 | |
| status_text.text( | |
| f"Frame {frame_count}/{total_frames} | " | |
| f"{fps_proc:.1f} fps | ETA: {int(eta)}s") | |
| cap.release() | |
| out.release() | |
| elapsed_total = time.time() - start_time | |
| progress_bar.progress(1.0) | |
| st.success(f"✅ Completato in {elapsed_total:.1f}s! ({width_out}×{height_out}px)") | |
| suffix_nome = "_shorts" if formato == "9:16" else "" | |
| with open(output_path, 'rb') as f: | |
| st.download_button( | |
| label="📥 SCARICA VIDEO", | |
| data=f.read(), | |
| file_name=f"sketch_{style}{suffix_nome}_{uploaded_file.name}", | |
| mime="video/mp4", | |
| type="primary", | |
| use_container_width=True | |
| ) | |
| try: | |
| os.unlink(input_path) | |
| os.unlink(output_path) | |
| except Exception: | |
| pass | |
| # ── TAB 2: Matita & Carboncino (foto) ─────────────────────────────── | |
| with tab2: | |
| st.markdown("### Trasforma le tue foto in disegni a matita o carboncino") | |
| col_a, col_b = st.columns(2) | |
| with col_a: | |
| st.subheader("📷 Input") | |
| foto = st.file_uploader("Carica una foto", | |
| type=['jpg', 'jpeg', 'png', 'bmp', 'webp'], | |
| key="foto_uploader") | |
| nome_eff = st.selectbox("🎨 Effetto", options=list(EFFETTI.keys())) | |
| fn, mn, mx, default = EFFETTI[nome_eff] | |
| intensita = st.slider("🔧 Intensità / Parametro", min_value=mn, max_value=mx, value=default) | |
| col_btn1, col_btn2 = st.columns(2) | |
| with col_btn1: | |
| btn_applica = st.button("✨ Applica", type="primary", | |
| use_container_width=True, key="btn_foto") | |
| with col_btn2: | |
| btn_batch = st.button("🔁 Tutti e 20", use_container_width=True, key="btn_batch") | |
| with col_b: | |
| st.subheader("🎨 Risultato") | |
| risultato_placeholder = st.empty() | |
| if foto and btn_applica: | |
| pil_img = Image.open(foto).convert("RGB") | |
| with st.spinner(f"Applicando {nome_eff}…"): | |
| risultato = fn(pil_img, v=intensita) | |
| risultato_placeholder.image(risultato, use_container_width=True) | |
| buf = io.BytesIO() | |
| risultato.save(buf, format="PNG") | |
| st.download_button("💾 Scarica", data=buf.getvalue(), | |
| file_name=f"matita_{nome_eff[:20].strip()}.png", | |
| mime="image/png") | |
| if foto and btn_batch: | |
| pil_img = Image.open(foto).convert("RGB") | |
| st.markdown("#### 🖼️ Galleria — Tutti e 20 gli effetti") | |
| cols = st.columns(4) | |
| with st.spinner("Elaborazione tutti gli effetti…"): | |
| for i, (nome, (f, mn, mx, default)) in enumerate(EFFETTI.items()): | |
| try: | |
| res = f(pil_img, v=default) | |
| with cols[i % 4]: | |
| st.image(res, caption=nome, use_container_width=True) | |
| except Exception as e: | |
| st.warning(f"{nome}: {e}") | |
| # ── TAB 3: Video Canny Edge Detection ─────────────────────────────── | |
| with tab3: | |
| st.markdown("### ⚡ Trasforma il tuo video in Canny Edge Detection") | |
| uploaded_canny = st.file_uploader( | |
| "📂 Carica il tuo video", | |
| type=["mp4", "avi", "mov", "mkv", "flv", "wmv", "webm"], | |
| key="canny_uploader" | |
| ) | |
| if not uploaded_canny: | |
| st.info("👆 Carica un video per iniziare.") | |
| else: | |
| with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp_c: | |
| tmp_c.write(uploaded_canny.read()) | |
| tmp_canny_path = tmp_c.name | |
| cap_info = cv2.VideoCapture(tmp_canny_path) | |
| total_f = int(cap_info.get(cv2.CAP_PROP_FRAME_COUNT)) | |
| fps_i = cap_info.get(cv2.CAP_PROP_FPS) or 25.0 | |
| w_i = int(cap_info.get(cv2.CAP_PROP_FRAME_WIDTH)) | |
| h_i = int(cap_info.get(cv2.CAP_PROP_FRAME_HEIGHT)) | |
| cap_info.release() | |
| ci1, ci2, ci3, ci4 = st.columns(4) | |
| ci1.metric("📐 Larghezza", f"{w_i}px") | |
| ci2.metric("📏 Altezza", f"{h_i}px") | |
| ci3.metric("🎞️ FPS", f"{fps_i:.1f}") | |
| ci4.metric("⏱️ Durata", f"{total_f / fps_i:.1f}s") | |
| st.divider() | |
| st.markdown("#### ⚙️ Parametri Canny") | |
| cp1, cp2, cp3 = st.columns(3) | |
| with cp1: c_low = st.slider("Soglia Bassa", 0, 200, 50, key="c_low") | |
| with cp2: c_high = st.slider("Soglia Alta", 0, 300, 150, key="c_high") | |
| with cp3: c_blur = st.slider("Sfocatura", 1, 15, 5, step=2, key="c_blur") | |
| c_916 = st.checkbox("📱 Converti in 9:16 verticale (1080×1920)", value=False, key="c_916") | |
| blur_k = c_blur if c_blur % 2 == 1 else c_blur + 1 | |
| st.divider() | |
| st.markdown("#### 👁️ Anteprima") | |
| pos_col, _ = st.columns([2, 3]) | |
| with pos_col: | |
| c_pos = st.slider("Posizione nel video", 0, 100, 30, format="%d%%", key="c_pos") | |
| preview = canny_genera_anteprima(tmp_canny_path, c_low, c_high, blur_k, c_pos/100.0) | |
| if preview: | |
| st.image(preview, | |
| caption=f"Anteprima — Low={c_low}, High={c_high}, Blur={blur_k}", | |
| use_container_width=True) | |
| else: | |
| st.warning("⚠️ Impossibile generare l'anteprima.") | |
| st.divider() | |
| st.markdown("#### 🚀 Elabora il Video Completo") | |
| if st.button("▶️ AVVIA ELABORAZIONE", type="primary", | |
| use_container_width=True, key="btn_canny"): | |
| c_progress = st.progress(0.0) | |
| c_status = st.empty() | |
| try: | |
| video_bytes, nome_file = canny_processa_video( | |
| tmp_canny_path, c_low, c_high, blur_k, c_916, c_progress, c_status) | |
| st.success(f"✅ Video elaborato! ({len(video_bytes)/1024/1024:.1f} MB)") | |
| st.download_button("⬇️ Scarica Video Canny", data=video_bytes, | |
| file_name=nome_file, mime="video/mp4", | |
| use_container_width=True, key="dl_canny") | |
| except Exception as e: | |
| st.error(f"❌ Errore: {e}") | |
| import traceback; st.code(traceback.format_exc()) | |
| try: | |
| os.unlink(tmp_canny_path) | |
| except Exception: | |
| pass | |
| if __name__ == "__main__": | |
| main() | |