add files

Dockerfile

@@ -0,0 +1,55 @@
+# Dockerfile
+
+# --- Этап 1: Сборка статического фронтенда ---
+# Мы используем легковесный образ Node.js для сборки React-приложения
+FROM node:18-alpine AS frontend-builder
+WORKDIR /app/frontend
+
+# Копируем только package.json, чтобы кэшировать установку зависимостей
+COPY frontend/package.json ./
+COPY frontend/package-lock.json ./
+RUN npm install
+
+# Копируем весь остальной код фронтенда и запускаем сборку
+COPY frontend/ ./
+# Важно: Убедитесь, что в вашем package.json есть скрипт "build"
+# Обычно он выглядит так: "build": "vite build" или "react-scripts build"
+RUN npm run build
+
+
+# --- Этап 2: Настройка Python-окружения и бэкенда ---
+# Используем официальный образ Python
+FROM python:3.10-slim
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+# Устанавливаем системные зависимости, если они нужны
+# (например, для компиляции C++ расширений в ReConV2)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Устанавливаем Python-зависимости
+COPY backend/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Копируем код бэкенда
+COPY backend/ .
+
+# Если у ReConV2 есть C++ расширения, которые нужно компилировать,
+# раскомментируйте и адаптируйте следующую строку:
+# RUN cd /app/ReConV2/extensions/ && python setup.py install
+
+
+# --- Этап 3: Финальный образ ---
+# Копируем собранный фронтенд из первого этапа в папку 'static'
+# FastAPI будет автоматически раздавать файлы из этой папки
+COPY --from=frontend-builder /app/frontend/dist ./static
+
+# Открываем порт, на котором будет работать FastAPI (стандартный для HF Spaces)
+EXPOSE 7860
+
+# Запускаем наш API-сервер с помощью Uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,143 @@
 ---
-title: Aic25 V2
-emoji: 💻
-colorFrom: pink
-colorTo: gray
+title: Cross-Modal Object Comparison Tool
+emoji: 👀
+colorFrom: green
+colorTo: yellow
 sdk: docker
-pinned: false
+pinned: true
+short_description: Demo of Image <-> 3D <-> Text retrival tool for AI Challenge
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# 🚀 Cross-Modal 3D Asset Retrieval & Comparison Tool
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![React](https://img.shields.io/badge/React-19-blue?logo=react)](https://react.dev/)
+[![FastAPI](https://img.shields.io/badge/FastAPI-0.110-green?logo=fastapi)](https://fastapi.tiangolo.com/)
+[![PyTorch](https://img.shields.io/badge/PyTorch-2.0-orange?logo=pytorch)](https://pytorch.org/)
+
+An advanced, full-stack application designed to manage and analyze multi-modal datasets containing 3D models, images, and text descriptions. The tool leverages deep learning models to compute and compare embeddings across different modalities, enabling powerful cross-modal search and retrieval.
+
+The interface allows users to upload their own datasets, explore a pre-loaded shared dataset, and perform detailed comparisons to find the most similar assets, regardless of their original format.
+
+---
+
+## ✨ Key Features
+
+- **🗂️ Multi-Modal Dataset Management**: Upload `.zip` archives containing images (`.png`), text (`.txt`), and 3D models (`.stl`). The system automatically processes and indexes them.
+- **☁️ Cloud & Local Datasets**: Seamlessly switch between a large, pre-processed shared dataset hosted on the server and local datasets stored securely in your browser's IndexedDB.
+- **👁️ Interactive Content Viewer**:
+  - A high-performance 3D viewer for `.stl` models with zoom/pan/rotate controls, powered by **Three.js**.
+  - Integrated image and text viewers.
+  - Fullscreen mode for detailed inspection of any asset.
+- **🧠 Powerful Cross-Modal Comparison**:
+  - **Dataset Item Search**: Select any item within a dataset to instantly see its top matches across all other modalities based on semantic similarity.
+  - **Ad-Hoc Search**: Upload a new, external image, 3D model, or text snippet to find the most similar items within a selected dataset.
+- **📊 Full Analysis Export**: Download the complete, pre-computed similarity matrix for any processed dataset as a `.json` or `.csv` file for offline analysis and reporting.
+- **⚡ Responsive & Modern UI**: A clean, fast, and intuitive user interface built with **React**, **TypeScript**, and **TailwindCSS**.
+- **🚀 High-Performance Backend**: Powered by **FastAPI** and **PyTorch**, the backend is optimized for asynchronous operations and efficient deep learning inference.
+
+---
+
+## 🛠️ Technical Stack
+
+| Area      | Technology                                                                                                  |
+| :-------- | :---------------------------------------------------------------------------------------------------------- |
+| **Frontend**  | [React 19](https://react.dev/), [TypeScript](https://www.typescriptlang.org/), [TailwindCSS](https://tailwindcss.com/), [Three.js](https://threejs.org/), [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API) |
+| **Backend**   | [Python 3.10](https://www.python.org/), [FastAPI](https://fastapi.tiangolo.com/), [PyTorch](https://pytorch.org/), [Uvicorn](https://www.uvicorn.org/), [scikit-learn](https://scikit-learn.org/) |
+| **Deployment**| [Docker](https://www.docker.com/), [Hugging Face Spaces](https://huggingface.co/spaces) (or any container-based platform)                                              |
+
+---
+
+## 🏛️ Project Architecture
+
+The application is architected as a modern monorepo with a clear separation between the frontend and backend services, designed for containerization and easy deployment.
+
+### Frontend (`/frontend`)
+
+A standalone Single-Page Application (SPA) built with React.
+- **`components/`**: Contains reusable UI components, organized by feature (e.g., `DatasetManager`, `ComparisonTool`, `common/`).
+- **`services/`**: Handles all side effects and external communication.
+  - `apiService.ts`: Manages all HTTP requests to the backend API.
+  - `dbService.ts`: Provides a simple interface for interacting with the browser's IndexedDB for local dataset persistence.
+  - `comparisonService.ts`: Logic for handling client-side interactions with pre-computed similarity data.
+- **`types.ts`**: Centralized TypeScript type definitions for robust data modeling.
+- **`App.tsx`**: The main application component that orchestrates state and views.
+
+### Backend (`/backend`)
+
+A high-performance API server built with FastAPI.
+- **`main.py`**: The main entry point for the FastAPI application. It defines all API endpoints, manages application lifecycle events (like model loading on startup), and serves the static frontend files.
+- **`inference_utils.py`**: The core of the AI logic. It handles ZIP file processing, asset parsing, embedding generation using the PyTorch models, and similarity calculation (cosine similarity). It also manages an in-memory cache for embeddings to ensure fast retrieval.
+- **`download_utils.py`**: A utility module for downloading model weights and shared datasets from external storage (e.g., Yandex.Disk) during the startup phase.
+- **`cad_retrieval_utils/`**: A proprietary library containing the core model definitions, data loaders, and training/inference configurations for the cross-modal retrieval task.
+- **`ReConV2/`**: A dependency containing model architectures and potentially C++ extensions for efficient 3D point cloud processing.
+
+---
+
+## ⚙️ How It Works
+
+The core workflow for processing a new dataset is as follows:
+
+1.  **Upload**: The user uploads a `.zip` file via the React frontend.
+2.  **API Request**: The frontend sends the file to the `/api/process-dataset` endpoint on the FastAPI backend.
+3.  **Unpacking & Preprocessing**: The backend saves the archive to a temporary directory and extracts all image, text, and mesh files.
+4.  **Embedding Generation**: For each file, a specialized PyTorch model generates a high-dimensional vector embedding:
+    -   An **Image Encoder** processes `.png` files.
+    -   A **Text Encoder** processes `.txt` files.
+    -   A **Point Cloud (PC) Encoder** processes `.stl` files after converting them to point clouds.
+5.  **Caching**: The generated embeddings and asset metadata are stored in an in-memory cache on the server for instant access.
+6.  **Full Comparison**: The backend pre-computes a full N x N similarity matrix by calculating the cosine similarity between every pair of embeddings.
+7.  **Response & Client-Side Storage**: The fully processed dataset object, including the comparison matrix, is sent back to the client. The frontend then saves this complete dataset to IndexedDB, making it available for future sessions without needing to re-upload.
+
+---
+
+## 🚀 Getting Started
+
+You can run this project locally using Docker, which encapsulates both the frontend and backend services.
+
+### Prerequisites
+
+- [Docker](https://www.docker.com/get-started) installed on your machine.
+
+### Local Installation & Startup
+
+1.  **Clone the repository:**
+    ```bash
+    git clone <your-repository-url>
+    cd <repository-name>
+    ```
+
+2.  **Check Model & Data URLs:**
+    The application is configured to download pre-trained models and a shared dataset from public URLs. Please verify the links inside `backend/main.py` and replace them with your own if necessary.
+
+3.  **Build and run with Docker:**
+    The provided `Dockerfile` is a multi-stage build that compiles the frontend and sets up the Python backend in a single, optimized image.
+
+    ```bash
+    # Build the Docker image
+    docker build -t cross-modal-retrieval .
+
+    # Run the container
+    docker run -p 7860:7860 cross-modal-retrieval
+    ```
+
+4.  **Access the application:**
+    Open your browser and navigate to [http://localhost:7860](http://localhost:7860).
+
+---
+
+## 💡 Future Improvements
+
+- **Support for More Formats**: Extend file support to `.obj`/`.glb` for 3D models and `.jpeg`/`.webp` for images.
+- **Advanced Search**: Implement more complex filtering and search options within the dataset viewer (e.g., by similarity score, item count).
+- **Embedding Visualization**: Add a new section to visualize the high-dimensional embedding space using techniques like t-SNE or UMAP.
+- **User Authentication**: Introduce user accounts to manage private datasets and share them with collaborators.
+- **Model Fine-tuning**: Allow users to fine-tune the retrieval models on their own datasets to improve domain-specific accuracy.
+
+---
+
+## 📜 License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

backend/ReConV2/extensions/chamfer_distance/__init__.py

@@ -0,0 +1 @@
+from .chamfer_distance import ChamferDistance

backend/ReConV2/extensions/chamfer_distance/chamfer_distance.cpp

@@ -0,0 +1,185 @@
+#include <torch/torch.h>
+
+// CUDA forward declarations
+void ChamferDistanceKernelLauncher(
+    const int b, const int n,
+    const float* xyz,
+    const int m,
+    const float* xyz2,
+    float* result,
+    int* result_i,
+    float* result2,
+    int* result2_i);
+
+void ChamferDistanceGradKernelLauncher(
+    const int b, const int n,
+    const float* xyz1,
+    const int m,
+    const float* xyz2,
+    const float* grad_dist1,
+    const int* idx1,
+    const float* grad_dist2,
+    const int* idx2,
+    float* grad_xyz1,
+    float* grad_xyz2);
+
+
+void chamfer_distance_forward_cuda(
+    const at::Tensor xyz1, 
+    const at::Tensor xyz2, 
+    const at::Tensor dist1, 
+    const at::Tensor dist2, 
+    const at::Tensor idx1, 
+    const at::Tensor idx2) 
+{
+    ChamferDistanceKernelLauncher(xyz1.size(0), xyz1.size(1), xyz1.data<float>(),
+                                            xyz2.size(1), xyz2.data<float>(),
+                                            dist1.data<float>(), idx1.data<int>(),
+                                            dist2.data<float>(), idx2.data<int>());
+}
+
+void chamfer_distance_backward_cuda(
+    const at::Tensor xyz1,
+    const at::Tensor xyz2, 
+    at::Tensor gradxyz1, 
+    at::Tensor gradxyz2, 
+    at::Tensor graddist1, 
+    at::Tensor graddist2, 
+    at::Tensor idx1, 
+    at::Tensor idx2)
+{
+    ChamferDistanceGradKernelLauncher(xyz1.size(0), xyz1.size(1), xyz1.data<float>(),
+                                           xyz2.size(1), xyz2.data<float>(),
+                                           graddist1.data<float>(), idx1.data<int>(),
+                                           graddist2.data<float>(), idx2.data<int>(),
+                                           gradxyz1.data<float>(), gradxyz2.data<float>());
+}
+
+
+void nnsearch(
+    const int b, const int n, const int m,
+    const float* xyz1,
+    const float* xyz2,
+    float* dist,
+    int* idx)
+{
+    for (int i = 0; i < b; i++) {
+        for (int j = 0; j < n; j++) {
+            const float x1 = xyz1[(i*n+j)*3+0];
+            const float y1 = xyz1[(i*n+j)*3+1];
+            const float z1 = xyz1[(i*n+j)*3+2];
+            double best = 0;
+            int besti = 0;
+            for (int k = 0; k < m; k++) {
+                const float x2 = xyz2[(i*m+k)*3+0] - x1;
+                const float y2 = xyz2[(i*m+k)*3+1] - y1;
+                const float z2 = xyz2[(i*m+k)*3+2] - z1;
+                const double d=x2*x2+y2*y2+z2*z2;
+                if (k==0 || d < best){
+                    best = d;
+                    besti = k;
+                }
+            }
+            dist[i*n+j] = best;
+            idx[i*n+j] = besti;
+        }
+    }
+}
+
+
+void chamfer_distance_forward(
+    const at::Tensor xyz1, 
+    const at::Tensor xyz2, 
+    const at::Tensor dist1, 
+    const at::Tensor dist2, 
+    const at::Tensor idx1, 
+    const at::Tensor idx2) 
+{
+    const int batchsize = xyz1.size(0);
+    const int n = xyz1.size(1);
+    const int m = xyz2.size(1);
+
+    const float* xyz1_data = xyz1.data<float>();
+    const float* xyz2_data = xyz2.data<float>();
+    float* dist1_data = dist1.data<float>();
+    float* dist2_data = dist2.data<float>();
+    int* idx1_data = idx1.data<int>();
+    int* idx2_data = idx2.data<int>();
+
+    nnsearch(batchsize, n, m, xyz1_data, xyz2_data, dist1_data, idx1_data);
+    nnsearch(batchsize, m, n, xyz2_data, xyz1_data, dist2_data, idx2_data);
+}
+
+
+void chamfer_distance_backward(
+    const at::Tensor xyz1, 
+    const at::Tensor xyz2, 
+    at::Tensor gradxyz1, 
+    at::Tensor gradxyz2, 
+    at::Tensor graddist1, 
+    at::Tensor graddist2, 
+    at::Tensor idx1, 
+    at::Tensor idx2) 
+{
+    const int b = xyz1.size(0);
+    const int n = xyz1.size(1);
+    const int m = xyz2.size(1);
+
+    const float* xyz1_data = xyz1.data<float>();
+    const float* xyz2_data = xyz2.data<float>();
+    float* gradxyz1_data = gradxyz1.data<float>();
+    float* gradxyz2_data = gradxyz2.data<float>();
+    float* graddist1_data = graddist1.data<float>();
+    float* graddist2_data = graddist2.data<float>();
+    const int* idx1_data = idx1.data<int>();
+    const int* idx2_data = idx2.data<int>();
+
+    for (int i = 0; i < b*n*3; i++)
+        gradxyz1_data[i] = 0;
+    for (int i = 0; i < b*m*3; i++)
+        gradxyz2_data[i] = 0;
+    for (int i = 0;i < b; i++) {
+        for (int j = 0; j < n; j++) {
+            const float x1 = xyz1_data[(i*n+j)*3+0];
+            const float y1 = xyz1_data[(i*n+j)*3+1];
+            const float z1 = xyz1_data[(i*n+j)*3+2];
+            const int j2 = idx1_data[i*n+j];
+
+            const float x2 = xyz2_data[(i*m+j2)*3+0];
+            const float y2 = xyz2_data[(i*m+j2)*3+1];
+            const float z2 = xyz2_data[(i*m+j2)*3+2];
+            const float g = graddist1_data[i*n+j]*2;
+
+            gradxyz1_data[(i*n+j)*3+0] += g*(x1-x2);
+            gradxyz1_data[(i*n+j)*3+1] += g*(y1-y2);
+            gradxyz1_data[(i*n+j)*3+2] += g*(z1-z2);
+            gradxyz2_data[(i*m+j2)*3+0] -= (g*(x1-x2));
+            gradxyz2_data[(i*m+j2)*3+1] -= (g*(y1-y2));
+            gradxyz2_data[(i*m+j2)*3+2] -= (g*(z1-z2));
+        }
+        for (int j = 0; j < m; j++) {
+            const float x1 = xyz2_data[(i*m+j)*3+0];
+            const float y1 = xyz2_data[(i*m+j)*3+1];
+            const float z1 = xyz2_data[(i*m+j)*3+2];
+            const int j2 = idx2_data[i*m+j];
+            const float x2 = xyz1_data[(i*n+j2)*3+0];
+            const float y2 = xyz1_data[(i*n+j2)*3+1];
+            const float z2 = xyz1_data[(i*n+j2)*3+2];
+            const float g = graddist2_data[i*m+j]*2;
+            gradxyz2_data[(i*m+j)*3+0] += g*(x1-x2);
+            gradxyz2_data[(i*m+j)*3+1] += g*(y1-y2);
+            gradxyz2_data[(i*m+j)*3+2] += g*(z1-z2);
+            gradxyz1_data[(i*n+j2)*3+0] -= (g*(x1-x2));
+            gradxyz1_data[(i*n+j2)*3+1] -= (g*(y1-y2));
+            gradxyz1_data[(i*n+j2)*3+2] -= (g*(z1-z2));
+        }
+    }
+}
+
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+    m.def("forward", &chamfer_distance_forward, "ChamferDistance forward");
+    m.def("forward_cuda", &chamfer_distance_forward_cuda, "ChamferDistance forward (CUDA)");
+    m.def("backward", &chamfer_distance_backward, "ChamferDistance backward");
+    m.def("backward_cuda", &chamfer_distance_backward_cuda, "ChamferDistance backward (CUDA)");
+}

backend/ReConV2/extensions/chamfer_distance/chamfer_distance.cu

@@ -0,0 +1,209 @@
+#include <ATen/ATen.h>
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+
+__global__ 
+void ChamferDistanceKernel(
+	int b,
+	int n,
+	const float* xyz,
+	int m,
+	const float* xyz2,
+	float* result,
+	int* result_i)
+{
+	const int batch=512;
+	__shared__ float buf[batch*3];
+	for (int i=blockIdx.x;i<b;i+=gridDim.x){
+		for (int k2=0;k2<m;k2+=batch){
+			int end_k=min(m,k2+batch)-k2;
+			for (int j=threadIdx.x;j<end_k*3;j+=blockDim.x){
+				buf[j]=xyz2[(i*m+k2)*3+j];
+			}
+			__syncthreads();
+			for (int j=threadIdx.x+blockIdx.y*blockDim.x;j<n;j+=blockDim.x*gridDim.y){
+				float x1=xyz[(i*n+j)*3+0];
+				float y1=xyz[(i*n+j)*3+1];
+				float z1=xyz[(i*n+j)*3+2];
+				int best_i=0;
+				float best=0;
+				int end_ka=end_k-(end_k&3);
+				if (end_ka==batch){
+					for (int k=0;k<batch;k+=4){
+						{
+							float x2=buf[k*3+0]-x1;
+							float y2=buf[k*3+1]-y1;
+							float z2=buf[k*3+2]-z1;
+							float d=x2*x2+y2*y2+z2*z2;
+							if (k==0 || d<best){
+								best=d;
+								best_i=k+k2;
+							}
+						}
+						{
+							float x2=buf[k*3+3]-x1;
+							float y2=buf[k*3+4]-y1;
+							float z2=buf[k*3+5]-z1;
+							float d=x2*x2+y2*y2+z2*z2;
+							if (d<best){
+								best=d;
+								best_i=k+k2+1;
+							}
+						}
+						{
+							float x2=buf[k*3+6]-x1;
+							float y2=buf[k*3+7]-y1;
+							float z2=buf[k*3+8]-z1;
+							float d=x2*x2+y2*y2+z2*z2;
+							if (d<best){
+								best=d;
+								best_i=k+k2+2;
+							}
+						}
+						{
+							float x2=buf[k*3+9]-x1;
+							float y2=buf[k*3+10]-y1;
+							float z2=buf[k*3+11]-z1;
+							float d=x2*x2+y2*y2+z2*z2;
+							if (d<best){
+								best=d;
+								best_i=k+k2+3;
+							}
+						}
+					}
+				}else{
+					for (int k=0;k<end_ka;k+=4){
+						{
+							float x2=buf[k*3+0]-x1;
+							float y2=buf[k*3+1]-y1;
+							float z2=buf[k*3+2]-z1;
+							float d=x2*x2+y2*y2+z2*z2;
+							if (k==0 || d<best){
+								best=d;
+								best_i=k+k2;
+							}
+						}
+						{
+							float x2=buf[k*3+3]-x1;
+							float y2=buf[k*3+4]-y1;
+							float z2=buf[k*3+5]-z1;
+							float d=x2*x2+y2*y2+z2*z2;
+							if (d<best){
+								best=d;
+								best_i=k+k2+1;
+							}
+						}
+						{
+							float x2=buf[k*3+6]-x1;
+							float y2=buf[k*3+7]-y1;
+							float z2=buf[k*3+8]-z1;
+							float d=x2*x2+y2*y2+z2*z2;
+							if (d<best){
+								best=d;
+								best_i=k+k2+2;
+							}
+						}
+						{
+							float x2=buf[k*3+9]-x1;
+							float y2=buf[k*3+10]-y1;
+							float z2=buf[k*3+11]-z1;
+							float d=x2*x2+y2*y2+z2*z2;
+							if (d<best){
+								best=d;
+								best_i=k+k2+3;
+							}
+						}
+					}
+				}
+				for (int k=end_ka;k<end_k;k++){
+					float x2=buf[k*3+0]-x1;
+					float y2=buf[k*3+1]-y1;
+					float z2=buf[k*3+2]-z1;
+					float d=x2*x2+y2*y2+z2*z2;
+					if (k==0 || d<best){
+						best=d;
+						best_i=k+k2;
+					}
+				}
+				if (k2==0 || result[(i*n+j)]>best){
+					result[(i*n+j)]=best;
+					result_i[(i*n+j)]=best_i;
+				}
+			}
+			__syncthreads();
+		}
+	}
+}
+
+void ChamferDistanceKernelLauncher(
+    const int b, const int n,
+    const float* xyz,
+    const int m,
+    const float* xyz2,
+    float* result,
+    int* result_i,
+    float* result2,
+    int* result2_i)
+{
+	ChamferDistanceKernel<<<dim3(32,16,1),512>>>(b, n, xyz, m, xyz2, result, result_i);
+	ChamferDistanceKernel<<<dim3(32,16,1),512>>>(b, m, xyz2, n, xyz, result2, result2_i);
+
+	cudaError_t err = cudaGetLastError();
+	if (err != cudaSuccess)
+	    printf("error in chamfer distance updateOutput: %s\n", cudaGetErrorString(err));
+}
+
+
+__global__ 
+void ChamferDistanceGradKernel(
+	int b, int n,
+	const float* xyz1,
+	int m,
+	const float* xyz2,
+	const float* grad_dist1,
+	const int* idx1,
+	float* grad_xyz1,
+	float* grad_xyz2)
+{
+	for (int i = blockIdx.x; i<b; i += gridDim.x) {
+		for (int j = threadIdx.x + blockIdx.y * blockDim.x; j < n; j += blockDim.x*gridDim.y) {
+			float x1=xyz1[(i*n+j)*3+0];
+			float y1=xyz1[(i*n+j)*3+1];
+			float z1=xyz1[(i*n+j)*3+2];
+			int j2=idx1[i*n+j];
+			float x2=xyz2[(i*m+j2)*3+0];
+			float y2=xyz2[(i*m+j2)*3+1];
+			float z2=xyz2[(i*m+j2)*3+2];
+			float g=grad_dist1[i*n+j]*2;
+			atomicAdd(&(grad_xyz1[(i*n+j)*3+0]),g*(x1-x2));
+			atomicAdd(&(grad_xyz1[(i*n+j)*3+1]),g*(y1-y2));
+			atomicAdd(&(grad_xyz1[(i*n+j)*3+2]),g*(z1-z2));
+			atomicAdd(&(grad_xyz2[(i*m+j2)*3+0]),-(g*(x1-x2)));
+			atomicAdd(&(grad_xyz2[(i*m+j2)*3+1]),-(g*(y1-y2)));
+			atomicAdd(&(grad_xyz2[(i*m+j2)*3+2]),-(g*(z1-z2)));
+		}
+	}
+}
+
+void ChamferDistanceGradKernelLauncher(
+    const int b, const int n,
+    const float* xyz1,
+    const int m,
+    const float* xyz2,
+    const float* grad_dist1,
+    const int* idx1,
+    const float* grad_dist2,
+    const int* idx2,
+    float* grad_xyz1,
+    float* grad_xyz2)
+{
+	cudaMemset(grad_xyz1, 0, b*n*3*4);
+	cudaMemset(grad_xyz2, 0, b*m*3*4);
+	ChamferDistanceGradKernel<<<dim3(1,16,1), 256>>>(b, n, xyz1, m, xyz2, grad_dist1, idx1, grad_xyz1, grad_xyz2);
+	ChamferDistanceGradKernel<<<dim3(1,16,1), 256>>>(b, m, xyz2, n, xyz1, grad_dist2, idx2, grad_xyz2, grad_xyz1);
+
+	cudaError_t err = cudaGetLastError();
+  	if (err != cudaSuccess)
+	    printf("error in chamfer distance get grad: %s\n", cudaGetErrorString(err));
+}

backend/ReConV2/extensions/chamfer_distance/chamfer_distance.py

@@ -0,0 +1,71 @@
+import os
+
+import torch
+
+script_path = os.path.dirname(os.path.abspath(__file__))
+
+from torch.utils.cpp_extension import load
+
+if torch.cuda.is_available():
+    cd = load(
+        name="cd",
+        sources=[
+            os.path.join(script_path, "chamfer_distance.cpp"),
+            os.path.join(script_path, "chamfer_distance.cu"),
+        ],
+    )
+
+
+class ChamferDistanceFunction(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, xyz1, xyz2):
+        batchsize, n, _ = xyz1.size()
+        _, m, _ = xyz2.size()
+        xyz1 = xyz1.contiguous()
+        xyz2 = xyz2.contiguous()
+        dist1 = torch.zeros(batchsize, n)
+        dist2 = torch.zeros(batchsize, m)
+
+        idx1 = torch.zeros(batchsize, n, dtype=torch.int)
+        idx2 = torch.zeros(batchsize, m, dtype=torch.int)
+
+        if not xyz1.is_cuda:
+            cd.forward(xyz1, xyz2, dist1, dist2, idx1, idx2)
+        else:
+            dist1 = dist1.cuda()
+            dist2 = dist2.cuda()
+            idx1 = idx1.cuda()
+            idx2 = idx2.cuda()
+            cd.forward_cuda(xyz1, xyz2, dist1, dist2, idx1, idx2)
+
+        ctx.save_for_backward(xyz1, xyz2, idx1, idx2)
+
+        return dist1, dist2, idx1
+
+    @staticmethod
+    def backward(ctx, graddist1, graddist2, _):
+        xyz1, xyz2, idx1, idx2 = ctx.saved_tensors
+
+        graddist1 = graddist1.contiguous()
+        graddist2 = graddist2.contiguous()
+
+        gradxyz1 = torch.zeros(xyz1.size())
+        gradxyz2 = torch.zeros(xyz2.size())
+
+        if not graddist1.is_cuda:
+            cd.backward(
+                xyz1, xyz2, gradxyz1, gradxyz2, graddist1, graddist2, idx1, idx2
+            )
+        else:
+            gradxyz1 = gradxyz1.cuda()
+            gradxyz2 = gradxyz2.cuda()
+            cd.backward_cuda(
+                xyz1, xyz2, gradxyz1, gradxyz2, graddist1, graddist2, idx1, idx2
+            )
+
+        return gradxyz1, gradxyz2
+
+
+class ChamferDistance(torch.nn.Module):
+    def forward(self, xyz1, xyz2):
+        return ChamferDistanceFunction.apply(xyz1, xyz2)

backend/ReConV2/models/ReCon.py

@@ -0,0 +1,630 @@
+import numpy as np
+import timm
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from scipy.optimize import linear_sum_assignment
+from timm.layers import trunc_normal_
+
+from ReConV2.extensions.chamfer_distance import ChamferDistance
+from ReConV2.models.transformer import (
+    GPTExtractor,
+    GPTGenerator,
+    Group,
+    MAEExtractor,
+    MAEGenerator,
+    PatchEmbedding,
+    PositionEmbeddingCoordsSine,
+    ZGroup,
+)
+from ReConV2.utils.checkpoint import (
+    get_missing_parameters_message,
+    get_unexpected_parameters_message,
+)
+from ReConV2.utils.logger import *
+
+from .build import MODELS
+
+
+# Pretrain model
+class MaskTransformer(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+
+        self.embed_dim = config.embed_dim
+        self.num_group = config.num_group
+        self.group_size = config.group_size
+        self.with_color = config.with_color
+        self.input_channel = 6 if self.with_color else 3
+        self.img_queries = config.img_queries
+        self.text_queries = config.text_queries
+        self.global_query_num = self.img_queries + self.text_queries
+        self.mask_type = config.mask_type
+        self.mask_ratio = config.mask_ratio
+        self.stop_grad = config.stop_grad
+
+        self.embed = PatchEmbedding(
+            embed_dim=self.embed_dim,
+            input_channel=self.input_channel,
+            large=config.large_embedding,
+        )
+
+        print_log(
+            f"[ReCon] divide point cloud into G{config.num_group} x S{config.group_size} points ...",
+            logger="ReCon",
+        )
+
+        if self.mask_type == "causal":
+            self.group_divider = ZGroup(
+                num_group=config.num_group, group_size=config.group_size
+            )
+            self.encoder = GPTExtractor(
+                embed_dim=config.embed_dim,
+                num_heads=config.num_heads,
+                depth=config.depth,
+                group_size=config.group_size,
+                drop_path_rate=config.drop_path_rate,
+                stop_grad=self.stop_grad,
+                pretrained_model_name=config.pretrained_model_name,
+            )
+            self.decoder = GPTGenerator(
+                embed_dim=config.embed_dim,
+                depth=config.decoder_depth,
+                drop_path_rate=config.drop_path_rate,
+                num_heads=config.num_heads,
+                group_size=config.group_size,
+                input_channel=self.input_channel,
+            )
+            self.pos_embed = PositionEmbeddingCoordsSine(3, self.embed_dim, 1.0)
+
+        else:
+            self.group_divider = Group(
+                num_group=config.num_group, group_size=config.group_size
+            )
+            self.encoder = MAEExtractor(
+                embed_dim=config.embed_dim,
+                num_heads=config.num_heads,
+                depth=config.depth,
+                group_size=config.group_size,
+                drop_path_rate=config.drop_path_rate,
+                stop_grad=self.stop_grad,
+                pretrained_model_name=config.pretrained_model_name,
+            )
+            self.decoder = MAEGenerator(
+                embed_dim=config.embed_dim,
+                depth=config.decoder_depth,
+                drop_path_rate=config.drop_path_rate,
+                num_heads=config.num_heads,
+                group_size=config.group_size,
+                input_channel=self.input_channel,
+            )
+            self.pos_embed = nn.Sequential(
+                nn.Linear(3, 128), nn.GELU(), nn.Linear(128, self.embed_dim)
+            )
+            self.decoder_pos_embed = nn.Sequential(
+                nn.Linear(3, 128), nn.GELU(), nn.Linear(128, self.embed_dim)
+            )
+
+        self.norm = nn.LayerNorm(self.embed_dim)
+        self.global_query = nn.Parameter(
+            torch.zeros(1, self.global_query_num, self.embed_dim)
+        )
+        self.apply(self._init_weights)
+
+        # do not perform additional mask on the first (self.keep_attend) tokens
+        self.keep_attend = 10
+        self.num_group = config.num_group
+        self.num_mask = int((self.num_group - self.keep_attend) * self.mask_ratio)
+
+        if config.pretrained_model_name == "":
+            print_log("[ReCon] No pretrained model is loaded.", logger="ReCon")
+        elif config.pretrained_model_name in timm.list_models(pretrained=True):
+            self.encoder.blocks.load_pretrained_timm_weights()
+            print_log(
+                f"[ReCon] Timm pretrained model {config.pretrained_model_name} is successful loaded.",
+                logger="ReCon",
+            )
+        else:
+            print_log(
+                f"[ReCon] Pretrained model {config.pretrained_model_name} is not found in Timm.",
+                logger="ReCon",
+            )
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            nn.init.normal_(m.weight, 0.02, 0.01)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.BatchNorm1d):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+
+    def _mask_center_rand(self, center):
+        """
+        center : B G 3
+        --------------
+        mask : B G (bool)
+        """
+        B, G, _ = center.shape
+        num_mask = int(self.mask_ratio * G)
+
+        overall_mask = np.zeros([B, G])
+        for i in range(B):
+            mask = np.hstack([
+                np.zeros(G - num_mask),
+                np.ones(num_mask),
+            ])
+            np.random.shuffle(mask)
+            overall_mask[i, :] = mask
+        overall_mask = torch.from_numpy(overall_mask).to(torch.bool)
+
+        return num_mask, overall_mask.to(center.device)
+
+    def inference(self, pts):
+        with torch.no_grad():
+            neighborhood, center = self.group_divider(pts)
+            group_input_tokens = self.embed(neighborhood)  # B G C
+            batch_size, seq_len, C = group_input_tokens.size()
+
+            global_query = self.global_query.expand(batch_size, -1, -1)
+            pos = self.pos_embed(center.to(group_input_tokens.dtype))
+
+            mask = torch.full(
+                (seq_len, seq_len),
+                -float("Inf"),
+                device=group_input_tokens.device,
+                dtype=group_input_tokens.dtype,
+            ).to(torch.bool)
+            if self.mask_type == "causal":
+                mask = torch.triu(mask, diagonal=1)
+            else:
+                mask = None
+
+            local_features, global_features = self.encoder(
+                group_input_tokens, pos, mask, global_query
+            )
+
+        return pos, local_features, global_features
+
+    def forward_mae(self, pts):
+        neighborhood, center = self.group_divider(pts)
+        num_mask, mask = self._mask_center_rand(center)
+        group_input_tokens = self.embed(neighborhood)  # B G C
+        batch_size, seq_len, C = group_input_tokens.size()
+        global_query = self.global_query.expand(batch_size, -1, -1)
+
+        pos = self.pos_embed(center.reshape(batch_size, -1, 3))
+        decoder_pos = self.decoder_pos_embed(center.reshape(batch_size, -1, 3))
+        x_vis, global_features = self.encoder(
+            group_input_tokens, pos, mask, global_query
+        )
+        generated_points = self.decoder(x_vis, decoder_pos, mask)
+
+        gt_points = neighborhood[mask].reshape(
+            batch_size * num_mask, self.group_size, self.input_channel
+        )
+
+        return generated_points, gt_points, global_features
+
+    def forward_gpt(self, pts):
+        neighborhood, center = self.group_divider(pts)
+        group_input_tokens = self.embed(neighborhood)  # B G C
+        batch_size, seq_len, C = group_input_tokens.size()
+
+        global_query = self.global_query.expand(batch_size, -1, -1)
+        pos_absolute = self.pos_embed(center).to(group_input_tokens.dtype)
+
+        relative_position = center[:, 1:, :] - center[:, :-1, :]
+        relative_norm = torch.norm(relative_position, dim=-1, keepdim=True)
+        relative_direction = relative_position / (relative_norm + 1e-5)
+        position = torch.cat([center[:, 0, :].unsqueeze(1), relative_direction], dim=1)
+        pos_relative = self.pos_embed(position).to(group_input_tokens.dtype)
+
+        attn_mask = torch.full(
+            (seq_len, seq_len),
+            -float("Inf"),
+            device=group_input_tokens.device,
+            dtype=group_input_tokens.dtype,
+        ).to(torch.bool)
+
+        with torch.no_grad():
+            attn_mask = torch.triu(attn_mask, diagonal=1)
+
+            # column wise
+            overall_mask = np.hstack([
+                np.zeros(self.num_group - self.keep_attend - self.num_mask),
+                np.ones(self.num_mask),
+            ])
+            np.random.shuffle(overall_mask)
+            overall_mask = np.hstack([
+                np.zeros(self.keep_attend),
+                overall_mask,
+            ])
+            overall_mask = (
+                torch.from_numpy(overall_mask)
+                .to(torch.bool)
+                .to(group_input_tokens.device)
+            )
+            eye_mask = torch.eye(
+                self.num_group, device=group_input_tokens.device, dtype=torch.bool
+            )
+            attn_mask = attn_mask | overall_mask.unsqueeze(0) & ~eye_mask
+
+        local_features, global_features = self.encoder(
+            group_input_tokens, pos_absolute, attn_mask, global_query
+        )
+        generated_points = self.decoder(local_features, pos_relative, attn_mask)
+
+        gt_points = neighborhood.reshape(
+            batch_size * self.num_group, self.group_size, self.input_channel
+        )
+
+        return generated_points, gt_points, global_features
+
+    def forward(self, pts):
+        if self.mask_type == "causal":
+            generated_points, gt_points, global_query = self.forward_gpt(pts)
+        else:
+            generated_points, gt_points, global_query = self.forward_mae(pts)
+
+        return generated_points, gt_points, global_query
+
+
+@MODELS.register_module()
+class ReCon2(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        print_log("[ReCon V2]", logger="ReCon V2")
+        self.config = config
+        self.embed_dim = config.embed_dim
+        self.with_color = config.with_color
+        self.img_queries = config.img_queries
+        self.text_queries = config.text_queries
+        self.global_query_num = self.img_queries + self.text_queries
+        self.input_channel = 6 if self.with_color else 3
+        self.contrast_type = config.contrast_type
+
+        self.model = MaskTransformer(config)
+        self.cd_loss = ChamferDistance()
+        self.l1_loss = torch.nn.SmoothL1Loss()
+
+        self.img_proj = nn.Linear(self.embed_dim, 1280)
+        self.img_proj.apply(self._init_weights)
+        self.text_proj = nn.Linear(self.embed_dim, 1280)
+        self.text_proj.apply(self._init_weights)
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            nn.init.normal_(m.weight, 0.02, 0.01)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.BatchNorm1d):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+
+    def info_nce_loss(self, feat1, feat2, logit_scale=1, mask=None):
+        feat1 = F.normalize(feat1, dim=1)
+        feat2 = F.normalize(feat2, dim=1)
+        all_feat1 = torch.cat(torch.distributed.nn.all_gather(feat1), dim=0)
+        all_feat2 = torch.cat(torch.distributed.nn.all_gather(feat2), dim=0)
+        logits = logit_scale * all_feat1 @ all_feat2.T
+        if mask is not None:
+            logits = logits * mask
+        labels = torch.arange(logits.shape[0]).to(self.config.device)
+        accuracy = (logits.argmax(dim=1) == labels).float().mean()
+        loss = (F.cross_entropy(logits, labels) + F.cross_entropy(logits.T, labels)) / 2
+        return loss, accuracy
+
+    def distillation_loss(self, token, feature):
+        B = token.shape[0]
+        loss = 0.0
+        for i in range(B):
+            pred = token[i]
+            feat = feature[i][torch.any(feature[i] != 0, dim=1)]
+            feat = F.normalize(feat, dim=-1)
+            similarity_matrix = torch.mm(pred, feat.T).cpu().detach().numpy()
+            row_ind, col_ind = linear_sum_assignment(-similarity_matrix)
+            loss = loss + self.l1_loss(pred[row_ind], feat[col_ind])
+
+        return loss * 5
+
+    def contrast_loss(self, token, feature):
+        if self.contrast_type == "simclr":
+            return self.info_nce_loss(
+                token, feature, logit_scale=self.logit_scale, mask=self.mask
+            )
+        elif self.contrast_type == "byol":
+            return self.distillation_loss(token, feature)
+        else:
+            raise ValueError("Unknown contrast type")
+
+    def inference(self, pts):
+        _, encoded_features, global_token = self.model.inference(pts)
+
+        img_token = global_token[:, : self.img_queries]
+        img_token = self.img_proj(img_token)
+        img_token = F.normalize(img_token, dim=-1)
+
+        text_token = global_token[:, self.img_queries :]
+        text_token = self.text_proj(text_token)
+        text_token = F.normalize(text_token, dim=-1)
+
+        return encoded_features, global_token, img_token, text_token
+
+    def forward_features(self, pts):
+        generated_points, gt_points, global_token = self.model(pts)
+
+        img_token = global_token[:, : self.img_queries]
+        img_token = self.img_proj(img_token)
+        img_token = F.normalize(img_token, dim=-1)
+
+        text_token = global_token[:, self.img_queries :]
+        text_token = self.text_proj(text_token)
+        text_token = F.normalize(text_token, dim=-1)
+
+        return img_token, text_token, gt_points, generated_points
+
+    def forward_reconstruct(self, pts):
+        _, _, gt_points, generated_points = self.forward_features(pts)
+
+        generated_xyz = generated_points[:, :, :3]
+        gt_xyz = gt_points[:, :, :3]
+        dist1, dist2, idx = self.cd_loss(generated_xyz, gt_xyz)
+        if self.with_color:
+            generated_color = generated_points[:, :, 3:]
+            gt_color = gt_points[:, :, 3:]
+            color_l1_loss = self.l1_loss(
+                generated_color,
+                torch.gather(gt_color, 1, idx.unsqueeze(-1).expand(-1, -1, 3).long()),
+            )
+        else:
+            color_l1_loss = 0
+        cd_l2_loss = (torch.mean(dist1)) + (torch.mean(dist2))
+        cd_l1_loss = (torch.mean(torch.sqrt(dist1)) + torch.mean(torch.sqrt(dist2))) / 2
+
+        loss = cd_l1_loss + cd_l2_loss + color_l1_loss
+
+        return loss
+
+    def forward_contrast(self, pts, img, text):
+        img_token, text_token, _, _ = self.forward_features(pts)
+        img_loss = self.contrast_loss(img_token, img)
+        text_loss = self.contrast_loss(text_token, text)
+        loss = img_loss + text_loss
+
+        return loss
+
+    def forward_all(self, pts, img, text):
+        img_token, text_token, gt_points, generated_points = self.forward_features(pts)
+
+        losses = {"mdm": 0, "csc_img": 0, "csc_text": 0}
+
+        generated_xyz = generated_points[:, :, :3]
+        gt_xyz = gt_points[:, :, :3]
+        dist1, dist2, idx = self.cd_loss(generated_xyz, gt_xyz)
+        if self.with_color:
+            generated_color = generated_points[:, :, 3:]
+            gt_color = gt_points[:, :, 3:]
+            color_l1_loss = self.l1_loss(
+                generated_color,
+                torch.gather(gt_color, 1, idx.unsqueeze(-1).expand(-1, -1, 3).long()),
+            )
+        else:
+            color_l1_loss = 0
+        cd_l2_loss = (torch.mean(dist1)) + (torch.mean(dist2))
+        cd_l1_loss = (torch.mean(torch.sqrt(dist1)) + torch.mean(torch.sqrt(dist2))) / 2
+
+        losses["mdm"] = cd_l1_loss + cd_l2_loss + color_l1_loss
+        losses["csc_img"] = self.contrast_loss(img_token, img)
+        losses["csc_text"] = self.contrast_loss(text_token, text)
+
+        print(losses)
+        loss = sum(losses.values())
+        return loss
+
+    def forward(self, pts, img, text, type="all"):
+        if type == "all":
+            return self.forward_all(pts, img, text)
+        elif type == "reconstruct":
+            return self.forward_reconstruct(pts)
+        elif type == "contrast":
+            return self.forward_contrast(pts, img, text)
+        else:
+            raise ValueError("Unknown type")
+
+    @property
+    def device(self):
+        return next(self.parameters()).device
+
+    @property
+    def dtype(self):
+        return next(self.parameters()).dtype
+
+
+# finetune model
+@MODELS.register_module()
+class PointTransformer(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+
+        self.cls_dim = config.cls_dim
+        self.embed_dim = config.embed_dim
+        self.with_color = config.with_color
+        self.input_channel = 6 if self.with_color else 3
+        self.num_group = config.num_group
+        self.group_size = config.group_size
+        self.img_queries = config.img_queries
+        self.text_queries = config.text_queries
+        self.global_query_num = self.img_queries + self.text_queries
+        self.large_embedding = config.large_embedding
+
+        self.embed = PatchEmbedding(
+            embed_dim=self.embed_dim,
+            input_channel=self.input_channel,
+            large=self.large_embedding,
+        )
+        self.pos_embed = PositionEmbeddingCoordsSine(3, self.embed_dim, 1.0)
+
+        self.group_divider = ZGroup(
+            num_group=config.num_group, group_size=config.group_size
+        )
+        print_log(
+            f"[PointTransformer] divide point cloud into G{config.num_group} x S{config.group_size} points ...",
+            logger="PointTransformer",
+        )
+
+        self.encoder = GPTExtractor(
+            embed_dim=config.embed_dim,
+            num_heads=config.num_heads,
+            depth=config.depth,
+            group_size=config.group_size,
+            drop_path_rate=config.drop_path_rate,
+            stop_grad=False,
+        )
+
+        self.decoder = GPTGenerator(
+            embed_dim=config.embed_dim,
+            depth=config.decoder_depth,
+            drop_path_rate=config.drop_path_rate,
+            num_heads=config.num_heads,
+            group_size=config.group_size,
+            input_channel=self.input_channel,
+        )
+        self.global_query = nn.Parameter(
+            torch.zeros(1, self.global_query_num, self.embed_dim)
+        )
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, self.embed_dim))
+
+        feature_dim = self.embed_dim * 4
+        self.cls_head_finetune = nn.Sequential(
+            nn.Linear(feature_dim, 256),
+            nn.BatchNorm1d(256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.5),
+            nn.Linear(256, 256),
+            nn.BatchNorm1d(256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.5),
+            nn.Linear(256, self.cls_dim),
+        )
+
+        self.loss_ce = nn.CrossEntropyLoss()
+        # chamfer distance loss
+        self.cd_loss = ChamferDistance()
+        self.apply(self._init_weights)
+
+    def get_loss_acc(self, ret, gt):
+        loss = self.loss_ce(ret, gt.long())
+        pred = ret.argmax(-1)
+        acc = (pred == gt).sum() / float(gt.size(0))
+        return loss, acc * 100
+
+    def load_model_from_ckpt(self, ckpt_path, log=True):
+        if ckpt_path is not None:
+            ckpt = torch.load(ckpt_path)
+            base_ckpt = {
+                k.replace("module.", ""): v for k, v in ckpt["base_model"].items()
+            }
+
+            for k in list(base_ckpt.keys()):
+                if k.startswith("model"):
+                    base_ckpt[k[len("model.") :]] = base_ckpt[k]
+                    del base_ckpt[k]
+                elif k.startswith("cls_head_finetune"):
+                    del base_ckpt[k]
+
+            incompatible = self.load_state_dict(base_ckpt, strict=False)
+            if log:
+                if incompatible.missing_keys:
+                    print_log("missing_keys", logger="PointTransformer")
+                    print_log(
+                        get_missing_parameters_message(incompatible.missing_keys),
+                        logger="PointTransformer",
+                    )
+                if incompatible.unexpected_keys:
+                    print_log("unexpected_keys", logger="PointTransformer")
+                    print_log(
+                        get_unexpected_parameters_message(incompatible.unexpected_keys),
+                        logger="PointTransformer",
+                    )
+
+                print_log(
+                    f"[PointTransformer] Successful Loading the ckpt from {ckpt_path}",
+                    logger="PointTransformer",
+                )
+        else:
+            print_log("Training from scratch!!!", logger="PointTransformer")
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            trunc_normal_(m.weight, std=0.02)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.LayerNorm):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+        elif isinstance(m, nn.Conv1d):
+            trunc_normal_(m.weight, std=0.02)
+            if m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+
+    def forward(self, pts):
+        neighborhood, center = self.group_divider(pts)
+        group_input_tokens = self.embed(neighborhood)  # B G C
+        batch_size, seq_len, C = group_input_tokens.size()
+
+        global_query = self.global_query.expand(batch_size, -1, -1)
+        cls_query = self.cls_token.expand(batch_size, -1, -1)
+        query = torch.cat([global_query, cls_query], dim=1)
+
+        relative_position = center[:, 1:, :] - center[:, :-1, :]
+        relative_norm = torch.norm(relative_position, dim=-1, keepdim=True)
+        relative_direction = relative_position / (relative_norm + 1e-5)
+        position = torch.cat([center[:, 0, :].unsqueeze(1), relative_direction], dim=1)
+        pos_relative = self.pos_embed(position).to(group_input_tokens.dtype)
+
+        pos = self.pos_embed(center).to(group_input_tokens.dtype)
+
+        attn_mask = torch.full(
+            (seq_len, seq_len),
+            -float("Inf"),
+            device=group_input_tokens.device,
+            dtype=group_input_tokens.dtype,
+        ).to(torch.bool)
+        attn_mask = torch.triu(attn_mask, diagonal=1)
+
+        # transformer
+        encoded_features, global_tokens = self.encoder(
+            group_input_tokens, pos, attn_mask, query
+        )
+        generated_points = self.decoder(encoded_features, pos_relative, attn_mask)
+
+        # neighborhood[:, :, :, :3] = neighborhood[:, :, :, :3] + center.unsqueeze(2)
+        gt_points = neighborhood.reshape(
+            batch_size * self.num_group, self.group_size, self.input_channel
+        )
+
+        generated_xyz = generated_points[:, :, :3]
+        gt_xyz = gt_points[:, :, :3]
+        dist1, dist2, idx = self.cd_loss(generated_xyz, gt_xyz)
+
+        cd_l2_loss = (torch.mean(dist1)) + (torch.mean(dist2))
+        cd_l1_loss = (torch.mean(torch.sqrt(dist1)) + torch.mean(torch.sqrt(dist2))) / 2
+
+        img_token = global_tokens[:, : self.img_queries]
+        text_token = global_tokens[:, self.img_queries : -1]
+        cls_token = global_tokens[:, -1]
+
+        concat_f = torch.cat(
+            [
+                cls_token,
+                img_token.max(1)[0],
+                text_token.max(1)[0],
+                encoded_features.max(1)[0],
+            ],
+            dim=-1,
+        )
+        ret = self.cls_head_finetune(concat_f)
+
+        return ret, cd_l1_loss + cd_l2_loss

backend/ReConV2/models/__init__.py

@@ -0,0 +1,4 @@
+import ReConV2.models.ReCon
+import ReConV2.models.transformer
+
+from .build import build_model_from_cfg

backend/ReConV2/models/build.py

@@ -0,0 +1,14 @@
+from ReConV2.utils import registry
+
+MODELS = registry.Registry("models")
+
+
+def build_model_from_cfg(cfg, **kwargs):
+    """
+    Build a dataset, defined by `dataset_name`.
+    Args:
+        cfg (eDICT):
+    Returns:
+        Dataset: a constructed dataset specified by dataset_name.
+    """
+    return MODELS.build(cfg, **kwargs)

backend/ReConV2/models/transformer.py

@@ -0,0 +1,788 @@
+import math
+
+import timm
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from timm.layers import DropPath, Mlp
+
+from ReConV2.utils import misc
+from ReConV2.utils.knn import knn_point
+from ReConV2.utils.logger import *
+
+
+class PatchEmbedding(nn.Module):  # Embedding module
+    def __init__(self, embed_dim, input_channel=3, large=False):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.input_channel = input_channel
+
+        # embed_dim_list = [c * (embed_dim // 512 + 1) for c in [128, 256, 512]]
+        #
+        # self.first_conv = nn.Sequential(
+        #     nn.Conv1d(self.input_channel, embed_dim_list[0], 1),
+        #     nn.BatchNorm1d(embed_dim_list[0]),
+        #     nn.ReLU(inplace=True),
+        #     nn.Conv1d(embed_dim_list[0], embed_dim_list[1], 1)
+        # )
+        # self.second_conv = nn.Sequential(
+        #     nn.Conv1d(embed_dim_list[2], embed_dim_list[2], 1),
+        #     nn.BatchNorm1d(embed_dim_list[2]),
+        #     nn.ReLU(inplace=True),
+        #     nn.Conv1d(embed_dim_list[2], self.embed_dim, 1)
+        # )
+
+        if large:
+            self.first_conv = nn.Sequential(
+                nn.Conv1d(self.input_channel, 256, 1),
+                nn.BatchNorm1d(256),
+                nn.ReLU(inplace=True),
+                nn.Conv1d(256, 512, 1),
+                nn.BatchNorm1d(512),
+                nn.ReLU(inplace=True),
+                nn.Conv1d(512, 1024, 1),
+            )
+            self.second_conv = nn.Sequential(
+                nn.Conv1d(2048, 2048, 1),
+                nn.BatchNorm1d(2048),
+                nn.ReLU(inplace=True),
+                nn.Conv1d(2048, embed_dim, 1),
+            )
+        else:
+            self.first_conv = nn.Sequential(
+                nn.Conv1d(self.input_channel, 128, 1),
+                nn.BatchNorm1d(128),
+                nn.ReLU(inplace=True),
+                nn.Conv1d(128, 256, 1),
+            )
+            self.second_conv = nn.Sequential(
+                nn.Conv1d(512, 512, 1),
+                nn.BatchNorm1d(512),
+                nn.ReLU(inplace=True),
+                nn.Conv1d(512, embed_dim, 1),
+            )
+
+    def forward(self, point_groups):
+        """
+        point_groups : B G N 3/6
+        -----------------
+        feature_global : B G C
+        """
+        bs, g, n, _ = point_groups.shape
+        point_groups = point_groups.reshape(bs * g, n, self.input_channel)
+        # encoder
+        feature = self.first_conv(point_groups.transpose(2, 1))
+        feature_global = torch.max(feature, dim=2, keepdim=True)[0]
+        feature = torch.cat([feature_global.expand(-1, -1, n), feature], dim=1)
+        feature = self.second_conv(feature)
+        feature_global = torch.max(feature, dim=2, keepdim=False)[0]
+        return feature_global.reshape(bs, g, self.embed_dim)
+
+
+class PositionEmbeddingCoordsSine(nn.Module):
+    """Similar to transformer's position encoding, but generalizes it to
+    arbitrary dimensions and continuous coordinates.
+
+    Args:
+        n_dim: Number of input dimensions, e.g. 2 for image coordinates.
+        d_model: Number of dimensions to encode into
+        temperature:
+        scale:
+    """
+
+    def __init__(self, n_dim: int = 1, d_model: int = 256, temperature=1.0, scale=None):
+        super().__init__()
+
+        self.n_dim = n_dim
+        self.num_pos_feats = d_model // n_dim // 2 * 2
+        self.temperature = temperature
+        self.padding = d_model - self.num_pos_feats * self.n_dim
+
+        if scale is None:
+            scale = 1.0
+        self.scale = scale * 2 * math.pi
+
+    def forward(self, xyz: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            xyz: Point positions (*, d_in)
+
+        Returns:
+            pos_emb (*, d_out)
+        """
+        assert xyz.shape[-1] == self.n_dim
+
+        dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=xyz.device)
+        dim_t = self.temperature ** (
+            2 * torch.div(dim_t, 2, rounding_mode="trunc") / self.num_pos_feats
+        )
+
+        xyz = xyz * self.scale
+        pos_divided = xyz.unsqueeze(-1) / dim_t
+        pos_sin = pos_divided[..., 0::2].sin()
+        pos_cos = pos_divided[..., 1::2].cos()
+        pos_emb = torch.stack([pos_sin, pos_cos], dim=-1).reshape(*xyz.shape[:-1], -1)
+
+        # Pad unused dimensions with zeros
+        pos_emb = F.pad(pos_emb, (0, self.padding))
+        return pos_emb
+
+
+class Group(nn.Module):  # FPS + KNN
+    def __init__(self, num_group, group_size):
+        super().__init__()
+        self.num_group = num_group
+        self.group_size = group_size
+
+    def forward(self, pts):
+        """
+        input: B N 3/6
+        ---------------------------
+        output: B G M 3/6
+        center : B G 3
+        """
+        xyz = pts[:, :, :3]
+        c = pts.shape[2]
+        batch_size, num_points, _ = xyz.shape
+        # fps the centers out
+        xyz = xyz.float()
+        center = misc.fps(xyz.contiguous(), self.num_group)  # B G 3
+        # knn to get the neighborhood
+        idx = knn_point(self.group_size, xyz, center)
+        assert idx.size(1) == self.num_group
+        assert idx.size(2) == self.group_size
+        idx_base = (
+            torch.arange(0, batch_size, device=xyz.device).view(-1, 1, 1) * num_points
+        )
+        idx = idx + idx_base
+        idx = idx.view(-1)
+        neighborhood = pts.view(batch_size * num_points, -1)[idx, :]
+        neighborhood = neighborhood.view(
+            batch_size, self.num_group, self.group_size, c
+        ).contiguous()
+        # normalize
+        neighborhood[:, :, :, :3] = neighborhood[:, :, :, :3] - center.unsqueeze(2)
+        return neighborhood, center
+
+
+class ZGroup(nn.Module):
+    def __init__(self, num_group, group_size):
+        super().__init__()
+        self.num_group = num_group
+        self.group_size = group_size
+
+    def simplied_morton_sorting(self, xyz, center):
+        """
+        Simplifying the Morton code sorting to iterate and set the nearest patch to the last patch as the next patch, we found this to be more efficient.
+        """
+        batch_size, num_points, _ = xyz.shape
+        distances_batch = torch.cdist(center, center)
+        distances_batch[:, torch.eye(self.num_group).bool()] = float("inf")
+        idx_base = torch.arange(0, batch_size, device=xyz.device) * self.num_group
+        sorted_indices_list = [idx_base]
+        distances_batch = (
+            distances_batch.view(batch_size, self.num_group, self.num_group)
+            .transpose(1, 2)
+            .contiguous()
+            .view(batch_size * self.num_group, self.num_group)
+        )
+        distances_batch[idx_base] = float("inf")
+        distances_batch = (
+            distances_batch.view(batch_size, self.num_group, self.num_group)
+            .transpose(1, 2)
+            .contiguous()
+        )
+        for i in range(self.num_group - 1):
+            distances_batch = distances_batch.view(
+                batch_size * self.num_group, self.num_group
+            )
+            distances_to_last_batch = distances_batch[sorted_indices_list[-1]]
+            closest_point_idx = torch.argmin(distances_to_last_batch, dim=-1)
+            closest_point_idx = closest_point_idx + idx_base
+            sorted_indices_list.append(closest_point_idx)
+            distances_batch = (
+                distances_batch.view(batch_size, self.num_group, self.num_group)
+                .transpose(1, 2)
+                .contiguous()
+                .view(batch_size * self.num_group, self.num_group)
+            )
+            distances_batch[closest_point_idx] = float("inf")
+            distances_batch = (
+                distances_batch.view(batch_size, self.num_group, self.num_group)
+                .transpose(1, 2)
+                .contiguous()
+            )
+        sorted_indices = torch.stack(sorted_indices_list, dim=-1)
+        sorted_indices = sorted_indices.view(-1)
+        return sorted_indices
+
+    def forward(self, pts):
+        """
+        input: B N 3/6
+        ---------------------------
+        output: B G M 3/6
+        center : B G 3
+        """
+        xyz = pts[:, :, :3]
+        c = pts.shape[2]
+        batch_size, num_points, _ = xyz.shape
+        # fps the centers out
+        xyz = xyz.float()
+        center = misc.fps(xyz.contiguous(), self.num_group)  # B G 3
+        # knn to get the neighborhood
+        idx = knn_point(self.group_size, xyz, center)
+        assert idx.size(1) == self.num_group
+        assert idx.size(2) == self.group_size
+        idx_base = (
+            torch.arange(0, batch_size, device=xyz.device).view(-1, 1, 1) * num_points
+        )
+        idx = idx + idx_base
+        idx = idx.view(-1)
+        neighborhood = pts.view(batch_size * num_points, -1)[idx, :]
+        neighborhood = neighborhood.view(
+            batch_size, self.num_group, self.group_size, c
+        ).contiguous()
+        # normalize
+        neighborhood[:, :, :, :3] = neighborhood[:, :, :, :3] - center.unsqueeze(2)
+
+        # can utilize morton_sorting by choosing morton_sorting function
+        sorted_indices = self.simplied_morton_sorting(xyz, center)
+
+        neighborhood = neighborhood.view(
+            batch_size * self.num_group, self.group_size, c
+        )[sorted_indices, :, :]
+        neighborhood = neighborhood.view(
+            batch_size, self.num_group, self.group_size, c
+        ).contiguous()
+        center = center.view(batch_size * self.num_group, 3)[sorted_indices, :]
+        center = center.view(batch_size, self.num_group, 3).contiguous()
+
+        return neighborhood, center
+
+
+# Transformers
+class Attention(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int = 8,
+        qkv_bias: bool = True,
+        qk_norm: bool = False,
+        attn_drop: float = 0.0,
+        proj_drop: float = 0.0,
+        norm_layer: nn.Module = nn.LayerNorm,
+    ) -> None:
+        super().__init__()
+        assert dim % num_heads == 0, "dim should be divisible by num_heads"
+        self.num_heads = num_heads
+        self.head_dim = dim // num_heads
+        self.scale = self.head_dim**-0.5
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.q_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+        self.k_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+    def forward(
+        self, x: torch.Tensor, mask: torch.Tensor | None = None
+    ) -> torch.Tensor:
+        B, N, C = x.shape
+        qkv = (
+            self.qkv(x)
+            .reshape(B, N, 3, self.num_heads, self.head_dim)
+            .permute(2, 0, 3, 1, 4)
+        )
+        q, k, v = qkv.unbind(0)
+        q, k = self.q_norm(q), self.k_norm(k)
+
+        q = q * self.scale
+        attn = q @ k.transpose(-2, -1)
+        if mask is not None:
+            attn = attn.masked_fill(mask, float("-inf"))
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+        x = attn @ v
+
+        x = x.transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class CrossAttention(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int = 8,
+        qkv_bias: bool = True,
+        qk_norm: bool = False,
+        attn_drop: float = 0.0,
+        proj_drop: float = 0.0,
+        norm_layer: nn.Module = nn.LayerNorm,
+    ) -> None:
+        super().__init__()
+        assert dim % num_heads == 0, "dim should be divisible by num_heads"
+        self.num_heads = num_heads
+        self.head_dim = dim // num_heads
+        self.scale = self.head_dim**-0.5
+
+        self.q = nn.Linear(dim, dim, bias=qkv_bias)
+        self.kv = nn.Linear(dim, dim * 2, bias=qkv_bias)
+        self.q_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+        self.k_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+    def forward(
+        self, x: torch.Tensor, y: torch.Tensor, mask: torch.Tensor | None = None
+    ) -> torch.Tensor:
+        B, N, C = y.shape
+        kv = (
+            self.kv(y)
+            .reshape(B, N, 2, self.num_heads, C // self.num_heads)
+            .permute(2, 0, 3, 1, 4)
+        )
+        k, v = kv.unbind(0)
+
+        B, N, C = x.shape
+        q = (
+            self.q(x)
+            .reshape(B, N, 1, self.num_heads, C // self.num_heads)
+            .permute(2, 0, 3, 1, 4)[0]
+        )
+
+        q, k = self.q_norm(q), self.k_norm(k)
+        q = q * self.scale
+        attn = q @ k.transpose(-2, -1)
+        if mask is not None:
+            attn = attn.masked_fill(mask, float("-inf"))
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+        x = attn @ v
+
+        x = x.transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class LayerScale(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        init_values: float = 1e-5,
+        inplace: bool = False,
+    ) -> None:
+        super().__init__()
+        self.inplace = inplace
+        self.gamma = nn.Parameter(init_values * torch.ones(dim))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x.mul_(self.gamma) if self.inplace else x * self.gamma
+
+
+class Block(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int,
+        mlp_ratio: float = 4.0,
+        qkv_bias: bool = True,
+        qk_norm: bool = False,
+        proj_drop: float = 0.0,
+        attn_drop: float = 0.0,
+        init_values: float | None = None,
+        drop_path: float = 0.0,
+        act_layer: nn.Module = nn.GELU,
+        norm_layer: nn.Module = nn.LayerNorm,
+    ) -> None:
+        super().__init__()
+        self.norm1 = norm_layer(dim)
+        self.attn = Attention(
+            dim,
+            num_heads=num_heads,
+            qkv_bias=qkv_bias,
+            qk_norm=qk_norm,
+            attn_drop=attn_drop,
+            proj_drop=proj_drop,
+            norm_layer=norm_layer,
+        )
+        self.ls1 = (
+            LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        )
+        self.drop_path1 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.norm2 = norm_layer(dim)
+        self.mlp = Mlp(
+            in_features=dim,
+            hidden_features=int(dim * mlp_ratio),
+            act_layer=act_layer,
+            drop=proj_drop,
+        )
+        self.ls2 = (
+            LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        )
+        self.drop_path2 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+    def forward(self, x, attn_mask=None):
+        x = x + self.drop_path1(self.ls1(self.attn(self.norm1(x), attn_mask)))
+        x = x + self.drop_path2(self.ls2(self.mlp(self.norm2(x))))
+        return x
+
+
+class CrossBlock(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int,
+        mlp_ratio: float = 4.0,
+        qkv_bias: bool = True,
+        qk_norm: bool = False,
+        proj_drop: float = 0.0,
+        attn_drop: float = 0.0,
+        init_values: float | None = None,
+        drop_path: float = 0.0,
+        act_layer: nn.Module = nn.GELU,
+        norm_layer: nn.Module = nn.LayerNorm,
+        stop_grad: bool = False,
+    ) -> None:
+        super().__init__()
+        self.norm1 = norm_layer(dim)
+        self.attn = CrossAttention(
+            dim,
+            num_heads=num_heads,
+            qkv_bias=qkv_bias,
+            qk_norm=qk_norm,
+            attn_drop=attn_drop,
+            proj_drop=proj_drop,
+            norm_layer=norm_layer,
+        )
+        self.ls1 = (
+            LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        )
+        self.drop_path1 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.norm2 = norm_layer(dim)
+        self.mlp = Mlp(
+            in_features=dim,
+            hidden_features=int(dim * mlp_ratio),
+            act_layer=act_layer,
+            drop=proj_drop,
+        )
+        self.ls2 = (
+            LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        )
+        self.drop_path2 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.stop_grad = stop_grad
+
+    def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        if self.stop_grad:
+            x = x + self.drop_path1(
+                self.ls1(self.attn(self.norm1(x), self.norm1(y.detach())))
+            )
+        else:
+            x = x + self.drop_path1(self.ls1(self.attn(self.norm1(x), self.norm1(y))))
+
+        x = x + self.drop_path2(self.ls2(self.mlp(self.norm2(x))))
+        return x
+
+
+class ReConBlocks(nn.Module):
+    def __init__(
+        self,
+        embed_dim: int = 768,
+        depth: int = 12,
+        num_heads: int = 12,
+        mlp_ratio: float = 4.0,
+        qkv_bias: bool = True,
+        qk_norm: bool = False,
+        init_values: float | None = None,
+        proj_drop: float = 0.0,
+        attn_drop_rate: float = 0.0,
+        drop_path_rate: list = [],
+        norm_layer: nn.Module = nn.LayerNorm,
+        act_layer: nn.Module = nn.GELU,
+        stop_grad: bool = False,
+        pretrained_model_name: str = "vit_base_patch32_clip_224.openai",
+        every_layer_add_pos: bool = True,
+    ):
+        super().__init__()
+
+        self.depth = depth
+        self.stop_grad = stop_grad
+        self.pretrained_model_name = pretrained_model_name
+        self.every_layer_add_pos = every_layer_add_pos
+        if "dino" in self.pretrained_model_name:
+            init_values = 1e-5
+        if "giant" in self.pretrained_model_name:
+            mlp_ratio = 48 / 11
+        self.local_blocks = nn.Sequential(*[
+            Block(
+                dim=embed_dim,
+                num_heads=num_heads,
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                qk_norm=qk_norm,
+                init_values=init_values,
+                proj_drop=proj_drop,
+                attn_drop=attn_drop_rate,
+                drop_path=drop_path_rate[i],
+                norm_layer=norm_layer,
+                act_layer=act_layer,
+            )
+            for i in range(depth)
+        ])
+
+        self.global_blocks = nn.Sequential(*[
+            CrossBlock(
+                dim=embed_dim,
+                num_heads=num_heads,
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                qk_norm=qk_norm,
+                init_values=init_values,
+                proj_drop=proj_drop,
+                attn_drop=attn_drop_rate,
+                drop_path=drop_path_rate[i],
+                norm_layer=norm_layer,
+                act_layer=act_layer,
+                stop_grad=stop_grad,
+            )
+            for i in range(depth)
+        ])
+
+    def load_pretrained_timm_weights(self):
+        model = timm.create_model(self.pretrained_model_name, pretrained=True)
+        state_dict = model.blocks.state_dict()
+        self.local_blocks.load_state_dict(state_dict, strict=True)
+
+        cross_state_dict = {}
+        for k, v in state_dict.items():
+            if "qkv" in k:
+                cross_state_dict[k.replace("qkv", "q")] = v[: int(v.shape[0] / 3)]
+                cross_state_dict[k.replace("qkv", "kv")] = v[int(v.shape[0] / 3) :]
+            else:
+                cross_state_dict[k] = v
+        self.global_blocks.load_state_dict(cross_state_dict, strict=True)
+
+    def forward(self, x, pos, attn_mask=None, query=None):
+        if self.every_layer_add_pos:
+            for i in range(self.depth):
+                x = self.local_blocks[i](x + pos, attn_mask)
+                if query is not None:
+                    query = self.global_blocks[i](query, x)
+        else:
+            x = x + pos
+            for i in range(self.depth):
+                x = self.local_blocks[i](x, attn_mask)
+                if query is not None:
+                    query = self.global_blocks[i](query, x)
+        return x, query
+
+
+class GPTExtractor(nn.Module):
+    def __init__(
+        self,
+        embed_dim: int = 768,
+        num_heads: int = 12,
+        depth: int = 12,
+        group_size: int = 32,
+        drop_path_rate: float = 0.0,
+        stop_grad: bool = False,
+        pretrained_model_name: str = "vit_base_patch32_clip_224.openai",
+    ):
+        super().__init__()
+
+        self.embed_dim = embed_dim
+        self.group_size = group_size
+
+        # start of sequence token
+        self.sos = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        self.sos_pos = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        nn.init.normal_(self.sos)
+        nn.init.normal_(self.sos_pos)
+
+        drop_path_rate = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]
+        self.blocks = ReConBlocks(
+            embed_dim=embed_dim,
+            num_heads=num_heads,
+            depth=depth,
+            drop_path_rate=drop_path_rate,
+            stop_grad=stop_grad,
+            pretrained_model_name=pretrained_model_name,
+        )
+
+        self.ln_f1 = nn.LayerNorm(embed_dim)
+        self.ln_f2 = nn.LayerNorm(embed_dim)
+
+    def forward(self, x, pos, attn_mask, query):
+        """
+        Expect input as shape [sequence len, batch]
+        """
+
+        batch, length, _ = x.shape
+
+        # prepend sos token
+        sos = self.sos.expand(batch, -1, -1)
+        sos_pos = self.sos_pos.expand(batch, -1, -1)
+
+        x = torch.cat([sos, x[:, :-1]], dim=1)
+        pos = torch.cat([sos_pos, pos[:, :-1]], dim=1)
+
+        # transformer
+        x, query = self.blocks(x, pos, attn_mask, query)
+
+        encoded_points = self.ln_f1(x)
+        query = self.ln_f2(query)
+
+        return encoded_points, query
+
+
+class GPTGenerator(nn.Module):
+    def __init__(
+        self,
+        embed_dim: int = 768,
+        num_heads: int = 12,
+        depth: int = 4,
+        group_size: int = 32,
+        drop_path_rate: float = 0.0,
+        input_channel: int = 3,
+    ):
+        super().__init__()
+
+        self.embed_dim = embed_dim
+        self.input_channel = input_channel
+
+        drop_path_rate = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]
+        self.blocks = nn.ModuleList([
+            Block(dim=embed_dim, num_heads=num_heads, drop_path=drop_path_rate[i])
+            for i in range(depth)
+        ])
+
+        self.ln_f = nn.LayerNorm(embed_dim)
+        self.increase_dim = nn.Sequential(
+            nn.Conv1d(embed_dim, input_channel * group_size, 1)
+        )
+
+    def forward(self, x, pos, attn_mask):
+        batch, length, C = x.shape
+
+        # transformer
+        for block in self.blocks:
+            x = block(x + pos, attn_mask)
+
+        x = self.ln_f(x)
+
+        rebuild_points = (
+            self.increase_dim(x.transpose(1, 2))
+            .transpose(1, 2)
+            .reshape(batch * length, -1, self.input_channel)
+        )
+
+        return rebuild_points
+
+
+class MAEExtractor(nn.Module):
+    def __init__(
+        self,
+        embed_dim: int = 768,
+        num_heads: int = 12,
+        depth: int = 12,
+        group_size: int = 32,
+        drop_path_rate: float = 0.0,
+        stop_grad: bool = False,
+        pretrained_model_name: str = "vit_base_patch32_clip_224.openai",
+    ):
+        super().__init__()
+
+        self.embed_dim = embed_dim
+        self.group_size = group_size
+
+        drop_path_rate = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]
+        self.blocks = ReConBlocks(
+            embed_dim=embed_dim,
+            num_heads=num_heads,
+            depth=depth,
+            drop_path_rate=drop_path_rate,
+            stop_grad=stop_grad,
+            pretrained_model_name=pretrained_model_name,
+        )
+
+        self.ln_f1 = nn.LayerNorm(embed_dim)
+        self.ln_f2 = nn.LayerNorm(embed_dim)
+
+    def forward(self, x, pos, mask=None, query=None):
+        """
+        Expect input as shape [sequence len, batch]
+        """
+
+        batch, length, C = x.shape
+        if mask is not None:
+            x_vis = x[~mask].reshape(batch, -1, C)
+            pos_vis = pos[~mask].reshape(batch, -1, C)
+        else:
+            x_vis = x
+            pos_vis = pos
+
+        # transformer
+        x_vis, query = self.blocks(x_vis, pos_vis, None, query)
+
+        encoded_points = self.ln_f1(x_vis)
+        query = self.ln_f2(query)
+
+        return encoded_points, query
+
+
+class MAEGenerator(nn.Module):
+    def __init__(
+        self,
+        embed_dim: int = 768,
+        num_heads: int = 12,
+        depth: int = 4,
+        group_size: int = 32,
+        drop_path_rate: float = 0.0,
+        input_channel: int = 3,
+    ):
+        super().__init__()
+
+        self.embed_dim = embed_dim
+        self.input_channel = input_channel
+        self.mask_token = nn.Parameter(torch.zeros(1, 1, self.embed_dim))
+
+        drop_path_rate = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]
+        self.blocks = nn.ModuleList([
+            Block(dim=embed_dim, num_heads=num_heads, drop_path=drop_path_rate[i])
+            for i in range(depth)
+        ])
+
+        self.ln_f = nn.LayerNorm(embed_dim)
+        self.increase_dim = nn.Sequential(
+            nn.Conv1d(embed_dim, input_channel * group_size, 1)
+        )
+
+    def forward(self, x_vis, pos, mask):
+        batch, length, C = x_vis.shape
+
+        pos_vis = pos[~mask].reshape(batch, -1, C)
+        pos_mask = pos[mask].reshape(batch, -1, C)
+        pos_full = torch.cat([pos_vis, pos_mask], dim=1)
+        mask_token = self.mask_token.expand(batch, pos_mask.shape[1], -1)
+        x = torch.cat([x_vis, mask_token], dim=1)
+
+        # transformer
+        for block in self.blocks:
+            x = block(x + pos_full)
+
+        x = self.ln_f(x[:, -pos_mask.shape[1] :])
+
+        rebuild_points = (
+            self.increase_dim(x.transpose(1, 2))
+            .transpose(1, 2)
+            .reshape(batch * pos_mask.shape[1], -1, self.input_channel)
+        )
+
+        return rebuild_points

backend/ReConV2/utils/checkpoint.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from collections import defaultdict
+from collections.abc import Iterable
+from typing import Any
+
+import torch.nn as nn
+from termcolor import colored
+
+
+def get_missing_parameters_message(keys: list[str]) -> str:
+    """
+    Get a logging-friendly message to report parameter names (keys) that are in
+    the model but not found in a checkpoint.
+    Args:
+        keys (list[str]): List of keys that were not found in the checkpoint.
+    Returns:
+        str: message.
+    """
+    groups = _group_checkpoint_keys(keys)
+    msg = "Some model parameters or buffers are not found in the checkpoint:\n"
+    msg += "\n".join(
+        "  " + colored(k + _group_to_str(v), "blue") for k, v in groups.items()
+    )
+    return msg
+
+
+def get_unexpected_parameters_message(keys: list[str]) -> str:
+    """
+    Get a logging-friendly message to report parameter names (keys) that are in
+    the checkpoint but not found in the model.
+    Args:
+        keys (list[str]): List of keys that were not found in the model.
+    Returns:
+        str: message.
+    """
+    groups = _group_checkpoint_keys(keys)
+    msg = "The checkpoint state_dict contains keys that are not used by the model:\n"
+    msg += "\n".join(
+        "  " + colored(k + _group_to_str(v), "magenta") for k, v in groups.items()
+    )
+    return msg
+
+
+def _strip_prefix_if_present(state_dict: dict[str, Any], prefix: str) -> None:
+    """
+    Strip the prefix in metadata, if any.
+    Args:
+        state_dict (OrderedDict): a state-dict to be loaded to the model.
+        prefix (str): prefix.
+    """
+    keys = sorted(state_dict.keys())
+    if not all(len(key) == 0 or key.startswith(prefix) for key in keys):
+        return
+
+    for key in keys:
+        newkey = key[len(prefix) :]
+        state_dict[newkey] = state_dict.pop(key)
+
+    # also strip the prefix in metadata, if any..
+    try:
+        metadata = state_dict._metadata  # pyre-ignore
+    except AttributeError:
+        pass
+    else:
+        for key in list(metadata.keys()):
+            # for the metadata dict, the key can be:
+            # '': for the DDP module, which we want to remove.
+            # 'module': for the actual model.
+            # 'module.xx.xx': for the rest.
+
+            if len(key) == 0:
+                continue
+            newkey = key[len(prefix) :]
+            metadata[newkey] = metadata.pop(key)
+
+
+def _group_checkpoint_keys(keys: list[str]) -> dict[str, list[str]]:
+    """
+    Group keys based on common prefixes. A prefix is the string up to the final
+    "." in each key.
+    Args:
+        keys (list[str]): list of parameter names, i.e. keys in the model
+            checkpoint dict.
+    Returns:
+        dict[list]: keys with common prefixes are grouped into lists.
+    """
+    groups = defaultdict(list)
+    for key in keys:
+        pos = key.rfind(".")
+        if pos >= 0:
+            head, tail = key[:pos], [key[pos + 1 :]]
+        else:
+            head, tail = key, []
+        groups[head].extend(tail)
+    return groups
+
+
+def _group_to_str(group: list[str]) -> str:
+    """
+    Format a group of parameter name suffixes into a loggable string.
+    Args:
+        group (list[str]): list of parameter name suffixes.
+    Returns:
+        str: formated string.
+    """
+    if len(group) == 0:
+        return ""
+
+    if len(group) == 1:
+        return "." + group[0]
+
+    return ".{" + ", ".join(group) + "}"
+
+
+def _named_modules_with_dup(
+    model: nn.Module, prefix: str = ""
+) -> Iterable[tuple[str, nn.Module]]:
+    """
+    The same as `model.named_modules()`, except that it includes
+    duplicated modules that have more than one name.
+    """
+    yield prefix, model
+    for name, module in model._modules.items():  # pyre-ignore
+        if module is None:
+            continue
+        submodule_prefix = prefix + ("." if prefix else "") + name
+        yield from _named_modules_with_dup(module, submodule_prefix)

backend/ReConV2/utils/config.py

@@ -0,0 +1,73 @@
+import os
+
+import yaml
+from easydict import EasyDict
+
+from .logger import print_log
+
+
+def log_args_to_file(args, pre="args", logger=None):
+    for key, val in args.__dict__.items():
+        print_log(f"{pre}.{key} : {val}", logger=logger)
+
+
+def log_config_to_file(cfg, pre="cfg", logger=None):
+    for key, val in cfg.items():
+        if isinstance(cfg[key], EasyDict):
+            print_log(f"{pre}.{key} = edict()", logger=logger)
+            log_config_to_file(cfg[key], pre=pre + "." + key, logger=logger)
+            continue
+        print_log(f"{pre}.{key} : {val}", logger=logger)
+
+
+def merge_new_config(config, new_config):
+    for key, val in new_config.items():
+        if not isinstance(val, dict):
+            if key == "_base_":
+                with open(new_config["_base_"]) as f:
+                    try:
+                        val = yaml.load(f, Loader=yaml.FullLoader)
+                    except:
+                        val = yaml.load(f)
+                config[key] = EasyDict()
+                merge_new_config(config[key], val)
+            else:
+                config[key] = val
+                continue
+        if key not in config:
+            config[key] = EasyDict()
+        merge_new_config(config[key], val)
+    return config
+
+
+def cfg_from_yaml_file(cfg_file):
+    config = EasyDict()
+    with open(cfg_file) as f:
+        try:
+            new_config = yaml.load(f, Loader=yaml.FullLoader)
+        except:
+            new_config = yaml.load(f)
+    merge_new_config(config=config, new_config=new_config)
+    return config
+
+
+def get_config(args, logger=None):
+    if args.resume:
+        cfg_path = os.path.join(args.experiment_path, "config.yaml")
+        if not os.path.exists(cfg_path):
+            print_log("Failed to resume", logger=logger)
+            raise FileNotFoundError()
+        print_log(f"Resume yaml from {cfg_path}", logger=logger)
+        args.config = cfg_path
+    config = cfg_from_yaml_file(args.config)
+    if not args.resume and args.local_rank == 0:
+        save_experiment_config(args, config, logger)
+    return config
+
+
+def save_experiment_config(args, config, logger=None):
+    config_path = os.path.join(args.experiment_path, "config.yaml")
+    os.system(f"cp {args.config} {config_path}")
+    print_log(
+        f"Copy the Config file from {args.config} to {config_path}", logger=logger
+    )

backend/ReConV2/utils/knn.py

@@ -0,0 +1,37 @@
+import torch
+
+
+def square_distance(src, dst):
+    """
+    Calculate Euclid distance between each two points.
+    src^T * dst = xn * xm + yn * ym + zn * zm；
+    sum(src^2, dim=-1) = xn*xn + yn*yn + zn*zn;
+    sum(dst^2, dim=-1) = xm*xm + ym*ym + zm*zm;
+    dist = (xn - xm)^2 + (yn - ym)^2 + (zn - zm)^2
+         = sum(src**2,dim=-1)+sum(dst**2,dim=-1)-2*src^T*dst
+    Input:
+        src: source points, [B, N, C]
+        dst: target points, [B, M, C]
+    Output:
+        dist: per-point square distance, [B, N, M]
+    """
+    B, N, _ = src.shape
+    _, M, _ = dst.shape
+    dist = -2 * torch.matmul(src, dst.permute(0, 2, 1))
+    dist += torch.sum(src**2, -1).view(B, N, 1)
+    dist += torch.sum(dst**2, -1).view(B, 1, M)
+    return dist
+
+
+def knn_point(nsample, xyz, new_xyz):
+    """
+    Input:
+        nsample: max sample number in local region
+        xyz: all points, [B, N, C]
+        new_xyz: query points, [B, S, C]
+    Return:
+        group_idx: grouped points index, [B, S, nsample]
+    """
+    sqrdists = square_distance(new_xyz, xyz)
+    _, group_idx = torch.topk(sqrdists, nsample, dim=-1, largest=False, sorted=False)
+    return group_idx

backend/ReConV2/utils/logger.py

@@ -0,0 +1,130 @@
+import logging
+
+import torch.distributed as dist
+
+logger_initialized = {}
+
+
+def get_root_logger(log_file=None, log_level=logging.INFO, name="main"):
+    """Get root logger and add a keyword filter to it.
+    The logger will be initialized if it has not been initialized. By default a
+    StreamHandler will be added. If `log_file` is specified, a FileHandler will
+    also be added. The name of the root logger is the top-level package name,
+    e.g., "mmdet3d".
+    Args:
+        log_file (str, optional): File path of log. Defaults to None.
+        log_level (int, optional): The level of logger.
+            Defaults to logging.INFO.
+        name (str, optional): The name of the root logger, also used as a
+            filter keyword. Defaults to 'mmdet3d'.
+    Returns:
+        :obj:`logging.Logger`: The obtained logger
+    """
+    logger = get_logger(name=name, log_file=log_file, log_level=log_level)
+    # add a logging filter
+    logging_filter = logging.Filter(name)
+    logging_filter.filter = lambda record: record.find(name) != -1
+
+    return logger
+
+
+def get_logger(name, log_file=None, log_level=logging.INFO, file_mode="w"):
+    """Initialize and get a logger by name.
+    If the logger has not been initialized, this method will initialize the
+    logger by adding one or two handlers, otherwise the initialized logger will
+    be directly returned. During initialization, a StreamHandler will always be
+    added. If `log_file` is specified and the process rank is 0, a FileHandler
+    will also be added.
+    Args:
+        name (str): Logger name.
+        log_file (str | None): The log filename. If specified, a FileHandler
+            will be added to the logger.
+        log_level (int): The logger level. Note that only the process of
+            rank 0 is affected, and other processes will set the level to
+            "Error" thus be silent most of the time.
+        file_mode (str): The file mode used in opening log file.
+            Defaults to 'w'.
+    Returns:
+        logging.Logger: The expected logger.
+    """
+    logger = logging.getLogger(name)
+    if name in logger_initialized:
+        return logger
+    # handle hierarchical names
+    # e.g., logger "a" is initialized, then logger "a.b" will skip the
+    # initialization since it is a child of "a".
+    for logger_name in logger_initialized:
+        if name.startswith(logger_name):
+            return logger
+
+    # handle duplicate logs to the console
+    # Starting in 1.8.0, PyTorch DDP attaches a StreamHandler <stderr> (NOTSET)
+    # to the root logger. As logger.propagate is True by default, this root
+    # level handler causes logging messages from rank>0 processes to
+    # unexpectedly show up on the console, creating much unwanted clutter.
+    # To fix this issue, we set the root logger's StreamHandler, if any, to log
+    # at the ERROR level.
+    for handler in logger.root.handlers:
+        if type(handler) is logging.StreamHandler:
+            handler.setLevel(logging.ERROR)
+
+    stream_handler = logging.StreamHandler()
+    handlers = [stream_handler]
+
+    if dist.is_available() and dist.is_initialized():
+        rank = dist.get_rank()
+    else:
+        rank = 0
+
+    # only rank 0 will add a FileHandler
+    if rank == 0 and log_file is not None:
+        # Here, the default behaviour of the official logger is 'a'. Thus, we
+        # provide an interface to change the file mode to the default
+        # behaviour.
+        file_handler = logging.FileHandler(log_file, file_mode)
+        handlers.append(file_handler)
+
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    for handler in handlers:
+        handler.setFormatter(formatter)
+        handler.setLevel(log_level)
+        logger.addHandler(handler)
+
+    if rank == 0:
+        logger.setLevel(log_level)
+    else:
+        logger.setLevel(logging.ERROR)
+
+    logger_initialized[name] = True
+
+    return logger
+
+
+def print_log(msg, logger=None, level=logging.INFO):
+    """Print a log message.
+    Args:
+        msg (str): The message to be logged.
+        logger (logging.Logger | str | None): The logger to be used.
+            Some special loggers are:
+            - "silent": no message will be printed.
+            - other str: the logger obtained with `get_root_logger(logger)`.
+            - None: The `print()` method will be used to print log messages.
+        level (int): Logging level. Only available when `logger` is a Logger
+            object or "root".
+    """
+    if logger is None:
+        print(msg)
+    elif isinstance(logger, logging.Logger):
+        logger.log(level, msg)
+    elif logger == "silent":
+        pass
+    elif isinstance(logger, str):
+        _logger = get_logger(logger)
+        _logger.log(level, msg)
+    else:
+        raise TypeError(
+            "logger should be either a logging.Logger object, str, "
+            f'"silent" or None, but got {type(logger)}'
+        )

backend/ReConV2/utils/misc.py

@@ -0,0 +1,287 @@
+import os
+import random
+from collections import abc
+
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from mpl_toolkits.mplot3d import Axes3D
+
+
+def fps(data: torch.Tensor, number: int) -> torch.Tensor:
+    B, N, _ = data.shape
+    device = data.device
+
+    centroids = torch.empty(B, number, dtype=torch.long, device=device)
+    distances = torch.full((B, N), float("inf"), device=device)
+    farthest = torch.randint(0, N, (B,), device=device)  # случайная первая
+
+    for i in range(number):
+        centroids[:, i] = farthest
+
+        centroid = data[torch.arange(B, device=device), farthest]  # (B,3)
+        dist = torch.sum((data - centroid[:, None, :]) ** 2, dim=-1)
+
+        distances = torch.minimum(distances, dist)
+        farthest = torch.max(distances, dim=1).indices  # чуть короче
+        # (или .indices в ≥1.10)
+    return data.gather(1, centroids[..., None].expand(-1, -1, 3))
+
+
+def worker_init_fn(worker_id):
+    np.random.seed(np.random.get_state()[1][0] + worker_id)
+
+
+def build_lambda_sche(opti, config):
+    if config.get("decay_step") is not None:
+
+        def lr_lbmd(e):
+            return max(config.lr_decay ** (e / config.decay_step), config.lowest_decay)
+
+        scheduler = torch.optim.lr_scheduler.LambdaLR(opti, lr_lbmd)
+    else:
+        raise NotImplementedError()
+    return scheduler
+
+
+def build_lambda_bnsche(model, config):
+    if config.get("decay_step") is not None:
+
+        def bnm_lmbd(e):
+            return max(
+                config.bn_momentum * config.bn_decay ** (e / config.decay_step),
+                config.lowest_decay,
+            )
+
+        bnm_scheduler = BNMomentumScheduler(model, bnm_lmbd)
+    else:
+        raise NotImplementedError()
+    return bnm_scheduler
+
+
+def set_random_seed(seed, deterministic=False):
+    """Set random seed.
+    Args:
+        seed (int): Seed to be used.
+        deterministic (bool): Whether to set the deterministic option for
+            CUDNN backend, i.e., set `torch.backends.cudnn.deterministic`
+            to True and `torch.backends.cudnn.benchmark` to False.
+            Default: False.
+
+    # Speed-reproducibility tradeoff https://pytorch.org/docs/stable/notes/randomness.html
+    if cuda_deterministic:  # slower, more reproducible
+        cudnn.deterministic = True
+        cudnn.benchmark = False
+    else:  # faster, less reproducible
+        cudnn.deterministic = False
+        cudnn.benchmark = True
+
+    """
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    if deterministic:
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+
+
+def is_seq_of(seq, expected_type, seq_type=None):
+    """Check whether it is a sequence of some type.
+    Args:
+        seq (Sequence): The sequence to be checked.
+        expected_type (type): Expected type of sequence items.
+        seq_type (type, optional): Expected sequence type.
+    Returns:
+        bool: Whether the sequence is valid.
+    """
+    if seq_type is None:
+        exp_seq_type = abc.Sequence
+    else:
+        assert isinstance(seq_type, type)
+        exp_seq_type = seq_type
+    if not isinstance(seq, exp_seq_type):
+        return False
+    for item in seq:
+        if not isinstance(item, expected_type):
+            return False
+    return True
+
+
+def set_bn_momentum_default(bn_momentum):
+    def fn(m):
+        if isinstance(m, nn.BatchNorm1d | nn.BatchNorm2d | nn.BatchNorm3d):
+            m.momentum = bn_momentum
+
+    return fn
+
+
+class BNMomentumScheduler:
+    def __init__(self, model, bn_lambda, last_epoch=-1, setter=set_bn_momentum_default):
+        if not isinstance(model, nn.Module):
+            raise RuntimeError(
+                f"Class '{type(model).__name__}' is not a PyTorch nn Module"
+            )
+
+        self.model = model
+        self.setter = setter
+        self.lmbd = bn_lambda
+
+        self.step(last_epoch + 1)
+        self.last_epoch = last_epoch
+
+    def step(self, epoch=None):
+        if epoch is None:
+            epoch = self.last_epoch + 1
+
+        self.last_epoch = epoch
+        self.model.apply(self.setter(self.lmbd(epoch)))
+
+    def get_momentum(self, epoch=None):
+        if epoch is None:
+            epoch = self.last_epoch + 1
+        return self.lmbd(epoch)
+
+
+def seprate_point_cloud(xyz, num_points, crop, fixed_points=None, padding_zeros=False):
+    """
+    seprate point cloud: usage : using to generate the incomplete point cloud with a setted number.
+    """
+    _, n, c = xyz.shape
+
+    assert n == num_points
+    assert c == 3
+    if crop == num_points:
+        return xyz, None
+
+    INPUT = []
+    CROP = []
+    for points in xyz:
+        if isinstance(crop, list):
+            num_crop = random.randint(crop[0], crop[1])
+        else:
+            num_crop = crop
+
+        points = points.unsqueeze(0)
+
+        if fixed_points is None:
+            center = F.normalize(torch.randn(1, 1, 3), p=2, dim=-1).cuda()
+        else:
+            if isinstance(fixed_points, list):
+                fixed_point = random.sample(fixed_points, 1)[0]
+            else:
+                fixed_point = fixed_points
+            center = fixed_point.reshape(1, 1, 3).cuda()
+
+        distance_matrix = torch.norm(
+            center.unsqueeze(2) - points.unsqueeze(1), p=2, dim=-1
+        )  # 1 1 2048
+
+        idx = torch.argsort(distance_matrix, dim=-1, descending=False)[0, 0]  # 2048
+
+        if padding_zeros:
+            input_data = points.clone()
+            input_data[0, idx[:num_crop]] = input_data[0, idx[:num_crop]] * 0
+
+        else:
+            input_data = points.clone()[0, idx[num_crop:]].unsqueeze(0)  # 1 N 3
+
+        crop_data = points.clone()[0, idx[:num_crop]].unsqueeze(0)
+
+        if isinstance(crop, list):
+            INPUT.append(fps(input_data, 2048))
+            CROP.append(fps(crop_data, 2048))
+        else:
+            INPUT.append(input_data)
+            CROP.append(crop_data)
+
+    input_data = torch.cat(INPUT, dim=0)  # B N 3
+    crop_data = torch.cat(CROP, dim=0)  # B M 3
+
+    return input_data.contiguous(), crop_data.contiguous()
+
+
+def get_ptcloud_img(ptcloud, roll, pitch):
+    fig = plt.figure(figsize=(8, 8))
+
+    x, z, y = ptcloud.transpose(1, 0)
+    ax = fig.gca(projection=Axes3D.name, adjustable="box")
+    ax.axis("off")
+    # ax.axis('scaled')
+    ax.view_init(roll, pitch)
+    max, min = np.max(ptcloud), np.min(ptcloud)
+    ax.set_xbound(min, max)
+    ax.set_ybound(min, max)
+    ax.set_zbound(min, max)
+    ax.scatter(x, y, z, zdir="z", c=y, cmap="jet")
+
+    fig.canvas.draw()
+    img = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep="")
+    img = img.reshape(fig.canvas.get_width_height()[::-1] + (3,))
+    return img
+
+
+def visualize_KITTI(
+    path,
+    data_list,
+    titles=["input", "pred"],
+    cmap=["bwr", "autumn"],
+    zdir="y",
+    xlim=(-1, 1),
+    ylim=(-1, 1),
+    zlim=(-1, 1),
+):
+    fig = plt.figure(figsize=(6 * len(data_list), 6))
+    cmax = data_list[-1][:, 0].max()
+
+    for i in range(len(data_list)):
+        data = data_list[i][:-2048] if i == 1 else data_list[i]
+        color = data[:, 0] / cmax
+        ax = fig.add_subplot(1, len(data_list), i + 1, projection="3d")
+        ax.view_init(30, -120)
+        ax.scatter(
+            data[:, 0],
+            data[:, 1],
+            data[:, 2],
+            zdir=zdir,
+            c=color,
+            vmin=-1,
+            vmax=1,
+            cmap=cmap[0],
+            s=4,
+            linewidth=0.05,
+            edgecolors="black",
+        )
+        ax.set_title(titles[i])
+
+        ax.set_axis_off()
+        ax.set_xlim(xlim)
+        ax.set_ylim(ylim)
+        ax.set_zlim(zlim)
+    plt.subplots_adjust(left=0, right=1, bottom=0, top=1, wspace=0.2, hspace=0)
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+    pic_path = path + ".png"
+    fig.savefig(pic_path)
+
+    np.save(os.path.join(path, "input.npy"), data_list[0].numpy())
+    np.save(os.path.join(path, "pred.npy"), data_list[1].numpy())
+    plt.close(fig)
+
+
+def random_dropping(pc, e):
+    up_num = max(64, 768 // (e // 50 + 1))
+    pc = pc
+    random_num = torch.randint(1, up_num, (1, 1))[0, 0]
+    pc = fps(pc, random_num)
+    padding = torch.zeros(pc.size(0), 2048 - pc.size(1), 3).to(pc.device)
+    pc = torch.cat([pc, padding], dim=1)
+    return pc
+
+
+def random_scale(partial, scale_range=[0.8, 1.2]):
+    scale = torch.rand(1).cuda() * (scale_range[1] - scale_range[0]) + scale_range[0]
+    return partial * scale

backend/ReConV2/utils/registry.py

@@ -0,0 +1,290 @@
+import inspect
+import warnings
+from functools import partial
+
+from ReConV2.utils import config
+
+
+class Registry:
+    """A registry to map strings to classes.
+    Registered object could be built from registry.
+    Example:
+        >>> MODELS = Registry('models')
+        >>> @MODELS.register_module()
+        >>> class ResNet:
+        >>>     pass
+        >>> resnet = MODELS.build(dict(NAME='ResNet'))
+    Please refer to https://mmcv.readthedocs.io/en/latest/registry.html for
+    advanced useage.
+    Args:
+        name (str): Registry name.
+        build_func(func, optional): Build function to construct instance from
+            Registry, func:`build_from_cfg` is used if neither ``parent`` or
+            ``build_func`` is specified. If ``parent`` is specified and
+            ``build_func`` is not given,  ``build_func`` will be inherited
+            from ``parent``. Default: None.
+        parent (Registry, optional): Parent registry. The class registered in
+            children registry could be built from parent. Default: None.
+        scope (str, optional): The scope of registry. It is the key to search
+            for children registry. If not specified, scope will be the name of
+            the package where class is defined, e.g. mmdet, mmcls, mmseg.
+            Default: None.
+    """
+
+    def __init__(self, name, build_func=None, parent=None, scope=None):
+        self._name = name
+        self._module_dict = dict()
+        self._children = dict()
+        self._scope = self.infer_scope() if scope is None else scope
+
+        # self.build_func will be set with the following priority:
+        # 1. build_func
+        # 2. parent.build_func
+        # 3. build_from_cfg
+        if build_func is None:
+            if parent is not None:
+                self.build_func = parent.build_func
+            else:
+                self.build_func = build_from_cfg
+        else:
+            self.build_func = build_func
+        if parent is not None:
+            assert isinstance(parent, Registry)
+            parent._add_children(self)
+            self.parent = parent
+        else:
+            self.parent = None
+
+    def __len__(self):
+        return len(self._module_dict)
+
+    def __contains__(self, key):
+        return self.get(key) is not None
+
+    def __repr__(self):
+        format_str = (
+            self.__class__.__name__ + f"(name={self._name}, items={self._module_dict})"
+        )
+        return format_str
+
+    @staticmethod
+    def infer_scope():
+        """Infer the scope of registry.
+        The name of the package where registry is defined will be returned.
+        Example:
+            # in mmdet/models/backbone/resnet.py
+            >>> MODELS = Registry('models')
+            >>> @MODELS.register_module()
+            >>> class ResNet:
+            >>>     pass
+            The scope of ``ResNet`` will be ``mmdet``.
+        Returns:
+            scope (str): The inferred scope name.
+        """
+        # inspect.stack() trace where this function is called, the index-2
+        # indicates the frame where `infer_scope()` is called
+        filename = inspect.getmodule(inspect.stack()[2][0]).__name__
+        split_filename = filename.split(".")
+        return split_filename[0]
+
+    @staticmethod
+    def split_scope_key(key):
+        """Split scope and key.
+        The first scope will be split from key.
+        Examples:
+            >>> Registry.split_scope_key('mmdet.ResNet')
+            'mmdet', 'ResNet'
+            >>> Registry.split_scope_key('ResNet')
+            None, 'ResNet'
+        Return:
+            scope (str, None): The first scope.
+            key (str): The remaining key.
+        """
+        split_index = key.find(".")
+        if split_index != -1:
+            return key[:split_index], key[split_index + 1 :]
+        else:
+            return None, key
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def scope(self):
+        return self._scope
+
+    @property
+    def module_dict(self):
+        return self._module_dict
+
+    @property
+    def children(self):
+        return self._children
+
+    def get(self, key):
+        """Get the registry record.
+        Args:
+            key (str): The class name in string format.
+        Returns:
+            class: The corresponding class.
+        """
+        scope, real_key = self.split_scope_key(key)
+        if scope is None or scope == self._scope:
+            # get from self
+            if real_key in self._module_dict:
+                return self._module_dict[real_key]
+        else:
+            # get from self._children
+            if scope in self._children:
+                return self._children[scope].get(real_key)
+            else:
+                # goto root
+                parent = self.parent
+                while parent.parent is not None:
+                    parent = parent.parent
+                return parent.get(key)
+
+    def build(self, *args, **kwargs):
+        return self.build_func(*args, **kwargs, registry=self)
+
+    def _add_children(self, registry):
+        """Add children for a registry.
+        The ``registry`` will be added as children based on its scope.
+        The parent registry could build objects from children registry.
+        Example:
+            >>> models = Registry('models')
+            >>> mmdet_models = Registry('models', parent=models)
+            >>> @mmdet_models.register_module()
+            >>> class ResNet:
+            >>>     pass
+            >>> resnet = models.build(dict(NAME='mmdet.ResNet'))
+        """
+
+        assert isinstance(registry, Registry)
+        assert registry.scope is not None
+        assert registry.scope not in self.children, (
+            f"scope {registry.scope} exists in {self.name} registry"
+        )
+        self.children[registry.scope] = registry
+
+    def _register_module(self, module_class, module_name=None, force=False):
+        if not inspect.isclass(module_class):
+            raise TypeError(f"module must be a class, but got {type(module_class)}")
+
+        if module_name is None:
+            module_name = module_class.__name__
+        if isinstance(module_name, str):
+            module_name = [module_name]
+        for name in module_name:
+            if not force and name in self._module_dict:
+                raise KeyError(f"{name} is already registered in {self.name}")
+            self._module_dict[name] = module_class
+
+    def deprecated_register_module(self, cls=None, force=False):
+        warnings.warn(
+            "The old API of register_module(module, force=False) "
+            "is deprecated and will be removed, please use the new API "
+            "register_module(name=None, force=False, module=None) instead."
+        )
+        if cls is None:
+            return partial(self.deprecated_register_module, force=force)
+        self._register_module(cls, force=force)
+        return cls
+
+    def register_module(self, name=None, force=False, module=None):
+        """Register a module.
+        A record will be added to `self._module_dict`, whose key is the class
+        name or the specified name, and value is the class itself.
+        It can be used as a decorator or a normal function.
+        Example:
+            >>> backbones = Registry('backbone')
+            >>> @backbones.register_module()
+            >>> class ResNet:
+            >>>     pass
+            >>> backbones = Registry('backbone')
+            >>> @backbones.register_module(name='mnet')
+            >>> class MobileNet:
+            >>>     pass
+            >>> backbones = Registry('backbone')
+            >>> class ResNet:
+            >>>     pass
+            >>> backbones.register_module(ResNet)
+        Args:
+            name (str | None): The module name to be registered. If not
+                specified, the class name will be used.
+            force (bool, optional): Whether to override an existing class with
+                the same name. Default: False.
+            module (type): Module class to be registered.
+        """
+        if not isinstance(force, bool):
+            raise TypeError(f"force must be a boolean, but got {type(force)}")
+        # NOTE: This is a walkaround to be compatible with the old api,
+        # while it may introduce unexpected bugs.
+        if isinstance(name, type):
+            return self.deprecated_register_module(name, force=force)
+
+        # raise the error ahead of time
+        if not (name is None or isinstance(name, str) or misc.is_seq_of(name, str)):
+            raise TypeError(
+                "name must be either of None, an instance of str or a sequence"
+                f"  of str, but got {type(name)}"
+            )
+
+        # use it as a normal method: x.register_module(module=SomeClass)
+        if module is not None:
+            self._register_module(module_class=module, module_name=name, force=force)
+            return module
+
+        # use it as a decorator: @x.register_module()
+        def _register(cls):
+            self._register_module(module_class=cls, module_name=name, force=force)
+            return cls
+
+        return _register
+
+
+def build_from_cfg(cfg, registry, default_args=None):
+    """Build a module from config dict.
+    Args:
+        cfg (edict): Config dict. It should at least contain the key "NAME".
+        registry (:obj:`Registry`): The registry to search the type from.
+    Returns:
+        object: The constructed object.
+    """
+    if not isinstance(cfg, dict):
+        raise TypeError(f"cfg must be a dict, but got {type(cfg)}")
+    if "NAME" not in cfg:
+        if default_args is None or "NAME" not in default_args:
+            raise KeyError(
+                '`cfg` or `default_args` must contain the key "NAME", '
+                f"but got {cfg}\n{default_args}"
+            )
+    if not isinstance(registry, Registry):
+        raise TypeError(
+            f"registry must be an mmcv.Registry object, but got {type(registry)}"
+        )
+
+    if not (isinstance(default_args, dict) or default_args is None):
+        raise TypeError(
+            f"default_args must be a dict or None, but got {type(default_args)}"
+        )
+
+    if default_args is not None:
+        cfg = config.merge_new_config(cfg, default_args)
+
+    obj_type = cfg.get("NAME")
+
+    if isinstance(obj_type, str):
+        obj_cls = registry.get(obj_type)
+        if obj_cls is None:
+            raise KeyError(f"{obj_type} is not in the {registry.name} registry")
+    elif inspect.isclass(obj_type):
+        obj_cls = obj_type
+    else:
+        raise TypeError(f"type must be a str or valid type, but got {type(obj_type)}")
+    try:
+        return obj_cls(cfg)
+    except Exception as e:
+        # Normal TypeError does not print class name.
+        raise type(e)(f"{obj_cls.__name__}: {e}")

backend/cad_retrieval_utils/__init__.py

@@ -0,0 +1,3 @@
+from .inference import make_submission
+
+__all__ = ["make_submission"]

backend/cad_retrieval_utils/augmentations.py

@@ -0,0 +1,15 @@
+from typing import cast
+
+import torchvision.transforms as T
+
+from .type_defs import ImageTransform
+
+
+def build_img_transforms(img_size: int) -> ImageTransform:
+    transform = T.Compose([
+        T.Resize(img_size),
+        T.CenterCrop(img_size),
+        T.ToTensor(),
+        T.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
+    ])
+    return cast(ImageTransform, transform)

backend/cad_retrieval_utils/configs/config.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+
+import torch
+from easydict import EasyDict as edict
+
+CONFIG = edict()
+
+# --- Конфиг pretrained модели Recon для загрузки ---
+CONFIG.model = edict({
+    "NAME": "ReCon2",
+    "group_size": 32,
+    "num_group": 512,
+    "mask_ratio": 0.7,
+    "mask_type": "rand",
+    "embed_dim": 1024,
+    "depth": 24,
+    "drop_path_rate": 0.2,
+    "num_heads": 16,
+    "decoder_depth": 4,
+    "with_color": True,
+    "stop_grad": False,
+    "large_embedding": False,
+    "img_queries": 13,
+    "text_queries": 3,
+    "contrast_type": "byol",
+    "pretrained_model_name": "eva_large_patch14_336.in22k_ft_in22k_in1k",
+})
+
+# --- Общие параметры ---
+CONFIG.npoints = 10_000
+CONFIG.emb_dim = 1280
+CONFIG.img_size = 336
+CONFIG.seed = 42
+CONFIG.device = torch.device("cpu")
+CONFIG.text_ratio = 0.3
+
+# --- Параметры инференса ---
+CONFIG.infer_img_batch_size = 32
+CONFIG.infer_pc_batch_size = 16
+CONFIG.infer_text_batch_size = 32
+
+# --- Параметры для MoE ---
+CONFIG.train_params = edict()
+CONFIG.train_params.n_experts = 8
+
+# --- Пути ---
+CONFIG.paths = edict()
+CONFIG.paths.test_data_root = Path("/kaggle/input/test-final/test")
+CONFIG.paths.submission_save_file = Path("./submission.csv")
+
+# Эти пути будут перезаписаны из командной строки inference_runner.py
+CONFIG.paths.model_spec = {
+    "text_proj": None,
+    "text_encoder": None,
+    "moe": None,
+    "pc_encoder": None
+}

backend/cad_retrieval_utils/datasets.py

@@ -0,0 +1,80 @@
+from pathlib import Path
+
+import numpy as np
+import torch
+import trimesh
+from PIL import Image
+from torch.utils.data import Dataset
+
+from .type_defs import ImageTransform
+
+
+def normalize_pc(pc: np.ndarray) -> np.ndarray:
+    centroid = np.mean(pc, axis=0)
+    pc = pc - centroid
+    m = np.max(np.sqrt(np.sum(pc**2, axis=1)))
+    if m < 1e-6:
+        return pc
+    pc = pc / m
+    return pc
+
+
+def create_pc_tensor_with_dummy_color(pc: np.ndarray, npoints: int) -> torch.Tensor:
+    pc_with_dummy_color = np.zeros((npoints, 6), dtype=np.float32)
+    pc_with_dummy_color[:, :3] = pc
+    # Модель ReConV2 ожидает 6 каналов (XYZ + RGB), добавляем нейтральный серый
+    pc_with_dummy_color[:, 3:6] = 0.5
+    return torch.from_numpy(pc_with_dummy_color).float()
+
+
+def load_mesh_safe(mesh_path: Path, npoints: int, seed: int) -> np.ndarray:
+    """Безопасная загрузка меша с обработкой Scene объектов"""
+    mesh_data = trimesh.load(str(mesh_path))
+    mesh = mesh_data.to_mesh() if isinstance(mesh_data, trimesh.Scene) else mesh_data
+    pc, _ = trimesh.sample.sample_surface(mesh, npoints, seed=seed)
+    return np.array(pc, dtype=np.float32)
+
+
+class InferenceMeshDataset(Dataset):
+    def __init__(self, file_paths: list[str], npoints: int, base_seed: int = 42) -> None:
+        self.file_paths = file_paths
+        self.npoints = npoints
+        self.base_seed = base_seed
+
+    def __len__(self) -> int:
+        return len(self.file_paths)
+
+    def __getitem__(self, idx: int) -> torch.Tensor:
+        pc_path = Path(self.file_paths[idx])
+        sample_seed = self.base_seed + idx
+        pc = load_mesh_safe(pc_path, self.npoints, sample_seed)
+        pc = normalize_pc(pc)
+        return create_pc_tensor_with_dummy_color(pc, self.npoints)
+
+
+class InferenceImageDataset(Dataset):
+    def __init__(self, file_paths: list[str], transform: ImageTransform) -> None:
+        self.file_paths = file_paths
+        self.transform = transform
+
+    def __len__(self) -> int:
+        return len(self.file_paths)
+
+    def __getitem__(self, idx: int) -> torch.Tensor:
+        img_path = self.file_paths[idx]
+        img = Image.open(img_path).convert("RGB")
+        return self.transform(img)
+
+
+class InferenceTextDataset(Dataset):
+    def __init__(self, file_paths: list[str]) -> None:
+        self.texts = []
+        for path in file_paths:
+            with open(path) as f:
+                self.texts.append(f.read().strip())
+
+    def __len__(self) -> int:
+        return len(self.texts)
+
+    def __getitem__(self, idx: int) -> str:
+        return self.texts[idx]

backend/cad_retrieval_utils/evaluation.py

@@ -0,0 +1,43 @@
+import numpy as np
+import torch
+from easydict import EasyDict as edict
+from torch.utils.data import DataLoader
+from tqdm.auto import tqdm
+
+from .models import ImageEncoder, InferencePcEncoder, InferenceTextEncoder
+from .type_defs import EmbeddingArray
+
+
+@torch.no_grad()
+def get_inference_embeddings_text(
+    model: InferenceTextEncoder, loader: DataLoader, config: edict
+) -> EmbeddingArray:
+    all_embs = []
+    for batch in tqdm(loader, desc="Извлечение text эмбеддингов"):
+        embs = model.encode_text(batch, normalize=True)
+        all_embs.append(embs.cpu().numpy())
+    return np.vstack(all_embs)
+
+
+@torch.no_grad()
+def get_inference_embeddings_mesh(
+    model: InferencePcEncoder, loader: DataLoader, config: edict
+) -> EmbeddingArray:
+    all_embs = []
+    for batch in tqdm(loader, desc="Извлечение mesh эмбеддингов"):
+        batch = batch.to(config.device)
+        embs = model.encode_pc(batch, normalize=True)
+        all_embs.append(embs.cpu().numpy())
+    return np.vstack(all_embs)
+
+
+@torch.no_grad()
+def get_inference_embeddings_image(
+    model: ImageEncoder, loader: DataLoader, config: edict
+) -> EmbeddingArray:
+    all_embs = []
+    for batch in tqdm(loader, desc="Извлечение image эмбеддингов"):
+        batch = batch.to(config.device)
+        embs = model.encode_image(batch, normalize=True)
+        all_embs.append(embs.cpu().numpy())
+    return np.vstack(all_embs)

backend/cad_retrieval_utils/inference.py

@@ -0,0 +1,242 @@
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from easydict import EasyDict as edict
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.preprocessing import normalize
+from torch.utils.data import DataLoader
+
+from .augmentations import build_img_transforms
+from .datasets import InferenceImageDataset, InferenceMeshDataset, InferenceTextDataset
+from .evaluation import (
+    get_inference_embeddings_image,
+    get_inference_embeddings_mesh,
+    get_inference_embeddings_text,
+)
+from .models import ImageEncoder, InferencePcEncoder, InferenceTextEncoder
+from .type_defs import CheckpointSpec
+
+
+# --- Загрузчики моделей ---
+def load_text_encoder(spec: CheckpointSpec, config: edict) -> InferenceTextEncoder:
+    text_encoder = InferenceTextEncoder(config).to(config.device)
+    text_encoder.load_text_weights(str(spec["text_proj"]), str(spec["text_encoder"]))
+    text_encoder.eval()
+    return text_encoder
+
+
+def load_pc_encoder(spec: CheckpointSpec, config: edict) -> InferencePcEncoder:
+    pc_encoder = InferencePcEncoder(config).to(config.device)
+    pc_encoder.load_pc_encoder_weights(str(spec["pc_encoder"]))
+    pc_encoder.eval()
+    return pc_encoder
+
+
+def load_image_encoder(spec: CheckpointSpec, config: edict) -> ImageEncoder:
+    img_encoder = ImageEncoder(config).to(config.device)
+    img_encoder.load_moe_weights(str(spec["moe"]))
+    img_encoder.eval()
+    return img_encoder
+
+
+# --- Подготовка данных ---
+def prepare_all_data(config: edict) -> dict:
+    test_root = Path(config.paths.test_data_root)
+    img_transform = build_img_transforms(config.img_size)
+    data_loaders = {}
+    data_ids = {}
+
+    # Image-to-Mesh
+    q_img_paths = sorted(test_root.joinpath("queries_image_to_mesh").glob("*.png"))
+    g_mesh_for_img_paths = sorted(test_root.joinpath("gallery_mesh_for_image").glob("*.stl"))
+    data_loaders['q_img'] = DataLoader(InferenceImageDataset([str(p) for p in q_img_paths], img_transform),
+                                       batch_size=config.infer_img_batch_size, shuffle=False)
+    data_loaders['g_mesh_for_img'] = DataLoader(
+        InferenceMeshDataset([str(p) for p in g_mesh_for_img_paths], config.npoints, config.seed),
+        batch_size=config.infer_pc_batch_size, shuffle=False)
+    data_ids['q_img'] = [p.stem for p in q_img_paths]
+    data_ids['g_mesh_for_img'] = [p.stem for p in g_mesh_for_img_paths]
+
+    # Mesh-to-Image
+    q_mesh_to_img_paths = sorted(test_root.joinpath("queries_mesh_to_image").glob("*.stl"))
+    g_img_for_mesh_paths = sorted(test_root.joinpath("gallery_image_for_mesh").glob("*.png"))
+    data_loaders['q_mesh_to_img'] = DataLoader(
+        InferenceMeshDataset([str(p) for p in q_mesh_to_img_paths], config.npoints, config.seed),
+        batch_size=config.infer_pc_batch_size, shuffle=False)
+    data_loaders['g_img_for_mesh'] = DataLoader(
+        InferenceImageDataset([str(p) for p in g_img_for_mesh_paths], img_transform),
+        batch_size=config.infer_img_batch_size, shuffle=False)
+    data_ids['q_mesh_to_img'] = [p.stem for p in q_mesh_to_img_paths]
+    data_ids['g_img_for_mesh_paths'] = g_img_for_mesh_paths  # Нужны полные пути для группировки
+
+    # Text-to-Mesh
+    q_text_paths = sorted(test_root.joinpath("queries_text_to_mesh").glob("*.txt"))
+    g_mesh_for_text_paths = sorted(test_root.joinpath("gallery_mesh_for_text").glob("*.stl"))
+    data_loaders['q_text'] = DataLoader(InferenceTextDataset([str(p) for p in q_text_paths]),
+                                        batch_size=config.infer_text_batch_size, shuffle=False)
+    data_loaders['g_mesh_for_text'] = DataLoader(
+        InferenceMeshDataset([str(p) for p in g_mesh_for_text_paths], config.npoints, config.seed),
+        batch_size=config.infer_pc_batch_size, shuffle=False)
+    data_ids['q_text'] = [p.stem for p in q_text_paths]
+    data_ids['g_mesh_for_text'] = [p.stem for p in g_mesh_for_text_paths]
+
+    # Mesh-to-Text
+    q_mesh_to_text_paths = sorted(test_root.joinpath("queries_mesh_to_text").glob("*.stl"))
+    g_text_for_mesh_paths = sorted(test_root.joinpath("gallery_text_for_mesh").glob("*.txt"))
+    data_loaders['q_mesh_to_text'] = DataLoader(
+        InferenceMeshDataset([str(p) for p in q_mesh_to_text_paths], config.npoints, config.seed),
+        batch_size=config.infer_pc_batch_size, shuffle=False)
+    data_loaders['g_text_for_mesh'] = DataLoader(InferenceTextDataset([str(p) for p in g_text_for_mesh_paths]),
+                                                 batch_size=config.infer_text_batch_size, shuffle=False)
+    data_ids['q_mesh_to_text'] = [p.stem for p in q_mesh_to_text_paths]
+    data_ids['g_text_for_mesh'] = [p.stem for p in g_text_for_mesh_paths]
+
+    return data_loaders, data_ids
+
+
+# --- Решатели задач ---
+def solve_img2mesh(loaders, ids, model_spec, config) -> pd.DataFrame:
+    print("  🖼️ → 📦 Image-to-Mesh: получение эмбеддингов...")
+    img_encoder = load_image_encoder(model_spec, config)
+    pc_encoder = load_pc_encoder(model_spec, config)
+
+    query_embs = get_inference_embeddings_image(img_encoder, loaders['q_img'], config)
+    gallery_embs = get_inference_embeddings_mesh(pc_encoder, loaders['g_mesh_for_img'], config)
+
+    sims = cosine_similarity(query_embs, gallery_embs)
+    top_indices = np.argsort(sims, axis=1)[:, ::-1][:, :3]
+
+    results = {q_id: [ids['g_mesh_for_img'][j] for j in top_indices[i]] for i, q_id in enumerate(ids['q_img'])}
+    df = pd.DataFrame(list(results.items()), columns=["image_to_mesh_image", "image_to_mesh_mesh"])
+    return df.sort_values("image_to_mesh_image").reset_index(drop=True)
+
+
+def solve_mesh2img(loaders, ids, model_spec, config) -> pd.DataFrame:
+    print("  📦 → 🖼️ Mesh-to-Image: получение эмбеддингов...")
+    pc_encoder = load_pc_encoder(model_spec, config)
+    img_encoder = load_image_encoder(model_spec, config)
+
+    query_embs = get_inference_embeddings_mesh(pc_encoder, loaders['q_mesh_to_img'], config)
+    gallery_embs = get_inference_embeddings_image(img_encoder, loaders['g_img_for_mesh'], config)
+
+    gallery_img_model_ids = [p.name.split("_")[0] for p in ids['g_img_for_mesh_paths']]
+    df_gallery = pd.DataFrame(gallery_embs)
+    df_gallery["model_id"] = gallery_img_model_ids
+    mean_embs_df = df_gallery.groupby("model_id").mean()
+
+    avg_gallery_embs = normalize(mean_embs_df.to_numpy(), axis=1)
+    avg_gallery_ids = mean_embs_df.index.tolist()
+
+    sims = cosine_similarity(query_embs, avg_gallery_embs)
+    top_indices = np.argsort(sims, axis=1)[:, ::-1][:, :3]
+
+    results = {q_id: [avg_gallery_ids[j] for j in top_indices[i]] for i, q_id in enumerate(ids['q_mesh_to_img'])}
+    df = pd.DataFrame(list(results.items()), columns=["mesh_to_image_mesh", "mesh_to_image_image"])
+    return df.sort_values("mesh_to_image_mesh").reset_index(drop=True)
+
+
+def solve_text2mesh(loaders, ids, model_spec, config) -> pd.DataFrame:
+    print("  📝 → 📦 Text-to-Mesh: получение эмбеддингов...")
+    text_encoder = load_text_encoder(model_spec, config)
+    pc_encoder = load_pc_encoder(model_spec, config)
+
+    query_embs = get_inference_embeddings_text(text_encoder, loaders['q_text'], config)
+    gallery_embs = get_inference_embeddings_mesh(pc_encoder, loaders['g_mesh_for_text'], config)
+
+    sims = cosine_similarity(query_embs, gallery_embs)
+    top_indices = np.argsort(sims, axis=1)[:, ::-1][:, :3]
+
+    results = {q_id: [ids['g_mesh_for_text'][j] for j in top_indices[i]] for i, q_id in enumerate(ids['q_text'])}
+    df = pd.DataFrame(list(results.items()), columns=["text_to_mesh_text", "text_to_mesh_mesh"])
+    return df.sort_values("text_to_mesh_text").reset_index(drop=True)
+
+
+def solve_mesh2text(loaders, ids, model_spec, config) -> pd.DataFrame:
+    print("  📦 → 📝 Mesh-to-Text: получение эмбеддингов...")
+    pc_encoder = load_pc_encoder(model_spec, config)
+    text_encoder = load_text_encoder(model_spec, config)
+
+    query_embs = get_inference_embeddings_mesh(pc_encoder, loaders['q_mesh_to_text'], config)
+    gallery_embs = get_inference_embeddings_text(text_encoder, loaders['g_text_for_mesh'], config)
+
+    sims = cosine_similarity(query_embs, gallery_embs)
+    top_indices = np.argsort(sims, axis=1)[:, ::-1][:, :3]
+
+    results = {q_id: [ids['g_text_for_mesh'][j] for j in top_indices[i]] for i, q_id in
+               enumerate(ids['q_mesh_to_text'])}
+    df = pd.DataFrame(list(results.items()), columns=["mesh_to_text_mesh", "mesh_to_text_text"])
+    return df.sort_values("mesh_to_text_mesh").reset_index(drop=True)
+
+
+# --- Главная функция ---
+def make_submission(config: edict) -> None:
+    print("\n" + "=" * 60)
+    print("🚀 Создание submission файла для всех 4 задач")
+    print("=" * 60)
+
+    model_spec = config.paths.model_spec
+    loaders, ids = prepare_all_data(config)
+
+    # Решаем все задачи
+    text2mesh_df = solve_text2mesh(loaders, ids, model_spec, config)
+    mesh2text_df = solve_mesh2text(loaders, ids, model_spec, config)
+    img2mesh_df = solve_img2mesh(loaders, ids, model_spec, config)
+    mesh2img_df = solve_mesh2img(loaders, ids, model_spec, config)
+
+    # Создаем финальный DataFrame с правильной структурой
+    # 2187 строк для image задач + 100 строк для text задач = 2287 строк
+    total_rows = 2287
+    final_df = pd.DataFrame(index=range(total_rows))
+
+    # Добавляем колонку id
+    final_df["id"] = final_df.index
+
+    # Инициализируем все колонки как None
+    for col in ["image_to_mesh_image", "image_to_mesh_mesh",
+                "mesh_to_image_mesh", "mesh_to_image_image",
+                "text_to_mesh_text", "text_to_mesh_mesh",
+                "mesh_to_text_mesh", "mesh_to_text_text"]:
+        final_df[col] = None
+
+    # Заполняем image задачи (первые 2187 стро��)
+    # Используем .at для присвоения списков
+    for i in range(len(img2mesh_df)):
+        final_df.at[i, "image_to_mesh_image"] = img2mesh_df.loc[i, "image_to_mesh_image"]
+        final_df.at[i, "image_to_mesh_mesh"] = img2mesh_df.loc[i, "image_to_mesh_mesh"]
+
+    for i in range(len(mesh2img_df)):
+        final_df.at[i, "mesh_to_image_mesh"] = mesh2img_df.loc[i, "mesh_to_image_mesh"]
+        final_df.at[i, "mesh_to_image_image"] = mesh2img_df.loc[i, "mesh_to_image_image"]
+
+    # Заполняем text задачи (последние 100 строк, начиная с индекса 2187)
+    text_start_idx = 2187
+    for i in range(len(text2mesh_df)):
+        final_df.at[text_start_idx + i, "text_to_mesh_text"] = text2mesh_df.loc[i, "text_to_mesh_text"]
+        final_df.at[text_start_idx + i, "text_to_mesh_mesh"] = text2mesh_df.loc[i, "text_to_mesh_mesh"]
+
+    for i in range(len(mesh2text_df)):
+        final_df.at[text_start_idx + i, "mesh_to_text_mesh"] = mesh2text_df.loc[i, "mesh_to_text_mesh"]
+        final_df.at[text_start_idx + i, "mesh_to_text_text"] = mesh2text_df.loc[i, "mesh_to_text_text"]
+
+    # Статистика
+    print(f"\n📊 Статистика submission:")
+    print(f"   Заполненных image_to_mesh: {final_df['image_to_mesh_image'].notna().sum()}")
+    print(f"   Заполненных mesh_to_image: {final_df['mesh_to_image_mesh'].notna().sum()}")
+    print(f"   Заполненных text_to_mesh: {final_df['text_to_mesh_text'].notna().sum()}")
+    print(f"   Заполненных mesh_to_text: {final_df['mesh_to_text_mesh'].notna().sum()}")
+
+    # Преобразуем списки в строки для CSV
+    for col in final_df.columns:
+        if col != "id":  # Не трогаем колонку id
+            mask = final_df[col].apply(lambda x: isinstance(x, list))
+            final_df.loc[mask, col] = final_df.loc[mask, col].apply(str)
+
+    # Сохраняем результат
+    output_path = config.paths.submission_save_file
+    final_df.to_csv(output_path, index=False)
+    print(f"\n✅ Файл для сабмита успешно создан: {output_path}")
+    print(f"   Всего строк: {len(final_df)}")
+    print(f"   Image задачи: строки 0-2186")
+    print(f"   Text задачи: строки 2187-2286")
+    print("=" * 60)

backend/cad_retrieval_utils/inference_runner.py

@@ -0,0 +1,45 @@
+import argparse
+from pathlib import Path
+
+from cad_retrieval_utils.utils import init_environment, load_config
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Inference runner for all 4 tasks",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--config", required=True, help="Путь к .py-файлу с CONFIG")
+    parser.add_argument("--pc_encoder", required=True, help="Путь к весам PC encoder")
+    parser.add_argument("--img_moe", required=True, help="Путь к весам Image MoE head")
+    parser.add_argument("--text_proj", required=True, help="Путь к весам text projection")
+    parser.add_argument("--text_encoder", required=True, help="Путь к весам text encoder")
+    parser.add_argument("--output", default="submission.csv", help="Путь для сохранения submission.csv")
+    args = parser.parse_args()
+
+    CONFIG = load_config(args.config)
+    print(f"Using config: {args.config}")
+
+    # Обновляем конфиг путями из аргументов
+    CONFIG.paths.model_spec = {
+        "pc_encoder": args.pc_encoder,
+        "moe": args.img_moe,
+        "text_proj": args.text_proj,
+        "text_encoder": args.text_encoder,
+    }
+    CONFIG.paths.submission_save_file = Path(args.output)
+
+    # Проверка существования файлов
+    for key, path in CONFIG.paths.model_spec.items():
+        if path and not Path(path).exists():
+            raise FileNotFoundError(f"Файл не найден: {key} -> {path}")
+
+    init_environment(CONFIG)
+
+    # Импортируем после инициализации
+    from cad_retrieval_utils.inference import make_submission
+    make_submission(CONFIG)
+
+
+if __name__ == "__main__":
+    main()

backend/cad_retrieval_utils/models.py

@@ -0,0 +1,124 @@
+from typing import cast
+
+import open_clip
+import timm
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from easydict import EasyDict as edict
+
+from ReConV2.models.ReCon import ReCon2
+
+
+# --- Базовый PC Encoder (общий для всех) ---
+class BasePcEncoder(nn.Module):
+    def __init__(self, config: edict):
+        super().__init__()
+        self.text_ratio = config.text_ratio
+        self.pc_encoder_base = ReCon2(config.model)
+        self.config = config
+
+    def encode_pc(self, pc: torch.Tensor, normalize: bool) -> torch.Tensor:
+        img_token, text_token, _, _ = self.pc_encoder_base.forward_features(pc)
+        img_pred_feat = torch.mean(img_token, dim=1)
+        text_pred_feat = torch.mean(text_token, dim=1)
+        pc_feats = img_pred_feat + text_pred_feat * self.text_ratio
+        return F.normalize(pc_feats, dim=-1) if normalize else pc_feats
+
+
+# --- Модели для Text-Mesh ---
+class TextEncoder(nn.Module):
+    def __init__(self, config: edict) -> None:
+        super().__init__()
+        self.config = config
+        model, _, _ = open_clip.create_model_and_transforms(
+            'EVA02-L-14-336',
+            pretrained='merged2b_s6b_b61k'
+        )
+        self.text_encoder = model
+        self.tokenizer = open_clip.get_tokenizer('EVA02-L-14-336')
+
+        text_dim = 768
+        self.text_proj = nn.Sequential(
+            nn.Linear(text_dim, config.emb_dim),
+            nn.ReLU(),
+            nn.Linear(config.emb_dim, config.emb_dim)
+        )
+
+    def encode_text(self, texts: list[str], normalize: bool = True) -> torch.Tensor:
+        tokens = self.tokenizer(texts).to(self.config.device)
+        text_features = self.text_encoder.encode_text(tokens)
+        text_embeddings = self.text_proj(text_features.float())
+        return F.normalize(text_embeddings, dim=-1) if normalize else text_embeddings
+
+
+class InferenceTextEncoder(nn.Module):
+    def __init__(self, config: edict) -> None:
+        super().__init__()
+        self.encoder = TextEncoder(config)
+
+    def load_text_weights(self, text_proj_path: str, text_encoder_path: str) -> None:
+        self.encoder.text_proj.load_state_dict(torch.load(text_proj_path, map_location="cpu"), strict=True)
+        print(f"✅ Text projection weights loaded from {text_proj_path}")
+
+
+        checkpoint = torch.load(text_encoder_path, map_location="cpu")
+        # Загружаем только те параметры, которые есть в чекпоинте
+        missing, unexpected = self.encoder.text_encoder.load_state_dict(checkpoint, strict=False)
+        print(f"✅ Text encoder weights loaded from {text_encoder_path}")
+        if missing:
+            print(f"   ℹ️  Missing keys (expected, frozen params): {len(missing)}")
+        if unexpected:
+            raise Exception(f"   ⚠️  Unexpected keys: {unexpected}")
+        #strict=False так как последние слои грузим(при обучении 4 слоя размораживали, их сохранили и их же грузим в инференсе)
+
+
+
+    def encode_text(self, texts: list[str], normalize: bool = True) -> torch.Tensor:
+        return self.encoder.encode_text(texts, normalize)
+
+
+# --- Модель для PC ---
+class InferencePcEncoder(BasePcEncoder):
+    def __init__(self, config: edict) -> None:
+        super().__init__(config)
+
+    def load_pc_encoder_weights(self, checkpoint_path: str) -> None:
+        self.pc_encoder_base.load_state_dict(torch.load(checkpoint_path, map_location="cpu"), strict=True)
+        print(f"✅ PC encoder weights loaded from {checkpoint_path}")
+
+
+# --- Модели для Image-Mesh ---
+class MoEImgHead(nn.Module):
+    def __init__(self, in_dim: int, out_dim: int, n_experts: int = 8) -> None:
+        super().__init__()
+        self.experts = nn.ModuleList([nn.Linear(in_dim, out_dim) for _ in range(n_experts)])
+        self.gate = nn.Sequential(nn.LayerNorm(in_dim), nn.Linear(in_dim, n_experts))
+
+    def forward(self, feats: torch.Tensor, normalize: bool) -> torch.Tensor:
+        logits = self.gate(feats)
+        w = torch.softmax(logits, dim=-1)
+        outs = torch.stack([e(feats) for e in self.experts], dim=1)
+        out = (w.unsqueeze(-1) * outs).sum(1)
+        return F.normalize(out, dim=-1) if normalize else out
+
+
+class ImageEncoder(nn.Module):
+    def __init__(self, config: edict) -> None:
+        super().__init__()
+        self.model = timm.create_model(config.model.pretrained_model_name, pretrained=True, num_classes=0)
+
+        self.img_proj = MoEImgHead(
+            config.model.embed_dim,
+            config.emb_dim,
+            n_experts=config.train_params.n_experts,
+        )
+
+    def encode_image(self, image: torch.Tensor, normalize: bool = True) -> torch.Tensor:
+        image_features = self.model(image) #вызываем под декоратором @torch.no_grad в evolution
+        image_embeddings = self.img_proj(image_features.float(), normalize=normalize)
+        return cast(torch.Tensor, image_embeddings)
+
+    def load_moe_weights(self, checkpoint_path: str) -> None:
+        self.img_proj.load_state_dict(torch.load(checkpoint_path, map_location="cpu"), strict=True)
+        print(f"✅ MoE weights loaded from {checkpoint_path}")

backend/cad_retrieval_utils/type_defs.py

@@ -0,0 +1,27 @@
+import os
+from collections.abc import Callable
+from pathlib import Path
+from typing import TypeAlias, TypedDict
+
+import numpy as np
+import torch
+from PIL import Image
+
+# --- Примитивные псевдонимы ---
+ModelID: TypeAlias = str
+PathLike: TypeAlias = str | Path | os.PathLike[str]
+ImageTransform: TypeAlias = Callable[[Image.Image], torch.Tensor]
+
+# --- Типы для NumPy массивов ---
+EmbeddingArray: TypeAlias = np.ndarray
+
+
+# --- Спецификация чекпоинтов для инференса ---
+class CheckpointSpec(TypedDict):
+    # Пути для text-to-mesh
+    text_proj: PathLike
+    text_encoder: PathLike
+
+    # Пути для image-to-mesh
+    moe: PathLike
+    pc_encoder: PathLike

backend/cad_retrieval_utils/utils.py

@@ -0,0 +1,91 @@
+import importlib.util
+import os
+import random
+from pathlib import Path
+
+import numpy as np
+import torch
+from easydict import EasyDict as edict
+
+
+def load_config(config_path: str) -> edict:
+    CONFIG = edict()
+
+    # --- Конфиг pretrained модели Recon для загрузки ---
+    CONFIG.model = edict({
+        "NAME": "ReCon2",
+        "group_size": 32,
+        "num_group": 512,
+        "mask_ratio": 0.7,
+        "mask_type": "rand",
+        "embed_dim": 1024,
+        "depth": 24,
+        "drop_path_rate": 0.2,
+        "num_heads": 16,
+        "decoder_depth": 4,
+        "with_color": True,
+        "stop_grad": False,
+        "large_embedding": False,
+        "img_queries": 13,
+        "text_queries": 3,
+        "contrast_type": "byol",
+        "pretrained_model_name": "eva_large_patch14_336.in22k_ft_in22k_in1k",
+    })
+
+    # --- Общие параметры ---
+    CONFIG.npoints = 10_000
+    CONFIG.emb_dim = 1280
+    CONFIG.img_size = 336
+    CONFIG.seed = 42
+    CONFIG.device = torch.device("cpu")
+    CONFIG.text_ratio = 0.3
+
+    # --- Параметры инференса ---
+    CONFIG.infer_img_batch_size = 32
+    CONFIG.infer_pc_batch_size = 16
+    CONFIG.infer_text_batch_size = 32
+
+    # --- Параметры для MoE ---
+    CONFIG.train_params = edict()
+    CONFIG.train_params.n_experts = 8
+
+    # --- Пути ---
+    CONFIG.paths = edict()
+    CONFIG.paths.test_data_root = Path("/kaggle/input/test-final/test")
+    CONFIG.paths.submission_save_file = Path("./submission.csv")
+
+    # Эти пути будут перезаписаны из командной строки inference_runner.py
+    CONFIG.paths.model_spec = {
+        "text_proj": None,
+        "text_encoder": None,
+        "moe": None,
+        "pc_encoder": None
+    }
+    return CONFIG
+
+
+def init_environment(config: edict) -> None:
+    SEED = config.seed
+
+    # Все используют один и тот же базовый сид
+    random.seed(SEED)
+    os.environ["PYTHONHASHSEED"] = str(SEED)
+    np.random.seed(SEED)
+    torch.manual_seed(SEED)
+    torch.cuda.manual_seed(SEED)
+    torch.cuda.manual_seed_all(SEED)
+
+    # CuDNN настройки
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+    # Отключение TF32
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32 = False
+
+    # Детерминированные алгоритмы
+    torch.use_deterministic_algorithms(True)
+    os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
+
+
+    print(f"✅ Детерминированная среда установлена с seed = {SEED}")

backend/config.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+
+import torch
+from easydict import EasyDict as edict
+
+CONFIG = edict()
+
+# --- Конфиг pretrained модели Recon для загрузки ---
+CONFIG.model = edict({
+    "NAME": "ReCon2",
+    "group_size": 32,
+    "num_group": 512,
+    "mask_ratio": 0.7,
+    "mask_type": "rand",
+    "embed_dim": 1024,
+    "depth": 24,
+    "drop_path_rate": 0.2,
+    "num_heads": 16,
+    "decoder_depth": 4,
+    "with_color": True,
+    "stop_grad": False,
+    "large_embedding": False,
+    "img_queries": 13,
+    "text_queries": 3,
+    "contrast_type": "byol",
+    "pretrained_model_name": "eva_large_patch14_336.in22k_ft_in22k_in1k",
+})
+
+# --- Общие параметры ---
+CONFIG.npoints = 10_000
+CONFIG.emb_dim = 1280
+CONFIG.img_size = 336
+CONFIG.seed = 42
+CONFIG.device = torch.device("cpu")
+CONFIG.text_ratio = 0.3
+
+# --- Параметры инференса ---
+CONFIG.infer_img_batch_size = 32
+CONFIG.infer_pc_batch_size = 16
+CONFIG.infer_text_batch_size = 32
+
+# --- Параметры для MoE ---
+CONFIG.train_params = edict()
+CONFIG.train_params.n_experts = 8
+
+# --- Пути ---
+CONFIG.paths = edict()
+CONFIG.paths.test_data_root = Path("/kaggle/input/test-final/test")
+CONFIG.paths.submission_save_file = Path("./submission.csv")
+
+# Эти пути будут перезаписаны из командной строки inference_runner.py
+CONFIG.paths.model_spec = {
+    "text_proj": None,
+    "text_encoder": None,
+    "moe": None,
+    "pc_encoder": None
+}

backend/download_utils.py

@@ -0,0 +1,56 @@
+import os
+import requests
+from tqdm.auto import tqdm
+
+def download_yandex_file(public_file_url: str, destination_path: str, filename: str):
+    """
+    Скачивает один файл с публичного Яндекс.Диска по прямой ссылке на файл.
+    """
+    api_url = "https://cloud-api.yandex.net/v1/disk/public/resources/download"
+    params = {'public_key': public_file_url}
+
+    print(f"🔎 Получение информации о файле: {filename}...")
+    try:
+        response = requests.get(api_url, params=params)
+        response.raise_for_status()
+        data = response.json()
+        download_url = data.get('href')
+
+        if not download_url:
+            print(f"❌ Не удалось получить URL для скачивания файла '{filename}'. Ответ API: {data}")
+            return False
+
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Ошибка при получении информации о файле '{filename}': {e}")
+        return False
+    except KeyError as e:
+        print(f"❌ Ошибка при разборе ответа API для '{filename}': отсутствует ключ {e}. Ответ: {data}")
+        return False
+
+    full_path = os.path.join(destination_path, filename)
+    os.makedirs(destination_path, exist_ok=True)
+
+    print(f"📥 Скачивание '{filename}' в '{full_path}'...")
+    try:
+        size_response = requests.head(download_url)
+        total_size = int(size_response.headers.get('content-length', 0))
+
+        download_response = requests.get(download_url, stream=True)
+        download_response.raise_for_status()
+
+        with open(full_path, 'wb') as f:
+            with tqdm(total=total_size, unit='B', unit_scale=True, desc=filename) as pbar:
+                for chunk in download_response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+                        pbar.update(len(chunk))
+
+    except requests.exceptions.RequestException as e:
+        print(f"\n❌ Ошибка при скачивании файла '{filename}': {e}")
+        return False
+    except Exception as e:
+        print(f"\n❌ Неожиданная ошибка при скачивании '{filename}': {e}")
+        return False
+
+    print(f"🎉 Файл '{filename}' успешно скачан.")
+    return True

backend/inference_utils.py

@@ -0,0 +1,355 @@
+# app/inference_utils.py
+
+import base64
+import tempfile
+import uuid
+import zipfile
+from io import BytesIO
+from pathlib import Path
+import datetime
+from typing import Callable # Add this import
+
+import numpy as np
+import torch
+from easydict import EasyDict as edict
+from PIL import Image
+from sklearn.metrics.pairwise import cosine_similarity
+from torch.utils.data import DataLoader
+
+from cad_retrieval_utils.augmentations import build_img_transforms
+from cad_retrieval_utils.datasets import (InferenceImageDataset,
+                                          InferenceMeshDataset,
+                                          InferenceTextDataset)
+from cad_retrieval_utils.evaluation import (get_inference_embeddings_image,
+                                            get_inference_embeddings_mesh,
+                                            get_inference_embeddings_text)
+from cad_retrieval_utils.inference import (load_image_encoder, load_pc_encoder,
+                                           load_text_encoder)
+from cad_retrieval_utils.models import (ImageEncoder, InferencePcEncoder,
+                                        InferenceTextEncoder)
+from cad_retrieval_utils.utils import init_environment, load_config
+
+CONFIG: edict = None
+IMG_TRANSFORM = None
+PC_ENCODER: InferencePcEncoder = None
+IMG_ENCODER: ImageEncoder = None
+TEXT_ENCODER: InferenceTextEncoder = None
+DATASET_CACHE = {}
+TOP_K_MATCHES = 5
+
+def load_models_and_config(config_path: str, model_paths: dict) -> None:
+    # This function is unchanged
+    global CONFIG, IMG_TRANSFORM, PC_ENCODER, IMG_ENCODER, TEXT_ENCODER
+    print("🚀 Загрузка конфигурации и моделей...")
+    if CONFIG is not None:
+        print("   Модели уже загружены.")
+        return
+    try:
+        CONFIG = load_config(config_path)
+        CONFIG.paths.model_spec = model_paths
+        init_environment(CONFIG)
+        PC_ENCODER = load_pc_encoder(CONFIG.paths.model_spec, CONFIG)
+        IMG_ENCODER = load_image_encoder(CONFIG.paths.model_spec, CONFIG)
+        TEXT_ENCODER = load_text_encoder(CONFIG.paths.model_spec, CONFIG)
+        IMG_TRANSFORM = build_img_transforms(CONFIG.img_size)
+        print("✅ Все модели успешно загружены в память.")
+    except Exception as e:
+        print(f"🔥 Критическая ошибка при загрузке моделей: {e}")
+        raise
+
+@torch.no_grad()
+def get_embedding_for_single_item(modality: str, content_bytes: bytes) -> np.ndarray:
+    # This function is unchanged
+    if modality == "image":
+        image = Image.open(BytesIO(content_bytes)).convert("RGB")
+        tensor = IMG_TRANSFORM(image).unsqueeze(0).to(CONFIG.device)
+        emb = IMG_ENCODER.encode_image(tensor, normalize=True)
+        return emb.cpu().numpy()
+    if modality == "text":
+        text = content_bytes.decode("utf-8")
+        emb = TEXT_ENCODER.encode_text([text], normalize=True)
+        return emb.cpu().numpy()
+    if modality == "mesh":
+        with tempfile.NamedTemporaryFile(suffix=".stl", delete=True) as tmp:
+            tmp.write(content_bytes)
+            tmp.flush()
+            dataset = InferenceMeshDataset([tmp.name], CONFIG.npoints, CONFIG.seed)
+            tensor = dataset[0].unsqueeze(0).to(CONFIG.device)
+            emb = PC_ENCODER.encode_pc(tensor, normalize=True)
+            return emb.cpu().numpy()
+    raise ValueError(f"Неизвестная модальность: {modality}")
+
+def process_uploaded_zip(
+    zip_file_bytes: bytes, 
+    original_filename: str, 
+    update_status: Callable[[str, int], None]
+) -> dict:
+    """
+    Основная функция для обработки ZIP-архива с обратными вызовами для обновления статуса.
+    """
+    dataset_id = str(uuid.uuid4())
+    print(f"⚙️  Начало обработки нового датасета: {original_filename} (ID: {dataset_id})")
+    update_status("Starting", 0)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_path = Path(tmpdir)
+        zip_path = tmp_path / "data.zip"
+        zip_path.write_bytes(zip_file_bytes)
+
+        update_status("Unpacking Files", 5)
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(tmp_path)
+        print(f"   🗂️  Архив распакован в {tmpdir}")
+        
+        update_status("Preparing Data", 10)
+        image_paths = sorted(list(tmp_path.glob("**/*.png")))
+        text_paths = sorted(list(tmp_path.glob("**/*.txt")))
+        mesh_paths = sorted(list(tmp_path.glob("**/*.stl")))
+        
+        image_ds = InferenceImageDataset([str(p) for p in image_paths], IMG_TRANSFORM)
+        text_ds = InferenceTextDataset([str(p) for p in text_paths])
+        mesh_ds = InferenceMeshDataset([str(p) for p in mesh_paths], CONFIG.npoints, CONFIG.seed)
+
+        image_loader = DataLoader(image_ds, batch_size=CONFIG.infer_img_batch_size, shuffle=False)
+        text_loader = DataLoader(text_ds, batch_size=CONFIG.infer_text_batch_size, shuffle=False)
+        mesh_loader = DataLoader(mesh_ds, batch_size=CONFIG.infer_pc_batch_size, shuffle=False)
+        
+        print("   🧠 Вычисление эмбеддингов...")
+        update_status("Processing Images", 15)
+        image_embs = get_inference_embeddings_image(IMG_ENCODER, image_loader, CONFIG)
+        
+        update_status("Processing Texts", 50)
+        text_embs = get_inference_embeddings_text(TEXT_ENCODER, text_loader, CONFIG)
+        
+        update_status("Processing 3D Models", 55)
+        mesh_embs = get_inference_embeddings_mesh(PC_ENCODER, mesh_loader, CONFIG)
+        print("   ✅ Эмбеддинги вычислены.")
+
+        update_status("Caching Data", 90)
+        image_names = [p.name for p in image_paths]
+        text_names = [p.name for p in text_paths]
+        mesh_names = [p.name for p in mesh_paths]
+        
+        image_items = [{"id": f"image_{i}", "name": name, "content": base64.b64encode(p.read_bytes()).decode('utf-8')} for i, (p, name) in enumerate(zip(image_paths, image_names))]
+        text_items = [{"id": f"text_{i}", "name": name, "content": p.read_text()} for i, (p, name) in enumerate(zip(text_paths, text_names))]
+        mesh_items = [{"id": f"mesh_{i}", "name": name, "content": base64.b64encode(p.read_bytes()).decode('utf-8')} for i, (p, name) in enumerate(zip(mesh_paths, mesh_names))]
+
+        dataset_data = {"images": image_items, "texts": text_items, "meshes": mesh_items}
+        
+        DATASET_CACHE[dataset_id] = {
+            "data": dataset_data,
+            "embeddings": {
+                "image": (image_names, image_embs),
+                "text": (text_names, text_embs),
+                "mesh": (mesh_names, mesh_embs)
+            }
+        }
+        print(f"   💾 Датасет {dataset_id} сохранен в кэш.")
+
+    print("   ⚖️  Вычисление полной матрицы схожести...")
+    update_status("Building Matrix", 95)
+    full_comparison = {"images": [], "texts": [], "meshes": []}
+    
+    all_embeddings = {
+        "image": (image_names, image_embs),
+        "text": (text_names, text_embs),
+        "mesh": (mesh_names, mesh_embs)
+    }
+
+    for source_modality, (source_names, source_embs) in all_embeddings.items():
+        for i, source_name in enumerate(source_names):
+            source_emb = source_embs[i:i+1]
+            matches = {}
+            for target_modality, (target_names, target_embs) in all_embeddings.items():
+                if not target_names: continue
+                sims = cosine_similarity(source_emb, target_embs).flatten()
+                
+                if source_modality == target_modality:
+                    sims[i] = -1 
+                
+                top_indices = np.argsort(sims)[::-1][:TOP_K_MATCHES]
+                matches[target_modality] = [
+                    {"item": target_names[j], "confidence": float(sims[j])} for j in top_indices if sims[j] > -1
+                ]
+            
+            key_name = "meshes" if source_modality == "mesh" else source_modality + 's'
+            full_comparison[key_name].append({"source": source_name, "matches": matches})
+    
+    print("   ✅ Матрица схожести готова.")
+
+    final_response = {
+        "id": dataset_id,
+        "name": original_filename,
+        "uploadDate": datetime.datetime.utcnow().isoformat() + "Z",
+        "data": dataset_data,
+        "processingState": "processed",
+        "processingProgress": 100,
+        "fullComparison": full_comparison
+    }
+    
+    print(f"✅ Обработка датасета {dataset_id} завершена.")
+    return final_response
+
+
+def process_shared_dataset_directory(directory_path: Path, embeddings_path: Path, dataset_id: str, dataset_name: str) -> dict:
+    # This function is unchanged
+    print(f"⚙️  Начало обработки общего датасета: {dataset_name} (ID: {dataset_id})")
+    print("   📂 Сканирование файлов данных...")
+    image_paths = sorted(list(directory_path.glob("**/*.png")))
+    text_paths = sorted(list(directory_path.glob("**/*.txt")))
+    mesh_paths = sorted(list(directory_path.glob("**/*.stl")))
+    if not any([image_paths, text_paths, mesh_paths]):
+        print(f"⚠️  В директории общего датасета '{directory_path}' не найдено файлов.")
+        return None
+    print(f"   ✅ Найдено: {len(image_paths)} изображений, {len(text_paths)} текстов, {len(mesh_paths)} моделей.")
+    print("   🧠 Индексирование предварительно вычисленных эмбеддингов...")
+    all_embedding_paths = list(embeddings_path.glob("**/*.npy"))
+    embedding_map = {p.stem: p for p in all_embedding_paths}
+    print(f"   ✅ Найдено {len(embedding_map)} файлов эмбеддингов.")
+    def load_embeddings_for_paths(data_paths: list[Path]):
+        names = []
+        embs_list = []
+        for data_path in data_paths:
+            file_stem = data_path.stem
+            if file_stem in embedding_map:
+                embedding_path = embedding_map[file_stem]
+                try:
+                    emb = np.load(embedding_path)
+                    embs_list.append(emb)
+                    names.append(data_path.name)
+                except Exception as e:
+                    print(f"  ⚠️  Не удалось загрузить или разобрать эмбеддинг для {data_path.name}: {e}")
+            else:
+                print(f"  ⚠️  Внимание: не найден соответствующий эмбеддинг для {data_path.name}")
+        return names, np.array(embs_list) if embs_list else np.array([])
+    print("   🚚 Загрузка и сопоставление эмбеддингов...")
+    image_names, image_embs = load_embeddings_for_paths(image_paths)
+    text_names, text_embs = load_embeddings_for_paths(text_paths)
+    mesh_names, mesh_embs = load_embeddings_for_paths(mesh_paths)
+    print("   ✅ Эмбеддинги для общего датасета загружены.")
+    static_root = Path("static")
+    image_items = [{"id": f"image_{i}", "name": p.name, "content": None, "contentUrl": f"/{p.relative_to(static_root)}"} for i, p in enumerate(image_paths)]
+    text_items = [{"id": f"text_{i}", "name": p.name, "content": None, "contentUrl": f"/{p.relative_to(static_root)}"} for i, p in enumerate(text_paths)]
+    mesh_items = [{"id": f"mesh_{i}", "name": p.name, "content": None, "contentUrl": f"/{p.relative_to(static_root)}"} for i, p in enumerate(mesh_paths)]
+    dataset_data = {"images": image_items, "texts": text_items, "meshes": mesh_items}
+    DATASET_CACHE[dataset_id] = {"data": dataset_data, "embeddings": {"image": (image_names, image_embs), "text": (text_names, text_embs), "mesh": (mesh_names, mesh_embs)}}
+    print(f"   💾 Эмбеддинги для общего датасета {dataset_id} сохранены в кэш.")
+    print("   ⚖️  Вычисление полной матрицы схожести для общего датасета...")
+    full_comparison = {"images": [], "texts": [], "meshes": []}
+    all_embeddings = {"image": (image_names, image_embs), "text": (text_names, text_embs), "mesh": (mesh_names, mesh_embs)}
+    for source_modality, (source_names, source_embs) in all_embeddings.items():
+        if len(source_names) == 0: continue
+        for i, source_name in enumerate(source_names):
+            source_emb = source_embs[i:i+1]
+            matches = {}
+            for target_modality, (target_names, target_embs) in all_embeddings.items():
+                if len(target_names) == 0: continue
+                sims = cosine_similarity(source_emb, target_embs).flatten()
+                if source_modality == target_modality:
+                    sims[i] = -1 
+                top_indices = np.argsort(sims)[::-1][:TOP_K_MATCHES]
+                matches[target_modality] = [{"item": target_names[j], "confidence": float(sims[j])} for j in top_indices if sims[j] > -1]
+            key_name = "meshes" if source_modality == "mesh" else source_modality + 's'
+            full_comparison[key_name].append({"source": source_name, "matches": matches})
+    print("   ✅ Матрица схожести для общего датасета готова.")
+    try:
+        creation_time = datetime.datetime.fromtimestamp(directory_path.stat().st_ctime)
+    except Exception:
+        creation_time = datetime.datetime.utcnow()
+    final_response = {"id": dataset_id, "name": dataset_name, "uploadDate": creation_time.isoformat() + "Z", "data": dataset_data, "processingState": "processed", "processingProgress": 100, "fullComparison": full_comparison, "isShared": True}
+    print(f"✅ Обработка общего датасета {dataset_id} завершена.")
+    return final_response
+
+def find_matches_for_item(modality: str, content_base64: str, dataset_id: str) -> dict:
+    # This function is unchanged
+    print(f"🔍 Поиск совпадений для объекта ({modality}) в датасете {dataset_id}...")
+    if dataset_id not in DATASET_CACHE:
+        raise ValueError(f"Датасет с ID {dataset_id} не найден в кэше.")
+    content_bytes = base64.b64decode(content_base64)
+    source_emb = get_embedding_for_single_item(modality, content_bytes)
+    cached_dataset = DATASET_CACHE[dataset_id]
+    results = {}
+    for target_modality, (target_names, target_embs) in cached_dataset["embeddings"].items():
+        key_name = "meshes" if target_modality == "mesh" else target_modality + 's'
+        if not target_names: continue
+        sims = cosine_similarity(source_emb, target_embs).flatten()
+        top_indices = np.argsort(sims)[::-1][:TOP_K_MATCHES]
+        target_items_map = {item['name']: item for item in cached_dataset['data'][key_name]}
+        matches = []
+        for j in top_indices:
+            item_name = target_names[j]
+            if item_name in target_items_map:
+                matches.append({"item": target_items_map[item_name], "confidence": float(sims[j])})
+        results[key_name] = matches
+    print("   ✅ Поиск завершен.")
+    return {"results": results}
+
+def cache_local_dataset(dataset: dict) -> None:
+    """
+    Receives a full dataset object from the frontend, computes embeddings,
+    and loads it into the in-memory cache.
+    """
+    dataset_id = dataset.get('id')
+    if not dataset_id:
+        print("⚠️ Attempted to cache a dataset without an ID.")
+        return
+
+    if dataset_id in DATASET_CACHE:
+        print(f"✅ Dataset {dataset_id} is already in the backend cache. Skipping re-hydration.")
+        return
+
+    print(f"🧠 Re-hydrating backend cache for local dataset ID: {dataset_id}")
+
+    try:
+        all_embeddings = {}
+        all_names = {}
+
+        # The content comes in different formats (data URL for images, text for text, etc.)
+        # We need to decode it before sending to the embedding function.
+        def get_bytes_from_content(content_str: str, modality: str) -> bytes:
+            if modality in ['image', 'mesh']:
+                 # Handle data URLs (e.g., "data:image/png;base64,...") or raw base64
+                if ',' in content_str:
+                    header, encoded = content_str.split(',', 1)
+                    return base64.b64decode(encoded)
+                else:
+                    return base64.b64decode(content_str)
+            else: # text
+                return content_str.encode('utf-8')
+
+
+        for modality_plural, items in dataset.get('data', {}).items():
+            modality_singular = "mesh" if modality_plural == "meshes" else modality_plural[:-1]
+            
+            names = []
+            embs_list = []
+
+            print(f"   ⚙️  Processing {len(items)} items for modality: {modality_singular}")
+
+            for item in items:
+                item_content = item.get('content')
+                if not item_content:
+                    continue
+
+                content_bytes = get_bytes_from_content(item_content, modality_singular)
+                embedding = get_embedding_for_single_item(modality_singular, content_bytes)
+                
+                embs_list.append(embedding[0]) # get_embedding returns shape (1, D)
+                names.append(item.get('name'))
+
+            all_names[modality_singular] = names
+            all_embeddings[modality_singular] = np.array(embs_list) if embs_list else np.array([])
+        
+        # Structure the cache entry exactly like process_uploaded_zip does
+        DATASET_CACHE[dataset_id] = {
+            "data": dataset.get('data'),
+            "embeddings": {
+                mod: (all_names[mod], all_embeddings[mod]) for mod in all_embeddings
+            }
+        }
+        print(f"   ✅ Successfully cached {dataset_id} with embeddings.")
+
+    except Exception as e:
+        print(f"🔥 CRITICAL ERROR while re-hydrating cache for {dataset_id}: {e}")
+        import traceback
+        traceback.print_exc()

backend/main.py

@@ -0,0 +1,278 @@
+# app/main.py
+
+import os
+import asyncio
+from pathlib import Path
+import zipfile
+import io
+import requests
+import uuid # Add this import
+from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks # Add BackgroundTasks
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any
+
+# Импортируем утилиты
+from inference_utils import (
+    load_models_and_config,
+    process_uploaded_zip,
+    find_matches_for_item,
+    process_shared_dataset_directory,
+    cache_local_dataset,
+)
+# Импортируем нашу новую функцию для скачивания
+from download_utils import download_yandex_file
+
+# --- Инициализация ---
+app = FastAPI()
+
+# Разрешаем CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- Глобальные кэши ---
+SHARED_DATASET_FULL_DATA = {}
+SHARED_DATASET_ID = "shared_dataset_1"
+PROCESSING_STATUS = {} # NEW: For tracking progress
+
+# --- Helper Functions ---
+
+def download_and_unzip_yandex_archive(public_url: str, destination_dir: Path, description: str):
+    # This function is unchanged
+    print(f"--- 📥 Checking for {description} ---")
+    if destination_dir.exists() and any(destination_dir.iterdir()):
+        print(f"✅ {description} already exists in '{destination_dir}'. Skipping download.")
+        return True
+    print(f"⏳ {description} not found. Starting download from Yandex.Disk...")
+    destination_dir.mkdir(parents=True, exist_ok=True)
+    if "YOUR_" in public_url or "ВАША_" in public_url:
+        print(f"🔥 WARNING: Placeholder URL detected for {description}. Download skipped.")
+        return False
+    try:
+        api_url = "https://cloud-api.yandex.net/v1/disk/public/resources/download"
+        params = {'public_key': public_url}
+        response = requests.get(api_url, params=params)
+        response.raise_for_status()
+        download_url = response.json().get('href')
+        if not download_url:
+            raise RuntimeError(f"Could not retrieve download URL for {description} from Yandex.Disk API.")
+        print(f"   🔗 Got download link. Fetching ZIP archive for {description}...")
+        zip_response = requests.get(download_url, stream=True)
+        zip_response.raise_for_status()
+        zip_in_memory = io.BytesIO(zip_response.content)
+        print(f"   🗂️  Unzipping archive for {description}...")
+        with zipfile.ZipFile(zip_in_memory, 'r') as zip_ref:
+            zip_ref.extractall(destination_dir)
+        print(f"🎉 {description} successfully downloaded and extracted to '{destination_dir}'.")
+        return True
+    except Exception as e:
+        print(f"🔥 CRITICAL ERROR downloading or unzipping {description}: {e}")
+        return False
+
+# --- NEW: Background Processing Wrapper ---
+def background_process_zip(zip_bytes: bytes, original_filename: str, job_id: str):
+    """Wrapper function to run processing and update status."""
+    def update_status(stage: str, progress: int):
+        """Callback to update the global status dictionary."""
+        print(f"Job {job_id}: {stage} - {progress}%")
+        PROCESSING_STATUS[job_id] = {"stage": stage, "progress": progress, "status": "processing"}
+
+    try:
+        processed_data = process_uploaded_zip(
+            zip_bytes, original_filename, update_status
+        )
+        PROCESSING_STATUS[job_id] = {
+            "status": "complete",
+            "result": processed_data
+        }
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        PROCESSING_STATUS[job_id] = {
+            "status": "error",
+            "message": f"An error occurred during processing: {e}"
+        }
+
+class SingleMatchRequest(BaseModel):
+    modality: str
+    content: str
+    dataset_id: str
+
+# --- MODIFIED: process-dataset endpoint ---
+class ProcessDatasetResponse(BaseModel):
+    job_id: str
+
+class DataItemModel(BaseModel):
+    id: str
+    name: str
+    content: str | None = None # Frontend sends content as string (base64 or text)
+    contentUrl: str | None = None
+
+class DatasetDataModel(BaseModel):
+    images: List[DataItemModel]
+    texts: List[DataItemModel]
+    meshes: List[DataItemModel]
+
+class LocalDatasetModel(BaseModel):
+    id: str
+    name: str
+    data: DatasetDataModel
+    # We only need the core data for re-hydration, other fields are optional
+    # Use 'Any' for complex fields we don't need to strictly validate here
+    fullComparison: Dict[str, Any] | None = None
+    
+@app.post("/api/cache-local-dataset")
+async def cache_local_dataset_endpoint(dataset: LocalDatasetModel):
+    """
+    Receives a local dataset from the frontend to re-hydrate the server's in-memory cache.
+    """
+    try:
+        # Pydantic's .dict() is deprecated, use .model_dump()
+        dataset_dict = dataset.model_dump()
+        await asyncio.to_thread(cache_local_dataset, dataset_dict)
+        return {"status": "cached", "id": dataset.id}
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Failed to cache dataset: {e}")
+        
+# --- Startup Event ---
+@app.on_event("startup")
+def startup_event():
+    # This function is unchanged
+    SHARED_DATASET_DIR = Path("static/shared_dataset")
+    SHARED_EMBEDDINGS_DIR = Path("static/shared_embeddings")
+    
+    SHARED_DATASET_ZIP_URL = "https://disk.yandex.ru/d/G9C3_FGGzSLAXw"
+    SHARED_EMBEDDINGS_ZIP_URL = "https://disk.yandex.ru/d/aVTX6n2pc0hrCw"
+    dataset_ready = download_and_unzip_yandex_archive(SHARED_DATASET_ZIP_URL, SHARED_DATASET_DIR, "shared dataset files")
+    embeddings_ready = download_and_unzip_yandex_archive(SHARED_EMBEDDINGS_ZIP_URL, SHARED_EMBEDDINGS_DIR, "pre-computed embeddings")
+    DATA_DIR = Path("data/")
+    MODEL_URLS = {
+        "text_proj.pth": "https://disk.yandex.ru/d/uMH1ls0nYM4txw",
+        "text_encoder.pth": "https://disk.yandex.ru/d/R0BBLPXj828OhA",
+        "moe.pth": "https://disk.yandex.ru/d/vDfuIPziuO45wg",
+        "pc_encoder.pth": "https://disk.yandex.ru/d/03Ps2TMcWAKkww",
+    }
+    print("--- 📥 Checking and loading models ---")
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    all_models_present = True
+    for filename, url in MODEL_URLS.items():
+        destination_file = DATA_DIR / filename
+        if not destination_file.exists():
+            print(f"⏳ Модель '{filename}' не найдена. Начинаю загрузку...")
+            if not "ВАША_ССЫЛКА" in url:
+                success = download_yandex_file(public_file_url=url, destination_path=str(DATA_DIR), filename=filename)
+                if not success:
+                    all_models_present = False
+                    print(f"🔥 Критическая ошибка: не удалось скачать модель '{filename}'.")
+            else:
+                all_models_present = False
+                print(f"🔥 ВНИМАНИЕ: Пропущена загрузка '{filename}', т.к. ссылка является плейсхолдером.")
+        else:
+            print(f"✅ Модель '{filename}' уже существует. Пропускаю загрузку.")
+    if not all_models_present:
+        raise RuntimeError("Не удалось загрузить все необходимые модели. Приложение не может запуститься.")
+    print("--- ✅ Все модели готовы к использованию ---")
+    model_paths = {"text_proj": str(DATA_DIR / "text_proj.pth"), "text_encoder": str(DATA_DIR / "text_encoder.pth"), "moe": str(DATA_DIR / "moe.pth"), "pc_encoder": str(DATA_DIR / "pc_encoder.pth")}
+    config_path = "cad_retrieval_utils/config/config.py"
+    try:
+        load_models_and_config(config_path=config_path, model_paths=model_paths)
+        print("✅ Все модели успешно загружены в память.")
+    except Exception as e:
+        print(f"🔥 Ошибка при загрузке моделей: {e}")
+        import traceback
+        traceback.print_exc()
+        raise RuntimeError(f"Ошибка загрузки моделей, приложение не может запуститься.") from e
+    if dataset_ready and embeddings_ready:
+        print("--- 🧠 Loading pre-computed embeddings for shared dataset ---")
+        try:
+            full_data = process_shared_dataset_directory(directory_path=SHARED_DATASET_DIR, embeddings_path=SHARED_EMBEDDINGS_DIR, dataset_id=SHARED_DATASET_ID, dataset_name="Cloud Multi-Modal Dataset")
+            if full_data:
+                SHARED_DATASET_FULL_DATA[SHARED_DATASET_ID] = full_data
+                print("--- ✅ Shared dataset processed and cached successfully. ---")
+            else:
+                print("--- ⚠️  Shared dataset processing returned no data. Caching skipped. ---")
+        except Exception as e:
+            print(f"🔥 CRITICAL ERROR processing shared dataset: {e}")
+            import traceback
+            traceback.print_exc()
+    else:
+        print("--- ⚠️  Shared dataset or embeddings not available. Processing skipped. ---")
+
+
+# --- API Endpoints ---
+@app.get("/api/shared-dataset-metadata")
+async def get_shared_dataset_metadata():
+    # This function is unchanged
+    metadata_list = []
+    for dataset_id, full_data in SHARED_DATASET_FULL_DATA.items():
+        metadata = {"id": full_data["id"], "name": full_data["name"], "uploadDate": full_data["uploadDate"], "processingState": full_data["processingState"], "itemCounts": {"images": len(full_data["data"]["images"]), "texts": len(full_data["data"]["texts"]), "meshes": len(full_data["data"]["meshes"])}, "isShared": True}
+        metadata_list.append(metadata)
+    return metadata_list
+
+@app.get("/api/shared-dataset")
+async def get_shared_dataset(id: str):
+    # This function is unchanged
+    dataset = SHARED_DATASET_FULL_DATA.get(id)
+    if not dataset:
+        raise HTTPException(status_code=404, detail=f"Shared dataset with id '{id}' not found.")
+    return dataset
+
+@app.post("/api/process-dataset", response_model=ProcessDatasetResponse)
+async def process_dataset_endpoint(
+    background_tasks: BackgroundTasks, file: UploadFile = File(...)
+):
+    if not file.filename or not file.filename.endswith('.zip'):
+        raise HTTPException(status_code=400, detail="A ZIP archive is required.")
+
+    zip_bytes = await file.read()
+    job_id = str(uuid.uuid4())
+    PROCESSING_STATUS[job_id] = {"status": "starting", "stage": "Queued", "progress": 0}
+
+    background_tasks.add_task(
+        background_process_zip, zip_bytes, file.filename, job_id
+    )
+    return {"job_id": job_id}
+
+# --- NEW: processing-status endpoint ---
+class StatusResponse(BaseModel):
+    status: str
+    stage: str | None = None
+    progress: int | None = None
+    message: str | None = None
+    result: dict | None = None
+
+@app.get("/api/processing-status/{job_id}", response_model=StatusResponse)
+async def get_processing_status(job_id: str):
+    """Poll this endpoint to get the status of a processing job."""
+    status = PROCESSING_STATUS.get(job_id)
+    if not status:
+        raise HTTPException(status_code=404, detail="Job ID not found.")
+    return status
+
+
+@app.post("/api/find-matches")
+async def find_matches_endpoint(request: SingleMatchRequest):
+    # This function is unchanged
+    try:
+        match_results = await asyncio.to_thread(
+            find_matches_for_item, request.modality, request.content, request.dataset_id
+        )
+        source_item_data = {"id": "source_item", "name": "Source Item", "content": request.content}
+        final_response = {"sourceItem": source_item_data, "sourceModality": request.modality, **match_results}
+        return final_response
+    except ValueError as ve:
+        raise HTTPException(status_code=404, detail=str(ve))
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Ошибка при поиске совпадений: {e}")
+
+app.mount("/", StaticFiles(directory="static", html=True), name="static")

backend/requirements.txt

@@ -0,0 +1,31 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
+
+# Framework
+fastapi
+uvicorn[standard]
+python-multipart
+
+# ML & Data Science
+easydict
+matplotlib
+ninja
+numpy
+open_clip_torch
+pandas
+Pillow
+PyYAML
+scikit-learn
+scipy
+seaborn
+termcolor
+timm
+torch
+torchaudio
+torchvision
+tqdm
+trimesh
+umap-learn
+
+# Other
+requests
+wandb

frontend/App.tsx

@@ -0,0 +1,220 @@
+
+import React, { useState, useMemo, useEffect, useCallback, lazy, Suspense } from 'react';
+import { DatasetManager } from './components/DatasetManager';
+import type { Dataset, DatasetMetadata } from './types';
+import * as db from './services/dbService';
+import * as apiService from './services/apiService';
+import { Spinner } from './components/common/Spinner';
+
+const ComparisonTool = lazy(() => import('./components/ComparisonTool').then(module => ({ default: module.ComparisonTool })));
+
+type View = 'manager' | 'comparison';
+
+const App: React.FC = () => {
+  const [datasets, setDatasets] = useState<DatasetMetadata[]>([]);
+  const [selectedDatasetId, setSelectedDatasetId] = useState<string | null>(null);
+  const [activeDataset, setActiveDataset] = useState<Dataset | null>(null);
+  const [view, setView] = useState<View>('manager');
+  const [isLoading, setIsLoading] = useState(true);
+  const [isNavigating, setIsNavigating] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    const loadInitialData = async () => {
+      try {
+        const localMeta = await db.getAllDatasetMetadata();
+        let sharedMeta: DatasetMetadata[] = [];
+        try {
+            sharedMeta = await apiService.getSharedDatasetMetadata();
+        } catch (e) {
+            console.error("Could not load shared datasets, continuing with local.", e);
+            setError("Could not load cloud datasets. The backend service may be unavailable. Local datasets are still accessible.");
+        }
+        
+        const allMeta = [...sharedMeta, ...localMeta];
+
+        setDatasets(allMeta);
+
+        if (allMeta.length > 0) {
+            // Select the most recent dataset by default
+            const sortedMeta = [...allMeta].sort((a, b) => new Date(b.uploadDate).getTime() - new Date(a.uploadDate).getTime());
+            setSelectedDatasetId(sortedMeta[0].id);
+        }
+      } catch (error) {
+        console.error("Failed to load initial data", error);
+        setError("A critical error occurred while loading local datasets.");
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    loadInitialData();
+  }, []);
+
+  const addDataset = async (newDataset: Dataset) => {
+    await db.addDataset(newDataset);
+    const localMeta = await db.getAllDatasetMetadata();
+    const sharedMeta = datasets.filter(d => d.isShared); // Keep existing shared meta
+    setDatasets([...sharedMeta, ...localMeta]);
+    setSelectedDatasetId(newDataset.id);
+  };
+
+  const deleteDataset = async (id: string) => {
+    await db.deleteDataset(id);
+    setDatasets(prevDatasets => {
+      const newDatasets = prevDatasets.filter(d => d.id !== id);
+      if (selectedDatasetId === id) {
+        const sortedMeta = [...newDatasets].sort((a, b) => new Date(b.uploadDate).getTime() - new Date(a.uploadDate).getTime());
+        setSelectedDatasetId(sortedMeta.length > 0 ? sortedMeta[0].id : null);
+      }
+      return newDatasets;
+    });
+  };
+
+  const renameDataset = async (id: string, newName: string) => {
+    await db.renameDataset(id, newName);
+    setDatasets(prev => prev.map(d => d.id === id ? { ...d, name: newName } : d));
+  };
+  
+  const processedDatasets = useMemo(() => {
+    return datasets.filter(d => d.processingState === 'processed');
+  }, [datasets]);
+
+  const getFullDataset = async (id: string): Promise<Dataset | null> => {
+    const meta = datasets.find(d => d.id === id);
+    if (!meta) return null;
+
+    if (meta.isShared) {
+      return apiService.getSharedDataset(id);
+    } else {
+      return db.getDataset(id);
+    }
+  };
+
+  const handleOpenComparisonTool = useCallback(async () => {
+    if (!selectedDatasetId) return;
+    const selectedMeta = datasets.find(d => d.id === selectedDatasetId);
+    if (!selectedMeta || selectedMeta.processingState !== 'processed') return;
+
+    setView('comparison');
+    setActiveDataset(null);
+    setIsNavigating(true);
+
+    try {
+        const fullDataset = await getFullDataset(selectedDatasetId);
+        if (!fullDataset) {
+            throw new Error(`Failed to load dataset ${selectedDatasetId}.`);
+        }
+
+        // *** NEW LOGIC ***
+        // If it's a local dataset, ensure it's in the backend's cache before proceeding.
+        if (!fullDataset.isShared) {
+            console.log("Local dataset selected. Ensuring it's cached on the backend...");
+            await apiService.ensureDatasetInCache(fullDataset);
+            console.log("Backend cache confirmed.");
+        }
+
+        setActiveDataset(fullDataset);
+
+    } catch (error) {
+        console.error("Error preparing comparison tool:", error);
+        alert(`Error: Could not load the selected dataset. ${error instanceof Error ? error.message : ''}`);
+        setView('manager'); // Go back on error
+    } finally {
+        setIsNavigating(false);
+    }
+  }, [selectedDatasetId, datasets]);
+
+  const handleDatasetChange = useCallback(async (newId: string) => {
+      setSelectedDatasetId(newId);
+      
+      setActiveDataset(null);
+      setIsNavigating(true);
+
+      try {
+        const fullDataset = await getFullDataset(newId);
+        if (!fullDataset) {
+            throw new Error(`Failed to load dataset ${newId}.`);
+        }
+
+        // Also ensure cache is hydrated when switching datasets inside the tool
+        if (!fullDataset.isShared) {
+            await apiService.ensureDatasetInCache(fullDataset);
+        }
+        
+        setActiveDataset(fullDataset);
+
+      } catch (error) {
+            console.error(`Error switching dataset to ${newId}:`, error);
+            setActiveDataset(null);
+      } finally {
+          setIsNavigating(false);
+      }
+  }, []);
+
+
+  const mainContent = () => {
+    if (isLoading) {
+        return <div className="flex justify-center items-center h-64"><Spinner /><span>Loading Datasets...</span></div>;
+    }
+    
+    const errorBanner = error ? (
+        <div className="bg-red-800/50 border border-red-600 text-red-200 px-4 py-3 rounded-lg mb-4" role="alert">
+          <p>
+            <strong className="font-bold">Cloud Connection Error:</strong> {error}
+          </p>
+        </div>
+    ) : null;
+
+    if (view === 'manager') {
+      return (
+        <DatasetManager
+          datasets={datasets}
+          selectedDatasetId={selectedDatasetId}
+          onSelectDataset={setSelectedDatasetId}
+          onAddDataset={addDataset}
+          onDeleteDataset={deleteDataset}
+          onRenameDataset={renameDataset}
+          onOpenComparisonTool={handleOpenComparisonTool}
+          onGetFullDataset={getFullDataset}
+          errorBanner={errorBanner}
+        />
+      );
+    }
+    
+    if (view === 'comparison') {
+        const fallbackUI = <div className="flex justify-center items-center h-64"><Spinner /><span>Loading Comparison Tool...</span></div>;
+        if (isNavigating || !activeDataset) {
+            return fallbackUI;
+        }
+        return (
+            <Suspense fallback={fallbackUI}>
+                <ComparisonTool
+                    key={activeDataset.id}
+                    dataset={activeDataset}
+                    allDatasets={processedDatasets}
+                    onDatasetChange={handleDatasetChange}
+                    onBack={() => { setView('manager'); setActiveDataset(null); }}
+                />
+            </Suspense>
+        );
+    }
+    return null;
+  };
+
+  return (
+    <div className="min-h-screen bg-gray-900 text-gray-200 font-sans">
+      <header className="bg-gray-800/50 backdrop-blur-sm border-b border-gray-700 sticky top-0 z-20">
+        <div className="container mx-auto px-4 sm:px-6 lg:px-8 py-4 flex items-center justify-between">
+          <h1 className="text-2xl font-bold text-cyan-400">
+            Cross-Modal Object Comparison Tool
+          </h1>
+        </div>
+      </header>
+      <main className="container mx-auto px-4 sm:px-6 lg:px-8 py-8">
+        {mainContent()}
+      </main>
+    </div>
+  );
+};
+
+export default App;

frontend/components/ComparisonTool.tsx

@@ -0,0 +1,558 @@
+
+import React, { useState, useMemo, useCallback, useEffect, useRef, lazy, Suspense } from 'react';
+import type { Dataset, Modality, DataItem, SingleComparisonResult, DatasetMetadata } from '../types';
+import { findTopMatches } from '../services/apiService';
+import { findTopMatchesFromLocal } from '../services/comparisonService';
+import { downloadJson } from '../services/fileService';
+import { FullscreenViewer } from './common/FullscreenViewer';
+import { Spinner } from './common/Spinner';
+import { getItemContent } from '../services/sharedDatasetService';
+
+const MeshViewer = lazy(() => import('./common/MeshViewer').then(module => ({ default: module.MeshViewer })));
+
+interface ItemCardBaseProps { 
+    modality: Modality; 
+    isSource?: boolean; 
+    confidence?: number;
+    onView: (item: DataItem, modality: Modality) => void;
+    onClick?: () => void;
+    className?: string;
+}
+
+const LazyItemCard: React.FC<ItemCardBaseProps & { item: DataItem }> = ({ item, ...props }) => {
+    const [loadedItem, setLoadedItem] = useState<DataItem>(item);
+    const [isLoading, setIsLoading] = useState(!item.content && !!item.contentUrl);
+
+    useEffect(() => {
+        let isMounted = true;
+        // Images are loaded by the browser directly via `contentUrl`, so we only fetch for text/mesh.
+        if (!item.content && item.contentUrl && props.modality !== 'image') {
+            setIsLoading(true);
+            getItemContent(item.contentUrl)
+                .then(content => {
+                    if (isMounted) {
+                        setLoadedItem({ ...item, content });
+                        setIsLoading(false);
+                    }
+                })
+                .catch(err => {
+                    console.error("Failed to load item content", err);
+                    if (isMounted) setIsLoading(false);
+                });
+        } else {
+            setLoadedItem(item);
+            setIsLoading(false);
+        }
+        return () => { isMounted = false; }
+    }, [item, props.modality]);
+
+    if (isLoading) {
+        return (
+            <div className={`bg-gray-800 rounded-lg shadow-md border border-gray-700 flex items-center justify-center aspect-[4/3] ${props.className}`}>
+                <Spinner />
+            </div>
+        );
+    }
+    
+    return <ItemCard {...props} item={loadedItem} />;
+};
+
+
+const ItemCard: React.FC<ItemCardBaseProps & { item: DataItem }> = ({ item, modality, isSource, confidence, onView, onClick }) => {
+  const isText = modality === 'text';
+  
+  // Use contentUrl for images directly, fallback to loaded content if available.
+  const imageUrl = modality === 'image' ? (item.contentUrl || (item.content as string)) : null;
+
+  const content = useMemo(() => {
+    switch (modality) {
+      case 'image':
+        if (!imageUrl) return null;
+        return (
+            <div className="relative pt-[75%]">
+                <div className="absolute inset-0">
+                    <img src={imageUrl} alt={item.name} className="object-cover w-full h-full rounded-md" />
+                </div>
+            </div>
+        );
+      case 'text':
+        if (typeof item.content !== 'string') return null;
+        return <div className="h-full overflow-y-auto"><p className="text-xs text-gray-300 p-3">{item.content}</p></div>;
+      case 'mesh':
+        return (
+          <div className="relative pt-[75%]">
+             <div className="absolute inset-0 bg-gray-700 rounded-md overflow-hidden">
+                <Suspense fallback={<div className="w-full h-full flex items-center justify-center"><Spinner /></div>}>
+                    <MeshViewer stlContent={item.content || item.contentUrl} interactive={false} />
+                </Suspense>
+            </div>
+          </div>
+        );
+    }
+  }, [item, modality, imageUrl]);
+
+  return (
+    <div 
+        className={`bg-gray-800 rounded-lg shadow-md border flex flex-col h-full transition-shadow hover:shadow-cyan-500/20 ${isSource ? 'border-cyan-500' : 'border-gray-700'}`}
+        onClick={() => onClick ? onClick() : onView(item, modality)}
+    >
+      <div className={`flex-grow ${isText ? 'h-32' : ''}`}>{content}</div>
+      <div className="p-2 text-xs bg-gray-800/50 rounded-b-lg">
+        <p className="font-semibold truncate text-white">{item.name}</p>
+        {confidence !== undefined && <p className="text-cyan-300">Confidence: {confidence.toFixed(4)}</p>}
+      </div>
+    </div>
+  );
+};
+
+const pluralToSingular = (plural: string): Modality => {
+    if (plural === 'meshes') return 'mesh';
+    return plural.slice(0, -1) as Modality;
+}
+
+const ResultsDisplay: React.FC<{ 
+    results: SingleComparisonResult;
+    onViewItem: (item: DataItem, modality: Modality) => void;
+}> = ({ results, onViewItem }) => {
+  const sourcePluralModality = results.sourceModality === 'mesh' ? 'meshes' : `${results.sourceModality}s`;
+  
+  return (
+    <div className="mt-6 p-4 bg-gray-800/50 border border-gray-700 rounded-lg">
+      <h3 className="text-xl font-bold mb-4">Comparison Results</h3>
+      <div className="flex flex-col md:flex-row gap-6 items-start">
+        {/* Source Item */}
+        <div className="w-full md:w-1/4 flex-shrink-0">
+          <h4 className="font-semibold mb-2 text-center text-cyan-400">Source Item</h4>
+          <div className="cursor-pointer">
+            <LazyItemCard item={results.sourceItem} modality={results.sourceModality} isSource onView={onViewItem}/>
+          </div>
+        </div>
+        {/* Matches */}
+        <div className="w-full md:w-3/4 flex flex-col gap-6">
+          {Object.entries(results.results)
+             .filter(([pluralModality, matches]) => pluralModality !== sourcePluralModality && matches && matches.length > 0)
+             .map(([pluralModality, matches]) => (
+            <div key={pluralModality}>
+              <h4 className="font-semibold mb-2 capitalize text-indigo-400">{pluralModality} Matches</h4>
+                <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-3">
+                  {(matches || []).slice(0, 3).map(match => (
+                    <div key={match.item.id} className="cursor-pointer">
+                        <LazyItemCard 
+                            item={match.item} 
+                            modality={pluralToSingular(pluralModality)} 
+                            confidence={match.confidence} 
+                            onView={onViewItem} 
+                        />
+                    </div>
+                  ))}
+                </div>
+            </div>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+};
+
+interface ComparisonToolProps {
+  dataset: Dataset;
+  allDatasets: DatasetMetadata[]; // Use metadata for the dropdown
+  onDatasetChange: (id: string) => void;
+  onBack: () => void;
+}
+
+const FileUploader: React.FC<{
+  onFileSelect: (file: File) => void | Promise<void>;
+  accept: string;
+  modality: Modality;
+  clear: () => void;
+}> = ({ onFileSelect, accept, modality, clear }) => {
+  const [file, setFile] = useState<File | null>(null);
+  const inputRef = React.useRef<HTMLInputElement>(null);
+
+  const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const selectedFile = e.target.files?.[0];
+    if (selectedFile) {
+      setFile(selectedFile);
+      onFileSelect(selectedFile);
+    }
+  };
+
+  const handleClear = () => {
+    setFile(null);
+    if(inputRef.current) inputRef.current.value = "";
+    clear();
+  }
+
+  return (
+    <div className="w-full text-center">
+        <input type="file" ref={inputRef} accept={accept} onChange={handleFileChange} className="hidden" />
+        <button 
+          onClick={() => inputRef.current?.click()}
+          className="w-full bg-gray-700 hover:bg-gray-600 text-white font-semibold py-3 px-4 rounded-lg transition-colors text-center flex items-center justify-center gap-2"
+        >
+            <svg xmlns="http://www.w3.org/2000/svg" className="h-5 w-5" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+              <path strokeLinecap="round" strokeLinejoin="round" d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-8l-4-4m0 0L8 8m4-4v12" />
+            </svg>
+            <span>{`Upload a ${modality} file`}</span>
+        </button>
+        {file && (
+          <div className="mt-2 text-sm">
+            <p className="text-gray-300 truncate">Selected: {file.name}</p>
+            <button onClick={handleClear} className="text-cyan-400 hover:text-cyan-300 underline" title="Clear selection">
+              Clear
+            </button>
+          </div>
+        )}
+    </div>
+  );
+};
+
+export const ComparisonTool: React.FC<ComparisonToolProps> = ({ dataset, allDatasets, onDatasetChange, onBack }) => {
+  const [activeTab, setActiveTab] = useState<Modality>('image');
+  const [selectedItem, setSelectedItem] = useState<DataItem | null>(null);
+  const [newItem, setNewItem] = useState<{file?: File, text?: string} | null>(null);
+  const [newItemPreview, setNewItemPreview] = useState<string | null>(null);
+  const [newItemMeshPreviewContent, setNewItemMeshPreviewContent] = useState<ArrayBuffer | null>(null);
+  const [comparisonResult, setComparisonResult] = useState<SingleComparisonResult | null>(null);
+  const [isComparing, setIsComparing] = useState(false);
+  const [searchTerm, setSearchTerm] = useState('');
+  const [viewingItem, setViewingItem] = useState<{ item: DataItem; modality: Modality } | null>(null);
+  const resultsRef = useRef<HTMLDivElement>(null);
+
+  const MAX_ITEMS_TO_DISPLAY = 30;
+
+  useEffect(() => {
+    // Cleanup object URLs to prevent memory leaks
+    return () => {
+        if(newItemPreview && newItemPreview.startsWith('blob:')) {
+            URL.revokeObjectURL(newItemPreview);
+        }
+    }
+  }, [newItemPreview]);
+
+  useEffect(() => {
+    // Scroll to results when they appear
+    if (comparisonResult && resultsRef.current) {
+        // A small delay to ensure the element is rendered and painted before scrolling
+        const timer = setTimeout(() => {
+            resultsRef.current?.scrollIntoView({ behavior: 'smooth', block: 'start' });
+        }, 100);
+        return () => clearTimeout(timer);
+    }
+  }, [comparisonResult]);
+
+  const handleItemSelect = async (item: DataItem) => {
+    setSelectedItem(item);
+    setNewItem(null);
+    setNewItemPreview(null);
+    setNewItemMeshPreviewContent(null);
+
+    // Optimistic UI update to show the newly selected source item immediately
+    setComparisonResult({
+        sourceItem: item,
+        sourceModality: activeTab,
+        results: {}, // No matches yet, will be populated below
+    });
+
+    let itemWithContent = item;
+    // For cloud items, the content is not loaded yet. We must fetch it.
+    // The individual card will show a spinner, so we don't need a global one.
+    if (!item.content && item.contentUrl) {
+        try {
+            const content = await getItemContent(item.contentUrl);
+            itemWithContent = { ...item, content };
+        } catch (e) {
+            console.error("Failed to lazy-load content for comparison:", e);
+            alert("Could not load item content from the server for comparison.");
+            setComparisonResult(null); // Clear results on error
+            setSelectedItem(null);
+            return;
+        }
+    }
+    
+    // Use fast, local search for existing dataset items and update the results
+    const results = findTopMatchesFromLocal(itemWithContent, activeTab, dataset);
+    setComparisonResult(results);
+  };
+  
+  const handleNewItemSearch = async () => {
+    if (!newItem) return;
+    
+    setSelectedItem(null); // Deselect grid item
+    setIsComparing(true);
+    setComparisonResult(null); // Clear previous results
+
+    try {
+        let content: string | ArrayBuffer;
+        let name: string;
+
+        if (newItem.file) {
+            name = newItem.file.name;
+            if (activeTab === 'image') {
+                content = await new Promise((resolve, reject) => {
+                    const reader = new FileReader();
+                    reader.onload = () => resolve(reader.result as string);
+                    reader.onerror = reject;
+                    reader.readAsDataURL(newItem.file);
+                });
+            } else if (activeTab === 'mesh') {
+                content = await new Promise((resolve, reject) => {
+                    const reader = new FileReader();
+                    reader.onload = () => resolve(reader.result as ArrayBuffer);
+                    reader.onerror = reject;
+                    reader.readAsArrayBuffer(newItem.file);
+                });
+            } else { // text file
+                 content = await new Promise((resolve, reject) => {
+                    const reader = new FileReader();
+                    reader.onload = () => resolve(reader.result as string);
+                    reader.onerror = reject;
+                    reader.readAsText(newItem.file);
+                });
+            }
+        } else if (newItem.text) {
+            name = 'Custom Text Input';
+            content = newItem.text;
+        } else {
+            throw new Error("No new item content found");
+        }
+        
+        const sourceItem: DataItem = { id: `new_${Date.now()}`, name, content };
+        
+        // Optimistic UI: Show the source item while waiting for matches.
+        setComparisonResult({
+            sourceItem,
+            sourceModality: activeTab,
+            results: {},
+        });
+
+        const results = await findTopMatches(sourceItem, activeTab, dataset.id);
+        setComparisonResult(results);
+
+    } catch (error) {
+      console.error("Failed to find matches for new item:", error);
+      alert(`Error finding matches: ${error instanceof Error ? error.message : String(error)}`);
+      setComparisonResult(null); // Clear on error
+    } finally {
+      setIsComparing(false);
+    }
+  }
+
+  const handleFullComparison = () => {
+    if (dataset.fullComparison) {
+      downloadJson(dataset.fullComparison, `${dataset.name}-full-comparison.json`);
+    } else {
+      alert("Full comparison data is not available for this dataset.");
+    }
+  };
+
+  const clearNewItem = useCallback(() => {
+    setNewItem(null);
+    if(newItemPreview && newItemPreview.startsWith('blob:')) URL.revokeObjectURL(newItemPreview);
+    setNewItemPreview(null);
+    setNewItemMeshPreviewContent(null);
+  }, [newItemPreview]);
+
+  const handleFileSelected = async (file: File) => {
+    setNewItem({ file });
+    setSelectedItem(null);
+    if(newItemPreview && newItemPreview.startsWith('blob:')) URL.revokeObjectURL(newItemPreview);
+    setNewItemPreview(null);
+    setNewItemMeshPreviewContent(null);
+
+    if(activeTab === 'image') {
+        setNewItemPreview(URL.createObjectURL(file));
+    } else if (activeTab === 'mesh') {
+        try {
+            const buffer = await file.arrayBuffer();
+            setNewItemMeshPreviewContent(buffer);
+        } catch (error) {
+            console.error("Error reading STL file for preview:", error);
+            alert("Could not read the file for preview.");
+        }
+    }
+  }
+
+  const handleTabChange = (mod: Modality) => {
+    setActiveTab(mod);
+    setComparisonResult(null);
+    setSelectedItem(null);
+    clearNewItem();
+  }
+  
+  const pluralKey = activeTab === 'mesh' ? 'meshes' : `${activeTab}s`;
+  const items = dataset.data[pluralKey as keyof typeof dataset.data];
+
+  const filteredItems = useMemo(() => {
+    if (!searchTerm) return items;
+    return items.filter(item => item.name.toLowerCase().includes(searchTerm.toLowerCase()));
+  }, [items, searchTerm]);
+
+  const displayedItems = useMemo(() => {
+    return filteredItems.slice(0, MAX_ITEMS_TO_DISPLAY);
+  }, [filteredItems]);
+
+  return (
+    <>
+    <div className="space-y-8">
+      <div className="flex flex-col sm:flex-row items-start sm:items-center justify-between gap-4">
+        <div className="flex items-center gap-4">
+          <h2 className="text-3xl font-bold tracking-tight">Comparison Tool:</h2>
+          <select 
+            value={dataset.id} 
+            onChange={(e) => onDatasetChange(e.target.value)}
+            className="bg-gray-700 border border-gray-600 rounded-md px-3 py-2 text-white text-lg focus:ring-2 focus:ring-cyan-500 focus:outline-none"
+          >
+            {allDatasets.map(d => <option key={d.id} value={d.id}>{d.name}</option>)}
+          </select>
+        </div>
+        <button onClick={onBack} className="bg-gray-600 hover:bg-gray-500 text-white font-bold py-2 px-4 rounded-lg transition-colors">
+          &larr; Back to Manager
+        </button>
+      </div>
+      
+      <div className="border-b border-gray-600">
+          <nav className="-mb-px flex space-x-8">
+              {(['image', 'text', 'mesh'] as Modality[]).map(mod => (
+              <button key={mod} onClick={() => handleTabChange(mod)}
+                  className={`${activeTab === mod ? 'border-cyan-400 text-cyan-400' : 'border-transparent text-gray-400 hover:text-gray-200'}
+                  whitespace-nowrap py-3 px-1 border-b-2 font-medium text-sm capitalize transition-colors`}>
+                  {mod === 'mesh' ? 'meshes' : `${mod}s`}
+              </button>
+              ))}
+          </nav>
+      </div>
+
+      {/* Single Element Search */}
+      <div className="bg-gray-800/50 p-6 rounded-lg border border-gray-700 space-y-6">
+        <div>
+            <h3 className="text-2xl font-bold text-center mb-6">Search with New Item</h3>
+            <div className="flex flex-col md:flex-row items-start justify-center gap-8 w-full max-w-4xl mx-auto">
+                {/* Left side: Uploader Controls */}
+                <div className="w-full md:w-1/2 flex flex-col justify-start items-center space-y-4">
+                    {activeTab === 'image' && (
+                        <div className="w-full max-w-sm">
+                            <FileUploader onFileSelect={handleFileSelected} accept="image/png, image/jpeg" modality="image" clear={clearNewItem} />
+                        </div>
+                    )}
+                    {activeTab === 'mesh' && (
+                        <div className="w-full max-w-sm">
+                            <FileUploader onFileSelect={handleFileSelected} accept=".stl" modality="mesh" clear={clearNewItem} />
+                        </div>
+                    )}
+                    {activeTab === 'text' && (
+                        <div className="space-y-3 h-full w-full max-w-sm flex flex-col">
+                            <textarea 
+                                value={newItem?.text ?? ''}
+                                onChange={(e) => { setNewItem({ text: e.target.value }); setSelectedItem(null); }}
+                                placeholder="Type or paste text here..."
+                                className="w-full h-28 bg-gray-700 border border-gray-600 rounded-md p-2 text-white focus:ring-2 focus:ring-cyan-500 focus:outline-none resize-none"
+                            />
+                            <div className="text-center text-gray-400 text-sm">or</div>
+                            <FileUploader onFileSelect={handleFileSelected} accept=".txt" modality="text" clear={clearNewItem} />
+                        </div>
+                    )}
+
+                    <button onClick={handleNewItemSearch} disabled={!newItem || isComparing} className="bg-cyan-500 hover:bg-cyan-600 text-white font-bold py-3 px-8 rounded-lg transition-colors flex items-center justify-center disabled:bg-gray-600 disabled:cursor-not-allowed text-base w-full max-w-sm">
+                        {isComparing ? <><Spinner /> Searching...</> : 'Find Matches for New Item'}
+                    </button>
+                </div>
+
+                {/* Right side: Preview */}
+                <div className="w-full md:w-1/2 flex flex-col items-center">
+                    <div className="w-full max-w-sm aspect-[4/3] bg-gray-900/50 rounded-md flex items-center justify-center relative overflow-hidden border border-gray-700">
+                        {activeTab === 'image' && newItemPreview ? (
+                            <img src={newItemPreview} alt="Preview" className="absolute inset-0 w-full h-full object-cover"/>
+                        ) : activeTab === 'mesh' && newItemMeshPreviewContent ? (
+                           <div className="absolute inset-0">
+                               <Suspense fallback={<div className="w-full h-full flex items-center justify-center"><Spinner /></div>}>
+                                   <MeshViewer stlContent={newItemMeshPreviewContent} interactive={true} />
+                               </Suspense>
+                           </div>
+                        ) : (
+                            <div className="text-gray-500 italic p-4 text-center">
+                                {activeTab === 'image' && 'Image preview will appear here'}
+                                {activeTab === 'mesh' && '3D model preview will appear here'}
+                                {activeTab === 'text' && 'Enter text or upload a TXT file to search'}
+                            </div>
+                        )}
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <div className="border-t border-gray-700 pt-6">
+            <div className="flex flex-col sm:flex-row justify-between items-center mb-4 gap-4">
+                <h3 className="text-2xl font-bold">...or Select from Dataset</h3>
+                <input 
+                    type="text"
+                    placeholder="Search items by name..."
+                    value={searchTerm}
+                    onChange={(e) => setSearchTerm(e.target.value)}
+                    className="bg-gray-700 border border-gray-600 rounded-md px-3 py-2 w-full sm:w-64 text-white focus:ring-2 focus:ring-cyan-500 focus:outline-none"
+                />
+            </div>
+            <div className="max-h-96 overflow-y-auto p-2 bg-gray-900/50 rounded-md">
+                <div className="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-6 gap-4">
+                    {displayedItems.map(item => (
+                        <div key={item.id}
+                            className={`rounded-lg overflow-hidden border-2 ${selectedItem?.id === item.id ? 'border-cyan-500 ring-2 ring-cyan-500' : 'border-transparent'}`}>
+                             <LazyItemCard 
+                                item={item} 
+                                modality={activeTab} 
+                                onView={(viewedItem, mod) => setViewingItem({item: viewedItem, modality: mod})} 
+                                onClick={() => handleItemSelect(item)}
+                                className="cursor-pointer"
+                             />
+                        </div>
+                    ))}
+                </div>
+                {filteredItems.length > displayedItems.length && (
+                  <p className="text-center text-gray-500 p-4 text-sm">
+                    Showing first {MAX_ITEMS_TO_DISPLAY} of {filteredItems.length} items.
+                    {searchTerm ? " Refine your search." : " Use search to narrow results."}
+                  </p>
+                )}
+                {filteredItems.length === 0 && <p className="text-center text-gray-500 p-8">No items found matching your search.</p>}
+            </div>
+        </div>
+
+        {isComparing && !comparisonResult && (
+          <div className="mt-6 p-4 text-center">
+            <div className="flex justify-center items-center gap-2 text-lg">
+              <Spinner />
+              <span>Finding matches...</span>
+            </div>
+          </div>
+        )}
+        <div ref={resultsRef}>
+            {comparisonResult && <ResultsDisplay results={comparisonResult} onViewItem={(item, modality) => setViewingItem({item, modality})}/>}
+        </div>
+      </div>
+      
+      {/* Full Dataset Comparison */}
+      <div className="bg-gray-800/50 p-6 rounded-lg border border-gray-700">
+        <h3 className="text-2xl font-bold mb-4">Full Dataset Comparison</h3>
+        <p className="text-gray-400 mb-4">
+            The full comparison results for this dataset have been pre-computed. Click the button to download them as a JSON file instantly.
+        </p>
+        <button 
+          onClick={handleFullComparison}
+          disabled={!dataset.fullComparison}
+          className="bg-indigo-500 hover:bg-indigo-600 text-white font-bold py-3 px-6 rounded-lg transition-colors w-full sm:w-auto flex items-center justify-center gap-2 disabled:bg-gray-600 disabled:cursor-not-allowed"
+        >
+          Download Full Comparison JSON
+        </button>
+      </div>
+    </div>
+    {viewingItem && (
+        <FullscreenViewer
+            item={viewingItem.item}
+            modality={viewingItem.modality}
+            onClose={() => setViewingItem(null)}
+        />
+    )}
+    </>
+  );
+};

frontend/components/DatasetManager.tsx

@@ -0,0 +1,460 @@
+import React, { useState, useRef, useEffect, useMemo } from 'react';
+import type { Dataset, DatasetMetadata } from '../types';
+import { DatasetViewer } from './DatasetViewer';
+import { Modal } from './common/Modal';
+import { Spinner } from './common/Spinner';
+import { ProgressBar } from './common/ProgressBar';
+import { startDatasetProcessing, getProcessingStatus } from '../services/apiService';
+import { downloadCsv } from '../services/fileService';
+
+interface DatasetManagerProps {
+  datasets: DatasetMetadata[];
+  selectedDatasetId: string | null;
+  onSelectDataset: (id: string | null) => void;
+  onAddDataset: (dataset: Dataset) => Promise<void>;
+  onDeleteDataset: (id: string) => Promise<void>;
+  onRenameDataset: (id: string, newName: string) => Promise<void>;
+  onOpenComparisonTool: () => void;
+  onGetFullDataset: (id: string) => Promise<Dataset | null>;
+  errorBanner?: React.ReactNode | null;
+}
+
+const useSmoothProgress = (targetProgress: number, duration: number = 6000) => {
+    const [displayedProgress, setDisplayedProgress] = useState(targetProgress);
+    // FIX: Initialize useRef with null to satisfy TypeScript's requirement for an initial value when a generic type is provided.
+    const animationFrameRef = useRef<number | null>(null);
+    const startProgressRef = useRef<number>(targetProgress);
+    // The value is set in useEffect before it's ever used, so initializing with 0 is safe.
+    const startTimeRef = useRef<number>(0);
+
+    useEffect(() => {
+        startProgressRef.current = displayedProgress;
+        // FIX: Explicitly call `window.performance.now()` to avoid potential scope resolution issues with build tools which could be causing the cryptic error.
+        startTimeRef.current = window.performance.now();
+
+        const animate = (currentTime: number) => {
+            const elapsedTime = currentTime - startTimeRef.current;
+            const progressFraction = Math.min(elapsedTime / duration, 1);
+            
+            // Ease-out quadratic easing function
+            const easedFraction = progressFraction * (2 - progressFraction);
+
+            const newProgress = startProgressRef.current + (targetProgress - startProgressRef.current) * easedFraction;
+            setDisplayedProgress(newProgress);
+
+            if (progressFraction < 1) {
+                animationFrameRef.current = requestAnimationFrame(animate);
+            }
+        };
+
+        if (animationFrameRef.current) {
+            cancelAnimationFrame(animationFrameRef.current);
+        }
+        animationFrameRef.current = requestAnimationFrame(animate);
+
+        return () => {
+            if (animationFrameRef.current) {
+                cancelAnimationFrame(animationFrameRef.current);
+            }
+        };
+    }, [targetProgress, duration]);
+
+    return displayedProgress;
+};
+
+
+const ThreeDotsIcon = () => (
+    <svg xmlns="http://www.w3.org/2000/svg" className="h-5 w-5" viewBox="0 0 20 20" fill="currentColor">
+        <path d="M10 6a2 2 0 110-4 2 2 0 010 4zM10 12a2 2 0 110-4 2 2 0 010 4zM10 18a2 2 0 110-4 2 2 0 010 4z" />
+    </svg>
+);
+
+const CloudIcon = () => (
+    <svg xmlns="http://www.w3.org/2000/svg" className="h-5 w-5 text-cyan-400" viewBox="0 0 20 20" fill="currentColor">
+      <path d="M5.5 16a3.5 3.5 0 01-.369-6.98 4 4 0 117.753-1.977A4.5 4.5 0 1113.5 16h-8z" />
+    </svg>
+);
+
+
+const CheckCircleIcon = () => (
+    <svg xmlns="http://www.w3.org/2000/svg" className="h-5 w-5 text-green-400" viewBox="0 0 20 20" fill="currentColor">
+      <path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clipRule="evenodd" />
+    </svg>
+);
+
+const ExclamationCircleIcon = () => (
+    <svg xmlns="http://www.w3.org/2000/svg" className="h-5 w-5 text-red-400" viewBox="0 0 20 20" fill="currentColor">
+        <path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm-1-9a1 1 0 112 0v4a1 1 0 11-2 0V9zm1-4a1 1 0 100 2 1 1 0 000-2z" clipRule="evenodd" />
+    </svg>
+);
+
+
+interface ProcessingStatus {
+    id: string; // This will be the job_id from the backend
+    name: string;
+    stage: string;
+    progress: number;
+    uploadDate: Date;
+    error?: string;
+}
+
+const StatusDisplay: React.FC<{dataset: DatasetMetadata | { stage: string; progress: number; error?: string } }> = ({ dataset }) => {
+    if ('stage' in dataset) { // It's a ProcessingStatus object
+        if (dataset.error) {
+             return <div className="flex items-center gap-2 text-red-400 truncate" title={dataset.error}> <ExclamationCircleIcon /> Error </div>;
+        }
+        return <ProgressBar progress={dataset.progress} label={dataset.stage} />;
+    }
+
+    switch (dataset.processingState) {
+        case 'processing':
+            return <ProgressBar progress={100} label="Processing..." />;
+        case 'processed':
+            return <div className="flex items-center gap-2 text-green-400"> <CheckCircleIcon /> Completed </div>;
+        case 'error':
+            return <div className="flex items-center gap-2 text-red-400"> <ExclamationCircleIcon /> Error </div>;
+        default:
+             return <span className="text-gray-400">Pending</span>;
+    }
+}
+
+const ProcessingRow: React.FC<{status: ProcessingStatus}> = ({ status }) => {
+    const displayedProgress = useSmoothProgress(status.progress);
+
+    return (
+        <ul className="divide-y divide-gray-700">
+            <li className="grid grid-cols-12 gap-4 p-4 items-center bg-gray-700/30">
+                <div className="col-span-3 font-medium truncate">{status.name}</div>
+                <div className="col-span-3 text-gray-400">---</div>
+                <div className="col-span-2 text-sm text-gray-400">{status.uploadDate.toLocaleString()}</div>
+                <div className="col-span-3 text-sm">
+                    <StatusDisplay dataset={{...status, progress: displayedProgress}} />
+                </div>
+                <div className="col-span-1 flex justify-end"></div>
+            </li>
+        </ul>
+    );
+}
+
+export const DatasetManager: React.FC<DatasetManagerProps> = ({
+  datasets,
+  selectedDatasetId,
+  onSelectDataset,
+  onAddDataset,
+  onDeleteDataset,
+  onRenameDataset,
+  onOpenComparisonTool,
+  onGetFullDataset,
+  errorBanner = null,
+}) => {
+  const [isViewerOpen, setViewerOpen] = useState(false);
+  const [isRenameModalOpen, setRenameModalOpen] = useState(false);
+  const [activeDropdown, setActiveDropdown] = useState<string | null>(null);
+  const [datasetToEdit, setDatasetToEdit] = useState<DatasetMetadata | null>(null);
+  const [fullDatasetForViewer, setFullDatasetForViewer] = useState<Dataset | null>(null);
+  const [isViewerLoading, setIsViewerLoading] = useState(false);
+  const [newDatasetName, setNewDatasetName] = useState('');
+  const [processingStatus, setProcessingStatus] = useState<ProcessingStatus | null>(null);
+  const pollingIntervalRef = useRef<number | null>(null);
+  const fileInputRef = useRef<HTMLInputElement>(null);
+
+  useEffect(() => {
+    return () => {
+      if (pollingIntervalRef.current) {
+        clearInterval(pollingIntervalRef.current);
+      }
+    };
+  }, []);
+
+  const handleUploadClick = () => {
+    fileInputRef.current?.click();
+  };
+  
+  const handleFileSelect = async (event: React.ChangeEvent<HTMLInputElement>) => {
+    const file = event.target.files?.[0];
+    if (!file) return;
+
+    if (pollingIntervalRef.current) clearInterval(pollingIntervalRef.current);
+
+    const tempStatus: ProcessingStatus = {
+        name: file.name,
+        progress: 0,
+        stage: 'Uploading...',
+        id: `processing-${Date.now()}`,
+        uploadDate: new Date()
+    };
+    setProcessingStatus(tempStatus);
+
+    try {
+        const jobId = await startDatasetProcessing(file);
+
+        setProcessingStatus(prev => prev ? { ...prev, id: jobId, stage: 'Queued', progress: 5 } : null);
+
+        pollingIntervalRef.current = window.setInterval(async () => {
+            try {
+                const status = await getProcessingStatus(jobId);
+                
+                if (status.status === 'processing') {
+                    setProcessingStatus(prev => {
+                        if (prev?.id === jobId) {
+                            return {
+                                ...prev,
+                                stage: status.stage || 'Processing...',
+                                progress: status.progress || prev.progress,
+                            };
+                        }
+                        return prev;
+                    });
+                } else if (status.status === 'complete') {
+                    if (pollingIntervalRef.current) clearInterval(pollingIntervalRef.current);
+                    if (status.result) {
+                        await onAddDataset(status.result);
+                    }
+                    setProcessingStatus(null);
+                } else if (status.status === 'error') {
+                    if (pollingIntervalRef.current) clearInterval(pollingIntervalRef.current);
+                    setProcessingStatus(prev => prev?.id === jobId ? {
+                        ...prev,
+                        stage: 'Error',
+                        progress: 100,
+                        error: status.message || 'An unknown error occurred.'
+                    } : prev);
+                }
+
+            } catch (pollError: any) {
+                console.error("Polling error:", pollError);
+                if (pollingIntervalRef.current) clearInterval(pollingIntervalRef.current);
+                setProcessingStatus(prev => prev?.id === jobId ? {
+                    ...prev,
+                    stage: 'Error',
+                    progress: 100,
+                    error: `Failed to get status: ${pollError.message}`
+                } : prev);
+            }
+        }, 2000);
+
+    } catch (error: any) {
+        console.error("Failed to start dataset processing:", error);
+        setProcessingStatus({
+            ...tempStatus,
+            stage: 'Error',
+            progress: 100,
+            error: error.message,
+        });
+    } finally {
+        if (fileInputRef.current) {
+            fileInputRef.current.value = '';
+        }
+    }
+  };
+
+  const handleRename = () => {
+    if (datasetToEdit && newDatasetName.trim()) {
+      onRenameDataset(datasetToEdit.id, newDatasetName.trim());
+      setRenameModalOpen(false);
+      setDatasetToEdit(null);
+      setNewDatasetName('');
+    }
+  };
+
+  const openRenameModal = (dataset: DatasetMetadata) => {
+    setDatasetToEdit(dataset);
+    setNewDatasetName(dataset.name);
+    setRenameModalOpen(true);
+    setActiveDropdown(null);
+  };
+
+  const openViewer = (datasetMeta: DatasetMetadata) => {
+    setViewerOpen(true);
+    setFullDatasetForViewer(null);
+    setIsViewerLoading(true);
+    setActiveDropdown(null);
+
+    onGetFullDataset(datasetMeta.id)
+      .then(fullDataset => {
+        if (fullDataset) {
+          setFullDatasetForViewer(fullDataset);
+        } else {
+          alert("Could not load dataset details.");
+          setViewerOpen(false);
+        }
+      })
+      .catch(e => {
+        console.error("Failed to fetch dataset for viewer:", e);
+        alert(`Error: Could not load dataset. ${e instanceof Error ? e.message : ''}`);
+        setViewerOpen(false);
+      })
+      .finally(() => {
+        setIsViewerLoading(false);
+      });
+  };
+
+  const handleDelete = (id: string) => {
+      if (window.confirm('Are you sure you want to delete this dataset?')) {
+          onDeleteDataset(id);
+      }
+      setActiveDropdown(null);
+  }
+
+  const handleDownloadAnalysis = (datasetMeta: DatasetMetadata) => {
+    if (datasetMeta.processingState !== 'processed') {
+        alert('Dataset is not processed yet.');
+        return;
+    }
+    
+    onGetFullDataset(datasetMeta.id).then(fullDataset => {
+        if (fullDataset && fullDataset.fullComparison) {
+            downloadCsv(fullDataset, `${fullDataset.name}-analysis.csv`);
+        } else {
+            alert('Full comparison data not found for this dataset.');
+        }
+    }).catch(err => {
+        console.error('Failed to get dataset for download:', err);
+        alert('Could not load dataset to download analysis.');
+    });
+
+    setActiveDropdown(null);
+  };
+
+  const isComparisonToolDisabled = () => {
+    if (!selectedDatasetId) return true;
+    const selected = datasets.find(d => d.id === selectedDatasetId);
+    return !selected || selected.processingState !== 'processed';
+  }
+
+  const { sharedDatasets, localDatasets } = useMemo(() => {
+    const shared: DatasetMetadata[] = [];
+    const local: DatasetMetadata[] = [];
+    datasets.forEach(d => {
+        if (d.isShared) {
+            shared.push(d);
+        } else {
+            local.push(d);
+        }
+    });
+    local.sort((a, b) => new Date(b.uploadDate).getTime() - new Date(a.uploadDate).getTime());
+    return { sharedDatasets: shared, localDatasets: local };
+  }, [datasets]);
+
+  const renderDatasetList = (list: DatasetMetadata[], title: string) => (
+    <>
+      {list.length > 0 && <h3 className="px-4 pt-4 pb-2 text-lg font-semibold text-gray-300">{title}</h3>}
+      <ul className="divide-y divide-gray-700">
+        {list.map(dataset => (
+          <li
+            key={dataset.id}
+            onClick={() => onSelectDataset(dataset.id)}
+            className={`grid grid-cols-12 gap-4 p-4 items-center cursor-pointer transition-colors ${
+              selectedDatasetId === dataset.id ? 'bg-indigo-600/30' : 'hover:bg-gray-700/50'
+            }`}
+          >
+            <div className="col-span-3 font-medium flex items-center gap-3">
+                {dataset.isShared && <CloudIcon />}
+                <span className="truncate">{dataset.name}</span>
+            </div>
+            <div className="col-span-3">{dataset.itemCounts.images} Images, {dataset.itemCounts.texts} Texts, {dataset.itemCounts.meshes} Meshes</div>
+            <div className="col-span-2 text-sm text-gray-400">{new Date(dataset.uploadDate).toLocaleString()}</div>
+            <div className="col-span-3 text-sm">
+                <StatusDisplay dataset={dataset} />
+            </div>
+            <div className="col-span-1 flex justify-end relative">
+              <button onClick={(e) => { e.stopPropagation(); setActiveDropdown(activeDropdown === dataset.id ? null : dataset.id)}} className="p-2 rounded-full hover:bg-gray-600">
+                  <ThreeDotsIcon />
+              </button>
+              {activeDropdown === dataset.id && (
+                  <div className="absolute top-full right-0 mt-2 w-48 bg-gray-800 border border-gray-600 rounded-md shadow-lg z-10">
+                      <ul className="py-1">
+                          <li className="px-4 py-2 hover:bg-gray-700 cursor-pointer" onClick={(e) => { e.stopPropagation(); openViewer(dataset); }}>View</li>
+                          {dataset.processingState === 'processed' && (
+                              <li className="px-4 py-2 hover:bg-gray-700 cursor-pointer" onClick={(e) => { e.stopPropagation(); handleDownloadAnalysis(dataset); }}>Download Analysis (.csv)</li>
+                          )}
+                          {!dataset.isShared && (
+                            <>
+                              <li className="px-4 py-2 hover:bg-gray-700 cursor-pointer" onClick={(e) => { e.stopPropagation(); openRenameModal(dataset); }}>Rename</li>
+                              <li className="px-4 py-2 hover:bg-gray-700 text-red-400 cursor-pointer" onClick={(e) => { e.stopPropagation(); handleDelete(dataset.id); }}>Delete</li>
+                            </>
+                          )}
+                      </ul>
+                  </div>
+              )}
+            </div>
+          </li>
+        ))}
+      </ul>
+    </>
+  );
+
+  return (
+    <div className="space-y-6">
+      {errorBanner}
+      <div className="flex justify-between items-center">
+        <h2 className="text-3xl font-bold tracking-tight">Dataset Manager</h2>
+        <div className="flex items-center gap-4">
+            <input 
+              type="file" 
+              ref={fileInputRef} 
+              onChange={handleFileSelect} 
+              accept=".zip" 
+              className="hidden" 
+            />
+            <button
+                onClick={handleUploadClick}
+                disabled={!!processingStatus && !processingStatus.error}
+                className="bg-cyan-500 hover:bg-cyan-600 text-white font-bold py-2 px-4 rounded-lg transition-colors flex items-center justify-center w-48 disabled:bg-gray-600 disabled:cursor-not-allowed"
+            >
+                {processingStatus && !processingStatus.error ? <><Spinner /> In Progress...</> : 'Upload Dataset (.zip)'}
+            </button>
+            <button
+                onClick={onOpenComparisonTool}
+                disabled={isComparisonToolDisabled()}
+                className="bg-indigo-500 hover:bg-indigo-600 text-white font-bold py-2 px-4 rounded-lg transition-colors disabled:bg-gray-600 disabled:cursor-not-allowed"
+            >
+                Open Comparison Tool
+            </button>
+        </div>
+      </div>
+      
+      <div className="bg-gray-800/50 rounded-lg border border-gray-700 shadow-lg">
+        <div className="grid grid-cols-12 gap-4 p-4 font-semibold text-gray-400 border-b border-gray-700">
+          <div className="col-span-3">Name</div>
+          <div className="col-span-3">Items</div>
+          <div className="col-span-2">Upload Date</div>
+          <div className="col-span-3">Status</div>
+          <div className="col-span-1 text-right">Actions</div>
+        </div>
+        
+        {processingStatus && <ProcessingRow status={processingStatus} />}
+        
+        {renderDatasetList(sharedDatasets, "Cloud Datasets")}
+        {renderDatasetList(localDatasets, "Local Datasets")}
+
+        {datasets.length === 0 && !processingStatus && <div className="text-center p-8 text-gray-500">No datasets found. Upload a new one to get started.</div>}
+      </div>
+
+      {isViewerOpen && (
+        <DatasetViewer 
+            dataset={fullDatasetForViewer} 
+            isLoading={isViewerLoading}
+            onClose={() => setViewerOpen(false)} 
+        />
+      )}
+      
+      {isRenameModalOpen && datasetToEdit && (
+        <Modal title="Rename Dataset" onClose={() => setRenameModalOpen(false)}>
+            <div className="space-y-4">
+                <input
+                    type="text"
+                    value={newDatasetName}
+                    onChange={(e) => setNewDatasetName(e.target.value)}
+                    className="w-full bg-gray-700 border border-gray-600 rounded-md px-3 py-2 text-white focus:ring-2 focus:ring-cyan-500 focus:outline-none"
+                />
+                <div className="flex justify-end gap-2">
+                    <button onClick={() => setRenameModalOpen(false)} className="px-4 py-2 rounded-md bg-gray-600 hover:bg-gray-500 transition-colors">Cancel</button>
+                    <button onClick={handleRename} className="px-4 py-2 rounded-md bg-cyan-500 hover:bg-cyan-600 text-white transition-colors">Save</button>
+                </div>
+            </div>
+        </Modal>
+      )}
+    </div>
+  );
+};

frontend/components/DatasetViewer.tsx

@@ -0,0 +1,220 @@
+
+import React, { useState, useEffect, lazy, Suspense } from 'react';
+import type { Dataset, Modality, DataItem } from '../types';
+import { Modal } from './common/Modal';
+import { FullscreenViewer } from './common/FullscreenViewer';
+import { getItemContent } from '../services/sharedDatasetService';
+import { Spinner } from './common/Spinner';
+
+const MeshViewer = lazy(() => import('./common/MeshViewer').then(module => ({ default: module.MeshViewer })));
+
+interface DatasetViewerProps {
+  dataset: Dataset | null;
+  isLoading: boolean;
+  onClose: () => void;
+}
+
+const ITEMS_PER_PAGE = 16;
+
+const LazyItem: React.FC<{
+    item: DataItem;
+    modality: Modality;
+    onClick: () => void;
+}> = ({ item, modality, onClick }) => {
+    const [loadedItem, setLoadedItem] = useState<DataItem>(item);
+    const [isLoading, setIsLoading] = useState(!item.content && !!item.contentUrl);
+    const [error, setError] = useState(false);
+
+    useEffect(() => {
+        let isMounted = true;
+        // Images are loaded by the browser via `contentUrl`, so we only fetch for text/mesh.
+        if (!item.content && item.contentUrl && modality !== 'image') {
+            setIsLoading(true);
+            setError(false);
+            getItemContent(item.contentUrl)
+                .then(content => {
+                    if (isMounted) {
+                        setLoadedItem({ ...item, content });
+                    }
+                })
+                .catch(err => {
+                    console.error("Failed to load item content", err);
+                    if (isMounted) setError(true);
+                })
+                .finally(() => {
+                    if (isMounted) setIsLoading(false);
+                });
+        } else {
+            setLoadedItem(item);
+            setIsLoading(false);
+        }
+        return () => { isMounted = false; };
+    }, [item, modality]);
+
+    const renderContent = () => {
+        if (isLoading) {
+            return <div className="flex items-center justify-center h-full"><Spinner /></div>;
+        }
+        if (error) {
+            return <div className="flex items-center justify-center h-full text-xs text-red-400 p-2 text-center">Load Failed</div>;
+        }
+
+        const content = loadedItem.content;
+        const name = loadedItem.name;
+        const imageUrl = modality === 'image' ? (loadedItem.contentUrl || content as string) : null;
+
+        switch (modality) {
+            case 'image':
+                return (
+                    <div className="group relative pt-[75%]">
+                        <div className="absolute inset-0">
+                            <img src={imageUrl || undefined} alt={name} className="object-cover w-full h-full rounded-lg shadow-md" />
+                            <div className="absolute bottom-0 left-0 w-full bg-black/50 text-white text-xs p-1 rounded-b-lg truncate">{name}</div>
+                        </div>
+                    </div>
+                );
+            case 'text':
+                return (
+                    <div className="bg-gray-700 p-3 rounded-lg h-full flex flex-col min-h-[120px]">
+                        <h4 className="font-bold text-sm text-cyan-300 mb-1 truncate">{name}</h4>
+                        <p className="text-xs text-gray-300 flex-grow break-words">{(content as string)?.substring(0, 100)}...</p>
+                    </div>
+                );
+            case 'mesh':
+                return (
+                    <div className="relative pt-[75%]">
+                        <div className="absolute inset-0 bg-gray-700 rounded-lg overflow-hidden">
+                           <Suspense fallback={<div className="w-full h-full flex items-center justify-center"><Spinner /></div>}>
+                               <MeshViewer stlContent={content || loadedItem.contentUrl} interactive={false} />
+                           </Suspense>
+                        </div>
+                        <div className="absolute bottom-0 left-0 w-full bg-black/50 text-white text-xs p-1 rounded-b-lg truncate pointer-events-none">{name}</div>
+                    </div>
+                );
+        }
+    };
+    
+    return (
+        <div onClick={onClick} className="cursor-pointer h-full">
+            {renderContent()}
+        </div>
+    );
+};
+
+
+const ModalityViewer: React.FC<{ items: DataItem[], modality: Modality, onViewItem: (item: DataItem, modality: Modality) => void }> = ({ items, modality, onViewItem }) => {
+    const [visibleCount, setVisibleCount] = useState(ITEMS_PER_PAGE);
+    
+    const visibleItems = items.slice(0, visibleCount);
+    
+    return (
+        <div>
+            <div className="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-4">
+                {visibleItems.map(item => (
+                    <LazyItem 
+                        key={item.id} 
+                        item={item} 
+                        modality={modality} 
+                        onClick={() => onViewItem(item, modality)} 
+                    />
+                ))}
+            </div>
+            {visibleCount < items.length && (
+                <div className="text-center mt-6">
+                    <button 
+                        onClick={() => setVisibleCount(c => c + ITEMS_PER_PAGE)}
+                        className="bg-gray-600 hover:bg-gray-500 text-white font-semibold py-2 px-6 rounded-lg transition-colors"
+                    >
+                        Load More
+                    </button>
+                </div>
+            )}
+        </div>
+    );
+};
+
+export const DatasetViewer: React.FC<DatasetViewerProps> = ({ dataset, isLoading, onClose }) => {
+  const [activeTab, setActiveTab] = useState<Modality>('image');
+  const [viewingItem, setViewingItem] = useState<{item: DataItem, modality: Modality} | null>(null);
+
+  const handleViewItem = async (item: DataItem, modality: Modality) => {
+    let itemWithContent = item;
+    // If content is not loaded (e.g., text/mesh from a shared dataset), load it now for the fullscreen viewer
+    if (!item.content && item.contentUrl) {
+        try {
+            const content = await getItemContent(item.contentUrl);
+            itemWithContent = { ...item, content };
+        } catch (e) {
+            console.error("Failed to load content for viewer:", e);
+            alert("Could not load item content.");
+            return;
+        }
+    }
+    setViewingItem({item: itemWithContent, modality});
+  };
+
+  const handleCloseViewer = () => {
+    setViewingItem(null);
+  };
+  
+  const renderBody = () => {
+      if (isLoading || !dataset) {
+          return (
+            <div className="flex justify-center items-center h-96">
+                <Spinner />
+                <span className="ml-2">Loading dataset...</span>
+            </div>
+          );
+      }
+      
+      const tabs: { name: string, modality: Modality }[] = [
+        { name: 'Images', modality: 'image' },
+        { name: 'Texts', modality: 'text' },
+        { name: '3D Models', modality: 'mesh' },
+      ];
+      
+      const getItems = (mod: Modality) => {
+          const key = mod === 'mesh' ? 'meshes' : `${mod}s`;
+          return dataset.data[key as keyof typeof dataset.data] || [];
+      };
+
+      return (
+        <>
+            <div className="border-b border-gray-600">
+              <nav className="-mb-px flex space-x-8" aria-label="Tabs">
+                {tabs.map(tab => {
+                  const items = getItems(tab.modality);
+                  return (
+                    <button
+                      key={tab.name}
+                      onClick={() => setActiveTab(tab.modality)}
+                      className={`${
+                        activeTab === tab.modality
+                          ? 'border-cyan-400 text-cyan-400'
+                          : 'border-transparent text-gray-400 hover:text-gray-200 hover:border-gray-400'
+                      } whitespace-nowrap py-4 px-1 border-b-2 font-medium text-sm transition-colors`}
+                    >
+                      {tab.name} ({items.length})
+                    </button>
+                  );
+                })}
+              </nav>
+            </div>
+            <div className="py-6">
+              <ModalityViewer items={getItems(activeTab)} modality={activeTab} onViewItem={handleViewItem} />
+            </div>
+        </>
+      );
+  }
+
+  return (
+    <>
+      <Modal title={`Viewing Dataset: ${dataset?.name || 'Loading...'}`} onClose={onClose} size="5xl">
+        {renderBody()}
+      </Modal>
+      {viewingItem && (
+        <FullscreenViewer item={viewingItem.item} modality={viewingItem.modality} onClose={handleCloseViewer} />
+      )}
+    </>
+  );
+};

frontend/components/common/FullscreenViewer.tsx

@@ -0,0 +1,81 @@
+
+import React, { lazy, Suspense } from 'react';
+import type { DataItem, Modality } from '../../types';
+import { Spinner } from './Spinner';
+
+const MeshViewer = lazy(() => import('./MeshViewer').then(module => ({ default: module.MeshViewer })));
+
+interface FullscreenViewerProps {
+  item: DataItem;
+  modality: Modality;
+  onClose: () => void;
+}
+
+export const FullscreenViewer: React.FC<FullscreenViewerProps> = ({ item, modality, onClose }) => {
+  const renderContent = () => {
+    switch (modality) {
+      case 'image':
+        if (typeof item.content !== 'string') return null;
+        return <img src={item.content} alt={item.name} className="max-w-full max-h-full object-contain" />;
+      case 'text':
+        if (typeof item.content !== 'string') return null;
+        return (
+          <div className="bg-gray-900 p-6 rounded-lg text-left h-full w-full overflow-y-auto">
+            <pre className="text-sm whitespace-pre-wrap break-words text-gray-200">
+              {item.content}
+            </pre>
+          </div>
+        );
+      case 'mesh':
+        return (
+            <div className="h-full w-full bg-gray-900 rounded-lg">
+                <Suspense fallback={<div className="w-full h-full flex items-center justify-center"><Spinner /></div>}>
+                    <MeshViewer stlContent={item.content} interactive={true} />
+                </Suspense>
+            </div>
+        );
+      default:
+        return null;
+    }
+  };
+
+  return (
+    <div
+      className="fixed inset-0 bg-black bg-opacity-80 flex justify-center items-center z-50 p-4 animate-fade-in"
+      onClick={onClose}
+    >
+      <div
+        className="relative w-full h-full max-w-6xl max-h-[90vh] flex items-center justify-center"
+        onClick={(e) => e.stopPropagation()}
+      >
+        <div className="absolute top-0 right-0 m-4 z-10">
+            <button onClick={onClose} className="text-white bg-black/50 rounded-full p-2 hover:bg-black/80 transition-colors">
+                <svg xmlns="http://www.w3.org/2000/svg" className="h-8 w-8" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
+                </svg>
+            </button>
+        </div>
+        
+        <div className="w-full h-full flex flex-col items-center justify-center">
+             {renderContent()}
+        </div>
+       
+        <div className="absolute bottom-0 left-0 right-0 p-4 text-center bg-black/50 text-white rounded-b-lg pointer-events-none">
+            <p className="font-bold">{item.name}</p>
+        </div>
+      </div>
+    </div>
+  );
+};
+
+// Add fade-in animation to tailwind config or a style tag if not using a config
+const style = document.createElement('style');
+style.innerHTML = `
+@keyframes fade-in {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+.animate-fade-in {
+    animation: fade-in 0.2s ease-out;
+}`;
+document.head.appendChild(style);

frontend/components/common/MeshViewer.tsx

@@ -0,0 +1,207 @@
+import React, { useRef, useEffect, useState } from 'react';
+import * as THREE from 'three';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';
+import { STLLoader } from 'three/examples/jsm/loaders/STLLoader';
+import { Spinner } from './Spinner';
+import { getItemContent } from '../../services/sharedDatasetService';
+
+interface MeshViewerProps {
+  stlContent: string | ArrayBuffer | null;
+  interactive?: boolean;
+}
+
+export const MeshViewer: React.FC<MeshViewerProps> = ({ stlContent, interactive = true }) => {
+  const mountRef = useRef<HTMLDivElement>(null);
+  const [isVisible, setIsVisible] = useState(false);
+  const [isLoading, setIsLoading] = useState(true);
+  const [loadedContent, setLoadedContent] = useState<ArrayBuffer | null>(null);
+
+  useEffect(() => {
+    const node = mountRef.current;
+    if (!node) return;
+
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        if (entry.isIntersecting) {
+            setIsVisible(true);
+            observer.disconnect(); // Load only once
+        }
+      },
+      {
+        rootMargin: '400px', // Load when it's 400px away from the viewport
+      }
+    );
+
+    observer.observe(node);
+
+    return () => {
+      observer.disconnect();
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!isVisible || !stlContent) return;
+    
+    let isCancelled = false;
+    
+    const fetchAndSetContent = async () => {
+        setIsLoading(true);
+        try {
+            let content: ArrayBuffer | null = null;
+            if (typeof stlContent === 'string') {
+                // It's a URL, fetch it.
+                content = await getItemContent(stlContent) as ArrayBuffer;
+            } else if (stlContent instanceof ArrayBuffer) {
+                // It's already an ArrayBuffer.
+                content = stlContent;
+            }
+            if (!isCancelled) {
+              setLoadedContent(content);
+            }
+        } catch (error) {
+            console.error("Failed to fetch mesh content:", error);
+            if (!isCancelled) setIsLoading(false); // Stop loading on error
+        }
+    };
+    
+    fetchAndSetContent();
+
+    return () => {
+      isCancelled = true;
+    }
+  }, [stlContent, isVisible]);
+
+  useEffect(() => {
+    const mountNode = mountRef.current;
+    if (!mountNode || !loadedContent) {
+        setIsLoading(!!stlContent);
+        return;
+    }
+    
+    setIsLoading(true);
+
+    let animationFrameId: number;
+    let renderer: THREE.WebGLRenderer;
+    let controls: OrbitControls | null = null;
+    let scene: THREE.Scene;
+    let handleResize: () => void;
+
+    const init = () => {
+        scene = new THREE.Scene();
+        scene.background = new THREE.Color(0x27272a); 
+
+        const camera = new THREE.PerspectiveCamera(35, mountNode.clientWidth / mountNode.clientHeight, 0.1, 1000);
+        camera.position.set(2.5, 2.5, 2.5);
+
+        renderer = new THREE.WebGLRenderer({ antialias: true, powerPreference: 'low-power' });
+        renderer.setSize(mountNode.clientWidth, mountNode.clientHeight);
+        renderer.setPixelRatio(window.devicePixelRatio);
+        mountNode.appendChild(renderer.domElement);
+        
+        scene.add(new THREE.AmbientLight(0xffffff, Math.PI / 1.5));
+        const directionalLight = new THREE.DirectionalLight(0xffffff, 2);
+        directionalLight.position.set(5, 5, 5);
+        scene.add(directionalLight);
+
+        if (interactive) {
+            controls = new OrbitControls(camera, renderer.domElement);
+            controls.enableDamping = true;
+        }
+
+        const loader = new STLLoader();
+        const geometry = loader.parse(loadedContent);
+        const material = new THREE.MeshStandardMaterial({ color: '#00ffff', flatShading: false, metalness: 0.2, roughness: 0.5 });
+        const mesh = new THREE.Mesh(geometry, material);
+        
+        const box = new THREE.Box3().setFromObject(mesh);
+        const center = box.getCenter(new THREE.Vector3());
+        mesh.position.sub(center); 
+        scene.add(mesh);
+
+        const size = box.getSize(new THREE.Vector3());
+        const maxDim = Math.max(size.x, size.y, size.z);
+        const fov = camera.fov * (Math.PI / 180);
+        let cameraZ = Math.abs(maxDim / 2 / Math.tan(fov / 2));
+        cameraZ *= 1.5; 
+        camera.position.z = camera.position.y = camera.position.x = cameraZ;
+        const minZ = box.min.z;
+        const cameraToFarEdge = ( minZ < 0 ) ? -minZ + cameraZ : cameraZ - minZ;
+        camera.far = cameraToFarEdge * 3;
+        camera.updateProjectionMatrix();
+
+        if (controls) {
+            controls.target.copy(mesh.position);
+            controls.update();
+        } else {
+            camera.lookAt(mesh.position);
+        }
+
+        handleResize = () => {
+            if (!mountNode || !renderer) return;
+            camera.aspect = mountNode.clientWidth / mountNode.clientHeight;
+            camera.updateProjectionMatrix();
+            renderer.setSize(mountNode.clientWidth, mountNode.clientHeight);
+        };
+        window.addEventListener('resize', handleResize);
+        
+        setIsLoading(false);
+
+        const animate = () => {
+            animationFrameId = requestAnimationFrame(animate);
+            if (controls) controls.update();
+            if (!interactive) {
+                mesh.rotation.y += 0.005;
+            }
+            if(renderer) renderer.render(scene, camera);
+        };
+        animate();
+    };
+
+    const timeoutId = setTimeout(init, 10); // Short delay to allow DOM to update
+
+    return () => {
+      clearTimeout(timeoutId);
+      cancelAnimationFrame(animationFrameId);
+      if (handleResize) {
+        window.removeEventListener('resize', handleResize);
+      }
+      
+      if(scene){
+          scene.traverse(object => {
+              if (object instanceof THREE.Mesh) {
+                  if(object.geometry) object.geometry.dispose();
+                  if(object.material) {
+                    if (Array.isArray(object.material)) {
+                        object.material.forEach(material => material.dispose());
+                    } else {
+                        object.material.dispose();
+                    }
+                  }
+              }
+          });
+      }
+      
+      controls?.dispose();
+      
+      if(renderer){
+          renderer.dispose();
+          if (mountNode && renderer.domElement.parentNode === mountNode) {
+            mountNode.removeChild(renderer.domElement);
+          }
+      }
+    };
+  }, [loadedContent, interactive]);
+
+  return (
+    <div className="w-full h-full relative bg-gray-700">
+       {isLoading && (
+        <div className="absolute inset-0 flex items-center justify-center z-10">
+          <div className="w-8 h-8">
+            <Spinner />
+          </div>
+        </div>
+      )}
+      <div ref={mountRef} className={`w-full h-full transition-opacity duration-300 ${isLoading ? 'opacity-0' : 'opacity-100'}`} />
+    </div>
+  );
+};

frontend/components/common/Modal.tsx

@@ -0,0 +1,47 @@
+
+import React from 'react';
+
+interface ModalProps {
+  title: string;
+  onClose: () => void;
+  children: React.ReactNode;
+  size?: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl';
+}
+
+const sizeClasses = {
+    sm: 'max-w-sm',
+    md: 'max-w-md',
+    lg: 'max-w-lg',
+    xl: 'max-w-xl',
+    '2xl': 'max-w-2xl',
+    '3xl': 'max-w-3xl',
+    '4xl': 'max-w-4xl',
+    '5xl': 'max-w-5xl',
+};
+
+
+export const Modal: React.FC<ModalProps> = ({ title, onClose, children, size = 'md' }) => {
+  return (
+    <div
+      className="fixed inset-0 bg-black bg-opacity-75 flex justify-center items-center z-50 p-4"
+      onClick={onClose}
+    >
+      <div
+        className={`bg-gray-800 rounded-xl shadow-2xl w-full ${sizeClasses[size]} flex flex-col max-h-[90vh]`}
+        onClick={(e) => e.stopPropagation()}
+      >
+        <div className="flex justify-between items-center p-4 border-b border-gray-700">
+          <h2 className="text-xl font-bold text-white">{title}</h2>
+          <button onClick={onClose} className="text-gray-400 hover:text-white">
+            <svg xmlns="http://www.w3.org/2000/svg" className="h-6 w-6" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
+            </svg>
+          </button>
+        </div>
+        <div className="p-6 overflow-y-auto">
+          {children}
+        </div>
+      </div>
+    </div>
+  );
+};

frontend/components/common/ProgressBar.tsx

@@ -0,0 +1,23 @@
+import React from 'react';
+
+interface ProgressBarProps {
+  progress: number;
+  label?: string;
+}
+
+export const ProgressBar: React.FC<ProgressBarProps> = ({ progress, label }) => {
+  const safeProgress = Math.max(0, Math.min(100, progress));
+
+  return (
+    <div className="flex items-center gap-3">
+      {label && <span className="text-xs text-gray-300 min-w-[8ch] text-right">{label}</span>}
+      <div className="w-full bg-gray-600 rounded-full h-2.5">
+        <div
+          className="bg-cyan-500 h-2.5 rounded-full transition-all duration-300 ease-out"
+          style={{ width: `${safeProgress}%` }}
+        ></div>
+      </div>
+      <span className="text-xs text-gray-300 min-w-[4ch] text-right">{Math.round(safeProgress)}%</span>
+    </div>
+  );
+};

frontend/components/common/Spinner.tsx

@@ -0,0 +1,9 @@
+
+import React from 'react';
+
+export const Spinner: React.FC = () => (
+  <svg className="animate-spin -ml-1 mr-3 h-5 w-5 text-white" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+    <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4"></circle>
+    <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+  </svg>
+);

frontend/index.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Cross-Modal Object Comparison</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+  <script type="importmap">
+{
+  "imports": {
+    "react/": "https://aistudiocdn.com/react@^19.2.0/",
+    "react": "https://aistudiocdn.com/react@^19.2.0",
+    "react-dom/": "https://aistudiocdn.com/react-dom@^19.2.0/",
+    "three": "https://esm.sh/[email protected]",
+    "three/": "https://esm.sh/[email protected]/",
+    "jszip": "https://esm.sh/[email protected]"
+  }
+}
+</script>
+</head>
+  <body class="bg-gray-900 text-white">
+    <div id="root"></div>
+    <script type="module" src="/index.tsx"></script>
+  </body>
+</html>

frontend/index.tsx

@@ -0,0 +1,16 @@
+
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './App';
+
+const rootElement = document.getElementById('root');
+if (!rootElement) {
+  throw new Error("Could not find root element to mount to");
+}
+
+const root = ReactDOM.createRoot(rootElement);
+root.render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);

frontend/metadata.json

@@ -0,0 +1,5 @@
+{
+  "name": "Cross-Modal Object Comparison Tool",
+  "description": "An application to manage datasets of 3D models, images, and text descriptions, and compare objects across these modalities. It features a dataset manager, a content viewer, and tools for both single-item and full-dataset comparison, with placeholder logic for future AI model integration.",
+  "requestFramePermissions": []
+}

frontend/package-lock.json

@@ -0,0 +1,1874 @@
+{
+  "name": "cross-modal-object-comparison-tool",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "cross-modal-object-comparison-tool",
+      "version": "0.0.0",
+      "dependencies": {
+        "jszip": "3.10.1",
+        "react": "^19.2.0",
+        "react-dom": "^19.2.0",
+        "three": "0.166.1"
+      },
+      "devDependencies": {
+        "@types/node": "^22.14.0",
+        "@vitejs/plugin-react": "^5.0.0",
+        "typescript": "~5.8.2",
+        "vite": "^6.2.0"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.27.1",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.5.tgz",
+      "integrity": "sha512-6uFXyCayocRbqhZOB+6XcuZbkMNimwfVGFji8CTZnCzOHVGvDqzvitu1re2AU5LROliz7eQPhB8CpAMvnx9EjA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
+      "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.27.1",
+        "@babel/generator": "^7.28.5",
+        "@babel/helper-compilation-targets": "^7.27.2",
+        "@babel/helper-module-transforms": "^7.28.3",
+        "@babel/helpers": "^7.28.4",
+        "@babel/parser": "^7.28.5",
+        "@babel/template": "^7.27.2",
+        "@babel/traverse": "^7.28.5",
+        "@babel/types": "^7.28.5",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.5.tgz",
+      "integrity": "sha512-3EwLFhZ38J4VyIP6WNtt2kUdW9dokXA9Cr4IVIFHuCpZ3H8/YFOl5JjZHisrn1fATPBmKKqXzDFvh9fUwHz6CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.28.5",
+        "@babel/types": "^7.28.5",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.27.2",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz",
+      "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.27.2",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz",
+      "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.27.1",
+        "@babel/types": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.28.3",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz",
+      "integrity": "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.27.1",
+        "@babel/traverse": "^7.28.3"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz",
+      "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.28.4",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.4.tgz",
+      "integrity": "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.27.2",
+        "@babel/types": "^7.28.4"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz",
+      "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.5"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.27.2",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz",
+      "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.27.1",
+        "@babel/parser": "^7.27.2",
+        "@babel/types": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.5.tgz",
+      "integrity": "sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.27.1",
+        "@babel/generator": "^7.28.5",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.28.5",
+        "@babel/template": "^7.27.2",
+        "@babel/types": "^7.28.5",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz",
+      "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
+      "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",
+      "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",
+      "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",
+      "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",
+      "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",
+      "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",
+      "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",
+      "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",
+      "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",
+      "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",
+      "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",
+      "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",
+      "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",
+      "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",
+      "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",
+      "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",
+      "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",
+      "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",
+      "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",
+      "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",
+      "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.43",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.43.tgz",
+      "integrity": "sha512-5Uxg7fQUCmfhax7FJke2+8B6cqgeUJUD9o2uXIKXhD+mG0mL6NObmVoi9wXEU1tY89mZKgAYA6fTbftx3q2ZPQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.52.5.tgz",
+      "integrity": "sha512-8c1vW4ocv3UOMp9K+gToY5zL2XiiVw3k7f1ksf4yO1FlDFQ1C2u72iACFnSOceJFsWskc2WZNqeRhFRPzv+wtQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.52.5.tgz",
+      "integrity": "sha512-mQGfsIEFcu21mvqkEKKu2dYmtuSZOBMmAl5CFlPGLY94Vlcm+zWApK7F/eocsNzp8tKmbeBP8yXyAbx0XHsFNA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.52.5.tgz",
+      "integrity": "sha512-takF3CR71mCAGA+v794QUZ0b6ZSrgJkArC+gUiG6LB6TQty9T0Mqh3m2ImRBOxS2IeYBo4lKWIieSvnEk2OQWA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.52.5.tgz",
+      "integrity": "sha512-W901Pla8Ya95WpxDn//VF9K9u2JbocwV/v75TE0YIHNTbhqUTv9w4VuQ9MaWlNOkkEfFwkdNhXgcLqPSmHy0fA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.52.5.tgz",
+      "integrity": "sha512-QofO7i7JycsYOWxe0GFqhLmF6l1TqBswJMvICnRUjqCx8b47MTo46W8AoeQwiokAx3zVryVnxtBMcGcnX12LvA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.52.5.tgz",
+      "integrity": "sha512-jr21b/99ew8ujZubPo9skbrItHEIE50WdV86cdSoRkKtmWa+DDr6fu2c/xyRT0F/WazZpam6kk7IHBerSL7LDQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.52.5.tgz",
+      "integrity": "sha512-PsNAbcyv9CcecAUagQefwX8fQn9LQ4nZkpDboBOttmyffnInRy8R8dSg6hxxl2Re5QhHBf6FYIDhIj5v982ATQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.52.5.tgz",
+      "integrity": "sha512-Fw4tysRutyQc/wwkmcyoqFtJhh0u31K+Q6jYjeicsGJJ7bbEq8LwPWV/w0cnzOqR2m694/Af6hpFayLJZkG2VQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.52.5.tgz",
+      "integrity": "sha512-a+3wVnAYdQClOTlyapKmyI6BLPAFYs0JM8HRpgYZQO02rMR09ZcV9LbQB+NL6sljzG38869YqThrRnfPMCDtZg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.52.5.tgz",
+      "integrity": "sha512-AvttBOMwO9Pcuuf7m9PkC1PUIKsfaAJ4AYhy944qeTJgQOqJYJ9oVl2nYgY7Rk0mkbsuOpCAYSs6wLYB2Xiw0Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.52.5.tgz",
+      "integrity": "sha512-DkDk8pmXQV2wVrF6oq5tONK6UHLz/XcEVow4JTTerdeV1uqPeHxwcg7aFsfnSm9L+OO8WJsWotKM2JJPMWrQtA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.52.5.tgz",
+      "integrity": "sha512-W/b9ZN/U9+hPQVvlGwjzi+Wy4xdoH2I8EjaCkMvzpI7wJUs8sWJ03Rq96jRnHkSrcHTpQe8h5Tg3ZzUPGauvAw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.52.5.tgz",
+      "integrity": "sha512-sjQLr9BW7R/ZiXnQiWPkErNfLMkkWIoCz7YMn27HldKsADEKa5WYdobaa1hmN6slu9oWQbB6/jFpJ+P2IkVrmw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.52.5.tgz",
+      "integrity": "sha512-hq3jU/kGyjXWTvAh2awn8oHroCbrPm8JqM7RUpKjalIRWWXE01CQOf/tUNWNHjmbMHg/hmNCwc/Pz3k1T/j/Lg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.52.5.tgz",
+      "integrity": "sha512-gn8kHOrku8D4NGHMK1Y7NA7INQTRdVOntt1OCYypZPRt6skGbddska44K8iocdpxHTMMNui5oH4elPH4QOLrFQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.52.5.tgz",
+      "integrity": "sha512-hXGLYpdhiNElzN770+H2nlx+jRog8TyynpTVzdlc6bndktjKWyZyiCsuDAlpd+j+W+WNqfcyAWz9HxxIGfZm1Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.52.5.tgz",
+      "integrity": "sha512-arCGIcuNKjBoKAXD+y7XomR9gY6Mw7HnFBv5Rw7wQRvwYLR7gBAgV7Mb2QTyjXfTveBNFAtPt46/36vV9STLNg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.52.5.tgz",
+      "integrity": "sha512-QoFqB6+/9Rly/RiPjaomPLmR/13cgkIGfA40LHly9zcH1S0bN2HVFYk3a1eAyHQyjs3ZJYlXvIGtcCs5tko9Cw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.52.5.tgz",
+      "integrity": "sha512-w0cDWVR6MlTstla1cIfOGyl8+qb93FlAVutcor14Gf5Md5ap5ySfQ7R9S/NjNaMLSFdUnKGEasmVnu3lCMqB7w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.52.5.tgz",
+      "integrity": "sha512-Aufdpzp7DpOTULJCuvzqcItSGDH73pF3ko/f+ckJhxQyHtp67rHw3HMNxoIdDMUITJESNE6a8uh4Lo4SLouOUg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.52.5.tgz",
+      "integrity": "sha512-UGBUGPFp1vkj6p8wCRraqNhqwX/4kNQPS57BCFc8wYh0g94iVIW33wJtQAx3G7vrjjNtRaxiMUylM0ktp/TRSQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.52.5.tgz",
+      "integrity": "sha512-TAcgQh2sSkykPRWLrdyy2AiceMckNf5loITqXxFI5VuQjS5tSuw3WlwdN8qv8vzjLAUTvYaH/mVjSFpbkFbpTg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "22.19.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.0.tgz",
+      "integrity": "sha512-xpr/lmLPQEj+TUnHmR+Ab91/glhJvsqcjB+yY0Ix9GO70H6Lb4FHH5GeqdOE5btAx7eIMwuHkp4H2MSkLcqWbA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-5.1.0.tgz",
+      "integrity": "sha512-4LuWrg7EKWgQaMJfnN+wcmbAW+VSsCmqGohftWjuct47bv8uE4n/nPpq4XjJPsxgq00GGG5J8dvBczp8uxScew==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.28.4",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.43",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.18.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.8.23",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.8.23.tgz",
+      "integrity": "sha512-616V5YX4bepJFzNyOfce5Fa8fDJMfoxzOIzDCZwaGL8MKVpFrXqfNUoIpRn9YMI5pXf/VKgzjB4htFMsFKKdiQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.js"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.27.0",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.27.0.tgz",
+      "integrity": "sha512-AXVQwdhot1eqLihwasPElhX2tAZiBjWdJ9i/Zcj2S6QYIjkx62OKSfnobkriB81C3l4w0rVy3Nt4jaTBltYEpw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "baseline-browser-mapping": "^2.8.19",
+        "caniuse-lite": "^1.0.30001751",
+        "electron-to-chromium": "^1.5.238",
+        "node-releases": "^2.0.26",
+        "update-browserslist-db": "^1.1.4"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001753",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001753.tgz",
+      "integrity": "sha512-Bj5H35MD/ebaOV4iDLqPEtiliTN29qkGtEHCwawWn4cYm+bPJM2NsaP30vtZcnERClMzp52J4+aw2UNbK4o+zw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/core-util-is": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
+      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.244",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.244.tgz",
+      "integrity": "sha512-OszpBN7xZX4vWMPJwB9illkN/znA8M36GQqQxi6MNy9axWxhOfJyZZJtSLQCpEFLHP2xK33BiWx9aIuIEXVCcw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",
+      "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.12",
+        "@esbuild/android-arm": "0.25.12",
+        "@esbuild/android-arm64": "0.25.12",
+        "@esbuild/android-x64": "0.25.12",
+        "@esbuild/darwin-arm64": "0.25.12",
+        "@esbuild/darwin-x64": "0.25.12",
+        "@esbuild/freebsd-arm64": "0.25.12",
+        "@esbuild/freebsd-x64": "0.25.12",
+        "@esbuild/linux-arm": "0.25.12",
+        "@esbuild/linux-arm64": "0.25.12",
+        "@esbuild/linux-ia32": "0.25.12",
+        "@esbuild/linux-loong64": "0.25.12",
+        "@esbuild/linux-mips64el": "0.25.12",
+        "@esbuild/linux-ppc64": "0.25.12",
+        "@esbuild/linux-riscv64": "0.25.12",
+        "@esbuild/linux-s390x": "0.25.12",
+        "@esbuild/linux-x64": "0.25.12",
+        "@esbuild/netbsd-arm64": "0.25.12",
+        "@esbuild/netbsd-x64": "0.25.12",
+        "@esbuild/openbsd-arm64": "0.25.12",
+        "@esbuild/openbsd-x64": "0.25.12",
+        "@esbuild/openharmony-arm64": "0.25.12",
+        "@esbuild/sunos-x64": "0.25.12",
+        "@esbuild/win32-arm64": "0.25.12",
+        "@esbuild/win32-ia32": "0.25.12",
+        "@esbuild/win32-x64": "0.25.12"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/immediate": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.0.6.tgz",
+      "integrity": "sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==",
+      "license": "MIT"
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
+      "license": "MIT"
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/jszip": {
+      "version": "3.10.1",
+      "resolved": "https://registry.npmjs.org/jszip/-/jszip-3.10.1.tgz",
+      "integrity": "sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==",
+      "license": "(MIT OR GPL-3.0-or-later)",
+      "dependencies": {
+        "lie": "~3.3.0",
+        "pako": "~1.0.2",
+        "readable-stream": "~2.3.6",
+        "setimmediate": "^1.0.5"
+      }
+    },
+    "node_modules/lie": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/lie/-/lie-3.3.0.tgz",
+      "integrity": "sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==",
+      "license": "MIT",
+      "dependencies": {
+        "immediate": "~3.0.5"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.27",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
+      "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pako": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+      "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
+      "license": "(MIT AND Zlib)"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.6",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "license": "MIT"
+    },
+    "node_modules/react": {
+      "version": "19.2.0",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.0.tgz",
+      "integrity": "sha512-tmbWg6W31tQLeB5cdIBOicJDJRR2KzXsV7uSK9iNfLWQ5bIZfxuPEHp7M8wiHyHnn0DD1i7w3Zmin0FtkrwoCQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "19.2.0",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.0.tgz",
+      "integrity": "sha512-UlbRu4cAiGaIewkPyiRGJk0imDN2T3JjieT6spoL2UeSf5od4n5LB/mQ4ejmxhCFT1tYe8IvaFulzynWovsEFQ==",
+      "license": "MIT",
+      "dependencies": {
+        "scheduler": "^0.27.0"
+      },
+      "peerDependencies": {
+        "react": "^19.2.0"
+      }
+    },
+    "node_modules/react-refresh": {
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.18.0.tgz",
+      "integrity": "sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.52.5",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.52.5.tgz",
+      "integrity": "sha512-3GuObel8h7Kqdjt0gxkEzaifHTqLVW56Y/bjN7PSQtkKr0w3V/QYSdt6QWYtd7A1xUtYQigtdUfgj1RvWVtorw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.52.5",
+        "@rollup/rollup-android-arm64": "4.52.5",
+        "@rollup/rollup-darwin-arm64": "4.52.5",
+        "@rollup/rollup-darwin-x64": "4.52.5",
+        "@rollup/rollup-freebsd-arm64": "4.52.5",
+        "@rollup/rollup-freebsd-x64": "4.52.5",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.52.5",
+        "@rollup/rollup-linux-arm-musleabihf": "4.52.5",
+        "@rollup/rollup-linux-arm64-gnu": "4.52.5",
+        "@rollup/rollup-linux-arm64-musl": "4.52.5",
+        "@rollup/rollup-linux-loong64-gnu": "4.52.5",
+        "@rollup/rollup-linux-ppc64-gnu": "4.52.5",
+        "@rollup/rollup-linux-riscv64-gnu": "4.52.5",
+        "@rollup/rollup-linux-riscv64-musl": "4.52.5",
+        "@rollup/rollup-linux-s390x-gnu": "4.52.5",
+        "@rollup/rollup-linux-x64-gnu": "4.52.5",
+        "@rollup/rollup-linux-x64-musl": "4.52.5",
+        "@rollup/rollup-openharmony-arm64": "4.52.5",
+        "@rollup/rollup-win32-arm64-msvc": "4.52.5",
+        "@rollup/rollup-win32-ia32-msvc": "4.52.5",
+        "@rollup/rollup-win32-x64-gnu": "4.52.5",
+        "@rollup/rollup-win32-x64-msvc": "4.52.5",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/scheduler": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/setimmediate": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz",
+      "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==",
+      "license": "MIT"
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "node_modules/three": {
+      "version": "0.166.1",
+      "resolved": "https://registry.npmjs.org/three/-/three-0.166.1.tgz",
+      "integrity": "sha512-LtuafkKHHzm61AQA1be2MAYIw1IjmhOUxhBa0prrLpEMWbV7ijvxCRHjSgHPGp2493wLBzwKV46tA9nivLEgKg==",
+      "license": "MIT"
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.8.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
+      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.4.tgz",
+      "integrity": "sha512-q0SPT4xyU84saUX+tomz1WLkxUbuaJnR1xWt17M7fJtEJigJeWUNGUqrauFXsHnqev9y9JTRGwk13tFBuKby4A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "license": "MIT"
+    },
+    "node_modules/vite": {
+      "version": "6.4.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz",
+      "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.3",
+        "rollup": "^4.34.9",
+        "tinyglobby": "^0.2.13"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    }
+  }
+}

frontend/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "cross-modal-object-comparison-tool",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "three": "0.166.1",
+    "jszip": "3.10.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.0",
+    "@vitejs/plugin-react": "^5.0.0",
+    "typescript": "~5.8.2",
+    "vite": "^6.2.0"
+  }
+}

frontend/services/apiService.ts

@@ -0,0 +1,265 @@
+import type { Dataset, DataItem, Modality, SingleComparisonResult, DatasetMetadata } from '../types';
+
+// Define the base URL for your backend API
+// For local development, it might be 'http://localhost:8000'
+// When deployed on Hugging Face Spaces, it will be a relative path '/'.
+const API_BASE_URL = '/'; 
+
+/**
+ * A helper function to handle API errors.
+ */
+const handleApiError = async (response: Response) => {
+  if (!response.ok) {
+    let errorMessage = `HTTP error! status: ${response.status}`;
+    try {
+      const errorData = await response.json();
+      errorMessage = errorData.detail || JSON.stringify(errorData);
+    } catch (e) {
+      // The response was not JSON
+      errorMessage = await response.text();
+    }
+    throw new Error(errorMessage);
+  }
+  return response.json();
+};
+
+// Helper to correctly encode unicode strings to base64, which is required by the backend.
+const unicodeToBase64 = (str: string) => {
+    return btoa(
+        encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (match, p1) => {
+            return String.fromCharCode(parseInt(p1, 16));
+        })
+    );
+};
+
+
+const contentToBase64 = (content: string | ArrayBuffer, modality: Modality): Promise<string> => {
+    return new Promise((resolve, reject) => {
+        if (modality === 'text') {
+            try {
+                // Use helper for proper unicode support
+                resolve(unicodeToBase64(content as string));
+            } catch (error) {
+                console.error("Failed to Base64 encode text content:", error);
+                reject(new Error("Failed to encode text. Ensure it doesn't contain unsupported characters."));
+            }
+        } else if (typeof content === 'string') {
+            // For images, content is a data URL
+            const parts = content.split(',');
+            resolve(parts.length > 1 ? parts[1] : content);
+        } else if (content instanceof ArrayBuffer) {
+            // For meshes
+            const bytes = new Uint8Array(content);
+            let binary = '';
+            for (let i = 0; i < bytes.byteLength; i++) {
+                binary += String.fromCharCode(bytes[i]);
+            }
+            resolve(btoa(binary));
+        } else {
+            reject(new Error('Unsupported content type for base64 conversion.'));
+        }
+    });
+};
+
+/**
+ * Post-processes data received from the backend to ensure correct frontend rendering.
+ * - Converts raw Base64 image strings to Data URLs.
+ * - Converts raw Base64 mesh strings to ArrayBuffers.
+ */
+const postProcessApiData = <T extends { content: string | ArrayBuffer }>(item: T, modality: 'images' | 'texts' | 'meshes'): T => {
+    if (modality === 'images' && typeof item.content === 'string' && !item.content.startsWith('data:')) {
+        item.content = `data:image/png;base64,${item.content}`;
+    }
+    if (modality === 'meshes' && typeof item.content === 'string') {
+        const binaryString = atob(item.content);
+        const len = binaryString.length;
+        const bytes = new Uint8Array(len);
+        for (let i = 0; i < len; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        item.content = bytes.buffer;
+    }
+    return item;
+}
+
+/**
+ * Starts the dataset processing on the backend by uploading a .zip file.
+ * @param file The .zip file to upload.
+ * @returns A promise that resolves with a job ID for polling the status.
+ */
+export const startDatasetProcessing = async (file: File): Promise<string> => {
+  const formData = new FormData();
+  formData.append('file', file);
+
+  const response = await fetch(`${API_BASE_URL}api/process-dataset`, {
+    method: 'POST',
+    body: formData,
+  });
+
+  const { job_id } = await handleApiError(response);
+  if (!job_id) {
+    throw new Error("API did not return a job ID.");
+  }
+  return job_id;
+};
+
+
+interface ProcessingStatus {
+    status: 'starting' | 'processing' | 'complete' | 'error';
+    stage?: string;
+    progress?: number;
+    message?: string;
+    result?: Dataset;
+}
+
+/**
+ * Polls the backend for the status of a dataset processing job.
+ * @param jobId The ID of the job to check.
+ * @returns A promise that resolves with the current status.
+ */
+export const getProcessingStatus = async (jobId: string): Promise<ProcessingStatus> => {
+    const response = await fetch(`${API_BASE_URL}api/processing-status/${jobId}`);
+    const status: ProcessingStatus = await handleApiError(response);
+    
+    // If the job is complete, post-process the resulting dataset data
+    if (status.status === 'complete' && status.result) {
+        const processedDataset = status.result;
+        // The backend returns a string for the date, convert it to a Date object.
+        if (processedDataset.uploadDate && typeof processedDataset.uploadDate === 'string') {
+            processedDataset.uploadDate = new Date(processedDataset.uploadDate);
+        }
+
+        // Ensure all data items have the correct format for frontend rendering.
+        if (processedDataset.data) {
+            if (processedDataset.data.images) {
+                processedDataset.data.images = processedDataset.data.images.map((item: DataItem) => postProcessApiData(item, 'images'));
+            }
+            if (processedDataset.data.meshes) {
+                processedDataset.data.meshes = processedDataset.data.meshes.map((item: DataItem) => postProcessApiData(item, 'meshes'));
+            }
+        }
+        status.result = processedDataset;
+    }
+    
+    return status;
+}
+
+/**
+ * Sends a local dataset to the backend to populate its in-memory cache.
+ * This is crucial for making comparisons after a page reload.
+ * @param dataset The full local dataset object from IndexedDB.
+ */
+export const ensureDatasetInCache = async (dataset: Dataset): Promise<void> => {
+    // The backend expects content as base64 or raw text, but our Mesh content is an ArrayBuffer.
+    // We need to convert it before sending. Images are already data URLs (string).
+    const payload = {
+        ...dataset,
+        data: {
+            ...dataset.data,
+            meshes: await Promise.all(dataset.data.meshes.map(async (mesh) => {
+                if (mesh.content instanceof ArrayBuffer) {
+                    return { ...mesh, content: await contentToBase64(mesh.content, 'mesh') };
+                }
+                return mesh;
+            })),
+        }
+    };
+
+    const response = await fetch(`${API_BASE_URL}api/cache-local-dataset`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+    });
+
+    await handleApiError(response);
+};
+
+/**
+ * Finds the top matches for a single item by querying the backend.
+ * @param sourceItem The item to find matches for.
+ * @param sourceModality The modality of the source item.
+ * @param datasetId The ID of the dataset to search within.
+ * @returns A promise that resolves with the comparison results.
+ */
+export const findTopMatches = async (
+  sourceItem: DataItem,
+  sourceModality: Modality,
+  datasetId: string
+): Promise<SingleComparisonResult> => {
+
+  const contentAsBase64 = await contentToBase64(sourceItem.content, sourceModality);
+  
+  const requestBody = {
+    modality: sourceModality,
+    content: contentAsBase64,
+    dataset_id: datasetId,
+  };
+
+  const response = await fetch(`${API_BASE_URL}api/find-matches`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(requestBody),
+  });
+
+  const result: SingleComparisonResult = await handleApiError(response);
+  
+  // The API returns a representation of the source item with raw base64.
+  // We replace it with our original source item which has the correct format for rendering.
+  result.sourceItem = sourceItem;
+
+  // Post-process all returned match items to ensure they render correctly.
+  for (const key of Object.keys(result.results)) {
+      const modalityKey = key as 'images' | 'texts' | 'meshes';
+      const matches = result.results[modalityKey];
+      if (matches) {
+          matches.forEach(match => {
+              postProcessApiData(match.item, modalityKey);
+          });
+      }
+  }
+
+  return result;
+};
+
+
+// --- Service functions for SHARED datasets ---
+
+/**
+ * Returns the metadata for all available shared datasets by querying the backend.
+ */
+export const getSharedDatasetMetadata = async (): Promise<DatasetMetadata[]> => {
+  try {
+    const response = await fetch('/api/shared-dataset-metadata');
+    const metadataList = await handleApiError(response);
+    
+    // The backend returns strings for dates, convert them to Date objects.
+    return metadataList.map((meta: any) => ({
+        ...meta,
+        uploadDate: new Date(meta.uploadDate),
+    }));
+  } catch (error) {
+    console.error("Failed to fetch shared dataset metadata:", error);
+    // Re-throw the error so the UI layer can handle it.
+    throw error;
+  }
+};
+
+/**
+ * Returns the full data structure for a specific shared dataset from the backend.
+ * The content for each item remains null, only the URLs are provided.
+ */
+export const getSharedDataset = async (id: string): Promise<Dataset | null> => {
+  try {
+    const response = await fetch(`/api/shared-dataset?id=${id}`);
+    const dataset = await handleApiError(response);
+    
+    // Convert date string from API to Date object
+    dataset.uploadDate = new Date(dataset.uploadDate);
+    
+    return dataset;
+  } catch (error) {
+    console.error(`Failed to fetch shared dataset with id ${id}:`, error);
+    // Re-throw the error so the UI layer can handle it.
+    throw error;
+  }
+};