如何利用 AI 自动生成 3D 预览图以优化‘购物类’生成式搜索结果？

各位同仁、技术爱好者们，

欢迎来到今天的讲座。我们即将探讨一个激动人心且极具实用价值的议题：如何利用人工智能自动生成 3D 预览图，以深度优化“购物类”生成式搜索结果。在当前电商竞争日益激烈的环境中，仅仅展示平面图片已经无法满足用户对商品信息深度和沉浸感的需求。生成式搜索的崛起，不仅改变了用户发现商品的方式，也对我们呈现商品信息提出了更高的要求。3D 预览图，作为一种极具表现力的媒介，能够显著提升用户体验，促进购买决策，并最终优化我们的业务指标。

作为一名编程专家，我将带领大家深入了解从数据准备、2D 到 3D 重建、模型优化、智能布景、智能渲染，到最终与生成式搜索结果集成的全链路技术细节。我们将一同探索如何构建一个可扩展、高效且智能化的 3D 预览图生成系统。

I. 3D 预览图在生成式搜索中的崛起与价值

传统的电商搜索，大多基于关键词匹配和商品列表展示。用户需要主动筛选、点击进入商品详情页，才能获取更多信息。商品图片往往是扁平的、静态的，难以全面展现商品的材质、尺寸、空间适配性等关键属性。这种信息获取模式，无疑增加了用户的认知负担和决策成本。

随着生成式 AI 的发展，搜索引擎正在从“信息检索”转向“内容生成”。用户可以提出更自然、更复杂的查询，搜索引擎则会综合多种信息源，生成个性化的、富媒体的答案。在购物场景中，这意味着用户可能不再仅仅搜索“白色沙发”，而是“适合小户型客厅，现代简约风格的白色三人沙发，最好能看到摆在我家里的效果”。

此时，3D 预览图的价值便凸显出来：

1. 沉浸式体验与信息丰富度： 3D 预览图允许用户从任意角度查看商品，甚至在虚拟环境中“放置”商品，直观感受其尺寸、比例和纹理。这远超平面图片所能提供的信息量。
2. 提高转化率： 用户对商品了解越深入、越真实，购买信心越强。直观的 3D 预览能有效减少购买犹豫，促成转化。
3. 降低退货率： 许多退货原因在于“实物与预期不符”，尤其是尺寸、颜色和材质。3D 预览图能最大限度地缩小这种预期差异。
4. 个性化与场景化： 结合生成式搜索的用户意图，我们可以自动为商品生成在特定场景下的预览图（例如，沙发在不同风格客厅中的效果），满足个性化需求。
5. 增强品牌形象： 提供先进的 3D 预览功能，能够提升品牌的技术感和用户体验，树立行业领先形象。

然而，手动为海量商品创建 3D 模型和预览图是不可持续的。这正是 AI 发挥作用的地方——实现自动化、规模化和智能化的 3D 预览图生成。

II. 核心技术栈概览：构建 AI 3D 预览系统所需的基石

要构建这样一个系统，我们需要整合计算机视觉、深度学习、3D 图形学和渲染技术。其核心技术栈包括：

模块	主要功能	关键技术/工具
数据源	原始商品信息，用于训练和生成	高分辨率图片、多视角图片、CAD/3D 模型、商品描述文本、用户反馈数据
2D 到 3D 重建	将 2D 图片或文本转换为 3D 模型	Structure from Motion (SfM), Multi-View Stereo (MVS), NeRF (Neural Radiance Fields), Diffusion Models for 3D
3D 模型生成与优化	完善 3D 模型细节，生成纹理、材质	网格处理 (简化、细分)、纹理映射、PBR 材质生成、几何细节生成 (法线贴图、位移贴图)
虚拟场景构建与智能布景	创建商品展示的虚拟环境，智能放置商品	3D 场景库、环境光照 (HDRI)、智能构图算法、目标检测与语义分割 (辅助布景)
AI 驱动的智能渲染	将 3D 场景转换为 2D 预览图	离线渲染器 (Blender Cycles/Eevee, V-Ray), 实时渲染器 (Unity, Unreal Engine), Blender Python API, 神经渲染
部署与集成	提供可访问的服务接口，与搜索系统对接	RESTful API (Flask, FastAPI), 微服务架构, 云计算平台 (AWS, GCP, Azure), 容器化 (Docker, Kubernetes)
用户反馈与迭代	收集用户数据，优化系统性能	A/B 测试框架、数据分析、模型再训练管道

III. 数据准备与预处理：AI 模型的“食粮”

高质量的数据是任何 AI 模型的生命线。对于 3D 预览图生成系统，我们需要多模态数据：

1. 高分辨率商品图片： 这是最常见的输入。单视角、多视角（产品图、场景图、细节图）都非常重要。图片质量直接影响 3D 重建的精度和纹理的细节。
2. CAD/3D 模型数据： 如果供应商能提供，这是最理想的起始数据。CAD 文件（如 .step, .iges）或已有的 3D 模型文件（如 .obj, .fbx, .gltf）能极大地简化重建过程。
3. 商品描述文本： 包含品类、材质、颜色、尺寸、风格等关键信息，用于指导 AI 模型生成更符合商品特性的 3D 模型和场景。
4. 用户反馈数据： 用户的点击、停留、购买、退货等行为数据，用于评估生成预览图的效果并进行优化。

数据标注与清洗：

• 3D 点云/网格标注： 对于一些复杂商品，可能需要人工辅助标注关键点或提供粗略的 3D 模型作为初始参考。
• 材质与光照信息： 尽可能从元数据或商品描述中提取材质类型（木、金属、布艺等）和颜色信息。
• 数据增强： 通过旋转、缩放、裁剪、颜色抖动等方式扩充数据集，提高模型泛化能力。对于 3D 数据，还可以合成不同光照、不同背景下的图片。

代码示例：数据加载与预处理

假设我们有一个商品数据集，包含商品图片和 JSON 格式的元数据。

import os
import json
from PIL import Image
import torch
from torchvision import transforms
from torch.utils.data import Dataset, DataLoader

# 定义一个简单的商品数据集类
class ProductDataset(Dataset):
    def __init__(self, data_dir, transform=None):
        self.data_dir = data_dir
        self.transform = transform
        self.items = []

        # 遍历目录，收集商品信息
        for product_id in os.listdir(data_dir):
            product_path = os.path.join(data_dir, product_id)
            if os.path.isdir(product_path):
                meta_file = os.path.join(product_path, f"{product_id}.json")
                if os.path.exists(meta_file):
                    with open(meta_file, 'r', encoding='utf-8') as f:
                        meta_data = json.load(f)
                    # 假设每件商品有多张图片
                    image_files = [f for f in os.listdir(product_path) if f.endswith(('.png', '.jpg', '.jpeg'))]
                    for img_file in image_files:
                        self.items.append({
                            'product_id': product_id,
                            'image_path': os.path.join(product_path, img_file),
                            'metadata': meta_data
                        })

    def __len__(self):
        return len(self.items)

    def __getitem__(self, idx):
        item = self.items[idx]
        image = Image.open(item['image_path']).convert('RGB')

        if self.transform:
            image = self.transform(image)

        # 提取关键元数据，例如材质、颜色、描述
        material = item['metadata'].get('material', 'unknown')
        color = item['metadata'].get('color', 'unknown')
        description = item['metadata'].get('description', '')

        # 返回图片张量和元数据（此处简化为文本，实际可能需要进一步编码）
        return image, {
            'product_id': item['product_id'],
            'material': material,
            'color': color,
            'description': description
        }

# 示例：创建虚拟数据目录
def create_dummy_data(base_dir="dummy_products", num_products=5, num_images_per_product=3):
    if not os.path.exists(base_dir):
        os.makedirs(base_dir)

    for i in range(num_products):
        product_id = f"product_{i:03d}"
        product_path = os.path.join(base_dir, product_id)
        os.makedirs(product_path, exist_ok=True)

        # 创建虚拟图片
        for j in range(num_images_per_product):
            img_path = os.path.join(product_path, f"image_{j}.jpg")
            # 实际中这里会是真实图片，这里用一个占位符
            dummy_image = Image.new('RGB', (256, 256), color = (i*50 % 255, j*50 % 255, (i+j)*50 % 255))
            dummy_image.save(img_path)

        # 创建虚拟元数据
        meta_data = {
            "product_id": product_id,
            "name": f"Luxury Item {product_id}",
            "category": "Furniture" if i % 2 == 0 else "Electronics",
            "material": "Wood" if i % 3 == 0 else ("Metal" if i % 3 == 1 else "Fabric"),
            "color": "White" if i % 4 == 0 else ("Black" if i % 4 == 1 else ("Red" if i % 4 == 2 else "Blue")),
            "dimensions_cm": {"length": 100 + i*10, "width": 50 + i*5, "height": 70 + i*7},
            "description": f"A beautiful and sturdy {('wooden' if i % 3 == 0 else ('metallic' if i % 3 == 1 else 'fabric'))} item."
        }
        with open(os.path.join(product_path, f"{product_id}.json"), 'w', encoding='utf-8') as f:
            json.dump(meta_data, f, indent=4)

    print(f"Created dummy data in {base_dir}")

# --- 运行示例 ---
if __name__ == "__main__":
    create_dummy_data()

    # 定义图像预处理转换
    transform = transforms.Compose([
        transforms.Resize((224, 224)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])

    # 创建数据集和数据加载器
    product_dataset = ProductDataset(data_dir="dummy_products", transform=transform)
    product_dataloader = DataLoader(product_dataset, batch_size=4, shuffle=True)

    print(f"nTotal items in dataset: {len(product_dataset)}")

    # 遍历数据加载器，查看数据
    for batch_idx, (images, metadatas) in enumerate(product_dataloader):
        print(f"nBatch {batch_idx+1}:")
        print(f"  Images shape: {images.shape}") # (batch_size, channels, height, width)
        print(f"  Metadata (first item in batch):")
        print(f"    Product ID: {metadatas['product_id'][0]}")
        print(f"    Material: {metadatas['material'][0]}")
        print(f"    Color: {metadatas['color'][0]}")
        print(f"    Description: {metadatas['description'][0][:50]}...") # 截断显示

        if batch_idx >= 1: # 只看前两批数据
            break

这个代码展示了如何组织商品数据，并使用 PyTorch 的 Dataset 和 DataLoader 进行加载和预处理。元数据（如材质、颜色、描述）将作为文本输入，与图像特征一起喂给后续的 AI 模型。

IV. 2D 到 3D 重建：从平面到立体的飞跃

这是整个系统的核心挑战之一。从有限的 2D 图像中重建出高质量、可渲染的 3D 模型，是实现自动化的关键。

1. 传统计算机视觉方法：SfM/MVS

• Structure from Motion (SfM): 通过在多张图片中匹配特征点，估算相机姿态（位置、方向）和稀疏的 3D 点云。
• Multi-View Stereo (MVS): 在 SfM 得到的相机姿态和稀疏点云基础上，利用多视角的像素信息，密集地重建场景的几何形状（生成密集的 3D 点云或网格）。

优点： 算法成熟，对于纹理丰富、视角差异大的物体效果较好。
缺点： 对输入图像质量和数量要求高，对于纹理单一、反光或透明物体效果不佳，重建出的网格可能不够平滑。

代码示例：SfM/MVS 概念性流程（使用 OpenCV 和 COLMAP 思路）

虽然 COLMAP 是一个独立的、功能强大的 SfM/MVS 库，但我们可以用 OpenCV 模拟其核心步骤，展示其逻辑。实际生产中，会直接调用 COLMAP 或其他专业库。

import cv2
import numpy as np
import os

# 假设我们有多张商品图片
# images = [cv2.imread(f"product_img_{i}.jpg") for i in range(N)]

def sfm_mvs_concept(image_paths):
    """
    概念性地演示 SfM/MVS 的核心步骤。
    实际应用中会使用 COLMAP, OpenMVG 等专业库。
    """
    if len(image_paths) < 2:
        print("需要至少两张图片进行 SfM/MVS。")
        return None

    images = []
    for path in image_paths:
        img = cv2.imread(path, cv2.IMREAD_GRAYSCALE) # SfM/MVS 通常在灰度图上进行特征匹配
        if img is None:
            print(f"无法加载图片: {path}")
            return None
        images.append(img)

    # 1. 特征检测与描述 (例如 SIFT, ORB)
    # 这里的 SIFT 需要 opencv-contrib-python
    try:
        sift = cv2.SIFT_create() 
    except AttributeError:
        print("警告: SIFT 模块可能未安装 (需要 opencv-contrib-python)。尝试使用 ORB。")
        sift = cv2.ORB_create()

    keypoints_list = []
    descriptors_list = []
    for img in images:
        kp, des = sift.detectAndCompute(img, None)
        keypoints_list.append(kp)
        descriptors_list.append(des)

    print(f"检测到 {len(keypoints_list)} 张图片的特征点。")

    # 2. 特征匹配 (Brute-Force Matcher)
    matcher = cv2.BFMatcher(cv2.NORM_L2, crossCheck=True) # SIFT 用 NORM_L2，ORB 用 NORM_HAMMING

    # 匹配第一张和第二张图片
    matches = matcher.match(descriptors_list[0], descriptors_list[1])
    matches = sorted(matches, key=lambda x: x.distance)

    # 获取匹配点的坐标
    pts1 = np.float32([keypoints_list[0][m.queryIdx].pt for m in matches]).reshape(-1, 1, 2)
    pts2 = np.float32([keypoints_list[1][m.trainIdx].pt for m in matches]).reshape(-1, 1, 2)

    print(f"在第一张和第二张图片之间找到 {len(matches)} 对匹配点。")

    # 3. 估算基本矩阵和本征矩阵 (Fundamental Matrix / Essential Matrix)
    # Essential Matrix 需要相机内参 K
    K = np.array([[800, 0, images[0].shape[1]/2],
                  [0, 800, images[0].shape[0]/2],
                  [0, 0, 1]], dtype=np.float32) # 假设的相机内参

    E, mask = cv2.findEssentialMat(pts1, pts2, K, method=cv2.RANSAC, prob=0.999, threshold=1.0)
    print(f"估算 Essential Matrix 完成。")

    # 4. 恢复相机姿态 (旋转 R 和平移 t)
    # 从 Essential Matrix 恢复 R 和 t，并进行三角测量 (Triangulation)
    # 这一步通常返回多个 R, t 组合，需要进一步验证
    points, R, t, mask = cv2.recoverPose(E, pts1, pts2, K)
    print(f"恢复相机姿态 (R, t) 完成。")

    # 5. 稀疏 3D 点云重建 (Triangulation)
    # P1 和 P2 是相机投影矩阵
    P1 = K @ np.hstack((np.eye(3), np.zeros((3, 1)))) # 第一个相机作为世界坐标系原点
    P2 = K @ np.hstack((R, t))

    # 对匹配点进行三角测量，得到 3D 点
    points_4d_hom = cv2.triangulatePoints(P1, P2, pts1, pts2)
    points_3d = cv2.convertPointsFromHomogeneous(points_4d_hom.T).reshape(-1, 3)

    print(f"重建出 {points_3d.shape[0]} 个稀疏 3D 点。")
    print("这是 SfM 的核心输出。MVS 会在此基础上生成更密集的几何。")

    # 实际中，这些 3D 点可以进一步被 MVS 算法（如 COLMAP 的 PatchMatch Stereo）
    # 转换为更密集的点云或网格。

    return points_3d, R, t

# --- 运行示例 ---
if __name__ == "__main__":
    # 创建一些虚拟图片路径
    dummy_img_dir = "dummy_sfm_images"
    os.makedirs(dummy_img_dir, exist_ok=True)
    # 创建一些简单图案的图片，方便特征匹配
    img1 = np.zeros((480, 640), dtype=np.uint8)
    cv2.circle(img1, (200, 200), 50, 255, -1)
    cv2.rectangle(img1, (300, 100), (400, 300), 128, -1)
    cv2.imwrite(os.path.join(dummy_img_dir, "img_01.jpg"), img1)

    img2 = np.zeros((480, 640), dtype=np.uint8)
    cv2.circle(img2, (220, 210), 50, 255, -1) # 稍微移动，模拟不同视角
    cv2.rectangle(img2, (320, 110), (420, 310), 128, -1)
    cv2.imwrite(os.path.join(dummy_img_dir, "img_02.jpg"), img2)

    img3 = np.zeros((480, 640), dtype=np.uint8)
    cv2.circle(img3, (240, 220), 50, 255, -1)
    cv2.rectangle(img3, (340, 120), (440, 320), 128, -1)
    cv2.imwrite(os.path.join(dummy_img_dir, "img_03.jpg"), img3)

    image_paths = [os.path.join(dummy_img_dir, f) for f in os.listdir(dummy_img_dir) if f.endswith('.jpg')]

    if len(image_paths) >= 2:
        points_3d, R, t = sfm_mvs_concept(image_paths)
        if points_3d is not None:
            print(f"n重建的 3D 点 (前5个):n{points_3d[:5]}")
            print(f"n恢复的旋转矩阵 R:n{R}")
            print(f"n恢复的平移向量 t:n{t}")

2. 基于深度学习的重建

近年来，深度学习在 3D 重建领域取得了突破性进展，尤其是针对单视角或少量视角图像的重建。

• NeRF (Neural Radiance Fields – 神经辐射场):
  • 原理： NeRF 将一个 3D 场景表示为一个连续的神经辐射场，输入 3D 坐标 (x, y, z) 和 2D 视角方向 (θ, φ)，输出该点的颜色和体素密度。通过体渲染（volume rendering）技术，可以从任意新视角渲染出高质量的图像。
  • 优点： 能够生成极其逼真的新视角图像，捕捉复杂的光学现象（如反射、折射）。
  • 缺点： 训练时间长，对每个场景需要单独训练一个网络，难以直接导出传统的 3D 网格模型。对于大规模商品重建，效率是瓶颈。
• Diffusion Models for 3D (扩散模型):
  • 原理： 结合文本到图像扩散模型和 NeRF 的思想。例如 Google 的 DreamFusion、Nvidia 的 MVDream 等，可以通过文本描述或单张 2D 图像，生成一个 3D NeRF 模型。其核心思想是利用 2D 扩散模型作为 3D 生成的“先验”，通过多视角一致性约束来优化 3D 模型的生成。
  • 优点： 能够从文本或单张图片生成多样化的、高语义的 3D 模型，泛化能力强。
  • 缺点： 生成的 3D 模型可能存在几何瑕疵，训练和推理计算量大，生成传统网格仍需额外步骤（如 Marching Cubes）。
• Implicit Neural Representations (隐式神经表示):
  • 原理： 将 3D 几何（如 SDF – Signed Distance Function）或纹理直接编码在神经网络的权重中，通过查询网络来获取 3D 点的属性。这与 NeRF 有共通之处，但更侧重于几何表示。
  • 优点： 内存效率高，能够表示任意复杂度的几何，易于处理拓扑变化。
  • 缺点： 同样难以直接导出传统网格，且渲染需要专门的神经渲染器。

代码示例：基于 Diffusion Models 的 3D 生成概念性调用

由于训练和运行一个完整的 NeRF 或 Diffusion 3D 模型非常复杂，需要大量 GPU 资源和专业框架（如 diffusers 结合 pytorch3d 或 nerfstudio），这里我们只展示其概念性接口调用，模拟输入和输出。

import torch
from transformers import pipeline
# from diffusers import AutoPipelineForText2Image # 假设有一个 text-to-3d pipeline

# 假设我们有一个专门用于 Text-to-3D 的模型接口
# 实际中，这会是一个复杂的模型，可能包含多个子模块
class TextTo3DGenerator:
    def __init__(self, model_name="text_to_3d_diffusion_model"):
        print(f"加载 {model_name} 模型...")
        # 实际这里会加载大型预训练模型，例如：
        # self.pipeline = AutoPipelineForText2Image.from_pretrained(...)
        # 但我们这里模拟一个简单的行为
        self.model_name = model_name
        print(f"{model_name} 模型加载完成。")

    def generate_3d_model(self, prompt, num_views=4, resolution=(256, 256), steps=50):
        """
        根据文本提示生成 3D 模型。
        这里模拟返回一个 3D 模型路径（如 .obj 文件）和一个 NeRF 隐式表示的句柄。
        """
        print(f"n生成 3D 模型中，提示词: '{prompt}'")
        print(f"  预计生成 {num_views} 个视角，分辨率 {resolution}x{resolution}。")

        # 模拟生成过程，可能需要一些时间
        # 实际这里会调用模型进行推理，可能涉及多阶段优化

        # 假设生成了一个虚拟的 3D 模型文件路径
        model_filename = f"generated_3d_model_{prompt.replace(' ', '_')}.obj"
        # 假设我们还得到了一个可以用于渲染的 NeRF 隐式表示句柄
        nerf_handle = f"nerf_representation_for_{prompt.replace(' ', '_')}"

        print(f"3D 模型生成完成，保存至: {model_filename}")
        print(f"NeRF 隐式表示句柄: {nerf_handle}")

        # 模拟生成一个空的 .obj 文件，表示模型已创建
        with open(model_filename, 'w') as f:
            f.write("# This is a dummy .obj file generated by TextTo3DGeneratorn")
            f.write("v 0.0 0.0 0.0n") # 简单顶点
            f.write("v 1.0 0.0 0.0n")
            f.write("v 0.0 1.0 0.0n")
            f.write("f 1 2 3n") # 简单面

        # 实际中，这里会返回一个 3D 模型对象，或者保存到文件并返回路径
        return model_filename, nerf_handle

# 假设我们还有一个从 2D 图片生成 3D 模型的接口
class ImageTo3DGenerator:
    def __init__(self, model_name="image_to_3d_diffusion_model"):
        print(f"加载 {model_name} 模型...")
        self.model_name = model_name
        print(f"{model_name} 模型加载完成。")

    def generate_3d_model(self, image_path, num_views=4, resolution=(256, 256)):
        """
        根据 2D 图片生成 3D 模型。
        """
        print(f"n生成 3D 模型中，基于图片: '{image_path}'")
        img = Image.open(image_path).convert('RGB')
        # 实际这里会是图片预处理和模型推理

        model_filename = f"generated_3d_model_from_image_{os.path.basename(image_path).split('.')[0]}.obj"
        nerf_handle = f"nerf_representation_from_image_{os.path.basename(image_path).split('.')[0]}"

        print(f"3D 模型生成完成，保存至: {model_filename}")
        print(f"NeRF 隐式表示句柄: {nerf_handle}")

        with open(model_filename, 'w') as f:
            f.write("# This is a dummy .obj file generated by ImageTo3DGeneratorn")
            f.write("v 0.0 0.0 0.0n")
            f.write("v 1.0 0.0 0.0n")
            f.write("v 0.0 1.0 0.0n")
            f.write("f 1 2 3n")

        return model_filename, nerf_handle

# --- 运行示例 ---
if __name__ == "__main__":
    # 1. 从文本生成 3D 模型
    text_generator = TextTo3DGenerator()
    prompt = "a modern wooden chair with a leather seat"
    obj_path_text, nerf_rep_text = text_generator.generate_3d_model(prompt)
    print(f"Text-to-3D 结果：{obj_path_text}, {nerf_rep_text}")

    # 2. 从图片生成 3D 模型
    # 需要一个实际的图片文件，这里使用前面创建的 dummy_products 中的一张
    dummy_product_img_path = "dummy_products/product_000/image_0.jpg"
    if not os.path.exists(dummy_product_img_path):
        # 如果没有，则先创建
        create_dummy_data(num_products=1, num_images_per_product=1)

    img_generator = ImageTo3DGenerator()
    obj_path_img, nerf_rep_img = img_generator.generate_3d_model(dummy_product_img_path)
    print(f"Image-to-3D 结果：{obj_path_img}, {nerf_rep_img}")

V. 3D 模型生成与优化：塑造虚拟商品

无论是通过 SfM/MVS 还是深度学习生成的 3D 模型，通常都需要进一步的优化和完善才能用于高质量渲染。

1. 纹理生成与贴图

• 从 2D 图像提取纹理： 对于 SfM/MVS 重建出的网格，可以将原始 2D 图像投影到 3D 表面上，生成 UV 纹理贴图。
• AI 生成 PBR（Physically Based Rendering）材质： PBR 材质能够更真实地模拟物理世界的光照交互。AI 模型可以从商品描述（如“拉丝金属”、“磨砂皮革”）或 2D 图片中学习，生成 PBR 所需的多个贴图：
  • Albedo/Base Color (反照率/基色): 物体固有颜色。
  • Normal Map (法线贴图): 模拟表面细节，无需增加几何体。
  • Roughness Map (粗糙度贴图): 控制表面粗糙度，影响反射光泽。
  • Metallic Map (金属度贴图): 指示哪些区域是金属，哪些是非金属。
  • Ambient Occlusion Map (环境光遮蔽贴图): 模拟物体缝隙或凹陷处的阴影。
• 纹理无缝拼接与修复： AI 可以识别并修复纹理接缝，处理图像中存在的瑕疵，确保纹理平滑、自然。

2. 几何细节优化

• 网格简化与细分： 初始重建的网格可能过于密集（高面数）或过于稀疏（低面数）。
  • 简化 (Decimation): 减少面数，降低渲染负担，同时尽量保持几何细节。
  • 细分 (Subdivision): 增加面数，使表面更平滑，尤其适用于有机形状。
• 法线贴图、位移贴图生成： 对于一些细微的表面凹凸，可以通过 AI 从 2D 图像或文本描述中生成法线贴图或位移贴图，避免增加大量几何面数。
• 形状修复与平滑： AI 模型可以学习常见商品的几何特征，对重建中出现的孔洞、噪声或不规则表面进行修复和平滑处理。

3. 姿态与变形 (Pose & Deformation)

对于服装、纺织品、可变形家具（如沙发、床垫）等商品，仅仅生成静态 3D 模型是不够的。

• 骨骼动画与蒙皮： 对于服装，可以与虚拟模特骨骼绑定，实现不同姿态的展示（如穿着、平铺）。
• 形变控制： 对于沙发，可以模拟人坐下时的轻微凹陷；对于窗帘，可以模拟不同折叠状态。这通常通过神经网络（如图神经网络或专用形变网络）学习物体的物理属性和变形规律来实现。

代码示例：使用 trimesh 进行 3D 模型处理与 PBR 材质概念

trimesh 是一个强大的 Python 库，用于处理 3D 几何和网格。

import trimesh
import numpy as np
import os
from PIL import Image

# 假设我们已经有一个 .obj 文件
# obj_path_text = "generated_3d_model_a_modern_wooden_chair_with_a_leather_seat.obj" # 来自上一节
# obj_path_img = "generated_3d_model_from_image_image_0.obj" # 来自上一节

def optimize_3d_model(model_path, target_face_count=1000, output_dir="optimized_models"):
    """
    加载 3D 模型，进行网格简化。
    """
    if not os.path.exists(model_path):
        print(f"模型文件不存在: {model_path}")
        return None

    print(f"n加载模型: {model_path}")
    mesh = trimesh.load(model_path)
    print(f"原始模型面数: {len(mesh.faces)}")

    # 1. 网格简化
    if len(mesh.faces) > target_face_count:
        print(f"正在简化网格至 {target_face_count} 面...")
        # `trimesh.remesh.simplify_mesh` 是一个选项，但通常用 V-REP 或 Open3D 效果更好
        # 这里使用一个简单的顶点移除策略
        simplified_mesh = mesh.simplify_quadratic_decimation(target_face_count)
        print(f"简化后模型面数: {len(simplified_mesh.faces)}")
    else:
        simplified_mesh = mesh
        print("模型面数已在目标范围内，无需简化。")

    # 2. 假设的 PBR 材质生成 (AI 驱动)
    # 实际中，AI 会根据商品描述和图片生成这些纹理
    # 这里我们只是模拟创建空的纹理文件
    base_name = os.path.basename(model_path).split('.')[0]
    output_path = os.path.join(output_dir, f"{base_name}_optimized.obj")
    os.makedirs(output_dir, exist_ok=True)

    # 模拟生成 PBR 纹理贴图
    texture_dir = os.path.join(output_dir, f"{base_name}_textures")
    os.makedirs(texture_dir, exist_ok=True)

    albedo_map_path = os.path.join(texture_dir, "albedo.png")
    normal_map_path = os.path.join(texture_dir, "normal.png")
    roughness_map_path = os.path.join(texture_dir, "roughness.png")
    metallic_map_path = os.path.join(texture_dir, "metallic.png")

    # AI 生成这些纹理 (这里用占位图模拟)
    dummy_texture = Image.new('RGB', (1024, 1024), color = 'white')
    dummy_texture.save(albedo_map_path)
    dummy_texture.save(normal_map_path)
    dummy_texture.save(roughness_map_path)
    dummy_texture.save(metallic_map_path)

    print(f"模拟生成 PBR 纹理到: {texture_dir}")

    # 3. 将 PBR 材质信息写入 .mtl 文件，并关联到 .obj
    # Trimesh 默认不直接处理 MTL，但我们可以手动创建
    mtl_content = f"""
newmtl material_0
Ka 1.000000 1.000000 1.000000
Kd 1.000000 1.000000 1.000000
Ks 0.000000 0.000000 0.000000
d 1.0
illum 1
map_Kd {os.path.basename(albedo_map_path)}
map_Normal {os.path.basename(normal_map_path)}
map_Pr {os.path.basename(roughness_map_path)} # PBR roughness map
map_Pm {os.path.basename(metallic_map_path)} # PBR metallic map
"""
    mtl_path = os.path.join(output_dir, f"{base_name}_optimized.mtl")
    with open(mtl_path, 'w') as f:
        f.write(mtl_content)

    # 将材质库引用添加到 OBJ 文件
    simplified_mesh.visual.material = trimesh.visual.texture.SimpleMaterial(image=None, ambient=(1,1,1,1)) # 占位
    simplified_mesh.export(output_path, file_type='obj', include_texture=True, header=f'mtllib {os.path.basename(mtl_path)}n')

    print(f"优化后的模型保存至: {output_path}")
    return output_path, mtl_path, texture_dir

# --- 运行示例 ---
if __name__ == "__main__":
    # 假设我们从 TextTo3DGenerator 得到了一个 .obj 文件
    dummy_obj_path = "generated_3d_model_a_modern_wooden_chair_with_a_leather_seat.obj"
    if not os.path.exists(dummy_obj_path):
        # 确保 dummy_obj_path 存在
        text_generator = TextTo3DGenerator()
        text_generator.generate_3d_model("a dummy cube") # 生成一个简单的obj文件

    optimized_obj_path, mtl_path, texture_dir = optimize_3d_model(dummy_obj_path, target_face_count=50)
    print(f"最终优化结果: OBJ={optimized_obj_path}, MTL={mtl_path}, Textures={texture_dir}")

    # 验证优化后的模型是否可加载
    try:
        optimized_mesh = trimesh.load(optimized_obj_path)
        print(f"成功加载优化后的模型，面数: {len(optimized_mesh.faces)}")
    except Exception as e:
        print(f"加载优化模型失败: {e}")

VI. 虚拟场景构建与智能布景：赋予商品生命力

仅仅拥有一个优化好的 3D 商品模型是不够的，我们需要将其放置在合适的虚拟场景中，才能生成有吸引力的预览图。

1. 场景模板

预定义多种高质量的虚拟场景，以适应不同品类的商品：

• 室内场景： 现代客厅、卧室、厨房、办公室、书房等，用于家具、家电、装饰品。
• 室外场景： 花园、露台、街道、自然风光等，用于户外家具、运动器材。
• 产品特写场景： 简洁的纯色背景、渐变背景、摄影棚风格，用于珠宝、电子产品、小型配件。
• 品牌定制场景： 带有品牌 Logo 或特定设计元素的场景。

每个场景模板应包含：

• 3D 几何模型： 墙壁、地面、天花板、窗户、家具等。
• 材质与纹理： PBR 材质，确保光照真实。
• 环境光照： HDRI (High Dynamic Range Image) 环境贴图，模拟真实世界的光照环境。
• 预设相机位置与角度： 常见的产品拍摄视角。
• 辅助道具： 如花瓶、书籍、抱枕等，用于增强场景的真实感和生活气息。

2. 智能布景算法

AI 在这里的作用是根据商品特性和用户意图，智能地选择场景模板，并优化商品在场景中的放置、构图和光照。

• 商品尺寸与场景匹配： 根据商品的 3D 尺寸信息，自动选择大小合适的场景。例如，一个大型沙发不会被放置在小型书房中。
• 构图优化：
  • 黄金比例、三分法： 算法可以根据这些摄影构图原则，自动调整商品在画面中的位置和大小。
  • 避免遮挡： 确保商品不会被场景中的其他物体过度遮挡。
  • 视觉焦点： 引导用户视线聚焦在商品上。
• 自动放置辅助道具： AI 可以识别场景中的空闲区域，并智能地放置与商品风格、场景主题相符的辅助道具，如在沙发旁放置茶几和绿植。这可以通过目标检测、语义分割和 3D 布局推理模型实现。
• 碰撞检测与物理模拟： 确保商品与场景中的其他物体不会发生穿模，并能根据重力原理正确放置在平面上。

3. 光照与阴影

光照是决定渲染真实感的关键。AI 可以学习并生成最佳的光照配置。

• 环境光照 (HDRI): 使用高动态范围图像作为环境光，提供全局照明和反射。
• 关键光、补光、背光： 模拟专业摄影棚的灯光设置，突出商品的形状、纹理和细节。AI 可以根据商品材质、颜色和场景氛围，自动调整灯光的颜色、强度和方向。
• AI 学习最佳光照配置： 通过对大量高质量产品渲染图的学习，AI 可以预测在给定场景和商品下，最能突出商品美感的灯光设置。这可能涉及强化学习或生成对抗网络 (GAN)。

代码示例：定义虚拟场景组件与智能放置逻辑

这里我们用 Python 类来模拟场景中的各种元素，并实现一个简单的智能放置逻辑。

import numpy as np
import random
import json
import os

class Camera:
    def __init__(self, position, target, fov=45, aspect_ratio=1.77):
        self.position = np.array(position)
        self.target = np.array(target)
        self.fov = fov # Field of View
        self.aspect_ratio = aspect_ratio
        # 实际中会包含更多参数，如近裁剪面、远裁剪面

    def get_view_matrix(self):
        # 简单模拟 look_at 矩阵
        # 实际渲染器会提供更复杂的矩阵计算
        print(f"相机位置: {self.position}, 目标: {self.target}")
        return f"ViewMatrix_from_{self.position}_to_{self.target}"

class Light:
    def __init__(self, position, color=(1.0, 1.0, 1.0), intensity=1.0, light_type="point"):
        self.position = np.array(position)
        self.color = np.array(color)
        self.intensity = intensity
        self.light_type = light_type # "point", "directional", "spot", "area"

    def __str__(self):
        return f"Light({self.light_type} at {self.position}, Intensity: {self.intensity})"

class SceneObject:
    def __init__(self, model_path, position=(0,0,0), rotation=(0,0,0), scale=(1,1,1), name=""):
        self.model_path = model_path
        self.position = np.array(position)
        self.rotation = np.array(rotation) # Euler angles (roll, pitch, yaw)
        self.scale = np.array(scale)
        self.name = name

    def get_bounding_box(self):
        # 模拟获取模型在本地坐标系下的边界框
        # 实际需要加载模型并计算
        # 这里假设一个简单的立方体边界框，根据模型大小调整
        if "chair" in self.name:
            return np.array([[-0.5, -0.5, 0], [0.5, 0.5, 1.0]]) * self.scale # 椅子
        elif "table" in self.name:
            return np.array([[-0.8, -0.4, 0], [0.8, 0.4, 0.7]]) * self.scale # 桌子
        else: # 默认小道具
            return np.array([[-0.1, -0.1, 0], [0.1, 0.1, 0.2]]) * self.scale

    def __str__(self):
        return f"Object '{self.name}' (Model: {os.path.basename(self.model_path)}) at {self.position}"

class VirtualScene:
    def __init__(self, name="default_scene"):
        self.name = name
        self.objects = []
        self.lights = []
        self.camera = None
        self.environment_map = None # HDRI path

    def add_object(self, obj: SceneObject):
        self.objects.append(obj)

    def add_light(self, light: Light):
        self.lights.append(light)

    def set_camera(self, camera: Camera):
        self.camera = camera

    def set_environment_map(self, hdri_path):
        self.environment_map = hdri_path

    def __str__(self):
        obj_names = [obj.name for obj in self.objects]
        light_types = [light.light_type for light in self.lights]
        return (f"Scene '{self.name}' with {len(self.objects)} objects ({obj_names}), "
                f"{len(self.lights)} lights ({light_types}), Camera set: {self.camera is not None}")

class AISceneComposer:
    def __init__(self, scene_templates_dir="scene_templates", prop_models_dir="prop_models"):
        self.scene_templates = self._load_scene_templates(scene_templates_dir)
        self.prop_models = self._load_prop_models(prop_models_dir)
        print(f"加载 {len(self.scene_templates)} 个场景模板和 {len(self.prop_models)} 个道具模型。")

    def _load_scene_templates(self, templates_dir):
        # 模拟加载场景模板，每个模板是一个预设的 VirtualScene 对象
        # 实际中会从文件加载复杂的场景定义
        templates = {}
        if not os.path.exists(templates_dir):
            os.makedirs(templates_dir)
            # 创建一个示例模板
            template_scene = VirtualScene("modern_living_room")
            template_scene.set_camera(Camera([3, 3, 3], [0, 0, 0.5]))
            template_scene.add_light(Light([2, 2, 5], intensity=1.5, light_type="directional"))
            template_scene.add_light(Light([-2, -2, 3], intensity=0.8, light_type="point"))
            template_scene.set_environment_map("path/to/living_room_hdri.hdr")
            template_scene.add_object(SceneObject("path/to/wall_model.obj", name="wall"))
            template_scene.add_object(SceneObject("path/to/floor_model.obj", name="floor"))
            templates["modern_living_room"] = template_scene
            print(f"创建了示例场景模板: {template_scene.name}")
        else:
            # 假设有一个预设的模板，这里简单模拟
            template_scene = VirtualScene("modern_living_room")
            template_scene.set_camera(Camera([3, 3, 3], [0, 0, 0.5]))
            template_scene.add_light(Light([2, 2, 5], intensity=1.5, light_type="directional"))
            template_scene.add_light(Light([-2, -2, 3], intensity=0.8, light_type="point"))
            template_scene.set_environment_map("path/to/living_room_hdri.hdr")
            template_scene.add_object(SceneObject("path/to/wall_model.obj", name="wall"))
            template_scene.add_object(SceneObject("path/to/floor_model.obj", name="floor"))
            templates["modern_living_room"] = template_scene

        return templates

    def _load_prop_models(self, props_dir):
        # 模拟加载道具模型列表
        # 实际中会加载模型文件，并可能包含语义信息
        if not os.path.exists(props_dir):
            os.makedirs(props_dir)
            # 创建示例道具模型
            with open(os.path.join(props_dir, "vase.obj"), 'w') as f: f.write("# vase dummy")
            with open(os.path.join(props_dir, "book.obj"), 'w') as f: f.write("# book dummy")
            with open(os.path.join(props_dir, "rug.obj"), 'w') as f: f.write("# rug dummy")
            print(f"创建了示例道具模型。")

        return {
            "vase": SceneObject(os.path.join(props_dir, "vase.obj"), name="vase"),
            "book": SceneObject(os.path.join(props_dir, "book.obj"), name="book"),
            "rug": SceneObject(os.path.join(props_dir, "rug.obj"), name="rug")
        }

    def compose_scene(self, product_3d_model_path, product_metadata):
        """
        根据商品元数据智能选择场景模板，并放置商品和道具。
        """
        print(f"n开始智能布景，商品模型: {product_3d_model_path}, 元数据: {product_metadata['category']}")

        # 1. 场景选择 (基于商品类别、风格等)
        # 简化逻辑：所有家具都用现代客厅
        scene_template_name = "modern_living_room"
        if product_metadata['category'] == "Furniture":
            selected_scene = self.scene_templates[scene_template_name]
        else: # 默认使用一个通用场景
            selected_scene = VirtualScene("generic_studio")
            selected_scene.set_camera(Camera([2, 2, 2], [0, 0, 0]))
            selected_scene.add_light(Light([1, 1, 3], intensity=2.0))
            print("选择通用摄影棚场景。")

        # 复制场景模板，避免修改原始模板
        composed_scene = VirtualScene(f"{selected_scene.name}_for_{product_metadata['product_id']}")
        composed_scene.objects = selected_scene.objects[:]
        composed_scene.lights = selected_scene.lights[:]
        composed_scene.camera = selected_scene.camera
        composed_scene.environment_map = selected_scene.environment_map

        # 2. 放置商品
        product_obj = SceneObject(
            product_3d_model_path,
            name=f"product_{product_metadata['product_id']}",
            scale=[s / 100.0 for s in product_metadata.get('dimensions_cm', {'length':100, 'width':50, 'height':70}).values()] # 厘米转米
        )
        # 智能放置逻辑 (简化：放置在场景中心地面)
        # 实际需要考虑场景几何、商品类型（如椅子靠墙，桌子居中）
        product_bbox = product_obj.get_bounding_box()
        # 假设地面在 Z=0
        product_obj.position = np.array([0, 0, -product_bbox[0, 2]]) # 放在地面上

        composed_scene.add_object(product_obj)
        print(f"商品 '{product_obj.name}' 放置在 {product_obj.position}。")

        # 3. 智能放置辅助道具
        # 简化逻辑：随机放置几个道具
        available_props = list(self.prop_models.keys())
        num_props_to_add = random.randint(1, 3)

        for _ in range(num_props_to_add):
            prop_name = random.choice(available_props)
            prop_template = self.prop_models[prop_name]

            # 随机位置，避免与商品重叠
            offset_x = random.uniform(-1.0, 1.0)
            offset_y = random.uniform(-1.0, 1.0)
            prop_obj = SceneObject(
                prop_template.model_path,
                position=[offset_x, offset_y, -prop_template.get_bounding_box()[0, 2]], # 放在地面上
                name=f"prop_{prop_name}_{_}"
            )
            # 碰撞检测 (简化：这里不实现复杂碰撞，只确保位置随机)

            composed_scene.add_object(prop_obj)
            print(f"添加道具 '{prop_obj.name}' 在 {prop_obj.position}。")

        # 4. 智能光照调整 (根据商品材质、颜色)
        # 简化：如果商品是深色，增加主光强度
        if product_metadata['color'] == 'Black':
            for light in composed_scene.lights:
                if light.light_type == "directional":
                    light.intensity *= 1.2
                    print(f"调整主光强度为 {light.intensity}，因为商品是黑色。")

        print(f"智能布景完成: {composed_scene}")
        return composed_scene

# --- 运行示例 ---
if __name__ == "__main__":
    composer = AISceneComposer()

    # 假设这是我们优化后的商品模型路径和元数据
    # 从前一节的 optimize_3d_model 结果中获取
    product_model_path = "optimized_models/generated_3d_model_a_modern_wooden_chair_with_a_leather_seat_optimized.obj"
    product_metadata = {
        "product_id": "product_001_chair",
        "name": "Modern Wooden Chair",
        "category": "Furniture",
        "material": "Wood",
        "color": "Brown",
        "dimensions_cm": {"length": 50, "width": 50, "height": 80},
        "description": "A stylish wooden chair with comfortable design."
    }

    # 确保 product_model_path 存在
    if not os.path.exists(product_model_path):
        print(f"警告: {product_model_path} 不存在，请先运行 V. 3D 模型生成与优化 示例。")
        # 尝试生成一个虚拟模型路径
        text_generator = TextTo3DGenerator()
        dummy_obj_path, _ = text_generator.generate_3d_model("a simple chair model")
        optimized_obj_path, _, _ = optimize_3d_model(dummy_obj_path, target_face_count=50)
        product_model_path = optimized_obj_path

    composed_scene = composer.compose_scene(product_model_path, product_metadata)
    print("n生成的场景结构:")
    for obj in composed_scene.objects:
        print(f"  - {obj}")
    for light in composed_scene.lights:
        print(f"  - {light}")
    print(f"  - Camera: {composed_scene.camera.position} -> {composed_scene.camera.target}")

VII. AI 驱动的智能渲染与预览图生成：从 3D 到 2D 的艺术

一旦 3D 商品模型被放置在智能布景的虚拟场景中，下一步就是将其渲染成 2D 预览图。AI 在这一阶段主要负责自动化渲染参数设置和生成高质量、多样化的预览图。

1. 渲染引擎选择

• 离线渲染器 (Offline Renderers):
  • 优点： 能够生成极其逼真、电影级的图像质量，支持高级光线追踪、全局照明等复杂物理效果。
  • 缺点： 渲染时间长，计算资源消耗大。
  • 典型代表： Blender Cycles/Eevee, V-Ray, Arnold。对于高质量产品渲染，Cycles 和 V-Ray 是常用选择。
• 实时渲染器 (Real-time Renderers):
  • 优点： 渲染速度快，能够实现交互式预览，适用于 Web 或移动端应用。
  • 缺点： 图像质量通常不如离线渲染器，复杂光照效果模拟能力有限。
  • 典型代表： Unity, Unreal Engine。
• 神经渲染器 (Neural Renderers):
  • 优点： 直接从隐式神经表示（如 NeRF）渲染，无需传统几何体，可以生成高质量的新视角图像。
  • 缺点： 需要专门的模型训练，渲染速度可能介于离线和实时之间。
  • 典型代表： NeRF 相关的各种变体。

对于生成式搜索结果，我们通常需要批量生成高质量的静态预览图，离线渲染器（如 Blender Cycles）结合其 Python API 是一个非常高效和灵活的选择。

2. 渲染参数自动化

AI 可以在渲染过程中自动化以下参数的设置：

• 相机角度、焦距、景深： 根据构图原则和商品特性，自动选择最佳视角。例如，对于细节丰富的商品，可能需要特写镜头和浅景深。
• 材质属性： 确保 PBR 材质参数（反射率、粗糙度、金属度）正确应用，以真实反映商品材质。
• 后期处理效果： 色调映射、抗锯齿、降噪、色彩校正、锐化等。AI 可以学习专业摄影师的后期处理风格，自动应用到渲染图中。

3. 多视角、多场景预览图生成

生成式搜索的强大之处在于其个性化能力。我们可以根据用户查询意图，动态生成多样化的预览图。

• 不同视角： 自动生成商品的正视图、侧视图、俯视图、细节特写等。
• 不同场景： 根据用户搜索的场景描述（如“适合现代简约风格客厅的沙发”），在对应的场景模板中渲染商品。
• 不同光照： 根据商品材质（如“高光金属”）或特定氛围（如“温馨夜晚”），调整渲染光照。

代码示例：使用 Blender Python API 进行渲染自动化

Blender 是一个强大的 3D 软件，其 Python API 允许我们完全自动化 3D 场景的创建、修改和渲染。

import bpy
import os
import math
import json
import numpy as np

# 这是一个在 Blender 环境中运行的脚本
# 你需要启动 Blender，然后打开 Scripting 工作区，粘贴并运行。
# 或者使用 `blender -b -P your_script.py` 命令在后台运行。

def setup_blender_scene(composed_scene, output_dir="rendered_previews", render_resolution=(1080, 1080)):
    """
    根据 VirtualScene 对象设置 Blender 场景并渲染。
    """
    # 清空默认场景
    bpy.ops.wm.read_factory_settings(use_empty=True)

    # 设置渲染器为 Cycles (高质量离线渲染)
    bpy.context.scene.render.engine = 'CYCLES'
    bpy.context.scene.cycles.device = 'GPU' # 如果有GPU，开启GPU加速
    bpy.context.scene.cycles.samples = 128 # 渲染采样数，影响质量和速度
    bpy.context.scene.render.resolution_x = render_resolution[0]
    bpy.context.scene.render.resolution_y = render_resolution[1]
    bpy.context.scene.render.image_settings.file_format = 'PNG'
    bpy.context.scene.render.film_transparent = True # 渲染透明背景，方便后期合成

    # 创建一个输出目录
    os.makedirs(output_dir, exist_ok=True)

    # 1. 设置相机
    if composed_scene.camera:
        cam_data = bpy.data.cameras.new(name="ProductCamera")
        camera_obj = bpy.data.objects.new("ProductCamera", cam_data)
        bpy.context.collection.objects.link(camera_obj)

        camera_obj.location = composed_scene.camera.position
        # 计算相机朝向 (Look At)
        direction = composed_scene.camera.target - composed_scene.camera.position
        rot_quat = direction.to_track_quat('-Z', 'Y') # -Z 轴指向目标，Y 轴为上方向
        camera_obj.rotation_euler = rot_quat.to_euler()

        bpy.context.scene.camera = camera_obj
        print(f"Blender 相机设置完成: {camera_obj.location} -> {composed_scene.camera.target}")

    # 2. 设置灯光
    for light_data in composed_scene.lights:
        lamp_data = bpy.data.lights.new(name=light_data.light_type, type=light_data.light_type.upper())
        lamp_obj = bpy.data.objects.new(light_data.light_type, lamp_data)
        bpy.context.collection.objects.link(lamp_obj)

        lamp_obj.location = light_data.position
        lamp_data.energy = light_data.intensity * 100 # Blender 能量单位可能需要调整
        lamp_data.color = light_data.color
        print(f"Blender 灯光设置完成: {light_data.light_type} at {light_data.position}")

    # 3. 加载场景物体和商品模型
    for obj_data in composed_scene.objects:
        if not os.path.exists(obj_data.model_path):
            print(f"警告: 模型文件不存在，跳过加载: {obj_data.model_path}")
            continue

        # 导入 .obj 文件
        try:
            bpy.ops.import_scene.obj(filepath=obj_data.model_path, axis_forward='-Z', axis_up='Y')
            imported_obj = bpy.context.selected_objects[0] # 假设导入后选中了物体
            imported_obj.name = obj_data.name

            imported_obj.location = obj_data.position
            imported_obj.rotation_euler = (math.radians(obj_data.rotation[0]),
                                            math.radians(obj_data.rotation[1]),
                                            math.radians(obj_data.rotation[2]))
            imported_obj.scale = obj_data.scale

            print(f"Blender 加载并放置模型: {obj_data.name} from {obj_data.model_path}")

            # 假设材质信息在 .mtl 文件中，导入 obj 时会自动处理
            # 否则，需要手动创建和应用 PBR 材质
            # 示例：创建一个简单材质
            if not imported_obj.data.materials:
                mat = bpy.data.materials.new(name=f"{obj_data.name}_Material")
                mat.use_nodes = True
                bsdf = mat.node_tree.nodes["Principled BSDF"]
                # 简单设置颜色，实际应读取 PBR 贴图
                bsdf.inputs['Base Color'].default_value = (random.random(), random.random(), random.random(), 1)
                imported_obj.data.materials.append(mat)
        except Exception as e:
            print(f"加载模型 {obj_data.model_path} 失败: {e}")

    # 4. 设置环境光 (HDRI)
    if composed_scene.environment_map and os.path.exists(composed_scene.environment_map):
        world = bpy.context.scene.world
        world.use_nodes = True
        bg = world.node_tree.nodes["Background"]
        env_tex = world.node_tree.nodes.new("ShaderNodeTexEnvironment")
        env_tex.image = bpy.data.images.load(composed_scene.environment_map)
        world.node_tree.links.new(env_tex.outputs["Color"], bg.inputs["Color"])
        print(f"Blender 环境光 (HDRI) 设置完成: {composed_scene.environment_map}")
    else:
        # 如果没有 HDRI，设置一个默认背景色
        bpy.context.scene.world.node_tree.nodes["Background"].inputs[0].default_value = (0.05, 0.05, 0.05, 1) # 深灰色

    # 渲染图像
    output_filepath = os.path.join(output_dir, f"{composed_scene.name}.png")
    bpy.context.scene.render.filepath = output_filepath
    print(f"n开始渲染到: {output_filepath}")
    bpy.ops.render.render(write_still=True)
    print("渲染完成！")
    return output_filepath

# --- 运行示例 (此部分需在 Blender 中或通过 Blender 后台模式执行) ---
if __name__ == "__main__":
    # 模拟一个 VirtualScene 对象，来自 AISceneComposer 的输出
    # 实际中，我们会从 Python 脚本的外部传入这个对象
    # 为了让这个脚本可以在 Blender 中独立运行，我们在这里创建一个简化的 VirtualScene
    # 你需要确保 product_model_path 和 HDRI 路径是有效的

    # 确保前几步的 dummy 文件存在
    text_generator = TextTo3DGenerator()
    dummy_obj_path, _ = text_generator.generate_3d_model("a simple chair model")
    optimized_obj_path, _, _ = optimize_3d_model(dummy_obj_path, target_face_count=50)

    # 创建一个虚拟 HDRI 文件
    hdri_path = "path/to/living_room_hdri.hdr" # 替换为你的 HDRI 路径
    if not os.path.exists(hdri_path):
        print(f"警告: HDRI 文件 {hdri_path} 不存在。请提供一个有效的 HDRI 文件路径。")
        print("将使用默认背景色渲染。")
        # 可以创建一个简单的黑色 HDR 图像作为占位符
        # from PIL import Image
        # dummy_hdri = Image.new('RGB', (1, 1), color = (0, 0, 0))
        # dummy_hdri.save(hdri_path) # 但这并非真正的 HDR

    example_composed_scene = VirtualScene("lecture_demo_scene")
    example_composed_scene.set_camera(Camera([3, -3, 2.5], [0, 0, 0.8]))
    example_composed_scene.add_light(Light([2, 2, 4], intensity=1.5, light_type="directional"))
    example_composed_scene.add_light(Light([-1, -1, 1], intensity=0.5, light_type="point"))
    example_composed_scene.set_environment_map(hdri_path) # 替换为真实 HDRI 路径

    product_obj_for_blender = SceneObject(
        optimized_obj_path,
        position=[0, 0, 0], # 假设模型原点在底部中心
        rotation=[0, 0, 45], # 旋转 45 度
        scale=[0.01, 0.01, 0.01], # Blender 默认单位可能是米，模型可能是厘米
        name="demo_chair"
    )
    example_composed_scene.add_object(product_obj_for_blender)

    # 添加一个简单的地面
    floor_obj_path = "path/to/simple_floor.obj" # 假设有一个地板模型
    if not os.path.exists(floor_obj_path):
        # 创建一个简单的立方体作为地板
        bpy.ops.mesh.primitive_plane_add(size=10, enter_editmode=False, align='WORLD', location=(0,0,0))
        bpy.context.active_object.name = "Floor"
        # 为地板添加一个材质
        floor_mat = bpy.data.materials.new(name="Floor_Material")
        floor_mat.use_nodes = True
        bsdf_floor = floor_mat.node_tree.nodes["Principled BSDF"]
        bsdf_floor.inputs['Base Color'].default_value = (0.2, 0.2, 0.2, 1) # 深灰色地板
        bsdf_floor.inputs['Roughness'].default_value = 0.8
        bpy.context.active_object.data.materials.append(floor_mat)

    print("Blender 场景设置准备就绪。")
    # 渲染并保存
    # rendered_image_path = setup_blender_scene(example_composed_scene)
    # print(f"最终渲染图像路径: {rendered_image_path}")

    # 注意：上述 `setup_blender_scene` 函数在实际运行中会非常耗时，
    # 并且需要 Blender 环境。这里只是展示其核心逻辑。
    # 实际部署时，会将其封装成一个渲染服务。

重要提示： 上述 Blender Python API 代码需要在 Blender 环境中运行。如果你是在一个普通的 Python 环境中运行整个讲座脚本，这部分代码会报错。你可以将这部分代码保存为 render_script.py，然后通过 blender -b -P render_script.py 命令来执行。

VIII. 与生成式搜索结果的集成：实现无缝购物体验

最后一步是将我们生成的 3D 预览图无缝集成到生成式搜索结果中。

1. API 设计

构建一个高性能、可扩展的 RESTful API，作为 3D 预览图生成服务的接口。

• 输入： 商品 ID、用户查询文本（用于指导场景和视角选择）、期望的预览图数量、渲染质量等。
• 输出： 生成的 2D 预览图 URL 列表，或指向交互式 3D 模型的 URL。

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uuid
import os
import time

# 假设这些类和函数来自我们前面定义的模块
# from your_module.text_to_3d_generator import TextTo3DGenerator
# from your_module.image_to_3d_generator import ImageTo3DGenerator
# from your_module.model_optimizer import optimize_3d_model
# from your_module.scene_composer import AISceneComposer
# from your_module.blender_renderer import setup_blender_scene # 这是一个 Blender 脚本，这里用模拟函数代替

# 模拟 TextTo3DGenerator, ImageTo3DGenerator, optimize_3d_model
class MockTextTo3DGenerator:
    def generate_3d_model(self, prompt):
        model_id = str(uuid.uuid4())
        obj_path = f"mock_models/{model_id}.obj"
        os.makedirs(os.path.dirname(obj_path), exist_ok=True)
        with open(obj_path, 'w') as f:
            f.write(f"# Dummy OBJ for prompt: {prompt}n")
        return obj_path, f"nerf_handle_{model_id}"

class MockImageTo3DGenerator:
    def generate_3d_model(self, image_path):
        model_id = str(uuid.uuid4())
        obj_path = f"mock_models/{model_id}.obj"
        os.makedirs(os.path.dirname(obj_path), exist_ok=True)
        with open(obj_path, 'w') as f:
            f.write(f"# Dummy OBJ for image: {image_path}n")
        return obj_path, f"nerf_handle_{model_id}"

def mock_optimize_3d_model(model_path, *args, **kwargs):
    optimized_path = model_path.replace(".obj", "_optimized.obj")
    mtl_path = model_path.replace(".obj", ".mtl")
    texture_dir = model_path.replace(".obj", "_textures")
    os.makedirs(texture_dir, exist_ok=True)
    with open(optimized_path, 'w') as f: f.write("# Optimized dummy OBJn")
    with open(mtl_path, 'w') as f: f.write("# Dummy MTLn")
    return optimized_path, mtl_path, texture_dir

class MockAISceneComposer:
    def compose_scene(self, product_3d_model_path, product_metadata):
        # 简单模拟返回一个场景对象
        class MockScene:
            def __init__(self, name):
                self.name = name
                self.objects = []
                self.lights = []
                self.camera = None
                self.environment_map = None

        scene = MockScene(f"composed_scene_for_{product_metadata.get('product_id', 'unknown')}")
        # 实际会填充更多场景数据
        return scene

def mock_blender_renderer(composed_scene, output_dir="rendered_previews", render_resolution=(1080, 1080)):
    # 模拟渲染时间
    time.sleep(1) 
    # 模拟生成图片文件
    img_filename = f"{composed_scene.name}_{str(uuid.uuid4())}.png"
    img_path = os.path.join(output_dir, img_filename)
    os.makedirs(output_dir, exist_ok=True)
    with open(img_path, 'wb') as f:
        f.write(b'Mock Image Content') # 写入一些虚拟内容
    return img_path

app = FastAPI()

# 初始化我们的核心服务 (使用 Mock 对象)
text_to_3d_gen = MockTextTo3DGenerator()
img_to_3d_gen = MockImageTo3DGenerator()
scene_composer = MockAISceneComposer()

class ProductRequest(BaseModel):
    product_id: str
    product_name: str
    category: str
    description: str
    image_url: str = None # 如果有图片，可从图片生成
    target_scene: str = "modern_living_room"
    num_previews: int = 1
    render_quality: str = "medium"

@app.post("/generate_3d_previews")
async def generate_3d_previews(request: ProductRequest):
    """
    接收商品信息，自动生成 3D 预览图。
    """
    print(f"收到生成请求: {request.product_id}")

    # 1. 2D 到 3D 模型重建
    product_metadata = request.dict()
    product_