Fixed dimension bug

app.py

@@ -90,18 +90,18 @@ available_i2v_presets = get_available_presets(I2V_LORA_REPO_ID, I2V_LORA_SUBFOLD
 
 
 # --- Constants and Configuration ---
-MOD_VALUE = 8
-DEFAULT_H_SLIDER_VALUE = 512
-DEFAULT_W_SLIDER_VALUE = 768
-NEW_FORMULA_MAX_AREA = 768.0 * 512.0
-LORA_MAX_AREA = 640.0 * 480.0 # Max pixel area when a LoRA is active
-
-SLIDER_MIN_H, SLIDER_MAX_H = 128, 896
-SLIDER_MIN_W, SLIDER_MAX_W = 128, 896
+MOD_VALUE = 16 # Changed to 16 for model compatibility
+DEFAULT_H_SLIDER_VALUE = 480 # Default to 480p height
+DEFAULT_W_SLIDER_VALUE = 640 # Default to 640p width
+NEW_FORMULA_MAX_AREA = 640.0 * 480.0 # Default area for new images
+
+LORA_MAX_AREA = 640.0 * 480.0 # Max area when using a LoRA
+
+SLIDER_MIN_H, SLIDER_MAX_H = 128, 1024
+SLIDER_MIN_W, SLIDER_MAX_W = 128, 1024
 MAX_SEED = np.iinfo(np.int32).max
 
 FIXED_FPS = 16
-T2V_FIXED_FPS = 16
 MIN_FRAMES_MODEL = 8
 MAX_FRAMES_MODEL = 81
 
@@ -164,11 +164,13 @@ def handle_lora_selection_change(preset_name, current_prompt, current_h, current
         gr.Info(f"Resolution too high for LoRA. Scaling down to a 640x480 equivalent area.")
         # aspect_ratio is W/H
         if aspect_ratio > 0:
-            calc_w = round(np.sqrt(LORA_MAX_AREA * aspect_ratio))
-            calc_h = round(np.sqrt(LORA_MAX_AREA / aspect_ratio))
+            # Calculate ideal dimensions based on area, without premature rounding
+            calc_w = np.sqrt(LORA_MAX_AREA * aspect_ratio)
+            calc_h = np.sqrt(LORA_MAX_AREA / aspect_ratio)
             
-            new_h = max(MOD_VALUE, (calc_h // MOD_VALUE) * MOD_VALUE)
-            new_w = max(MOD_VALUE, (calc_w // MOD_VALUE) * MOD_VALUE)
+            # Round to the nearest multiple of MOD_VALUE
+            new_h = max(MOD_VALUE, round(calc_h / MOD_VALUE) * MOD_VALUE)
+            new_w = max(MOD_VALUE, round(calc_w / MOD_VALUE) * MOD_VALUE)
             
             h_update = gr.update(value=new_h)
             w_update = gr.update(value=new_w)
@@ -201,7 +203,7 @@ def update_linked_dimension(driving_value, other_value, aspect_ratio, mod_val, m
         new_other_value = driving_value / aspect_ratio
 
     # Round to the nearest multiple of mod_val
-    new_other_value = max(mod_val, (round(new_other_value / mod_val)) * mod_val)
+    new_other_value = max(mod_val, round(new_other_value / mod_val) * mod_val)
 
     # Return an update only if the value has changed to prevent infinite loops
     return gr.update(value=new_other_value) if int(new_other_value) != int(other_value) else gr.update()
@@ -214,10 +216,15 @@ def _calculate_new_dimensions_wan(pil_image, mod_val, calculation_max_area,
     if orig_w <= 0 or orig_h <= 0:
         return default_h, default_w
     aspect_ratio = orig_h / orig_w
-    calc_h = round(np.sqrt(calculation_max_area * aspect_ratio))
-    calc_w = round(np.sqrt(calculation_max_area / aspect_ratio))
-    calc_h = max(mod_val, (calc_h // mod_val) * mod_val)
-    calc_w = max(mod_val, (calc_w // mod_val) * mod_val)
+    
+    # Calculate ideal dimensions based on area, without premature rounding
+    calc_h = np.sqrt(calculation_max_area * aspect_ratio)
+    calc_w = np.sqrt(calculation_max_area / aspect_ratio)
+
+    # Round to the nearest multiple of mod_val
+    calc_h = max(mod_val, round(calc_h / mod_val) * mod_val)
+    calc_w = max(mod_val, round(calc_w / mod_val) * mod_val)
+    
     new_h = int(np.clip(calc_h, min_slider_h, (max_slider_h // mod_val) * mod_val))
     new_w = int(np.clip(calc_w, min_slider_w, (max_slider_w // mod_val) * mod_val))
     return new_h, new_w
@@ -260,10 +267,10 @@ def get_t2v_duration(steps, duration_seconds):
 
 @spaces.GPU(duration_from_args=get_i2v_duration)
 def generate_i2v_video(input_image, prompt, height, width,
-                      negative_prompt, duration_seconds,
-                      guidance_scale, steps, seed, randomize_seed,                      
-                      preset_name, lora_weight,
-                      progress=gr.Progress(track_tqdm=True)):
+                       negative_prompt, duration_seconds,
+                       guidance_scale, steps, seed, randomize_seed,                       
+                       preset_name, lora_weight,
+                       progress=gr.Progress(track_tqdm=True)):
     """Generates a video from an initial image and a prompt."""
     if input_image is None:
         raise gr.Error("Please upload an input image for Image-to-Video generation.")
@@ -279,13 +286,13 @@ def generate_i2v_video(input_image, prompt, height, width,
             print(f"⚠️ Warning: Resolution {target_w}x{target_h} is too high for LoRA. Rescaling to fit max area.")
             aspect_ratio = target_w / target_h if target_h > 0 else 1.0
             
-            # Re-calculate w and h based on max area
-            target_w = round(np.sqrt(LORA_MAX_AREA * aspect_ratio))
-            target_h = round(np.sqrt(LORA_MAX_AREA / aspect_ratio))
+            # Re-calculate w and h based on max area, without premature rounding
+            calc_w = np.sqrt(LORA_MAX_AREA * aspect_ratio)
+            calc_h = np.sqrt(LORA_MAX_AREA / aspect_ratio)
 
-            # Snap to MOD_VALUE
-            target_h = max(MOD_VALUE, (target_h // MOD_VALUE) * MOD_VALUE)
-            target_w = max(MOD_VALUE, (target_w // MOD_VALUE) * MOD_VALUE)
+            # Snap to MOD_VALUE by rounding to the nearest multiple
+            target_h = max(MOD_VALUE, round(calc_h / MOD_VALUE) * MOD_VALUE)
+            target_w = max(MOD_VALUE, round(calc_w / MOD_VALUE) * MOD_VALUE)
             print(f"   - Rescaled to: {target_w}x{target_h}")
 
     # Calculate and adjust num_frames to be compatible with video codecs
@@ -454,4 +461,4 @@ with gr.Blocks() as demo:
 
 
 if __name__ == "__main__":
-    demo.queue().launch()
+    demo.queue().launch()