Initial commit: Animated Loop Generator

.gitignore

@@ -0,0 +1,16 @@
+cat > .gitignore << 'EOF'
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+dist/
+build/
+*.mp4
+*.avi
+*.mov
+flagged/
+gradio_cached_examples/
+.DS_Store
+EOF

README.md

@@ -1,14 +1,77 @@
 ---
-title: MONK3YSPAC333
-emoji: 🐢
-colorFrom: pink
-colorTo: gray
+title: Animated Loop Generator
+emoji: 🎬
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: 4.13.0
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: VIDEO GENERATOR
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎬 Animated Loop Generator
+
+Generate stunning animated video loops from static images using **Stable Video Diffusion**!
+
+## 🚀 Features
+
+- 📸 **Image to Video**: Transform any image into an animated video
+- 🔄 **Perfect Loops**: Create seamless, repeating animations
+- ⚙️ **Customizable**: Control motion strength, frame count, and FPS
+- 🎨 **High Quality**: Powered by Stability AI's SVD model
+- 💨 **Fast**: Optimized for quick generation
+
+## 🎯 How to Use
+
+1. **Upload an Image**: Choose any image (landscape, portrait, abstract)
+2. **Adjust Parameters**:
+   - **Frames**: 14-25 (more = longer video)
+   - **Motion Strength**: 1-255 (higher = more movement)
+   - **FPS**: 4-30 (video frame rate)
+   - **Perfect Loop**: Enable for seamless looping
+3. **Generate**: Click the button and wait ~30-60 seconds
+4. **Download**: Save your animated loop!
+
+## 🎨 Best Results
+
+- Use images with clear subjects and potential for motion
+- Landscapes and nature scenes work great
+- Start with default settings (25 frames, 127 motion strength)
+- Enable "Perfect Loop" for repeating animations
+
+## 🔧 Technical Details
+
+- **Model**: Stable Video Diffusion XT (stabilityai/stable-video-diffusion-img2vid-xt)
+- **Resolution**: 1024x576 (optimal)
+- **Generation Time**: ~30-60 seconds (depends on hardware)
+- **Hardware**: GPU T4 or better recommended
+
+## 💡 Tips
+
+- First generation is slower (model loading)
+- Subsequent generations are faster
+- Higher inference steps = better quality (but slower)
+- Motion strength 127 is a good starting point
+
+## 📚 Examples
+
+Try these types of images:
+- 🌄 Landscapes with clouds or water
+- 🎨 Abstract art with flowing patterns
+- 🌸 Nature close-ups with flowers or leaves
+- 🏙️ Cityscapes with lights
+
+## 🤝 Credits
+
+- **Model**: Stability AI - Stable Video Diffusion
+- **Framework**: HuggingFace Diffusers
+- **UI**: Gradio
+
+## 📄 License
+
+Apache 2.0
+
+---
+
+**Made with ❤️ for the AI community**

app.py

@@ -0,0 +1,321 @@
+"""
+Animated Loop Generator - HuggingFace Space
+Genera loop video animati da immagini usando Stable Video Diffusion
+"""
+
+import gradio as gr
+import torch
+from diffusers import StableVideoDiffusionPipeline
+from diffusers.utils import export_to_video
+from PIL import Image
+import numpy as np
+import os
+import tempfile
+
+# Configurazione
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+MODEL_ID = "stabilityai/stable-video-diffusion-img2vid-xt"
+
+# Carica pipeline globale
+print(f"🔧 Loading pipeline on {DEVICE}...")
+pipe = None
+
+def load_pipeline():
+    """Carica la pipeline SVD"""
+    global pipe
+    
+    if pipe is None:
+        try:
+            pipe = StableVideoDiffusionPipeline.from_pretrained(
+                MODEL_ID,
+                torch_dtype=torch.float16 if DEVICE == "cuda" else torch.float32,
+                variant="fp16" if DEVICE == "cuda" else None,
+            )
+            pipe.to(DEVICE)
+            
+            if DEVICE == "cuda":
+                pipe.enable_model_cpu_offload()
+                pipe.enable_vae_slicing()
+            
+            print("✅ Pipeline loaded successfully!")
+        except Exception as e:
+            print(f"❌ Error loading pipeline: {e}")
+            raise
+    
+    return pipe
+
+
+def preprocess_image(image):
+    """Preprocessa l'immagine per SVD"""
+    if image is None:
+        raise ValueError("No image provided")
+    
+    # Converti in PIL se necessario
+    if isinstance(image, np.ndarray):
+        image = Image.fromarray(image)
+    
+    # Converti in RGB
+    if image.mode != "RGB":
+        image = image.convert("RGB")
+    
+    # Ridimensiona a risoluzione ottimale
+    image = image.resize((1024, 576), Image.LANCZOS)
+    
+    return image
+
+
+def create_loop_video(frames, fps=6):
+    """
+    Crea un loop perfetto aggiungendo i frame in reverse
+    """
+    # Frame originali + reverse (senza duplicare primo e ultimo)
+    loop_frames = frames + frames[-2:0:-1]
+    return loop_frames
+
+
+def generate_animated_loop(
+    image,
+    num_frames=25,
+    motion_strength=127,
+    fps=6,
+    make_loop=True,
+    num_inference_steps=25,
+    progress=gr.Progress()
+):
+    """
+    Genera un loop video animato da un'immagine
+    
+    Args:
+        image: Input image (PIL or numpy array)
+        num_frames: Numero di frame (14-25)
+        motion_strength: Intensità movimento (1-255)
+        fps: Frame per secondo
+        make_loop: Se True, crea un loop perfetto
+        num_inference_steps: Step di inferenza (qualità)
+        progress: Gradio progress tracker
+    """
+    
+    try:
+        progress(0, desc="🔧 Initializing...")
+        
+        # Carica pipeline
+        pipeline = load_pipeline()
+        
+        progress(0.1, desc="🖼️ Processing image...")
+        
+        # Preprocessa immagine
+        processed_image = preprocess_image(image)
+        
+        progress(0.2, desc="🎬 Generating video frames...")
+        
+        # Genera video
+        with torch.no_grad():
+            output = pipeline(
+                processed_image,
+                height=576,
+                width=1024,
+                num_frames=num_frames,
+                motion_bucket_id=motion_strength,
+                fps=fps,
+                decode_chunk_size=4,
+                num_inference_steps=num_inference_steps,
+            )
+        
+        frames = output.frames[0]
+        
+        progress(0.8, desc="🔄 Creating loop...")
+        
+        # Crea loop se richiesto
+        if make_loop:
+            frames = create_loop_video(frames, fps)
+        
+        progress(0.9, desc="💾 Saving video...")
+        
+        # Salva video
+        output_path = tempfile.NamedTemporaryFile(
+            suffix=".mp4", 
+            delete=False
+        ).name
+        
+        export_to_video(frames, output_path, fps=fps)
+        
+        progress(1.0, desc="✅ Complete!")
+        
+        # Info
+        info = f"""
+        ✅ **Video generato con successo!**
+        
+        📊 **Dettagli:**
+        - Frame totali: {len(frames)}
+        - FPS: {fps}
+        - Durata: ~{len(frames)/fps:.1f} secondi
+        - Loop: {'Sì' if make_loop else 'No'}
+        - Motion strength: {motion_strength}
+        """
+        
+        return output_path, info
+        
+    except Exception as e:
+        error_msg = f"❌ **Errore:** {str(e)}"
+        print(f"Error in generation: {e}")
+        return None, error_msg
+
+
+def create_demo():
+    """Crea l'interfaccia Gradio"""
+    
+    with gr.Blocks(
+        title="🎬 Animated Loop Generator",
+        theme=gr.themes.Soft()
+    ) as demo:
+        
+        gr.Markdown("""
+        # 🎬 Animated Loop Generator
+        
+        Genera loop video animati da immagini usando **Stable Video Diffusion**
+        
+        ### Come usare:
+        1. 📤 Carica un'immagine
+        2. ⚙️ Regola i parametri
+        3. 🎬 Click su "Generate Loop"
+        4. 📥 Scarica il tuo video!
+        """)
+        
+        with gr.Row():
+            # Colonna sinistra - Input
+            with gr.Column(scale=1):
+                image_input = gr.Image(
+                    label="📸 Input Image",
+                    type="pil",
+                    sources=["upload", "webcam", "clipboard"]
+                )
+                
+                with gr.Accordion("⚙️ Advanced Settings", open=True):
+                    num_frames = gr.Slider(
+                        minimum=14,
+                        maximum=25,
+                        value=25,
+                        step=1,
+                        label="🎞️ Number of Frames",
+                        info="Più frame = video più lungo"
+                    )
+                    
+                    motion_strength = gr.Slider(
+                        minimum=1,
+                        maximum=255,
+                        value=127,
+                        step=1,
+                        label="💨 Motion Strength",
+                        info="Maggiore = più movimento"
+                    )
+                    
+                    fps = gr.Slider(
+                        minimum=4,
+                        maximum=30,
+                        value=6,
+                        step=1,
+                        label="🎥 FPS (Frames per Second)",
+                        info="Frame rate del video"
+                    )
+                    
+                    make_loop = gr.Checkbox(
+                        value=True,
+                        label="🔄 Create Perfect Loop",
+                        info="Crea un loop senza interruzioni"
+                    )
+                    
+                    num_inference_steps = gr.Slider(
+                        minimum=10,
+                        maximum=50,
+                        value=25,
+                        step=5,
+                        label="🎨 Quality (Inference Steps)",
+                        info="Più step = migliore qualità (ma più lento)"
+                    )
+                
+                generate_btn = gr.Button(
+                    "🎬 Generate Animated Loop",
+                    variant="primary",
+                    size="lg"
+                )
+            
+            # Colonna destra - Output
+            with gr.Column(scale=1):
+                video_output = gr.Video(
+                    label="🎬 Generated Loop",
+                    autoplay=True,
+                    loop=True
+                )
+                
+                info_output = gr.Markdown(
+                    label="ℹ️ Info",
+                    value="Upload un'immagine e genera il tuo loop!"
+                )
+        
+        # Examples
+        gr.Markdown("### 🎨 Esempi")
+        gr.Examples(
+            examples=[
+                ["examples/landscape.jpg", 25, 127, 6, True],
+                ["examples/portrait.jpg", 20, 80, 6, True],
+                ["examples/abstract.jpg", 25, 180, 8, True],
+            ],
+            inputs=[image_input, num_frames, motion_strength, fps, make_loop],
+            outputs=[video_output, info_output],
+            fn=generate_animated_loop,
+            cache_examples=False,
+        )
+        
+        # Event handler
+        generate_btn.click(
+            fn=generate_animated_loop,
+            inputs=[
+                image_input,
+                num_frames,
+                motion_strength,
+                fps,
+                make_loop,
+                num_inference_steps
+            ],
+            outputs=[video_output, info_output],
+        )
+        
+        # Info footer
+        gr.Markdown("""
+        ---
+        ### 📚 Tips per Risultati Migliori:
+        
+        - 🖼️ **Immagini ideali**: Paesaggi, nature, oggetti con potenziale di movimento
+        - 💨 **Motion strength**: Inizia con 127, aumenta per più movimento
+        - 🎞️ **Frames**: 25 per loop più lunghi, 14-18 per loop veloci
+        - 🔄 **Loop**: Attiva per animazioni cicliche perfette
+        
+        ### 🔧 Powered by:
+        - **Model**: Stability AI - Stable Video Diffusion XT
+        - **Framework**: Diffusers + Gradio
+        - **Hardware**: GPU T4 (upgrade per velocità maggiore)
+        
+        ### 💡 Note:
+        - Prima generazione più lenta (caricamento modello)
+        - Generazioni successive più veloci
+        - Qualità ottimale con immagini 1024x576
+        """)
+    
+    return demo
+
+
+# Carica pipeline all'avvio
+try:
+    load_pipeline()
+except Exception as e:
+    print(f"⚠️ Pipeline will be loaded on first generation: {e}")
+
+# Lancia app
+if __name__ == "__main__":
+    demo = create_demo()
+    demo.queue(max_size=20)
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

requirements.txt

@@ -0,0 +1,12 @@
+diffusers==0.25.1
+transformers==4.36.2
+accelerate==0.25.0
+torch==2.1.2
+torchvision==0.16.2
+gradio==4.13.0
+pillow==10.2.0
+numpy==1.26.3
+imageio==2.33.1
+imageio-ffmpeg==0.4.9
+safetensors==0.4.1
+huggingface-hub==0.20.3