Quick Start: Scene Model

#!/usr/bin/env bash
set -euo pipefail

base="https://apis.viggle.ai/v1/scenes"
auth="Authorization: Bearer $VIGGLE_API_KEY"
session="quickstart-$(date +%s)"

submit() { # operation, JSON body -> task ID
  curl -sf -X POST "$base/$1" -H "$auth" -H "Content-Type: application/json" -d "$2" | jq -r '.id'
}

wait_ready() { # task ID -> ready task JSON
  for _ in $(seq 1 360); do
    task=$(curl -sf "$base/$1" -H "$auth")
    case "$(echo "$task" | jq -r '.status')" in
      ready) echo "$task"; return 0 ;;
      failed|cancelled) echo "Task $1 ended: $(echo "$task" | jq -c '.error')" >&2; return 1 ;;
    esac
    sleep 5
  done
  echo "Timed out waiting for $1" >&2
  return 1
}

# 1. Create the scene from a prompt.
task_id=$(submit pano "$(jq -n --arg s "$session" '{
  sessionId: $s,
  prompt: "A sunlit Scandinavian living room with a grey sofa and large windows",
  quality: "low"
}')")
pano=$(wait_ready "$task_id")
curl -s -o scene.spz "$(echo "$pano" | jq -r '.result.spz.url')"
curl -s -o panorama.png "$(echo "$pano" | jq -r '.result.panorama.url')"
initial=$(echo "$pano" | jq -r '.result.outputBatch.batchId')
echo "saved scene.spz and panorama.png; initial batch $initial"

# 2. Generate views from the first camera, moved 0.3 units along its x axis.
target=$(echo "$pano" | jq -c '.result.outputBatch.views[0].c2w | .[0][3] += 0.3')
task_id=$(submit generate "$(jq -n --arg s "$session" --arg b "$initial" --argjson c "$target" '{
  sessionId: $s, referenceBatchIds: [$b], targetC2w: $c
}')")
generated=$(wait_ready "$task_id" | jq -r '.result.outputBatch.batchId')
echo "generated batch $generated"

# 3. Reconstruct from both batches.
task_id=$(submit reconstruct "$(jq -n --arg s "$session" --arg a "$initial" --arg b "$generated" '{
  sessionId: $s, referenceBatchIds: [$a, $b]
}')")
curl -s -o scene-v2.spz "$(wait_ready "$task_id" | jq -r '.result.spz.url')"
echo "saved scene-v2.spz"

import { writeFile } from "node:fs/promises";

const baseUrl = "https://apis.viggle.ai/v1/scenes";
const headers = {
  Authorization: `Bearer ${process.env.VIGGLE_API_KEY}`,
  "Content-Type": "application/json",
};
const sessionId = `quickstart-${Date.now()}`;

async function api(path, body) {
  const response = await fetch(`${baseUrl}${path}`, {
    method: body ? "POST" : "GET",
    headers,
    body: body && JSON.stringify(body),
  });
  const json = await response.json().catch(() => ({}));
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${JSON.stringify(json.error ?? json)}`);
  }
  return json;
}

async function waitReady(task) {
  for (let i = 0; i < 360 && task.status === "processing"; i++) {
    await new Promise((resolve) => setTimeout(resolve, 5000));
    task = await api(`/${task.id}`);
  }
  if (task.status !== "ready") {
    throw new Error(`Task ${task.id} ended ${task.status}: ${JSON.stringify(task.error)}`);
  }
  return task.result;
}

async function download(url, path) {
  const response = await fetch(url);
  await writeFile(path, Buffer.from(await response.arrayBuffer()));
  console.log(`saved ${path}`);
}

// 1. Create the scene from a prompt.
const pano = await waitReady(await api("/pano", {
  sessionId,
  prompt: "A sunlit Scandinavian living room with a grey sofa and large windows",
  quality: "low",
}));
await download(pano.spz.url, "scene.spz");
await download(pano.panorama.url, "panorama.png");
const initial = pano.outputBatch.batchId;

// 2. Generate views from the first camera, moved 0.3 units along its x axis.
const targetC2w = structuredClone(pano.outputBatch.views[0].c2w);
targetC2w[0][3] += 0.3;
const generated = await waitReady(await api("/generate", {
  sessionId,
  referenceBatchIds: [initial],
  targetC2w,
}));
console.log(`generated ${generated.newViewCount} views in batch ${generated.outputBatch.batchId}`);

// 3. Reconstruct from both batches.
const rebuilt = await waitReady(await api("/reconstruct", {
  sessionId,
  referenceBatchIds: [initial, generated.outputBatch.batchId],
}));
await download(rebuilt.spz.url, "scene-v2.spz");

import copy
import os
import time
import requests

base_url = "https://apis.viggle.ai/v1/scenes"
headers = {"Authorization": f"Bearer {os.environ['VIGGLE_API_KEY']}"}
session_id = f"quickstart-{int(time.time())}"


def submit(operation, body):
    response = requests.post(f"{base_url}/{operation}", headers=headers, json=body)
    response.raise_for_status()
    return response.json()


def wait_ready(task):
    for _ in range(360):
        if task["status"] != "processing":
            break
        time.sleep(5)
        response = requests.get(f"{base_url}/{task['id']}", headers=headers)
        response.raise_for_status()
        task = response.json()
    if task["status"] != "ready":
        raise RuntimeError(f"Task {task['id']} ended {task['status']}: {task.get('error')}")
    return task["result"]


def download(url, path):
    response = requests.get(url)
    response.raise_for_status()
    with open(path, "wb") as f:
        f.write(response.content)
    print(f"saved {path}")


# 1. Create the scene from a prompt.
pano = wait_ready(submit("pano", {
    "sessionId": session_id,
    "prompt": "A sunlit Scandinavian living room with a grey sofa and large windows",
    "quality": "low",
}))
download(pano["spz"]["url"], "scene.spz")
download(pano["panorama"]["url"], "panorama.png")
initial = pano["outputBatch"]["batchId"]

# 2. Generate views from the first camera, moved 0.3 units along its x axis.
target_c2w = copy.deepcopy(pano["outputBatch"]["views"][0]["c2w"])
target_c2w[0][3] += 0.3
generated = wait_ready(submit("generate", {
    "sessionId": session_id,
    "referenceBatchIds": [initial],
    "targetC2w": target_c2w,
}))
print(f"generated {generated['newViewCount']} views in batch {generated['outputBatch']['batchId']}")

# 3. Reconstruct from both batches.
rebuilt = wait_ready(submit("reconstruct", {
    "sessionId": session_id,
    "referenceBatchIds": [initial, generated["outputBatch"]["batchId"]],
}))
download(rebuilt["spz"]["url"], "scene-v2.spz")