LED布局优化：实现5cm外平面的均匀光照

问题概述 #

需在40×40cm的区域内布置100-200个LED，使距离LED平面5cm处的20×20cm目标区域获得最均匀的光照。约束条件如下：

• 所有LED功率一致，无法单独调节
• 固定采用朗伯型辐射模式，不可修改
• LED之间最小间距必须≥1cm

此前尝试多种常规布局（如网格、环形）均未得到理想均匀度，仅通过修改辐射模式的仿真得到接近结果；推测对称性可提升效果，但未找到适配真实辐射模式的对称实现方法。

优化方案与实现 #

核心优化思路 #

1. 真实物理模型仿真：严格基于朗伯辐射公式+平方反比照度定律计算，确保结果贴合实际场景
2. 对称性约束：初始化时采用中心对称布局，优化过程中强制LED位置对称更新，抵消局部照度偏差
3. 最小间距硬约束：在目标函数中加入间距惩罚项，一旦LED间距小于1cm则大幅提升非均匀度评分，强制优化器遵守约束
4. 全局优化算法：使用差分进化算法（DE）替代局部优化的L-BFGS-B，更适合高维度（100-200个LED对应200-400个变量）的布局寻优

完整实现代码 #

import numpy as np
from scipy.optimize import differential_evolution
import matplotlib.pyplot as plt

class LambertianRadiation:
    """标准朗伯型LED辐射模型"""
    def get_intensity_factor(self, cos_theta):
        # 朗伯辐射：强度与cosθ成正比，θ为光线与法线夹角
        return np.maximum(0, cos_theta)

class LEDIlluminationOptimizer:
    def __init__(self):
        # 布局区域：40×40cm（0.4m）
        self.grid_size = 0.4
        # 目标区域：20×20cm（0.2m）
        self.target_size = 0.2
        # 距离LED平面高度：5cm（0.05m）
        self.z_distance = 0.05
        # 仿真网格分辨率（越高越精确，计算越慢）
        self.grid_res = 100
        
        # 初始化仿真网格
        x = np.linspace(-self.grid_size/2, self.grid_size/2, self.grid_res)
        y = np.linspace(-self.grid_size/2, self.grid_size/2, self.grid_res)
        self.X, self.Y = np.meshgrid(x, y)
        
        # 标记目标区域掩码
        self.target_mask = (
            (self.X >= -self.target_size/2) & (self.X <= self.target_size/2) &
            (self.Y >= -self.target_size/2) & (self.Y <= self.target_size/2)
        )
        
        self.radiation_model = LambertianRadiation()
        self.convergence_history = []

    def calculate_illuminance(self, led_positions):
        """计算目标区域的总照度分布"""
        total_illum = np.zeros_like(self.X)
        led_positions = led_positions.reshape(-1, 2)
        
        for (x_led, y_led) in led_positions:
            # 计算LED到每个网格点的距离平方
            r_sq = (self.X - x_led)**2 + (self.Y - y_led)**2 + self.z_distance**2
            r = np.sqrt(r_sq)
            
            # 计算光线与法线的夹角余弦值
            cos_theta = self.z_distance / r
            
            # 朗伯辐射强度因子
            intensity = self.radiation_model.get_intensity_factor(cos_theta)
            
            # 照度计算：朗伯光源照度公式 E = (I0 * cosθ) / r²，这里I0归一化
            led_illum = intensity / r_sq
            total_illum += led_illum
        
        return total_illum

    def evaluate_uniformity(self, led_positions):
        """评估目标区域照度均匀性，返回非均匀度（越小越好）"""
        led_positions = led_positions.reshape(-1, 2)
        n_leds = len(led_positions)
        
        # 1. 计算目标区域照度的变异系数（标准差/均值）
        total_illum = self.calculate_illuminance(led_positions)
        target_illum = total_illum[self.target_mask]
        mean_illum = np.mean(target_illum)
        std_illum = np.std(target_illum)
        non_uniformity = std_illum / mean_illum if mean_illum > 0 else np.inf
        
        # 2. 加入最小间距惩罚（1cm=0.01m）
        min_spacing = 0.01
        penalty = 0
        for i in range(n_leds):
            for j in range(i+1, n_leds):
                dx = led_positions[i,0] - led_positions[j,0]
                dy = led_positions[i,1] - led_positions[j,1]
                dist = np.sqrt(dx**2 + dy**2)
                if dist < min_spacing:
                    # 间距越小，惩罚越大
                    penalty += (min_spacing - dist) * 1000
        
        return non_uniformity + penalty

    def generate_symmetric_initial_guess(self, n_leds):
        """生成中心对称的初始布局，确保对称性起点"""
        positions = []
        # 先计算一半数量的LED位置（奇数个则中心加一个）
        half_n = n_leds // 2
        has_center = n_leds % 2 == 1
        
        # 在右上象限生成初始点
        grid_side = int(np.ceil(np.sqrt(half_n)))
        spacing = self.grid_size * 0.4 / (grid_side - 1) if grid_side > 1 else 0
        
        count = 0
        for i in range(grid_side):
            for j in range(grid_side):
                if count >= half_n:
                    break
                x = spacing * i
                y = spacing * j
                if x == 0 and y == 0:
                    continue  # 中心位置单独处理
                positions.append([x, y])
                count += 1
        
        # 镜像生成对称点
        symmetric_positions = positions.copy()
        for (x, y) in positions:
            symmetric_positions.append([-x, y])
            symmetric_positions.append([x, -y])
            symmetric_positions.append([-x, -y])
        
        # 添加中心LED（如果需要）
        if has_center:
            symmetric_positions.append([0, 0])
        
        # 截断到指定数量并打乱（避免优化器陷入局部最优）
        final_pos = np.array(symmetric_positions[:n_leds])
        np.random.shuffle(final_pos)
        return final_pos.flatten()

    def optimize(self, n_leds):
        """执行全局优化"""
        self.convergence_history = []
        
        # 生成对称初始布局
        initial_guess = self.generate_symmetric_initial_guess(n_leds)
        
        # 定义位置边界（40×40cm区域内）
        bounds = []
        for _ in range(n_leds):
            bounds.append((-self.grid_size/2, self.grid_size/2))
            bounds.append((-self.grid_size/2, self.grid_size/2))
        
        # 回调函数跟踪收敛过程
        def callback(xk, convergence):
            score = self.evaluate_uniformity(xk)
            self.convergence_history.append(score)
            if len(self.convergence_history) % 20 == 0:
                print(f"迭代次数: {len(self.convergence_history)}，非均匀度: {score:.6f}")
        
        # 使用差分进化算法进行全局优化
        result = differential_evolution(
            self.evaluate_uniformity,
            bounds=bounds,
            x0=initial_guess,
            callback=callback,
            maxiter=200,
            popsize=15,
            mutation=(0.5, 1),
            recombination=0.7
        )
        
        optimal_pos = result.x.reshape(-1, 2)
        final_score = self.evaluate_uniformity(result.x)
        
        print(f"优化完成，最终非均匀度: {final_score:.6f}")
        return optimal_pos, final_score

    def plot_results(self, led_positions):
        """绘制照度分布和LED布局"""
        total_illum = self.calculate_illuminance(led_positions)
        
        plt.figure(figsize=(12, 10))
        # 绘制照度热图
        plt.pcolormesh(self.X, self.Y, total_illum, cmap='viridis', shading='auto')
        plt.colorbar(label='相对照度')
        plt.xlabel('X轴 (米)')
        plt.ylabel('Y轴 (米)')
        
        # 标记目标区域
        target_half = self.target_size / 2
        plt.plot(
            [-target_half, target_half, target_half, -target_half, -target_half],
            [-target_half, -target_half, target_half, target_half, -target_half],
            'r--', linewidth=2, label='目标区域'
        )
        
        # 标记LED位置
        plt.scatter(led_positions[:,0], led_positions[:,1], color='red', marker='x', s=80, label='LED')
        
        plt.title('LED布局与照度分布')
        plt.legend()
        plt.axis('equal')
        plt.tight_layout()
        plt.show()

# 示例：优化100个LED的布局
if __name__ == "__main__":
    optimizer = LEDIlluminationOptimizer()
    optimal_pos, score = optimizer.optimize(n_leds=100)
    optimizer.plot_results(optimal_pos)
    
    # 打印前10个LED位置示例
    print("\n优化后LED位置示例（单位：米）：")
    for i in range(10):
        print(f"LED {i+1}: ({optimal_pos[i,0]:.4f}, {optimal_pos[i,1]:.4f})")

关键改进说明 #

• 对称初始化：通过镜像生成初始布局，确保优化过程中更容易维持对称性，抵消局部照度波动
• 间距惩罚：在目标函数中加入硬约束惩罚，确保最终布局满足LED最小间距要求
• 全局算法：差分进化算法更适合处理高维度的布局优化问题，避免陷入局部最优解
• 真实模型：严格遵循朗伯辐射和平方反比定律，仿真结果可直接对应实际硬件实现

内容的提问来源于stack exchange，提问作者Nebris