Upload folder using huggingface_hub

modules/infographics_generator/__init__.py

@@ -0,0 +1,16 @@
+"""
+Infographics Generator package
+"""
+
+from modules.infographics_generator.infographics_generator import process
+from modules.infographics_generator.color_utils import get_contrast_color
+from .infographics_generator import process
+from .color_utils import get_contrast_color
+from .mask_utils import calculate_mask, calculate_content_height
+
+__all__ = [
+    'process',
+    'get_contrast_color',
+    'calculate_mask',
+    'calculate_content_height',
+]

modules/infographics_generator/chat_utils.py

@@ -0,0 +1,54 @@
+import base64
+from datetime import datetime
+import json
+import os
+import time
+import logging
+from pathlib import Path
+from PIL import Image
+
+
+my_logger = None
+
+def get_logger(name=None, log_path=None):
+    global my_logger
+    if my_logger is not None:
+        return my_logger
+    assert name is not None, 'name should not be None'
+    assert log_path is not None, 'log_path should not be None'
+    my_logger = logging.getLogger(name)
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', \
+        handlers=[logging.FileHandler(filename=log_path, encoding='utf-8', mode='a+'), logging.StreamHandler()])
+    return my_logger
+
+def load_json(save_path, output=False):
+    info_dict = {}
+    if os.path.exists(save_path):
+        with open(save_path, "r", encoding='utf-8') as f:
+            info_dict = json.load(f)
+    if output:
+        print('already have', len(info_dict))
+    return info_dict
+
+
+def load_txt(save_path):
+    assert os.path.exists(save_path), f'{save_path} not exist'
+    info = ''
+    if os.path.exists(save_path):
+        with open(save_path, "r", encoding='utf-8') as f:
+            info = f.read()
+    return info
+
+
+def safe_save_json(info_dict, save_path, output=False):
+    while True:
+        try:
+            with open(save_path, "w", encoding='utf-8') as f:
+                json.dump(info_dict, f, indent=2, ensure_ascii=False)
+            break
+        except Exception as e:
+            time.sleep(1)
+            print('----------save error:', str(e))
+            print('----------do not interrupt saving, retrying...')
+    if output:
+        print(f'--------------------save success,', len(info_dict), 'saved')

modules/infographics_generator/color_utils.py

@@ -0,0 +1,334 @@
+from typing import Tuple
+import colorsys
+import random
+import math
+
+def parse_color(c: str) -> Tuple[int, int, int]:
+    """将颜色字符串解析为RGB元组"""
+    if c.startswith('#'):
+        c = c.lstrip('#')
+        if len(c) == 3:
+            c = ''.join(x + x for x in c)
+        return tuple(int(c[i:i+2], 16) for i in (0, 2, 4))
+    elif c.startswith('rgb'):
+        return tuple(map(int, c.strip('rgb()').split(',')))
+    raise ValueError(f"Unsupported color format: {c}")
+
+def rgb_to_hsl(r: int, g: int, b: int) -> Tuple[float, float, float]:
+    """RGB颜色转换为HSL颜色空间"""
+    r, g, b = r/255.0, g/255.0, b/255.0
+    max_val = max(r, g, b)
+    min_val = min(r, g, b)
+    h, s, l = 0, 0, (max_val + min_val) / 2
+    
+    if max_val != min_val:
+        d = max_val - min_val
+        s = d / (2 - max_val - min_val) if l > 0.5 else d / (max_val + min_val)
+        if max_val == r:
+            h = (g - b) / d + (6 if g < b else 0)
+        elif max_val == g:
+            h = (b - r) / d + 2
+        elif max_val == b:
+            h = (r - g) / d + 4
+        h /= 6
+        
+    return h * 360, s * 100, l * 100
+
+def hsl_to_rgb(h: float, s: float, l: float) -> Tuple[int, int, int]:
+    """HSL颜色转换为RGB颜色空间"""
+    h, s, l = h/360, s/100, l/100
+    
+    def hue_to_rgb(p: float, q: float, t: float) -> float:
+        if t < 0:
+            t += 1
+        if t > 1:
+            t -= 1
+        if t < 1/6:
+            return p + (q - p) * 6 * t
+        if t < 1/2:
+            return q
+        if t < 2/3:
+            return p + (q - p) * (2/3 - t) * 6
+        return p
+    
+    if s == 0:
+        r = g = b = l
+    else:
+        q = l * (1 + s) if l < 0.5 else l + s - l * s
+        p = 2 * l - q
+        r = hue_to_rgb(p, q, h + 1/3)
+        g = hue_to_rgb(p, q, h)
+        b = hue_to_rgb(p, q, h - 1/3)
+        
+    return tuple(round(x * 255) for x in (r, g, b))
+
+def get_contrast_color(hex_color: str) -> str:
+    """获取与给定颜色形成对比的颜色"""
+    # 移除#号并转换为RGB
+    hex_color = hex_color.lstrip('#')
+    r, g, b = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+    
+    # 计算亮度
+    luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
+    
+    # 根据亮度返回黑色或白色
+    return '#000000' if luminance > 0.5 else '#ffffff'
+
+def hex_to_rgb(hex_color: str) -> tuple:
+    """
+    Convert hex color to RGB tuple
+    
+    Args:
+        hex_color: Hex color string (e.g. "#FFFFFF")
+        
+    Returns:
+        tuple: (r, g, b) where each value is between 0 and 1
+    """
+    hex_color = hex_color.lstrip('#')
+    r = int(hex_color[0:2], 16) / 255.0
+    g = int(hex_color[2:4], 16) / 255.0
+    b = int(hex_color[4:6], 16) / 255.0
+    return (r, g, b)
+
+def rgb_to_hex(rgb: tuple) -> str:
+    """
+    Convert RGB tuple to hex color
+    
+    Args:
+        rgb: (r, g, b) tuple where each value is between 0 and 1
+        
+    Returns:
+        str: Hex color string (e.g. "#FFFFFF")
+    """
+    r, g, b = [int(x * 255) for x in rgb]
+    return f"#{r:02x}{g:02x}{b:02x}"
+def lighten_color(hex_color: str, amount: float = 0.2) -> str:
+    """
+    Lighten a color by converting to HSL, increasing lightness, and converting back
+    
+    Args:
+        hex_color: Hex color string (e.g. "#FFFFFF")
+        amount: Amount to lighten (0-1)
+        
+    Returns:
+        str: Lightened hex color
+    """
+    # Convert hex to RGB
+    r, g, b = hex_to_rgb(hex_color)
+    
+    # Convert RGB to HSL
+    h, l, s = colorsys.rgb_to_hls(r, g, b)
+    
+    # Increase lightness to ensure RGB values are at least 220/255
+    # Calculate the minimum lightness needed to get RGB values above 220
+    r_new, g_new, b_new = r, g, b
+    target_min = 220/255
+    
+    # Gradually increase lightness until all RGB values are above target
+    while min(r_new, g_new, b_new) < target_min and l < 0.99:
+        l = min(0.99, l + 0.05)
+        r_new, g_new, b_new = colorsys.hls_to_rgb(h, l, s)
+    
+    # Convert back to hex
+    return rgb_to_hex((r_new, g_new, b_new))
+
+def is_dark_color(hex_color: str) -> bool:
+    """
+    Check if a color is dark by calculating its luminance
+    
+    Args:
+        hex_color: Hex color string (e.g. "#FFFFFF")
+        
+    Returns:
+        bool: True if color is dark, False otherwise
+    """
+    r, g, b = hex_to_rgb(hex_color)
+    luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b
+    return luminance < 0.8
+
+
+def has_indistinguishable_colors(color_list, threshold=0.85):
+    """
+    判断颜色列表中是否存在不可区分的颜色
+    
+    参数:
+        color_list: 十六进制颜色代码列表，如 ["#FF5733", "#33FF57"]
+        threshold: 相似度阈值，超过此值的两个颜色被视为不可区分
+        
+    返回:
+        如果存在不可区分的颜色，返回True，否则返回False
+    """
+    import math
+    
+    def color_similarity(color1, color2):
+        # 将十六进制转换为RGB
+        color1 = color1.lstrip('#')
+        r1, g1, b1 = tuple(int(color1[i:i+2], 16) for i in (0, 2, 4))
+        
+        color2 = color2.lstrip('#')
+        r2, g2, b2 = tuple(int(color2[i:i+2], 16) for i in (0, 2, 4))
+        
+        # 计算RGB空间中的欧氏距离
+        distance = math.sqrt((r1-r2)**2 + (g1-g2)**2 + (b1-b2)**2)
+        
+        # 归一化相似度 (最大可能距离是sqrt(3*255^2))
+        similarity = 1 - (distance / math.sqrt(3 * 255**2))
+        
+        return similarity
+    
+    # 比较每一对颜色
+    for i in range(len(color_list)):
+        for j in range(i+1, len(color_list)):
+            if color_similarity(color_list[i], color_list[j]) > threshold:
+                return True
+    
+    return False
+
+def generate_distinct_palette(main_color, num_colors=5):
+    """
+    根据主颜色生成一组美观且可区分的颜色调色板
+    
+    参数:
+        main_color: 主颜色，十六进制格式，如 "#FF5733"
+        num_colors: 需要生成的颜色数量，包括主颜色
+        
+    返回:
+        一个包含十六进制颜色代码的列表
+    """
+    # 将十六进制颜色转换为RGB
+    main_color = main_color.lstrip('#')
+    r, g, b = tuple(int(main_color[i:i+2], 16) for i in (0, 2, 4))
+    
+    # 转换RGB为HSL
+    h, s, l = colorsys.rgb_to_hls(r/255, g/255, b/255)
+    h = h * 360  # 转换到0-360度
+    s = s * 100  # 转换到0-100%
+    l = l * 100  # 转换到0-100%
+    
+    palette = ["#" + main_color]  # 添加主颜色到调色板
+    
+    # 选择生成策略
+    strategy = random.choice(["complementary", "analogous", "triadic", "golden_ratio"])
+    
+    # 根据不同策略生成颜色
+    if strategy == "complementary" and num_colors >= 2:
+        # 互补色方案，最容易区分
+        for i in range(1, num_colors):
+            # 互补色基础上增加变化
+            new_h = (h + 180 + (i-1) * 30) % 360
+            
+            # 限制饱和度和亮度范围
+            new_s = max(30, min(90, s + random.uniform(-20, 20)))
+            new_l = max(35, min(75, l + random.uniform(-15, 15)))
+            
+            # 转回RGB并添加到调色板
+            r, g, b = colorsys.hls_to_rgb(new_h/360, new_l/100, new_s/100)
+            hex_color = "#{:02x}{:02x}{:02x}".format(int(r*255), int(g*255), int(b*255))
+            palette.append(hex_color)
+    
+    elif strategy == "analogous":
+        # 类似色方案但确保足够区分
+        for i in range(1, num_colors):
+            # 在主色左右30-60度范围内分布
+            new_h = (h + (i % 2 * 2 - 1) * random.uniform(30, 60)) % 360
+            
+            # 限制饱和度和亮度范围
+            new_s = max(30, min(90, s + random.uniform(-15, 15)))
+            new_l = max(35, min(75, l + random.uniform(-10, 10)))
+            
+            r, g, b = colorsys.hls_to_rgb(new_h/360, new_l/100, new_s/100)
+            hex_color = "#{:02x}{:02x}{:02x}".format(int(r*255), int(g*255), int(b*255))
+            palette.append(hex_color)
+    
+    elif strategy == "triadic":
+        # 三等分色环方案
+        for i in range(1, num_colors):
+            # 在色环上120度间隔分布
+            new_h = (h + (i % 3) * 120) % 360
+            
+            # 限制饱和度和亮度范围
+            new_s = max(30, min(90, s + random.uniform(-10, 10)))
+            new_l = max(35, min(75, l + random.uniform(-10, 10)))
+            
+            r, g, b = colorsys.hls_to_rgb(new_h/360, new_l/100, new_s/100)
+            hex_color = "#{:02x}{:02x}{:02x}".format(int(r*255), int(g*255), int(b*255))
+            palette.append(hex_color)
+    
+    else:  # golden_ratio
+        # 黄金比例方法
+        golden_ratio = 0.618033988749895 * 360  # 转换到角度
+        for i in range(1, num_colors):
+            new_h = (h + golden_ratio * i) % 360
+            
+            # 限制饱和度和亮度范围
+            new_s = max(30, min(90, 60 + random.uniform(-20, 20)))  # 基准饱和度60%
+            new_l = max(35, min(75, 55 + random.uniform(-15, 15)))  # 基准亮度55%
+            
+            r, g, b = colorsys.hls_to_rgb(new_h/360, new_l/100, new_s/100)
+            hex_color = "#{:02x}{:02x}{:02x}".format(int(r*255), int(g*255), int(b*255))
+            palette.append(hex_color)
+    
+    # 检查颜色区分度，如果颜色太相似，则调整
+    final_palette = [palette[0]]  # 始终保留主颜色
+    for color in palette[1:]:
+        if len(final_palette) >= num_colors:
+            break
+            
+        # 检查与已有颜色的区分度
+        is_distinct = True
+        for existing_color in final_palette:
+            if color_similarity(color, existing_color) > 0.85:  # 相似度阈值
+                is_distinct = False
+                break
+                
+        if is_distinct:
+            final_palette.append(color)
+        else:
+            # 生成一个替代颜色
+            new_h = random.uniform(0, 360)
+            new_s = random.uniform(30, 90)  # 限��饱和度范围
+            new_l = random.uniform(35, 75)  # 限制亮度范围
+            
+            r, g, b = colorsys.hls_to_rgb(new_h/360, new_l/100, new_s/100)
+            hex_color = "#{:02x}{:02x}{:02x}".format(int(r*255), int(g*255), int(b*255))
+            final_palette.append(hex_color)
+    
+    # 如果颜色不足，继续补充
+    while len(final_palette) < num_colors:
+        new_h = random.uniform(0, 360)
+        new_s = random.uniform(30, 90)  # 限制饱和度范围
+        new_l = random.uniform(35, 75)  # 限制亮度范围
+        
+        r, g, b = colorsys.hls_to_rgb(new_h/360, new_l/100, new_s/100)
+        hex_color = "#{:02x}{:02x}{:02x}".format(int(r*255), int(g*255), int(b*255))
+        
+        # 检查与已有颜色的区分度
+        is_distinct = True
+        for existing_color in final_palette:
+            if color_similarity(hex_color, existing_color) > 0.85:
+                is_distinct = False
+                break
+                
+        if is_distinct:
+            final_palette.append(hex_color)
+    
+    return final_palette
+
+def color_similarity(color1, color2):
+    """
+    计算两个颜色的相似度（0-1之间，1表示完全相同）
+    """
+    # 将十六进制转换为RGB
+    color1 = color1.lstrip('#')
+    r1, g1, b1 = tuple(int(color1[i:i+2], 16) for i in (0, 2, 4))
+    
+    color2 = color2.lstrip('#')
+    r2, g2, b2 = tuple(int(color2[i:i+2], 16) for i in (0, 2, 4))
+    
+    # 计算RGB空间中的欧氏距离
+    distance = math.sqrt((r1-r2)**2 + (g1-g2)**2 + (b1-b2)**2)
+    
+    # 归一化相似度 (最大可能距离是sqrt(3*255^2))
+    similarity = 1 - (distance / math.sqrt(3 * 255**2))
+    
+    return similarity

modules/infographics_generator/data_utils.py

@@ -0,0 +1,115 @@
+from typing import Dict, List, Tuple
+import re
+from datetime import datetime
+import logging
+
+logger = logging.getLogger(__name__)
+
+def process_temporal_data(data: Dict) -> None:
+    """处理时间类型的数据"""
+    for column in data["data"]["columns"]:
+        if column["data_type"] == "temporal":
+            for row in data["data"]["data"]:
+                value = str(row.get(column["name"], ""))
+                
+                try:
+                    # 处理简单年份格式 (如 "05" 表示 2005)
+                    if value.isdigit():
+                        if len(value) == 2:
+                            row[column["name"]] = f"2000-{value}"  # 使用年份-月份格式
+                        else:
+                            row[column["name"]] = value  # 保持原样的年份
+                        continue
+                    
+                    # 处理带小数点的年份格式 (如 "2025.1" → "2025-01")
+                    if "." in value:
+                        year, month = value.split(".")
+                        if year.isdigit() and month.isdigit():
+                            # 确保月份是两位数
+                            month = month.zfill(2)
+                            row[column["name"]] = f"{year}-{month}"
+                        continue
+                    
+                    # 处理月份年份组合 (如 "Jul 2025")
+                    if " " in value:
+                        try:
+                            # 尝试解析完整的月份名称
+                            date_obj = datetime.strptime(value, "%B %Y")
+                        except ValueError:
+                            try:
+                                # 尝试解析缩写的月份名称
+                                date_obj = datetime.strptime(value, "%b %Y")
+                            except ValueError:
+                                continue
+                        
+                        # 转换为 "YYYY-MM" 格式
+                        row[column["name"]] = date_obj.strftime("%Y-%m")
+                        continue
+                        
+                except Exception as e:
+                    logger.warning(f"Failed to parse temporal value '{value}': {str(e)}")
+                    continue
+
+def process_numerical_data(data: Dict) -> None:
+    """处理数值类型的数据"""
+    for column in data["data"]["columns"]:
+        if column["data_type"] == "numerical":
+            for row in data["data"]["data"]:
+                value = row.get(column["name"])
+                
+                # 处理 null 或 None
+                if value is None or value == "null" or value == "":
+                    row[column["name"]] = 0
+                    continue
+                
+                # 转换为字符串以进行处理
+                value_str = str(value)
+                
+                # 提取数字（包括负号和小数点）
+                numeric_chars = re.findall(r'-?\d*\.?\d+', value_str)
+                if numeric_chars:
+                    # 使用第一个匹配的数字
+                    try:
+                        row[column["name"]] = float(numeric_chars[0])
+                    except ValueError:
+                        row[column["name"]] = 0
+                else:
+                    row[column["name"]] = 0 
+
+def deduplicate_combinations(data: Dict) -> None:
+    """检查并去重temporal和categorical属性的组合
+    
+    Args:
+        data: 包含数据的字典，格式为 {"data": {"columns": [...], "data": [...]}}
+    """
+    # 找出所有temporal和categorical列
+    temporal_categorical_cols = [
+        col["name"] for col in data["data"]["columns"]
+        if col["data_type"] in ["temporal", "categorical"]
+    ]
+    
+    if not temporal_categorical_cols:
+        return
+    
+    # 用于存储已见过的组合
+    seen_combinations = set()
+    # 用于存储要保留的行索引
+    rows_to_keep = []
+    
+    # 检查每一行
+    for idx, row in enumerate(data["data"]["data"]):
+        # 获取当前行的temporal和categorical值组合
+        combination = tuple(str(row.get(col, "")) for col in temporal_categorical_cols)
+        
+        # 如果这个组合还没见过，就保留这行
+        if combination not in seen_combinations:
+            seen_combinations.add(combination)
+            rows_to_keep.append(idx)
+    
+    # 只保留不重复的行
+    data["data"]["data"] = [data["data"]["data"][i] for i in rows_to_keep]
+    
+    # 记录去重信息
+    removed_count = len(data["data"]["data"]) - len(rows_to_keep)
+    #if removed_count > 0:
+    #    logger.info(f"Removed {removed_count} duplicate combinations of temporal/categorical attributes") 

modules/infographics_generator/image_utils.py

@@ -0,0 +1,247 @@
+import numpy as np
+from typing import Tuple
+from .mask_utils import calculate_mask, expand_mask
+import os
+from PIL import Image
+
+def find_best_size_and_position(main_mask: np.ndarray, image_content: str, padding: int, mode: str = "side", chart_bbox: dict = None, avoid_mask: np.ndarray = None) -> Tuple[int, int, int]:
+    """
+    通过降采样加速查找最佳图片尺寸和位置
+    
+    Args:
+        main_mask: 主要内容的mask
+        image_content: base64图片内容
+        padding: 边界padding
+        mode: 放置模式，可选"side"、"background"或"overlay"
+        chart_bbox: 图表边界框，格式为{"x": x, "y": y, "width": width, "height": height}
+        avoid_mask: 需要避免重叠的区域mask
+    
+    Returns:
+        Tuple[int, int, int]: (image_size, best_x, best_y)
+    """
+    # Save the main_mask to PNG for debugging
+    os.makedirs('tmp', exist_ok=True)
+    mask_image = Image.fromarray((main_mask * 255).astype(np.uint8))
+    mask_image.save('tmp/main_mask.png')
+    
+    grid_size = 5
+    
+    # 将main_mask降采样到1/grid_size大小
+    h, w = main_mask.shape
+    downsampled_h = h // grid_size
+    downsampled_w = w // grid_size
+    downsampled_main = np.zeros((downsampled_h, downsampled_w), dtype=np.uint8)
+        
+    # 对每个grid进行降采样，只要原grid中有内容（1）就标记为1
+    for i in range(downsampled_h):
+        for j in range(downsampled_w):
+            y_start = max(0, (i - 1) * (grid_size))
+            x_start = max(0, (j - 1) * (grid_size))
+            y_end = min((i + 2) * (grid_size), h)
+            x_end = min((j + 2) * (grid_size), w)
+            grid = main_mask[y_start:y_end, x_start:x_end]
+            downsampled_main[i, j] = 1 if np.any(grid == 1) else 0
+    
+    # 如果有avoid_mask，也进行降采样
+    downsampled_avoid = None
+    if avoid_mask is not None:
+        downsampled_avoid = np.zeros((downsampled_h, downsampled_w), dtype=np.uint8)
+        for i in range(downsampled_h):
+            for j in range(downsampled_w):
+                y_start = max(0, (i - 1) * (grid_size))
+                x_start = max(0, (j - 1) * (grid_size))
+                y_end = min((i + 2) * (grid_size), h)
+                x_end = min((j + 2) * (grid_size), w)
+                grid = avoid_mask[y_start:y_end, x_start:x_end]
+                downsampled_avoid[i, j] = 1 if np.any(grid == 1) else 0
+    
+    # 调整padding到降采样尺度
+    downsampled_padding = max(1, padding // grid_size)
+    
+    # 二分查找最佳尺寸
+    min_size = max(1, 64 // grid_size)  # 最小尺寸也要降采样
+    max_size = int(min(downsampled_main.shape) * 1)
+    best_size = min_size
+    best_x = downsampled_padding
+    best_y = downsampled_padding
+    
+    if mode == "side":
+        best_overlap_ratio = float('inf')
+    elif mode == "background":
+        best_overlap_ratio = float('inf')
+    else:
+        best_overlap_ratio = 0
+        
+    overlap_threshold = 0.01
+    if mode == "side":
+        overlap_threshold = 0.01
+    elif mode == "background":
+        overlap_threshold = 0.05
+    elif mode == "overlay":
+        overlap_threshold = 0.97
+    
+    while max_size - min_size >= 2:  # 由于降采样，可以用更小的阈值
+        mid_size = (min_size + max_size) // 2
+        
+        # 生成当前尺寸的图片mask并降采样
+        original_size = mid_size * grid_size
+        temp_svg = f"""<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{original_size}" height="{original_size}">
+            <image width="{original_size}" height="{original_size}" href="{image_content}"/>
+        </svg>"""
+        image_mask = calculate_mask(temp_svg, original_size, original_size, 0, grid_size=grid_size, bg_threshold=240)
+        if mode == "background":
+            image_mask = expand_mask(image_mask, 10)
+        # Save the original image mask to PNG for debugging
+        os.makedirs('tmp', exist_ok=True)
+        mask_image = Image.fromarray((image_mask * 255).astype(np.uint8))
+        mask_image.save('tmp/image_mask.png')
+        # 将image_mask降采样
+        downsampled_image = np.zeros((mid_size, mid_size), dtype=np.uint8)
+        for i in range(mid_size):
+            for j in range(mid_size):
+                y_start = max(0, (i - 1) * (grid_size))
+                x_start = max(0, (j - 1) * (grid_size))
+                y_end = min((i + 2) * (grid_size), original_size)
+                x_end = min((j + 2) * (grid_size), original_size)
+                grid = image_mask[y_start:y_end, x_start:x_end]
+                downsampled_image[i, j] = 1 if np.any(grid == 1) else 0
+        
+        # 计算有效的搜索范围
+        if mode == "background" and chart_bbox is not None:
+            # 将chart_bbox转换到降采样尺度
+            chart_x = max(0, chart_bbox["x"] // grid_size)
+            chart_y = max(0, chart_bbox["y"] // grid_size)
+            chart_width = min(chart_bbox["width"] // grid_size, downsampled_w - chart_x)
+            chart_height = min(chart_bbox["height"] // grid_size, downsampled_h - chart_y)
+            
+            # 确保搜索范围在chart_bbox内
+            y_range = chart_height - mid_size - downsampled_padding * 2
+            x_range = chart_width - mid_size - downsampled_padding * 2
+            
+            if y_range <= 0 or x_range <= 0:
+                max_size = mid_size - 1
+                continue
+        else:
+            y_range = downsampled_h - mid_size - downsampled_padding * 2
+            x_range = downsampled_w - mid_size - downsampled_padding * 2
+            
+            if y_range <= 0 or x_range <= 0:
+                max_size = mid_size - 1
+                continue
+        
+        # 在降采样空间中寻找最佳位置
+        min_overlap = float('inf')
+        if mode == "side" or mode == "background":
+            min_overlap = float('inf')
+        elif mode == "overlay":
+            min_overlap = 0
+        current_x = downsampled_padding
+        current_y = downsampled_padding
+        min_distance = float('inf')
+        mask_center_x = np.mean(np.where(downsampled_main == 1)[1]) if np.any(downsampled_main == 1) else downsampled_w // 2
+        mask_center_y = np.mean(np.where(downsampled_main == 1)[0]) if np.any(downsampled_main == 1) else downsampled_h // 2
+
+        if mode == "background" and chart_bbox is not None:
+            y_start = chart_y + downsampled_padding
+            y_end = chart_y + chart_height - mid_size - downsampled_padding + 1
+            x_start = chart_x + downsampled_padding
+            x_end = chart_x + chart_width - mid_size - downsampled_padding + 1
+        else:
+            y_start = downsampled_padding
+            y_end = downsampled_h - mid_size - downsampled_padding + 1
+            x_start = downsampled_padding
+            x_end = downsampled_w - mid_size - downsampled_padding + 1
+        
+        for y in range(y_start, y_end):
+            for x in range(x_start, x_end):
+                region = downsampled_main[y:y + mid_size, x:x + mid_size]
+                
+                overlap = np.sum((region == 1) & (downsampled_image == 1))
+                total = np.sum(downsampled_image == 1)
+                overlap_ratio = overlap / total if total > 0 else 1.0
+                
+                # 检查与avoid_mask的重叠
+                avoid_overlap = 0
+                if downsampled_avoid is not None:
+                    avoid_region = downsampled_avoid[y:y + mid_size, x:x + mid_size]
+                    avoid_overlap = np.sum((avoid_region == 1) & (downsampled_image == 1))
+                
+                if mode == "side" or mode == "background":
+                    if mode == "background" and chart_bbox is not None:
+                        distance_to_left = x - (chart_x + downsampled_padding)
+                        distance_to_right = (chart_x + chart_width - mid_size - downsampled_padding) - x
+                        distance_to_top = y - (chart_y + downsampled_padding)
+                        distance_to_bottom = (chart_y + chart_height - mid_size - downsampled_padding) - y
+                    else:
+                        distance_to_left = x - downsampled_padding
+                        distance_to_right = downsampled_w - mid_size - downsampled_padding - x
+                        distance_to_top = y - downsampled_padding
+                        distance_to_bottom = downsampled_h - mid_size - downsampled_padding - y
+
+                    distance_to_border = min(distance_to_left, distance_to_right, distance_to_top, distance_to_bottom)
+                    if overlap_ratio < min_overlap or (overlap_ratio < overlap_threshold and distance_to_border < min_distance):
+                        min_overlap = overlap_ratio
+                        current_x = x
+                        current_y = y
+                        min_distance = distance_to_border
+                elif mode == "overlay":
+                    # 对于overlay模式，需要同时满足与main_mask的重叠足够大，且与avoid_mask没有重叠
+                    if avoid_overlap > 0:
+                        continue  # 跳过与avoid_mask有重叠的位置
+                    distance_to_center = np.sqrt(((x + mid_size / 2 - mask_center_x) ** 2 + (y + mid_size / 2 - mask_center_y) ** 2))
+                    if overlap_ratio > min_overlap or (overlap_ratio > overlap_threshold and distance_to_center < min_distance):
+                        min_overlap = overlap_ratio
+                        current_x = x
+                        current_y = y
+                        min_distance = distance_to_center
+        
+        # print(f"Trying size {mid_size * grid_size}x{mid_size * grid_size}, minimum overlap ratio: {min_overlap:.3f}")
+        
+        if mode == "side" or mode == "background":
+            if min_overlap < overlap_threshold:
+                best_size = mid_size
+                best_overlap_ratio = min_overlap
+                best_x = current_x
+                best_y = current_y
+                min_size = mid_size + 1
+            else:
+                max_size = mid_size - 1
+        elif mode == "overlay":
+            if min_overlap > overlap_threshold:
+                best_size = mid_size
+                best_overlap_ratio = min_overlap
+                best_x = current_x
+                best_y = current_y
+                min_size = mid_size + 1
+            else:
+                max_size = mid_size - 1
+
+    if best_overlap_ratio > overlap_threshold and (mode == "side" or mode == "background"):
+        return 0, 0, 0
+    if best_overlap_ratio < overlap_threshold and mode == "overlay":
+        return 0, 0, 0
+
+    final_size = best_size * grid_size
+    final_x = best_x * grid_size
+    final_y = best_y * grid_size
+    
+    '''
+    # 生成最终尺寸的图片mask
+    temp_svg = f"""<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{final_size}" height="{final_size}">
+        <image width="{final_size}" height="{final_size}" href="{image_content}"/>
+    </svg>"""
+    final_image_mask = calculate_mask(temp_svg, final_size, final_size, 0)
+    
+    # 创建合并的mask，将image_mask放在正确的位置
+    combined_mask = np.zeros_like(main_mask)
+    combined_mask[main_mask == 1] = 1
+    # 将image_mask放在正确的位置
+    combined_mask[final_y:final_y + final_size, final_x:final_x + final_size] = np.where(final_image_mask == 1, 2, combined_mask[final_y:final_y + final_size, final_x:final_x + final_size])
+    
+    # 保存合并的mask
+    combined_image = Image.fromarray((combined_mask * 127).astype(np.uint8))
+    combined_image.save('tmp/all_mask.png')
+    
+    print(f"Final result: size={final_size}x{final_size}, position=({final_x}, {final_y}), overlap ratio={best_overlap_ratio:.3f}")
+    '''
+    return final_size, final_x, final_y 

modules/infographics_generator/layout_system/__init__.py

@@ -0,0 +1,6 @@
+"""元素加载模块"""
+
+from .element_loader import load_element_from_image, ElementLoader
+
+__all__ = ["load_element_from_image", "ElementLoader"]
+

modules/infographics_generator/layout_system/constraints/__init__.py

@@ -0,0 +1,20 @@
+"""Constraint processors for layout optimization."""
+
+from .base import ConstraintProcessor
+from .relative_size import RelativeSizeProcessor
+from .padding import PaddingProcessor
+from .orientation import OrientationProcessor
+from .overlap import OverlapProcessor
+from .alignment import AlignmentProcessor
+from .gap import GapProcessor
+
+__all__ = [
+    'ConstraintProcessor',
+    'RelativeSizeProcessor',
+    'PaddingProcessor',
+    'OrientationProcessor',
+    'OverlapProcessor',
+    'AlignmentProcessor',
+    'GapProcessor',
+]
+

modules/infographics_generator/layout_system/constraints/alignment.py

@@ -0,0 +1,102 @@
+"""Alignment constraint processor."""
+
+import torch
+import torch.nn.functional as F
+from typing import List, Tuple
+from .base import ConstraintProcessor
+
+
+class AlignmentProcessor(ConstraintProcessor):
+    """Processor for alignment constraints."""
+    
+    def can_handle(self, constraint_type: str) -> bool:
+        return constraint_type == "alignment"
+    
+    def process(self, constraint: dict, bboxes: List[Tuple[float, float, float, float]], 
+                device: str = "cpu") -> torch.Tensor:
+        """Process alignment constraints.
+        
+        Args:
+            constraint: Dictionary with "alignment" key containing alignment constraint
+            bboxes: List of (x, y, w, h) bounding boxes
+            device: Device for tensors
+        
+        Returns:
+            Loss tensor
+        """
+        alignment_constraint = constraint.get("alignment", {})
+        if not alignment_constraint:
+            return torch.tensor(0.0, device=device)
+        
+        L_alignment = torch.tensor(0.0, device=device)
+        
+        direction = alignment_constraint.get("direction", "horizontal")  # "horizontal" or "vertical"
+        value = alignment_constraint.get("value", "center")  # "left", "center", "right", "top", "bottom"
+        
+        if not bboxes:
+            return L_alignment
+        
+        # Get container size (should be passed separately, but for now estimate from bboxes)
+        # Calculate bounding box of all elements
+        all_x = [x for x, _, _, _ in bboxes]
+        all_y = [y for _, y, _, _ in bboxes]
+        all_w = [w for _, _, w, _ in bboxes]
+        all_h = [h for _, _, _, h in bboxes]
+        
+        container_w = max(x + w for x, w in zip(all_x, all_w)) if all_x else 1000.0
+        container_h = max(y + h for y, h in zip(all_y, all_h)) if all_y else 1000.0
+        
+        if direction == "horizontal":
+            # Horizontal alignment: align elements along x-axis
+            if value == "left":
+                # All elements should align to left edge
+                for x, _, _, _ in bboxes:
+                    x_t = torch.tensor(x, device=device)
+                    L_alignment += x_t ** 2
+            elif value == "center":
+                # All elements should be centered horizontally
+                for x, _, w, _ in bboxes:
+                    x_t = torch.tensor(x, device=device)
+                    w_t = torch.tensor(w, device=device)
+                    center_x = x_t + 0.5 * w_t
+                    target_center = torch.tensor(container_w / 2.0, device=device)
+                    L_alignment += (center_x - target_center) ** 2
+            elif value == "right":
+                # All elements should align to right edge
+                for x, _, w, _ in bboxes:
+                    x_t = torch.tensor(x, device=device)
+                    w_t = torch.tensor(w, device=device)
+                    right_x = x_t + w_t
+                    target_right = torch.tensor(container_w, device=device)
+                    L_alignment += (right_x - target_right) ** 2
+        
+        elif direction == "vertical":
+            # Vertical alignment: align elements along y-axis
+            if value == "top":
+                # All elements should align to top edge
+                for _, y, _, _ in bboxes:
+                    y_t = torch.tensor(y, device=device)
+                    L_alignment += y_t ** 2
+            elif value == "center":
+                # All elements should be centered vertically
+                for _, y, _, h in bboxes:
+                    y_t = torch.tensor(y, device=device)
+                    h_t = torch.tensor(h, device=device)
+                    center_y = y_t + 0.5 * h_t
+                    target_center = torch.tensor(container_h / 2.0, device=device)
+                    L_alignment += (center_y - target_center) ** 2
+            elif value == "bottom":
+                # All elements should align to bottom edge
+                for _, y, _, h in bboxes:
+                    y_t = torch.tensor(y, device=device)
+                    h_t = torch.tensor(h, device=device)
+                    bottom_y = y_t + h_t
+                    target_bottom = torch.tensor(container_h, device=device)
+                    L_alignment += (bottom_y - target_bottom) ** 2
+        
+        return L_alignment
+    
+    def get_weight_key(self) -> str:
+        return "w_alignment"
+
+

modules/infographics_generator/layout_system/constraints/base.py

@@ -0,0 +1,46 @@
+"""Base class for constraint processors."""
+
+from abc import ABC, abstractmethod
+from typing import List, Tuple
+import torch
+
+
+class ConstraintProcessor(ABC):
+    """Base class for constraint processors."""
+    
+    @abstractmethod
+    def can_handle(self, constraint_type: str) -> bool:
+        """Check if this processor can handle the given constraint type.
+        
+        Args:
+            constraint_type: Type of constraint (e.g., "relative_size", "padding")
+        
+        Returns:
+            True if this processor can handle the constraint type
+        """
+        pass
+    
+    @abstractmethod
+    def process(self, constraint: dict, bboxes: List[Tuple[float, float, float, float]], 
+                device: str = "cpu") -> torch.Tensor:
+        """Process constraint and return loss tensor.
+        
+        Args:
+            constraint: Constraint dictionary from JSON
+            bboxes: List of (x, y, w, h) bounding boxes for nodes
+            device: Device to create tensors on
+        
+        Returns:
+            Loss tensor (scalar)
+        """
+        pass
+    
+    @abstractmethod
+    def get_weight_key(self) -> str:
+        """Get the weight parameter key for this constraint.
+        
+        Returns:
+            Weight key name (e.g., "w_relative_size")
+        """
+        pass
+

modules/infographics_generator/layout_system/constraints/gap.py

@@ -0,0 +1,74 @@
+"""Gap constraint processor."""
+
+import torch
+import torch.nn.functional as F
+from typing import List, Tuple
+from .base import ConstraintProcessor
+
+
+class GapProcessor(ConstraintProcessor):
+    """Processor for gap constraints."""
+    
+    def can_handle(self, constraint_type: str) -> bool:
+        return constraint_type == "gap"
+    
+    def process(self, constraint: dict, bboxes: List[Tuple[float, float, float, float]], 
+                device: str = "cpu") -> torch.Tensor:
+        """Process gap constraints.
+        
+        Args:
+            constraint: Dictionary with "gap" key containing gap constraint
+            bboxes: List of (x, y, w, h) bounding boxes
+            device: Device for tensors
+        
+        Returns:
+            Loss tensor
+        """
+        gap_constraint = constraint.get("gap", {})
+        if not gap_constraint:
+            return torch.tensor(0.0, device=device)
+        
+        L_gap = torch.tensor(0.0, device=device)
+        
+        direction = gap_constraint.get("direction", "vertical")  # "horizontal" or "vertical"
+        target_gap = gap_constraint.get("value", 0.0)  # Target gap value in pixels
+        
+        if len(bboxes) < 2:
+            return L_gap
+        
+        if direction == "vertical":
+            # Vertical gap: distance between bottom of first element and top of second element
+            # Sort by y coordinate
+            sorted_bboxes = sorted(bboxes, key=lambda b: b[1])
+            for i in range(len(sorted_bboxes) - 1):
+                _, y1, _, h1 = sorted_bboxes[i]
+                _, y2, _, _ = sorted_bboxes[i + 1]
+                
+                bottom1 = y1 + h1
+                top2 = y2
+                actual_gap = top2 - bottom1
+                
+                gap_diff = actual_gap - target_gap
+                L_gap += gap_diff ** 2
+        
+        elif direction == "horizontal":
+            # Horizontal gap: distance between right edge of first element and left edge of second element
+            # Sort by x coordinate
+            sorted_bboxes = sorted(bboxes, key=lambda b: b[0])
+            for i in range(len(sorted_bboxes) - 1):
+                x1, _, w1, _ = sorted_bboxes[i]
+                x2, _, _, _ = sorted_bboxes[i + 1]
+                
+                right1 = x1 + w1
+                left2 = x2
+                actual_gap = left2 - right1
+                
+                gap_diff = actual_gap - target_gap
+                L_gap += gap_diff ** 2
+        
+        return L_gap
+    
+    def get_weight_key(self) -> str:
+        return "w_gap"
+
+

modules/infographics_generator/layout_system/constraints/orientation.py

@@ -0,0 +1,97 @@
+"""Orientation constraint processor."""
+
+import torch
+import torch.nn.functional as F
+from typing import List, Tuple
+from .base import ConstraintProcessor
+
+
+class OrientationProcessor(ConstraintProcessor):
+    """Processor for orientation constraints."""
+    
+    def can_handle(self, constraint_type: str) -> bool:
+        return constraint_type == "orientation"
+    
+    def process(self, constraint: dict, bboxes: List[Tuple[float, float, float, float]], 
+                device: str = "cpu") -> torch.Tensor:
+        """Process orientation constraints.
+        
+        Args:
+            constraint: Dictionary with "orientation" key containing list of constraints
+            bboxes: List of (x, y, w, h) bounding boxes
+            device: Device for tensors
+        
+        Returns:
+            Loss tensor
+        """
+        orientation_constraints = constraint.get("orientation", [])
+        if not orientation_constraints:
+            return torch.tensor(0.0, device=device)
+        
+        L_orientation = torch.tensor(0.0, device=device)
+        
+        for orient_constraint in orientation_constraints:
+            src_idx = orient_constraint["source_index"]
+            tgt_idx = orient_constraint["target_index"]
+            position = orient_constraint["position"]
+            
+            if src_idx >= len(bboxes) or tgt_idx >= len(bboxes):
+                continue
+            
+            src_x, src_y, src_w, src_h = bboxes[src_idx]
+            tgt_x, tgt_y, tgt_w, tgt_h = bboxes[tgt_idx]
+            
+            # Compute centers
+            src_cx = src_x + 0.5 * src_w
+            src_cy = src_y + 0.5 * src_h
+            tgt_cx = tgt_x + 0.5 * tgt_w
+            tgt_cy = tgt_y + 0.5 * tgt_h
+            
+            # Convert to tensors
+            src_cx_t = torch.tensor(src_cx, device=device)
+            src_cy_t = torch.tensor(src_cy, device=device)
+            tgt_cx_t = torch.tensor(tgt_cx, device=device)
+            tgt_cy_t = torch.tensor(tgt_cy, device=device)
+            
+            # Divide target bbox into 3x3 grid
+            tgt_cell_w = tgt_w / 3.0
+            tgt_cell_h = tgt_h / 3.0
+            
+            # Map position string to grid coordinates (col, row)
+            position_map = {
+                "Top-Left": (0, 0),
+                "Top": (1, 0),
+                "Top-Right": (2, 0),
+                "Left": (0, 1),
+                "Center": (1, 1),
+                "Right": (2, 1),
+                "Bottom-Left": (0, 2),
+                "Bottom": (1, 2),
+                "Bottom-Right": (2, 2),
+                "left": (0, 1),
+                "right": (2, 1),
+                "top": (1, 0),
+                "bottom": (1, 2),
+            }
+            
+            if position not in position_map:
+                continue
+            
+            col, row = position_map[position]
+            
+            # Compute target region center
+            tgt_region_cx = tgt_x + (col + 0.5) * tgt_cell_w
+            tgt_region_cy = tgt_y + (row + 0.5) * tgt_cell_h
+            
+            tgt_region_cx_t = torch.tensor(tgt_region_cx, device=device)
+            tgt_region_cy_t = torch.tensor(tgt_region_cy, device=device)
+            
+            # Compute squared distance from source center to target region center
+            dist_sq = (src_cx_t - tgt_region_cx_t) ** 2 + (src_cy_t - tgt_region_cy_t) ** 2
+            L_orientation += dist_sq
+        
+        return L_orientation
+    
+    def get_weight_key(self) -> str:
+        return "w_orientation"
+

modules/infographics_generator/layout_system/constraints/overlap.py

@@ -0,0 +1,36 @@
+"""Overlap constraint processor."""
+
+import torch
+from typing import List, Tuple
+from .base import ConstraintProcessor
+
+
+class OverlapProcessor(ConstraintProcessor):
+    """Processor for overlap constraints.
+    
+    Note: Overlap is typically handled as a hard constraint in the optimization,
+    but this processor can provide additional soft penalties if needed.
+    """
+    
+    def can_handle(self, constraint_type: str) -> bool:
+        return constraint_type == "overlap"
+    
+    def process(self, constraint: dict, bboxes: List[Tuple[float, float, float, float]], 
+                device: str = "cpu") -> torch.Tensor:
+        """Process overlap constraints.
+        
+        Args:
+            constraint: Dictionary with "overlap" key
+            bboxes: List of (x, y, w, h) bounding boxes
+            device: Device for tensors
+        
+        Returns:
+            Loss tensor (typically 0, as overlap is handled as hard constraint)
+        """
+        # Overlap is handled as a hard constraint in the main optimization loop
+        # This processor can be extended to add soft penalties if needed
+        return torch.tensor(0.0, device=device)
+    
+    def get_weight_key(self) -> str:
+        return "w_overlap"
+

modules/infographics_generator/layout_system/constraints/padding.py

@@ -0,0 +1,69 @@
+"""Padding constraint processor."""
+
+import torch
+import torch.nn.functional as F
+from typing import List, Tuple
+from .base import ConstraintProcessor
+
+
+class PaddingProcessor(ConstraintProcessor):
+    """Processor for padding constraints."""
+    
+    def can_handle(self, constraint_type: str) -> bool:
+        return constraint_type == "padding"
+    
+    def process(self, constraint: dict, bboxes: List[Tuple[float, float, float, float]], 
+                device: str = "cpu") -> torch.Tensor:
+        """Process padding constraints.
+        
+        Args:
+            constraint: Dictionary with "padding" key
+            bboxes: List of (x, y, w, h) bounding boxes
+            device: Device for tensors
+        
+        Returns:
+            Loss tensor
+        """
+        padding_constraint = constraint.get("padding", {})
+        if not padding_constraint:
+            return torch.tensor(0.0, device=device)
+        
+        L_padding = torch.tensor(0.0, device=device)
+        
+        horiz = padding_constraint.get("horizontal", {})
+        vert = padding_constraint.get("vertical", {})
+        
+        pad_left = horiz.get("left", 0)
+        pad_right = horiz.get("right", 0)
+        pad_top = vert.get("top", 0)
+        pad_bottom = vert.get("bottom", 0)
+        
+        # Get container size from first bbox (assuming all bboxes are within container)
+        if not bboxes:
+            return L_padding
+        
+        # Estimate container size (this should be passed separately in real implementation)
+        # For now, assume container is large enough
+        container_w = 1000.0  # Default, should be passed as parameter
+        container_h = 1000.0  # Default, should be passed as parameter
+        
+        for x, y, w, h in bboxes:
+            x_t = torch.tensor(x, device=device)
+            y_t = torch.tensor(y, device=device)
+            w_t = torch.tensor(w, device=device)
+            h_t = torch.tensor(h, device=device)
+            
+            if pad_left > 0:
+                L_padding += F.relu(torch.tensor(pad_left, device=device) - x_t) ** 2
+            if pad_right > 0:
+                L_padding += F.relu((x_t + w_t) - (torch.tensor(container_w, device=device) - torch.tensor(pad_right, device=device))) ** 2
+            if pad_top > 0:
+                L_padding += F.relu(torch.tensor(pad_top, device=device) - y_t) ** 2
+            if pad_bottom > 0:
+                L_padding += F.relu((y_t + h_t) - (torch.tensor(container_h, device=device) - torch.tensor(pad_bottom, device=device))) ** 2
+        
+        return L_padding
+    
+    def get_weight_key(self) -> str:
+        return "w_padding"
+

modules/infographics_generator/layout_system/constraints/relative_size.py

@@ -0,0 +1,68 @@
+"""Relative size constraint processor."""
+
+import torch
+import torch.nn.functional as F
+from typing import List, Tuple
+from .base import ConstraintProcessor
+
+
+class RelativeSizeProcessor(ConstraintProcessor):
+    """Processor for relative size constraints."""
+    
+    def can_handle(self, constraint_type: str) -> bool:
+        return constraint_type == "relative_size"
+    
+    def process(self, constraint: dict, bboxes: List[Tuple[float, float, float, float]], 
+                device: str = "cpu") -> torch.Tensor:
+        """Process relative size constraints.
+        
+        Args:
+            constraint: Dictionary with "relative_size" key containing list of constraints
+            bboxes: List of (x, y, w, h) bounding boxes
+            device: Device for tensors
+        
+        Returns:
+            Loss tensor
+        """
+        relative_size_constraints = constraint.get("relative_size", [])
+        if not relative_size_constraints:
+            return torch.tensor(0.0, device=device)
+        
+        L_relative_size = torch.tensor(0.0, device=device)
+        
+        for rel_constraint in relative_size_constraints:
+            src_idx = rel_constraint["source_index"]
+            tgt_idx = rel_constraint["target_index"]
+            target_ratio = rel_constraint["ratio"]
+            
+            if src_idx >= len(bboxes) or tgt_idx >= len(bboxes):
+                continue
+            
+            _, _, w_src, h_src = bboxes[src_idx]
+            _, _, w_tgt, h_tgt = bboxes[tgt_idx]
+            
+            w_src_t = torch.tensor(w_src, device=device)
+            h_src_t = torch.tensor(h_src, device=device)
+            w_tgt_t = torch.tensor(w_tgt, device=device)
+            h_tgt_t = torch.tensor(h_tgt, device=device)
+            target_ratio_t = torch.tensor(target_ratio, device=device)
+            
+            if rel_constraint["type"] == "relative_height":
+                actual_ratio = h_src_t / (h_tgt_t + 1e-8)
+            elif rel_constraint["type"] == "relative_width":
+                actual_ratio = w_src_t / (w_tgt_t + 1e-8)
+            else:
+                continue
+            
+            # Use relative error
+            if target_ratio > 1e-6:
+                relative_error = (actual_ratio - target_ratio_t) / target_ratio_t
+                L_relative_size += relative_error ** 2
+            else:
+                L_relative_size += (actual_ratio - target_ratio_t) ** 2
+        
+        return L_relative_size
+    
+    def get_weight_key(self) -> str:
+        return "w_relative_size"
+

modules/infographics_generator/layout_system/element_loader.py

@@ -0,0 +1,196 @@
+"""
+元素加载器
+
+从RGBA格式的PNG图片加载元素，根据图片尺寸确定元素尺寸，
+并根据alpha通道生成mask
+"""
+
+import os
+import numpy as np
+from PIL import Image
+from typing import Optional, Tuple
+
+from .utils.nodes import LeafNode, NodeType
+
+
+def resize_image_with_aspect_ratio(img: Image.Image, 
+                                   target_width: int, 
+                                   target_height: int) -> Tuple[Image.Image, Tuple[int, int]]:
+    """
+    保持横纵比resize图片，最短边对齐，不添加透明padding
+    
+    例如：原始1024x1024，目标500x1000，结果500x500（保持1:1比例，最短边对齐）
+    
+    Args:
+        img: PIL图片对象（RGBA格式）
+        target_width: 目标宽度
+        target_height: 目标高度
+    
+    Returns:
+        (resized_image, actual_size): 调整后的图片和实际尺寸
+    """
+    original_width, original_height = img.size
+    original_aspect = original_width / original_height
+    print("original_aspect: ", original_aspect)
+    print("target_width: ", target_width, "target_height: ", target_height)
+    # 找到目标尺寸的较短边，以较短边为基准
+    if target_width <= target_height:
+        # 目标宽度是较短边，以宽度为准
+        new_width = target_width
+        new_height = int(original_height * (target_width / original_width))
+    else:
+        # 目标高度是较短边，以高度为准
+        new_height = target_height
+        new_width = int(original_width * (target_height / original_height))
+    
+    # 确保不超过目标尺寸（双重检查）
+    if new_width > target_width:
+        new_width = target_width
+        new_height = int(original_height * (target_width / original_width))
+    if new_height > target_height:
+        new_height = target_height
+        new_width = int(original_width * (target_height / original_height))
+    
+    print("new_width: ", new_width, "new_height: ", new_height)
+    # Resize图片（保持横纵比，不添加透明padding）
+    resized_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+    
+    return resized_img, (new_width, new_height)
+
+
+class ElementLoader:
+    """元素加载器"""
+    
+    def __init__(self, base_dir: Optional[str] = None):
+        """
+        初始化元素加载器
+        
+        Args:
+            base_dir: 图片文件的基础目录，如果提供，相对路径会基于此目录
+        """
+        self.base_dir = base_dir
+    
+    def load_from_image(self, image_path: str, node_id: str, 
+                       node_type: NodeType, 
+                       metadata: Optional[dict] = None,
+                       target_width: Optional[float] = None,
+                       target_height: Optional[float] = None) -> LeafNode:
+        """
+        从PNG图片加载元素
+        
+        Args:
+            image_path: 图片文件路径（可以是绝对路径或相对于base_dir的路径）
+            node_id: 节点ID
+            node_type: 节点类型
+            metadata: 额外的元数据
+            target_width: 目标宽度（可选，如果提供则resize图片）
+            target_height: 目标高度（可选，如果提供则resize图片）
+            
+        Returns:
+            LeafNode对象，包含图片尺寸和mask
+        """
+        # 解析路径
+        full_path = self._resolve_path(image_path)
+        
+        # 加载图片
+        img = Image.open(full_path)
+        
+        # 确保是RGBA格式
+        if img.mode != 'RGBA':
+            img = img.convert('RGBA')
+        
+        # 获取原始尺寸
+        original_width, original_height = img.size
+        
+        # 如果指定了目标尺寸，resize图片（保持横纵比，最短边对齐）
+        if target_width is not None and target_height is not None:
+            target_width = int(target_width)
+            target_height = int(target_height)
+            # 使用保持横纵比的resize函数（最短边对齐，不添加透明padding）
+            img, (width, height) = resize_image_with_aspect_ratio(
+                img, target_width, target_height
+            )
+        else:
+            width, height = original_width, original_height
+        
+        # 从alpha通道生成mask
+        # mask是二值图像，alpha > 0 的像素为1，否则为0
+        alpha_channel = np.array(img.split()[3])  # 获取alpha通道
+        mask = (alpha_channel > 0).astype(np.uint8) * 255
+        
+        # 创建元数据
+        node_metadata = metadata or {}
+        node_metadata['image_path'] = image_path
+        node_metadata['image_size'] = (width, height)
+        node_metadata['original_image_size'] = (original_width, original_height)
+        if target_width is not None and target_height is not None:
+            node_metadata['resized'] = True
+        
+        # 创建叶子节点
+        node = LeafNode(
+            node_id=node_id,
+            node_type=node_type,
+            width=float(width),
+            height=float(height),
+            mask=mask,
+            metadata=node_metadata
+        )
+        
+        return node
+    
+    def _resolve_path(self, image_path: str) -> str:
+        """解析图片路径"""
+        if os.path.isabs(image_path):
+            return image_path
+        
+        if self.base_dir:
+            return os.path.join(self.base_dir, image_path)
+        
+        return image_path
+    
+    def load_chart(self, image_path: str, node_id: str, 
+                   metadata: Optional[dict] = None) -> LeafNode:
+        """加载图表元素"""
+        return self.load_from_image(image_path, node_id, NodeType.CHART, metadata)
+    
+    def load_image(self, image_path: str, node_id: str,
+                  metadata: Optional[dict] = None) -> LeafNode:
+        """加载图像元素"""
+        return self.load_from_image(image_path, node_id, NodeType.IMAGE, metadata)
+    
+    def load_text(self, image_path: str, node_id: str,
+                 metadata: Optional[dict] = None) -> LeafNode:
+        """加载文本元素（文本渲染为图片）"""
+        return self.load_from_image(image_path, node_id, NodeType.TEXT, metadata)
+    
+    def load_shape(self, image_path: str, node_id: str,
+                  metadata: Optional[dict] = None) -> LeafNode:
+        """加载形状元素"""
+        return self.load_from_image(image_path, node_id, NodeType.SHAPE, metadata)
+
+
+def load_element_from_image(image_path: str, node_id: str, 
+                           node_type: NodeType,
+                           base_dir: Optional[str] = None,
+                           metadata: Optional[dict] = None,
+                           target_width: Optional[float] = None,
+                           target_height: Optional[float] = None) -> LeafNode:
+    """
+    便捷函数：从图片加载元素
+    
+    Args:
+        image_path: 图片文件路径
+        node_id: 节点ID
+        node_type: 节点类型
+        base_dir: 基础目录（可选）
+        metadata: 额外的元数据（可选）
+        target_width: 目标宽度（可选，如果提供则resize图片）
+        target_height: 目标高度（可选，如果提供则resize图片）
+        
+    Returns:
+        LeafNode对象
+    """
+    loader = ElementLoader(base_dir=base_dir)
+    return loader.load_from_image(image_path, node_id, node_type, metadata, 
+                                 target_width, target_height)
+

modules/infographics_generator/layout_system/handlers/__init__.py

@@ -0,0 +1,12 @@
+"""Node handlers for loading and processing different node types."""
+
+from .base import NodeHandler
+from .image_handler import ImageNodeHandler
+from .text_handler import TextNodeHandler
+
+__all__ = [
+    'NodeHandler',
+    'ImageNodeHandler',
+    'TextNodeHandler',
+]
+

modules/infographics_generator/layout_system/handlers/base.py

@@ -0,0 +1,55 @@
+"""Base class for node handlers."""
+
+from abc import ABC, abstractmethod
+from typing import Tuple, Optional
+import numpy as np
+from PIL import Image
+
+
+class NodeHandler(ABC):
+    """Base class for node handlers."""
+    
+    @abstractmethod
+    def can_handle(self, node_type: str) -> bool:
+        """Check if this handler can handle the given node type.
+        
+        Args:
+            node_type: Type of node (e.g., "image", "text", "chart")
+        
+        Returns:
+            True if this handler can handle the node type
+        """
+        pass
+    
+    @abstractmethod
+    def load(self, node: dict, base_dir: Optional[str] = None) -> Tuple[np.ndarray, dict]:
+        """Load node data and return mask and metadata.
+        
+        Args:
+            node: Node dictionary from JSON
+            base_dir: Base directory for resolving relative paths
+        
+        Returns:
+            Tuple of (mask, metadata)
+            - mask: Binary mask array (H, W) with values 0 or 1
+            - metadata: Dictionary with additional node information
+        """
+        pass
+    
+    @abstractmethod
+    def create_placeholder(self, width: float, height: float, 
+                          metadata: Optional[dict] = None) -> Tuple[Image.Image, np.ndarray]:
+        """Create placeholder image and mask for nodes without image_path.
+        
+        Args:
+            width: Placeholder width
+            height: Placeholder height
+            metadata: Optional metadata dictionary
+        
+        Returns:
+            Tuple of (image, mask)
+            - image: PIL Image (RGBA format)
+            - mask: Binary mask array (H, W)
+        """
+        pass
+

modules/infographics_generator/layout_system/handlers/image_handler.py

@@ -0,0 +1,99 @@
+"""Image node handler."""
+
+import os
+import numpy as np
+from PIL import Image
+from typing import Tuple, Optional
+from .base import NodeHandler
+from modules.infographics_generator.layout_system.utils.placeholder import create_placeholder_rectangle
+
+
+def load_binary_mask_from_rgba(png_path: str, alpha_thresh: int = 1) -> np.ndarray:
+    """Load binary mask from RGBA PNG.
+    
+    For chart images, will try to use the no_grid version if available.
+    """
+    # 如果是 chart 图片,尝试使用 no_grid 版本
+    actual_path = get_no_grid_version(png_path)
+    
+    img = Image.open(actual_path).convert("RGBA")
+    a = np.array(img, dtype=np.uint8)[..., 3]
+    mask = (a > alpha_thresh).astype(np.float32)
+    return mask
+
+
+def get_no_grid_version(image_path: str) -> str:
+    """
+    获取图片的 no_grid 版本路径,如果不存在则返回原始路径。
+    
+    用于图表(chart)图片的 mask 计算时,优先使用去掉网格线的版本,
+    这样可以更准确地计算图表的实际内容区域。
+    
+    Args:
+        image_path: 原始图片路径 (如 variation_xxx.png)
+    
+    Returns:
+        no_grid 版本路径(如果存在)或原始路径
+    """
+    if not image_path or not os.path.exists(image_path):
+        return image_path
+    
+    # 构造 no_grid 版本的路径
+    base_name, ext = os.path.splitext(image_path)
+    no_grid_path = f"{base_name}_no_grid{ext}"
+    
+    # 如果 no_grid 版本存在,返回它;否则返回原始路径
+    if os.path.exists(no_grid_path):
+        print(f"[ImageHandler] 使用 no_grid 版本进行 mask 计算: {os.path.basename(no_grid_path)}")
+        return no_grid_path
+    else:
+        return image_path
+
+
+class ImageNodeHandler(NodeHandler):
+    """Handler for image and chart nodes."""
+    
+    def can_handle(self, node_type: str) -> bool:
+        return node_type in ["image", "chart"]
+    
+    def load(self, node: dict, base_dir: Optional[str] = None) -> Tuple[np.ndarray, dict]:
+        """Load image node data.
+        
+        Args:
+            node: Node dictionary with "image_path" key
+            base_dir: Base directory for resolving relative paths
+        
+        Returns:
+            Tuple of (mask, metadata)
+        """
+        image_path = node.get("image_path")
+        if not image_path:
+            # No image_path, create placeholder from bbox
+            bbox = node.get("bbox", {})
+            width = bbox.get("width", 100)
+            height = bbox.get("height", 100)
+            _, mask = create_placeholder_rectangle(width, height)
+            return mask, {"placeholder": True, "width": width, "height": height}
+        
+        # Resolve path
+        if base_dir and not os.path.isabs(image_path):
+            full_path = os.path.join(base_dir, image_path)
+        else:
+            full_path = image_path
+        
+        # Load mask
+        mask = load_binary_mask_from_rgba(full_path)
+        
+        metadata = {
+            "image_path": image_path,
+            "full_path": full_path,
+            "shape": mask.shape,
+        }
+        
+        return mask, metadata
+    
+    def create_placeholder(self, width: float, height: float, 
+                          metadata: Optional[dict] = None) -> Tuple[Image.Image, np.ndarray]:
+        """Create placeholder for image node."""
+        return create_placeholder_rectangle(width, height)
+

modules/infographics_generator/layout_system/handlers/text_handler.py

@@ -0,0 +1,77 @@
+"""Text node handler."""
+
+import os
+import numpy as np
+from PIL import Image
+from typing import Tuple, Optional
+from .base import NodeHandler
+from modules.infographics_generator.layout_system.utils.placeholder import create_placeholder_rectangle
+
+
+def load_binary_mask_from_rgba(png_path: str, alpha_thresh: int = 1) -> np.ndarray:
+    """Load binary mask from RGBA PNG."""
+    img = Image.open(png_path).convert("RGBA")
+    a = np.array(img, dtype=np.uint8)[..., 3]
+    mask = (a > alpha_thresh).astype(np.float32)
+    return mask
+
+
+class TextNodeHandler(NodeHandler):
+    """Handler for text nodes."""
+    
+    def can_handle(self, node_type: str) -> bool:
+        return node_type == "text"
+    
+    def load(self, node: dict, base_dir: Optional[str] = None) -> Tuple[np.ndarray, dict]:
+        """Load text node data.
+        
+        Args:
+            node: Node dictionary with bbox and optionally image_path
+            base_dir: Base directory for resolving image paths
+        
+        Returns:
+            Tuple of (mask, metadata)
+        """
+        # Check if text node has image_path (e.g., rendered text image)
+        image_path = node.get("image_path")
+        if image_path:
+            # Resolve full path
+            if base_dir:
+                full_path = os.path.join(base_dir, image_path)
+            else:
+                full_path = image_path
+            
+            # Load actual mask from image if file exists
+            if os.path.exists(full_path):
+                mask = load_binary_mask_from_rgba(full_path)
+                metadata = {
+                    "image_path": image_path,
+                    "placeholder": False,
+                    "content": node.get("content", ""),
+                    "type": "text",
+                }
+                return mask, metadata
+        
+        # Fallback: use bbox to create placeholder
+        bbox = node.get("bbox", {})
+        width = bbox.get("width", 100)
+        height = bbox.get("height", 100)
+        
+        # Create placeholder rectangle
+        _, mask = create_placeholder_rectangle(width, height)
+        
+        metadata = {
+            "placeholder": True,
+            "width": width,
+            "height": height,
+            "content": node.get("content", ""),
+            "type": "text",
+        }
+        
+        return mask, metadata
+    
+    def create_placeholder(self, width: float, height: float, 
+                          metadata: Optional[dict] = None) -> Tuple[Image.Image, np.ndarray]:
+        """Create placeholder for text node."""
+        return create_placeholder_rectangle(width, height)
+

modules/infographics_generator/layout_system/hierarchical_optimizer.py

@@ -0,0 +1,640 @@
+"""Hierarchical layout optimizer with extensible architecture."""
+
+from typing import Dict, List, Optional, Tuple, Any
+import numpy as np
+from dataclasses import dataclass, field
+from . import parameters as params
+from .constraints import (
+    ConstraintProcessor,
+    RelativeSizeProcessor,
+    PaddingProcessor,
+    OrientationProcessor,
+    OverlapProcessor,
+    AlignmentProcessor,
+    GapProcessor,
+)
+from .handlers import (
+    NodeHandler,
+    ImageNodeHandler,
+    TextNodeHandler,
+)
+from .strategies import OptimizationStrategy, SDFOptimizationStrategy, RuleBasedLayoutStrategy
+from .utils.parser import parse_layout_tree, LayoutNode
+from .utils.composite import composite_nodes
+from .utils.placeholder import create_placeholder_rectangle, create_placeholder_rounded_rectangle
+
+
+@dataclass
+class OptimizationConfig:
+    """Optimization configuration."""
+    strategy: OptimizationStrategy = field(default_factory=SDFOptimizationStrategy)
+    constraint_processors: Dict[str, ConstraintProcessor] = field(default_factory=dict)
+    node_handlers: Dict[str, NodeHandler] = field(default_factory=dict)
+    weights: Dict[str, float] = field(default_factory=dict)
+    optimization_params: Dict[str, Any] = field(default_factory=dict)
+    placeholder_config: Dict[str, Any] = field(default_factory=dict)
+    base_dir: Optional[str] = None
+    device: Optional[str] = None
+    debug: bool = False  # Enable debug mode: visualization and detailed logging
+    use_rule_based: bool = True  # Enable rule-based layout for row/column nodes (faster)
+    rule_based_types: List[str] = field(default_factory=lambda: ['row', 'column'])  # Types that use rule-based layout
+    
+    def __post_init__(self):
+        """Initialize default values."""
+        if not self.constraint_processors:
+            self.constraint_processors = {
+                "relative_size": RelativeSizeProcessor(),
+                "padding": PaddingProcessor(),
+                "orientation": OrientationProcessor(),
+                "overlap": OverlapProcessor(),
+                "gap": GapProcessor(),
+            }
+        
+        if not self.node_handlers:
+            self.node_handlers = {
+                "image": ImageNodeHandler(),
+                "chart": ImageNodeHandler(),
+                "text": TextNodeHandler(),
+            }
+        
+        if not self.weights:
+            self.weights = {
+                "w_similarity": params.W_SIMILARITY,
+                "w_readability": params.W_READABILITY,
+                "w_alignment_consistency": params.W_ALIGNMENT_CONSISTENCY,
+                "w_alignment_similarity": params.W_ALIGNMENT_SIMILARITY,
+                "w_proximity": params.W_PROXIMITY,
+            }
+        
+        if not self.optimization_params:
+            self.optimization_params = {
+                "opt_res_list": params.OPT_RES_LIST,
+                "outer_rounds": params.OUTER_ROUNDS,
+                "inner_steps": params.INNER_STEPS,
+                "lr": params.LEARNING_RATE,
+            }
+
+
+class HierarchicalOptimizer:
+    """Hierarchical layout optimizer with extensible architecture."""
+    
+    def __init__(self, config: Optional[OptimizationConfig] = None):
+        """Initialize optimizer.
+        
+        Args:
+            config: Optimization configuration (uses default if None)
+        """
+        self.config = config or OptimizationConfig()
+        self._register_default_processors()
+        self._register_default_handlers()
+    
+    def _register_default_processors(self):
+        """Register default constraint processors."""
+        if not self.config.constraint_processors:
+            self.config.constraint_processors = {
+                "relative_size": RelativeSizeProcessor(),
+                "padding": PaddingProcessor(),
+                "orientation": OrientationProcessor(),
+                "overlap": OverlapProcessor(),
+            }
+    
+    def _register_default_handlers(self):
+        """Register default node handlers."""
+        if not self.config.node_handlers:
+            self.config.node_handlers = {
+                "image": ImageNodeHandler(),
+                "chart": ImageNodeHandler(),
+                "text": TextNodeHandler(),
+            }
+    
+    def register_processor(self, processor: ConstraintProcessor):
+        """Register a custom constraint processor.
+        
+        Args:
+            processor: Constraint processor instance
+        """
+        # Register for all constraint types it can handle
+        for constraint_type in ["relative_size", "padding", "orientation", "overlap", "gap", "alignment"]:
+            if processor.can_handle(constraint_type):
+                self.config.constraint_processors[constraint_type] = processor
+    
+    def register_handler(self, handler: NodeHandler):
+        """Register a custom node handler.
+        
+        Args:
+            handler: Node handler instance
+        """
+        # Register for all node types it can handle
+        for node_type in ["image", "chart", "text", "shape", "layer", "column", "row"]:
+            if handler.can_handle(node_type):
+                self.config.node_handlers[node_type] = handler
+    
+    def set_strategy(self, strategy: OptimizationStrategy):
+        """Set optimization strategy.
+        
+        Args:
+            strategy: Optimization strategy instance
+        """
+        self.config.strategy = strategy
+    
+    def optimize_tree(self, tree_json: dict) -> Dict[str, Any]:
+        """Optimize entire tree structure.
+        
+        Args:
+            tree_json: JSON dictionary with layout tree structure
+        
+        Returns:
+            Dictionary with optimization results for each node
+        """
+        # Parse tree
+        root_node = parse_layout_tree(tree_json)
+        # print("Root node: ", root_node)
+        
+        # Get container bbox from root
+        root_bbox = (
+            root_node.bbox.get("x", 0),
+            root_node.bbox.get("y", 0),
+            root_node.bbox.get("width", 1000),
+            root_node.bbox.get("height", 1000),
+        )
+        
+        # Optimize recursively from bottom up
+        result = self._optimize_node(root_node, root_bbox, "root")
+        
+        return result
+    
+    def _optimize_node(self, node: LayoutNode, parent_bbox: Tuple[float, float, float, float], 
+                       node_path: str = "root") -> Dict[str, Any]:
+        """Optimize a single node and its children recursively.
+        
+        Args:
+            node: Layout node to optimize
+            parent_bbox: Parent container bounding box (x, y, w, h)
+            node_path: Path string for this node (e.g., "root.child0.child1")
+        
+        Returns:
+            Dictionary with optimization results
+        """
+        result = {
+            "type": node.type,
+            "bbox": node.bbox,
+            "final_bbox": None,
+            "image_path": getattr(node, "image_path", None),  # Preserve image_path for saving
+        }
+        
+        # Check if node is a container (has children)
+        if node.children:
+            # Check if we can use rule-based layout (much faster for row/column)
+            if self._can_use_rule_based_layout(node):
+                return self._rule_based_layout(node, parent_bbox, node_path)
+            
+            # Container node: optimize children using SDF optimization
+            # print(f"[HierarchicalOptimizer] Processing container node: type={node.type}, num_children={len(node.children)}, path={node_path}")
+            child_results = []
+            child_nodes_data = []
+            
+            # First, recursively optimize all children
+            for i, child in enumerate(node.children):
+                child_path = f"{node_path}.child{i}"
+                child_result = self._optimize_node(child, parent_bbox, child_path)
+                child_results.append(child_result)
+            
+            # Load child node data (masks, etc.)
+            # Use final_bbox from child_result if available (for container nodes that have been optimized),
+            # otherwise use initial bbox
+            for i, child in enumerate(node.children):
+                child_result = child_results[i]
+                # Get bbox: use final_bbox from child_result if child is a container that has been optimized
+                if child_result.get("final_bbox") is not None:
+                    # Convert final_bbox tuple to dict format for consistency
+                    final_bbox = child_result["final_bbox"]
+                    if isinstance(final_bbox, (tuple, list)) and len(final_bbox) >= 4:
+                        child_bbox = {
+                            "x": final_bbox[0],
+                            "y": final_bbox[1],
+                            "width": final_bbox[2],
+                            "height": final_bbox[3]
+                        }
+                    else:
+                        child_bbox = child.bbox
+                else:
+                    child_bbox = child.bbox
+                
+                # Check if child has composite_mask (from previous optimization)
+                # Use composite_mask if available, as it represents the actual shape
+                mask = None
+                metadata = {}
+                if child_result.get("composite_mask") is not None:
+                    mask = child_result["composite_mask"]
+                    # print(f"[HierarchicalOptimizer] Using composite_mask for child {i} (type={child.type})")
+                else:
+                    handler = self._get_handler(child.type)
+                    if handler:
+                        mask, metadata = handler.load(child.__dict__, self.config.base_dir)
+                    else:
+                        # Fallback: use placeholder
+                        bbox = child_bbox
+                        width = bbox.get("width", 100) if isinstance(bbox, dict) else (bbox[2] if isinstance(bbox, (tuple, list)) else 100)
+                        height = bbox.get("height", 100) if isinstance(bbox, dict) else (bbox[3] if isinstance(bbox, (tuple, list)) else 100)
+                        # For container nodes (layer/column/row), create a rounded rectangle instead of solid rectangle
+                        if child.type in ["layer", "column", "row"]:
+                            try:
+                                _, mask = create_placeholder_rounded_rectangle(width, height)
+                            except Exception:
+                                # Fallback to rectangle if rounded rectangle is unavailable
+                                _, mask = create_placeholder_rectangle(width, height)
+                        else:
+                            _, mask = create_placeholder_rectangle(width, height)
+                        metadata = {"placeholder": True}
+                
+                child_nodes_data.append({
+                    "mask": mask,
+                    "bbox": child_bbox,
+                    "metadata": metadata,
+                    "type": child.type,
+                })
+            
+            # Get container bbox (use node's bbox or parent's)
+            container_bbox = (
+                node.bbox.get("x", 0),
+                node.bbox.get("y", 0),
+                node.bbox.get("width", parent_bbox[2]),
+                node.bbox.get("height", parent_bbox[3]),
+            )
+            
+            # Optimize children layout
+            constraints = node.constraints or {}
+            
+            # Generate unique save prefix for this node using node path
+            # Replace dots and special characters to make valid filename
+            save_prefix = node_path.replace(".", "_").replace(" ", "_")
+            
+            # Extract grandchildren info for proximity ratio calculation
+            # For each child, collect its children's bboxes (grandchildren of current container)
+            grandchildren_list = []
+            for child_result in child_results:
+                grandchildren = []
+                # Check if child_result has children (from recursive optimization)
+                child_children = child_result.get("children", [])
+                for grandchild_result in child_children:
+                    grandchild_bbox = grandchild_result.get("final_bbox")
+                    if grandchild_bbox:
+                        if isinstance(grandchild_bbox, (tuple, list)) and len(grandchild_bbox) >= 4:
+                            grandchildren.append(tuple(grandchild_bbox[:4]))
+                        elif isinstance(grandchild_bbox, dict):
+                            grandchildren.append((
+                                grandchild_bbox.get("x", 0),
+                                grandchild_bbox.get("y", 0),
+                                grandchild_bbox.get("width", grandchild_bbox.get("w", 0)),
+                                grandchild_bbox.get("height", grandchild_bbox.get("h", 0))
+                            ))
+                grandchildren_list.append(grandchildren)
+            
+            config = {
+                **self.config.optimization_params,
+                "device": self.config.device,
+                "debug": self.config.debug,  # Pass debug flag
+                "w_similarity": self.config.weights.get("w_similarity", 1.0),
+                "w_readability": self.config.weights.get("w_readability", 1.0),
+                "w_alignment_consistency": self.config.weights.get("w_alignment_consistency", 1.0),
+                "w_alignment_similarity": self.config.weights.get("w_alignment_similarity", params.W_ALIGNMENT_SIMILARITY),
+                "w_proximity": self.config.weights.get("w_proximity", params.W_PROXIMITY),
+                "container_type": node.type,  # Pass container type (column, row, or layer)
+                "grandchildren_list": grandchildren_list,  # Pass grandchildren for proximity calculation
+            }
+            
+            # print(f"[HierarchicalOptimizer] Calling strategy.optimize for container_type={node.type}, num_children={len(child_nodes_data)}")
+            # print("child_nodes_data:", child_nodes_data)
+            # print("config:", config)
+            optimized_bboxes = self.config.strategy.optimize(
+                child_nodes_data,
+                container_bbox,
+                constraints,
+                config,
+                save_prefix=save_prefix,
+            )
+            
+            # print(f"[HierarchicalOptimizer] Strategy returned optimized_bboxes: {optimized_bboxes}")
+            # Calculate actual container bbox based on children's layout results
+            # Note: optimized_bboxes are relative to container origin (0,0)
+            if optimized_bboxes:
+                # Convert bbox to tuple format if needed (handle both dict and tuple formats)
+                def bbox_to_tuple(bbox):
+                    if isinstance(bbox, dict):
+                        return (
+                            bbox.get("x", 0),
+                            bbox.get("y", 0),
+                            bbox.get("width", bbox.get("w", 0)),
+                            bbox.get("height", bbox.get("h", 0))
+                        )
+                    elif isinstance(bbox, (tuple, list)) and len(bbox) >= 4:
+                        return tuple(bbox[:4])
+                    else:
+                        return (0, 0, 0, 0)
+                
+                bbox_tuples = [bbox_to_tuple(bbox) for bbox in optimized_bboxes]
+                
+                # print("bbox_tuples:", bbox_tuples)
+                # Find the bounding box that contains all children (for position adjustment)
+                min_x = min(bbox[0] for bbox in bbox_tuples)
+                min_y = min(bbox[1] for bbox in bbox_tuples)
+                
+                # Adjust children's bboxes: shift them so that min_x and min_y become 0
+                # This makes children relative to the new container origin (0,0)
+                # For container nodes, preserve their own calculated width/height
+                adjusted_bboxes_for_composite = []
+                for i, (child_result, opt_bbox) in enumerate(zip(child_results, optimized_bboxes)):
+                    bbox_tuple = bbox_to_tuple(opt_bbox)
+                    # Adjust coordinates: subtract min_x and min_y to start from (0,0)
+                    adjusted_x = bbox_tuple[0] - min_x
+                    adjusted_y = bbox_tuple[1] - min_y
+                    
+                    # For container nodes, preserve the width/height calculated from their children
+                    # Only update position (x, y), not size (w, h)
+                    if child_result.get("children") and child_result.get("final_bbox"):
+                        # Child is a container with its own final_bbox calculated from its children
+                        child_final = child_result["final_bbox"]
+                        if isinstance(child_final, (tuple, list)) and len(child_final) >= 4:
+                            # Use the child's own calculated width and height
+                            adjusted_bbox = (
+                                adjusted_x,
+                                adjusted_y,
+                                child_final[2],  # Keep child's calculated width
+                                child_final[3]   # Keep child's calculated height
+                            )
+                        else:
+                            adjusted_bbox = (adjusted_x, adjusted_y, bbox_tuple[2], bbox_tuple[3])
+                    else:
+                        # Leaf node or no children: use optimized bbox size
+                        adjusted_bbox = (adjusted_x, adjusted_y, bbox_tuple[2], bbox_tuple[3])
+                    
+                    adjusted_bboxes_for_composite.append(adjusted_bbox)
+                    
+                    # Store relative coordinates (relative to parent container) in final_bbox
+                    # save_result.py will convert to absolute coordinates by adding parent offsets
+                    child_result["final_bbox"] = adjusted_bbox
+                    if i < len(node.children):
+                        node.children[i].final_bbox = adjusted_bbox
+                        # print(f"node.children[{i}].final_bbox:", node.children[i].final_bbox)
+                
+                # Calculate actual container size based on adjusted bboxes
+                # This ensures the container size is based on children's preserved widths/heights
+                actual_max_x = max(bbox[0] + bbox[2] for bbox in adjusted_bboxes_for_composite)
+                actual_max_y = max(bbox[1] + bbox[3] for bbox in adjusted_bboxes_for_composite)
+                actual_width = actual_max_x
+                actual_height = actual_max_y
+                # print(f"actual_container_size: width={actual_width:.2f}, height={actual_height:.2f}")
+                
+                # Container position: keep original container position
+                # Container size: actual size needed to contain all children
+                # Children are now adjusted to start from (0,0) relative to container
+                actual_container_bbox = (
+                    container_bbox[0],  # Keep original x position
+                    container_bbox[1],  # Keep original y position
+                    actual_width,       # Actual width needed
+                    actual_height       # Actual height needed
+                )
+            else:
+                # Fallback to original container bbox if no children
+                actual_container_bbox = container_bbox
+                adjusted_bboxes_for_composite = optimized_bboxes
+                # Update child results with optimized bboxes (no adjustment needed)
+                for i, (child_result, opt_bbox) in enumerate(zip(child_results, optimized_bboxes)):
+                    child_result["final_bbox"] = opt_bbox
+                    if i < len(node.children):
+                        node.children[i].final_bbox = opt_bbox
+            
+            # Composite children results (use actual container bbox and adjusted bboxes)
+            composite_mask, composite_sdf = self.config.strategy.composite(
+                child_nodes_data,
+                adjusted_bboxes_for_composite,
+                actual_container_bbox,
+            )
+            
+            result["final_bbox"] = actual_container_bbox
+            result["composite_mask"] = composite_mask
+            result["composite_sdf"] = composite_sdf
+            result["children"] = child_results
+            
+        else:
+            # Leaf node: just load data
+            handler = self._get_handler(node.type)
+            if handler:
+                mask, metadata = handler.load(node.__dict__, self.config.base_dir)
+                result["mask"] = mask
+                result["metadata"] = metadata
+                result["final_bbox"] = (
+                    node.bbox.get("x", 0),
+                    node.bbox.get("y", 0),
+                    node.bbox.get("width", 100),
+                    node.bbox.get("height", 100),
+                )
+        
+        return result
+    
+    def _get_handler(self, node_type: str) -> Optional[NodeHandler]:
+        """Get handler for node type.
+        
+        Args:
+            node_type: Type of node
+        
+        Returns:
+            Node handler or None
+        """
+        return self.config.node_handlers.get(node_type)
+    
+    def _can_use_rule_based_layout(self, node: LayoutNode) -> bool:
+        """Check if node can use rule-based layout instead of SDF optimization.
+        
+        Rule-based layout is much faster and more accurate for simple row/column layouts.
+        
+        Args:
+            node: Layout node to check
+        
+        Returns:
+            True if rule-based layout can be used
+        """
+        # Check if rule-based is enabled
+        if not self.config.use_rule_based:
+            return False
+        
+        # Check if node type is in the allowed list
+        if node.type not in self.config.rule_based_types:
+            return False
+        
+        # Need at least 2 children to benefit from rule-based layout
+        if not node.children or len(node.children) < 2:
+            return False
+        
+        # Check for complex overlap constraints that require SDF
+        constraints = node.constraints or {}
+        if 'overlap' in constraints:
+            # Overlap constraints need precise collision detection - use SDF
+            return False
+        
+        return True
+    
+    def _rule_based_layout(self, node: LayoutNode, parent_bbox: Tuple[float, float, float, float],
+                          node_path: str) -> Dict[str, Any]:
+        """Execute rule-based layout for simple row/column arrangements.
+        
+        Args:
+            node: Layout node to optimize
+            parent_bbox: Parent container bounding box (x, y, w, h)
+            node_path: Path string for this node
+        
+        Returns:
+            Dictionary with optimization results
+        """
+        # print(f"[HierarchicalOptimizer] Using rule-based layout for {node.type} node: {node_path}")
+        
+        result = {
+            "type": node.type,
+            "bbox": node.bbox,
+            "final_bbox": None,
+            "image_path": getattr(node, "image_path", None),
+        }
+        
+        # First, recursively optimize all children
+        child_results = []
+        for i, child in enumerate(node.children):
+            child_path = f"{node_path}.child{i}"
+            child_result = self._optimize_node(child, parent_bbox, child_path)
+            child_results.append(child_result)
+        
+        # Load child node data
+        child_nodes_data = []
+        for i, child in enumerate(node.children):
+            child_result = child_results[i]
+            
+            # Get bbox from child result
+            if child_result.get("final_bbox") is not None:
+                final_bbox = child_result["final_bbox"]
+                if isinstance(final_bbox, (tuple, list)) and len(final_bbox) >= 4:
+                    child_bbox = {
+                        "x": final_bbox[0],
+                        "y": final_bbox[1],
+                        "width": final_bbox[2],
+                        "height": final_bbox[3]
+                    }
+                else:
+                    child_bbox = child.bbox
+            else:
+                child_bbox = child.bbox
+            
+            # Get mask
+            mask = None
+            metadata = {}
+            if child_result.get("composite_mask") is not None:
+                mask = child_result["composite_mask"]
+            else:
+                handler = self._get_handler(child.type)
+                if handler:
+                    mask, metadata = handler.load(child.__dict__, self.config.base_dir)
+                else:
+                    # Fallback placeholder
+                    bbox = child_bbox
+                    width = bbox.get("width", 100) if isinstance(bbox, dict) else bbox[2]
+                    height = bbox.get("height", 100) if isinstance(bbox, dict) else bbox[3]
+                    if child.type in ["layer", "column", "row"]:
+                        _, mask = create_placeholder_rounded_rectangle(width, height)
+                    else:
+                        _, mask = create_placeholder_rectangle(width, height)
+                    metadata = {"placeholder": True}
+            
+            child_nodes_data.append({
+                "mask": mask,
+                "bbox": child_bbox,
+                "metadata": metadata,
+                "type": child.type,
+            })
+        
+        # Get container bbox
+        container_bbox = (
+            node.bbox.get("x", 0),
+            node.bbox.get("y", 0),
+            node.bbox.get("width", parent_bbox[2]),
+            node.bbox.get("height", parent_bbox[3]),
+        )
+        
+        # Use rule-based strategy
+        from .strategies import RuleBasedLayoutStrategy
+        rule_strategy = RuleBasedLayoutStrategy()
+        
+        constraints = node.constraints or {}
+        config = {
+            "container_type": node.type,
+        }
+        
+        # Calculate optimized bboxes using rule-based layout
+        optimized_bboxes = rule_strategy.optimize(
+            child_nodes_data,
+            container_bbox,
+            constraints,
+            config,
+        )
+        
+        # Adjust bboxes to start from (0, 0) relative to container
+        if optimized_bboxes:
+            min_x = min(bbox[0] for bbox in optimized_bboxes)
+            min_y = min(bbox[1] for bbox in optimized_bboxes)
+            
+            adjusted_bboxes_for_composite = []
+            for i, (child_result, opt_bbox) in enumerate(zip(child_results, optimized_bboxes)):
+                adjusted_x = opt_bbox[0] - min_x
+                adjusted_y = opt_bbox[1] - min_y
+                
+                # For container nodes, preserve their calculated size
+                if child_result.get("children") and child_result.get("final_bbox"):
+                    child_final = child_result["final_bbox"]
+                    if isinstance(child_final, (tuple, list)) and len(child_final) >= 4:
+                        adjusted_bbox = (
+                            adjusted_x,
+                            adjusted_y,
+                            child_final[2],  # Keep child's calculated width
+                            child_final[3]   # Keep child's calculated height
+                        )
+                    else:
+                        adjusted_bbox = (adjusted_x, adjusted_y, opt_bbox[2], opt_bbox[3])
+                else:
+                    adjusted_bbox = (adjusted_x, adjusted_y, opt_bbox[2], opt_bbox[3])
+                
+                adjusted_bboxes_for_composite.append(adjusted_bbox)
+                child_result["final_bbox"] = adjusted_bbox
+                if i < len(node.children):
+                    node.children[i].final_bbox = adjusted_bbox
+            
+            # Calculate actual container size
+            actual_max_x = max(bbox[0] + bbox[2] for bbox in adjusted_bboxes_for_composite)
+            actual_max_y = max(bbox[1] + bbox[3] for bbox in adjusted_bboxes_for_composite)
+            actual_width = actual_max_x
+            actual_height = actual_max_y
+            
+            actual_container_bbox = (
+                container_bbox[0],
+                container_bbox[1],
+                actual_width,
+                actual_height
+            )
+        else:
+            actual_container_bbox = container_bbox
+            adjusted_bboxes_for_composite = optimized_bboxes
+            for i, (child_result, opt_bbox) in enumerate(zip(child_results, optimized_bboxes)):
+                child_result["final_bbox"] = opt_bbox
+                if i < len(node.children):
+                    node.children[i].final_bbox = opt_bbox
+        
+        # Composite children results
+        composite_mask, composite_sdf = rule_strategy.composite(
+            child_nodes_data,
+            adjusted_bboxes_for_composite,
+            actual_container_bbox,
+        )
+        
+        result["final_bbox"] = actual_container_bbox
+        result["composite_mask"] = composite_mask
+        result["composite_sdf"] = composite_sdf
+        result["children"] = child_results
+        
+        return result
+

modules/infographics_generator/layout_system/parameters.py

@@ -0,0 +1,45 @@
+"""Global parameters for layout optimization."""
+
+# Optimization resolution stages
+OPT_RES_LIST = (1000,)  # Reduced from (256, 512, 1000) for faster optimization
+
+# Augmented Lagrangian parameters
+OUTER_ROUNDS = 8   # augmented-lagrangian outer updates per stage (reduced from 5 for faster convergence)
+INNER_STEPS = 30  # gradient steps per outer round (reduced from 50 for faster convergence)
+RHO_INIT = 1e-4    # initial penalty parameter for constraint enforcement
+RHO_MULT = 5.0     # multiplier for penalty parameter
+
+# Optimizer parameters
+LEARNING_RATE = 0.02
+SIZE_MIN = 20.0    # minimum element size in pixels
+
+# Penalty weights
+PEN_WEIGHT = 1000.0   # weight for penetration penalty
+PEN_ETA_PX = 1.0   # eta parameter for penetration penalty
+
+# Loss weights
+W_SIMILARITY = 0   # weight for position/size similarity loss
+W_READABILITY = 0  # weight for readability loss (size hierarchy)
+W_ALIGNMENT_CONSISTENCY = 10000.0  # weight for alignment consistency loss (hierarchical alignment)
+W_ALIGNMENT_SIMILARITY = 0  # weight for alignment similarity loss (based on JSON constraint)
+W_DATA_INK = 10  # weight for data ink loss (maximize union area, minimize white space)
+W_VISUAL_BALANCE = 0.0  # weight for visual balance loss (centroid to center distance)
+
+# Tau schedule for soft mask (controls boundary sharpness)
+TAU_SCHEDULE = (2.0, 1.5, 1.2, 1.0, 0.8, 0.6, 0.5, 0.4, 0.35, 0.3, 0.25, 0.2)
+
+# Pictogram dilation radius
+PICTOGRAM_DILATION_RADIUS = 5.0  # pixels
+
+# Readability threshold
+SIZE_RATIO_THRESHOLD = 1.5  # minimum ratio to consider size difference significant
+# Rules: if ratio >= 1.5 or ratio <= 1/1.5 (0.67), the size difference is significant
+
+# Min size constraints (default values)
+MIN_WIDTH_DEFAULT = 30.0
+MIN_HEIGHT_DEFAULT = 30.0
+
+# Proximity ratio loss parameters
+W_PROXIMITY = 0  # Weight for proximity ratio loss (default disabled, can be enabled when needed)
+PROXIMITY_EPSILON = 1e-6  # Small value to avoid division by zero
+

modules/infographics_generator/layout_system/sdf/__init__.py

@@ -0,0 +1,10 @@
+"""SDF-based layout optimization module.
+
+This module provides SDF (Signed Distance Field) based optimization
+for layout arrangement.
+"""
+
+from .optimizer import optimize
+
+__all__ = ["optimize"]
+

modules/infographics_generator/layout_system/sdf/bbox.py

@@ -0,0 +1,156 @@
+"""BBox parameterization functions for optimization."""
+
+import numpy as np
+import torch
+
+
+def bbox_aspect_from_unconstrained(tx, ty, ts, W, H, r, min_width=None, min_height=None, size_min=None):
+    """Convert unconstrained parameters to bbox with fixed aspect ratio.
+    
+    This function maps unconstrained optimization parameters (tx, ty, ts) to
+    a valid bounding box that:
+    - Maintains the aspect ratio r = w/h
+    - Stays within the container bounds (W, H)
+    - Respects minimum size constraints
+    
+    Args:
+        tx, ty, ts: Unconstrained parameters (will be mapped via sigmoid)
+        W, H: Container width and height
+        r: Aspect ratio (w/h)
+        min_width: Minimum width constraint (if None, uses size_min or default)
+        min_height: Minimum height constraint (if None, uses size_min or default)
+        size_min: Legacy parameter for backward compatibility (maps to both min_width and min_height)
+    
+    Returns:
+        (x, y, w, h) bounding box
+    """
+    # Backward compatibility: if size_min is provided, use it for both
+    if size_min is not None:
+        if min_width is None:
+            min_width = size_min
+        if min_height is None:
+            min_height = size_min
+    
+    # Use defaults if not provided
+    if min_width is None:
+        min_width = 30.0  # Default from parameters
+    if min_height is None:
+        min_height = 30.0  # Default from parameters
+    
+    # w must satisfy w<=W and h=w/r<=H => w <= rH
+    wmax = min(float(W), float(r) * float(H))
+
+    # Enforce constraints:
+    # w >= min_width
+    # h = w/r >= min_height => w >= r * min_height
+    # Combined: w >= max(min_width, r * min_height)
+    wmin = max(float(min_width), float(r) * float(min_height))
+    if wmin >= wmax:
+        # infeasible min size; fall back
+        wmin = max(1.0, 0.5 * wmax)
+
+    w = wmin + (wmax - wmin) * torch.sigmoid(ts)
+    h = w / r
+
+    x = (W - w) * torch.sigmoid(tx)
+    y = (H - h) * torch.sigmoid(ty)
+    return x, y, w, h
+
+
+def unconstrained_from_bbox(x, y, w, h, W, H, r, min_width=None, min_height=None, size_min=None):
+    """Convert bbox to unconstrained parameters (inverse of bbox_aspect_from_unconstrained).
+    
+    This function is used to initialize optimization parameters from a reference bbox.
+    It adjusts the bbox to match the material's aspect ratio while keeping the area
+    approximately constant.
+    
+    Args:
+        x, y, w, h: Bounding box (x, y, w, h)
+        W, H: Container width and height
+        r: Aspect ratio (w/h) - material's aspect ratio (used to adjust w/h)
+        min_width: Minimum width constraint
+        min_height: Minimum height constraint
+        size_min: Legacy parameter for backward compatibility
+    
+    Returns:
+        (tx, ty, ts) unconstrained parameters
+    """
+    # Backward compatibility: if size_min is provided, use it for both
+    if size_min is not None:
+        if min_width is None:
+            min_width = size_min
+        if min_height is None:
+            min_height = size_min
+    
+    # Use defaults if not provided
+    if min_width is None:
+        min_width = 30.0
+    if min_height is None:
+        min_height = 30.0
+    
+    # Adjust w and h to match material's aspect ratio r
+    # If JSON bbox has aspect ratio r_json = w/h, but material has r = w_material/h_material
+    # We need to adjust: use material's aspect ratio, keep area approximately constant
+    r_json = w / h if h > 0 else 1.0
+    
+    if abs(r_json - r) > 1e-6:
+        # Aspect ratios don't match, adjust to material's aspect ratio
+        # Strategy: keep area approximately constant, adjust to match r
+        area = w * h
+        if r > 0:
+            # w_new * h_new = area, w_new / h_new = r => h_new^2 * r = area => h_new = sqrt(area/r)
+            h_adjusted = np.sqrt(area / r)
+            w_adjusted = h_adjusted * r
+        else:
+            h_adjusted = h
+            w_adjusted = w
+        
+        # Ensure adjusted dimensions are within bounds
+        w_adjusted = max(min_width, min(w_adjusted, W))
+        h_adjusted = w_adjusted / r if r > 0 else h_adjusted
+        h_adjusted = max(min_height, min(h_adjusted, H))
+        if r > 0:
+            w_adjusted = h_adjusted * r
+        
+        w = float(w_adjusted)
+        h = float(h_adjusted)
+        print(f"  Adjusted bbox from ({w/h if h>0 else 0:.4f}) to aspect ratio {r:.4f}: w={w:.1f}, h={h:.1f}")
+    
+    # Compute wmin and wmax (same as in bbox_aspect_from_unconstrained)
+    wmax = min(float(W), float(r) * float(H))
+    wmin = max(float(min_width), float(r) * float(min_height))
+    if wmin >= wmax:
+        wmin = max(1.0, 0.5 * wmax)
+    
+    # Invert: w = wmin + (wmax - wmin) * sigmoid(ts)
+    # => sigmoid(ts) = (w - wmin) / (wmax - wmin)
+    # => ts = logit((w - wmin) / (wmax - wmin))
+    if wmax > wmin:
+        sigmoid_ts = (w - wmin) / (wmax - wmin)
+        sigmoid_ts = np.clip(sigmoid_ts, 1e-6, 1.0 - 1e-6)  # Avoid log(0)
+        ts = np.log(sigmoid_ts / (1.0 - sigmoid_ts))
+    else:
+        ts = 0.0
+    
+    # Invert: x = (W - w) * sigmoid(tx)
+    # => sigmoid(tx) = x / (W - w)
+    # => tx = logit(x / (W - w))
+    if W > w:
+        sigmoid_tx = x / (W - w)
+        sigmoid_tx = np.clip(sigmoid_tx, 1e-6, 1.0 - 1e-6)
+        tx = np.log(sigmoid_tx / (1.0 - sigmoid_tx))
+    else:
+        tx = 0.0
+    
+    # Invert: y = (H - h) * sigmoid(ty)
+    # => sigmoid(ty) = y / (H - h)
+    # => ty = logit(y / (H - h))
+    if H > h:
+        sigmoid_ty = y / (H - h)
+        sigmoid_ty = np.clip(sigmoid_ty, 1e-6, 1.0 - 1e-6)
+        ty = np.log(sigmoid_ty / (1.0 - sigmoid_ty))
+    else:
+        ty = 0.0
+    
+    return tx, ty, ts
+

modules/infographics_generator/layout_system/sdf/core.py

@@ -0,0 +1,193 @@
+"""SDF core functions: IO, mask processing, and SDF computation."""
+
+import numpy as np
+from PIL import Image
+from scipy.ndimage import distance_transform_edt, binary_dilation
+
+import torch
+import torch.nn.functional as F
+
+
+# -----------------------------
+# IO: RGBA PNG -> binary mask from alpha
+# -----------------------------
+def load_binary_mask_from_rgba(png_path: str, alpha_thresh: int = 1) -> np.ndarray:
+    """Load a binary mask from an RGBA PNG file using the alpha channel.
+    
+    Args:
+        png_path: Path to the PNG file
+        alpha_thresh: Threshold for alpha channel (pixels with alpha > thresh are 1)
+    
+    Returns:
+        Binary mask as float32 array (0 or 1)
+    """
+    img = Image.open(png_path).convert("RGBA")
+    a = np.array(img, dtype=np.uint8)[..., 3]
+    mask = (a > alpha_thresh).astype(np.float32)
+    return mask
+
+
+def tight_bbox_ratio(mask01: np.ndarray):
+    """Calculate the aspect ratio of the tight bounding box of a mask.
+    
+    Args:
+        mask01: Binary mask (0 or 1)
+    
+    Returns:
+        Tuple of (aspect_ratio, (x0, y0, w, h))
+    """
+    ys, xs = np.where(mask01 > 0.5)
+    if len(xs) == 0:
+        raise ValueError("Mask is empty.")
+    x0, x1 = xs.min(), xs.max() + 1
+    y0, y1 = ys.min(), ys.max() + 1
+    w0 = x1 - x0
+    h0 = y1 - y0
+    r = w0 / float(h0)
+    return r, (x0, y0, w0, h0)
+
+
+# -----------------------------
+# Binary mask -> SDF (inside negative, outside positive), normalized to local coord units
+# local coords are [-1,1]x[-1,1]
+# -----------------------------
+def binary_to_sdf_norm(mask01: np.ndarray, pad: int = 16) -> np.ndarray:
+    """Convert a binary mask to a normalized signed distance field.
+    
+    The SDF is normalized so that distances are in local coordinate units
+    where the mask spans [-1, 1] in both dimensions.
+    
+    Args:
+        mask01: Binary mask (0 or 1)
+        pad: Padding to add around the mask
+    
+    Returns:
+        Normalized SDF (positive outside, negative inside)
+    """
+    mask = (mask01 > 0.5)
+
+    # pad with outside False to ensure border is outside
+    mask_p = np.pad(mask, ((pad, pad), (pad, pad)), mode="constant", constant_values=False)
+
+    dist_out = distance_transform_edt(~mask_p)   # outside: dist to nearest inside
+    dist_in = distance_transform_edt(mask_p)     # inside: dist to nearest outside
+    sdf_px = dist_out - dist_in                  # outside +, inside -
+
+    Ht, Wt = sdf_px.shape
+    scale = (min(Ht, Wt) / 2.0)                  # px per local-unit (since [-1,1] spans ~min/2)
+    sdf_norm = (sdf_px / scale).astype(np.float32)
+    return sdf_norm
+
+
+# -----------------------------
+# Morphological dilation for mask expansion
+# -----------------------------
+def dilate_mask(mask01: np.ndarray, radius: float) -> np.ndarray:
+    """Dilate a binary mask using morphological dilation with a circular structuring element.
+    
+    Args:
+        mask01: Binary mask (0 or 1)
+        radius: Dilation radius in pixels
+    
+    Returns:
+        Dilated binary mask
+    """
+    if radius <= 0:
+        return mask01
+    
+    # Create circular structuring element
+    # For radius r, we need a (2*r+1) x (2*r+1) square, then mask it to a circle
+    r_int = int(np.ceil(radius))
+    size = 2 * r_int + 1
+    y, x = np.ogrid[-r_int:r_int+1, -r_int:r_int+1]
+    mask_circle = (x*x + y*y <= radius*radius)
+    
+    # Perform dilation
+    dilated = binary_dilation(mask01, structure=mask_circle.astype(np.uint8))
+    
+    return dilated.astype(np.float32)
+
+
+# -----------------------------
+# Container sampling grid (pixel centers) for a chosen optimization resolution
+# -----------------------------
+def make_container_grid(H: int, W: int, device):
+    """Create a grid of pixel center coordinates for a container.
+    
+    Args:
+        H: Container height
+        W: Container width
+        device: PyTorch device
+    
+    Returns:
+        Tuple of (X, Y) coordinate grids, each of shape [H, W]
+    """
+    ys = torch.arange(H, device=device, dtype=torch.float32) + 0.5
+    xs = torch.arange(W, device=device, dtype=torch.float32) + 0.5
+    Y, X = torch.meshgrid(ys, xs, indexing="ij")
+    return X, Y  # [H,W]
+
+
+# -----------------------------
+# Differentiable rasterization: sample SDF -> soft mask
+# tau_px controls boundary softness in container pixel units
+# -----------------------------
+def sdf_to_softmask(
+    sdf_norm_t: torch.Tensor,  # [1,1,Ht,Wt]
+    x, y, w, h,                # bbox in container pixels
+    X, Y,                      # grid in container pixels [Hs,Ws]
+    tau_px: float = 1.5,
+):
+    """Convert a normalized SDF to a soft mask at given bbox location.
+    
+    Args:
+        sdf_norm_t: Normalized SDF tensor [1, 1, Ht, Wt]
+        x, y, w, h: Bounding box in container pixels
+        X, Y: Grid coordinates in container pixels [Hs, Ws]
+        tau_px: Softness parameter in pixels
+    
+    Returns:
+        Tuple of (soft_mask, distance_in_pixels)
+    """
+    cx = x + 0.5 * w
+    cy = y + 0.5 * h
+
+    # local coords (u,v) in [-1,1] within bbox
+    u = (X - cx) / (0.5 * w)
+    v = (Y - cy) / (0.5 * h)
+    grid = torch.stack([u, v], dim=-1).unsqueeze(0)  # [1,Hs,Ws,2]
+
+    d_norm = F.grid_sample(
+        sdf_norm_t, grid,
+        mode="bilinear",
+        padding_mode="border",
+        align_corners=False
+    )  # [1,1,Hs,Ws]
+
+    # convert local distance -> approx container pixel distance
+    d_px = d_norm * (0.5 * torch.minimum(w, h))
+    m = torch.sigmoid(-d_px / tau_px)
+
+    # Window function to clip to bbox
+    eps = 0.02
+    win = torch.sigmoid((1.0 - u.abs()) / eps) * torch.sigmoid((1.0 - v.abs()) / eps)
+    m = m * win
+    
+    return m, d_px
+
+
+def area_sum(mask01: torch.Tensor, W_container: int, H_container: int):
+    """Calculate the area of a mask scaled to container coordinates.
+    
+    Args:
+        mask01: Mask tensor [1, 1, Hs, Ws]
+        W_container: Container width
+        H_container: Container height
+    
+    Returns:
+        Scaled area sum
+    """
+    _, _, Hs, Ws = mask01.shape
+    da = (W_container / float(Ws)) * (H_container / float(Hs))
+    return mask01.sum() * da
+

modules/infographics_generator/layout_system/sdf/losses.py

@@ -0,0 +1,558 @@
+"""Loss functions for SDF-based layout optimization."""
+
+from typing import List, Tuple, Optional
+import torch
+
+
+# -----------------------------
+# Alignment Consistency Loss (Hierarchical Alignment)
+# -----------------------------
+def compute_alignment_consistency_loss(
+    reference_bboxes: List[Tuple[float, float, float, float]],
+    generated_bboxes: List[torch.Tensor],
+    reference_parent_bbox: Tuple[float, float, float, float],
+    generated_parent_bbox: Tuple[float, float, float, float],
+    device: str = "cpu"
+) -> torch.Tensor:
+    if len(generated_bboxes) < 2:
+        return torch.tensor(0.0, device=device)
+    
+    bbox_tensor = torch.stack([bbox for bbox in generated_bboxes])
+    
+    x = bbox_tensor[:, 0]
+    y = bbox_tensor[:, 1]
+    w = bbox_tensor[:, 2]
+    h = bbox_tensor[:, 3]
+    
+    left_coords = x
+    right_coords = x + w
+    center_x_coords = x + w / 2.0
+    top_coords = y
+    bottom_coords = y + h
+    center_y_coords = y + h / 2.0
+    
+    horizontal_coords = torch.stack([
+        left_coords,
+        right_coords,
+        center_x_coords
+    ])
+    
+    vertical_coords = torch.stack([
+        top_coords,
+        bottom_coords,
+        center_y_coords
+    ])
+    
+    sigma_horizontal = torch.std(horizontal_coords, dim=1)
+    sigma_vertical = torch.std(vertical_coords, dim=1)
+    
+    penalty = torch.min(sigma_horizontal) + torch.min(sigma_vertical)
+    
+    return penalty
+
+
+# -----------------------------
+# Alignment Similarity Loss (Based on JSON Constraint)
+# -----------------------------
+def compute_alignment_similarity_loss(
+    generated_bboxes: List[torch.Tensor],
+    container_bbox: Tuple[float, float, float, float],
+    alignment_constraint: dict,
+    device: str = "cpu"
+) -> torch.Tensor:
+    """Compute alignment similarity loss based on JSON alignment constraint.
+    
+    For row/column layouts, JSON specifies which axis to align elements along,
+    rather than taking the minimum loss across all alignment possibilities.
+    
+    Args:
+        generated_bboxes: List of generated element bboxes as torch tensors (x, y, w, h)
+        container_bbox: Container bbox (x, y, w, h)
+        alignment_constraint: Dictionary with "direction" and "value" keys
+            - direction: "horizontal" or "vertical"
+            - value: "left", "center", "right" (for horizontal) or "top", "center", "bottom" (for vertical)
+        device: Device for tensor operations
+    
+    Returns:
+        Alignment loss tensor
+    """
+    if len(generated_bboxes) < 2:
+        return torch.tensor(0.0, device=device)
+    
+    if not alignment_constraint:
+        return torch.tensor(0.0, device=device)
+    
+    direction = alignment_constraint.get("direction", "horizontal")
+    value = alignment_constraint.get("value", "center")
+    
+    _, _, container_w, container_h = container_bbox
+    
+    L_alignment = torch.tensor(0.0, device=device)
+    
+    if direction == "horizontal":
+        if value == "left":
+            left_coords = []
+            for bbox in generated_bboxes:
+                x = bbox[0]
+                left_coords.append(x)
+            left_tensor = torch.stack(left_coords)
+            L_alignment = torch.std(left_tensor) ** 2
+        elif value == "center":
+            center_x_coords = []
+            for bbox in generated_bboxes:
+                x, w = bbox[0], bbox[2]
+                center_x = x + w / 2.0
+                target_center = container_w / 2.0
+                center_x_coords.append(center_x - target_center)
+            center_x_tensor = torch.stack(center_x_coords)
+            L_alignment = torch.mean(center_x_tensor ** 2)
+        elif value == "right":
+            right_coords = []
+            for bbox in generated_bboxes:
+                x, w = bbox[0], bbox[2]
+                right_x = x + w
+                target_right = container_w
+                right_coords.append(right_x - target_right)
+            right_tensor = torch.stack(right_coords)
+            L_alignment = torch.mean(right_tensor ** 2)
+    
+    elif direction == "vertical":
+        if value == "top":
+            top_coords = []
+            for bbox in generated_bboxes:
+                y = bbox[1]
+                top_coords.append(y)
+            top_tensor = torch.stack(top_coords)
+            L_alignment = torch.std(top_tensor) ** 2
+        elif value == "center":
+            center_y_coords = []
+            for bbox in generated_bboxes:
+                y, h = bbox[1], bbox[3]
+                center_y = y + h / 2.0
+                target_center = container_h / 2.0
+                center_y_coords.append(center_y - target_center)
+            center_y_tensor = torch.stack(center_y_coords)
+            L_alignment = torch.mean(center_y_tensor ** 2)
+        elif value == "bottom":
+            bottom_coords = []
+            for bbox in generated_bboxes:
+                y, h = bbox[1], bbox[3]
+                bottom_y = y + h
+                target_bottom = container_h
+                bottom_coords.append(bottom_y - target_bottom)
+            bottom_tensor = torch.stack(bottom_coords)
+            L_alignment = torch.mean(bottom_tensor ** 2)
+    
+    return L_alignment
+
+
+# -----------------------------
+# Readability Loss (Global Size Consistency)
+# -----------------------------
+def compute_readability_loss(
+    size_rules: List[Tuple[int, int]],
+    generated_bboxes: List[torch.Tensor],
+    size_ratio_threshold: float = 1.5,
+    device: str = "cpu"
+) -> torch.Tensor:
+    """Compute readability loss based on element size hierarchy rules.
+    
+    Args:
+        size_rules: List of tuples (source_idx, target_idx) indicating that 
+                   element at source_idx should be larger than element at target_idx
+        generated_bboxes: List of bbox tensors (x, y, w, h) for generated elements
+        size_ratio_threshold: Minimum ratio threshold (default from params.SIZE_RATIO_THRESHOLD)
+        device: Device for tensor operations
+    
+    Returns:
+        Sum of size difference penalties for violated rules
+    """
+    if not size_rules or len(size_rules) == 0:
+        return torch.tensor(0.0, device=device)
+    
+    # Calculate size (area) for each element: Size = width × height
+    sizes = []
+    for bbox in generated_bboxes:
+        w, h = bbox[2], bbox[3]  # width and height
+        size = w * h
+        sizes.append(size)
+    
+    # For each rule (source_idx, target_idx): source should be >= target * size_ratio_threshold
+    # Penalty = max(0, target * size_ratio_threshold - source)
+    total_loss = torch.tensor(0.0, device=device)
+    for source_idx, target_idx in size_rules:
+        if source_idx < len(sizes) and target_idx < len(sizes):
+            size_source = sizes[source_idx]
+            size_target = sizes[target_idx]
+            # Required minimum size for source: target * size_ratio_threshold
+            min_size_source = size_target * size_ratio_threshold
+            # Penalty if source is smaller than required
+            penalty = torch.clamp(min_size_source - size_source, min=0.0)
+            total_loss = total_loss + penalty
+    
+    return total_loss
+
+
+# -----------------------------
+# Proximity Ratio Loss
+# -----------------------------
+def compute_proximity_ratio_loss(
+    container_bboxes: List[Tuple[float, float, float, float]],
+    child_bboxes_list: List[List],  # Can be List[Tuple] or List[Tensor]
+    grandchild_bboxes_list: List[List[List[Tuple[float, float, float, float]]]],
+    container_types: List[str],
+    container_weights: Optional[List[float]] = None,
+    epsilon: float = 1e-6,
+    device: str = "cpu"
+) -> torch.Tensor:
+    """Compute proximity ratio loss for layout hierarchy clarity.
+    
+    Simplified for bottom-up layout: only considers current layer's children spacing
+    and children's children spacing.
+    
+    Proximity Ratio measures whether inner-group distance < outer-group distance.
+    Score_P = Gap_external / (Gap_internal + epsilon)
+    Higher score (>1.0, ideally >1.5) indicates clear grouping.
+    
+    Args:
+        container_bboxes: List of container bboxes (x, y, w, h)
+        child_bboxes_list: For each container, list of child bboxes (x, y, w, h)
+        grandchild_bboxes_list: For each container, list of lists of grandchildren bboxes
+                                (children of each child)
+        container_types: List of container types ("column", "row", or "layer")
+        container_weights: Optional weights for weighted average (default: equal weights)
+        epsilon: Small value to avoid division by zero
+        device: Device for tensor operations
+    
+    Returns:
+        Proximity loss: negative of weighted average score (to minimize)
+    """
+    if len(container_bboxes) == 0:
+        return torch.tensor(0.0, device=device)
+    
+    scores = []
+    weights = []
+
+    for i, container_bbox in enumerate(container_bboxes):
+        container_type = container_types[i] if i < len(container_types) else "layer"
+        
+        # Skip layer type (free arrangement, no proximity constraint)
+        if container_type == "layer":
+            continue
+        
+        child_bboxes = child_bboxes_list[i] if i < len(child_bboxes_list) else []
+        grandchild_bboxes_list_for_container = grandchild_bboxes_list[i] if i < len(grandchild_bboxes_list) else []
+        
+        # Ensure grandchild_bboxes_list_for_container is a list of lists (one list per child)
+        if not isinstance(grandchild_bboxes_list_for_container, list):
+            grandchild_bboxes_list_for_container = []
+        elif len(grandchild_bboxes_list_for_container) > 0:
+            # Check if it's a flat list (first element is a bbox tuple) or nested list
+            first_elem = grandchild_bboxes_list_for_container[0]
+            if isinstance(first_elem, (tuple, list)) and len(first_elem) == 4 and isinstance(first_elem[0], (int, float)):
+                # Flat list: wrap it as a single child's grandchildren list
+                grandchild_bboxes_list_for_container = [grandchild_bboxes_list_for_container]
+        
+        if len(child_bboxes) < 2:
+            # Need at least 2 children to calculate internal gap
+            continue
+        
+        # Step A: Determine direction based on container type
+        # column: vertical arrangement, row: horizontal arrangement
+        is_horizontal = (container_type == "row")
+        
+        # Step B: Calculate Gap_internal
+        # For each child, calculate gap between its children (grandchildren), then take the maximum
+        gap_internal_max = 0.0
+        if len(grandchild_bboxes_list_for_container) > 0:
+            for child_idx, grandchild_list in enumerate(grandchild_bboxes_list_for_container):
+                if grandchild_list is None or not isinstance(grandchild_list, list):
+                    continue
+                
+                # Collect valid grandchildren for this child
+                grandchildren = []
+                for gc in grandchild_list:
+                    if gc is None:
+                        continue
+                    if isinstance(gc, (tuple, list)) and len(gc) >= 4:
+                        grandchildren.append(tuple(gc[:4]))
+                    elif isinstance(gc, dict):
+                        grandchildren.append((
+                            gc.get("x", 0), gc.get("y", 0),
+                            gc.get("width", gc.get("w", 0)),
+                            gc.get("height", gc.get("h", 0))
+                        ))
+                
+                if len(grandchildren) < 2:
+                    continue
+                
+                # Sort grandchildren by the same direction as container
+                if is_horizontal:
+                    sorted_gc = sorted(grandchildren, key=lambda b: b[0])
+                else:
+                    sorted_gc = sorted(grandchildren, key=lambda b: b[1])
+                
+                # Calculate gaps between adjacent grandchildren within this child
+                for j in range(len(sorted_gc) - 1):
+                    bbox1 = sorted_gc[j]
+                    bbox2 = sorted_gc[j + 1]
+                    
+                    if is_horizontal:
+                        gap = bbox2[0] - (bbox1[0] + bbox1[2])
+                    else:
+                        gap = bbox2[1] - (bbox1[1] + bbox1[3])
+                    
+                    gap_internal_max = max(gap_internal_max, max(0.0, gap))
+        
+        if gap_internal_max == 0.0:
+            # No valid internal gaps found, skip this container
+            continue
+        
+        gap_internal = gap_internal_max
+        
+        # Step C: Calculate Gap_external (spacing between children)
+        # Convert child_bboxes to tensors if needed for gradient computation
+        child_bboxes_tensors = []
+        for bbox in child_bboxes:
+            if isinstance(bbox, torch.Tensor):
+                child_bboxes_tensors.append(bbox)
+            elif isinstance(bbox, (tuple, list)) and len(bbox) >= 4:
+                # If bbox is tuple/list, create tensor but note: this breaks gradient chain
+                # Ideally, bboxes should be passed as tensors from the caller
+                child_bboxes_tensors.append(torch.tensor([bbox[0], bbox[1], bbox[2], bbox[3]], device=device, dtype=torch.float32))
+            else:
+                continue
+        
+        if len(child_bboxes_tensors) < 2:
+            # Not enough children: skip or use fallback
+            _, _, w_container, h_container = container_bbox
+            gap_external_tensor = torch.tensor(max(w_container, h_container) * 0.1, device=device, dtype=torch.float32)
+        else:
+            # Sort children by x (horizontal) or y (vertical)
+            if is_horizontal:
+                x_coords = torch.stack([bbox[0] for bbox in child_bboxes_tensors])
+                sorted_indices = torch.argsort(x_coords)
+            else:
+                y_coords = torch.stack([bbox[1] for bbox in child_bboxes_tensors])
+                sorted_indices = torch.argsort(y_coords)
+            
+            sorted_children_tensors = [child_bboxes_tensors[i] for i in sorted_indices]
+            
+            gap_external_list = []
+            for j in range(len(sorted_children_tensors) - 1):
+                bbox1 = sorted_children_tensors[j]
+                bbox2 = sorted_children_tensors[j + 1]
+                
+                if is_horizontal:
+                    # Horizontal: gap = x2 - (x1 + w1)
+                    gap = bbox2[0] - (bbox1[0] + bbox1[2])
+                else:
+                    # Vertical: gap = y2 - (y1 + h1)
+                    gap = bbox2[1] - (bbox1[1] + bbox1[3])
+                
+                gap_external_list.append(gap)
+            
+            if len(gap_external_list) > 0:
+                gap_external_tensor = torch.stack(gap_external_list).mean()
+            else:
+                _, _, w_container, h_container = container_bbox
+                gap_external_tensor = torch.tensor(max(w_container, h_container) * 0.1, device=device, dtype=torch.float32)
+        
+        gap_internal_tensor = torch.tensor(gap_internal, device=device, dtype=torch.float32)
+        
+        # Step D: Calculate Score_P
+        # Use gap_external directly (can be negative), but scale it for score calculation
+        # When gap_external is negative, we still want gradient, so use a smooth function
+        # Score = gap_external / (internal_gap + epsilon)
+        # This allows negative scores, which will be penalized in the loss
+        score_p = gap_external_tensor / (gap_internal_tensor + epsilon)
+        
+        scores.append(score_p)
+        
+        # Weight by container area (larger containers have more influence)
+        _, _, w_container, h_container = container_bbox
+        weight = w_container * h_container
+        weights.append(weight)
+    
+    if len(scores) == 0:
+        return torch.tensor(0.0, device=device)
+    
+    # Stack scores to preserve gradients
+    scores_tensor = torch.stack(scores)
+    
+    # Normalize weights
+    if container_weights is not None and len(container_weights) == len(weights):
+        weights = container_weights
+    
+    weights_tensor = torch.tensor(weights, device=device)
+    if weights_tensor.sum() > 0:
+        weights_tensor = weights_tensor / weights_tensor.sum()
+    else:
+        weights_tensor = torch.ones_like(weights_tensor) / len(weights_tensor)
+    
+    # Weighted average score
+    weighted_score = (scores_tensor * weights_tensor).sum()
+    
+    # Loss: penalize deviation from target score of 1.5
+    # Ideal: gap_external / gap_internal should be exactly 1.5
+    target_score = 1.5
+    
+    # Loss is the squared deviation from target (or absolute deviation)
+    # This ensures loss = 0 only when score = 1.5
+    loss = (weighted_score - target_score) ** 2
+    
+    return loss
+
+
+# -----------------------------
+# Visual Balance Loss
+# -----------------------------
+def compute_visual_balance_loss(
+    bboxes: List[Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]],  # List of (x, y, w, h) tuples
+    W_container: int,
+    H_container: int,
+    device: str = "cpu"
+) -> torch.Tensor:
+    """Compute visual balance loss based on weighted centroid of elements.
+    
+    Each element has:
+    - Centroid position: (x + w/2, y + h/2) - moves with tx, ty
+    - Mass: w * h (area) - scales with ts
+    
+    Visual balance is measured by the distance between the weighted centroid of all elements
+    and the center of the container. Lower loss means better balance.
+    
+    This implementation is differentiable with respect to tx, ty, ts:
+    - tx, ty changes: directly affect centroid position (x, y)
+    - ts changes: affects mass (w, h) and indirectly affects centroid position
+    
+    Args:
+        bboxes: List of bbox tuples (x, y, w, h) where each is a torch.Tensor
+        W_container: Container width in pixels
+        H_container: Container height in pixels
+        device: Device for tensor operations
+    
+    Returns:
+        Visual balance loss: squared distance from weighted centroid to container center
+    """
+    if len(bboxes) == 0:
+        return torch.tensor(0.0, device=device)
+    
+    # Calculate centroid and mass for each element
+    total_mass = torch.tensor(0.0, device=device)
+    weighted_x = torch.tensor(0.0, device=device)
+    weighted_y = torch.tensor(0.0, device=device)
+    
+    for bbox in bboxes:
+        x, y, w, h = bbox
+        
+        # Centroid position: center of bbox
+        centroid_x = x + w / 2.0
+        centroid_y = y + h / 2.0
+        
+        # Mass: area of bbox (scales with ts through w, h)
+        mass = w * h
+        
+        # Accumulate weighted centroid
+        total_mass = total_mass + mass
+        weighted_x = weighted_x + mass * centroid_x
+        weighted_y = weighted_y + mass * centroid_y
+    
+    # Handle edge case: if total mass is zero, return zero loss
+    if total_mass < 1e-8:
+        return torch.tensor(0.0, device=device)
+    
+    # Calculate overall centroid
+    overall_centroid_x = weighted_x / total_mass
+    overall_centroid_y = weighted_y / total_mass
+    
+    # Container center
+    center_x = torch.tensor(W_container / 2.0, device=device, dtype=torch.float32)
+    center_y = torch.tensor(H_container / 2.0, device=device, dtype=torch.float32)
+    
+    # Calculate squared distance from centroid to center
+    loss = (overall_centroid_x - center_x) ** 2 + (overall_centroid_y - center_y) ** 2
+    
+    return loss
+
+
+# -----------------------------
+# Position/Size Similarity Loss
+# -----------------------------
+def compute_position_size_similarity_loss(
+    reference_bboxes: List[Tuple[float, float, float, float]],
+    generated_bboxes: List[torch.Tensor],  # List of (x, y, w, h) tensors
+    reference_parent_bbox: Tuple[float, float, float, float],
+    generated_parent_bbox: Tuple[float, float, float, float],
+    device: str = "cpu"
+) -> torch.Tensor:
+    """Compute position/size similarity loss between reference and generated layouts.
+    
+    Args:
+        reference_bboxes: List of reference element bboxes (x, y, w, h) from Example layout
+        generated_bboxes: List of generated element bboxes as torch tensors (x, y, w, h)
+        reference_parent_bbox: Parent container bbox (x, y, w, h) for reference layout
+        generated_parent_bbox: Parent container bbox (x, y, w, h) for generated layout
+        device: Device for tensor operations
+    
+    Returns:
+        Total similarity loss (L2 distance sum over all elements)
+    """
+    if len(reference_bboxes) != len(generated_bboxes):
+        raise ValueError(f"Mismatch in number of elements: {len(reference_bboxes)} vs {len(generated_bboxes)}")
+    
+    # Extract parent container coordinates
+    x_PE, y_PE, w_PE, h_PE = reference_parent_bbox
+    x_PG, y_PG, w_PG, h_PG = generated_parent_bbox
+    
+    # Convert reference parent to tensors
+    x_PE_t = torch.tensor(x_PE, device=device, dtype=torch.float32)
+    y_PE_t = torch.tensor(y_PE, device=device, dtype=torch.float32)
+    w_PE_t = torch.tensor(w_PE, device=device, dtype=torch.float32)
+    h_PE_t = torch.tensor(h_PE, device=device, dtype=torch.float32)
+    
+    # Convert generated parent to tensors
+    x_PG_t = torch.tensor(x_PG, device=device, dtype=torch.float32)
+    y_PG_t = torch.tensor(y_PG, device=device, dtype=torch.float32)
+    w_PG_t = torch.tensor(w_PG, device=device, dtype=torch.float32)
+    h_PG_t = torch.tensor(h_PG, device=device, dtype=torch.float32)
+    
+    total_loss = torch.tensor(0.0, device=device)
+    
+    for ref_bbox, gen_bbox in zip(reference_bboxes, generated_bboxes):
+        # Extract element coordinates
+        x_E, y_E, w_E, h_E = ref_bbox
+        
+        # Convert reference element to tensors
+        x_E_t = torch.tensor(x_E, device=device, dtype=torch.float32)
+        y_E_t = torch.tensor(y_E, device=device, dtype=torch.float32)
+        w_E_t = torch.tensor(w_E, device=device, dtype=torch.float32)
+        h_E_t = torch.tensor(h_E, device=device, dtype=torch.float32)
+        
+        # Generated bbox is already a tensor (x, y, w, h)
+        x_G_t, y_G_t, w_G_t, h_G_t = gen_bbox
+        
+        # Compute relative attribute vector V_E for reference element
+        V_E = torch.stack([
+            (x_E_t - x_PE_t) / w_PE_t,  # relative x position
+            (y_E_t - y_PE_t) / h_PE_t,  # relative y position
+            w_E_t / w_PE_t,              # relative width
+            h_E_t / h_PE_t               # relative height
+        ])
+        
+        # Compute relative attribute vector V_G for generated element
+        V_G = torch.stack([
+            (x_G_t - x_PG_t) / w_PG_t,  # relative x position
+            (y_G_t - y_PG_t) / h_PG_t,  # relative y position
+            w_G_t / w_PG_t,              # relative width
+            h_G_t / h_PG_t               # relative height
+        ])
+        
+        # Compute L2 distance: D = ||V_E - V_G||_2
+        diff = V_E - V_G
+        distance = torch.norm(diff, p=2)
+        
+        total_loss = total_loss + distance
+    
+    return total_loss
+

modules/infographics_generator/layout_system/sdf/optimizer.py

@@ -0,0 +1,921 @@
+"""Main optimization function for SDF-based layout optimization."""
+
+import os
+import shutil
+from typing import List, Tuple, Optional, Dict
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from modules.infographics_generator.layout_system import parameters as params
+
+from .core import (
+    load_binary_mask_from_rgba,
+    tight_bbox_ratio,
+    binary_to_sdf_norm,
+    dilate_mask,
+    make_container_grid,
+    sdf_to_softmask,
+    area_sum,
+)
+from .bbox import (
+    bbox_aspect_from_unconstrained,
+    unconstrained_from_bbox,
+)
+from .losses import (
+    compute_alignment_consistency_loss,
+    compute_alignment_similarity_loss,
+    compute_readability_loss,
+    compute_proximity_ratio_loss,
+    compute_visual_balance_loss,
+    compute_position_size_similarity_loss,
+)
+from .visualization import (
+    visualize_optimization_progress,
+    visualize_final_result,
+    save_composite_image,
+)
+
+
+def optimize(
+    png_list,  # List of image paths for N nodes
+    original_png_list=None,  # List of original image paths for saving composite
+    Wc=1000, Hc=1000,
+    opt_res_list=params.OPT_RES_LIST,  # optimize on these resolutions
+    outer_rounds=params.OUTER_ROUNDS,  # augmented-lagrangian outer updates per stage
+    inner_steps=params.INNER_STEPS,    # gradient steps per outer round
+    tau_schedule=params.TAU_SCHEDULE,
+    rho_init=params.RHO_INIT,          # initial penalty parameter
+    rho_mult=params.RHO_MULT,          # penalty multiplier
+    lr=params.LEARNING_RATE,
+    size_min=params.SIZE_MIN,         # Legacy parameter for backward compatibility
+    min_sizes=None,                    # List of (min_width, min_height) tuples for each element
+    pen_weight=params.PEN_WEIGHT,      # weight for penetration penalty
+    pen_eta_px=params.PEN_ETA_PX,
+    reference_bboxes=None,             # List of reference element bboxes (x, y, w, h) from Example layout
+    reference_parent_bbox=None,        # Reference parent container bbox (x, y, w, h)
+    w_similarity=params.W_SIMILARITY,  # weight for position/size similarity loss
+    size_rules=None,                   # List of tuples (source_idx, target_idx) for size hierarchy rules
+    w_readability=params.W_READABILITY, # weight for readability loss
+    w_alignment_consistency=params.W_ALIGNMENT_CONSISTENCY,  # weight for alignment consistency loss
+    alignment_constraint=None,          # Dictionary with alignment constraint from JSON (direction, value)
+    w_alignment_similarity=params.W_ALIGNMENT_SIMILARITY,  # weight for alignment similarity loss
+    proximity_info=None,               # Dictionary with container hierarchy info for proximity ratio calculation
+    w_proximity=params.W_PROXIMITY,    # weight for proximity ratio loss
+    w_data_ink=params.W_DATA_INK,      # weight for data ink loss (maximize union area)
+    w_visual_balance=params.W_VISUAL_BALANCE,  # weight for visual balance loss
+    min_gap_px=20.0,                    # minimum gap between elements in pixels
+    device=None,
+    save_prefix=None,                  # Prefix for saving result images (None = use default names)
+    debug=False,                        # Enable debug mode: visualization and detailed logging
+):
+    """Main SDF-based layout optimization function.
+    
+    Args:
+        png_list: List of image paths for N nodes
+        original_png_list: List of original image paths for saving composite
+        Wc, Hc: Container width and height
+        opt_res_list: Optimize on these resolutions
+        outer_rounds: Augmented-lagrangian outer updates per stage
+        inner_steps: Gradient steps per outer round
+        tau_schedule: Schedule for tau parameter
+        rho_init: Initial penalty parameter
+        rho_mult: Penalty multiplier
+        lr: Learning rate
+        size_min: Legacy minimum size parameter
+        min_sizes: List of (min_width, min_height) tuples for each element
+        pen_weight: Weight for penetration penalty
+        pen_eta_px: Eta parameter for penetration penalty
+        reference_bboxes: List of reference element bboxes from Example layout
+        reference_parent_bbox: Reference parent container bbox
+        w_similarity: Weight for position/size similarity loss
+        size_rules: List of tuples (source_idx, target_idx) for size hierarchy rules
+        w_readability: Weight for readability loss
+        w_alignment_consistency: Weight for alignment consistency loss
+        alignment_constraint: Dictionary with alignment constraint from JSON
+        w_alignment_similarity: Weight for alignment similarity loss
+        proximity_info: Dictionary with container hierarchy info
+        w_proximity: Weight for proximity ratio loss
+        w_data_ink: Weight for data ink loss
+        w_visual_balance: Weight for visual balance loss
+        min_gap_px: Minimum gap between elements in pixels
+        device: PyTorch device
+        save_prefix: Prefix for saving result images
+        debug: Enable debug mode (visualization and detailed logging)
+    
+    Returns:
+        List of final bounding boxes [(x, y, w, h), ...]
+    """
+    if device is None:
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+    print("Device:", device)
+
+    # Validate png_list
+    if png_list is None or len(png_list) < 1:
+        raise ValueError("png_list must be provided with at least one image path")
+    
+    num_nodes = len(png_list)
+    
+    # Handle original_png_list
+    if original_png_list is None:
+        original_png_list = png_list
+    
+    # Set dilation_radii to 100 for all elements
+    dilation_radii = [20.0] * num_nodes
+    
+    # print(f"Number of nodes: {num_nodes}")
+    # print(f"Dilation radii: {dilation_radii}")
+
+    # Validate reference bboxes
+    if reference_bboxes is None:
+        reference_bboxes = []
+    if reference_parent_bbox is None:
+        reference_parent_bbox = (0.0, 0.0, float(Wc), float(Hc))
+    
+    # Normalize reference bboxes: subtract x_min and y_min to make coordinates start from 0
+    if reference_bboxes and len(reference_bboxes) > 0:
+        # Find minimum x and y across all reference bboxes
+        x_min = min(bbox[0] for bbox in reference_bboxes)
+        y_min = min(bbox[1] for bbox in reference_bboxes)
+        
+        # Subtract x_min and y_min from all bboxes
+        normalized_reference_bboxes = []
+        for bbox in reference_bboxes:
+            if isinstance(bbox, (tuple, list)) and len(bbox) >= 4:
+                normalized_bbox = (bbox[0] - x_min, bbox[1] - y_min, bbox[2], bbox[3])
+            elif isinstance(bbox, dict):
+                normalized_bbox = {
+                    'x': bbox.get('x', 0) - x_min,
+                    'y': bbox.get('y', 0) - y_min,
+                    'width': bbox.get('width', bbox.get('w', 100)),
+                    'height': bbox.get('height', bbox.get('h', 100))
+                }
+            else:
+                normalized_bbox = bbox
+            normalized_reference_bboxes.append(normalized_bbox)
+        
+        reference_bboxes = normalized_reference_bboxes
+        
+        # Also normalize reference_parent_bbox
+        if reference_parent_bbox:
+            x_p, y_p, w_p, h_p = reference_parent_bbox
+            reference_parent_bbox = (x_p - x_min, y_p - y_min, w_p, h_p)
+        
+        # print(f"Normalized reference bboxes: subtracted x_min={x_min:.1f}, y_min={y_min:.1f}")
+    
+    # Validate size rules
+    if size_rules is None:
+        size_rules = []
+    
+    # Validate and set up min_sizes
+    if min_sizes is None:
+        # Use default values for all elements
+        min_sizes = [(params.MIN_WIDTH_DEFAULT, params.MIN_HEIGHT_DEFAULT)] * num_nodes
+    elif len(min_sizes) < num_nodes:
+        # Extend with default values
+        default_size = (params.MIN_WIDTH_DEFAULT, params.MIN_HEIGHT_DEFAULT)
+        min_sizes = min_sizes + [default_size] * (num_nodes - len(min_sizes))
+    elif len(min_sizes) > num_nodes:
+        # Truncate to num_nodes
+        min_sizes = min_sizes[:num_nodes]
+    
+    # print(f"Reference bboxes: {len(reference_bboxes)} elements")
+    # print(f"Reference parent bbox: {reference_parent_bbox}")
+    # print(f"Size rules: {len(size_rules)} rules")
+    # print(f"Similarity weight: {w_similarity}, Readability weight: {w_readability}")
+    # print(f"Min sizes: {min_sizes}")
+    # print(f"Debug mode: {debug}")
+
+    # Create visualization folder for this optimization run (only in debug mode)
+    viz_folder = None
+    if debug:
+        if save_prefix:
+            viz_folder = f"{save_prefix}_visualization"
+        else:
+            viz_folder = "optimization_visualization"
+        
+        # Clear existing folder contents if it exists
+        if os.path.exists(viz_folder):
+            shutil.rmtree(viz_folder)
+        
+        os.makedirs(viz_folder, exist_ok=True)
+        # print(f"Visualization folder created: {viz_folder}")
+
+    # load masks for all nodes
+    masks = []
+    ratios = []
+    for i, png_path in enumerate(png_list):
+        if png_path is None:
+            raise ValueError(f"Image path at index {i} is None")
+        mask = load_binary_mask_from_rgba(png_path)
+        
+        # Apply dilation with radius 100 to all elements
+        mask = dilate_mask(mask, dilation_radii[i])
+        # print(f"Applied dilation to node {i} mask with radius {dilation_radii[i]:.1f} pixels")
+        
+        masks.append(mask)
+        r, _ = tight_bbox_ratio(mask)
+        ratios.append(r)
+        # print(f"Node {i} aspect ratio (tight alpha bbox): r={r:.4f}")
+
+    # precompute SDF templates for all nodes
+    sdf_norms = []
+    sdf_tensors = []
+    for i, mask in enumerate(masks):
+        sdf_norm = binary_to_sdf_norm(mask, pad=16)
+        sdf_norms.append(sdf_norm)
+        sdf_t = torch.from_numpy(sdf_norm)[None, None].to(device)
+        sdf_tensors.append(sdf_t)
+
+    # learnable parameters: (tx,ty,ts) for each object
+    # Initialize from reference_bboxes if available, otherwise use zeros
+    opt_params = []
+    for i in range(num_nodes):
+        if reference_bboxes and i < len(reference_bboxes):
+            # Initialize from reference bbox
+            ref_bbox = reference_bboxes[i]
+            if isinstance(ref_bbox, (tuple, list)) and len(ref_bbox) >= 4:
+                ref_x, ref_y, ref_w, ref_h = ref_bbox[0], ref_bbox[1], ref_bbox[2], ref_bbox[3]
+            elif isinstance(ref_bbox, dict):
+                ref_x = ref_bbox.get("x", 0)
+                ref_y = ref_bbox.get("y", 0)
+                ref_w = ref_bbox.get("width", ref_bbox.get("w", 100))
+                ref_h = ref_bbox.get("height", ref_bbox.get("h", 100))
+            else:
+                ref_x, ref_y, ref_w, ref_h = 0, 0, 100, 100
+            
+            # Convert reference bbox to unconstrained parameters
+            # Use material's aspect ratio (ratios[i]) instead of JSON's w/h
+            min_width, min_height = min_sizes[i]
+            tx_init, ty_init, ts_init = unconstrained_from_bbox(
+                ref_x, ref_y, ref_w, ref_h,
+                Wc, Hc, ratios[i],
+                min_width=min_width, min_height=min_height,
+                size_min=size_min
+            )
+            # print(f"Node {i}: Initializing from reference bbox ({ref_x:.1f}, {ref_y:.1f}, {ref_w:.1f}, {ref_h:.1f}), "
+                #   f"adjusted to aspect ratio {ratios[i]:.4f}")
+        else:
+            # Initialize with zeros (default)
+            tx_init, ty_init, ts_init = 0.0, 0.0, 0.0
+        
+        tx = torch.nn.Parameter(torch.tensor(tx_init, device=device))
+        ty = torch.nn.Parameter(torch.tensor(ty_init, device=device))
+        ts = torch.nn.Parameter(torch.tensor(ts_init, device=device))
+        opt_params.extend([tx, ty, ts])
+    
+    opt = torch.optim.Adam(opt_params, lr=lr)
+
+    # augmented lagrangian multipliers for constraint g = A_inter = 0
+    lam = torch.tensor(0.0, device=device)
+    rho = torch.tensor(rho_init, device=device)
+
+    tau_list = list(tau_schedule)
+    if len(tau_list) < outer_rounds:
+        tau_list += [tau_list[-1]] * (outer_rounds - len(tau_list))
+
+    # staged optimization over resolutions
+    for stage_idx, stage_res in enumerate(opt_res_list):
+        Hs = Ws = int(stage_res)
+        X, Y = make_container_grid(Hs, Ws, device=device)
+        # print(f"\n=== Stage optimize at {Ws}x{Hs} (container {Wc}x{Hc}) ===")
+
+        # Visualize initial state before optimization (only for first stage and only in debug mode)
+        if stage_idx == 0 and debug:
+            with torch.no_grad():
+                # Use full resolution for visualization
+                X_init, Y_init = make_container_grid(Hc, Wc, device=device)
+                initial_bboxes = []
+                initial_softmasks = []
+                for i in range(num_nodes):
+                    tx_idx = i * 3
+                    ty_idx = i * 3 + 1
+                    ts_idx = i * 3 + 2
+                    tx = opt_params[tx_idx]
+                    ty = opt_params[ty_idx]
+                    ts = opt_params[ts_idx]
+                    
+                    min_width, min_height = min_sizes[i]
+                    x, y, w, h = bbox_aspect_from_unconstrained(
+                        tx, ty, ts, Wc, Hc, ratios[i],
+                        min_width=min_width, min_height=min_height,
+                        size_min=size_min
+                    )
+                    # print(f"Node {i} initial bbox: ({x.item():.1f}, {y.item():.1f}, {w.item():.1f}, {h.item():.1f})")
+                    initial_bboxes.append((x.item(), y.item(), w.item(), h.item()))
+                    
+                    # Use smaller tau for initial visualization to show actual mask shape
+                    m, _ = sdf_to_softmask(sdf_tensors[i], x, y, w, h, X_init, Y_init, tau_px=0.5)
+                    initial_softmasks.append(m)
+                
+                # Compute initial loss values for display
+                initial_union = torch.ones_like(initial_softmasks[0])
+                for m in initial_softmasks:
+                    initial_union = initial_union * (1.0 - m)
+                initial_union = 1.0 - initial_union
+                initial_A_union = initial_union.sum().item()  # Full resolution, da=1
+                
+                initial_inter = torch.zeros_like(initial_softmasks[0])
+                for i in range(num_nodes):
+                    for j in range(i + 1, num_nodes):
+                        initial_inter = initial_inter + initial_softmasks[i] * initial_softmasks[j]
+                initial_A_inter = initial_inter.sum().item()  # Full resolution, da=1
+                
+                # Compute visual balance loss for initial state (using bboxes)
+                initial_bboxes_tensors = []
+                for i in range(num_nodes):
+                    tx_idx = i * 3
+                    ty_idx = i * 3 + 1
+                    ts_idx = i * 3 + 2
+                    tx = opt_params[tx_idx]
+                    ty = opt_params[ty_idx]
+                    ts = opt_params[ts_idx]
+                    
+                    min_width, min_height = min_sizes[i]
+                    x, y, w, h = bbox_aspect_from_unconstrained(
+                        tx, ty, ts, Wc, Hc, ratios[i],
+                        min_width=min_width, min_height=min_height,
+                        size_min=size_min
+                    )
+                    initial_bboxes_tensors.append((x, y, w, h))
+                
+                L_visual_balance_init = compute_visual_balance_loss(
+                    initial_bboxes_tensors, Wc, Hc, device=device
+                )
+                
+                initial_loss_info = {
+                    'A_union': initial_A_union,
+                    'A_inter': initial_A_inter,
+                    'visual_balance': w_visual_balance * L_visual_balance_init.item(),
+                }
+                
+                initial_save_path = os.path.join(viz_folder, f"initial_stage{stage_idx}.png")
+                
+                visualize_optimization_progress(
+                    initial_softmasks, initial_bboxes, Wc, Hc,
+                    epoch=-1, loss_info=initial_loss_info,
+                    save_path=initial_save_path
+                )
+
+        for k in range(outer_rounds):
+            tau_px = float(tau_list[min(k, len(tau_list)-1)])
+
+            for t in range(inner_steps):
+                opt.zero_grad(set_to_none=True)
+
+                # Compute bboxes for all nodes
+                bboxes = []
+                softmasks = []
+                distances = []
+                for i in range(num_nodes):
+                    tx_idx = i * 3
+                    ty_idx = i * 3 + 1
+                    ts_idx = i * 3 + 2
+                    tx = opt_params[tx_idx]
+                    ty = opt_params[ty_idx]
+                    ts = opt_params[ts_idx]
+                    
+                    min_width, min_height = min_sizes[i]
+                    x, y, w, h = bbox_aspect_from_unconstrained(
+                        tx, ty, ts, Wc, Hc, ratios[i],
+                        min_width=min_width, min_height=min_height,
+                        size_min=size_min
+                    )
+                    bboxes.append((x, y, w, h))
+                    
+                    m, d_px = sdf_to_softmask(sdf_tensors[i], x, y, w, h, X, Y, tau_px=tau_px)
+                    softmasks.append(m)
+                    distances.append(d_px)
+
+                # Compute union: 1 - product of (1 - mask_i)
+                union = torch.ones_like(softmasks[0])
+                for m in softmasks:
+                    union = union * (1.0 - m)
+                union = 1.0 - union
+
+                # Compute intersection: sum of all pairwise intersections
+                inter = torch.zeros_like(softmasks[0])
+                for i in range(num_nodes):
+                    for j in range(i + 1, num_nodes):
+                        inter = inter + softmasks[i] * softmasks[j]
+
+                A_union = area_sum(union, Wc, Hc)
+                A_inter = area_sum(inter, Wc, Hc)  # must go to 0
+
+                # Visual balance loss (using bboxes directly for differentiability)
+                L_visual_balance = compute_visual_balance_loss(
+                    bboxes, Wc, Hc, device=device
+                )
+
+                # Penetration loss: based on actual bbox gap (not limited by SDF range)
+                # Penalize when gap < min_gap_px (ensures minimum gap between elements)
+                # Use ReLU for hard cutoff: no penalty when gap >= min_gap_px
+                # For "layer" container type, skip this loss (overlapping is allowed)
+                L_pen = torch.tensor(0.0, device=device)
+                
+                # # Check if this is a layer container (overlapping allowed)
+                # is_layer = False
+                # if proximity_info:
+                #     container_types = proximity_info.get("types", [])
+                #     if len(container_types) > 0:
+                #         is_layer = (container_types[0] == "layer")
+                
+                # if not is_layer:
+                # # Only apply penetration penalty for row/column layouts
+                #     for i in range(num_nodes):
+                #         for j in range(i + 1, num_nodes):
+                #             x_i, y_i, w_i, h_i = bboxes[i]
+                #             x_j, y_j, w_j, h_j = bboxes[j]
+                            
+                #             # Compute gap in each dimension (negative if overlapping)
+                #             gap_x = torch.max(x_j - (x_i + w_i), x_i - (x_j + w_j))
+                #             gap_y = torch.max(y_j - (y_i + h_i), y_i - (y_j + h_j))
+                            
+                #             # Combined gap logic:
+                #             # - If both separated (both positive): Euclidean distance
+                #             # - If both overlapping (both negative): use MAX (smallest overlap, easiest to fix)
+                #             # - If one separated, one overlapping: use the separated one (that's the actual gap)
+                #             if gap_x >= 0 and gap_y >= 0:
+                #                 # Both separated: Euclidean distance
+                #                 gap = torch.sqrt(gap_x * gap_x + gap_y * gap_y)
+                #             elif gap_x < 0 and gap_y < 0:
+                #                 # Both overlapping: use the smaller overlap (easier to separate)
+                #                 gap = torch.max(gap_x, gap_y)
+                #             else:
+                #                 # One separated, one overlapping: they're aligned in overlapping dimension
+                #                 # Use the separated dimension's gap
+                #                 gap = torch.max(gap_x, gap_y)
+                            
+                #             # Penalty if gap < min_gap_px
+                #             L_pen = L_pen + F.relu(min_gap_px - gap)
+
+                # Position/Size similarity loss
+                L_similarity = torch.tensor(0.0, device=device)
+                if reference_bboxes and len(reference_bboxes) >= num_nodes:
+                    # Current generated bboxes as tensors
+                    generated_bboxes = [torch.stack([bbox[0], bbox[1], bbox[2], bbox[3]]) for bbox in bboxes]
+                    # Generated parent container bbox (current container)
+                    generated_parent_bbox = (0.0, 0.0, float(Wc), float(Hc))
+                    
+                    L_similarity = compute_position_size_similarity_loss(
+                        reference_bboxes[:num_nodes],
+                        generated_bboxes,
+                        reference_parent_bbox,
+                        generated_parent_bbox,
+                        device=device
+                    )
+
+                # Readability loss (size hierarchy consistency)
+                L_readability = torch.tensor(0.0, device=device)
+                if size_rules and len(size_rules) > 0:
+                    generated_bboxes_readability = [torch.stack([bbox[0], bbox[1], bbox[2], bbox[3]]) for bbox in bboxes]
+                    L_readability = compute_readability_loss(
+                        size_rules,
+                        generated_bboxes_readability,
+                        size_ratio_threshold=params.SIZE_RATIO_THRESHOLD,
+                        device=device
+                    )
+
+                # Alignment consistency loss (hierarchical alignment)
+                L_alignment_consistency = torch.tensor(0.0, device=device)
+                if reference_bboxes and len(reference_bboxes) >= num_nodes:
+                    generated_bboxes_alignment = [torch.stack([bbox[0], bbox[1], bbox[2], bbox[3]]) for bbox in bboxes]
+                    generated_parent_bbox_alignment = (0.0, 0.0, float(Wc), float(Hc))
+                    
+                    L_alignment_consistency = compute_alignment_consistency_loss(
+                        reference_bboxes[:num_nodes],
+                        generated_bboxes_alignment,
+                        reference_parent_bbox,
+                        generated_parent_bbox_alignment,
+                        device=device
+                    )
+                
+                # Alignment similarity loss (based on JSON constraint)
+                L_alignment_similarity = torch.tensor(0.0, device=device)
+                if alignment_constraint and w_alignment_similarity > 0:
+                    generated_bboxes_alignment_sim = [torch.stack([bbox[0], bbox[1], bbox[2], bbox[3]]) for bbox in bboxes]
+                    container_bbox_alignment = (0.0, 0.0, float(Wc), float(Hc))
+                    
+                    L_alignment_similarity = compute_alignment_similarity_loss(
+                        generated_bboxes_alignment_sim,
+                        container_bbox_alignment,
+                        alignment_constraint,
+                        device=device
+                    )
+
+                # Proximity ratio loss
+                L_proximity = torch.tensor(0.0, device=device)
+                if proximity_info and w_proximity > 0:
+                    # Extract information from proximity_info
+                    container_bboxes = proximity_info.get("containers", [])
+                    child_bboxes_list = proximity_info.get("children", [])
+                    grandchild_bboxes_list = proximity_info.get("grandchildren", [])
+                    container_types = proximity_info.get("types", [])
+                    container_weights = proximity_info.get("weights", None)
+                    
+                    # Convert current generated bboxes to tuples for proximity calculation
+                    # For N-element case: treat as single container with N children
+                    if len(container_bboxes) == 0:
+                        # Simplified N-element case: create a container with N children
+                        # Note: container type should be provided in proximity_info
+                        container_bbox = (0.0, 0.0, float(Wc), float(Hc))
+                        # Keep bboxes as tensors for gradient computation
+                        child_bboxes = [torch.stack([bbox[0], bbox[1], bbox[2], bbox[3]]) for bbox in bboxes]
+                        # For N-element case, grandchildren would be empty (children are leaf nodes)
+                        grandchild_bboxes = []
+                        container_type = container_types[0] if container_types else "row"  # Default to row
+                        
+                        L_proximity = compute_proximity_ratio_loss(
+                            [container_bbox],
+                            [child_bboxes],
+                            [grandchild_bboxes],
+                            [container_type],
+                            container_weights=[1.0] if container_weights is None else container_weights,
+                            epsilon=params.PROXIMITY_EPSILON,
+                            device=device
+                        )
+                    else:
+                        # Use provided proximity_info
+                        # Keep bboxes as tensors for gradient computation
+                        generated_bboxes_proximity = [torch.stack([bbox[0], bbox[1], bbox[2], bbox[3]]) for bbox in bboxes]
+                        
+                        # Update child_bboxes_list with current generated bboxes if needed
+                        # This is a simplified approach - in full implementation, we'd need to map
+                        # generated bboxes to the correct containers
+                        if len(child_bboxes_list) > 0 and len(child_bboxes_list[0]) == num_nodes:
+                            # Update first container's children with generated bboxes (as tensors)
+                            updated_child_bboxes_list = [generated_bboxes_proximity] + child_bboxes_list[1:]
+                        else:
+                            updated_child_bboxes_list = child_bboxes_list
+                        
+                        L_proximity = compute_proximity_ratio_loss(
+                            container_bboxes,
+                            updated_child_bboxes_list,
+                            grandchild_bboxes_list,
+                            container_types,
+                            container_weights,
+                            epsilon=params.PROXIMITY_EPSILON,
+                            device=device
+                        )
+
+                g = A_inter
+                # Data ink loss: maximize union area (minimize white space)
+                # Negative because we want to maximize A_union (minimize -A_union)
+                L_data_ink = -A_union
+                
+                # Scale pen_weight by rho to prevent L_pen from being overwhelmed when rho is large
+                # When rho is large, AL constraint dominates, so we need to scale pen_weight accordingly
+                pen_weight_scaled = pen_weight * (1.0 + rho.item() / 1e4)
+                
+                # AL constraint on overlap + penalty term + similarity loss + readability loss + alignment consistency loss + alignment similarity loss + proximity loss + data ink loss + visual balance loss
+                loss = (lam * g + 0.5 * rho * g * g + pen_weight_scaled * L_pen + 
+                        w_similarity * L_similarity + w_readability * L_readability + 
+                        w_alignment_consistency * L_alignment_consistency + w_alignment_similarity * L_alignment_similarity + 
+                        w_proximity * L_proximity + w_data_ink * L_data_ink + w_visual_balance * L_visual_balance)
+
+                loss.backward()
+                opt.step()
+
+            # outer AL update
+            with torch.no_grad():
+                # Compute bboxes for logging and AL update
+                bboxes_log = []
+                for i in range(num_nodes):
+                    tx_idx = i * 3
+                    ty_idx = i * 3 + 1
+                    ts_idx = i * 3 + 2
+                    tx = opt_params[tx_idx]
+                    ty = opt_params[ty_idx]
+                    ts = opt_params[ts_idx]
+                    
+                    min_width, min_height = min_sizes[i]
+                    x, y, w, h = bbox_aspect_from_unconstrained(
+                        tx, ty, ts, Wc, Hc, ratios[i],
+                        min_width=min_width, min_height=min_height,
+                        size_min=size_min
+                    )
+                    bboxes_log.append((x, y, w, h))
+                
+                # Compute A_inter for AL update (always needed)
+                softmasks_log = []
+                for i in range(num_nodes):
+                    x, y, w, h = bboxes_log[i]
+                    m, d_px = sdf_to_softmask(sdf_tensors[i], x, y, w, h, X, Y, tau_px=tau_px)
+                    softmasks_log.append(m)
+                
+                inter_log = torch.zeros_like(softmasks_log[0])
+                for i in range(num_nodes):
+                    for j in range(i + 1, num_nodes):
+                        inter_log = inter_log + softmasks_log[i] * softmasks_log[j]
+                
+                A_inter = area_sum(inter_log, Wc, Hc)
+                
+                # Update Lagrangian multiplier
+                lam = lam + rho * A_inter
+                rho = rho * rho_mult
+                
+                # Detailed logging and visualization (only in debug mode)
+                if debug:
+                    # Compute all loss components for detailed logging
+                    distances_log = []
+                    for i in range(num_nodes):
+                        x, y, w, h = bboxes_log[i]
+                        m, d_px = sdf_to_softmask(sdf_tensors[i], x, y, w, h, X, Y, tau_px=tau_px)
+                        distances_log.append(d_px)
+                    
+                    union_log = torch.ones_like(softmasks_log[0])
+                    for m in softmasks_log:
+                        union_log = union_log * (1.0 - m)
+                    union_log = 1.0 - union_log
+                    A_union = area_sum(union_log, Wc, Hc)
+
+                    A_union = area_sum(union_log, Wc, Hc)
+
+                    # Recompute penalty for logging (based on actual bbox gap)
+                    # Skip for layer containers (overlapping allowed)
+                    L_pen_val = torch.tensor(0.0, device=device)
+                    
+                    # Check if this is a layer container
+                    is_layer = False
+                    if proximity_info:
+                        container_types = proximity_info.get("types", [])
+                        if len(container_types) > 0:
+                            is_layer = (container_types[0] == "layer")
+                    
+                    if not is_layer:
+                        for i in range(num_nodes):
+                            for j in range(i + 1, num_nodes):
+                                x_i, y_i, w_i, h_i = bboxes_log[i]
+                                x_j, y_j, w_j, h_j = bboxes_log[j]
+                                
+                                # Compute gap in each dimension
+                                gap_x = torch.max(x_j - (x_i + w_i), x_i - (x_j + w_j))
+                                gap_y = torch.max(y_j - (y_i + h_i), y_i - (y_j + h_j))
+                                
+                                # Combined gap logic
+                                if gap_x >= 0 and gap_y >= 0:
+                                    # Both separated: Euclidean distance
+                                    gap = torch.sqrt(gap_x * gap_x + gap_y * gap_y)
+                                elif gap_x < 0 and gap_y < 0:
+                                    # Both overlapping: use smaller overlap
+                                    gap = torch.max(gap_x, gap_y)
+                                else:
+                                    # One separated, one overlapping
+                                    gap = torch.max(gap_x, gap_y)
+                                
+                                # Penalty if gap < min_gap_px
+                                L_pen_val = L_pen_val + F.relu(min_gap_px - gap)
+
+                    # Recompute similarity loss for logging
+                    L_similarity_val = torch.tensor(0.0, device=device)
+                    if reference_bboxes and len(reference_bboxes) >= num_nodes:
+                        generated_bboxes_log = [torch.stack([bbox[0], bbox[1], bbox[2], bbox[3]]) for bbox in bboxes_log]
+                        generated_parent_bbox_log = (0.0, 0.0, float(Wc), float(Hc))
+                        
+                        L_similarity_val = compute_position_size_similarity_loss(
+                            reference_bboxes[:num_nodes],
+                            generated_bboxes_log,
+                            reference_parent_bbox,
+                            generated_parent_bbox_log,
+                            device=device
+                        )
+
+                    # Recompute readability loss for logging
+                    L_readability_val = torch.tensor(0.0, device=device)
+                    if size_rules and len(size_rules) > 0:
+                        generated_bboxes_readability_log = [torch.stack([bbox[0], bbox[1], bbox[2], bbox[3]]) for bbox in bboxes_log]
+                        L_readability_val = compute_readability_loss(
+                            size_rules,
+                            generated_bboxes_readability_log,
+                            size_ratio_threshold=params.SIZE_RATIO_THRESHOLD,
+                            device=device
+                        )
+
+                    # Recompute alignment consistency loss for logging
+                    L_alignment_consistency_val = torch.tensor(0.0, device=device)
+                    if reference_bboxes and len(reference_bboxes) >= num_nodes:
+                        generated_bboxes_alignment_log = [torch.stack([bbox[0], bbox[1], bbox[2], bbox[3]]) for bbox in bboxes_log]
+                        generated_parent_bbox_alignment_log = (0.0, 0.0, float(Wc), float(Hc))
+                        
+                        L_alignment_consistency_val = compute_alignment_consistency_loss(
+                            reference_bboxes[:num_nodes],
+                            generated_bboxes_alignment_log,
+                            reference_parent_bbox,
+                            generated_parent_bbox_alignment_log,
+                            device=device
+                        )
+                    
+                    # Recompute alignment similarity loss for logging
+                    L_alignment_similarity_val = torch.tensor(0.0, device=device)
+                    if alignment_constraint and w_alignment_similarity > 0:
+                        generated_bboxes_alignment_sim_log = [torch.stack([bbox[0], bbox[1], bbox[2], bbox[3]]) for bbox in bboxes_log]
+                        container_bbox_alignment_log = (0.0, 0.0, float(Wc), float(Hc))
+                        
+                        L_alignment_similarity_val = compute_alignment_similarity_loss(
+                            generated_bboxes_alignment_sim_log,
+                            container_bbox_alignment_log,
+                            alignment_constraint,
+                            device=device
+                        )
+
+                    # Recompute proximity ratio loss for logging
+                    L_proximity_val = torch.tensor(0.0, device=device)
+                    if proximity_info and w_proximity > 0:
+                        container_bboxes = proximity_info.get("containers", [])
+                        child_bboxes_list = proximity_info.get("children", [])
+                        grandchild_bboxes_list = proximity_info.get("grandchildren", [])
+                        container_types = proximity_info.get("types", [])
+                        container_weights = proximity_info.get("weights", None)
+                        
+                        if len(container_bboxes) == 0:
+                            container_bbox = (0.0, 0.0, float(Wc), float(Hc))
+                            child_bboxes = [(bbox[0].item(), bbox[1].item(), bbox[2].item(), bbox[3].item()) for bbox in bboxes_log]
+                            grandchild_bboxes = []
+                            container_type = container_types[0] if container_types else "row"  # Default to row
+                            
+                            L_proximity_val = compute_proximity_ratio_loss(
+                                [container_bbox],
+                                [child_bboxes],
+                                [grandchild_bboxes],
+                                [container_type],
+                                container_weights=[1.0] if container_weights is None else container_weights,
+                                epsilon=params.PROXIMITY_EPSILON,
+                                device=device
+                            )
+                        else:
+                            generated_bboxes_proximity_log = [(bbox[0].item(), bbox[1].item(), bbox[2].item(), bbox[3].item()) for bbox in bboxes_log]
+                            if len(child_bboxes_list) > 0 and len(child_bboxes_list[0]) == num_nodes:
+                                updated_child_bboxes_list_log = [generated_bboxes_proximity_log] + child_bboxes_list[1:]
+                            else:
+                                updated_child_bboxes_list_log = child_bboxes_list
+                            
+                            L_proximity_val = compute_proximity_ratio_loss(
+                                container_bboxes,
+                                updated_child_bboxes_list_log,
+                                grandchild_bboxes_list,
+                                container_types,
+                                container_weights,
+                                epsilon=params.PROXIMITY_EPSILON,
+                                device=device
+                            )
+                    
+                    # Compute data ink loss for logging
+                    L_data_ink_val = -A_union
+                    
+                    # Compute visual balance loss for logging (using bboxes_log)
+                    L_visual_balance_val = compute_visual_balance_loss(
+                        bboxes_log, Wc, Hc, device=device
+                    )
+                    
+                    # Compute total loss for visualization
+                    g_val = A_inter
+                    total_loss_val = (lam.item() * g_val.item() + 0.5 * rho.item() * g_val.item() * g_val.item() +
+                                     pen_weight * L_pen_val.item() +
+                                     w_similarity * L_similarity_val.item() +
+                                     w_readability * L_readability_val.item() +
+                                     w_alignment_consistency * L_alignment_consistency_val.item() +
+                                     w_alignment_similarity * L_alignment_similarity_val.item() +
+                                     w_proximity * L_proximity_val.item() +
+                                     w_data_ink * L_data_ink_val.item() +
+                                     w_visual_balance * L_visual_balance_val.item())
+                    
+                    print(f"[outer {k:02d}] tau={tau_px:.3f}  A_union={A_union.item():.2f}  A_inter={A_inter.item():.6f}  "
+                          f"L_pen={pen_weight*L_pen_val.item():.4f}  L_sim={w_similarity*L_similarity_val.item():.4f}  "
+                          f"L_read={w_readability*L_readability_val.item():.4f}  "
+                          f"L_align_cons={w_alignment_consistency*L_alignment_consistency_val.item():.4f}  "
+                          f"L_align_sim={w_alignment_similarity*L_alignment_similarity_val.item():.4f}  "
+                          f"L_prox={w_proximity*L_proximity_val.item():.4f}  "
+                          f"L_data_ink={w_data_ink*L_data_ink_val.item():.4f}  "
+                          f"L_balance={w_visual_balance*L_visual_balance_val.item():.4f}  "
+                          f"lam={lam.item():.3e}  rho={rho.item():.3e}")
+                    
+                    # Visualize optimization progress at end of each outer epoch
+                    # Use full resolution for visualization
+                    X_viz, Y_viz = make_container_grid(Hc, Wc, device=device)
+                    epoch_bboxes = []
+                    epoch_softmasks = []
+                    for i, bbox_log in enumerate(bboxes_log):
+                        x, y, w, h = bbox_log
+                        epoch_bboxes.append((x.item(), y.item(), w.item(), h.item()))
+                        m_viz, _ = sdf_to_softmask(sdf_tensors[i], x, y, w, h, X_viz, Y_viz, tau_px=tau_px)
+                        epoch_softmasks.append(m_viz)
+                    
+                    epoch_loss_info = {
+                        'total': total_loss_val,
+                        'A_union': A_union.item(),
+                        'A_inter': A_inter.item(),
+                        'pen': L_pen_val.item(),
+                        'similarity': w_similarity * L_similarity_val.item(),
+                        'readability': w_readability * L_readability_val.item(),
+                        'alignment': w_alignment_consistency * L_alignment_consistency_val.item() + w_alignment_similarity * L_alignment_similarity_val.item(),
+                        'alignment_consistency': w_alignment_consistency * L_alignment_consistency_val.item(),
+                        'alignment_similarity': w_alignment_similarity * L_alignment_similarity_val.item(),
+                        'proximity': w_proximity * L_proximity_val.item(),
+                        'data_ink': w_data_ink * L_data_ink_val.item(),
+                    }
+                    
+                    epoch_save_path = os.path.join(viz_folder, f"stage{stage_idx}_epoch{k:02d}.png")
+                    
+                    visualize_optimization_progress(
+                        epoch_softmasks, epoch_bboxes, Wc, Hc,
+                        epoch=k, loss_info=epoch_loss_info,
+                        save_path=epoch_save_path
+                    )
+                else:
+                    # Non-debug mode: simple logging
+                    print(f"[outer {k:02d}] tau={tau_px:.3f}  A_inter={A_inter.item():.6f}  lam={lam.item():.3e}  rho={rho.item():.3e}")
+
+    # final bbox (continuous)
+    final_bboxes = []
+    with torch.no_grad():
+        for i in range(num_nodes):
+            tx_idx = i * 3
+            ty_idx = i * 3 + 1
+            ts_idx = i * 3 + 2
+            tx = opt_params[tx_idx]
+            ty = opt_params[ty_idx]
+            ts = opt_params[ts_idx]
+            
+            min_width, min_height = min_sizes[i]
+            x, y, w, h = bbox_aspect_from_unconstrained(
+                tx, ty, ts, Wc, Hc, ratios[i],
+                min_width=min_width, min_height=min_height,
+                size_min=size_min
+            )
+            final_bboxes.append((x.item(), y.item(), w.item(), h.item()))
+
+    # hard evaluation at full 1000x1000: overlap using (SDF<0) AND
+    with torch.no_grad():
+        Xf, Yf = make_container_grid(Hc, Wc, device=device)
+        # use a small tau for union display (not needed for hard overlap)
+        softmasks_f = []
+        distances_f = []
+        for i in range(num_nodes):
+            x, y, w, h = final_bboxes[i]
+            m, d_px = sdf_to_softmask(sdf_tensors[i], 
+                                     torch.tensor(x, device=device), 
+                                     torch.tensor(y, device=device),
+                                     torch.tensor(w, device=device), 
+                                     torch.tensor(h, device=device), 
+                                     Xf, Yf, tau_px=0.2)
+            softmasks_f.append(m)
+            distances_f.append(d_px)
+
+        # Compute union
+        union_f = torch.ones_like(softmasks_f[0])
+        for m in softmasks_f:
+            union_f = union_f * (1.0 - m)
+        union_f = 1.0 - union_f
+        A_union_f = union_f.sum().item()  # da=1 at full res
+        
+        # hard inside test: d_px < 0 for all pairs
+        hard_overlap = torch.zeros_like(softmasks_f[0])
+        for i in range(num_nodes):
+            for j in range(i + 1, num_nodes):
+                overlap_ij = ((distances_f[i] < 0.0) & (distances_f[j] < 0.0)).float()
+                hard_overlap = hard_overlap + overlap_ij
+        A_overlap_hard = hard_overlap.sum().item()
+
+    # print("\n=== Final Results ===")
+    # for i, bbox in enumerate(final_bboxes):
+    #     print(f"bbox{i+1} (x,y,w,h) = {bbox}")
+    # print(f"Union area (approx, {Wc}x{Hc}) = {A_union_f:.2f}  -> ratio {A_union_f/(Wc*Hc):.4f}")
+    # print(f"Hard overlap area (SDF<0)       = {A_overlap_hard:.0f} pixels")
+
+    # Save visualization and composite images (only in debug mode)
+    if debug:
+        # Determine save paths based on prefix (save to visualization folder)
+        if save_prefix:
+            final_result_path = os.path.join(viz_folder, f"{save_prefix}_final_result.png")
+            composite_result_path = os.path.join(viz_folder, f"{save_prefix}_composite_result.png")
+        else:
+            final_result_path = os.path.join(viz_folder, "final_result.png")
+            composite_result_path = os.path.join(viz_folder, "composite_result.png")
+        
+        # Visualize final result (only for 2 nodes, skip for N nodes)
+        # TODO: Extend visualize_final_result to support N nodes
+        if num_nodes == 2:
+            mask1_orig = load_binary_mask_from_rgba(png_list[0])
+            mask2_orig = load_binary_mask_from_rgba(png_list[1])
+            if mask1_orig is not None and mask2_orig is not None:
+                visualize_final_result(softmasks_f[0], softmasks_f[1], distances_f[0], distances_f[1], 
+                                      final_bboxes[0], final_bboxes[1], 
+                                      mask1_orig, mask2_orig, Wc, Hc, 
+                                      save_path=final_result_path)
+        
+        # Save composite image with original images
+        # Use original paths if provided, otherwise use the paths passed to optimize
+        save_png_list = []
+        for i in range(num_nodes):
+            orig_png = original_png_list[i] if i < len(original_png_list) and original_png_list[i] is not None else png_list[i]
+            save_png_list.append(orig_png)
+        
+        if all(png is not None for png in save_png_list):
+            save_composite_image(png_list=save_png_list, bbox_list=final_bboxes, Wc=Wc, Hc=Hc, 
+                               save_path=composite_result_path)
+        else:
+            print(f"Warning: Skipping composite image save - some image paths are None")
+
+    return final_bboxes
+

modules/infographics_generator/layout_system/sdf/visualization.py

@@ -0,0 +1,634 @@
+"""Visualization functions for SDF-based layout optimization."""
+
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+from typing import List, Tuple, Dict
+import torch
+
+from .core import make_container_grid, sdf_to_softmask
+
+
+# -----------------------------
+# Visualize SDF normalization and softmask conversion
+# -----------------------------
+def visualize_sdf_norm_and_softmask(sdf_norm: np.ndarray, mask: np.ndarray,
+                                    bbox: tuple = None, container_size: tuple = None,
+                                    tau_values: list = [0.5, 1.0, 1.5, 2.0],
+                                    save_path: str = None):
+    """
+    Visualize SDF normalization and sdf_to_softmask conversion process.
+    
+    Args:
+        sdf_norm: Normalized SDF array [H, W]
+        mask: Original binary mask [H, W]
+        bbox: Optional bounding box (x, y, w, h) for softmask visualization
+        container_size: Optional container size (W, H) for softmask visualization
+        tau_values: List of tau values to visualize for softmask conversion
+        save_path: Optional path to save the figure
+    """
+    fig = plt.figure(figsize=(20, 12))
+    
+    # Row 1: SDF normalization visualization
+    # Original mask
+    ax1 = plt.subplot(3, 4, 1)
+    ax1.imshow(mask, cmap='gray', interpolation='bilinear')
+    ax1.set_title('Original Binary Mask', fontsize=11, fontweight='bold')
+    ax1.set_xlabel('Width')
+    ax1.set_ylabel('Height')
+    
+    # SDF normalized - full range
+    ax2 = plt.subplot(3, 4, 2)
+    im2 = ax2.imshow(sdf_norm, cmap='RdYlBu', interpolation='bilinear')
+    ax2.contour(sdf_norm, levels=[0], colors='black', linewidths=2)
+    ax2.set_title(f'SDF Normalized (Full Range)\n[{sdf_norm.min():.3f}, {sdf_norm.max():.3f}]', 
+                  fontsize=11, fontweight='bold')
+    ax2.set_xlabel('Width')
+    ax2.set_ylabel('Height')
+    plt.colorbar(im2, ax=ax2, label='SDF Value')
+    
+    # SDF normalized - zoomed range around zero
+    ax3 = plt.subplot(3, 4, 3)
+    sdf_range = 0.1
+    vmin, vmax = -sdf_range, sdf_range
+    im3 = ax3.imshow(sdf_norm, cmap='RdYlBu', interpolation='bilinear', vmin=vmin, vmax=vmax)
+    ax3.contour(sdf_norm, levels=[0], colors='black', linewidths=2)
+    ax3.contour(sdf_norm, levels=np.linspace(-sdf_range, sdf_range, 11), 
+                colors='gray', linewidths=0.5, alpha=0.3)
+    ax3.set_title(f'SDF Normalized (Zoomed)\nRange: [-{sdf_range}, {sdf_range}]', 
+                  fontsize=11, fontweight='bold')
+    ax3.set_xlabel('Width')
+    ax3.set_ylabel('Height')
+    plt.colorbar(im3, ax=ax3, label='SDF Value')
+    
+    # SDF histogram
+    ax4 = plt.subplot(3, 4, 4)
+    ax4.hist(sdf_norm.flatten(), bins=100, alpha=0.7, edgecolor='black')
+    ax4.axvline(x=0, color='red', linestyle='--', linewidth=2, label='Zero level')
+    ax4.set_title('SDF Value Distribution', fontsize=11, fontweight='bold')
+    ax4.set_xlabel('SDF Value')
+    ax4.set_ylabel('Frequency')
+    ax4.legend()
+    ax4.grid(True, alpha=0.3)
+    
+    # Row 2-3: Softmask conversion with different tau values
+    if bbox is not None and container_size is not None:
+        x, y, w, h = bbox
+        Wc, Hc = container_size
+        
+        # Convert to torch tensors
+        sdf_norm_t = torch.from_numpy(sdf_norm)[None, None].float()
+        device = sdf_norm_t.device
+        
+        # Create container grid
+        X, Y = make_container_grid(Hc, Wc, device=device)
+        
+        # Visualize softmask for different tau values
+        # Layout: Row 2-3, each row has 2 tau values, each tau has 2 subplots (mask + distance)
+        for idx, tau_px in enumerate(tau_values):
+            # Row: 1 (idx 0-1) or 2 (idx 2-3)
+            row = 1 + idx // 2
+            # Column: 1-2 (idx 0) or 3-4 (idx 1) for row 1, 1-2 (idx 2) or 3-4 (idx 3) for row 2
+            col_offset = (idx % 2) * 2  # 0 or 2
+            
+            # Convert bbox values to torch tensors for sdf_to_softmask
+            x_t = torch.tensor(x, device=device, dtype=torch.float32)
+            y_t = torch.tensor(y, device=device, dtype=torch.float32)
+            w_t = torch.tensor(w, device=device, dtype=torch.float32)
+            h_t = torch.tensor(h, device=device, dtype=torch.float32)
+            
+            # Compute softmask
+            m, d_px = sdf_to_softmask(sdf_norm_t, x_t, y_t, w_t, h_t, X, Y, tau_px=tau_px)
+            m_np = m.squeeze().cpu().numpy()
+            d_px_np = d_px.squeeze().cpu().numpy()
+            
+            # Softmask visualization - position: row*4 + col_offset + 1
+            ax_mask = plt.subplot(3, 4, row * 4 + col_offset + 1)
+            im_mask = ax_mask.imshow(m_np, cmap='viridis', interpolation='bilinear', vmin=0, vmax=1)
+            rect = plt.Rectangle((x, y), w, h, linewidth=2, edgecolor='red', facecolor='none')
+            ax_mask.add_patch(rect)
+            ax_mask.set_title(f'Softmask (τ={tau_px:.1f}px)', fontsize=11, fontweight='bold')
+            ax_mask.set_xlabel('Width')
+            ax_mask.set_ylabel('Height')
+            ax_mask.set_xlim(0, Wc)
+            ax_mask.set_ylim(Hc, 0)
+            plt.colorbar(im_mask, ax=ax_mask, label='Mask Value')
+            
+            # Distance visualization - position: row*4 + col_offset + 2
+            ax_dist = plt.subplot(3, 4, row * 4 + col_offset + 2)
+            d_range = 5.0  # Show distance range
+            im_dist = ax_dist.imshow(d_px_np, cmap='coolwarm', interpolation='bilinear', 
+                                     vmin=-d_range, vmax=d_range)
+            ax_dist.contour(d_px_np, levels=[0], colors='black', linewidths=2)
+            rect_dist = plt.Rectangle((x, y), w, h, linewidth=2, edgecolor='red', facecolor='none')
+            ax_dist.add_patch(rect_dist)
+            ax_dist.set_title(f'Distance (τ={tau_px:.1f}px)\nRange: [-{d_range}, {d_range}]px', 
+                             fontsize=11, fontweight='bold')
+            ax_dist.set_xlabel('Width')
+            ax_dist.set_ylabel('Height')
+            ax_dist.set_xlim(0, Wc)
+            ax_dist.set_ylim(Hc, 0)
+            plt.colorbar(im_dist, ax=ax_dist, label='Distance (px)')
+    
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path, dpi=150, bbox_inches='tight')
+        print(f"SDF norm and softmask visualization saved to: {save_path}")
+    else:
+        plt.show()
+    
+    plt.close()
+
+
+# -----------------------------
+# Visualize SDF
+# -----------------------------
+def visualize_sdf(sdf1: np.ndarray, sdf2: np.ndarray, 
+                  mask1: np.ndarray = None, mask2: np.ndarray = None,
+                  save_path: str = None, sdf_range: float = 0.1):
+    """
+    Visualize two SDFs side by side with heatmaps and zero contours.
+    
+    Args:
+        sdf1: First SDF array [H, W]
+        sdf2: Second SDF array [H, W]
+        mask1: Optional original mask for first image
+        mask2: Optional original mask for second image
+        save_path: Optional path to save the figure
+        sdf_range: Range of SDF values to display around zero (default 0.1)
+    """
+    fig, axes = plt.subplots(2, 2, figsize=(14, 14))
+    
+    # SDF 1 visualization - limit range for finer detail
+    ax1 = axes[0, 0]
+    vmin1, vmax1 = -sdf_range, sdf_range
+    im1 = ax1.imshow(sdf1, cmap='RdYlBu', interpolation='bilinear', 
+                     vmin=vmin1, vmax=vmax1)
+    # Add multiple contour lines for detail
+    ax1.contour(sdf1, levels=[0], colors='black', linewidths=2)
+    ax1.contour(sdf1, levels=np.linspace(-sdf_range, sdf_range, 11), 
+                colors='gray', linewidths=0.5, alpha=0.3)
+    ax1.set_title('SDF 1 (chart.png)', fontsize=12, fontweight='bold')
+    ax1.set_xlabel('Width')
+    ax1.set_ylabel('Height')
+    plt.colorbar(im1, ax=ax1, label='SDF Value')
+    
+    # SDF 2 visualization - limit range for finer detail
+    ax2 = axes[0, 1]
+    vmin2, vmax2 = -sdf_range, sdf_range
+    im2 = ax2.imshow(sdf2, cmap='RdYlBu', interpolation='bilinear',
+                     vmin=vmin2, vmax=vmax2)
+    # Add multiple contour lines for detail
+    ax2.contour(sdf2, levels=[0], colors='black', linewidths=2)
+    ax2.contour(sdf2, levels=np.linspace(-sdf_range, sdf_range, 11), 
+                colors='gray', linewidths=0.5, alpha=0.3)
+    ax2.set_title('SDF 2 (pictogram.png)', fontsize=12, fontweight='bold')
+    ax2.set_xlabel('Width')
+    ax2.set_ylabel('Height')
+    plt.colorbar(im2, ax=ax2, label='SDF Value')
+    
+    # Original masks if provided
+    if mask1 is not None:
+        ax3 = axes[1, 0]
+        ax3.imshow(mask1, cmap='gray', interpolation='bilinear')
+        ax3.set_title('Original Mask 1', fontsize=12, fontweight='bold')
+        ax3.set_xlabel('Width')
+        ax3.set_ylabel('Height')
+    
+    if mask2 is not None:
+        ax4 = axes[1, 1]
+        ax4.imshow(mask2, cmap='gray', interpolation='bilinear')
+        ax4.set_title('Original Mask 2', fontsize=12, fontweight='bold')
+        ax4.set_xlabel('Width')
+        ax4.set_ylabel('Height')
+    
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path, dpi=150, bbox_inches='tight')
+        print(f"SDF visualization saved to: {save_path}")
+    else:
+        plt.show()
+    
+    plt.close()
+
+
+# -----------------------------
+# Visualize optimization progress
+# -----------------------------
+def visualize_optimization_progress(
+    softmasks: List[torch.Tensor],
+    bboxes: List[Tuple[float, float, float, float]],
+    Wc: int, Hc: int,
+    epoch: int = -1,  # -1 for initial, >=0 for epoch number
+    loss_info: Dict[str, float] = None,
+    save_path: str = None
+):
+    """
+    Visualize optimization progress showing current layout and loss information.
+    
+    Args:
+        softmasks: List of soft masks for each node [1,1,H,W]
+        bboxes: List of bounding boxes (x, y, w, h) for each node
+        Wc: Container width
+        Hc: Container height
+        epoch: Epoch number (-1 for initial, >=0 for epoch number)
+        loss_info: Dictionary with loss values (keys: 'total', 'pen', 'similarity', 'readability', 
+                  'alignment', 'proximity', 'data_ink', 'A_union', 'A_inter', etc.)
+        save_path: Path to save the figure
+    """
+    num_nodes = len(softmasks)
+    
+    # Convert tensors to numpy
+    masks_np = []
+    for m in softmasks:
+        masks_np.append(m.squeeze().cpu().numpy())
+    
+    # Create figure with subplots
+    fig = plt.figure(figsize=(16, 10))
+    
+    # Main layout visualization (left side)
+    ax_main = plt.subplot(1, 2, 1)
+    
+    # Create combined visualization
+    combined = np.zeros((Hc, Wc, 3))
+    colors = plt.cm.tab10(np.linspace(0, 1, num_nodes))
+    
+    # Compute union mask for visual balance calculation
+    union_mask = np.ones((Hc, Wc))
+    for mask_np in masks_np:
+        union_mask = union_mask * (1.0 - mask_np)
+    union_mask = 1.0 - union_mask
+    
+    for i, (mask_np, bbox) in enumerate(zip(masks_np, bboxes)):
+        x, y, w, h = bbox
+        # Use different colors for each node
+        combined[:, :, 0] += mask_np * colors[i][0]  # Red channel
+        combined[:, :, 1] += mask_np * colors[i][1]  # Green channel
+        combined[:, :, 2] += mask_np * colors[i][2]  # Blue channel
+        
+        # Draw bbox rectangle
+        rect = plt.Rectangle((x, y), w, h, linewidth=2, edgecolor=colors[i], 
+                            facecolor='none', linestyle='--')
+        ax_main.add_patch(rect)
+    
+    # Normalize combined image
+    combined = np.clip(combined, 0, 1)
+    ax_main.imshow(combined, interpolation='bilinear')
+    ax_main.set_xlim(0, Wc)
+    ax_main.set_ylim(Hc, 0)
+    ax_main.set_xlabel('Width (px)', fontsize=12)
+    ax_main.set_ylabel('Height (px)', fontsize=12)
+    
+    title = "Initial Layout" if epoch < 0 else f"Epoch {epoch}"
+    ax_main.set_title(title, fontsize=14, fontweight='bold')
+    
+    # Add bbox labels
+    for i, bbox in enumerate(bboxes):
+        x, y, w, h = bbox
+        ax_main.text(x + w/2, y + h/2, f"Node {i+1}", 
+                    ha='center', va='center', fontsize=10, fontweight='bold',
+                    color='white', bbox=dict(boxstyle='round', facecolor='black', alpha=0.5))
+    
+    # Visual balance visualization: show centroid and container center
+    total_mass = union_mask.sum()
+    if total_mass > 1e-8:
+        # Calculate centroid
+        x_coords = np.arange(Wc)
+        y_coords = np.arange(Hc)
+        x_grid, y_grid = np.meshgrid(x_coords, y_coords)
+        
+        centroid_x = (union_mask * x_grid).sum() / total_mass
+        centroid_y = (union_mask * y_grid).sum() / total_mass
+        
+        # Container center
+        center_x = Wc / 2.0
+        center_y = Hc / 2.0
+        
+        # Draw container center (green cross)
+        ax_main.plot(center_x, center_y, 'g+', markersize=15, markeredgewidth=3, 
+                    label='Container Center', zorder=10)
+        
+        # Draw centroid (red circle)
+        ax_main.plot(centroid_x, centroid_y, 'ro', markersize=10, markeredgewidth=2,
+                    label='Centroid', zorder=10)
+        
+        # Draw line connecting centroid to center
+        ax_main.plot([centroid_x, center_x], [centroid_y, center_y], 
+                    'r--', linewidth=2, alpha=0.7, label='Balance Distance', zorder=9)
+        
+        # Add distance annotation
+        distance = np.sqrt((centroid_x - center_x)**2 + (centroid_y - center_y)**2)
+        mid_x = (centroid_x + center_x) / 2
+        mid_y = (centroid_y + center_y) / 2
+        ax_main.annotate(f'd={distance:.1f}px', 
+                        xy=(mid_x, mid_y), xytext=(5, 5), textcoords='offset points',
+                        fontsize=9, color='red', fontweight='bold',
+                        bbox=dict(boxstyle='round,pad=0.3', facecolor='yellow', alpha=0.7))
+        
+        ax_main.legend(loc='upper right', fontsize=9)
+    
+    # Loss information (right side)
+    ax_info = plt.subplot(1, 2, 2)
+    ax_info.axis('off')
+    
+    # Build loss info text
+    info_lines = []
+    info_lines.append("Optimization Progress")
+    info_lines.append("=" * 30)
+    info_lines.append("")
+    
+    if epoch >= 0:
+        info_lines.append(f"Epoch: {epoch}")
+    else:
+        info_lines.append("Stage: Initial")
+    
+    info_lines.append("")
+    info_lines.append("Layout Information:")
+    info_lines.append(f"  Container: {Wc} x {Hc} px")
+    info_lines.append(f"  Number of nodes: {num_nodes}")
+    info_lines.append("")
+    info_lines.append("Node Bounding Boxes:")
+    info_lines.append("-" * 30)
+    for i, bbox in enumerate(bboxes):
+        x, y, w, h = bbox
+        info_lines.append(f"  Node {i+1}:")
+        info_lines.append(f"    x: {x:.2f} px")
+        info_lines.append(f"    y: {y:.2f} px")
+        info_lines.append(f"    w: {w:.2f} px")
+        info_lines.append(f"    h: {h:.2f} px")
+        info_lines.append("")
+    
+    if loss_info:
+        info_lines.append("Loss Values:")
+        info_lines.append("-" * 30)
+        
+        if 'total' in loss_info:
+            info_lines.append(f"  Total Loss: {loss_info['total']:.6f}")
+        
+        if 'A_union' in loss_info:
+            info_lines.append(f"  Union Area: {loss_info['A_union']:.2f} px²")
+        
+        if 'A_inter' in loss_info:
+            info_lines.append(f"  Intersection: {loss_info['A_inter']:.6f} px²")
+        
+        info_lines.append("")
+        info_lines.append("Loss Components:")
+        info_lines.append("-" * 30)
+        
+        if 'pen' in loss_info:
+            info_lines.append(f"  Penetration: {loss_info['pen']:.6f}")
+        
+        if 'similarity' in loss_info:
+            info_lines.append(f"  Similarity: {loss_info['similarity']:.6f}")
+        
+        if 'readability' in loss_info:
+            info_lines.append(f"  Readability: {loss_info['readability']:.6f}")
+        
+        if 'alignment' in loss_info:
+            info_lines.append(f"  Alignment: {loss_info['alignment']:.6f}")
+        
+        if 'proximity' in loss_info:
+            info_lines.append(f"  Proximity: {loss_info['proximity']:.6f}")
+        
+        if 'data_ink' in loss_info:
+            info_lines.append(f"  Data Ink: {loss_info['data_ink']:.6f}")
+        
+        if 'visual_balance' in loss_info:
+            info_lines.append(f"  Visual Balance: {loss_info['visual_balance']:.6f}")
+    
+    # Display text
+    info_text = "\n".join(info_lines)
+    ax_info.text(0.1, 0.95, info_text, transform=ax_info.transAxes,
+                fontsize=11, verticalalignment='top', fontfamily='monospace',
+                bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8))
+    
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path, dpi=150, bbox_inches='tight')
+        print(f"Optimization progress visualization saved to: {save_path}")
+    else:
+        plt.show()
+    
+    plt.close()
+
+
+# -----------------------------
+# Visualize final layout result
+# -----------------------------
+def visualize_final_result(m1f: torch.Tensor, m2f: torch.Tensor, 
+                           d1f_px: torch.Tensor, d2f_px: torch.Tensor,
+                           bbox1: tuple, bbox2: tuple,
+                           mask1: np.ndarray, mask2: np.ndarray,
+                           Wc: int, Hc: int,
+                           save_path: str = None):
+    """
+    Visualize the final optimization result showing layout, masks, and overlap.
+    
+    Args:
+        m1f: Final soft mask for object 1 [1,1,H,W]
+        m2f: Final soft mask for object 2 [1,1,H,W]
+        d1f_px: Final SDF distance for object 1 [1,1,H,W]
+        d2f_px: Final SDF distance for object 2 [1,1,H,W]
+        bbox1: Bounding box (x, y, w, h) for object 1
+        bbox2: Bounding box (x, y, w, h) for object 2
+        mask1: Original mask for object 1
+        mask2: Original mask for object 2
+        Wc: Container width
+        Hc: Container height
+        save_path: Optional path to save the figure
+    """
+    # Convert tensors to numpy
+    m1_np = m1f.squeeze().cpu().numpy()
+    m2_np = m2f.squeeze().cpu().numpy()
+    d1_np = d1f_px.squeeze().cpu().numpy()
+    d2_np = d2f_px.squeeze().cpu().numpy()
+    
+    # Compute union and intersection
+    union = 1.0 - (1.0 - m1_np) * (1.0 - m2_np)
+    inter = m1_np * m2_np
+    hard_overlap = ((d1_np < 0.0) & (d2_np < 0.0)).astype(np.float32)
+    
+    fig, axes = plt.subplots(2, 3, figsize=(18, 12))
+    
+    # Row 1: Individual masks
+    ax1 = axes[0, 0]
+    ax1.imshow(m1_np, cmap='gray', interpolation='bilinear')
+    x1, y1, w1, h1 = bbox1
+    rect1 = plt.Rectangle((x1, y1), w1, h1, linewidth=2, edgecolor='red', facecolor='none')
+    ax1.add_patch(rect1)
+    ax1.set_title(f'Object 1 Mask\nbbox: ({x1:.1f}, {y1:.1f}, {w1:.1f}, {h1:.1f})', 
+                  fontsize=11, fontweight='bold')
+    ax1.set_xlabel('Width')
+    ax1.set_ylabel('Height')
+    ax1.set_xlim(0, Wc)
+    ax1.set_ylim(Hc, 0)
+    
+    ax2 = axes[0, 1]
+    ax2.imshow(m2_np, cmap='gray', interpolation='bilinear')
+    x2, y2, w2, h2 = bbox2
+    rect2 = plt.Rectangle((x2, y2), w2, h2, linewidth=2, edgecolor='blue', facecolor='none')
+    ax2.add_patch(rect2)
+    ax2.set_title(f'Object 2 Mask\nbbox: ({x2:.1f}, {y2:.1f}, {w2:.1f}, {h2:.1f})', 
+                  fontsize=11, fontweight='bold')
+    ax2.set_xlabel('Width')
+    ax2.set_ylabel('Height')
+    ax2.set_xlim(0, Wc)
+    ax2.set_ylim(Hc, 0)
+    
+    # Combined view
+    ax3 = axes[0, 2]
+    combined = np.zeros((Hc, Wc, 3))
+    combined[:, :, 0] = m1_np  # Red channel for object 1
+    combined[:, :, 2] = m2_np  # Blue channel for object 2
+    combined[:, :, 1] = inter  # Green channel for intersection
+    ax3.imshow(combined, interpolation='bilinear')
+    rect1_comb = plt.Rectangle((x1, y1), w1, h1, linewidth=2, edgecolor='red', 
+                               facecolor='none', linestyle='--')
+    rect2_comb = plt.Rectangle((x2, y2), w2, h2, linewidth=2, edgecolor='blue', 
+                               facecolor='none', linestyle='--')
+    ax3.add_patch(rect1_comb)
+    ax3.add_patch(rect2_comb)
+    ax3.set_title('Combined Layout\n(Red: Obj1, Blue: Obj2, Green: Overlap)', 
+                  fontsize=11, fontweight='bold')
+    ax3.set_xlabel('Width')
+    ax3.set_ylabel('Height')
+    ax3.set_xlim(0, Wc)
+    ax3.set_ylim(Hc, 0)
+    
+    # Row 2: Union, Intersection, and Hard Overlap
+    ax4 = axes[1, 0]
+    im4 = ax4.imshow(union, cmap='viridis', interpolation='bilinear')
+    ax4.set_title('Union Area', fontsize=11, fontweight='bold')
+    ax4.set_xlabel('Width')
+    ax4.set_ylabel('Height')
+    plt.colorbar(im4, ax=ax4, label='Union Value')
+    
+    ax5 = axes[1, 1]
+    im5 = ax5.imshow(inter, cmap='hot', interpolation='bilinear')
+    ax5.set_title('Intersection Area (Soft)', fontsize=11, fontweight='bold')
+    ax5.set_xlabel('Width')
+    ax5.set_ylabel('Height')
+    plt.colorbar(im5, ax=ax5, label='Intersection Value')
+    
+    ax6 = axes[1, 2]
+    im6 = ax6.imshow(hard_overlap, cmap='Reds', interpolation='bilinear')
+    ax6.set_title('Hard Overlap (SDF < 0)', fontsize=11, fontweight='bold')
+    ax6.set_xlabel('Width')
+    ax6.set_ylabel('Height')
+    plt.colorbar(im6, ax=ax6, label='Overlap')
+    
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path, dpi=150, bbox_inches='tight')
+        print(f"Final result visualization saved to: {save_path}")
+    else:
+        plt.show()
+    
+    plt.close()
+
+
+# -----------------------------
+# Save composite image with original images placed according to optimized layout
+# -----------------------------
+def save_composite_image(png1: str = None, png2: str = None, bbox1: tuple = None, bbox2: tuple = None,
+                        png_list: List[str] = None, bbox_list: List[tuple] = None,
+                        Wc: int = 1000, Hc: int = 1000, save_path: str = "composite_result.png"):
+    """
+    Load original PNG images and composite them according to optimized bbox positions.
+    
+    Supports both legacy 2-node format and new N-node format.
+    
+    Args:
+        png1: Legacy - Path to first image (for backward compatibility)
+        png2: Legacy - Path to second image (for backward compatibility)
+        bbox1: Legacy - Bounding box (x, y, w, h) for first image
+        bbox2: Legacy - Bounding box (x, y, w, h) for second image
+        png_list: List of image paths for N nodes
+        bbox_list: List of bounding boxes (x, y, w, h) for N nodes
+        Wc: Container width
+        Hc: Container height
+        save_path: Path to save the composite image
+    """
+    import os
+    
+    # Handle backward compatibility: convert png1/png2 to png_list
+    if png_list is None:
+        if png1 is not None and png2 is not None:
+            png_list = [png1, png2]
+            bbox_list = [bbox1, bbox2]
+        else:
+            raise ValueError("Either (png_list, bbox_list) or (png1, png2, bbox1, bbox2) must be provided")
+    
+    if bbox_list is None:
+        raise ValueError("bbox_list must be provided")
+    
+    if len(png_list) != len(bbox_list):
+        raise ValueError(f"Mismatch: {len(png_list)} images but {len(bbox_list)} bboxes")
+    
+    num_nodes = len(png_list)
+    if num_nodes == 0:
+        print("Warning: No images to composite")
+        return
+    
+    # Check if paths are valid
+    for i, png_path in enumerate(png_list):
+        if png_path is None:
+            print(f"Warning: Image path at index {i} is None")
+            return
+        if not os.path.exists(png_path):
+            print(f"Warning: Image file not found: {png_path}")
+            return
+    
+    print(f"Loading {num_nodes} images for composite")
+    print(f"Container size: {Wc}x{Hc}")
+    
+    # Create output canvas
+    canvas = Image.new("RGBA", (Wc, Hc), (255, 255, 255, 255))
+    
+    # Place all images
+    for i, (png_path, bbox) in enumerate(zip(png_list, bbox_list)):
+        x, y, w, h = bbox
+        x_int = int(x)
+        y_int = int(y)
+        w_int = max(1, int(w))
+        h_int = max(1, int(h))
+        
+        if w_int > 0 and h_int > 0:
+            # Clip coordinates to canvas bounds
+            x_clip = max(0, min(x_int, Wc - 1))
+            y_clip = max(0, min(y_int, Hc - 1))
+            
+            # Calculate how much of the image fits in the canvas
+            x_end = min(x_clip + w_int, Wc)
+            y_end = min(y_clip + h_int, Hc)
+            w_fit = x_end - x_clip
+            h_fit = y_end - y_clip
+            
+            if w_fit > 0 and h_fit > 0:
+                # Load image
+                img = Image.open(png_path).convert("RGBA")
+                orig_w, orig_h = img.size
+                
+                img_resized = img.resize((w_int, h_int), Image.Resampling.LANCZOS)
+                # Crop image if it extends beyond canvas
+                if w_fit < w_int or h_fit < h_int:
+                    img_resized = img_resized.crop((0, 0, w_fit, h_fit))
+                canvas.paste(img_resized, (x_clip, y_clip), img_resized)
+                print(f"Placed image{i+1} ({png_path}) at ({x_clip}, {y_clip}) with size ({w_fit}, {h_fit})")
+            else:
+                print(f"Warning: Image{i+1} has no valid area to place: ({x_clip}, {y_clip}, {w_fit}, {h_fit})")
+        else:
+            print(f"Warning: Skipping image{i+1} - invalid size: ({w_int}, {h_int})")
+    
+    # Convert to RGB for saving (remove alpha channel)
+    canvas_rgb = Image.new("RGB", canvas.size, (255, 255, 255))
+    canvas_rgb.paste(canvas, mask=canvas.split()[3])  # Use alpha channel as mask
+    
+    # Save result
+    canvas_rgb.save(save_path, "PNG")
+    print(f"Composite image saved to: {save_path}")
+

modules/infographics_generator/layout_system/strategies/__init__.py

@@ -0,0 +1,12 @@
+"""Optimization strategies for layout optimization."""
+
+from .base import OptimizationStrategy
+from .sdf_strategy import SDFOptimizationStrategy
+from .rule_based_strategy import RuleBasedLayoutStrategy
+
+__all__ = [
+    'OptimizationStrategy',
+    'SDFOptimizationStrategy',
+    'RuleBasedLayoutStrategy',
+]
+

modules/infographics_generator/layout_system/strategies/base.py

@@ -0,0 +1,43 @@
+"""Base class for optimization strategies."""
+
+from abc import ABC, abstractmethod
+from typing import List, Tuple, Optional
+import numpy as np
+
+
+class OptimizationStrategy(ABC):
+    """Base class for optimization strategies."""
+    
+    @abstractmethod
+    def optimize(self, nodes: List[dict], container_bbox: Tuple[float, float, float, float],
+                 constraints: dict, config: dict) -> List[Tuple[float, float, float, float]]:
+        """Execute optimization and return bounding boxes for each node.
+        
+        Args:
+            nodes: List of node dictionaries with masks and metadata
+            container_bbox: Container bounding box (x, y, w, h)
+            constraints: Constraints dictionary from JSON
+            config: Optimization configuration
+        
+        Returns:
+            List of optimized bounding boxes (x, y, w, h) for each node
+        """
+        pass
+    
+    @abstractmethod
+    def composite(self, nodes: List[dict], bboxes: List[Tuple[float, float, float, float]],
+                  container_bbox: Tuple[float, float, float, float]) -> Tuple[np.ndarray, np.ndarray]:
+        """Composite optimized results and return mask and SDF.
+        
+        Args:
+            nodes: List of node dictionaries with masks and metadata
+            bboxes: List of optimized bounding boxes (x, y, w, h)
+            container_bbox: Container bounding box (x, y, w, h)
+        
+        Returns:
+            Tuple of (mask, sdf)
+            - mask: Composite mask array (H, W)
+            - sdf: Signed distance field array (H, W)
+        """
+        pass
+

modules/infographics_generator/layout_system/strategies/rule_based_strategy.py

@@ -0,0 +1,328 @@
+"""Rule-based layout strategy for simple row/column layouts.
+
+This strategy provides deterministic, fast layout calculation for simple
+row and column arrangements without requiring gradient-based optimization.
+"""
+
+import numpy as np
+from typing import List, Tuple, Dict, Any
+from .base import OptimizationStrategy
+
+
+class RuleBasedLayoutStrategy(OptimizationStrategy):
+    """Rule-based layout strategy for row/column layouts.
+    
+    This strategy calculates positions deterministically based on:
+    - Container type (row/column)
+    - Alignment constraints
+    - Gap/spacing between elements
+    
+    Much faster than SDF-based optimization for simple linear arrangements.
+    """
+    
+    def optimize(self, nodes: List[dict], container_bbox: Tuple[float, float, float, float],
+                 constraints: dict, config: dict, save_prefix: str = None) -> List[Tuple[float, float, float, float]]:
+        """Execute rule-based layout optimization.
+        
+        Args:
+            nodes: List of node dictionaries with "mask", "bbox" keys
+            container_bbox: Container bounding box (x, y, w, h)
+            constraints: Constraints dictionary (gap, alignment, etc.)
+            config: Configuration dictionary with container_type
+            save_prefix: Prefix for saving (unused in rule-based)
+        
+        Returns:
+            List of optimized bounding boxes (x, y, w, h) for each node
+        """
+        container_type = config.get("container_type", "row")
+        
+        print(f"[RuleBasedLayoutStrategy] Optimizing {len(nodes)} nodes in {container_type} layout")
+        
+        if len(nodes) == 0:
+            return []
+        
+        if len(nodes) == 1:
+            # Single node: just return its bbox
+            bbox = nodes[0].get("bbox", (0, 0, 100, 100))
+            return [self._normalize_bbox(bbox)]
+        
+        # Choose layout method based on container type
+        if container_type == "row":
+            return self._layout_row(nodes, container_bbox, constraints)
+        elif container_type == "column":
+            return self._layout_column(nodes, container_bbox, constraints)
+        else:
+            # Fallback to center alignment for unknown types
+            print(f"[RuleBasedLayoutStrategy] Warning: Unknown container type '{container_type}', using default layout")
+            return self._layout_default(nodes, container_bbox)
+    
+    def _layout_row(self, nodes: List[dict], container_bbox: Tuple[float, float, float, float],
+                    constraints: dict) -> List[Tuple[float, float, float, float]]:
+        """Layout nodes horizontally (left to right).
+        
+        Args:
+            nodes: List of nodes to layout
+            container_bbox: Container bounding box (x, y, w, h)
+            constraints: Layout constraints (gap, alignment)
+        
+        Returns:
+            List of positioned bounding boxes
+        """
+        x, y, container_w, container_h = container_bbox
+        
+        # Extract constraints
+        gap = self._get_gap(constraints)
+        alignment = self._get_alignment(constraints, default='center')
+        
+        # Calculate total content size and scale if needed
+        original_bboxes = []
+        total_width = 0.0
+        max_height = 0.0
+        
+        for node in nodes:
+            child_bbox = self._normalize_bbox(node.get("bbox", (0, 0, 100, 100)))
+            original_bboxes.append(child_bbox)
+            child_w = child_bbox[2]
+            child_h = child_bbox[3]
+            total_width += child_w
+            max_height = max(max_height, child_h)
+        
+        # Add gaps to total width
+        total_width += gap * (len(nodes) - 1)
+        
+        # Calculate scale factor to fit container (if needed)
+        scale_w = 1.0
+        scale_h = 1.0
+        
+        if total_width > container_w:
+            scale_w = container_w / total_width
+        if max_height > container_h:
+            scale_h = container_h / max_height
+        
+        # Use the smaller scale to maintain aspect ratio
+        scale = min(scale_w, scale_h)
+        
+        # Layout elements with scaling
+        current_x = x
+        optimized_bboxes = []
+        
+        for child_bbox in original_bboxes:
+            child_w = child_bbox[2] * scale
+            child_h = child_bbox[3] * scale
+            
+            # X position: sequential from left to right
+            child_x = current_x
+            
+            # Y position: based on alignment
+            child_y = self._calculate_cross_axis_position(
+                y, container_h, child_h, alignment, is_vertical=True
+            )
+            
+            optimized_bboxes.append((child_x, child_y, child_w, child_h))
+            current_x += child_w + gap * scale
+        
+        print(f"[RuleBasedLayoutStrategy] Row layout: gap={gap}, alignment={alignment}, scale={scale:.3f}")
+        return optimized_bboxes
+    
+    def _layout_column(self, nodes: List[dict], container_bbox: Tuple[float, float, float, float],
+                       constraints: dict) -> List[Tuple[float, float, float, float]]:
+        """Layout nodes vertically (top to bottom).
+        
+        Args:
+            nodes: List of nodes to layout
+            container_bbox: Container bounding box (x, y, w, h)
+            constraints: Layout constraints (gap, alignment)
+        
+        Returns:
+            List of positioned bounding boxes
+        """
+        x, y, container_w, container_h = container_bbox
+        
+        # Extract constraints
+        gap = self._get_gap(constraints)
+        alignment = self._get_alignment(constraints, default='center')
+        
+        # Calculate total content size and scale if needed
+        original_bboxes = []
+        total_height = 0.0
+        max_width = 0.0
+        
+        for node in nodes:
+            child_bbox = self._normalize_bbox(node.get("bbox", (0, 0, 100, 100)))
+            original_bboxes.append(child_bbox)
+            child_w = child_bbox[2]
+            child_h = child_bbox[3]
+            total_height += child_h
+            max_width = max(max_width, child_w)
+        
+        # Add gaps to total height
+        total_height += gap * (len(nodes) - 1)
+        
+        # Calculate scale factor to fit container (if needed)
+        scale_w = 1.0
+        scale_h = 1.0
+        
+        if max_width > container_w:
+            scale_w = container_w / max_width
+        if total_height > container_h:
+            scale_h = container_h / total_height
+        
+        # Use the smaller scale to maintain aspect ratio
+        scale = min(scale_w, scale_h)
+        
+        # Layout elements with scaling
+        current_y = y
+        optimized_bboxes = []
+        
+        for child_bbox in original_bboxes:
+            child_w = child_bbox[2] * scale
+            child_h = child_bbox[3] * scale
+            
+            # Y position: sequential from top to bottom
+            child_y = current_y
+            
+            # X position: based on alignment
+            child_x = self._calculate_cross_axis_position(
+                x, container_w, child_w, alignment, is_vertical=False
+            )
+            
+            optimized_bboxes.append((child_x, child_y, child_w, child_h))
+            current_y += child_h + gap * scale
+        
+        print(f"[RuleBasedLayoutStrategy] Column layout: gap={gap}, alignment={alignment}, scale={scale:.3f}")
+        return optimized_bboxes
+    
+    def _layout_default(self, nodes: List[dict], container_bbox: Tuple[float, float, float, float]
+                       ) -> List[Tuple[float, float, float, float]]:
+        """Default layout: center all nodes at their original positions.
+        
+        Fallback for unknown container types.
+        """
+        optimized_bboxes = []
+        for node in nodes:
+            child_bbox = self._normalize_bbox(node.get("bbox", (0, 0, 100, 100)))
+            optimized_bboxes.append(child_bbox)
+        return optimized_bboxes
+    
+    def _calculate_cross_axis_position(self, container_start: float, container_size: float,
+                                      child_size: float, alignment: str, is_vertical: bool) -> float:
+        """Calculate position on the cross axis based on alignment.
+        
+        Args:
+            container_start: Starting position of container (x or y)
+            container_size: Size of container (width or height)
+            child_size: Size of child element (width or height)
+            alignment: Alignment string ('left'/'top', 'center', 'right'/'bottom')
+            is_vertical: True if calculating Y position, False for X position
+        
+        Returns:
+            Position on cross axis
+        """
+        alignment_lower = alignment.lower()
+        
+        # Map alignment strings
+        if is_vertical:
+            # Vertical alignment (Y axis)
+            if alignment_lower in ['top', 'start', 'flex-start']:
+                return container_start
+            elif alignment_lower in ['center', 'middle']:
+                return container_start + (container_size - child_size) / 2
+            elif alignment_lower in ['bottom', 'end', 'flex-end']:
+                return container_start + container_size - child_size
+            else:
+                # Default: center
+                return container_start + (container_size - child_size) / 2
+        else:
+            # Horizontal alignment (X axis)
+            if alignment_lower in ['left', 'start', 'flex-start']:
+                return container_start
+            elif alignment_lower in ['center', 'middle']:
+                return container_start + (container_size - child_size) / 2
+            elif alignment_lower in ['right', 'end', 'flex-end']:
+                return container_start + container_size - child_size
+            else:
+                # Default: center
+                return container_start + (container_size - child_size) / 2
+    
+    def _get_gap(self, constraints: dict) -> float:
+        """Extract gap value from constraints.
+        
+        Args:
+            constraints: Constraints dictionary
+        
+        Returns:
+            Gap value in pixels (default: 20)
+        """
+        if not constraints:
+            return 30
+        
+        # Try to get gap - it might be a dict or a direct value
+        gap = constraints.get('gap', constraints.get('spacing', 20.0))
+        
+        # If gap is a dict (e.g., {'type': 'gap', 'value': 32.0}), extract the value
+        if isinstance(gap, dict):
+            return float(gap.get('value', 20.0))
+        
+        return float(gap)
+    
+    def _get_alignment(self, constraints: dict, default: str = 'center') -> str:
+        """Extract alignment from constraints.
+        
+        Args:
+            constraints: Constraints dictionary
+            default: Default alignment if not specified
+        
+        Returns:
+            Alignment string
+        """
+        if not constraints:
+            return default
+        
+        # Try to get alignment - it might be a dict or a direct value
+        alignment = constraints.get('alignment', default)
+        
+        # If alignment is a dict (e.g., {'type': 'alignment', 'value': 'center'}), extract the value
+        if isinstance(alignment, dict):
+            return str(alignment.get('value', alignment.get('direction', default)))
+        
+        return str(alignment)
+    
+    def _normalize_bbox(self, bbox) -> Tuple[float, float, float, float]:
+        """Normalize bbox to (x, y, w, h) tuple format.
+        
+        Args:
+            bbox: Bbox in tuple or dict format
+        
+        Returns:
+            Normalized bbox tuple (x, y, w, h)
+        """
+        if isinstance(bbox, dict):
+            return (
+                float(bbox.get('x', 0)),
+                float(bbox.get('y', 0)),
+                float(bbox.get('width', bbox.get('w', 100))),
+                float(bbox.get('height', bbox.get('h', 100)))
+            )
+        elif isinstance(bbox, (tuple, list)) and len(bbox) >= 4:
+            return (float(bbox[0]), float(bbox[1]), float(bbox[2]), float(bbox[3]))
+        else:
+            return (0.0, 0.0, 100.0, 100.0)
+    
+    def composite(self, nodes: List[dict], bboxes: List[Tuple[float, float, float, float]],
+                  container_bbox: Tuple[float, float, float, float]) -> Tuple[np.ndarray, np.ndarray]:
+        """Composite nodes using existing utility function.
+        
+        This delegates to the common composite function since rule-based layout
+        doesn't need special compositing logic.
+        
+        Args:
+            nodes: List of node dictionaries
+            bboxes: List of optimized bounding boxes
+            container_bbox: Container bounding box
+        
+        Returns:
+            Tuple of (composite_mask, composite_sdf)
+        """
+        from ..utils.composite import composite_nodes
+        return composite_nodes(nodes, bboxes, container_bbox)
+

modules/infographics_generator/layout_system/strategies/sdf_strategy.py

@@ -0,0 +1,314 @@
+"""SDF-based optimization strategy."""
+
+import numpy as np
+import tempfile
+import os
+from PIL import Image
+from typing import List, Tuple, Dict, Any
+from .base import OptimizationStrategy
+from modules.infographics_generator.layout_system import parameters as params
+from modules.infographics_generator.layout_system.sdf import optimize as sdf_optimize
+from modules.infographics_generator.layout_system.utils.composite import composite_nodes
+
+
+class SDFOptimizationStrategy(OptimizationStrategy):
+    """SDF-based optimization strategy using existing optimize function."""
+    
+    def optimize(self, nodes: List[dict], container_bbox: Tuple[float, float, float, float],
+                 constraints: dict, config: dict, save_prefix: str = None) -> List[Tuple[float, float, float, float]]:
+        """Execute SDF-based optimization.
+        
+        Args:
+            nodes: List of node dictionaries with "mask", "image_path", and "bbox" keys
+            container_bbox: Container bounding box (x, y, w, h)
+            constraints: Constraints dictionary from JSON (deprecated, kept for compatibility)
+            config: Optimization configuration
+        
+        Returns:
+            List of optimized bounding boxes (x, y, w, h) for each node
+        """
+        container_type = config.get("container_type", "unknown")
+        debug = config.get("debug", False)  # Get debug mode from config
+        print(f"[SDFOptimizationStrategy] optimize called: container_type={container_type}, num_nodes={len(nodes)}, debug={debug}")
+        
+        if len(nodes) < 2:
+            # For single node, return its initial bbox
+            if nodes:
+                bbox = nodes[0].get("bbox", (0, 0, 100, 100))
+                return [bbox]
+            return []
+        
+        # Extract image paths and masks, create temp files if needed
+        image_paths = []
+        original_paths = []  # Store original paths for saving composite image
+        temp_files = []  # Track temp files for cleanup
+        
+        for i, node in enumerate(nodes):
+            metadata = node.get("metadata", {})
+            image_path = metadata.get("image_path") or node.get("image_path")
+            mask = node.get("mask")
+            
+            # Store original path
+            original_paths.append(image_path)
+            
+            if image_path and os.path.exists(image_path):
+                image_paths.append(image_path)
+            elif mask is not None:
+                # Create temporary image from mask for optimization
+                # But we'll use original path for saving composite image
+                mask_uint8 = (mask * 255).astype(np.uint8)
+                mask_image = Image.fromarray(mask_uint8, mode='L')
+                # Convert to RGBA with white background
+                rgba_image = Image.new('RGBA', mask_image.size, (255, 255, 255, 255))
+                rgba_image.putalpha(mask_image)
+                
+                # Save to temp file
+                temp_file = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
+                rgba_image.save(temp_file.name)
+                temp_files.append(temp_file.name)
+                image_paths.append(temp_file.name)
+            else:
+                # Fallback: use placeholder
+                image_paths.append(None)
+        
+        # Handle N-node case
+        print(f"[SDFOptimizationStrategy] Processing {len(nodes)}-node case for container_type={container_type}")
+        
+        # Check if all image paths are valid
+        if not all(image_paths):
+            # Cleanup temp files
+            for tf in temp_files:
+                if os.path.exists(tf):
+                    os.unlink(tf)
+            # Fallback: return initial bboxes if no image paths
+            return [node.get("bbox", (0, 0, 100, 100)) for node in nodes]
+        
+        # Get container dimensions
+        _, _, Wc, Hc = container_bbox
+        Wc = int(Wc)
+        Hc = int(Hc)
+        
+        # Extract optimization parameters from config
+        opt_res_list = config.get("opt_res_list", (256, 512, 1000))
+        outer_rounds = config.get("outer_rounds", 12)
+        inner_steps = config.get("inner_steps", 300)
+        lr = config.get("lr", 0.05)
+        w_similarity = config.get("w_similarity", 1.0)
+        w_readability = config.get("w_readability", 1.0)
+        w_alignment_consistency = config.get("w_alignment_consistency", 1.0)
+        w_alignment_similarity = config.get("w_alignment_similarity", params.W_ALIGNMENT_SIMILARITY)
+        w_data_ink = config.get("w_data_ink", params.W_DATA_INK)
+        
+        # Extract reference bboxes from nodes (initial bboxes from Example layout)
+        reference_bboxes = []
+        for node in nodes:
+            bbox = node.get("bbox", (0, 0, 100, 100))
+            if isinstance(bbox, dict):
+                # Convert dict bbox to tuple
+                ref_bbox = (
+                    bbox.get("x", 0),
+                    bbox.get("y", 0),
+                    bbox.get("width", bbox.get("w", 100)),
+                    bbox.get("height", bbox.get("h", 100))
+                )
+            else:
+                ref_bbox = bbox
+            reference_bboxes.append(ref_bbox)
+        
+        # Reference parent container bbox (from container_bbox parameter)
+        reference_parent_bbox = container_bbox
+        
+        # Extract size rules from constraints (only significant size differences)
+        size_rules = []
+        if constraints:
+            print("constraints:", constraints)
+            print("relative_size:", constraints.get("relative_size"))
+            relative_size_constraints = constraints.get("relative_size", [])
+            for rel_constraint in relative_size_constraints:
+                ratio = rel_constraint.get("ratio", 1.0)
+                source_idx = rel_constraint.get("source_index")
+                target_idx = rel_constraint.get("target_index")
+                
+                if source_idx is not None and target_idx is not None:
+                    # Only keep rules with significant size differences
+                    # ratio >= SIZE_RATIO_THRESHOLD: source should be larger than target
+                    # ratio <= 1/SIZE_RATIO_THRESHOLD: target should be larger than source
+                    threshold = params.SIZE_RATIO_THRESHOLD
+                    if ratio >= threshold:
+                        size_rules.append((source_idx, target_idx))
+                    elif ratio <= 1.0 / threshold:
+                        size_rules.append((target_idx, source_idx))
+        print("size rules:", size_rules)
+        
+        # Extract min_width and min_height from each node
+        min_sizes = []
+        for node in nodes:
+            # Check multiple possible locations for min_width and min_height
+            min_width = node.get("min_width")
+            min_height = node.get("min_height")
+            
+            # If not found at node level, check bbox dict
+            if min_width is None or min_height is None:
+                bbox = node.get("bbox", {})
+                if isinstance(bbox, dict):
+                    min_width = min_width or bbox.get("min_width")
+                    min_height = min_height or bbox.get("min_height")
+            
+            # If still not found, check metadata
+            if min_width is None or min_height is None:
+                metadata = node.get("metadata", {})
+                min_width = min_width or metadata.get("min_width")
+                min_height = min_height or metadata.get("min_height")
+            
+            # Use defaults if not found
+            if min_width is None:
+                min_width = params.MIN_WIDTH_DEFAULT
+            if min_height is None:
+                min_height = params.MIN_HEIGHT_DEFAULT
+            
+            min_sizes.append((float(min_width), float(min_height)))
+        
+        print(f"Min sizes extracted: {min_sizes}")
+        
+        # Extract proximity info for proximity ratio loss
+        # Simplified for bottom-up layout: only considers current layer's children spacing
+        # and children's children spacing
+        proximity_info = None
+        w_proximity = config.get("w_proximity", params.W_PROXIMITY)
+        
+        if w_proximity > 0:
+            # Get container type from config (passed from hierarchical_optimizer)
+            container_type = config.get("container_type", "row")  # Default to row
+            
+            # Get grandchildren list from config (passed from hierarchical_optimizer)
+            grandchildren_list_from_config = config.get("grandchildren_list", [])
+            
+            # Build proximity_info for current container
+            # Container is the parent container
+            container_bbox = container_bbox
+            
+            # Children are the N elements (will be updated during optimization)
+            # For now, use initial bboxes
+            child_bboxes = []
+            grandchild_bboxes_list = []  # List of lists: grandchildren for each child
+            
+            # Ensure grandchildren_list_from_config is a list of lists
+            # If it's a flat list, we need to handle it differently
+            if len(grandchildren_list_from_config) > 0:
+                first_elem = grandchildren_list_from_config[0]
+                if isinstance(first_elem, (tuple, list)) and len(first_elem) == 4 and isinstance(first_elem[0], (int, float)):
+                    # Flat list: all grandchildren in one list, need to distribute to children
+                    # This shouldn't happen, but handle it gracefully
+                    # print(f"Warning: grandchildren_list_from_config appears to be a flat list, expected list of lists")
+                    # For now, assign all grandchildren to first child (not ideal, but better than crashing)
+                    if len(nodes) > 0:
+                        grandchild_bboxes_list = [grandchildren_list_from_config] + [[]] * (len(nodes) - 1)
+                    else:
+                        grandchild_bboxes_list = []
+                else:
+                    # Proper nested structure: list of lists
+                    grandchild_bboxes_list = grandchildren_list_from_config[:len(nodes)]
+                    # Pad with empty lists if needed
+                    while len(grandchild_bboxes_list) < len(nodes):
+                        grandchild_bboxes_list.append([])
+            
+            for i, node in enumerate(nodes):
+                bbox = node.get("bbox", (0, 0, 100, 100))
+                if isinstance(bbox, dict):
+                    child_bboxes.append((
+                        bbox.get("x", 0),
+                        bbox.get("y", 0),
+                        bbox.get("width", bbox.get("w", 100)),
+                        bbox.get("height", bbox.get("h", 100))
+                    ))
+                else:
+                    child_bboxes.append(bbox)
+                
+                # Use grandchildren from grandchild_bboxes_list (already processed above)
+                # If not available, try to extract from node metadata as fallback
+                if i >= len(grandchild_bboxes_list) or not grandchild_bboxes_list[i]:
+                    grandchildren = []
+                    node_children = node.get("children", [])
+                    if isinstance(node_children, list):
+                        for grandchild in node_children:
+                            grandchild_bbox = grandchild.get("bbox") if isinstance(grandchild, dict) else None
+                            if grandchild_bbox:
+                                if isinstance(grandchild_bbox, dict):
+                                    grandchildren.append((
+                                        grandchild_bbox.get("x", 0),
+                                        grandchild_bbox.get("y", 0),
+                                        grandchild_bbox.get("width", grandchild_bbox.get("w", 0)),
+                                        grandchild_bbox.get("height", grandchild_bbox.get("h", 0))
+                                    ))
+                                elif isinstance(grandchild_bbox, (tuple, list)) and len(grandchild_bbox) >= 4:
+                                    grandchildren.append(tuple(grandchild_bbox[:4]))
+                    if i < len(grandchild_bboxes_list):
+                        grandchild_bboxes_list[i] = grandchildren
+                    else:
+                        grandchild_bboxes_list.append(grandchildren)
+            
+            proximity_info = {
+                "containers": [container_bbox],
+                "children": [child_bboxes],
+                "grandchildren": grandchild_bboxes_list,
+                "types": [container_type],
+                "weights": None  # Will use area-based weighting
+            }
+            print(f"Proximity info prepared: container={container_bbox}, type={container_type}, "
+                  f"children={len(child_bboxes)}, grandchildren={[len(gc) for gc in grandchild_bboxes_list]}")
+        
+        # Store original image paths for saving composite image
+        original_png_list = original_paths
+        
+        # Get save prefix from parameter or config
+        save_prefix = save_prefix or config.get("save_prefix")
+        
+        # Call optimize function with N-node support
+        # Use temp files for optimization, but pass original paths for saving
+        print(f"[SDFOptimizationStrategy] Calling test_sdf.optimize for container_type={container_type}, num_nodes={len(nodes)}")
+        optimized_bboxes = sdf_optimize(
+            png_list=image_paths,
+            original_png_list=original_png_list,
+            Wc=Wc,
+            Hc=Hc,
+            opt_res_list=opt_res_list,
+            outer_rounds=outer_rounds,
+            inner_steps=inner_steps,
+            lr=lr,
+            min_sizes=min_sizes,
+            reference_bboxes=reference_bboxes,
+            reference_parent_bbox=reference_parent_bbox,
+            w_similarity=w_similarity,
+            size_rules=size_rules,
+            w_readability=w_readability,
+            w_alignment_consistency=w_alignment_consistency,
+            # alignment_constraint=alignment_constraint,
+            w_alignment_similarity=w_alignment_similarity,
+            proximity_info=proximity_info,
+            w_proximity=w_proximity,
+            w_data_ink=w_data_ink,
+            device=config.get("device"),
+            save_prefix=save_prefix,
+            debug=debug,  # Pass debug flag
+        )
+        
+        # Note: Don't cleanup temp files here because save_composite_image 
+        # is called inside sdf_optimize and needs the files
+        # Temp files will be cleaned up by Python's garbage collector or manually later
+        
+        return optimized_bboxes
+    
+    def composite(self, nodes: List[dict], bboxes: List[Tuple[float, float, float, float]],
+                  container_bbox: Tuple[float, float, float, float]) -> Tuple[np.ndarray, np.ndarray]:
+        """Composite optimized results.
+        
+        Args:
+            nodes: List of node dictionaries
+            bboxes: List of optimized bounding boxes
+            container_bbox: Container bounding box
+        
+        Returns:
+            Tuple of (mask, sdf)
+        """
+        return composite_nodes(nodes, bboxes, container_bbox)
+

modules/infographics_generator/layout_system/test_hierarchical.py

@@ -0,0 +1,92 @@
+"""Test script for hierarchical layout optimization."""
+
+import json
+import sys
+
+from layout_system.hierarchical_optimizer import (
+    HierarchicalOptimizer,
+    OptimizationConfig,
+)
+from layout_system.utils.save_result import save_hierarchical_result
+
+
+def test_simplified_json():
+    """Test with simplified.json."""
+    print("=" * 60)
+    print("Testing hierarchical optimization with simplified.json")
+    print("=" * 60)
+    
+    # Load JSON
+    with open("simplified.json", "r") as f:
+        tree_json = json.load(f)
+    
+    # Create optimizer
+    config = OptimizationConfig(
+        base_dir=".",
+        device="cuda" if __import__("torch").cuda.is_available() else "cpu",
+    )
+    optimizer = HierarchicalOptimizer(config)
+    
+    # Optimize tree
+    result = optimizer.optimize_tree(tree_json)
+    
+    # Print results
+    print("\n" + "=" * 60)
+    print("Optimization Results:")
+    print("=" * 60)
+    print(json.dumps(result, indent=2, default=str))
+    
+    return result
+
+
+def test_complex_json(json_path=None):
+    """Test with complex JSON file."""
+    print("\n" + "=" * 60)
+    print("Testing hierarchical optimization with complex JSON")
+    print("=" * 60)
+    
+    if json_path is None:
+        json_path = "2ff42ec4163d2bd9552a934f46e5090b3f6e2827da236aef6f645152974af629.png_with_constraints.json"
+    
+    with open(json_path, "r") as f:
+        json_data = json.load(f)
+    
+    tree_json = json_data.get("scene_tree", json_data)
+    
+    # Create optimizer
+    # base_dir = os.path.dirname(json_path)
+    base_dir = "."
+    config = OptimizationConfig(
+        base_dir=base_dir,
+        device="cuda" if __import__("torch").cuda.is_available() else "cpu",
+    )
+    print("Creating optimizer with config: ", config)
+    optimizer = HierarchicalOptimizer(config)
+    
+    # Optimize tree
+    result = optimizer.optimize_tree(tree_json)
+    
+    # Print summary
+    print("\n" + "=" * 60)
+    print("Optimization Results Summary:")
+    print("=" * 60)
+    print(f"Root node type: {result.get('type')}")
+    print(f"Root final bbox: {result.get('final_bbox')}")
+    if "children" in result:
+        print(f"Number of children: {len(result['children'])}")
+        for i, child in enumerate(result["children"]):
+            print(f"  Child {i}: {child.get('type')}, bbox: {child.get('final_bbox')}")
+    
+    # Save hierarchical layout result
+    print("\n" + "=" * 60)
+    print("Saving hierarchical layout result...")
+    print("=" * 60)
+    save_hierarchical_result(result, save_path="hierarchical_result.png", base_dir=base_dir)
+    
+    return result
+
+
+if __name__ == "__main__":
+    json_path = sys.argv[1] if len(sys.argv) > 1 else None
+    test_complex_json(json_path)
+

modules/infographics_generator/layout_system/test_sdf.py

@@ -0,0 +1,99 @@
+"""Backward compatibility wrapper for sdf module.
+
+This module re-exports all functions from the sdf subpackage for backward compatibility.
+New code should import directly from the sdf subpackage instead.
+"""
+
+from layout_system.sdf import optimize
+from layout_system.sdf.core import (
+    binary_to_sdf_norm,
+    load_binary_mask_from_rgba,
+)
+from layout_system.sdf.visualization import (
+    visualize_sdf,
+    visualize_sdf_norm_and_softmask,
+)
+
+if __name__ == "__main__":
+    import json
+    
+    # Visualize SDFs
+    print("Loading images and computing SDFs...")
+    mask1 = load_binary_mask_from_rgba("chart.png")
+    mask2 = load_binary_mask_from_rgba("pictogram.png")
+    
+    sdf1_norm = binary_to_sdf_norm(mask1, pad=16)
+    sdf2_norm = binary_to_sdf_norm(mask2, pad=16)
+    
+    print(f"SDF 1 shape: {sdf1_norm.shape}, range: [{sdf1_norm.min():.3f}, {sdf1_norm.max():.3f}]")
+    print(f"SDF 2 shape: {sdf2_norm.shape}, range: [{sdf2_norm.min():.3f}, {sdf2_norm.max():.3f}]")
+    
+    # Use a smaller range (0.05) for finer detail around the boundary
+    visualize_sdf(sdf1_norm, sdf2_norm, mask1, mask2, 
+                  save_path="sdf_visualization.png", sdf_range=0.05)
+    
+    # Visualize SDF normalization and softmask conversion for both images
+    print("\nVisualizing SDF normalization and softmask conversion...")
+    
+    # For mask1 (chart) - use a sample bbox covering most of the image
+    H1, W1 = mask1.shape
+    bbox1_sample = (W1 * 0.1, H1 * 0.1, W1 * 0.8, H1 * 0.8)
+    visualize_sdf_norm_and_softmask(sdf1_norm, mask1, 
+                                     bbox=bbox1_sample, 
+                                     container_size=(W1, H1),
+                                     save_path="sdf_norm_softmask_chart.png")
+    
+    # For mask2 (pictogram) - use a sample bbox covering most of the image
+    H2, W2 = mask2.shape
+    bbox2_sample = (W2 * 0.1, H2 * 0.1, W2 * 0.8, H2 * 0.8)
+    visualize_sdf_norm_and_softmask(sdf2_norm, mask2,
+                                     bbox=bbox2_sample,
+                                     container_size=(W2, H2),
+                                     save_path="sdf_norm_softmask_pictogram.png")
+    
+    # Load reference layout from JSON
+    print("\n" + "="*50)
+    print("Loading reference layout from simplified.json...")
+    print("="*50)
+    
+    json_path = "simplified.json"
+    
+    with open(json_path, 'r') as f:
+        json_data = json.load(f)
+    
+    # Extract reference bboxes from children
+    reference_bboxes = []
+    reference_parent_bbox = None
+    
+    if "children" in json_data and len(json_data["children"]) >= 2:
+        # Extract parent container bbox
+        parent_bbox = json_data.get("bbox", {})
+        reference_parent_bbox = (
+            parent_bbox.get("x", 0),
+            parent_bbox.get("y", 0),
+            parent_bbox.get("width", 1000),
+            parent_bbox.get("height", 1000)
+        )
+        
+        # Extract children bboxes (reference layout)
+        for child in json_data["children"]:
+            child_bbox = child.get("bbox", {})
+            ref_bbox = (
+                child_bbox.get("x", 0),
+                child_bbox.get("y", 0),
+                child_bbox.get("width", 100),
+                child_bbox.get("height", 100)
+            )
+            reference_bboxes.append(ref_bbox)
+    
+    print(f"Reference parent bbox: {reference_parent_bbox}")
+    print(f"Reference bboxes: {reference_bboxes}")
+    
+    # Run optimization
+    print("\n" + "="*50)
+    print("Running optimization...")
+    print("="*50)
+    optimize(png_list=["chart.png", "pictogram.png"], 
+             reference_bboxes=reference_bboxes,
+             reference_parent_bbox=reference_parent_bbox,
+             w_similarity=1000.0)

modules/infographics_generator/layout_system/utils/__init__.py

@@ -0,0 +1,13 @@
+"""Utility functions for hierarchical optimization."""
+
+from .placeholder import create_placeholder_rectangle
+from .parser import parse_layout_tree, LayoutNode
+from .composite import composite_nodes
+
+__all__ = [
+    'create_placeholder_rectangle',
+    'parse_layout_tree',
+    'LayoutNode',
+    'composite_nodes',
+]
+

modules/infographics_generator/layout_system/utils/composite.py

@@ -0,0 +1,92 @@
+"""Composite utilities for combining node results."""
+
+import numpy as np
+from typing import List, Tuple
+from PIL import Image
+
+
+def composite_nodes(nodes: List[dict], bboxes: List[Tuple[float, float, float, float]],
+                    container_bbox: Tuple[float, float, float, float]) -> Tuple[np.ndarray, np.ndarray]:
+    """Composite multiple nodes into a single mask.
+    
+    Args:
+        nodes: List of node dictionaries with "mask" key
+        bboxes: List of (x, y, w, h) bounding boxes for each node
+        container_bbox: Container bounding box (x, y, w, h)
+    
+    Returns:
+        Tuple of (composite_mask, composite_sdf)
+        - composite_mask: Combined mask (H, W)
+        - composite_sdf: Combined SDF (H, W) - simplified version
+    """
+    # Handle container_bbox format
+    if isinstance(container_bbox, (tuple, list)) and len(container_bbox) == 4:
+        cx, cy, cw, ch = container_bbox
+    elif isinstance(container_bbox, dict):
+        cx = container_bbox.get("x", 0)
+        cy = container_bbox.get("y", 0)
+        cw = container_bbox.get("width", container_bbox.get("w", 0))
+        ch = container_bbox.get("height", container_bbox.get("h", 0))
+    else:
+        raise ValueError(f"Invalid container_bbox format: {container_bbox}")
+    
+    cw_int = int(float(cw))
+    ch_int = int(float(ch))
+    
+    # Initialize composite mask
+    composite_mask = np.zeros((ch_int, cw_int), dtype=np.float32)
+    
+    # Place each node's mask at its bbox position
+    for i, (node, bbox) in enumerate(zip(nodes, bboxes)):
+        mask = node.get("mask")
+        if mask is None:
+            continue
+        
+        # Handle different bbox formats
+        if isinstance(bbox, (tuple, list)) and len(bbox) == 4:
+            x, y, w, h = bbox
+        elif isinstance(bbox, dict):
+            x = bbox.get("x", 0)
+            y = bbox.get("y", 0)
+            w = bbox.get("width", bbox.get("w", 0))
+            h = bbox.get("height", bbox.get("h", 0))
+        else:
+            print(f"Warning: Invalid bbox format at index {i}: {bbox} (type: {type(bbox)})")
+            continue
+        
+        x_int = int(float(x))
+        y_int = int(float(y))
+        w_int = int(float(w))
+        h_int = int(float(h))
+        
+        # Resize mask to bbox size if needed
+        if mask.shape != (h_int, w_int):
+            from scipy.ndimage import zoom
+            zoom_y = h_int / mask.shape[0]
+            zoom_x = w_int / mask.shape[1]
+            mask_resized = zoom(mask, (zoom_y, zoom_x), order=1)
+        else:
+            mask_resized = mask
+        
+        # Clip to valid range
+        mask_resized = np.clip(mask_resized, 0, 1)
+        
+        # Place mask in composite
+        y_end = min(y_int + h_int, ch_int)
+        x_end = min(x_int + w_int, cw_int)
+        y_start = max(0, y_int)
+        x_start = max(0, x_int)
+        
+        if y_end > y_start and x_end > x_start:
+            mask_crop = mask_resized[:y_end-y_start, :x_end-x_start]
+            composite_mask[y_start:y_end, x_start:x_end] = np.maximum(
+                composite_mask[y_start:y_end, x_start:x_end],
+                mask_crop
+            )
+    
+    # Generate simplified SDF from composite mask
+    # This is a simplified version - full SDF generation would use distance_transform_edt
+    composite_sdf = composite_mask - 0.5  # Simple approximation
+    
+    return composite_mask, composite_sdf
+

modules/infographics_generator/layout_system/utils/nodes.py

@@ -0,0 +1,378 @@
+"""
+布局系统核心节点定义
+
+基于 template.ebnf 实现的布局系统
+支持：
+- Flow Layout (ROW/COLUMN)
+- Non-Flow Layout (Z-layer)
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Optional, Tuple, Any
+from dataclasses import dataclass, field
+from enum import Enum
+import numpy as np
+
+
+# ============= 枚举定义 =============
+
+class NodeType(Enum):
+    """节点类型"""
+    GROUP = "GROUP"
+    TEXT = "TEXT"
+    IMAGE = "IMAGE"
+    CHART = "CHART"
+    SHAPE = "SHAPE"
+
+
+class LayoutType(Enum):
+    """布局类型"""
+    FLOW = "FLOW"
+    NON_FLOW = "NON_FLOW"
+
+
+class FlowDirection(Enum):
+    """Flow布局方向"""
+    ROW = "ROW"           # 水平排列
+    COLUMN = "COLUMN"     # 垂直排列
+    # 未来扩展:
+    # GRID = "GRID"
+    # CIRCULAR = "CIRCULAR"
+    # IRREGULAR = "IRREGULAR"
+
+
+class MainAlignment(Enum):
+    """主轴对齐方式"""
+    START = "START"
+    CENTER = "CENTER"
+    END = "END"
+
+
+class CrossAlignment(Enum):
+    """交叉轴对齐方式"""
+    START = "START"
+    CENTER = "CENTER"
+    END = "END"
+    STRETCH = "STRETCH"
+
+
+class PositionAlign(Enum):
+    """非流式布局位置对齐"""
+    TOP_LEFT = "top-left"
+    TOP_CENTER = "top-center"
+    TOP_RIGHT = "top-right"
+    CENTER_LEFT = "left"
+    CENTER = "center"
+    CENTER_RIGHT = "right"
+    BOTTOM_LEFT = "bottom-left"
+    BOTTOM_CENTER = "bottom-center"
+    BOTTOM_RIGHT = "bottom-right"
+
+
+class Alignment(Enum):
+    """对齐方式（用于每个节点自己的对齐）"""
+    START = "START"
+    CENTER = "CENTER"
+    END = "END"
+    LEFT = "LEFT"
+    RIGHT = "RIGHT"
+    # 特殊值（用于 layer 子节点）
+    BACKGROUND = "BACKGROUND"
+    TOP_LEFT = "TOP_LEFT"
+    TOP_CENTER = "TOP_CENTER"
+    TOP_RIGHT = "TOP_RIGHT"
+    BOTTOM_LEFT = "BOTTOM_LEFT"
+    BOTTOM_CENTER = "BOTTOM_CENTER"
+    BOTTOM_RIGHT = "BOTTOM_RIGHT"
+
+
+# ============= 数据类定义 =============
+
+@dataclass
+class BoundingBox:
+    """边界框 (x, y, width, height)"""
+    x: float
+    y: float
+    width: float
+    height: float
+    
+    @property
+    def left(self) -> float:
+        return self.x
+    
+    @property
+    def right(self) -> float:
+        return self.x + self.width
+    
+    @property
+    def top(self) -> float:
+        return self.y
+    
+    @property
+    def bottom(self) -> float:
+        return self.y + self.height
+    
+    @property
+    def center_x(self) -> float:
+        return self.x + self.width / 2
+    
+    @property
+    def center_y(self) -> float:
+        return self.y + self.height / 2
+
+
+@dataclass
+class Padding:
+    """内边距"""
+    top: float = 0
+    right: float = 0
+    bottom: float = 0
+    left: float = 0
+    
+    @classmethod
+    def uniform(cls, value: float) -> 'Padding':
+        """创建统一的内边距"""
+        return cls(value, value, value, value)
+    
+    @property
+    def horizontal(self) -> float:
+        """水平方向总内边距"""
+        return self.left + self.right
+    
+    @property
+    def vertical(self) -> float:
+        """垂直方向总内边距"""
+        return self.top + self.bottom
+
+
+@dataclass
+class FlowAlignment:
+    """Flow布局对齐配置"""
+    main: MainAlignment = MainAlignment.START
+    cross: CrossAlignment = CrossAlignment.START
+
+
+# ============= 抽象基类 =============
+
+class Node(ABC):
+    """节点抽象基类"""
+    
+    def __init__(self, node_id: str, node_type: NodeType, alignment: Optional[str] = None, parent: Optional['Node'] = None):
+        self.id = node_id
+        self.type = node_type
+        self.alignment = alignment  # 每个节点自己的对齐方式
+        self.bbox: Optional[BoundingBox] = None  # 布局计算后的边界框
+        self.parent: Optional['Node'] = parent  # 父节点引用
+        
+    @abstractmethod
+    def compute_intrinsic_size(self) -> Tuple[float, float]:
+        """
+        计算节点的固有尺寸 (width, height)
+        
+        对于 Leaf Node: 返回内容的实际尺寸
+        对于 Non-Leaf Node: 根据子节点和布局规则计算
+        """
+        pass
+    
+    @abstractmethod
+    def layout(self, x: float, y: float, available_width: Optional[float] = None, 
+               available_height: Optional[float] = None) -> BoundingBox:
+        """
+        执行布局计算
+        
+        Args:
+            x: 起始 x 坐标
+            y: 起始 y 坐标
+            available_width: 可用宽度（可选）
+            available_height: 可用高度（可选）
+            
+        Returns:
+            计算后的边界框
+        """
+        pass
+    
+    @abstractmethod
+    def to_dict(self) -> dict:
+        """序列化为字典"""
+        pass
+
+
+# ============= Leaf Node =============
+
+class LeafNode(Node):
+    """叶子节点
+    
+    叶子节点表示具体的视觉元素，具有固定的尺寸和可选的遮罩
+    """
+    
+    def __init__(self, node_id: str, node_type: NodeType, 
+                 width: float, height: float, 
+                 mask: Optional[np.ndarray] = None,
+                 metadata: Optional[dict] = None,
+                 alignment: Optional[str] = None,
+                 parent: Optional[Node] = None):
+        super().__init__(node_id, node_type, alignment, parent)
+        self.width = width
+        self.height = height
+        self.mask = mask  # 可选的二值遮罩，用于不规则形状
+        self.metadata = metadata or {}  # 存储额外的元数据（如content, role, src等）
+        
+    def compute_intrinsic_size(self) -> Tuple[float, float]:
+        """叶子节点的固有尺寸就是其宽高"""
+        return (self.width, self.height)
+    
+    def layout(self, x: float, y: float, available_width: Optional[float] = None,
+               available_height: Optional[float] = None) -> BoundingBox:
+        """叶子节点的布局很简单，直接放置在指定位置"""
+        self.bbox = BoundingBox(x, y, self.width, self.height)
+        return self.bbox
+    
+    def to_dict(self) -> dict:
+        result = {
+            "id": self.id,
+            "type": self.type.value,
+            "bbox": {
+                "x": self.bbox.x if self.bbox else 0,
+                "y": self.bbox.y if self.bbox else 0,
+                "width": self.width,
+                "height": self.height
+            }
+        }
+        # 添加元数据
+        if self.metadata:
+            result.update(self.metadata)
+        return result
+
+
+# ============= Non-Leaf Node =============
+
+class GroupNode(Node):
+    """组节点（非叶子节点）
+    
+    组节点包含多个子节点，并根据布局类型对子节点进行排列
+    """
+    
+    def __init__(self, node_id: str, layout_type: LayoutType, 
+                 children: List[Node], padding: Optional[Padding] = None,
+                 alignment: Optional[str] = None,
+                 parent: Optional[Node] = None):
+        super().__init__(node_id, NodeType.GROUP, alignment, parent)
+        self.layout_type = layout_type
+        self.children = children
+        # 设置每个子节点的 parent
+        for child in self.children:
+            child.parent = self
+        self.padding = padding or Padding()
+        self.mask: Optional[np.ndarray] = None  # 根据子节点mask合并得到
+        
+        # 布局特定属性（子类设置）
+        self.layout_attrs = {}
+        
+    def compute_intrinsic_size(self) -> Tuple[float, float]:
+        """
+        根据子节点和布局规则计算固有尺寸
+        这个方法会在具体的布局子类中实现
+        """
+        raise NotImplementedError("Subclass must implement compute_intrinsic_size")
+    
+    def layout(self, x: float, y: float, available_width: Optional[float] = None,
+               available_height: Optional[float] = None) -> BoundingBox:
+        """
+        执行组节点的布局
+        具体的布局算法由子类实现
+        """
+        raise NotImplementedError("Subclass must implement layout")
+    
+    def _compute_mask_from_children(self):
+        """
+        根据所有子节点的mask计算父节点的mask
+        
+        将每个子节点的mask根据其bbox位置转换到父节点坐标系，
+        然后合并所有mask（使用OR操作）
+        """
+        if not self.bbox or not self.children:
+            self.mask = None
+            return
+        
+        # 收集所有有mask的子节点
+        children_with_mask = [
+            child for child in self.children 
+            if child.mask is not None and child.bbox is not None
+        ]
+        
+        if not children_with_mask:
+            self.mask = None
+            return
+        
+        # 创建父节点的mask（全零）
+        parent_width = int(self.bbox.width)
+        parent_height = int(self.bbox.height)
+        parent_mask = np.zeros((parent_height, parent_width), dtype=np.uint8)
+        
+        # 将每个子节点的mask转换到父节点坐标系并合并
+        for child in children_with_mask:
+            child_mask = child.mask
+            child_bbox = child.bbox
+            
+            # 计算子节点在父节点坐标系中的位置（相对于父节点左上角）
+            child_x_in_parent = int(child_bbox.x - self.bbox.x)
+            child_y_in_parent = int(child_bbox.y - self.bbox.y)
+            child_width = int(child_bbox.width)
+            child_height = int(child_bbox.height)
+            
+            # 确保子节点mask的尺寸与bbox一致
+            if child_mask.shape != (child_height, child_width):
+                # 如果尺寸不匹配，调整mask尺寸（使用最近邻插值）
+                mask_h, mask_w = child_mask.shape
+                
+                # 计算源坐标
+                y_coords = np.clip(
+                    (np.arange(child_height) * mask_h / child_height).astype(int),
+                    0, mask_h - 1
+                )
+                x_coords = np.clip(
+                    (np.arange(child_width) * mask_w / child_width).astype(int),
+                    0, mask_w - 1
+                )
+                
+                # 使用numpy的高级索引进行最近邻插值
+                y_indices, x_indices = np.meshgrid(y_coords, x_coords, indexing='ij')
+                child_mask = child_mask[y_indices, x_indices]
+            
+            # 计算在父节点mask中的位置范围
+            y_start = max(0, child_y_in_parent)
+            y_end = min(parent_height, child_y_in_parent + child_height)
+            x_start = max(0, child_x_in_parent)
+            x_end = min(parent_width, child_x_in_parent + child_width)
+            
+            # 计算在子节点mask中的对应范围
+            child_y_start = max(0, -child_y_in_parent)
+            child_y_end = child_y_start + (y_end - y_start)
+            child_x_start = max(0, -child_x_in_parent)
+            child_x_end = child_x_start + (x_end - x_start)
+            
+            # 将子节点mask复制到父节点mask的对应位置（OR操作）
+            if (y_end > y_start and x_end > x_start and 
+                child_y_end > child_y_start and child_x_end > child_x_start):
+                parent_mask[y_start:y_end, x_start:x_end] = np.maximum(
+                    parent_mask[y_start:y_end, x_start:x_end],
+                    child_mask[child_y_start:child_y_end, child_x_start:child_x_end]
+                )
+        
+        self.mask = parent_mask
+    
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "type": self.type.value,
+            "layout": self.layout_type.value,
+            "layoutAttrs": self.layout_attrs,
+            "children": [child.to_dict() for child in self.children],
+            "bbox": {
+                "x": self.bbox.x if self.bbox else 0,
+                "y": self.bbox.y if self.bbox else 0,
+                "width": self.bbox.width if self.bbox else 0,
+                "height": self.bbox.height if self.bbox else 0
+            }
+        }
+

modules/infographics_generator/layout_system/utils/parser.py

@@ -0,0 +1,62 @@
+"""JSON parser for layout tree structure."""
+
+from typing import List, Optional, Dict, Any
+from dataclasses import dataclass, field
+
+
+@dataclass
+class LayoutNode:
+    """Layout node data structure."""
+    type: str
+    bbox: Dict[str, float]
+    constraints: Dict[str, Any] = field(default_factory=dict)
+    children: List['LayoutNode'] = field(default_factory=list)
+    image_path: Optional[str] = None
+    content: Optional[str] = None
+    alignment: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    # Optimization results (filled after optimization)
+    final_bbox: Optional[tuple] = None
+    composite_mask: Optional[Any] = None
+    composite_sdf: Optional[Any] = None
+
+
+def parse_layout_tree(json_data: dict) -> LayoutNode:
+    """Parse JSON layout tree structure.
+    
+    Args:
+        json_data: JSON dictionary with layout tree structure
+    
+    Returns:
+        Root LayoutNode
+    """
+    # Handle different JSON formats
+    if "scene_tree" in json_data:
+        tree_data = json_data["scene_tree"]
+    else:
+        tree_data = json_data
+    
+    return _parse_node(tree_data)
+
+
+def _parse_node(node_data: dict) -> LayoutNode:
+    """Recursively parse a node from JSON data."""
+    node = LayoutNode(
+        type=node_data.get("type", "unknown"),
+        bbox=node_data.get("bbox", {}),
+        constraints=node_data.get("constraints", {}),
+        image_path=node_data.get("image_path"),
+        content=node_data.get("content"),
+        alignment=node_data.get("alignment"),
+        metadata={},
+    )
+    
+    # Parse children recursively
+    children_data = node_data.get("children", [])
+    for child_data in children_data:
+        child_node = _parse_node(child_data)
+        node.children.append(child_node)
+    
+    return node
+

modules/infographics_generator/layout_system/utils/placeholder.py

@@ -0,0 +1,69 @@
+"""Placeholder generation utilities."""
+
+import numpy as np
+from PIL import Image, ImageDraw
+from typing import Tuple
+
+
+def create_placeholder_rectangle(width: float, height: float, 
+                                color: Tuple[int, int, int, int] = (224, 224, 224, 255)) -> Tuple[Image.Image, np.ndarray]:
+    """
+    Create a solid color rectangle placeholder.
+    
+    Args:
+        width: Rectangle width
+        height: Rectangle height
+        color: RGBA color tuple, default light gray
+    
+    Returns:
+        Tuple of (image, mask)
+        - image: PIL Image in RGBA format
+        - mask: Binary mask array (H, W) with all ones (fully filled rectangle)
+    """
+    w_int = int(width)
+    h_int = int(height)
+    
+    # Create RGBA image with solid color
+    image = Image.new("RGBA", (w_int, h_int), color)
+    
+    # Create mask (all ones for a filled rectangle)
+    mask = np.ones((h_int, w_int), dtype=np.float32)
+    
+    return image, mask
+
+
+def create_placeholder_rounded_rectangle(width: float, height: float,
+                                        radius: float = None,
+                                        color: Tuple[int, int, int, int] = (224, 224, 224, 255)) -> Tuple[Image.Image, np.ndarray]:
+    """
+    Create a rounded rectangle placeholder with rounded corners.
+    
+    Args:
+        width: Rectangle width
+        height: Rectangle height
+        radius: Corner radius (default: min(width, height) * 0.1)
+        color: RGBA color tuple, default light gray
+    
+    Returns:
+        Tuple of (image, mask)
+        - image: PIL Image in RGBA format
+        - mask: Binary mask array (H, W) with rounded rectangle shape
+    """
+    w_int = int(width)
+    h_int = int(height)
+    
+    if radius is None:
+        radius = min(w_int, h_int) * 0.1
+    
+    # Create RGBA image
+    image = Image.new("RGBA", (w_int, h_int), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(image)
+    
+    # Draw rounded rectangle
+    draw.rounded_rectangle([(0, 0), (w_int-1, h_int-1)], radius=radius, fill=color)
+    
+    # Create mask from alpha channel
+    mask = np.array(image.split()[3], dtype=np.float32) / 255.0
+    
+    return image, mask
+

modules/infographics_generator/layout_system/utils/save_result.py

@@ -0,0 +1,303 @@
+"""Save hierarchical layout optimization results."""
+
+import numpy as np
+from PIL import Image, ImageDraw
+from typing import Dict, Any, Tuple, Optional
+import os
+
+
+def save_hierarchical_result(result: Dict[str, Any], save_path: str = "hierarchical_result.png",
+                            base_dir: str = ".") -> None:
+    """Save hierarchical optimization result as an image.
+    
+    Args:
+        result: Result dictionary from HierarchicalOptimizer.optimize_tree()
+        save_path: Path to save the final image
+        base_dir: Base directory for resolving image paths
+    """
+    # Get root bbox
+    root_bbox = result.get("final_bbox")
+    if root_bbox is None:
+        print("Warning: No final_bbox found in result")
+        return
+    
+    # Handle different bbox formats
+    if isinstance(root_bbox, (tuple, list)) and len(root_bbox) == 4:
+        x, y, w, h = root_bbox
+    elif isinstance(root_bbox, dict):
+        x = root_bbox.get("x", 0)
+        y = root_bbox.get("y", 0)
+        w = root_bbox.get("width", root_bbox.get("w", 1000))
+        h = root_bbox.get("height", root_bbox.get("h", 1000))
+    else:
+        print(f"Warning: Invalid root_bbox format: {root_bbox}")
+        return
+    
+    root_x = int(float(x))
+    root_y = int(float(y))
+    Wc = int(float(w))
+    Hc = int(float(h))
+    
+    # First pass: calculate the actual bounding box needed for all nodes
+    # Root node's final_bbox is absolute, so pass 0,0 as offset (will use final_bbox directly)
+    min_x, min_y, max_x, max_y = _calculate_bounds(result, offset_x=0, offset_y=0, is_root=True)
+    
+    # Add some padding to ensure nothing is cut off
+    padding = 10
+    canvas_width = max_x - min_x + padding * 2
+    canvas_height = max_y - min_y + padding * 2
+    canvas_offset_x = min_x - padding
+    canvas_offset_y = min_y - padding
+    
+    # Create canvas
+    canvas = Image.new("RGBA", (canvas_width, canvas_height), (255, 255, 255, 255))
+    
+    # Print root bbox info
+    print(f"\n[Saving hierarchical result]")
+    print(f"  Root bbox: ({root_x}, {root_y}, {Wc}, {Hc})")
+    print(f"  Content bounds: ({min_x}, {min_y}) to ({max_x}, {max_y})")
+    print(f"  Canvas size: {canvas_width}x{canvas_height} (offset: {canvas_offset_x}, {canvas_offset_y})")
+    
+    # Second pass: recursively composite all nodes
+    # Root node's final_bbox is absolute, so we need to adjust for canvas offset
+    # For root node, we pass a flag indicating it's the root
+    _composite_node_to_canvas(result, canvas, base_dir, 
+                              offset_x=root_x - canvas_offset_x, 
+                              offset_y=root_y - canvas_offset_y,
+                              is_root=True)
+    
+    # Convert to RGB and save
+    canvas_rgb = Image.new("RGB", canvas.size, (255, 255, 255))
+    canvas_rgb.paste(canvas, mask=canvas.split()[3])
+    canvas_rgb.save(save_path, "PNG")
+    print(f"Hierarchical layout result saved to: {save_path}\n")
+
+
+def _draw_bbox(canvas: Image.Image, x: int, y: int, w: int, h: int, node_type: str) -> None:
+    """Draw bounding box on canvas.
+    
+    Args:
+        canvas: PIL Image canvas to draw on
+        x: X coordinate (absolute)
+        y: Y coordinate (absolute)
+        w: Width
+        h: Height
+        node_type: Type of node (for color selection)
+    """
+    # Clip coordinates to canvas bounds
+    x_clip = max(0, min(x, canvas.width - 1))
+    y_clip = max(0, min(y, canvas.height - 1))
+    x_end = min(x + w, canvas.width)
+    y_end = min(y + h, canvas.height)
+    
+    if x_end <= x_clip or y_end <= y_clip:
+        return
+    
+    # Choose color based on node type
+    color_map = {
+        "column": (255, 0, 0, 255),      # Red for column
+        "row": (0, 255, 0, 255),         # Green for row
+        "layer": (0, 0, 255, 255),       # Blue for layer
+        "chart": (255, 165, 0, 255),     # Orange for chart
+        "image": (255, 0, 255, 255),     # Magenta for image
+        "text": (0, 255, 255, 255),      # Cyan for text
+    }
+    color = color_map.get(node_type, (128, 128, 128, 255))  # Gray for unknown types
+    
+    # Draw rectangle
+    draw = ImageDraw.Draw(canvas)
+    draw.rectangle([x_clip, y_clip, x_end - 1, y_end - 1], outline=color, width=2)
+
+
+def _calculate_bounds(node_result: Dict[str, Any], offset_x: int = 0, offset_y: int = 0, 
+                      is_root: bool = False) -> Tuple[int, int, int, int]:
+    """Calculate the bounding box of all nodes in the tree.
+    
+    Args:
+        node_result: Node result dictionary
+        offset_x: X offset accumulated from parent containers (for relative coordinates)
+        offset_y: Y offset accumulated from parent containers (for relative coordinates)
+        is_root: Whether this is the root node (root's final_bbox is absolute, others are relative)
+    
+    Returns:
+        Tuple of (min_x, min_y, max_x, max_y) in absolute coordinates
+    """
+    # Get node bbox
+    bbox = node_result.get("final_bbox")
+    if bbox is None:
+        return (0, 0, 0, 0)
+    
+    # Handle different bbox formats
+    if isinstance(bbox, (tuple, list)) and len(bbox) == 4:
+        x, y, w, h = bbox
+    elif isinstance(bbox, dict):
+        x = bbox.get("x", 0)
+        y = bbox.get("y", 0)
+        w = bbox.get("width", bbox.get("w", 0))
+        h = bbox.get("height", bbox.get("h", 0))
+    else:
+        return (0, 0, 0, 0)
+    
+    # Root node's bbox is absolute, other nodes' bboxes are relative to parent container
+    if is_root:
+        # Root bbox is already absolute, use it directly
+        x_abs = int(float(x))
+        y_abs = int(float(y))
+    else:
+        # Convert relative coordinates to absolute by adding parent offset
+        x_abs = offset_x + int(float(x))
+        y_abs = offset_y + int(float(y))
+    
+    w_int = max(1, int(float(w)))
+    h_int = max(1, int(float(h)))
+    
+    # Initialize bounds with this node's bounds
+    min_x = x_abs
+    min_y = y_abs
+    max_x = x_abs + w_int
+    max_y = y_abs + h_int
+    
+    # Recursively process children
+    # Children are not root nodes, so pass is_root=False
+    children = node_result.get("children", [])
+    for child_result in children:
+        child_min_x, child_min_y, child_max_x, child_max_y = _calculate_bounds(
+            child_result, offset_x=x_abs, offset_y=y_abs, is_root=False
+        )
+        if child_min_x < min_x:
+            min_x = child_min_x
+        if child_min_y < min_y:
+            min_y = child_min_y
+        if child_max_x > max_x:
+            max_x = child_max_x
+        if child_max_y > max_y:
+            max_y = child_max_y
+    
+    return (min_x, min_y, max_x, max_y)
+
+
+def _composite_node_to_canvas(node_result: Dict[str, Any], canvas: Image.Image, 
+                              base_dir: str, offset_x: int = 0, offset_y: int = 0, 
+                              is_root: bool = False) -> None:
+    """Recursively composite node results onto canvas.
+    
+    Args:
+        node_result: Node result dictionary
+        canvas: PIL Image canvas to composite onto
+        base_dir: Base directory for resolving image paths
+        offset_x: X offset accumulated from parent containers (for canvas offset adjustment)
+        offset_y: Y offset accumulated from parent containers (for canvas offset adjustment)
+        is_root: Whether this is the root node (root's final_bbox is absolute, others are relative)
+    """
+    # Get node bbox
+    bbox = node_result.get("final_bbox")
+    if bbox is None:
+        return
+    
+    # Handle different bbox formats
+    if isinstance(bbox, (tuple, list)) and len(bbox) == 4:
+        x, y, w, h = bbox
+    elif isinstance(bbox, dict):
+        x = bbox.get("x", 0)
+        y = bbox.get("y", 0)
+        w = bbox.get("width", bbox.get("w", 0))
+        h = bbox.get("height", bbox.get("h", 0))
+    else:
+        return
+    
+    # Root node's bbox is absolute, other nodes' bboxes are relative to parent container
+    if is_root:
+        # Root bbox is already absolute, offset_x/offset_y here are canvas offsets (root_x - canvas_offset_x)
+        # For root: final_bbox x is root_x (absolute), offset_x = root_x - canvas_offset_x
+        # We want canvas-relative: root_x - canvas_offset_x = offset_x
+        # So we use offset_x directly (it's already the canvas-relative position)
+        x_abs = offset_x
+        y_abs = offset_y
+    else:
+        # Child node bbox is relative to parent container
+        # Convert to absolute coordinates by adding parent offset
+        x_abs = offset_x + int(float(x))
+        y_abs = offset_y + int(float(y))
+    w_int = max(1, int(float(w)))
+    h_int = max(1, int(float(h)))
+    
+    # Get node type for debugging
+    node_type = node_result.get("type", "unknown")
+    
+    # Check if this is a leaf node with an image
+    metadata = node_result.get("metadata", {})
+    image_path = metadata.get("image_path") or metadata.get("full_path") or node_result.get("image_path")
+    
+    # Try to resolve path
+    if image_path:
+        if os.path.isabs(image_path):
+            full_path = image_path
+        else:
+            full_path = os.path.join(base_dir, image_path)
+        
+        if os.path.exists(full_path):
+            # Load and place image
+            img = Image.open(full_path).convert("RGBA")
+            
+            # Resize image while preserving aspect ratio
+            # Calculate scale to fit within bbox
+            img_w, img_h = img.size
+            scale_w = w_int / img_w if img_w > 0 else 1.0
+            scale_h = h_int / img_h if img_h > 0 else 1.0
+            scale = min(scale_w, scale_h)  # Use smaller scale to fit within bbox
+            
+            # Calculate new size preserving aspect ratio
+            new_w = int(img_w * scale)
+            new_h = int(img_h * scale)
+            
+            # Resize image
+            img_resized = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
+            
+            # Center image within bbox
+            x_offset = (w_int - new_w) // 2
+            y_offset = (h_int - new_h) // 2
+            
+            # Calculate final position on canvas
+            x_final = x_abs + x_offset
+            y_final = y_abs + y_offset
+            
+            # Clip coordinates to canvas bounds
+            x_clip = max(0, min(x_final, canvas.width - 1))
+            y_clip = max(0, min(y_final, canvas.height - 1))
+            
+            # Calculate how much of the image fits
+            x_end = min(x_clip + new_w, canvas.width)
+            y_end = min(y_clip + new_h, canvas.height)
+            w_fit = x_end - x_clip
+            h_fit = y_end - y_clip
+            
+            if w_fit > 0 and h_fit > 0:
+                if w_fit < new_w or h_fit < new_h:
+                    img_resized = img_resized.crop((0, 0, w_fit, h_fit))
+                canvas.paste(img_resized, (x_clip, y_clip), img_resized)
+                # Print bbox info for debugging
+                coord_type = "absolute" if is_root else "relative"
+                print(f"  [Save] Node '{node_type}': image={os.path.basename(image_path)}, "
+                      f"bbox=({int(float(x))}, {int(float(y))}, {w_int}, {h_int}) [{coord_type}], "
+                      f"img_size=({img_w}x{img_h}→{new_w}x{new_h}), "
+                      f"placed_at=({x_final}, {y_final}) [canvas-relative]")
+        else:
+            # Print bbox info even if image doesn't exist
+            coord_type = "absolute" if is_root else "relative"
+            print(f"  [Save] Node '{node_type}': bbox=({int(float(x))}, {int(float(y))}, {w_int}, {h_int}) [{coord_type}], "
+                  f"image_path={image_path} (not found)")
+    else:
+        # Print bbox info for nodes without image_path (container nodes, text nodes, etc.)
+        coord_type = "absolute" if is_root else "relative"
+        print(f"  [Save] Node '{node_type}': bbox=({int(float(x))}, {int(float(y))}, {w_int}, {h_int}) [{coord_type}], no image")
+    
+    # Draw bounding box
+    _draw_bbox(canvas, x_abs, y_abs, w_int, h_int, node_type)
+    
+    # Recursively process children
+    # Children's coordinates are relative to this container, so pass this container's absolute position as offset
+    # Children are not root nodes
+    children = node_result.get("children", [])
+    for child_result in children:
+        _composite_node_to_canvas(child_result, canvas, base_dir, offset_x=x_abs, offset_y=y_abs, is_root=False)
+

modules/infographics_generator/mask_utils.py

@@ -0,0 +1,622 @@
+import os
+import random
+import subprocess
+import re
+from PIL import Image
+import numpy as np
+from typing import Tuple
+import tempfile
+from bs4 import BeautifulSoup
+import scipy.ndimage as ndimage
+import time
+import logging
+import base64
+
+
+
+# 设置日志
+logging.basicConfig(level=logging.ERROR, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def validate_svg_file(file_path):
+    """验证SVG文件是否存在且内容有效"""
+    if not os.path.exists(file_path):
+        logger.error(f"SVG文件不存在: {file_path}")
+        return False
+    
+    file_size = os.path.getsize(file_path)
+    if file_size == 0:
+        logger.error(f"SVG文件为空: {file_path}")
+        return False
+    
+    return True
+
+
+def extract_mask_from_base64(base64_str: str, width: int, height: int, background_color: str = "#FFFFFF") -> np.ndarray:
+    """
+    从base64编码的图像中提取mask
+    
+    Args:
+        base64_str: base64编码的图像字符串（可以带data:image/...;base64,前缀）
+        width: 目标宽度
+        height: 目标高度
+        background_color: 背景色，用于判断哪些区域是有内容的
+        
+    Returns:
+        np.ndarray: 二值mask，1表示有内容，0表示背景
+    """
+    from PIL import Image
+    import io
+    
+    if "base64," in base64_str:
+        base64_str = base64_str.split("base64,")[1]
+    
+    img_data = base64.b64decode(base64_str)
+    img = Image.open(io.BytesIO(img_data))
+    
+    if img.mode != 'RGBA':
+        img = img.convert('RGBA')
+    
+    img = img.resize((int(width), int(height)), Image.Resampling.LANCZOS)
+    img_array = np.array(img)
+    
+    if img_array.shape[2] == 4:
+        mask = (img_array[:, :, 3] > 0).astype(np.uint8)
+    else:
+        bg_rgb = tuple(int(background_color.lstrip('#')[i:i+2], 16) for i in (0, 2, 4))
+        diff = np.abs(img_array[:, :, :3].astype(int) - np.array(bg_rgb))
+        mask = (np.sum(diff, axis=2) > 30).astype(np.uint8)
+    
+    return mask
+
+
+def calculate_mask_v3(svg_content: str, width: int, height: int, background_color: str, grid_size: int = 5, max_difference = 15) -> np.ndarray:
+    """将SVG转换为基于背景色的二值化mask数组"""
+    width = int(width)
+    height = int(height)
+    
+    # 将背景色转换为RGB格式
+    original_background_color = background_color
+    background_color = tuple(int(background_color[i:i+2], 16) for i in (1, 3, 5))
+    
+    # 预处理SVG内容，删除背景元素和细线条
+    
+    # 解析SVG内容
+    soup = BeautifulSoup(svg_content, 'xml')
+    # 删除class="background"的所有元素
+    background_elements = soup.select('[class="background"]')
+    for element in background_elements:
+        element.decompose()
+    
+    # 删除stroke-width<=1或没有stroke-width的所有line元素
+    thin_lines = soup.find_all('line')
+    for line in thin_lines:
+        stroke_width = line.get('stroke-width')
+        if not stroke_width or float(stroke_width) <= 1:
+            line.decompose()
+            
+    # 删除opacity<=0.1的所有元素
+    all_elements = soup.find_all()
+    for element in all_elements:
+        opacity = element.get('opacity')
+        if opacity and float(opacity) <= 0.1:
+            element.decompose()
+    # 删除所有text元素
+    text_elements = soup.find_all('text')
+    for text in text_elements:
+        text.decompose()
+    
+    # 重新获取处理后的SVG内容
+    svg_content_without_text = str(soup)
+    
+    # 创建临时文件
+    with tempfile.NamedTemporaryFile(suffix='.svg', delete=False) as mask_svg_file_without_text, \
+         tempfile.NamedTemporaryFile(suffix='.png', delete=False) as temp_mask_png_file_without_text:
+        mask_svg_without_text = mask_svg_file_without_text.name
+        temp_mask_png_without_text = temp_mask_png_file_without_text.name
+        
+        # 修改SVG内容，移除渐变
+        # 将渐变填充替换为可见的纯色填充，而不是none
+        mask_svg_content = svg_content_without_text
+        # mask_svg_content = re.sub(r'fill="url\(#[^"]*\)"', 'fill="#333333"', mask_svg_content)
+        # mask_svg_content = re.sub(r'stroke="url\(#[^"]*\)"', 'stroke="#333333"', mask_svg_content)
+        mask_svg_content = mask_svg_content.replace('&', '&amp;')
+        
+        # 提取SVG内容并添加新的SVG标签
+        svg_content_match = re.search(r'<svg[^>]*>(.*?)</svg>', mask_svg_content, re.DOTALL)
+        if svg_content_match:
+            inner_content = svg_content_match.group(1)
+            # 创建新的SVG标签
+            mask_svg_content = f'<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{width}" height="{height}"> \
+            <rect width="{width}" height="{height}" fill="{original_background_color}" /> \
+            {inner_content} \
+            </svg>'
+        
+        mask_svg_file_without_text.write(mask_svg_content.encode('utf-8'))
+        mask_svg_file_without_text.flush()
+        
+        # 验证SVG文件
+        if not validate_svg_file(mask_svg_without_text):
+            logger.error(f"无效的SVG文件: {mask_svg_without_text}")
+        
+        retry_count = 0
+        max_retries = 3
+        while retry_count < max_retries:
+            try:
+                subprocess.run([
+                    'rsvg-convert',
+                    '-f', 'png',
+                    '-o', temp_mask_png_without_text,
+                    '--dpi-x', '300',
+                    '--dpi-y', '300',
+                    '--background-color', f"{original_background_color}",
+                    mask_svg_without_text
+                ], check=True)
+                break
+            except Exception as e:
+                retry_count += 1
+                logger.error(f"rsvg-convert执行失败 (尝试 {retry_count}/{max_retries}): {str(e)}")
+                if retry_count >= max_retries:
+                    raise e
+                time.sleep(1)
+                
+    img_without_text = Image.open(temp_mask_png_without_text).convert('RGB')
+    img_array_without_text = np.array(img_without_text)
+    
+    # 确保图像尺寸匹配预期尺寸
+    actual_height, actual_width = img_array_without_text.shape[:2]
+    if actual_width != width or actual_height != height:
+        img_without_text = img_without_text.resize((width, height), Image.LANCZOS)
+        img_array_without_text = np.array(img_without_text)
+    
+    
+    # 解析SVG内容
+    soup = BeautifulSoup(svg_content, 'xml')
+    # 仅保留text、group和image元素
+    for element in soup.find_all():
+        if element.name not in ['text', 'g', 'svg', 'image']:
+            element.decompose()
+    
+    svg_content_only_text = str(soup)
+    
+    # 创建临时文件
+    with tempfile.NamedTemporaryFile(suffix='.svg', delete=False) as mask_svg_file_only_text, \
+         tempfile.NamedTemporaryFile(suffix='.png', delete=False) as temp_mask_png_file_only_text:
+        mask_svg_only_text = mask_svg_file_only_text.name
+        temp_mask_png_only_text = temp_mask_png_file_only_text.name
+        mask_svg_file_only_text.write(svg_content_only_text.encode('utf-8'))
+        mask_svg_file_only_text.flush()
+        
+        # 验证SVG文件
+        if not validate_svg_file(mask_svg_only_text):
+            logger.error(f"无效的SVG文件: {mask_svg_only_text}")
+            
+        retry_count = 0
+        max_retries = 3
+        while retry_count < max_retries:
+            try:
+                subprocess.run([
+                    'rsvg-convert',
+                    '-f', 'png', 
+                    '-o', temp_mask_png_only_text,
+                    '--dpi-x', '300',
+                    '--dpi-y', '300',
+                    '--background-color', f"{original_background_color}",
+                    mask_svg_only_text
+                ], check=True)
+                break
+            except Exception as e:
+                retry_count += 1
+                logger.error(f"rsvg-convert执行失败 (尝试 {retry_count}/{max_retries}): {str(e)}")
+                if retry_count >= max_retries:
+                    raise e
+                time.sleep(1)
+        
+        
+    img_only_text = Image.open(temp_mask_png_only_text).convert('RGB')
+    img_array_only_text = np.array(img_only_text)
+    
+    # 确保图像尺寸匹配预期尺寸
+    actual_height, actual_width = img_array_only_text.shape[:2]
+    if actual_width != width or actual_height != height:
+        img_only_text = img_only_text.resize((width, height), Image.LANCZOS)
+        img_array_only_text = np.array(img_only_text)
+    
+    # 转换为二值mask
+    mask = np.ones((height, width), dtype=np.uint8)
+    # 随机采样300个点
+    total_pixels = height * width
+    sample_indices = np.random.choice(total_pixels, min(1000, total_pixels), replace=False)
+    sample_pixels = img_array_without_text.reshape(-1, 3)[sample_indices]
+    
+    # 排除接近背景色的像素
+    non_bg_pixels = sample_pixels[~np.all(np.abs(sample_pixels - background_color) <= 40, axis=1)]
+    
+    if len(non_bg_pixels) == 0:
+        mode_color = np.array([0, 0, 0])  # 如果没有非背景色像素，返回黑色
+    else:
+        # 将像素转换为元组以便计数
+        pixels_tuple = [tuple(p) for p in non_bg_pixels]
+        # 直接用Counter找出最常见的颜色
+        from collections import Counter
+        mode_color = np.array(Counter(pixels_tuple).most_common(1)[0][0])
+    # 使用mode_color作为众数颜色创建mask
+    mask = np.zeros((height, width), dtype=np.uint8)
+    mask_only_text = np.zeros((height, width), dtype=np.uint8)
+    
+    color_diff = np.sqrt(np.sum((img_array_without_text - mode_color) ** 2, axis=2))
+    mask[color_diff <= 2] = 1
+    
+    # 计算与背景色的差异,使用更严格的阈值
+    color_diff_only_text = np.sqrt(np.sum((img_array_only_text - background_color) ** 2, axis=2))
+    mask_only_text[color_diff_only_text >= 15] = 1  # 提高阈值从10到15,要求与背景色差异更��
+    
+    # 初始化填充mask
+    fill_mask = np.zeros((height, width), dtype=np.uint8)
+    fill_mask_only_text = np.zeros((height, width), dtype=np.uint8)
+    mask_padding = 3
+    for i in range(height):
+        last_j = -mask_padding
+        for j in range(width):
+            if mask[i, j] == 1:
+                if j - last_j < mask_padding:
+                    fill_mask[i, last_j:j+1] = 1
+                else:
+                    fill_mask[i, j] = 1
+                last_j = j
+
+    for j in range(width):
+        last_i = -mask_padding
+        for i in range(height):
+            if mask[i, j] == 1:
+                if i - last_i < mask_padding:
+                    fill_mask[last_i:i+1, j] = 1
+                else:
+                    fill_mask[i, j] = 1
+                last_i = i
+
+    for j in range(width):
+        last_i = -mask_padding
+        for i in range(height):
+            if mask_only_text[i, j] == 1:
+                if i - last_i < mask_padding:
+                    fill_mask_only_text[last_i:i+1, j] = 1
+                else:
+                    fill_mask_only_text[i, j] = 1
+                last_i = i
+
+    for i in range(height):
+        last_j = -mask_padding
+        for j in range(width):
+            if mask_only_text[i, j] == 1:
+                if j - last_j < mask_padding:
+                    fill_mask_only_text[i, last_j:j+1] = 1
+                else:
+                    fill_mask_only_text[i, j] = 1
+                last_j = j
+
+    mask = fill_mask
+    mask_only_text = fill_mask_only_text
+    os.remove(mask_svg_without_text)
+    os.remove(temp_mask_png_without_text)
+    os.remove(mask_svg_only_text)
+    os.remove(temp_mask_png_only_text)
+    
+    return mask, mask_only_text
+
+
+
+def calculate_mask_v2(svg_content: str, width: int, height: int, background_color: str, grid_size: int = 5, max_difference = 15, avoid_chart = False) -> np.ndarray:
+    """将SVG转换为基于背景色的二值化mask数组"""
+    width = int(width)
+    height = int(height)
+    
+    # 将背景色转换为RGB格式
+    original_background_color = background_color
+    background_color = tuple(int(background_color[i:i+2], 16) for i in (1, 3, 5))
+    
+    # 预处理SVG内容，删除背景元素和细线条
+    
+    # 解析SVG内容
+    soup = BeautifulSoup(svg_content, 'xml')
+    
+    background_elements = soup.select('[class="background"]')
+    for element in background_elements:
+        element.decompose()
+    
+    # 删除stroke-width<=1或没有stroke-width的所有line元素
+    thin_lines = soup.find_all('line')
+    for line in thin_lines:
+        stroke_width = line.get('stroke-width')
+        if not stroke_width or float(stroke_width) <= 1:
+            line.decompose()
+            
+    # 删除opacity<=0.1的所有元素
+    all_elements = soup.find_all()
+    for element in all_elements:
+        opacity = element.get('opacity')
+        if opacity and float(opacity) <= 0.1:
+            element.decompose()
+            
+    # 重新获取处理后的SVG内容
+    svg_content = str(soup)
+    
+    # 创建临时文件
+    with tempfile.NamedTemporaryFile(suffix='.svg', delete=False) as mask_svg_file, \
+         tempfile.NamedTemporaryFile(suffix='.png', delete=False) as temp_mask_png_file:
+        mask_svg = mask_svg_file.name
+        temp_mask_png = temp_mask_png_file.name
+        
+        # 修改SVG内容，移除渐变
+        # 将渐变填充替换为可见的纯色填充，而不是none
+        mask_svg_content = re.sub(r'fill="url\(#[^"]*\)"', 'fill="#333333"', svg_content)
+        mask_svg_content = re.sub(r'stroke="url\(#[^"]*\)"', 'stroke="#333333"', mask_svg_content)
+        mask_svg_content = mask_svg_content.replace('&', '&amp;')
+        
+        # 提取SVG内容并添加新的SVG标签
+        svg_content_match = re.search(r'<svg[^>]*>(.*?)</svg>', mask_svg_content, re.DOTALL)
+        if svg_content_match:
+            inner_content = svg_content_match.group(1)
+            # 创建新的SVG标签
+            mask_svg_content = f'<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{width}" height="{height}"> \
+            <rect width="{width}" height="{height}" fill="{original_background_color}" /> \
+            {inner_content} \
+            </svg>'
+        
+        mask_svg_file.write(mask_svg_content.encode('utf-8'))
+        mask_svg_file.flush()
+        
+        # 验证SVG文件
+        if not validate_svg_file(mask_svg):
+            logger.error(f"无效的SVG文件: {mask_svg}")
+        
+    max_retries = 3
+    retry_count = 0
+    while retry_count < max_retries:
+        try:
+            subprocess.run([
+                'rsvg-convert',
+                '-f', 'png', 
+                '-o', temp_mask_png,
+                '--dpi-x', '300',
+                '--dpi-y', '300',
+                '--background-color', f"{original_background_color}",
+                mask_svg
+            ], check=True)
+            break
+        except Exception as e:
+            retry_count += 1
+            logger.error(f"rsvg-convert执行失败 (尝试 {retry_count}/{max_retries}): {str(e)}")
+            if retry_count >= max_retries:
+                raise Exception(f"重试{max_retries}次后仍然失败: {str(e)}")
+            time.sleep(1)  # 等待1秒后重试
+    
+    # 读取为numpy数组并处理
+    img = Image.open(temp_mask_png).convert('RGB')
+    img_array = np.array(img)
+    
+    # 确保图像尺寸匹配预期尺寸
+    actual_height, actual_width = img_array.shape[:2]
+    if actual_width != width or actual_height != height:
+        img = img.resize((width, height), Image.LANCZOS)
+        img_array = np.array(img)
+    
+    # 转换为二值mask
+    mask = np.ones((height, width), dtype=np.uint8)
+    
+    for y in range(0, height, grid_size):
+        for x in range(0, width, grid_size):
+            y_end = min(y + grid_size, height)
+            x_end = min(x + grid_size, width)
+            
+            if y_end > y and x_end > x:
+                grid = img_array[y:y_end, x:x_end]
+                if grid.size > 0:
+                    # 计算与背景色的差异
+                    background_diff = np.sqrt(np.sum((grid - background_color) ** 2, axis=2))
+                    white_ratio = np.mean(background_diff < max_difference)
+                    mask[y:y_end, x:x_end] = 0 if white_ratio > 0.95 else 1
+    if avoid_chart:
+        # 如果avoid_chart为True，则找到mask中的1的x_min,x_max,y_min,y_max
+        y_min, x_min, y_max, x_max = calculate_bbox(mask)
+        print("x_min, x_max, y_min, y_max: ", x_min, x_max, y_min, y_max)
+        # 将mask中的x_min,x_max,y_min,y_max之间的区域填充为1
+        mask[y_min:y_max+1, x_min:x_max+1] = 1
+    
+    # 删除临时文件
+    os.remove(mask_svg)
+    os.remove(temp_mask_png)
+    
+    return mask
+
+
+def calculate_mask(svg_content: str, width: int, height: int, padding: int, grid_size: int = 5, bg_threshold: float = 220) -> np.ndarray:
+    """将SVG转换为二值化的mask数组"""
+    width = int(width)
+    height = int(height)
+    
+    # 创建临时文件
+    tmp_dir = "./tmp"
+    os.makedirs(tmp_dir, exist_ok=True)
+    mask_svg = os.path.join(tmp_dir, f"temp_mask_{random.randint(0, 999999)}.svg")
+    temp_mask_png = os.path.join(tmp_dir, f"temp_mask_{random.randint(0, 999999)}.png")
+    
+    try:
+        # 修改SVG内容，移除渐变
+        # 将渐变填充替换为可见的纯色填充，而不是none
+        mask_svg_content = re.sub(r'fill="url\(#[^"]*\)"', 'fill="#333333"', svg_content)
+        mask_svg_content = re.sub(r'stroke="url\(#[^"]*\)"', 'stroke="#333333"', mask_svg_content)
+        mask_svg_content = mask_svg_content.replace('&', '&amp;')
+        
+        # 提取SVG内容并添加新的SVG标签
+        svg_content_match = re.search(r'<svg[^>]*>(.*?)</svg>', mask_svg_content, re.DOTALL)
+        if svg_content_match:
+            inner_content = svg_content_match.group(1)
+            # 创建新的SVG标签
+            mask_svg_content = f'<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{width}" height="{height}">{inner_content}</svg>'
+        
+        # 添加padding
+        if padding > 0:
+            svg_tag_match = re.search(r'<svg[^>]*>', mask_svg_content)
+            if svg_tag_match:
+                svg_tag = svg_tag_match.group(0)
+                svg_tag_end = svg_tag_match.end()
+                svg_content_part = mask_svg_content[svg_tag_end:]
+                svg_end_tag = '</svg>'
+                svg_content_without_end = svg_content_part.replace(svg_end_tag, '')
+                
+                # 添加transform group
+                mask_svg_content = svg_tag + f'<g transform="translate({padding}, {padding})">' + svg_content_without_end + '</g>' + svg_end_tag
+        
+        with open(mask_svg, "w", encoding="utf-8") as f:
+            f.write(mask_svg_content)
+            
+        # 验证SVG文件
+        if not validate_svg_file(mask_svg):
+            logger.error(f"无效的SVG文件: {mask_svg}")
+            
+        retry_count = 0
+        max_retries = 3
+        while retry_count < max_retries:
+            try:
+                subprocess.run([
+                    'rsvg-convert',
+                    '-f', 'png',
+                    '-o', temp_mask_png,
+                    '--dpi-x', '300',
+                    '--dpi-y', '300',
+                    '--background-color', "#ffffff",
+                    mask_svg
+                ], check=True)
+                break
+            except Exception as e:
+                retry_count += 1
+                logger.error(f"rsvg-convert执行失败 (尝试 {retry_count}/{max_retries}): {str(e)}")
+                if retry_count >= max_retries:
+                    raise e
+                time.sleep(1)
+        
+        # 读取为numpy数组并处理
+        img = Image.open(temp_mask_png).convert('RGB')
+        img_array = np.array(img)
+        
+        # 确保图像尺寸匹配预期尺寸
+        actual_height, actual_width = img_array.shape[:2]
+        if actual_width != width or actual_height != height:
+            img = img.resize((width, height), Image.LANCZOS)
+            img_array = np.array(img)
+        
+        # 转换为二值mask
+        mask = np.ones((height, width), dtype=np.uint8)
+        
+        for y in range(0, height, grid_size):
+            for x in range(0, width, grid_size):
+                y_end = min(y + grid_size, height)
+                x_end = min(x + grid_size, width)
+                
+                if y_end > y and x_end > x:
+                    grid = img_array[y:y_end, x:x_end]
+                    if grid.size > 0:
+                        white_pixels = np.all(grid >= bg_threshold, axis=2)
+                        white_ratio = np.mean(white_pixels)
+                        mask[y:y_end, x:x_end] = 0 if white_ratio > 0.95 else 1
+        
+        return mask
+        
+    finally:
+        if os.path.exists(mask_svg):
+            os.remove(mask_svg)
+        if os.path.exists(temp_mask_png):
+            os.remove(temp_mask_png)
+
+def calculate_bbox(mask: np.ndarray) -> Tuple[int, int, int, int]:
+    """计算mask的bbox"""
+    rows = np.sum(mask == 1, axis=1) > 0
+    cols = np.sum(mask == 1, axis=0) > 0
+    row_indices = np.where(rows)[0]
+    col_indices = np.where(cols)[0]
+    return row_indices[0], col_indices[0], row_indices[-1], col_indices[-1]
+
+def calculate_content_width(mask: np.ndarray, padding: int = 0) -> Tuple[int, int, int]:
+    """计算mask中内容的实际宽度范围"""
+    content_columns = np.sum(mask == 1, axis=0) > 0  # 任何非零值表示该列有内容
+    content_indices = np.where(content_columns)[0]
+    
+    return content_indices[0] - padding, content_indices[-1] - padding, content_indices[-1] - content_indices[0] + 1
+
+def calculate_content_height(mask: np.ndarray, padding: int = 0) -> Tuple[int, int, int]:
+    """计算mask中内容的实际高度范围"""
+    # mask中1表示内容，0表示背景
+    content_rows = np.sum(mask == 1, axis=1) > 0  # 任何非零值表示该行有内容
+    content_indices = np.where(content_rows)[0]
+    
+    if len(content_indices) == 0:
+        return 0, 0, 0
+        
+    start_y = content_indices[0]
+    end_y = content_indices[-1]
+    height = end_y - start_y + 1
+    
+    return start_y - padding, end_y - padding, height
+
+def fill_columns_between_bounds(mask: np.ndarray, x_min: int, x_max: int, y_min: int, y_max: int) -> np.ndarray:
+    """
+    扫描子矩形区域内每一列的第一个1和最后一个1，将两者之间的区域填充为1
+    
+    Args:
+        mask: 输入的mask数组
+        x_min: 子矩形区域的最小x坐标
+        x_max: 子矩形区域的最大x坐标
+        y_min: 子矩形区域的最小y坐标
+        y_max: 子矩形区域的最大y坐标
+    
+    Returns:
+        np.ndarray: 处理后的mask数组
+    """
+    # 确保坐标在有效范围内
+    height, width = mask.shape
+    x_min = max(0, min(x_min, width - 1))
+    x_max = max(0, min(x_max, width - 1))
+    y_min = max(0, min(y_min, height - 1))
+    y_max = max(0, min(y_max, height - 1))
+    
+    # 创建新的mask副本
+    new_mask = mask.copy()
+    
+    # 对每一列进行处理
+    for x in range(x_min, x_max + 1):
+        # 直接获取该列在指定范围内的切片
+        col_slice = new_mask[y_min:y_max+1, x]
+        
+        if np.any(col_slice == 1):
+            # 找出该列中1的位置
+            content_indices = np.where(col_slice == 1)[0]
+            
+            if len(content_indices) > 0:
+                # 填充该列从第一个1到最后一个1之间的所有位置
+                col_slice[content_indices[0]:content_indices[-1]+1] = 1
+                # 将修改后的切片放回原数组
+                new_mask[y_min:y_max+1, x] = col_slice
+    
+    return new_mask
+
+def expand_mask(mask: np.ndarray, dist: int) -> np.ndarray:
+    """
+    扩展现有掩码，将任何与现有掩码距离小于dist的像素设为1。
+    
+    Args:
+        mask: 输入的掩码数组，其中1表示内容，0表示背景
+        dist: 距离阈值（像素）
+    
+    Returns:
+        np.ndarray: 扩展后的掩码数组
+    """
+    # 使用距离变换计算每个背景像素到最近的内容像素的距离
+    # 首先反转掩码，因为距离变换计算到0的距离
+    inv_mask = 1 - mask
+    # 计算距离图
+    dist_map = ndimage.distance_transform_edt(inv_mask)
+    # 创建新的掩码，将距离小于dist的像素设为1
+    expanded_mask = np.where(dist_map < dist, 1, mask)
+    
+    return expanded_mask

modules/infographics_generator/parse_utils.py

@@ -0,0 +1,152 @@
+import time
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from bs4 import BeautifulSoup, NavigableString
+from modules.infographics_generator.chat_utils import safe_save_json, load_txt
+
+def parse_element_with_style_and_bbox(driver, web_element):
+    computed_style = driver.execute_script("""
+        const elem = arguments[0];
+        const styles = window.getComputedStyle(elem);
+        const style_dict = {};
+        for (let i = 0; i < styles.length; i++) {
+            const prop = styles[i];
+            style_dict[prop] = styles.getPropertyValue(prop);
+        }
+        return style_dict;
+    """, web_element)
+
+    # only keep color-related attributes in style
+    color_attributes = ['fill', 'stroke', 'opacity', 'fill-opacity', 'stroke-opacity', 'stroke-width']
+    computed_style = {k: v for k, v in computed_style.items() if k in color_attributes}
+
+    bbox = driver.execute_script("""
+        const elem = arguments[0];
+        try {
+            const box = elem.getBoundingClientRect();
+            return {x: box.x, y: box.y, width: box.width, height: box.height};
+        } catch (e) {
+            return null;
+        }
+    """, web_element)
+    
+    svg_bbox = driver.execute_script("""
+        const elem = arguments[0];
+        try {
+            const box = elem.getBBox();
+            return {x: box.x, y: box.y, width: box.width, height: box.height};
+        } catch (e) {
+            return null;
+        }
+    """, web_element)
+
+    return computed_style, bbox, svg_bbox
+
+def parse_svg_tree(driver, bs_element: BeautifulSoup, selenium_element):
+    tag_name = bs_element.name
+    assert not isinstance(bs_element, NavigableString), "bs_element should not be NavigableString"
+    
+    attributes = dict(bs_element.attrs)
+    computed_style, bbox, svg_bbox = None, None, None
+    if selenium_element:
+        computed_style, bbox, svg_bbox = parse_element_with_style_and_bbox(driver, selenium_element)
+
+    node_info = {
+        "tag": tag_name,
+        "attributes": attributes,
+        "computed_style": computed_style,
+        "bounding_box": bbox,
+        "svg_bounding_box": svg_bbox,
+        "html": str(bs_element),
+        "children": []
+    }
+
+    if len(bs_element.find_all(recursive=False)) > 5000:
+        print(f"--- {bs_element.name} has too many children: {len(bs_element.find_all(recursive=False))}")
+        return node_info
+
+    for child in bs_element.find_all(recursive=False):
+        siblings = child.find_previous_siblings(child.name)
+        index = len(siblings) + 1
+        child_sele = selenium_element.find_element(By.XPATH, f'./*[local-name()="{child.name}"][{index}]')
+        child_info = parse_svg_tree(driver, child, child_sele)
+        if child_info:
+            node_info["children"].append(child_info)
+    if not node_info["children"]:
+        # judge if has text
+        text_content = bs_element.text.strip()
+        if text_content:
+            node_info["text"] = text_content
+
+
+    return node_info
+
+def parse_tree_from_html(driver: webdriver.Chrome, html_path: str, save_svg=True):
+    driver.get(f'file://{html_path}')
+    
+    time.sleep(0.2)
+
+    svg_element = driver.find_element("css selector", "svg")
+    svg_content = svg_element.get_attribute('outerHTML')    
+    if save_svg:
+        svg_file_path = html_path.replace('.html', '_extracted.svg')
+        with open(svg_file_path, 'w', encoding='utf-8') as f:
+            f.write(svg_content)
+    
+    soup = BeautifulSoup(svg_content, "xml")
+    svg_root = soup.find('svg')
+
+    tree_data = parse_svg_tree(driver, svg_root, svg_element)
+    safe_save_json(tree_data, html_path.replace('.html', '.json'))
+    return tree_data
+
+def convert_svg_to_html(svg_path: str, html_path: str):
+    svg_content = load_txt(svg_path)
+    html = f"""<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <title>Infographic Chart</title>
+        <style>
+            html, body {{
+                margin: 0;
+                padding: 0;
+                background: #ffffff;
+            }}
+            svg {{
+                display: block;
+            }}
+        </style>
+    </head>
+    <body>
+        <div id="chart-container">
+          {svg_content}
+        </div>
+    </body>
+</html>
+"""
+    with open(html_path, 'w', encoding='utf-8') as f:
+        f.write(html)
+    return html
+
+def convert_g_to_html(g_str, gw, gh, html_path: str):
+    html = f"""<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <title>Infographic Chart</title>
+    </head>
+    <body>
+        <div id="chart-container">
+            <svg width="{gw}" height="{gh}">
+                <g transform="translate({gw / 2}, {gh / 2})">
+                    {g_str}
+                </g>
+            </svg>
+        </div>
+    </body>
+</html>
+"""
+    with open(html_path, 'w', encoding='utf-8') as f:
+        f.write(html)
+    return html

modules/infographics_generator/screenshot_utils.py

@@ -0,0 +1,299 @@
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.common.exceptions import WebDriverException, NoSuchElementException
+from selenium.webdriver.chrome.service import Service as ChromeService
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.common.by import By
+import time
+import tempfile
+import random
+import os
+import sys
+import warnings
+warnings.filterwarnings('ignore')
+_stderr = sys.stderr
+sys.stderr = open(os.devnull, 'w')
+from PIL import Image
+sys.stderr = _stderr
+
+try:
+    from config import RENDER_LONGEST_SIDE
+except Exception:
+    RENDER_LONGEST_SIDE = 3860
+
+
+def get_driver(max_retries=1, delay=0):
+    """启动稳定的 headless Chrome，支持 Linux headless 环境。"""
+    for attempt in range(1, max_retries + 1):
+        try:
+            options = webdriver.ChromeOptions()
+            options.add_argument("--headless=new")
+            options.add_argument("--no-sandbox")
+            options.add_argument("--disable-software-rasterizer")
+            options.add_argument("--disable-gpu")
+            options.add_argument("--disable-extensions")
+            options.add_argument("--disable-background-networking")
+            options.add_argument("--disable-default-apps")
+            options.add_argument("--disable-sync")
+            options.add_argument("--disable-translate")
+            options.add_argument("--metrics-recording-only")
+            options.add_argument("--mute-audio")
+            options.add_argument("--hide-scrollbars")
+
+            base_tmp = os.environ.get("CHROMIUM_TMP", "/dev/shm/chartpipeline_chromium" if os.path.isdir("/dev/shm") else os.path.join(tempfile.gettempdir(), "chartpipeline_chromium"))
+            cache_dir = os.path.join(base_tmp, "cache")
+            crash_dir = os.path.join(base_tmp, "crash")
+            media_cache_dir = os.path.join(base_tmp, "media_cache")
+            os.makedirs(cache_dir, exist_ok=True)
+            os.makedirs(crash_dir, exist_ok=True)
+            os.makedirs(media_cache_dir, exist_ok=True)
+
+            options.add_argument(f"--disk-cache-dir={cache_dir}")
+            options.add_argument(f"--media-cache-dir={media_cache_dir}")
+            options.add_argument(f"--crash-dumps-dir={crash_dir}")
+
+            service = ChromeService(
+                log_output=open(f"chromedriver_attempt{attempt}.log", "w")
+            )
+            options.add_argument("--enable-logging")
+            options.add_argument("--v=1")
+            options.add_argument("--log-file=chrome.log")
+
+            unique_tmpdir = tempfile.mkdtemp(prefix="chrome_")
+            options.add_argument(f"--user-data-dir={unique_tmpdir}")
+
+            driver = webdriver.Chrome(options=options, service=service)
+            print(f">>> ChromeDriver started successfully on attempt {attempt}")
+            return driver
+        except WebDriverException as e:
+            if attempt < max_retries:
+                print(f"[Retry {attempt}/{max_retries}] Chrome 启动失败: {e}, {delay}s 后重试...")
+                time.sleep(delay)
+            else:
+                raise
+
+
+# JS run inside the headless Chrome to mitigate text-overlap artifacts before
+# rasterizing. We never know in advance which chart template will produce
+# overlapping labels (outer-ring labels on circular charts, dense axis ticks,
+# absolute-positioned annotations, ...), so we work directly on the live DOM:
+#   * collect every visible non-empty <text>
+#   * find pairs whose client rects overlap by more than MIN_OVERLAP_FRAC
+#   * shrink the font-size of every text in a conflict by SHRINK each round
+# Repeat until no overlaps remain, every conflicting text has hit MIN_FONT_PX,
+# or we exhaust MAX_ITER. Pure font-size tweaks keep each <text> anchored at
+# the same x/y so SVG layout stays valid; we then serialize the patched DOM
+# back so the caller can persist the post-processed SVG alongside the PNG.
+_RESOLVE_TEXT_OVERLAP_JS = r"""
+return (function() {
+  const MIN_FONT_PX = 6.0;
+  const SHRINK = 0.9;
+  const MAX_ITER = 12;
+  const MAX_TEXTS = 600;
+  // Require this much breathing room (in CSS px) between any two text bboxes.
+  // We inflate each rect by MARGIN_PX/2 on every side before testing for
+  // overlap, so a "real" 0-px touch counts as a conflict and the algorithm
+  // keeps shrinking until at least MARGIN_PX of whitespace exists between
+  // neighbouring labels (or font hits MIN_FONT_PX).
+  const MARGIN_PX = 3.0;
+  // Even with margin enforced, ignore micro-overlaps below this many
+  // squared pixels so anti-alias seams or sub-pixel rounding don't trigger
+  // an infinite shrink loop.
+  const MIN_OVERLAP_AREA_PX2 = 1.0;
+
+  function inflate(r, m) {
+    return {
+      left: r.left - m,
+      right: r.right + m,
+      top: r.top - m,
+      bottom: r.bottom + m,
+      width: r.width + 2 * m,
+      height: r.height + 2 * m,
+    };
+  }
+
+  function rectsOverlap(a, b) {
+    const ai = inflate(a, MARGIN_PX / 2);
+    const bi = inflate(b, MARGIN_PX / 2);
+    const ix = Math.max(0, Math.min(ai.right, bi.right) - Math.max(ai.left, bi.left));
+    const iy = Math.max(0, Math.min(ai.bottom, bi.bottom) - Math.max(ai.top, bi.top));
+    if (ix <= 0 || iy <= 0) return 0;
+    const inter = ix * iy;
+    if (inter < MIN_OVERLAP_AREA_PX2) return 0;
+    return inter;
+  }
+
+  function visibleNonEmptyTexts() {
+    const all = document.querySelectorAll('text');
+    const out = [];
+    for (const t of all) {
+      const cs = window.getComputedStyle(t);
+      if (cs.display === 'none' || cs.visibility === 'hidden') continue;
+      if (!t.textContent || !t.textContent.trim()) continue;
+      const r = t.getBoundingClientRect();
+      if (r.width <= 0 || r.height <= 0) continue;
+      out.push(t);
+      if (out.length >= MAX_TEXTS) break;
+    }
+    return out;
+  }
+
+  function fs(el) {
+    const cs = window.getComputedStyle(el);
+    return parseFloat(cs.fontSize) || 12;
+  }
+
+  let conflictsAtStart = 0;
+  let totalShrunk = 0;
+  let iters = 0;
+  let conflictsAtEnd = 0;
+
+  for (let it = 0; it < MAX_ITER; it++) {
+    iters = it + 1;
+    const texts = visibleNonEmptyTexts();
+    if (texts.length === 0) break;
+
+    const rects = texts.map(t => t.getBoundingClientRect());
+    const conflict = new Set();
+    for (let i = 0; i < texts.length; i++) {
+      for (let j = i + 1; j < texts.length; j++) {
+        if (rectsOverlap(rects[i], rects[j]) > 0) {
+          conflict.add(i);
+          conflict.add(j);
+        }
+      }
+    }
+    if (it === 0) conflictsAtStart = conflict.size;
+    conflictsAtEnd = conflict.size;
+    if (conflict.size === 0) break;
+
+    let shrunkThisIter = 0;
+    for (const i of conflict) {
+      const cur = fs(texts[i]);
+      if (cur > MIN_FONT_PX + 0.01) {
+        const nv = Math.max(MIN_FONT_PX, cur * SHRINK);
+        texts[i].style.fontSize = nv.toFixed(2) + 'px';
+        shrunkThisIter++;
+      }
+    }
+    totalShrunk += shrunkThisIter;
+    if (shrunkThisIter === 0) break;
+  }
+
+  const svgEl = document.querySelector('svg');
+  const finalSvg = svgEl ? new XMLSerializer().serializeToString(svgEl) : '';
+  return {
+    conflictsAtStart: conflictsAtStart,
+    conflictsAtEnd: conflictsAtEnd,
+    totalShrunk: totalShrunk,
+    iters: iters,
+    svg: finalSvg,
+  };
+})();
+"""
+
+
+def take_screenshot(
+    driver: webdriver.Chrome,
+    html_path: str,
+    longest_side: int = None,
+    resolve_text_overlap: bool = False,
+):
+    """
+    Use headless Chrome to rasterize the chart at the requested longest side,
+    using CDP to set a high device pixel ratio so output matches browser rendering
+    (font weight, kerning, fallbacks).
+
+    When ``resolve_text_overlap`` is true, we run an in-browser pass that
+    iteratively shrinks the font-size of any visible <text> elements whose
+    bounding boxes overlap, then capture the screenshot of the patched DOM.
+    The post-processed SVG (with inline ``style="font-size:..."`` on each
+    shrunk text) is returned so the caller can persist it alongside the PNG.
+
+    Returns
+    -------
+    dict | None
+        ``{"conflictsAtStart", "conflictsAtEnd", "totalShrunk", "iters", "svg"}``
+        when text-overlap resolution ran (regardless of whether anything was
+        shrunk), or ``None`` if it was disabled.
+    """
+    if longest_side is None:
+        longest_side = int(os.environ.get("RENDER_LONGEST_SIDE", RENDER_LONGEST_SIDE))
+
+    abs_path = os.path.abspath(html_path)
+    out_png = abs_path.replace('.html', '.png')
+
+    driver.get(f'file://{abs_path}')
+    wait = WebDriverWait(driver, 10)
+    svg = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "svg")))
+
+    overlap_result = None
+    if resolve_text_overlap:
+        try:
+            overlap_result = driver.execute_script(_RESOLVE_TEXT_OVERLAP_JS)
+        except Exception as _e:
+            import traceback as _tb
+            print(f"[overlap-fix] JS failed: {_e}\n{_tb.format_exc()}", flush=True)
+            overlap_result = None
+
+    svg_width = float(driver.execute_script("return arguments[0].getBoundingClientRect().width;", svg))
+    svg_height = float(driver.execute_script("return arguments[0].getBoundingClientRect().height;", svg))
+    if svg_width <= 0 or svg_height <= 0:
+        raise RuntimeError("Failed to measure SVG size")
+
+    # Pick DPR so the long edge in physical pixels equals longest_side.
+    css_long = max(svg_width, svg_height)
+    dpr = max(1.0, longest_side / css_long)
+    # Cap DPR so chrome doesn't try to allocate huge buffers; we'll LANCZOS-upscale
+    # the rest if needed.
+    MAX_DPR = 4.0
+    dpr = min(dpr, MAX_DPR)
+
+    css_w = int(round(svg_width)) + 2
+    css_h = int(round(svg_height)) + 2
+
+    try:
+        driver.execute_cdp_cmd("Emulation.setDeviceMetricsOverride", {
+            "width": css_w,
+            "height": css_h,
+            "deviceScaleFactor": dpr,
+            "mobile": False,
+        })
+    except Exception:
+        pass
+
+    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as temp_file:
+        temp_path = temp_file.name
+    try:
+        location = svg.location
+        size = svg.size
+        driver.save_screenshot(temp_path)
+
+        image = Image.open(temp_path)
+        # Coordinates are in CSS pixels; multiply by DPR to crop the actual image.
+        left = max(0, int(round(location['x'] * dpr)))
+        top = max(0, int(round(location['y'] * dpr)))
+        right = min(image.width, int(round((location['x'] + size['width']) * dpr)))
+        bottom = min(image.height, int(round((location['y'] + size['height']) * dpr)))
+        cropped = image.crop((left, top, right, bottom))
+
+        cw, ch = cropped.size
+        if cw > 0 and ch > 0 and max(cw, ch) != longest_side:
+            scale = longest_side / max(cw, ch)
+            cropped = cropped.resize(
+                (max(1, int(round(cw * scale))), max(1, int(round(ch * scale)))),
+                Image.LANCZOS,
+            )
+        cropped.save(out_png)
+    finally:
+        try:
+            os.unlink(temp_path)
+        except OSError:
+            pass
+        try:
+            driver.execute_cdp_cmd("Emulation.clearDeviceMetricsOverride", {})
+        except Exception:
+            pass
+
+    return overlap_result

modules/infographics_generator/svg_utils.py

@@ -0,0 +1,544 @@
+from typing import Optional
+from lxml import etree
+import xml.etree.ElementTree as ET
+from svgpathtools import parse_path
+import re
+import numpy as np
+from PIL import Image
+import subprocess
+import tempfile
+import os
+import re
+import colorsys
+
+def add_gradient_to_rect(rect_svg):
+    """
+    将普通填充的矩形SVG转换为带有渐变效果的矩形
+    
+    参数:
+        rect_svg (str): 普通填充的矩形SVG，例如 <rect x="0" y="0" width="781" height="707" fill="#E2F1F6" />
+        
+    返回:
+        str: 带有渐变效果的矩形SVG
+    """
+    # 提取矩形属性
+    x_match = re.search(r'x="([^"]*)"', rect_svg)
+    y_match = re.search(r'y="([^"]*)"', rect_svg)
+    width_match = re.search(r'width="([^"]*)"', rect_svg)
+    height_match = re.search(r'height="([^"]*)"', rect_svg)
+    fill_match = re.search(r'fill="([^"]*)"', rect_svg)
+    
+    # 默认值
+    x = x_match.group(1) if x_match else "0"
+    y = y_match.group(1) if y_match else "0"
+    width = width_match.group(1) if width_match else "100"
+    height = height_match.group(1) if height_match else "100"
+    fill = fill_match.group(1) if fill_match else "#000000"
+    
+    # 创建渐变ID
+    gradient_id = f"gradient_{hash(rect_svg) % 10000}"
+    
+    # 计算渐变的第二个颜色（稍微暗一点或者亮一点）
+    # 移除#前缀并解析十六进制颜色
+    hex_color = fill.lstrip('#')
+    # 转换十六进制为RGB
+    r, g, b = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+    # 转换RGB为HSL
+    h, l, s = colorsys.rgb_to_hls(r/255, g/255, b/255)
+    
+    # 创建稍微暗一点的颜色
+    l_darker = max(0, l - 0.1)  # 降低亮度，但不低于0
+    r_darker, g_darker, b_darker = colorsys.hls_to_rgb(h, l_darker, s)
+    
+    # 转换回十六进制
+    end_color = "#{:02x}{:02x}{:02x}".format(
+        int(r_darker * 255), 
+        int(g_darker * 255), 
+        int(b_darker * 255)
+    )
+    
+    # 创建带有渐变的SVG
+    gradient_svg = f"""<defs>
+    <!-- 背景渐变 -->
+    <linearGradient id="{gradient_id}" x1="0%" y1="0%" x2="0%" y2="100%">
+        <stop offset="0%" stop-color="{fill}" />
+        <stop offset="100%" stop-color="{end_color}" />
+    </linearGradient>
+</defs>
+
+<!-- 背景矩形 -->
+<rect x="{x}" y="{y}" width="{width}" height="{height}" fill="url(#{gradient_id})" />"""
+    
+    return gradient_svg
+
+def extract_svg_content(svg_content: str) -> Optional[str]:
+    """从SVG内容中提取内部元素"""
+    # try:
+    svg_tree = etree.fromstring(svg_content.encode())
+    # 获取所有子元素
+    children = svg_tree.getchildren()
+    if not children:
+        return None
+    
+    # 将子元素转换为字符串
+    content = ""
+    for child in children:
+        content += etree.tostring(child, encoding='unicode')
+    return content
+    # except Exception as e:
+    #     return None
+
+def remove_large_rects(svg_content: str) -> str:
+    """移除SVG中的大型矩形元素"""
+    try:
+        svg_tree = etree.fromstring(svg_content.encode())
+        for rect in svg_tree.xpath("//rect"):
+            width = float(rect.get("width", 0))
+            height = float(rect.get("height", 0))
+            if width * height > 500 * 500:
+                rect.getparent().remove(rect)
+        return etree.tostring(svg_tree, encoding='unicode')
+    except Exception as e:
+        return svg_content 
+
+def extract_large_rect(svg_content: str) -> tuple[str, str]:
+    """
+    提取SVG中的大型背景矩形或图像元素，并从原SVG中删除它。
+    
+    条件：
+    1. 元素是rect或image，且class="background"
+    2. width*height > 500*500
+    3. 没有设置opacity属性或opacity > 0.5
+    
+    参数:
+        svg_content (str): 原始SVG内容
+        
+    返回:
+        tuple[str, str]: (修改后的SVG内容, 提取的背景元素内容)
+                         如果没有找到符合条件的元素，则返回(原始SVG, '')
+    """
+    try:
+        # 确保SVG内容被正确的<svg>标签包围
+        if not svg_content.strip().startswith('<svg'):
+            svg_content = f'<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">{svg_content}</svg>'
+        
+        svg_tree = etree.fromstring(svg_content.encode())
+        
+        # 寻找class为background的rect元素
+        background_elements = svg_tree.xpath("//*[local-name()='rect' and @class='background']|"
+                            "//*[local-name()='image' and @class='background']")
+        # print("background_elements", background_elements)
+        
+        for element in background_elements:
+            # 获取宽度和高度
+            width = float(element.get("width", 0))
+            height = float(element.get("height", 0))
+            
+            # 检查大小条件
+            if width * height <= 500 * 500:
+                continue
+                
+            # 检查opacity条件
+            opacity = element.get("opacity")
+            if opacity is not None and float(opacity) <= 0.5:
+                continue
+                
+            # 提取背景元素
+            background_element = etree.tostring(element, encoding='unicode')
+            
+            # 从原SVG中删除该元素
+            element.getparent().remove(element)
+            
+            # 返回修改后的SVG内容和提取的背景元素内容
+            result_svg = etree.tostring(svg_tree, encoding='unicode')
+            # 如果原始内容不包含<svg>标签，则提取内部内容
+            if not svg_content.strip().startswith('<svg'):
+                result_svg = extract_svg_content(result_svg) or ''
+            
+            return result_svg, background_element
+            
+        # 如果没有找到符合条件的元素
+        if not svg_content.strip().startswith('<svg'):
+            return svg_content, ''
+        else:
+            content = extract_svg_content(svg_content) or ''
+            return content, ''
+        
+    except Exception as e:
+        print(f"提取背景元素时发生错误: {e}")
+        return svg_content, ''
+
+def extract_background_element(svg_content: str) -> str:
+    """
+    提取SVG中属于class="chart"下面且class="background"的元素,并把他们移动到svg的顶层，放置在image元素的前面
+    注意：需要保持位置不变，因此需要将transform属性累加
+    """
+    try:
+        # 确保SVG内容被正确的<svg>标签包围
+        if not svg_content.strip().startswith('<svg'):
+            svg_content = f'<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">{svg_content}</svg>'
+        
+        # 解析SVG内容
+        svg_tree = etree.fromstring(svg_content.encode())
+        
+        # 查找所有class="chart"元素下的class="background"元素
+        namespaces = {'svg': 'http://www.w3.org/2000/svg'}
+        background_elements = svg_tree.xpath("//*[contains(@class, 'chart')]//*[contains(@class, 'background')]")
+        
+        if not background_elements:
+            return svg_content
+            
+        # 存储提取的背景元素
+        extracted_elements = []
+        
+        for element in background_elements:
+            # 计算累积的transform
+            current = element
+            total_transform = ""
+            transforms = []
+            
+            while current is not None and current != svg_tree:
+                transform = current.get("transform")
+                if transform:
+                    transforms.insert(0, transform)
+                current = current.getparent()
+            
+            if transforms:
+                total_transform = " ".join(transforms)
+            
+            # 创建新元素，复制原始元素的所有属性
+            new_element = etree.Element(element.tag)
+            for key, value in element.attrib.items():
+                if key != "transform":  # 不复制原始的transform
+                    new_element.set(key, value)
+            
+            # 设置累积后的transform
+            if total_transform:
+                new_element.set("transform", total_transform)
+            
+            # 保存新元素的字符串表示
+            extracted_elements.append(etree.tostring(new_element, encoding='unicode'))
+            
+            # 从原位置移除元素
+            element.getparent().remove(element)
+        # print("svg_tree", svg_tree)
+        # 找到第一个image元素 (tag是image且class是image)
+        # 使用xpath查找所有image元素,不管是否有class属性
+        first_image = svg_tree.xpath(".//image")
+        if first_image:
+            first_image = first_image[0]
+        else:
+            # 如果没有找到image元素,尝试使用命名空间查找
+            namespaces = {'svg': 'http://www.w3.org/2000/svg'}
+            first_image = svg_tree.xpath(".//svg:image", namespaces=namespaces)
+            if first_image:
+                first_image = first_image[0]
+            else:
+                first_image = None
+        # print("找到的image元素:", first_image)
+        
+        
+        # 将提取的元素插入到适当的位置
+        if first_image is not None:
+            # print("first_image", first_image)
+            # 如果存在image元素，将背景元素插入到其前面
+            parent = first_image.getparent()
+            for elem_str in extracted_elements:
+                new_elem = etree.fromstring(elem_str)
+                parent.insert(parent.index(first_image), new_elem)
+        else:
+            # print("no first_image")
+            # 如果不存在image元素，将背景元素添加到SVG的开始位置
+            for elem_str in reversed(extracted_elements):
+                new_elem = etree.fromstring(elem_str)
+                svg_tree.insert(0, new_elem)
+        
+        # 转换回字符串
+        result = etree.tostring(svg_tree, encoding='unicode')
+        
+        # 如果原始输入没有svg标签，则提取内部内容
+        if not svg_content.strip().startswith('<svg'):
+            result = extract_svg_content(result) or ''
+            
+        return result
+        
+    except Exception as e:
+        print(f"提取背景元素时发生错误: {e}")
+        return svg_content
+
+def parse_translate(transform_str):
+    """Parse translate(x, y) from the transform attribute."""
+    match = re.search(r'translate\(\s*([-\d.]+)(?:[\s,]+([-\d.]+))?\s*\)', transform_str)
+    if match:
+        tx = float(match.group(1))
+        ty = float(match.group(2)) if match.group(2) else 0.0
+        return tx, ty
+    return 0.0, 0.0
+
+
+def adjust_and_get_bbox(svg_content, background_color = "#FFFFFF"):
+    """Adjust SVG and get precise bounding box."""
+    # Create temporary files for SVG and PNG
+    with tempfile.NamedTemporaryFile(suffix='.svg', delete=False) as temp_svg, \
+         tempfile.NamedTemporaryFile(suffix='.png', delete=False) as temp_png:
+        temp_svg_path = temp_svg.name
+        temp_png_path = temp_png.name
+
+        svg_container = f"<svg \
+            width='1000' \
+            height='1000' \
+            xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'> \
+            {svg_content}</svg>"
+        with open(temp_svg_path, 'w', encoding='utf-8') as f:
+            f.write(svg_container)
+            f.flush()
+        bbox = get_svg_actual_bbox(temp_svg_path)
+        if bbox is None:
+            try:
+                os.unlink(temp_svg_path)
+                os.unlink(temp_png_path)
+            except Exception:
+                pass
+            raise ValueError("chart SVG has no recognizable geometry (empty bbox)")
+        padding = 150
+        new_width = bbox['width'] + padding * 2
+        new_height = bbox['height'] + padding * 2
+        svg_container = f"<svg \
+            width='{new_width}' \
+            height='{new_height}' \
+            xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'> \
+            <rect width='{new_width}' height='{new_height}' fill='{background_color}' /> \
+            <g transform='translate({padding - bbox['min_x']}, {padding - bbox['min_y']})'> \
+                {svg_content} \
+            </g> \
+            </svg>"
+    
+        with open(temp_svg_path, 'w', encoding='utf-8') as f:
+            f.write(svg_container)
+            f.flush()
+        svg_to_png(temp_svg_path, temp_png_path, background_color)
+        x_min, y_min, x_max, y_max = get_precise_bbox(temp_png_path, background_color)
+        width = x_max - x_min + 1
+        height = y_max - y_min + 1
+        offset_x = padding - bbox['min_x'] - x_min
+        offset_y = padding - bbox['min_y'] - y_min
+        svg_container = f"<g transform='translate({offset_x}, {offset_y})'> \
+            {svg_content} \
+        </g>"
+
+        os.unlink(temp_svg_path)
+        os.unlink(temp_png_path)
+    
+    return svg_container, width, height, offset_x, offset_y
+    
+def remove_image_element(svg_content: str) -> str:
+    """Remove image element from SVG content."""
+    try:
+        # 确保SVG内容以</svg>结尾
+        if not svg_content.strip().endswith('</svg>'):
+            svg_content = svg_content + '</svg>'
+            
+        # 解析SVG内容
+        svg_tree = etree.fromstring(svg_content.encode())
+        
+        # 移除所有image元素,包括不同命名空间下的image元素
+        namespaces = {'svg': 'http://www.w3.org/2000/svg', 
+                     'xlink': 'http://www.w3.org/1999/xlink'}
+        for image in svg_tree.xpath("//image | //*[local-name()='image']", namespaces=namespaces):
+            # print("image", image)
+            image.getparent().remove(image)
+            
+        # 转换回字符串
+        return etree.tostring(svg_tree, encoding='unicode', pretty_print=True)
+    except Exception as e:
+        print(f"Error removing image element: {str(e)}")
+        print(f"SVG content: {svg_content}")
+        return svg_content
+
+def svg_to_png(svg_path, png_path, background_color = "#FFFFFF"):
+    """Convert SVG to PNG using rsvg-convert with a white background."""
+    # Add --background-color=#FFFFFF to set white background
+    cmd = ['rsvg-convert', '--background-color=' + background_color, svg_path, '-o', png_path]
+    subprocess.run(cmd, check=True)
+
+def get_precise_bbox(png_path, background_color = "#FFFFFF"):
+    """Get precise bounding box by detecting the exact non-transparent pixels."""
+    img = Image.open(png_path).convert("RGBA")
+    width, height = img.size
+    
+    # Convert image to numpy array for efficient processing
+    img_array = np.array(img)
+    
+    # Get alpha channel and RGB values
+    alpha = img_array[:, :, 3]
+    rgb = img_array[:, :, :3]
+    
+    # Consider pixels close to the background color as transparent too
+    bg_rgb = np.array([int(background_color[i:i+2], 16) for i in (1, 3, 5)])  # Convert hex to RGB
+    threshold = 15  # Define a threshold for color similarity
+    is_background = np.all(np.abs(rgb - bg_rgb) < threshold, axis=2)
+    
+    # Find non-transparent and non-background pixels
+    non_transparent = (alpha > 0) & (~is_background)
+    
+    # If there are no non-transparent pixels, return the full image dimensions
+    if not np.any(non_transparent):
+        return 0, 0, width, height
+    
+    # Find the bounds of non-transparent pixels
+    rows = np.any(non_transparent, axis=1)
+    cols = np.any(non_transparent, axis=0)
+    
+    # Get the boundaries
+    y_min, y_max = np.where(rows)[0][[0, -1]]
+    x_min, x_max = np.where(cols)[0][[0, -1]]
+    # Get full image dimensions
+    return x_min, y_min, x_max + 1, y_max + 1
+
+def get_svg_actual_bbox(svg_path):
+    # print("svg_path: ", svg_path)
+    # 使用lxml而不是xml.etree.ElementTree
+    tree = etree.parse(svg_path)
+    root = tree.getroot()
+    # 获取SVG的原始宽度和高度
+    svg_width = float(root.get('width', '0').replace('px', ''))
+    svg_height = float(root.get('height', '0').replace('px', ''))
+
+    min_x, min_y = float('inf'), float('inf')
+    max_x, max_y = float('-inf'), float('-inf')
+
+    def update_bounds(x_vals, y_vals):
+        nonlocal min_x, min_y, max_x, max_y
+        min_x = min(min_x, min(x_vals))
+        max_x = max(max_x, max(x_vals))
+        min_y = min(min_y, min(y_vals))
+        max_y = max(max_y, max(y_vals))
+
+    def get_accumulated_transform(elem):
+        # 获取从根元素到当前元素的所有transform累加
+        total_dx, total_dy = 0.0, 0.0
+        current = elem
+        while current is not None:
+            transform = current.get("transform")
+            if transform:
+                dx, dy = parse_translate(transform)
+                total_dx += dx
+                total_dy += dy
+            parent = current.getparent()
+            if current == root:
+                break
+            current = parent
+        return total_dx, total_dy
+
+    def parse_percentage(value, base):
+        """解析百分比值，返回实际数值"""
+        if isinstance(value, str) and '%' in value:
+            percentage = float(value.replace('%', '')) / 100
+            return base * percentage
+        return float(value)
+
+    def parse_points(points_str):
+        """解析points属性中的点坐标"""
+        points = []
+        for point in points_str.strip().split():
+            x, y = point.split(',')
+            points.append((float(x), float(y)))
+        return points
+
+    for elem in root.iter():
+        tag = elem.tag.split('}')[-1]
+        dx, dy = get_accumulated_transform(elem)
+        # print("tag: ", tag)
+        if tag == 'rect':
+            # 检查是否应该忽略此矩形（fill="none"且没有stroke属性）
+            fill = elem.get('fill', '').lower()
+            has_stroke = elem.get('stroke') is not None
+            if fill == 'none' and not has_stroke:
+                continue  # 忽略这个矩形
+                
+            x = parse_percentage(elem.get('x', '0'), svg_width) + dx
+            y = parse_percentage(elem.get('y', '0'), svg_height) + dy
+            w = parse_percentage(elem.get('width', '0'), svg_width)
+            h = parse_percentage(elem.get('height', '0'), svg_height)
+            update_bounds([x, x + w], [y, y + h])
+        elif tag == 'circle':
+            cx = parse_percentage(elem.get('cx', '0'), svg_width) + dx
+            cy = parse_percentage(elem.get('cy', '0'), svg_height) + dy
+            r = parse_percentage(elem.get('r', '0'), svg_width)
+            update_bounds([cx - r, cx + r], [cy - r, cy + r])
+        elif tag == 'ellipse':
+            cx = parse_percentage(elem.get('cx', '0'), svg_width) + dx
+            cy = parse_percentage(elem.get('cy', '0'), svg_height) + dy
+            rx = parse_percentage(elem.get('rx', '0'), svg_width)
+            ry = parse_percentage(elem.get('ry', '0'), svg_height)
+            update_bounds([cx - rx, cx + rx], [cy - ry, cy + ry])
+        elif tag == 'line':
+            x1 = parse_percentage(elem.get('x1', '0'), svg_width) + dx
+            y1 = parse_percentage(elem.get('y1', '0'), svg_height) + dy
+            x2 = parse_percentage(elem.get('x2', '0'), svg_width) + dx
+            y2 = parse_percentage(elem.get('y2', '0'), svg_height) + dy
+            update_bounds([x1, x2], [y1, y2])
+        elif tag == 'polygon':
+            points_str = elem.get('points', '')
+            if points_str:
+                points = parse_points(points_str)
+                x_vals = [x + dx for x, _ in points]
+                y_vals = [y + dy for _, y in points]
+                update_bounds(x_vals, y_vals)
+        elif tag == 'path':
+            d = elem.get('d')
+            if d:
+                try:
+                    path = parse_path(d)
+                    for segment in path:
+                        box = segment.bbox()
+                        update_bounds(
+                            [box[0] + dx, box[1] + dx],
+                            [box[2] + dy, box[3] + dy]
+                        )
+                except Exception as e:
+                    # 处理无效路径
+                    print(f"Error parsing path: {e}")
+        elif tag == 'text':
+            x = parse_percentage(elem.get('x', '0'), svg_width) + dx
+            y = parse_percentage(elem.get('y', '0'), svg_height) + dy
+            font_size_str = elem.get('font-size', '16')
+            font_size = float(font_size_str.replace('px', '')) if 'px' in font_size_str else float(font_size_str)
+            text_len = len(elem.text or "")
+            text_width = font_size * 0.6 * text_len
+            text_height = font_size
+            
+            # 处理文本对齐方式
+            text_anchor = elem.get('text-anchor', 'start')
+            if text_anchor == 'start':
+                text_left = x
+                text_right = x + text_width
+            elif text_anchor == 'middle':
+                text_left = x - text_width / 2
+                text_right = x + text_width / 2
+            elif text_anchor == 'end':
+                text_left = x - text_width
+                text_right = x
+            else:  # 默认为start
+                text_left = x
+                text_right = x + text_width
+            
+            update_bounds(
+                [text_left, text_right],
+                [y - 0.8 * text_height, y + 0.2 * text_height]
+            )
+    # print("min_x: ", min_x)
+    # print("min_y: ", min_y)
+    # print("max_x: ", max_x)
+    # print("max_y: ", max_y)
+    if min_x == float('inf'):
+        return None  # 没有有效图形
+
+    return {
+        'min_x': min_x,
+        'min_y': min_y,
+        'max_x': max_x,
+        'max_y': max_y,
+        'width': max_x - min_x,
+        'height': max_y - min_y
+    }

modules/infographics_generator/template_utils.py

@@ -0,0 +1,585 @@
+from typing import Dict, List, Tuple, Optional, Union
+import random
+import json
+from modules.infographics_generator.color_utils import get_contrast_color, has_indistinguishable_colors, generate_distinct_palette
+import os
+
+# 添加全局字典来跟踪模板使用频率
+template_usage_counter = {}
+field_order = ['x', 'y', 'y2', 'y3', 'size', 'group', 'group2', 'group3']
+
+# ============================================================
+# chart_type 白名单
+# ------------------------------------------------------------
+# 通过外部 JSON 文件指定允许使用的 chart_type 子集（例如只关心
+# "bump chart" / "bar chart"）。analyze_templates 和
+# check_template_compatibility 都会读这份白名单：
+#   * 文件不存在 / 为空 / 内容不是非空列表  ->  不过滤（保留原全量行为）
+#   * 文件存在且为非空列表                   ->  只保留列表内的 chart_type
+#
+# 文件路径默认为工作目录下的 ``allowed_chart_types.json``，可通过
+# 环境变量 ``ALLOWED_CHART_TYPES_FILE`` 覆盖。
+#
+# 支持的文件格式（任选其一）：
+#   ["bump chart", "bar chart"]
+#   {"chart_types": ["bump chart", "bar chart"]}
+# ============================================================
+_ALLOWED_CHART_TYPES_DEFAULT_PATH = "allowed_chart_types.json"
+_allowed_chart_types_cache: Optional[set] = None
+_allowed_chart_types_cache_mtime: Optional[float] = None
+_allowed_chart_types_cache_path: Optional[str] = None
+
+
+def _get_allowed_chart_types_path() -> str:
+    return os.environ.get("ALLOWED_CHART_TYPES_FILE", _ALLOWED_CHART_TYPES_DEFAULT_PATH)
+
+
+def _load_allowed_chart_types() -> Optional[set]:
+    """加载允许的 chart_type 白名单；返回 None 表示不过滤。
+
+    带 mtime 缓存：文件被修改时自动重新读取，多线程/多进程环境下也安全
+    （ProcessPoolExecutor 的 worker 各自独立 import，缓存彼此隔离）。
+    """
+    global _allowed_chart_types_cache, _allowed_chart_types_cache_mtime, _allowed_chart_types_cache_path
+
+    path = _get_allowed_chart_types_path()
+    if not os.path.exists(path):
+        _allowed_chart_types_cache = None
+        _allowed_chart_types_cache_mtime = None
+        _allowed_chart_types_cache_path = path
+        return None
+
+    mtime = os.path.getmtime(path)
+    if (
+        _allowed_chart_types_cache_path == path
+        and _allowed_chart_types_cache_mtime == mtime
+    ):
+        return _allowed_chart_types_cache
+
+    with open(path, "r", encoding="utf-8") as f:
+        raw = json.load(f)
+    if isinstance(raw, dict):
+        raw = raw.get("chart_types", [])
+    if not isinstance(raw, list) or len(raw) == 0:
+        _allowed_chart_types_cache = None
+    else:
+        _allowed_chart_types_cache = set(raw)
+
+    _allowed_chart_types_cache_mtime = mtime
+    _allowed_chart_types_cache_path = path
+    return _allowed_chart_types_cache
+
+
+def _is_chart_type_allowed(chart_type: str) -> bool:
+    allowed = _load_allowed_chart_types()
+    if allowed is None:
+        return True
+    return chart_type in allowed
+
+def flatten(lst):
+    """Flattens a nested list into a single list."""
+    result = []
+    for item in lst:
+        if isinstance(item, list):  # Check if the item is a list
+            result.extend(flatten(item))  # Recursively flatten the sublist
+        else:
+            result.append(item)  # Add the non-list item to the result
+    return result
+
+def get_flatten_fields(required_fields) -> List[str]:
+    """Flatten a nested list of fields into a single list"""
+    lst = flatten(required_fields)
+    lst = [field for field in field_order if field in lst]
+    return lst
+
+def get_unique_fields_and_types(
+        required_fields: Union[List[str], List[List[str]]],
+        required_fields_type: Union[List[List[str]], List[List[List[str]]]],
+        required_fields_range: Optional[Union[List[List[int]], List[List[List[int]]]]] = None
+    ) -> Tuple[List[str], Dict[str, str], List[List[int]]]:
+    """Extract unique fields and their corresponding types from nested structure"""
+    field_types = {}
+    field_ranges = {}
+
+    # Check if required_fields is a list of lists
+    if required_fields and isinstance(required_fields[0], list):
+        # Handle list of lists case
+        for i, (fields_group, types_group) in enumerate(zip(required_fields, required_fields_type)):
+            range_group = required_fields_range[i] if required_fields_range != None else [[float('-inf'), float('inf')] for _ in fields_group]
+            for field, type_list, range_list in zip(fields_group, types_group, range_group):
+                if field not in field_types:
+                    field_types[field] = type_list[0]  # Use first type from the list
+                    field_ranges[field] = range_list  # Use first range from the list
+    else:
+        # Handle simple list case
+        range_list = required_fields_range if required_fields_range != None else [[float('-inf'), float('inf')] for _ in required_fields]
+        for field, type_list, range_val in zip(required_fields, required_fields_type, range_list):
+            if field not in field_types:
+                field_types[field] = type_list[0]  # Use first type from the list
+                field_ranges[field] = range_val  # Use first range from the list
+
+    # Order fields according to field_order, keeping only those that exist
+    ordered_fields = [field for field in field_order if field in field_types]
+    for field in field_ranges:
+        r = field_ranges[field]
+        try:
+            if r[0] == "-inf":
+                r[0] = float('-inf')
+            if r[1] == "inf":
+                r[1] = float('inf')
+        except:
+            pass
+    ordered_ranges = [field_ranges[field] for field in ordered_fields]
+
+    return ordered_fields, field_types, ordered_ranges
+
+def analyze_templates(templates: Dict) -> Tuple[int, Dict[str, str], int]:
+    """Analyze templates and return count, data requirements and unique colors count"""
+    template_count = 0
+    template_requirements = {}
+    template_list = []
+    unique_colors = set()
+    requirement_dump = {}
+
+    for engine, templates_dict in templates.items():
+        for chart_type, chart_names_dict in templates_dict.items():
+            if not _is_chart_type_allowed(chart_type):
+                continue
+            for chart_name, template_info in chart_names_dict.items():
+                if 'base' in chart_name:
+                    continue
+                if engine == 'vegalite_py':
+                    continue
+                template_list.append(f"{chart_type} / {chart_name}")
+                template_count += 1
+                if 'requirements' in template_info:
+                    req = template_info['requirements']
+
+                    # Count unique required colors
+                    if 'required_other_colors' in req:
+                        for color in req['required_other_colors']:
+                            unique_colors.add(color)
+
+                    if 'required_fields_colors' in req:
+                        for color in req['required_fields_colors']:
+                            unique_colors.add(color)
+
+                    if 'required_fields' in req and 'required_fields_type' in req:
+                        template_requirements[f"{engine}/{chart_type}/{chart_name}"] = template_info['requirements']
+                        requirement_dump[chart_name] = template_info['requirements']
+
+    # print("template_count", template_count)
+    if not os.path.exists("template_list.txt"):
+        f = open("template_list.txt", "w")
+        f.write("\n".join(template_list))
+        f.close()
+    if not os.path.exists("requirement_dump.json"):
+        f = open("requirement_dump.json", "w")
+        f.write(json.dumps(requirement_dump, indent=4))
+        f.close()
+
+    return template_count, template_requirements
+
+# block_list = ["multiple_line_graph_06", "layered_area_chart_02", "multiple_area_chart_01", "stacked_area_chart_01", "stacked_area_chart_03"]
+block_list = []
+
+def check_field_color_compatibility(requirements: Dict, data: Dict) -> bool:
+    """Check if the field color is compatible with the template"""
+    if len(requirements.get('required_fields_colors', [])) > 0 and len(data.get("colors", {}).get("field", {}).keys()) == 0:
+        return False
+    data_fields = get_flatten_fields(requirements.get('required_fields',[]))
+    for color_field in requirements.get('required_fields_colors', []):
+        field_column = None
+        for i, field in enumerate(data_fields):
+            if field == color_field:
+                field_column = data.get("data", {}).get("columns", {})[i]
+                break
+        if field_column is None:
+            return False
+        field_name = field_column["name"]
+        for value in data.get("data", {}).get("data", []):
+            if value[field_name] not in data.get("colors", {}).get("field", {}).keys():
+                return False
+    return True
+
+def check_field_icon_compatibility(requirements: Dict, data: Dict) -> bool:
+    """Check if the field icon is compatible with the template"""
+    if len(requirements.get('required_fields_icons', [])) > 0 and len(data.get("images", {}).get("field", {}).keys()) == 0:
+        return False
+    data_fields = get_flatten_fields(requirements.get('required_fields',[]))
+    for icon_field in requirements.get('required_fields_icons', []):
+        for i, field in enumerate(data_fields):
+            if field == icon_field:
+                field_column = data.get("data", {}).get("columns", {})[i]
+                break
+        if field_column is None:
+            return False
+        field_name = field_column["name"]
+        for value in data.get("data", {}).get("data", []):
+            if value[field_name] not in data.get("images", {}).get("field", {}).keys():
+                return False
+    return True
+
+def check_template_compatibility(data: Dict, templates: Dict, specific_chart_name: str = None) -> List[str]:
+    """Check which templates are compatible with the given data"""
+    compatible_templates = []
+
+    def normalize_range_bound(value):
+        if isinstance(value, str):
+            normalized = value.strip().lower()
+            if normalized in {"inf", "+inf", "infinity", "+infinity"}:
+                return float("inf")
+            if normalized in {"-inf", "-infinity"}:
+                return float("-inf")
+            try:
+                return float(normalized)
+            except ValueError:
+                return value
+        return value
+
+    # Get the combination type from the data
+    combination_type = data.get("data", {}).get("type_combination", "")
+    combination_types = [col["data_type"] for col in data["data"]["columns"]]
+    if combination_type == "":
+        combination_type = " + ".join(combination_types)
+
+    if not combination_type:
+        return compatible_templates
+
+    for engine, templates_dict in templates.items():
+        for chart_type, chart_names_dict in templates_dict.items():
+            if not _is_chart_type_allowed(chart_type):
+                continue
+            for chart_name, template_info in chart_names_dict.items():
+                if 'base' in chart_name:
+                    continue
+                if engine == 'vegalite_py':
+                    continue
+
+                template_key = f"{engine}/{chart_type}/{chart_name}"
+
+                if specific_chart_name and specific_chart_name != chart_name:
+                    continue
+
+                try:
+                    if 'requirements' in template_info:
+                        req = template_info['requirements']
+                        hierarchy = req.get('hierarchy', [])
+                        if 'required_fields' in req and 'required_fields_type' in req:
+                            ordered_fields, field_types, ordered_ranges = get_unique_fields_and_types(
+                                req['required_fields'],
+                                req['required_fields_type'],
+                                req.get('required_fields_range', None)
+                            )
+                            data_types = [field_types[field] for field in ordered_fields]
+                            data_type_str = ' + '.join(data_types)
+                            if len(req.get('required_fields_colors', [])) > 0 and len(data.get("colors", {}).get("field", [])) == 0:
+                                # print(f"template {template_key} failed color compatibility check")
+                                continue
+
+                            # if len(req.get('required_fields_icons', [])) > 0 and len(data.get("images", {}).get("field", [])) == 0:
+                            #     print(f"template {template_key} failed icon compatibility check")
+                            #     continue
+
+                            if not check_field_color_compatibility(req, data):
+                                # print(f"template {template_key} failed color compatibility check")
+                                continue
+
+                            if not check_field_icon_compatibility(req, data):
+                                # print(f"template {template_key} failed icon compatibility check")
+                                continue
+                            # print("data_types", data_types)
+                            # print("combination_types", combination_types)
+                            # 如果data_types和combination_types相同，或者data_types是combination_types的一个子序列
+                            if len(data_types) == len(combination_types):# or all(data_type in combination_types for data_type in data_types):
+                                check_flag = True
+                                for data_type, combination_type in zip(data_types, combination_types[:len(data_types)]):
+                                    if data_type == "categorical" and (combination_type == "temporal" or combination_type == "categorical"):
+                                        pass
+                                    elif data_type == "numerical" and combination_type == "numerical":
+                                        pass
+                                    elif data_type == "temporal" and combination_type == "temporal":
+                                        pass
+                                    else:
+                                        check_flag = False
+                                        break
+                                if not check_flag:
+                                    # print(f"template {template_key} failed data type compatibility check")
+                                    continue
+                            else:
+                                # print(f"template {template_key} failed data type compatibility check")
+                                continue
+
+                            disallow_temporal_fields = set(req.get('disallow_temporal_fields', []))
+                            if disallow_temporal_fields:
+                                rejected_for_temporal = False
+                                for i, field in enumerate(ordered_fields):
+                                    if (
+                                        field in disallow_temporal_fields
+                                        and i < len(data["data"]["columns"])
+                                        and data["data"]["columns"][i].get("data_type") == "temporal"
+                                    ):
+                                        rejected_for_temporal = True
+                                        break
+                                if rejected_for_temporal:
+                                    continue
+
+                            flag = True
+                            # print("check compatibility")
+                            for i, range_bounds in enumerate(ordered_ranges):
+                                if i >= len(data["data"]["columns"]):
+                                    flag = False
+                                    break
+                                min_bound = normalize_range_bound(range_bounds[0])
+                                max_bound = normalize_range_bound(range_bounds[1])
+
+                                if data["data"]["columns"][i]["data_type"] in ["temporal", "categorical"]:
+                                    key = data["data"]["columns"][i]["name"]
+                                    unique_values = list(set(value[key] for value in data["data"]["data"]))
+                                    if len(unique_values) > max_bound or len(unique_values) < min_bound:
+                                        flag = False
+                                        break
+                                    else:
+                                        pass
+                                        #if specific_chart_name and specific_chart_name == chart_name:
+                                        #    print(f"template {template_key} matched", data["name"], len(unique_values), range)
+                                elif data["data"]["columns"][i]["data_type"] in ["numerical"]:
+                                    key = data["data"]["columns"][i]["name"]
+                                    min_value = min(value[key] for value in data["data"]["data"])
+                                    max_value = max(value[key] for value in data["data"]["data"])
+                                    if min_value < min_bound or max_value > max_bound:
+                                        flag = False
+                                        break
+                                    elif "diverging" in chart_name and min_value >= 0 and min_bound < 0:
+                                        flag = False
+                                        break
+                                    elif "scatterplot" in chart_name and min_value >= 0 and min_bound < 0:
+                                        flag = False
+                                        break
+                            for i, field in enumerate(ordered_fields):
+                                if field == "group":
+                                    x_col = [j for j, field2 in enumerate(ordered_fields) if field2 == "x"][0]
+                                    x_name = data["data"]["columns"][x_col]["name"]
+                                    field_name = data["data"]["columns"][i]["name"]
+                                    num_unique_x  = len(list(set(value[x_name] for value in data["data"]["data"])))
+                                    num_unique_comb = len(list(set(str(value[x_name]) + ' ' + str(value[field_name]) for value in data["data"]["data"])))
+                                    if field in hierarchy:
+                                        if num_unique_comb > num_unique_x:
+                                            flag = False
+                                            break
+                                    else:
+                                        if num_unique_comb == num_unique_x:
+                                            flag = False
+                                            break
+                                elif field == "group2":
+                                    x_col = [j for j, field2 in enumerate(ordered_fields) if field2 == "x"][0]
+                                    group_col = [j for j, field2 in enumerate(ordered_fields) if field2 == "group"][0]
+                                    x_name = data["data"]["columns"][x_col]["name"]
+                                    group_name = data["data"]["columns"][group_col]["name"]
+                                    field_name = data["data"]["columns"][i]["name"]
+                                    num_unique_x  = len(list(set(str(value[x_name]) + ' ' + str(value[group_name]) for value in data["data"]["data"])))
+                                    num_unique_comb = len(list(set(str(value[x_name]) + ' ' + str(value[group_name]) + ' ' + str(value[field_name]) for value in data["data"]["data"])))
+                                    if field in hierarchy:
+                                        if num_unique_comb > num_unique_x:
+                                            flag = False
+                                            break
+                                    else:
+                                        if num_unique_comb == num_unique_x:
+                                            flag = False
+                                            break
+                            if flag:
+                                if specific_chart_name == None or specific_chart_name == chart_name:
+                                    compatible_templates.append((template_key, ordered_fields))
+                except:
+                    pass
+    #print("compatible_templates", compatible_templates)
+    return compatible_templates
+
+
+import fcntl  # 用于文件锁
+def select_template(compatible_templates: List[str]) -> Tuple[str, str, str]:
+    """
+    根据variation.json中的使用统计选择模板
+    按照使用频率分为4个level，优先选择使用较少的level
+    同level内按照具体使用次数加权随机选择
+    使用文件锁确保多线程安全
+    """
+    # 读取variation.json，使用文件锁
+    try:
+        with open('variation.json', 'r') as f:
+            # 获取文件锁
+            fcntl.flock(f, fcntl.LOCK_EX)
+            try:
+                variation_stats = json.load(f)
+            finally:
+                # 释放文件锁
+                fcntl.flock(f, fcntl.LOCK_UN)
+    except:
+        variation_stats = {}
+
+    # 获取所有模板的使用次数
+    template_counts = []
+    for template_info in compatible_templates:
+        template_key = template_info[0]
+        _, chart_type, chart_name = template_key.split('/')
+
+        # 如果variation_stats为空,所有模板使用次数都为0
+        if not variation_stats:
+            count = 0
+        else:
+            if chart_type not in variation_stats:
+                variation_stats[chart_type] = {"total_count": 0}
+
+            if chart_name not in variation_stats[chart_type]:
+                variation_stats[chart_type][chart_name] = 0
+
+            count = variation_stats[chart_type][chart_name]
+
+        template_counts.append((template_info, count))
+
+    # 按使用次数排序并分level
+    template_counts.sort(key=lambda x: x[1])
+    n = len(template_counts)
+    
+    # 如果没有可用模板，返回 None
+    if n == 0:
+        return None, None, None, None
+    
+    level_size = max(1, n // 4)
+    # 找出使用次数最少的模板
+    min_count = min(c for _, c in template_counts)
+    min_level_templates = [(t, c) for t, c in template_counts if c == min_count]
+
+    # 固定选择第一个最少使用的模板
+    selected_index = 0
+
+    selected_template, _ = min_level_templates[selected_index]
+    [template_key, ordered_fields] = selected_template
+    print("selected_template", selected_template)
+
+    # 更新variation.json，使用文件锁
+    engine, chart_type, chart_name = template_key.split('/')
+    if os.environ.get("CHARTPIPELINE_SKIP_VARIATION_STATS_UPDATE") == "1":
+        return engine, chart_type, chart_name, ordered_fields
+    try:
+        with open('variation.json', 'r+') as f:
+            # 获取文件锁
+            fcntl.flock(f, fcntl.LOCK_EX)
+            try:
+                # 重新读取以确保获取最新数据
+                variation_stats = json.load(f)
+
+                # 初始化如果不存在
+                if chart_type not in variation_stats:
+                    variation_stats[chart_type] = {"total_count": 0}
+                if chart_name not in variation_stats[chart_type]:
+                    variation_stats[chart_type][chart_name] = 0
+
+                # 更新计数
+                variation_stats[chart_type][chart_name] += 1
+                variation_stats[chart_type]["total_count"] += 1
+
+                # 写入更新后的数据
+                f.seek(0)
+                json.dump(variation_stats, f, indent=2)
+                f.truncate()
+            finally:
+                # 释放文件锁
+                fcntl.flock(f, fcntl.LOCK_UN)
+    except FileNotFoundError:
+        # 如果文件不存在,创建新的variation_stats
+        variation_stats = {
+            chart_type: {
+                "total_count": 1,
+                chart_name: 1
+            }
+        }
+        with open('variation.json', 'w') as f:
+            json.dump(variation_stats, f, indent=2)
+    return engine, chart_type, chart_name, ordered_fields
+
+
+def process_template_requirements(requirements: Dict, data: Dict, engine: str, chart_name: str) -> None:
+    """处理模板的颜色要求"""
+    default_colors = {
+        "text_color": "#333333",
+        "background_color": "#ffffff",
+        "field": {},
+        "other": {"primary": "#4e79a7"},
+        "available_colors": ["#4e79a7", "#f28e2b", "#59a14f", "#e15759", "#76b7b2", "#edc948"]
+    }
+    default_dark_colors = {
+        "text_color": "#ffffff",
+        "background_color": "#1f2933",
+        "field": {},
+        "other": {"primary": "#76b7b2"},
+        "available_colors": ["#76b7b2", "#f28e2b", "#59a14f", "#e15759", "#9c755f", "#edc948"]
+    }
+
+    if not isinstance(data.get("colors"), dict):
+        data["colors"] = json.loads(json.dumps(default_colors))
+    else:
+        data["colors"].setdefault("text_color", default_colors["text_color"])
+        data["colors"].setdefault("background_color", default_colors["background_color"])
+        data["colors"].setdefault("field", {})
+        data["colors"].setdefault("other", {})
+        data["colors"]["other"].setdefault("primary", default_colors["other"]["primary"])
+        data["colors"].setdefault("available_colors", default_colors["available_colors"])
+
+    if not isinstance(data.get("colors_dark"), dict):
+        data["colors_dark"] = json.loads(json.dumps(default_dark_colors))
+    else:
+        data["colors_dark"].setdefault("text_color", default_dark_colors["text_color"])
+        data["colors_dark"].setdefault("background_color", default_dark_colors["background_color"])
+        data["colors_dark"].setdefault("field", {})
+        data["colors_dark"].setdefault("other", {})
+        data["colors_dark"]["other"].setdefault("primary", default_dark_colors["other"]["primary"])
+        data["colors_dark"].setdefault("available_colors", default_dark_colors["available_colors"])
+
+    colors = data["colors"]
+    colors_dark = data["colors_dark"]
+
+    if len(colors["field"]) > 1:
+        # 检查颜色是否可区分
+        field_colors = list(colors["field"].values())
+        if has_indistinguishable_colors(field_colors):
+            # 如果颜色不可区分,使用主色生成新的调色板
+            primary_color = colors["other"]["primary"]
+            new_colors = generate_distinct_palette(primary_color, len(field_colors))
+            # 更新颜色字典
+            for i, field in enumerate(colors["field"].keys()):
+                colors["field"][field] = new_colors[i]
+
+    if len(colors_dark["field"]) > 1:
+        # 检查颜色是否可区分
+        field_colors = list(colors_dark["field"].values())
+        if has_indistinguishable_colors(field_colors):
+            # 如果颜色不可区分,使用主色生成新的调色板
+            primary_color = colors_dark["other"]["primary"]
+            new_colors = generate_distinct_palette(primary_color, len(field_colors))
+            # 更新颜色字典
+            for i, field in enumerate(colors_dark["field"].keys()):
+                colors_dark["field"][field] = new_colors[i]
+
+
+    if len(requirements.get("required_other_colors", [])) > 0:
+        for key in requirements["required_other_colors"]:
+            if key == "positive" and "positive" not in colors["other"]:
+                colors["other"]["positive"] = colors["other"]["primary"]
+            elif key == "negative" and "negative" not in colors["other"]:
+                colors["other"]["negative"] = get_contrast_color(colors["other"]["primary"])
+
+    colors_dark["text_color"] = "#ffffff"
+    # if ('donut' in chart_name or 'pie' in chart_name) and engine == 'vegalite_py':
+    #     data["variables"]["height"] = 500
+    #     data["variables"]["width"] = 500
+    # else:
+    #     if "min_height" in requirements:
+    #         data["variables"]["height"] = max(600, requirements["min_height"])
+    #     elif 'height' in requirements:
+    #         data["variables"]["height"] = max(600, requirements["height"][0])
+
+    #     if "min_width" in requirements:
+    #         data["variables"]["width"] = max(800, requirements["min_width"])
+    #     elif 'width' in requirements:
+    #         data["variables"]["width"] = max(600, requirements["width"][0])

modules/infographics_generator/utils/logger.py

@@ -0,0 +1,29 @@
+import os
+import logging
+from logging import getLogger
+
+def setup_logger():
+    """Configure and return the logger for infographics generator"""
+    # 创建tmp目录（如果不存在）
+    os.makedirs("tmp", exist_ok=True)
+
+    # 配置日志
+    logger = getLogger(__name__)
+    logger.setLevel(logging.INFO)
+
+    # 移除所有现有的处理器
+    for handler in logger.handlers[:]:
+        logger.removeHandler(handler)
+
+    # 创建文件处理器
+    file_handler = logging.FileHandler('tmp/log.txt')
+    file_handler.setLevel(logging.INFO)
+
+    # 创建格式化器
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    file_handler.setFormatter(formatter)
+
+    # 添加处理器到logger
+    logger.addHandler(file_handler)
+    
+    return logger