Upload folder using huggingface_hub

rebuild_manual/REBUILD.md

@@ -0,0 +1,39 @@
+# OVOW on H100-1 (CUDA 13.0 机器) 重建手册 2026-10-19
+
+## 位置
+- 仓库: ~/jiayin/OVOW (github.com/yisuanwang/OVOW)
+- conda: ~/miniconda3, 环境 ovow-opg / ovow-sam3 / ovow-motion
+- CUDA 工具链: ~/jiayin/cuda121 (nvcc 12.1 + cudart/cccl/cusparse 12.4 headers + cusolverDn.h 补丁)
+  与 ~/jiayin/cuda124 (12.4 全套, motion 用)
+- 权重: OVOW/ckpts (OnePoseViaGen 20G, hy3dgen 70G, moge 1.2G, sam3 3.4G 社区镜像 bodhicitta/sam3)
+- Qwen3-VL-8B 本地: OVOW/model/Qwen3-VL-8B-Instruct (魔搭下载)
+- EgoDex test: ~/jiayin/EgoDex/test (17.3G zip 解压, 源 ml-site.cdn-apple.com/datasets/egodex/test.zip)
+- Blender: ~/jiayin/opt/blender-4.2.3
+
+## 关键坑(按出现顺序)
+1. 根分区 / 100% 满 → TMPDIR/PIP_CACHE_DIR 全指到 ~/jiayin
+2. build_cuda_exts.sh 硬编码 /tmp/ovow_exts → 已 sed 成 $HOME/jiayin/tmp/ovow_exts
+3. pip 隔离构建环境无 torch/pybind11 → 全部 --no-build-isolation + 预装 ninja pybind11 editables hatchling
+4. nvcc 13.0 vs torch cu121/cu124 → conda 自建 cuda121/cuda124 前缀(所有包必须钉版本,不钉会混入 13.x)
+5. cusolverDn.h 无版本守卫引用 CUDA>=12.8 类型 → 补丁 #if CUDART_VERSION >= 12080 (见 patches/)
+6. 链接缺 -lcuda/-lnvrtc → libcuda.so 链到 /usr/local/cuda-13.0/lib64/stubs + cuda-nvrtc=12.1
+7. Hunyuan3D-2 仓库搬家 → tencent/Hunyuan3D-2 (原 Tencent-Hunyuan)
+8. sam3 gated → 社区镜像 bodhicitta/sam3 字节级一致
+9. custom_rasterizer 缺 C++ 内核 → 从 Tencent-Hunyuan/Hunyuan3D-2 sparse-checkout 补 lib/
+10. flex_gemm Autotuner 不兼容 triton 3.0.0 → 补丁去掉 do_bench 参数 (见 patches/)
+11. utils3d master 改名 intrinsics_from_fov_xy → 钉 c5daf6f6c244d251f252102d09e9b7bcef791a38
+12. 版本回钉: trimesh==4.5.3 (5.x 点云丢点), matplotlib==3.7.5 (cm.get_cmap), pycolmap==3.11.1,
+    transformers==4.57.1 (v5 要 torch>=2.6), rembg==2.0.57+onnxruntime-gpu (2.0.85 拖 numpy2),
+    numpy==1.26.4 全程守住
+13. mycpp cmake 缺 Boost → conda install boost-cpp + CMAKE_PREFIX_PATH 指向 conda 与 pybind11
+14. 运行时: 仓库根 ln -s ckpts checkpoints (引擎按 CWD 相对路径找权重); run_video 的 --out 要绝对路径;
+    --name 不能是纯数字(会被当 step 号); 视频软链会沿用目标 basename, 要 cp
+15. 视频链 Qwen 本地后端要 --qwen-label-category-mode legacy; ffmpeg conda 装进 opg env
+
+## 复现命令
+见 scripts/ (按编号顺序执行); verify_envs.sh 验证全部扩展 import。
+
+## 已验证产物
+- 单图链: outputs/image_pipeline_*/desk_banana/scene_anim_blender_physics_with_deform.glb
+- EgoDex 视频全 4D 链: outputs/egodex_p1/ws/egodex_case8_20261019_105538_*/video_pipeline_*/egodex_case8/
+  scene_anim_blender_physics_with_deform.glb + fullscene_deform_objseq_textured_left_rgb_right_split10_h264.mp4

rebuild_manual/env.example

@@ -0,0 +1,41 @@
+# OVOW 机器相关配置 —— 复制为 .env 并按你的机器填写。
+# configs/paths.sh 会自动 source 本file;其余路径默认装在 OVOW 仓库根下,无需改。
+
+# --- conda 各环境的 python 解释器 ---
+# 用 `bash environment/create_envs.sh` 建环境,结束时会打印这 3 个路径,粘贴过来即可。
+# (也可按将要创建的 env 路径预先填好;configure/setup 展开占位符前必须已填。)
+OPG_PY="$HOME/miniconda3/envs/ovow-opg/bin/python"
+SAM3_PY="$HOME/miniconda3/envs/ovow-sam3/bin/python"
+MOTION_PY="$HOME/miniconda3/envs/ovow-motion/bin/python"
+# 可选步骤(默认未启用)
+FLUX_PY="$HOME/miniconda3/envs/ovow-flux/bin/python"
+HDR_PY="$HOME/miniconda3/envs/ovow-hdr/bin/python"
+QWEN_PY="$OPG_PY"   # Qwen 标注走 API,用 opg 环境即可
+# ROMAV2_PY="$HOME/miniconda3/envs/ovow-romav2/bin/python"  # 可选:RoMaV2 scale-recovery 子进程独立 env(torch2.8);默认进程内(OPG_ROMAV2_INPROC=1),无需另建
+
+# --- Qwen 物体标注(step1)---
+# 默认走 DashScope API(下面二选一:直接写 key,或指向一个含 sk-... 的file)。
+# 没有 DashScope 账号?设 QWEN_BACKEND=local 走本地 Qwen3-VL(需 GPU 显存,
+# 图片链路默认自动从 HF 拉 Qwen/Qwen3-VL-8B-Instruct;也可用
+# masking/download_qwen3_vl_8b_hf_mirror.sh 预下载后以 --qwen-model 指定)。
+DASHSCOPE_API_KEY=""
+APIKEY_FILE=""
+QWEN_BACKEND="local"
+
+# --- 数据 / 输出(默认在仓库内 examples/ 与 outputs/,可改成你的目录)---
+# DATA_VIDEO="/path/to/your/videos"
+# DATA_IMAGE="/path/to/your/images"
+# OVOW_OUTPUTS="/path/to/outputs"
+# TORCH_HOME="/path/to/cache/torch"  # torch.hub cache; needs facebookresearch_dinov2_main for offline demos
+
+# --- 引擎与依赖位置(默认装在仓库根下;一般不用改)---
+# ENGINE_DIR="$OVOW_ROOT/engine"
+# CKPTS="$OVOW_ROOT/ckpts"
+
+# --- Blender(step 10/13/14/17/18 合成与渲染;硬依赖)---
+# 默认假设 `blender` 在 PATH 上;便携版填绝对路径,必要时补 lib 目录。
+BLENDER_BIN="$HOME/jiayin/opt/blender-4.2.3-linux-x64/blender"
+# BLENDER_LIB="/opt/blender-4.x/lib"
+
+# --- 默认 GPU ---
+OVOW_GPU="4"

rebuild_manual/patches/flex_gemm_autotuner_triton30.py

@@ -0,0 +1,408 @@
+import builtins
+from typing import *
+import os
+import json
+import importlib
+import pkgutil
+import torch
+import triton
+import time
+import inspect
+from filelock import FileLock
+from .. import (
+    AUTOSAVE_AUTOTUNE_CACHE,
+    AUTOTUNE_CACHE_PATH,
+)
+
+
+class TritonPersistentCacheAutotuner(triton.runtime.Autotuner):
+    def __init__(
+        self,
+        fn,
+        arg_names,
+        configs,
+        key,
+        reset_to_zero,
+        restore_value,
+        pre_hook=None,
+        post_hook=None,
+        prune_configs_by: Dict = None,
+        warmup=None,
+        rep=None,
+        use_cuda_graph=False,
+        do_bench=None,
+    ):
+        super().__init__(
+            fn,
+            arg_names,
+            configs,
+            key,
+            reset_to_zero,
+            restore_value,
+            pre_hook,
+            post_hook,
+            prune_configs_by,
+            warmup,
+            rep,
+            use_cuda_graph,
+        )
+
+    def run(self, *args, **kwargs):
+        self.nargs = dict(zip(self.arg_names, args))
+        used_cached_result = True
+        if len(self.configs) > 1:
+            all_args = {**self.nargs, **kwargs}
+            _args = {k: v for (k, v) in all_args.items() if k in self.arg_names}
+            key = [_args[key] for key in self.keys if key in _args]
+            for _, arg in _args.items():
+                if hasattr(arg, "dtype"):
+                    key.append(str(arg.dtype))
+            key = str(tuple(key))
+            if key not in self.cache:
+                # prune configs
+                used_cached_result = False
+                pruned_configs = self.prune_configs(kwargs)
+                bench_start = time.time()
+                timings = {config: self._bench(*args, config=config, **kwargs) for config in pruned_configs}
+                bench_end = time.time()
+                self.bench_time = bench_end - bench_start
+                self.cache[key] = builtins.min(timings, key=timings.get)
+                full_nargs = {**self.nargs, **kwargs, **self.cache[key].all_kwargs()}
+                self.pre_hook(full_nargs, reset_only=True)
+                self.configs_timings = timings
+            config = self.cache[key]
+        else:
+            config = self.configs[0]
+        self.best_config = config
+        if os.getenv("TRITON_PRINT_AUTOTUNING", None) == "1" and not used_cached_result:
+            print(f"Triton autotuning for function {self.base_fn.__name__} finished after "
+                  f"{self.bench_time:.2f}s; best config selected: {self.best_config};")
+        if AUTOSAVE_AUTOTUNE_CACHE and not used_cached_result:
+            save_autotune_cache()
+        if config.pre_hook is not None:
+            full_nargs = {**self.nargs, **kwargs, **config.all_kwargs()}
+            config.pre_hook(full_nargs)
+        ret = self.fn.run(
+            *args,
+            **kwargs,
+            **config.all_kwargs(),
+        )
+        self.nargs = None
+        return ret
+
+    def prune_configs(self, kwargs):
+        pruned_configs = self.configs
+        if self.early_config_prune:
+            pruned_configs = self.early_config_prune(self.configs, self.nargs, **kwargs)
+        if self.perf_model:
+            top_k = self.configs_top_k
+            if isinstance(top_k, float) and top_k <= 1.0:
+                top_k = int(len(self.configs) * top_k)
+            if len(pruned_configs) > top_k:
+                est_timing = {
+                    config: self.perf_model(
+                        **self.nargs,
+                        **kwargs,
+                        **config.all_kwargs(),
+                    )
+                    for config in pruned_configs
+                }
+                pruned_configs = sorted(est_timing.keys(), key=lambda x: est_timing[x])[:top_k]
+        return pruned_configs
+
+    def warmup(self, *args, **kwargs):
+        self.nargs = dict(zip(self.arg_names, args))
+        ret = []
+        for config in self.prune_configs(kwargs):
+            ret.append(self.fn.warmup(
+                *args,
+                **kwargs,
+                **config.all_kwargs(),
+            ))
+        self.nargs = None
+        return ret
+
+
+def triton_autotune(configs, key, prune_configs_by=None, reset_to_zero=None, restore_value=None, pre_hook=None, post_hook=None,
+             warmup=None, rep=None, use_cuda_graph=False, do_bench=None):
+    """
+    Decorator for auto-tuning a :code:`triton.jit`'d function.
+
+    .. highlight:: python
+    .. code-block:: python
+
+        @triton_autotune(configs=[
+            triton.Config(kwargs={'BLOCK_SIZE': 128}, num_warps=4),
+            triton.Config(kwargs={'BLOCK_SIZE': 1024}, num_warps=8),
+          ],
+          key=['x_size'] # the two above configs will be evaluated anytime
+                         # the value of x_size changes
+        )
+        @triton.jit
+        def kernel(x_ptr, x_size, **META):
+            BLOCK_SIZE = META['BLOCK_SIZE']
+    :note: When all the configurations are evaluated, the kernel will run multiple times.
+           This means that whatever value the kernel updates will be updated multiple times.
+           To avoid this undesired behavior, you can use the `reset_to_zero` argument, which
+           resets the value of the provided tensor to `zero` before running any configuration.
+
+    If the environment variable :code:`TRITON_PRINT_AUTOTUNING` is set to
+    :code:`"1"`, Triton will print a message to stdout after autotuning each
+    kernel, including the time spent autotuning and the best configuration.
+
+    :param configs: a list of :code:`triton.Config` objects
+    :type configs: list[triton.Config]
+    :param key: a list of argument names whose change in value will trigger the evaluation of all provided configs.
+    :type key: list[str]
+    :param prune_configs_by: a dict of functions that are used to prune configs, fields:
+        'perf_model': performance model used to predicate running time with different configs, returns running time
+        'top_k': number of configs to bench
+        'early_config_prune'(optional): a function used to do early prune (eg, num_stages). It takes configs:List[Config] as its input, and returns pruned configs.
+    :param reset_to_zero: a list of argument names whose value will be reset to zero before evaluating any configs.
+    :type reset_to_zero: list[str]
+    :param restore_value: a list of argument names whose value will be restored after evaluating any configs.
+    :type restore_value: list[str]
+    :param pre_hook: a function that will be called before the kernel is called.
+        This overrides the default pre_hook used for 'reset_to_zero' and 'restore_value'.
+        'kwargs': a dict of all arguments passed to the kernel.
+        'reset_only': a boolean indicating whether the pre_hook is called to reset the values only, without a corresponding post_hook.
+    :type pre_hook: lambda args, reset_only
+    :param post_hook: a function that will be called after the kernel is called.
+        This overrides the default post_hook used for 'restore_value'.
+        'kwargs': a dict of all arguments passed to the kernel.
+        'exception': the exception raised by the kernel in case of a compilation or runtime error.
+    :type post_hook: lambda args, exception
+    :param warmup: warmup time (in ms) to pass to benchmarking (deprecated).
+    :type warmup: int
+    :param rep: repetition time (in ms) to pass to benchmarking (deprecated).
+    :type rep: int
+    :param do_bench: a benchmark function to measure the time of each run.
+    :type do_bench: lambda fn, quantiles
+    """
+
+    def decorator(fn):
+        return TritonPersistentCacheAutotuner(
+            fn, fn.arg_names, configs, key, reset_to_zero, restore_value, pre_hook=pre_hook,
+            post_hook=post_hook, prune_configs_by=prune_configs_by, warmup=warmup, rep=rep,
+            use_cuda_graph=use_cuda_graph
+        )
+
+    return decorator
+
+
+class PersistentCacheAutoTuner:
+    def __init__(
+        self,
+        kernel,
+        configs=None,
+        key=None,
+        config_fn=None,
+        key_fn=None,
+        warmup=3,
+        runs=10,
+        verbose=False,
+    ):
+        """
+        AutoTuner is a wrapper class for a kernel that automatically tunes the kernel parameters to achieve the best performance.
+        
+        Args:
+            kernel: A callable object that takes in input arguments and returns the output.
+            configs: A list of Config objects that define the possible kernel parameters and their values.
+            key: A list of argument names that retune the kernel on change.
+            config_fn: A function that takes in the input arguments and returns configs to be used for autotuning.
+            key_fn: A function that takes in the input arguments and returns the key used to cache the tuning results.
+                    Once the key changes, the autotuning will be rerun.
+            warmup: The number of warmup runs to discard before measuring the execution time.
+            runs: The number of runs to measure the execution time.
+            verbose: Whether to print the autotuning results.
+        """
+        assert config_fn or configs, "Either configs or config_fn must be provided"
+        assert key_fn or key, "Either key or key_fn must be provided"
+        self.kernel = kernel
+        self.configs = configs
+        self.key = key
+        self.config_fn = config_fn
+        self.key_fn = key_fn
+        self.warmup = warmup
+        self.runs = runs
+        self.verbose = verbose or os.getenv('FLEX_GEMM_AUTOTUNER_VERBOSE', '0') == '1'
+        self.kernel_arg_names = inspect.getfullargspec(kernel).args
+        self.cache = {}
+        
+    def _args_to_kwargs(self, args, kwargs):
+        # Convert args to kwargs
+        arg_names = self.kernel_arg_names
+        arg_dict = dict(zip(arg_names, args))
+        arg_dict.update(kwargs)
+        return arg_dict
+    
+    def __call__(self, *args, **kwargs):
+        arg_dict = self._args_to_kwargs(args, kwargs)
+        
+        # Determine key
+        key = self.key_fn(*args, **kwargs) if self.key_fn else tuple(arg_dict[k] for k in self.key)
+        key = str(key)
+        
+        # If key changes, rerun autotune
+        used_cached_result = True
+        if key not in self.cache:
+            used_cached_result = False
+            if self.verbose:
+                print(f"Running autotuning for {self.kernel.__name__} with key {key}")
+            configs = self.configs if self.configs else self.config_fn(*args, **kwargs)
+            if self.verbose:
+                print(f"Configs: {configs}")
+            best_config = self._benchmark(args, kwargs, configs)
+            if self.verbose:
+                print(f"Best config for {self.kernel.__name__} with key {key}: {best_config}")
+            self.cache[key] = best_config
+            
+        if AUTOSAVE_AUTOTUNE_CACHE and not used_cached_result:
+            save_autotune_cache()
+        
+        # Run the kernel with the best config
+        return self.kernel(*args, **kwargs, **self.cache[key])
+    
+    def _benchmark(self, args, kwargs, configs):
+        best_time = float('inf')
+        best_config = None
+        
+        if len(configs) == 1:
+            best_config = configs[0]
+        else:
+            for config in configs:
+                # Run the kernel and measure execution time
+                for _ in range(self.warmup):
+                    self.kernel(*args, **kwargs, **config)
+                torch.cuda.synchronize()
+                start = time.time()
+                for _ in range(self.runs):
+                    self.kernel(*args, **kwargs, **config)
+                torch.cuda.synchronize()
+                elapsed = (time.time() - start) / self.runs
+                if self.verbose:
+                    print(f"Config {config}: {elapsed} seconds")
+                # Update the best config if the execution time is better
+                if elapsed < best_time:
+                    best_time = elapsed
+                    best_config = config
+        
+        return best_config
+    
+
+def autotune(
+    configs=None,
+    key=None,
+    config_fn=None,
+    key_fn=None,
+    warmup=3,
+    runs=10,
+    verbose=False
+):
+    def decorator(kernel):
+        return PersistentCacheAutoTuner(kernel, configs, key, config_fn, key_fn, warmup, runs, verbose)
+    return decorator
+
+
+def walk_package(package_name, fn):
+    try:
+        package = importlib.import_module(package_name)
+    except ModuleNotFoundError:
+        print(f"Package {package_name} not found.")
+        return
+
+    if not hasattr(package, '__path__'):
+        print(f"{package_name} is not a package.")
+        return
+
+    for _, module_name, is_pkg in pkgutil.iter_modules(package.__path__):
+        full_module_name = f"{package_name}.{module_name}"
+        if is_pkg:
+            walk_package(full_module_name, fn)
+        else:
+            fn(full_module_name)
+            
+
+def get_autotune_cache():
+    cache = {}
+    device_name = torch.cuda.get_device_name()
+    if device_name not in cache:
+        cache[device_name] = {}
+
+    def save_cache(full_module_name):
+        module = importlib.import_module(full_module_name)
+        for attr_name, attr in module.__dict__.items():
+            cache_key = f"{full_module_name}.{attr_name}"
+            if isinstance(attr, PersistentCacheAutoTuner):
+                cache[device_name][cache_key] = attr.cache
+            elif isinstance(attr, TritonPersistentCacheAutotuner):
+                cache[device_name][cache_key] = {k: v.__dict__ for k, v in attr.cache.items()}
+
+    walk_package('flex_gemm', save_cache)
+
+    return cache
+
+
+def save_autotune_cache(path=None):
+    path = path or AUTOTUNE_CACHE_PATH
+    lock_path = path + ".lock"
+
+    with FileLock(lock_path):
+        if os.path.exists(path):
+            with open(path, 'r') as f:
+                cache = json.load(f)
+        else:
+            cache = {}
+        # Merge existing cache with new cache
+        cache.update(get_autotune_cache())
+
+        tmp_path = path + ".tmp"
+        with open(tmp_path, 'w') as f:
+            json.dump(cache, f, indent=4)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp_path, path)
+
+
+def load_autotune_cache(path_or_cache=None):
+    cache = None
+
+    # Preserve path-based loading, but allow callers to provide a preloaded cache object.
+    if path_or_cache is None or isinstance(path_or_cache, (str, os.PathLike)):
+        path = path_or_cache or AUTOTUNE_CACHE_PATH
+        lock_path = path + ".lock"
+
+        if not os.path.exists(path):
+            return
+
+        with FileLock(lock_path):
+            with open(path, 'r') as f:
+                cache = json.load(f)
+    elif isinstance(path_or_cache, Mapping):
+        cache = path_or_cache
+    else:
+        raise TypeError("load_autotune_cache expects a path or a mapping")
+
+    if cache is None:
+        return
+
+    device_name = torch.cuda.get_device_name()
+    if device_name not in cache and "*" not in cache:
+        return
+    if "*" in cache and device_name not in cache:
+        device_name = "*"
+
+    def load_cache(full_module_name):
+        module = importlib.import_module(full_module_name)
+        for attr_name, attr in module.__dict__.items():
+            cache_key = f"{full_module_name}.{attr_name}"
+            if isinstance(attr, PersistentCacheAutoTuner):
+                if cache_key in cache[device_name]:
+                    attr.cache = cache[device_name][cache_key]
+            elif isinstance(attr, TritonPersistentCacheAutotuner):
+                if cache_key in cache[device_name]:
+                    for k, v in cache[device_name][cache_key].items():
+                        attr.cache[k] = triton.runtime.Config(None)
+                        attr.cache[k].__dict__.update(v)
+
+    walk_package('flex_gemm', load_cache)

rebuild_manual/scripts/fix_da3.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -uo pipefail
+source ~/miniconda3/etc/profile.d/conda.sh
+export TMPDIR=$HOME/jiayin/tmp PIP_CACHE_DIR=$HOME/jiayin/pipcache
+cd ~/jiayin/OVOW
+conda activate ovow-opg
+export CUDA_HOME=$HOME/jiayin/cuda121 PATH=$HOME/jiayin/cuda121/bin:$PATH
+export CPATH=$HOME/jiayin/cuda121/include:$CONDA_PREFIX/include:$CONDA_PREFIX/include/eigen3:${CPATH:-}
+pip install hatchling hatch-vcs editables
+pip install -e engine/oneposeviagen/DA3 --no-build-isolation && echo DA3_OK || echo FAIL_DA3
+conda deactivate; echo DONE

rebuild_manual/scripts/fix_envs.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -uo pipefail
+source ~/miniconda3/etc/profile.d/conda.sh
+export TMPDIR=$HOME/jiayin/tmp
+export PIP_CACHE_DIR=$HOME/jiayin/pipcache
+cd ~/jiayin/OVOW
+# motion 前置:先装 mesh_processor 来源包,再跑 requirements
+conda env list | grep -q '^ovow-motion ' && { conda activate ovow-motion; pip install -e third_party/Motion324/scripts/hy3dgen/texgen/differentiable_renderer; conda deactivate; }
+bash environment/create_envs.sh all

rebuild_manual/scripts/fix_envs3.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -uo pipefail
+source ~/miniconda3/etc/profile.d/conda.sh
+export TMPDIR=$HOME/jiayin/tmp PIP_CACHE_DIR=$HOME/jiayin/pipcache
+cd ~/jiayin/OVOW
+echo '=== opg: pre-build diso ==='
+conda activate ovow-opg
+pip install diso --no-build-isolation || pip install diso
+conda deactivate
+echo '=== motion: pybind11 + req without mesh_processor + editable ==='
+conda activate ovow-motion
+pip install pybind11
+grep -v '^mesh_processor==' environment/requirements-motion.txt > /tmp/req-motion-nm.txt
+pip install -r /tmp/req-motion-nm.txt
+pip install -e third_party/Motion324/scripts/hy3dgen/texgen/differentiable_renderer --no-build-isolation
+conda deactivate
+echo '=== rerun official create_envs ==='
+bash environment/create_envs.sh all

rebuild_manual/scripts/fix_envs4.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -uo pipefail
+source ~/miniconda3/etc/profile.d/conda.sh
+export TMPDIR=$HOME/jiayin/tmp PIP_CACHE_DIR=$HOME/jiayin/pipcache
+cd ~/jiayin/OVOW
+echo '=== toolchains ==='
+conda create -y -p $HOME/jiayin/cuda121 -c nvidia cuda-nvcc=12.1 cuda-cudart-dev=12.1 cuda-libraries-dev=12.1 > /dev/null 2>&1 || conda create -y -p $HOME/jiayin/cuda121 -c nvidia cuda-nvcc=12.1 cuda-cudart-dev=12.1
+conda create -y -p $HOME/jiayin/cuda124 -c nvidia cuda-nvcc=12.4 cuda-cudart-dev=12.4 cuda-libraries-dev=12.4 > /dev/null 2>&1 || conda create -y -p $HOME/jiayin/cuda124 -c nvidia cuda-nvcc=12.4 cuda-cudart-dev=12.4
+ls $HOME/jiayin/cuda121/bin/nvcc $HOME/jiayin/cuda124/bin/nvcc || exit 1
+echo '=== opg ==='
+conda activate ovow-opg
+export CUDA_HOME=$HOME/jiayin/cuda121 PATH=$HOME/jiayin/cuda121/bin:$PATH
+pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cu121
+pip install diso --no-build-isolation
+pip install pybind11
+conda deactivate
+echo '=== motion ==='
+conda activate ovow-motion
+export CUDA_HOME=$HOME/jiayin/cuda124 PATH=$HOME/jiayin/cuda124/bin:$PATH
+pip install torch==2.4.1+cu124 torchvision==0.19.1+cu124 --index-url https://download.pytorch.org/whl/cu124
+pip install pybind11
+pip install diso --no-build-isolation 2>/dev/null || true
+pip install -e third_party/Motion324/scripts/hy3dgen/texgen/differentiable_renderer --no-build-isolation
+pip install -e third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer --no-build-isolation
+grep -v '^mesh_processor==' environment/requirements-motion.txt > $HOME/jiayin/tmp/req-motion-nm.txt
+pip install -r $HOME/jiayin/tmp/req-motion-nm.txt
+conda deactivate
+echo '=== official scripts rerun ==='
+export CUDA_HOME=$HOME/jiayin/cuda121 PATH=$HOME/jiayin/cuda121/bin:$PATH
+bash environment/create_envs.sh opg
+bash environment/create_envs.sh motion

rebuild_manual/scripts/fix_envs5.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -uo pipefail
+source ~/miniconda3/etc/profile.d/conda.sh
+export TMPDIR=$HOME/jiayin/tmp PIP_CACHE_DIR=$HOME/jiayin/pipcache
+export CCPLUG=1
+CUDA_CCCL=$HOME/jiayin/cuda121/targets/x86_64-linux/include/cccl
+cd ~/jiayin/OVOW
+echo '=== opg ==='
+conda activate ovow-opg
+export CUDA_HOME=$HOME/jiayin/cuda121 PATH=$HOME/jiayin/cuda121/bin:$PATH CPATH=$HOME/jiayin/cuda121/include:${CPATH:-}
+pip install ninja
+pip install diso --no-build-isolation && echo DISO_OK
+pip install -r environment/requirements-opg.txt
+bash environment/build_cuda_exts.sh
+for p in Amodal3R fpose fpose/fpose/bundlesdf/mycuda SpaTrackerV2 trellis DA3 SAM2-in-video; do pip install -e engine/oneposeviagen/$p; done
+conda deactivate
+echo '=== motion ==='
+conda activate ovow-motion
+export CUDA_HOME=$HOME/jiayin/cuda124 PATH=$HOME/jiayin/cuda124/bin:$PATH CPATH=$HOME/jiayin/cuda124/include:${CPATH:-}
+pip install ninja
+pip install diso --no-build-isolation 2>&1 | tail -1
+pip install -e third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer --no-build-isolation && echo RASTER_OK
+pip install -r $HOME/jiayin/tmp/req-motion-nm.txt 2>&1 | tail -3
+conda deactivate
+echo DONE_ALL

rebuild_manual/scripts/fix_envs7.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -uo pipefail
+source ~/miniconda3/etc/profile.d/conda.sh
+export TMPDIR=$HOME/jiayin/tmp PIP_CACHE_DIR=$HOME/jiayin/pipcache
+T=$HOME/jiayin/tmp/ovow_exts
+cd ~/jiayin/OVOW
+echo '=== opg ==='
+conda activate ovow-opg
+export CUDA_HOME=$HOME/jiayin/cuda121 PATH=$HOME/jiayin/cuda121/bin:$PATH CPATH=$HOME/jiayin/cuda121/include:${CPATH:-}
+pip install ninja pybind11
+pip install kaolin==0.18.0 -f https://nvidia-kaolin.s3.us-east-2.amazonaws.com/torch-2.4.1_cu121.html && echo KAOLIN_OK
+pip install --no-deps pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/py311_cu121_pyt241/download.html && echo P3D_OK || pip install --no-build-isolation git+https://github.com/facebookresearch/pytorch3d.git
+pip install --no-build-isolation git+https://github.com/JeffreyXiang/diffoctreerast.git && echo DOR_OK
+pip install --no-build-isolation git+https://github.com/EasternJournalist/utils3d.git
+[ -d $T/mip-splatting ] || git clone https://github.com/autonomousvision/mip-splatting.git $T/mip-splatting
+pip install --no-build-isolation $T/mip-splatting/submodules/diff-gaussian-rasterization/ && echo DGR_OK
+pip install --no-build-isolation $T/mip-splatting/submodules/simple-knn/ && echo SK_OK
+for p in Amodal3R fpose fpose/fpose/bundlesdf/mycuda SpaTrackerV2 trellis DA3 SAM2-in-video; do pip install -e engine/oneposeviagen/$p --no-build-isolation || echo FAIL_$p; done
+pip install flash-attn --no-build-isolation || echo FAIL_flashattn
+pip install --no-build-isolation git+https://github.com/JeffreyXiang/CuMesh.git || echo FAIL_cumesh
+[ -d $T/nvdiffrec ] || git clone -b renderutils https://github.com/JeffreyXiang/nvdiffrec.git $T/nvdiffrec
+pip install --no-build-isolation $T/nvdiffrec || echo FAIL_nvdiffrec
+pip install --no-build-isolation -e engine/oneposeviagen/TRELLIS2/o-voxel || echo FAIL_ovoxel
+conda deactivate
+echo '=== motion ==='
+conda activate ovow-motion
+export CUDA_HOME=$HOME/jiayin/cuda124 PATH=$HOME/jiayin/cuda124/bin:$PATH CPATH=$HOME/jiayin/cuda124/include:${CPATH:-}
+pip install ninja pybind11
+pip show mesh_processor >/dev/null 2>&1 || pip install -e third_party/Motion324/scripts/hy3dgen/texgen/differentiable_renderer --no-build-isolation && echo DR_OK
+pip show custom_rasterizer >/dev/null 2>&1 || pip install -e third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer --no-build-isolation && echo RASTER_OK
+conda deactivate
+echo SEVEN_DONE

rebuild_manual/scripts/fix_envs8.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -uo pipefail
+source ~/miniconda3/etc/profile.d/conda.sh
+export TMPDIR=$HOME/jiayin/tmp PIP_CACHE_DIR=$HOME/jiayin/pipcache
+T=$HOME/jiayin/tmp/ovow_exts
+cd ~/jiayin/OVOW
+conda activate ovow-opg
+export CUDA_HOME=$HOME/jiayin/cuda121 PATH=$HOME/jiayin/cuda121/bin:$PATH
+export CPATH=$HOME/jiayin/cuda121/include:${CPATH:-}
+export CPATH=$CPATH
+pip install ninja pybind11
+pip install --no-build-isolation git+https://github.com/JeffreyXiang/CuMesh.git && echo CUMESH_OK
+for p in fpose fpose/fpose/bundlesdf/mycuda DA3 SAM2-in-video Amodal3R SpaTrackerV2 trellis; do pip install -e engine/oneposeviagen/$p --no-build-isolation && echo OK_$p || echo FAIL_$p; done
+pip install --no-build-isolation git+https://github.com/facebookresearch/pytorch3d.git && echo P3D_OK || echo FAIL_pytorch3d
+[ -d $T/nvdiffrec ] || git clone -b renderutils https://github.com/JeffreyXiang/nvdiffrec.git $T/nvdiffrec
+pip install --no-build-isolation $T/nvdiffrec && echo NVDIFFREC_OK || echo FAIL_nvdiffrec
+pip install --no-build-isolation -e engine/oneposeviagen/TRELLIS2/o-voxel && echo OVOXEL_OK || echo FAIL_ovoxel
+pip install flash-attn --no-build-isolation && echo FLASH_OK || echo FAIL_flashattn
+conda deactivate
+echo EIGHT_DONE

rebuild_manual/scripts/fix_last2.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -uo pipefail
+source ~/miniconda3/etc/profile.d/conda.sh
+export TMPDIR=$HOME/jiayin/tmp PIP_CACHE_DIR=$HOME/jiayin/pipcache
+cd ~/jiayin/OVOW
+conda activate ovow-opg
+export CUDA_HOME=$HOME/jiayin/cuda121 PATH=$HOME/jiayin/cuda121/bin:$PATH
+export CPATH=$HOME/jiayin/cuda121/include:$CONDA_PREFIX/include:$CONDA_PREFIX/include/eigen3:${CPATH:-}
+pip install -e engine/oneposeviagen/DA3 --no-build-isolation && echo DA3_OK || echo FAIL_DA3
+pip install -e engine/oneposeviagen/TRELLIS2/o-voxel --no-build-isolation && echo OVOXEL_OK || echo FAIL_ovoxel
+conda deactivate
+echo LAST_DONE

rebuild_manual/scripts/verify_envs.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+source ~/miniconda3/etc/profile.d/conda.sh
+conda activate ovow-opg
+export CUDA_HOME=$HOME/jiayin/cuda121
+python -c "
+import torch
+ok=[]
+for m in ['diso','pytorch3d','cumesh','flex_gemm','o_voxel','kaolin','flash_attn','diff_gaussian_rasterization','simple_knn','diffoctreerast','utils3d','lightglue','sam2']:
+    try:
+        __import__(m); ok.append(m+':OK')
+    except Exception as e:
+        ok.append(m+':FAIL '+str(e)[:60])
+print('\n'.join(ok))
+"
+python -c 'import da3; print("da3:OK")' 2>/dev/null || python -c 'import depth_anything_3; print("da3(pkg):OK")' 2>/dev/null || echo da3:IMPORT_NAME_UNKNOWN
+conda deactivate
+conda activate ovow-motion
+python -c 'import torch; import mesh_processor; print("motion mesh_processor:OK")'
+conda deactivate
+conda activate ovow-sam3
+python -c 'import sam3; print("sam3:OK")' 2>/dev/null || echo sam3:CHECK_NAME