更新代码

LICENSE

@@ -0,0 +1,47 @@
+Copyright (C) 2025 Apple Inc. All Rights Reserved.
+
+Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple
+Inc. ("Apple") in consideration of your agreement to the following
+terms, and your use, installation, modification or redistribution of
+this Apple software constitutes acceptance of these terms.  If you do
+not agree with these terms, please do not use, install, modify or
+redistribute this Apple software.
+
+In consideration of your agreement to abide by the following terms, and
+subject to these terms, Apple grants you a personal, non-exclusive
+license, under Apple's copyrights in this original Apple software (the
+"Apple Software"), to use, reproduce, modify and redistribute the Apple
+Software, with or without modifications, in source and/or binary forms;
+provided that if you redistribute the Apple Software in its entirety and
+without modifications, you must retain this notice and the following
+text and disclaimers in all such redistributions of the Apple Software.
+Neither the name, trademarks, service marks or logos of Apple Inc. may
+be used to endorse or promote products derived from the Apple Software
+without specific prior written permission from Apple.  Except as
+expressly stated in this notice, no other rights or licenses, express or
+implied, are granted by Apple herein, including but not limited to any
+patent rights that may be infringed by your derivative works or by other
+works in which the Apple Software may be incorporated.
+
+The Apple Software is provided by Apple on an "AS IS" basis.  APPLE
+MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
+THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
+OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
+
+IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
+MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
+AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
+STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+
+-------------------------------------------------------------------------------
+SOFTWARE DISTRIBUTED IN THIS REPOSITORY:
+
+This software includes a number of subcomponents with separate
+copyright notices and license terms - please see the file ACKNOWLEDGEMENTS.
+-------------------------------------------------------------------------------

README.md

@@ -0,0 +1,37 @@
+---
+library_name: onnxruntime
+tags:
+  - onnx
+  - sharp
+  - view-synthesis
+  - 3d-gaussian-splatting
+base_model: apple/Sharp
+---
+
+# SHARP — ONNX Exports (INT8)
+
+This repository provides ONNX exports of Apple’s **SHARP** model predictor, which outputs **NDC-space 3D Gaussians**.
+
+## Export to ONNX (INT8)
+
+Run the following command to export the model:
+
+```bash
+python export_onnx.py --int8
+````
+
+## Launch Web UI
+
+Start the web interface with:
+
+```bash
+python webui.py \
+  --host 0.0.0.0 \
+  --port 7860 \
+  --ssl_cert cert.pem \
+  --ssl_key key.pem
+```
+
+## Notes
+
+This project is for learning purposes. Please refer to the LICENSE for usage terms.

export_onnx.py

@@ -0,0 +1,259 @@
+import argparse
+import logging
+import os
+from pathlib import Path
+
+import warnings
+import torch
+from sharp.models import PredictorParams, create_predictor
+
+LOGGER = logging.getLogger(__name__)
+
+# 默认权重文件名
+DEFAULT_CHECKPOINT_NAME = "sharp_2572gikvuh.pt"
+MODEL_URL = f"https://ml-site.cdn-apple.com/models/sharp/{DEFAULT_CHECKPOINT_NAME}"
+
+def verify_model_precision(model_path: Path):
+    """
+    静态检测 ONNX 模型的权重数据类型分布，用于验证量化是否生效。
+    """
+    try:
+        import onnx
+        from collections import Counter
+        # 尝试加载模型，注意大模型可能带 .data 后缀
+        model = onnx.load(str(model_path))
+        # 统计所有初始化器（权重）的数据类型
+        # 在 ONNX 中，FLOAT=1, UINT8=2, INT8=3, FLOAT16=10, UINT4=27, INT4=28, FLOAT4=29
+        dtypes = [onnx.TensorProto.DataType.Name(i.data_type) for i in model.graph.initializer]
+        counter = Counter(dtypes)
+        
+        LOGGER.info(f"--- 权重类型分布报告 [{model_path.name}] ---")
+        for dtype, count in counter.items():
+            LOGGER.info(f" - {dtype}: {count} 个张量")
+        
+        # 计算文件大小并打印
+        file_size = os.path.getsize(model_path)
+        LOGGER.info(f" [文件信息] 路径: {model_path}")
+        LOGGER.info(f" [文件信息] 体积: {file_size / (1024*1024):.2f} MB")
+        LOGGER.info("------------------------------------------------")
+    except ImportError:
+        LOGGER.warning("未安装 'onnx' 模块，跳过权重精度验证。")
+    except Exception as e:
+        LOGGER.warning(f"验证模型精度时发生异常: {e}")
+
+def export_onnx(output_path: Path, checkpoint_path: str = None, internal_shape: int = 1536, is_fp16: bool = False):
+    device = torch.device("cpu")
+    
+    LOGGER.info("正在创建预测器模型...")
+    predictor = create_predictor(PredictorParams())
+    
+    # FP16 处理：将网络参数转为半精度，体积减半
+    if is_fp16:
+        LOGGER.info("正在将模型转换为 FP16 (半精度) 以直接将其缩减进单一 < 2GB 的文件中...")
+        predictor = predictor.half()
+    
+    if checkpoint_path is None:
+        torch_hub_checkpoints = Path(torch.hub.get_dir()) / "checkpoints"
+        search_paths = [
+            Path(DEFAULT_CHECKPOINT_NAME),
+            Path("data") / DEFAULT_CHECKPOINT_NAME,
+            torch_hub_checkpoints / DEFAULT_CHECKPOINT_NAME,
+        ]
+        
+        found_path = None
+        for p in search_paths:
+            if p.exists():
+                found_path = p
+                break
+        
+        if found_path:
+            LOGGER.info(f"在本地找到模型权重: {found_path}，加载本地权重...")
+            state_dict = torch.load(found_path, map_location="cpu", weights_only=True)
+        else:
+            state_dict = torch.hub.load_state_dict_from_url(MODEL_URL, progress=True, map_location="cpu")
+    else:
+        state_dict = torch.load(checkpoint_path, map_location="cpu", weights_only=True)
+        
+    predictor.load_state_dict(state_dict)
+    predictor.eval()
+    predictor.to(device)
+    
+    dummy_image = torch.randn(1, 3, internal_shape, internal_shape, device=device)
+    dummy_disparity = torch.tensor([1.0], device=device)
+    
+    if is_fp16:
+        dummy_image = dummy_image.half()
+        dummy_disparity = dummy_disparity.half()
+        
+    dummy_inputs = (dummy_image, dummy_disparity)
+    
+    LOGGER.info("正在导出为 ONNX 格式...")
+    torch.onnx.export(
+        predictor,
+        dummy_inputs,
+        str(output_path),
+        export_params=True,
+        opset_version=19,
+        do_constant_folding=True,
+        input_names=['image', 'disparity_factor'],
+        output_names=['mean_vectors', 'singular_values', 'quaternions', 'colors', 'opacities'],
+        keep_initializers_as_inputs=False,
+        dynamic_axes={k: {0: 'batch_size'} for k in ['image', 'disparity_factor', 'mean_vectors', 'singular_values', 'quaternions', 'colors', 'opacities']}
+    )
+    LOGGER.info(f"成功将全精度 ONNX 模型导出至: {output_path}")
+
+def main():
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+    parser = argparse.ArgumentParser(description="将 ML-SHARP 模型导出为多种精度的 ONNX 格式。")
+    parser.add_argument("--output", type=str, default="sharp.onnx", help="导出的基础 ONNX 模型保存路径。")
+    parser.add_argument("--checkpoint", type=str, default=None, help="本地 .pt 权重文件路径。")
+    parser.add_argument("--fp16", action="store_true", help="启用 FP16 半精度导出。")
+    parser.add_argument("--int8", action="store_true", help="应用动态 INT8 量化。")
+    parser.add_argument("--int4", action="store_true", help="应用真正的 INT4 重量级量化 (WOQ)。")
+    args = parser.parse_args()
+
+    # 如果启用了 FP16 模式且用户未指定 output，则重定向默认输出名
+    if args.fp16 and args.output == "sharp.onnx":
+        args.output = "sharp_fp16.onnx"
+        
+    output_path = Path(args.output)
+    is_quant_requested = args.int8 or args.int4
+    
+    if is_quant_requested and output_path.exists():
+        LOGGER.info(f"检测到基础模型 '{output_path}' 已存在，跳过导出并开始验证。")
+        verify_model_precision(output_path)
+    else:
+        export_onnx(output_path, args.checkpoint, is_fp16=args.fp16)
+        verify_model_precision(output_path)
+
+    if is_quant_requested:
+        try:
+            from onnxruntime.quantization import quantize_dynamic, QuantType
+            import onnx
+            from onnx import shape_inference
+        except ImportError:
+            LOGGER.error("缺失依赖项：请安装 onnx 和 onnxruntime。")
+            return
+
+        preprocessed_path = output_path.with_name(f"{output_path.stem}_pre.onnx")
+        if not preprocessed_path.exists():
+            LOGGER.info("正在将基础模型转换为外部数据格式 (已跳过导致崩溃的形状推导模式)...")
+            try:
+                model_raw = onnx.load(str(output_path))
+                onnx.save(
+                    model_raw, 
+                    str(preprocessed_path),
+                    save_as_external_data=True,
+                    all_tensors_to_one_file=True,
+                    location=preprocessed_path.name + ".data",
+                    size_threshold=1024,
+                    convert_attribute=True
+                )
+                model_source = preprocessed_path
+            except Exception as e:
+                LOGGER.warning(f"预分流模型保存失败: {e}")
+                model_source = output_path
+        else:
+            model_source = preprocessed_path
+
+        tasks = []
+        if args.int8: tasks.append("int8")
+        if args.int4: tasks.append("int4")
+
+        # 1. INT8 量化
+        int8_path = output_path.with_name(f"{output_path.stem}_int8.onnx")
+        if "int8" in tasks:
+            LOGGER.info("正在应用动态 INT8 量化...")
+            quantize_dynamic(str(model_source), str(int8_path), weight_type=QuantType.QUInt8)
+            verify_model_precision(int8_path)
+
+        # 2. INT4 重量级量化 (WOQ)
+        if "int4" in tasks:
+            LOGGER.info("正在准备进行真正的 INT4 权重压缩 (WOQ)...")
+            quantized_output = output_path.with_name(f"{output_path.stem}_int4.onnx")
+            
+            import onnxruntime.quantization as oq
+            import importlib
+            import pkgutil
+
+            # 优先尝试新版 Unified API
+            quantize_func = getattr(oq, "quantize", None)
+            WeightOnlyConfig = getattr(oq, "MatMulWeightOnlyQuantConfig", None)
+            
+            if quantize_func and WeightOnlyConfig:
+                LOGGER.info("[INT4] 使用 MatMulWeightOnlyQuantConfig 执行量化...")
+                try:
+                    model = onnx.load(str(model_source))
+                    config = WeightOnlyConfig(weight_type=getattr(QuantType, 'QInt4', QuantType.QUInt8))
+                    quantize_func(model, str(quantized_output), config)
+                    LOGGER.info(f"[INT4] Unified API 导出成功!")
+                    verify_model_precision(quantized_output)
+                    return
+                except Exception as e:
+                    LOGGER.warning(f"[INT4] Unified API 失败: {e}")
+
+            # Fallback 1: 尝试 Bnb4Quantizer
+            Bnb4Quantizer = None
+            try:
+                from onnxruntime.quantization.matmul_bnb4_quantizer import MatMulBnb4Quantizer
+                Bnb4Quantizer = MatMulBnb4Quantizer
+            except: pass
+
+            if Bnb4Quantizer:
+                LOGGER.info("[INT4] 使用 MatMulBnb4Quantizer (BnB 4-bit) 执行量化...")
+                try:
+                    import inspect
+                    model = onnx.load(str(model_source))
+                    sig = inspect.signature(Bnb4Quantizer.__init__)
+                    params = sig.parameters
+                    kwargs = {"model": model, "block_size": 32}
+                    if "quant_type" in params:
+                        kwargs["quant_type"] = 1
+                    
+                    q = Bnb4Quantizer(**kwargs)
+                    q.process()
+                    m = q.model.model if hasattr(q, 'model') and hasattr(q.model, 'model') else (q.model if hasattr(q, 'model') else q)
+                    LOGGER.info(f"正在保存单体 INT4 模型...")
+                    onnx.save(m, str(quantized_output))
+                    LOGGER.info(f"[INT4] BnB 导出成功!")
+                    verify_model_precision(quantized_output)
+                    return
+                except Exception as e:
+                    LOGGER.warning(f"[INT4] BnB 失败: {e}")
+
+            # Fallback 2: 暴力搜索兼容旧版 Class API
+            def search_legacy(pkg):
+                for attr in dir(pkg):
+                    low = attr.lower()
+                    if ("quantiz" in low or "quantis" in low) and ("4bit" in low or "nbit" in low or "weight" in low):
+                        return getattr(pkg, attr), pkg.__name__
+                if hasattr(pkg, "__path__"):
+                    for _, modname, _ in pkgutil.walk_packages(pkg.__path__, pkg.__name__ + "."):
+                        try:
+                            mod = importlib.import_module(modname)
+                            res, src = search_legacy(mod)
+                            if res: return res, src
+                        except: continue
+                return None, None
+
+            LegacyQuantizer, src = search_legacy(oq)
+            if LegacyQuantizer and (isinstance(LegacyQuantizer, type) or callable(LegacyQuantizer)):
+                LOGGER.info(f"[INT4] 找到量化类/函数: {src}.{LegacyQuantizer.__name__}")
+                try:
+                    model = onnx.load(str(model_source))
+                    if "Quantizer" in LegacyQuantizer.__name__:
+                        q = LegacyQuantizer(model, block_size=32, is_symmetric=True)
+                        q.process()
+                        m = q.model.model if hasattr(q, 'model') and hasattr(q.model, 'model') else (q.model if hasattr(q, 'model') else q)
+                        onnx.save(m, str(quantized_output))
+                    else:
+                        LegacyQuantizer(model, str(quantized_output), weight_type=QuantType.QInt4)
+                    LOGGER.info(f"[INT4] 导出成功!")
+                    verify_model_precision(quantized_output)
+                except Exception as e:
+                    LOGGER.error(f"[INT4] 执行失败: {e}")
+            else:
+                LOGGER.error(f"[INT4] 未找到有效量化器。所有属性: {dir(oq)}")
+
+if __name__ == "__main__":
+    main()

webui.py

@@ -0,0 +1,399 @@
+import warnings
+import gradio as gr
+import onnxruntime as ort
+import torch
+import torch.nn.functional as F
+import numpy as np
+import tempfile
+import os
+import time
+import logging
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.append(os.path.join(os.getcwd(), 'src'))
+
+from sharp.utils import io
+from sharp.utils.gaussians import Gaussians3D, save_ply, unproject_gaussians
+
+warnings.filterwarnings("ignore")
+logging.basicConfig(level=logging.INFO)
+LOGGER = logging.getLogger(__name__)
+
+SESSION = None
+CURRENT_MODEL_PATH = None
+
+def load_model(model_path):
+    global SESSION, CURRENT_MODEL_PATH
+    if SESSION is not None and CURRENT_MODEL_PATH == model_path:
+        return SESSION
+        
+    if not Path(model_path).exists():
+        LOGGER.error(f"Model file not found: {model_path}")
+        return None
+        
+    try:
+        LOGGER.info(f"Loading model: {model_path}...")
+        options = ort.SessionOptions()
+        options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        options.intra_op_num_threads = os.cpu_count() or 4
+        options.inter_op_num_threads = min(4, os.cpu_count() or 4)
+        options.enable_mem_pattern = True
+        options.enable_cpu_mem_arena = True
+        providers = ['CPUExecutionProvider']
+        
+        # Free old session memory if possible
+        if SESSION is not None:
+            del SESSION
+            
+        SESSION = ort.InferenceSession(model_path, sess_options=options, providers=providers)
+        CURRENT_MODEL_PATH = model_path
+        LOGGER.info(f"Model loaded successfully: {model_path}")
+        return SESSION
+    except Exception as e:
+        LOGGER.error(f"Failed to load model {model_path}: {e}")
+        return None
+
+def get_available_models():
+    models = list(Path('.').glob('*.onnx'))
+    return [str(m) for m in models]
+
+def process_image(image_filepath, opacity_threshold, downsample_rate):
+    if not image_filepath:
+        return None
+    if SESSION is None:
+        gr.Warning("Model not loaded. Using dummy processing or check console.")
+        return None
+        
+    start_time = time.perf_counter()
+    img, _, f_px = io.load_rgb(Path(image_filepath), auto_rotate=True, remove_alpha=True)
+    height, width = img.shape[:2]
+    image_pt = torch.from_numpy(img.copy()).float().permute(2, 0, 1) / 255.0
+    disparity_factor = torch.tensor([f_px / width]).float()
+    internal_shape = (1536, 1536)
+    image_resized_pt = F.interpolate(
+        image_pt[None], size=(internal_shape[1], internal_shape[0]), mode="bilinear", align_corners=True
+    )
+    model_inputs = SESSION.get_inputs()
+    if model_inputs[0].type == 'tensor(float16)':
+        image_resized_pt = image_resized_pt.half()
+        disparity_factor = disparity_factor.half()
+    inputs = {'image': image_resized_pt.numpy(), 'disparity_factor': disparity_factor.numpy()}
+    outputs = SESSION.run(None, inputs)
+    gaussians_ndc = Gaussians3D(
+        mean_vectors=torch.from_numpy(outputs[0]).float(),
+        singular_values=torch.from_numpy(outputs[1]).float(),
+        quaternions=torch.from_numpy(outputs[2]).float(),
+        colors=torch.from_numpy(outputs[3]).float(),
+        opacities=torch.from_numpy(outputs[4]).float()
+    )
+    mask = gaussians_ndc.opacities[0] > opacity_threshold
+    sampler = slice(0, None, int(downsample_rate))
+    def apply_mask_and_sampling(tensor):
+        return tensor[:, mask][:, sampler]
+    filtered_gaussians_ndc = Gaussians3D(
+        mean_vectors=apply_mask_and_sampling(gaussians_ndc.mean_vectors),
+        singular_values=apply_mask_and_sampling(gaussians_ndc.singular_values),
+        quaternions=apply_mask_and_sampling(gaussians_ndc.quaternions),
+        colors=apply_mask_and_sampling(gaussians_ndc.colors),
+        opacities=apply_mask_and_sampling(gaussians_ndc.opacities)
+    )
+    intrinsics = torch.tensor([
+        [f_px, 0, width / 2, 0],
+        [0, f_px, height / 2, 0],
+        [0, 0, 1, 0],
+        [0, 0, 0, 1],
+    ]).float()
+    intrinsics_resized = intrinsics.clone()
+    intrinsics_resized[0] *= internal_shape[0] / width
+    intrinsics_resized[1] *= internal_shape[1] / height
+    gaussians = unproject_gaussians(filtered_gaussians_ndc, torch.eye(4), intrinsics_resized, internal_shape)
+    out_dir = Path(tempfile.mkdtemp())
+    out_path = out_dir / "output.ply"
+    save_ply(gaussians, f_px, (height, width), out_path)
+    return str(out_path)
+
+custom_css = """
+body, .gradio-container {
+    background: radial-gradient(circle at top left, #0d0d12 0%, #000000 100%) !important;
+    color: #e0e0e0 !important;
+    font-family: 'Inter', system-ui, -apple-system, sans-serif !important;
+    margin: 0 !important;
+    padding: 0 !important;
+}
+.panel-box {
+    background: rgba(20, 20, 25, 0.8) !important;
+    backdrop-filter: blur(10px);
+    border: 1px solid rgba(255, 255, 255, 0.1) !important;
+    border-radius: 20px !important;
+    padding: 24px;
+    box-shadow: 0 8px 32px 0 rgba(0, 0, 0, 0.8);
+    transition: all 0.3s ease;
+    margin-bottom: 16px;
+}
+#spark-container {
+    width: 100%;
+    height: 70vh; /* Responsive height */
+    min-height: 400px;
+    max-height: 720px;
+    background: #000;
+    border-radius: 12px;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    position: relative;
+    overflow: hidden;
+}
+#generate-btn {
+    background: linear-gradient(135deg, #6366f1 0%, #a855f7 100%) !important;
+    color: white !important;
+    font-weight: 700 !important;
+    border-radius: 12px !important;
+    border: none !important;
+    margin-top: 10px;
+    padding: 16px 24px !important; /* Larger for touch */
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    font-size: 1.1rem !important;
+    transition: transform 0.2s, box-shadow 0.2s !important;
+}
+header h1 {
+    background: linear-gradient(to right, #fff, #a5a5a5);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    font-size: 2rem !important;
+    font-weight: 900 !important;
+    text-align: center;
+    margin: 20px 0 !important;
+}
+
+/* Mobile Optimizations */
+@media (max-width: 768px) {
+    .panel-box {
+        padding: 16px;
+        border-radius: 16px !important;
+    }
+    #spark-container {
+        height: 50vh; /* Shorter on mobile to leave room for controls */
+        min-height: 300px;
+    }
+    header h1 {
+        font-size: 1.5rem !important;
+    }
+    .gr-row {
+        flex-direction: column !important;
+    }
+    /* Make inputs full width on mobile */
+    .gr-form {
+        width: 100% !important;
+    }
+}
+"""
+
+head_content = """
+<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;700;900&display=swap" rel="stylesheet">
+<script type="importmap">
+  {
+    "imports": {
+      "three": "https://cdnjs.cloudflare.com/ajax/libs/three.js/0.178.0/three.module.js",
+      "@sparkjsdev/spark": "https://sparkjs.dev/releases/spark/0.1.10/spark.module.js"
+    }
+  }
+</script>
+<script type="module">
+  import * as THREE from "three";
+  import { OrbitControls } from "https://unpkg.com/three@0.178.0/examples/jsm/controls/OrbitControls.js";
+  import { SplatMesh } from "@sparkjsdev/spark";
+
+  let renderer, scene, camera, controls, splat, container;
+  let startTime, timerInterval;
+
+  window.initSpark = function() {
+    container = document.getElementById('spark-container');
+    if (!container || window.sparkInitialized) return;
+    scene = new THREE.Scene();
+    camera = new THREE.PerspectiveCamera(60, container.clientWidth / container.clientHeight, 0.1, 1000);
+    camera.position.set(0, 1, 4);
+    renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true, logarithmicDepthBuffer: true });
+    renderer.setSize(container.clientWidth, container.clientHeight);
+    renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+    container.appendChild(renderer.domElement);
+    controls = new OrbitControls(camera, renderer.domElement);
+    controls.enableDamping = true;
+    function animate() {
+      requestAnimationFrame(animate);
+      controls.update();
+      renderer.render(scene, camera);
+    }
+    animate();
+    window.addEventListener('resize', () => {
+      if (!container) return;
+      camera.aspect = container.clientWidth / container.clientHeight;
+      camera.updateProjectionMatrix();
+      renderer.setSize(container.clientWidth, container.clientHeight);
+    });
+    window.sparkInitialized = true;
+  };
+
+  window.loadSplat = async function(url) {
+    if (!window.sparkInitialized) window.initSpark();
+    if (splat) { scene.remove(splat); splat.dispose(); }
+    try {
+        splat = new SplatMesh({ url: url });
+        splat.rotation.x = Math.PI;
+        scene.add(splat);
+        setTimeout(window.focusModel, 500);
+    } catch (e) { console.error(e); }
+  };
+  
+  window.focusModel = function() {
+    if (!splat || !controls || !camera) return;
+    const box = new THREE.Box3();
+    let pointsFound = 0;
+    splat.traverse((obj) => {
+        if (obj.geometry && obj.geometry.attributes.position) {
+            const pos = obj.geometry.attributes.position;
+            const count = pos.count;
+            const step = Math.max(1, Math.floor(count / 5000)); 
+            for (let i = 0; i < count; i += step) {
+                const p = new THREE.Vector3(pos.getX(i), pos.getY(i), pos.getZ(i));
+                p.applyMatrix4(obj.matrixWorld);
+                box.expandByPoint(p);
+            }
+            pointsFound += count;
+        }
+    });
+    let center = new THREE.Vector3();
+    let size = new THREE.Vector3();
+    if (pointsFound === 0 || box.isEmpty()) { center.set(0, 1.5, -3); size.set(2, 2, 2); }
+    else { box.getCenter(center); box.getSize(size); }
+    const maxDim = Math.max(size.x, size.y, size.z);
+    const fovRad = camera.fov * (Math.PI / 180);
+    let distance = (maxDim / 2) / Math.tan(fovRad / 2) * 1.5;
+    controls.target.copy(center);
+    camera.position.set(center.x, center.y, center.z + distance);
+    controls.update();
+  };
+
+  function getBtn() {
+      return document.getElementById('generate-btn') || document.querySelector('#generate-btn button');
+  }
+
+  window.startTimer = function() {
+    const btn = getBtn();
+    if (!btn) return;
+    btn.disabled = true;
+    btn.style.opacity = "0.6";
+    btn.style.cursor = "wait";
+    startTime = Date.now();
+    timerInterval = setInterval(() => {
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        btn.innerText = `Generating... ${elapsed}s`;
+    }, 100);
+  };
+
+  window.stopTimer = function() {
+    if (timerInterval) {
+        clearInterval(timerInterval);
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        const btn = getBtn();
+        if (btn) btn.innerText = `Done in ${elapsed}s`;
+    }
+  };
+
+  window.resetBtn = function(hasImage) {
+    const btn = getBtn();
+    if (btn) {
+        btn.disabled = !hasImage;
+        btn.style.opacity = hasImage ? "1.0" : "0.5";
+        btn.style.cursor = hasImage ? "pointer" : "default";
+        btn.innerText = "Generate 3D Gaussians";
+    }
+    if (timerInterval) clearInterval(timerInterval);
+  };
+</script>
+"""
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", type=str, default="ml-sharp_int4.onnx")
+    parser.add_argument("--host", type=str, default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=7860)
+    parser.add_argument("--ssl_cert", type=str, default="cert.pem")
+    parser.add_argument("--ssl_key", type=str, default="key.pem")
+    args = parser.parse_args()
+    
+    # Pre-load initial model
+    load_model(args.model)
+    
+    # Define UI inside __main__ or pass args to it
+    with gr.Blocks(css=custom_css, theme=gr.themes.Default(), head=head_content, title="SHARP 3D Recon") as demo:
+        gr.HTML("<header><h1>SHARP 3D RECONSTRUCTION</h1></header>")
+        with gr.Row():
+            with gr.Column(scale=1):
+                with gr.Group(elem_classes="panel-box"):
+                    available_models = get_available_models()
+                    model_selector = gr.Dropdown(
+                        choices=available_models, 
+                        value=args.model if args.model in available_models else (available_models[0] if available_models else None),
+                        label="Select ONNX Model (Precision)",
+                        interactive=True
+                    )
+                    
+                    input_image = gr.Image(
+                        type="filepath", 
+                        label="Capture or Upload Image", 
+                        height=400,
+                        sources=["upload", "webcam"]
+                    )
+                    
+                    with gr.Accordion("Advanced Settings", open=False):
+                        opacity_val = gr.Slider(0.0, 1.0, value=0.0, label="Opacity Threshold")
+                        downsample_val = gr.Slider(1, 10, step=1, value=1, label="Downsample Rate")
+                    
+                    submit_btn = gr.Button("Generate 3D Gaussians", variant="primary", elem_id="generate-btn", interactive=False)
+                    
+                    gr.Markdown("Capture a photo from your phone or upload an image to start the real-time 3D conversion.")
+                    
+            with gr.Column(scale=2):
+                with gr.Group(elem_classes="panel-box"):
+                    gr.HTML("<div id='spark-container'></div>")
+                    output_file = gr.File(label="Output Model", visible=False)
+        
+        demo.load(fn=None, inputs=None, outputs=None, js="() => { setTimeout(window.initSpark, 500); window.resetBtn(false); }")
+        
+        model_selector.change(fn=load_model, inputs=[model_selector], outputs=None)
+        
+        input_image.change(fn=lambda x: x is not None, inputs=[input_image], outputs=None, js="(img) => { window.resetBtn(!!img); }")
+        
+        submit_btn.click(
+            fn=process_image, 
+            inputs=[input_image, opacity_val, downsample_val], 
+            outputs=[output_file],
+            js="(img, op, down) => { window.startTimer(); return [img, op, down]; }"
+        )
+        
+        input_image.upload(
+            fn=process_image,
+            inputs=[input_image, opacity_val, downsample_val],
+            outputs=[output_file],
+            js="(img, op, down) => { window.startTimer(); return [img, op, down]; }"
+        )
+        
+        output_file.change(
+            fn=None, 
+            inputs=[output_file], 
+            js="(f) => { window.stopTimer(); if (f && f.url) { window.loadSplat(f.url); } }"
+        )
+
+    # Launch with HTTPS support
+    demo.queue().launch(
+        server_name=args.host, 
+        server_port=args.port, 
+        share=False,
+        ssl_certfile=args.ssl_cert if os.path.exists(args.ssl_cert) else None,
+        ssl_keyfile=args.ssl_key if os.path.exists(args.ssl_key) else None,
+        ssl_verify=False
+    )