AI 3D生成技术深度解析：Hyper3D WorldGen与Tripo P2.0对比评测

pip install requests trimesh numpy pillow

import requests
import time
import json

# 配置API密钥
HYPER3D_API_KEY = "your_api_key_here"
BASE_URL = "https://api.hyper3d.com/v1"

def generate_world_from_image(image_path, quality="standard"):
    """
    从单张图片生成3D世界
    
    参数:
        image_path: 输入图片路径
        quality: 生成质量，'standard' 或 'high'
    
    返回:
        任务ID
    """
    # 读取图片文件
    with open(image_path, "rb") as f:
        image_data = f.read()
    
    # 构建请求
    headers = {
        "Authorization": f"Bearer {HYPER3D_API_KEY}"
    }
    
    files = {
        "image": ("input.jpg", image_data, "image/jpeg")
    }
    
    data = {
        "quality": quality,
        "separate_objects": True,  # 分离每个物体为独立模型
        "generate_textures": True,  # 生成纹理贴图
        "texture_resolution": 2048,  # 纹理分辨率
        "background_mode": "complete"  # 背景补全模式
    }
    
    # 发送生成请求
    response = requests.post(
        f"{BASE_URL}/worldgen/generate",
        headers=headers,
        files=files,
        data=data
    )
    
    if response.status_code != 200:
        raise Exception(f"生成请求失败: {response.status_code} - {response.text}")
    
    result = response.json()
    task_id = result["task_id"]
    print(f"任务已提交，ID: {task_id}")
    return task_id


def check_task_status(task_id):
    """检查任务状态"""
    headers = {
        "Authorization": f"Bearer {HYPER3D_API_KEY}"
    }
    
    response = requests.get(
        f"{BASE_URL}/worldgen/status/{task_id}",
        headers=headers
    )
    
    if response.status_code != 200:
        raise Exception(f"状态查询失败: {response.status_code} - {response.text}")
    
    return response.json()


def wait_for_completion(task_id, poll_interval=5, timeout=600):
    """等待任务完成"""
    start_time = time.time()
    
    while True:
        if time.time() - start_time > timeout:
            raise Exception("任务超时")
        
        status = check_task_status(task_id)
        state = status["state"]
        progress = status.get("progress", 0)
        
        print(f"
当前状态: {state}，进度: {progress}%", end="", flush=True)
        
        if state == "completed":
            print("
生成完成！")
            return status
        elif state == "failed":
            raise Exception(f"任务失败: {status.get('error', '未知错误')}")
        
        time.sleep(poll_interval)


def download_result(task_id, output_path):
    """下载生成结果"""
    headers = {
        "Authorization": f"Bearer {HYPER3D_API_KEY}"
    }
    
    # 获取下载链接
    response = requests.get(
        f"{BASE_URL}/worldgen/export/{task_id}",
        headers=headers,
        params={"format": "glb"}
    )
    
    if response.status_code != 200:
        raise Exception(f"导出请求失败: {response.status_code} - {response.text}")
    
    export_info = response.json()
    download_url = export_info["download_url"]
    
    # 下载文件
    print(f"正在下载模型文件...")
    file_response = requests.get(download_url, stream=True)
    
    with open(output_path, "wb") as f:
        for chunk in file_response.iter_content(chunk_size=8192):
            f.write(chunk)
    
    print(f"模型已保存到: {output_path}")
    return output_path


# 使用示例
if __name__ == "__main__":
    image_path = "living_room.jpg"  # 替换为你的图片路径
    output_path = "living_room_world.glb"
    
    try:
        # 提交生成任务
        task_id = generate_world_from_image(image_path, quality="high")
        
        # 等待完成
        result = wait_for_completion(task_id)
        
        # 下载结果
        download_result(task_id, output_path)
        
        # 打印生成的物体列表
        objects = result.get("objects", [])
        print(f"
生成了 {len(objects)} 个物体:")
        for obj in objects:
            print(f"  - {obj['name']} (类别: {obj['category']}, 面数: {obj['face_count']})")
            
    except Exception as e:
        print(f"错误: {e}")

import requests
import time
import os

# 配置API密钥
TRIPO_API_KEY = "your_api_key_here"
BASE_URL = "https://api.tripo3d.ai/v2"

def text_to_3d(prompt, negative_prompt=None, quality="medium", style="realistic"):
    """
    文本生成3D模型
    
    参数:
        prompt: 文本描述
        negative_prompt: 负面提示词
        quality: 质量等级 'low' | 'medium' | 'high'
        style: 风格 'realistic' | 'stylized' | 'anime'
    
    返回:
        任务ID
    """
    headers = {
        "Authorization": f"Bearer {TRIPO_API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "prompt": prompt,
        "negative_prompt": negative_prompt or "",
        "quality": quality,
        "style": style,
        "mesh_type": "quad",  # 四边面网格
        "pbr": True,  # PBR材质
        "texture_resolution": 4096,  # 4K纹理
        "target_face_count": 20000,  # 目标面数
        "generate_lod": True,  # 生成LOD
        "generate_collision": True  # 生成碰撞体
    }
    
    response = requests.post(
        f"{BASE_URL}/generate/text-to-3d",
        headers=headers,
        json=payload
    )
    
    if response.status_code != 200:
        raise Exception(f"生成请求失败: {response.status_code} - {response.text}")
    
    result = response.json()
    task_id = result["data"]["task_id"]
    print(f"任务已提交，ID: {task_id}")
    return task_id


def check_task_status(task_id):
    """检查任务状态"""
    headers = {
        "Authorization": f"Bearer {TRIPO_API_KEY}"
    }
    
    response = requests.get(
        f"{BASE_URL}/tasks/{task_id}",
        headers=headers
    )
    
    if response.status_code != 200:
        raise Exception(f"状态查询失败: {response.status_code} - {response.text}")
    
    return response.json()["data"]


def wait_for_completion(task_id, poll_interval=3, timeout=300):
    """等待任务完成（支持Webhook回调的话更好，但这里用轮询演示）"""
    start_time = time.time()
    
    while True:
        if time.time() - start_time > timeout:
            raise Exception("任务超时")
        
        status_data = check_task_status(task_id)
        status = status_data["status"]
        progress = status_data.get("progress", 0)
        
        print(f"
当前状态: {status}，进度: {progress}%", end="", flush=True)
        
        if status == "success":
            print("
生成成功！")
            return status_data
        elif status == "failed":
            raise Exception(f"任务失败: {status_data.get('error', '未知错误')}")
        
        time.sleep(poll_interval)


def download_model(task_id, output_dir="output"):
    """下载生成的模型文件"""
    os.makedirs(output_dir, exist_ok=True)
    
    status_data = check_task_status(task_id)
    models = status_data["output"]["model"]
    
    downloaded_files = []
    
    for model_info in models:
        url = model_info["url"]
        filename = model_info.get("name", "model.glb")
        filepath = os.path.join(output_dir, filename)
        
        print(f"正在下载: {filename}")
        response = requests.get(url, stream=True)
        
        with open(filepath, "wb") as f:
            for chunk in response.iter_content(chunk_size=8192):
                f.write(chunk)
        
        downloaded_files.append(filepath)
        print(f"  已保存到: {filepath}")
    
    return downloaded_files


def batch_generate(prompts, output_dir="batch_output"):
    """
    批量生成3D模型
    
    参数:
        prompts: 提示词列表
        output_dir: 输出目录
    """
    task_ids = []
    
    # 批量提交任务
    for i, prompt in enumerate(prompts):
        print(f"
[{i+1}/{len(prompts)}] 提交任务: {prompt[:50]}...")
        try:
            task_id = text_to_3d(
                prompt=prompt,
                quality="medium",
                style="realistic"
            )
            task_ids.append(task_id)
        except Exception as e:
            print(f"  提交失败: {e}")
    
    print(f"
共提交 {len(task_ids)} 个任务，等待完成...
")
    
    # 等待所有任务完成并下载
    for i, task_id in enumerate(task_ids):
        print(f"
处理任务 {i+1}/{len(task_ids)}: {task_id}")
        try:
            wait_for_completion(task_id)
            files = download_model(task_id, output_dir)
            print(f"  下载完成: {len(files)} 个文件")
        except Exception as e:
            print(f"  处理失败: {e}")


# 使用示例
if __name__ == "__main__":
    # 示例1：单个模型生成
    print("=== 示例1：单个模型生成 ===")
    try:
        task_id = text_to_3d(
            prompt="一个中世纪风格的木制宝箱，带有金属加固和金色锁扣，放置在石质底座上，高细节，PBR材质",
            negative_prompt="低质量，模糊，变形，多余的肢体",
            quality="high",
            style="realistic"
        )
        
        result = wait_for_completion(task_id)
        files = download_model(task_id, "treasure_chest")
        print(f"
模型信息: 面数={result['output'].get('face_count', 'N/A')}")
        
    except Exception as e:
        print(f"错误: {e}")
    
    # 示例2：批量生成游戏道具
    print("
=== 示例2：批量生成游戏道具 ===")
    game_props = [
        "一把幻想风格的剑，带有蓝色宝石装饰，金属质感强",
        "一个魔法水晶球，内部有发光的星云效果，放置在雕花底座上",
        "一面古老的盾牌，上面有狮子纹章，有使用痕迹和磨损",
        "一瓶红色的魔法药水，玻璃瓶，金色瓶塞，液体发光",
        "一本皮革封面的魔法书，上面有神秘符文，书角微卷"
    ]
    
    try:
        batch_generate(game_props, "game_props")
        print("
批量生成完成！")
    except Exception as e:
        print(f"批量生成错误: {e}")

import trimesh
import numpy as np

def optimize_mesh(input_path, output_path, max_faces=None, smooth_iterations=2):
    """
    优化3D网格：简化面数、平滑表面、计算法线
    
    参数:
        input_path: 输入模型路径
        output_path: 输出模型路径
        max_faces: 最大面数，None表示不简化
        smooth_iterations: 平滑迭代次数
    """
    # 加载模型
    mesh = trimesh.load(input_path)
    
    # 如果是Scene，提取第一个mesh
    if isinstance(mesh, trimesh.Scene):
        mesh = list(mesh.geometry.values())[0]
    
    print(f"原始模型: {len(mesh.vertices)} 顶点, {len(mesh.faces)} 面")
    
    # 面数简化
    if max_faces and len(mesh.faces) > max_faces:
        mesh = mesh.simplify_quadric_decimation(max_faces)
        print(f"简化后: {len(mesh.vertices)} 顶点, {len(mesh.faces)} 面")
    
    # 平滑处理（Laplacian平滑）
    if smooth_iterations > 0:
        # 使用Humphrey平滑算法，保持形状的同时减少噪声
        mesh = trimesh.smoothing.filter_humphrey(
            mesh,
            iterations=smooth_iterations
        )
        print(f"平滑完成: {smooth_iterations} 次迭代")
    
    # 重新计算法线
    mesh.compute_vertex_normals()
    mesh.compute_face_normals()
    
    # 居中并缩放到单位大小
    mesh.vertices -= mesh.center_mass
    scale = 1.0 / mesh.extents.max()
    mesh.vertices *= scale
    
    # 导出
    mesh.export(output_path)
    print(f"优化后的模型已保存到: {output_path}")
    
    return mesh


def generate_uv_unwrapping(mesh_path, output_path):
    """
    为模型生成UV展开（如果模型没有UV的话）
    注意：trimesh的UV展开功能有限，复杂模型建议使用专业工具
    """
    mesh = trimesh.load(mesh_path)
    
    if isinstance(mesh, trimesh.Scene):
        mesh = list(mesh.geometry.values())[0]
    
    # 检查是否已有UV
    has_uv = hasattr(mesh.visual, 'uv') and mesh.visual.uv is not None
    print(f"UV状态: {'已有UV' if has_uv else '无UV'}")
    
    # 使用xatlas进行UV展开（需要安装trimesh[easy]）
    try:
        uv = trimesh.util.decoded_stb_image  # 占位
        # 实际UV展开通常使用xatlas或blender的smart UV project
        # 这里仅作演示
        print("建议使用xatlas或Blender进行高质量UV展开")
    except Exception as e:
        print(f"UV展开提示: {e}")
    
    return mesh


# 使用示例
if __name__ == "__main__":
    # 优化模型
    optimize_mesh(
        input_path="treasure_chest/model.glb",
        output_path="treasure_chest/model_optimized.glb",
        max_faces=10000,
        smooth_iterations=3
    )