วิธีใช้ Tripo 3D API: คู่มือพัฒนาฉบับสมบูรณ์

ความสามารถในการสร้างโมเดล 3 มิติจากคำอธิบายที่เป็นข้อความหรือรูปภาพได้เปลี่ยนแปลงวิธีการที่นักพัฒนาสร้างแอปพลิเคชันสำหรับเกม, อีคอมเมิร์ซ, ความจริงเสมือน และการนำเสนอทางสถาปัตยกรรม Tripo 3D API นำเสนอวิธีที่ตรงไปตรงมาในการรวมการสร้างโมเดล 3 มิติที่ขับเคลื่อนด้วย AI เข้ากับแอปพลิเคชันของคุณ โดยไม่ต้องมีความเชี่ยวชาญด้านการสร้างโมเดล 3 มิติมากนัก

💡

ต้องการเครื่องมือทดสอบ API ที่ยอดเยี่ยมที่สร้าง เอกสารประกอบ API ที่สวยงาม หรือไม่?

ต้องการแพลตฟอร์มแบบครบวงจรสำหรับทีมพัฒนของคุณเพื่อทำงานร่วมกันด้วย ประสิทธิภาพสูงสุด หรือไม่?

Apidog ตอบสนองความต้องการทั้งหมดของคุณ และ แทนที่ Postman ด้วยราคาที่เข้าถึงได้มากกว่ามาก!

ปุ่ม

คู่มือนี้จะอธิบายทุกสิ่งที่คุณจำเป็นต้องรู้เพื่อใช้งาน Tripo 3D API ตั้งแต่การตั้งค่าเบื้องต้นไปจนถึงการใช้งานจริง

Tripo 3D API คืออะไร?

Tripo 3D API แปลงข้อความสั่ง (text prompts) หรือรูปภาพ 2 มิติ ให้เป็นโมเดล 3 มิติที่พร้อมใช้งานผ่านอัลกอริทึม AI ขั้นสูง บริการนี้จัดการกระบวนการ Machine Learning ที่ซับซ้อนเบื้องหลัง โดยเปิดเผยปลายทาง REST ที่เรียบง่ายซึ่งนักพัฒนาสามารถรวมเข้าด้วยกันได้ภายในไม่กี่นาที

คุณสามารถเข้าถึง Tripo 3D API ในราคาถูกได้ที่ Hypereal AI

แพลตฟอร์มนี้รองรับโหมดการสร้างหลักสามโหมด:

ข้อความเป็น 3 มิติ (Text-to-3D): สร้างโมเดลจากคำอธิบายภาษาธรรมชาติ
รูปภาพเป็น 3 มิติ (Image-to-3D): แปลงรูปภาพเดียวหรือหลายรูปภาพให้เป็นวัตถุ 3 มิติ
หลายมุมมองเป็น 3 มิติ (Multi-view to 3D): สร้างโมเดลที่มีความละเอียดสูงจากหลายมุมมองของรูปภาพ

โมเดลที่สร้างขึ้นสามารถส่งออกในรูปแบบมาตรฐาน เช่น GLB, GLTF, FBX และ OBJ ซึ่งทำให้เข้ากันได้กับซอฟต์แวร์ 3 มิติและเอ็นจิ้นเกมส่วนใหญ่

เริ่มต้นใช้งาน: การรับรองความถูกต้องและการตั้งค่า

ขั้นตอนที่ 1: สร้างคีย์ API ของคุณ

ก่อนที่จะเรียกใช้ API ใดๆ คุณต้องมีข้อมูลรับรองการรับรองความถูกต้อง:

เยี่ยมชมหน้าเอกสารประกอบแพลตฟอร์ม Tripo 3D

2. คลิก "Generate New API Key"

3. คัดลอกคีย์ของคุณทันที (เริ่มต้นด้วย tsk_)

4. จัดเก็บอย่างปลอดภัย คุณจะไม่สามารถเรียกคืนได้อีกหลังจากปิดหน้าต่าง

หมายเหตุด้านความปลอดภัย: อย่าเปิดเผยคีย์ API ในโค้ดฝั่งไคลเอ็นต์หรือที่เก็บสาธารณะ ใช้ตัวแปรสภาพแวดล้อมหรือบริการจัดการข้อมูลลับที่ปลอดภัย

ขั้นตอนที่ 2: ติดตั้ง Python SDK (ไม่บังคับ)

แม้ว่าคุณจะสามารถใช้ REST API ได้โดยตรงกับไคลเอ็นต์ HTTP ใดๆ แต่ Python SDK อย่างเป็นทางการช่วยให้การรวมระบบง่ายขึ้น:

pip install tripo3d

SDK จัดการการรับรองความถูกต้อง, การสำรวจงานแบบอะซิงโครนัส และการดาวน์โหลดไฟล์โดยอัตโนมัติ

ขั้นตอนที่ 3: ตรวจสอบการตั้งค่าของคุณ

ทดสอบการรับรองความถูกต้องของคุณด้วยคำขอ cURL พื้นฐานนี้:

export TRIPO_API_KEY="tsk_your_actual_key_here"

curl https://api.tripo3d.ai/v2/openapi/task \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${TRIPO_API_KEY}" \
  -d '{"type": "text_to_model", "prompt": "a simple wooden chair"}'

การตอบสนองที่สำเร็จจะส่งคืนรหัสงาน (task ID) ซึ่งบ่งชี้ว่าการรับรองความถูกต้องของคุณทำงานได้อย่างถูกต้อง

วิธีที่ 1: การสร้างโมเดล 3 มิติจากข้อความ

การใช้งานพื้นฐาน

การสร้าง 3 มิติจากข้อความจะแปลงคำอธิบายภาษาธรรมชาติให้เป็นวัตถุ 3 มิติ ซึ่งทำงานได้ดีสำหรับการสร้างสินทรัพย์จากคำอธิบายแนวคิด

ตัวอย่าง Python SDK:

import asyncio
from tripo3d import TripoClient, TaskStatus

async def generate_from_text():
    async with TripoClient(api_key="YOUR_API_KEY") as client:
        # ส่งงานสร้าง
        task_id = await client.text_to_model(
            prompt="a vintage leather armchair with wooden legs",
            negative_prompt="low quality, blurry, distorted",
            model_version="v2.5"
        )

        print(f"ส่งงานแล้ว: {task_id}")

        # รอให้เสร็จสิ้น
        task = await client.wait_for_task(task_id, verbose=True)

        # ดาวน์โหลดผลลัพธ์
        if task.status == TaskStatus.SUCCESS:
            files = await client.download_task_models(task, "./output")
            for model_type, path in files.items():
                print(f"ดาวน์โหลด {model_type}: {path}")
        else:
            print(f"งานล้มเหลว: {task.status}")

asyncio.run(generate_from_text())

ตัวอย่าง REST API:

curl -X POST https://api.tripo3d.ai/v2/openapi/task \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${TRIPO_API_KEY}" \
  -d '{
    "type": "text_to_model",
    "prompt": "a vintage leather armchair with wooden legs",
    "negative_prompt": "low quality, blurry, distorted",
    "model_version": "v2.5"
  }'

ทำความเข้าใจพารามิเตอร์

พารามิเตอร์	ประเภท	จำเป็น	คำอธิบาย
prompt	string	ใช่	คำอธิบายโดยละเอียดของโมเดล 3 มิติที่ต้องการ
negative_prompt	string	ไม่	ลักษณะที่ควรหลีกเลี่ยงในการสร้าง
model_version	string	ไม่	เวอร์ชัน API (ค่าเริ่มต้น: ล่าสุด)

เคล็ดลับการออกแบบข้อความสั่ง (Prompt Engineering)

ระบุวัสดุ สี และรูปร่างให้ชัดเจน
รวมคำอธิบายสไตล์ (สมจริง, การ์ตูน, โพลีกอนต่ำ)
อ้างอิงขนาดเมื่อเกี่ยวข้อง
เพิ่มการตั้งค่าแสงเพื่อการสร้างพื้นผิวที่ดีขึ้น

วิธีที่ 2: การสร้างโมเดล 3 มิติจากรูปภาพ

การแปลงรูปภาพเดียว

แปลงภาพถ่ายเดียวหรือภาพประกอบให้เป็นโมเดล 3 มิติ วิธีนี้ทำงานได้ดีที่สุดกับภาพที่ชัดเจน มีแสงสว่างเพียงพอที่แสดงวัตถุจากมุมที่ตรงไปตรงมา

ตัวอย่าง Python SDK:

import asyncio
from tripo3d import TripoClient, TaskStatus

async def generate_from_image():
    async with TripoClient(api_key="YOUR_API_KEY") as client:
        task_id = await client.image_to_model(
            image="./path/to/product-photo.jpg",
            texture_quality="high",
            auto_scale=True,
            face_limit=50000
        )

        print(f"กำลังประมวลผลรูปภาพ: {task_id}")

        task = await client.wait_for_task(task_id, verbose=True)

        if task.status == TaskStatus.SUCCESS:
            files = await client.download_task_models(task, "./models")
            print(f"บันทึกโมเดลไปที่: {files}")

asyncio.run(generate_from_image())

พารามิเตอร์ขั้นสูง

พารามิเตอร์	ประเภท	ค่าเริ่มต้น	คำอธิบาย
texture_seed	integer	สุ่ม	ค่า Seed สำหรับการสร้างพื้นผิวที่ทำซ้ำได้
auto_scale	boolean	เท็จ	ปรับขนาดโมเดลให้เป็นขนาดจริง
quad	boolean	เท็จ	สร้างตาข่ายสี่เหลี่ยม (+$0.05 ต่องาน)
texture_quality	string	"original_image"	ลำดับความสำคัญในการจัดเรียงพื้นผิว
orientation	string	"default"	ตั้งค่าเป็น "align_image" สำหรับการหมุนอัตโนมัติ
face_limit	integer	ปรับเปลี่ยนได้	ควบคุมจำนวนโพลีกอนเพื่อการปรับแต่ง

การสร้างจากหลายมุมมอง

เพื่อให้ได้ผลลัพธ์ที่มีคุณภาพสูงขึ้น ให้ระบุมุมมองหลายมุมของวัตถุเดียวกัน:

async def generate_from_multiview():
    async with TripoClient(api_key="YOUR_API_KEY") as client:
        task_id = await client.multiview_to_model(
            images=[
                "./front-view.jpg",
                "./side-view.jpg",
                "./top-view.jpg"
            ],
            texture_quality="high"
        )

        task = await client.wait_for_task(task_id, verbose=True)

        if task.status == TaskStatus.SUCCESS:
            files = await client.download_task_models(task, "./output")

การสร้างจากหลายมุมมองให้รูปทรงเรขาคณิตและรายละเอียดพื้นผิวที่ดีกว่าการแปลงจากรูปภาพเดียวอย่างเห็นได้ชัด

ทำความเข้าใจสถานะงานและการสำรวจ

Tripo 3D API ประมวลผลคำขอแบบอะซิงโครนัส หลังจากส่งงานแล้ว คุณจะทำการสำรวจเพื่อรอการเสร็จสิ้น แทนที่จะบล็อก

วงจรชีวิตของงาน

Submitted (ส่งแล้ว): งานได้รับการยอมรับและเข้าคิวแล้ว
Processing (กำลังประมวลผล): โมเดล AI กำลังสร้างผลลัพธ์ 3 มิติ
Success (สำเร็จ): โมเดลพร้อมสำหรับการดาวน์โหลด
Failed (ล้มเหลว): การสร้างเกิดข้อผิดพลาด

การสำรวจด้วยตนเอง (REST API)

curl https://api.tripo3d.ai/v2/openapi/task/{task_id} \
  -H "Authorization: Bearer ${TRIPO_API_KEY}"

โครงสร้างการตอบสนอง:

{
  "code": 0,
  "data": {
    "task_id": "abc123",
    "status": "success",
    "output": {
      "model": "https://download-url/model.glb",
      "pbr_model": "https://download-url/model-pbr.glb"
    }
  }
}

การสำรวจอัตโนมัติ (Python SDK)

SDK จัดการการสำรวจโดยอัตโนมัติ:

task = await client.wait_for_task(
    task_id,
    verbose=True,  # แสดงการอัปเดตความคืบหน้า
    timeout=300    # เวลารอสูงสุดเป็นวินาที
)

ระบบราคาและเครดิต

Tripo ใช้โมเดลการกำหนดราคาแบบเครดิต ซึ่งการดำเนินการที่แตกต่างกันจะใช้เครดิตในปริมาณที่ต่างกัน

ระดับราคา

แผน	ราคา	เครดิตรายเดือน	งานที่ดำเนินการพร้อมกัน
Basic	ฟรี	300	1
Professional	$15.90/เดือน*	3,000	10
Advanced	$39.90/เดือน*	8,000	15

*การเรียกเก็บเงินรายปี: ส่วนลด 20% ($190.80/ปี สำหรับ Professional, $478.80/ปี สำหรับ Advanced)

ค่าใช้จ่ายเครดิต

Text-to-3D: ~30 เครดิตต่อการสร้างหนึ่งครั้ง
Image-to-3D: ~30-50 เครดิต ขึ้นอยู่กับการตั้งค่าคุณภาพ
Multi-view to 3D: ~60-80 เครดิต
Quad mesh output: เพิ่ม $0.05 (ประมาณ 5 เครดิต)

เคล็ดลับการเพิ่มประสิทธิภาพต้นทุน

ใช้ค่า `face_limit` ที่ต่ำกว่าสำหรับการสร้างตัวอย่าง
ทดสอบด้วยแผน Basic ก่อนที่จะขยายไปยังแผนแบบชำระเงิน
รวมคำขอที่คล้ายกันเพื่อเพิ่มขีดจำกัดงานพร้อมกันให้สูงสุด
แคชโมเดลที่สร้างขึ้นเพื่อหลีกเลี่ยงการสร้างสินทรัพย์ที่เหมือนกันซ้ำ

การจัดการข้อผิดพลาดและแนวทางปฏิบัติที่ดีที่สุด

จัดการข้อผิดพลาด API อย่างเหมาะสม

from tripo3d import TripoClient, TripoAPIError

async def safe_generation():
    try:
        async with TripoClient(api_key="YOUR_API_KEY") as client:
            task_id = await client.text_to_model(
                prompt="a detailed spaceship"
            )
            task = await client.wait_for_task(task_id)

            if task.status == TaskStatus.SUCCESS:
                files = await client.download_task_models(task, "./output")
                return files
            else:
                print(f"การสร้างล้มเหลว: {task.status}")
                return None

    except TripoAPIError as e:
        if e.status_code == 401:
            print("การรับรองความถูกต้องล้มเหลว ตรวจสอบคีย์ API ของคุณ")
        elif e.status_code == 429:
            print("เกินขีดจำกัดอัตราการร้องขอ โปรดรอสักครู่ก่อนลองใหม่")
        elif e.status_code >= 500:
            print("ข้อผิดพลาดเซิร์ฟเวอร์ ลองใหม่หลังจากล่าช้า")
        else:
            print(f"ข้อผิดพลาด API: {e}")
        return None

แนวทางปฏิบัติที่ดีที่สุดสำหรับการผลิต

ใช้ตรรกะการลองใหม่ (retry logic) สำหรับความล้มเหลวชั่วคราว (ข้อผิดพลาดระดับ 500)
ตั้งค่าการหมดเวลาที่เหมาะสมตามความซับซ้อนของงาน
ตรวจสอบการใช้เครดิตเพื่อป้องกันการหยุดชะงักของบริการ
ตรวจสอบความถูกต้องของข้อมูลก่อนส่งการดำเนินการที่ใช้ทรัพยากรมาก
จัดเก็บรหัสงาน (task IDs) สำหรับการดีบักและการตรวจสอบ
ใช้ Webhooks (หากมี) แทนการสำรวจอย่างรุนแรง (aggressive polling)

การจำกัดอัตราการร้องขอ (Rate Limiting)

เคารพขีดจำกัดงานพร้อมกันตามระดับแผนของคุณ การเกินขีดจำกัดจะส่งผลให้เกิดข้อผิดพลาด 429:

from asyncio import Semaphore

async def batch_generate(prompts, max_concurrent=10):
    semaphore = Semaphore(max_concurrent)

    async def generate_with_limit(prompt):
        async with semaphore:
            async with TripoClient(api_key="YOUR_API_KEY") as client:
                task_id = await client.text_to_model(prompt=prompt)
                return await client.wait_for_task(task_id)

    tasks = [generate_with_limit(p) for p in prompts]
    return await asyncio.gather(*tasks)

การรวมกับเฟรมเวิร์กยอดนิยม

เว็บแอปพลิเคชัน Flask

from flask import Flask, request, jsonify
from tripo3d import TripoClient
import asyncio

app = Flask(__name__)

@app.route('/generate-3d', methods=['POST'])
def generate_model():
    data = request.json
    prompt = data.get('prompt')

    if not prompt:
        return jsonify({'error': 'ต้องมีข้อความสั่ง'}), 400

    async def generate():
        async with TripoClient(api_key="YOUR_API_KEY") as client:
            task_id = await client.text_to_model(prompt=prompt)
            return {'task_id': task_id}

    result = asyncio.run(generate())
    return jsonify(result)

@app.route('/check-status/<task_id>')
def check_status(task_id):
    async def get_status():
        async with TripoClient(api_key="YOUR_API_KEY") as client:
            task = await client.get_task(task_id)
            return {'status': task.status}

    result = asyncio.run(get_status())
    return jsonify(result)

ตัวอย่าง Node.js Express

const express = require('express');
const axios = require('axios');
const app = express();

app.post('/generate', async (req, res) => {
  const { prompt } = req.body;

  try {
    const response = await axios.post(
      'https://api.tripo3d.ai/v2/openapi/task',
      {
        type: 'text_to_model',
        prompt: prompt
      },
      {
        headers: {
          'Authorization': `Bearer ${process.env.TRIPO_API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );

    res.json({ task_id: response.data.data.task_id });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

การจัดการการรวม API ด้วย Apidog

แอปพลิเคชันที่ซับซ้อนมักจะรวม API หลายตัวพร้อมกัน การจัดการการรับรองความถูกต้อง การทดสอบปลายทาง และการตรวจสอบประสิทธิภาพในบริการต่างๆ กลายเป็นเรื่องที่ท้าทาย

Apidog ให้การจัดการ API แบบครบวงจรสำหรับนักพัฒนาที่ทำงานกับ Tripo 3D API และบริการอื่นๆ:

คุณสมบัติหลัก:

ตัวสร้างคำขอแบบภาพ (Visual request builder): สร้างการเรียกใช้ API โดยไม่ต้องจัดรูปแบบ JSON ด้วยตนเอง
การจัดการสภาพแวดล้อม (Environment management): สลับระหว่างข้อมูลรับรองการพัฒนา, การจัดเตรียม (staging) และการผลิต
การทดสอบอัตโนมัติ (Automated testing): ตรวจสอบการตอบสนองและแก้ไขปัญหาการรวมระบบตั้งแต่เนิ่นๆ
การทำงานร่วมกันเป็นทีม (Team collaboration): แชร์คอลเลกชัน API และเอกสารประกอบกับนักพัฒนา
การตรวจสอบประสิทธิภาพ (Performance monitoring): ติดตามเวลาตอบสนองและอัตราข้อผิดพลาดในทุกปลายทาง

นำเข้าคำขอ Tripo 3D API ของคุณไปยัง Apidog บันทึกเป็นเทมเพลต และดำเนินการด้วยการคลิกเพียงครั้งเดียว ตรวจสอบรูปแบบการใช้เครดิตและระบุโอกาสในการเพิ่มประสิทธิภาพผ่านการวิเคราะห์ในตัว

ปุ่ม

สรุป

Tripo 3D API ขจัดอุปสรรคทางเทคนิคในการรวมการสร้างโมเดล 3 มิติที่ขับเคลื่อนด้วย AI เข้ากับแอปพลิเคชัน อินเทอร์เฟซ REST ที่ตรงไปตรงมาและ Python SDK อย่างเป็นทางการช่วยให้นักพัฒนาสามารถเพิ่มความสามารถ Text-to-3D และ Image-to-3D ได้ภายในไม่กี่ชั่วโมงแทนที่จะเป็นสัปดาห์

เริ่มต้นด้วยแผน Basic ฟรีเพื่อสร้างต้นแบบการรวมระบบของคุณ ทดสอบสไตล์ข้อความสั่งและอินพุตรูปภาพที่แตกต่างกันเพื่อทำความเข้าใจคุณภาพของผลลัพธ์ ตรวจสอบรูปแบบการใช้เครดิตก่อนที่จะตัดสินใจใช้แผนแบบชำระเงิน

โมเดลการประมวลผลแบบอะซิงโครนัสของแพลตฟอร์มปรับขนาดได้ดีสำหรับเวิร์คโหลดการผลิต ในขณะที่รูปแบบการส่งออกมาตรฐานช่วยให้มั่นใจถึงความเข้ากันได้กับไปป์ไลน์ 3 มิติและเอ็นจิ้นเกมที่มีอยู่