Update app.py

app.py

@@ -36,9 +36,7 @@ import tempfile
 from PIL import Image
 import io
 import requests
-
-
-
+import numpy as np
 
 
 
@@ -814,136 +812,164 @@ def get_video_html(video_path, width="100%"):
 
 # *********
 
-def resize_image_for_video(image_data, max_size=(1024, 1024)):
-    """Resize image to be compatible with video generation"""
+def validate_and_preprocess_image(image_data, target_size=(576, 1024)):
+    """Validate and preprocess image for video generation with detailed logging"""
     try:
+        st.write("Starting image preprocessing...")
+        
         # Convert bytes to PIL Image if needed
         if isinstance(image_data, bytes):
             img = Image.open(io.BytesIO(image_data))
         elif isinstance(image_data, Image.Image):
             img = image_data
         else:
-            raise ValueError("Unsupported image data type")
-
+            raise ValueError(f"Unsupported image data type: {type(image_data)}")
+        
+        st.write(f"Original image size: {img.size}, mode: {img.mode}")
+        
         # Convert to RGB if necessary
         if img.mode != 'RGB':
+            st.write(f"Converting image from {img.mode} to RGB")
             img = img.convert('RGB')
-
-        # Calculate new size maintaining aspect ratio
-        ratio = min(max_size[0] / img.size[0], max_size[1] / img.size[1])
-        new_size = tuple(int(dim * ratio) for dim in img.size)
         
-        # Resize image
-        resized_img = img.resize(new_size, Image.Resampling.LANCZOS)
-        return resized_img
+        # Calculate aspect ratio
+        aspect_ratio = img.size[0] / img.size[1]
+        st.write(f"Original aspect ratio: {aspect_ratio:.2f}")
+        
+        # Determine target dimensions maintaining aspect ratio
+        if aspect_ratio > target_size[0]/target_size[1]:  # Wider than target
+            new_width = target_size[0]
+            new_height = int(new_width / aspect_ratio)
+        else:  # Taller than target
+            new_height = target_size[1]
+            new_width = int(new_height * aspect_ratio)
+            
+        # Ensure dimensions are even numbers
+        new_width = (new_width // 2) * 2
+        new_height = (new_height // 2) * 2
+        
+        st.write(f"Resizing to: {new_width}x{new_height}")
+        
+        # Resize image using high-quality downsampling
+        resized_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        
+        # Create white background image of target size
+        final_img = Image.new('RGB', target_size, (255, 255, 255))
+        
+        # Calculate position to paste resized image (center)
+        paste_x = (target_size[0] - new_width) // 2
+        paste_y = (target_size[1] - new_height) // 2
+        
+        # Paste resized image onto white background
+        final_img.paste(resized_img, (paste_x, paste_y))
+        
+        st.write(f"Final image size: {final_img.size}")
+        
+        # Validate final image
+        if final_img.size != target_size:
+            raise ValueError(f"Final image size {final_img.size} doesn't match target size {target_size}")
+            
+        return final_img
+        
     except Exception as e:
-        st.error(f"Error resizing image: {str(e)}")
+        st.error(f"Error in image preprocessing: {str(e)}")
         return None
 
 def generate_video_from_image(image_data, seed=None, motion_bucket_id=127, fps_id=6, max_retries=3):
-    """Generate video from image using Stable Video Diffusion with improved error handling"""
-    temp_files = []  # Keep track of temporary files
+    """Generate video from image with improved preprocessing and error handling"""
+    temp_files = []
     try:
-        # Create progress bar
+        # Set up progress tracking
         progress_bar = st.progress(0)
         status_text = st.empty()
         
-        status_text.text("Preparing image...")
+        # Preprocess image
+        status_text.text("Preprocessing image...")
         progress_bar.progress(10)
-
-        # Resize image
-        resized_img = resize_image_for_video(image_data)
-        if resized_img is None:
+        
+        processed_img = validate_and_preprocess_image(image_data)
+        if processed_img is None:
+            st.error("Image preprocessing failed")
             return None, None
-
-        # Save resized image to temporary file
+            
+        # Show preprocessed image
+        st.write("Preprocessed image preview:")
+        st.image(processed_img, caption="Preprocessed image", use_column_width=True)
+        
+        # Save processed image
         with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as temp_img:
             temp_files.append(temp_img.name)
-            resized_img.save(temp_img.name, format='PNG')
-
+            processed_img.save(temp_img.name, format='PNG', optimize=True)
+            st.write(f"Saved preprocessed image to: {temp_img.name}")
+            
+            # Verify file size
+            file_size = os.path.getsize(temp_img.name)
+            st.write(f"Preprocessed image file size: {file_size/1024:.2f}KB")
+        
         status_text.text("Connecting to video generation service...")
-        progress_bar.progress(20)
-
-        # Initialize the Gradio client with error handling
+        progress_bar.progress(30)
+        
+        # Initialize client with debug flags
         client = Client(
             "awacke1/stable-video-diffusion",
-            hf_token=os.environ.get("HUGGINGFACE_TOKEN")  # Add your token if needed
+            hf_token=os.environ.get("HUGGINGFACE_TOKEN"),
         )
-
-        # Get random seed if none provided
+        
         if seed is None:
-            try:
-                seed = client.predict(api_name="/get_random_value")
-            except Exception as e:
-                st.warning(f"Could not get random seed, using default. Error: {str(e)}")
-                seed = int(time.time())  # Use timestamp as fallback
-
-        status_text.text("Generating video...")
+            seed = int(time.time() * 1000)  # Use millisecond timestamp as seed
+        
+        status_text.text("Starting video generation...")
         progress_bar.progress(40)
-
-        # Attempt video generation with retries
-        error = None
+        
         for attempt in range(max_retries):
             try:
                 status_text.text(f"Generating video (attempt {attempt + 1}/{max_retries})...")
                 progress_bar.progress(40 + (attempt * 20))
-
-                # First try to resize the image using the API
-                try:
-                    resized_result = client.predict(
-                        image=temp_img.name,
-                        api_name="/resize_image"
-                    )
-                    if resized_result:
-                        temp_files.append(resized_result)
-                        input_image = resized_result
-                    else:
-                        input_image = temp_img.name
-                except Exception as e:
-                    st.warning(f"Image resize API failed, using original image. Error: {str(e)}")
-                    input_image = temp_img.name
-
-                # Generate video
+                
+                # Call video generation API
                 result = client.predict(
-                    image=input_image,
+                    image=temp_img.name,
                     seed=seed,
-                    randomize_seed=True,
+                    randomize_seed=False,  # Set to False for reproducibility
                     motion_bucket_id=motion_bucket_id,
                     fps_id=fps_id,
                     api_name="/video"
                 )
-
+                
+                # Validate result
                 if result and isinstance(result, tuple) and len(result) >= 1:
-                    video_path = result[0].get('video') if isinstance(result[0], dict) else None
-                    if video_path:
-                        status_text.text("Video generated successfully!")
-                        progress_bar.progress(100)
-                        return video_path, seed
-
-                error = f"Invalid result format on attempt {attempt + 1}"
+                    if isinstance(result[0], dict) and 'video' in result[0]:
+                        video_path = result[0]['video']
+                        if os.path.exists(video_path):
+                            status_text.text("Video generated successfully!")
+                            progress_bar.progress(100)
+                            return video_path, seed
+                
+                st.warning(f"Invalid result format on attempt {attempt + 1}: {result}")
                 time.sleep(2 ** attempt)  # Exponential backoff
+                
             except Exception as e:
-                error = str(e)
-                st.warning(f"Attempt {attempt + 1} failed: {error}")
-                time.sleep(2 ** attempt)  # Exponential backoff
-
-        raise Exception(f"Failed after {max_retries} attempts. Last error: {error}")
-
+                st.warning(f"Attempt {attempt + 1} failed: {str(e)}")
+                time.sleep(2 ** attempt)
+        
+        raise Exception(f"Failed to generate video after {max_retries} attempts")
+        
     except Exception as e:
         st.error(f"Error in video generation: {str(e)}")
         return None, None
+        
     finally:
-        # Cleanup temporary files
+        # Cleanup
         for temp_file in temp_files:
             try:
                 if os.path.exists(temp_file):
                     os.unlink(temp_file)
+                    st.write(f"Cleaned up temporary file: {temp_file}")
             except Exception as e:
-                st.warning(f"Error cleaning up temporary file {temp_file}: {str(e)}")
+                st.warning(f"Error cleaning up {temp_file}: {str(e)}")
 
-# Add this to your main Streamlit interface, in the appropriate section:
 def add_video_generation_ui(container):
-    """Add video generation UI components"""
+    """Enhanced video generation UI with better error handling and feedback"""
     st.markdown("### 🎥 Video Generation")
     
     col1, col2 = st.columns([2, 1])
@@ -952,120 +978,99 @@ def add_video_generation_ui(container):
         uploaded_image = st.file_uploader(
             "Upload Image for Video Generation 🖼️",
             type=['png', 'jpg', 'jpeg'],
-            help="Upload an image to generate a video from"
+            help="Upload a clear, well-lit image. Recommended size: 576x1024 pixels."
         )
     
     with col2:
-        st.markdown("#### Parameters")
+        st.markdown("#### Generation Parameters")
         motion_bucket_id = st.slider(
             "Motion Intensity 🌊",
             min_value=1,
             max_value=255,
             value=127,
-            help="Controls the amount of motion in the generated video"
+            help="Lower values create subtle movement, higher values create more dramatic motion"
         )
         fps_id = st.slider(
             "Frames per Second 🎬",
             min_value=1,
             max_value=30,
             value=6,
-            help="Controls the smoothness of the generated video"
+            help="Higher values create smoother but potentially less stable videos"
         )
+        
+        # Add advanced options in an expander
+        with st.expander("Advanced Options"):
+            use_custom_seed = st.checkbox("Use Custom Seed")
+            if use_custom_seed:
+                seed = st.number_input("Seed Value", value=int(time.time() * 1000))
+            else:
+                seed = None
 
     if uploaded_image:
-        st.image(uploaded_image, caption="Preview of uploaded image", use_column_width=True)
-        
-        if st.button("🎥 Generate Video", help="Click to start video generation"):
-            with st.spinner("Processing your video... This may take a few minutes 🎬"):
-                image_bytes = uploaded_image.read()
-                video_path, used_seed = generate_video_from_image(
-                    image_bytes,
-                    motion_bucket_id=motion_bucket_id,
-                    fps_id=fps_id
-                )
-                
-                if video_path:
-                    # Save video locally
-                    video_filename = f"generated_video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
-                    try:
-                        shutil.copy(video_path, video_filename)
-                        
-                        # Display the generated video
-                        st.success(f"Video generated successfully! Seed: {used_seed}")
-                        st.video(video_filename)
-                        
-                        # Save to Cosmos DB
-                        if container:
-                            video_record = {
-                                "id": generate_unique_id(),
-                                "type": "generated_video",
-                                "filename": video_filename,
-                                "seed": used_seed,
-                                "motion_bucket_id": motion_bucket_id,
-                                "fps_id": fps_id,
-                                "timestamp": datetime.now().isoformat()
-                            }
-                            success, message = insert_record(container, video_record)
-                            if success:
-                                st.success("Video record saved to database!")
-                            else:
-                                st.error(f"Error saving video record: {message}")
-                    except Exception as e:
-                        st.error(f"Error saving video: {str(e)}")
-                else:
-                    st.error("Failed to generate video. Please try again with different parameters.")
-
-
-# Add this to the 'Show as Run AI' section in your main function, 
-# right after the "🤖 Run AI" button:
-
-# Add image upload and video generation
-st.image_uploader = st.file_uploader("Upload Image for Video Generation 🖼️", type=['png', 'jpg', 'jpeg'])
-st.video_gen_params = {
-    'motion_bucket_id': st.slider("Motion Intensity 🌊", 1, 255, 127),
-    'fps_id': st.slider("Frames per Second 🎬", 1, 30, 6)
-}
-
-if st.image_uploader is not None:
-    if st.button("🎥 Generate Video"):
-        with st.spinner("Generating video... 🎬"):
-            # Read uploaded image
-            image_bytes = st.image_uploader.read()
-            
-            # Generate video
-            video_path, used_seed = generate_video_from_image(
-                image_bytes,
-                motion_bucket_id=st.video_gen_params['motion_bucket_id'],
-                fps_id=st.video_gen_params['fps_id']
-            )
+        try:
+            # Preview original image
+            preview_col1, preview_col2 = st.columns(2)
+            with preview_col1:
+                st.write("Original Image:")
+                st.image(uploaded_image, caption="Original", use_column_width=True)
             
-            if video_path:
-                # Save video to local storage
-                video_filename = f"generated_video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
-                shutil.copy(video_path, video_filename)
-                
-                st.success(f"Video generated successfully! Seed used: {used_seed}")
-                
-                # Display the generated video
-                st.video(video_filename)
-                
-                # Save to Cosmos DB if needed
-                if container:
-                    video_record = {
-                        "id": generate_unique_id(),
-                        "type": "generated_video",
-                        "filename": video_filename,
-                        "seed": used_seed,
-                        "motion_bucket_id": st.video_gen_params['motion_bucket_id'],
-                        "fps_id": st.video_gen_params['fps_id'],
-                        "timestamp": datetime.now().isoformat()
-                    }
-                    success, message = insert_record(container, video_record)
-                    if success:
-                        st.success("Video record saved to database")
+            # Preview preprocessed image
+            with preview_col2:
+                preprocessed = validate_and_preprocess_image(uploaded_image.read())
+                if preprocessed:
+                    st.write("Preprocessed Image:")
+                    st.image(preprocessed, caption="Preprocessed", use_column_width=True)
+        except Exception as e:
+            st.error(f"Error previewing image: {str(e)}")
+        
+        if st.button("🎥 Generate Video", help="Start video generation process"):
+            try:
+                with st.spinner("Processing your video... This may take a few minutes 🎬"):
+                    video_path, used_seed = generate_video_from_image(
+                        uploaded_image.read(),
+                        seed=seed,
+                        motion_bucket_id=motion_bucket_id,
+                        fps_id=fps_id
+                    )
+                    
+                    if video_path and os.path.exists(video_path):
+                        # Save video locally
+                        video_filename = f"generated_video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+                        try:
+                            shutil.copy(video_path, video_filename)
+                            
+                            # Display success and video
+                            st.success(f"""
+                            Video generated successfully! 🎉
+                            - Seed: {used_seed}
+                            - Motion Intensity: {motion_bucket_id}
+                            - FPS: {fps_id}
+                            """)
+                            
+                            st.video(video_filename)
+                            
+                            # Save to Cosmos DB
+                            if container:
+                                video_record = {
+                                    "id": generate_unique_id(),
+                                    "type": "generated_video",
+                                    "filename": video_filename,
+                                    "seed": used_seed,
+                                    "motion_bucket_id": motion_bucket_id,
+                                    "fps_id": fps_id,
+                                    "timestamp": datetime.now().isoformat()
+                                }
+                                success, message = insert_record(container, video_record)
+                                if success:
+                                    st.success("Video record saved to database!")
+                                else:
+                                    st.error(f"Error saving video record: {message}")
+                        except Exception as e:
+                            st.error(f"Error saving video: {str(e)}")
                     else:
-                        st.error(f"Error saving video record: {message}")
-
+                        st.error("Video generation failed. Please try again with different parameters.")
+            except Exception as e:
+                st.error(f"Error during video generation process: {str(e)}")
 
 # ******************************************