diff --git a/app.py b/app.py
index c433e0d61236e0cc039e1af99294f842ba480751..3378c2e4db9c84ab08deba5c05db1eda978778f2 100644
--- a/app.py
+++ b/app.py
@@ -2,8 +2,9 @@ import gradio as gr
 import numpy as np
 from PIL import Image
 import torch
+import os
+import tempfile
 
-# ====== 你的原有导入和模型加载保持不变 ======
 from paths import *
 from vision_tower import VGGT_OriAny_Ref
 from inference import *
@@ -81,37 +82,52 @@ def run_inference(image_ref, image_tgt, do_rm_bkg):
     ro = safe_float(ans_dict.get('ref_ro_pred', 0))
     alpha = int(ans_dict.get('ref_alpha_pred', 1))  # 注意：target 默认 alpha=1，但 ref 可能不是
 
-    # ===== 渲染参考图的坐标轴 =====
-    axis_renderer.render_axis(az, el, ro, alpha, save_path=REF_AXIS_IMAGE)
-    axis_ref = Image.open(REF_AXIS_IMAGE).convert("RGBA")
-
-    # 叠加坐标轴到参考图
-    # 确保尺寸一致
-    if axis_ref.size != pil_ref.size:
-        axis_ref = axis_ref.resize(pil_ref.size, Image.LANCZOS)
-    pil_ref_rgba = pil_ref.convert("RGBA")
-    overlaid_ref = Image.alpha_composite(pil_ref_rgba, axis_ref).convert("RGB")
-
-    # ===== 处理目标图（如果有）=====
-    if pil_tgt is not None:
-        rel_az = safe_float(ans_dict.get('rel_az_pred', 0))
-        rel_el = safe_float(ans_dict.get('rel_el_pred', 0))
-        rel_ro = safe_float(ans_dict.get('rel_ro_pred', 0))
-
-        tgt_azi, tgt_ele, tgt_rot = Get_target_azi_ele_rot(az, el, ro, rel_az, rel_el, rel_ro)
-        print("Target: Azi",tgt_azi,"Ele",tgt_ele,"Rot",tgt_rot)
-        
-        # target 默认 alpha=1（根据你的说明）
-        axis_renderer.render_axis(tgt_azi, tgt_ele, tgt_rot, alpha=1, save_path=TGT_AXIS_IMAGE)
-        axis_tgt = Image.open(TGT_AXIS_IMAGE).convert("RGBA")
-
-        if axis_tgt.size != pil_tgt.size:
-            axis_tgt = axis_tgt.resize(pil_tgt.size, Image.LANCZOS)
-        pil_tgt_rgba = pil_tgt.convert("RGBA")
-        overlaid_tgt = Image.alpha_composite(pil_tgt_rgba, axis_tgt).convert("RGB")
-    else:
-        overlaid_tgt = None
-        rel_az = rel_el = rel_ro = 0.0
+    # ===== 用临时文件保存渲染结果 =====
+    tmp_ref = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
+    tmp_tgt = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
+    tmp_ref.close()
+    tmp_tgt.close()
+
+    try:
+        # ===== 渲染参考图的坐标轴 =====
+        axis_renderer.render_axis(az, el, ro, alpha, save_path=tmp_ref.name)
+        axis_ref = Image.open(tmp_ref.name).convert("RGBA")
+
+        # 叠加坐标轴到参考图
+        # 确保尺寸一致
+        if axis_ref.size != pil_ref.size:
+            pil_ref = pil_ref.resize(axis_ref.size, Image.BICUBIC)
+        pil_ref_rgba = pil_ref.convert("RGBA")
+        overlaid_ref = Image.alpha_composite(pil_ref_rgba, axis_ref).convert("RGB")
+
+        # ===== 处理目标图（如果有）=====
+        if pil_tgt is not None:
+            rel_az = safe_float(ans_dict.get('rel_az_pred', 0))
+            rel_el = safe_float(ans_dict.get('rel_el_pred', 0))
+            rel_ro = safe_float(ans_dict.get('rel_ro_pred', 0))
+
+            tgt_azi, tgt_ele, tgt_rot = Get_target_azi_ele_rot(az, el, ro, rel_az, rel_el, rel_ro)
+            print("Target: Azi",tgt_azi,"Ele",tgt_ele,"Rot",tgt_rot)
+            
+            # target 默认 alpha=1（根据你的说明）
+            axis_renderer.render_axis(tgt_azi, tgt_ele, tgt_rot, alpha=1, save_path=tmp_tgt.name)
+            axis_tgt = Image.open(tmp_tgt.name).convert("RGBA")
+
+            if axis_tgt.size != pil_tgt.size:
+                pil_tgt = pil_tgt.resize(axis_tgt.size, Image.BICUBIC)
+            pil_tgt_rgba = pil_tgt.convert("RGBA")
+            overlaid_tgt = Image.alpha_composite(pil_tgt_rgba, axis_tgt).convert("RGB")
+        else:
+            overlaid_tgt = None
+            rel_az = rel_el = rel_ro = 0.0
+    finally:
+        # 安全删除临时文件（即使出错也清理）
+        if os.path.exists(tmp_ref.name):
+            os.remove(tmp_ref.name)
+            print('cleaned {}'.format(tmp_ref.name))
+        if os.path.exists(tmp_tgt.name):
+            os.remove(tmp_tgt.name)
+            print('cleaned {}'.format(tmp_tgt.name))
 
     return [
         overlaid_ref,  # 渲染+叠加后的参考图
@@ -153,6 +169,26 @@ with gr.Blocks(title="Orient-Anything Demo") as demo:
                 )
             rm_bkg = gr.Checkbox(label="Remove Background", value=True)
             run_btn = gr.Button("Run Inference", variant="primary")
+            # === 在这里插入示例 ===
+            with gr.Row():
+                gr.Examples(
+                    examples=[
+                        ["assets/examples/F35-0.jpg", "assets/examples/F35-1.jpg"],
+                        ["assets/examples/skateboard-0.jpg", "assets/examples/skateboard-1.jpg"],
+                    ],
+                    inputs=[ref_img, tgt_img],
+                    examples_per_page=2,
+                    label="Example Inputs (click to load)"
+                )
+                gr.Examples(
+                    examples=[
+                        ["assets/examples/table-0.jpg", "assets/examples/table-1.jpg"],
+                        ["assets/examples/bottle.jpg", None],
+                    ],
+                    inputs=[ref_img, tgt_img],
+                    examples_per_page=2,
+                    label=""
+                )
 
         # 右侧：结果图像 + 文本输出
         with gr.Column():
@@ -175,17 +211,17 @@ with gr.Blocks(title="Orient-Anything Demo") as demo:
                 
             # 文本输出放在图像下方
             with gr.Row():
-                with gr.Column(scale=1):
+                with gr.Column():
                     gr.Markdown("### Absolute Pose (Reference)")
-                    az_out = gr.Textbox(label="Azimuth (0~360°)",scale=0.5)
-                    el_out = gr.Textbox(label="Polar (-90~90°)",scale=0.5)
-                    ro_out = gr.Textbox(label="Rotation (-90~90°)",scale=0.5)
-                    alpha_out = gr.Textbox(label="Number of Directions (0/1/2/4)",scale=0.5)
-                with gr.Column(scale=1):
+                    az_out = gr.Textbox(label="Azimuth (0~360°)")
+                    el_out = gr.Textbox(label="Polar (-90~90°)")
+                    ro_out = gr.Textbox(label="Rotation (-90~90°)")
+                    alpha_out = gr.Textbox(label="Number of Directions (0/1/2/4)")
+                with gr.Column():
                     gr.Markdown("### Relative Pose (Target w.r.t Reference)")
-                    rel_az_out = gr.Textbox(label="Relative Azimuth (0~360°)",scale=0.5)
-                    rel_el_out = gr.Textbox(label="Relative Polar (-90~90°)",scale=0.5)
-                    rel_ro_out = gr.Textbox(label="Relative Rotation (-90~90°)",scale=0.5)
+                    rel_az_out = gr.Textbox(label="Relative Azimuth (0~360°)")
+                    rel_el_out = gr.Textbox(label="Relative Polar (-90~90°)")
+                    rel_ro_out = gr.Textbox(label="Relative Rotation (-90~90°)")
 
     # 绑定点击事件
     run_btn.click(
diff --git a/assets/axis_ref.png b/assets/axis_ref.png
deleted file mode 100644
index 595d29d663570f9b7aa9ddb5420fc48c24199284..0000000000000000000000000000000000000000
--- a/assets/axis_ref.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4ac0eb370f3d33fb8d6fc5c4e309b35f38a879d4a51e34ab490a35d39d09b1fa
-size 139793
diff --git a/assets/axis_tgt.png b/assets/axis_tgt.png
deleted file mode 100644
index bfb0108af3e564d4a17f415a083e0c9953694656..0000000000000000000000000000000000000000
--- a/assets/axis_tgt.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:39fb1b1e9ef7e16ff25c4d1d9df8fd53ec14f9e7006356db0609ab9c2ee9c048
-size 132931
diff --git a/assets/examples/F35-0.jpg b/assets/examples/F35-0.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..8df91489e944e6939cdc4355376ac0a013014de1
--- /dev/null
+++ b/assets/examples/F35-0.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5ed3bf9c7f42e2a0c97bceefdc677208219eb9d4b37db47cc389042da43c767
+size 39116
diff --git a/assets/examples/F35-1.jpg b/assets/examples/F35-1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..84047557bf065c714003f85ffb67bf14ca57854b
--- /dev/null
+++ b/assets/examples/F35-1.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aab7c7f484265dc8051e63c00bc3c8ba271bb1f84c3a9a206045b9d1f8e36b1c
+size 355430
diff --git a/assets/examples/bottle.jpg b/assets/examples/bottle.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..03db0bf5b97c75ed3a99940686c3ed35bb3bd9fb
--- /dev/null
+++ b/assets/examples/bottle.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a06e763afda918b0bbd5d5fe248e09b88bdeb72cd10c0343babf4eb14209a062
+size 20072
diff --git a/assets/examples/hat.jpg b/assets/examples/hat.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..0a031768c8ca7e511c51735d6a852500e56745b4
--- /dev/null
+++ b/assets/examples/hat.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fec959db7ee5ccad6cb20e74ffa68ef697bf0a1aa207ccc694b1faf29fccbcb
+size 131537
diff --git a/assets/examples/skateboard-0.jpg b/assets/examples/skateboard-0.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..ba032618ab858ea8f1ddf0ef1b2b9a33e66c5eb8
--- /dev/null
+++ b/assets/examples/skateboard-0.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f5783079542c8aec34b3ce041245f0e2050484c7fdabe7658cefa9fca05c078
+size 258377
diff --git a/assets/examples/skateboard-1.jpg b/assets/examples/skateboard-1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..0f71b73c2cc12415e149b480bb4fc939ef0ec673
--- /dev/null
+++ b/assets/examples/skateboard-1.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e88dbf8357d1d83960004e8a4723f5b9e4aee1a4eb4b3dc5384b75467019d576
+size 64998
diff --git a/assets/examples/table-0.jpg b/assets/examples/table-0.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..300d2198fb9eba5ea15690384cf9393c300a0d1b
--- /dev/null
+++ b/assets/examples/table-0.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9eee2a881ea0be52bf5381b0948a0eea9bb173b4982dbd5e867b95b2368e7031
+size 4806
diff --git a/assets/examples/table-1.jpg b/assets/examples/table-1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..9b54a0318746dac7af51f6850aaad5932dd13d1e
--- /dev/null
+++ b/assets/examples/table-1.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:590d5702941a56a3296f4c86cc7f8110ce8dae4b6103002ce0993cfb24b82489
+size 4595
diff --git a/inference.py b/inference.py
index c777e66d2f4e7bb31920ba5e02c95e2ee83ce615..29c20b27f89c81459334867534bd45aa6e0b3208 100644
--- a/inference.py
+++ b/inference.py
@@ -51,11 +51,11 @@ def val_fit_alpha(distribute):
         mu_fit, kappa_fit = saved_params[max_index]
         r_squared = saved_r_squared[max_index]
         
-        if alpha == 1. and kappa_fit>=0.5 and r_squared>=0.5:
+        if alpha == 1. and kappa_fit>=0.6 and r_squared>=0.45:
             pass
-        elif alpha == 2. and kappa_fit>=0.35 and r_squared>=0.35:
+        elif alpha == 2. and kappa_fit>=0.4 and r_squared>=0.45:
             pass
-        elif alpha == 4. and kappa_fit>=0.25 and r_squared>=0.25:
+        elif alpha == 4. and kappa_fit>=0.25 and r_squared>=0.45:
             pass
         else:
             alpha=0.
diff --git a/orianyV2_demo.ipynb b/orianyV2_demo.ipynb
deleted file mode 100644
index c39d2597f8020b9ee9683b3a68f2743218b6a872..0000000000000000000000000000000000000000
--- a/orianyV2_demo.ipynb
+++ /dev/null
@@ -1,492 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "load over\n"
-     ]
-    }
-   ],
-   "source": [
-    "import torch\n",
-    "from vision_tower import VGGT_OriAny_Ref\n",
-    "import os\n",
-    "from app_utils import *\n",
-    "from paths import *\n",
-    "\n",
-    "device = 'cuda:0'\n",
-    "\n",
-    "mark_dtype = torch.bfloat16 if torch.cuda.get_device_capability()[0] >= 8 else torch.float16\n",
-    "model = VGGT_OriAny_Ref(\n",
-    "                out_dim     = 900,\n",
-    "                dtype       = mark_dtype,\n",
-    "                nopretrain  = True\n",
-    "            )\n",
-    "\n",
-    "ckpt = torch.load(LOCAL_CKPT_PATH, map_location='cpu')\n",
-    "# ckpt = torch.load('verwoIN3D0.pt', map_location='cpu')\n",
-    "\n",
-    "model.load_state_dict(ckpt)\n",
-    "model.eval()\n",
-    "model = model.to(device)\n",
-    "image_root  = '/mnt/workspace/muang/repos/OriAnyV2_Train/demo/'\n",
-    "\n",
-    "print('load over')\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import rembg\n",
-    "from PIL import Image, ImageOps\n",
-    "from typing import Any, Optional, List, Dict, Union\n",
-    "from torchvision import transforms as TF\n",
-    "import torch.nn.functional as F\n",
-    "\n",
-    "rembg_session = rembg.new_session()\n",
-    "\n",
-    "def load_and_preprocess_images(image_path_list, mode=\"crop\"):\n",
-    "    \"\"\"\n",
-    "    A quick start function to load and preprocess images for model input.\n",
-    "    This assumes the images should have the same shape for easier batching, but our model can also work well with different shapes.\n",
-    "\n",
-    "    Args:\n",
-    "        image_path_list (list): List of paths to image files\n",
-    "        mode (str, optional): Preprocessing mode, either \"crop\" or \"pad\".\n",
-    "                             - \"crop\" (default): Sets width to 518px and center crops height if needed.\n",
-    "                             - \"pad\": Preserves all pixels by making the largest dimension 518px\n",
-    "                               and padding the smaller dimension to reach a square shape.\n",
-    "\n",
-    "    Returns:\n",
-    "        torch.Tensor: Batched tensor of preprocessed images with shape (N, 3, H, W)\n",
-    "\n",
-    "    Raises:\n",
-    "        ValueError: If the input list is empty or if mode is invalid\n",
-    "\n",
-    "    Notes:\n",
-    "        - Images with different dimensions will be padded with white (value=1.0)\n",
-    "        - A warning is printed when images have different shapes\n",
-    "        - When mode=\"crop\": The function ensures width=518px while maintaining aspect ratio\n",
-    "          and height is center-cropped if larger than 518px\n",
-    "        - When mode=\"pad\": The function ensures the largest dimension is 518px while maintaining aspect ratio\n",
-    "          and the smaller dimension is padded to reach a square shape (518x518)\n",
-    "        - Dimensions are adjusted to be divisible by 14 for compatibility with model requirements\n",
-    "    \"\"\"\n",
-    "    # Check for empty list\n",
-    "    if len(image_path_list) == 0:\n",
-    "        raise ValueError(\"At least 1 image is required\")\n",
-    "    \n",
-    "    # Validate mode\n",
-    "    if mode not in [\"crop\", \"pad\"]:\n",
-    "        raise ValueError(\"Mode must be either 'crop' or 'pad'\")\n",
-    "\n",
-    "    images = []\n",
-    "    shapes = set()\n",
-    "    to_tensor = TF.ToTensor()\n",
-    "    target_size = 518\n",
-    "\n",
-    "    # First process all images and collect their shapes\n",
-    "    for item in image_path_list:\n",
-    "        if isinstance(item, Image.Image):\n",
-    "            img = item  # 已经是 PIL Image，直接使用\n",
-    "        else:\n",
-    "            img = Image.open(item)  # 否则认为是路径，打开它\n",
-    "\n",
-    "        # If there's an alpha channel, blend onto white background:\n",
-    "        if img.mode == \"RGBA\":\n",
-    "            # Create white background\n",
-    "            background = Image.new(\"RGBA\", img.size, (255, 255, 255, 255))\n",
-    "            # Alpha composite onto the white background\n",
-    "            img = Image.alpha_composite(background, img)\n",
-    "\n",
-    "        # Now convert to \"RGB\" (this step assigns white for transparent areas)\n",
-    "        img = img.convert(\"RGB\")\n",
-    "\n",
-    "        width, height = img.size\n",
-    "        \n",
-    "        if mode == \"pad\":\n",
-    "            # Make the largest dimension 518px while maintaining aspect ratio\n",
-    "            if width >= height:\n",
-    "                new_width = target_size\n",
-    "                new_height = round(height * (new_width / width) / 14) * 14  # Make divisible by 14\n",
-    "            else:\n",
-    "                new_height = target_size\n",
-    "                new_width = round(width * (new_height / height) / 14) * 14  # Make divisible by 14\n",
-    "        else:  # mode == \"crop\"\n",
-    "            # Original behavior: set width to 518px\n",
-    "            new_width = target_size\n",
-    "            # Calculate height maintaining aspect ratio, divisible by 14\n",
-    "            new_height = round(height * (new_width / width) / 14) * 14\n",
-    "\n",
-    "        # Resize with new dimensions (width, height)\n",
-    "        img = img.resize((new_width, new_height), Image.Resampling.BICUBIC)\n",
-    "        img = to_tensor(img)  # Convert to tensor (0, 1)\n",
-    "\n",
-    "        # Center crop height if it's larger than 518 (only in crop mode)\n",
-    "        if mode == \"crop\" and new_height > target_size:\n",
-    "            start_y = (new_height - target_size) // 2\n",
-    "            img = img[:, start_y : start_y + target_size, :]\n",
-    "        \n",
-    "        # For pad mode, pad to make a square of target_size x target_size\n",
-    "        if mode == \"pad\":\n",
-    "            h_padding = target_size - img.shape[1]\n",
-    "            w_padding = target_size - img.shape[2]\n",
-    "            \n",
-    "            if h_padding > 0 or w_padding > 0:\n",
-    "                pad_top = h_padding // 2\n",
-    "                pad_bottom = h_padding - pad_top\n",
-    "                pad_left = w_padding // 2\n",
-    "                pad_right = w_padding - pad_left\n",
-    "                \n",
-    "                # Pad with white (value=1.0)\n",
-    "                img = torch.nn.functional.pad(\n",
-    "                    img, (pad_left, pad_right, pad_top, pad_bottom), mode=\"constant\", value=1.0\n",
-    "                )\n",
-    "\n",
-    "        shapes.add((img.shape[1], img.shape[2]))\n",
-    "        images.append(img)\n",
-    "\n",
-    "    # Check if we have different shapes\n",
-    "    # In theory our model can also work well with different shapes\n",
-    "    if len(shapes) > 1:\n",
-    "        print(f\"Warning: Found images with different shapes: {shapes}\")\n",
-    "        # Find maximum dimensions\n",
-    "        max_height = max(shape[0] for shape in shapes)\n",
-    "        max_width = max(shape[1] for shape in shapes)\n",
-    "\n",
-    "        # Pad images if necessary\n",
-    "        padded_images = []\n",
-    "        for img in images:\n",
-    "            h_padding = max_height - img.shape[1]\n",
-    "            w_padding = max_width - img.shape[2]\n",
-    "\n",
-    "            if h_padding > 0 or w_padding > 0:\n",
-    "                pad_top = h_padding // 2\n",
-    "                pad_bottom = h_padding - pad_top\n",
-    "                pad_left = w_padding // 2\n",
-    "                pad_right = w_padding - pad_left\n",
-    "\n",
-    "                img = torch.nn.functional.pad(\n",
-    "                    img, (pad_left, pad_right, pad_top, pad_bottom), mode=\"constant\", value=1.0\n",
-    "                )\n",
-    "            padded_images.append(img)\n",
-    "        images = padded_images\n",
-    "\n",
-    "    images = torch.stack(images)  # concatenate images\n",
-    "\n",
-    "    # Ensure correct shape when single image\n",
-    "    if len(image_path_list) == 1:\n",
-    "        # Verify shape is (1, C, H, W)\n",
-    "        if images.dim() == 3:\n",
-    "            images = images.unsqueeze(0)\n",
-    "\n",
-    "    return images\n",
-    "\n",
-    "def remove_background(image: Image, rembg_session: Any=None, force: bool = False, **rembg_kwargs) -> Image :\n",
-    "    do_remove = True\n",
-    "    if image.mode == 'RGBA' and image.getextrema()[3][0] < 255:\n",
-    "        do_remove = False\n",
-    "    do_remove = do_remove or force\n",
-    "    if do_remove:\n",
-    "        image = rembg.remove(image, session = rembg_session, **rembg_kwargs)\n",
-    "    return image\n",
-    "\n",
-    "\n",
-    "from scipy.special import i0\n",
-    "from scipy.optimize import curve_fit\n",
-    "from scipy.integrate import trapezoid\n",
-    "from functools import partial\n",
-    "\n",
-    "def von_mises_pdf_alpha_numpy(alpha, x, mu, kappa):\n",
-    "    normalization = 2 * np.pi\n",
-    "    pdf = np.exp(kappa * np.cos(alpha * (x - mu))) / normalization\n",
-    "    return pdf\n",
-    "\n",
-    "def val_fit_alpha(distribute):\n",
-    "    fit_alphas = []\n",
-    "    for y_noise in distribute:\n",
-    "        x = np.linspace(0, 2 * np.pi, 360)\n",
-    "        y_noise /= trapezoid(y_noise, x) + 1e-8\n",
-    "        \n",
-    "        initial_guess = [x[np.argmax(y_noise)], 1]\n",
-    "\n",
-    "        alphas = [1.0, 2.0, 4.0]\n",
-    "        saved_params = []\n",
-    "        saved_r_squared = []\n",
-    "\n",
-    "        for alpha in alphas:\n",
-    "            try:\n",
-    "                von_mises_pdf_alpha_partial = partial(von_mises_pdf_alpha_numpy, alpha)\n",
-    "                params, covariance = curve_fit(von_mises_pdf_alpha_partial, x, y_noise, p0=initial_guess)\n",
-    "\n",
-    "                residuals = y_noise - von_mises_pdf_alpha_partial(x, *params)\n",
-    "                ss_res = np.sum(residuals**2)\n",
-    "                ss_tot = np.sum((y_noise - np.mean(y_noise))**2)\n",
-    "                r_squared = 1 - (ss_res / (ss_tot+1e-8))\n",
-    "\n",
-    "                saved_params.append(params)\n",
-    "                saved_r_squared.append(r_squared)\n",
-    "                if r_squared > 0.8:\n",
-    "                    break\n",
-    "            except:\n",
-    "                saved_params.append((0.,0.))\n",
-    "                saved_r_squared.append(0.)\n",
-    "\n",
-    "        max_index = np.argmax(saved_r_squared)\n",
-    "        alpha = alphas[max_index]\n",
-    "        mu_fit, kappa_fit = saved_params[max_index]\n",
-    "        r_squared = saved_r_squared[max_index]\n",
-    "        \n",
-    "        print(alpha, mu_fit, kappa_fit, r_squared)\n",
-    "        if alpha == 1. and kappa_fit>=0.5 and r_squared>=0.5:\n",
-    "            pass\n",
-    "        elif alpha == 2. and kappa_fit>=0.35 and r_squared>=0.35:\n",
-    "            pass\n",
-    "        elif alpha == 4. and kappa_fit>=0.25 and r_squared>=0.25:\n",
-    "            pass\n",
-    "        else:\n",
-    "            alpha=0.\n",
-    "        fit_alphas.append(alpha)\n",
-    "    return torch.tensor(fit_alphas)\n",
-    "\n",
-    "@torch.no_grad()\n",
-    "def ref_single(ref_name, tgt_name, remove_bkg = True, softmax = False):\n",
-    "    ref_img = Image.open(ref_name)\n",
-    "    tgt_img = Image.open(tgt_name)\n",
-    "    if remove_bkg:\n",
-    "        ref_img = remove_background(ref_img, rembg_session, force=True)\n",
-    "        tgt_img = remove_background(tgt_img, rembg_session, force=True)\n",
-    "    \n",
-    "    batch_img_inputs = load_and_preprocess_images([ref_img, tgt_img], mode=\"pad\")\n",
-    "        \n",
-    "    batch_img_inputs = batch_img_inputs.unsqueeze(0).to(device)\n",
-    "    # print(batch_img_inputs.shape)\n",
-    "    B, S, C, H, W = batch_img_inputs.shape\n",
-    "    pose_enc = model(batch_img_inputs) # (B, S, D) S = 1\n",
-    "\n",
-    "    pose_enc = pose_enc.view(B*S, -1)\n",
-    "\n",
-    "    angle_az_pred = torch.argmax(pose_enc[:, 0:360]       , dim=-1)\n",
-    "    angle_el_pred = torch.argmax(pose_enc[:, 360:360+180] , dim=-1) - 90\n",
-    "    angle_ro_pred = torch.argmax(pose_enc[:, 360+180:360+180+360] , dim=-1) - 180\n",
-    "    if softmax:\n",
-    "        alpha_pred = val_fit_alpha(distribute = F.softmax(pose_enc[:, 0:360], dim=-1).cpu().float().numpy())\n",
-    "    else:\n",
-    "        alpha_pred = val_fit_alpha(distribute = F.sigmoid(pose_enc[:, 0:360]).cpu().float().numpy())\n",
-    "\n",
-    "    ori_az = (angle_az_pred.reshape(B,S)[:,0]).cpu().float().numpy()\n",
-    "    ori_el = (angle_el_pred.reshape(B,S)[:,0]).cpu().float().numpy()\n",
-    "    ori_ro = (angle_ro_pred.reshape(B,S)[:,0]).cpu().float().numpy()\n",
-    "    rel_az = (angle_az_pred.reshape(B,S)[:,1]).cpu().float().numpy()\n",
-    "    rel_el = (angle_el_pred.reshape(B,S)[:,1]).cpu().float().numpy()\n",
-    "    rel_ro = (angle_ro_pred.reshape(B,S)[:,1]).cpu().float().numpy()\n",
-    "    \n",
-    "    print('ori_az', ori_az)\n",
-    "    print('ori_el', ori_el)\n",
-    "    print('ori_ro', ori_ro)\n",
-    "    print('alpha' , alpha_pred)\n",
-    "    print('rel_az', rel_az)\n",
-    "    print('rel_el', rel_el)\n",
-    "    print('rel_ro', rel_ro)\n",
-    "    \n",
-    "    # return pose_enc\n",
-    "    \n",
-    "    return ori_az, ori_el, ori_ro, alpha_pred, rel_az, rel_el, rel_ro, pose_enc\n",
-    "\n",
-    "@torch.no_grad()\n",
-    "def ori_single(ref_name, remove_bkg = True, softmax=True):\n",
-    "    ref_img = Image.open(ref_name)\n",
-    "    if remove_bkg:\n",
-    "        ref_img = remove_background(ref_img, rembg_session, force=True)\n",
-    "\n",
-    "    batch_img_inputs = load_and_preprocess_images([ref_img], mode=\"pad\")\n",
-    "    \n",
-    "    batch_img_inputs = batch_img_inputs.unsqueeze(0).to(device)\n",
-    "    # print(batch_img_inputs.shape)\n",
-    "    B, S, C, H, W = batch_img_inputs.shape\n",
-    "    pose_enc = model(batch_img_inputs) # (B, S, D) S = 1\n",
-    "\n",
-    "    pose_enc = pose_enc.view(B*S, -1)\n",
-    "    gaus_az_pred   = pose_enc[:, 0:360]\n",
-    "    gaus_el_pred   = pose_enc[:, 360:360+180]\n",
-    "    gaus_ro_pred   = pose_enc[:, 360+180:360+180+360]\n",
-    "    \n",
-    "    \n",
-    "    if softmax:\n",
-    "        gaus_az_pred = F.relu(gaus_az_pred)\n",
-    "        gaus_el_pred = F.relu(gaus_el_pred)\n",
-    "        gaus_ro_pred = F.relu(gaus_ro_pred)\n",
-    "        gaus_az_pred = F.softmax(gaus_az_pred)\n",
-    "        gaus_el_pred = F.softmax(gaus_el_pred)\n",
-    "        gaus_ro_pred = F.softmax(gaus_ro_pred)\n",
-    "\n",
-    "    angle_az_pred = (torch.argmax(gaus_az_pred, dim=-1)).cpu().float().numpy()\n",
-    "    angle_el_pred = (torch.argmax(gaus_el_pred, dim=-1) - 90).cpu().float().numpy()\n",
-    "    angle_ro_pred = (torch.argmax(gaus_ro_pred, dim=-1) - 180).cpu().float().numpy()\n",
-    "\n",
-    "    alpha_pred = val_fit_alpha(distribute = F.sigmoid(gaus_az_pred).cpu().float().numpy())\n",
-    "    \n",
-    "    print('ori_az', angle_az_pred)\n",
-    "    print('ori_el', angle_el_pred)\n",
-    "    print('ori_ro', angle_ro_pred)\n",
-    "    print('alpha' , alpha_pred)\n",
-    "\n",
-    "    # return pose_enc\n",
-    "    return angle_az_pred, angle_el_pred, angle_ro_pred, alpha_pred, pose_enc"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "def vis_distribution(image_paths, dists, titles=None, save_path=None):\n",
-    "    dists = dists.cpu()\n",
-    "    n_samples = len(image_paths)\n",
-    "    \n",
-    "    # 创建子图：每行 2 列（img + plot），高度自适应\n",
-    "    fig, axes = plt.subplots(n_samples, 2, figsize=(10, 3 * n_samples))\n",
-    "    if n_samples == 1:\n",
-    "        axes = [axes]  # 统一维度\n",
-    "\n",
-    "    x = np.arange(360)  # 0 到 359\n",
-    "\n",
-    "    for row in range(n_samples):\n",
-    "        img_path = image_paths[row]\n",
-    "        ax_img = axes[row][0] if n_samples > 1 else axes[0][0]\n",
-    "        ax_plot = axes[row][1] if n_samples > 1 else axes[0][1]\n",
-    "\n",
-    "        # --- 显示图像 ---\n",
-    "        img = plt.imread(img_path)\n",
-    "        ax_img.imshow(img)\n",
-    "        ax_img.set_title(titles[row] if titles else f\"Image {row+1}\")\n",
-    "        ax_img.axis('on')  # 保留坐标轴（显示刻度和边框）\n",
-    "        ax_img.set_xticks([])\n",
-    "        ax_img.set_yticks([])\n",
-    "        # 可选：保留边框\n",
-    "        for spine in ax_img.spines.values():\n",
-    "            spine.set_linewidth(1.5)\n",
-    "            spine.set_color('black')\n",
-    "\n",
-    "        # --- 显示分布 ---\n",
-    "        ref_dis = dists[row][:360].float().numpy()\n",
-    "        ax_plot.plot(x, ref_dis, color='blue', linewidth=1.5)\n",
-    "\n",
-    "        ax_plot.set_title(f\"Azimuth {row+1}\")\n",
-    "        ax_plot.set_xlabel(\"Angle (degrees)\")\n",
-    "        ax_plot.set_ylabel(\"Value\")\n",
-    "        ax_plot.grid(True, alpha=0.3)\n",
-    "\n",
-    "    plt.tight_layout()\n",
-    "    if save_path != None:\n",
-    "        plt.savefig(save_path, format='jpg', dpi=300, bbox_inches='tight')\n",
-    "    plt.show()\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1.0 6.335738976087225 0.3758221538851055 0.46655786181987247\n",
-      "ori_az [349.]\n",
-      "ori_el [11.]\n",
-      "ori_ro [0.]\n",
-      "alpha tensor([0.])\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x300 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# image_paths = ['./test_demo/lion.jpg']\n",
-    "# image_paths = ['./test_demo/bowl.jpg']\n",
-    "# save_path = './test_demo_output/bowl.jpg'\n",
-    "# image_paths = ['./test_demo/coin2.jpg', './test_demo/coin3.jpg']\n",
-    "# image_paths = ['./test_demo/coin2.jpg']\n",
-    "# save_path = './test_demo_output/coin.jpg'\n",
-    "\n",
-    "# image_paths = ['./test_demo/F22-0.jpg', './test_demo/F22-1.jpg']\n",
-    "# save_path = './test_demo_output/F22.jpg'\n",
-    "\n",
-    "# image_paths = ['./test_demo/F22-1.jpg']\n",
-    "# save_path = './test_demo_output/F22.jpg'\n",
-    "\n",
-    "# image_paths = ['./test_demo/handbag6.jpg']\n",
-    "# save_path = './test_demo_output/handbag.jpg'\n",
-    "\n",
-    "# image_paths = ['./test_demo/bottle.jpg']\n",
-    "# save_path = './test_demo_output/bottle.jpg'\n",
-    "\n",
-    "image_paths = ['./test_demo/apple.jpg']\n",
-    "save_path = './test_demo_output/apple.jpg'\n",
-    "\n",
-    "# image_paths = ['./test_demo/pot.jpg', './test_demo/pot2.jpg']\n",
-    "# save_path = './test_demo_output/pot.jpg'\n",
-    "\n",
-    "if len(image_paths) == 1:\n",
-    "    ori_az, ori_el, ori_ro, alpha_pred, pose_enc = ori_single(image_paths[0], True, False)\n",
-    "    titles = [f'azi:{ori_az} ele:{ori_el} rot:{ori_ro} alpha:{alpha_pred}']\n",
-    "else:\n",
-    "    ori_az, ori_el, ori_ro, alpha_pred, rel_az, rel_el, rel_ro, pose_enc = ref_single(image_paths[0], image_paths[1], False, False)\n",
-    "    titles = [f'azi:{ori_az} ele:{ori_el} rot:{ori_ro} alpha:{alpha_pred}', f'azi:{rel_az} ele:{rel_el} rot:{rel_ro}']\n",
-    "\n",
-    "vis_distribution(image_paths, F.sigmoid(pose_enc), titles, save_path)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "OriAnyV2",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/paths.py b/paths.py
index 4b50f6c4299fd4229296c7fcab7572e17f868047..f72f48b7421140aa7d8a0cbd591445155fb3fa1a 100644
--- a/paths.py
+++ b/paths.py
@@ -7,10 +7,7 @@ VGGT_1B     = "facebook/VGGT-1B"
 
 ORIANY_V2 = "Viglong/OriAnyV2_ckpt"
 
-REMOTE_CKPT_PATH = "demo_ckpts/acc8mask20lowlr.pt"
-
+REMOTE_CKPT_PATH = "demo_ckpts/rotmod_realrotaug_best.pt"
 
 RENDER_FILE = "assets/axis_render.blend"
-REF_AXIS_IMAGE = "assets/axis_ref.png"
-TGT_AXIS_IMAGE = "assets/axis_tgt.png"