Update app.py

app.py

@@ -78,7 +78,7 @@ def tiled_flux_img2img(image, prompt, strength, num_inference_steps, guidance_sc
     result = Image.new('RGB', (width, height))
     stride = tile_size - overlap
     
-    # For simplicity, tile in both directions, but handle small sizes
+    # Tile in both directions, handling small sizes
     for y in range(0, height, stride):
         for x in range(0, width, stride):
             tile_left = x
@@ -106,44 +106,38 @@ def tiled_flux_img2img(image, prompt, strength, num_inference_steps, guidance_sc
                 result.paste(generated_tile, (tile_left, tile_top))
                 continue
             
-            # Blend with previous if overlap
-            if y > 0:  # Vertical blend
-                effective_overlap = min(overlap, tile_bottom - tile_top, result.crop((tile_left, tile_top - overlap, tile_right, tile_top)).height)
+            # Vertical blend
+            if y > 0:
+                effective_overlap = min(overlap, tile_bottom - tile_top, height - tile_top)
                 if effective_overlap > 0:
                     mask = Image.new('L', (tile_right - tile_left, effective_overlap))
                     for i in range(mask.width):
                         for j in range(mask.height):
-                            # Fixed: use effective_overlap for division and range
-                            mask.putpixel((i, j), int(255 * (j / (effective_overlap - 1 if effective_overlap > 1 else 1))))
-                    # Blend the top part of the tile with the bottom of the previous
+                            mask.putpixel((i, j), int(255 * (j / effective_overlap)))
                     blend_region = Image.composite(
                         generated_tile.crop((0, 0, mask.width, mask.height)),
                         result.crop((tile_left, tile_top, tile_right, tile_top + mask.height)),
                         mask
                     )
                     result.paste(blend_region, (tile_left, tile_top))
-                    # Paste the non-overlap part
                     result.paste(generated_tile.crop((0, effective_overlap, generated_tile.width, generated_tile.height)), (tile_left, tile_top + effective_overlap))
                 else:
                     result.paste(generated_tile, (tile_left, tile_top))
             
-            # Similar for horizontal blend (if x > 0), implement analogously
-            if x > 0:  # Horizontal blend
-                # Similar logic, but for left overlap, gradient horizontal
-                effective_overlap_h = min(overlap, tile_right - tile_left)
+            # Horizontal blend
+            if x > 0:
+                effective_overlap_h = min(overlap, tile_right - tile_left, width - tile_left)
                 if effective_overlap_h > 0:
                     mask_h = Image.new('L', (effective_overlap_h, tile_bottom - tile_top))
                     for i in range(mask_h.width):
                         for j in range(mask_h.height):
-                            mask_h.putpixel((i, j), int(255 * (i / (effective_overlap_h - 1 if effective_overlap_h > 1 else 1))))
-                    # Blend left part
+                            mask_h.putpixel((i, j), int(255 * (i / effective_overlap_h)))
                     blend_region_h = Image.composite(
                         generated_tile.crop((0, 0, mask_h.width, mask_h.height)),
                         result.crop((tile_left, tile_top, tile_left + mask_h.width, tile_bottom)),
                         mask_h
                     )
                     result.paste(blend_region_h, (tile_left, tile_top))
-                    # Paste non-overlap
                     result.paste(generated_tile.crop((effective_overlap_h, 0, generated_tile.width, generated_tile.height)), (tile_left + effective_overlap_h, tile_top))
                 else:
                     result.paste(generated_tile, (tile_left, tile_top))
@@ -164,15 +158,19 @@ def enhance_image(image, text_prompt, seed, randomize_seed, width, height, guida
     if image and (image.size[0] > MAX_IMAGE_SIZE or image.size[1] > MAX_IMAGE_SIZE):
         output_image = tiled_flux_img2img(image, prompt, strength, num_inference_steps, guidance_scale)
     else:
+        kw = {}
+        if image is not None:
+            kw['image'] = image
+            kw['strength'] = strength
+        else:
+            kw['width'] = width
+            kw['height'] = height
         output_image = pipe(
             prompt,
-            image=image,
             generator=generator,
             num_inference_steps=num_inference_steps,
-            width=width if image is None else None,
-            height=height if image is None else None,
             guidance_scale=guidance_scale,
-            strength=strength if image is not None else 1.0  # For text2img, strength=1.0
+            **kw
         ).images[0]
     return output_image, prompt, seed