652 lines
24 KiB
Python
652 lines
24 KiB
Python
import asyncio
|
||
import io
|
||
import json
|
||
import logging
|
||
import mimetypes
|
||
import os
|
||
import time
|
||
from pathlib import Path
|
||
from typing import Any, Dict, Iterator, Tuple, List
|
||
from urllib.parse import urlparse
|
||
|
||
import httpx
|
||
import numpy as np
|
||
import requests
|
||
import trimesh
|
||
from minio import Minio, S3Error
|
||
|
||
from src.core.config import settings
|
||
from src.schemas.generate_3D import Tripo3dApiModel
|
||
from src.server.canvas_generate_3D.callback import notify_callback
|
||
|
||
logger = logging.getLogger(__name__)
|
||
minio_client = Minio(settings.MINIO_URL, access_key=settings.MINIO_ACCESS, secret_key=settings.MINIO_SECRET, secure=settings.MINIO_SECURE)
|
||
|
||
|
||
class TripoAPIError(RuntimeError):
|
||
pass
|
||
|
||
|
||
class Triop3dApiServer:
|
||
def __init__(self):
|
||
self.base_url = "https://api.tripo3d.ai/v2/openapi"
|
||
|
||
async def _get_client(self) -> httpx.AsyncClient:
|
||
"""获取或创建异步客户端（懒加载）"""
|
||
self.async_client = httpx.AsyncClient(
|
||
timeout=httpx.Timeout(120.0), # 可根据需要调整
|
||
headers={
|
||
"Authorization": f"Bearer {settings.TRIPO_API_KEY}",
|
||
"Accept": "application/json"
|
||
},
|
||
limits=httpx.Limits(max_connections=20, max_keepalive_connections=10)
|
||
)
|
||
return self.async_client
|
||
|
||
async def request_json(self, method: str, endpoint: str, request_timeout: float, **kwargs) -> Dict[str, Any]:
|
||
"""异步请求核心方法 - 直接返回原始 resp（成功或失败都不抛异常）"""
|
||
url = f"{self.base_url}{endpoint}"
|
||
client = await self._get_client()
|
||
|
||
try:
|
||
resp = await client.request(method=method, url=url, timeout=request_timeout, **kwargs)
|
||
except httpx.RequestError as e:
|
||
# 网络层错误也包装成类似 API 的格式返回
|
||
return {
|
||
"code": -1,
|
||
"message": f"网络请求失败: {method} {url}",
|
||
"detail": str(e)
|
||
}
|
||
|
||
try:
|
||
return resp.json()
|
||
except Exception:
|
||
# 非 JSON 返回也包装返回
|
||
return {
|
||
"code": -2,
|
||
"message": f"响应不是合法 JSON: HTTP {resp.status_code}",
|
||
"raw": resp.text[:500] # 截取一部分避免过长
|
||
}
|
||
|
||
async def upload_image(self, image_path: str, request_timeout: float) -> str:
|
||
"""
|
||
从 MinIO 读取图片 → 直接上传到 Tripo3D
|
||
|
||
Args:
|
||
image_path: MinIO 中的完整路径，例如 "fida-public-bucket/furniture/sketches/xxx.png"
|
||
或 "user_123/images/test.png"
|
||
request_timeout: 请求超时时间
|
||
|
||
Returns:
|
||
str: Tripo3D 返回的 image_token
|
||
"""
|
||
try:
|
||
# 解析 bucket 和 object_name
|
||
bucket_name, object_name = image_path.split('/', 1)
|
||
print(f"从 MinIO 下载图片: {bucket_name}/{object_name}")
|
||
logger.info(f"从 MinIO 下载图片: {bucket_name}/{object_name}")
|
||
|
||
# 1. 从 MinIO 获取文件
|
||
response = minio_client.get_object(bucket_name=bucket_name, object_name=object_name)
|
||
# 2. 读取为 bytes（关键修复点）
|
||
data = response.read()
|
||
file_name = Path(object_name).name
|
||
content_type = get_mime_type(file_name)
|
||
# 3. 用 BytesIO 包装（httpx 处理更稳定）
|
||
file_obj = io.BytesIO(data)
|
||
|
||
files = {
|
||
"file": (
|
||
file_name, # 文件名
|
||
file_obj, # BytesIO 对象
|
||
content_type
|
||
)
|
||
}
|
||
|
||
# 4. 异步上传
|
||
payload = await self.request_json(
|
||
"POST",
|
||
"/upload",
|
||
request_timeout=request_timeout,
|
||
files=files
|
||
)
|
||
data = payload.get("data") or {}
|
||
file_token = data.get("image_token")
|
||
|
||
if not file_token:
|
||
raise TripoAPIError(f"上传成功但未返回 image_token: {json.dumps(payload, ensure_ascii=False)}")
|
||
|
||
print(f"✅ 图片上传成功 | image_token: {file_token} | 文件: {file_name}")
|
||
logger.info(f"✅ 图片上传成功 | image_token: {file_token} | 文件: {file_name}")
|
||
|
||
return file_token
|
||
except Exception as e:
|
||
logger.error(f"上传图片失败 {image_path}: {e}")
|
||
raise
|
||
|
||
# ====================== 异步上传多张图片 ======================
|
||
async def upload_images(self, image_paths: List[str], request_timeout: float) -> List[str]:
|
||
"""
|
||
批量从 MinIO 上传多张图片到 Tripo3D
|
||
|
||
Args:
|
||
image_paths: MinIO 对象路径列表
|
||
request_timeout: 请求超时时间
|
||
|
||
Returns:
|
||
List[str]: Tripo3D 返回的 image_token 列表
|
||
"""
|
||
file_tokens = []
|
||
|
||
for idx, image_path in enumerate(image_paths, 1):
|
||
print(f" - 上传第 {idx}/{len(image_paths)} 张图片: {image_path}")
|
||
logger.info(f" - 上传第 {idx}/{len(image_paths)} 张图片: {image_path}")
|
||
|
||
token = await self.upload_image(
|
||
image_path=image_path,
|
||
request_timeout=request_timeout
|
||
)
|
||
|
||
file_tokens.append(token)
|
||
|
||
print(f"✅ 所有图片上传完成，共 {len(file_tokens)} 张")
|
||
logger.info(f"✅ 所有图片上传完成，共 {len(file_tokens)} 张")
|
||
|
||
return file_tokens
|
||
|
||
async def create_task(self, payload: Dict[str, Any], request_timeout: float) -> Dict[str, Any]:
|
||
"""
|
||
创建任务
|
||
- 成功时返回原始响应（包含 code: 0 和 data.task_id）
|
||
- 失败时也返回原始响应，并确保错误码（code）被带上
|
||
"""
|
||
resp = await self.request_json("POST", "/task", request_timeout=request_timeout, json=payload)
|
||
|
||
# 如果是成功响应（通常 code == 0），直接返回
|
||
if isinstance(resp, dict) and resp.get("code") == 0:
|
||
return resp
|
||
|
||
# 失败情况：确保错误码存在，并返回完整响应（不抛异常）
|
||
if not isinstance(resp, dict):
|
||
resp = {"code": -3, "message": "未知错误", "raw_response": str(resp)}
|
||
|
||
# 如果响应中没有 code 字段，补充一个
|
||
if "code" not in resp:
|
||
resp["code"] = resp.get("error", {}).get("code") or -999
|
||
|
||
# 可选：统一加上一个更明显的错误标识（方便上层判断）
|
||
if resp.get("code") != 0:
|
||
resp.setdefault("success", False)
|
||
# 如果有 suggestion，可以保留
|
||
if "suggestion" not in resp and isinstance(resp.get("error"), dict):
|
||
resp["suggestion"] = resp["error"].get("suggestion")
|
||
|
||
return resp
|
||
|
||
# step 3 查询任务状态
|
||
async def poll_task(self, task_id: str, poll_interval: float, poll_timeout: float, request_timeout: float, callback_url: str) -> Dict[str, Any]:
|
||
start = asyncio.get_running_loop().time()
|
||
last_line = ""
|
||
|
||
while True:
|
||
resp = await self.request_json("GET", f"/task/{task_id}", request_timeout=request_timeout)
|
||
data = resp.get("data") or {}
|
||
|
||
status = str(data.get("status", "unknown")).lower()
|
||
progress = data.get("progress", 0)
|
||
elapsed = asyncio.get_running_loop().time() - start
|
||
|
||
line = f"[状态] {status:<10} | [进度] {progress:>3}% | [已等待] {elapsed:>7.1f}s"
|
||
if line != last_line:
|
||
logger.info(line)
|
||
print(line)
|
||
|
||
last_line = line
|
||
|
||
if status == "success":
|
||
return resp
|
||
|
||
if status == "failed":
|
||
await notify_callback(callback_url=callback_url, task_id=task_id, status="failed", result={})
|
||
error_message = data.get("error_message") or extract_error_message(resp)
|
||
raise TripoAPIError(f"任务失败 | task_id={task_id} | {error_message}")
|
||
|
||
if elapsed > poll_timeout:
|
||
await notify_callback(callback_url=callback_url, task_id=task_id, status="failed", result={})
|
||
raise TimeoutError(f"轮询超时: 已等待 {elapsed:.1f}s，task_id={task_id}")
|
||
|
||
await asyncio.sleep(poll_interval)
|
||
|
||
# step 4 上传结果
|
||
async def save_outputs(self, task_resp: Dict[str, Any], request_timeout: float, bucket_name: str, user_id: str):
|
||
data = task_resp.get("data") or {}
|
||
task_id = data.get("task_id", "unknown_task")
|
||
result = data.get("result") or {}
|
||
|
||
print("\n📥 开始异步处理并上传输出文件...")
|
||
logger.info("\n📥 开始异步处理并上传输出文件...")
|
||
|
||
outputs = {}
|
||
for key, value in result.items():
|
||
if not isinstance(value, dict) or 'url' not in value:
|
||
continue
|
||
|
||
url = value['url']
|
||
parsed = urlparse(url)
|
||
path = Path(parsed.path.split('?')[0])
|
||
ext = path.suffix.lower() or ".bin"
|
||
|
||
object_name = f"{user_id}/3d_result/{task_id}{ext}"
|
||
|
||
# 异步上传到 MinIO
|
||
await upload_file_to_minio_from_url_async(
|
||
url=url,
|
||
bucket_name=bucket_name,
|
||
object_name=object_name,
|
||
request_timeout=request_timeout
|
||
)
|
||
|
||
if value.get('type') == "glb":
|
||
outputs['glb_path'] = f"{bucket_name}/{object_name}"
|
||
elif value.get('type') == "webp":
|
||
outputs['glb_static_img_path'] = f"{bucket_name}/{object_name}"
|
||
else:
|
||
outputs[value.get('type', key)] = f"{bucket_name}/{object_name}"
|
||
|
||
# 异步分析 GLB 模型（CPU密集型任务）
|
||
if 'glb_path' in outputs:
|
||
glb_info = await analyze_mesh_async(outputs['glb_path'])
|
||
outputs['glb_info'] = glb_info
|
||
|
||
# outputs = {
|
||
# 'glb_path': 'test/3d_result/glb/aea689fd4ee14f53ac9ab0922f9fe5b3.glb',
|
||
# 'glb_static_img_path': 'test/3d_result/png/26a7fa7ca48641348847c1f4bca353db.png',
|
||
# 'glb_info': {'file_format': '.glb', 'vertex_count': 5275, 'centroid': [0.0044253334706297175, -0.01139796154609474, -0.06385942913980143], 'bounding_box_min': [-0.500163733959198, -0.18078294396400452, -0.29821905493736267], 'bounding_box_max': [0.49963313341140747, 0.17052923142910004, 0.3003925383090973], 'size': [0.9997968673706055, 0.35131217539310455, 0.59861159324646], 'size_ratio': [0.5127898063471029, 0.1801859040236737, 0.30702428962922335],
|
||
# 'size_ratio_percentage': [51.278980634710294, 18.01859040236737, 30.702428962922333]}}
|
||
return outputs
|
||
|
||
async def call_back_result(self, callback_url: str, result: Dict, task_id: str):
|
||
await notify_callback(
|
||
callback_url=callback_url,
|
||
task_id=task_id,
|
||
status="completed",
|
||
result=result,
|
||
)
|
||
return "ok"
|
||
|
||
|
||
async def upload_file_to_minio_from_url_async(url: str, bucket_name: str, object_name: str, request_timeout: float = 60.0, content_type: str = None):
|
||
"""
|
||
异步从 Tripo URL 下载文件并上传到 MinIO（最终修复版）
|
||
"""
|
||
try:
|
||
async with httpx.AsyncClient(timeout=request_timeout) as client:
|
||
async with client.stream("GET", url) as resp:
|
||
resp.raise_for_status()
|
||
|
||
# 正确方式：先读取所有内容为 bytes
|
||
data_bytes = await resp.aread()
|
||
|
||
if content_type is None:
|
||
content_type = get_mime_type(object_name)
|
||
|
||
# 关键修复：用 BytesIO 包装 bytes，让它拥有 .read() 方法
|
||
file_obj = io.BytesIO(data_bytes)
|
||
|
||
logger.info(f"开始上传到 MinIO → {bucket_name}/{object_name} | 大小: {len(data_bytes):,} bytes")
|
||
|
||
# 上传到 MinIO
|
||
result = minio_client.put_object(
|
||
bucket_name=bucket_name,
|
||
object_name=object_name,
|
||
data=file_obj, # ← 必须传 BytesIO 或有 .read() 的对象
|
||
length=len(data_bytes),
|
||
content_type=content_type,
|
||
part_size=0 # 自动分片
|
||
)
|
||
|
||
logger.info(f"✅ 成功上传到 MinIO: {bucket_name}/{object_name}")
|
||
return result
|
||
|
||
except httpx.HTTPError as e:
|
||
raise TripoAPIError(f"下载 Tripo 文件失败: {url} | {e}") from e
|
||
except S3Error as e:
|
||
raise TripoAPIError(f"上传到 MinIO 失败: {bucket_name}/{object_name} | {e}") from e
|
||
except Exception as e:
|
||
raise TripoAPIError(f"上传过程异常 {url}: {e}") from e
|
||
|
||
|
||
async def analyze_mesh_async(image_path: str) -> Dict:
|
||
"""异步包装 analyze_mesh（CPU密集型）"""
|
||
loop = asyncio.get_running_loop()
|
||
return await loop.run_in_executor(None, analyze_mesh_sync, image_path)
|
||
|
||
|
||
def analyze_mesh_sync(image_path: str):
|
||
"""同步版本（供 executor 调用）"""
|
||
bucket_name, object_name = image_path.split('/', 1)
|
||
vertices = load_mesh_from_minio(bucket_name=bucket_name, object_name=object_name)
|
||
|
||
min_coords = vertices.min(axis=0)
|
||
max_coords = vertices.max(axis=0)
|
||
centroid = vertices.mean(axis=0)
|
||
size = max_coords - min_coords
|
||
|
||
total_size = np.sum(size)
|
||
size_ratio = size / total_size if total_size != 0 else np.zeros(3)
|
||
|
||
return {
|
||
"file_format": os.path.splitext(image_path)[1].lower(),
|
||
"vertex_count": len(vertices),
|
||
"centroid": centroid.tolist(),
|
||
"bounding_box_min": min_coords.tolist(),
|
||
"bounding_box_max": max_coords.tolist(),
|
||
"size": size.tolist(),
|
||
"size_ratio": size_ratio.tolist(),
|
||
"size_ratio_percentage": (size_ratio * 100).tolist()
|
||
}
|
||
|
||
|
||
def get_mime_type(path):
|
||
mime, _ = mimetypes.guess_type(str(path))
|
||
return mime or "application/octet-stream"
|
||
|
||
|
||
def extract_error_message(payload: Any) -> str:
|
||
if isinstance(payload, dict):
|
||
for key in ("message", "error", "error_message", "detail", "suggestion"):
|
||
if payload.get(key):
|
||
return str(payload[key])
|
||
|
||
data = payload.get("data")
|
||
if isinstance(data, dict):
|
||
for key in ("message", "error", "error_message", "detail", "suggestion"):
|
||
if data.get(key):
|
||
return str(data[key])
|
||
|
||
return json.dumps(payload, ensure_ascii=False)[:800]
|
||
|
||
return str(payload)[:800]
|
||
|
||
|
||
def iter_urls(obj: Any, prefix: str = "output") -> Iterator[Tuple[str, str]]:
|
||
if isinstance(obj, dict):
|
||
for k, v in obj.items():
|
||
yield from iter_urls(v, f"{prefix}.{k}")
|
||
elif isinstance(obj, list):
|
||
for i, v in enumerate(obj):
|
||
yield from iter_urls(v, f"{prefix}[{i}]")
|
||
elif isinstance(obj, str) and obj.startswith(("http://", "https://")):
|
||
yield prefix, obj
|
||
|
||
|
||
def upload_file_to_minio_from_url(session: requests.Session, url: str, bucket_name: str, object_name: str, request_timeout: float = 30.0, content_type: str = "application/octet-stream"):
|
||
"""
|
||
从 URL 下载文件流，直接上传到 MinIO，不落地本地
|
||
"""
|
||
try:
|
||
with session.get(url, stream=True, timeout=request_timeout) as resp:
|
||
resp.raise_for_status()
|
||
|
||
# 获取文件大小（如果服务器返回 Content-Length）
|
||
content_length = int(resp.headers.get('Content-Length', 0))
|
||
|
||
# 如果无法获取长度，可以设为 -1（MinIO 会自动处理分块上传）
|
||
length = content_length if content_length > 0 else -1
|
||
|
||
# 直接把 response.raw 传给 put_object（最推荐的流式方式）
|
||
result = minio_client.put_object( # 假设你的 MinIO 客户端是 self.minio_client
|
||
bucket_name=bucket_name,
|
||
object_name=object_name,
|
||
data=resp.raw, # 关键：直接传 raw stream
|
||
length=length,
|
||
content_type=content_type,
|
||
part_size=0 # 0 表示让 MinIO 自动选择合适的分片大小
|
||
)
|
||
|
||
except requests.RequestException as e:
|
||
raise TripoAPIError(f"下载失败: {url} | {e}") from e
|
||
except S3Error as e:
|
||
raise TripoAPIError(f"上传到 MinIO 失败: {bucket_name}/{object_name} | {e}") from e
|
||
|
||
return result
|
||
|
||
|
||
def analyze_mesh(image_path: str):
|
||
# 加载模型顶点（直接从 MinIO）
|
||
bucket_name, object_name = image_path.split('/', 1)
|
||
vertices = load_mesh_from_minio(bucket_name=bucket_name, object_name=object_name)
|
||
|
||
# 计算各项指标
|
||
min_coords = vertices.min(axis=0)
|
||
max_coords = vertices.max(axis=0)
|
||
centroid = vertices.mean(axis=0)
|
||
size = max_coords - min_coords
|
||
|
||
total_size = np.sum(size)
|
||
size_ratio = size / total_size if total_size != 0 else np.zeros(3)
|
||
|
||
info = {
|
||
"file_format": os.path.splitext(image_path)[1].lower(),
|
||
"vertex_count": len(vertices),
|
||
"centroid": centroid.tolist(),
|
||
"bounding_box_min": min_coords.tolist(),
|
||
"bounding_box_max": max_coords.tolist(),
|
||
"size": size.tolist(),
|
||
"size_ratio": size_ratio.tolist(),
|
||
"size_ratio_percentage": (size_ratio * 100).tolist()
|
||
}
|
||
|
||
return info
|
||
|
||
|
||
def load_mesh_from_minio(object_name: str, bucket_name: str = "fida-user"):
|
||
"""
|
||
从 MinIO 直接加载 .glb / .gltf / .obj 文件，返回顶点数组
|
||
"""
|
||
try:
|
||
# 从 MinIO 获取文件流
|
||
response = minio_client.get_object(bucket_name, object_name)
|
||
|
||
# 读取为 bytes 并包装成 BytesIO
|
||
data = response.read()
|
||
file_obj = io.BytesIO(data)
|
||
|
||
file_ext = os.path.splitext(object_name)[1].lower()
|
||
|
||
# 根据后缀加载模型
|
||
if file_ext in ('.glb', '.gltf'):
|
||
mesh = trimesh.load(file_obj, file_type='glb')
|
||
elif file_ext == '.obj':
|
||
mesh = trimesh.load(file_obj, file_type='obj')
|
||
else:
|
||
raise ValueError(f"不支持的文件格式: {file_ext}，仅支持 .obj 和 .glb/.gltf")
|
||
|
||
except S3Error as e:
|
||
raise RuntimeError(f"从 MinIO 获取模型失败: {object_name} | {e}") from e
|
||
except Exception as e:
|
||
raise RuntimeError(f"加载模型失败: {object_name} | {e}") from e
|
||
|
||
# 处理 Scene 或单个 Mesh
|
||
if isinstance(mesh, trimesh.Scene):
|
||
vertices = np.vstack([geom.vertices for geom in mesh.geometry.values()])
|
||
else:
|
||
vertices = mesh.vertices
|
||
|
||
if len(vertices) == 0:
|
||
raise ValueError(f"模型中未找到顶点数据: {object_name}")
|
||
|
||
return vertices
|
||
|
||
|
||
async def create_single_task(input_data: Tripo3dApiModel):
|
||
"""
|
||
异步版本：创建单个图片转 3D 的任务
|
||
"""
|
||
server = Triop3dApiServer()
|
||
|
||
# Step 1: 上传图片（异步）
|
||
print(f"开始上传图片: {input_data.input_images[0]}")
|
||
logger.info(f"开始上传图片: {input_data.input_images[0]}")
|
||
|
||
file_token = await server.upload_image(
|
||
image_path=input_data.input_images[0],
|
||
request_timeout=input_data.request_timeout
|
||
)
|
||
print(f"✅ 图片上传成功，file_token: {file_token}")
|
||
logger.info(f"✅ 图片上传成功，file_token: {file_token}")
|
||
|
||
# Step 2: 构建请求 payload
|
||
file_ext = Path(input_data.input_images[0]).suffix.lower().lstrip('.') or "png"
|
||
if file_ext == "jpeg":
|
||
file_ext = "jpg"
|
||
|
||
input_payload = {
|
||
"type": "image_to_model",
|
||
"file": {
|
||
"type": file_ext,
|
||
"file_token": file_token,
|
||
}
|
||
}
|
||
|
||
# 合并用户传入的参数（Pydantic Model 转 dict）
|
||
payload = input_payload | input_data.model_dump(exclude_unset=True)
|
||
|
||
# Step 3: 提交任务（异步）
|
||
logger.info("正在提交 Tripo3D 任务...")
|
||
|
||
resp = await server.create_task(
|
||
payload=payload,
|
||
request_timeout=input_data.request_timeout
|
||
)
|
||
|
||
return resp
|
||
|
||
|
||
async def create_multi_task(input_data: Tripo3dApiModel):
|
||
"""
|
||
异步版本：创建多图转 3D 的任务
|
||
"""
|
||
server = Triop3dApiServer()
|
||
|
||
# Step 1: 上传多张图片（异步）
|
||
logger.info(f"开始上传 {len(input_data.input_images)} 张图片...")
|
||
print(f"开始上传 {len(input_data.input_images)} 张图片...")
|
||
file_tokens = await server.upload_images(
|
||
image_paths=input_data.input_images,
|
||
request_timeout=input_data.request_timeout
|
||
)
|
||
logger.info(f"✅ 图片上传完成，共 {len(file_tokens)} 个 token")
|
||
print(f"✅ 图片上传完成，共 {len(file_tokens)} 个 token")
|
||
|
||
# Step 2: 构建多图 payload
|
||
files = []
|
||
for image_path, file_token in zip(input_data.input_images, file_tokens):
|
||
file_ext = Path(image_path).suffix.lower().lstrip('.') or "png"
|
||
if file_ext == "jpeg":
|
||
file_ext = "jpg"
|
||
|
||
files.append({
|
||
"type": file_ext,
|
||
"file_token": file_token,
|
||
})
|
||
while len(files) < 4:
|
||
files.append({})
|
||
|
||
if len(files) > 4:
|
||
files = files[:4]
|
||
|
||
payload: Dict[str, Any] = {
|
||
"type": "multiview_to_model",
|
||
"model_version": input_data.model_version,
|
||
"files": files,
|
||
"face_limit": 2000,
|
||
"texture": input_data.texture,
|
||
"pbr": input_data.pbr,
|
||
}
|
||
# Step 3: 提交任务（异步）
|
||
logger.info(f"正在提交多图 Tripo3D 任务...{payload}")
|
||
print(f"正在提交多图 Tripo3D 任务...{payload}")
|
||
resp = await server.create_task(payload=payload, request_timeout=input_data.request_timeout)
|
||
|
||
return resp
|
||
|
||
|
||
async def get_task_result_async(input_data: Tripo3dApiModel, task_id: str, api_task_id: str, callback_url: str):
|
||
server = Triop3dApiServer()
|
||
task_resp = await server.poll_task(
|
||
task_id=api_task_id,
|
||
poll_interval=input_data.poll_interval,
|
||
poll_timeout=input_data.poll_timeout,
|
||
request_timeout=input_data.request_timeout,
|
||
callback_url=callback_url
|
||
)
|
||
outputs = await server.save_outputs(
|
||
task_resp=task_resp,
|
||
request_timeout=input_data.request_timeout,
|
||
bucket_name=input_data.bucket_name,
|
||
user_id=input_data.user_id
|
||
)
|
||
|
||
print(f"tripo3d 任务处理完成 | api_task_id: {api_task_id} | status: success")
|
||
logger.info(f"tripo3d 任务处理完成 | api_task_id: {api_task_id} | status: success")
|
||
await server.call_back_result(callback_url, outputs, task_id)
|
||
|
||
|
||
async def single_img_to_model_async(input_data: Tripo3dApiModel):
|
||
"""
|
||
完整的单图转 3D 异步流程
|
||
"""
|
||
try:
|
||
# Step 1: 创建任务
|
||
task_id = await create_single_task(input_data)
|
||
|
||
# Step 2: 轮询任务状态 + 处理输出 + 回调
|
||
await get_task_result_async(input_data, task_id, input_data.callback_url)
|
||
return task_id
|
||
|
||
except Exception as e:
|
||
logger.error(f"单图转 3D 任务失败 | error: {e}", exc_info=True)
|
||
# 可在此处调用失败回调
|
||
await notify_callback(
|
||
callback_url=input_data.callback_url,
|
||
task_id="unknown",
|
||
status="failed",
|
||
result={"error": str(e)}
|
||
)
|
||
raise
|
||
|
||
|
||
async def multi_img_to_model_async(input_data: Tripo3dApiModel):
|
||
"""
|
||
完整的多图转 3D 异步流程
|
||
"""
|
||
try:
|
||
# Step 1: 创建多图任务
|
||
task_id = await create_multi_task(input_data)
|
||
|
||
# Step 2: 轮询任务 + 处理输出 + 回调
|
||
await get_task_result_async(input_data, task_id, input_data.callback_url)
|
||
|
||
except Exception as e:
|
||
logger.error(f"多图转 3D 任务失败 | error: {e}", exc_info=True)
|
||
# 失败回调
|
||
await notify_callback(
|
||
callback_url=input_data.callback_url,
|
||
task_id="unknown",
|
||
status="failed",
|
||
result={"error": str(e)}
|
||
)
|
||
raise
|
||
|
||
|
||
if __name__ == '__main__':
|
||
# input_data = Tripo3dApiModel(input_images=['test/img_to_3d_data/example_multi_image/mushroom_1.png'], bucket_name='test', user_id='test', callback_url="http://18.167.251.121:10015/api/image/webhook/img-to-3d")
|
||
# asyncio.run(single_img_to_model_async(input_data))
|
||
input_data = Tripo3dApiModel(
|
||
input_images=['test/img_to_3d_data/example_multi_image/mushroom_3.png', 'test/img_to_3d_data/example_multi_image/mushroom_2.png', 'test/img_to_3d_data/example_multi_image/mushroom_1.png'],
|
||
bucket_name='test', user_id='test', callback_url="http://18.167.251.121:10015/api/image/webhook/img-to-3d",
|
||
face_limit=4000
|
||
)
|
||
asyncio.run(multi_img_to_model_async(input_data))
|