Update app.py

app.py

@@ -3,48 +3,40 @@ from PIL import Image
 import io
 import zipfile
 
-def resize_image_to_multiple_of_64(img: Image.Image, fill_color=(0, 0, 0)):
-    """
-    将单张图片缩放到 (w', h')，其中 w'、h' 均为 64 的整数倍。
-    若原图宽高比与 w'/h' 不完全一致，则在空余处用 fill_color 填充（不裁切）。
-    """
+def resize_image_to_multiple_of_64_rgba(img: Image.Image):
     w, h = img.size
-    
-    # 计算最接近的 64 倍数
-    # 若 round(...) 结果为 0，至少保底 64
+    # 计算最接近的 64 倍数（保底64）
     w64 = max(64, round(w / 64) * 64)
     h64 = max(64, round(h / 64) * 64)
     
-    # 根据最小缩放策略，保证图片能放进 w64 × h64
+    # 按最小缩放比，使原图能贴进 w64 x h64
     scale = min(w64 / w, h64 / h)
     new_width = int(w * scale)
     new_height = int(h * scale)
     
-    # 创建背景
-    new_img = Image.new("RGB", (w64, h64), fill_color)
-    # 将原图缩放
+    # 用 RGBA、黑色背景(全不透明)
+    background = Image.new("RGBA", (w64, h64), (0, 0, 0, 255))
+    # 缩放原图到 new_width, new_height
     scaled_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
-    # 居中贴到背景上
+    
+    # 贴到背景中央，保留其透明度
     offset_x = (w64 - new_width) // 2
     offset_y = (h64 - new_height) // 2
-    new_img.paste(scaled_img, (offset_x, offset_y))
-    return new_img
+    background.paste(scaled_img, (offset_x, offset_y), scaled_img)
+    return background
 
-def make_collage(four_images, fill_color=(0, 0, 0)):
-    """
-    将 4 张同样尺寸的图片（2×2）拼接成一张大图。
-    如果结果大于 2048×2048，则等比例缩小到不超过 2048。
-    """
-    assert len(four_images) == 4, "必须是 4 张图"
-    w, h = four_images[0].size  # 假设 4 张图尺寸相同
-    collage = Image.new("RGB", (2 * w, 2 * h), fill_color)
-    # 依次贴上
-    collage.paste(four_images[0], (0, 0))
-    collage.paste(four_images[1], (w, 0))
-    collage.paste(four_images[2], (0, h))
-    collage.paste(four_images[3], (w, h))
+def make_collage_2x2(four_rgba_images):
+    # 4 张图，均已是 RGBA、同尺寸
+    w, h = four_rgba_images[0].size
+    # 新画布：2x2 => 宽度 2*w，高度 2*h，背景黑
+    collage = Image.new("RGBA", (2 * w, 2 * h), (0, 0, 0, 255))
+    collage.paste(four_rgba_images[0], (0, 0), four_rgba_images[0])
+    collage.paste(four_rgba_images[1], (w, 0), four_rgba_images[1])
+    collage.paste(four_rgba_images[2], (0, h), four_rgba_images[2])
+    collage.paste(four_rgba_images[3], (w, h), four_rgba_images[3])
     
     cw, ch = collage.size
+    # 若合并后任意边 > 2048，则等比例缩小
     if cw > 2048 or ch > 2048:
         scale = min(2048 / cw, 2048 / ch)
         new_cw = int(cw * scale)
@@ -53,99 +45,78 @@ def make_collage(four_images, fill_color=(0, 0, 0)):
     
     return collage
 
-def process_images(uploaded_files):
-    """
-    处理用户上传的多张图片：
-    1. 每组 4 张图 -> 统一到 64 的倍数尺寸 -> 拼成 2×2 的大图
-    2. 大于 2048×2048 则缩小
-    3. 返回多张拼接图（以列表的形式）供 Gradio 显示
-    4. 若最后一组不足 4 张，则跳过
-    """
-    # 读取成 PIL 对象
+def process_images_for_preview(uploaded_files):
     pil_images = []
-    for file_obj in uploaded_files:
-        if file_obj is not None:
-            img = Image.open(file_obj.name).convert("RGB")
+    for f in uploaded_files:
+        if f is not None:
+            # 以 RGBA 读图，保证可保留透明通道
+            img = Image.open(f.name).convert("RGBA")
             pil_images.append(img)
-    
+
     results = []
-    # 以 4 张为一组进行处理
+    # 每 4 张为一组，不足 4 张跳过
     for i in range(0, len(pil_images), 4):
         group = pil_images[i : i + 4]
         if len(group) < 4:
-            # 不足 4 张，跳过
             break
-        
-        # 分别 resize
-        resized = [resize_image_to_multiple_of_64(img, fill_color=(0,0,0)) for img in group]
-        # 拼接
-        collage = make_collage(resized, fill_color=(0,0,0))
+        # 每张做64倍数 resize + 黑色背景填充
+        resized = [resize_image_to_multiple_of_64_rgba(im) for im in group]
+        # 再 2×2 拼接
+        collage = make_collage_2x2(resized)
         results.append(collage)
     
     return results
 
-def process_and_zip(uploaded_files):
-    """
-    在内存中创建 Zip，将所有生成的拼接图打包。
-    返回一个 BytesIO 给 Gradio 的 File 输出，用于下载。
-    """
-    # 先按需求生成拼接结果
-    collages = process_images(uploaded_files)
-    
-    # 如果没有生成任何拼接图，则返回 None，让前端不显示下载
+def process_and_zip_for_download(uploaded_files):
+    collages = process_images_for_preview(uploaded_files)
     if not collages:
+        # 没有任何拼接图，就返回 None，让界面不显示可下载链接
         return None
     
-    # 在内存中创建 zip
     buf = io.BytesIO()
-    with zipfile.ZipFile(buf, "w") as zf:
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
         for idx, img in enumerate(collages):
-            # 将 PIL 图像转成字节并写入 zip
+            # 转字节并写入 zip
             img_bytes = io.BytesIO()
+            # 以 PNG 格式保存，带 RGBA
             img.save(img_bytes, format="PNG")
             img_bytes.seek(0)
             zf.writestr(f"collage_{idx+1}.png", img_bytes.read())
     buf.seek(0)
     return buf
 
-########################################
-#        构建 Gradio 界面
-########################################
-css_custom = """
-/* 你可根据需要，在此自定义或覆盖 Gradio 的 CSS 样式 */
-"""
-
-with gr.Blocks(css=css_custom) as demo:
+with gr.Blocks() as demo:
     gr.Markdown("## 图片 2×2 拼接小工具")
     gr.Markdown(
-        "1. 请选择若干张图片（数量需为 4 的倍数才能完整拼接）。<br>"
-        "2. 每 4 张会被缩放并以 2×2 的形式合并成新图。<br>"
-        "3. 如果合并后图像尺寸超过 2048×2048，会自动缩小。<br>"
-        "4. 你可以在下方预览结果或打包下载。"
+        "1. 一次可上传多张图片，每 4 张为一组。\n"
+        "2. 每组里 4 张图会先缩放到 64 的倍数、空余处用黑色填充，然后 2×2 拼接。\n"
+        "3. 拼接结果若超过 2048×2048，则缩小到不超过 2048。\n"
+        "4. 不足 4 张的剩余图片忽略。\n"
+        "5. 支持保留 PNG 透明度，拼图时使用黑色背景。"
     )
     
     with gr.Row():
         with gr.Column():
             file_input = gr.Files(label="上传图片（可多选）", file_types=["image"])
-            btn_preview = gr.Button("生成预览")
-            btn_zip = gr.Button("打包下载 ZIP")
-        
+            preview_btn = gr.Button("生成预览")
+            download_btn = gr.Button("打包下载 ZIP")
         with gr.Column():
-            gallery_output = gr.Gallery(label="拼接结果预览").style(grid=[2], height="auto")
-            zip_file = gr.File(label="下载拼接结果 ZIP", interactive=False, visible=False)
+            # Gallery 构造上不使用 .style() 以兼容老版本
+            gallery_output = gr.Gallery(label="拼接结果预览", columns=2)
+            zip_output = gr.File(label="下载拼接结果 ZIP", interactive=False, visible=False)
     
-    # 点击“生成预览” -> 显示拼接好的图片（可能多张）
-    btn_preview.click(
-        fn=process_images,
+    # 点击“生成预览” -> 返回拼接图列表
+    preview_btn.click(
+        fn=process_images_for_preview,
         inputs=[file_input],
         outputs=[gallery_output]
     )
     
-    # 点击“打包下载 ZIP” -> 生成 zip 文件供下载
-    btn_zip.click(
-        fn=process_and_zip,
+    # 点击“打包下载 ZIP” -> 生成 zip
+    download_btn.click(
+        fn=process_and_zip_for_download,
         inputs=[file_input],
-        outputs=[zip_file]
+        outputs=[zip_output]
     )
 
 demo.launch()