Datasets:

---

QingchuanMa

/

RoTA-Bench

Like 0

#!/usr/bin/env python3

from __future__ import annotations

import argparse

from datetime import datetime, timezone

import base64

import csv

import hashlib

import json

import math

import os

import pickle

import random

import re

import subprocess

import sys

import time

import platform

import zlib

from concurrent.futures import ThreadPoolExecutor

from pathlib import Path

from time import perf_counter

from typing import Any, Dict, List, Optional

try:

from tqdm import tqdm

except Exception:

def tqdm(iterable=None, **kwargs): # type: ignore

return iterable

try:

import numpy as np

except Exception:

np = None

try:

import cv2

except Exception:

cv2 = None

from llm_client import API_KEY, BASE_URL, DEFAULT_MODEL, chat_completions

from benchmark_core import (

ACTIONS,

Pose,

apply_action,

get_last_render_backend,

iou,

now_ms,

read_json,

render_views_fast,

resolve_paths,

write_json,

write_png_gray,

)

from render_protocol import (

RENDER_PARAMETER_SCHEMA,

STANDARD_DISPLAY_SIZE,

STANDARD_IMAGE_SIZE,

STANDARD_POINT_BATCH_SIZE,

STANDARD_PANEL_SEPARATOR,

STANDARD_PANEL_SEPARATOR_VALUE,

require_standard_square_size,

require_cuda_backend,

)

BASE_ACTIONS = [a for a in ACTIONS if a != "STOP"]

ALL_ACTIONS = BASE_ACTIONS + ["STOP"]

VALID_STEP_ANGLES = [30, 10, 5, 1]

PROMPT_PROFILES = ["baseline", "geometry_audit", "projection_first", "game_manual_plus"]

METRIC_FEEDBACK_MODES = ["full", "threshold", "none"]

METRIC_BLIND_SENTENCE = (

"The task ends automatically when the requirement is met. "

"If it continues, the current result has not yet met the requirement."

)

RENDER_SEMAPHORE_ENV = "PROJECTION_RENDER_SEMAPHORE"

RENDER_SEMAPHORE_COUNT_ENV = "PROJECTION_RENDER_SEMAPHORE_COUNT"

def render_views_limited(*args, **kwargs):

"""Serialize CUDA rendering across parallel task subprocesses on Windows."""

semaphore_name = os.environ.get(RENDER_SEMAPHORE_ENV, "").strip()

if not semaphore_name or os.name != "nt":

result = render_views_fast(*args, **kwargs)

require_cuda_backend(get_last_render_backend(), context="LLM benchmark")

return result

import ctypes

count = max(1, int(os.environ.get(RENDER_SEMAPHORE_COUNT_ENV, "1")))

kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)

kernel32.CreateSemaphoreW.restype = ctypes.c_void_p

kernel32.CreateSemaphoreW.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.c_long, ctypes.c_wchar_p]

kernel32.WaitForSingleObject.argtypes = [ctypes.c_void_p, ctypes.c_ulong]

kernel32.ReleaseSemaphore.argtypes = [ctypes.c_void_p, ctypes.c_long, ctypes.c_void_p]

kernel32.CloseHandle.argtypes = [ctypes.c_void_p]

handle = kernel32.CreateSemaphoreW(None, count, count, semaphore_name)

if not handle:

raise OSError(ctypes.get_last_error(), "CreateSemaphoreW failed")

try:

wait_result = kernel32.WaitForSingleObject(handle, 0xFFFFFFFF)

if wait_result != 0: