Add files using upload-large-folder tool

Code/Baselines/CraftsMan3D/README.md

@@ -0,0 +1,257 @@
+#### Important: we released [CraftsMan3D-DoraVAE](https://aruichen.github.io/Dora/) trained using rectified flow. 
+
+[中文版](README_zh.md)
+<p align="center">
+  <img src="asset/logo.png"  height=220>
+</p>
+
+### <div align="center">CraftsMan3D: High-fidelity Mesh Generation <br> with 3D Native Generation and Interactive Geometry Refiner<div> 
+#####  <p align="center"> [Weiyu Li<sup>*1,2</sup>](https://wyysf-98.github.io/), Jiarui Liu<sup>*1,2</sup>, Hongyu Yan<sup>*1</sup>, [Rui Chen<sup>1</sup>](https://aruichen.github.io/), [Yixun Liang<sup>1,2</sup>](https://yixunliang.github.io/), [Xuelin Chen<sup>3</sup>](https://xuelin-chen.github.io/), [Ping Tan<sup>1,2</sup>](https://ece.hkust.edu.hk/pingtan), [Xiaoxiao Long<sup>1,2</sup>](https://www.xxlong.site/)</p>
+#####  <p align="center"> <sup>1</sup>HKUST, <sup>2</sup>LightIllusions, <sup>3</sup>Adobe Research</p>
+<div align="center">
+  <a href="https://craftsman3d.github.io/"><img src="https://img.shields.io/static/v1?label=Project%20Page&message=Github&color=blue&logo=github-pages"></a> &ensp;
+  <a href="https://huggingface.co/spaces/wyysf/CraftsMan"><img src="https://www.gradio.app/_app/immutable/assets/gradio.CHB5adID.svg" height="25"/></a> &ensp;
+  <a href="https://triverse.lightillusions.com/"><img src="asset/icon.png" height="25"/>Local Website</a> &ensp;
+  <a href="https://arxiv.org/pdf/2405.14979"><img src="https://img.shields.io/static/v1?label=Paper&message=Arxiv&color=red&logo=arxiv"></a> &ensp;
+</div>
+
+# Usage
+
+```
+from craftsman import CraftsManPipeline
+import torch
+
+# load from local ckpt
+# mkdir ckpts && cd ckpts
+# mkdir craftsman-DoraVAE && cd craftsman-DoraVAE
+# wget https://pub-c7137d332b4145b6b321a6c01fcf8911.r2.dev/craftsman-DoraVAE/config.yaml
+# wget https://pub-c7137d332b4145b6b321a6c01fcf8911.r2.dev/craftsman-DoraVAE/model.ckpt
+# pipeline = CraftsManPipeline.from_pretrained("./ckpts/craftsman-DoraVAE", device="cuda:0", torch_dtype=torch.bfloat16) 
+
+# load from huggingface model hub, I uploading...
+pipeline = CraftsManPipeline.from_pretrained("craftsman3d/craftsman-DoraVAE", device="cuda:0", torch_dtype=torch.bfloat16)
+
+# inference
+mesh = pipeline("https://pub-f9073a756ec645d692ce3d171c2e1232.r2.dev/data/werewolf.png").meshes[0]
+mesh.export("werewolf.obj")
+
+```
+
+The results should be like this:
+<p align="center">
+  <img src="asset/demo_result.png"  height=220>
+</p>
+
+
+#### TL; DR: <font color="red">**CraftsMan3D (aka 匠心)**</font> is a two-stage text/image to 3D mesh generation model. By mimicking the modeling workflow of artist/craftsman, we propose to generate a coarse mesh (5s) with smooth geometry using 3D diffusion model and then refine it (20s) using enhanced multi-view normal maps generated by 2D normal diffusion, which is also can be in a interactive manner like Zbrush.
+
+
+
+## ✨ Overview
+
+This repo contains source code (training / inference) of 3D diffusion model, pretrained weights and gradio demo code of our 3D mesh generation project, you can find more visualizations on our [project page](https://craftsman3d.github.io/) and try our [demo](http://algodemo.bj.lightions.top:24926). If you have high-quality 3D data or some other ideas, we very much welcome any form of cooperation.
+<details><summary>Full abstract here</summary>
+We present a novel generative 3D modeling system, coined CraftsMan, which can generate high-fidelity 3D geometries with highly varied shapes, regular mesh topologies, and detailed surfaces, and, notably, allows for refining the geometry in an interactive manner. Despite the significant advancements in 3D generation, existing methods still struggle with lengthy optimization processes, irregular mesh topologies, noisy surfaces, and difficulties in accommodating user edits, consequently impeding their widespread adoption and implentation in 3D modeling softwares. Our work is inspired by the craftsman, who usually roughs out the holistic figure of the work first and elaborate the surface details subsequently. Specifically, we employ a 3D native diffusion model, which operates on latent space learned from latent set-based 3D representations, to generate coarse geometries with regular mesh topology in seconds. In particular, this process takes as input a text prompt or a reference image, and leverages a powerful multi-view (MV) diffusion model to generates multiple views of the coarse geometry, which are fed into our MV-conditioned 3D diffusion model for generating the 3D geometry, significantly improving robustness and generalizability. Following that, a normal-based geometry refiner is used to significantly enhance the surface details. This refinement can be performed automatically, or interactively with user-supplied edits. Extensive experiments demonstrate that our method achieves high efficiency in producing superior quality 3D assets compared to existing methods.
+</details>
+
+<p align="center">
+  <img src="asset/teaser.jpg" >
+</p>
+
+# 💪 ToDo List
+
+- [x] Inference code
+- [x] Training code
+- [x] Gradio & Hugging Face demo
+- [x] Model zoo
+- [x] Environment setup
+- [x] Data sample
+- [x] CraftsMan3D-DoraVAE (not the official version)
+- [x] support rectified flow training
+- [x] support [flashVDM](https://github.com/Tencent/FlashVDM/tree/main), thanks for their open-source
+- [ ] release multiview(4 views) conditioned model (including weights and training data sample) 
+- [x] add data for vae training, we release the data preprocessing script in `watertight_and_sampling.py`
+- [ ] support training and finetuning TripoSG model (almost done)
+- [ ] support training Hunyuan3D-2 model(it is not release the weights for vae encoder)
+
+
+## Contents
+* [Pretrained Models](##-Pretrained-models)
+* [Gradio & Huggingface Demo](#Gradio-demo)
+* [Inference](#Inference)
+* [Training](#Train)
+* [Data Prepration](#data)
+* [Video](#Video)
+* [Acknowledgement](#Acknowledgements)
+* [Citation](#Bibtex)
+
+## Environment Setup
+
+<details> <summary>Hardware</summary>
+We train our model on 32x A800 GPUs with a batch size of 32 per GPU for 7 days.
+
+The mesh refinement part is performed on a GTX 3080 GPU.
+
+
+</details>
+<details> <summary>Setup environment</summary>
+
+:smiley: We also provide a Dockerfile for easy installation, see [Setup using Docker](./docker/README.md).
+
+ - Python 3.10.0
+ - PyTorch 2.5.1 (for RSMNorm)
+ - Cuda Toolkit 12.4.0
+ - Ubuntu 22.04
+
+Clone this repository.
+
+```sh
+git clone https://github.com/wyysf-98/CraftsMan.git
+```
+
+Install the required packages.
+
+```sh
+conda create -n CraftsMan python=3.10 -y
+conda activate CraftsMan
+# conda install -c "nvidia/label/cuda-12.1.1" cudatoolkit
+# conda install pytorch==2.5.1 torchvision==0.20.1 torchaudio==2.5.1 pytorch-cuda=12.1 -c pytorch -c nvidia
+pip install torch==2.5.1 torchvision==0.20.1
+pip install -r docker/requirements.txt
+pip install torch-cluster -f https://data.pyg.org/whl/torch-2.5.1+cu124.html
+
+```
+
+</details>
+
+
+## ✨ History
+This repo will port some recent techniques for 3D diffusion model and the history version like the arxiv version can be found in different branch.
+<details> 
+
+<p align="center">
+  <img src="asset/history.png" >
+</p>
+
+
+</details>
+
+# 🎥 Video
+
+[![Watch the video](asset/video_cover.png)](https://www.youtube.com/watch?v=WhEs4tS4mGo)
+
+
+# 3D Native DiT Model (Latent Set DiT Model)
+We provide the training and the inference code here for future research.
+The latent set VAE model is heavily build on the same structure of [Michelangelo](https://github.com/NeuralCarver/Michelangelo).
+The latent set diffusion model is based on a [DiT/Pixart-alpha](https://pixart-alpha.github.io/) and with 500M parameters.
+
+## Pretrained models
+Currently, We provide the [models](https://huggingface.co/wyysf/CraftsMan) with single view image as condition with DiT.
+We will consider open source the further models according to the real situation.
+If you run the ``inference.py`` without specifying the model path, it will automatically download the model from the huggingface model hub.
+
+Or you can download the model manually:
+```bash
+## you can just manually get the model using wget:
+mkdir ckpts
+cd ckpts
+mkdir craftsman-v1-5
+cd craftsman-v1-5
+wget https://huggingface.co/craftsman3d/craftsman/resolve/main/config.yaml
+wget https://huggingface.co/craftsman3d/craftsman/resolve/main/model.ckpt
+### for DoraVAE version(https://aruichen.github.io/Dora/)
+cd ..
+mkdir craftsman-doravae
+cd craftsman-doravae
+wget https://huggingface.co/craftsman3d/craftsman-doravae/resolve/main/config.yaml
+wget https://huggingface.co/craftsman3d/craftsman-doravae/resolve/main/model.ckpt
+
+## OR you can git clone the repo:
+git lfs install
+git clone https://huggingface.co/craftsman3d/craftsman
+### for DoraVAE version(https://aruichen.github.io/Dora/)
+git clone https://huggingface.co/craftsman3d/craftsman-doravae
+
+```
+If you download the models using wget, you should manually put them under the `ckpts/craftsman` directory.
+
+## Gradio demo
+We provide gradio demos for easy usage.
+
+```bash
+python gradio_app.py --model_path ./ckpts/craftsman
+```
+
+## Inference
+To generate 3D meshes from images folders via command line, simply run:
+```bash
+python inference.py --input eval_data --device 0 --model ./ckpts/craftsman
+```
+
+For more configs, please refer to the `inference.py`.
+
+## Train from scratch
+We provide our training code to facilitate future research. And we provide a data sample in `data`.
+100k data sample for VAE training can be downloaded from (to be uploaded)
+
+100k data sample for diffusion training can be downloaded from https://pub-c7137d332b4145b6b321a6c01fcf8911.r2.dev/Objaverse_100k.zip
+
+selected 190k UUID for training can be downloaded from https://pub-c7137d332b4145b6b321a6c01fcf8911.r2.dev/objaverse_190k.json
+
+selected 320k UUID for training can be downloaded from https://pub-c7137d332b4145b6b321a6c01fcf8911.r2.dev/objaverse_320k.json
+
+For more training details and configs, please refer to the `configs` folder.
+
+```bash
+### training the shape-autoencoder
+python train.py --config ./configs/shape-autoencoder/michelangelo-l768-e64-ne8-nd16.yaml \
+                 --train --gpu 0
+
+### training the image-to-shape diffusion model
+# for single view conditioned generation
+python train.py --config ./configs/image-to-shape-diffusion/clip-dinov2-pixart-diffusion-dit32.yaml --train --gpu 0
+
+# for multi view conditioned generation (original paper)
+python train.py --config ./configs/image-to-shape-diffusion/clip-mvrgb-modln-l256-e64-ne8-nd16-nl6.yaml --train --gpu 0
+
+# for DoraVAE single view diffusion version (We can not provide the data for you due to the license issue, you can processed it by yourself)
+# (https://github.com/Seed3D/Dora/tree/main/sharp_edge_sampling)
+python train.py --config ./configs/image-to-shape-diffusion/DoraVAE-dinov2reglarge518-pixart-rectified-flow-dit32.yaml --train --gpu 0
+
+```
+
+
+# ❓Common questions
+Q: Tips to get better results.
+0. Due to limited resources, we will gradually expand the dataset and training scale, and therefore we will release more pre-trained models in the future.
+1. Just like the 2D diffusion model, try different seeds, adjust the CFG scale or different scheduler. Good Luck.
+2. We will provide a version that conditioned on the text prompt, so you can use some positive and negative prompts.
+
+
+# 🤗 Acknowledgements
+
+- Thanks to [LightIllusion](https://www.lightillusions.com/) for providing computational resources and Jianxiong Pan for data preprocessing. If you have any idea about high-quality 3D Generation, welcome to contact us!
+- Thanks to [Hugging Face](https://github.com/huggingface) for sponsoring the nicely demo!
+- Thanks to [3DShape2VecSet](https://github.com/1zb/3DShape2VecSet/tree/master) for their amazing work, the latent set representation provides an efficient way to represent 3D shape!
+- Thanks to [Michelangelo](https://github.com/NeuralCarver/Michelangelo) for their great work, our model structure is heavily build on this repo!
+- Thanks to [CRM](https://github.com/thu-ml/CRM), [Wonder3D](https://github.com/xxlong0/Wonder3D/) and [LGM](https://github.com/3DTopia/LGM) for their released model about multi-view images generation. If you have a more advanced version and want to contribute to the community, we are welcome to update.
+- Thanks to [Objaverse](https://objaverse.allenai.org/), [Objaverse-MIX](https://huggingface.co/datasets/BAAI/Objaverse-MIX/tree/main) for their open-sourced data, which help us to do many validation experiments.
+- Thanks to [ThreeStudio](https://github.com/threestudio-project/threestudio) for their great repo, we follow their fantastic and easy-to-use code structure!
+- Thanks to [Direct3D](https://github.com/DreamTechAI/Direct3D) especially [Shuang Wu](https://scholar.google.it/citations?user=SN8J78EAAAAJ&hl=zh-CN) for providing their results.
+- Thanks to [TripoSG](https://github.com/VAST-AI-Research/TripoSG) and [Hunyuan3D-2](https://github.com/Tencent/Hunyuan3D-2) for their open-source, we adapted our code to support loading their weights, training, and fine-tuning.
+
+
+# 📑License
+CraftsMan3D is under MIT License. 
+
+
+# 📖 BibTeX
+
+    @misc{li2024craftsman,
+    title         = {CraftsMan3D: High-fidelity Mesh Generation with 3D Native Generation and Interactive Geometry Refiner}, 
+    author        = {Weiyu Li and Jiarui Liu and Hongyu Yan and Rui Chen and Yixun Liang and Xuelin Chen and Ping Tan and Xiaoxiao Long},
+    year          = {2024},
+    archivePrefix = {arXiv preprint arXiv:2405.14979},
+    primaryClass  = {cs.CG}
+    }

Code/Baselines/CraftsMan3D/README_zh.md

@@ -0,0 +1,207 @@
+<p align="center">
+  <img src="asset/logo.png"  height=220>
+</p>
+
+### <div align="center">匠心1.5：基于3D原生扩模型和交互式几何优化的高质量网格模型生成<div> 
+#####  <p align="center"> [李威宇<sup>1,2</sup>](https://wyysf-98.github.io/), 刘嘉瑞<sup>1,2</sup>, 闫鸿禹<sup>*1,2</sup>, [陈锐<sup>1,2</sup>](https://aruichen.github.io/), [梁逸勋<sup>3,2</sup>](https://yixunliang.github.io/), [陈学霖<sup>4</sup>](https://xuelin-chen.github.io/), [谭平<sup>1,2</sup>](https://ece.hkust.edu.hk/pingtan), [龙霄潇<sup>1,2</sup>](https://www.xxlong.site/)</p>
+#####  <p align="center"> <sup>1</sup>香港科技大学, <sup>2</sup>光影幻象, <sup>3</sup>香港科技大学（广州）, <sup>4</sup>腾讯 AI Lab</p>
+<div align="center">
+  <a href="https://craftsman3d.github.io/"><img src="https://img.shields.io/static/v1?label=Project%20Page&message=Github&color=blue&logo=github-pages"></a> &ensp;
+  <a href="https://huggingface.co/spaces/wyysf/CraftsMan"><img src="https://www.gradio.app/_app/immutable/assets/gradio.CHB5adID.svg" height="25"/>(不带纹理)</a> &ensp;
+  <a href="http://algodemo.bj.lightions.top:24926"><img src="https://www.gradio.app/_app/immutable/assets/gradio.CHB5adID.svg" height="25"/>(带纹理)</a> &ensp;
+  <a href="https://arxiv.org/pdf/2405.14979"><img src="https://img.shields.io/static/v1?label=Paper&message=Arxiv&color=red&logo=arxiv"></a> &ensp;
+</div>
+
+# 使用方案
+
+```
+from craftsman import CraftsManPipeline
+import torch
+
+# load from local ckpt
+# pipeline = CraftsManPipeline.from_pretrained("./ckpts/craftsman", device="cuda:0", torch_dtype=torch.float32) 
+
+# load from huggingface model hub
+pipeline = CraftsManPipeline.from_pretrained("craftsman3d/craftsman", device="cuda:0", torch_dtype=torch.float32)
+
+# inference
+mesh = pipeline("https://pub-f9073a756ec645d692ce3d171c2e1232.r2.dev/data/werewolf.png").meshes[0]
+mesh.export("werewolf.obj")
+
+```
+
+这个结果应该是:
+<p align="center">
+  <img src="asset/demo_result.png"  height=220>
+</p>
+
+
+#### 一句话总结: <font color="red">**CraftsMan (又名 匠心)**</font> 是一个两阶段的文本/图像到3D网格生成模型。通过模仿艺术家/工匠的建模工作流程，我们提出首先使用3D扩散模型生成一个具有平滑几何形状的粗糙网格（5秒），然后使用2D法线扩散生成的增强型多视图法线图进行细化（20秒），这也可以通过类似Zbrush的交互方式进行。
+
+
+## ✨ 总览
+这个仓库包含了我们3D网格生成项目的源代码（训练/推理）、预训练权重和gradio演示代码，你可以在我们的[项目页面](https://craftsman3d.github.io/)找到更多的可视化内容以及[演示](https://huggingface.co/spaces/wyysf/CraftsMan)试玩生成结果。如果你有高质量的3D数据或其他想法，我们非常欢迎任何形式的合作。
+<details><summary>完整摘要</summary>
+我们提出了一个新颖的3D建模系统，匠心。它可以生成具有多样形状、规则网格拓扑和光滑表面的高保真3D几何，并且值得注意的是，它可以和人工建模流程一样以交互方式细化几何体。尽管3D生成领域取得了显著进展，但现有方法仍然难以应对漫长的优化过程、不规则的网格拓扑、嘈杂的表面以及难以适应用户编辑的问题，因此阻碍了它们在3D建模软件中的广泛采用和实施。我们的工作受到工匠建模的启发，他们通常会首先粗略地勾勒出作品的整体形状，然后详细描绘表面细节。具体来说，我们采用了一个3D原生扩散模型，该模型在从基于潜在集的3D表示学习到的潜在空间上操作，只需几秒钟就可以生成具有规则网格拓扑的粗糙几何体。特别是，这个过程以文本提示或参考图像作为输入，并利用强大的多视图（MV）二维扩散模型生成粗略几何体的多个视图，这些视图被输入到我们的多视角条件3D扩散模型中，用于生成3D几何，显著提高其了鲁棒性和泛化能力。随后，使用基于法线的几何细化器显著增强表面细节。这种细化可以自动执行，或者通过用户提供的编辑以交互方式进行。广泛的实验表明，我们的方法在生成优于现有方法的高质量3D资产方面十分高效。
+</details>
+
+<p align="center">
+  <img src="asset/teaser.jpg" >
+</p>
+
+
+## 内容
+* [视频](#Video)
+* [预训练模型](##-Pretrained-models)
+* [Gradio & Huggingface 示例](#Gradio-demo)
+* [推理代码](#Inference)
+* [训练代码](#Train)
+* [数据准备](#data)
+* [致谢](#Acknowledgements)
+* [引用](#Bibtex)
+
+## 环境搭建
+
+<details> <summary>硬件</summary>
+我们在32个A800 GPU上以每GPU 32的批量大小训练模型，训练了7天。
+
+网格细化部分在GTX 3080 GPU上执行。
+
+
+</details>
+<details> <summary>运行环境搭建</summary>
+
+:smiley: 为了方便使用，我们提供了docker镜像文件[Setup using Docker](./docker/README.md).
+
+ - Python 3.10.0
+ - PyTorch 2.1.0
+ - Cuda Toolkit 11.8.0
+ - Ubuntu 22.04
+
+克隆这个仓库.
+
+```sh
+git clone git@github.com:wyysf-98/CraftsMan.git
+```
+
+安装所需要的依赖包.
+
+```sh
+conda create -n CraftsMan python=3.10 -y
+conda activate CraftsMan
+conda install cudatoolkit=11.8 -c pytorch -y
+pip install torch==2.5.0 torchvision==0.18.0 
+pip install -r docker/requirements.txt
+```
+
+</details>
+
+
+# 🎥 视频
+
+[![观看视频](asset/video_cover.png)](https://www.youtube.com/watch?v=WhEs4tS4mGo)
+
+
+# 三维原生扩散模型 (Latent Set DiT Model)
+我们在这里提供了训练和推理代码，以便于未来的研究。
+The latent set diffusion model 在很大程度上基于[Michelangelo](https://github.com/NeuralCarver/Michelangelo),
+采用了 [DiT/Pixart-alpha](https://pixart-alpha.github.io/) DiT架构，并且参数量为500M.
+
+## 预训练模型
+目前，我们提供了以单视图图像作为条件的模型。
+我们将根据实际情况考虑开源进一步的模型。
+```bash
+## 您可以直接使用 wget 下载:
+wget https://huggingface.co/craftsman3d/craftsman/resolve/main/config.yaml
+wget https://huggingface.co/craftsman3d/craftsman/resolve/main/model.ckpt
+
+## 或者克隆模型仓库:
+git lfs install
+git clone https://huggingface.co/craftsman3d/craftsman
+
+```
+如果使用 wget 下载，应该手动将模型文件放置于 `ckpts/craftsman` 文件夹。
+
+
+## Gradio 示例
+我们提供了gradio示例，为了更方便的使用。
+要在本地机器上运行gradio演示，请简单运行：
+
+```bash
+python gradio_app.py --model_path ./ckpts/craftsman
+
+```
+
+## 模型推理
+要通过命令行从图像文件夹生成3D网格，简单运行：
+```bash
+python inference.py --input eval_data --device 0 --model ./ckpts/craftsman
+```
+
+更多推理配置，请参考 `inference.py`
+
+## 从头开始训练
+我们提供了我们的训练代码以方便未来的研究。我们已经提供数据样本。
+对于训练数据，请填写表格[form](https://docs.google.com/forms/d/e/1FAIpQLSdhjMFNaOqMqioqZyJNcSCfXb4H0WrcYyEcHvFI2nf60_fPhw/viewform)获取下载链接。
+
+*由于部署数据的成本问题，如果您能帮助在社交媒体上分享我们的工作（任何形式都可），您将收到存储在AWS S3上的下载链接，这可以实现20-100 MB/s的下载速度。*
+有关更多的训练细节和配置，请参考configs文件夹。
+
+```bash
+### 训练形状自动编码器
+python train.py --config ./configs/shape-autoencoder/l256-e64-ne8-nd16.yaml \
+                 --train --gpu 0
+
+### 训练单视图DiT模型
+python train.py --config .configs/image-to-shape-diffusion/clip-dino-rgb-pixart-lr2e4-ddim.yaml \
+                 --train --gpu 0
+
+```
+
+# 2D法线增强扩散模型（即将推出）
+
+我们正在努力发布我们的三维网格细化代码。感谢您的耐心等待，我们将为这个激动人心的发展做最后的努力。" 🔧🚀
+
+您也可以在视频中找到网格细化部分的结果。
+
+
+# ❓常见问题
+问题: 如何获得更好的结果？
+0. 由于我们资源有限，将会逐步扩大数据集和训练规模，因此我们将在未来发布更多的预训练模型。
+1. 就像2D扩散模型一样，尝试不同的随机数种子，调整CFG比例或不同的调度器。
+2. 我们将在后期考虑提供一个以文本提示为条件的版本，因此您可以使用一些正面和负面的提示。
+
+
+# 💪 待办事项
+
+- [x]  推理代码
+- [x]  训练代码
+- [x]  Gradio & Hugging Face演示
+- [x]  模型库，我们将在未来发布更多的ckpt
+- [x]  环境设置
+- [x]  数据样本
+- [ ]  网格细化代码
+
+
+# 🤗 致谢
+
+- 感谢[光影幻像](https://www.lightillusions.com/)提供计算资源和潘建雄进行数据预处理。如果您对高质量的3D生成有任何想法，欢迎与我们联系！
+- Thanks to [Hugging Face](https://github.com/huggingface) for sponsoring the nicely demo!
+- Thanks to [3DShape2VecSet](https://github.com/1zb/3DShape2VecSet/tree/master) for their amazing work, the latent set representation provides an efficient way to represent 3D shape!
+- Thanks to [Michelangelo](https://github.com/NeuralCarver/Michelangelo) for their great work, our model structure is heavily build on this repo!
+- Thanks to [CRM](https://github.com/thu-ml/CRM), [Wonder3D](https://github.com/xxlong0/Wonder3D/) and [LGM](https://github.com/3DTopia/LGM) for their released model about multi-view images generation. If you have a more advanced version and want to contribute to the community, we are welcome to update.
+- 感谢 [Objaverse](https://objaverse.allenai.org/), [Objaverse-MIX](https://huggingface.co/datasets/BAAI/Objaverse-MIX/tree/main) 开源的数据，这帮助我们进行了许多验证实验。
+- 感谢 [ThreeStudio](https://github.com/threestudio-project/threestudio) 实现了一个完整的框架，我们参考他们出色且易于使用的代码结构。
+
+# 📑许可证
+CraftsMan在[AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html)下，因此任何包含CraftsMan代码或训练模型（无论是预训练还是自定义训练）的下游解决方案和产品（包括云服务）都应该是开源的，以符合AGPL的条件。如果您对CraftsMan的使用有任何疑问，请先与我们联系。
+
+# 📖 BibTeX
+
+    @misc{li2024craftsman,
+    title         = {CraftsMan: High-fidelity Mesh Generation with 3D Native Generation and Interactive Geometry Refiner}, 
+    author        = {Weiyu Li and Jiarui Liu and Hongyu Yan and Rui Chen and Yixun Liang and Xuelin Chen and Ping Tan and Xiaoxiao Long},
+    year          = {2024},
+    archivePrefix = {arXiv preprint arXiv:2405.14979},
+    primaryClass  = {cs.CG}
+    }

Code/Baselines/CraftsMan3D/gradio_app.py

@@ -0,0 +1,313 @@
+import spaces
+import argparse
+import os
+import json
+import torch
+import sys
+import time
+import importlib
+import numpy as np
+from omegaconf import OmegaConf
+from huggingface_hub import hf_hub_download
+from diffusers import DiffusionPipeline
+
+import PIL
+from PIL import Image
+from collections import OrderedDict
+import trimesh
+import rembg
+import gradio as gr
+from typing import Any
+
+proj_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(os.path.join(proj_dir))
+
+import tempfile
+
+import craftsman
+from craftsman.utils.config import ExperimentConfig, load_config
+
+_TITLE = '''CraftsMan: High-fidelity Mesh Generation with 3D Native Generation and Interactive Geometry Refiner'''
+_DESCRIPTION = '''
+<div>
+<span style="color: red;">Important: If you have your own data and want to collaborate, we are welcom to any contact.</span>
+<div>
+Select or upload a image, then just click 'Generate'. 
+<br>
+By mimicking the artist/craftsman modeling workflow, we propose CraftsMan (aka 匠心) that uses 3D Latent Set Diffusion Model that directly generate coarse meshes,
+then a multi-view normal enhanced image generation model is used to refine the mesh.
+We provide the coarse 3D diffusion part here. 
+<br>
+If you found CraftsMan is helpful, please help to ⭐ the <a href='https://github.com/wyysf-98/CraftsMan/' target='_blank'>Github Repo</a>. Thanks!
+<a style="display:inline-block; margin-left: .5em" href='https://github.com/wyysf-98/CraftsMan/'><img src='https://img.shields.io/github/stars/wyysf-98/CraftsMan?style=social' /></a>
+<br>
+*If you have your own multi-view images, you can directly upload it.
+</div>
+'''
+_CITE_ = r"""
+---
+📝 **Citation**
+If you find our work useful for your research or applications, please cite using this bibtex:
+```bibtex
+@article{li2024craftsman,
+author    = {Weiyu Li and Jiarui Liu and Rui Chen and Yixun Liang and Xuelin Chen and Ping Tan and Xiaoxiao Long},
+title     = {CraftsMan: High-fidelity Mesh Generation with 3D Native Generation and Interactive Geometry Refiner},
+journal   = {arXiv preprint arXiv:2405.14979},
+year      = {2024},
+}
+```
+🤗 **Acknowledgements**
+We use <a href='https://github.com/wjakob/instant-meshes' target='_blank'>Instant Meshes</a> to remesh the generated mesh to a lower face count, thanks to the authors for the great work.
+📋 **License**
+CraftsMan is under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html), so any downstream solution and products (including cloud services) that include CraftsMan code or a trained model (both pretrained or custom trained) inside it should be open-sourced to comply with the AGPL conditions. If you have any questions about the usage of CraftsMan, please contact us first.
+📧 **Contact**
+If you have any questions, feel free to open a discussion or contact us at <b>weiyuli.cn@gmail.com</b>.
+"""
+
+model = None
+cached_dir = None
+
+generator = None
+
+def check_input_image(input_image):
+    if input_image is None:
+        raise gr.Error("No image uploaded!")
+
+class RMBG(object):
+    def __init__(self):
+        pass
+
+    def rmbg_rembg(self, input_image, background_color):
+        def _rembg_remove(
+            image: PIL.Image.Image,
+            rembg_session = None,
+            force: bool = False,
+            **rembg_kwargs,
+        ) -> PIL.Image.Image:
+            do_remove = True
+            if image.mode == "RGBA" and image.getextrema()[3][0] < 255:
+                # explain why current do not rm bg
+                print("alhpa channl not enpty, skip remove background, using alpha channel as mask")
+                background = Image.new("RGBA", image.size, background_color)
+                image = Image.alpha_composite(background, image)
+                do_remove = False
+            do_remove = do_remove or force
+            if do_remove:
+                image = rembg.remove(image, session=rembg_session, **rembg_kwargs)
+
+            # calculate the min bbox of the image
+            alpha = image.split()[-1]
+            image = image.crop(alpha.getbbox())
+
+            return image
+        return _rembg_remove(input_image, None, force_remove=True)
+
+    def run(self, rm_type, image, foreground_ratio, background_choice, background_color=(0, 0, 0, 0)):
+        if "Original" in background_choice:
+            return image
+        else:
+            if background_choice == "Alpha as mask":
+                alpha = image.split()[-1]
+                image = image.crop(alpha.getbbox())
+            
+            elif "Remove" in background_choice:
+                if rm_type.upper() == "REMBG":
+                    image = self.rmbg_rembg(image, background_color=background_color)
+                else:
+                    return -1
+        
+            # Calculate the new size after rescaling
+            new_size = tuple(int(dim * foreground_ratio) for dim in image.size)
+            # Resize the image while maintaining the aspect ratio
+            resized_image = image.resize(new_size)
+            # Create a new image with the original size and white background
+            padded_image = PIL.Image.new("RGBA", image.size, (0, 0, 0, 0))
+            paste_position = ((image.width - resized_image.width) // 2, (image.height - resized_image.height) // 2)
+            padded_image.paste(resized_image, paste_position)
+
+            # expand image to 1:1
+            width, height = padded_image.size
+            if width == height:
+                return padded_image
+            new_size = (max(width, height), max(width, height))
+            image = PIL.Image.new("RGBA", new_size, (0, 0, 0, 0))
+            paste_position = ((new_size[0] - width) // 2, (new_size[1] - height) // 2)
+            image.paste(padded_image, paste_position)
+            return image
+
+# @spaces.GPU
+def image2mesh(image: Any, 
+               more: bool = False,
+               scheluder_name: str ="DDIMScheduler",
+               guidance_scale: int = 7.5,
+               steps: int = 30,
+               seed: int = 4,
+               target_face_count: int = 2000,
+               octree_depth: int = 7):
+    
+    sample_inputs = {
+        "image": [
+            image
+        ]
+    }
+
+    global model
+    latents = model.sample(
+        sample_inputs,
+        sample_times=1,
+        steps=steps,
+        guidance_scale=guidance_scale,
+        seed=seed
+    )[0]
+    
+    # decode the latents to mesh
+    box_v = 1.1
+    mesh_outputs, _ = model.shape_model.extract_geometry(
+        latents,
+        bounds=[-box_v, -box_v, -box_v, box_v, box_v, box_v],
+        octree_depth=octree_depth
+    )
+    assert len(mesh_outputs) == 1, "Only support single mesh output for gradio demo"
+    mesh = trimesh.Trimesh(mesh_outputs[0][0], mesh_outputs[0][1])
+    # filepath = f"{cached_dir}/{time.time()}.obj"
+    filepath = tempfile.NamedTemporaryFile(suffix=f".obj", delete=False).name
+    mesh.export(filepath, include_normals=True)
+
+    if 'Remesh' in more:
+        remeshed_filepath = tempfile.NamedTemporaryFile(suffix=f"_remeshed.obj", delete=False).name
+        print("Remeshing with Instant Meshes...")
+        command = f"{proj_dir}/apps/third_party/InstantMeshes {filepath} -f {target_face_count} -o {remeshed_filepath}"
+        os.system(command)
+        filepath = remeshed_filepath
+    
+    return filepath
+
+if __name__=="__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_path", type=str, default="./ckpts/craftsman-v1-5", help="Path to the object file",)
+    parser.add_argument("--cached_dir", type=str, default="")
+    parser.add_argument("--device", type=int, default=0)
+    args = parser.parse_args()
+
+
+    cached_dir = args.cached_dir
+    if cached_dir != "":
+        os.makedirs(args.cached_dir, exist_ok=True)
+    device = torch.device(f"cuda:{args.device}" if torch.cuda.is_available() else "cpu")
+    print(f"using device: {device}")
+
+    # for input image
+    background_choice = OrderedDict({ 
+        "Alpha as Mask": "Alpha as Mask",
+        "Auto Remove Background": "Auto Remove Background",
+        "Original Image": "Original Image",        
+    })
+
+    generator = torch.Generator(device)
+
+    # for 3D latent set diffusion
+    if args.model_path == "":
+        ckpt_path = hf_hub_download(repo_id="craftsman3d/craftsman-v1-5", filename="model.ckpt", repo_type="model")
+        config_path = hf_hub_download(repo_id="craftsman3d/craftsman-v1-5", filename="config.yaml", repo_type="model")
+    else:
+        ckpt_path = os.path.join(args.model_path, "model.ckpt")
+        config_path = os.path.join(args.model_path, "config.yaml")
+    scheluder_dict = OrderedDict({ 
+        "DDIMScheduler": 'diffusers.schedulers.DDIMScheduler',
+        # "DPMSolverMultistepScheduler": 'diffusers.schedulers.DPMSolverMultistepScheduler', # not support yet
+        # "UniPCMultistepScheduler": 'diffusers.schedulers.UniPCMultistepScheduler', # not support yet
+    })
+    
+    # main GUI
+    custom_theme = gr.themes.Soft(primary_hue="blue").set(
+                    button_secondary_background_fill="*neutral_100",
+                    button_secondary_background_fill_hover="*neutral_200")
+    custom_css = '''#disp_image {
+        text-align: center; /* Horizontally center the content */
+    }'''
+    
+    with gr.Blocks(title=_TITLE, theme=custom_theme, css=custom_css) as demo:
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown('# ' + _TITLE)
+        gr.Markdown(_DESCRIPTION)
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                with gr.Column():
+                    # input image
+                    with gr.Row():
+                        image_input = gr.Image(
+                            label="Image Input",
+                            image_mode="RGBA",
+                            sources="upload",
+                            type="pil",
+                        )
+                run_btn = gr.Button('Generate', variant='primary', interactive=True)
+
+                with gr.Row():
+                    gr.Markdown('''Try a different <b>seed and MV Model</b> for better results. Good Luck :)''')
+                with gr.Row():
+                    seed = gr.Number(0, label='Seed', show_label=True)
+                    more = gr.CheckboxGroup(["Remesh"], label="More", show_label=False)
+                    target_face_count = gr.Number(2000, label='Target Face Count', show_label=True)
+
+                with gr.Row():
+                    gr.Examples(
+                        examples=[os.path.join("./asset/examples", i) for i in os.listdir("./asset/examples")],
+                        inputs=[image_input],
+                        examples_per_page=8
+                    )
+
+            with gr.Column(scale=4):
+                with gr.Row():
+                    output_model_obj = gr.Model3D(
+                        label="Output Model (OBJ Format)",
+                        camera_position=(90.0, 90.0, 3.5),
+                        interactive=False,
+                    )
+                with gr.Row():
+                    gr.Markdown('''*please note that the model is fliped due to the gradio viewer, please download the obj file and you will get the correct orientation.''')
+                    
+                with gr.Accordion('Advanced options', open=False):
+                    with gr.Row():
+                        background_choice = gr.Dropdown(label="Backgroud Choice", value="Auto Remove Background",choices=list(background_choice.keys()))
+                        rmbg_type = gr.Dropdown(label="Backgroud Remove Type", value="rembg",choices=['sam', "rembg"])
+                        foreground_ratio = gr.Slider(label="Foreground Ratio", value=1.0, minimum=0.5, maximum=1.0, step=0.01)
+
+                    with gr.Row():
+                        guidance_scale = gr.Number(label="3D Guidance Scale", value=5.0, minimum=3.0, maximum=10.0)
+                        steps = gr.Number(value=50, minimum=20, maximum=100, label="3D Sample Steps")
+                        
+                    with gr.Row():
+                        scheduler = gr.Dropdown(label="scheluder", value="DDIMScheduler",choices=list(scheluder_dict.keys()))
+                        octree_depth = gr.Slider(label="Octree Depth", value=7, minimum=4, maximum=8, step=1)
+                    
+        gr.Markdown(_CITE_)
+
+        outputs = [output_model_obj]
+        rmbg = RMBG()
+        
+        # model = load_model(ckpt_path, config_path, device)
+        cfg = load_config(config_path)
+        model = craftsman.find(cfg.system_type)(cfg.system)
+        print(f"Restoring states from the checkpoint path at {ckpt_path} with config {cfg}")
+        ckpt = torch.load(ckpt_path, map_location=torch.device('cpu'))
+        model.load_state_dict(
+            ckpt["state_dict"] if "state_dict" in ckpt else ckpt,
+        )
+        model = model.to(device).eval()
+
+
+        run_btn.click(fn=check_input_image, inputs=[image_input]
+                    ).success(
+                            fn=rmbg.run, 
+                            inputs=[rmbg_type, image_input, foreground_ratio, background_choice],
+                            outputs=[image_input]
+                    ).success(
+                            fn=image2mesh, 
+                            inputs=[image_input, more, scheduler, guidance_scale, steps, seed, target_face_count, octree_depth],
+                            outputs=outputs, 
+                            api_name="generate_img2obj")
+        
+        demo.queue().launch(share=True, allowed_paths=[args.cached_dir])

Code/Baselines/CraftsMan3D/inference.py

@@ -0,0 +1,22 @@
+from craftsman import CraftsManPipeline
+import torch
+
+# load from local ckpt
+# pipeline = CraftsManPipeline.from_pretrained("./ckpts/craftsman-v1-5", device="cuda:0", torch_dtype=torch.float32) 
+# pipeline = CraftsManPipeline.from_pretrained("./ckpts/craftsman-DoraVAE", device="cuda:0", torch_dtype=torch.float32) 
+pipeline = CraftsManPipeline.from_pretrained("./ckpts/craftsman-DoraVAE", device="cuda:0", torch_dtype=torch.bfloat16) # bf16 for fast inference
+
+# # load from huggingface model hub
+# pipeline = CraftsManPipeline.from_pretrained("craftsman3d/craftsman-v1-5", device="cuda:0", torch_dtype=torch.float32)
+# pipeline = CraftsManPipeline.from_pretrained("craftsman3d/craftsman-DoraVAE", device="cuda:0", torch_dtype=torch.float32)
+# pipeline = CraftsManPipeline.from_pretrained("craftsman3d/craftsman-DoraVAE", device="cuda:0", torch_dtype=torch.bfloat16) # bf16 for fast inference
+
+image_file = "val_data/dragon.png"
+obj_file = "dragon.glb" # output obj or glb file
+textured_obj_file = "dragon_textured.glb"
+# inference
+mesh = pipeline(image_file).meshes[0]
+mesh.export(obj_file)
+
+########## For texture generation, we recommend to use hunyuan3d-2 ##########
+# https://github.com/Tencent/Hunyuan3D-2/tree/main/hy3dgen/texgen

Code/Baselines/CraftsMan3D/material.mtl

@@ -0,0 +1,7 @@
+# https://github.com/mikedh/trimesh
+
+newmtl material_0
+Ka 0.40000000 0.40000000 0.40000000
+Kd 1.00000000 1.00000000 1.00000000
+Ks 0.40000000 0.40000000 0.40000000
+Ns 1.00000000

Code/Baselines/CraftsMan3D/train.py

@@ -0,0 +1,306 @@
+import argparse
+import getpass
+import contextlib
+import importlib
+import logging
+import os
+import sys
+import time
+import re
+import datetime
+import traceback
+import pytorch_lightning as pl
+import torch
+from pytorch_lightning import Trainer
+from pytorch_lightning.callbacks import LearningRateMonitor, ModelCheckpoint
+from pytorch_lightning.loggers import CSVLogger, TensorBoardLogger
+from pytorch_lightning.utilities.rank_zero import rank_zero_only
+import craftsman
+from craftsman.systems.base import BaseSystem
+from craftsman.utils.callbacks import (
+    EarlyEnvironmentSetter,
+    CodeSnapshotCallback,
+    ConfigSnapshotCallback,
+    CustomProgressBar,
+    ProgressCallback,
+)
+from craftsman.utils.config import ExperimentConfig, load_config
+from craftsman.utils.misc import get_rank
+from craftsman.utils.typing import Optional
+class ColoredFilter(logging.Filter):
+    """
+    A logging filter to add color to certain log levels.
+    """
+
+    RESET = "\033[0m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+
+    COLORS = {
+        "WARNING": YELLOW,
+        "INFO": GREEN,
+        "DEBUG": BLUE,
+        "CRITICAL": MAGENTA,
+        "ERROR": RED,
+    }
+
+    RESET = "\x1b[0m"
+
+    def __init__(self):
+        super().__init__()
+
+    def filter(self, record):
+        if record.levelname in self.COLORS:
+            color_start = self.COLORS[record.levelname]
+            record.levelname = f"{color_start}[{record.levelname}]"
+            record.msg = f"{record.msg}{self.RESET}"
+        return True
+
+
+def load_custom_module(module_path):
+    module_name = os.path.basename(module_path)
+    if os.path.isfile(module_path):
+        sp = os.path.splitext(module_path)
+        module_name = sp[0]
+    try:
+        if os.path.isfile(module_path):
+            module_spec = importlib.util.spec_from_file_location(
+                module_name, module_path
+            )
+        else:
+            module_spec = importlib.util.spec_from_file_location(
+                module_name, os.path.join(module_path, "__init__.py")
+            )
+
+        module = importlib.util.module_from_spec(module_spec)
+        sys.modules[module_name] = module
+        module_spec.loader.exec_module(module)
+        return True
+    except Exception as e:
+        print(traceback.format_exc())
+        print(f"Cannot import {module_path} module for custom nodes:", e)
+        return False
+
+
+def load_custom_modules():
+    node_paths = ["custom"]
+    node_import_times = []
+    if not os.path.exists("node_paths"):
+        return
+    for custom_node_path in node_paths:
+        possible_modules = os.listdir(custom_node_path)
+        if "__pycache__" in possible_modules:
+            possible_modules.remove("__pycache__")
+
+        for possible_module in possible_modules:
+            module_path = os.path.join(custom_node_path, possible_module)
+            if (
+                os.path.isfile(module_path)
+                and os.path.splitext(module_path)[1] != ".py"
+            ):
+                continue
+            if module_path.endswith(".disabled"):
+                continue
+            time_before = time.perf_counter()
+            success = load_custom_module(module_path)
+            node_import_times.append(
+                (time.perf_counter() - time_before, module_path, success)
+            )
+
+    if len(node_import_times) > 0:
+        print("\nImport times for custom modules:")
+        for n in sorted(node_import_times):
+            if n[2]:
+                import_message = ""
+            else:
+                import_message = " (IMPORT FAILED)"
+            print("{:6.1f} seconds{}:".format(n[0], import_message), n[1])
+        print()
+
+
+def main(args, extras) -> None:
+    # set CUDA_VISIBLE_DEVICES if needed, then import pytorch-lightning
+    os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+    env_gpus_str = os.environ.get("CUDA_VISIBLE_DEVICES", None)
+    env_gpus = list(env_gpus_str.split(",")) if env_gpus_str else []
+    selected_gpus = [0]
+    torch.set_float32_matmul_precision("high")
+
+    # Always rely on CUDA_VISIBLE_DEVICES if specific GPU ID(s) are specified.
+    # As far as Pytorch Lightning is concerned, we always use all available GPUs
+    # (possibly filtered by CUDA_VISIBLE_DEVICES).
+    devices = -1
+    if len(env_gpus) > 0:
+        n_gpus = len(env_gpus)
+    else:
+        selected_gpus = list(args.gpu.split(","))
+        n_gpus = len(selected_gpus)
+        print(f"Using {n_gpus} GPUs: {selected_gpus}")
+        os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
+
+    if args.typecheck:
+        from jaxtyping import install_import_hook
+
+        install_import_hook("craftsman", "typeguard.typechecked")
+
+    logger = logging.getLogger("pytorch_lightning")
+    if args.verbose:
+        logger.setLevel(logging.DEBUG)
+
+    for handler in logger.handlers:
+        if handler.stream == sys.stderr:  # type: ignore
+            if not args.gradio:
+                handler.setFormatter(logging.Formatter("%(levelname)s %(message)s"))
+                handler.addFilter(ColoredFilter())
+            else:
+                handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
+
+    load_custom_modules()
+
+    # parse YAML config to OmegaConf
+    cfg: ExperimentConfig
+    cfg = load_config(args.config, cli_args=extras, n_gpus=n_gpus)
+
+    # set a different seed for each device
+    rank = get_rank()
+    pl.seed_everything(cfg.seed + rank, workers=True)
+
+    dm = craftsman.find(cfg.data_type)(cfg.data)
+    system: BaseSystem = craftsman.find(cfg.system_type)(
+        cfg.system, resumed=cfg.resume is not None
+    )
+    system.set_save_dir(os.path.join(cfg.trial_dir, "save"))
+
+    if args.gradio:
+        fh = logging.FileHandler(os.path.join(cfg.trial_dir, "logs"))
+        fh.setLevel(logging.INFO)
+        if args.verbose:
+            fh.setLevel(logging.DEBUG)
+        fh.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
+        logger.addHandler(fh)
+
+    callbacks = []
+    if args.train:
+        callbacks += [
+            EarlyEnvironmentSetter(),
+            ModelCheckpoint(
+                dirpath=os.path.join(cfg.trial_dir, "ckpts"), **cfg.checkpoint
+            ),
+            LearningRateMonitor(logging_interval="step"),
+            CodeSnapshotCallback(
+                os.path.join(cfg.trial_dir, "code"), use_version=False
+            ),
+            ConfigSnapshotCallback(
+                args.config,
+                cfg,
+                os.path.join(cfg.trial_dir, "configs"),
+                use_version=False,
+            ),
+        ]
+        if args.gradio:
+            callbacks += [
+                ProgressCallback(save_path=os.path.join(cfg.trial_dir, "progress"))
+            ]
+        else:
+            callbacks += [CustomProgressBar(refresh_rate=1)]
+
+    def write_to_text(file, lines):
+        with open(file, "w") as f:
+            for line in lines:
+                f.write(line + "\n")
+
+    loggers = []
+    if args.train:
+        # make tensorboard logging dir to suppress warning
+        rank_zero_only(
+            lambda: os.makedirs(os.path.join(cfg.trial_dir, "tb_logs"), exist_ok=True)
+        )()
+        loggers += [
+            TensorBoardLogger(cfg.trial_dir, name="tb_logs"),
+            CSVLogger(cfg.trial_dir, name="csv_logs"),
+        ] + system.get_loggers()
+        rank_zero_only(
+            lambda: write_to_text(
+                os.path.join(cfg.trial_dir, "cmd.txt"),
+                ["python " + " ".join(sys.argv), str(args)],
+            )
+        )()
+
+    trainer = Trainer(
+        callbacks=callbacks,
+        logger=loggers,
+        inference_mode=False,
+        accelerator="gpu",
+        devices=devices,
+        **cfg.trainer
+        # profiler="pytorch",
+    )
+
+    def set_system_status(system: BaseSystem, ckpt_path: Optional[str]):
+        if ckpt_path is None:
+            return
+        ckpt = torch.load(ckpt_path, map_location="cpu")
+        system.set_resume_status(ckpt["epoch"], ckpt["global_step"])
+    if args.train:
+        trainer.fit(system, datamodule=dm, ckpt_path=cfg.resume)
+        trainer.test(system, datamodule=dm)
+        if args.gradio:
+            # also export assets if in gradio mode
+            trainer.predict(system, datamodule=dm)
+    elif args.validate:
+        # manually set epoch and global_step as they cannot be automatically resumed
+        set_system_status(system, cfg.resume)
+        trainer.validate(system, datamodule=dm, ckpt_path=cfg.resume)
+    elif args.test:
+        # manually set epoch and global_step as they cannot be automatically resumed
+        set_system_status(system, cfg.resume)
+        trainer.test(system, datamodule=dm, ckpt_path=cfg.resume)
+    elif args.export:
+        set_system_status(system, cfg.resume)
+        trainer.predict(system, datamodule=dm, ckpt_path=cfg.resume)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", required=True, help="path to config file")
+    parser.add_argument(
+        "--gpu",
+        default="0",
+        help="GPU(s) to be used. 0 means use the 1st available GPU. "
+        "1,2 means use the 2nd and 3rd available GPU. "
+        "If CUDA_VISIBLE_DEVICES is set before calling `launch.py`, "
+        "this argument is ignored and all available GPUs are always used.",
+    )
+
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--train", action="store_true")
+    group.add_argument("--validate", action="store_true")
+    group.add_argument("--test", action="store_true")
+    group.add_argument("--export", action="store_true")
+
+    parser.add_argument(
+        "--gradio", action="store_true", help="if true, run in gradio mode"
+    )
+
+    parser.add_argument(
+        "--verbose", action="store_true", help="if true, set logging level to DEBUG"
+    )
+
+    parser.add_argument(
+        "--typecheck",
+        action="store_true",
+        help="whether to enable dynamic type checking",
+    )
+
+    args, extras = parser.parse_known_args()
+
+    if args.gradio:
+        with contextlib.redirect_stdout(sys.stderr):
+            main(args, extras)
+    else:
+        main(args, extras)

Code/Baselines/CraftsMan3D/train_autoencoder.sh

@@ -0,0 +1,4 @@
+export CUDA_VISIBLE_DEVICES=0
+export CUDA_LAUNCH_BLOCKING=1
+
+python launch.py --config ./configs/shape-autoencoder/l256-e64-ne8-nd16.yaml --train --gpu 0

Code/Baselines/CraftsMan3D/watertight_and_sampling.py

@@ -0,0 +1,613 @@
+import os
+import math
+import torch
+import torch.nn.functional as F
+import igl # pip install libigl==2.5.1
+import trimesh
+import mcubes # pip install mcubes
+import numpy as np
+import nvdiffrast.torch as dr
+
+from pysdf import SDF
+from matplotlib import image
+from argparse import ArgumentParser
+
+def sample_from_sphere(num_views, radius, upper=False):
+    """sample x,y,z location from the sphere
+    reference: https://zhuanlan.zhihu.com/p/25988652?group_id=828963677192491008
+    """
+    num_views = num_views * 2 if upper else num_views
+    phi = (np.sqrt(5) - 1.0) / 2.0
+    pos_list = []
+    for n in range(1, num_views + 1):
+        y = (2.0 * n - 1) / num_views - 1.0
+        x = np.cos(2 * np.pi * n * phi) * np.sqrt(1 - y * y)
+        z = np.sin(2 * np.pi * n * phi) * np.sqrt(1 - y * y)
+        if upper and y < 0:
+            continue
+        pos_list.append((x * radius, y * radius, z * radius))
+    return np.array(pos_list)
+
+
+class MeshRenderer:
+    def __init__(
+            self,
+            resolution=(1024, 1024), # resolution of the rendered image
+            near=0.1, # near plane for the camera
+            far=10.0, # far plane for the camera
+            device='cuda' # device to run the renderer on
+            ):
+        """Initialize the mesh renderer."""
+        self.resolution = resolution
+        self.near = near
+        self.far = far
+        self.device = torch.device(device)
+        # check if the device is cuda
+        if torch.cuda.is_available() and device == 'cuda':
+            self._ctx = dr.RasterizeCudaContext(device=self.device)
+        elif device == 'cpu':
+            self._ctx = dr.RasterizeGLContext(device=self.device)
+        else:
+            raise ValueError("Device must be 'cuda' or 'cpu'.")
+
+        # warm up the renderer
+        self._warmup()
+
+    def _warmup(self):
+        """Warm up the renderer to avoid the first frame being slow."""
+        #windows workaround for https://github.com/NVlabs/nvdiffrast/issues/59
+        def tensor(*args, **kwargs):
+            return torch.tensor(*args, device='cuda', **kwargs)
+        pos = tensor([[[-0.8, -0.8, 0, 1], [0.8, -0.8, 0, 1], [-0.8, 0.8, 0, 1]]], dtype=torch.float32)
+        tri = tensor([[0, 1, 2]], dtype=torch.int32)
+        dr.rasterize(self._ctx, pos, tri, resolution=[256, 256])
+
+
+    def rasterize(
+        self,
+        pos: torch.FloatTensor,
+        tri: torch.IntTensor,
+        resolution = (1024, 1024), # resolution of the rendered image
+        grad_db: bool = True,
+    ):
+        """
+        Rasterize the given vertices and triangles.
+        Args:
+            pos (Float[Tensor, "B Nv 4"]): Vertex positions
+            tri (Integer[Tensor, "Nf 3"]): Triangle indices
+            resolution (Union[int, Tuple[int, int]]): Output resolution
+            grad_db (Bool): Enable gradient backpropagation
+        Returns:
+            Rasterized outputs
+        """
+        # rasterize in instance mode (single topology)
+        return dr.rasterize(
+            self._ctx, pos.float(), tri.int(), resolution, grad_db=grad_db
+        )
+
+    def interpolate(
+        self,
+        attr: torch.FloatTensor,
+        rast: torch.FloatTensor,
+        tri: torch.IntTensor,
+        rast_db=None,
+        diff_attrs=None,
+    ):
+        """
+        Interpolate attributes using the given rasterization outputs.
+        Args:
+            attr (Float[Tensor, "B Nv C"]): Attributes to interpolate
+            rast (Float[Tensor, "B H W 4"]): Rasterization outputs
+            tri (Integer[Tensor, "Nf 3"]): Triangle indices
+            rast_db (Float[Tensor, "B H W 4"], optional): Differentiable rasterization outputs
+            diff_attrs (Float[Tensor, "B Nv C"], optional): Differentiable attributes
+        Returns:
+            Interpolated attribute values
+        """
+        return dr.interpolate(
+            attr.float(), rast, tri.int(), rast_db=rast_db, diff_attrs=diff_attrs
+        )
+
+    def render(
+        self,
+        mesh: trimesh.Trimesh, # trimesh object
+        cam2world_matrixs: torch.Tensor, #N,4,4
+        mvp_matrixs: torch.Tensor, #N,4,4
+        render_vert_depth: bool = True, # whether to render vertex depth
+        render_face_normals: bool = True, # whether to render face normals
+    ):
+        """
+        Render the mesh using the given camera and model view projection matrices.
+        Args:
+            mesh (trimesh.Trimesh): The mesh to render
+            cam2world_matrixs (torch.Tensor): Camera to world matrix (N, 4, 4)
+            mvp_matrixs (torch.Tensor): Model view projection matrix (N, 4, 4)
+            render_vert_depth (bool): Whether to render vertex depth
+            render_face_normals (bool): Whether to render face normals
+        Returns:
+            results (dict): Dictionary containing rendered outputs
+        """
+        results = {}
+
+        v_pos = torch.tensor(mesh.vertices, dtype=torch.float32, device=self.device) # (num_vertices, 3)
+        t_pos_idx = torch.tensor(mesh.faces, dtype=torch.int32, device=self.device) # (num_faces, 3)
+
+        verts_homo = torch.cat([v_pos, torch.ones([v_pos.shape[0], 1]).to(v_pos)], dim=-1)
+        v_pos_clip: Float[Tensor, "B Nv 4"] = torch.matmul(verts_homo, mvp_matrixs.permute(0, 2, 1))
+
+        rast, _ = self.rasterize(v_pos_clip, t_pos_idx, self.resolution)
+        mask = rast[..., 3:] > 0
+
+        if render_vert_depth:
+            verts_homo = torch.cat(
+                [
+                    v_pos, torch.ones([v_pos.shape[0], 1]).to(v_pos),
+                ],
+                dim=-1,
+            )
+            v_pos_cam = verts_homo @ cam2world_matrixs.inverse().transpose(-1, -2)
+            v_depth = v_pos_cam[..., 2:3] * -1  # (B,n_v,1)
+            gb_depth, _ = self.interpolate(
+                v_depth.contiguous(), rast, t_pos_idx
+            )
+            gb_depth[~mask] = self.far
+            results.update({"vert_depth": gb_depth})
+        
+
+        if render_face_normals:
+            flat_face_index = torch.arange(
+                len(t_pos_idx) * 3, device=self.device, dtype=torch.int
+            ).reshape(-1, 3)
+            
+            i0 = t_pos_idx[:, 0]
+            i1 = t_pos_idx[:, 1]
+            i2 = t_pos_idx[:, 2]
+
+            v0 = v_pos[i0, :]
+            v1 = v_pos[i1, :]
+            v2 = v_pos[i2, :]
+
+            face_normals = torch.linalg.cross(v1 - v0, v2 - v0)
+            f_nrm = face_normals[:, None, :].repeat(1, 3, 1).reshape(-1, 3)
+
+            gb_normal, _ = self.interpolate(f_nrm, rast, flat_face_index)
+
+            gb_normal = gb_normal.view(-1, self.resolution[0] * self.resolution[1], 3)
+            gb_normal = torch.matmul(
+                torch.linalg.inv(cam2world_matrixs[:, :3, :3]),
+                gb_normal.transpose(1, 2),
+            ).transpose(1, 2)
+            gb_normal = gb_normal.view(-1, self.resolution[0], self.resolution[0], 3)
+            gb_normal = F.normalize(gb_normal, dim=-1).contiguous()
+            gb_normal = torch.lerp(
+                torch.zeros_like(gb_normal), (gb_normal + 1.0) / 2.0, mask.float()
+            )
+            gb_normal = torch.cat([gb_normal, mask], dim=-1)
+            results.update({"face_normal": gb_normal})
+
+        return results
+
+
+@torch.no_grad()
+def visibility_check(points, depths, cam2world_matrixs, mvp_matrixs):
+    '''
+    Visibility check for points in 3D space
+
+    Args:
+    - points: (n_points, 3), 3D points in world space
+    - depths: (n_view, H, W, 1), depth maps
+    - cam2world_matrixs: (n_views, 4, 4), camera to world matrix
+    - mvp_matrixs: (n_views, 4, 4), model view projection matrix
+
+    Returns:
+    - mask: (n_points, ), visibility mask
+    - dist: (n_points, ), distance to the visible surface
+    '''
+    dist = torch.ones(points.shape[0]).to(points) # defult as one
+    mask = torch.zeros(points.shape[0], dtype=torch.bool).to(points.device)  # visibility
+
+    points_homo = torch.cat(
+        [points, torch.ones([points.shape[0], 1]).to(points)], dim=-1
+    )
+    for i, cam2world_matrix in enumerate(cam2world_matrixs):
+        points_clip_i = points_homo @ mvp_matrixs[i].permute(1,0)
+        valid_region = (torch.abs(points_clip_i[...,0]) < 0.999) & \
+            (torch.abs(points_clip_i[...,1]) < 0.999) 
+        points_valid = points_clip_i[valid_region].float()
+
+        v_pos_cam = points_homo @ cam2world_matrix.inverse().transpose(-1, -2)
+        v_depth = v_pos_cam[..., 2:3] * -1
+
+        # query using (u, v)
+        sample_z = torch.nn.functional.grid_sample(depths[i].view(1, 1, depths.shape[1], depths.shape[2]).float(),
+            points_valid[:, :2].reshape(1, 1, points_valid.shape[0], 2), align_corners=True, mode='bilinear').reshape(-1) 
+
+        visible_points = v_depth[valid_region].squeeze() < sample_z  # visible if z smaller than render depth
+        mask[torch.where(valid_region)[0][torch.where(visible_points)[0]]] = True
+
+        # dist to hitting point along camera ray
+        dist[valid_region] = torch.minimum(dist[valid_region], torch.abs(sample_z - v_depth[valid_region].squeeze())) 
+
+    return mask, dist
+
+
+@torch.no_grad()
+def watertight(
+        mesh, 
+        grid_resolution=256, 
+        device='cuda', 
+        num_views=50, 
+        sample_size=2.1, 
+        winding_number_thres=0.5,
+    ):
+    """
+    Convert a mesh to a watertight mesh using trimesh.
+    
+    Args:
+        mesh: Input mesh as a trimesh object
+        grid_resolution: Resolution of the grid for sampling
+        device: Device to run the script on (cpu or cuda)
+        num_views: Number of views for visibility check, default is 50
+        sample_size: Size of the sample space, default is 2.1
+        winding_number_thres: Threshold for winding number, default is 0.5
+    
+    Returns:
+        watertight_mesh: A watertight mesh as a trimesh object
+    """
+    # setup grid points
+    x,y,z = np.meshgrid(
+        np.arange(grid_resolution, dtype=np.float32), 
+        np.arange(grid_resolution, dtype=np.float32), 
+        np.arange(grid_resolution, dtype=np.float32),  
+        indexing='ij')
+    grid_points = np.stack(
+            (x.reshape(-1) + 0.5, y.reshape(-1) + 0.5, z.reshape(-1) + 0.5
+        ),axis=-1) / grid_resolution * sample_size - sample_size / 2.0
+    grid_points = torch.tensor(grid_points).to(device)
+    print(f"number of grid_points: {grid_points.shape} with resolution {grid_resolution}, range {grid_points.min()} to {grid_points.max()}")
+    
+    # setup for rendering depth maps
+    cam_poses = sample_from_sphere(num_views, 4.0, upper=False) # (num_views, 3)
+    scale = 1.0 # scale for the orthogonal camera projection matrix
+    resolution = 1024 # resolution of the rendered images
+    aspect_ratio = 1.0 # aspect ratio of the rendered images
+    near, far = 0.1, 10.0 # near and far plane for the camera
+    cam2world_matrixs, mvp_matrixs = [], []
+    for position in cam_poses:
+        # extrinsic matrix
+        backward = np.array([0, 0, 0]) - position
+        backward = backward / np.linalg.norm(backward)
+        right = np.cross(backward, np.array([0, 1, 0]))
+        right = right / np.linalg.norm(right)
+        up = np.cross(right, backward)
+
+        R = np.stack([right, up, -backward], axis=0)
+        t = -R @ position
+        extrinsic = np.eye(4)
+        extrinsic[:3, :3] = R
+        extrinsic[:3, 3] = t
+        cam2world_matrixs.append(np.linalg.inv(extrinsic)) # (4, 4)
+
+        # projection matrix
+        proj_mtx = np.zeros([4, 4])
+        proj_mtx[0, 0] = scale
+        proj_mtx[1, 1] = scale * -1
+        proj_mtx[2, 2] = -2 / (far - near)
+        proj_mtx[2, 3] = -(far + near) / (far - near)
+        proj_mtx[3, 3] = 1
+        mvp_matrix = proj_mtx @ extrinsic
+        mvp_matrixs.append(mvp_matrix) # (4, 4)
+    cam2world_matrixs = torch.tensor(np.array(cam2world_matrixs), dtype=torch.float32).to(device) # (num_views, 4, 4)
+    mvp_matrixs = torch.tensor(np.array(mvp_matrixs), dtype=torch.float32).to(device) # (num_views, 4, 4)
+
+    rendererd_imgs = MeshRenderer((resolution, resolution), near, far, device).render(
+        mesh,
+        cam2world_matrixs=cam2world_matrixs,
+        mvp_matrixs=mvp_matrixs,
+    )
+
+    # STEP A. do visibility_check for each grid point
+    visibility, dist = visibility_check(grid_points, rendererd_imgs['vert_depth'], cam2world_matrixs, mvp_matrixs)
+    winding_numbers = igl.fast_winding_number_for_meshes(
+        np.array(mesh.vertices, dtype=np.float32), 
+        np.array(mesh.faces, dtype=np.int32), 
+        grid_points.detach().cpu().numpy()
+    )
+    winding_numbers = torch.from_numpy(winding_numbers).to(device)
+    visibility[visibility & (winding_numbers > winding_number_thres)]= False # combine visibility with winding number mask
+
+    ## STEP B. refine sdf close to the surface
+    near_surface_idx = torch.where(dist < 1.0)[0]
+    squared_distances, closest_points, face_indices = \
+            igl.point_mesh_squared_distance(grid_points[near_surface_idx].detach().cpu().numpy(),
+                                            mesh.vertices,
+                                            mesh.faces)
+    squared_distances = torch.from_numpy(squared_distances).to(grid_points)
+    dist[near_surface_idx] = torch.sqrt(squared_distances)
+
+    ## STEP C. convert udf to sdf
+    dist[visibility==False] *= -1
+
+    ## STEP D. generate the mesh using Marching Cube
+    sdf = dist.view(grid_resolution, grid_resolution, grid_resolution)
+    # not the 0-level surface, we use the surface with a small offset
+    mesh = mcubes.marching_cubes(sdf.cpu().numpy(), sample_size / grid_resolution)
+    mesh = trimesh.Trimesh(
+        vertices=mesh[0] / grid_resolution * sample_size - sample_size / 2.0,
+        faces=mesh[1],
+        process=False
+    )
+
+    return mesh
+
+
+def sharp_edge_sampling(mesh_path, num_views=100000, sharpness_threshold=math.radians(30)):
+    """
+    Sample points on sharp edges of the mesh.
+    Code borrowed from the Dora github repository: https://github.com/Seed3D/Dora/blob/main/sharp_edge_sampling/sharp_sample.py#L37
+    Please consider citing the Dora paper if you use this code in your work.
+
+    Args:
+        mesh_path: Path to the OBJ file
+        sharpness_threshold: Threshold for sharp edge detection
+        num_views: Target number of points to generate
+    
+    Returns:
+        sharp_surface: Array of sharp surface points with positions and normals
+    """
+    import bpy # bpy==4.0.0
+    import bmesh
+    # Import OBJ file
+    bpy.ops.wm.obj_import(filepath=mesh_path)
+    obj = bpy.context.selected_objects[0]
+
+    # Enter Edit mode
+    bpy.context.view_layer.objects.active = obj
+    bpy.ops.object.mode_set(mode='EDIT')
+
+    # Ensure edge selection mode
+    bpy.ops.mesh.select_mode(type="EDGE")
+
+    # Select sharp edges
+    bpy.ops.mesh.edges_select_sharp(sharpness=sharpness_threshold)
+
+    # Switch back to Object mode to access selection state
+    bpy.ops.object.mode_set(mode='OBJECT')
+
+    # Create bmesh instance
+    bm = bmesh.new()
+    bm.from_mesh(obj.data)
+
+    # Get selected sharp edges
+    sharp_edges = [edge for edge in bm.edges if edge.select]
+
+    # Collect sharp edge vertex pairs
+    sharp_edges_vertices = []
+    link_normal1 = []
+    link_normal2 = []
+    sharp_edges_angle = []
+    # Unique vertices set
+    vertices_set = set()
+
+    for edge in sharp_edges:
+        vertices_set.update(edge.verts[:])  # Add to unique vertices set
+        
+        # Collect sharp edge vertex pair indices
+        sharp_edges_vertices.append([edge.verts[0].index, edge.verts[1].index])
+
+        # Get normals of linked faces
+        normal1 = edge.link_faces[0].normal
+        normal2 = edge.link_faces[1].normal
+
+        link_normal1.append(normal1)
+        link_normal2.append(normal2)
+
+        if normal1.length == 0.0 or normal2.length == 0.0:
+            sharp_edges_angle.append(0.0)
+        # Compute the angle between the two normals
+        else:
+            sharp_edges_angle.append(math.degrees(normal1.angle(normal2)))
+
+    # Extract vertex data
+    vertices = []
+    vertices_index = []
+    vertices_normal = []
+
+    for vertex in vertices_set:
+        vertices.append(vertex.co)
+        vertices_index.append(vertex.index)
+        vertices_normal.append(vertex.normal)
+
+    # Convert to numpy arrays
+    vertices = np.array(vertices)
+    vertices_index = np.array(vertices_index)
+    vertices_normal = np.array(vertices_normal)
+
+    sharp_edges_count = np.array(len(sharp_edges))
+    sharp_edges_angle_array = np.array(sharp_edges_angle)
+
+    if sharp_edges_count > 0:
+        sharp_edge_link_normal = np.array(np.concatenate([link_normal1, link_normal2], axis=1))
+        nan_mask = np.isnan(sharp_edge_link_normal)
+        # Replace NaN values with 0 using boolean indexing
+        sharp_edge_link_normal = np.where(nan_mask, 0, sharp_edge_link_normal)
+        
+        nan_mask = np.isnan(vertices_normal)
+        # Replace NaN values with 0 using boolean indexing
+        vertices_normal = np.where(nan_mask, 0, vertices_normal)
+
+    # Convert to numpy array
+    sharp_edges_vertices_array = np.array(sharp_edges_vertices)
+
+    if sharp_edges_count > 0:
+        mesh = trimesh.load(mesh_path, process=False, force='mesh')
+        num_target_sharp_vertices = num_views // 2
+        sharp_edge_length = sharp_edges_count
+        sharp_edges_vertices_pair = sharp_edges_vertices_array
+        sharp_vertices_pair = mesh.vertices[sharp_edges_vertices_pair]  # Vertex pair coordinates (1225, 2, 3)
+        epsilon = 1e-4  # Small numerical value
+        
+        # Calculate edge normals
+        edge_normal = 0.5 * sharp_edge_link_normal[:, :3] + 0.5 * sharp_edge_link_normal[:, 3:]
+        norms = np.linalg.norm(edge_normal, axis=1, keepdims=True)
+        norms = np.where(norms > epsilon, norms, epsilon)
+        edge_normal = edge_normal / norms  # Normalize edge normals
+        
+        known_vertices = vertices  # Unique sharp vertices
+        known_vertices_normal = vertices_normal
+        known_vertices = np.concatenate([known_vertices, known_vertices_normal], axis=1)
+
+        num_known_vertices = known_vertices.shape[0]  # Number of unique sharp vertices
+        
+        if num_known_vertices < num_target_sharp_vertices:  # If known vertices < target vertices
+            num_new_vertices = num_target_sharp_vertices - num_known_vertices
+            
+            if num_new_vertices >= sharp_edge_length:  # If new vertices needed >= sharp edges count
+                # Each sharp edge needs at least one interpolated vertex
+                num_new_vertices_per_pair = num_new_vertices // sharp_edge_length  # Vertices per edge
+                new_vertices = np.zeros((sharp_edge_length, num_new_vertices_per_pair, 6))  # Initialize new vertices array
+
+                start_vertex = sharp_vertices_pair[:, 0]
+                end_vertex = sharp_vertices_pair[:, 1]
+                
+                for j in range(1, num_new_vertices_per_pair + 1):
+                    t = j / float(num_new_vertices_per_pair + 1)
+                    new_vertices[:, j - 1, :3] = (1 - t) * start_vertex + t * end_vertex
+                    new_vertices[:, j - 1, 3:] = edge_normal  # Same normal within each edge
+                
+                new_vertices = new_vertices.reshape(-1, 6)
+
+                remaining_vertices = num_new_vertices % sharp_edge_length  # Calculate remaining vertices
+                if remaining_vertices > 0:
+                    rng = np.random.default_rng()
+                    ind = rng.choice(sharp_edge_length, remaining_vertices, replace=False)
+                    new_vertices_remain = np.zeros((remaining_vertices, 6))  # Initialize remaining vertices array
+                    
+                    start_vertex = sharp_vertices_pair[ind, 0]
+                    end_vertex = sharp_vertices_pair[ind, 1]
+                    t = np.random.rand(remaining_vertices).reshape(-1, 1)
+                    new_vertices_remain[:, :3] = (1 - t) * start_vertex + t * end_vertex
+
+                    edge_normal = 0.5 * sharp_edge_link_normal[ind, :3] + 0.5 * sharp_edge_link_normal[ind, 3:]
+                    edge_normal = edge_normal / np.linalg.norm(edge_normal, axis=1, keepdims=True)
+                    new_vertices_remain[:, 3:] = edge_normal
+
+                    new_vertices = np.concatenate([new_vertices, new_vertices_remain], axis=0)
+            else:
+                remaining_vertices = num_new_vertices % sharp_edge_length  # Calculate remaining vertices to allocate
+                if remaining_vertices > 0:
+                    rng = np.random.default_rng()
+                    ind = rng.choice(sharp_edge_length, remaining_vertices, replace=False)
+                    new_vertices_remain = np.zeros((remaining_vertices, 6))  # Initialize new vertices array
+                    
+                    start_vertex = sharp_vertices_pair[ind, 0]
+                    end_vertex = sharp_vertices_pair[ind, 1]
+                    t = np.random.rand(remaining_vertices).reshape(-1, 1)
+                    new_vertices_remain[:, :3] = (1 - t) * start_vertex + t * end_vertex
+
+                    edge_normal = 0.5 * sharp_edge_link_normal[ind, :3] + 0.5 * sharp_edge_link_normal[ind, 3:]
+                    edge_normal = edge_normal / np.linalg.norm(edge_normal, axis=1, keepdims=True)
+                    new_vertices_remain[:, 3:] = edge_normal
+
+                    new_vertices = new_vertices_remain
+
+            sharp_surface = np.concatenate([new_vertices, known_vertices], axis=0)
+        else:
+            sharp_surface = known_vertices
+        # Make sure the sharp surface has the correct number of samples
+        sharp_surface = sharp_surface[np.random.choice(sharp_surface.shape[0], num_views, replace=True), :]
+        print(f"Sampled {sharp_surface.shape[0]} points on sharp edges of the mesh.")
+        # manually remove the bpy object and free memory
+        bm.free()
+        bpy.data.objects.remove(obj, do_unlink=True)
+
+        return sharp_surface
+    else:
+        print("No sharp edges found in the mesh.")
+        return None
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser(description="Watertight mesh and sampling points")
+    parser.add_argument("--input_mesh", type=str, required=True, help="Path to the input mesh file")
+    parser.add_argument("--output_path", type=str, default="./output", help="Path to save the watertight mesh and sampled points")
+    parser.add_argument("--skip_watertight", action='store_true', help="Skip the watertight check and directly sample points from the mesh")
+    parser.add_argument("--device", type=str, default="cuda", help="Device to run the script on (cpu or cuda)")
+    # Add command-line arguments for watertight conversion
+    parser.add_argument("--grid_resolution", type=int, default=256, help="Resolution of the grid for sampling")
+    # Add command-line arguments for sampling
+    parser.add_argument("--sample_sharp_edge", type=bool, default=True, help="Sample points on sharp edges of the mesh in Dora paper")
+    parser.add_argument("--angle_threshold", type=float, default=15.0, help="Angle threshold for sharp edge detection in degrees")
+    parser.add_argument("--num_surface_points", type=int, default=100000, help="Number of points to sample from the mesh")
+    parser.add_argument("--num_sharp_surface_points", type=int, default=100000, help="Number of points to sample from the sharp edges of the mesh")
+    parser.add_argument("--num_near_surface_points", type=int, default=100000, help="Number of points to sample near the mesh surface")
+    parser.add_argument("--num_vlume_points", type=int, default=100000, help="Number of points to sample inside the mesh volume")
+    parser.add_argument("--bounds", type=float, default=1.05, help="Bounds for sampling points in the mesh, a little larger than the mesh size")
+    args = parser.parse_args()
+
+    # Load the mesh
+    mesh = trimesh.load(args.input_mesh, force='mesh')
+    # Normalize the mesh into a unit cube
+    mesh.apply_translation(-np.mean(mesh.vertices, axis=0))
+    mesh.apply_scale(1.0 / np.max(np.abs(mesh.vertices)))
+
+    # Check if the mesh is watertight
+    if mesh.is_watertight and args.skip_watertight:
+        print("Mesh is already watertight. Proceeding to sample points.")
+    else:
+        print("Attempting to convert the mesh to a watertight mesh.")
+        mesh = watertight(
+            mesh,
+            grid_resolution=args.grid_resolution,
+            device=args.device,
+        )
+
+    # Save the watertight mesh
+    output_path = f"{args.output_path}/{args.input_mesh.split('/')[-1].split('.')[0]}"
+    os.makedirs(output_path, exist_ok=True)
+    mesh.export(f"{output_path}/watertight_mesh.obj")
+    print(f"Watertight mesh saved to {output_path}/watertight_mesh.obj")
+
+    # sample points near the surface and in the space within bounds
+    surface_points, faces = mesh.sample(args.num_surface_points, return_index=True)
+    near_points = [
+        surface_points + np.random.normal(scale=0.001, size=(args.num_near_surface_points, 3)),
+        surface_points + np.random.normal(scale=0.01, size=(args.num_near_surface_points, 3)),
+    ]
+    near_surface_points = np.concatenate(near_points)
+    volume_rand_points = np.random.uniform(-args.bounds, args.bounds, size=(args.num_vlume_points, 3))
+    f = SDF(mesh.vertices, mesh.faces); # (num_vertices, 3) and (num_faces, 3)
+    # compute SDF values for the sampled points
+    near_surface_points_with_sdf = np.concatenate([near_surface_points, f(near_surface_points)[:, np.newaxis]], axis=1) # (num_near_surface_points, 4)
+    volume_rand_points_with_sdf = np.concatenate([volume_rand_points, f(volume_rand_points)[:, np.newaxis]], axis=1) # (num_vlume_points, 4)
+
+    # Sample points with normals on the surface
+    surface_points, faces = mesh.sample(args.num_surface_points, return_index=True)
+    normals = mesh.face_normals[faces]
+    surface = np.concatenate([surface_points, normals], axis=1)
+    if args.sample_sharp_edge:
+        # Sample points on sharp edges
+        print("Sampling points on sharp edges of the mesh.")
+        sharp_surface = sharp_edge_sampling(
+            args.input_mesh, 
+            num_views=args.num_sharp_surface_points,
+            sharpness_threshold=math.radians(args.angle_threshold)
+        )
+        # Save the samples
+        np.savez(
+            f'{output_path}/samples.npz',
+            surface=surface, # (num_surface_points, 6), surface points with normals
+            sharp_surface=sharp_surface, # (num_sharp_surface_points, 6), sharp surface points with normals
+            near_surface_points=near_surface_points_with_sdf, # (num_near_surface_points, 4), sampled points near the surface with SDF values
+            volume_rand_points=volume_rand_points_with_sdf, # (num_vlume_points, 4), sampled points in the volume within bounds with SDF values
+            bounds=np.array([-args.bounds, args.bounds])
+        )
+    else:
+        # Save the samples
+        np.savez(
+            f'{output_path}/samples.npz',
+            surface=surface, # (num_surface_points, 6), surface points with normals
+            near_surface_points=near_surface_points_with_sdf, # (num_near_surface_points, 4), sampled points near the surface with SDF values
+            volume_rand_points=volume_rand_points_with_sdf, # (num_vlume_points, 4), sampled points in the volume within bounds with SDF values
+            bounds=np.array([-args.bounds, args.bounds])
+        )

Code/Baselines/sd-dino/README.md

@@ -0,0 +1,162 @@
+# A Tale of Two Features: Stable Diffusion Complements DINO for Zero-Shot Semantic Correspondence
+
+**A Tale of Two Features** explores the complementary nature of Stable Diffusion (SD) and DINOv2 features for zero-shot semantic correspondence. The results demonstrate that a simple fusion of the two features leads to state-of-the-art performance on the SPair-71k, PF-Pascal, and TSS datasets.
+
+This repository is the official implementation of the paper:
+
+[**A Tale of Two Features: Stable Diffusion Complements DINO for Zero-Shot Semantic Correspondence**](https://arxiv.org/abs/2305.15347)
+[*Junyi Zhang*](https://junyi42.github.io/),
+[*Charles Herrmann*](https://scholar.google.com/citations?user=LQvi5XAAAAAJ),
+[*Junhwa Hur*](https://hurjunhwa.github.io/),
+[*Luisa F. Polanía*](https://scholar.google.com/citations?user=HGLobX4AAAAJ),
+[*Varun Jampani*](https://varunjampani.github.io/),
+[*Deqing Sun*](https://deqings.github.io/),
+[*Ming-Hsuan Yang*](https://faculty.ucmerced.edu/mhyang/)
+NeurIPS, 2023.
+
+**[New!] We have released the code for [Telling Left from Right](https://github.com/Junyi42/geoaware-sc), a follow-up with better semantic correspondence.**
+
+![teaser](assets/teaser.png)
+
+## Visual Results
+### Dense Correspondence
+<img src="assets/dense_correspondence.png" width="100%">
+
+### Object Swapping
+<div align="center">
+<img src="assets/swap_aero.gif" width="32%">
+<img src="assets/swap_bird.gif" width="32%">
+<img src="assets/swap_bus.gif" width="32%">
+</div>
+<div align="center">
+<img src="assets/swap_car.gif" width="32%">
+<img src="assets/swap_cow.gif" width="32%">
+<img src="assets/swap_dog.gif" width="32%">
+</div>
+<div align="center">
+<img src="assets/swap_person.gif" width="32%">
+<img src="assets/swap_sheep.gif" width="32%">
+<img src="assets/swap_train.gif" width="32%">
+</div>
+
+### Object Swapping (with refinement process)
+<div align="center">
+<img src="assets/instance_swapping_cat.png" width="49%">
+<img src="assets/instance_swapping_bird.png" width="49%">
+</div>
+
+## Links
+* [Project Page](https://sd-complements-dino.github.io) (with additional visual results)
+* [arXiv Page](https://arxiv.org/abs/2305.15347)
+
+## Environment Setup
+
+To install the required dependencies, use the following commands:
+
+```bash
+conda create -n sd-dino python=3.9
+conda activate sd-dino
+conda install pytorch=1.13.1 torchvision=0.14.1 pytorch-cuda=11.6 -c pytorch -c nvidia
+conda install -c "nvidia/label/cuda-11.6.1" libcusolver-dev
+git clone git@github.com:Junyi42/sd-dino.git 
+cd sd-dino
+pip install -e .
+```
+(Optional) You may also want to install [xformers](https://github.com/facebookresearch/xformers) for efficient transformer implementation:
+
+```
+pip install xformers==0.0.16
+```
+
+## Get Started
+
+### Prepare the data
+
+We provide the scripts to download the datasets in the `data` folder. To download specific datasets, use the following commands:
+
+* SPair-71k: 
+```bash
+bash data/prepare_spair.sh
+```
+* PF-Pascal: 
+```bash
+bash data/prepare_pfpascal.sh
+```
+* TSS: 
+```bash
+bash data/prepare_tss.sh
+```
+
+### Evaluate the PCK Results of SPair-71k
+
+
+Run [pck_spair_pascal.py](pck_spair_pascal.py) file: 
+
+```bash
+python pck_spair_pascal.py --SAMPLE 20
+```
+
+Note that the `SAMPLE` is the number of sampled pairs for each category, which is set to 20 by default. Set to `0` to use all the samples (settings in the paper).
+
+Additional important parameters in [pck_spair_pascal.py](pck_spair_pascal.py) include:
+
+* `--NOT_FUSE`: if set to True, only use the SD feature.
+* `--ONLY_DINO`: if set to True, only use the DINO feature.
+* `--DRAW_DENSE`: if set to True, draw the dense correspondence map.
+* `--DRAW_SWAP`: if set to True, draw the object swapping result.
+* `--DRAW_GIF`: if set to True, draw the object swapping result as a gif.
+* `--TOTAL_SAVE_RESULT`: number of samples to save the qualitative results, set to 0 to disable and accelerate the evaluation process.
+
+Please refer to the [pck_spair_pascal.py](pck_spair_pascal.py) file for more details. You may find samples of qualitative results in the `results_spair` folder.
+
+### Evaluate the PCK Results of PF-Pascal
+
+Run [pck_spair_pascal.py](pck_spair_pascal.py) file: 
+
+```bash
+python pck_spair_pascal.py --PASCAL
+```
+
+You may find samples of qualitative results in the `results_pascal` folder.
+
+### Evaluate the PCK Results of TSS
+
+Run [pck_tss.py](pck_tss.py) file: 
+
+```bash
+python pck_tss.py
+```
+
+You may find samples of qualitative results in the `results_tss` folder.
+
+## Demo
+
+### PCA / K-means Visualization of the Features
+
+To extract the fused features of the input pair images and visualize the correspondence,
+please check the notebook [demo_vis_features.ipynb](demo_vis_features.ipynb) for more details.
+
+### Quick Try on the Object Swapping
+
+To swap the objects in the input pair images, please check the notebook [demo_swap.ipynb](demo_swap.ipynb) for more details.
+
+### Refine the Result
+
+TODO
+
+## Citation
+
+If you find our work useful, please cite:
+
+```BiBTeX
+@article{zhang2023tale,
+  title={{A Tale of Two Features: Stable Diffusion Complements DINO for Zero-Shot Semantic Correspondence}},
+  author={Zhang, Junyi and Herrmann, Charles and Hur, Junhwa and Cabrera, Luisa Polania and Jampani, Varun and Sun, Deqing and Yang, Ming-Hsuan},
+  journal={arXiv preprint arxiv:2305.15347},
+  year={2023}
+}
+```
+
+## Acknowledgement
+
+Our code is largely based on the following open-source projects: [ODISE](https://github.com/NVlabs/ODISE), [dino-vit-features (official implementation)](https://github.com/ShirAmir/dino-vit-features), [dino-vit-features (Kamal Gupta's implementation)](https://github.com/kampta/dino-vit-features), [DenseMatching](https://github.com/PruneTruong/DenseMatching), and [ncnet](https://github.com/ignacio-rocco/ncnet). Our heartfelt gratitude goes to the developers of these resources!

Code/Baselines/sd-dino/demo_swap_proj_mot_clean.py

@@ -0,0 +1,499 @@
+import os
+path_example = '../../../Raw_datasets/uploaded/to_upload/chair_example'
+os.listdir('../../../Raw_datasets/uploaded/to_upload/chair_example')
+
+import imageio as imageio
+import numpy as np
+import matplotlib.pyplot as plt
+
+path_video = os.path.join(path_example, 'target_video_trim.mp4')
+
+reader = imageio.get_reader(path_video)
+frames = [frame for frame in reader]
+reader.close()
+print(f'Number of frames: {len(frames)}')
+
+# plot every 10th frame
+
+# for i in range(0, len(frames), 10):
+#     plt.imshow(frames[i])
+#     plt.axis('off')
+#     plt.title(f'Frame {i}')
+#     plt.show()# Uncomment to close the plot after saving
+
+# save the first frame as a jpg image
+imageio.imwrite(os.path.join(path_example, 'target_frame1.jpg'), frames[0])
+
+# check frame shape
+print(f'Frame shape: {frames[0].shape}')
+
+import os
+os.environ['CUDA_VISIBLE_DEVICES'] = '6'
+import torch
+import os
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+import torch.nn.functional as F
+import extractor_sd as extractor_sd
+from extractor_sd import load_model, process_features_and_mask, get_mask
+from utils.utils_correspondence import co_pca, resize, find_nearest_patchs, find_nearest_patchs_replace, animate_image_transfer_reverse
+import matplotlib.pyplot as plt
+from extractor_dino import ViTExtractor
+
+MASK = True
+VER = "v1-5"
+PCA = False
+CO_PCA = True
+PCA_DIMS = [256, 256, 256]
+SIZE =960
+RESOLUTION = 256
+EDGE_PAD = False
+
+FUSE_DINO = 1
+ONLY_DINO = 0
+DRAW_GIF=1
+DINOV2 = True
+MODEL_SIZE = 'base' # 'small' or 'base', indicate dinov2 model
+DRAW_DENSE = 1
+DRAW_SWAP = 1
+SWAP = 1
+TEXT_INPUT = False
+SEED = 42
+TIMESTEP = 100 #flexible from 0~200
+
+DIST = 'l2' if FUSE_DINO and not ONLY_DINO else 'cos'
+if ONLY_DINO:
+    FUSE_DINO = True
+
+
+np.random.seed(SEED)
+torch.manual_seed(SEED)
+torch.cuda.manual_seed(SEED)
+torch.backends.cudnn.benchmark = True
+
+# model, aug = load_model(diffusion_ver=VER, image_size=SIZE, num_timesteps=TIMESTEP)
+model, aug = load_model(diffusion_ver=VER, image_size=SIZE, num_timesteps=TIMESTEP, decoder_only=False)
+
+
+from utils.utils_correspondence import animate_image_transfer, animate_image_transfer_reverse
+
+from PIL import Image
+import torch
+import numpy as np
+import torchvision.transforms as T
+
+def apply_mask_to_image(image_pil, mask_tensor):
+    # Convert PIL image to tensor (C, H, W) in [0, 1]
+    image_tensor = T.ToTensor()(image_pil)  # Shape: (3, 840, 840)
+    
+    # Ensure mask is binary and shape (1, H, W)
+    if mask_tensor.ndim == 2:
+        mask_tensor = mask_tensor.unsqueeze(0)  # (1, 840, 840)
+    
+    # Apply mask to each channel
+    masked_image_tensor = image_tensor * mask_tensor
+
+    # Convert back to PIL image
+    masked_image_pil = T.ToPILImage()(masked_image_tensor)
+
+    return masked_image_pil
+
+
+def find_nearest_patchs_replace_mask_first(mask1, mask2, image1, image2, features1, features2, mask=False, resolution=128, draw_gif=False, save_path=None, gif_reverse=False):
+
+    # # mask 
+    # image1_mask = 
+
+    print('mask2 shape:', mask2.shape)
+    print('mask1 shape:', mask1.shape)
+    print('image1 shape:', image1.size) # image1 shape: (840, 840)
+    print('image2 shape:', image2.size) # image2 shape: (840, 840) PIL image
+
+    # mask out image_1 and image_2 in PIL format, image1 and image2 are PIL images, mask1 and mask2 are torch tensors
+    image1_mask = apply_mask_to_image(image1, mask1.cpu())
+    image2_mask = apply_mask_to_image(image2, mask2.cpu())
+
+    print('image1_mask shape:', image1_mask.size) # image1_mask shape: (840, 840)
+    print('image2_mask shape:', image2_mask.size) # image2_mask shape: (840, 840)
+
+    
+    if resolution is not None: # resize the feature map to the resolution
+        features1 = F.interpolate(features1, size=resolution, mode='bilinear')
+        features2 = F.interpolate(features2, size=resolution, mode='bilinear')
+    
+    # resize the image to the shape of the feature map
+    # resized_image1 = resize(image1, features1.shape[2], resize=True, to_pil=False)
+    # resized_image2 = resize(image2, features2.shape[2], resize=True, to_pil=False)
+    resized_image1 = resize(image1_mask, features1.shape[2], resize=True, to_pil=False)
+    resized_image2 = resize(image2_mask, features2.shape[2], resize=True, to_pil=False)
+
+    if mask: # mask the features
+        resized_mask1 = F.interpolate(mask1.cuda().unsqueeze(0).unsqueeze(0).float(), size=features1.shape[2:], mode='nearest')
+        resized_mask2 = F.interpolate(mask2.cuda().unsqueeze(0).unsqueeze(0).float(), size=features2.shape[2:], mode='nearest')
+        features1 = features1 * resized_mask1.repeat(1, features1.shape[1], 1, 1)
+        features2 = features2 * resized_mask2.repeat(1, features2.shape[1], 1, 1)
+        # set where mask==0 a very large number
+        features1[(features1.sum(1)==0).repeat(1, features1.shape[1], 1, 1)] = 100000
+        features2[(features2.sum(1)==0).repeat(1, features2.shape[1], 1, 1)] = 100000
+    
+    features1_2d = features1.reshape(features1.shape[1], -1).permute(1, 0)
+    features2_2d = features2.reshape(features2.shape[1], -1).permute(1, 0)
+
+    resized_image1 = torch.tensor(resized_image1).to("cuda").float()
+    resized_image2 = torch.tensor(resized_image2).to("cuda").float()
+
+    # mask1 = F.interpolate(mask1.cuda().unsqueeze(0).unsqueeze(0).float(), size=resized_image1.shape[:2], mode='nearest').squeeze(0).squeeze(0)
+    # mask2 = F.interpolate(mask2.cuda().unsqueeze(0).unsqueeze(0).float(), size=resized_image2.shape[:2], mode='nearest').squeeze(0).squeeze(0)
+
+    # Mask the images
+    # resized_image1 = resized_image1 * mask1.unsqueeze(-1).repeat(1, 1, 3)
+    # resized_image2 = resized_image2 * mask2.unsqueeze(-1).repeat(1, 1, 3)
+    # Normalize the images to the range [0, 1]
+    resized_image1 = (resized_image1 - resized_image1.min()) / (resized_image1.max() - resized_image1.min())
+    resized_image2 = (resized_image2 - resized_image2.min()) / (resized_image2.max() - resized_image2.min())
+
+    distances = torch.cdist(features1_2d, features2_2d)
+    nearest_patch_indices = torch.argmin(distances, dim=1)
+    nearest_patches = torch.index_select(resized_image2.cuda().clone().detach().reshape(-1, 3), 0, nearest_patch_indices)
+
+    nearest_patches_image = nearest_patches.reshape(resized_image1.shape)
+
+    if draw_gif:
+        assert save_path is not None, "save_path must be provided when draw_gif is True"
+        img_1 = resize(image1, features1.shape[2], resize=True, to_pil=True)
+        img_2 = resize(image2, features2.shape[2], resize=True, to_pil=True)
+        mapping = torch.zeros((img_1.size[1], img_1.size[0], 2))
+        for i in range(len(nearest_patch_indices)):
+            mapping[i // img_1.size[0], i % img_1.size[0]] = torch.tensor([nearest_patch_indices[i] // img_2.size[0], nearest_patch_indices[i] % img_2.size[0]])
+        animate_image_transfer(img_1, img_2, mapping, save_path) if gif_reverse else animate_image_transfer_reverse(img_1, img_2, mapping, save_path)
+
+    # TODO: upsample the nearest_patches_image to the resolution of the original image
+    # nearest_patches_image = F.interpolate(nearest_patches_image.permute(2,0,1).unsqueeze(0), size=256, mode='bilinear').squeeze(0).permute(1,2,0)
+    # resized_image2 = F.interpolate(resized_image2.permute(2,0,1).unsqueeze(0), size=256, mode='bilinear').squeeze(0).permute(1,2,0)
+
+    nearest_patches_image = (nearest_patches_image).cpu().numpy()
+    resized_image2 = (resized_image2).cpu().numpy()
+
+    return nearest_patches_image, resized_image2
+
+
+def compute_pair_feature(model, aug, save_path, files, category, mask=False, dist='cos', real_size=960):
+    if type(category) == str:
+        category = [category]
+    img_size = 840 if DINOV2 else 244
+    model_dict={'small':'dinov2_vits14',
+                'base':'dinov2_vitb14',
+                'large':'dinov2_vitl14',
+                'giant':'dinov2_vitg14'}
+    
+    model_type = model_dict[MODEL_SIZE] if DINOV2 else 'dino_vits8'
+    layer = 11 if DINOV2 else 9
+    if 'l' in model_type:
+        layer = 23
+    elif 'g' in model_type:
+        layer = 39
+    facet = 'token' if DINOV2 else 'key'
+    stride = 14 if DINOV2 else 4
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    # indiactor = 'v2' if DINOV2 else 'v1'
+    # model_size = model_type.split('vit')[-1]
+    extractor = ViTExtractor(model_type, stride, device=device)
+    patch_size = extractor.model.patch_embed.patch_size[0] if DINOV2 else extractor.model.patch_embed.patch_size
+    num_patches = int(patch_size / stride * (img_size // patch_size - 1) + 1)
+
+    print('patch_size:', patch_size)
+    print('num_patches:', num_patches)
+    
+    input_text = "a photo of "+category[-1][0] if TEXT_INPUT else None
+
+    N = len(files) // 2
+    pbar = tqdm(total=N)
+    result = []
+    for pair_idx in range(N):
+
+        # Load image 1
+        img1 = Image.open(files[2*pair_idx]).convert('RGB')
+        img1_input = resize(img1, real_size, resize=True, to_pil=True, edge=EDGE_PAD)
+        img1 = resize(img1, img_size, resize=True, to_pil=True, edge=EDGE_PAD)
+
+        # Load image 2
+        img2 = Image.open(files[2*pair_idx+1]).convert('RGB')
+        img2_input = resize(img2, real_size, resize=True, to_pil=True, edge=EDGE_PAD)
+        img2 = resize(img2, img_size, resize=True, to_pil=True, edge=EDGE_PAD)
+
+        with torch.no_grad():
+            if not CO_PCA:
+                if not ONLY_DINO:
+                    img1_desc = process_features_and_mask(model, aug, img1_input, input_text=input_text, mask=False, pca=PCA).reshape(1,1,-1, num_patches**2).permute(0,1,3,2)
+                    img2_desc = process_features_and_mask(model, aug, img2_input, category[-1], input_text=input_text,  mask=mask, pca=PCA).reshape(1,1,-1, num_patches**2).permute(0,1,3,2)
+                if FUSE_DINO:
+                    img1_batch = extractor.preprocess_pil(img1)
+                    img1_desc_dino = extractor.extract_descriptors(img1_batch.to(device), layer, facet)
+                    img2_batch = extractor.preprocess_pil(img2)
+                    img2_desc_dino = extractor.extract_descriptors(img2_batch.to(device), layer, facet)
+
+            else:
+                if not ONLY_DINO:
+                    features1 = process_features_and_mask(model, aug, img1_input, input_text=input_text,  mask=False, raw=True)
+                    features2 = process_features_and_mask(model, aug, img2_input, input_text=input_text,  mask=False, raw=True)
+
+                    
+                    processed_features1, processed_features2 = co_pca(features1, features2, PCA_DIMS)
+                    # print('processed_feautres1 shape:', processed_features1.shape) # torch.Size([1, 768, 60, 60])
+                    # print('processed_feautres2 shape:', processed_features2.shape) # torch.Size([1, 768, 60, 60])
+                    img1_desc = processed_features1.reshape(1, 1, -1, num_patches**2).permute(0,1,3,2)
+                    img2_desc = processed_features2.reshape(1, 1, -1, num_patches**2).permute(0,1,3,2)
+                if FUSE_DINO:
+                    img1_batch = extractor.preprocess_pil(img1)
+                    img1_desc_dino = extractor.extract_descriptors(img1_batch.to(device), layer, facet)
+                    img2_batch = extractor.preprocess_pil(img2)
+                    img2_desc_dino = extractor.extract_descriptors(img2_batch.to(device), layer, facet)
+
+                    # print('img1_desc_dino shape:', img1_desc_dino.shape) # torch.Size([1, 1, 3600, 768])
+                    # print('img2_desc_dino shape:', img2_desc_dino.shape) # torch.Size([1, 1, 3600, 768])
+                
+            if dist == 'l1' or dist == 'l2':
+                # normalize the features
+                img1_desc = img1_desc / img1_desc.norm(dim=-1, keepdim=True)
+                img2_desc = img2_desc / img2_desc.norm(dim=-1, keepdim=True)
+                if FUSE_DINO:
+                    img1_desc_dino = img1_desc_dino / img1_desc_dino.norm(dim=-1, keepdim=True)
+                    img2_desc_dino = img2_desc_dino / img2_desc_dino.norm(dim=-1, keepdim=True)
+
+            if FUSE_DINO and not ONLY_DINO:
+                # cat two features together
+                img1_desc = torch.cat((img1_desc, img1_desc_dino), dim=-1)
+                img2_desc = torch.cat((img2_desc, img2_desc_dino), dim=-1)
+
+            if ONLY_DINO:
+                img1_desc = img1_desc_dino
+                img2_desc = img2_desc_dino
+
+            if DRAW_DENSE:
+                mask1 = get_mask(model, aug, img1, category[0])
+                mask2 = get_mask(model, aug, img2, category[-1])
+
+                print('mask 1 shape:', mask1.shape) # torch.Size([840, 840])
+                print('mask 2 shape:', mask2.shape) # torch.Size([840, 840])
+                import matplotlib.pyplot as plt
+                fig_mask, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
+                ax1.axis('off')
+                ax2.axis('off')
+                # ax1.imshow(mask1.cpu().numpy())
+                # ax2.imshow(mask2.cpu().numpy())
+                ax1.imshow(img1)
+                ax1.contour(mask1.cpu().numpy(), colors='r', alpha=0.5)
+                ax2.imshow(img2)
+                ax2.contour(mask2.cpu().numpy(), colors='r', alpha=0.5)
+                plt.show()
+
+                if ONLY_DINO or not FUSE_DINO:
+                    img1_desc = img1_desc / img1_desc.norm(dim=-1, keepdim=True)
+                    img2_desc = img2_desc / img2_desc.norm(dim=-1, keepdim=True)
+                
+                img1_desc_reshaped = img1_desc.permute(0,1,3,2).reshape(-1, img1_desc.shape[-1], num_patches, num_patches)
+                img2_desc_reshaped = img2_desc.permute(0,1,3,2).reshape(-1, img2_desc.shape[-1], num_patches, num_patches)
+                trg_dense_output, src_color_map = find_nearest_patchs(mask2, mask1, img2, img1, img2_desc_reshaped, img1_desc_reshaped, mask=mask)
+
+                if not os.path.exists(f'{save_path}/{category[0]}'):
+                    os.makedirs(f'{save_path}/{category[0]}')
+                import matplotlib.pyplot as plt
+                fig_colormap, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
+                ax1.axis('off')
+                ax2.axis('off')
+                ax1.imshow(src_color_map)
+                ax2.imshow(trg_dense_output)
+                fig_colormap.savefig(f'{save_path}/{category[0]}/{pair_idx}_colormap.png')
+
+                print('src_color_map shape:', src_color_map.shape) # (60, 60, 3)
+                print('trg_dense_output shape:', trg_dense_output.shape) # (60, 60, 3)
+                plt.close(fig_colormap)
+            
+            if DRAW_SWAP:
+                if not DRAW_DENSE:
+
+                    print('I am getting the masks for swap')
+                    mask1 = get_mask(model, aug, img1, category[0])
+                    mask2 = get_mask(model, aug, img2, category[-1])
+
+                    import matplotlib.pyplot as plt
+                    fig_mask, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
+                    ax1.axis('off')
+                    ax2.axis('off')
+                    # ax1.imshow(mask1.cpu().numpy())
+                    # ax2.imshow(mask2.cpu().numpy())
+                    # overlay the masks on the images
+                    ax1.imshow(img1)
+                    ax1.contour(mask1.cpu().numpy(), colors='r', alpha=0.5)
+                    ax2.imshow(img2)
+                    ax2.contour(mask2.cpu().numpy(), colors='r', alpha=0.5)
+                    plt.show()
+                    print(torch.max(mask1), torch.min(mask1), torch.max(mask2), torch.min(mask2))
+
+                if (ONLY_DINO or not FUSE_DINO) and not DRAW_DENSE:
+                    img1_desc = img1_desc / img1_desc.norm(dim=-1, keepdim=True)
+                    img2_desc = img2_desc / img2_desc.norm(dim=-1, keepdim=True)
+                
+                print('img1_desc shape:', img1_desc.shape) # torch.Size([1, 1, 3600, 1536])
+                print('img2_desc shape:', img2_desc.shape) # torch.Size([1, 1, 3600, 1536])
+                    
+                img1_desc_reshaped = img1_desc.permute(0,1,3,2).reshape(-1, img1_desc.shape[-1], num_patches, num_patches)
+                img2_desc_reshaped = img2_desc.permute(0,1,3,2).reshape(-1, img2_desc.shape[-1], num_patches, num_patches)
+
+                print('img1_desc_reshaped shape:', img1_desc_reshaped.shape) # torch.Size([1, 1536, 60, 60])
+                print('img2_desc_reshaped shape:', img2_desc_reshaped.shape) # torch.Size([1, 1536, 60, 60])
+                trg_dense_output, src_color_map = find_nearest_patchs_replace_mask_first(mask2, mask1, img2, img1, img2_desc_reshaped, img1_desc_reshaped, mask=mask, resolution=156) # 156 max resolution find_nearest_patchs_replace
+
+                if not os.path.exists(f'{save_path}/{category[0]}'):
+                    os.makedirs(f'{save_path}/{category[0]}')
+                fig_colormap, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
+                ax1.axis('off')
+                ax2.axis('off')
+                ax1.imshow(src_color_map)
+                ax2.imshow(trg_dense_output)
+
+                print('src_color_map shape:', src_color_map.shape) # (156, 156, 3)
+                print('trg_dense_output shape:', trg_dense_output.shape) # (156, 156, 3)
+                fig_colormap.savefig(f'{save_path}/{category[0]}/{pair_idx}_swap.png')
+                plt.close(fig_colormap)
+            if not DRAW_SWAP and not DRAW_DENSE:
+                result.append([img1_desc.cpu(), img2_desc.cpu()])
+            else:
+                result.append([img1_desc.cpu(), img2_desc.cpu(), mask1.cpu(), mask2.cpu()])
+
+    pbar.update(1)
+    return result
+
+
+import matplotlib.pyplot as plt
+
+def process_images_mask_first(src_img_path,trg_img_path,categories):
+
+    files = [src_img_path, trg_img_path]
+    # save_path = './results_swap' + f'/{trg_img_path.split("/")[-1].split(".")[0]}_{src_img_path.split("/")[-1].split(".")[0]}'
+    save_path = './results_swap/video_demo/'
+    if not os.path.exists(save_path):
+        os.makedirs(save_path)
+
+    # print('save_path:', save_path)
+
+    result = compute_pair_feature(model, aug, save_path, files, mask=MASK, category=categories, dist=DIST)
+    
+    if SWAP:
+        # high resolution swap, will take the instance of interest from the target image and replace it in the source image
+        for (feature2,feature1,mask2,mask1) in result:
+
+            print('feature1 shape:', feature1.shape) # torch.Size([1, 1, 3600, 1536])
+            print('feature2 shape:', feature2.shape) # torch.Size([1, 1, 3600, 1536])
+            print('mask1 shape:', mask1.shape) # torch.Size([840, 840])
+            print('mask2 shape:', mask2.shape) # torch.Size([840, 840])
+
+            src_feature_reshaped = feature1.squeeze().permute(1,0).reshape(1,-1,60,60).cuda()
+            tgt_feature_reshaped = feature2.squeeze().permute(1,0).reshape(1,-1,60,60).cuda()
+            src_img=Image.open(trg_img_path) # image which contains an object to be replaced
+            tgt_img=Image.open(src_img_path) # object of interest
+            
+            patch_size = RESOLUTION # the resolution of the output image, set to 256 could be faster
+
+            # plt.imshow(mask1.cpu().numpy())
+            # plt.show()
+
+            # plt.imshow(mask2.cpu().numpy())
+            # plt.show()
+            src_img = resize(src_img, 840, resize=True, to_pil=True, edge=EDGE_PAD)
+            tgt_img = resize(tgt_img, 840, resize=True, to_pil=True, edge=EDGE_PAD)
+            
+            src_img_mask = apply_mask_to_image(src_img, mask1.cpu())
+            tgt_img_mask = apply_mask_to_image(tgt_img, mask2.cpu())
+            print('src_img_mask shape:', src_img_mask.size) # src_img_mask shape: (840, 840)
+            print('tgt_img_mask shape:', tgt_img_mask.size) # tgt_img_mask shape: (840, 840)
+            
+            src_img = resize(src_img, patch_size, resize=True, to_pil=False, edge=EDGE_PAD)
+            # tgt_img = resize(tgt_img, patch_size, resize=True, to_pil=False, edge=EDGE_PAD)
+            src_img_mask = resize(src_img_mask, patch_size, resize=True, to_pil=False, edge=EDGE_PAD)
+            tgt_img_mask = resize(tgt_img_mask, patch_size, resize=True, to_pil=False, edge=EDGE_PAD)
+
+
+            resized_src_mask = F.interpolate(mask1.unsqueeze(0).unsqueeze(0), size=(patch_size, patch_size), mode='nearest').squeeze().cuda()
+            resized_tgt_mask = F.interpolate(mask2.unsqueeze(0).unsqueeze(0), size=(patch_size, patch_size), mode='nearest').squeeze().cuda()
+
+
+            src_feature_upsampled = F.interpolate(src_feature_reshaped, size=(patch_size, patch_size), mode='bilinear').squeeze()
+            tgt_feature_upsampled = F.interpolate(tgt_feature_reshaped, size=(patch_size, patch_size), mode='bilinear').squeeze()
+
+
+            src_feature_upsampled = src_feature_upsampled * resized_src_mask.repeat(src_feature_upsampled.shape[0],1,1)
+            tgt_feature_upsampled = tgt_feature_upsampled * resized_tgt_mask.repeat(src_feature_upsampled.shape[0],1,1)
+            
+
+            # Set the masked area to a very small number
+            src_feature_upsampled[src_feature_upsampled == 0] = -100000
+            tgt_feature_upsampled[tgt_feature_upsampled == 0] = -100000
+            # Calculate the cosine similarity between src_feature and tgt_feature
+            src_features_2d=src_feature_upsampled.reshape(src_feature_upsampled.shape[0],-1).permute(1,0)
+            tgt_features_2d=tgt_feature_upsampled.reshape(tgt_feature_upsampled.shape[0],-1).permute(1,0)
+            swapped_image=src_img
+            mapping = torch.zeros(patch_size,patch_size,2).cuda()
+            for patch_idx in tqdm(range(patch_size*patch_size)):
+                # If the patch is in the resized_src_mask_out_layers, find the corresponding patch in the target_output and swap them
+                if resized_src_mask[patch_idx // patch_size, patch_idx % patch_size] == 1:
+                    # Find the corresponding patch with the highest cosine similarity
+                    distances = torch.linalg.norm(tgt_features_2d - src_features_2d[patch_idx], dim=1)
+                    tgt_patch_idx = torch.argmin(distances)
+
+                    tgt_patch_row = tgt_patch_idx // patch_size
+                    tgt_patch_col = tgt_patch_idx % patch_size
+
+                    # Swap the patches in output
+                    swapped_image[patch_idx // patch_size, patch_idx % patch_size,:] = tgt_img_mask[tgt_patch_row, tgt_patch_col,:] #tgt_img[tgt_patch_row, tgt_patch_col,:]
+                    mapping[patch_idx // patch_size, patch_idx % patch_size] = torch.tensor([tgt_patch_row,tgt_patch_col])
+
+        # swapped_image=Image.fromarray(swapped_image)
+
+        print('swapped_image shape bf:', swapped_image.shape) # swapped_image shape: (patch_size, patch_size, 3)
+        
+        # only retain the masked area of the swapped image, resized_src_mask is tensor of shape (patch_size, patch_size), src_image and swapped image are numpy arrays of shape (patch_size, patch_size, 3)]
+        swapped_image = src_img * (1 - resized_src_mask.unsqueeze(-1).repeat(1, 1, 3).cpu().numpy()) + swapped_image * resized_src_mask.unsqueeze(-1).repeat(1, 1, 3).cpu().numpy()  # swap the masked area of the source image with the swapped image
+        swapped_image = swapped_image.astype(np.uint8)
+
+        print('swapped_image shape aft:', swapped_image.shape)
+
+        swapped_image = Image.fromarray(swapped_image)
+
+        # save the swapped image
+        # swapped_image = Image.from
+        
+        tgt_name = trg_img_path.split('/')[-1].split('.')[0]
+        # swapped_image.save(save_path+'/swapped_image.png')
+        swapped_image.save(save_path+f'/{tgt_name}_swapped_image.png')
+        if DRAW_GIF:
+            # animate_image_transfer_reverse(resize(Image.open(trg_img_path), patch_size, resize=True, to_pil=True, edge=EDGE_PAD),resize(Image.open(src_img_path), patch_size, resize=True, to_pil=True, edge=EDGE_PAD),mapping,save_path+'/warp_pixel.gif')
+            animate_image_transfer_reverse(resize(Image.open(trg_img_path), patch_size, resize=True, to_pil=True, edge=EDGE_PAD),resize(Image.open(src_img_path), patch_size, resize=True, to_pil=True, edge=EDGE_PAD),mapping,save_path+f'/{tgt_name}_warp_pixel.gif')
+        
+    return result
+
+
+# src_paths=[
+#             # "data/images/cat1.jpg",
+#             # "data/images/cat2.jpg",
+#             # "data/images/cat3.jpg",
+#             os.path.join(path_example, 'source_image.jpg')
+#            ]
+
+if __name__ == "__main__":
+
+    src_path = os.path.join(path_example, 'source_image.jpg')
+    SWAP=1
+    DRAW_GIF=1
+    RESOLUTION = 400 # resolution for swapped images, set to 512 to align with the paper
+    trg_img_paths = [os.path.join(path_example, f'target_video_trim_frames/target_frame_{i:04d}.jpg') for i in range(7, 67)] # 0,67
+    # for src_path in src_paths:
+    for trg_img_path in trg_img_paths:
+        src_img_path = src_path
+        # trg_img_path = "data/images/cat0.jpg"
+        # trg_img_path = os.path.join(path_example, 'target_frame1.jpg')
+        # trg_img_path = os.path.join(path_example, 'target_video_trim_frames/target_frame_0040.jpg')
+        categories = [['chair'], ['chair']]
+        # result = process_images(src_img_path, trg_img_path, categories)
+        result = process_images_mask_first(src_img_path, trg_img_path, categories)

Code/Baselines/sd-dino/extractor_dino.py

@@ -0,0 +1,387 @@
+import argparse
+import torch
+import torchvision.transforms
+from torch import nn
+from torchvision import transforms
+import torch.nn.modules.utils as nn_utils
+import math
+import timm
+import types
+from pathlib import Path
+from typing import Union, List, Tuple
+from PIL import Image
+
+
+class ViTExtractor:
+    """ This class facilitates extraction of features, descriptors, and saliency maps from a ViT.
+    We use the following notation in the documentation of the module's methods:
+    B - batch size
+    h - number of heads. usually takes place of the channel dimension in pytorch's convention BxCxHxW
+    p - patch size of the ViT. either 8 or 16.
+    t - number of tokens. equals the number of patches + 1, e.g. HW / p**2 + 1. Where H and W are the height and width
+    of the input image.
+    d - the embedding dimension in the ViT.
+    """
+
+    def __init__(self, model_type: str = 'dino_vits8', stride: int = 4, model: nn.Module = None, device: str = 'cuda'):
+        """
+        :param model_type: A string specifying the type of model to extract from.
+                          [dino_vits8 | dino_vits16 | dino_vitb8 | dino_vitb16 | vit_small_patch8_224 |
+                          vit_small_patch16_224 | vit_base_patch8_224 | vit_base_patch16_224]
+        :param stride: stride of first convolution layer. small stride -> higher resolution.
+        :param model: Optional parameter. The nn.Module to extract from instead of creating a new one in ViTExtractor.
+                      should be compatible with model_type.
+        """
+        self.model_type = model_type
+        self.device = device
+        if model is not None:
+            self.model = model
+        else:
+            self.model = ViTExtractor.create_model(model_type)
+
+        self.model = ViTExtractor.patch_vit_resolution(self.model, stride=stride)
+        self.model.eval()
+        self.model.to(self.device)
+        self.p = self.model.patch_embed.patch_size
+        if type(self.p)==tuple:
+            self.p = self.p[0]
+        self.stride = self.model.patch_embed.proj.stride
+
+        self.mean = (0.485, 0.456, 0.406) if "dino" in self.model_type else (0.5, 0.5, 0.5)
+        self.std = (0.229, 0.224, 0.225) if "dino" in self.model_type else (0.5, 0.5, 0.5)
+
+        self._feats = []
+        self.hook_handlers = []
+        self.load_size = None
+        self.num_patches = None
+
+    @staticmethod
+    def create_model(model_type: str) -> nn.Module:
+        """
+        :param model_type: a string specifying which model to load. [dino_vits8 | dino_vits16 | dino_vitb8 |
+                           dino_vitb16 | vit_small_patch8_224 | vit_small_patch16_224 | vit_base_patch8_224 |
+                           vit_base_patch16_224]
+        :return: the model
+        """
+        torch.hub._validate_not_a_forked_repo=lambda a,b,c: True
+        if 'v2' in model_type:
+            model = torch.hub.load('facebookresearch/dinov2', model_type)
+        elif 'dino' in model_type:
+            model = torch.hub.load('facebookresearch/dino:main', model_type)
+        else:  # model from timm -- load weights from timm to dino model (enables working on arbitrary size images).
+            temp_model = timm.create_model(model_type, pretrained=True)
+            model_type_dict = {
+            'vit_small_patch16_224': 'dino_vits16',
+            'vit_small_patch8_224': 'dino_vits8',
+            'vit_base_patch16_224': 'dino_vitb16',
+            'vit_base_patch8_224': 'dino_vitb8'
+            }
+            model = torch.hub.load('facebookresearch/dino:main', model_type_dict[model_type])
+            temp_state_dict = temp_model.state_dict()
+            del temp_state_dict['head.weight']
+            del temp_state_dict['head.bias']
+            model.load_state_dict(temp_state_dict)
+        return model
+
+    @staticmethod
+    def _fix_pos_enc(patch_size: int, stride_hw: Tuple[int, int]):
+        """
+        Creates a method for position encoding interpolation.
+        :param patch_size: patch size of the model.
+        :param stride_hw: A tuple containing the new height and width stride respectively.
+        :return: the interpolation method
+        """
+        def interpolate_pos_encoding(self, x: torch.Tensor, w: int, h: int) -> torch.Tensor:
+            npatch = x.shape[1] - 1
+            N = self.pos_embed.shape[1] - 1
+            if npatch == N and w == h:
+                return self.pos_embed
+            class_pos_embed = self.pos_embed[:, 0]
+            patch_pos_embed = self.pos_embed[:, 1:]
+            dim = x.shape[-1]
+            # compute number of tokens taking stride into account
+            w0 = 1 + (w - patch_size) // stride_hw[1]
+            h0 = 1 + (h - patch_size) // stride_hw[0]
+            assert (w0 * h0 == npatch), f"""got wrong grid size for {h}x{w} with patch_size {patch_size} and 
+                                            stride {stride_hw} got {h0}x{w0}={h0 * w0} expecting {npatch}"""
+            # we add a small number to avoid floating point error in the interpolation
+            # see discussion at https://github.com/facebookresearch/dino/issues/8
+            w0, h0 = w0 + 0.1, h0 + 0.1
+            patch_pos_embed = nn.functional.interpolate(
+                patch_pos_embed.reshape(1, int(math.sqrt(N)), int(math.sqrt(N)), dim).permute(0, 3, 1, 2),
+                scale_factor=(w0 / math.sqrt(N), h0 / math.sqrt(N)),
+                mode='bicubic',
+                align_corners=False, recompute_scale_factor=False
+            )
+            assert int(w0) == patch_pos_embed.shape[-2] and int(h0) == patch_pos_embed.shape[-1]
+            patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+            return torch.cat((class_pos_embed.unsqueeze(0), patch_pos_embed), dim=1)
+
+        return interpolate_pos_encoding
+
+    @staticmethod
+    def patch_vit_resolution(model: nn.Module, stride: int) -> nn.Module:
+        """
+        change resolution of model output by changing the stride of the patch extraction.
+        :param model: the model to change resolution for.
+        :param stride: the new stride parameter.
+        :return: the adjusted model
+        """
+        patch_size = model.patch_embed.patch_size
+        if type(patch_size) == tuple:
+            patch_size = patch_size[0]
+        if stride == patch_size:  # nothing to do
+            return model
+
+        stride = nn_utils._pair(stride)
+        assert all([(patch_size // s_) * s_ == patch_size for s_ in
+                    stride]), f'stride {stride} should divide patch_size {patch_size}'
+
+        # fix the stride
+        model.patch_embed.proj.stride = stride
+        # fix the positional encoding code
+        model.interpolate_pos_encoding = types.MethodType(ViTExtractor._fix_pos_enc(patch_size, stride), model)
+        return model
+
+    def preprocess(self, image_path: Union[str, Path],
+                   load_size: Union[int, Tuple[int, int]] = None, patch_size: int = 14) -> Tuple[torch.Tensor, Image.Image]:
+        """
+        Preprocesses an image before extraction.
+        :param image_path: path to image to be extracted.
+        :param load_size: optional. Size to resize image before the rest of preprocessing.
+        :return: a tuple containing:
+                    (1) the preprocessed image as a tensor to insert the model of shape BxCxHxW.
+                    (2) the pil image in relevant dimensions
+        """
+        def divisible_by_num(num, dim):
+            return num * (dim // num)
+        pil_image = Image.open(image_path).convert('RGB')
+        if load_size is not None:
+            pil_image = transforms.Resize(load_size, interpolation=transforms.InterpolationMode.LANCZOS)(pil_image)
+
+            width, height = pil_image.size
+            new_width = divisible_by_num(patch_size, width)
+            new_height = divisible_by_num(patch_size, height)
+            pil_image = pil_image.resize((new_width, new_height), resample=Image.LANCZOS)
+            
+        prep = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize(mean=self.mean, std=self.std)
+        ])
+        prep_img = prep(pil_image)[None, ...]
+        return prep_img, pil_image
+
+    def preprocess_pil(self, pil_image):
+        """
+        Preprocesses an image before extraction.
+        :param image_path: path to image to be extracted.
+        :param load_size: optional. Size to resize image before the rest of preprocessing.
+        :return: a tuple containing:
+                    (1) the preprocessed image as a tensor to insert the model of shape BxCxHxW.
+                    (2) the pil image in relevant dimensions
+        """
+        prep = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize(mean=self.mean, std=self.std)
+        ])
+        prep_img = prep(pil_image)[None, ...]
+        return prep_img
+
+    def _get_hook(self, facet: str):
+        """
+        generate a hook method for a specific block and facet.
+        """
+        if facet in ['attn', 'token']:
+            def _hook(model, input, output):
+                self._feats.append(output)
+            return _hook
+
+        if facet == 'query':
+            facet_idx = 0
+        elif facet == 'key':
+            facet_idx = 1
+        elif facet == 'value':
+            facet_idx = 2
+        else:
+            raise TypeError(f"{facet} is not a supported facet.")
+
+        def _inner_hook(module, input, output):
+            input = input[0]
+            B, N, C = input.shape
+            qkv = module.qkv(input).reshape(B, N, 3, module.num_heads, C // module.num_heads).permute(2, 0, 3, 1, 4)
+            self._feats.append(qkv[facet_idx]) #Bxhxtxd
+        return _inner_hook
+
+    def _register_hooks(self, layers: List[int], facet: str) -> None:
+        """
+        register hook to extract features.
+        :param layers: layers from which to extract features.
+        :param facet: facet to extract. One of the following options: ['key' | 'query' | 'value' | 'token' | 'attn']
+        """
+        for block_idx, block in enumerate(self.model.blocks):
+            if block_idx in layers:
+                if facet == 'token':
+                    self.hook_handlers.append(block.register_forward_hook(self._get_hook(facet)))
+                elif facet == 'attn':
+                    self.hook_handlers.append(block.attn.attn_drop.register_forward_hook(self._get_hook(facet)))
+                elif facet in ['key', 'query', 'value']:
+                    self.hook_handlers.append(block.attn.register_forward_hook(self._get_hook(facet)))
+                else:
+                    raise TypeError(f"{facet} is not a supported facet.")
+
+    def _unregister_hooks(self) -> None:
+        """
+        unregisters the hooks. should be called after feature extraction.
+        """
+        for handle in self.hook_handlers:
+            handle.remove()
+        self.hook_handlers = []
+
+    def _extract_features(self, batch: torch.Tensor, layers: List[int] = 11, facet: str = 'key') -> List[torch.Tensor]:
+        """
+        extract features from the model
+        :param batch: batch to extract features for. Has shape BxCxHxW.
+        :param layers: layer to extract. A number between 0 to 11.
+        :param facet: facet to extract. One of the following options: ['key' | 'query' | 'value' | 'token' | 'attn']
+        :return : tensor of features.
+                  if facet is 'key' | 'query' | 'value' has shape Bxhxtxd
+                  if facet is 'attn' has shape Bxhxtxt
+                  if facet is 'token' has shape Bxtxd
+        """
+        B, C, H, W = batch.shape
+        self._feats = []
+        self._register_hooks(layers, facet)
+        _ = self.model(batch)
+        self._unregister_hooks()
+        self.load_size = (H, W)
+        self.num_patches = (1 + (H - self.p) // self.stride[0], 1 + (W - self.p) // self.stride[1])
+        return self._feats
+
+    def _log_bin(self, x: torch.Tensor, hierarchy: int = 2) -> torch.Tensor:
+        """
+        create a log-binned descriptor.
+        :param x: tensor of features. Has shape Bxhxtxd.
+        :param hierarchy: how many bin hierarchies to use.
+        """
+        B = x.shape[0]
+        num_bins = 1 + 8 * hierarchy
+
+        bin_x = x.permute(0, 2, 3, 1).flatten(start_dim=-2, end_dim=-1)  # Bx(t-1)x(dxh)
+        bin_x = bin_x.permute(0, 2, 1)
+        bin_x = bin_x.reshape(B, bin_x.shape[1], self.num_patches[0], self.num_patches[1])
+        # Bx(dxh)xnum_patches[0]xnum_patches[1]
+        sub_desc_dim = bin_x.shape[1]
+
+        avg_pools = []
+        # compute bins of all sizes for all spatial locations.
+        for k in range(0, hierarchy):
+            # avg pooling with kernel 3**kx3**k
+            win_size = 3 ** k
+            avg_pool = torch.nn.AvgPool2d(win_size, stride=1, padding=win_size // 2, count_include_pad=False)
+            avg_pools.append(avg_pool(bin_x))
+
+        bin_x = torch.zeros((B, sub_desc_dim * num_bins, self.num_patches[0], self.num_patches[1])).to(self.device)
+        for y in range(self.num_patches[0]):
+            for x in range(self.num_patches[1]):
+                part_idx = 0
+                # fill all bins for a spatial location (y, x)
+                for k in range(0, hierarchy):
+                    kernel_size = 3 ** k
+                    for i in range(y - kernel_size, y + kernel_size + 1, kernel_size):
+                        for j in range(x - kernel_size, x + kernel_size + 1, kernel_size):
+                            if i == y and j == x and k != 0:
+                                continue
+                            if 0 <= i < self.num_patches[0] and 0 <= j < self.num_patches[1]:
+                                bin_x[:, part_idx * sub_desc_dim: (part_idx + 1) * sub_desc_dim, y, x] = avg_pools[k][
+                                                                                                           :, :, i, j]
+                            else:  # handle padding in a more delicate way than zero padding
+                                temp_i = max(0, min(i, self.num_patches[0] - 1))
+                                temp_j = max(0, min(j, self.num_patches[1] - 1))
+                                bin_x[:, part_idx * sub_desc_dim: (part_idx + 1) * sub_desc_dim, y, x] = avg_pools[k][
+                                                                                                           :, :, temp_i,
+                                                                                                           temp_j]
+                            part_idx += 1
+        bin_x = bin_x.flatten(start_dim=-2, end_dim=-1).permute(0, 2, 1).unsqueeze(dim=1)
+        # Bx1x(t-1)x(dxh)
+        return bin_x
+
+    def extract_descriptors(self, batch: torch.Tensor, layer: int = 11, facet: str = 'key',
+                            bin: bool = False, include_cls: bool = False) -> torch.Tensor:
+        """
+        extract descriptors from the model
+        :param batch: batch to extract descriptors for. Has shape BxCxHxW.
+        :param layers: layer to extract. A number between 0 to 11.
+        :param facet: facet to extract. One of the following options: ['key' | 'query' | 'value' | 'token']
+        :param bin: apply log binning to the descriptor. default is False.
+        :return: tensor of descriptors. Bx1xtxd' where d' is the dimension of the descriptors.
+        """
+        assert facet in ['key', 'query', 'value', 'token'], f"""{facet} is not a supported facet for descriptors. 
+                                                             choose from ['key' | 'query' | 'value' | 'token'] """
+        self._extract_features(batch, [layer], facet)
+        x = self._feats[0]
+        if facet == 'token':
+            x.unsqueeze_(dim=1) #Bx1xtxd
+        if not include_cls:
+            x = x[:, :, 1:, :]  # remove cls token
+        else:
+            assert not bin, "bin = True and include_cls = True are not supported together, set one of them False."
+        if not bin:
+            desc = x.permute(0, 2, 3, 1).flatten(start_dim=-2, end_dim=-1).unsqueeze(dim=1)  # Bx1xtx(dxh)
+        else:
+            desc = self._log_bin(x)
+        return desc
+
+    def extract_saliency_maps(self, batch: torch.Tensor) -> torch.Tensor:
+        """
+        extract saliency maps. The saliency maps are extracted by averaging several attention heads from the last layer
+        in of the CLS token. All values are then normalized to range between 0 and 1.
+        :param batch: batch to extract saliency maps for. Has shape BxCxHxW.
+        :return: a tensor of saliency maps. has shape Bxt-1
+        """
+        assert self.model_type == "dino_vits8", f"saliency maps are supported only for dino_vits model_type."
+        self._extract_features(batch, [11], 'attn')
+        head_idxs = [0, 2, 4, 5]
+        curr_feats = self._feats[0] #Bxhxtxt
+        cls_attn_map = curr_feats[:, head_idxs, 0, 1:].mean(dim=1) #Bx(t-1)
+        temp_mins, temp_maxs = cls_attn_map.min(dim=1)[0], cls_attn_map.max(dim=1)[0]
+        cls_attn_maps = (cls_attn_map - temp_mins) / (temp_maxs - temp_mins)  # normalize to range [0,1]
+        return cls_attn_maps
+
+""" taken from https://stackoverflow.com/questions/15008758/parsing-boolean-values-with-argparse"""
+def str2bool(v):
+    if isinstance(v, bool):
+        return v
+    if v.lower() in ('yes', 'true', 't', 'y', '1'):
+        return True
+    elif v.lower() in ('no', 'false', 'f', 'n', '0'):
+        return False
+    else:
+        raise argparse.ArgumentTypeError('Boolean value expected.')
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Facilitate ViT Descriptor extraction.')
+    parser.add_argument('--image_path', type=str, required=True, help='path of the extracted image.')
+    parser.add_argument('--output_path', type=str, required=True, help='path to file containing extracted descriptors.')
+    parser.add_argument('--load_size', default=224, type=int, help='load size of the input image.')
+    parser.add_argument('--stride', default=4, type=int, help="""stride of first convolution layer. 
+                                                              small stride -> higher resolution.""")
+    parser.add_argument('--model_type', default='dino_vits8', type=str,
+                        help="""type of model to extract. 
+                        Choose from [dino_vits8 | dino_vits16 | dino_vitb8 | dino_vitb16 | vit_small_patch8_224 | 
+                        vit_small_patch16_224 | vit_base_patch8_224 | vit_base_patch16_224]""")
+    parser.add_argument('--facet', default='key', type=str, help="""facet to create descriptors from. 
+                                                                    options: ['key' | 'query' | 'value' | 'token']""")
+    parser.add_argument('--layer', default=11, type=int, help="layer to create descriptors from.")
+    parser.add_argument('--bin', default='False', type=str2bool, help="create a binned descriptor if True.")
+    parser.add_argument('--patch_size', default=14, type=int, help="patch size of the model.")
+    args = parser.parse_args()
+
+    with torch.no_grad():
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        extractor = ViTExtractor(args.model_type, args.stride, device=device)
+        image_batch, image_pil = extractor.preprocess(args.image_path, args.load_size, args.patch_size)
+        print(f"Image {args.image_path} is preprocessed to tensor of size {image_batch.shape}.")
+        descriptors = extractor.extract_descriptors(image_batch.to(device), args.layer, args.facet, args.bin)
+        print(f"Descriptors are of size: {descriptors.shape}")
+        torch.save(descriptors, args.output_path)
+        print(f"Descriptors saved to: {args.output_path}")

Code/Baselines/sd-dino/extractor_sd.py

@@ -0,0 +1,410 @@
+import itertools
+from contextlib import ExitStack
+import torch
+from mask2former.data.datasets.register_ade20k_panoptic import ADE20K_150_CATEGORIES
+from PIL import Image
+import numpy as np
+import torch.nn.functional as F
+from detectron2.config import instantiate
+from detectron2.data import MetadataCatalog
+from detectron2.data import detection_utils as utils
+from detectron2.config import LazyCall as L
+from detectron2.data import transforms as T
+from detectron2.data.datasets.builtin_meta import COCO_CATEGORIES
+from detectron2.evaluation import inference_context
+from detectron2.utils.env import seed_all_rng
+from detectron2.utils.visualizer import ColorMode, Visualizer, random_color
+from detectron2.utils.logger import setup_logger
+
+from odise import model_zoo
+from odise.checkpoint import ODISECheckpointer
+from odise.config import instantiate_odise
+from odise.data import get_openseg_labels
+from odise.modeling.wrapper import OpenPanopticInference
+
+from utils.utils_correspondence import resize
+import faiss
+
+COCO_THING_CLASSES = [
+    label
+    for idx, label in enumerate(get_openseg_labels("coco_panoptic", True))
+    if COCO_CATEGORIES[idx]["isthing"] == 1
+]
+COCO_THING_COLORS = [c["color"] for c in COCO_CATEGORIES if c["isthing"] == 1]
+COCO_STUFF_CLASSES = [
+    label
+    for idx, label in enumerate(get_openseg_labels("coco_panoptic", True))
+    if COCO_CATEGORIES[idx]["isthing"] == 0
+]
+COCO_STUFF_COLORS = [c["color"] for c in COCO_CATEGORIES if c["isthing"] == 0]
+
+ADE_THING_CLASSES = [
+    label
+    for idx, label in enumerate(get_openseg_labels("ade20k_150", True))
+    if ADE20K_150_CATEGORIES[idx]["isthing"] == 1
+]
+ADE_THING_COLORS = [c["color"] for c in ADE20K_150_CATEGORIES if c["isthing"] == 1]
+ADE_STUFF_CLASSES = [
+    label
+    for idx, label in enumerate(get_openseg_labels("ade20k_150", True))
+    if ADE20K_150_CATEGORIES[idx]["isthing"] == 0
+]
+ADE_STUFF_COLORS = [c["color"] for c in ADE20K_150_CATEGORIES if c["isthing"] == 0]
+
+LVIS_CLASSES = get_openseg_labels("lvis_1203", True)
+# use beautiful coco colors
+LVIS_COLORS = list(
+    itertools.islice(itertools.cycle([c["color"] for c in COCO_CATEGORIES]), len(LVIS_CLASSES))
+)
+
+
+class StableDiffusionSeg(object):
+    def __init__(self, model, metadata, aug, instance_mode=ColorMode.IMAGE):
+        """
+        Args:
+            model (nn.Module):
+            metadata (MetadataCatalog): image metadata.
+            instance_mode (ColorMode):
+            parallel (bool): whether to run the model in different processes from visualization.
+                Useful since the visualization logic can be slow.
+        """
+        self.model = model
+        self.metadata = metadata
+        self.aug = aug
+        self.cpu_device = torch.device("cpu")
+        self.instance_mode = instance_mode
+
+    def get_features(self, original_image, caption=None, pca=None):
+        """
+        Args:
+            original_image (np.ndarray): an image of shape (H, W, C) (in BGR order).
+
+        Returns:
+            features (dict):
+                the output of the model for one image only.
+        """
+        height, width = original_image.shape[:2]
+        aug_input = T.AugInput(original_image, sem_seg=None)
+        self.aug(aug_input)
+        image = aug_input.image
+        image = torch.as_tensor(image.astype("float32").transpose(2, 0, 1))
+
+        inputs = {"image": image, "height": height, "width": width}
+        if caption is not None:
+            features = self.model.get_features([inputs],caption,pca=pca)
+        else:
+            features = self.model.get_features([inputs],pca=pca)
+        return features
+    
+    def predict(self, original_image):
+        """
+        Args:
+            original_image (np.ndarray): an image of shape (H, W, C) (in BGR order).
+
+        Returns:
+            predictions (dict):
+                the output of the model for one image only.
+                See :doc:`/tutorials/models` for details about the format.
+        """
+        height, width = original_image.shape[:2]
+        aug_input = T.AugInput(original_image, sem_seg=None)
+        self.aug(aug_input)
+        image = aug_input.image
+        image = torch.as_tensor(image.astype("float32").transpose(2, 0, 1))
+
+        inputs = {"image": image, "height": height, "width": width}
+        predictions = self.model([inputs])[0]
+        return predictions
+
+def build_demo_classes_and_metadata(vocab, label_list):
+    extra_classes = []
+
+    if vocab:
+        for words in vocab.split(";"):
+            extra_classes.append([word.strip() for word in words.split(",")])
+    extra_colors = [random_color(rgb=True, maximum=1) for _ in range(len(extra_classes))]
+
+    demo_thing_classes = extra_classes
+    demo_stuff_classes = []
+    demo_thing_colors = extra_colors
+    demo_stuff_colors = []
+
+    if "COCO" in label_list:
+        demo_thing_classes += COCO_THING_CLASSES
+        demo_stuff_classes += COCO_STUFF_CLASSES
+        demo_thing_colors += COCO_THING_COLORS
+        demo_stuff_colors += COCO_STUFF_COLORS
+    if "ADE" in label_list:
+        demo_thing_classes += ADE_THING_CLASSES
+        demo_stuff_classes += ADE_STUFF_CLASSES
+        demo_thing_colors += ADE_THING_COLORS
+        demo_stuff_colors += ADE_STUFF_COLORS
+    if "LVIS" in label_list:
+        demo_thing_classes += LVIS_CLASSES
+        demo_thing_colors += LVIS_COLORS
+
+    MetadataCatalog.pop("odise_demo_metadata", None)
+    demo_metadata = MetadataCatalog.get("odise_demo_metadata")
+    demo_metadata.thing_classes = [c[0] for c in demo_thing_classes]
+    demo_metadata.stuff_classes = [
+        *demo_metadata.thing_classes,
+        *[c[0] for c in demo_stuff_classes],
+    ]
+    demo_metadata.thing_colors = demo_thing_colors
+    demo_metadata.stuff_colors = demo_thing_colors + demo_stuff_colors
+    demo_metadata.stuff_dataset_id_to_contiguous_id = {
+        idx: idx for idx in range(len(demo_metadata.stuff_classes))
+    }
+    demo_metadata.thing_dataset_id_to_contiguous_id = {
+        idx: idx for idx in range(len(demo_metadata.thing_classes))
+    }
+
+    demo_classes = demo_thing_classes + demo_stuff_classes
+
+    return demo_classes, demo_metadata
+
+import sys
+
+
+def load_model(config_path="Panoptic/odise_label_coco_50e.py", seed=42, diffusion_ver="v1-3", image_size=1024, num_timesteps=0, block_indices=(2,5,8,11), decoder_only=True, encoder_only=False, resblock_only=False):
+    cfg = model_zoo.get_config(config_path, trained=True)
+
+    cfg.model.backbone.feature_extractor.init_checkpoint = "sd://"+diffusion_ver
+    cfg.model.backbone.feature_extractor.steps = (num_timesteps,)
+    cfg.model.backbone.feature_extractor.unet_block_indices = block_indices
+    cfg.model.backbone.feature_extractor.encoder_only = encoder_only
+    cfg.model.backbone.feature_extractor.decoder_only = decoder_only
+    cfg.model.backbone.feature_extractor.resblock_only = resblock_only
+    cfg.model.overlap_threshold = 0
+    seed_all_rng(seed)
+
+    cfg.dataloader.test.mapper.augmentations=[
+            L(T.ResizeShortestEdge)(short_edge_length=image_size, sample_style="choice", max_size=2560),
+        ]
+    dataset_cfg = cfg.dataloader.test
+
+    aug = instantiate(dataset_cfg.mapper).augmentations
+
+    model = instantiate_odise(cfg.model)
+    model.to(cfg.train.device)
+    ODISECheckpointer(model).load(cfg.train.init_checkpoint)
+
+    return model, aug
+
+def inference(model, aug, image, vocab, label_list):
+
+    demo_classes, demo_metadata = build_demo_classes_and_metadata(vocab, label_list)
+    with ExitStack() as stack:
+        inference_model = OpenPanopticInference(
+            model=model,
+            labels=demo_classes,
+            metadata=demo_metadata,
+            semantic_on=False,
+            instance_on=False,
+            panoptic_on=True,
+        )
+        stack.enter_context(inference_context(inference_model))
+        stack.enter_context(torch.no_grad())
+
+        demo = StableDiffusionSeg(inference_model, demo_metadata, aug)
+        pred = demo.predict(np.array(image))
+        return (pred, demo_classes)
+    
+def get_features(model, aug, image, vocab, label_list, caption=None, pca=False):
+    
+    demo_classes, demo_metadata = build_demo_classes_and_metadata(vocab, label_list)
+    with ExitStack() as stack:
+        inference_model = OpenPanopticInference(
+            model=model,
+            labels=demo_classes,
+            metadata=demo_metadata,
+            semantic_on=False,
+            instance_on=False,
+            panoptic_on=True,
+        )
+        stack.enter_context(inference_context(inference_model))
+        stack.enter_context(torch.no_grad())
+
+        demo = StableDiffusionSeg(inference_model, demo_metadata, aug)
+        if caption is not None:
+            features = demo.get_features(np.array(image), caption, pca=pca)
+        else:
+            features = demo.get_features(np.array(image), pca=pca)
+        return features
+
+
+def pca_process(features):
+    # Get the feature tensors
+    size_s5=features['s5'].shape[-1]
+    size_s4=features['s4'].shape[-1]
+    size_s3=features['s3'].shape[-1]
+
+    print(f"Original shapes: s5: {features['s5'].shape}, s4: {features['s4'].shape}, s3: {features['s3'].shape}")
+
+    s5 = features['s5'].reshape(features['s5'].shape[0], features['s5'].shape[1], -1)
+    s4 = features['s4'].reshape(features['s4'].shape[0], features['s4'].shape[1], -1)
+    s3 = features['s3'].reshape(features['s3'].shape[0], features['s3'].shape[1], -1)
+
+    print(f"Reshaped tensors: s5: {s5.shape}, s4: {s4.shape}, s3: {s3.shape}")
+
+    # Define the target dimensions
+    target_dims = {'s5': 128, 's4': 128, 's3': 128}
+
+    # Apply PCA to each tensor using Faiss CPU
+    for name, tensor in zip(['s5', 's4', 's3'], [s5, s4, s3]):
+        target_dim = target_dims[name]
+
+        # Transpose the tensor so that the last dimension is the number of features
+        tensor = tensor.permute(0, 2, 1)
+
+        # # Norm the tensor
+        # tensor = tensor / tensor.norm(dim=-1, keepdim=True)
+
+        # Initialize a Faiss PCA object
+        pca = faiss.PCAMatrix(tensor.shape[-1], target_dim)
+
+        # Train the PCA object
+        pca.train(tensor[0].cpu().numpy())
+
+        # Apply PCA to the data
+        transformed_tensor_np = pca.apply(tensor[0].cpu().numpy())
+
+        # Convert the transformed data back to a tensor
+        transformed_tensor = torch.tensor(transformed_tensor_np, device=tensor.device).unsqueeze(0)
+
+        # Store the transformed tensor in the features dictionary
+        features[name] = transformed_tensor
+    
+    # print(f"Transformed shapes: s5: {features['s5'].shape}, s4: {features['s4'].shape}, s3: {features['s3'].shape}") 
+    # # s5: torch.Size([1, 256, 225]), s4: torch.Size([1, 256, 900]), s3: torch.Size([1, 256, 3600])
+
+    # Reshape the tensors back to their original shapes
+    features['s5'] = features['s5'].permute(0, 2, 1).reshape(features['s5'].shape[0], -1, size_s5, size_s5)
+    features['s4'] = features['s4'].permute(0, 2, 1).reshape(features['s4'].shape[0], -1, size_s4, size_s4)
+    features['s3'] = features['s3'].permute(0, 2, 1).reshape(features['s3'].shape[0], -1, size_s3, size_s3)
+    # Upsample s5 spatially by a factor of 2
+    upsampled_s5 = torch.nn.functional.interpolate(features['s5'], scale_factor=2, mode='bilinear', align_corners=False)
+
+    print(f"features['s5'] shape after upsampling: {upsampled_s5.shape}")
+
+    # Concatenate upsampled_s5 and s4 to create a new s5
+    features['s5'] = torch.cat((upsampled_s5, features['s4']), dim=1)
+
+    print(f"features['s5'] shape after concatenation: {features['s5'].shape}")
+
+    # Set s3 as the new s4
+    features['s4'] = features['s3']
+
+    # Remove s3 from the features dictionary
+    del features['s3']
+    
+    return features
+    
+
+def process_features_and_mask(model, aug, image, category=None, input_text=None, mask=True, pca=False, raw=False):
+
+    input_image = image
+    caption = input_text
+    vocab = ""
+    label_list = ["COCO"]
+    category_convert_dict={
+        'aeroplane':'airplane',
+        'motorbike':'motorcycle',
+        'pottedplant':'potted plant',
+        'tvmonitor':'tv',
+    }
+    if type(category) is not list and category in category_convert_dict:
+        category=category_convert_dict[category]
+    elif type(category) is list:
+        category=[category_convert_dict[cat] if cat in category_convert_dict else cat for cat in category]
+    features = get_features(model, aug, input_image, vocab, label_list, caption, pca=(pca or raw))
+    if pca:
+        features = pca_process(features)
+    if raw:
+        # print("features['s5'].shape, features['s4'].shape, features['s3'].shape)", features['s5'].shape, features['s4'].shape, features['s3'].shape)
+        # torch.Size([1, 2560, 15, 15]) torch.Size([1, 1920, 30, 30]) torch.Size([1, 960, 60, 60])
+        return features
+    
+    features_gether_s4_s5 = torch.cat([features['s4'], F.interpolate(features['s5'], size=(features['s4'].shape[-2:]), mode='bilinear')], dim=1)
+    
+    if mask:
+        (pred,classes) =inference(model, aug, input_image, vocab, label_list)
+        seg_map=pred['panoptic_seg'][0]
+        target_mask_id = []
+        for item in pred['panoptic_seg'][1]:
+            item['category_name']=classes[item['category_id']]
+            if category in item['category_name']:
+                target_mask_id.append(item['id'])
+        resized_seg_map_s4 = F.interpolate(seg_map.unsqueeze(0).unsqueeze(0).float(), 
+                                    size=(features['s4'].shape[-2:]), mode='nearest')
+        # to do adjust size
+        binary_seg_map = torch.zeros_like(resized_seg_map_s4)
+        for i in target_mask_id:
+            binary_seg_map += (resized_seg_map_s4 == i).float()
+        if len(target_mask_id) == 0 or binary_seg_map.sum() < 6:
+            binary_seg_map = torch.ones_like(resized_seg_map_s4)
+        features_gether_s4_s5 = features_gether_s4_s5 * binary_seg_map
+        # set where mask is 0 to inf
+        features_gether_s4_s5[(binary_seg_map == 0).repeat(1,features_gether_s4_s5.shape[1],1,1)] = -1
+    
+    # print(f"final features_gether_s4_s5 shape: {features_gether_s4_s5.shape}")
+
+    return features_gether_s4_s5
+
+def get_mask(model, aug, image, category=None, input_text=None):
+    model.backbone.feature_extractor.decoder_only = False
+    model.backbone.feature_extractor.encoder_only = False
+    model.backbone.feature_extractor.resblock_only = False
+    input_image = image
+    caption = input_text
+    vocab = ""
+    label_list = ["COCO"]
+    category_convert_dict={
+        'aeroplane':'airplane',
+        'motorbike':'motorcycle',
+        'pottedplant':'potted plant',
+        'tvmonitor':'tv',
+    }
+    if type(category) is not list and category in category_convert_dict:
+        category=category_convert_dict[category]
+    elif type(category) is list:
+        category=[category_convert_dict[cat] if cat in category_convert_dict else cat for cat in category]
+
+    (pred,classes) =inference(model, aug, input_image, vocab, label_list)
+    seg_map=pred['panoptic_seg'][0]
+    target_mask_id = []
+    for item in pred['panoptic_seg'][1]:
+        item['category_name']=classes[item['category_id']]
+        if type(category) is list:
+            for cat in category:
+                if cat in item['category_name']:
+                    target_mask_id.append(item['id'])
+        else:
+            if category in item['category_name']:
+                target_mask_id.append(item['id'])
+    resized_seg_map_s4 = seg_map.float()
+    binary_seg_map = torch.zeros_like(resized_seg_map_s4)
+    for i in target_mask_id:
+        binary_seg_map += (resized_seg_map_s4 == i).float()
+    if len(target_mask_id) == 0 or binary_seg_map.sum() < 6:
+        binary_seg_map = torch.ones_like(resized_seg_map_s4)
+
+    return binary_seg_map
+
+if __name__ == "__main__":
+    image_path = sys.argv[1]
+    try:
+        input_text = sys.argv[2]
+    except:
+        input_text = None
+
+    model, aug = load_model()
+    img_size = 960
+    image = Image.open(image_path).convert('RGB')
+    image = resize(image, img_size, resize=True, to_pil=True)
+
+    features = process_features_and_mask(model, aug, image, category=input_text, pca=False, raw=True)
+    features = features['s4'] # save the features of layer 5
+    
+    # save the features
+    np.save(image_path[:-4]+'.npy', features.cpu().numpy())

Code/Baselines/sd-dino/pck_spair_pascal.py

@@ -0,0 +1,575 @@
+import os
+import sys
+import torch
+torch.set_num_threads(16)
+import os
+import pandas as pd
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+import torch.nn.functional as F
+import json
+from glob import glob
+from utils.utils_correspondence import pairwise_sim, draw_correspondences_gathered, chunk_cosine_sim, co_pca, resize, find_nearest_patchs, find_nearest_patchs_replace, draw_correspondences_lines
+import matplotlib.pyplot as plt
+import sys
+import time
+from utils.logger import get_logger
+from loguru import logger
+import argparse
+from extractor_dino import ViTExtractor
+from extractor_sd import load_model, process_features_and_mask, get_mask
+
+def preprocess_kps_pad(kps, img_width, img_height, size):
+    # Once an image has been pre-processed via border (or zero) padding,
+    # the location of key points needs to be updated. This function applies
+    # that pre-processing to the key points so they are correctly located
+    # in the border-padded (or zero-padded) image.
+    kps = kps.clone()
+    scale = size / max(img_width, img_height)
+    kps[:, [0, 1]] *= scale
+    if img_height < img_width:
+        new_h = int(np.around(size * img_height / img_width))
+        offset_y = int((size - new_h) / 2)
+        offset_x = 0
+        kps[:, 1] += offset_y
+    elif img_width < img_height:
+        new_w = int(np.around(size * img_width / img_height))
+        offset_x = int((size - new_w) / 2)
+        offset_y = 0
+        kps[:, 0] += offset_x
+    else:
+        offset_x = 0
+        offset_y = 0
+    if not COUNT_INVIS:
+        kps *= kps[:, 2:3].clone()  # zero-out any non-visible key points
+    return kps, offset_x, offset_y, scale
+
+def load_spair_data(path, size=256, category='cat', split='test', subsample=None):
+    np.random.seed(SEED)
+    pairs = sorted(glob(f'{path}/PairAnnotation/{split}/*:{category}.json'))
+    if subsample is not None and subsample > 0:
+        pairs = [pairs[ix] for ix in np.random.choice(len(pairs), subsample)]
+    logger.info(f'Number of SPairs for {category} = {len(pairs)}')
+    files = []
+    thresholds = []
+    category_anno = list(glob(f'{path}/ImageAnnotation/{category}/*.json'))[0]
+    with open(category_anno) as f:
+        num_kps = len(json.load(f)['kps'])
+    logger.info(f'Number of SPair key points for {category} <= {num_kps}')
+    kps = []
+    blank_kps = torch.zeros(num_kps, 3)
+    for pair in pairs:
+        with open(pair) as f:
+            data = json.load(f)
+        assert category == data["category"]
+        assert data["mirror"] == 0
+        source_fn = f'{path}/JPEGImages/{category}/{data["src_imname"]}'
+        target_fn = f'{path}/JPEGImages/{category}/{data["trg_imname"]}'
+        source_bbox = np.asarray(data["src_bndbox"])
+        target_bbox = np.asarray(data["trg_bndbox"])
+        # The source thresholds aren't actually used to evaluate PCK on SPair-71K, but for completeness
+        # they are computed as well:
+        # thresholds.append(max(source_bbox[3] - source_bbox[1], source_bbox[2] - source_bbox[0]))
+        # thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0]))
+
+        source_size = data["src_imsize"][:2]  # (W, H)
+        target_size = data["trg_imsize"][:2]  # (W, H)
+
+        kp_ixs = torch.tensor([int(id) for id in data["kps_ids"]]).view(-1, 1).repeat(1, 3)
+        source_raw_kps = torch.cat([torch.tensor(data["src_kps"], dtype=torch.float), torch.ones(kp_ixs.size(0), 1)], 1)
+        source_kps = blank_kps.scatter(dim=0, index=kp_ixs, src=source_raw_kps)
+        source_kps, src_x, src_y, src_scale = preprocess_kps_pad(source_kps, source_size[0], source_size[1], size)
+        
+        target_raw_kps = torch.cat([torch.tensor(data["trg_kps"], dtype=torch.float), torch.ones(kp_ixs.size(0), 1)], 1)
+        target_kps = blank_kps.scatter(dim=0, index=kp_ixs, src=target_raw_kps)
+        target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(target_kps, target_size[0], target_size[1], size)
+        
+        thresholds.append(max(target_bbox[3] - target_bbox[1], target_bbox[2] - target_bbox[0])*trg_scale)
+
+        kps.append(source_kps)
+        kps.append(target_kps)
+        files.append(source_fn)
+        files.append(target_fn)
+
+    kps = torch.stack(kps)
+    used_kps, = torch.where(kps[:, :, 2].any(dim=0))
+    kps = kps[:, used_kps, :]
+    logger.info(f'Final number of used key points: {kps.size(1)}')
+    return files, kps, thresholds
+
+def load_pascal_data(path, size=256, category='cat', split='test', subsample=None):
+    
+    def get_points(point_coords_list, idx):
+        X = np.fromstring(point_coords_list.iloc[idx, 0], sep=";")
+        Y = np.fromstring(point_coords_list.iloc[idx, 1], sep=";")
+        Xpad = -np.ones(20)
+        Xpad[: len(X)] = X
+        Ypad = -np.ones(20)
+        Ypad[: len(X)] = Y
+        Zmask = np.zeros(20)
+        Zmask[: len(X)] = 1
+        point_coords = np.concatenate(
+            (Xpad.reshape(1, 20), Ypad.reshape(1, 20), Zmask.reshape(1,20)), axis=0
+        )
+        # make arrays float tensor for subsequent processing
+        point_coords = torch.Tensor(point_coords.astype(np.float32))
+        return point_coords
+    
+    np.random.seed(SEED)
+    files = []
+    kps = []
+    test_data = pd.read_csv(f'{path}/{split}_pairs_pf_pascal.csv')
+    cls = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle',
+                    'bus', 'car', 'cat', 'chair', 'cow',
+                    'diningtable', 'dog', 'horse', 'motorbike', 'person',
+                    'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']
+    cls_ids = test_data.iloc[:,2].values.astype("int") - 1
+    cat_id = cls.index(category)
+    subset_id = np.where(cls_ids == cat_id)[0]
+    logger.info(f'Number of SPairs for {category} = {len(subset_id)}')
+    subset_pairs = test_data.iloc[subset_id,:]
+    src_img_names = np.array(subset_pairs.iloc[:,0])
+    trg_img_names = np.array(subset_pairs.iloc[:,1])
+    # print(src_img_names.shape, trg_img_names.shape)
+    point_A_coords = subset_pairs.iloc[:,3:5]
+    point_B_coords = subset_pairs.iloc[:,5:]
+    # print(point_A_coords.shape, point_B_coords.shape)
+    for i in range(len(src_img_names)):
+        point_coords_src = get_points(point_A_coords, i).transpose(1,0)
+        point_coords_trg = get_points(point_B_coords, i).transpose(1,0)
+        src_fn= f'{path}/../{src_img_names[i]}'
+        trg_fn= f'{path}/../{trg_img_names[i]}'
+        src_size=Image.open(src_fn).size
+        trg_size=Image.open(trg_fn).size
+        # print(src_size)
+        source_kps, src_x, src_y, src_scale = preprocess_kps_pad(point_coords_src, src_size[0], src_size[1], size)
+        target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(point_coords_trg, trg_size[0], trg_size[1], size)
+        kps.append(source_kps)
+        kps.append(target_kps)
+        files.append(src_fn)
+        files.append(trg_fn)
+    
+    kps = torch.stack(kps)
+    used_kps, = torch.where(kps[:, :, 2].any(dim=0))
+    kps = kps[:, used_kps, :]
+    logger.info(f'Final number of used key points: {kps.size(1)}')
+    return files, kps, None
+
+def compute_pck(model, aug, save_path, files, kps, category, mask=False, dist='cos', thresholds=None, real_size=960):
+    
+    img_size = 840 if DINOV2 else 224 if ONLY_DINO else 480
+    model_dict={'small':'dinov2_vits14',
+                'base':'dinov2_vitb14',
+                'large':'dinov2_vitl14',
+                'giant':'dinov2_vitg14'}
+    
+    model_type = model_dict[MODEL_SIZE] if DINOV2 else 'dino_vits8'
+    layer = 11 if DINOV2 else 9
+    if 'l' in model_type:
+        layer = 23
+    elif 'g' in model_type:
+        layer = 39
+    facet = 'token' if DINOV2 else 'key'
+    stride = 14 if DINOV2 else 4 if ONLY_DINO else 8
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    # indiactor = 'v2' if DINOV2 else 'v1'
+    # model_size = model_type.split('vit')[-1]
+    extractor = ViTExtractor(model_type, stride, device=device)
+    patch_size = extractor.model.patch_embed.patch_size[0] if DINOV2 else extractor.model.patch_embed.patch_size
+    num_patches = int(patch_size / stride * (img_size // patch_size - 1) + 1)
+    
+    input_text = "a photo of "+category if TEXT_INPUT else None
+
+    current_save_results = 0
+    gt_correspondences = []
+    pred_correspondences = []
+    if thresholds is not None:
+        thresholds = torch.tensor(thresholds).to(device)
+        bbox_size=[]
+    N = len(files) // 2
+    pbar = tqdm(total=N)
+
+    for pair_idx in range(N):
+        # Load image 1
+        img1 = Image.open(files[2*pair_idx]).convert('RGB')
+        img1_input = resize(img1, real_size, resize=True, to_pil=True, edge=EDGE_PAD)
+        img1 = resize(img1, img_size, resize=True, to_pil=True, edge=EDGE_PAD)
+        img1_kps = kps[2*pair_idx]
+
+        # Get patch index for the keypoints
+        img1_y, img1_x = img1_kps[:, 1].numpy(), img1_kps[:, 0].numpy()
+        img1_y_patch = (num_patches / img_size * img1_y).astype(np.int32)
+        img1_x_patch = (num_patches / img_size * img1_x).astype(np.int32)
+        img1_patch_idx = num_patches * img1_y_patch + img1_x_patch
+
+        # Load image 2
+        img2 = Image.open(files[2*pair_idx+1]).convert('RGB')
+        img2_input = resize(img2, real_size, resize=True, to_pil=True, edge=EDGE_PAD)
+        img2 = resize(img2, img_size, resize=True, to_pil=True, edge=EDGE_PAD)
+        img2_kps = kps[2*pair_idx+1]
+
+        # Get patch index for the keypoints
+        img2_y, img2_x = img2_kps[:, 1].numpy(), img2_kps[:, 0].numpy()
+        img2_y_patch = (num_patches / img_size * img2_y).astype(np.int32)
+        img2_x_patch = (num_patches / img_size * img2_x).astype(np.int32)
+        img2_patch_idx = num_patches * img2_y_patch + img2_x_patch
+
+
+        with torch.no_grad():
+            if not CO_PCA:
+                if not ONLY_DINO:
+                    img1_desc = process_features_and_mask(model, aug, img1_input, input_text=input_text, mask=False).reshape(1,1,-1, num_patches**2).permute(0,1,3,2)
+                    img2_desc = process_features_and_mask(model, aug, img2_input, category, input_text=input_text,  mask=mask).reshape(1,1,-1, num_patches**2).permute(0,1,3,2)
+                if FUSE_DINO:
+                    img1_batch = extractor.preprocess_pil(img1)
+                    img1_desc_dino = extractor.extract_descriptors(img1_batch.to(device), layer, facet)
+                    img2_batch = extractor.preprocess_pil(img2)
+                    img2_desc_dino = extractor.extract_descriptors(img2_batch.to(device), layer, facet)
+
+            else:
+                if not ONLY_DINO:
+                    features1 = process_features_and_mask(model, aug, img1_input, input_text=input_text,  mask=False, raw=True)
+                    features2 = process_features_and_mask(model, aug, img2_input, input_text=input_text,  mask=False, raw=True)
+                    if not RAW:
+                        processed_features1, processed_features2 = co_pca(features1, features2, PCA_DIMS)
+                    else:
+                        if WEIGHT[0]:
+                            processed_features1 = features1['s5']
+                            processed_features2 = features2['s5']
+                        elif WEIGHT[1]:
+                            processed_features1 = features1['s4']
+                            processed_features2 = features2['s4']
+                        elif WEIGHT[2]:
+                            processed_features1 = features1['s3']
+                            processed_features2 = features2['s3']
+                        elif WEIGHT[3]:
+                            processed_features1 = features1['s2']
+                            processed_features2 = features2['s2']
+                        else:
+                            raise NotImplementedError
+                        # rescale the features
+                        processed_features1 = F.interpolate(processed_features1, size=(num_patches, num_patches), mode='bilinear', align_corners=False)
+                        processed_features2 = F.interpolate(processed_features2, size=(num_patches, num_patches), mode='bilinear', align_corners=False)
+
+                    img1_desc = processed_features1.reshape(1, 1, -1, num_patches**2).permute(0,1,3,2)
+                    img2_desc = processed_features2.reshape(1, 1, -1, num_patches**2).permute(0,1,3,2)
+                if FUSE_DINO:
+                    img1_batch = extractor.preprocess_pil(img1)
+                    img1_desc_dino = extractor.extract_descriptors(img1_batch.to(device), layer, facet)
+                    img2_batch = extractor.preprocess_pil(img2)
+                    img2_desc_dino = extractor.extract_descriptors(img2_batch.to(device), layer, facet)
+            
+            if CO_PCA_DINO:
+                cat_desc_dino = torch.cat((img1_desc_dino, img2_desc_dino), dim=2).squeeze() # (1, 1, num_patches**2, dim)
+                mean = torch.mean(cat_desc_dino, dim=0, keepdim=True)
+                centered_features = cat_desc_dino - mean
+                U, S, V = torch.pca_lowrank(centered_features, q=CO_PCA_DINO)
+                reduced_features = torch.matmul(centered_features, V[:, :CO_PCA_DINO]) # (t_x+t_y)x(d)
+                processed_co_features = reduced_features.unsqueeze(0).unsqueeze(0)
+                img1_desc_dino = processed_co_features[:, :, :img1_desc_dino.shape[2], :]
+                img2_desc_dino = processed_co_features[:, :, img1_desc_dino.shape[2]:, :]
+
+            if not ONLY_DINO and not RAW: # reweight different layers of sd
+
+                img1_desc[...,:PCA_DIMS[0]]*=WEIGHT[0]
+                img1_desc[...,PCA_DIMS[0]:PCA_DIMS[1]+PCA_DIMS[0]]*=WEIGHT[1]
+                img1_desc[...,PCA_DIMS[1]+PCA_DIMS[0]:PCA_DIMS[2]+PCA_DIMS[1]+PCA_DIMS[0]]*=WEIGHT[2]
+
+                img2_desc[...,:PCA_DIMS[0]]*=WEIGHT[0]
+                img2_desc[...,PCA_DIMS[0]:PCA_DIMS[1]+PCA_DIMS[0]]*=WEIGHT[1]
+                img2_desc[...,PCA_DIMS[1]+PCA_DIMS[0]:PCA_DIMS[2]+PCA_DIMS[1]+PCA_DIMS[0]]*=WEIGHT[2]
+
+            if 'l1' in dist or 'l2' in dist or dist == 'plus_norm':
+                # normalize the features
+                img1_desc = img1_desc / img1_desc.norm(dim=-1, keepdim=True)
+                img2_desc = img2_desc / img2_desc.norm(dim=-1, keepdim=True)
+                img1_desc_dino = img1_desc_dino / img1_desc_dino.norm(dim=-1, keepdim=True)
+                img2_desc_dino = img2_desc_dino / img2_desc_dino.norm(dim=-1, keepdim=True)
+
+            if FUSE_DINO and not ONLY_DINO and dist!='plus' and dist!='plus_norm':
+                # cat two features together
+                img1_desc = torch.cat((img1_desc, img1_desc_dino), dim=-1)
+                img2_desc = torch.cat((img2_desc, img2_desc_dino), dim=-1)
+                if not RAW:
+                    # reweight sd and dino
+                    img1_desc[...,:PCA_DIMS[2]+PCA_DIMS[1]+PCA_DIMS[0]]*=WEIGHT[3]
+                    img1_desc[...,PCA_DIMS[2]+PCA_DIMS[1]+PCA_DIMS[0]:]*=WEIGHT[4]
+                    img2_desc[...,:PCA_DIMS[2]+PCA_DIMS[1]+PCA_DIMS[0]]*=WEIGHT[3]
+                    img2_desc[...,PCA_DIMS[2]+PCA_DIMS[1]+PCA_DIMS[0]:]*=WEIGHT[4]
+
+            elif dist=='plus' or dist=='plus_norm':
+                img1_desc = img1_desc + img1_desc_dino
+                img2_desc = img2_desc + img2_desc_dino
+                dist='cos'
+            
+            if ONLY_DINO:
+                img1_desc = img1_desc_dino
+                img2_desc = img2_desc_dino
+            # logger.info(img1_desc.shape, img2_desc.shape)
+
+            if DRAW_DENSE:
+                mask1 = get_mask(model, aug, img1, category)
+                mask2 = get_mask(model, aug, img2, category)
+
+                if ONLY_DINO or not FUSE_DINO:
+                    img1_desc = img1_desc / img1_desc.norm(dim=-1, keepdim=True)
+                    img2_desc = img2_desc / img2_desc.norm(dim=-1, keepdim=True)
+                
+                img1_desc_reshaped = img1_desc.permute(0,1,3,2).reshape(-1, img1_desc.shape[-1], num_patches, num_patches)
+                img2_desc_reshaped = img2_desc.permute(0,1,3,2).reshape(-1, img2_desc.shape[-1], num_patches, num_patches)
+                trg_dense_output, src_color_map = find_nearest_patchs(mask2, mask1, img2, img1, img2_desc_reshaped, img1_desc_reshaped, mask=mask, resolution=128)
+                if current_save_results!=TOTAL_SAVE_RESULT:
+                    if not os.path.exists(f'{save_path}/{category}'):
+                        os.makedirs(f'{save_path}/{category}')
+                    fig_colormap, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
+                    ax1.axis('off')
+                    ax2.axis('off')
+                    ax1.imshow(src_color_map)
+                    ax2.imshow(trg_dense_output)
+                    fig_colormap.savefig(f'{save_path}/{category}/{pair_idx}_colormap.png')
+                    plt.close(fig_colormap)
+            
+            if DRAW_SWAP:
+                if not DRAW_DENSE:
+                    mask1 = get_mask(model, aug, img1, category)
+                    mask2 = get_mask(model, aug, img2, category)
+
+                if ONLY_DINO or not FUSE_DINO:
+                    img1_desc = img1_desc / img1_desc.norm(dim=-1, keepdim=True)
+                    img2_desc = img2_desc / img2_desc.norm(dim=-1, keepdim=True)
+                    
+                img1_desc_reshaped = img1_desc.permute(0,1,3,2).reshape(-1, img1_desc.shape[-1], num_patches, num_patches)
+                img2_desc_reshaped = img2_desc.permute(0,1,3,2).reshape(-1, img2_desc.shape[-1], num_patches, num_patches)
+                trg_dense_output, src_color_map = find_nearest_patchs_replace(mask2, mask1, img2, img1, img2_desc_reshaped, img1_desc_reshaped, mask=mask, resolution=156, draw_gif=DRAW_GIF, save_path=f'{save_path}/{category}/{pair_idx}_swap.gif')
+                if current_save_results!=TOTAL_SAVE_RESULT:
+                    if not os.path.exists(f'{save_path}/{category}'):
+                        os.makedirs(f'{save_path}/{category}')
+                    fig_colormap, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
+                    ax1.axis('off')
+                    ax2.axis('off')
+                    ax1.imshow(src_color_map)
+                    ax2.imshow(trg_dense_output)
+                    fig_colormap.savefig(f'{save_path}/{category}/{pair_idx}_swap.png')
+                    plt.close(fig_colormap)
+
+        if MASK and CO_PCA:
+            mask2 = get_mask(model, aug, img2, category)
+            img2_desc = img2_desc.permute(0,1,3,2).reshape(-1, img2_desc.shape[-1], num_patches, num_patches)
+            resized_mask2 = F.interpolate(mask2.cuda().unsqueeze(0).unsqueeze(0).float(), size=(num_patches, num_patches), mode='nearest')
+            img2_desc = img2_desc * resized_mask2.repeat(1, img2_desc.shape[1], 1, 1)
+            img2_desc[(img2_desc.sum(dim=1)==0).repeat(1, img2_desc.shape[1], 1, 1)] = 100000
+            # reshape back
+            img2_desc = img2_desc.reshape(1, 1, img2_desc.shape[1], num_patches*num_patches).permute(0,1,3,2)
+
+        # Get mutual visibility
+        vis = img1_kps[:, 2] * img2_kps[:, 2] > 0
+        if COUNT_INVIS:
+            vis = torch.ones_like(vis)
+        # Get similarity matrix
+        if dist == 'cos':
+            sim_1_to_2 = chunk_cosine_sim(img1_desc, img2_desc).squeeze()
+        elif dist == 'l2':
+            sim_1_to_2 = pairwise_sim(img1_desc, img2_desc, p=2).squeeze()
+        elif dist == 'l1':
+            sim_1_to_2 = pairwise_sim(img1_desc, img2_desc, p=1).squeeze()
+        elif dist == 'l2_norm':
+            sim_1_to_2 = pairwise_sim(img1_desc, img2_desc, p=2, normalize=True).squeeze()
+        elif dist == 'l1_norm':
+            sim_1_to_2 = pairwise_sim(img1_desc, img2_desc, p=1, normalize=True).squeeze()
+        else:
+            raise ValueError('Unknown distance metric')
+
+        # Get nearest neighors
+        nn_1_to_2 = torch.argmax(sim_1_to_2[img1_patch_idx], dim=1)
+        nn_y_patch, nn_x_patch = nn_1_to_2 // num_patches, nn_1_to_2 % num_patches
+        nn_x = (nn_x_patch - 1) * stride + stride + patch_size // 2 - .5
+        nn_y = (nn_y_patch - 1) * stride + stride + patch_size // 2 - .5
+        kps_1_to_2 = torch.stack([nn_x, nn_y]).permute(1, 0)
+
+        gt_correspondences.append(img2_kps[vis][:, [1,0]])
+        pred_correspondences.append(kps_1_to_2[vis][:, [1,0]])
+        if thresholds is not None:
+            bbox_size.append(thresholds[pair_idx].repeat(vis.sum()))
+        
+        if current_save_results!=TOTAL_SAVE_RESULT:
+            tmp_alpha = torch.tensor([0.1, 0.05, 0.01])
+            if thresholds is not None:
+                tmp_bbox_size = thresholds[pair_idx].repeat(vis.sum()).cpu()
+                tmp_threshold = tmp_alpha.unsqueeze(-1) * tmp_bbox_size.unsqueeze(0)
+            else:
+                tmp_threshold = tmp_alpha * img_size
+            if not os.path.exists(f'{save_path}/{category}'):
+                os.makedirs(f'{save_path}/{category}')
+            # fig=draw_correspondences_gathered(img1_kps[vis][:, [1,0]], kps_1_to_2[vis][:, [1,0]], img1, img2)
+            fig=draw_correspondences_lines(img1_kps[vis][:, [1,0]], kps_1_to_2[vis][:, [1,0]], img2_kps[vis][:, [1,0]], img1, img2, tmp_threshold)
+            fig.savefig(f'{save_path}/{category}/{pair_idx}_pred.png')
+            fig_gt=draw_correspondences_gathered(img1_kps[vis][:, [1,0]], img2_kps[vis][:, [1,0]], img1, img2)
+            fig_gt.savefig(f'{save_path}/{category}/{pair_idx}_gt.png')
+            plt.close(fig)
+            plt.close(fig_gt)
+            current_save_results+=1
+
+        pbar.update(1)
+
+    gt_correspondences = torch.cat(gt_correspondences, dim=0).cpu()
+    pred_correspondences = torch.cat(pred_correspondences, dim=0).cpu()
+    alpha = torch.tensor([0.1, 0.05, 0.01]) if not PASCAL else torch.tensor([0.1, 0.05, 0.15])
+    correct = torch.zeros(len(alpha))
+
+    err = (pred_correspondences - gt_correspondences).norm(dim=-1)
+    err = err.unsqueeze(0).repeat(len(alpha), 1)
+    if thresholds is not None:
+        bbox_size = torch.cat(bbox_size, dim=0).cpu()
+        threshold = alpha.unsqueeze(-1) * bbox_size.unsqueeze(0)
+        correct = err < threshold
+    else:
+        threshold = alpha * img_size
+        correct = err < threshold.unsqueeze(-1)
+
+    correct = correct.sum(dim=-1) / len(gt_correspondences)
+
+    alpha2pck = zip(alpha.tolist(), correct.tolist())
+    logger.info(' | '.join([f'PCK-Transfer@{alpha:.2f}: {pck_alpha * 100:.2f}%'
+                    for alpha, pck_alpha in alpha2pck]))
+
+    return correct
+
+def main(args):
+    global MASK, SAMPLE, DIST, COUNT_INVIS, TOTAL_SAVE_RESULT, BBOX_THRE, VER, CO_PCA, PCA_DIMS, SIZE, FUSE_DINO, DINOV2, MODEL_SIZE, DRAW_DENSE, TEXT_INPUT, DRAW_SWAP, ONLY_DINO, SEED, EDGE_PAD, WEIGHT, CO_PCA_DINO, PASCAL, DRAW_GIF, RAW
+    MASK = args.MASK
+    SAMPLE = args.SAMPLE
+    DIST = args.DIST
+    COUNT_INVIS = args.COUNT_INVIS
+    TOTAL_SAVE_RESULT = args.TOTAL_SAVE_RESULT
+    BBOX_THRE = False if args.IMG_THRESHOLD else True
+    VER = args.VER
+    CO_PCA = False if args.PROJ_LAYER else True
+    CO_PCA_DINO = args.CO_PCA_DINO
+    PCA_DIMS = args.PCA_DIMS
+    SIZE = args.SIZE
+    INDICES = args.INDICES
+    EDGE_PAD = args.EDGE_PAD
+
+    FUSE_DINO = False if args.NOT_FUSE else True
+    ONLY_DINO = args.ONLY_DINO
+    DINOV2 = False if args.DINOV1 else True
+    MODEL_SIZE = args.MODEL_SIZE
+    
+    DRAW_DENSE = args.DRAW_DENSE
+    DRAW_SWAP = args.DRAW_SWAP
+    DRAW_GIF = args.DRAW_GIF
+    TEXT_INPUT = args.TEXT_INPUT
+    
+    SEED = args.SEED
+    WEIGHT = args.WEIGHT # corresponde to three groups for the sd features, and one group for the dino features
+    PASCAL = args.PASCAL
+    RAW = args.RAW
+
+    if SAMPLE == 0:
+        SAMPLE = None
+    if DRAW_DENSE or DRAW_SWAP:
+        TOTAL_SAVE_RESULT = SAMPLE
+        MASK = True
+    if ONLY_DINO:
+        FUSE_DINO = True
+    if FUSE_DINO and not ONLY_DINO:
+        DIST = "l2"
+    else:
+        DIST = "cos"
+    if args.DIST != "cos" and args.DIST != "l2":
+        DIST = args.DIST
+    if PASCAL:
+        SAMPLE = 0
+
+    np.random.seed(args.SEED)
+    torch.manual_seed(args.SEED)
+    torch.cuda.manual_seed(args.SEED)
+    torch.backends.cudnn.benchmark = True
+    model, aug = load_model(diffusion_ver=VER, image_size=SIZE, num_timesteps=args.TIMESTEP, block_indices=tuple(INDICES))
+    save_path=f'./results_spair/pck_fuse_{args.NOTE}mask_{MASK}_sample_{SAMPLE}_BBOX_{BBOX_THRE}_dist_{DIST}_Invis_{COUNT_INVIS}_{args.TIMESTEP}{VER}_{MODEL_SIZE}_{SIZE}_copca_{CO_PCA}_{INDICES[0]}_{PCA_DIMS[0]}_{INDICES[1]}_{PCA_DIMS[1]}_{INDICES[2]}_{PCA_DIMS[2]}_text_{TEXT_INPUT}_sd_{WEIGHT[3]}{not ONLY_DINO}_dino_{WEIGHT[4]}{FUSE_DINO}'
+    if PASCAL:
+        save_path=f'./results_pascal/pck_fuse_{args.NOTE}mask_{MASK}_sample_{SAMPLE}_BBOX_{BBOX_THRE}_dist_{DIST}_Invis_{COUNT_INVIS}_{args.TIMESTEP}{VER}_{MODEL_SIZE}_{SIZE}_copca_{CO_PCA}_{INDICES[0]}_{PCA_DIMS[0]}_{INDICES[1]}_{PCA_DIMS[1]}_{INDICES[2]}_{PCA_DIMS[2]}_text_{TEXT_INPUT}_sd_{WEIGHT[3]}{not ONLY_DINO}_dino_{WEIGHT[4]}{FUSE_DINO}'
+    if EDGE_PAD:
+        save_path += '_edge_pad'
+    if not os.path.exists(save_path):
+        os.makedirs(save_path)
+    
+    logger = get_logger(save_path+'/result.log')
+
+    logger.info(args)
+    data_dir = 'data/SPair-71k' if not PASCAL else 'data/PF-dataset-PASCAL'
+    if not PASCAL:
+        categories = os.listdir(os.path.join(data_dir, 'ImageAnnotation'))
+        categories = sorted(categories)
+    else:
+        categories = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle',
+                    'bus', 'car', 'cat', 'chair', 'cow',
+                    'diningtable', 'dog', 'horse', 'motorbike', 'person',
+                    'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor'] # for pascal
+    img_size = 840 if DINOV2 else 224 if ONLY_DINO else 480
+
+    pcks = []
+    pcks_05 = []
+    pcks_01 = []
+    start_time=time.time()
+    for cat in categories:
+        files, kps, thresholds = load_spair_data(data_dir, size=img_size, category=cat, subsample=SAMPLE) if not PASCAL else load_pascal_data(data_dir, size=img_size, category=cat, subsample=SAMPLE)
+        if BBOX_THRE:
+            pck = compute_pck(model, aug, save_path, files, kps, cat, mask=MASK, dist=DIST, thresholds=thresholds, real_size=SIZE)
+        else:
+            pck = compute_pck(model, aug, save_path, files, kps, cat, mask=MASK, dist=DIST, real_size=SIZE)
+        pcks.append(pck[0])
+        pcks_05.append(pck[1])
+        pcks_01.append(pck[2])
+    end_time=time.time()
+    minutes, seconds = divmod(end_time-start_time, 60)
+    logger.info(f"Time: {minutes:.0f}m {seconds:.0f}s")
+    logger.info(f"Average PCK0.10: {np.average(pcks) * 100:.2f}")
+    logger.info(f"Average PCK0.05: {np.average(pcks_05) * 100:.2f}")
+    logger.info(f"Average PCK0.01: {np.average(pcks_01) * 100:.2f}") if not PASCAL else logger.info(f"Average PCK0.15: {np.average(pcks_01) * 100:.2f}")
+    if SAMPLE is None or SAMPLE==0:
+        weights_pascal=[15,30,10,6,8,32,19,27,13,3,8,24,9,27,12,7,1,13,20,15]
+        weights_spair=[690,650,702,702,870,644,564,600,646,640,600,600,702,650,862,664,756,692]
+        weights = weights_pascal if PASCAL else weights_spair
+    else:
+        weights = [1] * len(pcks)
+    logger.info(f"Weighted PCK0.10: {np.average(pcks, weights=weights) * 100:.2f}")
+    logger.info(f"Weighted PCK0.05: {np.average(pcks_05, weights=weights) * 100:.2f}")
+    logger.info(f"Weighted PCK0.01: {np.average(pcks_01, weights=weights) * 100:.2f}") if not PASCAL else logger.info(f"Weighted PCK0.15: {np.average(pcks_01, weights=weights) * 100:.2f}")
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--SEED', type=int, default=42)
+    parser.add_argument('--MASK', action='store_true', default=False)               # set true to use the segmentation mask for the extracted features
+    parser.add_argument('--SAMPLE', type=int, default=20)                           # sample 20 pairs for each category, set to 0 to use all pairs
+    parser.add_argument('--DIST', type=str, default='l2')                           # distance metric, cos, l2, l1, l2_norm, l1_norm, plus, plus_norm
+    parser.add_argument('--COUNT_INVIS', action='store_true', default=False)        # set true to count invisible keypoints
+    parser.add_argument('--TOTAL_SAVE_RESULT', type=int, default=5)                 # save the qualitative results for the first 5 pairs
+    parser.add_argument('--IMG_THRESHOLD', action='store_true', default=False)      # set the pck threshold to the image size rather than the bbox size
+    parser.add_argument('--VER', type=str, default="v1-5")                          # version of diffusion, v1-3, v1-4, v1-5, v2-1-base
+    parser.add_argument('--PROJ_LAYER', action='store_true', default=False)         # set true to use the pretrained projection layer from ODISE for dimension reduction
+    parser.add_argument('--CO_PCA_DINO', type=int, default=0)                       # whether perform co-pca on dino features
+    parser.add_argument('--PCA_DIMS', nargs=3, type=int, default=[256, 256, 256])   # the dimensions of the three groups of sd features
+    parser.add_argument('--TIMESTEP', type=int, default=100)                        # timestep for diffusion, [0, 1000], 0 for no noise added
+    parser.add_argument('--SIZE', type=int, default=960)                            # image size for the sd input
+    parser.add_argument('--INDICES', nargs=4, type=int, default=[2,5,8,11])         # select different layers of sd features, only the first three are used by default
+    parser.add_argument('--EDGE_PAD', action='store_true', default=False)           # set true to pad the image with the edge pixels
+    parser.add_argument('--WEIGHT', nargs=5, type=float, default=[1,1,1,1,1])       # first three corresponde to three layers for the sd features, and the last two for the ensembled sd/dino features
+    parser.add_argument('--RAW', action='store_true', default=False)                # set true to use the raw features from sd
+
+    parser.add_argument('--NOT_FUSE', action='store_true', default=False)           # set true to use only sd features
+    parser.add_argument('--ONLY_DINO', action='store_true', default=False)          # set true to use only dino features
+    parser.add_argument('--DINOV1',  action='store_true', default=False)            # set true to use dinov1
+    parser.add_argument('--MODEL_SIZE', type=str, default='base')                   # model size of thye dinov2, small, base, large
+
+    parser.add_argument('--DRAW_DENSE', action='store_true', default=False)         # set true to draw the dense correspondences
+    parser.add_argument('--DRAW_SWAP', action='store_true', default=False)          # set true to draw the swapped images
+    parser.add_argument('--DRAW_GIF', action='store_true', default=False)           # set true to generate the gif for the swapped images
+    parser.add_argument('--TEXT_INPUT', action='store_true', default=False)         # set true to use the explicit text input
+
+    parser.add_argument('--PASCAL', action='store_true', default=False)             # set true to test on pfpascal dataset
+    parser.add_argument('--NOTE', type=str, default='')
+
+    args = parser.parse_args()
+    main(args)

Code/Baselines/sd-dino/pck_tss.py

@@ -0,0 +1,505 @@
+import os
+import sys
+import torch
+import os
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+import torch.nn.functional as F
+from utils.utils_correspondence import co_pca, resize, find_nearest_patchs, find_nearest_patchs_replace
+import matplotlib.pyplot as plt
+import time
+from utils.logger import get_logger
+from loguru import logger
+import argparse
+from extractor_sd import load_model, process_features_and_mask, get_mask
+from extractor_dino import ViTExtractor
+from utils.utils_tss import TSSDataset
+from torch.utils.data import DataLoader
+import torchvision.transforms as transforms
+import imageio
+from imageio import imwrite
+from utils.utils_flow import remap_using_flow_fields, flow_to_image, convert_flow_to_mapping, overlay_semantic_mask
+import torch.nn.functional as F 
+
+def get_smooth(img, mask=None):
+
+    if mask is not None:
+        img_smooth=img.clone().permute(0, 2, 3, 1)
+        img_smooth[~mask] = 0
+        img=img_smooth.permute(0, 3, 1, 2)
+
+    def _gradient_x(img,mask): #tobe implemented
+        img = F.pad(img, (0, 1, 0, 0), mode="replicate")
+        gx = img[:, :, :, :-1] - img[:, :, :, 1:]  # NCHW
+        return gx
+
+    def _gradient_y(img,mask):
+        img = F.pad(img, (0, 0, 0, 1), mode="replicate")
+        gy = img[:, :, :-1, :] - img[:, :, 1:, :]  # NCHW
+        return gy
+        
+    img_grad_x = _gradient_x(img, mask)
+    img_grad_y = _gradient_y(img, mask)
+
+    if mask is not None:
+        smooth = (torch.abs(img_grad_x).sum() + torch.abs(img_grad_y).sum())/torch.sum(mask)
+    else:
+        smooth = torch.mean(torch.abs(img_grad_x)) + torch.mean(torch.abs(img_grad_y))
+
+    return smooth
+
+
+def plot_individual_images(save_path, name_image, source_image, target_image, flow_est, flow_gt,
+                           mask_used=None, color=[255, 102, 51]):
+    if not isinstance(source_image, np.ndarray):
+        source_image = source_image.squeeze().permute(1, 2, 0).cpu().numpy().astype(np.uint8)
+        target_image = target_image.squeeze().permute(1, 2, 0).cpu().numpy().astype(np.uint8)
+    else:
+        # numpy array
+        if not source_image.shape[2] == 3:
+            source_image = source_image.transpose(1, 2, 0)
+            target_image = target_image.transpose(1, 2, 0)
+
+    flow_target = flow_est.detach().permute(0, 2, 3, 1)[0].cpu().numpy()
+    flow_gt = flow_gt.detach().permute(0, 2, 3, 1)[0].cpu().numpy()
+    remapped_est = remap_using_flow_fields(source_image, flow_target[:, :, 0], flow_target[:, :, 1])
+
+    max_mapping = 520
+    max_flow = 400
+    rgb_flow = flow_to_image(flow_target, max_flow)
+    rgb_flow_gt = flow_to_image(flow_gt, max_flow)
+    rgb_mapping = flow_to_image(convert_flow_to_mapping(flow_target, False), max_mapping)
+
+    if not os.path.isdir(os.path.join(save_path, 'individual_images')):
+        os.makedirs(os.path.join(save_path, 'individual_images'))
+    # save the rgb flow
+    imageio.imwrite(os.path.join(save_path, 'individual_images', "{}_rgb_flow.png".format(name_image)), rgb_flow)
+    imageio.imwrite(os.path.join(save_path, 'individual_images', "{}_rgb_flow_gt.png".format(name_image)), rgb_flow_gt)
+    imageio.imwrite(os.path.join(save_path, 'individual_images', "{}_rgb_mapping.png".format(name_image)),rgb_mapping)
+    imageio.imwrite(os.path.join(save_path, 'individual_images', "{}_image_s.png".format(name_image)), source_image)
+    imageio.imwrite(os.path.join(save_path, 'individual_images', "{}_image_t.png".format(name_image)), target_image)
+    imageio.imwrite(os.path.join(save_path, 'individual_images', "{}_warped_s.png".format(name_image)),
+                    remapped_est)
+
+    if mask_used is not None:
+        mask_used = mask_used.squeeze().cpu().numpy()
+        imageio.imwrite(os.path.join(save_path, 'individual_images', "{}_mask.png".format(name_image)),
+                        mask_used.astype(np.uint8) * 255)
+        imageio.imwrite(
+            os.path.join(save_path, 'individual_images', "{}_image_s_warped_and_mask.png".format(name_image)),
+            remapped_est * np.tile(np.expand_dims(mask_used.astype(np.uint8), axis=2), (1, 1, 3)))
+
+        # overlay mask on warped image
+        img_mask_overlay_color = overlay_semantic_mask(remapped_est.astype(np.uint8),
+                                                       255 - mask_used.astype(np.uint8) * 255, color=color)
+        imwrite(os.path.join(save_path, 'individual_images',
+                             '{}_warped_overlay_mask_color.png'.format(name_image)), img_mask_overlay_color)
+
+        flow_mask_overlay_color = overlay_semantic_mask(rgb_flow, 255 - mask_used.astype(np.uint8) * 255, color=color)
+        imwrite(os.path.join(save_path, 'individual_images',
+                                '{}_flow_overlay_mask_color.png'.format(name_image)), flow_mask_overlay_color)
+        
+        flow_gt_mask_overlay_color = overlay_semantic_mask(rgb_flow_gt, 255 - mask_used.astype(np.uint8) * 255, color=color)
+        imwrite(os.path.join(save_path, 'individual_images',
+                                '{}_flow_gt_overlay_mask_color.png'.format(name_image)), flow_gt_mask_overlay_color)
+
+
+def nearest_neighbor_flow(src_descriptor, trg_descriptor, ori_shape, mask1=None, mask2=None):
+    B, C, H, W = src_descriptor.shape
+
+    if mask1 is not None and mask2 is not None:
+        resized_mask1 = F.interpolate(mask1.cuda().unsqueeze(0).unsqueeze(0).float(), size=src_descriptor.shape[2:], mode='nearest')
+        resized_mask2 = F.interpolate(mask2.cuda().unsqueeze(0).unsqueeze(0).float(), size=trg_descriptor.shape[2:], mode='nearest')
+        src_descriptor = src_descriptor * resized_mask1.repeat(1, src_descriptor.shape[1], 1, 1)
+        trg_descriptor = trg_descriptor * resized_mask2.repeat(1, trg_descriptor.shape[1], 1, 1)
+        # set where mask==0 a very large number
+        src_descriptor[(src_descriptor.sum(1)==0).repeat(1, src_descriptor.shape[1], 1, 1)] = 100000
+        trg_descriptor[(trg_descriptor.sum(1)==0).repeat(1, trg_descriptor.shape[1], 1, 1)] = 100000
+
+    real_H, real_W = ori_shape
+    long_edge = max(real_H, real_W)
+    src_descriptor = src_descriptor.view(B, C, -1).permute(0, 2, 1).squeeze()
+    trg_descriptor = trg_descriptor.view(B, C, -1).permute(0, 2, 1).squeeze()
+
+    # Compute distance matrix using broadcasting and torch.cdist
+    distances = torch.cdist(trg_descriptor, src_descriptor)
+
+    # Find the indices of the minimum distances
+    indices = torch.argmin(distances, dim=1).reshape(B, H, W)
+
+    # Convert indices to coordinates
+    trg_y = torch.div(indices, W).to(torch.float32)
+    trg_x = torch.fmod(indices, W).to(torch.float32)
+
+    # Create coordinate grid
+    grid_y, grid_x = torch.meshgrid(torch.arange(H, dtype=torch.float32, device=src_descriptor.device), torch.arange(W, dtype=torch.float32, device=src_descriptor.device))
+
+    # Compare target coordinates with source coordinate grid
+    flow_x = trg_x - grid_x
+    flow_y = trg_y - grid_y
+
+    # Stack the flow fields together to form the final optical flow
+    flow = torch.stack([flow_x, flow_y], dim=1)
+
+    # Perform bilinear interpolation to adjust the optical flow from (60, 60) to (real_H, real_W)
+    flow = F.interpolate(flow, size=(long_edge, long_edge), mode='bilinear', align_corners=False)
+    flow *= torch.tensor([long_edge / 60.0, long_edge / 60.0], dtype=torch.float32, device=src_descriptor.device).view(1, 2, 1, 1)
+
+    # Crop the flow field to the original image size
+    if long_edge == real_H:
+        flow = flow[:, :, :, (long_edge - real_W) // 2:(long_edge - real_W) // 2 + real_W]
+    else:
+        flow = flow[:, :, (long_edge - real_H) // 2:(long_edge - real_H) // 2 + real_H, :]
+
+    return flow
+
+def compute_flow(model, aug, source_img, target_img, save_path, batch_num=0, category=['car'], mask=False, dist='cos', real_size=960):
+    if type(category) == str:
+        category = [category]
+    img_size = 840 if DINOV2 else 480
+    model_dict={'small':'dinov2_vits14',
+                'base':'dinov2_vitb14',
+                'large':'dinov2_vitl14',
+                'giant':'dinov2_vitg14'}
+    
+    model_type = model_dict[MODEL_SIZE] if DINOV2 else 'dino_vits8'
+    layer = 11 if DINOV2 else 9
+    if 'l' in model_type:
+        layer = 23
+    elif 'g' in model_type:
+        layer = 39
+    facet = 'token' if DINOV2 else 'key'
+    stride = 14 if DINOV2 else 8
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    # indiactor = 'v2' if DINOV2 else 'v1'
+    # model_size = model_type.split('vit')[-1]
+    extractor = ViTExtractor(model_type, stride, device=device)
+    patch_size = extractor.model.patch_embed.patch_size[0] if DINOV2 else extractor.model.patch_embed.patch_size
+    num_patches = int(patch_size / stride * (img_size // patch_size - 1) + 1)
+    
+    input_text = "a photo of "+category[-1][0] if TEXT_INPUT else None
+
+    current_save_results = 0
+
+    N = 1
+    result = []
+
+    for pair_idx in range(N):
+        shape = source_img.shape[2:]
+        # Load image 1
+        img1=Image.fromarray(source_img.squeeze().numpy().transpose(1,2,0).astype(np.uint8))
+        img1_input = resize(img1, real_size, resize=True, to_pil=True, edge=EDGE_PAD)
+        img1 = resize(img1, img_size, resize=True, to_pil=True, edge=EDGE_PAD)
+
+        # Load image 2
+        img2=Image.fromarray(target_img.squeeze().numpy().transpose(1,2,0).astype(np.uint8))
+        img2_input = resize(img2, real_size, resize=True, to_pil=True, edge=EDGE_PAD)
+        img2 = resize(img2, img_size, resize=True, to_pil=True, edge=EDGE_PAD)
+
+        with torch.no_grad():
+            if not CO_PCA:
+                if not ONLY_DINO:
+                    img1_desc = process_features_and_mask(model, aug, img1_input, input_text=input_text, mask=False).reshape(1,1,-1, num_patches**2).permute(0,1,3,2)
+                    img2_desc = process_features_and_mask(model, aug, img2_input, category[-1], input_text=input_text,  mask=mask).reshape(1,1,-1, num_patches**2).permute(0,1,3,2)
+                if FUSE_DINO:
+                    img1_batch = extractor.preprocess_pil(img1)
+                    img1_desc_dino = extractor.extract_descriptors(img1_batch.to(device), layer, facet)
+                    img2_batch = extractor.preprocess_pil(img2)
+                    img2_desc_dino = extractor.extract_descriptors(img2_batch.to(device), layer, facet)
+
+            else:
+                if not ONLY_DINO:
+                    features1 = process_features_and_mask(model, aug, img1_input, input_text=input_text,  mask=False, raw=True)
+                    features2 = process_features_and_mask(model, aug, img2_input, category[-1], input_text=input_text,  mask=mask, raw=True)
+                    processed_features1, processed_features2 = co_pca(features1, features2, PCA_DIMS)
+                    img1_desc = processed_features1.reshape(1, 1, -1, num_patches**2).permute(0,1,3,2)
+                    img2_desc = processed_features2.reshape(1, 1, -1, num_patches**2).permute(0,1,3,2)
+                if FUSE_DINO:
+                    img1_batch = extractor.preprocess_pil(img1)
+                    img1_desc_dino = extractor.extract_descriptors(img1_batch.to(device), layer, facet)
+
+                    img2_batch = extractor.preprocess_pil(img2)
+                    img2_desc_dino = extractor.extract_descriptors(img2_batch.to(device), layer, facet) # (1,1,3600,768)
+
+
+            if dist == 'l1' or dist == 'l2':
+                # normalize the features
+                img1_desc = img1_desc / img1_desc.norm(dim=-1, keepdim=True)
+                img2_desc = img2_desc / img2_desc.norm(dim=-1, keepdim=True)
+                if FUSE_DINO:
+                    img1_desc_dino = img1_desc_dino / img1_desc_dino.norm(dim=-1, keepdim=True)
+                    img2_desc_dino = img2_desc_dino / img2_desc_dino.norm(dim=-1, keepdim=True)
+
+            if FUSE_DINO and not ONLY_DINO:
+                # cat two features together
+                img1_desc = torch.cat((img1_desc, img1_desc_dino), dim=-1)
+                img2_desc = torch.cat((img2_desc, img2_desc_dino), dim=-1)
+                
+                img1_desc[...,:PCA_DIMS[0]]*=WEIGHT[0]
+                img1_desc[...,PCA_DIMS[0]:PCA_DIMS[1]+PCA_DIMS[0]]*=WEIGHT[1]
+                img1_desc[...,PCA_DIMS[1]+PCA_DIMS[0]:PCA_DIMS[2]+PCA_DIMS[1]+PCA_DIMS[0]]*=WEIGHT[2]
+
+                img2_desc[...,:PCA_DIMS[0]]*=WEIGHT[0]
+                img2_desc[...,PCA_DIMS[0]:PCA_DIMS[1]+PCA_DIMS[0]]*=WEIGHT[1]
+                img2_desc[...,PCA_DIMS[1]+PCA_DIMS[0]:PCA_DIMS[2]+PCA_DIMS[1]+PCA_DIMS[0]]*=WEIGHT[2]
+
+            if ONLY_DINO:
+                img1_desc = img1_desc_dino
+                img2_desc = img2_desc_dino
+            # logger.info(img1_desc.shape, img2_desc.shape)
+
+            if DRAW_DENSE:
+                mask1 = get_mask(model, aug, img1, category[0])
+                mask2 = get_mask(model, aug, img2, category[-1])
+                if ONLY_DINO or not FUSE_DINO:
+                    img1_desc = img1_desc / img1_desc.norm(dim=-1, keepdim=True)
+                    img2_desc = img2_desc / img2_desc.norm(dim=-1, keepdim=True)
+                
+                img1_desc_reshaped = img1_desc.permute(0,1,3,2).reshape(-1, img1_desc.shape[-1], num_patches, num_patches)
+                img2_desc_reshaped = img2_desc.permute(0,1,3,2).reshape(-1, img2_desc.shape[-1], num_patches, num_patches)
+                trg_dense_output, src_color_map = find_nearest_patchs(mask2, mask1, img2, img1, img2_desc_reshaped, img1_desc_reshaped, mask=mask)
+                if current_save_results!=TOTAL_SAVE_RESULT:
+                    if not os.path.exists(f'{save_path}/{category[0]}'):
+                        os.makedirs(f'{save_path}/{category[0]}')
+                    fig_colormap, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
+                    ax1.axis('off')
+                    ax2.axis('off')
+                    ax1.imshow(src_color_map)
+                    ax2.imshow(trg_dense_output)
+                    fig_colormap.savefig(f'{save_path}/{category[0]}/{batch_num}_colormap.png')
+                    plt.close(fig_colormap)
+            
+            if DRAW_SWAP:
+                if not DRAW_DENSE:
+                    mask1 = get_mask(model, aug, img1, category[0])
+                    mask2 = get_mask(model, aug, img2, category[-1])
+
+                if (ONLY_DINO or not FUSE_DINO) and not DRAW_DENSE:
+                    img1_desc = img1_desc / img1_desc.norm(dim=-1, keepdim=True)
+                    img2_desc = img2_desc / img2_desc.norm(dim=-1, keepdim=True)
+                    
+                img1_desc_reshaped = img1_desc.permute(0,1,3,2).reshape(-1, img1_desc.shape[-1], num_patches, num_patches)
+                img2_desc_reshaped = img2_desc.permute(0,1,3,2).reshape(-1, img2_desc.shape[-1], num_patches, num_patches)
+                trg_dense_output, src_color_map = find_nearest_patchs_replace(mask2, mask1, img2, img1, img2_desc_reshaped, img1_desc_reshaped, mask=mask, resolution=156)
+                if current_save_results!=TOTAL_SAVE_RESULT:
+                    if not os.path.exists(f'{save_path}/{category[0]}'):
+                        os.makedirs(f'{save_path}/{category[0]}')
+                    fig_colormap, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
+                    ax1.axis('off')
+                    ax2.axis('off')
+                    ax1.imshow(src_color_map)
+                    ax2.imshow(trg_dense_output)
+                    fig_colormap.savefig(f'{save_path}/{category[0]}/{batch_num}_swap.png')
+                    plt.close(fig_colormap)
+            
+            # compute the flow map based on the nearest neighbor
+            # reshape the descriptors (1,dim,80,60)
+            img1_desc_reshaped = img1_desc.permute(0,1,3,2).reshape(-1, img1_desc.shape[-1], num_patches, num_patches)
+            img2_desc_reshaped = img2_desc.permute(0,1,3,2).reshape(-1, img2_desc.shape[-1], num_patches, num_patches)
+
+            # compute the flow map based on the nearest neighbor
+            if MASK:
+                mask1 = get_mask(model, aug, img1, category[0])
+                mask2 = get_mask(model, aug, img2, category[-1])
+                result = nearest_neighbor_flow(img1_desc_reshaped, img2_desc_reshaped, shape, mask1, mask2)
+            else:
+                result = nearest_neighbor_flow(img1_desc_reshaped, img2_desc_reshaped, shape)
+
+    return result
+
+
+def run_evaluation_semantic(model, aug, test_dataloader, device,
+                            path_to_save=None, plot=False, plot_100=False, plot_ind_images=False):
+    current_save_results = 0
+    pbar = tqdm(enumerate(test_dataloader), total=len(test_dataloader))
+    mean_epe_list, epe_all_list, pck_0_05_list, pck_0_01_list, pck_0_1_list, pck_0_15_list = [], [], [], [], [], []
+    smooth_est_list, smooth_gt_list = [], []
+    eval_buf = {'cls_pck': dict(), 'vpvar': dict(), 'scvar': dict(), 'trncn': dict(), 'occln': dict()}
+
+    # pck curve per image
+    pck_thresholds = [0.01]
+    pck_thresholds.extend(np.arange(0.05, 0.4, 0.05).tolist())
+    pck_per_image_curve = np.zeros((len(pck_thresholds), len(test_dataloader)), np.float32)
+
+    for i_batch, mini_batch in pbar:
+        source_img = mini_batch['source_image']
+        target_img = mini_batch['target_image']
+        flow_gt = mini_batch['flow_map'].to(device)
+        mask_valid = mini_batch['correspondence_mask'].to(device)
+        category = mini_batch['category']
+
+        if 'pckthres' in list(mini_batch.keys()):
+            L_pck = mini_batch['pckthres'][0].float().item()
+        else:
+            raise ValueError('No pck threshold in mini_batch')
+
+        flow_est = compute_flow(model, aug, source_img, target_img, batch_num=i_batch, save_path=path_to_save, category=category)
+
+        if plot_ind_images or current_save_results < TOTAL_SAVE_RESULT:
+            plot_individual_images(path_to_save, 'image_{}'.format(i_batch), source_img, target_img, flow_est,flow_gt , mask_used=mask_valid)
+            current_save_results += 1
+
+        smooth_est_list.append(get_smooth(flow_est,mask_valid).cpu().numpy())
+        smooth_gt_list.append(get_smooth(flow_gt,mask_valid).cpu().numpy())
+
+        flow_est = flow_est.permute(0, 2, 3, 1)[mask_valid]
+        flow_gt = flow_gt.permute(0, 2, 3, 1)[mask_valid]
+
+        epe = torch.sum((flow_est - flow_gt) ** 2, dim=1).sqrt()
+
+        epe_all_list.append(epe.view(-1).cpu().numpy())
+        mean_epe_list.append(epe.mean().item())
+        pck_0_05_list.append(epe.le(0.05*L_pck).float().mean().item())
+        pck_0_01_list.append(epe.le(0.01*L_pck).float().mean().item())
+        pck_0_1_list.append(epe.le(0.1*L_pck).float().mean().item())
+        pck_0_15_list.append(epe.le(0.15*L_pck).float().mean().item())
+        for t in range(len(pck_thresholds)):
+            pck_per_image_curve[t, i_batch] = epe.le(pck_thresholds[t]*L_pck).float().mean().item()
+
+    epe_all = np.concatenate(epe_all_list)
+    pck_0_05_dataset = np.mean(epe_all <= 0.05 * L_pck)
+    pck_0_01_dataset = np.mean(epe_all <= 0.01 * L_pck)
+    pck_0_1_dataset = np.mean(epe_all <= 0.1 * L_pck)
+    pck_0_15_dataset = np.mean(epe_all <= 0.15 * L_pck)
+    smooth_est_dataset = np.mean(smooth_est_list)
+    smooth_gt_dataset = np.mean(smooth_gt_list)
+
+    output = {'AEPE': np.mean(mean_epe_list), 'PCK_0_05_per_image': np.mean(pck_0_05_list),
+              'PCK_0_01_per_image': np.mean(pck_0_01_list), 'PCK_0_1_per_image': np.mean(pck_0_1_list),
+              'PCK_0_15_per_image': np.mean(pck_0_15_list),
+              'PCK_0_01_per_dataset': pck_0_01_dataset, 'PCK_0_05_per_dataset': pck_0_05_dataset,
+              'PCK_0_1_per_dataset': pck_0_1_dataset, 'PCK_0_15_per_dataset': pck_0_15_dataset,
+              'pck_threshold_alpha': pck_thresholds, 'pck_curve_per_image': np.mean(pck_per_image_curve, axis=1).tolist()
+              }
+    logger.info("Validation EPE: %f, alpha=0_01: %f, alpha=0.05: %f" % (output['AEPE'], output['PCK_0_01_per_image'],
+                                                                  output['PCK_0_05_per_image']))
+    logger.info("smooth_est: %f, smooth_gt: %f" % (smooth_est_dataset, smooth_gt_dataset))
+
+    for name in eval_buf.keys():
+        output[name] = {}
+        for cls in eval_buf[name]:
+            if eval_buf[name] is not None:
+                cls_avg = sum(eval_buf[name][cls]) / len(eval_buf[name][cls])
+                output[name][cls] = cls_avg
+
+    return output
+
+def main(args):
+    global MASK, SAMPLE, DIST, TOTAL_SAVE_RESULT, VER, CO_PCA, PCA_DIMS, SIZE, FUSE_DINO, DINOV2, MODEL_SIZE, DRAW_DENSE, TEXT_INPUT, DRAW_SWAP, ONLY_DINO, SEED, EDGE_PAD, WEIGHT
+    MASK = args.MASK
+    SAMPLE = args.SAMPLE
+    DIST = args.DIST
+    TOTAL_SAVE_RESULT = args.TOTAL_SAVE_RESULT
+    VER = args.VER
+    CO_PCA = args.CO_PCA
+    PCA_DIMS = args.PCA_DIMS
+    SIZE = args.SIZE
+    INDICES = args.INDICES
+    EDGE_PAD = args.EDGE_PAD
+
+    FUSE_DINO = False if args.NOT_FUSE else True
+    ONLY_DINO = args.ONLY_DINO
+    DINOV2 = False if args.DINOV1 else True
+    MODEL_SIZE = args.MODEL_SIZE
+    DRAW_DENSE = args.DRAW_DENSE
+    DRAW_SWAP = args.DRAW_SWAP
+    TEXT_INPUT = args.TEXT_INPUT
+    SEED = args.SEED
+    WEIGHT = args.WEIGHT # corresponde to three groups for the sd features, and one group for the dino features
+
+    if SAMPLE == 0:
+        SAMPLE = None
+    if DRAW_DENSE or DRAW_SWAP:
+        TOTAL_SAVE_RESULT = SAMPLE
+    if ONLY_DINO:
+        FUSE_DINO = True
+    if FUSE_DINO and not ONLY_DINO:
+        DIST = "l2"
+    else:
+        DIST = "cos"
+
+    np.random.seed(args.SEED)
+    torch.manual_seed(args.SEED)
+    torch.cuda.manual_seed(args.SEED)
+    torch.backends.cudnn.benchmark = True
+
+    model, aug = load_model(diffusion_ver=VER, image_size=SIZE, num_timesteps=args.TIMESTEP, block_indices=tuple(INDICES))
+    save_path=f'./results_tss/pck_tss_mask_{MASK}_dist_{DIST}_{args.TIMESTEP}{VER}_{MODEL_SIZE}_{SIZE}_copca_{CO_PCA}_{INDICES[0]}_{PCA_DIMS[0]}_{INDICES[1]}_{PCA_DIMS[1]}_{INDICES[2]}_{PCA_DIMS[2]}_text_{TEXT_INPUT}_sd_{not ONLY_DINO}_dino_{FUSE_DINO}'
+    if EDGE_PAD:
+        save_path += '_edge_pad'
+    if not os.path.exists(save_path):
+        os.makedirs(save_path)
+    
+    logger = get_logger(save_path+'/result.log')
+
+    logger.info(args)
+    data_dir = "data/TSS_CVPR2016"
+
+    start_time=time.time()
+
+    class ArrayToTensor(object):
+        """Converts a numpy.ndarray (H x W x C) to a torch.FloatTensor of shape (C x H x W)."""
+        def __init__(self, get_float=True):
+            self.get_float = get_float
+
+        def __call__(self, array):
+
+            if not isinstance(array, np.ndarray):
+                array = np.array(array)
+            array = np.transpose(array, (2, 0, 1))
+            # handle numpy array
+            tensor = torch.from_numpy(array)
+            # put it from HWC to CHW format
+            if self.get_float:
+                # carefull, this is not normalized to [0, 1]
+                return tensor.float()
+            else:
+                return tensor
+
+    co_transform = None
+    target_transform = transforms.Compose([ArrayToTensor()])  # only put channel first
+    input_transform = transforms.Compose([ArrayToTensor(get_float=False)])  # only put channel first
+    output = {}
+    for sub_data in ['FG3DCar', 'JODS', 'PASCAL']:
+        test_set = TSSDataset(os.path.join(data_dir, sub_data),
+                                                    source_image_transform=input_transform,
+                                                    target_image_transform=input_transform, flow_transform=target_transform,
+                                                    co_transform=co_transform,
+                                                    num_samples=SAMPLE)
+        test_dataloader = DataLoader(test_set, batch_size=1, num_workers=8)
+        results = run_evaluation_semantic(model,aug, test_dataloader, device='cuda', path_to_save=save_path+'/'+sub_data, plot_ind_images=DRAW_SWAP)
+        output[sub_data] = results
+
+    end_time=time.time()
+    minutes, seconds = divmod(end_time-start_time, 60)
+    logger.info(f"Time: {minutes:.0f}m {seconds:.0f}s")
+    torch.save(output, save_path+'/result.pth')
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--SEED', type=int, default=42)
+    parser.add_argument('--MASK', action='store_true', default=False)
+    parser.add_argument('--SAMPLE', type=int, default=0)
+    parser.add_argument('--DIST', type=str, default='l2')
+    parser.add_argument('--TOTAL_SAVE_RESULT', type=int, default=5)
+    parser.add_argument('--VER', type=str, default="v1-5")
+    parser.add_argument('--CO_PCA', type=bool, default=True)
+    parser.add_argument('--PCA_DIMS', nargs=3, type=int, default=[256, 256, 256])
+    parser.add_argument('--TIMESTEP', type=int, default=100)
+    parser.add_argument('--SIZE', type=int, default=960)
+    parser.add_argument('--INDICES', nargs=4, type=int, default=[2,5,8,11])
+    parser.add_argument('--WEIGHT', nargs=4, type=float, default=[1,1,1,1])
+    parser.add_argument('--EDGE_PAD', action='store_true', default=False)
+
+    parser.add_argument('--NOT_FUSE', action='store_true', default=False)
+    parser.add_argument('--ONLY_DINO', action='store_true', default=False)
+    parser.add_argument('--DINOV1', action='store_true', default=False)
+    parser.add_argument('--MODEL_SIZE', type=str, default='base')
+
+    parser.add_argument('--DRAW_DENSE', action='store_true', default=False)
+    parser.add_argument('--DRAW_SWAP', action='store_true', default=False)
+    parser.add_argument('--TEXT_INPUT', action='store_true', default=False)
+
+    args = parser.parse_args()
+    main(args)