Upload 88 files

.gitattributes

@@ -33,3 +33,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+pix2pix3D-main/pix2pix3D-main/assets/demo.mp4 filter=lfs diff=lfs merge=lfs -text
+pix2pix3D-main/pix2pix3D-main/assets/rendered_mesh_colored.gif filter=lfs diff=lfs merge=lfs -text
+pix2pix3D-main/pix2pix3D-main/assets/seg2cat_1_label.gif filter=lfs diff=lfs merge=lfs -text
+pix2pix3D-main/pix2pix3D-main/assets/seg2cat_1.gif filter=lfs diff=lfs merge=lfs -text
+pix2pix3D-main/pix2pix3D-main/assets/seg2cat_1666_1_color.png filter=lfs diff=lfs merge=lfs -text
+pix2pix3D-main/pix2pix3D-main/assets/teaser_gif.gif filter=lfs diff=lfs merge=lfs -text
+pix2pix3D-main/pix2pix3D-main/assets/teaser_jpg.jpg filter=lfs diff=lfs merge=lfs -text
+pix2pix3D-main/pix2pix3D-main/assets/teaser_png.png filter=lfs diff=lfs merge=lfs -text

pix2pix3D-main/pix2pix3D-main/.gitignore

@@ -0,0 +1,146 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+logs
+data
+wandb
+scripts
+web
+*.pyc
+.vscode

pix2pix3D-main/pix2pix3D-main/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Kangle Deng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pix2pix3D-main/pix2pix3D-main/README.md

@@ -0,0 +1,170 @@
+
+
+# 3D-aware Conditional Image Synthesis (pix2pix3D)
+
+[**Project**](https://www.cs.cmu.edu/~pix2pix3D/) | [**Paper**](https://arxiv.org/abs/2302.08509)
+
+This is the official PyTorch implementation of "3D-aware Conditional Image Synthesis". Pix2pix3D synthesizes 3D objects (neural fields) given a 2D label map, such as a segmentation or edge map. We also provide an interactive 3D editing demo. 
+
+https://user-images.githubusercontent.com/28395429/222578030-8bb2c727-397e-44b6-9ab1-9b0b09dd3b5b.mp4
+
+
+[3D-aware Conditional Image Synthesis](https://arxiv.org/abs/2302.08509)
+
+CVPR 2023
+
+ [Kangle Deng](https://dunbar12138.github.io/),
+ [Gengshan Yang](https://gengshan-y.github.io/),
+ [Deva Ramanan](https://www.cs.cmu.edu/~deva/),
+ [Jun-Yan Zhu](https://www.cs.cmu.edu/~junyanz/)
+
+Carnegie Mellon University
+
+---
+
+We propose pix2pix3D, a 3D-aware conditional generative model for controllable photorealistic image synthesis. Given a 2D label map, such as a segmentation or edge map, our model learns to synthesize a corresponding image from different viewpoints. To enable explicit 3D user control, we extend conditional generative models with neural radiance fields. Given widely-available monocular images and label map pairs, our model learns to assign a label to every 3D point in addition to color and density, which enables it to render the image and pixel-aligned label map simultaneously. Finally, we build an interactive system that allows users to edit the label map from any viewpoint and generate outputs accordingly.
+
+<p align="center">
+  <img src="assets/teaser_jpg.jpg"  width="720" />
+</p>
+
+## Getting Started
+
+### Dependencies
+
+We provide a conda env file that contains all the other dependencies. You can use the following commands with Miniconda3 to create and activate your Python environment:
+```
+conda env create -f environment.yml
+conda activate pix2pix3d
+```
+
+### Data
+
+We provide our preprocessed datasets, including segmentation maps and edge maps. You can download the [CelebAMask](https://drive.google.com/drive/folders/1mC6i4YmdpazJSmXrW8WFSfsImAJ8a_CF?usp=sharing) dataset, [AFHQ-Cat-Seg](https://drive.google.com/drive/folders/1yjTTE57P9-hEe-IVcE-GXdh04WGo5lD9?usp=sharing) dataset, and [Shapenet-Car-Edge](https://drive.google.com/drive/folders/1XTPuu784DIvk0ie094qyLrcF-v-jMe3_?usp=sharing) dataset and put those zip files under ```data/```.
+
+
+### Pre-trained Models
+
+You can download our pre-trained models using the following script:
+```
+bash checkpoints/download_models.sh
+```
+
+---
+### Inference
+
+We provide several scripts to generate the results once you download the pre-trained models.
+
+<p align="center">
+<img src="assets/teaser_gif.gif" width="720" />
+</p>
+
+#### Generate Samples
+You can generate results based on the samples in the dataset.
+```
+python applications/generate_samples.py --network <network_pkl> --outdir <output_dir> --random_seed <random_seeds list, e.g. 0 1> --cfg <configs, e.g., seg2cat, seg2face, edge2car> --input_id <sample_id in dataset>
+```
+For example:
+
+| Input Label Map  | Generated Image | Generated Label Map |
+| ------------- | ------------- | -------- |
+| <img src="assets/seg2cat_1666_input.png"  width="256" />  | <img src="assets/seg2cat_1666_1_color.png"  width="256" />  | <img src="assets/seg2cat_1666_1_label.png"  width="256" /> |
+
+You can get the results above by running:
+```
+python applications/generate_samples.py --network checkpoints/pix2pix3d_seg2cat.pkl --outdir examples --random_seed 1 --cfg seg2cat --input_id 1666
+```
+
+#### Render Videos
+You can render a video result based on a specified input label map.
+```
+python applications/generate_video.py --network <network_pkl> --outdir <output_dir> --random_seed <random_seeds list, e.g. 0 1> --cfg <configs, e.g., seg2cat, seg2face, edge2car> --input <input label map>
+```
+
+For example:
+| Input Label Map  | Generated Image | Generated Label Map |
+| ------------- | ------------- | -------- |
+| <img src="assets/seg2cat_1666_input.png"  width="256" />  | <img src="assets/seg2cat_1.gif"  width="256" />  | <img src="assets/seg2cat_1_label.gif"  width="256" /> |
+
+You can get the results above using the following command: 
+```
+python applications/generate_video.py --network checkpoints/pix2pix3d_seg2cat.pkl --outdir examples --random_seed 1 --cfg seg2cat --input examples/example_input.png
+```
+
+#### Extract Semantic Mesh
+You can also extract the mesh and color it using 3D semantic labels. Some extra packages (`pyrender`, `trimesh`, and `mcubes`) are required for mesh extraction. You can install them by `pip`. The extracted mesh will be saved as `semantic_mesh.ply`.
+
+For example:
+| Input Label Map  | Semantic Mesh | 
+| ------------- | ------------- | 
+| <img src="assets/seg2cat_1666_input.png"  width="256" />  | <img src="assets/rendered_mesh_colored.gif"  width="256" />  |
+
+You can get the results above with the following command:
+```
+python applications/extract_mesh.py --network checkpoints/pix2pix3d_seg2cat.pkl --outdir examples --cfg seg2cat --input examples/example_input.png
+```
+
+<!-- #### Interpolation -->
+
+
+### Training
+
+We provide an example training script at `train_scripts/afhq_seg.sh`:
+```
+python train.py --outdir=<log_dir> \
+                --cfg=afhq --data=data/afhq_v2_train_cat_512.zip \
+                --mask_data=data/afhqcat_seg_6c.zip \
+                --data_type=seg --semantic_channels=6 \ 
+                --render_mask=True --dis_mask=True \ 
+                --neural_rendering_resolution_initial=128 \
+                --resume=<EG3D-checkpoints>/afhqcats512-128.pkl \
+                --gpus=2 --batch=4 --mbstd-group=2 \ 
+                --gamma=5 --gen_pose_cond=True \ 
+                --random_c_prob=0.5 \
+                --lambda_d_semantic=0.1 \
+                --lambda_lpips=1 \
+                --lambda_cross_view=1e-4 \
+                --only_raw_recons=True \
+                --wandb_log=False
+```
+Training parameters:
+- `outdir`: The directory to save checkpoints and logs.
+- `cfg`: Choose from [afhq, celeba, shapenet]. 
+- `data`: RGB data file.
+- `mask_data`: label map data file.
+- `data_type`: Choose from [seg, edge]. Specify the `semantic_channels` if using `seg`.
+- `render_mask`: Whether to render label maps along with RGB.
+- `dis_mask`: Whether to use a GAN loss on rendered label maps.
+- `neural_rendering_resolution_initial`: The resolution of NeRF outputs.
+- `resume`: We partially initialize our network with EG3D pretrained checkpoints (download [here](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/research/models/eg3d)).
+- `gpus`, `batch`, `mbstd-group`: Parameters for batch size and multi-gpu training.
+- `gen_pose_cond`: Whether to condition the generation on camera poses.
+- `random_c_prob`: Probablity of sampling random poses for training.
+- `lambda_d_semantic`: The weight of GAN loss on label maps.
+- `lambda_lpips`: The weight of RGB LPIPS loss.
+- `lambda_cross_view`: The weight of cross-view consistency loss.
+- `wandb_log`: Whether to use wandb log.
+
+### Prepare your own dataset
+
+We follow the dataset format of EG3D [here](https://github.com/NVlabs/eg3d#preparing-datasets). You can obtain the segmentation masks of your own dataset by [DINO clustering](https://github.com/ShirAmir/dino-vit-features/blob/main/part_cosegmentation.py), and obtain the edge map by [pidinet](https://github.com/hellozhuo/pidinet) and [informative drawing](https://github.com/carolineec/informative-drawings).
+
+---
+
+## Citation
+
+If you find this repository useful for your research, please cite the following work.
+```
+@inproceedings{kangle2023pix2pix3d,
+  title={3D-aware Conditional Image Synthesis},
+  author={Deng, Kangle and Yang, Gengshan and Ramanan, Deva and Zhu, Jun-Yan},
+  booktitle = {CVPR},
+  year = {2023}
+}
+```
+
+---
+
+## Acknowledgments
+We thank Sheng-Yu Wang, Nupur Kumari, Gaurav Parmer, Ruihan Gao, Muyang Li, George Cazenavette, Andrew Song, Zhipeng Bao, Tamaki Kojima, Krishna Wadhwani, Takuya Narihira, and Tatsuo Fujiwara for their discussion and help. We are grateful for the support from Sony Corporation, Singapore DSTA, and the CMU Argo AI Center for Autonomous Vehicle Research.
+This codebase borrows heavily from [EG3D](https://github.com/NVlabs/eg3d) and [StyleNeRF](https://github.com/facebookresearch/StyleNeRF). 

pix2pix3D-main/pix2pix3D-main/applications/demo/qt_demo_seg2cat.py

@@ -0,0 +1,504 @@
+import sys
+sys.path.append('./')
+
+import os
+import cv2
+import time
+import numpy as np
+from PIL import Image
+
+import torch
+from torchvision.utils import save_image
+
+from ui_qt.ui_clean import Ui_Form_Seg2cat as Ui_Form
+from ui_qt.mouse_event import GraphicsScene
+
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
+from PyQt5.QtWidgets import *
+from PyQt5.QtPrintSupport import QPrintDialog, QPrinter
+
+import dnnlib
+import legacy
+from torch_utils import misc
+
+from camera_utils import LookAtPoseSampler, FOV_to_intrinsics
+from torch_utils import misc
+from training.triplane_cond import TriPlaneGenerator
+from training.training_loop import setup_snapshot_image_grid, get_image_grid, save_image_grid
+from train import init_conditional_dataset_kwargs
+
+from matplotlib import pyplot as plt
+
+from pathlib import Path
+
+from rich.progress import track
+import json
+
+import imageio
+
+from torch import nn
+import torch.nn.functional as F
+
+import argparse
+
+from scipy.spatial.transform import Rotation as R
+
+from training.utils import color_mask as color_mask_np
+
+color_list = [QColor(255, 255, 255), QColor(204, 0, 0), QColor(76, 153, 0), QColor(204, 204, 0), QColor(51, 51, 255), QColor(204, 0, 204), QColor(0, 255, 255), QColor(255, 204, 204), QColor(102, 51, 0), QColor(255, 0, 0), QColor(102, 204, 0), QColor(255, 255, 0), QColor(0, 0, 153), QColor(0, 0, 204), QColor(255, 51, 153), QColor(0, 204, 204), QColor(0, 51, 0), QColor(255, 153, 51), QColor(0, 204, 0)]
+
+def color_mask(m):
+    my_color_list = [[255, 255, 255], [204, 0, 0], [76, 153, 0], [204, 204, 0], [51, 51, 255], [204, 0, 204], [0, 255, 255], [255, 204, 204], [102, 51, 0], [255, 0, 0], [102, 204, 0], [255, 255, 0], [0, 0, 153], [0, 0, 204], [255, 51, 153], [0, 204, 204], [0, 51, 0], [255, 153, 51], [0, 204, 0]]
+    if len(m.shape) == 2:
+        im_base = np.zeros((m.shape[0], m.shape[1], 3))
+        for idx, color in enumerate(my_color_list):
+            im_base[m == idx] = color
+        return im_base
+    elif len(m.shape) == 3:
+        im_base = np.zeros((m.shape[0], m.shape[1], m.shape[2], 3))
+        for idx, color in enumerate(my_color_list):
+            im_base[m == idx] = color
+        return im_base
+
+def get_camera_traj(model, pitch, yaw, fov=12, batch_size=1, device='cuda'):
+    gen = model.synthesis
+    range_u, range_v = gen.C.range_u, gen.C.range_v
+    u = (yaw - range_u[0]) / (range_u[1] - range_u[0])
+    v = (pitch - range_v[0]) / (range_v[1] - range_v[0])
+    cam = gen.get_camera(batch_size=batch_size, mode=[u, v, 0.5], device=device, fov=fov)
+    return cam
+
+def get_yaw_pitch(cam2world):
+    forward = cam2world[0:3, 2]
+    yaw = np.arctan2(forward[0], forward[2]) - np.pi / 2
+    phi = np.arccos(forward[1])
+    v = (1 - np.cos(phi)) / 2
+    pitch = (1+forward[1]) / 2 * np.pi
+    return yaw, pitch
+
+def create_cam2world_fromeuler(euler, radius):
+    r = R.from_euler('zyx', euler, degrees=False)
+    cam2world = r.as_matrix()
+    cam2world = np.concatenate([cam2world, np.array([[0, 0, 0]])], axis=0)
+    cam2world = np.concatenate([cam2world, np.array([0, 0, 0, 1])[...,None]], axis=1)
+    cam2world[:3, 3] = -cam2world[:3, 2] * radius
+    return cam2world
+
+class Ex(QWidget, Ui_Form):
+    def __init__(self):
+        super(Ex, self).__init__()
+        self.size = 35
+        self.yaw = 100
+        self.pitch = 50
+        self.roll = 0
+        self.truncation = 0.75
+        
+        self.setupUi(self)
+        self.show()
+        self.output_img = None
+
+        self.mat_img = None
+
+        self.mode = 0
+        self.mask = None
+        self.mask_m = np.ones((512, 512, 1), dtype=np.uint8) * 255
+        self.img = None
+
+        self.mouse_clicked = False
+        self.scene = GraphicsScene(self.mode, self.size)
+        self.graphicsView.setScene(self.scene)
+        self.graphicsView.setAlignment(Qt.AlignTop | Qt.AlignLeft)
+        self.graphicsView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.graphicsView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+
+        self.result_scene = QGraphicsScene()
+        self.graphicsView_2.setScene(self.result_scene)
+        self.graphicsView_2.setAlignment(Qt.AlignTop | Qt.AlignLeft)
+        self.graphicsView_2.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.graphicsView_2.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+
+        self.dlg = QColorDialog(self.graphicsView)
+        self.color = None
+        self.device = torch.device('cuda')
+
+        # Parse arguments
+        parser = argparse.ArgumentParser(description='Real-time 3D editing demo')
+        parser.add_argument('--network', help='Path to the network pickle file', required=True)
+        parser.add_argument('--data_dir', default='data/', help='Directory to the data', required=False)
+        args = parser.parse_args()
+
+        network_pkl = args.network
+        self.G = self.get_model(network_pkl)
+        
+        # Initialize dataset.
+        data_path = Path(args.data_dir) / 'afhq_v2_train_cat_512.zip'
+        mask_data = Path(args.data_dir) / 'afhqcat_seg_6c.zip'
+        data_type= 'seg'
+        dataset_kwargs, dataset_name = init_conditional_dataset_kwargs(data_path, mask_data, data_type)
+        self.training_data = dnnlib.util.construct_class_by_name(**dataset_kwargs)
+        
+        self.input_batch = None
+        # self.ws = None
+        self.ws_texture = None
+
+        self.buffer_mask = None
+
+        focal_length = 4.2647 # shapenet has higher FOV
+        self.intrinsics = torch.tensor([[focal_length, 0, 0.5], [0, focal_length, 0.5], [0, 0, 1]], device=self.device)
+
+        os.makedirs('examples/ui', exist_ok=True)
+
+
+    def open(self):
+        fileName, _ = QFileDialog.getOpenFileName(self, "Open File",
+                QDir.currentPath())
+        if fileName:
+            image = QPixmap(fileName)
+            mat_img = Image.open(fileName)
+            self.img = mat_img.copy()
+            if image.isNull():
+                QMessageBox.information(self, "Image Viewer",
+                        "Cannot load %s." % fileName)
+                return
+            image = image.scaled(self.graphicsView.size(), Qt.IgnoreAspectRatio)
+        
+            if len(self.ref_scene.items())>0:
+                self.ref_scene.removeItem(self.ref_scene.items()[-1])
+            self.ref_scene.addPixmap(image)
+            if len(self.result_scene.items())>0:
+                self.result_scene.removeItem(self.result_scene.items()[-1])
+            self.result_scene.addPixmap(image)
+
+    def open_mask(self):
+        fileName, _ = QFileDialog.getOpenFileName(self, "Open File",
+                QDir.currentPath())
+        if fileName:    
+            mat_img = cv2.imread(fileName)
+            self.mask = mat_img.copy()
+            self.mask_m = mat_img     
+            mat_img = mat_img.copy()
+            image = QImage(mat_img, 512, 512, QImage.Format_RGB888)
+
+            if image.isNull():
+                QMessageBox.information(self, "Image Viewer",
+                        "Cannot load %s." % fileName)
+                return    
+
+            for i in range(512):
+                for j in range(512):
+                    r, g, b, a = image.pixelColor(i, j).getRgb()
+                    image.setPixel(i, j, color_list[r].rgb()) 
+           
+            pixmap = QPixmap()
+            pixmap.convertFromImage(image)  
+            self.image = pixmap.scaled(self.graphicsView.size(), Qt.IgnoreAspectRatio)
+            self.scene.reset()
+            if len(self.scene.items())>0:
+                self.scene.reset_items() 
+            self.scene.addPixmap(self.image)
+
+
+    def bg_mode(self):
+        self.scene.mode = 0
+
+    def skin_mode(self):
+        self.scene.mode = 1
+
+    def nose_mode(self):
+        self.scene.mode = 2
+
+    def eye_g_mode(self):
+        self.scene.mode = 3
+
+    def l_eye_mode(self):
+        self.scene.mode = 4
+
+    def r_eye_mode(self):
+        self.scene.mode = 5
+
+    def l_brow_mode(self):
+        self.scene.mode = 6
+
+    def r_brow_mode(self):
+        self.scene.mode = 7
+
+    def l_ear_mode(self):
+        self.scene.mode = 8
+
+    def r_ear_mode(self):
+        self.scene.mode = 9
+
+    def mouth_mode(self):
+        self.scene.mode = 10
+
+    def u_lip_mode(self):
+        self.scene.mode = 11
+
+    def l_lip_mode(self):
+        self.scene.mode = 12
+
+    def hair_mode(self):
+        self.scene.mode = 13
+
+    def hat_mode(self):
+        self.scene.mode = 14
+
+    def ear_r_mode(self):
+        self.scene.mode = 15
+
+    def neck_l_mode(self):
+        self.scene.mode = 16
+
+    def neck_mode(self):
+        self.scene.mode = 17
+
+    def cloth_mode(self):
+        self.scene.mode = 18
+
+    def increase(self):
+        if self.scene.size < 50:
+            self.scene.size += 1
+    
+    def decrease(self):
+        if self.scene.size > 1:
+            self.scene.size -= 1 
+
+    def changeBrushSize(self, s):
+        self.scene.size = s
+
+    def changeYaw(self, s):
+        self.yaw = s
+        if self.ws is not None:
+            self.generate()
+
+    def changePitch(self, s):
+        self.pitch = s
+        # print('changing pitch', self.pitch)
+        if self.ws is not None:
+            self.generate()
+
+    def changeRoll(self, s):
+        self.roll = s
+        if self.ws is not None:
+            self.generate()
+
+    def changeTruncation(self, s):
+        self.truncation = s / 100
+        self.reconstruct()
+        self.generate()
+
+    def inputID(self):
+        input_id = int(self.text_inputID.toPlainText())
+        self.input_batch = self.training_data[input_id]
+
+        self.mask = self.input_batch['mask'].transpose(1,2,0).astype(np.uint8)
+        # self.mask_m = self.input_batch['mask'].transpose(1,2,0).astype(np.uint8)
+        mat_img = cv2.resize(self.mask[:,:,0], (512, 512), interpolation=cv2.INTER_NEAREST)
+        self.mask = mat_img[:,:,np.newaxis]
+        self.mask_m = self.mask.copy()
+        image = QImage(mat_img, 512, 512, QImage.Format_RGB888)
+
+
+        for i in range(512):
+            for j in range(512):
+                # r, g, b, a = image.pixelColor(i, j).getRgb()
+                r = mat_img[j, i]
+                # print(r)
+                image.setPixel(i, j, color_list[r].rgb()) 
+        
+        pixmap = QPixmap()
+        pixmap.convertFromImage(image)  
+        self.image = pixmap.scaled(self.graphicsView.size(), Qt.IgnoreAspectRatio)
+        self.scene.reset()
+        if len(self.scene.items())>0:
+            self.scene.reset_items() 
+        self.scene.addPixmap(self.image)
+
+        self.ws = None
+
+        roll, yaw, pitch = R.from_matrix(self.input_batch['pose'][:16].reshape(4,4)[:3,:3]).as_euler('zyx', degrees=False)
+        # print(yaw, pitch)
+        # print(self.input_batch['pose'][:16].reshape(4, 4))
+        pitch_range = np.pi
+        yaw_range = np.pi / 2
+        roll_range = np.pi / 4
+
+        pitch = pitch - np.pi
+        pitch = pitch + 2 * np.pi if pitch < -np.pi else pitch
+
+        self.yaw = ((yaw) / yaw_range * 100)
+        self.pitch = ((pitch) / pitch_range * 100)
+        self.roll = ((roll) / (roll_range) * 100)
+        print(self.roll, self.yaw, self.pitch)
+
+        self.intrinsics = torch.tensor(self.input_batch['pose'][16:].reshape(3,3)).float().to(self.device)
+
+
+        self.slider_yawselect.setValue(self.yaw)
+        self.slider_pitchselect.setValue(self.pitch)
+        self.slider_rollselect.setValue(self.roll)
+
+
+    def get_mask(self): # get from output
+        mat_img = self.buffer_mask[0].astype(np.uint8)
+
+        # print(self.mask.shape)
+        # mat_img = cv2.resize(mat_img, (512, 512), interpolation=cv2.INTER_NEAREST)
+        self.mask = mat_img[:,:,np.newaxis]
+        self.mask_m = self.mask.copy()
+        # print(mat_img.shape)
+        image = QImage(mat_img, 512, 512, QImage.Format_RGB888)
+
+
+        for i in range(512):
+            for j in range(512):
+                # r, g, b, a = image.pixelColor(i, j).getRgb()
+                r = mat_img[j, i]
+                # print(r)
+                image.setPixel(i, j, color_list[r].rgb()) 
+        
+        pixmap = QPixmap()
+        pixmap.convertFromImage(image)  
+        self.image = pixmap.scaled(self.graphicsView.size(), Qt.IgnoreAspectRatio)
+        self.scene.reset()
+        if len(self.scene.items())>0:
+            self.scene.reset_items() 
+        self.scene.addPixmap(self.image)
+
+
+
+    def generate(self):
+        ws = self.ws
+
+        pitch_range = np.pi
+        yaw_range = np.pi / 2
+        roll_range = np.pi / 4
+        pitch = self.pitch / 100 * pitch_range
+        yaw = self.yaw / 100 * yaw_range
+        roll = self.roll / 100 * roll_range
+        
+        cam2world_pose = torch.tensor(create_cam2world_fromeuler([roll, yaw, pitch+np.pi], radius=2.7)).float().to(self.device)
+
+        # print(cam2world_pose)
+        pose = torch.cat([cam2world_pose.reshape(-1, 16), self.intrinsics.reshape(-1, 9)], 1)
+
+        out = self.G.synthesis(ws, pose.to(self.device), noise_mode='const', neural_rendering_resolution=128)
+        img = ((out['image'].permute(0,2,3,1).squeeze(0).cpu().numpy().clip(-1, 1) * 0.5 + 0.5) * 255).astype(np.uint8).copy()
+        if out['image'].shape[-1] != 512:
+            # print(f"Resizing {out['image'].shape[-1]} to {512}")
+            img = cv2.resize(img, (512, 512))
+
+        qim = QImage(img.data, img.shape[1], img.shape[0], img.strides[0], QImage.Format_RGB888)
+        if len(self.result_scene.items())>0:
+            self.result_scene.removeItem(self.result_scene.items()[-1])
+        self.result_scene.addPixmap(QPixmap.fromImage(qim))
+
+        self.buffer_mask = torch.argmax(out['semantic'].detach(), dim=1).cpu().numpy() # 1 x 512 x 512
+        self.output_img = img.copy()
+        self.get_mask()
+
+
+    def reconstruct(self):
+        if self.input_batch is None:
+            return
+        ws = self.ws
+
+        out = self.G.synthesis(ws, torch.tensor(self.input_batch['pose']).unsqueeze(0).to(self.device))
+        if out['img'].shape[-1] != 512:
+            print(f"Resizing {out['img'].shape[-1]} to {512}")
+            img = resize_image(out['img'].detach(), 512)
+        else:
+            img = out['img'].detach()
+        img = ((img.permute(0,2,3,1).squeeze(0).cpu().numpy().clip(-1, 1) * 0.5 + 0.5) * 255).astype(np.uint8).copy()
+        qim = QImage(img.data, img.shape[1], img.shape[0], img.strides[0], QImage.Format_RGB888)
+        if len(self.ref_scene.items())>0:
+            self.ref_scene.removeItem(self.ref_scene.items()[-1])
+        self.ref_scene.addPixmap(QPixmap.fromImage(qim))
+
+        if out['semantic'].shape[-1] != 512:
+            seg = resize_image(out['semantic'].detach(), 512)
+        else:
+            seg = out['semantic'].detach()
+        seg = color_mask(torch.argmax(seg, dim=1).cpu())[0].astype(np.uint8).copy()
+        qim = QImage(seg.data, seg.shape[1], seg.shape[0], seg.strides[0], QImage.Format_RGB888)
+        if len(self.ref_seg_scene.items())>0:
+            self.ref_seg_scene.removeItem(self.ref_seg_scene.items()[-1])
+        self.ref_seg_scene.addPixmap(QPixmap.fromImage(qim))
+
+    def get_ws(self):
+        z = torch.from_numpy(np.random.RandomState(int(self.text_seed.toPlainText())).randn(1, self.G.z_dim).astype('float32')).to(self.device)
+    
+        for i in range(6):
+            self.mask_m = self.make_mask(self.mask_m, self.scene.mask_points[i], self.scene.size_points[i], i)
+        
+        cv2.imwrite('examples/ui/mask_input.png', self.mask_m)
+
+        forward_cam2world_pose = LookAtPoseSampler.sample(3.14/2, 3.14/2, torch.tensor(self.G.rendering_kwargs['avg_camera_pivot'], device=self.device), 
+                                                radius=self.G.rendering_kwargs['avg_camera_radius'], device=self.device)
+        focal_length = 4.2647 # shapenet has higher FOV
+        intrinsics = torch.tensor([[focal_length, 0, 0.5], [0, focal_length, 0.5], [0, 0, 1]], device=self.device)
+        forward_pose = torch.cat([forward_cam2world_pose.reshape(-1, 16), intrinsics.reshape(-1, 9)], 1)
+        
+        self.ws = self.G.mapping(z, forward_pose.to(self.device), 
+                        {'mask': torch.tensor(self.mask_m[None,...,0]).unsqueeze(0).to(self.device), 'pose': torch.tensor(self.input_batch['pose']).unsqueeze(0).to(self.device)})
+
+        if self.ws_texture is None:
+            self.ws_texture = self.ws[:,8:,:]
+        else:
+            self.ws[:,8:,:] = self.ws_texture
+        # print(self.ws[:,8:,:])
+
+    
+    def generateAndReconstruct(self):
+        self.get_ws()
+        self.generate()
+        # self.reconstruct()
+
+
+    def make_mask(self, mask, pts, sizes, color):
+        if len(pts)>0:
+            for idx, pt in enumerate(pts):
+                cv2.line(mask,pt['prev'],pt['curr'],(color,color,color),sizes[idx])
+        return mask
+
+    def save_img(self):
+        for i in range(6):
+            self.mask_m = self.make_mask(self.mask_m, self.scene.mask_points[i], self.scene.size_points[i], i)
+        mask_np = np.array(self.mask_m)[..., 0]
+        print(mask_np.shape)
+        cv2.imwrite('examples/ui/mask.png', mask_np)
+        cv2.imwrite('examples/ui/mask_color.png', color_mask_np(mask_np).astype(np.uint8)[...,::-1])
+        cv2.imwrite('examples/ui/output.png',self.output_img[...,::-1])
+
+
+    def undo(self):
+        self.scene.undo()
+
+    def clear(self):
+        self.mask_m = self.mask.copy()
+    
+        self.scene.reset_items()
+        self.scene.reset()
+        if type(self.image):
+            self.scene.addPixmap(self.image)
+
+        if len(self.result_scene.items())>0:
+            self.result_scene.removeItem(self.result_scene.items()[-1])
+
+        self.ws = None
+
+    def get_model(self, network_pkl):
+        device = torch.device('cuda')
+        with dnnlib.util.open_url(network_pkl) as f:
+            G = legacy.load_network_pkl(f)['G_ema'].eval().to(device)
+
+        return G
+
+    def clear_ws(self):
+        self.ws = None
+
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+    ex = Ex()
+    sys.exit(app.exec_())

pix2pix3D-main/pix2pix3D-main/applications/demo/ui_qt/mouse_event.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
+from PyQt5.QtWidgets import *
+import numpy as np
+
+color_list = [QColor(255, 255, 255), QColor(204, 0, 0), QColor(76, 153, 0), QColor(204, 204, 0), QColor(51, 51, 255), QColor(204, 0, 204), QColor(0, 255, 255), QColor(255, 204, 204), QColor(102, 51, 0), QColor(255, 0, 0), QColor(102, 204, 0), QColor(255, 255, 0), QColor(0, 0, 153), QColor(0, 0, 204), QColor(255, 51, 153), QColor(0, 204, 204), QColor(0, 51, 0), QColor(255, 153, 51), QColor(0, 204, 0)]
+
+class GraphicsScene(QGraphicsScene):
+    def __init__(self, mode, size, parent=None):
+        QGraphicsScene.__init__(self, parent)
+        self.mode = mode
+        self.size = size
+        self.mouse_clicked = False
+        self.prev_pt = None
+
+        # self.masked_image = None
+
+        # save the points
+        self.mask_points = []
+        for i in range(len(color_list)):
+            self.mask_points.append([])
+
+        # save the size of points
+        self.size_points = []
+        for i in range(len(color_list)):
+            self.size_points.append([])
+
+        # save the history of edit
+        self.history = []
+
+    def reset(self):
+        # save the points
+        self.mask_points = []
+        for i in range(len(color_list)):
+            self.mask_points.append([])
+        # save the size of points
+        self.size_points = []
+        for i in range(len(color_list)):
+            self.size_points.append([])
+        # save the history of edit
+        self.history = []
+
+        self.mode = 0
+        self.prev_pt = None
+
+    def mousePressEvent(self, event):
+        self.mouse_clicked = True
+
+    def mouseReleaseEvent(self, event):
+        self.prev_pt = None
+        self.mouse_clicked = False
+
+    def mouseMoveEvent(self, event): # drawing
+        if self.mouse_clicked:
+            if self.prev_pt:
+                self.drawMask(self.prev_pt, event.scenePos(), color_list[self.mode], self.size)
+                pts = {}
+                pts['prev'] = (int(self.prev_pt.x()),int(self.prev_pt.y()))
+                pts['curr'] = (int(event.scenePos().x()),int(event.scenePos().y()))
+        
+                self.size_points[self.mode].append(self.size)
+                self.mask_points[self.mode].append(pts)
+                self.history.append(self.mode)
+                self.prev_pt = event.scenePos()
+            else:
+                self.prev_pt = event.scenePos()
+
+    def drawMask(self, prev_pt, curr_pt, color, size):
+        lineItem = QGraphicsLineItem(QLineF(prev_pt, curr_pt))
+        lineItem.setPen(QPen(color, size, Qt.SolidLine)) # rect
+        self.addItem(lineItem)
+
+    def erase_prev_pt(self):
+        self.prev_pt = None
+
+    def reset_items(self):
+        for i in range(len(self.items())):
+            item = self.items()[0]
+            self.removeItem(item)
+        
+    def undo(self):
+        if len(self.items())>1:
+            if len(self.items())>=9:
+                for i in range(8):
+                    item = self.items()[0]
+                    self.removeItem(item)
+                    if self.history[-1] == self.mode:
+                        self.mask_points[self.mode].pop()
+                        self.size_points[self.mode].pop()
+                        self.history.pop()
+            else:
+                for i in range(len(self.items())-1):
+                    item = self.items()[0]
+                    self.removeItem(item)
+                    if self.history[-1] == self.mode:
+                        self.mask_points[self.mode].pop()
+                        self.size_points[self.mode].pop()
+                        self.history.pop() 

pix2pix3D-main/pix2pix3D-main/applications/demo/ui_qt/ui.py

@@ -0,0 +1,988 @@
+from PyQt5 import QtCore, QtGui, QtWidgets
+from PyQt5.QtCore import Qt
+
+class Ui_Form(object):
+    def setupUi(self, Form):
+        Form.setObjectName("Form")
+        Form.resize(1800, 660)
+        self.pushButton = QtWidgets.QPushButton(Form)
+        # self.pushButton.setGeometry(QtCore.QRect(1160, 360, 81, 27))
+        self.pushButton.setGeometry(QtCore.QRect(535, 360, 81, 27))
+        self.pushButton.setObjectName("pushButton")
+        self.pushButton_2 = QtWidgets.QPushButton(Form)
+        self.pushButton_2.setGeometry(QtCore.QRect(10, 10, 97, 27))
+        self.pushButton_2.setObjectName("pushButton_2")
+        self.pushButton_3 = QtWidgets.QPushButton(Form)
+        self.pushButton_3.setGeometry(QtCore.QRect(10, 40, 97, 27))
+        self.pushButton_3.setObjectName("pushButton_3")
+        self.pushButton_4 = QtWidgets.QPushButton(Form)
+        self.pushButton_4.setGeometry(QtCore.QRect(130, 10, 97, 27))
+        self.pushButton_4.setObjectName("pushButton_4")
+        self.pushButton_5 = QtWidgets.QPushButton(Form)
+        self.pushButton_5.setGeometry(QtCore.QRect(130, 40, 97, 27))
+        self.pushButton_5.setObjectName("pushButton_5")
+        self.pushButton_6 = QtWidgets.QPushButton(Form)
+        self.pushButton_6.setGeometry(QtCore.QRect(250, 10, 97, 27))
+        self.pushButton_6.setObjectName("pushButton_6")
+        self.pushButton_7 = QtWidgets.QPushButton(Form)
+        self.pushButton_7.setGeometry(QtCore.QRect(250, 40, 97, 27))
+        self.pushButton_7.setObjectName("pushButton_7")
+        self.pushButton_8 = QtWidgets.QPushButton(Form)
+        self.pushButton_8.setGeometry(QtCore.QRect(450, 10, 97, 27))
+        self.pushButton_8.setObjectName("pushButton_8")
+        self.pushButton_9 = QtWidgets.QPushButton(Form)
+        self.pushButton_9.setGeometry(QtCore.QRect(450, 40, 97, 27))
+        self.pushButton_9.setObjectName("pushButton_9")
+        self.pushButton_10 = QtWidgets.QPushButton(Form)
+        self.pushButton_10.setGeometry(QtCore.QRect(570, 10, 97, 27))
+        self.pushButton_10.setObjectName("pushButton_10")
+        self.pushButton_11 = QtWidgets.QPushButton(Form)
+        self.pushButton_11.setGeometry(QtCore.QRect(570, 40, 97, 27))
+        self.pushButton_11.setObjectName("pushButton_11")
+        self.pushButton_12 = QtWidgets.QPushButton(Form)
+        self.pushButton_12.setGeometry(QtCore.QRect(690, 10, 97, 27))
+        self.pushButton_12.setObjectName("pushButton_12")
+        self.pushButton_13 = QtWidgets.QPushButton(Form)
+        self.pushButton_13.setGeometry(QtCore.QRect(690, 40, 97, 27))
+        self.pushButton_13.setObjectName("pushButton_13")
+        self.pushButton_14 = QtWidgets.QPushButton(Form)
+        self.pushButton_14.setGeometry(QtCore.QRect(810, 10, 97, 27))
+        self.pushButton_14.setObjectName("pushButton_14")
+        self.pushButton_15 = QtWidgets.QPushButton(Form)
+        self.pushButton_15.setGeometry(QtCore.QRect(810, 40, 97, 27))
+        self.pushButton_15.setObjectName("pushButton_15")
+        self.pushButton_16 = QtWidgets.QPushButton(Form)
+        self.pushButton_16.setGeometry(QtCore.QRect(930, 10, 97, 27))
+        self.pushButton_16.setObjectName("pushButton_16")
+        self.pushButton_17 = QtWidgets.QPushButton(Form)
+        self.pushButton_17.setGeometry(QtCore.QRect(930, 40, 97, 27))
+        self.pushButton_17.setObjectName("pushButton_17")
+        self.pushButton_18 = QtWidgets.QPushButton(Form)
+        self.pushButton_18.setGeometry(QtCore.QRect(1050, 10, 97, 27))
+        self.pushButton_18.setObjectName("pushButton_18")
+        self.pushButton_19 = QtWidgets.QPushButton(Form)
+        self.pushButton_19.setGeometry(QtCore.QRect(1050, 40, 97, 27))
+        self.pushButton_19.setObjectName("pushButton_19")
+        self.pushButton_20 = QtWidgets.QPushButton(Form)
+        self.pushButton_20.setGeometry(QtCore.QRect(1170, 10, 97, 27))
+        self.pushButton_20.setObjectName("pushButton_20")
+        self.pushButton_21 = QtWidgets.QPushButton(Form)
+        self.pushButton_21.setGeometry(QtCore.QRect(1170, 40, 97, 27))
+        self.pushButton_21.setObjectName("pushButton_21")
+        self.pushButton_22 = QtWidgets.QPushButton(Form)
+        self.pushButton_22.setGeometry(QtCore.QRect(1290, 10, 97, 27))
+        self.pushButton_22.setObjectName("pushButton_22")
+        self.pushButton_23 = QtWidgets.QPushButton(Form)
+        self.pushButton_23.setGeometry(QtCore.QRect(1290, 40, 97, 27))
+        self.pushButton_23.setObjectName("pushButton_23")
+        self.pushButton_24 = QtWidgets.QPushButton(Form)
+        self.pushButton_24.setGeometry(QtCore.QRect(1410, 10, 97, 27))
+        self.pushButton_24.setObjectName("pushButton_24")
+        self.pushButton_25 = QtWidgets.QPushButton(Form)
+        self.pushButton_25.setGeometry(QtCore.QRect(1410, 40, 97, 27))
+        self.pushButton_25.setObjectName("pushButton_25")
+        # self.pushButton_26 = QtWidgets.QPushButton(Form)
+        # self.pushButton_26.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+        # self.pushButton_26.setObjectName("pushButton_26")
+        # self.pushButton_27 = QtWidgets.QPushButton(Form)
+        # self.pushButton_27.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+        # self.pushButton_27.setObjectName("pushButton_27")
+
+
+        self.slider_sizeselect = QtWidgets.QSlider(Form)
+        self.slider_sizeselect.setRange(10,70)
+        self.slider_sizeselect.setOrientation(Qt.Horizontal)
+        self.slider_sizeselect.setValue(Form.size)
+        self.slider_sizeselect.setGeometry(QtCore.QRect(1530, 70, 97, 27))
+
+        self.label_sizeselect = QtWidgets.QLabel(Form)
+        self.label_sizeselect.setText("Brush Size")
+        self.label_sizeselect.setGeometry(QtCore.QRect(1630, 70, 97, 27))
+
+        self.slider_yawselect = QtWidgets.QSlider(Form)
+        self.slider_yawselect.setRange(-100,100)
+        self.slider_yawselect.setOrientation(Qt.Horizontal)
+        self.slider_yawselect.setValue(Form.yaw)
+        self.slider_yawselect.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+
+        self.label_yawselect = QtWidgets.QLabel(Form)
+        self.label_yawselect.setText("Yaw")
+        self.label_yawselect.setGeometry(QtCore.QRect(1630, 10, 97, 27))
+
+        self.slider_pitchselect = QtWidgets.QSlider(Form)
+        self.slider_pitchselect.setRange(-100,100)
+        self.slider_pitchselect.setOrientation(Qt.Horizontal)
+        self.slider_pitchselect.setValue(Form.pitch)
+        self.slider_pitchselect.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+
+        self.label_pitchselect = QtWidgets.QLabel(Form)
+        self.label_pitchselect.setText("Pitch")
+        self.label_pitchselect.setGeometry(QtCore.QRect(1630, 40, 97, 27))
+
+        self.text_inputID = QtWidgets.QTextEdit(Form)
+        self.text_inputID.setGeometry(QtCore.QRect(10, 70, 40, 27))
+        self.text_inputID.setObjectName("text_inputID")
+
+        self.pushButton_inputID = QtWidgets.QPushButton(Form)
+        self.pushButton_inputID.setGeometry(QtCore.QRect(60, 70, 60, 27))
+        self.pushButton_inputID.setObjectName("pushButton_inputID")
+
+        self.text_seed = QtWidgets.QTextEdit(Form)
+        self.text_seed.setGeometry(QtCore.QRect(140, 70, 40, 27))
+        self.text_seed.setObjectName("text_seed")
+        self.text_seed.setPlainText("0")
+
+        self.label_seed = QtWidgets.QLabel(Form)
+        self.label_seed.setText("Seed")
+        self.label_seed.setGeometry(QtCore.QRect(190, 70, 97, 27))
+
+
+
+
+        self.graphicsView = QtWidgets.QGraphicsView(Form)
+        self.graphicsView.setGeometry(QtCore.QRect(20, 120, 512, 512))
+        self.graphicsView.setObjectName("graphicsView")
+        self.graphicsView_2 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_2.setGeometry(QtCore.QRect(620, 120, 512, 512))
+        self.graphicsView_2.setObjectName("graphicsView_2") 
+        self.graphicsView_3 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_3.setGeometry(QtCore.QRect(1260, 120, 512, 512))
+        self.graphicsView_3.setObjectName("graphicsView_3")
+
+
+        self.retranslateUi(Form)
+        self.pushButton.clicked.connect(Form.generateAndReconstruct)
+        self.pushButton_2.clicked.connect(Form.open)
+        self.pushButton_3.clicked.connect(Form.open_mask)
+        self.pushButton_4.clicked.connect(Form.clear)
+        self.pushButton_5.clicked.connect(Form.undo)
+        self.pushButton_6.clicked.connect(Form.save_img)
+        self.pushButton_7.clicked.connect(Form.bg_mode)
+        self.pushButton_8.clicked.connect(Form.skin_mode)
+        self.pushButton_9.clicked.connect(Form.nose_mode)
+        self.pushButton_10.clicked.connect(Form.eye_g_mode)
+        self.pushButton_11.clicked.connect(Form.l_eye_mode)
+        self.pushButton_12.clicked.connect(Form.r_eye_mode)
+        self.pushButton_13.clicked.connect(Form.l_brow_mode)
+        self.pushButton_14.clicked.connect(Form.r_brow_mode)
+        self.pushButton_15.clicked.connect(Form.l_ear_mode)
+        self.pushButton_16.clicked.connect(Form.r_ear_mode)
+        self.pushButton_17.clicked.connect(Form.mouth_mode)
+        self.pushButton_18.clicked.connect(Form.u_lip_mode)
+        self.pushButton_19.clicked.connect(Form.l_lip_mode)
+        self.pushButton_20.clicked.connect(Form.hair_mode)
+        self.pushButton_21.clicked.connect(Form.hat_mode)
+        self.pushButton_22.clicked.connect(Form.ear_r_mode)
+        self.pushButton_23.clicked.connect(Form.neck_l_mode)
+        self.pushButton_24.clicked.connect(Form.neck_mode)
+        self.pushButton_25.clicked.connect(Form.cloth_mode)
+        # self.pushButton_26.clicked.connect(Form.increase)
+        # self.pushButton_27.clicked.connect(Form.decrease)
+        
+
+        self.slider_sizeselect.valueChanged.connect(Form.changeBrushSize)
+        self.slider_yawselect.valueChanged.connect(Form.changeYaw)
+        self.slider_pitchselect.valueChanged.connect(Form.changePitch)
+
+        self.pushButton_inputID.clicked.connect(Form.inputID)
+
+        QtCore.QMetaObject.connectSlotsByName(Form)
+
+    def retranslateUi(self, Form):
+        _translate = QtCore.QCoreApplication.translate
+        Form.setWindowTitle(_translate("Form", "3D-GauGAN"))
+        self.pushButton.setText(_translate("Form", "Generate"))
+        self.pushButton_2.setText(_translate("Form", "Open Image"))
+        self.pushButton_3.setText(_translate("Form", "Open Mask"))
+        self.pushButton_4.setText(_translate("Form", "Clear"))
+        self.pushButton_5.setText(_translate("Form", "Undo"))
+        self.pushButton_6.setText(_translate("Form", "Save Image"))
+        self.pushButton_7.setText(_translate("Form", "BackGround"))
+        self.pushButton_8.setText(_translate("Form", "Skin"))
+        self.pushButton_9.setText(_translate("Form", "Nose"))
+        self.pushButton_10.setText(_translate("Form", "Eyeglass"))
+        self.pushButton_11.setText(_translate("Form", "Left Eye"))
+        self.pushButton_12.setText(_translate("Form", "Right Eye"))
+        self.pushButton_13.setText(_translate("Form", "Left Eyebrow"))
+        self.pushButton_14.setText(_translate("Form", "Right Eyebrow"))
+        self.pushButton_15.setText(_translate("Form", "Left ear"))
+        self.pushButton_16.setText(_translate("Form", "Right ear"))
+        self.pushButton_17.setText(_translate("Form", "Mouth"))
+        self.pushButton_18.setText(_translate("Form", "Upper Lip"))
+        self.pushButton_19.setText(_translate("Form", "Lower Lip"))
+        self.pushButton_20.setText(_translate("Form", "Hair"))
+        self.pushButton_21.setText(_translate("Form", "Hat"))
+        self.pushButton_22.setText(_translate("Form", "Earring"))
+        self.pushButton_23.setText(_translate("Form", "Necklace"))
+        self.pushButton_24.setText(_translate("Form", "Neck"))
+        self.pushButton_25.setText(_translate("Form", "Cloth"))
+        # self.pushButton_26.setText(_translate("Form", "+"))
+        # self.pushButton_27.setText(_translate("Form", "-"))
+        self.pushButton_inputID.setText(_translate("Form", "Input ID"))
+
+
+class Ui_Form_Seg(object):
+    def setupUi(self, Form):
+        Form.setObjectName("Form")
+        Form.resize(1800, 1260)
+        self.pushButton = QtWidgets.QPushButton(Form)
+        # self.pushButton.setGeometry(QtCore.QRect(1160, 360, 81, 27))
+        self.pushButton.setGeometry(QtCore.QRect(535, 360, 81, 27))
+        self.pushButton.setObjectName("pushButton")
+        self.pushButton_2 = QtWidgets.QPushButton(Form)
+        self.pushButton_2.setGeometry(QtCore.QRect(10, 10, 97, 27))
+        self.pushButton_2.setObjectName("pushButton_2")
+        self.pushButton_3 = QtWidgets.QPushButton(Form)
+        self.pushButton_3.setGeometry(QtCore.QRect(10, 40, 97, 27))
+        self.pushButton_3.setObjectName("pushButton_3")
+        self.pushButton_4 = QtWidgets.QPushButton(Form)
+        self.pushButton_4.setGeometry(QtCore.QRect(130, 10, 97, 27))
+        self.pushButton_4.setObjectName("pushButton_4")
+        self.pushButton_5 = QtWidgets.QPushButton(Form)
+        self.pushButton_5.setGeometry(QtCore.QRect(130, 40, 97, 27))
+        self.pushButton_5.setObjectName("pushButton_5")
+        self.pushButton_6 = QtWidgets.QPushButton(Form)
+        self.pushButton_6.setGeometry(QtCore.QRect(250, 10, 97, 27))
+        self.pushButton_6.setObjectName("pushButton_6")
+        self.pushButton_7 = QtWidgets.QPushButton(Form)
+        self.pushButton_7.setGeometry(QtCore.QRect(250, 40, 97, 27))
+        self.pushButton_7.setObjectName("pushButton_7")
+        self.pushButton_8 = QtWidgets.QPushButton(Form)
+        self.pushButton_8.setGeometry(QtCore.QRect(450, 10, 97, 27))
+        self.pushButton_8.setObjectName("pushButton_8")
+        self.pushButton_9 = QtWidgets.QPushButton(Form)
+        self.pushButton_9.setGeometry(QtCore.QRect(450, 40, 97, 27))
+        self.pushButton_9.setObjectName("pushButton_9")
+        self.pushButton_10 = QtWidgets.QPushButton(Form)
+        self.pushButton_10.setGeometry(QtCore.QRect(570, 10, 97, 27))
+        self.pushButton_10.setObjectName("pushButton_10")
+        self.pushButton_11 = QtWidgets.QPushButton(Form)
+        self.pushButton_11.setGeometry(QtCore.QRect(570, 40, 97, 27))
+        self.pushButton_11.setObjectName("pushButton_11")
+        self.pushButton_12 = QtWidgets.QPushButton(Form)
+        self.pushButton_12.setGeometry(QtCore.QRect(690, 10, 97, 27))
+        self.pushButton_12.setObjectName("pushButton_12")
+        self.pushButton_13 = QtWidgets.QPushButton(Form)
+        self.pushButton_13.setGeometry(QtCore.QRect(690, 40, 97, 27))
+        self.pushButton_13.setObjectName("pushButton_13")
+        self.pushButton_14 = QtWidgets.QPushButton(Form)
+        self.pushButton_14.setGeometry(QtCore.QRect(810, 10, 97, 27))
+        self.pushButton_14.setObjectName("pushButton_14")
+        self.pushButton_15 = QtWidgets.QPushButton(Form)
+        self.pushButton_15.setGeometry(QtCore.QRect(810, 40, 97, 27))
+        self.pushButton_15.setObjectName("pushButton_15")
+        self.pushButton_16 = QtWidgets.QPushButton(Form)
+        self.pushButton_16.setGeometry(QtCore.QRect(930, 10, 97, 27))
+        self.pushButton_16.setObjectName("pushButton_16")
+        self.pushButton_17 = QtWidgets.QPushButton(Form)
+        self.pushButton_17.setGeometry(QtCore.QRect(930, 40, 97, 27))
+        self.pushButton_17.setObjectName("pushButton_17")
+        self.pushButton_18 = QtWidgets.QPushButton(Form)
+        self.pushButton_18.setGeometry(QtCore.QRect(1050, 10, 97, 27))
+        self.pushButton_18.setObjectName("pushButton_18")
+        self.pushButton_19 = QtWidgets.QPushButton(Form)
+        self.pushButton_19.setGeometry(QtCore.QRect(1050, 40, 97, 27))
+        self.pushButton_19.setObjectName("pushButton_19")
+        self.pushButton_20 = QtWidgets.QPushButton(Form)
+        self.pushButton_20.setGeometry(QtCore.QRect(1170, 10, 97, 27))
+        self.pushButton_20.setObjectName("pushButton_20")
+        self.pushButton_21 = QtWidgets.QPushButton(Form)
+        self.pushButton_21.setGeometry(QtCore.QRect(1170, 40, 97, 27))
+        self.pushButton_21.setObjectName("pushButton_21")
+        self.pushButton_22 = QtWidgets.QPushButton(Form)
+        self.pushButton_22.setGeometry(QtCore.QRect(1290, 10, 97, 27))
+        self.pushButton_22.setObjectName("pushButton_22")
+        self.pushButton_23 = QtWidgets.QPushButton(Form)
+        self.pushButton_23.setGeometry(QtCore.QRect(1290, 40, 97, 27))
+        self.pushButton_23.setObjectName("pushButton_23")
+        self.pushButton_24 = QtWidgets.QPushButton(Form)
+        self.pushButton_24.setGeometry(QtCore.QRect(1410, 10, 97, 27))
+        self.pushButton_24.setObjectName("pushButton_24")
+        self.pushButton_25 = QtWidgets.QPushButton(Form)
+        self.pushButton_25.setGeometry(QtCore.QRect(1410, 40, 97, 27))
+        self.pushButton_25.setObjectName("pushButton_25")
+        # self.pushButton_26 = QtWidgets.QPushButton(Form)
+        # self.pushButton_26.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+        # self.pushButton_26.setObjectName("pushButton_26")
+        # self.pushButton_27 = QtWidgets.QPushButton(Form)
+        # self.pushButton_27.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+        # self.pushButton_27.setObjectName("pushButton_27")
+
+        self.slider_sizeselect = QtWidgets.QSlider(Form)
+        self.slider_sizeselect.setRange(10,70)
+        self.slider_sizeselect.setOrientation(Qt.Horizontal)
+        self.slider_sizeselect.setValue(Form.size)
+        self.slider_sizeselect.setGeometry(QtCore.QRect(1530, 70, 97, 27))
+
+        self.label_sizeselect = QtWidgets.QLabel(Form)
+        self.label_sizeselect.setText("Brush Size")
+        self.label_sizeselect.setGeometry(QtCore.QRect(1630, 70, 97, 27))
+
+        self.slider_yawselect = QtWidgets.QSlider(Form)
+        self.slider_yawselect.setRange(-100,100)
+        self.slider_yawselect.setOrientation(Qt.Horizontal)
+        self.slider_yawselect.setValue(Form.yaw)
+        self.slider_yawselect.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+
+        self.label_yawselect = QtWidgets.QLabel(Form)
+        self.label_yawselect.setText("Yaw")
+        self.label_yawselect.setGeometry(QtCore.QRect(1630, 10, 97, 27))
+
+        self.slider_pitchselect = QtWidgets.QSlider(Form)
+        self.slider_pitchselect.setRange(-100,100)
+        self.slider_pitchselect.setOrientation(Qt.Horizontal)
+        self.slider_pitchselect.setValue(Form.pitch)
+        self.slider_pitchselect.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+
+        self.label_pitchselect = QtWidgets.QLabel(Form)
+        self.label_pitchselect.setText("Pitch")
+        self.label_pitchselect.setGeometry(QtCore.QRect(1630, 40, 97, 27))
+
+        self.slider_truncation = QtWidgets.QSlider(Form)
+        self.slider_truncation.setRange(0,100)
+        self.slider_truncation.setOrientation(Qt.Horizontal)
+        self.slider_truncation.setValue(Form.truncation)
+        self.slider_truncation.setGeometry(QtCore.QRect(1530, 100, 97, 27))
+
+        self.label_truncation = QtWidgets.QLabel(Form)
+        self.label_truncation.setText("Truncation")
+        self.label_truncation.setGeometry(QtCore.QRect(1630, 100, 97, 27))
+
+        self.text_inputID = QtWidgets.QTextEdit(Form)
+        self.text_inputID.setGeometry(QtCore.QRect(10, 70, 40, 27))
+        self.text_inputID.setObjectName("text_inputID")
+
+        self.pushButton_inputID = QtWidgets.QPushButton(Form)
+        self.pushButton_inputID.setGeometry(QtCore.QRect(60, 70, 60, 27))
+        self.pushButton_inputID.setObjectName("pushButton_inputID")
+
+        self.text_seed = QtWidgets.QTextEdit(Form)
+        self.text_seed.setGeometry(QtCore.QRect(140, 70, 40, 27))
+        self.text_seed.setObjectName("text_seed")
+        self.text_seed.setPlainText("0")
+
+        self.label_seed = QtWidgets.QLabel(Form)
+        self.label_seed.setText("Seed")
+        self.label_seed.setGeometry(QtCore.QRect(190, 70, 97, 27))
+
+        self.pushButton_inverse = QtWidgets.QPushButton(Form)
+        self.pushButton_inverse.setGeometry(QtCore.QRect(535, 400, 81, 27))
+        self.pushButton_inverse.setObjectName("pushButton_inverse")
+
+        self.pushButton_clear_ws = QtWidgets.QPushButton(Form)
+        self.pushButton_clear_ws.setGeometry(QtCore.QRect(535, 430, 81, 27))
+        self.pushButton_clear_ws.setObjectName("pushButton_clear_ws")
+
+
+
+
+        self.graphicsView = QtWidgets.QGraphicsView(Form)
+        self.graphicsView.setGeometry(QtCore.QRect(20, 120, 512, 512))
+        self.graphicsView.setObjectName("graphicsView")
+        self.graphicsView_2 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_2.setGeometry(QtCore.QRect(620, 120, 512, 512))
+        self.graphicsView_2.setObjectName("graphicsView_2") 
+        self.graphicsView_3 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_3.setGeometry(QtCore.QRect(1260, 120, 512, 512))
+        self.graphicsView_3.setObjectName("graphicsView_3")
+
+        self.graphicsView_5 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_5.setGeometry(QtCore.QRect(620, 680, 512, 512))
+        self.graphicsView_5.setObjectName("graphicsView_5") 
+        self.graphicsView_6 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_6.setGeometry(QtCore.QRect(1260, 680, 512, 512))
+        self.graphicsView_6.setObjectName("graphicsView_6")
+
+
+        self.retranslateUi(Form)
+        self.pushButton.clicked.connect(Form.generateAndReconstruct)
+        self.pushButton_2.clicked.connect(Form.open)
+        self.pushButton_3.clicked.connect(Form.open_mask)
+        self.pushButton_4.clicked.connect(Form.clear)
+        self.pushButton_5.clicked.connect(Form.undo)
+        self.pushButton_6.clicked.connect(Form.save_img)
+        self.pushButton_7.clicked.connect(Form.bg_mode)
+        self.pushButton_8.clicked.connect(Form.skin_mode)
+        self.pushButton_9.clicked.connect(Form.nose_mode)
+        self.pushButton_10.clicked.connect(Form.eye_g_mode)
+        self.pushButton_11.clicked.connect(Form.l_eye_mode)
+        self.pushButton_12.clicked.connect(Form.r_eye_mode)
+        self.pushButton_13.clicked.connect(Form.l_brow_mode)
+        self.pushButton_14.clicked.connect(Form.r_brow_mode)
+        self.pushButton_15.clicked.connect(Form.l_ear_mode)
+        self.pushButton_16.clicked.connect(Form.r_ear_mode)
+        self.pushButton_17.clicked.connect(Form.mouth_mode)
+        self.pushButton_18.clicked.connect(Form.u_lip_mode)
+        self.pushButton_19.clicked.connect(Form.l_lip_mode)
+        self.pushButton_20.clicked.connect(Form.hair_mode)
+        self.pushButton_21.clicked.connect(Form.hat_mode)
+        self.pushButton_22.clicked.connect(Form.ear_r_mode)
+        self.pushButton_23.clicked.connect(Form.neck_l_mode)
+        self.pushButton_24.clicked.connect(Form.neck_mode)
+        self.pushButton_25.clicked.connect(Form.cloth_mode)
+        # self.pushButton_26.clicked.connect(Form.increase)
+        # self.pushButton_27.clicked.connect(Form.decrease)
+
+        self.slider_sizeselect.valueChanged.connect(Form.changeBrushSize)
+        self.slider_yawselect.valueChanged.connect(Form.changeYaw)
+        self.slider_pitchselect.valueChanged.connect(Form.changePitch)
+        self.slider_truncation.valueChanged.connect(Form.changeTruncation)
+
+        self.pushButton_inputID.clicked.connect(Form.inputID)
+
+        self.pushButton_inverse.clicked.connect(Form.inverse)
+        self.pushButton_clear_ws.clicked.connect(Form.clear_ws)
+
+        QtCore.QMetaObject.connectSlotsByName(Form)
+
+    def retranslateUi(self, Form):
+        _translate = QtCore.QCoreApplication.translate
+        Form.setWindowTitle(_translate("Form", "3D-GauGAN"))
+        self.pushButton.setText(_translate("Form", "Generate"))
+        self.pushButton_2.setText(_translate("Form", "Open Image"))
+        self.pushButton_3.setText(_translate("Form", "Open Mask"))
+        self.pushButton_4.setText(_translate("Form", "Clear"))
+        self.pushButton_5.setText(_translate("Form", "Undo"))
+        self.pushButton_6.setText(_translate("Form", "Save Image"))
+        self.pushButton_7.setText(_translate("Form", "BackGround"))
+        self.pushButton_8.setText(_translate("Form", "Skin"))
+        self.pushButton_9.setText(_translate("Form", "Nose"))
+        self.pushButton_10.setText(_translate("Form", "Eyeglass"))
+        self.pushButton_11.setText(_translate("Form", "Left Eye"))
+        self.pushButton_12.setText(_translate("Form", "Right Eye"))
+        self.pushButton_13.setText(_translate("Form", "Left Eyebrow"))
+        self.pushButton_14.setText(_translate("Form", "Right Eyebrow"))
+        self.pushButton_15.setText(_translate("Form", "Left ear"))
+        self.pushButton_16.setText(_translate("Form", "Right ear"))
+        self.pushButton_17.setText(_translate("Form", "Mouth"))
+        self.pushButton_18.setText(_translate("Form", "Upper Lip"))
+        self.pushButton_19.setText(_translate("Form", "Lower Lip"))
+        self.pushButton_20.setText(_translate("Form", "Hair"))
+        self.pushButton_21.setText(_translate("Form", "Hat"))
+        self.pushButton_22.setText(_translate("Form", "Earring"))
+        self.pushButton_23.setText(_translate("Form", "Necklace"))
+        self.pushButton_24.setText(_translate("Form", "Neck"))
+        self.pushButton_25.setText(_translate("Form", "Cloth"))
+        # self.pushButton_26.setText(_translate("Form", "+"))
+        # self.pushButton_27.setText(_translate("Form", "-"))
+        self.pushButton_inputID.setText(_translate("Form", "Input ID"))
+        self.pushButton_inverse.setText(_translate("Form", "Inverse"))
+        self.pushButton_clear_ws.setText(_translate("Form", "Clear ws"))
+
+
+class Ui_Form_Video(object):
+    def setupUi(self, Form):
+        Form.setObjectName("Form")
+        Form.resize(1800, 1260)
+        self.pushButton = QtWidgets.QPushButton(Form)
+        # self.pushButton.setGeometry(QtCore.QRect(1160, 360, 81, 27))
+        self.pushButton.setGeometry(QtCore.QRect(535, 360, 81, 27))
+        self.pushButton.setObjectName("pushButton")
+        self.pushButton_2 = QtWidgets.QPushButton(Form)
+        self.pushButton_2.setGeometry(QtCore.QRect(10, 10, 97, 27))
+        self.pushButton_2.setObjectName("pushButton_2")
+        self.pushButton_3 = QtWidgets.QPushButton(Form)
+        self.pushButton_3.setGeometry(QtCore.QRect(10, 40, 97, 27))
+        self.pushButton_3.setObjectName("pushButton_3")
+        self.pushButton_4 = QtWidgets.QPushButton(Form)
+        self.pushButton_4.setGeometry(QtCore.QRect(130, 10, 97, 27))
+        self.pushButton_4.setObjectName("pushButton_4")
+        self.pushButton_5 = QtWidgets.QPushButton(Form)
+        self.pushButton_5.setGeometry(QtCore.QRect(130, 40, 97, 27))
+        self.pushButton_5.setObjectName("pushButton_5")
+        self.pushButton_6 = QtWidgets.QPushButton(Form)
+        self.pushButton_6.setGeometry(QtCore.QRect(250, 10, 97, 27))
+        self.pushButton_6.setObjectName("pushButton_6")
+        self.pushButton_7 = QtWidgets.QPushButton(Form)
+        self.pushButton_7.setGeometry(QtCore.QRect(250, 40, 97, 27))
+        self.pushButton_7.setObjectName("pushButton_7")
+        self.pushButton_8 = QtWidgets.QPushButton(Form)
+        self.pushButton_8.setGeometry(QtCore.QRect(450, 10, 97, 27))
+        self.pushButton_8.setObjectName("pushButton_8")
+        self.pushButton_9 = QtWidgets.QPushButton(Form)
+        self.pushButton_9.setGeometry(QtCore.QRect(450, 40, 97, 27))
+        self.pushButton_9.setObjectName("pushButton_9")
+        self.pushButton_10 = QtWidgets.QPushButton(Form)
+        self.pushButton_10.setGeometry(QtCore.QRect(570, 10, 97, 27))
+        self.pushButton_10.setObjectName("pushButton_10")
+        self.pushButton_11 = QtWidgets.QPushButton(Form)
+        self.pushButton_11.setGeometry(QtCore.QRect(570, 40, 97, 27))
+        self.pushButton_11.setObjectName("pushButton_11")
+        self.pushButton_12 = QtWidgets.QPushButton(Form)
+        self.pushButton_12.setGeometry(QtCore.QRect(690, 10, 97, 27))
+        self.pushButton_12.setObjectName("pushButton_12")
+        self.pushButton_13 = QtWidgets.QPushButton(Form)
+        self.pushButton_13.setGeometry(QtCore.QRect(690, 40, 97, 27))
+        self.pushButton_13.setObjectName("pushButton_13")
+        self.pushButton_14 = QtWidgets.QPushButton(Form)
+        self.pushButton_14.setGeometry(QtCore.QRect(810, 10, 97, 27))
+        self.pushButton_14.setObjectName("pushButton_14")
+        self.pushButton_15 = QtWidgets.QPushButton(Form)
+        self.pushButton_15.setGeometry(QtCore.QRect(810, 40, 97, 27))
+        self.pushButton_15.setObjectName("pushButton_15")
+        self.pushButton_16 = QtWidgets.QPushButton(Form)
+        self.pushButton_16.setGeometry(QtCore.QRect(930, 10, 97, 27))
+        self.pushButton_16.setObjectName("pushButton_16")
+        self.pushButton_17 = QtWidgets.QPushButton(Form)
+        self.pushButton_17.setGeometry(QtCore.QRect(930, 40, 97, 27))
+        self.pushButton_17.setObjectName("pushButton_17")
+        self.pushButton_18 = QtWidgets.QPushButton(Form)
+        self.pushButton_18.setGeometry(QtCore.QRect(1050, 10, 97, 27))
+        self.pushButton_18.setObjectName("pushButton_18")
+        self.pushButton_19 = QtWidgets.QPushButton(Form)
+        self.pushButton_19.setGeometry(QtCore.QRect(1050, 40, 97, 27))
+        self.pushButton_19.setObjectName("pushButton_19")
+        self.pushButton_20 = QtWidgets.QPushButton(Form)
+        self.pushButton_20.setGeometry(QtCore.QRect(1170, 10, 97, 27))
+        self.pushButton_20.setObjectName("pushButton_20")
+        self.pushButton_21 = QtWidgets.QPushButton(Form)
+        self.pushButton_21.setGeometry(QtCore.QRect(1170, 40, 97, 27))
+        self.pushButton_21.setObjectName("pushButton_21")
+        self.pushButton_22 = QtWidgets.QPushButton(Form)
+        self.pushButton_22.setGeometry(QtCore.QRect(1290, 10, 97, 27))
+        self.pushButton_22.setObjectName("pushButton_22")
+        self.pushButton_23 = QtWidgets.QPushButton(Form)
+        self.pushButton_23.setGeometry(QtCore.QRect(1290, 40, 97, 27))
+        self.pushButton_23.setObjectName("pushButton_23")
+        self.pushButton_24 = QtWidgets.QPushButton(Form)
+        self.pushButton_24.setGeometry(QtCore.QRect(1410, 10, 97, 27))
+        self.pushButton_24.setObjectName("pushButton_24")
+        self.pushButton_25 = QtWidgets.QPushButton(Form)
+        self.pushButton_25.setGeometry(QtCore.QRect(1410, 40, 97, 27))
+        self.pushButton_25.setObjectName("pushButton_25")
+        # self.pushButton_26 = QtWidgets.QPushButton(Form)
+        # self.pushButton_26.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+        # self.pushButton_26.setObjectName("pushButton_26")
+        # self.pushButton_27 = QtWidgets.QPushButton(Form)
+        # self.pushButton_27.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+        # self.pushButton_27.setObjectName("pushButton_27")
+
+        self.slider_sizeselect = QtWidgets.QSlider(Form)
+        self.slider_sizeselect.setRange(10,70)
+        self.slider_sizeselect.setOrientation(Qt.Horizontal)
+        self.slider_sizeselect.setValue(Form.size)
+        self.slider_sizeselect.setGeometry(QtCore.QRect(1530, 70, 97, 27))
+
+        self.label_sizeselect = QtWidgets.QLabel(Form)
+        self.label_sizeselect.setText("Brush Size")
+        self.label_sizeselect.setGeometry(QtCore.QRect(1630, 70, 97, 27))
+
+        self.slider_yawselect = QtWidgets.QSlider(Form)
+        self.slider_yawselect.setRange(-100,100)
+        self.slider_yawselect.setOrientation(Qt.Horizontal)
+        self.slider_yawselect.setValue(Form.yaw)
+        self.slider_yawselect.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+
+        self.label_yawselect = QtWidgets.QLabel(Form)
+        self.label_yawselect.setText("Yaw")
+        self.label_yawselect.setGeometry(QtCore.QRect(1630, 10, 97, 27))
+
+        self.slider_pitchselect = QtWidgets.QSlider(Form)
+        self.slider_pitchselect.setRange(-100,100)
+        self.slider_pitchselect.setOrientation(Qt.Horizontal)
+        self.slider_pitchselect.setValue(Form.pitch)
+        self.slider_pitchselect.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+
+        self.label_pitchselect = QtWidgets.QLabel(Form)
+        self.label_pitchselect.setText("Pitch")
+        self.label_pitchselect.setGeometry(QtCore.QRect(1630, 40, 97, 27))
+
+        self.slider_truncation = QtWidgets.QSlider(Form)
+        self.slider_truncation.setRange(0,100)
+        self.slider_truncation.setOrientation(Qt.Horizontal)
+        self.slider_truncation.setValue(Form.truncation)
+        self.slider_truncation.setGeometry(QtCore.QRect(1530, 100, 97, 27))
+
+        self.label_truncation = QtWidgets.QLabel(Form)
+        self.label_truncation.setText("Truncation")
+        self.label_truncation.setGeometry(QtCore.QRect(1630, 100, 97, 27))
+
+        self.text_inputID = QtWidgets.QTextEdit(Form)
+        self.text_inputID.setGeometry(QtCore.QRect(10, 70, 40, 27))
+        self.text_inputID.setObjectName("text_inputID")
+
+        self.pushButton_inputID = QtWidgets.QPushButton(Form)
+        self.pushButton_inputID.setGeometry(QtCore.QRect(60, 70, 60, 27))
+        self.pushButton_inputID.setObjectName("pushButton_inputID")
+
+        self.text_seed = QtWidgets.QTextEdit(Form)
+        self.text_seed.setGeometry(QtCore.QRect(140, 70, 40, 27))
+        self.text_seed.setObjectName("text_seed")
+        self.text_seed.setPlainText("0")
+
+        self.label_seed = QtWidgets.QLabel(Form)
+        self.label_seed.setText("Seed")
+        self.label_seed.setGeometry(QtCore.QRect(190, 70, 97, 27))
+
+        # self.pushButton_inverse = QtWidgets.QPushButton(Form)
+        # self.pushButton_inverse.setGeometry(QtCore.QRect(535, 400, 81, 27))
+        # self.pushButton_inverse.setObjectName("pushButton_inverse")
+
+        # self.pushButton_clear_ws = QtWidgets.QPushButton(Form)
+        # self.pushButton_clear_ws.setGeometry(QtCore.QRect(535, 430, 81, 27))
+        # self.pushButton_clear_ws.setObjectName("pushButton_clear_ws")
+        self.pushButton_get = QtWidgets.QPushButton(Form)
+        self.pushButton_get.setGeometry(QtCore.QRect(1500, 680 + 512 + 10, 81, 27))
+        self.pushButton_get.setObjectName("pushButton_get")
+
+
+
+
+        self.graphicsView = QtWidgets.QGraphicsView(Form)
+        self.graphicsView.setGeometry(QtCore.QRect(20, 120, 512, 512))
+        self.graphicsView.setObjectName("graphicsView")
+        self.graphicsView_2 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_2.setGeometry(QtCore.QRect(620, 120, 512, 512))
+        self.graphicsView_2.setObjectName("graphicsView_2") 
+        self.graphicsView_3 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_3.setGeometry(QtCore.QRect(1260, 120, 512, 512))
+        self.graphicsView_3.setObjectName("graphicsView_3")
+
+        self.graphicsView_5 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_5.setGeometry(QtCore.QRect(620, 680, 512, 512))
+        self.graphicsView_5.setObjectName("graphicsView_5") 
+        self.graphicsView_6 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_6.setGeometry(QtCore.QRect(1260, 680, 512, 512))
+        self.graphicsView_6.setObjectName("graphicsView_6")
+
+
+        self.retranslateUi(Form)
+        self.pushButton.clicked.connect(Form.generateAndReconstruct)
+        self.pushButton_2.clicked.connect(Form.open)
+        self.pushButton_3.clicked.connect(Form.open_mask)
+        self.pushButton_4.clicked.connect(Form.clear)
+        self.pushButton_5.clicked.connect(Form.undo)
+        self.pushButton_6.clicked.connect(Form.save_img)
+        self.pushButton_7.clicked.connect(Form.bg_mode)
+        self.pushButton_8.clicked.connect(Form.skin_mode)
+        self.pushButton_9.clicked.connect(Form.nose_mode)
+        self.pushButton_10.clicked.connect(Form.eye_g_mode)
+        self.pushButton_11.clicked.connect(Form.l_eye_mode)
+        self.pushButton_12.clicked.connect(Form.r_eye_mode)
+        self.pushButton_13.clicked.connect(Form.l_brow_mode)
+        self.pushButton_14.clicked.connect(Form.r_brow_mode)
+        self.pushButton_15.clicked.connect(Form.l_ear_mode)
+        self.pushButton_16.clicked.connect(Form.r_ear_mode)
+        self.pushButton_17.clicked.connect(Form.mouth_mode)
+        self.pushButton_18.clicked.connect(Form.u_lip_mode)
+        self.pushButton_19.clicked.connect(Form.l_lip_mode)
+        self.pushButton_20.clicked.connect(Form.hair_mode)
+        self.pushButton_21.clicked.connect(Form.hat_mode)
+        self.pushButton_22.clicked.connect(Form.ear_r_mode)
+        self.pushButton_23.clicked.connect(Form.neck_l_mode)
+        self.pushButton_24.clicked.connect(Form.neck_mode)
+        self.pushButton_25.clicked.connect(Form.cloth_mode)
+        # self.pushButton_26.clicked.connect(Form.increase)
+        # self.pushButton_27.clicked.connect(Form.decrease)
+
+        self.slider_sizeselect.valueChanged.connect(Form.changeBrushSize)
+        self.slider_yawselect.valueChanged.connect(Form.changeYaw)
+        self.slider_pitchselect.valueChanged.connect(Form.changePitch)
+        self.slider_truncation.valueChanged.connect(Form.changeTruncation)
+
+        self.pushButton_inputID.clicked.connect(Form.inputID)
+
+        # self.pushButton_inverse.clicked.connect(Form.inverse)
+        # self.pushButton_clear_ws.clicked.connect(Form.clear_ws)
+        self.pushButton_get.clicked.connect(Form.get_mask)
+
+        QtCore.QMetaObject.connectSlotsByName(Form)
+
+    def retranslateUi(self, Form):
+        _translate = QtCore.QCoreApplication.translate
+        Form.setWindowTitle(_translate("Form", "3D-aware Conditional Image Synthesis"))
+        self.pushButton.setText(_translate("Form", "Generate"))
+        self.pushButton_2.setText(_translate("Form", "Open Image"))
+        self.pushButton_3.setText(_translate("Form", "Open Mask"))
+        self.pushButton_4.setText(_translate("Form", "Clear"))
+        self.pushButton_5.setText(_translate("Form", "Undo"))
+        self.pushButton_6.setText(_translate("Form", "Save Image"))
+        self.pushButton_7.setText(_translate("Form", "BackGround"))
+        self.pushButton_8.setText(_translate("Form", "Skin"))
+        self.pushButton_9.setText(_translate("Form", "Nose"))
+        self.pushButton_10.setText(_translate("Form", "Eyeglass"))
+        self.pushButton_11.setText(_translate("Form", "Left Eye"))
+        self.pushButton_12.setText(_translate("Form", "Right Eye"))
+        self.pushButton_13.setText(_translate("Form", "Left Eyebrow"))
+        self.pushButton_14.setText(_translate("Form", "Right Eyebrow"))
+        self.pushButton_15.setText(_translate("Form", "Left ear"))
+        self.pushButton_16.setText(_translate("Form", "Right ear"))
+        self.pushButton_17.setText(_translate("Form", "Mouth"))
+        self.pushButton_18.setText(_translate("Form", "Upper Lip"))
+        self.pushButton_19.setText(_translate("Form", "Lower Lip"))
+        self.pushButton_20.setText(_translate("Form", "Hair"))
+        self.pushButton_21.setText(_translate("Form", "Hat"))
+        self.pushButton_22.setText(_translate("Form", "Earring"))
+        self.pushButton_23.setText(_translate("Form", "Necklace"))
+        self.pushButton_24.setText(_translate("Form", "Neck"))
+        self.pushButton_25.setText(_translate("Form", "Cloth"))
+        # self.pushButton_26.setText(_translate("Form", "+"))
+        # self.pushButton_27.setText(_translate("Form", "-"))
+        self.pushButton_inputID.setText(_translate("Form", "Input ID"))
+        # self.pushButton_inverse.setText(_translate("Form", "Inverse"))
+        # self.pushButton_clear_ws.setText(_translate("Form", "Clear ws"))
+        self.pushButton_get.setText(_translate("Form", "Get"))
+
+
+class Ui_Form_Edge2car(object):
+    def setupUi(self, Form):
+        Form.setObjectName("Form")
+        Form.resize(1800, 1260)
+        self.pushButton = QtWidgets.QPushButton(Form)
+        # self.pushButton.setGeometry(QtCore.QRect(1160, 360, 81, 27))
+        self.pushButton.setGeometry(QtCore.QRect(535, 360, 81, 27))
+        self.pushButton.setObjectName("pushButton")
+        self.pushButton_2 = QtWidgets.QPushButton(Form)
+        self.pushButton_2.setGeometry(QtCore.QRect(10, 10, 97, 27))
+        self.pushButton_2.setObjectName("pushButton_2")
+        self.pushButton_3 = QtWidgets.QPushButton(Form)
+        self.pushButton_3.setGeometry(QtCore.QRect(10, 40, 97, 27))
+        self.pushButton_3.setObjectName("pushButton_3")
+        self.pushButton_4 = QtWidgets.QPushButton(Form)
+        self.pushButton_4.setGeometry(QtCore.QRect(130, 10, 97, 27))
+        self.pushButton_4.setObjectName("pushButton_4")
+        self.pushButton_5 = QtWidgets.QPushButton(Form)
+        self.pushButton_5.setGeometry(QtCore.QRect(130, 40, 97, 27))
+        self.pushButton_5.setObjectName("pushButton_5")
+        self.pushButton_6 = QtWidgets.QPushButton(Form)
+        self.pushButton_6.setGeometry(QtCore.QRect(250, 10, 97, 27))
+        self.pushButton_6.setObjectName("pushButton_6")
+        self.pushButton_7 = QtWidgets.QPushButton(Form)
+        self.pushButton_7.setGeometry(QtCore.QRect(250, 40, 97, 27))
+        self.pushButton_7.setObjectName("pushButton_7")
+        self.pushButton_8 = QtWidgets.QPushButton(Form)
+        self.pushButton_8.setGeometry(QtCore.QRect(450, 10, 97, 27))
+        self.pushButton_8.setObjectName("pushButton_8")
+        self.pushButton_9 = QtWidgets.QPushButton(Form)
+        self.pushButton_9.setGeometry(QtCore.QRect(450, 40, 97, 27))
+        self.pushButton_9.setObjectName("pushButton_9")
+        self.pushButton_10 = QtWidgets.QPushButton(Form)
+        self.pushButton_10.setGeometry(QtCore.QRect(570, 10, 97, 27))
+        self.pushButton_10.setObjectName("pushButton_10")
+        self.pushButton_11 = QtWidgets.QPushButton(Form)
+        self.pushButton_11.setGeometry(QtCore.QRect(570, 40, 97, 27))
+        self.pushButton_11.setObjectName("pushButton_11")
+        self.pushButton_12 = QtWidgets.QPushButton(Form)
+        self.pushButton_12.setGeometry(QtCore.QRect(690, 10, 97, 27))
+        self.pushButton_12.setObjectName("pushButton_12")
+        self.pushButton_13 = QtWidgets.QPushButton(Form)
+        self.pushButton_13.setGeometry(QtCore.QRect(690, 40, 97, 27))
+        self.pushButton_13.setObjectName("pushButton_13")
+        self.pushButton_14 = QtWidgets.QPushButton(Form)
+        self.pushButton_14.setGeometry(QtCore.QRect(810, 10, 97, 27))
+        self.pushButton_14.setObjectName("pushButton_14")
+        self.pushButton_15 = QtWidgets.QPushButton(Form)
+        self.pushButton_15.setGeometry(QtCore.QRect(810, 40, 97, 27))
+        self.pushButton_15.setObjectName("pushButton_15")
+        self.pushButton_16 = QtWidgets.QPushButton(Form)
+        self.pushButton_16.setGeometry(QtCore.QRect(930, 10, 97, 27))
+        self.pushButton_16.setObjectName("pushButton_16")
+        self.pushButton_17 = QtWidgets.QPushButton(Form)
+        self.pushButton_17.setGeometry(QtCore.QRect(930, 40, 97, 27))
+        self.pushButton_17.setObjectName("pushButton_17")
+        self.pushButton_18 = QtWidgets.QPushButton(Form)
+        self.pushButton_18.setGeometry(QtCore.QRect(1050, 10, 97, 27))
+        self.pushButton_18.setObjectName("pushButton_18")
+        self.pushButton_19 = QtWidgets.QPushButton(Form)
+        self.pushButton_19.setGeometry(QtCore.QRect(1050, 40, 97, 27))
+        self.pushButton_19.setObjectName("pushButton_19")
+        self.pushButton_20 = QtWidgets.QPushButton(Form)
+        self.pushButton_20.setGeometry(QtCore.QRect(1170, 10, 97, 27))
+        self.pushButton_20.setObjectName("pushButton_20")
+        self.pushButton_21 = QtWidgets.QPushButton(Form)
+        self.pushButton_21.setGeometry(QtCore.QRect(1170, 40, 97, 27))
+        self.pushButton_21.setObjectName("pushButton_21")
+        self.pushButton_22 = QtWidgets.QPushButton(Form)
+        self.pushButton_22.setGeometry(QtCore.QRect(1290, 10, 97, 27))
+        self.pushButton_22.setObjectName("pushButton_22")
+        self.pushButton_23 = QtWidgets.QPushButton(Form)
+        self.pushButton_23.setGeometry(QtCore.QRect(1290, 40, 97, 27))
+        self.pushButton_23.setObjectName("pushButton_23")
+        self.pushButton_24 = QtWidgets.QPushButton(Form)
+        self.pushButton_24.setGeometry(QtCore.QRect(1410, 10, 97, 27))
+        self.pushButton_24.setObjectName("pushButton_24")
+        self.pushButton_25 = QtWidgets.QPushButton(Form)
+        self.pushButton_25.setGeometry(QtCore.QRect(1410, 40, 97, 27))
+        self.pushButton_25.setObjectName("pushButton_25")
+        # self.pushButton_26 = QtWidgets.QPushButton(Form)
+        # self.pushButton_26.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+        # self.pushButton_26.setObjectName("pushButton_26")
+        # self.pushButton_27 = QtWidgets.QPushButton(Form)
+        # self.pushButton_27.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+        # self.pushButton_27.setObjectName("pushButton_27")
+
+        self.slider_sizeselect = QtWidgets.QSlider(Form)
+        self.slider_sizeselect.setRange(10,70)
+        self.slider_sizeselect.setOrientation(Qt.Horizontal)
+        self.slider_sizeselect.setValue(Form.size)
+        self.slider_sizeselect.setGeometry(QtCore.QRect(1530, 70, 97, 27))
+
+        self.label_sizeselect = QtWidgets.QLabel(Form)
+        self.label_sizeselect.setText("Brush Size")
+        self.label_sizeselect.setGeometry(QtCore.QRect(1630, 70, 97, 27))
+
+        self.slider_yawselect = QtWidgets.QSlider(Form)
+        self.slider_yawselect.setRange(-100,100)
+        self.slider_yawselect.setOrientation(Qt.Horizontal)
+        self.slider_yawselect.setValue(Form.yaw)
+        self.slider_yawselect.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+
+        self.label_yawselect = QtWidgets.QLabel(Form)
+        self.label_yawselect.setText("Yaw")
+        self.label_yawselect.setGeometry(QtCore.QRect(1630, 10, 97, 27))
+
+        self.slider_pitchselect = QtWidgets.QSlider(Form)
+        self.slider_pitchselect.setRange(-100,100)
+        self.slider_pitchselect.setOrientation(Qt.Horizontal)
+        self.slider_pitchselect.setValue(Form.pitch)
+        self.slider_pitchselect.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+
+        self.label_pitchselect = QtWidgets.QLabel(Form)
+        self.label_pitchselect.setText("Pitch")
+        self.label_pitchselect.setGeometry(QtCore.QRect(1630, 40, 97, 27))
+
+        self.slider_truncation = QtWidgets.QSlider(Form)
+        self.slider_truncation.setRange(0,100)
+        self.slider_truncation.setOrientation(Qt.Horizontal)
+        self.slider_truncation.setValue(Form.truncation)
+        self.slider_truncation.setGeometry(QtCore.QRect(1530, 100, 97, 27))
+
+        self.label_truncation = QtWidgets.QLabel(Form)
+        self.label_truncation.setText("Truncation")
+        self.label_truncation.setGeometry(QtCore.QRect(1630, 100, 97, 27))
+
+        self.text_inputID = QtWidgets.QTextEdit(Form)
+        self.text_inputID.setGeometry(QtCore.QRect(10, 70, 40, 27))
+        self.text_inputID.setObjectName("text_inputID")
+
+        self.pushButton_inputID = QtWidgets.QPushButton(Form)
+        self.pushButton_inputID.setGeometry(QtCore.QRect(60, 70, 60, 27))
+        self.pushButton_inputID.setObjectName("pushButton_inputID")
+
+        self.text_seed = QtWidgets.QTextEdit(Form)
+        self.text_seed.setGeometry(QtCore.QRect(140, 70, 40, 27))
+        self.text_seed.setObjectName("text_seed")
+        self.text_seed.setPlainText("0")
+
+        self.label_seed = QtWidgets.QLabel(Form)
+        self.label_seed.setText("Seed")
+        self.label_seed.setGeometry(QtCore.QRect(190, 70, 97, 27))
+
+        # self.pushButton_inverse = QtWidgets.QPushButton(Form)
+        # self.pushButton_inverse.setGeometry(QtCore.QRect(535, 400, 81, 27))
+        # self.pushButton_inverse.setObjectName("pushButton_inverse")
+
+        # self.pushButton_clear_ws = QtWidgets.QPushButton(Form)
+        # self.pushButton_clear_ws.setGeometry(QtCore.QRect(535, 430, 81, 27))
+        # self.pushButton_clear_ws.setObjectName("pushButton_clear_ws")
+        self.pushButton_get = QtWidgets.QPushButton(Form)
+        self.pushButton_get.setGeometry(QtCore.QRect(1500, 680 + 512 + 10, 81, 27))
+        self.pushButton_get.setObjectName("pushButton_get")
+
+
+
+
+        self.graphicsView = QtWidgets.QGraphicsView(Form)
+        self.graphicsView.setGeometry(QtCore.QRect(20, 120, 512, 512))
+        self.graphicsView.setObjectName("graphicsView")
+        self.graphicsView_2 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_2.setGeometry(QtCore.QRect(620, 120, 512, 512))
+        self.graphicsView_2.setObjectName("graphicsView_2") 
+        self.graphicsView_3 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_3.setGeometry(QtCore.QRect(1260, 120, 512, 512))
+        self.graphicsView_3.setObjectName("graphicsView_3")
+
+        self.graphicsView_5 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_5.setGeometry(QtCore.QRect(620, 680, 512, 512))
+        self.graphicsView_5.setObjectName("graphicsView_5") 
+        self.graphicsView_6 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_6.setGeometry(QtCore.QRect(1260, 680, 512, 512))
+        self.graphicsView_6.setObjectName("graphicsView_6")
+
+
+        self.retranslateUi(Form)
+        self.pushButton.clicked.connect(Form.generateAndReconstruct)
+        self.pushButton_2.clicked.connect(Form.open)
+        self.pushButton_3.clicked.connect(Form.open_mask)
+        self.pushButton_4.clicked.connect(Form.clear)
+        self.pushButton_5.clicked.connect(Form.undo)
+        self.pushButton_6.clicked.connect(Form.save_img)
+        self.pushButton_7.clicked.connect(Form.bg_mode)
+        self.pushButton_8.clicked.connect(Form.skin_mode)
+        self.pushButton_9.clicked.connect(Form.nose_mode)
+        self.pushButton_10.clicked.connect(Form.eye_g_mode)
+        self.pushButton_11.clicked.connect(Form.l_eye_mode)
+        self.pushButton_12.clicked.connect(Form.r_eye_mode)
+        self.pushButton_13.clicked.connect(Form.l_brow_mode)
+        self.pushButton_14.clicked.connect(Form.r_brow_mode)
+        self.pushButton_15.clicked.connect(Form.l_ear_mode)
+        self.pushButton_16.clicked.connect(Form.r_ear_mode)
+        self.pushButton_17.clicked.connect(Form.mouth_mode)
+        self.pushButton_18.clicked.connect(Form.u_lip_mode)
+        self.pushButton_19.clicked.connect(Form.l_lip_mode)
+        self.pushButton_20.clicked.connect(Form.hair_mode)
+        self.pushButton_21.clicked.connect(Form.hat_mode)
+        self.pushButton_22.clicked.connect(Form.ear_r_mode)
+        self.pushButton_23.clicked.connect(Form.neck_l_mode)
+        self.pushButton_24.clicked.connect(Form.neck_mode)
+        self.pushButton_25.clicked.connect(Form.cloth_mode)
+        # self.pushButton_26.clicked.connect(Form.increase)
+        # self.pushButton_27.clicked.connect(Form.decrease)
+
+        self.slider_sizeselect.valueChanged.connect(Form.changeBrushSize)
+        self.slider_yawselect.valueChanged.connect(Form.changeYaw)
+        self.slider_pitchselect.valueChanged.connect(Form.changePitch)
+        self.slider_truncation.valueChanged.connect(Form.changeTruncation)
+
+        self.pushButton_inputID.clicked.connect(Form.inputID)
+
+        # self.pushButton_inverse.clicked.connect(Form.inverse)
+        # self.pushButton_clear_ws.clicked.connect(Form.clear_ws)
+        self.pushButton_get.clicked.connect(Form.get_mask)
+
+        QtCore.QMetaObject.connectSlotsByName(Form)
+
+    def retranslateUi(self, Form):
+        _translate = QtCore.QCoreApplication.translate
+        Form.setWindowTitle(_translate("Form", "3D-aware Conditional Image Synthesis (Edge2car)"))
+        self.pushButton.setText(_translate("Form", "Generate"))
+        self.pushButton_2.setText(_translate("Form", "Open Image"))
+        self.pushButton_3.setText(_translate("Form", "Open Mask"))
+        self.pushButton_4.setText(_translate("Form", "Clear"))
+        self.pushButton_5.setText(_translate("Form", "Undo"))
+        self.pushButton_6.setText(_translate("Form", "Save Image"))
+        self.pushButton_7.setText(_translate("Form", "BackGround"))
+        self.pushButton_8.setText(_translate("Form", "Skin"))
+        self.pushButton_9.setText(_translate("Form", "Nose"))
+        self.pushButton_10.setText(_translate("Form", "Eyeglass"))
+        self.pushButton_11.setText(_translate("Form", "Left Eye"))
+        self.pushButton_12.setText(_translate("Form", "Right Eye"))
+        self.pushButton_13.setText(_translate("Form", "Left Eyebrow"))
+        self.pushButton_14.setText(_translate("Form", "Right Eyebrow"))
+        self.pushButton_15.setText(_translate("Form", "Left ear"))
+        self.pushButton_16.setText(_translate("Form", "Right ear"))
+        self.pushButton_17.setText(_translate("Form", "Mouth"))
+        self.pushButton_18.setText(_translate("Form", "Upper Lip"))
+        self.pushButton_19.setText(_translate("Form", "Lower Lip"))
+        self.pushButton_20.setText(_translate("Form", "Hair"))
+        self.pushButton_21.setText(_translate("Form", "Hat"))
+        self.pushButton_22.setText(_translate("Form", "Earring"))
+        self.pushButton_23.setText(_translate("Form", "Necklace"))
+        self.pushButton_24.setText(_translate("Form", "Neck"))
+        self.pushButton_25.setText(_translate("Form", "Cloth"))
+        # self.pushButton_26.setText(_translate("Form", "+"))
+        # self.pushButton_27.setText(_translate("Form", "-"))
+        self.pushButton_inputID.setText(_translate("Form", "Input ID"))
+        # self.pushButton_inverse.setText(_translate("Form", "Inverse"))
+        # self.pushButton_clear_ws.setText(_translate("Form", "Clear ws"))
+        self.pushButton_get.setText(_translate("Form", "Get"))
+
+if __name__ == "__main__":
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    Form = QtWidgets.QWidget()
+    ui = Ui_Form()
+    ui.setupUi(Form)
+    Form.show()
+    sys.exit(app.exec_())
+

pix2pix3D-main/pix2pix3D-main/applications/demo/ui_qt/ui_clean.py

@@ -0,0 +1,797 @@
+from PyQt5 import QtCore, QtGui, QtWidgets
+from PyQt5.QtCore import Qt
+
+class Ui_Form_Clean(object):
+    def setupUi(self, Form):
+        Form.setObjectName("Form")
+        Form.resize(1800, 660)
+        self.pushButton = QtWidgets.QPushButton(Form)
+        # self.pushButton.setGeometry(QtCore.QRect(1160, 360, 81, 27))
+        self.pushButton.setGeometry(QtCore.QRect(685, 360, 81, 27))
+        self.pushButton.setObjectName("pushButton")
+        self.pushButton_2 = QtWidgets.QPushButton(Form)
+        self.pushButton_2.setGeometry(QtCore.QRect(10, 10, 97, 27))
+        self.pushButton_2.setObjectName("pushButton_2")
+        self.pushButton_3 = QtWidgets.QPushButton(Form)
+        self.pushButton_3.setGeometry(QtCore.QRect(10, 40, 97, 27))
+        self.pushButton_3.setObjectName("pushButton_3")
+        self.pushButton_4 = QtWidgets.QPushButton(Form)
+        self.pushButton_4.setGeometry(QtCore.QRect(130, 10, 97, 27))
+        self.pushButton_4.setObjectName("pushButton_4")
+        self.pushButton_5 = QtWidgets.QPushButton(Form)
+        self.pushButton_5.setGeometry(QtCore.QRect(130, 40, 97, 27))
+        self.pushButton_5.setObjectName("pushButton_5")
+        self.pushButton_6 = QtWidgets.QPushButton(Form)
+        self.pushButton_6.setGeometry(QtCore.QRect(250, 10, 97, 27))
+        self.pushButton_6.setObjectName("pushButton_6")
+        self.pushButton_7 = QtWidgets.QPushButton(Form)
+        self.pushButton_7.setGeometry(QtCore.QRect(250, 40, 97, 27))
+        self.pushButton_7.setObjectName("pushButton_7")
+        self.pushButton_8 = QtWidgets.QPushButton(Form)
+        self.pushButton_8.setGeometry(QtCore.QRect(450, 10, 97, 27))
+        self.pushButton_8.setObjectName("pushButton_8")
+        self.pushButton_9 = QtWidgets.QPushButton(Form)
+        self.pushButton_9.setGeometry(QtCore.QRect(450, 40, 97, 27))
+        self.pushButton_9.setObjectName("pushButton_9")
+        self.pushButton_10 = QtWidgets.QPushButton(Form)
+        self.pushButton_10.setGeometry(QtCore.QRect(570, 10, 97, 27))
+        self.pushButton_10.setObjectName("pushButton_10")
+        self.pushButton_11 = QtWidgets.QPushButton(Form)
+        self.pushButton_11.setGeometry(QtCore.QRect(570, 40, 97, 27))
+        self.pushButton_11.setObjectName("pushButton_11")
+        self.pushButton_12 = QtWidgets.QPushButton(Form)
+        self.pushButton_12.setGeometry(QtCore.QRect(690, 10, 97, 27))
+        self.pushButton_12.setObjectName("pushButton_12")
+        self.pushButton_13 = QtWidgets.QPushButton(Form)
+        self.pushButton_13.setGeometry(QtCore.QRect(690, 40, 97, 27))
+        self.pushButton_13.setObjectName("pushButton_13")
+        self.pushButton_14 = QtWidgets.QPushButton(Form)
+        self.pushButton_14.setGeometry(QtCore.QRect(810, 10, 97, 27))
+        self.pushButton_14.setObjectName("pushButton_14")
+        self.pushButton_15 = QtWidgets.QPushButton(Form)
+        self.pushButton_15.setGeometry(QtCore.QRect(810, 40, 97, 27))
+        self.pushButton_15.setObjectName("pushButton_15")
+        self.pushButton_16 = QtWidgets.QPushButton(Form)
+        self.pushButton_16.setGeometry(QtCore.QRect(930, 10, 97, 27))
+        self.pushButton_16.setObjectName("pushButton_16")
+        self.pushButton_17 = QtWidgets.QPushButton(Form)
+        self.pushButton_17.setGeometry(QtCore.QRect(930, 40, 97, 27))
+        self.pushButton_17.setObjectName("pushButton_17")
+        self.pushButton_18 = QtWidgets.QPushButton(Form)
+        self.pushButton_18.setGeometry(QtCore.QRect(1050, 10, 97, 27))
+        self.pushButton_18.setObjectName("pushButton_18")
+        self.pushButton_19 = QtWidgets.QPushButton(Form)
+        self.pushButton_19.setGeometry(QtCore.QRect(1050, 40, 97, 27))
+        self.pushButton_19.setObjectName("pushButton_19")
+        self.pushButton_20 = QtWidgets.QPushButton(Form)
+        self.pushButton_20.setGeometry(QtCore.QRect(1170, 10, 97, 27))
+        self.pushButton_20.setObjectName("pushButton_20")
+        self.pushButton_21 = QtWidgets.QPushButton(Form)
+        self.pushButton_21.setGeometry(QtCore.QRect(1170, 40, 97, 27))
+        self.pushButton_21.setObjectName("pushButton_21")
+        self.pushButton_22 = QtWidgets.QPushButton(Form)
+        self.pushButton_22.setGeometry(QtCore.QRect(1290, 10, 97, 27))
+        self.pushButton_22.setObjectName("pushButton_22")
+        self.pushButton_23 = QtWidgets.QPushButton(Form)
+        self.pushButton_23.setGeometry(QtCore.QRect(1290, 40, 97, 27))
+        self.pushButton_23.setObjectName("pushButton_23")
+        self.pushButton_24 = QtWidgets.QPushButton(Form)
+        self.pushButton_24.setGeometry(QtCore.QRect(1410, 10, 97, 27))
+        self.pushButton_24.setObjectName("pushButton_24")
+        self.pushButton_25 = QtWidgets.QPushButton(Form)
+        self.pushButton_25.setGeometry(QtCore.QRect(1410, 40, 97, 27))
+        self.pushButton_25.setObjectName("pushButton_25")
+        # self.pushButton_26 = QtWidgets.QPushButton(Form)
+        # self.pushButton_26.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+        # self.pushButton_26.setObjectName("pushButton_26")
+        # self.pushButton_27 = QtWidgets.QPushButton(Form)
+        # self.pushButton_27.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+        # self.pushButton_27.setObjectName("pushButton_27")
+
+        self.slider_sizeselect = QtWidgets.QSlider(Form)
+        self.slider_sizeselect.setRange(10,70)
+        self.slider_sizeselect.setOrientation(Qt.Horizontal)
+        self.slider_sizeselect.setValue(Form.size)
+        self.slider_sizeselect.setGeometry(QtCore.QRect(1530, 70, 97, 27))
+
+        self.label_sizeselect = QtWidgets.QLabel(Form)
+        self.label_sizeselect.setText("Brush Size")
+        self.label_sizeselect.setGeometry(QtCore.QRect(1630, 70, 97, 27))
+
+        self.slider_yawselect = QtWidgets.QSlider(Form)
+        self.slider_yawselect.setRange(-100,100)
+        self.slider_yawselect.setOrientation(Qt.Horizontal)
+        self.slider_yawselect.setValue(Form.yaw)
+        self.slider_yawselect.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+
+        self.label_yawselect = QtWidgets.QLabel(Form)
+        self.label_yawselect.setText("Yaw")
+        self.label_yawselect.setGeometry(QtCore.QRect(1630, 10, 97, 27))
+
+        self.slider_pitchselect = QtWidgets.QSlider(Form)
+        self.slider_pitchselect.setRange(-100,100)
+        self.slider_pitchselect.setOrientation(Qt.Horizontal)
+        self.slider_pitchselect.setValue(Form.pitch)
+        self.slider_pitchselect.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+
+        self.label_pitchselect = QtWidgets.QLabel(Form)
+        self.label_pitchselect.setText("Pitch")
+        self.label_pitchselect.setGeometry(QtCore.QRect(1630, 40, 97, 27))
+
+        self.slider_truncation = QtWidgets.QSlider(Form)
+        self.slider_truncation.setRange(0,100)
+        self.slider_truncation.setOrientation(Qt.Horizontal)
+        self.slider_truncation.setValue(Form.truncation)
+        self.slider_truncation.setGeometry(QtCore.QRect(1530, 100, 97, 27))
+
+        self.label_truncation = QtWidgets.QLabel(Form)
+        self.label_truncation.setText("Truncation")
+        self.label_truncation.setGeometry(QtCore.QRect(1630, 100, 97, 27))
+
+        self.text_inputID = QtWidgets.QTextEdit(Form)
+        self.text_inputID.setGeometry(QtCore.QRect(10, 70, 40, 27))
+        self.text_inputID.setObjectName("text_inputID")
+
+        self.pushButton_inputID = QtWidgets.QPushButton(Form)
+        self.pushButton_inputID.setGeometry(QtCore.QRect(60, 70, 60, 27))
+        self.pushButton_inputID.setObjectName("pushButton_inputID")
+
+        self.text_seed = QtWidgets.QTextEdit(Form)
+        self.text_seed.setGeometry(QtCore.QRect(140, 70, 40, 27))
+        self.text_seed.setObjectName("text_seed")
+        self.text_seed.setPlainText("0")
+
+        self.label_seed = QtWidgets.QLabel(Form)
+        self.label_seed.setText("Seed")
+        self.label_seed.setGeometry(QtCore.QRect(190, 70, 97, 27))
+
+        # self.pushButton_inverse = QtWidgets.QPushButton(Form)
+        # self.pushButton_inverse.setGeometry(QtCore.QRect(535, 400, 81, 27))
+        # self.pushButton_inverse.setObjectName("pushButton_inverse")
+
+        # self.pushButton_clear_ws = QtWidgets.QPushButton(Form)
+        # self.pushButton_clear_ws.setGeometry(QtCore.QRect(535, 430, 81, 27))
+        # self.pushButton_clear_ws.setObjectName("pushButton_clear_ws")
+        self.pushButton_get = QtWidgets.QPushButton(Form)
+        self.pushButton_get.setGeometry(QtCore.QRect(1500, 680 + 512 + 10, 81, 27))
+        self.pushButton_get.setObjectName("pushButton_get")
+
+
+
+
+        self.graphicsView = QtWidgets.QGraphicsView(Form)
+        self.graphicsView.setGeometry(QtCore.QRect(120, 120, 512, 512))
+        self.graphicsView.setObjectName("graphicsView")
+        self.graphicsView_2 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_2.setGeometry(QtCore.QRect(820, 120, 512, 512))
+        self.graphicsView_2.setObjectName("graphicsView_2") 
+        # self.graphicsView_3 = QtWidgets.QGraphicsView(Form)
+        # self.graphicsView_3.setGeometry(QtCore.QRect(1260, 120, 512, 512))
+        # self.graphicsView_3.setObjectName("graphicsView_3")
+
+        # self.graphicsView_5 = QtWidgets.QGraphicsView(Form)
+        # self.graphicsView_5.setGeometry(QtCore.QRect(620, 680, 512, 512))
+        # self.graphicsView_5.setObjectName("graphicsView_5") 
+        # self.graphicsView_6 = QtWidgets.QGraphicsView(Form)
+        # self.graphicsView_6.setGeometry(QtCore.QRect(1260, 680, 512, 512))
+        # self.graphicsView_6.setObjectName("graphicsView_6")
+
+
+        self.retranslateUi(Form)
+        self.pushButton.clicked.connect(Form.generateAndReconstruct)
+        self.pushButton_2.clicked.connect(Form.open)
+        self.pushButton_3.clicked.connect(Form.open_mask)
+        self.pushButton_4.clicked.connect(Form.clear)
+        self.pushButton_5.clicked.connect(Form.undo)
+        self.pushButton_6.clicked.connect(Form.save_img)
+        self.pushButton_7.clicked.connect(Form.bg_mode)
+        self.pushButton_8.clicked.connect(Form.skin_mode)
+        self.pushButton_9.clicked.connect(Form.nose_mode)
+        self.pushButton_10.clicked.connect(Form.eye_g_mode)
+        self.pushButton_11.clicked.connect(Form.l_eye_mode)
+        self.pushButton_12.clicked.connect(Form.r_eye_mode)
+        self.pushButton_13.clicked.connect(Form.l_brow_mode)
+        self.pushButton_14.clicked.connect(Form.r_brow_mode)
+        self.pushButton_15.clicked.connect(Form.l_ear_mode)
+        self.pushButton_16.clicked.connect(Form.r_ear_mode)
+        self.pushButton_17.clicked.connect(Form.mouth_mode)
+        self.pushButton_18.clicked.connect(Form.u_lip_mode)
+        self.pushButton_19.clicked.connect(Form.l_lip_mode)
+        self.pushButton_20.clicked.connect(Form.hair_mode)
+        self.pushButton_21.clicked.connect(Form.hat_mode)
+        self.pushButton_22.clicked.connect(Form.ear_r_mode)
+        self.pushButton_23.clicked.connect(Form.neck_l_mode)
+        self.pushButton_24.clicked.connect(Form.neck_mode)
+        self.pushButton_25.clicked.connect(Form.cloth_mode)
+        # self.pushButton_26.clicked.connect(Form.increase)
+        # self.pushButton_27.clicked.connect(Form.decrease)
+
+        self.slider_sizeselect.valueChanged.connect(Form.changeBrushSize)
+        self.slider_yawselect.valueChanged.connect(Form.changeYaw)
+        self.slider_pitchselect.valueChanged.connect(Form.changePitch)
+        self.slider_truncation.valueChanged.connect(Form.changeTruncation)
+
+        self.pushButton_inputID.clicked.connect(Form.inputID)
+
+        # self.pushButton_inverse.clicked.connect(Form.inverse)
+        # self.pushButton_clear_ws.clicked.connect(Form.clear_ws)
+        self.pushButton_get.clicked.connect(Form.get_mask)
+
+        QtCore.QMetaObject.connectSlotsByName(Form)
+
+    def retranslateUi(self, Form):
+        _translate = QtCore.QCoreApplication.translate
+        Form.setWindowTitle(_translate("Form", "3D-aware Conditional Image Synthesis"))
+        self.pushButton.setText(_translate("Form", "Generate"))
+        self.pushButton_2.setText(_translate("Form", "Open Image"))
+        self.pushButton_3.setText(_translate("Form", "Open Mask"))
+        self.pushButton_4.setText(_translate("Form", "Clear"))
+        self.pushButton_5.setText(_translate("Form", "Undo"))
+        self.pushButton_6.setText(_translate("Form", "Save Image"))
+        self.pushButton_7.setText(_translate("Form", "BackGround"))
+        self.pushButton_8.setText(_translate("Form", "Skin"))
+        self.pushButton_9.setText(_translate("Form", "Nose"))
+        self.pushButton_10.setText(_translate("Form", "Eyeglass"))
+        self.pushButton_11.setText(_translate("Form", "Left Eye"))
+        self.pushButton_12.setText(_translate("Form", "Right Eye"))
+        self.pushButton_13.setText(_translate("Form", "Left Eyebrow"))
+        self.pushButton_14.setText(_translate("Form", "Right Eyebrow"))
+        self.pushButton_15.setText(_translate("Form", "Left ear"))
+        self.pushButton_16.setText(_translate("Form", "Right ear"))
+        self.pushButton_17.setText(_translate("Form", "Mouth"))
+        self.pushButton_18.setText(_translate("Form", "Upper Lip"))
+        self.pushButton_19.setText(_translate("Form", "Lower Lip"))
+        self.pushButton_20.setText(_translate("Form", "Hair"))
+        self.pushButton_21.setText(_translate("Form", "Hat"))
+        self.pushButton_22.setText(_translate("Form", "Earring"))
+        self.pushButton_23.setText(_translate("Form", "Necklace"))
+        self.pushButton_24.setText(_translate("Form", "Neck"))
+        self.pushButton_25.setText(_translate("Form", "Cloth"))
+        # self.pushButton_26.setText(_translate("Form", "+"))
+        # self.pushButton_27.setText(_translate("Form", "-"))
+        self.pushButton_inputID.setText(_translate("Form", "Input ID"))
+        # self.pushButton_inverse.setText(_translate("Form", "Inverse"))
+        # self.pushButton_clear_ws.setText(_translate("Form", "Clear ws"))
+        self.pushButton_get.setText(_translate("Form", "Get"))
+
+
+class Ui_Form_Edge2car(object):
+    def setupUi(self, Form):
+        Form.setObjectName("Form")
+        Form.resize(1800, 660)
+        self.pushButton = QtWidgets.QPushButton(Form)
+        # self.pushButton.setGeometry(QtCore.QRect(1160, 360, 81, 27))
+        self.pushButton.setGeometry(QtCore.QRect(685, 360, 81, 27))
+        self.pushButton.setObjectName("pushButton")
+        self.pushButton_2 = QtWidgets.QPushButton(Form)
+        self.pushButton_2.setGeometry(QtCore.QRect(10, 10, 97, 27))
+        self.pushButton_2.setObjectName("pushButton_2")
+        self.pushButton_3 = QtWidgets.QPushButton(Form)
+        self.pushButton_3.setGeometry(QtCore.QRect(10, 40, 97, 27))
+        self.pushButton_3.setObjectName("pushButton_3")
+        self.pushButton_4 = QtWidgets.QPushButton(Form)
+        self.pushButton_4.setGeometry(QtCore.QRect(130, 10, 97, 27))
+        self.pushButton_4.setObjectName("pushButton_4")
+        self.pushButton_5 = QtWidgets.QPushButton(Form)
+        self.pushButton_5.setGeometry(QtCore.QRect(130, 40, 97, 27))
+        self.pushButton_5.setObjectName("pushButton_5")
+        self.pushButton_6 = QtWidgets.QPushButton(Form)
+        self.pushButton_6.setGeometry(QtCore.QRect(250, 10, 97, 27))
+        self.pushButton_6.setObjectName("pushButton_6")
+        self.pushButton_7 = QtWidgets.QPushButton(Form)
+        self.pushButton_7.setGeometry(QtCore.QRect(250, 40, 97, 27))
+        self.pushButton_7.setObjectName("pushButton_7")
+        self.pushButton_8 = QtWidgets.QPushButton(Form)
+        self.pushButton_8.setGeometry(QtCore.QRect(450, 10, 97, 27))
+        self.pushButton_8.setObjectName("pushButton_8")
+        # self.pushButton_9 = QtWidgets.QPushButton(Form)
+        # self.pushButton_9.setGeometry(QtCore.QRect(450, 40, 97, 27))
+        # self.pushButton_9.setObjectName("pushButton_9")
+        # self.pushButton_10 = QtWidgets.QPushButton(Form)
+        # self.pushButton_10.setGeometry(QtCore.QRect(570, 10, 97, 27))
+        # self.pushButton_10.setObjectName("pushButton_10")
+        # self.pushButton_11 = QtWidgets.QPushButton(Form)
+        # self.pushButton_11.setGeometry(QtCore.QRect(570, 40, 97, 27))
+        # self.pushButton_11.setObjectName("pushButton_11")
+        # self.pushButton_12 = QtWidgets.QPushButton(Form)
+        # self.pushButton_12.setGeometry(QtCore.QRect(690, 10, 97, 27))
+        # self.pushButton_12.setObjectName("pushButton_12")
+        # self.pushButton_13 = QtWidgets.QPushButton(Form)
+        # self.pushButton_13.setGeometry(QtCore.QRect(690, 40, 97, 27))
+        # self.pushButton_13.setObjectName("pushButton_13")
+        # self.pushButton_14 = QtWidgets.QPushButton(Form)
+        # self.pushButton_14.setGeometry(QtCore.QRect(810, 10, 97, 27))
+        # self.pushButton_14.setObjectName("pushButton_14")
+        # self.pushButton_15 = QtWidgets.QPushButton(Form)
+        # self.pushButton_15.setGeometry(QtCore.QRect(810, 40, 97, 27))
+        # self.pushButton_15.setObjectName("pushButton_15")
+        # self.pushButton_16 = QtWidgets.QPushButton(Form)
+        # self.pushButton_16.setGeometry(QtCore.QRect(930, 10, 97, 27))
+        # self.pushButton_16.setObjectName("pushButton_16")
+        # self.pushButton_17 = QtWidgets.QPushButton(Form)
+        # self.pushButton_17.setGeometry(QtCore.QRect(930, 40, 97, 27))
+        # self.pushButton_17.setObjectName("pushButton_17")
+        # self.pushButton_18 = QtWidgets.QPushButton(Form)
+        # self.pushButton_18.setGeometry(QtCore.QRect(1050, 10, 97, 27))
+        # self.pushButton_18.setObjectName("pushButton_18")
+        # self.pushButton_19 = QtWidgets.QPushButton(Form)
+        # self.pushButton_19.setGeometry(QtCore.QRect(1050, 40, 97, 27))
+        # self.pushButton_19.setObjectName("pushButton_19")
+        # self.pushButton_20 = QtWidgets.QPushButton(Form)
+        # self.pushButton_20.setGeometry(QtCore.QRect(1170, 10, 97, 27))
+        # self.pushButton_20.setObjectName("pushButton_20")
+        # self.pushButton_21 = QtWidgets.QPushButton(Form)
+        # self.pushButton_21.setGeometry(QtCore.QRect(1170, 40, 97, 27))
+        # self.pushButton_21.setObjectName("pushButton_21")
+        # self.pushButton_22 = QtWidgets.QPushButton(Form)
+        # self.pushButton_22.setGeometry(QtCore.QRect(1290, 10, 97, 27))
+        # self.pushButton_22.setObjectName("pushButton_22")
+        # self.pushButton_23 = QtWidgets.QPushButton(Form)
+        # self.pushButton_23.setGeometry(QtCore.QRect(1290, 40, 97, 27))
+        # self.pushButton_23.setObjectName("pushButton_23")
+        # self.pushButton_24 = QtWidgets.QPushButton(Form)
+        # self.pushButton_24.setGeometry(QtCore.QRect(1410, 10, 97, 27))
+        # self.pushButton_24.setObjectName("pushButton_24")
+        # self.pushButton_25 = QtWidgets.QPushButton(Form)
+        # self.pushButton_25.setGeometry(QtCore.QRect(1410, 40, 97, 27))
+        # self.pushButton_25.setObjectName("pushButton_25")
+        # self.pushButton_26 = QtWidgets.QPushButton(Form)
+        # self.pushButton_26.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+        # self.pushButton_26.setObjectName("pushButton_26")
+        # self.pushButton_27 = QtWidgets.QPushButton(Form)
+        # self.pushButton_27.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+        # self.pushButton_27.setObjectName("pushButton_27")
+
+        self.slider_sizeselect = QtWidgets.QSlider(Form)
+        self.slider_sizeselect.setRange(10,70)
+        self.slider_sizeselect.setOrientation(Qt.Horizontal)
+        self.slider_sizeselect.setValue(Form.size)
+        self.slider_sizeselect.setGeometry(QtCore.QRect(1530, 100, 97, 27))
+
+        self.label_sizeselect = QtWidgets.QLabel(Form)
+        self.label_sizeselect.setText("Brush Size")
+        self.label_sizeselect.setGeometry(QtCore.QRect(1630, 100, 97, 27))
+
+        self.slider_yawselect = QtWidgets.QSlider(Form)
+        self.slider_yawselect.setRange(-100,100)
+        self.slider_yawselect.setOrientation(Qt.Horizontal)
+        self.slider_yawselect.setValue(Form.yaw)
+        self.slider_yawselect.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+
+        self.label_yawselect = QtWidgets.QLabel(Form)
+        self.label_yawselect.setText("Yaw")
+        self.label_yawselect.setGeometry(QtCore.QRect(1630, 10, 97, 27))
+
+        self.slider_pitchselect = QtWidgets.QSlider(Form)
+        self.slider_pitchselect.setRange(-100,100)
+        self.slider_pitchselect.setOrientation(Qt.Horizontal)
+        self.slider_pitchselect.setValue(Form.pitch)
+        self.slider_pitchselect.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+
+        self.label_pitchselect = QtWidgets.QLabel(Form)
+        self.label_pitchselect.setText("Pitch")
+        self.label_pitchselect.setGeometry(QtCore.QRect(1630, 40, 97, 27))
+
+        self.slider_rollselect = QtWidgets.QSlider(Form)
+        self.slider_rollselect.setRange(0,100)
+        self.slider_rollselect.setOrientation(Qt.Horizontal)
+        self.slider_rollselect.setValue(Form.roll)
+        self.slider_rollselect.setGeometry(QtCore.QRect(1530, 70, 97, 27))
+
+        self.label_rollselect = QtWidgets.QLabel(Form)
+        self.label_rollselect.setText("Roll")
+        self.label_rollselect.setGeometry(QtCore.QRect(1630, 70, 97, 27))
+
+
+        self.slider_truncation = QtWidgets.QSlider(Form)
+        self.slider_truncation.setRange(0,100)
+        self.slider_truncation.setOrientation(Qt.Horizontal)
+        self.slider_truncation.setValue(Form.truncation)
+        self.slider_truncation.setGeometry(QtCore.QRect(1530, 130, 97, 27))
+
+        self.label_truncation = QtWidgets.QLabel(Form)
+        self.label_truncation.setText("Truncation")
+        self.label_truncation.setGeometry(QtCore.QRect(1630, 130, 97, 27))
+
+        self.text_inputID = QtWidgets.QTextEdit(Form)
+        self.text_inputID.setGeometry(QtCore.QRect(10, 70, 40, 27))
+        self.text_inputID.setObjectName("text_inputID")
+
+        self.pushButton_inputID = QtWidgets.QPushButton(Form)
+        self.pushButton_inputID.setGeometry(QtCore.QRect(60, 70, 60, 27))
+        self.pushButton_inputID.setObjectName("pushButton_inputID")
+
+        self.text_seed = QtWidgets.QTextEdit(Form)
+        self.text_seed.setGeometry(QtCore.QRect(140, 70, 40, 27))
+        self.text_seed.setObjectName("text_seed")
+        self.text_seed.setPlainText("0")
+
+        self.label_seed = QtWidgets.QLabel(Form)
+        self.label_seed.setText("Seed")
+        self.label_seed.setGeometry(QtCore.QRect(190, 70, 97, 27))
+
+        # self.pushButton_inverse = QtWidgets.QPushButton(Form)
+        # self.pushButton_inverse.setGeometry(QtCore.QRect(535, 400, 81, 27))
+        # self.pushButton_inverse.setObjectName("pushButton_inverse")
+
+        # self.pushButton_clear_ws = QtWidgets.QPushButton(Form)
+        # self.pushButton_clear_ws.setGeometry(QtCore.QRect(535, 430, 81, 27))
+        # self.pushButton_clear_ws.setObjectName("pushButton_clear_ws")
+        self.pushButton_get = QtWidgets.QPushButton(Form)
+        self.pushButton_get.setGeometry(QtCore.QRect(1500, 680 + 512 + 10, 81, 27))
+        self.pushButton_get.setObjectName("pushButton_get")
+
+
+
+
+        self.graphicsView = QtWidgets.QGraphicsView(Form)
+        self.graphicsView.setGeometry(QtCore.QRect(120, 120, 512, 512))
+        self.graphicsView.setObjectName("graphicsView")
+        self.graphicsView_2 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_2.setGeometry(QtCore.QRect(820, 120, 512, 512))
+        self.graphicsView_2.setObjectName("graphicsView_2") 
+        # self.graphicsView_3 = QtWidgets.QGraphicsView(Form)
+        # self.graphicsView_3.setGeometry(QtCore.QRect(1260, 120, 512, 512))
+        # self.graphicsView_3.setObjectName("graphicsView_3")
+
+        # self.graphicsView_5 = QtWidgets.QGraphicsView(Form)
+        # self.graphicsView_5.setGeometry(QtCore.QRect(620, 680, 512, 512))
+        # self.graphicsView_5.setObjectName("graphicsView_5") 
+        # self.graphicsView_6 = QtWidgets.QGraphicsView(Form)
+        # self.graphicsView_6.setGeometry(QtCore.QRect(1260, 680, 512, 512))
+        # self.graphicsView_6.setObjectName("graphicsView_6")
+
+
+        self.retranslateUi(Form)
+        self.pushButton.clicked.connect(Form.generateAndReconstruct)
+        self.pushButton_2.clicked.connect(Form.open)
+        self.pushButton_3.clicked.connect(Form.open_mask)
+        self.pushButton_4.clicked.connect(Form.clear)
+        self.pushButton_5.clicked.connect(Form.undo)
+        self.pushButton_6.clicked.connect(Form.save_img)
+        self.pushButton_7.clicked.connect(Form.bg_mode)
+        self.pushButton_8.clicked.connect(Form.skin_mode)
+        # self.pushButton_9.clicked.connect(Form.nose_mode)
+        # self.pushButton_10.clicked.connect(Form.eye_g_mode)
+        # self.pushButton_11.clicked.connect(Form.l_eye_mode)
+        # self.pushButton_12.clicked.connect(Form.r_eye_mode)
+        # self.pushButton_13.clicked.connect(Form.l_brow_mode)
+        # self.pushButton_14.clicked.connect(Form.r_brow_mode)
+        # self.pushButton_15.clicked.connect(Form.l_ear_mode)
+        # self.pushButton_16.clicked.connect(Form.r_ear_mode)
+        # self.pushButton_17.clicked.connect(Form.mouth_mode)
+        # self.pushButton_18.clicked.connect(Form.u_lip_mode)
+        # self.pushButton_19.clicked.connect(Form.l_lip_mode)
+        # self.pushButton_20.clicked.connect(Form.hair_mode)
+        # self.pushButton_21.clicked.connect(Form.hat_mode)
+        # self.pushButton_22.clicked.connect(Form.ear_r_mode)
+        # self.pushButton_23.clicked.connect(Form.neck_l_mode)
+        # self.pushButton_24.clicked.connect(Form.neck_mode)
+        # self.pushButton_25.clicked.connect(Form.cloth_mode)
+        # self.pushButton_26.clicked.connect(Form.increase)
+        # self.pushButton_27.clicked.connect(Form.decrease)
+
+        self.slider_sizeselect.valueChanged.connect(Form.changeBrushSize)
+        self.slider_yawselect.valueChanged.connect(Form.changeYaw)
+        self.slider_pitchselect.valueChanged.connect(Form.changePitch)
+        self.slider_rollselect.valueChanged.connect(Form.changeRoll)
+        self.slider_truncation.valueChanged.connect(Form.changeTruncation)
+
+        self.pushButton_inputID.clicked.connect(Form.inputID)
+
+        # self.pushButton_inverse.clicked.connect(Form.inverse)
+        # self.pushButton_clear_ws.clicked.connect(Form.clear_ws)
+        self.pushButton_get.clicked.connect(Form.get_mask)
+
+        QtCore.QMetaObject.connectSlotsByName(Form)
+
+    def retranslateUi(self, Form):
+        _translate = QtCore.QCoreApplication.translate
+        Form.setWindowTitle(_translate("Form", "3D-aware Conditional Image Synthesis (Edge2car)"))
+        self.pushButton.setText(_translate("Form", "Generate"))
+        self.pushButton_2.setText(_translate("Form", "Open Image"))
+        self.pushButton_3.setText(_translate("Form", "Open Mask"))
+        self.pushButton_4.setText(_translate("Form", "Clear"))
+        self.pushButton_5.setText(_translate("Form", "Undo"))
+        self.pushButton_6.setText(_translate("Form", "Save Image"))
+        self.pushButton_7.setText(_translate("Form", "BackGround"))
+        self.pushButton_8.setText(_translate("Form", "Edge"))
+        # self.pushButton_9.setText(_translate("Form", "Nose"))
+        # self.pushButton_10.setText(_translate("Form", "Eyeglass"))
+        # self.pushButton_11.setText(_translate("Form", "Left Eye"))
+        # self.pushButton_12.setText(_translate("Form", "Right Eye"))
+        # self.pushButton_13.setText(_translate("Form", "Left Eyebrow"))
+        # self.pushButton_14.setText(_translate("Form", "Right Eyebrow"))
+        # self.pushButton_15.setText(_translate("Form", "Left ear"))
+        # self.pushButton_16.setText(_translate("Form", "Right ear"))
+        # self.pushButton_17.setText(_translate("Form", "Mouth"))
+        # self.pushButton_18.setText(_translate("Form", "Upper Lip"))
+        # self.pushButton_19.setText(_translate("Form", "Lower Lip"))
+        # self.pushButton_20.setText(_translate("Form", "Hair"))
+        # self.pushButton_21.setText(_translate("Form", "Hat"))
+        # self.pushButton_22.setText(_translate("Form", "Earring"))
+        # self.pushButton_23.setText(_translate("Form", "Necklace"))
+        # self.pushButton_24.setText(_translate("Form", "Neck"))
+        # self.pushButton_25.setText(_translate("Form", "Cloth"))
+        # self.pushButton_26.setText(_translate("Form", "+"))
+        # self.pushButton_27.setText(_translate("Form", "-"))
+        self.pushButton_inputID.setText(_translate("Form", "Input ID"))
+        # self.pushButton_inverse.setText(_translate("Form", "Inverse"))
+        # self.pushButton_clear_ws.setText(_translate("Form", "Clear ws"))
+        self.pushButton_get.setText(_translate("Form", "Get"))
+
+
+class Ui_Form_Seg2cat(object):
+    def setupUi(self, Form):
+        Form.setObjectName("Form")
+        Form.resize(1800, 660)
+        self.pushButton = QtWidgets.QPushButton(Form)
+        # self.pushButton.setGeometry(QtCore.QRect(1160, 360, 81, 27))
+        self.pushButton.setGeometry(QtCore.QRect(685, 360, 81, 27))
+        self.pushButton.setObjectName("pushButton")
+        self.pushButton_2 = QtWidgets.QPushButton(Form)
+        self.pushButton_2.setGeometry(QtCore.QRect(10, 10, 97, 27))
+        self.pushButton_2.setObjectName("pushButton_2")
+        self.pushButton_3 = QtWidgets.QPushButton(Form)
+        self.pushButton_3.setGeometry(QtCore.QRect(10, 40, 97, 27))
+        self.pushButton_3.setObjectName("pushButton_3")
+        self.pushButton_4 = QtWidgets.QPushButton(Form)
+        self.pushButton_4.setGeometry(QtCore.QRect(130, 10, 97, 27))
+        self.pushButton_4.setObjectName("pushButton_4")
+        self.pushButton_5 = QtWidgets.QPushButton(Form)
+        self.pushButton_5.setGeometry(QtCore.QRect(130, 40, 97, 27))
+        self.pushButton_5.setObjectName("pushButton_5")
+        self.pushButton_6 = QtWidgets.QPushButton(Form)
+        self.pushButton_6.setGeometry(QtCore.QRect(250, 10, 97, 27))
+        self.pushButton_6.setObjectName("pushButton_6")
+        self.pushButton_7 = QtWidgets.QPushButton(Form)
+        self.pushButton_7.setGeometry(QtCore.QRect(250, 40, 97, 27))
+        self.pushButton_7.setObjectName("pushButton_7")
+        self.pushButton_8 = QtWidgets.QPushButton(Form)
+        self.pushButton_8.setGeometry(QtCore.QRect(450, 10, 97, 27))
+        self.pushButton_8.setObjectName("pushButton_8")
+        self.pushButton_9 = QtWidgets.QPushButton(Form)
+        self.pushButton_9.setGeometry(QtCore.QRect(450, 40, 97, 27))
+        self.pushButton_9.setObjectName("pushButton_9")
+        self.pushButton_10 = QtWidgets.QPushButton(Form)
+        self.pushButton_10.setGeometry(QtCore.QRect(570, 10, 97, 27))
+        self.pushButton_10.setObjectName("pushButton_10")
+        self.pushButton_11 = QtWidgets.QPushButton(Form)
+        self.pushButton_11.setGeometry(QtCore.QRect(570, 40, 97, 27))
+        self.pushButton_11.setObjectName("pushButton_11")
+        self.pushButton_12 = QtWidgets.QPushButton(Form)
+        self.pushButton_12.setGeometry(QtCore.QRect(690, 10, 97, 27))
+        self.pushButton_12.setObjectName("pushButton_12")
+        # self.pushButton_13 = QtWidgets.QPushButton(Form)
+        # self.pushButton_13.setGeometry(QtCore.QRect(690, 40, 97, 27))
+        # self.pushButton_13.setObjectName("pushButton_13")
+        # self.pushButton_14 = QtWidgets.QPushButton(Form)
+        # self.pushButton_14.setGeometry(QtCore.QRect(810, 10, 97, 27))
+        # self.pushButton_14.setObjectName("pushButton_14")
+        # self.pushButton_15 = QtWidgets.QPushButton(Form)
+        # self.pushButton_15.setGeometry(QtCore.QRect(810, 40, 97, 27))
+        # self.pushButton_15.setObjectName("pushButton_15")
+        # self.pushButton_16 = QtWidgets.QPushButton(Form)
+        # self.pushButton_16.setGeometry(QtCore.QRect(930, 10, 97, 27))
+        # self.pushButton_16.setObjectName("pushButton_16")
+        # self.pushButton_17 = QtWidgets.QPushButton(Form)
+        # self.pushButton_17.setGeometry(QtCore.QRect(930, 40, 97, 27))
+        # self.pushButton_17.setObjectName("pushButton_17")
+        # self.pushButton_18 = QtWidgets.QPushButton(Form)
+        # self.pushButton_18.setGeometry(QtCore.QRect(1050, 10, 97, 27))
+        # self.pushButton_18.setObjectName("pushButton_18")
+        # self.pushButton_19 = QtWidgets.QPushButton(Form)
+        # self.pushButton_19.setGeometry(QtCore.QRect(1050, 40, 97, 27))
+        # self.pushButton_19.setObjectName("pushButton_19")
+        # self.pushButton_20 = QtWidgets.QPushButton(Form)
+        # self.pushButton_20.setGeometry(QtCore.QRect(1170, 10, 97, 27))
+        # self.pushButton_20.setObjectName("pushButton_20")
+        # self.pushButton_21 = QtWidgets.QPushButton(Form)
+        # self.pushButton_21.setGeometry(QtCore.QRect(1170, 40, 97, 27))
+        # self.pushButton_21.setObjectName("pushButton_21")
+        # self.pushButton_22 = QtWidgets.QPushButton(Form)
+        # self.pushButton_22.setGeometry(QtCore.QRect(1290, 10, 97, 27))
+        # self.pushButton_22.setObjectName("pushButton_22")
+        # self.pushButton_23 = QtWidgets.QPushButton(Form)
+        # self.pushButton_23.setGeometry(QtCore.QRect(1290, 40, 97, 27))
+        # self.pushButton_23.setObjectName("pushButton_23")
+        # self.pushButton_24 = QtWidgets.QPushButton(Form)
+        # self.pushButton_24.setGeometry(QtCore.QRect(1410, 10, 97, 27))
+        # self.pushButton_24.setObjectName("pushButton_24")
+        # self.pushButton_25 = QtWidgets.QPushButton(Form)
+        # self.pushButton_25.setGeometry(QtCore.QRect(1410, 40, 97, 27))
+        # self.pushButton_25.setObjectName("pushButton_25")
+        # self.pushButton_26 = QtWidgets.QPushButton(Form)
+        # self.pushButton_26.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+        # self.pushButton_26.setObjectName("pushButton_26")
+        # self.pushButton_27 = QtWidgets.QPushButton(Form)
+        # self.pushButton_27.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+        # self.pushButton_27.setObjectName("pushButton_27")
+
+        self.slider_sizeselect = QtWidgets.QSlider(Form)
+        self.slider_sizeselect.setRange(10,70)
+        self.slider_sizeselect.setOrientation(Qt.Horizontal)
+        self.slider_sizeselect.setValue(Form.size)
+        self.slider_sizeselect.setGeometry(QtCore.QRect(1530, 100, 97, 27))
+
+        self.label_sizeselect = QtWidgets.QLabel(Form)
+        self.label_sizeselect.setText("Brush Size")
+        self.label_sizeselect.setGeometry(QtCore.QRect(1630, 100, 97, 27))
+
+        self.slider_yawselect = QtWidgets.QSlider(Form)
+        self.slider_yawselect.setRange(-100,100)
+        self.slider_yawselect.setOrientation(Qt.Horizontal)
+        self.slider_yawselect.setValue(Form.yaw)
+        self.slider_yawselect.setGeometry(QtCore.QRect(1530, 10, 97, 27))
+
+        self.label_yawselect = QtWidgets.QLabel(Form)
+        self.label_yawselect.setText("Yaw")
+        self.label_yawselect.setGeometry(QtCore.QRect(1630, 10, 97, 27))
+
+        self.slider_pitchselect = QtWidgets.QSlider(Form)
+        self.slider_pitchselect.setRange(-100,100)
+        self.slider_pitchselect.setOrientation(Qt.Horizontal)
+        self.slider_pitchselect.setValue(Form.pitch)
+        self.slider_pitchselect.setGeometry(QtCore.QRect(1530, 40, 97, 27))
+
+        self.label_pitchselect = QtWidgets.QLabel(Form)
+        self.label_pitchselect.setText("Pitch")
+        self.label_pitchselect.setGeometry(QtCore.QRect(1630, 40, 97, 27))
+
+        self.slider_rollselect = QtWidgets.QSlider(Form)
+        self.slider_rollselect.setRange(-100,100)
+        self.slider_rollselect.setOrientation(Qt.Horizontal)
+        self.slider_rollselect.setValue(Form.roll)
+        self.slider_rollselect.setGeometry(QtCore.QRect(1530, 70, 97, 27))
+
+        self.label_rollselect = QtWidgets.QLabel(Form)
+        self.label_rollselect.setText("Roll")
+        self.label_rollselect.setGeometry(QtCore.QRect(1630, 70, 97, 27))
+
+
+        self.slider_truncation = QtWidgets.QSlider(Form)
+        self.slider_truncation.setRange(0,100)
+        self.slider_truncation.setOrientation(Qt.Horizontal)
+        self.slider_truncation.setValue(Form.truncation)
+        self.slider_truncation.setGeometry(QtCore.QRect(1530, 130, 97, 27))
+
+        self.label_truncation = QtWidgets.QLabel(Form)
+        self.label_truncation.setText("Truncation")
+        self.label_truncation.setGeometry(QtCore.QRect(1630, 130, 97, 27))
+
+        self.text_inputID = QtWidgets.QTextEdit(Form)
+        self.text_inputID.setGeometry(QtCore.QRect(10, 70, 40, 27))
+        self.text_inputID.setObjectName("text_inputID")
+
+        self.pushButton_inputID = QtWidgets.QPushButton(Form)
+        self.pushButton_inputID.setGeometry(QtCore.QRect(60, 70, 60, 27))
+        self.pushButton_inputID.setObjectName("pushButton_inputID")
+
+        self.text_seed = QtWidgets.QTextEdit(Form)
+        self.text_seed.setGeometry(QtCore.QRect(140, 70, 40, 27))
+        self.text_seed.setObjectName("text_seed")
+        self.text_seed.setPlainText("0")
+
+        self.label_seed = QtWidgets.QLabel(Form)
+        self.label_seed.setText("Seed")
+        self.label_seed.setGeometry(QtCore.QRect(190, 70, 97, 27))
+
+        # self.pushButton_inverse = QtWidgets.QPushButton(Form)
+        # self.pushButton_inverse.setGeometry(QtCore.QRect(535, 400, 81, 27))
+        # self.pushButton_inverse.setObjectName("pushButton_inverse")
+
+        # self.pushButton_clear_ws = QtWidgets.QPushButton(Form)
+        # self.pushButton_clear_ws.setGeometry(QtCore.QRect(535, 430, 81, 27))
+        # self.pushButton_clear_ws.setObjectName("pushButton_clear_ws")
+        self.pushButton_get = QtWidgets.QPushButton(Form)
+        self.pushButton_get.setGeometry(QtCore.QRect(1500, 680 + 512 + 10, 81, 27))
+        self.pushButton_get.setObjectName("pushButton_get")
+
+
+
+
+        self.graphicsView = QtWidgets.QGraphicsView(Form)
+        self.graphicsView.setGeometry(QtCore.QRect(120, 120, 512, 512))
+        self.graphicsView.setObjectName("graphicsView")
+        self.graphicsView_2 = QtWidgets.QGraphicsView(Form)
+        self.graphicsView_2.setGeometry(QtCore.QRect(820, 120, 512, 512))
+        self.graphicsView_2.setObjectName("graphicsView_2") 
+        # self.graphicsView_3 = QtWidgets.QGraphicsView(Form)
+        # self.graphicsView_3.setGeometry(QtCore.QRect(1260, 120, 512, 512))
+        # self.graphicsView_3.setObjectName("graphicsView_3")
+
+        # self.graphicsView_5 = QtWidgets.QGraphicsView(Form)
+        # self.graphicsView_5.setGeometry(QtCore.QRect(620, 680, 512, 512))
+        # self.graphicsView_5.setObjectName("graphicsView_5") 
+        # self.graphicsView_6 = QtWidgets.QGraphicsView(Form)
+        # self.graphicsView_6.setGeometry(QtCore.QRect(1260, 680, 512, 512))
+        # self.graphicsView_6.setObjectName("graphicsView_6")
+
+
+        self.retranslateUi(Form)
+        self.pushButton.clicked.connect(Form.generateAndReconstruct)
+        self.pushButton_2.clicked.connect(Form.open)
+        self.pushButton_3.clicked.connect(Form.open_mask)
+        self.pushButton_4.clicked.connect(Form.clear)
+        self.pushButton_5.clicked.connect(Form.undo)
+        self.pushButton_6.clicked.connect(Form.save_img)
+        self.pushButton_7.clicked.connect(Form.bg_mode)
+        self.pushButton_8.clicked.connect(Form.skin_mode)
+        self.pushButton_9.clicked.connect(Form.nose_mode)
+        self.pushButton_10.clicked.connect(Form.eye_g_mode)
+        self.pushButton_11.clicked.connect(Form.l_eye_mode)
+        self.pushButton_12.clicked.connect(Form.r_eye_mode)
+        # self.pushButton_13.clicked.connect(Form.l_brow_mode)
+        # self.pushButton_14.clicked.connect(Form.r_brow_mode)
+        # self.pushButton_15.clicked.connect(Form.l_ear_mode)
+        # self.pushButton_16.clicked.connect(Form.r_ear_mode)
+        # self.pushButton_17.clicked.connect(Form.mouth_mode)
+        # self.pushButton_18.clicked.connect(Form.u_lip_mode)
+        # self.pushButton_19.clicked.connect(Form.l_lip_mode)
+        # self.pushButton_20.clicked.connect(Form.hair_mode)
+        # self.pushButton_21.clicked.connect(Form.hat_mode)
+        # self.pushButton_22.clicked.connect(Form.ear_r_mode)
+        # self.pushButton_23.clicked.connect(Form.neck_l_mode)
+        # self.pushButton_24.clicked.connect(Form.neck_mode)
+        # self.pushButton_25.clicked.connect(Form.cloth_mode)
+        # self.pushButton_26.clicked.connect(Form.increase)
+        # self.pushButton_27.clicked.connect(Form.decrease)
+
+        self.slider_sizeselect.valueChanged.connect(Form.changeBrushSize)
+        self.slider_yawselect.valueChanged.connect(Form.changeYaw)
+        self.slider_pitchselect.valueChanged.connect(Form.changePitch)
+        self.slider_rollselect.valueChanged.connect(Form.changeRoll)
+        self.slider_truncation.valueChanged.connect(Form.changeTruncation)
+
+        self.pushButton_inputID.clicked.connect(Form.inputID)
+
+        # self.pushButton_inverse.clicked.connect(Form.inverse)
+        # self.pushButton_clear_ws.clicked.connect(Form.clear_ws)
+        self.pushButton_get.clicked.connect(Form.get_mask)
+
+        QtCore.QMetaObject.connectSlotsByName(Form)
+
+    def retranslateUi(self, Form):
+        _translate = QtCore.QCoreApplication.translate
+        Form.setWindowTitle(_translate("Form", "3D-aware Conditional Image Synthesis (Seg2cat)"))
+        self.pushButton.setText(_translate("Form", "Generate"))
+        self.pushButton_2.setText(_translate("Form", "Open Image"))
+        self.pushButton_3.setText(_translate("Form", "Open Mask"))
+        self.pushButton_4.setText(_translate("Form", "Clear"))
+        self.pushButton_5.setText(_translate("Form", "Undo"))
+        self.pushButton_6.setText(_translate("Form", "Save Image"))
+        self.pushButton_7.setText(_translate("Form", "BackGround"))
+        self.pushButton_8.setText(_translate("Form", "Face"))
+        self.pushButton_9.setText(_translate("Form", "Ear"))
+        self.pushButton_10.setText(_translate("Form", "Mouth"))
+        self.pushButton_11.setText(_translate("Form", "Eyes"))
+        self.pushButton_12.setText(_translate("Form", "Whiskers"))
+        # self.pushButton_13.setText(_translate("Form", "Left Eyebrow"))
+        # self.pushButton_14.setText(_translate("Form", "Right Eyebrow"))
+        # self.pushButton_15.setText(_translate("Form", "Left ear"))
+        # self.pushButton_16.setText(_translate("Form", "Right ear"))
+        # self.pushButton_17.setText(_translate("Form", "Mouth"))
+        # self.pushButton_18.setText(_translate("Form", "Upper Lip"))
+        # self.pushButton_19.setText(_translate("Form", "Lower Lip"))
+        # self.pushButton_20.setText(_translate("Form", "Hair"))
+        # self.pushButton_21.setText(_translate("Form", "Hat"))
+        # self.pushButton_22.setText(_translate("Form", "Earring"))
+        # self.pushButton_23.setText(_translate("Form", "Necklace"))
+        # self.pushButton_24.setText(_translate("Form", "Neck"))
+        # self.pushButton_25.setText(_translate("Form", "Cloth"))
+        # self.pushButton_26.setText(_translate("Form", "+"))
+        # self.pushButton_27.setText(_translate("Form", "-"))
+        self.pushButton_inputID.setText(_translate("Form", "Input ID"))
+        # self.pushButton_inverse.setText(_translate("Form", "Inverse"))
+        # self.pushButton_clear_ws.setText(_translate("Form", "Clear ws"))
+        self.pushButton_get.setText(_translate("Form", "Get"))
+
+if __name__ == "__main__":
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    Form = QtWidgets.QWidget()
+    ui = Ui_Form()
+    ui.setupUi(Form)
+    Form.show()
+    sys.exit(app.exec_())
+

pix2pix3D-main/pix2pix3D-main/applications/extract_mesh.py

@@ -0,0 +1,267 @@
+import sys
+sys.path.append('./')
+
+import os
+import re
+from typing import List, Optional, Tuple, Union
+
+import click
+import dnnlib
+import numpy as np
+import PIL.Image
+import torch
+from tqdm import tqdm
+
+
+import legacy
+from camera_utils import LookAtPoseSampler
+
+from matplotlib import pyplot as plt
+
+from pathlib import Path
+
+import json
+
+from training.utils import color_mask, color_list
+
+from tqdm import tqdm
+
+import imageio
+
+import argparse
+
+import trimesh
+import pyrender
+import mcubes
+
+os.environ["PYOPENGL_PLATFORM"] = "egl"
+
+def init_conditional_dataset_kwargs(data, mask_data, data_type, resolution=None):
+    try:
+        if data_type =='seg':
+            dataset_kwargs = dnnlib.EasyDict(class_name='training.dataset.ImageSegFolderDataset', path=data, mask_path=mask_data, data_type=data_type, use_labels=True, max_size=None, xflip=False, resolution=resolution)
+            dataset_obj = dnnlib.util.construct_class_by_name(**dataset_kwargs) # Subclass of training.dataset.Dataset.
+            dataset_kwargs.resolution = dataset_obj.resolution # Be explicit about resolution.
+            dataset_kwargs.use_labels = dataset_obj.has_labels # Be explicit about labels.
+            dataset_kwargs.max_size = len(dataset_obj) # Be explicit about dataset size.
+            return dataset_kwargs, dataset_obj.name
+        elif data_type == 'edge':
+            dataset_kwargs = dnnlib.EasyDict(class_name='training.dataset.ImageEdgeFolderDataset', path=data, mask_path=mask_data, data_type=data_type, use_labels=True, max_size=None, xflip=False)
+            dataset_obj = dnnlib.util.construct_class_by_name(**dataset_kwargs) # Subclass of training.dataset.Dataset.
+            dataset_kwargs.resolution = dataset_obj.resolution # Be explicit about resolution.
+            dataset_kwargs.use_labels = dataset_obj.has_labels # Be explicit about labels.
+            dataset_kwargs.max_size = len(dataset_obj) # Be explicit about dataset size.
+            return dataset_kwargs, dataset_obj.name
+        else:
+            raise click.ClickException(f'Unknown data_type: {data_type}')
+    except IOError as err:
+        raise click.ClickException(f'--data: {err}')
+
+def get_sigma_field_np(nerf, styles, resolution=512, block_resolution=64):
+    # return numpy array of forwarded sigma value
+    # bound = (nerf.rendering_kwargs['ray_end'] - nerf.rendering_kwargs['ray_start']) * 0.5
+    bound = nerf.rendering_kwargs['box_warp'] * 0.5
+    X = torch.linspace(-bound, bound, resolution).split(block_resolution)
+
+    sigma_np = np.zeros([resolution, resolution, resolution], dtype=np.float32)
+
+    for xi, xs in enumerate(X):
+        for yi, ys in enumerate(X):
+            for zi, zs in enumerate(X):
+                xx, yy, zz = torch.meshgrid(xs, ys, zs)
+                pts = torch.stack([xx, yy, zz], dim=-1).unsqueeze(0).to(styles.device)  # B, H, H, H, C
+                block_shape = [1, len(xs), len(ys), len(zs)]
+                out = nerf.sample_mixed(pts.reshape(1,-1,3), None, ws=styles, noise_mode='const')
+                feat_out, sigma_out = out['rgb'], out['sigma']
+                sigma_np[xi * block_resolution: xi * block_resolution + len(xs), \
+                yi * block_resolution: yi * block_resolution + len(ys), \
+                zi * block_resolution: zi * block_resolution + len(zs)] = sigma_out.reshape(block_shape[1:]).detach().cpu().numpy()
+                # print(feat_out.shape)
+
+    return sigma_np, bound
+
+
+def extract_geometry(nerf, styles, resolution, threshold):
+
+    # print('threshold: {}'.format(threshold))
+    u, bound = get_sigma_field_np(nerf, styles, resolution)
+    vertices, faces = mcubes.marching_cubes(u, threshold)
+    # vertices, faces, normals, values = skimage.measure.marching_cubes(
+    #     u, level=10
+    # )
+    b_min_np = np.array([-bound, -bound, -bound])
+    b_max_np = np.array([ bound,  bound,  bound])
+
+    vertices = vertices / (resolution - 1.0) * (b_max_np - b_min_np)[None, :] + b_min_np[None, :]
+    return vertices.astype('float32'), faces
+
+
+
+def main():
+    # Parse arguments
+    parser = argparse.ArgumentParser(description='Generate samples from a trained model')
+    parser.add_argument('--network', help='Path to the network pickle file', required=True)
+    parser.add_argument('--outdir', help='Directory to save the output', required=True)
+
+    parser.add_argument('--input_id', type=int, default=0, help='Input label map id', required=False)
+    parser.add_argument('--data_dir', default='data/', help='Directory to the data', required=False)
+    parser.add_argument('--input', help='input label map', required=False)
+    parser.add_argument('--cfg', help='Base Configuration: seg2face, seg2cat, edge2car', required=True)
+    args = parser.parse_args()
+    device = 'cuda'
+
+    # Load the network
+    with dnnlib.util.open_url(args.network) as f:
+        G = legacy.load_network_pkl(f)['G_ema'].eval().to(device)
+
+    if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+        neural_rendering_resolution = 128
+        pitch_range, yaw_range = 0.25, 0.35
+        data_type = 'seg'
+        # Initialize pose sampler.
+        forward_cam2world_pose = LookAtPoseSampler.sample(3.14/2, 3.14/2, torch.tensor(G.rendering_kwargs['avg_camera_pivot'], device=device), 
+                                                        radius=G.rendering_kwargs['avg_camera_radius'], device=device)
+        focal_length = 4.2647 # shapenet has higher FOV
+        intrinsics = torch.tensor([[focal_length, 0, 0.5], [0, focal_length, 0.5], [0, 0, 1]], device=device)
+        forward_pose = torch.cat([forward_cam2world_pose.reshape(-1, 16), intrinsics.reshape(-1, 9)], 1)
+    elif args.cfg == 'edge2car':
+        neural_rendering_resolution = 64
+        pitch_range, yaw_range = np.pi / 2, np.pi
+        data_type= 'edge'
+
+        forward_cam2world_pose = LookAtPoseSampler.sample(3.14/2, 3.14/2, torch.tensor(G.rendering_kwargs['avg_camera_pivot'], device=device), 
+                                                        radius=G.rendering_kwargs['avg_camera_radius'], device=device)
+        focal_length = 1.7074 # shapenet has higher FOV
+        intrinsics = torch.tensor([[focal_length, 0, 0.5], [0, focal_length, 0.5], [0, 0, 1]], device=device)
+        forward_pose = torch.cat([forward_cam2world_pose.reshape(-1, 16), intrinsics.reshape(-1, 9)], 1)
+    else:
+        print('Invalid cfg')
+        return
+
+    save_dir = Path(args.outdir)
+
+    # Load the input label map
+    if args.input is not None:
+        input_label = PIL.Image.open(args.input)
+        if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+            input_label = np.array(input_label).astype(np.uint8)
+            input_label = torch.from_numpy(input_label).unsqueeze(0).unsqueeze(0).to(device)
+
+            # Save the visualized input label map
+            PIL.Image.fromarray(color_mask(input_label[0,0].cpu().numpy()).astype(np.uint8)).save(save_dir / f'{args.cfg}_input.png') 
+        elif args.cfg == 'edge2car':
+            input_label = np.array(input_label).astype(np.float32)[..., 0]
+            input_label = -(torch.tensor(input_label).to(torch.float32) / 127.5 - 1).unsqueeze(0).unsqueeze(0).to(device)
+        input_pose = forward_pose.to(device)
+       
+    elif args.input_id is not None:
+        if args.cfg == 'seg2cat':
+            data_path = Path(args.data_dir) / 'afhq_v2_train_cat_512.zip'
+            mask_data = Path(args.data_dir) / 'afhqcat_seg_6c.zip'
+        elif args.cfg == 'edge2car':
+            data_path = Path(args.data_dir) / 'cars_128.zip'
+            mask_data = Path(args.data_dir) / 'shapenet_car_contour.zip'
+        elif args.cfg == 'seg2face':
+            data_path = Path(args.data_dir) / 'celebamask_test.zip'
+            mask_data = Path(args.data_dir) / 'celebamask_test_label.zip'
+
+        dataset_kwargs, dataset_name = init_conditional_dataset_kwargs(str(data_path), str(mask_data), data_type)
+        dataset = dnnlib.util.construct_class_by_name(**dataset_kwargs)
+        batch = dataset[args.input_id]
+
+        save_dir = Path(args.outdir)
+
+        # Save the input label map
+        if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+            PIL.Image.fromarray(color_mask(batch['mask'][0]).astype(np.uint8)).save(save_dir / f'{args.cfg}_{args.input_id}_input.png')
+        elif args.cfg == 'edge2car':
+            PIL.Image.fromarray((255 - batch['mask'][0]).astype(np.uint8)).save(save_dir / f'{args.cfg}_{args.input_id}_input.png')
+
+        input_pose = torch.tensor(batch['pose']).unsqueeze(0).to(device)
+        if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+            input_label = torch.tensor(batch['mask']).unsqueeze(0).to(device)
+        elif args.cfg == 'edge2car':
+            input_label = -(torch.tensor(batch['mask']).to(torch.float32) / 127.5 - 1).unsqueeze(0).to(device)
+
+    # Generate videos
+    z = torch.from_numpy(np.random.RandomState(int(0)).randn(1, G.z_dim).astype('float32')).to(device)
+
+    with torch.no_grad():
+        ws = G.mapping(z, input_pose, {'mask': input_label, 'pose': input_pose})
+    
+    mesh_trimesh = trimesh.Trimesh(*extract_geometry(G, ws, resolution=512, threshold=50.))
+
+    if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+
+        verts_np = np.array(mesh_trimesh.vertices)
+        colors = torch.zeros((verts_np.shape[0], 3), device=device)
+        semantic_colors = torch.zeros((verts_np.shape[0], 6), device=device)
+        samples_color = torch.tensor(verts_np, device=device).unsqueeze(0).float()
+
+        head = 0
+        max_batch = 10000000
+        with tqdm(total = verts_np.shape[0]) as pbar:
+            with torch.no_grad():
+                while head < verts_np.shape[0]:
+                    torch.manual_seed(0)
+                    out = G.sample_mixed(samples_color[:, head:head+max_batch], None, ws, truncation_psi=1, noise_mode='const')
+                    # sigma = out['sigma']
+                    colors[head:head+max_batch, :] = out['rgb'][0,:,:3]
+                    seg = out['rgb'][0, :, 32:32+6]
+                    semantic_colors[head:head+max_batch, :] = seg
+                    # semantics[:, head:head+max_batch] = out['semantic']
+                    head += max_batch
+                    pbar.update(max_batch)
+
+        semantic_colors = torch.tensor(color_list)[torch.argmax(semantic_colors, dim=-1)]
+
+        mesh_trimesh.visual.vertex_colors = semantic_colors.cpu().numpy().astype(np.uint8)
+
+        # Save mesh.
+        mesh_trimesh.export(os.path.join(save_dir, f'semantic_mesh.ply'))
+    elif args.cfg == 'edge2car':
+        # Save mesh.
+        mesh_trimesh.export(os.path.join(save_dir, f'{args.cfg}_mesh.ply'))
+
+    mesh = pyrender.Mesh.from_trimesh(mesh_trimesh)
+    light = pyrender.SpotLight(color=np.ones(3), intensity=3.0,
+                innerConeAngle=np.pi/4)
+    r = pyrender.OffscreenRenderer(512, 512)
+    if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+        camera = pyrender.OrthographicCamera(xmag=0.3, ymag=0.3)
+
+    elif args.cfg == 'edge2car':
+        camera = pyrender.OrthographicCamera(xmag=0.6, ymag=0.6)
+
+
+    frames_mesh = []
+    num_frames = 120
+
+    for frame_idx in tqdm(range(num_frames)):
+        scene = pyrender.Scene()
+        scene.add(mesh)
+
+        if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+            camera_pose = LookAtPoseSampler.sample(3.14/2 + yaw_range * np.sin(2 * 3.14 * frame_idx / num_frames),
+                                                3.14/2 -0.05 + pitch_range * np.cos(2 * 3.14 * frame_idx / num_frames),
+                                                torch.tensor(G.rendering_kwargs['avg_camera_pivot'], device=device), radius=1, device=device)
+        elif args.cfg == 'edge2car':
+            camera_pose = LookAtPoseSampler.sample(-3.14/2 + yaw_range * np.sin(2 * 3.14 * frame_idx / num_frames),
+                                                3.14/2 -0.05 + pitch_range * np.cos(2 * 3.14 * frame_idx / num_frames),
+                                                torch.tensor(G.rendering_kwargs['avg_camera_pivot'], device=device), radius=1.2, device=device)
+        camera_pose = camera_pose.reshape(4, 4).cpu().numpy().copy()
+        camera_pose[:, 1] = -camera_pose[:, 1]
+        camera_pose[:, 2] = -camera_pose[:, 2]
+
+        scene.add(camera, pose=camera_pose)
+        scene.add(light, pose=camera_pose)
+        color, depth = r.render(scene)
+        frames_mesh.append(color)
+
+    imageio.mimsave(os.path.join(save_dir, f'rendered_mesh.gif'), frames_mesh, fps=60)
+    r.delete()
+
+
+
+if __name__ == '__main__':
+    main()

pix2pix3D-main/pix2pix3D-main/applications/generate_samples.py

@@ -0,0 +1,128 @@
+import sys
+sys.path.append('./')
+
+import os
+import re
+from typing import List, Optional, Tuple, Union
+
+import click
+import dnnlib
+import numpy as np
+import PIL.Image
+import torch
+from tqdm import tqdm
+
+
+import legacy
+
+from matplotlib import pyplot as plt
+
+from pathlib import Path
+
+import json
+
+from training.utils import color_mask, color_list
+
+from tqdm import tqdm
+
+import argparse
+
+def init_conditional_dataset_kwargs(data, mask_data, data_type, resolution=None):
+    try:
+        if data_type =='seg':
+            dataset_kwargs = dnnlib.EasyDict(class_name='training.dataset.ImageSegFolderDataset', path=data, mask_path=mask_data, data_type=data_type, use_labels=True, max_size=None, xflip=False, resolution=resolution)
+            dataset_obj = dnnlib.util.construct_class_by_name(**dataset_kwargs) # Subclass of training.dataset.Dataset.
+            dataset_kwargs.resolution = dataset_obj.resolution # Be explicit about resolution.
+            dataset_kwargs.use_labels = dataset_obj.has_labels # Be explicit about labels.
+            dataset_kwargs.max_size = len(dataset_obj) # Be explicit about dataset size.
+            return dataset_kwargs, dataset_obj.name
+        elif data_type == 'edge':
+            dataset_kwargs = dnnlib.EasyDict(class_name='training.dataset.ImageEdgeFolderDataset', path=data, mask_path=mask_data, data_type=data_type, use_labels=True, max_size=None, xflip=False)
+            dataset_obj = dnnlib.util.construct_class_by_name(**dataset_kwargs) # Subclass of training.dataset.Dataset.
+            dataset_kwargs.resolution = dataset_obj.resolution # Be explicit about resolution.
+            dataset_kwargs.use_labels = dataset_obj.has_labels # Be explicit about labels.
+            dataset_kwargs.max_size = len(dataset_obj) # Be explicit about dataset size.
+            return dataset_kwargs, dataset_obj.name
+        else:
+            raise click.ClickException(f'Unknown data_type: {data_type}')
+    except IOError as err:
+        raise click.ClickException(f'--data: {err}')
+
+def main():
+    # Parse arguments
+    parser = argparse.ArgumentParser(description='Generate samples from a trained model')
+    parser.add_argument('--network', help='Path to the network pickle file', required=True)
+    parser.add_argument('--outdir', help='Directory to save the output', required=True)
+    # Define an argument of a list of random seeds
+    parser.add_argument('--random_seed', help='Random seed', nargs="+", type=int)
+
+    parser.add_argument('--input_id', type=int, default=0, help='Input label map id', required=True)
+    parser.add_argument('--data_dir', default='data/', help='Directory to the data', required=False)
+    parser.add_argument('--cfg', help='Base Configuration: seg2face, seg2cat, edge2car', required=True)
+    args = parser.parse_args()
+    device = 'cuda'
+
+    if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+        neural_rendering_resolution = 128
+        data_type = 'seg'
+    elif args.cfg == 'edge2car':
+        neural_rendering_resolution = 64
+        data_type= 'edge'
+    else:
+        print('Invalid cfg')
+        return
+
+    # Load the network
+    with dnnlib.util.open_url(args.network) as f:
+        G = legacy.load_network_pkl(f)['G_ema'].eval().to(device)
+
+    # Load the input label map
+    # Initialize dataset.
+    if args.cfg == 'seg2cat':
+        data_path = Path(args.data_dir) / 'afhq_v2_train_cat_512.zip'
+        mask_data = Path(args.data_dir) / 'afhqcat_seg_6c.zip'
+    elif args.cfg == 'edge2car':
+        data_path = Path(args.data_dir) / 'cars_128.zip'
+        mask_data = Path(args.data_dir) / 'shapenet_car_contour.zip'
+    elif args.cfg == 'seg2face':
+        data_path = Path(args.data_dir) / 'celebamask_test.zip'
+        mask_data = Path(args.data_dir) / 'celebamask_test_label.zip'
+
+    dataset_kwargs, dataset_name = init_conditional_dataset_kwargs(str(data_path), str(mask_data), data_type)
+    dataset = dnnlib.util.construct_class_by_name(**dataset_kwargs)
+    batch = dataset[args.input_id]
+
+    save_dir = Path(args.outdir)
+
+    # Save the input label map
+    if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+        PIL.Image.fromarray(color_mask(batch['mask'][0]).astype(np.uint8)).save(save_dir / f'{args.cfg}_{args.input_id}_input.png')
+    elif args.cfg == 'edge2car':
+        PIL.Image.fromarray((255 - batch['mask'][0]).astype(np.uint8)).save(save_dir / f'{args.cfg}_{args.input_id}_input.png')
+
+    # Generate samples
+    for seed in args.random_seed:
+        z = torch.from_numpy(np.random.RandomState(int(seed)).randn(1, G.z_dim).astype('float32')).to(device)
+        input_pose = torch.tensor(batch['pose']).unsqueeze(0).to(device)
+        if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+            input_label = torch.tensor(batch['mask']).unsqueeze(0).to(device)
+        elif args.cfg == 'edge2car':
+            input_label = -(torch.tensor(batch['mask']).to(torch.float32) / 127.5 - 1).unsqueeze(0).to(device)
+
+        with torch.no_grad():
+            ws = G.mapping(z, input_pose, {'mask': input_label, 'pose': input_pose})
+            out = G.synthesis(ws, input_pose, noise_mode='const', neural_rendering_resolution=neural_rendering_resolution)
+            
+        image_color = ((out['image'][0].permute(1, 2, 0).cpu().numpy().clip(-1, 1) + 1) * 127.5).astype(np.uint8)
+        if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+            image_label = color_mask(torch.argmax(out['semantic'][0], dim=0).cpu().numpy()).astype(np.uint8)
+        elif args.cfg == 'edge2car':
+            image_label = ((out['semantic'][0].cpu().numpy() + 1) * 127.5).clip(0, 255).astype(np.uint8)[0]
+
+        PIL.Image.fromarray(image_color).save(save_dir / f'{args.cfg}_{args.input_id}_{seed}_color.png')
+        PIL.Image.fromarray(image_label).save(save_dir / f'{args.cfg}_{args.input_id}_{seed}_label.png')
+
+
+
+if __name__ == '__main__':
+    main()

pix2pix3D-main/pix2pix3D-main/applications/generate_video.py

@@ -0,0 +1,220 @@
+import sys
+sys.path.append('./')
+
+import os
+import re
+from typing import List, Optional, Tuple, Union
+
+import click
+import dnnlib
+import numpy as np
+import PIL.Image
+import torch
+from tqdm import tqdm
+
+
+import legacy
+from camera_utils import LookAtPoseSampler
+
+from matplotlib import pyplot as plt
+
+from pathlib import Path
+
+import json
+
+from training.utils import color_mask, color_list
+
+from tqdm import tqdm
+
+import imageio
+
+import argparse
+
+def init_conditional_dataset_kwargs(data, mask_data, data_type, resolution=None):
+    try:
+        if data_type =='seg':
+            dataset_kwargs = dnnlib.EasyDict(class_name='training.dataset.ImageSegFolderDataset', path=data, mask_path=mask_data, data_type=data_type, use_labels=True, max_size=None, xflip=False, resolution=resolution)
+            dataset_obj = dnnlib.util.construct_class_by_name(**dataset_kwargs) # Subclass of training.dataset.Dataset.
+            dataset_kwargs.resolution = dataset_obj.resolution # Be explicit about resolution.
+            dataset_kwargs.use_labels = dataset_obj.has_labels # Be explicit about labels.
+            dataset_kwargs.max_size = len(dataset_obj) # Be explicit about dataset size.
+            return dataset_kwargs, dataset_obj.name
+        elif data_type == 'edge':
+            dataset_kwargs = dnnlib.EasyDict(class_name='training.dataset.ImageEdgeFolderDataset', path=data, mask_path=mask_data, data_type=data_type, use_labels=True, max_size=None, xflip=False)
+            dataset_obj = dnnlib.util.construct_class_by_name(**dataset_kwargs) # Subclass of training.dataset.Dataset.
+            dataset_kwargs.resolution = dataset_obj.resolution # Be explicit about resolution.
+            dataset_kwargs.use_labels = dataset_obj.has_labels # Be explicit about labels.
+            dataset_kwargs.max_size = len(dataset_obj) # Be explicit about dataset size.
+            return dataset_kwargs, dataset_obj.name
+        else:
+            raise click.ClickException(f'Unknown data_type: {data_type}')
+    except IOError as err:
+        raise click.ClickException(f'--data: {err}')
+
+def render_video(G, ws, intrinsics, num_frames = 120, pitch_range = 0.25, yaw_range = 0.35, neural_rendering_resolution = 128, device='cuda'):
+    frames, frames_label = [], []
+
+    for frame_idx in tqdm(range(num_frames)):
+        cam2world_pose = LookAtPoseSampler.sample(3.14/2 + yaw_range * np.sin(2 * 3.14 * frame_idx / num_frames),
+                                                3.14/2 -0.05 + pitch_range * np.cos(2 * 3.14 * frame_idx / num_frames),
+                                                torch.tensor(G.rendering_kwargs['avg_camera_pivot'], device=device), radius=G.rendering_kwargs['avg_camera_radius'], device=device)
+        pose = torch.cat([cam2world_pose.reshape(-1, 16), intrinsics.reshape(-1, 9)], 1)
+        with torch.no_grad():
+            out = G.synthesis(ws, pose, noise_mode='const', neural_rendering_resolution=neural_rendering_resolution)
+        # frames.append(((out['image'].cpu().numpy()[0] + 1) * 127.5).clip(0, 255).astype(np.uint8).transpose(1, 2, 0))
+        image_color = ((out['image'][0].permute(1, 2, 0).cpu().numpy().clip(-1, 1) + 1) * 127.5).astype(np.uint8)
+        frames.append(image_color)
+        frames_label.append(color_mask(torch.argmax(out['semantic'], dim=1).cpu().numpy()[0]).astype(np.uint8))
+
+    return frames, frames_label
+
+def render_video_edge(G, ws, intrinsics, num_frames = 120, pitch_range = np.pi / 2, yaw_range = np.pi, neural_rendering_resolution = 64, device='cuda'):
+    frames, frames_label = [], []
+
+    for frame_idx in tqdm(range(num_frames)):
+        cam2world_pose = LookAtPoseSampler.sample(-3.14/2 + yaw_range * np.cos(2 * 3.14 * frame_idx / num_frames),
+                                                3.14/2 -0.05 + pitch_range * np.sin(2 * 3.14 * frame_idx / num_frames),
+                                                torch.tensor(G.rendering_kwargs['avg_camera_pivot'], device=device), radius=G.rendering_kwargs['avg_camera_radius'], device=device)
+        pose = torch.cat([cam2world_pose.reshape(-1, 16), intrinsics.reshape(-1, 9)], 1)
+        with torch.no_grad():
+            out = G.synthesis(ws, pose, noise_mode='const', neural_rendering_resolution=neural_rendering_resolution)
+        frames.append(((out['image'].cpu().numpy()[0] + 1) * 127.5).clip(0, 255).astype(np.uint8).transpose(1, 2, 0))
+        frames_label.append(((out['semantic'].cpu().numpy()[0] + 1) * 127.5).clip(0, 255).astype(np.uint8)[0])
+
+    return frames, frames_label
+
+def render_video_edge2cat(G, ws, intrinsics, num_frames = 120, pitch_range = np.pi / 2, yaw_range = np.pi, neural_rendering_resolution = 64, device='cuda'):
+    frames, frames_label = [], []
+
+    for frame_idx in tqdm(range(num_frames)):
+        cam2world_pose = LookAtPoseSampler.sample(3.14/2 + yaw_range * np.sin(2 * 3.14 * frame_idx / num_frames),
+                                                3.14/2 -0.05 + pitch_range * np.cos(2 * 3.14 * frame_idx / num_frames),
+                                                torch.tensor(G.rendering_kwargs['avg_camera_pivot'], device=device), radius=G.rendering_kwargs['avg_camera_radius'], device=device)
+        pose = torch.cat([cam2world_pose.reshape(-1, 16), intrinsics.reshape(-1, 9)], 1)
+        with torch.no_grad():
+            out = G.synthesis(ws, pose, noise_mode='const', neural_rendering_resolution=neural_rendering_resolution)
+        frames.append(((out['image'].cpu().numpy()[0] + 1) * 127.5).clip(0, 255).astype(np.uint8).transpose(1, 2, 0))
+        frames_label.append(((out['semantic'].cpu().numpy()[0] + 1) * 127.5).clip(0, 255).astype(np.uint8)[0])
+
+    return frames, frames_label
+
+def main():
+    # Parse arguments
+    parser = argparse.ArgumentParser(description='Generate samples from a trained model')
+    parser.add_argument('--network', help='Path to the network pickle file', required=True)
+    parser.add_argument('--outdir', help='Directory to save the output', required=True)
+    # Define an argument of a list of random seeds
+    parser.add_argument('--random_seed', help='Random seed', nargs="+", type=int)
+
+    parser.add_argument('--input_id', type=int, default=0, help='Input label map id', required=False)
+    parser.add_argument('--data_dir', default='data/', help='Directory to the data', required=False)
+    parser.add_argument('--input', help='input label map', required=False)
+    parser.add_argument('--cfg', help='Base Configuration: seg2face, seg2cat, edge2car', required=True)
+    args = parser.parse_args()
+    device = 'cuda'
+
+    # Load the network
+    with dnnlib.util.open_url(args.network) as f:
+        G = legacy.load_network_pkl(f)['G_ema'].eval().to(device)
+
+    if args.cfg == 'seg2cat' or args.cfg == 'seg2face' or args.cfg == 'edge2cat':
+        neural_rendering_resolution = 128
+        pitch_range, yaw_range = 0.25, 0.35
+        data_type = 'seg'
+        # Initialize pose sampler.
+        forward_cam2world_pose = LookAtPoseSampler.sample(3.14/2, 3.14/2, torch.tensor(G.rendering_kwargs['avg_camera_pivot'], device=device), 
+                                                        radius=G.rendering_kwargs['avg_camera_radius'], device=device)
+        focal_length = 4.2647 
+        intrinsics = torch.tensor([[focal_length, 0, 0.5], [0, focal_length, 0.5], [0, 0, 1]], device=device)
+        forward_pose = torch.cat([forward_cam2world_pose.reshape(-1, 16), intrinsics.reshape(-1, 9)], 1)
+    elif args.cfg == 'edge2car':
+        neural_rendering_resolution = 64
+        pitch_range, yaw_range = np.pi / 2, np.pi
+        data_type= 'edge'
+
+        forward_cam2world_pose = LookAtPoseSampler.sample(3.14/2, 3.14/2, torch.tensor(G.rendering_kwargs['avg_camera_pivot'], device=device), 
+                                                        radius=G.rendering_kwargs['avg_camera_radius'], device=device)
+        focal_length = 1.7074 # shapenet has higher FOV
+        intrinsics = torch.tensor([[focal_length, 0, 0.5], [0, focal_length, 0.5], [0, 0, 1]], device=device)
+        forward_pose = torch.cat([forward_cam2world_pose.reshape(-1, 16), intrinsics.reshape(-1, 9)], 1)
+    else:
+        print('Invalid cfg')
+        return
+
+    save_dir = Path(args.outdir)
+
+    # Load the input label map
+    if args.input is not None:
+        input_label = PIL.Image.open(args.input)
+        if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+            input_label = np.array(input_label).astype(np.uint8)
+            input_label = torch.from_numpy(input_label).unsqueeze(0).unsqueeze(0).to(device)
+
+            # Save the visualized input label map
+            PIL.Image.fromarray(color_mask(input_label[0,0].cpu().numpy()).astype(np.uint8)).save(save_dir / f'{args.cfg}_input.png') 
+        elif args.cfg == 'edge2car' or args.cfg == 'edge2cat':
+            input_label = np.array(input_label).astype(np.float32)
+            if input_label.ndim == 3:
+                input_label = input_label[:,:,0]
+            print(input_label.min(), input_label.max())
+            input_label = (torch.tensor(input_label).to(torch.float32) / 127.5 - 1).unsqueeze(0).unsqueeze(0).to(device)
+            plt.imshow(input_label.cpu().numpy()[0,0], cmap='gray')
+            plt.savefig(save_dir / f'{args.cfg}_input.png')
+
+        input_pose = forward_pose.to(device)
+       
+    elif args.input_id is not None:
+        if args.cfg == 'seg2cat':
+            data_path = Path(args.data_dir) / 'afhq_v2_train_cat_512.zip'
+            mask_data = Path(args.data_dir) / 'afhqcat_seg_6c.zip'
+        elif args.cfg == 'edge2car':
+            data_path = Path(args.data_dir) / 'cars_128.zip'
+            mask_data = Path(args.data_dir) / 'shapenet_car_contour.zip'
+        elif args.cfg == 'seg2face':
+            # data_path = Path(args.data_dir) / 'celebamask_test.zip'
+            # mask_data = Path(args.data_dir) / 'celebamask_test_label.zip'
+            data_path = '/data2/datasets/CelebAMask_eg3d/test/celebamask_test.zip'
+            mask_data = '/data2/datasets/CelebAMask_eg3d/test/celebamask_test_label.zip'
+        elif args.cfg == 'edge2cat':
+            data_path = '/data2/datasets/AFHQ_eg3d/afhq_v2_train_cat_512.zip'
+            mask_data = '/data2/datasets/AFHQ_eg3d/afhqcat_contour_pidinet.zip'
+
+        dataset_kwargs, dataset_name = init_conditional_dataset_kwargs(str(data_path), str(mask_data), data_type)
+        dataset = dnnlib.util.construct_class_by_name(**dataset_kwargs)
+        batch = dataset[args.input_id]
+
+        save_dir = Path(args.outdir)
+
+        # Save the input label map
+        if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+            PIL.Image.fromarray(color_mask(batch['mask'][0]).astype(np.uint8)).save(save_dir / f'{args.cfg}_{args.input_id}_input.png')
+        elif args.cfg == 'edge2car' or args.cfg == 'edge2cat':
+            PIL.Image.fromarray((255 - batch['mask'][0]).astype(np.uint8)).save(save_dir / f'{args.cfg}_{args.input_id}_input.png')
+
+        input_pose = torch.tensor(batch['pose']).unsqueeze(0).to(device)
+        if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+            input_label = torch.tensor(batch['mask']).unsqueeze(0).to(device)
+        elif args.cfg == 'edge2car' or args.cfg == 'edge2cat':
+            input_label = -(torch.tensor(batch['mask']).to(torch.float32) / 127.5 - 1).unsqueeze(0).to(device)
+
+    # Generate videos
+    for seed in args.random_seed:
+        z = torch.from_numpy(np.random.RandomState(int(seed)).randn(1, G.z_dim).astype('float32')).to(device)
+
+        with torch.no_grad():
+            ws = G.mapping(z, input_pose, {'mask': input_label, 'pose': input_pose})
+        
+        # Generate the video
+        if args.cfg == 'seg2cat' or args.cfg == 'seg2face':
+            frames, frames_label = render_video(G, ws, intrinsics, num_frames = 120, pitch_range = pitch_range, yaw_range = yaw_range, neural_rendering_resolution=neural_rendering_resolution, device=device)
+        elif args.cfg == 'edge2car' or args.cfg == 'edge2cat':
+            frames, frames_label = render_video_edge2cat(G, ws, intrinsics, num_frames = 120, pitch_range = pitch_range, yaw_range = yaw_range, neural_rendering_resolution=neural_rendering_resolution, device=device)
+
+        # Save the video
+        imageio.mimsave(save_dir / f'{args.cfg}_{seed}.gif', frames, fps=60)
+        imageio.mimsave(save_dir / f'{args.cfg}_{seed}_label.gif', frames_label, fps=60)
+
+
+
+if __name__ == '__main__':
+    main()

pix2pix3D-main/pix2pix3D-main/assets/demo.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:021005482c8f89c0d62b62709020c7e7e3de05152132d2c1dfa1b9256962fe59
+size 6362125

pix2pix3D-main/pix2pix3D-main/camera_utils.py

@@ -0,0 +1,149 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""
+Helper functions for constructing camera parameter matrices. Primarily used in visualization and inference scripts.
+"""
+
+import math
+
+import torch
+import torch.nn as nn
+
+from training.volumetric_rendering import math_utils
+
+class GaussianCameraPoseSampler:
+    """
+    Samples pitch and yaw from a Gaussian distribution and returns a camera pose.
+    Camera is specified as looking at the origin.
+    If horizontal and vertical stddev (specified in radians) are zero, gives a
+    deterministic camera pose with yaw=horizontal_mean, pitch=vertical_mean.
+    The coordinate system is specified with y-up, z-forward, x-left.
+    Horizontal mean is the azimuthal angle (rotation around y axis) in radians,
+    vertical mean is the polar angle (angle from the y axis) in radians.
+    A point along the z-axis has azimuthal_angle=0, polar_angle=pi/2.
+
+    Example:
+    For a camera pose looking at the origin with the camera at position [0, 0, 1]:
+    cam2world = GaussianCameraPoseSampler.sample(math.pi/2, math.pi/2, radius=1)
+    """
+
+    @staticmethod
+    def sample(horizontal_mean, vertical_mean, horizontal_stddev=0, vertical_stddev=0, radius=1, batch_size=1, device='cpu'):
+        h = torch.randn((batch_size, 1), device=device) * horizontal_stddev + horizontal_mean
+        v = torch.randn((batch_size, 1), device=device) * vertical_stddev + vertical_mean
+        v = torch.clamp(v, 1e-5, math.pi - 1e-5)
+
+        theta = h
+        v = v / math.pi
+        phi = torch.arccos(1 - 2*v)
+
+        camera_origins = torch.zeros((batch_size, 3), device=device)
+
+        camera_origins[:, 0:1] = radius*torch.sin(phi) * torch.cos(math.pi-theta)
+        camera_origins[:, 2:3] = radius*torch.sin(phi) * torch.sin(math.pi-theta)
+        camera_origins[:, 1:2] = radius*torch.cos(phi)
+
+        forward_vectors = math_utils.normalize_vecs(-camera_origins)
+        return create_cam2world_matrix(forward_vectors, camera_origins)
+
+
+class LookAtPoseSampler:
+    """
+    Same as GaussianCameraPoseSampler, except the
+    camera is specified as looking at 'lookat_position', a 3-vector.
+
+    Example:
+    For a camera pose looking at the origin with the camera at position [0, 0, 1]:
+    cam2world = LookAtPoseSampler.sample(math.pi/2, math.pi/2, torch.tensor([0, 0, 0]), radius=1)
+    """
+
+    @staticmethod
+    def sample(horizontal_mean, vertical_mean, lookat_position, horizontal_stddev=0, vertical_stddev=0, radius=1, batch_size=1, device='cpu'):
+        h = torch.randn((batch_size, 1), device=device) * horizontal_stddev + horizontal_mean
+        v = torch.randn((batch_size, 1), device=device) * vertical_stddev + vertical_mean
+        v = torch.clamp(v, 1e-5, math.pi - 1e-5)
+
+        theta = h
+        v = v / math.pi
+        phi = torch.arccos(1 - 2*v)
+
+        camera_origins = torch.zeros((batch_size, 3), device=device)
+
+        camera_origins[:, 0:1] = radius*torch.sin(phi) * torch.cos(math.pi-theta)
+        camera_origins[:, 2:3] = radius*torch.sin(phi) * torch.sin(math.pi-theta)
+        camera_origins[:, 1:2] = radius*torch.cos(phi)
+
+        # forward_vectors = math_utils.normalize_vecs(-camera_origins)
+        forward_vectors = math_utils.normalize_vecs(lookat_position - camera_origins)
+        return create_cam2world_matrix(forward_vectors, camera_origins)
+
+class UniformCameraPoseSampler:
+    """
+    Same as GaussianCameraPoseSampler, except the
+    pose is sampled from a uniform distribution with range +-[horizontal/vertical]_stddev.
+
+    Example:
+    For a batch of random camera poses looking at the origin with yaw sampled from [-pi/2, +pi/2] radians:
+
+    cam2worlds = UniformCameraPoseSampler.sample(math.pi/2, math.pi/2, horizontal_stddev=math.pi/2, radius=1, batch_size=16)
+    """
+
+    @staticmethod
+    def sample(horizontal_mean, vertical_mean, horizontal_stddev=0, vertical_stddev=0, radius=1, batch_size=1, device='cpu'):
+        h = (torch.rand((batch_size, 1), device=device) * 2 - 1) * horizontal_stddev + horizontal_mean
+        v = (torch.rand((batch_size, 1), device=device) * 2 - 1) * vertical_stddev + vertical_mean
+        v = torch.clamp(v, 1e-5, math.pi - 1e-5)
+
+        theta = h
+        v = v / math.pi
+        phi = torch.arccos(1 - 2*v)
+
+        camera_origins = torch.zeros((batch_size, 3), device=device)
+
+        camera_origins[:, 0:1] = radius*torch.sin(phi) * torch.cos(math.pi-theta)
+        camera_origins[:, 2:3] = radius*torch.sin(phi) * torch.sin(math.pi-theta)
+        camera_origins[:, 1:2] = radius*torch.cos(phi)
+
+        forward_vectors = math_utils.normalize_vecs(-camera_origins)
+        return create_cam2world_matrix(forward_vectors, camera_origins)    
+
+def create_cam2world_matrix(forward_vector, origin):
+    """
+    Takes in the direction the camera is pointing and the camera origin and returns a cam2world matrix.
+    Works on batches of forward_vectors, origins. Assumes y-axis is up and that there is no camera roll.
+    """
+
+    forward_vector = math_utils.normalize_vecs(forward_vector)
+    up_vector = torch.tensor([0, 1, 0], dtype=torch.float, device=origin.device).expand_as(forward_vector)
+
+    right_vector = -math_utils.normalize_vecs(torch.cross(up_vector, forward_vector, dim=-1))
+    up_vector = math_utils.normalize_vecs(torch.cross(forward_vector, right_vector, dim=-1))
+
+    rotation_matrix = torch.eye(4, device=origin.device).unsqueeze(0).repeat(forward_vector.shape[0], 1, 1)
+    rotation_matrix[:, :3, :3] = torch.stack((right_vector, up_vector, forward_vector), axis=-1)
+
+    translation_matrix = torch.eye(4, device=origin.device).unsqueeze(0).repeat(forward_vector.shape[0], 1, 1)
+    translation_matrix[:, :3, 3] = origin
+    cam2world = (translation_matrix @ rotation_matrix)[:, :, :]
+    assert(cam2world.shape[1:] == (4, 4))
+    return cam2world
+
+
+def FOV_to_intrinsics(fov_degrees, device='cpu'):
+    """
+    Creates a 3x3 camera intrinsics matrix from the camera field of view, specified in degrees.
+    Note the intrinsics are returned as normalized by image size, rather than in pixel units.
+    Assumes principal point is at image center.
+    """
+
+    focal_length = float(1 / (math.tan(fov_degrees * 3.14159 / 360) * 1.414))
+    intrinsics = torch.tensor([[focal_length, 0, 0.5], [0, focal_length, 0.5], [0, 0, 1]], device=device)
+    return intrinsics

pix2pix3D-main/pix2pix3D-main/checkpoints/download_models.sh

@@ -0,0 +1,5 @@
+cd checkpoints
+wget http://cs.cmu.edu/~pix2pix3D/release.tar
+tar -xvf release.tar
+rm release.tar
+cd ..

pix2pix3D-main/pix2pix3D-main/dnnlib/__init__.py

@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+from .util import EasyDict, make_cache_dir_path

pix2pix3D-main/pix2pix3D-main/dnnlib/util.py

@@ -0,0 +1,493 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""Miscellaneous utility classes and functions."""
+
+import ctypes
+import fnmatch
+import importlib
+import inspect
+import numpy as np
+import os
+import shutil
+import sys
+import types
+import io
+import pickle
+import re
+import requests
+import html
+import hashlib
+import glob
+import tempfile
+import urllib
+import urllib.request
+import uuid
+
+from distutils.util import strtobool
+from typing import Any, List, Tuple, Union
+
+
+# Util classes
+# ------------------------------------------------------------------------------------------
+
+
+class EasyDict(dict):
+    """Convenience class that behaves like a dict but allows access with the attribute syntax."""
+
+    def __getattr__(self, name: str) -> Any:
+        try:
+            return self[name]
+        except KeyError:
+            raise AttributeError(name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        self[name] = value
+
+    def __delattr__(self, name: str) -> None:
+        del self[name]
+
+
+class Logger(object):
+    """Redirect stderr to stdout, optionally print stdout to a file, and optionally force flushing on both stdout and the file."""
+
+    def __init__(self, file_name: str = None, file_mode: str = "w", should_flush: bool = True):
+        self.file = None
+
+        if file_name is not None:
+            self.file = open(file_name, file_mode)
+
+        self.should_flush = should_flush
+        self.stdout = sys.stdout
+        self.stderr = sys.stderr
+
+        sys.stdout = self
+        sys.stderr = self
+
+    def __enter__(self) -> "Logger":
+        return self
+
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+        self.close()
+
+    def write(self, text: Union[str, bytes]) -> None:
+        """Write text to stdout (and a file) and optionally flush."""
+        if isinstance(text, bytes):
+            text = text.decode()
+        if len(text) == 0: # workaround for a bug in VSCode debugger: sys.stdout.write(''); sys.stdout.flush() => crash
+            return
+
+        if self.file is not None:
+            self.file.write(text)
+
+        self.stdout.write(text)
+
+        if self.should_flush:
+            self.flush()
+
+    def flush(self) -> None:
+        """Flush written text to both stdout and a file, if open."""
+        if self.file is not None:
+            self.file.flush()
+
+        self.stdout.flush()
+
+    def close(self) -> None:
+        """Flush, close possible files, and remove stdout/stderr mirroring."""
+        self.flush()
+
+        # if using multiple loggers, prevent closing in wrong order
+        if sys.stdout is self:
+            sys.stdout = self.stdout
+        if sys.stderr is self:
+            sys.stderr = self.stderr
+
+        if self.file is not None:
+            self.file.close()
+            self.file = None
+
+
+# Cache directories
+# ------------------------------------------------------------------------------------------
+
+_dnnlib_cache_dir = None
+
+def set_cache_dir(path: str) -> None:
+    global _dnnlib_cache_dir
+    _dnnlib_cache_dir = path
+
+def make_cache_dir_path(*paths: str) -> str:
+    if _dnnlib_cache_dir is not None:
+        return os.path.join(_dnnlib_cache_dir, *paths)
+    if 'DNNLIB_CACHE_DIR' in os.environ:
+        return os.path.join(os.environ['DNNLIB_CACHE_DIR'], *paths)
+    if 'HOME' in os.environ:
+        return os.path.join(os.environ['HOME'], '.cache', 'dnnlib', *paths)
+    if 'USERPROFILE' in os.environ:
+        return os.path.join(os.environ['USERPROFILE'], '.cache', 'dnnlib', *paths)
+    return os.path.join(tempfile.gettempdir(), '.cache', 'dnnlib', *paths)
+
+# Small util functions
+# ------------------------------------------------------------------------------------------
+
+
+def format_time(seconds: Union[int, float]) -> str:
+    """Convert the seconds to human readable string with days, hours, minutes and seconds."""
+    s = int(np.rint(seconds))
+
+    if s < 60:
+        return "{0}s".format(s)
+    elif s < 60 * 60:
+        return "{0}m {1:02}s".format(s // 60, s % 60)
+    elif s < 24 * 60 * 60:
+        return "{0}h {1:02}m {2:02}s".format(s // (60 * 60), (s // 60) % 60, s % 60)
+    else:
+        return "{0}d {1:02}h {2:02}m".format(s // (24 * 60 * 60), (s // (60 * 60)) % 24, (s // 60) % 60)
+
+
+def format_time_brief(seconds: Union[int, float]) -> str:
+    """Convert the seconds to human readable string with days, hours, minutes and seconds."""
+    s = int(np.rint(seconds))
+
+    if s < 60:
+        return "{0}s".format(s)
+    elif s < 60 * 60:
+        return "{0}m {1:02}s".format(s // 60, s % 60)
+    elif s < 24 * 60 * 60:
+        return "{0}h {1:02}m".format(s // (60 * 60), (s // 60) % 60)
+    else:
+        return "{0}d {1:02}h".format(s // (24 * 60 * 60), (s // (60 * 60)) % 24)
+
+
+def ask_yes_no(question: str) -> bool:
+    """Ask the user the question until the user inputs a valid answer."""
+    while True:
+        try:
+            print("{0} [y/n]".format(question))
+            return strtobool(input().lower())
+        except ValueError:
+            pass
+
+
+def tuple_product(t: Tuple) -> Any:
+    """Calculate the product of the tuple elements."""
+    result = 1
+
+    for v in t:
+        result *= v
+
+    return result
+
+
+_str_to_ctype = {
+    "uint8": ctypes.c_ubyte,
+    "uint16": ctypes.c_uint16,
+    "uint32": ctypes.c_uint32,
+    "uint64": ctypes.c_uint64,
+    "int8": ctypes.c_byte,
+    "int16": ctypes.c_int16,
+    "int32": ctypes.c_int32,
+    "int64": ctypes.c_int64,
+    "float32": ctypes.c_float,
+    "float64": ctypes.c_double
+}
+
+
+def get_dtype_and_ctype(type_obj: Any) -> Tuple[np.dtype, Any]:
+    """Given a type name string (or an object having a __name__ attribute), return matching Numpy and ctypes types that have the same size in bytes."""
+    type_str = None
+
+    if isinstance(type_obj, str):
+        type_str = type_obj
+    elif hasattr(type_obj, "__name__"):
+        type_str = type_obj.__name__
+    elif hasattr(type_obj, "name"):
+        type_str = type_obj.name
+    else:
+        raise RuntimeError("Cannot infer type name from input")
+
+    assert type_str in _str_to_ctype.keys()
+
+    my_dtype = np.dtype(type_str)
+    my_ctype = _str_to_ctype[type_str]
+
+    assert my_dtype.itemsize == ctypes.sizeof(my_ctype)
+
+    return my_dtype, my_ctype
+
+
+def is_pickleable(obj: Any) -> bool:
+    try:
+        with io.BytesIO() as stream:
+            pickle.dump(obj, stream)
+        return True
+    except:
+        return False
+
+
+# Functionality to import modules/objects by name, and call functions by name
+# ------------------------------------------------------------------------------------------
+
+def get_module_from_obj_name(obj_name: str) -> Tuple[types.ModuleType, str]:
+    """Searches for the underlying module behind the name to some python object.
+    Returns the module and the object name (original name with module part removed)."""
+
+    # allow convenience shorthands, substitute them by full names
+    obj_name = re.sub("^np.", "numpy.", obj_name)
+    obj_name = re.sub("^tf.", "tensorflow.", obj_name)
+
+    # list alternatives for (module_name, local_obj_name)
+    parts = obj_name.split(".")
+    name_pairs = [(".".join(parts[:i]), ".".join(parts[i:])) for i in range(len(parts), 0, -1)]
+
+    # try each alternative in turn
+    for module_name, local_obj_name in name_pairs:
+        try:
+            module = importlib.import_module(module_name) # may raise ImportError
+            get_obj_from_module(module, local_obj_name) # may raise AttributeError
+            return module, local_obj_name
+        except:
+            pass
+
+    # maybe some of the modules themselves contain errors?
+    for module_name, _local_obj_name in name_pairs:
+        try:
+            importlib.import_module(module_name) # may raise ImportError
+        except ImportError:
+            if not str(sys.exc_info()[1]).startswith("No module named '" + module_name + "'"):
+                raise
+
+    # maybe the requested attribute is missing?
+    for module_name, local_obj_name in name_pairs:
+        try:
+            module = importlib.import_module(module_name) # may raise ImportError
+            get_obj_from_module(module, local_obj_name) # may raise AttributeError
+        except ImportError:
+            pass
+
+    # we are out of luck, but we have no idea why
+    raise ImportError(obj_name)
+
+
+def get_obj_from_module(module: types.ModuleType, obj_name: str) -> Any:
+    """Traverses the object name and returns the last (rightmost) python object."""
+    if obj_name == '':
+        return module
+    obj = module
+    for part in obj_name.split("."):
+        obj = getattr(obj, part)
+    return obj
+
+
+def get_obj_by_name(name: str) -> Any:
+    """Finds the python object with the given name."""
+    module, obj_name = get_module_from_obj_name(name)
+    return get_obj_from_module(module, obj_name)
+
+
+def call_func_by_name(*args, func_name: str = None, **kwargs) -> Any:
+    """Finds the python object with the given name and calls it as a function."""
+    assert func_name is not None
+    func_obj = get_obj_by_name(func_name)
+    assert callable(func_obj)
+    return func_obj(*args, **kwargs)
+
+
+def construct_class_by_name(*args, class_name: str = None, **kwargs) -> Any:
+    """Finds the python class with the given name and constructs it with the given arguments."""
+    return call_func_by_name(*args, func_name=class_name, **kwargs)
+
+
+def get_module_dir_by_obj_name(obj_name: str) -> str:
+    """Get the directory path of the module containing the given object name."""
+    module, _ = get_module_from_obj_name(obj_name)
+    return os.path.dirname(inspect.getfile(module))
+
+
+def is_top_level_function(obj: Any) -> bool:
+    """Determine whether the given object is a top-level function, i.e., defined at module scope using 'def'."""
+    return callable(obj) and obj.__name__ in sys.modules[obj.__module__].__dict__
+
+
+def get_top_level_function_name(obj: Any) -> str:
+    """Return the fully-qualified name of a top-level function."""
+    assert is_top_level_function(obj)
+    module = obj.__module__
+    if module == '__main__':
+        module = os.path.splitext(os.path.basename(sys.modules[module].__file__))[0]
+    return module + "." + obj.__name__
+
+
+# File system helpers
+# ------------------------------------------------------------------------------------------
+
+def list_dir_recursively_with_ignore(dir_path: str, ignores: List[str] = None, add_base_to_relative: bool = False) -> List[Tuple[str, str]]:
+    """List all files recursively in a given directory while ignoring given file and directory names.
+    Returns list of tuples containing both absolute and relative paths."""
+    assert os.path.isdir(dir_path)
+    base_name = os.path.basename(os.path.normpath(dir_path))
+
+    if ignores is None:
+        ignores = []
+
+    result = []
+
+    for root, dirs, files in os.walk(dir_path, topdown=True):
+        for ignore_ in ignores:
+            dirs_to_remove = [d for d in dirs if fnmatch.fnmatch(d, ignore_)]
+
+            # dirs need to be edited in-place
+            for d in dirs_to_remove:
+                dirs.remove(d)
+
+            files = [f for f in files if not fnmatch.fnmatch(f, ignore_)]
+
+        absolute_paths = [os.path.join(root, f) for f in files]
+        relative_paths = [os.path.relpath(p, dir_path) for p in absolute_paths]
+
+        if add_base_to_relative:
+            relative_paths = [os.path.join(base_name, p) for p in relative_paths]
+
+        assert len(absolute_paths) == len(relative_paths)
+        result += zip(absolute_paths, relative_paths)
+
+    return result
+
+
+def copy_files_and_create_dirs(files: List[Tuple[str, str]]) -> None:
+    """Takes in a list of tuples of (src, dst) paths and copies files.
+    Will create all necessary directories."""
+    for file in files:
+        target_dir_name = os.path.dirname(file[1])
+
+        # will create all intermediate-level directories
+        if not os.path.exists(target_dir_name):
+            os.makedirs(target_dir_name)
+
+        shutil.copyfile(file[0], file[1])
+
+
+# URL helpers
+# ------------------------------------------------------------------------------------------
+
+def is_url(obj: Any, allow_file_urls: bool = False) -> bool:
+    """Determine whether the given object is a valid URL string."""
+    if not isinstance(obj, str) or not "://" in obj:
+        return False
+    if allow_file_urls and obj.startswith('file://'):
+        return True
+    try:
+        res = requests.compat.urlparse(obj)
+        if not res.scheme or not res.netloc or not "." in res.netloc:
+            return False
+        res = requests.compat.urlparse(requests.compat.urljoin(obj, "/"))
+        if not res.scheme or not res.netloc or not "." in res.netloc:
+            return False
+    except:
+        return False
+    return True
+
+
+def open_url(url: str, cache_dir: str = None, num_attempts: int = 10, verbose: bool = True, return_filename: bool = False, cache: bool = True) -> Any:
+    """Download the given URL and return a binary-mode file object to access the data."""
+    assert num_attempts >= 1
+    assert not (return_filename and (not cache))
+
+    # Doesn't look like an URL scheme so interpret it as a local filename.
+    if not re.match('^[a-z]+://', url):
+        return url if return_filename else open(url, "rb")
+
+    # Handle file URLs.  This code handles unusual file:// patterns that
+    # arise on Windows:
+    #
+    # file:///c:/foo.txt
+    #
+    # which would translate to a local '/c:/foo.txt' filename that's
+    # invalid.  Drop the forward slash for such pathnames.
+    #
+    # If you touch this code path, you should test it on both Linux and
+    # Windows.
+    #
+    # Some internet resources suggest using urllib.request.url2pathname() but
+    # but that converts forward slashes to backslashes and this causes
+    # its own set of problems.
+    if url.startswith('file://'):
+        filename = urllib.parse.urlparse(url).path
+        if re.match(r'^/[a-zA-Z]:', filename):
+            filename = filename[1:]
+        return filename if return_filename else open(filename, "rb")
+
+    assert is_url(url)
+
+    # Lookup from cache.
+    if cache_dir is None:
+        cache_dir = make_cache_dir_path('downloads')
+
+    url_md5 = hashlib.md5(url.encode("utf-8")).hexdigest()
+    if cache:
+        cache_files = glob.glob(os.path.join(cache_dir, url_md5 + "_*"))
+        if len(cache_files) == 1:
+            filename = cache_files[0]
+            return filename if return_filename else open(filename, "rb")
+
+    # Download.
+    url_name = None
+    url_data = None
+    with requests.Session() as session:
+        if verbose:
+            print("Downloading %s ..." % url, end="", flush=True)
+        for attempts_left in reversed(range(num_attempts)):
+            try:
+                with session.get(url) as res:
+                    res.raise_for_status()
+                    if len(res.content) == 0:
+                        raise IOError("No data received")
+
+                    if len(res.content) < 8192:
+                        content_str = res.content.decode("utf-8")
+                        if "download_warning" in res.headers.get("Set-Cookie", ""):
+                            links = [html.unescape(link) for link in content_str.split('"') if "export=download" in link]
+                            if len(links) == 1:
+                                url = requests.compat.urljoin(url, links[0])
+                                raise IOError("Google Drive virus checker nag")
+                        if "Google Drive - Quota exceeded" in content_str:
+                            raise IOError("Google Drive download quota exceeded -- please try again later")
+
+                    match = re.search(r'filename="([^"]*)"', res.headers.get("Content-Disposition", ""))
+                    url_name = match[1] if match else url
+                    url_data = res.content
+                    if verbose:
+                        print(" done")
+                    break
+            except KeyboardInterrupt:
+                raise
+            except:
+                if not attempts_left:
+                    if verbose:
+                        print(" failed")
+                    raise
+                if verbose:
+                    print(".", end="", flush=True)
+
+    # Save to cache.
+    if cache:
+        safe_name = re.sub(r"[^0-9a-zA-Z-._]", "_", url_name)
+        cache_file = os.path.join(cache_dir, url_md5 + "_" + safe_name)
+        temp_file = os.path.join(cache_dir, "tmp_" + uuid.uuid4().hex + "_" + url_md5 + "_" + safe_name)
+        os.makedirs(cache_dir, exist_ok=True)
+        with open(temp_file, "wb") as f:
+            f.write(url_data)
+        os.replace(temp_file, cache_file) # atomic
+        if return_filename:
+            return cache_file
+
+    # Return data as file object.
+    assert not return_filename
+    return io.BytesIO(url_data)

pix2pix3D-main/pix2pix3D-main/environment.yml

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+name: pix2pix3d
+channels:
+  - pytorch
+  - nvidia
+dependencies:
+  - python >= 3.8
+  - pip
+  - numpy>=1.20
+  - click>=8.0
+  - pillow=8.3.1
+  - scipy=1.7.1
+  - pytorch=1.11.0
+  - cudatoolkit=11.1
+  - requests=2.26.0
+  - tqdm=4.62.2
+  - ninja=1.10.2
+  - matplotlib=3.4.2
+  - imageio=2.9.0
+  - pip:
+    - imgui==1.3.0
+    - glfw==2.2.0
+    - pyopengl==3.1.5
+    - imageio-ffmpeg==0.4.3
+    - pyspng
+    - psutil
+    - mrcfile
+    - tensorboard
+    - einops
+    - opencv-python

pix2pix3D-main/pix2pix3D-main/legacy.py

@@ -0,0 +1,325 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""Converting legacy network pickle into the new format."""
+
+import click
+import pickle
+import re
+import copy
+import numpy as np
+import torch
+import dnnlib
+from torch_utils import misc
+
+#----------------------------------------------------------------------------
+
+def load_network_pkl(f, force_fp16=False):
+    data = _LegacyUnpickler(f).load()
+
+    # Legacy TensorFlow pickle => convert.
+    if isinstance(data, tuple) and len(data) == 3 and all(isinstance(net, _TFNetworkStub) for net in data):
+        tf_G, tf_D, tf_Gs = data
+        G = convert_tf_generator(tf_G)
+        D = convert_tf_discriminator(tf_D)
+        G_ema = convert_tf_generator(tf_Gs)
+        data = dict(G=G, D=D, G_ema=G_ema)
+
+    # Add missing fields.
+    if 'training_set_kwargs' not in data:
+        data['training_set_kwargs'] = None
+    if 'augment_pipe' not in data:
+        data['augment_pipe'] = None
+
+    # Validate contents.
+    assert isinstance(data['G'], torch.nn.Module)
+    assert isinstance(data['D'], torch.nn.Module)
+    assert isinstance(data['G_ema'], torch.nn.Module)
+    assert isinstance(data['training_set_kwargs'], (dict, type(None)))
+    assert isinstance(data['augment_pipe'], (torch.nn.Module, type(None)))
+
+    # Force FP16.
+    if force_fp16:
+        for key in ['G', 'D', 'G_ema']:
+            old = data[key]
+            kwargs = copy.deepcopy(old.init_kwargs)
+            fp16_kwargs = kwargs.get('synthesis_kwargs', kwargs)
+            fp16_kwargs.num_fp16_res = 4
+            fp16_kwargs.conv_clamp = 256
+            if kwargs != old.init_kwargs:
+                new = type(old)(**kwargs).eval().requires_grad_(False)
+                misc.copy_params_and_buffers(old, new, require_all=True)
+                data[key] = new
+    return data
+
+#----------------------------------------------------------------------------
+
+class _TFNetworkStub(dnnlib.EasyDict):
+    pass
+
+class _LegacyUnpickler(pickle.Unpickler):
+    def find_class(self, module, name):
+        if module == 'dnnlib.tflib.network' and name == 'Network':
+            return _TFNetworkStub
+        return super().find_class(module, name)
+
+#----------------------------------------------------------------------------
+
+def _collect_tf_params(tf_net):
+    # pylint: disable=protected-access
+    tf_params = dict()
+    def recurse(prefix, tf_net):
+        for name, value in tf_net.variables:
+            tf_params[prefix + name] = value
+        for name, comp in tf_net.components.items():
+            recurse(prefix + name + '/', comp)
+    recurse('', tf_net)
+    return tf_params
+
+#----------------------------------------------------------------------------
+
+def _populate_module_params(module, *patterns):
+    for name, tensor in misc.named_params_and_buffers(module):
+        found = False
+        value = None
+        for pattern, value_fn in zip(patterns[0::2], patterns[1::2]):
+            match = re.fullmatch(pattern, name)
+            if match:
+                found = True
+                if value_fn is not None:
+                    value = value_fn(*match.groups())
+                break
+        try:
+            assert found
+            if value is not None:
+                tensor.copy_(torch.from_numpy(np.array(value)))
+        except:
+            print(name, list(tensor.shape))
+            raise
+
+#----------------------------------------------------------------------------
+
+def convert_tf_generator(tf_G):
+    if tf_G.version < 4:
+        raise ValueError('TensorFlow pickle version too low')
+
+    # Collect kwargs.
+    tf_kwargs = tf_G.static_kwargs
+    known_kwargs = set()
+    def kwarg(tf_name, default=None, none=None):
+        known_kwargs.add(tf_name)
+        val = tf_kwargs.get(tf_name, default)
+        return val if val is not None else none
+
+    # Convert kwargs.
+    from training import networks_stylegan2
+    network_class = networks_stylegan2.Generator
+    kwargs = dnnlib.EasyDict(
+        z_dim               = kwarg('latent_size',          512),
+        c_dim               = kwarg('label_size',           0),
+        w_dim               = kwarg('dlatent_size',         512),
+        img_resolution      = kwarg('resolution',           1024),
+        img_channels        = kwarg('num_channels',         3),
+        channel_base        = kwarg('fmap_base',            16384) * 2,
+        channel_max         = kwarg('fmap_max',             512),
+        num_fp16_res        = kwarg('num_fp16_res',         0),
+        conv_clamp          = kwarg('conv_clamp',           None),
+        architecture        = kwarg('architecture',         'skip'),
+        resample_filter     = kwarg('resample_kernel',      [1,3,3,1]),
+        use_noise           = kwarg('use_noise',            True),
+        activation          = kwarg('nonlinearity',         'lrelu'),
+        mapping_kwargs      = dnnlib.EasyDict(
+            num_layers      = kwarg('mapping_layers',       8),
+            embed_features  = kwarg('label_fmaps',          None),
+            layer_features  = kwarg('mapping_fmaps',        None),
+            activation      = kwarg('mapping_nonlinearity', 'lrelu'),
+            lr_multiplier   = kwarg('mapping_lrmul',        0.01),
+            w_avg_beta      = kwarg('w_avg_beta',           0.995,  none=1),
+        ),
+    )
+
+    # Check for unknown kwargs.
+    kwarg('truncation_psi')
+    kwarg('truncation_cutoff')
+    kwarg('style_mixing_prob')
+    kwarg('structure')
+    kwarg('conditioning')
+    kwarg('fused_modconv')
+    unknown_kwargs = list(set(tf_kwargs.keys()) - known_kwargs)
+    if len(unknown_kwargs) > 0:
+        raise ValueError('Unknown TensorFlow kwarg', unknown_kwargs[0])
+
+    # Collect params.
+    tf_params = _collect_tf_params(tf_G)
+    for name, value in list(tf_params.items()):
+        match = re.fullmatch(r'ToRGB_lod(\d+)/(.*)', name)
+        if match:
+            r = kwargs.img_resolution // (2 ** int(match.group(1)))
+            tf_params[f'{r}x{r}/ToRGB/{match.group(2)}'] = value
+            kwargs.synthesis.kwargs.architecture = 'orig'
+    #for name, value in tf_params.items(): print(f'{name:<50s}{list(value.shape)}')
+
+    # Convert params.
+    G = network_class(**kwargs).eval().requires_grad_(False)
+    # pylint: disable=unnecessary-lambda
+    # pylint: disable=f-string-without-interpolation
+    _populate_module_params(G,
+        r'mapping\.w_avg',                                  lambda:     tf_params[f'dlatent_avg'],
+        r'mapping\.embed\.weight',                          lambda:     tf_params[f'mapping/LabelEmbed/weight'].transpose(),
+        r'mapping\.embed\.bias',                            lambda:     tf_params[f'mapping/LabelEmbed/bias'],
+        r'mapping\.fc(\d+)\.weight',                        lambda i:   tf_params[f'mapping/Dense{i}/weight'].transpose(),
+        r'mapping\.fc(\d+)\.bias',                          lambda i:   tf_params[f'mapping/Dense{i}/bias'],
+        r'synthesis\.b4\.const',                            lambda:     tf_params[f'synthesis/4x4/Const/const'][0],
+        r'synthesis\.b4\.conv1\.weight',                    lambda:     tf_params[f'synthesis/4x4/Conv/weight'].transpose(3, 2, 0, 1),
+        r'synthesis\.b4\.conv1\.bias',                      lambda:     tf_params[f'synthesis/4x4/Conv/bias'],
+        r'synthesis\.b4\.conv1\.noise_const',               lambda:     tf_params[f'synthesis/noise0'][0, 0],
+        r'synthesis\.b4\.conv1\.noise_strength',            lambda:     tf_params[f'synthesis/4x4/Conv/noise_strength'],
+        r'synthesis\.b4\.conv1\.affine\.weight',            lambda:     tf_params[f'synthesis/4x4/Conv/mod_weight'].transpose(),
+        r'synthesis\.b4\.conv1\.affine\.bias',              lambda:     tf_params[f'synthesis/4x4/Conv/mod_bias'] + 1,
+        r'synthesis\.b(\d+)\.conv0\.weight',                lambda r:   tf_params[f'synthesis/{r}x{r}/Conv0_up/weight'][::-1, ::-1].transpose(3, 2, 0, 1),
+        r'synthesis\.b(\d+)\.conv0\.bias',                  lambda r:   tf_params[f'synthesis/{r}x{r}/Conv0_up/bias'],
+        r'synthesis\.b(\d+)\.conv0\.noise_const',           lambda r:   tf_params[f'synthesis/noise{int(np.log2(int(r)))*2-5}'][0, 0],
+        r'synthesis\.b(\d+)\.conv0\.noise_strength',        lambda r:   tf_params[f'synthesis/{r}x{r}/Conv0_up/noise_strength'],
+        r'synthesis\.b(\d+)\.conv0\.affine\.weight',        lambda r:   tf_params[f'synthesis/{r}x{r}/Conv0_up/mod_weight'].transpose(),
+        r'synthesis\.b(\d+)\.conv0\.affine\.bias',          lambda r:   tf_params[f'synthesis/{r}x{r}/Conv0_up/mod_bias'] + 1,
+        r'synthesis\.b(\d+)\.conv1\.weight',                lambda r:   tf_params[f'synthesis/{r}x{r}/Conv1/weight'].transpose(3, 2, 0, 1),
+        r'synthesis\.b(\d+)\.conv1\.bias',                  lambda r:   tf_params[f'synthesis/{r}x{r}/Conv1/bias'],
+        r'synthesis\.b(\d+)\.conv1\.noise_const',           lambda r:   tf_params[f'synthesis/noise{int(np.log2(int(r)))*2-4}'][0, 0],
+        r'synthesis\.b(\d+)\.conv1\.noise_strength',        lambda r:   tf_params[f'synthesis/{r}x{r}/Conv1/noise_strength'],
+        r'synthesis\.b(\d+)\.conv1\.affine\.weight',        lambda r:   tf_params[f'synthesis/{r}x{r}/Conv1/mod_weight'].transpose(),
+        r'synthesis\.b(\d+)\.conv1\.affine\.bias',          lambda r:   tf_params[f'synthesis/{r}x{r}/Conv1/mod_bias'] + 1,
+        r'synthesis\.b(\d+)\.torgb\.weight',                lambda r:   tf_params[f'synthesis/{r}x{r}/ToRGB/weight'].transpose(3, 2, 0, 1),
+        r'synthesis\.b(\d+)\.torgb\.bias',                  lambda r:   tf_params[f'synthesis/{r}x{r}/ToRGB/bias'],
+        r'synthesis\.b(\d+)\.torgb\.affine\.weight',        lambda r:   tf_params[f'synthesis/{r}x{r}/ToRGB/mod_weight'].transpose(),
+        r'synthesis\.b(\d+)\.torgb\.affine\.bias',          lambda r:   tf_params[f'synthesis/{r}x{r}/ToRGB/mod_bias'] + 1,
+        r'synthesis\.b(\d+)\.skip\.weight',                 lambda r:   tf_params[f'synthesis/{r}x{r}/Skip/weight'][::-1, ::-1].transpose(3, 2, 0, 1),
+        r'.*\.resample_filter',                             None,
+        r'.*\.act_filter',                                  None,
+    )
+    return G
+
+#----------------------------------------------------------------------------
+
+def convert_tf_discriminator(tf_D):
+    if tf_D.version < 4:
+        raise ValueError('TensorFlow pickle version too low')
+
+    # Collect kwargs.
+    tf_kwargs = tf_D.static_kwargs
+    known_kwargs = set()
+    def kwarg(tf_name, default=None):
+        known_kwargs.add(tf_name)
+        return tf_kwargs.get(tf_name, default)
+
+    # Convert kwargs.
+    kwargs = dnnlib.EasyDict(
+        c_dim                   = kwarg('label_size',           0),
+        img_resolution          = kwarg('resolution',           1024),
+        img_channels            = kwarg('num_channels',         3),
+        architecture            = kwarg('architecture',         'resnet'),
+        channel_base            = kwarg('fmap_base',            16384) * 2,
+        channel_max             = kwarg('fmap_max',             512),
+        num_fp16_res            = kwarg('num_fp16_res',         0),
+        conv_clamp              = kwarg('conv_clamp',           None),
+        cmap_dim                = kwarg('mapping_fmaps',        None),
+        block_kwargs = dnnlib.EasyDict(
+            activation          = kwarg('nonlinearity',         'lrelu'),
+            resample_filter     = kwarg('resample_kernel',      [1,3,3,1]),
+            freeze_layers       = kwarg('freeze_layers',        0),
+        ),
+        mapping_kwargs = dnnlib.EasyDict(
+            num_layers          = kwarg('mapping_layers',       0),
+            embed_features      = kwarg('mapping_fmaps',        None),
+            layer_features      = kwarg('mapping_fmaps',        None),
+            activation          = kwarg('nonlinearity',         'lrelu'),
+            lr_multiplier       = kwarg('mapping_lrmul',        0.1),
+        ),
+        epilogue_kwargs = dnnlib.EasyDict(
+            mbstd_group_size    = kwarg('mbstd_group_size',     None),
+            mbstd_num_channels  = kwarg('mbstd_num_features',   1),
+            activation          = kwarg('nonlinearity',         'lrelu'),
+        ),
+    )
+
+    # Check for unknown kwargs.
+    kwarg('structure')
+    kwarg('conditioning')
+    unknown_kwargs = list(set(tf_kwargs.keys()) - known_kwargs)
+    if len(unknown_kwargs) > 0:
+        raise ValueError('Unknown TensorFlow kwarg', unknown_kwargs[0])
+
+    # Collect params.
+    tf_params = _collect_tf_params(tf_D)
+    for name, value in list(tf_params.items()):
+        match = re.fullmatch(r'FromRGB_lod(\d+)/(.*)', name)
+        if match:
+            r = kwargs.img_resolution // (2 ** int(match.group(1)))
+            tf_params[f'{r}x{r}/FromRGB/{match.group(2)}'] = value
+            kwargs.architecture = 'orig'
+    #for name, value in tf_params.items(): print(f'{name:<50s}{list(value.shape)}')
+
+    # Convert params.
+    from training import networks_stylegan2
+    D = networks_stylegan2.Discriminator(**kwargs).eval().requires_grad_(False)
+    # pylint: disable=unnecessary-lambda
+    # pylint: disable=f-string-without-interpolation
+    _populate_module_params(D,
+        r'b(\d+)\.fromrgb\.weight',     lambda r:       tf_params[f'{r}x{r}/FromRGB/weight'].transpose(3, 2, 0, 1),
+        r'b(\d+)\.fromrgb\.bias',       lambda r:       tf_params[f'{r}x{r}/FromRGB/bias'],
+        r'b(\d+)\.conv(\d+)\.weight',   lambda r, i:    tf_params[f'{r}x{r}/Conv{i}{["","_down"][int(i)]}/weight'].transpose(3, 2, 0, 1),
+        r'b(\d+)\.conv(\d+)\.bias',     lambda r, i:    tf_params[f'{r}x{r}/Conv{i}{["","_down"][int(i)]}/bias'],
+        r'b(\d+)\.skip\.weight',        lambda r:       tf_params[f'{r}x{r}/Skip/weight'].transpose(3, 2, 0, 1),
+        r'mapping\.embed\.weight',      lambda:         tf_params[f'LabelEmbed/weight'].transpose(),
+        r'mapping\.embed\.bias',        lambda:         tf_params[f'LabelEmbed/bias'],
+        r'mapping\.fc(\d+)\.weight',    lambda i:       tf_params[f'Mapping{i}/weight'].transpose(),
+        r'mapping\.fc(\d+)\.bias',      lambda i:       tf_params[f'Mapping{i}/bias'],
+        r'b4\.conv\.weight',            lambda:         tf_params[f'4x4/Conv/weight'].transpose(3, 2, 0, 1),
+        r'b4\.conv\.bias',              lambda:         tf_params[f'4x4/Conv/bias'],
+        r'b4\.fc\.weight',              lambda:         tf_params[f'4x4/Dense0/weight'].transpose(),
+        r'b4\.fc\.bias',                lambda:         tf_params[f'4x4/Dense0/bias'],
+        r'b4\.out\.weight',             lambda:         tf_params[f'Output/weight'].transpose(),
+        r'b4\.out\.bias',               lambda:         tf_params[f'Output/bias'],
+        r'.*\.resample_filter',         None,
+    )
+    return D
+
+#----------------------------------------------------------------------------
+
+@click.command()
+@click.option('--source', help='Input pickle', required=True, metavar='PATH')
+@click.option('--dest', help='Output pickle', required=True, metavar='PATH')
+@click.option('--force-fp16', help='Force the networks to use FP16', type=bool, default=False, metavar='BOOL', show_default=True)
+def convert_network_pickle(source, dest, force_fp16):
+    """Convert legacy network pickle into the native PyTorch format.
+
+    The tool is able to load the main network configurations exported using the TensorFlow version of StyleGAN2 or StyleGAN2-ADA.
+    It does not support e.g. StyleGAN2-ADA comparison methods, StyleGAN2 configs A-D, or StyleGAN1 networks.
+
+    Example:
+
+    \b
+    python legacy.py \\
+        --source=https://nvlabs-fi-cdn.nvidia.com/stylegan2/networks/stylegan2-cat-config-f.pkl \\
+        --dest=stylegan2-cat-config-f.pkl
+    """
+    print(f'Loading "{source}"...')
+    with dnnlib.util.open_url(source) as f:
+        data = load_network_pkl(f, force_fp16=force_fp16)
+    print(f'Saving "{dest}"...')
+    with open(dest, 'wb') as f:
+        pickle.dump(data, f)
+    print('Done.')
+
+#----------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    convert_network_pickle() # pylint: disable=no-value-for-parameter
+
+#----------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/metrics/__init__.py

@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+# empty

pix2pix3D-main/pix2pix3D-main/metrics/equivariance.py

@@ -0,0 +1,269 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""Equivariance metrics (EQ-T, EQ-T_frac, and EQ-R) from the paper
+"Alias-Free Generative Adversarial Networks"."""
+
+import copy
+import numpy as np
+import torch
+import torch.fft
+from torch_utils.ops import upfirdn2d
+from . import metric_utils
+
+#----------------------------------------------------------------------------
+# Utilities.
+
+def sinc(x):
+    y = (x * np.pi).abs()
+    z = torch.sin(y) / y.clamp(1e-30, float('inf'))
+    return torch.where(y < 1e-30, torch.ones_like(x), z)
+
+def lanczos_window(x, a):
+    x = x.abs() / a
+    return torch.where(x < 1, sinc(x), torch.zeros_like(x))
+
+def rotation_matrix(angle):
+    angle = torch.as_tensor(angle).to(torch.float32)
+    mat = torch.eye(3, device=angle.device)
+    mat[0, 0] = angle.cos()
+    mat[0, 1] = angle.sin()
+    mat[1, 0] = -angle.sin()
+    mat[1, 1] = angle.cos()
+    return mat
+
+#----------------------------------------------------------------------------
+# Apply integer translation to a batch of 2D images. Corresponds to the
+# operator T_x in Appendix E.1.
+
+def apply_integer_translation(x, tx, ty):
+    _N, _C, H, W = x.shape
+    tx = torch.as_tensor(tx * W).to(dtype=torch.float32, device=x.device)
+    ty = torch.as_tensor(ty * H).to(dtype=torch.float32, device=x.device)
+    ix = tx.round().to(torch.int64)
+    iy = ty.round().to(torch.int64)
+
+    z = torch.zeros_like(x)
+    m = torch.zeros_like(x)
+    if abs(ix) < W and abs(iy) < H:
+        y = x[:, :, max(-iy,0) : H+min(-iy,0), max(-ix,0) : W+min(-ix,0)]
+        z[:, :, max(iy,0) : H+min(iy,0), max(ix,0) : W+min(ix,0)] = y
+        m[:, :, max(iy,0) : H+min(iy,0), max(ix,0) : W+min(ix,0)] = 1
+    return z, m
+
+#----------------------------------------------------------------------------
+# Apply integer translation to a batch of 2D images. Corresponds to the
+# operator T_x in Appendix E.2.
+
+def apply_fractional_translation(x, tx, ty, a=3):
+    _N, _C, H, W = x.shape
+    tx = torch.as_tensor(tx * W).to(dtype=torch.float32, device=x.device)
+    ty = torch.as_tensor(ty * H).to(dtype=torch.float32, device=x.device)
+    ix = tx.floor().to(torch.int64)
+    iy = ty.floor().to(torch.int64)
+    fx = tx - ix
+    fy = ty - iy
+    b = a - 1
+
+    z = torch.zeros_like(x)
+    zx0 = max(ix - b, 0)
+    zy0 = max(iy - b, 0)
+    zx1 = min(ix + a, 0) + W
+    zy1 = min(iy + a, 0) + H
+    if zx0 < zx1 and zy0 < zy1:
+        taps = torch.arange(a * 2, device=x.device) - b
+        filter_x = (sinc(taps - fx) * sinc((taps - fx) / a)).unsqueeze(0)
+        filter_y = (sinc(taps - fy) * sinc((taps - fy) / a)).unsqueeze(1)
+        y = x
+        y = upfirdn2d.filter2d(y, filter_x / filter_x.sum(), padding=[b,a,0,0])
+        y = upfirdn2d.filter2d(y, filter_y / filter_y.sum(), padding=[0,0,b,a])
+        y = y[:, :, max(b-iy,0) : H+b+a+min(-iy-a,0), max(b-ix,0) : W+b+a+min(-ix-a,0)]
+        z[:, :, zy0:zy1, zx0:zx1] = y
+
+    m = torch.zeros_like(x)
+    mx0 = max(ix + a, 0)
+    my0 = max(iy + a, 0)
+    mx1 = min(ix - b, 0) + W
+    my1 = min(iy - b, 0) + H
+    if mx0 < mx1 and my0 < my1:
+        m[:, :, my0:my1, mx0:mx1] = 1
+    return z, m
+
+#----------------------------------------------------------------------------
+# Construct an oriented low-pass filter that applies the appropriate
+# bandlimit with respect to the input and output of the given affine 2D
+# image transformation.
+
+def construct_affine_bandlimit_filter(mat, a=3, amax=16, aflt=64, up=4, cutoff_in=1, cutoff_out=1):
+    assert a <= amax < aflt
+    mat = torch.as_tensor(mat).to(torch.float32)
+
+    # Construct 2D filter taps in input & output coordinate spaces.
+    taps = ((torch.arange(aflt * up * 2 - 1, device=mat.device) + 1) / up - aflt).roll(1 - aflt * up)
+    yi, xi = torch.meshgrid(taps, taps)
+    xo, yo = (torch.stack([xi, yi], dim=2) @ mat[:2, :2].t()).unbind(2)
+
+    # Convolution of two oriented 2D sinc filters.
+    fi = sinc(xi * cutoff_in) * sinc(yi * cutoff_in)
+    fo = sinc(xo * cutoff_out) * sinc(yo * cutoff_out)
+    f = torch.fft.ifftn(torch.fft.fftn(fi) * torch.fft.fftn(fo)).real
+
+    # Convolution of two oriented 2D Lanczos windows.
+    wi = lanczos_window(xi, a) * lanczos_window(yi, a)
+    wo = lanczos_window(xo, a) * lanczos_window(yo, a)
+    w = torch.fft.ifftn(torch.fft.fftn(wi) * torch.fft.fftn(wo)).real
+
+    # Construct windowed FIR filter.
+    f = f * w
+
+    # Finalize.
+    c = (aflt - amax) * up
+    f = f.roll([aflt * up - 1] * 2, dims=[0,1])[c:-c, c:-c]
+    f = torch.nn.functional.pad(f, [0, 1, 0, 1]).reshape(amax * 2, up, amax * 2, up)
+    f = f / f.sum([0,2], keepdim=True) / (up ** 2)
+    f = f.reshape(amax * 2 * up, amax * 2 * up)[:-1, :-1]
+    return f
+
+#----------------------------------------------------------------------------
+# Apply the given affine transformation to a batch of 2D images.
+
+def apply_affine_transformation(x, mat, up=4, **filter_kwargs):
+    _N, _C, H, W = x.shape
+    mat = torch.as_tensor(mat).to(dtype=torch.float32, device=x.device)
+
+    # Construct filter.
+    f = construct_affine_bandlimit_filter(mat, up=up, **filter_kwargs)
+    assert f.ndim == 2 and f.shape[0] == f.shape[1] and f.shape[0] % 2 == 1
+    p = f.shape[0] // 2
+
+    # Construct sampling grid.
+    theta = mat.inverse()
+    theta[:2, 2] *= 2
+    theta[0, 2] += 1 / up / W
+    theta[1, 2] += 1 / up / H
+    theta[0, :] *= W / (W + p / up * 2)
+    theta[1, :] *= H / (H + p / up * 2)
+    theta = theta[:2, :3].unsqueeze(0).repeat([x.shape[0], 1, 1])
+    g = torch.nn.functional.affine_grid(theta, x.shape, align_corners=False)
+
+    # Resample image.
+    y = upfirdn2d.upsample2d(x=x, f=f, up=up, padding=p)
+    z = torch.nn.functional.grid_sample(y, g, mode='bilinear', padding_mode='zeros', align_corners=False)
+
+    # Form mask.
+    m = torch.zeros_like(y)
+    c = p * 2 + 1
+    m[:, :, c:-c, c:-c] = 1
+    m = torch.nn.functional.grid_sample(m, g, mode='nearest', padding_mode='zeros', align_corners=False)
+    return z, m
+
+#----------------------------------------------------------------------------
+# Apply fractional rotation to a batch of 2D images. Corresponds to the
+# operator R_\alpha in Appendix E.3.
+
+def apply_fractional_rotation(x, angle, a=3, **filter_kwargs):
+    angle = torch.as_tensor(angle).to(dtype=torch.float32, device=x.device)
+    mat = rotation_matrix(angle)
+    return apply_affine_transformation(x, mat, a=a, amax=a*2, **filter_kwargs)
+
+#----------------------------------------------------------------------------
+# Modify the frequency content of a batch of 2D images as if they had undergo
+# fractional rotation -- but without actually rotating them. Corresponds to
+# the operator R^*_\alpha in Appendix E.3.
+
+def apply_fractional_pseudo_rotation(x, angle, a=3, **filter_kwargs):
+    angle = torch.as_tensor(angle).to(dtype=torch.float32, device=x.device)
+    mat = rotation_matrix(-angle)
+    f = construct_affine_bandlimit_filter(mat, a=a, amax=a*2, up=1, **filter_kwargs)
+    y = upfirdn2d.filter2d(x=x, f=f)
+    m = torch.zeros_like(y)
+    c = f.shape[0] // 2
+    m[:, :, c:-c, c:-c] = 1
+    return y, m
+
+#----------------------------------------------------------------------------
+# Compute the selected equivariance metrics for the given generator.
+
+def compute_equivariance_metrics(opts, num_samples, batch_size, translate_max=0.125, rotate_max=1, compute_eqt_int=False, compute_eqt_frac=False, compute_eqr=False):
+    assert compute_eqt_int or compute_eqt_frac or compute_eqr
+
+    # Setup generator and labels.
+    G = copy.deepcopy(opts.G).eval().requires_grad_(False).to(opts.device)
+    I = torch.eye(3, device=opts.device)
+    M = getattr(getattr(getattr(G, 'synthesis', None), 'input', None), 'transform', None)
+    if M is None:
+        raise ValueError('Cannot compute equivariance metrics; the given generator does not support user-specified image transformations')
+    c_iter = metric_utils.iterate_random_labels(opts=opts, batch_size=batch_size)
+
+    # Sampling loop.
+    sums = None
+    progress = opts.progress.sub(tag='eq sampling', num_items=num_samples)
+    for batch_start in range(0, num_samples, batch_size * opts.num_gpus):
+        progress.update(batch_start)
+        s = []
+
+        # Randomize noise buffers, if any.
+        for name, buf in G.named_buffers():
+            if name.endswith('.noise_const'):
+                buf.copy_(torch.randn_like(buf))
+
+        # Run mapping network.
+        z = torch.randn([batch_size, G.z_dim], device=opts.device)
+        c = next(c_iter)
+        ws = G.mapping(z=z, c=c)
+
+        # Generate reference image.
+        M[:] = I
+        orig = G.synthesis(ws=ws, noise_mode='const', **opts.G_kwargs)
+
+        # Integer translation (EQ-T).
+        if compute_eqt_int:
+            t = (torch.rand(2, device=opts.device) * 2 - 1) * translate_max
+            t = (t * G.img_resolution).round() / G.img_resolution
+            M[:] = I
+            M[:2, 2] = -t
+            img = G.synthesis(ws=ws, noise_mode='const', **opts.G_kwargs)
+            ref, mask = apply_integer_translation(orig, t[0], t[1])
+            s += [(ref - img).square() * mask, mask]
+
+        # Fractional translation (EQ-T_frac).
+        if compute_eqt_frac:
+            t = (torch.rand(2, device=opts.device) * 2 - 1) * translate_max
+            M[:] = I
+            M[:2, 2] = -t
+            img = G.synthesis(ws=ws, noise_mode='const', **opts.G_kwargs)
+            ref, mask = apply_fractional_translation(orig, t[0], t[1])
+            s += [(ref - img).square() * mask, mask]
+
+        # Rotation (EQ-R).
+        if compute_eqr:
+            angle = (torch.rand([], device=opts.device) * 2 - 1) * (rotate_max * np.pi)
+            M[:] = rotation_matrix(-angle)
+            img = G.synthesis(ws=ws, noise_mode='const', **opts.G_kwargs)
+            ref, ref_mask = apply_fractional_rotation(orig, angle)
+            pseudo, pseudo_mask = apply_fractional_pseudo_rotation(img, angle)
+            mask = ref_mask * pseudo_mask
+            s += [(ref - pseudo).square() * mask, mask]
+
+        # Accumulate results.
+        s = torch.stack([x.to(torch.float64).sum() for x in s])
+        sums = sums + s if sums is not None else s
+    progress.update(num_samples)
+
+    # Compute PSNRs.
+    if opts.num_gpus > 1:
+        torch.distributed.all_reduce(sums)
+    sums = sums.cpu()
+    mses = sums[0::2] / sums[1::2]
+    psnrs = np.log10(2) * 20 - mses.log10() * 10
+    psnrs = tuple(psnrs.numpy())
+    return psnrs[0] if len(psnrs) == 1 else psnrs
+
+#----------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/metrics/frechet_inception_distance.py

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""Frechet Inception Distance (FID) from the paper
+"GANs trained by a two time-scale update rule converge to a local Nash
+equilibrium". Matches the original implementation by Heusel et al. at
+https://github.com/bioinf-jku/TTUR/blob/master/fid.py"""
+
+import numpy as np
+import scipy.linalg
+from . import metric_utils
+
+#----------------------------------------------------------------------------
+
+def compute_fid(opts, max_real, num_gen):
+    # Direct TorchScript translation of http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz
+    detector_url = 'https://api.ngc.nvidia.com/v2/models/nvidia/research/stylegan3/versions/1/files/metrics/inception-2015-12-05.pkl'
+    detector_kwargs = dict(return_features=True) # Return raw features before the softmax layer.
+
+    mu_real, sigma_real = metric_utils.compute_feature_stats_for_dataset(
+        opts=opts, detector_url=detector_url, detector_kwargs=detector_kwargs,
+        rel_lo=0, rel_hi=0, capture_mean_cov=True, max_items=max_real).get_mean_cov()
+
+    mu_gen, sigma_gen = metric_utils.compute_feature_stats_for_generator(
+        opts=opts, detector_url=detector_url, detector_kwargs=detector_kwargs,
+        rel_lo=0, rel_hi=1, capture_mean_cov=True, max_items=num_gen).get_mean_cov()
+
+    if opts.rank != 0:
+        return float('nan')
+
+    m = np.square(mu_gen - mu_real).sum()
+    s, _ = scipy.linalg.sqrtm(np.dot(sigma_gen, sigma_real), disp=False) # pylint: disable=no-member
+    fid = np.real(m + np.trace(sigma_gen + sigma_real - s * 2))
+    return float(fid)
+
+#----------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/metrics/inception_score.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""Inception Score (IS) from the paper "Improved techniques for training
+GANs". Matches the original implementation by Salimans et al. at
+https://github.com/openai/improved-gan/blob/master/inception_score/model.py"""
+
+import numpy as np
+from . import metric_utils
+
+#----------------------------------------------------------------------------
+
+def compute_is(opts, num_gen, num_splits):
+    # Direct TorchScript translation of http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz
+    detector_url = 'https://api.ngc.nvidia.com/v2/models/nvidia/research/stylegan3/versions/1/files/metrics/inception-2015-12-05.pkl'
+    detector_kwargs = dict(no_output_bias=True) # Match the original implementation by not applying bias in the softmax layer.
+
+    gen_probs = metric_utils.compute_feature_stats_for_generator(
+        opts=opts, detector_url=detector_url, detector_kwargs=detector_kwargs,
+        capture_all=True, max_items=num_gen).get_all()
+
+    if opts.rank != 0:
+        return float('nan'), float('nan')
+
+    scores = []
+    for i in range(num_splits):
+        part = gen_probs[i * num_gen // num_splits : (i + 1) * num_gen // num_splits]
+        kl = part * (np.log(part) - np.log(np.mean(part, axis=0, keepdims=True)))
+        kl = np.mean(np.sum(kl, axis=1))
+        scores.append(np.exp(kl))
+    return float(np.mean(scores)), float(np.std(scores))
+
+#----------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/metrics/kernel_inception_distance.py

@@ -0,0 +1,48 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""Kernel Inception Distance (KID) from the paper "Demystifying MMD
+GANs". Matches the original implementation by Binkowski et al. at
+https://github.com/mbinkowski/MMD-GAN/blob/master/gan/compute_scores.py"""
+
+import numpy as np
+from . import metric_utils
+
+#----------------------------------------------------------------------------
+
+def compute_kid(opts, max_real, num_gen, num_subsets, max_subset_size):
+    # Direct TorchScript translation of http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz
+    detector_url = 'https://api.ngc.nvidia.com/v2/models/nvidia/research/stylegan3/versions/1/files/metrics/inception-2015-12-05.pkl'
+    detector_kwargs = dict(return_features=True) # Return raw features before the softmax layer.
+
+    real_features = metric_utils.compute_feature_stats_for_dataset(
+        opts=opts, detector_url=detector_url, detector_kwargs=detector_kwargs,
+        rel_lo=0, rel_hi=0, capture_all=True, max_items=max_real).get_all()
+
+    gen_features = metric_utils.compute_feature_stats_for_generator(
+        opts=opts, detector_url=detector_url, detector_kwargs=detector_kwargs,
+        rel_lo=0, rel_hi=1, capture_all=True, max_items=num_gen).get_all()
+
+    if opts.rank != 0:
+        return float('nan')
+
+    n = real_features.shape[1]
+    m = min(min(real_features.shape[0], gen_features.shape[0]), max_subset_size)
+    t = 0
+    for _subset_idx in range(num_subsets):
+        x = gen_features[np.random.choice(gen_features.shape[0], m, replace=False)]
+        y = real_features[np.random.choice(real_features.shape[0], m, replace=False)]
+        a = (x @ x.T / n + 1) ** 3 + (y @ y.T / n + 1) ** 3
+        b = (x @ y.T / n + 1) ** 3
+        t += (a.sum() - np.diag(a).sum()) / (m - 1) - b.sum() * 2 / m
+    kid = t / num_subsets / m
+    return float(kid)
+
+#----------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/metrics/metric_main.py

@@ -0,0 +1,155 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""Main API for computing and reporting quality metrics."""
+
+import os
+import time
+import json
+import torch
+import dnnlib
+
+from . import metric_utils
+from . import frechet_inception_distance
+from . import kernel_inception_distance
+from . import precision_recall
+from . import perceptual_path_length
+from . import inception_score
+from . import equivariance
+
+#----------------------------------------------------------------------------
+
+_metric_dict = dict() # name => fn
+
+def register_metric(fn):
+    assert callable(fn)
+    _metric_dict[fn.__name__] = fn
+    return fn
+
+def is_valid_metric(metric):
+    return metric in _metric_dict
+
+def list_valid_metrics():
+    return list(_metric_dict.keys())
+
+#----------------------------------------------------------------------------
+
+def calc_metric(metric, **kwargs): # See metric_utils.MetricOptions for the full list of arguments.
+    assert is_valid_metric(metric)
+    opts = metric_utils.MetricOptions(**kwargs)
+
+    # Calculate.
+    start_time = time.time()
+    results = _metric_dict[metric](opts)
+    total_time = time.time() - start_time
+
+    # Broadcast results.
+    for key, value in list(results.items()):
+        if opts.num_gpus > 1:
+            value = torch.as_tensor(value, dtype=torch.float64, device=opts.device)
+            torch.distributed.broadcast(tensor=value, src=0)
+            value = float(value.cpu())
+        results[key] = value
+
+    # Decorate with metadata.
+    return dnnlib.EasyDict(
+        results         = dnnlib.EasyDict(results),
+        metric          = metric,
+        total_time      = total_time,
+        total_time_str  = dnnlib.util.format_time(total_time),
+        num_gpus        = opts.num_gpus,
+    )
+
+#----------------------------------------------------------------------------
+
+def report_metric(result_dict, run_dir=None, snapshot_pkl=None):
+    metric = result_dict['metric']
+    assert is_valid_metric(metric)
+    if run_dir is not None and snapshot_pkl is not None:
+        snapshot_pkl = os.path.relpath(snapshot_pkl, run_dir)
+
+    jsonl_line = json.dumps(dict(result_dict, snapshot_pkl=snapshot_pkl, timestamp=time.time()))
+    print(jsonl_line)
+    if run_dir is not None and os.path.isdir(run_dir):
+        with open(os.path.join(run_dir, f'metric-{metric}.jsonl'), 'at') as f:
+            f.write(jsonl_line + '\n')
+
+#----------------------------------------------------------------------------
+# Recommended metrics.
+
+@register_metric
+def fid50k_full(opts):
+    opts.dataset_kwargs.update(max_size=None, xflip=False)
+    fid = frechet_inception_distance.compute_fid(opts, max_real=None, num_gen=50000)
+    return dict(fid50k_full=fid)
+
+@register_metric
+def kid50k_full(opts):
+    opts.dataset_kwargs.update(max_size=None, xflip=False)
+    kid = kernel_inception_distance.compute_kid(opts, max_real=1000000, num_gen=50000, num_subsets=100, max_subset_size=1000)
+    return dict(kid50k_full=kid)
+
+@register_metric
+def pr50k3_full(opts):
+    opts.dataset_kwargs.update(max_size=None, xflip=False)
+    precision, recall = precision_recall.compute_pr(opts, max_real=200000, num_gen=50000, nhood_size=3, row_batch_size=10000, col_batch_size=10000)
+    return dict(pr50k3_full_precision=precision, pr50k3_full_recall=recall)
+
+@register_metric
+def ppl2_wend(opts):
+    ppl = perceptual_path_length.compute_ppl(opts, num_samples=50000, epsilon=1e-4, space='w', sampling='end', crop=False, batch_size=2)
+    return dict(ppl2_wend=ppl)
+
+@register_metric
+def eqt50k_int(opts):
+    opts.G_kwargs.update(force_fp32=True)
+    psnr = equivariance.compute_equivariance_metrics(opts, num_samples=50000, batch_size=4, compute_eqt_int=True)
+    return dict(eqt50k_int=psnr)
+
+@register_metric
+def eqt50k_frac(opts):
+    opts.G_kwargs.update(force_fp32=True)
+    psnr = equivariance.compute_equivariance_metrics(opts, num_samples=50000, batch_size=4, compute_eqt_frac=True)
+    return dict(eqt50k_frac=psnr)
+
+@register_metric
+def eqr50k(opts):
+    opts.G_kwargs.update(force_fp32=True)
+    psnr = equivariance.compute_equivariance_metrics(opts, num_samples=50000, batch_size=4, compute_eqr=True)
+    return dict(eqr50k=psnr)
+
+#----------------------------------------------------------------------------
+# Legacy metrics.
+
+@register_metric
+def fid50k(opts):
+    opts.dataset_kwargs.update(max_size=None)
+    fid = frechet_inception_distance.compute_fid(opts, max_real=50000, num_gen=50000)
+    return dict(fid50k=fid)
+
+@register_metric
+def kid50k(opts):
+    opts.dataset_kwargs.update(max_size=None)
+    kid = kernel_inception_distance.compute_kid(opts, max_real=50000, num_gen=50000, num_subsets=100, max_subset_size=1000)
+    return dict(kid50k=kid)
+
+@register_metric
+def pr50k3(opts):
+    opts.dataset_kwargs.update(max_size=None)
+    precision, recall = precision_recall.compute_pr(opts, max_real=50000, num_gen=50000, nhood_size=3, row_batch_size=10000, col_batch_size=10000)
+    return dict(pr50k3_precision=precision, pr50k3_recall=recall)
+
+@register_metric
+def is50k(opts):
+    opts.dataset_kwargs.update(max_size=None, xflip=False)
+    mean, std = inception_score.compute_is(opts, num_gen=50000, num_splits=10)
+    return dict(is50k_mean=mean, is50k_std=std)
+
+#----------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/metrics/metric_utils.py

@@ -0,0 +1,281 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""Miscellaneous utilities used internally by the quality metrics."""
+
+import os
+import time
+import hashlib
+import pickle
+import copy
+import uuid
+import numpy as np
+import torch
+import dnnlib
+
+#----------------------------------------------------------------------------
+
+class MetricOptions:
+    def __init__(self, G=None, G_kwargs={}, dataset_kwargs={}, num_gpus=1, rank=0, device=None, progress=None, cache=True):
+        assert 0 <= rank < num_gpus
+        self.G              = G
+        self.G_kwargs       = dnnlib.EasyDict(G_kwargs)
+        self.dataset_kwargs = dnnlib.EasyDict(dataset_kwargs)
+        self.num_gpus       = num_gpus
+        self.rank           = rank
+        self.device         = device if device is not None else torch.device('cuda', rank)
+        self.progress       = progress.sub() if progress is not None and rank == 0 else ProgressMonitor()
+        self.cache          = cache
+
+#----------------------------------------------------------------------------
+
+_feature_detector_cache = dict()
+
+def get_feature_detector_name(url):
+    return os.path.splitext(url.split('/')[-1])[0]
+
+def get_feature_detector(url, device=torch.device('cpu'), num_gpus=1, rank=0, verbose=False):
+    assert 0 <= rank < num_gpus
+    key = (url, device)
+    if key not in _feature_detector_cache:
+        is_leader = (rank == 0)
+        if not is_leader and num_gpus > 1:
+            torch.distributed.barrier() # leader goes first
+        with dnnlib.util.open_url(url, verbose=(verbose and is_leader)) as f:
+            _feature_detector_cache[key] = pickle.load(f).to(device)
+        if is_leader and num_gpus > 1:
+            torch.distributed.barrier() # others follow
+    return _feature_detector_cache[key]
+
+#----------------------------------------------------------------------------
+
+def iterate_random_labels(opts, batch_size):
+    if opts.G.c_dim == 0:
+        c = torch.zeros([batch_size, opts.G.c_dim], device=opts.device)
+        while True:
+            yield c
+    else:
+        dataset = dnnlib.util.construct_class_by_name(**opts.dataset_kwargs)
+        while True:
+            c = [dataset.get_label(np.random.randint(len(dataset))) for _i in range(batch_size)]
+            c = torch.from_numpy(np.stack(c)).pin_memory().to(opts.device)
+            yield c
+
+#----------------------------------------------------------------------------
+
+class FeatureStats:
+    def __init__(self, capture_all=False, capture_mean_cov=False, max_items=None):
+        self.capture_all = capture_all
+        self.capture_mean_cov = capture_mean_cov
+        self.max_items = max_items
+        self.num_items = 0
+        self.num_features = None
+        self.all_features = None
+        self.raw_mean = None
+        self.raw_cov = None
+
+    def set_num_features(self, num_features):
+        if self.num_features is not None:
+            assert num_features == self.num_features
+        else:
+            self.num_features = num_features
+            self.all_features = []
+            self.raw_mean = np.zeros([num_features], dtype=np.float64)
+            self.raw_cov = np.zeros([num_features, num_features], dtype=np.float64)
+
+    def is_full(self):
+        return (self.max_items is not None) and (self.num_items >= self.max_items)
+
+    def append(self, x):
+        x = np.asarray(x, dtype=np.float32)
+        assert x.ndim == 2
+        if (self.max_items is not None) and (self.num_items + x.shape[0] > self.max_items):
+            if self.num_items >= self.max_items:
+                return
+            x = x[:self.max_items - self.num_items]
+
+        self.set_num_features(x.shape[1])
+        self.num_items += x.shape[0]
+        if self.capture_all:
+            self.all_features.append(x)
+        if self.capture_mean_cov:
+            x64 = x.astype(np.float64)
+            self.raw_mean += x64.sum(axis=0)
+            self.raw_cov += x64.T @ x64
+
+    def append_torch(self, x, num_gpus=1, rank=0):
+        assert isinstance(x, torch.Tensor) and x.ndim == 2
+        assert 0 <= rank < num_gpus
+        if num_gpus > 1:
+            ys = []
+            for src in range(num_gpus):
+                y = x.clone()
+                torch.distributed.broadcast(y, src=src)
+                ys.append(y)
+            x = torch.stack(ys, dim=1).flatten(0, 1) # interleave samples
+        self.append(x.cpu().numpy())
+
+    def get_all(self):
+        assert self.capture_all
+        return np.concatenate(self.all_features, axis=0)
+
+    def get_all_torch(self):
+        return torch.from_numpy(self.get_all())
+
+    def get_mean_cov(self):
+        assert self.capture_mean_cov
+        mean = self.raw_mean / self.num_items
+        cov = self.raw_cov / self.num_items
+        cov = cov - np.outer(mean, mean)
+        return mean, cov
+
+    def save(self, pkl_file):
+        with open(pkl_file, 'wb') as f:
+            pickle.dump(self.__dict__, f)
+
+    @staticmethod
+    def load(pkl_file):
+        with open(pkl_file, 'rb') as f:
+            s = dnnlib.EasyDict(pickle.load(f))
+        obj = FeatureStats(capture_all=s.capture_all, max_items=s.max_items)
+        obj.__dict__.update(s)
+        return obj
+
+#----------------------------------------------------------------------------
+
+class ProgressMonitor:
+    def __init__(self, tag=None, num_items=None, flush_interval=1000, verbose=False, progress_fn=None, pfn_lo=0, pfn_hi=1000, pfn_total=1000):
+        self.tag = tag
+        self.num_items = num_items
+        self.verbose = verbose
+        self.flush_interval = flush_interval
+        self.progress_fn = progress_fn
+        self.pfn_lo = pfn_lo
+        self.pfn_hi = pfn_hi
+        self.pfn_total = pfn_total
+        self.start_time = time.time()
+        self.batch_time = self.start_time
+        self.batch_items = 0
+        if self.progress_fn is not None:
+            self.progress_fn(self.pfn_lo, self.pfn_total)
+
+    def update(self, cur_items):
+        assert (self.num_items is None) or (cur_items <= self.num_items)
+        if (cur_items < self.batch_items + self.flush_interval) and (self.num_items is None or cur_items < self.num_items):
+            return
+        cur_time = time.time()
+        total_time = cur_time - self.start_time
+        time_per_item = (cur_time - self.batch_time) / max(cur_items - self.batch_items, 1)
+        if (self.verbose) and (self.tag is not None):
+            print(f'{self.tag:<19s} items {cur_items:<7d} time {dnnlib.util.format_time(total_time):<12s} ms/item {time_per_item*1e3:.2f}')
+        self.batch_time = cur_time
+        self.batch_items = cur_items
+
+        if (self.progress_fn is not None) and (self.num_items is not None):
+            self.progress_fn(self.pfn_lo + (self.pfn_hi - self.pfn_lo) * (cur_items / self.num_items), self.pfn_total)
+
+    def sub(self, tag=None, num_items=None, flush_interval=1000, rel_lo=0, rel_hi=1):
+        return ProgressMonitor(
+            tag             = tag,
+            num_items       = num_items,
+            flush_interval  = flush_interval,
+            verbose         = self.verbose,
+            progress_fn     = self.progress_fn,
+            pfn_lo          = self.pfn_lo + (self.pfn_hi - self.pfn_lo) * rel_lo,
+            pfn_hi          = self.pfn_lo + (self.pfn_hi - self.pfn_lo) * rel_hi,
+            pfn_total       = self.pfn_total,
+        )
+
+#----------------------------------------------------------------------------
+
+def compute_feature_stats_for_dataset(opts, detector_url, detector_kwargs, rel_lo=0, rel_hi=1, batch_size=64, data_loader_kwargs=None, max_items=None, **stats_kwargs):
+    dataset = dnnlib.util.construct_class_by_name(**opts.dataset_kwargs)
+    if data_loader_kwargs is None:
+        data_loader_kwargs = dict(pin_memory=True, num_workers=3, prefetch_factor=2)
+
+    # Try to lookup from cache.
+    cache_file = None
+    if opts.cache:
+        # Choose cache file name.
+        args = dict(dataset_kwargs=opts.dataset_kwargs, detector_url=detector_url, detector_kwargs=detector_kwargs, stats_kwargs=stats_kwargs)
+        md5 = hashlib.md5(repr(sorted(args.items())).encode('utf-8'))
+        cache_tag = f'{dataset.name}-{get_feature_detector_name(detector_url)}-{md5.hexdigest()}'
+        cache_file = dnnlib.make_cache_dir_path('gan-metrics', cache_tag + '.pkl')
+
+        # Check if the file exists (all processes must agree).
+        flag = os.path.isfile(cache_file) if opts.rank == 0 else False
+        if opts.num_gpus > 1:
+            flag = torch.as_tensor(flag, dtype=torch.float32, device=opts.device)
+            torch.distributed.broadcast(tensor=flag, src=0)
+            flag = (float(flag.cpu()) != 0)
+
+        # Load.
+        if flag:
+            return FeatureStats.load(cache_file)
+
+    # Initialize.
+    num_items = len(dataset)
+    if max_items is not None:
+        num_items = min(num_items, max_items)
+    stats = FeatureStats(max_items=num_items, **stats_kwargs)
+    progress = opts.progress.sub(tag='dataset features', num_items=num_items, rel_lo=rel_lo, rel_hi=rel_hi)
+    detector = get_feature_detector(url=detector_url, device=opts.device, num_gpus=opts.num_gpus, rank=opts.rank, verbose=progress.verbose)
+
+    # Main loop.
+    item_subset = [(i * opts.num_gpus + opts.rank) % num_items for i in range((num_items - 1) // opts.num_gpus + 1)]
+    for images, _labels in torch.utils.data.DataLoader(dataset=dataset, sampler=item_subset, batch_size=batch_size, **data_loader_kwargs):
+        if images.shape[1] == 1:
+            images = images.repeat([1, 3, 1, 1])
+        features = detector(images.to(opts.device), **detector_kwargs)
+        stats.append_torch(features, num_gpus=opts.num_gpus, rank=opts.rank)
+        progress.update(stats.num_items)
+
+    # Save to cache.
+    if cache_file is not None and opts.rank == 0:
+        os.makedirs(os.path.dirname(cache_file), exist_ok=True)
+        temp_file = cache_file + '.' + uuid.uuid4().hex
+        stats.save(temp_file)
+        os.replace(temp_file, cache_file) # atomic
+    return stats
+
+#----------------------------------------------------------------------------
+
+def compute_feature_stats_for_generator(opts, detector_url, detector_kwargs, rel_lo=0, rel_hi=1, batch_size=64, batch_gen=None, **stats_kwargs):
+    if batch_gen is None:
+        batch_gen = min(batch_size, 4)
+    assert batch_size % batch_gen == 0
+
+    # Setup generator and labels.
+    G = copy.deepcopy(opts.G).eval().requires_grad_(False).to(opts.device)
+    c_iter = iterate_random_labels(opts=opts, batch_size=batch_gen)
+
+    # Initialize.
+    stats = FeatureStats(**stats_kwargs)
+    assert stats.max_items is not None
+    progress = opts.progress.sub(tag='generator features', num_items=stats.max_items, rel_lo=rel_lo, rel_hi=rel_hi)
+    detector = get_feature_detector(url=detector_url, device=opts.device, num_gpus=opts.num_gpus, rank=opts.rank, verbose=progress.verbose)
+
+    # Main loop.
+    while not stats.is_full():
+        images = []
+        for _i in range(batch_size // batch_gen):
+            z = torch.randn([batch_gen, G.z_dim], device=opts.device)
+            img = G(z=z, c=next(c_iter), **opts.G_kwargs)['image']
+            img = (img * 127.5 + 128).clamp(0, 255).to(torch.uint8)
+            images.append(img)
+        images = torch.cat(images)
+        if images.shape[1] == 1:
+            images = images.repeat([1, 3, 1, 1])
+        features = detector(images, **detector_kwargs)
+        stats.append_torch(features, num_gpus=opts.num_gpus, rank=opts.rank)
+        progress.update(stats.num_items)
+    return stats
+
+#----------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/metrics/perceptual_path_length.py

@@ -0,0 +1,127 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""Perceptual Path Length (PPL) from the paper "A Style-Based Generator
+Architecture for Generative Adversarial Networks". Matches the original
+implementation by Karras et al. at
+https://github.com/NVlabs/stylegan/blob/master/metrics/perceptual_path_length.py"""
+
+import copy
+import numpy as np
+import torch
+from . import metric_utils
+
+#----------------------------------------------------------------------------
+
+# Spherical interpolation of a batch of vectors.
+def slerp(a, b, t):
+    a = a / a.norm(dim=-1, keepdim=True)
+    b = b / b.norm(dim=-1, keepdim=True)
+    d = (a * b).sum(dim=-1, keepdim=True)
+    p = t * torch.acos(d)
+    c = b - d * a
+    c = c / c.norm(dim=-1, keepdim=True)
+    d = a * torch.cos(p) + c * torch.sin(p)
+    d = d / d.norm(dim=-1, keepdim=True)
+    return d
+
+#----------------------------------------------------------------------------
+
+class PPLSampler(torch.nn.Module):
+    def __init__(self, G, G_kwargs, epsilon, space, sampling, crop, vgg16):
+        assert space in ['z', 'w']
+        assert sampling in ['full', 'end']
+        super().__init__()
+        self.G = copy.deepcopy(G)
+        self.G_kwargs = G_kwargs
+        self.epsilon = epsilon
+        self.space = space
+        self.sampling = sampling
+        self.crop = crop
+        self.vgg16 = copy.deepcopy(vgg16)
+
+    def forward(self, c):
+        # Generate random latents and interpolation t-values.
+        t = torch.rand([c.shape[0]], device=c.device) * (1 if self.sampling == 'full' else 0)
+        z0, z1 = torch.randn([c.shape[0] * 2, self.G.z_dim], device=c.device).chunk(2)
+
+        # Interpolate in W or Z.
+        if self.space == 'w':
+            w0, w1 = self.G.mapping(z=torch.cat([z0,z1]), c=torch.cat([c,c])).chunk(2)
+            wt0 = w0.lerp(w1, t.unsqueeze(1).unsqueeze(2))
+            wt1 = w0.lerp(w1, t.unsqueeze(1).unsqueeze(2) + self.epsilon)
+        else: # space == 'z'
+            zt0 = slerp(z0, z1, t.unsqueeze(1))
+            zt1 = slerp(z0, z1, t.unsqueeze(1) + self.epsilon)
+            wt0, wt1 = self.G.mapping(z=torch.cat([zt0,zt1]), c=torch.cat([c,c])).chunk(2)
+
+        # Randomize noise buffers.
+        for name, buf in self.G.named_buffers():
+            if name.endswith('.noise_const'):
+                buf.copy_(torch.randn_like(buf))
+
+        # Generate images.
+        img = self.G.synthesis(ws=torch.cat([wt0,wt1]), noise_mode='const', force_fp32=True, **self.G_kwargs)
+
+        # Center crop.
+        if self.crop:
+            assert img.shape[2] == img.shape[3]
+            c = img.shape[2] // 8
+            img = img[:, :, c*3 : c*7, c*2 : c*6]
+
+        # Downsample to 256x256.
+        factor = self.G.img_resolution // 256
+        if factor > 1:
+            img = img.reshape([-1, img.shape[1], img.shape[2] // factor, factor, img.shape[3] // factor, factor]).mean([3, 5])
+
+        # Scale dynamic range from [-1,1] to [0,255].
+        img = (img + 1) * (255 / 2)
+        if self.G.img_channels == 1:
+            img = img.repeat([1, 3, 1, 1])
+
+        # Evaluate differential LPIPS.
+        lpips_t0, lpips_t1 = self.vgg16(img, resize_images=False, return_lpips=True).chunk(2)
+        dist = (lpips_t0 - lpips_t1).square().sum(1) / self.epsilon ** 2
+        return dist
+
+#----------------------------------------------------------------------------
+
+def compute_ppl(opts, num_samples, epsilon, space, sampling, crop, batch_size):
+    vgg16_url = 'https://api.ngc.nvidia.com/v2/models/nvidia/research/stylegan3/versions/1/files/metrics/vgg16.pkl'
+    vgg16 = metric_utils.get_feature_detector(vgg16_url, num_gpus=opts.num_gpus, rank=opts.rank, verbose=opts.progress.verbose)
+
+    # Setup sampler and labels.
+    sampler = PPLSampler(G=opts.G, G_kwargs=opts.G_kwargs, epsilon=epsilon, space=space, sampling=sampling, crop=crop, vgg16=vgg16)
+    sampler.eval().requires_grad_(False).to(opts.device)
+    c_iter = metric_utils.iterate_random_labels(opts=opts, batch_size=batch_size)
+
+    # Sampling loop.
+    dist = []
+    progress = opts.progress.sub(tag='ppl sampling', num_items=num_samples)
+    for batch_start in range(0, num_samples, batch_size * opts.num_gpus):
+        progress.update(batch_start)
+        x = sampler(next(c_iter))
+        for src in range(opts.num_gpus):
+            y = x.clone()
+            if opts.num_gpus > 1:
+                torch.distributed.broadcast(y, src=src)
+            dist.append(y)
+    progress.update(num_samples)
+
+    # Compute PPL.
+    if opts.rank != 0:
+        return float('nan')
+    dist = torch.cat(dist)[:num_samples].cpu().numpy()
+    lo = np.percentile(dist, 1, interpolation='lower')
+    hi = np.percentile(dist, 99, interpolation='higher')
+    ppl = np.extract(np.logical_and(dist >= lo, dist <= hi), dist).mean()
+    return float(ppl)
+
+#----------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/metrics/precision_recall.py

@@ -0,0 +1,64 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""Precision/Recall (PR) from the paper "Improved Precision and Recall
+Metric for Assessing Generative Models". Matches the original implementation
+by Kynkaanniemi et al. at
+https://github.com/kynkaat/improved-precision-and-recall-metric/blob/master/precision_recall.py"""
+
+import torch
+from . import metric_utils
+
+#----------------------------------------------------------------------------
+
+def compute_distances(row_features, col_features, num_gpus, rank, col_batch_size):
+    assert 0 <= rank < num_gpus
+    num_cols = col_features.shape[0]
+    num_batches = ((num_cols - 1) // col_batch_size // num_gpus + 1) * num_gpus
+    col_batches = torch.nn.functional.pad(col_features, [0, 0, 0, -num_cols % num_batches]).chunk(num_batches)
+    dist_batches = []
+    for col_batch in col_batches[rank :: num_gpus]:
+        dist_batch = torch.cdist(row_features.unsqueeze(0), col_batch.unsqueeze(0))[0]
+        for src in range(num_gpus):
+            dist_broadcast = dist_batch.clone()
+            if num_gpus > 1:
+                torch.distributed.broadcast(dist_broadcast, src=src)
+            dist_batches.append(dist_broadcast.cpu() if rank == 0 else None)
+    return torch.cat(dist_batches, dim=1)[:, :num_cols] if rank == 0 else None
+
+#----------------------------------------------------------------------------
+
+def compute_pr(opts, max_real, num_gen, nhood_size, row_batch_size, col_batch_size):
+    detector_url = 'https://api.ngc.nvidia.com/v2/models/nvidia/research/stylegan3/versions/1/files/metrics/vgg16.pkl'
+    detector_kwargs = dict(return_features=True)
+
+    real_features = metric_utils.compute_feature_stats_for_dataset(
+        opts=opts, detector_url=detector_url, detector_kwargs=detector_kwargs,
+        rel_lo=0, rel_hi=0, capture_all=True, max_items=max_real).get_all_torch().to(torch.float16).to(opts.device)
+
+    gen_features = metric_utils.compute_feature_stats_for_generator(
+        opts=opts, detector_url=detector_url, detector_kwargs=detector_kwargs,
+        rel_lo=0, rel_hi=1, capture_all=True, max_items=num_gen).get_all_torch().to(torch.float16).to(opts.device)
+
+    results = dict()
+    for name, manifold, probes in [('precision', real_features, gen_features), ('recall', gen_features, real_features)]:
+        kth = []
+        for manifold_batch in manifold.split(row_batch_size):
+            dist = compute_distances(row_features=manifold_batch, col_features=manifold, num_gpus=opts.num_gpus, rank=opts.rank, col_batch_size=col_batch_size)
+            kth.append(dist.to(torch.float32).kthvalue(nhood_size + 1).values.to(torch.float16) if opts.rank == 0 else None)
+        kth = torch.cat(kth) if opts.rank == 0 else None
+        pred = []
+        for probes_batch in probes.split(row_batch_size):
+            dist = compute_distances(row_features=probes_batch, col_features=manifold, num_gpus=opts.num_gpus, rank=opts.rank, col_batch_size=col_batch_size)
+            pred.append((dist <= kth).any(dim=1) if opts.rank == 0 else None)
+        results[name] = float(torch.cat(pred).to(torch.float32).mean() if opts.rank == 0 else 'nan')
+    return results['precision'], results['recall']
+
+#----------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/torch_utils/__init__.py

@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+# empty

pix2pix3D-main/pix2pix3D-main/torch_utils/custom_ops.py

@@ -0,0 +1,159 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+import glob
+import hashlib
+import importlib
+import os
+import re
+import shutil
+import uuid
+
+import torch
+import torch.utils.cpp_extension
+from torch.utils.file_baton import FileBaton
+
+#----------------------------------------------------------------------------
+# Global options.
+
+verbosity = 'brief' # Verbosity level: 'none', 'brief', 'full'
+
+#----------------------------------------------------------------------------
+# Internal helper funcs.
+
+def _find_compiler_bindir():
+    patterns = [
+        'C:/Program Files (x86)/Microsoft Visual Studio/*/Professional/VC/Tools/MSVC/*/bin/Hostx64/x64',
+        'C:/Program Files (x86)/Microsoft Visual Studio/*/BuildTools/VC/Tools/MSVC/*/bin/Hostx64/x64',
+        'C:/Program Files (x86)/Microsoft Visual Studio/*/Community/VC/Tools/MSVC/*/bin/Hostx64/x64',
+        'C:/Program Files (x86)/Microsoft Visual Studio */vc/bin',
+    ]
+    for pattern in patterns:
+        matches = sorted(glob.glob(pattern))
+        if len(matches):
+            return matches[-1]
+    return None
+
+#----------------------------------------------------------------------------
+
+def _get_mangled_gpu_name():
+    name = torch.cuda.get_device_name().lower()
+    out = []
+    for c in name:
+        if re.match('[a-z0-9_-]+', c):
+            out.append(c)
+        else:
+            out.append('-')
+    return ''.join(out)
+
+#----------------------------------------------------------------------------
+# Main entry point for compiling and loading C++/CUDA plugins.
+
+_cached_plugins = dict()
+
+def get_plugin(module_name, sources, headers=None, source_dir=None, **build_kwargs):
+    assert verbosity in ['none', 'brief', 'full']
+    if headers is None:
+        headers = []
+    if source_dir is not None:
+        sources = [os.path.join(source_dir, fname) for fname in sources]
+        headers = [os.path.join(source_dir, fname) for fname in headers]
+
+    # Already cached?
+    if module_name in _cached_plugins:
+        return _cached_plugins[module_name]
+
+    # Print status.
+    if verbosity == 'full':
+        print(f'Setting up PyTorch plugin "{module_name}"...')
+    elif verbosity == 'brief':
+        print(f'Setting up PyTorch plugin "{module_name}"... ', end='', flush=True)
+    verbose_build = (verbosity == 'full')
+
+    # Compile and load.
+    try: # pylint: disable=too-many-nested-blocks
+        # Make sure we can find the necessary compiler binaries.
+        if os.name == 'nt' and os.system("where cl.exe >nul 2>nul") != 0:
+            compiler_bindir = _find_compiler_bindir()
+            if compiler_bindir is None:
+                raise RuntimeError(f'Could not find MSVC/GCC/CLANG installation on this computer. Check _find_compiler_bindir() in "{__file__}".')
+            os.environ['PATH'] += ';' + compiler_bindir
+
+        # Some containers set TORCH_CUDA_ARCH_LIST to a list that can either
+        # break the build or unnecessarily restrict what's available to nvcc.
+        # Unset it to let nvcc decide based on what's available on the
+        # machine.
+        os.environ['TORCH_CUDA_ARCH_LIST'] = ''
+
+        # Incremental build md5sum trickery.  Copies all the input source files
+        # into a cached build directory under a combined md5 digest of the input
+        # source files.  Copying is done only if the combined digest has changed.
+        # This keeps input file timestamps and filenames the same as in previous
+        # extension builds, allowing for fast incremental rebuilds.
+        #
+        # This optimization is done only in case all the source files reside in
+        # a single directory (just for simplicity) and if the TORCH_EXTENSIONS_DIR
+        # environment variable is set (we take this as a signal that the user
+        # actually cares about this.)
+        #
+        # EDIT: We now do it regardless of TORCH_EXTENSIOS_DIR, in order to work
+        # around the *.cu dependency bug in ninja config.
+        #
+        all_source_files = sorted(sources + headers)
+        all_source_dirs = set(os.path.dirname(fname) for fname in all_source_files)
+        if len(all_source_dirs) == 1: # and ('TORCH_EXTENSIONS_DIR' in os.environ):
+
+            # Compute combined hash digest for all source files.
+            hash_md5 = hashlib.md5()
+            for src in all_source_files:
+                with open(src, 'rb') as f:
+                    hash_md5.update(f.read())
+
+            # Select cached build directory name.
+            source_digest = hash_md5.hexdigest()
+            build_top_dir = torch.utils.cpp_extension._get_build_directory(module_name, verbose=verbose_build) # pylint: disable=protected-access
+            cached_build_dir = os.path.join(build_top_dir, f'{source_digest}-{_get_mangled_gpu_name()}')
+
+            if not os.path.isdir(cached_build_dir):
+                tmpdir = f'{build_top_dir}/srctmp-{uuid.uuid4().hex}'
+                os.makedirs(tmpdir)
+                for src in all_source_files:
+                    shutil.copyfile(src, os.path.join(tmpdir, os.path.basename(src)))
+                try:
+                    os.replace(tmpdir, cached_build_dir) # atomic
+                except OSError:
+                    # source directory already exists, delete tmpdir and its contents.
+                    shutil.rmtree(tmpdir)
+                    if not os.path.isdir(cached_build_dir): raise
+
+            # Compile.
+            cached_sources = [os.path.join(cached_build_dir, os.path.basename(fname)) for fname in sources]
+            torch.utils.cpp_extension.load(name=module_name, build_directory=cached_build_dir,
+                verbose=verbose_build, sources=cached_sources, **build_kwargs)
+        else:
+            torch.utils.cpp_extension.load(name=module_name, verbose=verbose_build, sources=sources, **build_kwargs)
+
+        # Load.
+        module = importlib.import_module(module_name)
+
+    except:
+        if verbosity == 'brief':
+            print('Failed!')
+        raise
+
+    # Print status and add to cache dict.
+    if verbosity == 'full':
+        print(f'Done setting up PyTorch plugin "{module_name}".')
+    elif verbosity == 'brief':
+        print('Done.')
+    _cached_plugins[module_name] = module
+    return module
+
+#----------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/torch_utils/misc.py

@@ -0,0 +1,280 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+import re
+import contextlib
+import numpy as np
+import torch
+import warnings
+import dnnlib
+
+#----------------------------------------------------------------------------
+# Cached construction of constant tensors. Avoids CPU=>GPU copy when the
+# same constant is used multiple times.
+
+_constant_cache = dict()
+
+def constant(value, shape=None, dtype=None, device=None, memory_format=None):
+    value = np.asarray(value)
+    if shape is not None:
+        shape = tuple(shape)
+    if dtype is None:
+        dtype = torch.get_default_dtype()
+    if device is None:
+        device = torch.device('cpu')
+    if memory_format is None:
+        memory_format = torch.contiguous_format
+
+    key = (value.shape, value.dtype, value.tobytes(), shape, dtype, device, memory_format)
+    tensor = _constant_cache.get(key, None)
+    if tensor is None:
+        tensor = torch.as_tensor(value.copy(), dtype=dtype, device=device)
+        if shape is not None:
+            tensor, _ = torch.broadcast_tensors(tensor, torch.empty(shape))
+        tensor = tensor.contiguous(memory_format=memory_format)
+        _constant_cache[key] = tensor
+    return tensor
+
+#----------------------------------------------------------------------------
+# Replace NaN/Inf with specified numerical values.
+
+try:
+    nan_to_num = torch.nan_to_num # 1.8.0a0
+except AttributeError:
+    def nan_to_num(input, nan=0.0, posinf=None, neginf=None, *, out=None): # pylint: disable=redefined-builtin
+        assert isinstance(input, torch.Tensor)
+        if posinf is None:
+            posinf = torch.finfo(input.dtype).max
+        if neginf is None:
+            neginf = torch.finfo(input.dtype).min
+        assert nan == 0
+        return torch.clamp(input.unsqueeze(0).nansum(0), min=neginf, max=posinf, out=out)
+
+#----------------------------------------------------------------------------
+# Symbolic assert.
+
+try:
+    symbolic_assert = torch._assert # 1.8.0a0 # pylint: disable=protected-access
+except AttributeError:
+    symbolic_assert = torch.Assert # 1.7.0
+
+#----------------------------------------------------------------------------
+# Context manager to temporarily suppress known warnings in torch.jit.trace().
+# Note: Cannot use catch_warnings because of https://bugs.python.org/issue29672
+
+@contextlib.contextmanager
+def suppress_tracer_warnings():
+    flt = ('ignore', None, torch.jit.TracerWarning, None, 0)
+    warnings.filters.insert(0, flt)
+    yield
+    warnings.filters.remove(flt)
+
+#----------------------------------------------------------------------------
+# Assert that the shape of a tensor matches the given list of integers.
+# None indicates that the size of a dimension is allowed to vary.
+# Performs symbolic assertion when used in torch.jit.trace().
+
+def assert_shape(tensor, ref_shape):
+    if tensor.ndim != len(ref_shape):
+        raise AssertionError(f'Wrong number of dimensions: got {tensor.ndim}, expected {len(ref_shape)}')
+    for idx, (size, ref_size) in enumerate(zip(tensor.shape, ref_shape)):
+        if ref_size is None:
+            pass
+        elif isinstance(ref_size, torch.Tensor):
+            with suppress_tracer_warnings(): # as_tensor results are registered as constants
+                symbolic_assert(torch.equal(torch.as_tensor(size), ref_size), f'Wrong size for dimension {idx}')
+        elif isinstance(size, torch.Tensor):
+            with suppress_tracer_warnings(): # as_tensor results are registered as constants
+                symbolic_assert(torch.equal(size, torch.as_tensor(ref_size)), f'Wrong size for dimension {idx}: expected {ref_size}')
+        elif size != ref_size:
+            raise AssertionError(f'Wrong size for dimension {idx}: got {size}, expected {ref_size}')
+
+#----------------------------------------------------------------------------
+# Function decorator that calls torch.autograd.profiler.record_function().
+
+def profiled_function(fn):
+    def decorator(*args, **kwargs):
+        with torch.autograd.profiler.record_function(fn.__name__):
+            return fn(*args, **kwargs)
+    decorator.__name__ = fn.__name__
+    return decorator
+
+#----------------------------------------------------------------------------
+# Sampler for torch.utils.data.DataLoader that loops over the dataset
+# indefinitely, shuffling items as it goes.
+
+class InfiniteSampler(torch.utils.data.Sampler):
+    def __init__(self, dataset, rank=0, num_replicas=1, shuffle=True, seed=0, window_size=0.5):
+        assert len(dataset) > 0
+        assert num_replicas > 0
+        assert 0 <= rank < num_replicas
+        assert 0 <= window_size <= 1
+        super().__init__(dataset)
+        self.dataset = dataset
+        self.rank = rank
+        self.num_replicas = num_replicas
+        self.shuffle = shuffle
+        self.seed = seed
+        self.window_size = window_size
+
+    def __iter__(self):
+        order = np.arange(len(self.dataset))
+        rnd = None
+        window = 0
+        if self.shuffle:
+            rnd = np.random.RandomState(self.seed)
+            rnd.shuffle(order)
+            window = int(np.rint(order.size * self.window_size))
+
+        idx = 0
+        while True:
+            i = idx % order.size
+            if idx % self.num_replicas == self.rank:
+                yield order[i]
+            if window >= 2:
+                j = (i - rnd.randint(window)) % order.size
+                order[i], order[j] = order[j], order[i]
+            idx += 1
+
+#----------------------------------------------------------------------------
+# Utilities for operating with torch.nn.Module parameters and buffers.
+
+def params_and_buffers(module):
+    assert isinstance(module, torch.nn.Module)
+    return list(module.parameters()) + list(module.buffers())
+
+def named_params_and_buffers(module):
+    assert isinstance(module, torch.nn.Module)
+    return list(module.named_parameters()) + list(module.named_buffers())
+
+def copy_params_and_buffers(src_module, dst_module, require_all=False, allow_mismatch=False):
+    assert isinstance(src_module, torch.nn.Module)
+    assert isinstance(dst_module, torch.nn.Module)
+    src_tensors = dict(named_params_and_buffers(src_module))
+    for name, tensor in named_params_and_buffers(dst_module):
+        assert (name in src_tensors) or (not require_all)
+        if name not in src_tensors and name.replace('_semantic', '') not in src_tensors:
+            print(f'Warning: {name} not found in source module')
+            continue
+        if name not in src_tensors:
+            # print(f'Warning: {name} not found in source module, using {name.replace("_semantic", "")}')
+            name_src = name.replace('_semantic', '')
+        else:
+            name_src = name
+        if src_tensors[name_src].shape != tensor.shape and allow_mismatch:
+            print(f'Warning: {name_src} shape mismatch: {src_tensors[name_src].shape} vs {tensor.shape}')
+            continue
+        if name_src in src_tensors:
+            tensor.copy_(src_tensors[name_src].detach()).requires_grad_(tensor.requires_grad)
+            # print(f'Copied {name}')
+
+#----------------------------------------------------------------------------
+# Context manager for easily enabling/disabling DistributedDataParallel
+# synchronization.
+
+@contextlib.contextmanager
+def ddp_sync(module, sync):
+    assert isinstance(module, torch.nn.Module)
+    if sync or not isinstance(module, torch.nn.parallel.DistributedDataParallel):
+        yield
+    else:
+        with module.no_sync():
+            yield
+
+#----------------------------------------------------------------------------
+# Check DistributedDataParallel consistency across processes.
+
+def check_ddp_consistency(module, ignore_regex=None):
+    assert isinstance(module, torch.nn.Module)
+    for name, tensor in named_params_and_buffers(module):
+        fullname = type(module).__name__ + '.' + name
+        if ignore_regex is not None and re.fullmatch(ignore_regex, fullname):
+            continue
+        tensor = tensor.detach()
+        if tensor.is_floating_point():
+            tensor = nan_to_num(tensor)
+        other = tensor.clone()
+        torch.distributed.broadcast(tensor=other, src=0)
+        assert (tensor == other).all(), fullname
+
+#----------------------------------------------------------------------------
+# Print summary table of module hierarchy.
+
+def print_module_summary(module, inputs, max_nesting=3, skip_redundant=True):
+    assert isinstance(module, torch.nn.Module)
+    assert not isinstance(module, torch.jit.ScriptModule)
+    assert isinstance(inputs, (tuple, list))
+
+    # Register hooks.
+    entries = []
+    nesting = [0]
+    def pre_hook(_mod, _inputs):
+        nesting[0] += 1
+    def post_hook(mod, _inputs, outputs):
+        nesting[0] -= 1
+        if nesting[0] <= max_nesting:
+            outputs = list(outputs) if isinstance(outputs, (tuple, list)) else [outputs]
+            outputs = [t for t in outputs if isinstance(t, torch.Tensor)]
+            entries.append(dnnlib.EasyDict(mod=mod, outputs=outputs))
+    hooks = [mod.register_forward_pre_hook(pre_hook) for mod in module.modules()]
+    hooks += [mod.register_forward_hook(post_hook) for mod in module.modules()]
+
+    # Run module.
+    outputs = module(*inputs)
+    for hook in hooks:
+        hook.remove()
+
+    # Identify unique outputs, parameters, and buffers.
+    tensors_seen = set()
+    for e in entries:
+        e.unique_params = [t for t in e.mod.parameters() if id(t) not in tensors_seen]
+        e.unique_buffers = [t for t in e.mod.buffers() if id(t) not in tensors_seen]
+        e.unique_outputs = [t for t in e.outputs if id(t) not in tensors_seen]
+        tensors_seen |= {id(t) for t in e.unique_params + e.unique_buffers + e.unique_outputs}
+
+    # Filter out redundant entries.
+    if skip_redundant:
+        entries = [e for e in entries if len(e.unique_params) or len(e.unique_buffers) or len(e.unique_outputs)]
+
+    # Construct table.
+    rows = [[type(module).__name__, 'Parameters', 'Buffers', 'Output shape', 'Datatype']]
+    rows += [['---'] * len(rows[0])]
+    param_total = 0
+    buffer_total = 0
+    submodule_names = {mod: name for name, mod in module.named_modules()}
+    for e in entries:
+        name = '<top-level>' if e.mod is module else submodule_names[e.mod]
+        param_size = sum(t.numel() for t in e.unique_params)
+        buffer_size = sum(t.numel() for t in e.unique_buffers)
+        output_shapes = [str(list(t.shape)) for t in e.outputs]
+        output_dtypes = [str(t.dtype).split('.')[-1] for t in e.outputs]
+        rows += [[
+            name + (':0' if len(e.outputs) >= 2 else ''),
+            str(param_size) if param_size else '-',
+            str(buffer_size) if buffer_size else '-',
+            (output_shapes + ['-'])[0],
+            (output_dtypes + ['-'])[0],
+        ]]
+        for idx in range(1, len(e.outputs)):
+            rows += [[name + f':{idx}', '-', '-', output_shapes[idx], output_dtypes[idx]]]
+        param_total += param_size
+        buffer_total += buffer_size
+    rows += [['---'] * len(rows[0])]
+    rows += [['Total', str(param_total), str(buffer_total), '-', '-']]
+
+    # Print table.
+    widths = [max(len(cell) for cell in column) for column in zip(*rows)]
+    print()
+    for row in rows:
+        print('  '.join(cell + ' ' * (width - len(cell)) for cell, width in zip(row, widths)))
+    print()
+    return outputs
+
+#----------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/torch_utils/ops/__init__.py

@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+# empty

pix2pix3D-main/pix2pix3D-main/torch_utils/ops/bias_act.cpp

@@ -0,0 +1,103 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+#include <torch/extension.h>
+#include <ATen/cuda/CUDAContext.h>
+#include <c10/cuda/CUDAGuard.h>
+#include "bias_act.h"
+
+//------------------------------------------------------------------------
+
+static bool has_same_layout(torch::Tensor x, torch::Tensor y)
+{
+    if (x.dim() != y.dim())
+        return false;
+    for (int64_t i = 0; i < x.dim(); i++)
+    {
+        if (x.size(i) != y.size(i))
+            return false;
+        if (x.size(i) >= 2 && x.stride(i) != y.stride(i))
+            return false;
+    }
+    return true;
+}
+
+//------------------------------------------------------------------------
+
+static torch::Tensor bias_act(torch::Tensor x, torch::Tensor b, torch::Tensor xref, torch::Tensor yref, torch::Tensor dy, int grad, int dim, int act, float alpha, float gain, float clamp)
+{
+    // Validate arguments.
+    TORCH_CHECK(x.is_cuda(), "x must reside on CUDA device");
+    TORCH_CHECK(b.numel() == 0 || (b.dtype() == x.dtype() && b.device() == x.device()), "b must have the same dtype and device as x");
+    TORCH_CHECK(xref.numel() == 0 || (xref.sizes() == x.sizes() && xref.dtype() == x.dtype() && xref.device() == x.device()), "xref must have the same shape, dtype, and device as x");
+    TORCH_CHECK(yref.numel() == 0 || (yref.sizes() == x.sizes() && yref.dtype() == x.dtype() && yref.device() == x.device()), "yref must have the same shape, dtype, and device as x");
+    TORCH_CHECK(dy.numel() == 0 || (dy.sizes() == x.sizes() && dy.dtype() == x.dtype() && dy.device() == x.device()), "dy must have the same dtype and device as x");
+    TORCH_CHECK(x.numel() <= INT_MAX, "x is too large");
+    TORCH_CHECK(b.dim() == 1, "b must have rank 1");
+    TORCH_CHECK(b.numel() == 0 || (dim >= 0 && dim < x.dim()), "dim is out of bounds");
+    TORCH_CHECK(b.numel() == 0 || b.numel() == x.size(dim), "b has wrong number of elements");
+    TORCH_CHECK(grad >= 0, "grad must be non-negative");
+
+    // Validate layout.
+    TORCH_CHECK(x.is_non_overlapping_and_dense(), "x must be non-overlapping and dense");
+    TORCH_CHECK(b.is_contiguous(), "b must be contiguous");
+    TORCH_CHECK(xref.numel() == 0 || has_same_layout(xref, x), "xref must have the same layout as x");
+    TORCH_CHECK(yref.numel() == 0 || has_same_layout(yref, x), "yref must have the same layout as x");
+    TORCH_CHECK(dy.numel() == 0 || has_same_layout(dy, x), "dy must have the same layout as x");
+
+    // Create output tensor.
+    const at::cuda::OptionalCUDAGuard device_guard(device_of(x));
+    torch::Tensor y = torch::empty_like(x);
+    TORCH_CHECK(has_same_layout(y, x), "y must have the same layout as x");
+
+    // Initialize CUDA kernel parameters.
+    bias_act_kernel_params p;
+    p.x     = x.data_ptr();
+    p.b     = (b.numel()) ? b.data_ptr() : NULL;
+    p.xref  = (xref.numel()) ? xref.data_ptr() : NULL;
+    p.yref  = (yref.numel()) ? yref.data_ptr() : NULL;
+    p.dy    = (dy.numel()) ? dy.data_ptr() : NULL;
+    p.y     = y.data_ptr();
+    p.grad  = grad;
+    p.act   = act;
+    p.alpha = alpha;
+    p.gain  = gain;
+    p.clamp = clamp;
+    p.sizeX = (int)x.numel();
+    p.sizeB = (int)b.numel();
+    p.stepB = (b.numel()) ? (int)x.stride(dim) : 1;
+
+    // Choose CUDA kernel.
+    void* kernel;
+    AT_DISPATCH_FLOATING_TYPES_AND_HALF(x.scalar_type(), "upfirdn2d_cuda", [&]
+    {
+        kernel = choose_bias_act_kernel<scalar_t>(p);
+    });
+    TORCH_CHECK(kernel, "no CUDA kernel found for the specified activation func");
+
+    // Launch CUDA kernel.
+    p.loopX = 4;
+    int blockSize = 4 * 32;
+    int gridSize = (p.sizeX - 1) / (p.loopX * blockSize) + 1;
+    void* args[] = {&p};
+    AT_CUDA_CHECK(cudaLaunchKernel(kernel, gridSize, blockSize, args, 0, at::cuda::getCurrentCUDAStream()));
+    return y;
+}
+
+//------------------------------------------------------------------------
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m)
+{
+    m.def("bias_act", &bias_act);
+}
+
+//------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/torch_utils/ops/bias_act.cu

@@ -0,0 +1,177 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+#include <c10/util/Half.h>
+#include "bias_act.h"
+
+//------------------------------------------------------------------------
+// Helpers.
+
+template <class T> struct InternalType;
+template <> struct InternalType<double>     { typedef double scalar_t; };
+template <> struct InternalType<float>      { typedef float  scalar_t; };
+template <> struct InternalType<c10::Half>  { typedef float  scalar_t; };
+
+//------------------------------------------------------------------------
+// CUDA kernel.
+
+template <class T, int A>
+__global__ void bias_act_kernel(bias_act_kernel_params p)
+{
+    typedef typename InternalType<T>::scalar_t scalar_t;
+    int G                 = p.grad;
+    scalar_t alpha        = (scalar_t)p.alpha;
+    scalar_t gain         = (scalar_t)p.gain;
+    scalar_t clamp        = (scalar_t)p.clamp;
+    scalar_t one          = (scalar_t)1;
+    scalar_t two          = (scalar_t)2;
+    scalar_t expRange     = (scalar_t)80;
+    scalar_t halfExpRange = (scalar_t)40;
+    scalar_t seluScale    = (scalar_t)1.0507009873554804934193349852946;
+    scalar_t seluAlpha    = (scalar_t)1.6732632423543772848170429916717;
+
+    // Loop over elements.
+    int xi = blockIdx.x * p.loopX * blockDim.x + threadIdx.x;
+    for (int loopIdx = 0; loopIdx < p.loopX && xi < p.sizeX; loopIdx++, xi += blockDim.x)
+    {
+        // Load.
+        scalar_t x = (scalar_t)((const T*)p.x)[xi];
+        scalar_t b = (p.b) ? (scalar_t)((const T*)p.b)[(xi / p.stepB) % p.sizeB] : 0;
+        scalar_t xref = (p.xref) ? (scalar_t)((const T*)p.xref)[xi] : 0;
+        scalar_t yref = (p.yref) ? (scalar_t)((const T*)p.yref)[xi] : 0;
+        scalar_t dy = (p.dy) ? (scalar_t)((const T*)p.dy)[xi] : one;
+        scalar_t yy = (gain != 0) ? yref / gain : 0;
+        scalar_t y = 0;
+
+        // Apply bias.
+        ((G == 0) ? x : xref) += b;
+
+        // linear
+        if (A == 1)
+        {
+            if (G == 0) y = x;
+            if (G == 1) y = x;
+        }
+
+        // relu
+        if (A == 2)
+        {
+            if (G == 0) y = (x > 0) ? x : 0;
+            if (G == 1) y = (yy > 0) ? x : 0;
+        }
+
+        // lrelu
+        if (A == 3)
+        {
+            if (G == 0) y = (x > 0) ? x : x * alpha;
+            if (G == 1) y = (yy > 0) ? x : x * alpha;
+        }
+
+        // tanh
+        if (A == 4)
+        {
+            if (G == 0) { scalar_t c = exp(x); scalar_t d = one / c; y = (x < -expRange) ? -one : (x > expRange) ? one : (c - d) / (c + d); }
+            if (G == 1) y = x * (one - yy * yy);
+            if (G == 2) y = x * (one - yy * yy) * (-two * yy);
+        }
+
+        // sigmoid
+        if (A == 5)
+        {
+            if (G == 0) y = (x < -expRange) ? 0 : one / (exp(-x) + one);
+            if (G == 1) y = x * yy * (one - yy);
+            if (G == 2) y = x * yy * (one - yy) * (one - two * yy);
+        }
+
+        // elu
+        if (A == 6)
+        {
+            if (G == 0) y = (x >= 0) ? x : exp(x) - one;
+            if (G == 1) y = (yy >= 0) ? x : x * (yy + one);
+            if (G == 2) y = (yy >= 0) ? 0 : x * (yy + one);
+        }
+
+        // selu
+        if (A == 7)
+        {
+            if (G == 0) y = (x >= 0) ? seluScale * x : (seluScale * seluAlpha) * (exp(x) - one);
+            if (G == 1) y = (yy >= 0) ? x * seluScale : x * (yy + seluScale * seluAlpha);
+            if (G == 2) y = (yy >= 0) ? 0 : x * (yy + seluScale * seluAlpha);
+        }
+
+        // softplus
+        if (A == 8)
+        {
+            if (G == 0) y = (x > expRange) ? x : log(exp(x) + one);
+            if (G == 1) y = x * (one - exp(-yy));
+            if (G == 2) { scalar_t c = exp(-yy); y = x * c * (one - c); }
+        }
+
+        // swish
+        if (A == 9)
+        {
+            if (G == 0)
+                y = (x < -expRange) ? 0 : x / (exp(-x) + one);
+            else
+            {
+                scalar_t c = exp(xref);
+                scalar_t d = c + one;
+                if (G == 1)
+                    y = (xref > halfExpRange) ? x : x * c * (xref + d) / (d * d);
+                else
+                    y = (xref > halfExpRange) ? 0 : x * c * (xref * (two - d) + two * d) / (d * d * d);
+                yref = (xref < -expRange) ? 0 : xref / (exp(-xref) + one) * gain;
+            }
+        }
+
+        // Apply gain.
+        y *= gain * dy;
+
+        // Clamp.
+        if (clamp >= 0)
+        {
+            if (G == 0)
+                y = (y > -clamp & y < clamp) ? y : (y >= 0) ? clamp : -clamp;
+            else
+                y = (yref > -clamp & yref < clamp) ? y : 0;
+        }
+
+        // Store.
+        ((T*)p.y)[xi] = (T)y;
+    }
+}
+
+//------------------------------------------------------------------------
+// CUDA kernel selection.
+
+template <class T> void* choose_bias_act_kernel(const bias_act_kernel_params& p)
+{
+    if (p.act == 1) return (void*)bias_act_kernel<T, 1>;
+    if (p.act == 2) return (void*)bias_act_kernel<T, 2>;
+    if (p.act == 3) return (void*)bias_act_kernel<T, 3>;
+    if (p.act == 4) return (void*)bias_act_kernel<T, 4>;
+    if (p.act == 5) return (void*)bias_act_kernel<T, 5>;
+    if (p.act == 6) return (void*)bias_act_kernel<T, 6>;
+    if (p.act == 7) return (void*)bias_act_kernel<T, 7>;
+    if (p.act == 8) return (void*)bias_act_kernel<T, 8>;
+    if (p.act == 9) return (void*)bias_act_kernel<T, 9>;
+    return NULL;
+}
+
+//------------------------------------------------------------------------
+// Template specializations.
+
+template void* choose_bias_act_kernel<double>       (const bias_act_kernel_params& p);
+template void* choose_bias_act_kernel<float>        (const bias_act_kernel_params& p);
+template void* choose_bias_act_kernel<c10::Half>    (const bias_act_kernel_params& p);
+
+//------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/torch_utils/ops/bias_act.h

@@ -0,0 +1,42 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+//------------------------------------------------------------------------
+// CUDA kernel parameters.
+
+struct bias_act_kernel_params
+{
+    const void* x;      // [sizeX]
+    const void* b;      // [sizeB] or NULL
+    const void* xref;   // [sizeX] or NULL
+    const void* yref;   // [sizeX] or NULL
+    const void* dy;     // [sizeX] or NULL
+    void*       y;      // [sizeX]
+
+    int         grad;
+    int         act;
+    float       alpha;
+    float       gain;
+    float       clamp;
+
+    int         sizeX;
+    int         sizeB;
+    int         stepB;
+    int         loopX;
+};
+
+//------------------------------------------------------------------------
+// CUDA kernel selection.
+
+template <class T> void* choose_bias_act_kernel(const bias_act_kernel_params& p);
+
+//------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/torch_utils/ops/bias_act.py

@@ -0,0 +1,211 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""Custom PyTorch ops for efficient bias and activation."""
+
+import os
+import numpy as np
+import torch
+import dnnlib
+
+from .. import custom_ops
+from .. import misc
+
+#----------------------------------------------------------------------------
+
+activation_funcs = {
+    'linear':   dnnlib.EasyDict(func=lambda x, **_:         x,                                          def_alpha=0,    def_gain=1,             cuda_idx=1, ref='',  has_2nd_grad=False),
+    'relu':     dnnlib.EasyDict(func=lambda x, **_:         torch.nn.functional.relu(x),                def_alpha=0,    def_gain=np.sqrt(2),    cuda_idx=2, ref='y', has_2nd_grad=False),
+    'lrelu':    dnnlib.EasyDict(func=lambda x, alpha, **_:  torch.nn.functional.leaky_relu(x, alpha),   def_alpha=0.2,  def_gain=np.sqrt(2),    cuda_idx=3, ref='y', has_2nd_grad=False),
+    'tanh':     dnnlib.EasyDict(func=lambda x, **_:         torch.tanh(x),                              def_alpha=0,    def_gain=1,             cuda_idx=4, ref='y', has_2nd_grad=True),
+    'sigmoid':  dnnlib.EasyDict(func=lambda x, **_:         torch.sigmoid(x),                           def_alpha=0,    def_gain=1,             cuda_idx=5, ref='y', has_2nd_grad=True),
+    'elu':      dnnlib.EasyDict(func=lambda x, **_:         torch.nn.functional.elu(x),                 def_alpha=0,    def_gain=1,             cuda_idx=6, ref='y', has_2nd_grad=True),
+    'selu':     dnnlib.EasyDict(func=lambda x, **_:         torch.nn.functional.selu(x),                def_alpha=0,    def_gain=1,             cuda_idx=7, ref='y', has_2nd_grad=True),
+    'softplus': dnnlib.EasyDict(func=lambda x, **_:         torch.nn.functional.softplus(x),            def_alpha=0,    def_gain=1,             cuda_idx=8, ref='y', has_2nd_grad=True),
+    'swish':    dnnlib.EasyDict(func=lambda x, **_:         torch.sigmoid(x) * x,                       def_alpha=0,    def_gain=np.sqrt(2),    cuda_idx=9, ref='x', has_2nd_grad=True),
+}
+
+#----------------------------------------------------------------------------
+
+_plugin = None
+_null_tensor = torch.empty([0])
+
+def _init():
+    global _plugin
+    if _plugin is None:
+        _plugin = custom_ops.get_plugin(
+            module_name='bias_act_plugin',
+            sources=['bias_act.cpp', 'bias_act.cu'],
+            headers=['bias_act.h'],
+            source_dir=os.path.dirname(__file__),
+            extra_cuda_cflags=['--use_fast_math'],
+        )
+    return True
+
+#----------------------------------------------------------------------------
+
+def bias_act(x, b=None, dim=1, act='linear', alpha=None, gain=None, clamp=None, impl='cuda'):
+    r"""Fused bias and activation function.
+
+    Adds bias `b` to activation tensor `x`, evaluates activation function `act`,
+    and scales the result by `gain`. Each of the steps is optional. In most cases,
+    the fused op is considerably more efficient than performing the same calculation
+    using standard PyTorch ops. It supports first and second order gradients,
+    but not third order gradients.
+
+    Args:
+        x:      Input activation tensor. Can be of any shape.
+        b:      Bias vector, or `None` to disable. Must be a 1D tensor of the same type
+                as `x`. The shape must be known, and it must match the dimension of `x`
+                corresponding to `dim`.
+        dim:    The dimension in `x` corresponding to the elements of `b`.
+                The value of `dim` is ignored if `b` is not specified.
+        act:    Name of the activation function to evaluate, or `"linear"` to disable.
+                Can be e.g. `"relu"`, `"lrelu"`, `"tanh"`, `"sigmoid"`, `"swish"`, etc.
+                See `activation_funcs` for a full list. `None` is not allowed.
+        alpha:  Shape parameter for the activation function, or `None` to use the default.
+        gain:   Scaling factor for the output tensor, or `None` to use default.
+                See `activation_funcs` for the default scaling of each activation function.
+                If unsure, consider specifying 1.
+        clamp:  Clamp the output values to `[-clamp, +clamp]`, or `None` to disable
+                the clamping (default).
+        impl:   Name of the implementation to use. Can be `"ref"` or `"cuda"` (default).
+
+    Returns:
+        Tensor of the same shape and datatype as `x`.
+    """
+    assert isinstance(x, torch.Tensor)
+    assert impl in ['ref', 'cuda']
+    if impl == 'cuda' and x.device.type == 'cuda' and _init():
+        return _bias_act_cuda(dim=dim, act=act, alpha=alpha, gain=gain, clamp=clamp).apply(x, b)
+    return _bias_act_ref(x=x, b=b, dim=dim, act=act, alpha=alpha, gain=gain, clamp=clamp)
+
+#----------------------------------------------------------------------------
+
+@misc.profiled_function
+def _bias_act_ref(x, b=None, dim=1, act='linear', alpha=None, gain=None, clamp=None):
+    """Slow reference implementation of `bias_act()` using standard TensorFlow ops.
+    """
+    assert isinstance(x, torch.Tensor)
+    assert clamp is None or clamp >= 0
+    spec = activation_funcs[act]
+    alpha = float(alpha if alpha is not None else spec.def_alpha)
+    gain = float(gain if gain is not None else spec.def_gain)
+    clamp = float(clamp if clamp is not None else -1)
+
+    # Add bias.
+    if b is not None:
+        assert isinstance(b, torch.Tensor) and b.ndim == 1
+        assert 0 <= dim < x.ndim
+        assert b.shape[0] == x.shape[dim]
+        x = x + b.reshape([-1 if i == dim else 1 for i in range(x.ndim)])
+
+    # Evaluate activation function.
+    alpha = float(alpha)
+    x = spec.func(x, alpha=alpha)
+
+    # Scale by gain.
+    gain = float(gain)
+    if gain != 1:
+        x = x * gain
+
+    # Clamp.
+    if clamp >= 0:
+        x = x.clamp(-clamp, clamp) # pylint: disable=invalid-unary-operand-type
+    return x
+
+#----------------------------------------------------------------------------
+
+_bias_act_cuda_cache = dict()
+
+def _bias_act_cuda(dim=1, act='linear', alpha=None, gain=None, clamp=None):
+    """Fast CUDA implementation of `bias_act()` using custom ops.
+    """
+    # Parse arguments.
+    assert clamp is None or clamp >= 0
+    spec = activation_funcs[act]
+    alpha = float(alpha if alpha is not None else spec.def_alpha)
+    gain = float(gain if gain is not None else spec.def_gain)
+    clamp = float(clamp if clamp is not None else -1)
+
+    # Lookup from cache.
+    key = (dim, act, alpha, gain, clamp)
+    if key in _bias_act_cuda_cache:
+        return _bias_act_cuda_cache[key]
+
+    # Forward op.
+    class BiasActCuda(torch.autograd.Function):
+        @staticmethod
+        def forward(ctx, x, b): # pylint: disable=arguments-differ
+            ctx.memory_format = torch.channels_last if x.ndim > 2 and x.stride(1) == 1 else torch.contiguous_format
+            x = x.contiguous(memory_format=ctx.memory_format)
+            b = b.contiguous() if b is not None else _null_tensor
+            y = x
+            if act != 'linear' or gain != 1 or clamp >= 0 or b is not _null_tensor:
+                y = _plugin.bias_act(x, b, _null_tensor, _null_tensor, _null_tensor, 0, dim, spec.cuda_idx, alpha, gain, clamp)
+            ctx.save_for_backward(
+                x if 'x' in spec.ref or spec.has_2nd_grad else _null_tensor,
+                b if 'x' in spec.ref or spec.has_2nd_grad else _null_tensor,
+                y if 'y' in spec.ref else _null_tensor)
+            return y
+
+        @staticmethod
+        def backward(ctx, dy): # pylint: disable=arguments-differ
+            dy = dy.contiguous(memory_format=ctx.memory_format)
+            x, b, y = ctx.saved_tensors
+            dx = None
+            db = None
+
+            if ctx.needs_input_grad[0] or ctx.needs_input_grad[1]:
+                dx = dy
+                if act != 'linear' or gain != 1 or clamp >= 0:
+                    dx = BiasActCudaGrad.apply(dy, x, b, y)
+
+            if ctx.needs_input_grad[1]:
+                db = dx.sum([i for i in range(dx.ndim) if i != dim])
+
+            return dx, db
+
+    # Backward op.
+    class BiasActCudaGrad(torch.autograd.Function):
+        @staticmethod
+        def forward(ctx, dy, x, b, y): # pylint: disable=arguments-differ
+            ctx.memory_format = torch.channels_last if dy.ndim > 2 and dy.stride(1) == 1 else torch.contiguous_format
+            dx = _plugin.bias_act(dy, b, x, y, _null_tensor, 1, dim, spec.cuda_idx, alpha, gain, clamp)
+            ctx.save_for_backward(
+                dy if spec.has_2nd_grad else _null_tensor,
+                x, b, y)
+            return dx
+
+        @staticmethod
+        def backward(ctx, d_dx): # pylint: disable=arguments-differ
+            d_dx = d_dx.contiguous(memory_format=ctx.memory_format)
+            dy, x, b, y = ctx.saved_tensors
+            d_dy = None
+            d_x = None
+            d_b = None
+            d_y = None
+
+            if ctx.needs_input_grad[0]:
+                d_dy = BiasActCudaGrad.apply(d_dx, x, b, y)
+
+            if spec.has_2nd_grad and (ctx.needs_input_grad[1] or ctx.needs_input_grad[2]):
+                d_x = _plugin.bias_act(d_dx, b, x, y, dy, 2, dim, spec.cuda_idx, alpha, gain, clamp)
+
+            if spec.has_2nd_grad and ctx.needs_input_grad[2]:
+                d_b = d_x.sum([i for i in range(d_x.ndim) if i != dim])
+
+            return d_dy, d_x, d_b, d_y
+
+    # Add to cache.
+    _bias_act_cuda_cache[key] = BiasActCuda
+    return BiasActCuda
+
+#----------------------------------------------------------------------------

pix2pix3D-main/pix2pix3D-main/torch_utils/ops/conv2d_gradfix.py

@@ -0,0 +1,199 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+"""Custom replacement for `torch.nn.functional.conv2d` that supports
+arbitrarily high order gradients with zero performance penalty."""
+
+import contextlib
+import torch
+
+# pylint: disable=redefined-builtin
+# pylint: disable=arguments-differ
+# pylint: disable=protected-access
+
+#----------------------------------------------------------------------------
+
+enabled = False                     # Enable the custom op by setting this to true.
+weight_gradients_disabled = False   # Forcefully disable computation of gradients with respect to the weights.
+
+@contextlib.contextmanager
+def no_weight_gradients(disable=True):
+    global weight_gradients_disabled
+    old = weight_gradients_disabled
+    if disable:
+        weight_gradients_disabled = True
+    yield
+    weight_gradients_disabled = old
+
+#----------------------------------------------------------------------------
+
+def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
+    if _should_use_custom_op(input):
+        return _conv2d_gradfix(transpose=False, weight_shape=weight.shape, stride=stride, padding=padding, output_padding=0, dilation=dilation, groups=groups).apply(input, weight, bias)
+    return torch.nn.functional.conv2d(input=input, weight=weight, bias=bias, stride=stride, padding=padding, dilation=dilation, groups=groups)
+
+def conv_transpose2d(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1):
+    if _should_use_custom_op(input):
+        return _conv2d_gradfix(transpose=True, weight_shape=weight.shape, stride=stride, padding=padding, output_padding=output_padding, groups=groups, dilation=dilation).apply(input, weight, bias)
+    return torch.nn.functional.conv_transpose2d(input=input, weight=weight, bias=bias, stride=stride, padding=padding, output_padding=output_padding, groups=groups, dilation=dilation)
+
+#----------------------------------------------------------------------------
+
+def _should_use_custom_op(input):
+    assert isinstance(input, torch.Tensor)
+    if (not enabled) or (not torch.backends.cudnn.enabled):
+        return False
+    if input.device.type != 'cuda':
+        return False
+    return True
+
+def _tuple_of_ints(xs, ndim):
+    xs = tuple(xs) if isinstance(xs, (tuple, list)) else (xs,) * ndim
+    assert len(xs) == ndim
+    assert all(isinstance(x, int) for x in xs)
+    return xs
+
+#----------------------------------------------------------------------------
+
+_conv2d_gradfix_cache = dict()
+_null_tensor = torch.empty([0])
+
+def _conv2d_gradfix(transpose, weight_shape, stride, padding, output_padding, dilation, groups):
+    # Parse arguments.
+    ndim = 2
+    weight_shape = tuple(weight_shape)
+    stride = _tuple_of_ints(stride, ndim)
+    padding = _tuple_of_ints(padding, ndim)
+    output_padding = _tuple_of_ints(output_padding, ndim)
+    dilation = _tuple_of_ints(dilation, ndim)
+
+    # Lookup from cache.
+    key = (transpose, weight_shape, stride, padding, output_padding, dilation, groups)
+    if key in _conv2d_gradfix_cache:
+        return _conv2d_gradfix_cache[key]
+
+    # Validate arguments.
+    assert groups >= 1
+    assert len(weight_shape) == ndim + 2
+    assert all(stride[i] >= 1 for i in range(ndim))
+    assert all(padding[i] >= 0 for i in range(ndim))
+    assert all(dilation[i] >= 0 for i in range(ndim))
+    if not transpose:
+        assert all(output_padding[i] == 0 for i in range(ndim))
+    else: # transpose
+        assert all(0 <= output_padding[i] < max(stride[i], dilation[i]) for i in range(ndim))
+
+    # Helpers.
+    common_kwargs = dict(stride=stride, padding=padding, dilation=dilation, groups=groups)
+    def calc_output_padding(input_shape, output_shape):
+        if transpose:
+            return [0, 0]
+        return [
+            input_shape[i + 2]
+            - (output_shape[i + 2] - 1) * stride[i]
+            - (1 - 2 * padding[i])
+            - dilation[i] * (weight_shape[i + 2] - 1)
+            for i in range(ndim)
+        ]
+
+    # Forward & backward.
+    class Conv2d(torch.autograd.Function):
+        @staticmethod
+        def forward(ctx, input, weight, bias):
+            assert weight.shape == weight_shape
+            ctx.save_for_backward(
+                input if weight.requires_grad else _null_tensor,
+                weight if input.requires_grad else _null_tensor,
+            )
+            ctx.input_shape = input.shape
+
+            # Simple 1x1 convolution => cuBLAS (only on Volta, not on Ampere).
+            if weight_shape[2:] == stride == dilation == (1, 1) and padding == (0, 0) and torch.cuda.get_device_capability(input.device) < (8, 0):
+                a = weight.reshape(groups, weight_shape[0] // groups, weight_shape[1])
+                b = input.reshape(input.shape[0], groups, input.shape[1] // groups, -1)
+                c = (a.transpose(1, 2) if transpose else a) @ b.permute(1, 2, 0, 3).flatten(2)
+                c = c.reshape(-1, input.shape[0], *input.shape[2:]).transpose(0, 1)
+                c = c if bias is None else c + bias.unsqueeze(0).unsqueeze(2).unsqueeze(3)
+                return c.contiguous(memory_format=(torch.channels_last if input.stride(1) == 1 else torch.contiguous_format))
+
+            # General case => cuDNN.
+            if transpose:
+                return torch.nn.functional.conv_transpose2d(input=input, weight=weight, bias=bias, output_padding=output_padding, **common_kwargs)
+            return torch.nn.functional.conv2d(input=input, weight=weight, bias=bias, **common_kwargs)
+
+        @staticmethod
+        def backward(ctx, grad_output):
+            input, weight = ctx.saved_tensors
+            input_shape = ctx.input_shape
+            grad_input = None
+            grad_weight = None
+            grad_bias = None
+
+            if ctx.needs_input_grad[0]:
+                p = calc_output_padding(input_shape=input_shape, output_shape=grad_output.shape)
+                op = _conv2d_gradfix(transpose=(not transpose), weight_shape=weight_shape, output_padding=p, **common_kwargs)
+                grad_input = op.apply(grad_output, weight, None)
+                assert grad_input.shape == input_shape
+
+            if ctx.needs_input_grad[1] and not weight_gradients_disabled:
+                grad_weight = Conv2dGradWeight.apply(grad_output, input, weight)
+                assert grad_weight.shape == weight_shape
+
+            if ctx.needs_input_grad[2]:
+                grad_bias = grad_output.sum([0, 2, 3])
+
+            return grad_input, grad_weight, grad_bias
+
+    # Gradient with respect to the weights.
+    class Conv2dGradWeight(torch.autograd.Function):
+        @staticmethod
+        def forward(ctx, grad_output, input, weight):
+            ctx.save_for_backward(
+                grad_output if input.requires_grad else _null_tensor,
+                input if grad_output.requires_grad else _null_tensor,
+            )
+            ctx.grad_output_shape = grad_output.shape
+            ctx.input_shape = input.shape
+
+            # Simple 1x1 convolution => cuBLAS (on both Volta and Ampere).
+            if weight_shape[2:] == stride == dilation == (1, 1) and padding == (0, 0):
+                a = grad_output.reshape(grad_output.shape[0], groups, grad_output.shape[1] // groups, -1).permute(1, 2, 0, 3).flatten(2)
+                b = input.reshape(input.shape[0], groups, input.shape[1] // groups, -1).permute(1, 2, 0, 3).flatten(2)
+                c = (b @ a.transpose(1, 2) if transpose else a @ b.transpose(1, 2)).reshape(weight_shape)
+                return c.contiguous(memory_format=(torch.channels_last if input.stride(1) == 1 else torch.contiguous_format))
+
+            # General case => cuDNN.
+            return torch.ops.aten.convolution_backward(grad_output=grad_output, input=input, weight=weight, bias_sizes=None, stride=stride, padding=padding, dilation=dilation, transposed=transpose, output_padding=output_padding, groups=groups, output_mask=[False, True, False])[1]
+
+
+        @staticmethod
+        def backward(ctx, grad2_grad_weight):
+            grad_output, input = ctx.saved_tensors
+            grad_output_shape = ctx.grad_output_shape
+            input_shape = ctx.input_shape
+            grad2_grad_output = None
+            grad2_input = None
+
+            if ctx.needs_input_grad[0]:
+                grad2_grad_output = Conv2d.apply(input, grad2_grad_weight, None)
+                assert grad2_grad_output.shape == grad_output_shape
+
+            if ctx.needs_input_grad[1]:
+                p = calc_output_padding(input_shape=input_shape, output_shape=grad_output_shape)
+                op = _conv2d_gradfix(transpose=(not transpose), weight_shape=weight_shape, output_padding=p, **common_kwargs)
+                grad2_input = op.apply(grad_output, grad2_grad_weight, None)
+                assert grad2_input.shape == input_shape
+
+            return grad2_grad_output, grad2_input
+
+    _conv2d_gradfix_cache[key] = Conv2d
+    return Conv2d
+
+#----------------------------------------------------------------------------