From 49fed463a2c612a905cfb63ec28b4f9754881866 Mon Sep 17 00:00:00 2001
From: MrForExample <62230687+MrForExample@users.noreply.github.com>
Date: Fri, 12 Jan 2024 21:43:44 +0100
Subject: [PATCH] Add Deep Marching Tetrahedra (DMTet)
---
README.md | 8 +-
.../Images_to_3DGS_to_DMTetMesh.json | 602 ++++++++++++++++++
.../Load_3DGS_to_DMTetMesh.json | 190 ++++++
algorithms/_Test.py | 8 +
.../diff_mesh_renderer.py | 0
{diff_rast => algorithms}/diff_texturing.py | 36 +-
algorithms/dmtet.py | 271 ++++++++
algorithms/dmtet_network.py | 93 +++
.../main_3DGS.py | 39 +-
.../main_3DGS_renderer.py | 57 +-
algorithms/metrics_utils.py | 9 +
algorithms/tetmesh.py | 165 +++++
data/samples_tets/128_tets_0.npz | Bin 0 -> 2070272 bytes
data/samples_tets/128_tets_1.npz | Bin 0 -> 1917273 bytes
data/samples_tets/128_tets_2.npz | Bin 0 -> 1932682 bytes
data/samples_tets/128_tets_3.npz | Bin 0 -> 1797870 bytes
data/samples_tets/128_verts.npz | Bin 0 -> 610391 bytes
data/tets/128_tets.npz | Bin 0 -> 7884982 bytes
data/tets/32_tets.npz | Bin 0 -> 156364 bytes
data/tets/64_tets.npz | Bin 0 -> 949934 bytes
diff_rast/__init__.py | 0
mesh_processer/mesh.py | 30 +-
mesh_processer/mesh_utils.py | 152 +++++
nodes.py | 232 +++++--
24 files changed, 1773 insertions(+), 119 deletions(-)
create mode 100644 _Example_Workflows/Images_to_3DGS_to_DMTetMesh.json
create mode 100644 _Example_Workflows/Load_3DGS_to_DMTetMesh.json
create mode 100644 algorithms/_Test.py
rename {diff_rast => algorithms}/diff_mesh_renderer.py (100%)
rename {diff_rast => algorithms}/diff_texturing.py (93%)
create mode 100644 algorithms/dmtet.py
create mode 100644 algorithms/dmtet_network.py
rename {gaussian_splatting => algorithms}/main_3DGS.py (97%)
rename {gaussian_splatting => algorithms}/main_3DGS_renderer.py (96%)
create mode 100644 algorithms/metrics_utils.py
create mode 100644 algorithms/tetmesh.py
create mode 100644 data/samples_tets/128_tets_0.npz
create mode 100644 data/samples_tets/128_tets_1.npz
create mode 100644 data/samples_tets/128_tets_2.npz
create mode 100644 data/samples_tets/128_tets_3.npz
create mode 100644 data/samples_tets/128_verts.npz
create mode 100644 data/tets/128_tets.npz
create mode 100644 data/tets/32_tets.npz
create mode 100644 data/tets/64_tets.npz
delete mode 100644 diff_rast/__init__.py
diff --git a/README.md b/README.md
index 392a4ef..6e4c31e 100644
--- a/README.md
+++ b/README.md
@@ -72,6 +72,7 @@ Copy the files inside folder [__New_ComfyUI_Bats](./_New_ComfyUI_Bats/) to your
- Load 3D file (.obj, .ply, .glb)
+ - Also have node that support save and load 3DGS .ply file
- 3D Gaussian Splatting, with:
- [Improved Differential Gaussian Rasterization](https://github.com/ashawkey/diff-gaussian-rasterization)
- Better Compactness-based Densification method from [Gsgen](https://gsgen3d.github.io/),
@@ -83,9 +84,14 @@ Copy the files inside folder [__New_ComfyUI_Bats](./_New_ComfyUI_Bats/) to your
- Bake Multi-View images into UVTexture of given 3D mesh using [Nvdiffrast](https://github.com/NVlabs/nvdiffrast), supports:
- Export to .obj, .ply, .glb
+- Deep Marching Tetrahedrons
+ - Allow convert 3DGS .ply file to 3D mesh
+ *Note: I didn't spent time to turn the hyperprameters yet, the result will be improved in the future!*
+
### To-Do Next:
- Add interactive 3D UI inside ComfuUI to visulaize training and generated results for 3D representations
-- Add DMTet algorithm to allow convertion from points cloud(Gaussian/.ply) to mesh (.obj, .ply, .glb)
+- ~~Add DMTet algorithm to allow convertion from points cloud(Gaussian/.ply) to mesh (.obj, .ply, .glb)~~
+- Improve DMTet result & add support to training it with images(RGB, Alpha, Normal Map)
- Add a general SDS/VSD Optimization algorithm to allow training 3D representations with diffusion model, *The real fun begins here* ;)
- Add a few best Nerf algorithms (No idea yet, [instant-ngp](https://github.com/NVlabs/instant-ngp) maybe?)
diff --git a/_Example_Workflows/Images_to_3DGS_to_DMTetMesh.json b/_Example_Workflows/Images_to_3DGS_to_DMTetMesh.json
new file mode 100644
index 0000000..09df809
--- /dev/null
+++ b/_Example_Workflows/Images_to_3DGS_to_DMTetMesh.json
@@ -0,0 +1,602 @@
+{
+ "last_node_id": 22,
+ "last_link_id": 26,
+ "nodes": [
+ {
+ "id": 10,
+ "type": "PreviewImage",
+ "pos": [
+ 1410,
+ -320
+ ],
+ "size": {
+ "0": 210,
+ "1": 246
+ },
+ "flags": {},
+ "order": 7,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "images",
+ "type": "IMAGE",
+ "link": 4
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "PreviewImage"
+ }
+ },
+ {
+ "id": 9,
+ "type": "MaskToImage",
+ "pos": [
+ 1110,
+ -320
+ ],
+ "size": {
+ "0": 210,
+ "1": 26
+ },
+ "flags": {},
+ "order": 5,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "mask",
+ "type": "MASK",
+ "link": 8
+ }
+ ],
+ "outputs": [
+ {
+ "name": "IMAGE",
+ "type": "IMAGE",
+ "links": [
+ 4
+ ],
+ "shape": 3,
+ "slot_index": 0
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "MaskToImage"
+ }
+ },
+ {
+ "id": 8,
+ "type": "InvertMask",
+ "pos": [
+ 746,
+ -14
+ ],
+ "size": {
+ "0": 210,
+ "1": 26
+ },
+ "flags": {},
+ "order": 4,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "mask",
+ "type": "MASK",
+ "link": 2
+ }
+ ],
+ "outputs": [
+ {
+ "name": "MASK",
+ "type": "MASK",
+ "links": [
+ 8,
+ 18
+ ],
+ "shape": 3,
+ "slot_index": 0
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "InvertMask"
+ }
+ },
+ {
+ "id": 4,
+ "type": "[ComfyUI-3D] Generate Orbit Camera Poses",
+ "pos": [
+ 830,
+ 132
+ ],
+ "size": {
+ "0": 400,
+ "1": 200
+ },
+ "flags": {},
+ "order": 2,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "reference_images",
+ "type": "IMAGE",
+ "link": 1
+ }
+ ],
+ "outputs": [
+ {
+ "name": "orbit_camposes",
+ "type": "ORBIT_CAMPOSES",
+ "links": [
+ 19
+ ],
+ "shape": 3,
+ "slot_index": 0
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "[ComfyUI-3D] Generate Orbit Camera Poses"
+ },
+ "widgets_values": [
+ "([0:120], 1.75, 0, 0, 360)"
+ ]
+ },
+ {
+ "id": 7,
+ "type": "VHS_LoadImages",
+ "pos": [
+ 113,
+ 54
+ ],
+ "size": [
+ 243.60000610351562,
+ 194
+ ],
+ "flags": {},
+ "order": 0,
+ "mode": 0,
+ "outputs": [
+ {
+ "name": "IMAGE",
+ "type": "IMAGE",
+ "links": [
+ 1,
+ 17,
+ 22
+ ],
+ "shape": 3,
+ "slot_index": 0
+ },
+ {
+ "name": "MASK",
+ "type": "MASK",
+ "links": [
+ 2
+ ],
+ "shape": 3,
+ "slot_index": 1
+ },
+ {
+ "name": "INT",
+ "type": "INT",
+ "links": null,
+ "shape": 3
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "VHS_LoadImages"
+ },
+ "widgets_values": {
+ "directory": "Images_enhanced",
+ "image_load_cap": 0,
+ "skip_first_images": 0,
+ "select_every_nth": 1,
+ "choose folder to upload": "image",
+ "videopreview": {
+ "hidden": false,
+ "paused": false,
+ "params": {
+ "frame_load_cap": 0,
+ "skip_first_images": 0,
+ "filename": "Images_enhanced",
+ "type": "input",
+ "format": "folder",
+ "select_every_nth": 1
+ }
+ }
+ }
+ },
+ {
+ "id": 19,
+ "type": "PreviewImage",
+ "pos": [
+ 420,
+ -320
+ ],
+ "size": {
+ "0": 210,
+ "1": 246
+ },
+ "flags": {},
+ "order": 3,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "images",
+ "type": "IMAGE",
+ "link": 22
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "PreviewImage"
+ }
+ },
+ {
+ "id": 18,
+ "type": "[ComfyUI-3D] Gaussian Splatting",
+ "pos": [
+ 1486,
+ 53
+ ],
+ "size": {
+ "0": 468.5999755859375,
+ "1": 718
+ },
+ "flags": {
+ "collapsed": false
+ },
+ "order": 6,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "reference_images",
+ "type": "IMAGE",
+ "link": 17
+ },
+ {
+ "name": "reference_masks",
+ "type": "MASK",
+ "link": 18
+ },
+ {
+ "name": "reference_orbit_camera_poses",
+ "type": "ORBIT_CAMPOSES",
+ "link": 19
+ },
+ {
+ "name": "mesh_to_initialize_gaussian",
+ "type": "MESH",
+ "link": null
+ }
+ ],
+ "outputs": [
+ {
+ "name": "raw_3DGS",
+ "type": "GS_RAW",
+ "links": [
+ 21,
+ 24
+ ],
+ "shape": 3,
+ "slot_index": 0
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "[ComfyUI-3D] Gaussian Splatting"
+ },
+ "widgets_values": [
+ 49.1,
+ 1000,
+ 1,
+ 10000,
+ 0.2,
+ 3,
+ 0,
+ 0,
+ 0.5,
+ 0.01,
+ 0.05,
+ 0.005,
+ 0.005,
+ 0.001,
+ 0.00002,
+ 0.02,
+ 500,
+ 5000,
+ 3,
+ 0.01,
+ 100,
+ 100000,
+ 100,
+ 700,
+ 0.01,
+ 0
+ ]
+ },
+ {
+ "id": 17,
+ "type": "[ComfyUI-3D] Save 3DGS",
+ "pos": [
+ 2243,
+ 52
+ ],
+ "size": {
+ "0": 315,
+ "1": 58
+ },
+ "flags": {},
+ "order": 8,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "raw_3DGS",
+ "type": "GS_RAW",
+ "link": 21
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "[ComfyUI-3D] Save 3DGS"
+ },
+ "widgets_values": [
+ "MeshTest\\3DGS_01.ply"
+ ]
+ },
+ {
+ "id": 20,
+ "type": "[ComfyUI-3D] Convert 3DGS To Pointcloud",
+ "pos": [
+ 2242,
+ 251
+ ],
+ "size": {
+ "0": 267,
+ "1": 26
+ },
+ "flags": {},
+ "order": 9,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "raw_3DGS",
+ "type": "GS_RAW",
+ "link": 24
+ }
+ ],
+ "outputs": [
+ {
+ "name": "points_cloud",
+ "type": "POINTCLOUD",
+ "links": [
+ 25
+ ],
+ "shape": 3,
+ "slot_index": 0
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "[ComfyUI-3D] Convert 3DGS To Pointcloud"
+ }
+ },
+ {
+ "id": 13,
+ "type": "[ComfyUI-3D] Load 3D Mesh",
+ "pos": [
+ 1053,
+ 415
+ ],
+ "size": {
+ "0": 315,
+ "1": 154
+ },
+ "flags": {},
+ "order": 1,
+ "mode": 0,
+ "outputs": [
+ {
+ "name": "mesh",
+ "type": "MESH",
+ "links": [],
+ "shape": 3,
+ "slot_index": 0
+ }
+ ],
+ "title": "Load 3D Mesh [Optional]",
+ "properties": {
+ "Node name for S&R": "[ComfyUI-3D] Load 3D Mesh"
+ },
+ "widgets_values": [
+ "Meshes\\Cammy_Uniform.obj",
+ false,
+ true,
+ false,
+ false
+ ]
+ },
+ {
+ "id": 22,
+ "type": "[ComfyUI-3D] Save 3D Mesh",
+ "pos": [
+ 3261,
+ 55
+ ],
+ "size": {
+ "0": 353.38916015625,
+ "1": 61.879417419433594
+ },
+ "flags": {},
+ "order": 11,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "mesh",
+ "type": "MESH",
+ "link": 26
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "[ComfyUI-3D] Save 3D Mesh"
+ },
+ "widgets_values": [
+ "MeshTest\\Cammy_Uniform_DMTet_01.obj"
+ ]
+ },
+ {
+ "id": 21,
+ "type": "[ComfyUI-3D] Deep Marching Tetrahedrons",
+ "pos": [
+ 2710,
+ 56
+ ],
+ "size": {
+ "0": 443.4000244140625,
+ "1": 314
+ },
+ "flags": {},
+ "order": 10,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "reference_points_cloud",
+ "type": "POINTCLOUD",
+ "link": 25
+ },
+ {
+ "name": "reference_images",
+ "type": "IMAGE",
+ "link": null
+ },
+ {
+ "name": "reference_masks",
+ "type": "MASK",
+ "link": null
+ }
+ ],
+ "outputs": [
+ {
+ "name": "trained_mesh",
+ "type": "MESH",
+ "links": [
+ 26
+ ],
+ "shape": 3,
+ "slot_index": 0
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "[ComfyUI-3D] Deep Marching Tetrahedrons"
+ },
+ "widgets_values": [
+ 5000,
+ 1,
+ 0.1,
+ 1,
+ 1,
+ 128,
+ 0.0001,
+ 2,
+ 128,
+ 5
+ ]
+ }
+ ],
+ "links": [
+ [
+ 1,
+ 7,
+ 0,
+ 4,
+ 0,
+ "IMAGE"
+ ],
+ [
+ 2,
+ 7,
+ 1,
+ 8,
+ 0,
+ "MASK"
+ ],
+ [
+ 4,
+ 9,
+ 0,
+ 10,
+ 0,
+ "IMAGE"
+ ],
+ [
+ 8,
+ 8,
+ 0,
+ 9,
+ 0,
+ "MASK"
+ ],
+ [
+ 17,
+ 7,
+ 0,
+ 18,
+ 0,
+ "IMAGE"
+ ],
+ [
+ 18,
+ 8,
+ 0,
+ 18,
+ 1,
+ "MASK"
+ ],
+ [
+ 19,
+ 4,
+ 0,
+ 18,
+ 2,
+ "ORBIT_CAMPOSES"
+ ],
+ [
+ 21,
+ 18,
+ 0,
+ 17,
+ 0,
+ "GS_RAW"
+ ],
+ [
+ 22,
+ 7,
+ 0,
+ 19,
+ 0,
+ "IMAGE"
+ ],
+ [
+ 24,
+ 18,
+ 0,
+ 20,
+ 0,
+ "GS_RAW"
+ ],
+ [
+ 25,
+ 20,
+ 0,
+ 21,
+ 0,
+ "POINTCLOUD"
+ ],
+ [
+ 26,
+ 21,
+ 0,
+ 22,
+ 0,
+ "MESH"
+ ]
+ ],
+ "groups": [],
+ "config": {},
+ "extra": {},
+ "version": 0.4
+}
\ No newline at end of file
diff --git a/_Example_Workflows/Load_3DGS_to_DMTetMesh.json b/_Example_Workflows/Load_3DGS_to_DMTetMesh.json
new file mode 100644
index 0000000..06e2fab
--- /dev/null
+++ b/_Example_Workflows/Load_3DGS_to_DMTetMesh.json
@@ -0,0 +1,190 @@
+{
+ "last_node_id": 4,
+ "last_link_id": 3,
+ "nodes": [
+ {
+ "id": 2,
+ "type": "[ComfyUI-3D] Convert 3DGS To Pointcloud",
+ "pos": [
+ 561,
+ 484
+ ],
+ "size": {
+ "0": 267,
+ "1": 26
+ },
+ "flags": {},
+ "order": 1,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "raw_3DGS",
+ "type": "GS_RAW",
+ "link": 1
+ }
+ ],
+ "outputs": [
+ {
+ "name": "points_cloud",
+ "type": "POINTCLOUD",
+ "links": [
+ 2
+ ],
+ "shape": 3,
+ "slot_index": 0
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "[ComfyUI-3D] Convert 3DGS To Pointcloud"
+ }
+ },
+ {
+ "id": 1,
+ "type": "[ComfyUI-3D] Load 3DGS",
+ "pos": [
+ 166,
+ 484
+ ],
+ "size": {
+ "0": 315,
+ "1": 58
+ },
+ "flags": {},
+ "order": 0,
+ "mode": 0,
+ "outputs": [
+ {
+ "name": "raw_3DGS",
+ "type": "GS_RAW",
+ "links": [
+ 1
+ ],
+ "shape": 3,
+ "slot_index": 0
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "[ComfyUI-3D] Load 3DGS"
+ },
+ "widgets_values": [
+ "Meshes\\Generated\\Cammy_Uniform_3DGS_01.ply"
+ ]
+ },
+ {
+ "id": 4,
+ "type": "[ComfyUI-3D] Save 3D Mesh",
+ "pos": [
+ 1446,
+ 485
+ ],
+ "size": {
+ "0": 315,
+ "1": 58
+ },
+ "flags": {},
+ "order": 3,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "mesh",
+ "type": "MESH",
+ "link": 3
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "[ComfyUI-3D] Save 3D Mesh"
+ },
+ "widgets_values": [
+ "MeshTest\\Cammy_Uniform_DMTet_01.obj"
+ ]
+ },
+ {
+ "id": 3,
+ "type": "[ComfyUI-3D] Deep Marching Tetrahedrons",
+ "pos": [
+ 913,
+ 484
+ ],
+ "size": {
+ "0": 443.4000244140625,
+ "1": 314
+ },
+ "flags": {},
+ "order": 2,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "reference_points_cloud",
+ "type": "POINTCLOUD",
+ "link": 2
+ },
+ {
+ "name": "reference_images",
+ "type": "IMAGE",
+ "link": null
+ },
+ {
+ "name": "reference_masks",
+ "type": "MASK",
+ "link": null
+ }
+ ],
+ "outputs": [
+ {
+ "name": "trained_mesh",
+ "type": "MESH",
+ "links": [
+ 3
+ ],
+ "shape": 3,
+ "slot_index": 0
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "[ComfyUI-3D] Deep Marching Tetrahedrons"
+ },
+ "widgets_values": [
+ 5000,
+ 1,
+ 0.1,
+ 1,
+ 1,
+ 128,
+ 0.0001,
+ 2,
+ 128,
+ 5
+ ]
+ }
+ ],
+ "links": [
+ [
+ 1,
+ 1,
+ 0,
+ 2,
+ 0,
+ "GS_RAW"
+ ],
+ [
+ 2,
+ 2,
+ 0,
+ 3,
+ 0,
+ "POINTCLOUD"
+ ],
+ [
+ 3,
+ 3,
+ 0,
+ 4,
+ 0,
+ "MESH"
+ ]
+ ],
+ "groups": [],
+ "config": {},
+ "extra": {},
+ "version": 0.4
+}
\ No newline at end of file
diff --git a/algorithms/_Test.py b/algorithms/_Test.py
new file mode 100644
index 0000000..3d5a616
--- /dev/null
+++ b/algorithms/_Test.py
@@ -0,0 +1,8 @@
+import os
+import numpy as np
+import torch
+
+grid_res = 128
+p = os.path.join(os.path.dirname(__file__), f'../data/tets/{grid_res}_tets.npz')
+print(p)
+
diff --git a/diff_rast/diff_mesh_renderer.py b/algorithms/diff_mesh_renderer.py
similarity index 100%
rename from diff_rast/diff_mesh_renderer.py
rename to algorithms/diff_mesh_renderer.py
diff --git a/diff_rast/diff_texturing.py b/algorithms/diff_texturing.py
similarity index 93%
rename from diff_rast/diff_texturing.py
rename to algorithms/diff_texturing.py
index 2dff5e3..0f559c2 100644
--- a/diff_rast/diff_texturing.py
+++ b/algorithms/diff_texturing.py
@@ -6,25 +6,14 @@ import torch.nn.functional as F
import numpy as np
from pytorch_msssim import SSIM, MS_SSIM
-from ..diff_rast.diff_mesh_renderer import Renderer
+from .diff_mesh_renderer import Renderer
from ..shared_utils.camera_utils import orbit_camera, OrbitCamera
class DiffTextureBaker:
- def __init__(self, reference_images, reference_masks, reference_orbit_camera_poses, reference_orbit_camera_fovy, mesh,
- training_iterations, batch_size, texture_learning_rate, train_mesh_geometry, geometry_learning_rate, ms_ssim_loss_weight, force_cuda_rasterize):
+ def __init__(self, mesh, training_iterations, batch_size, texture_learning_rate, train_mesh_geometry, geometry_learning_rate, ms_ssim_loss_weight, force_cuda_rasterize):
self.device = torch.device("cuda")
- self.ref_imgs_num = len(reference_images)
-
- self.all_ref_cam_poses = reference_orbit_camera_poses
- self.ref_cam_fovy = reference_orbit_camera_fovy
-
- self.ref_size_H = reference_images[0].shape[0]
- self.ref_size_W = reference_images[0].shape[1]
-
- self.cam = OrbitCamera(self.ref_size_W, self.ref_size_H, fovy=reference_orbit_camera_fovy)
-
# prepare main components for optimization
self.renderer = Renderer(mesh, force_cuda_rasterize).to(self.device)
@@ -36,6 +25,22 @@ class DiffTextureBaker:
self.training_iterations = training_iterations
self.batch_size = batch_size
+
+ def prepare_img(self, img):
+ img_new = img.permute(2, 0, 1).unsqueeze(0).to(self.device)
+ img_new = F.interpolate(img_new, (self.ref_size_H, self.ref_size_W), mode="bilinear", align_corners=False).contiguous()
+ return img_new
+
+ def prepare_training(self, reference_images, reference_masks, reference_orbit_camera_poses, reference_orbit_camera_fovy):
+ self.ref_imgs_num = len(reference_images)
+
+ self.all_ref_cam_poses = reference_orbit_camera_poses
+ self.ref_cam_fovy = reference_orbit_camera_fovy
+
+ self.ref_size_H = reference_images[0].shape[0]
+ self.ref_size_W = reference_images[0].shape[1]
+
+ self.cam = OrbitCamera(self.ref_size_W, self.ref_size_H, fovy=reference_orbit_camera_fovy)
# prepare reference images and masks
ref_imgs_torch_list = []
@@ -47,11 +52,6 @@ class DiffTextureBaker:
self.ref_imgs_torch = torch.cat(ref_imgs_torch_list, dim=0)
self.ref_masks_torch = torch.cat(ref_masks_torch_list, dim=0)
- def prepare_img(self, img):
- img_new = img.permute(2, 0, 1).unsqueeze(0).to(self.device)
- img_new = F.interpolate(img_new, (self.ref_size_H, self.ref_size_W), mode="bilinear", align_corners=False).contiguous()
- return img_new
-
def training(self):
starter = torch.cuda.Event(enable_timing=True)
ender = torch.cuda.Event(enable_timing=True)
diff --git a/algorithms/dmtet.py b/algorithms/dmtet.py
new file mode 100644
index 0000000..6f68258
--- /dev/null
+++ b/algorithms/dmtet.py
@@ -0,0 +1,271 @@
+import os
+import tqdm
+
+import numpy as np
+import torch
+from pytorch3d.loss import chamfer_distance, mesh_laplacian_smoothing
+from pytorch3d.structures.meshes import Meshes
+
+from ..mesh_processer.mesh import Mesh
+from ..mesh_processer.mesh_utils import sample_points
+from .dmtet_network import Decoder
+
+# Deep Marching Tetrahedrons implementation, adapted from
+# https://github.com/NVIDIAGameWorks/kaolin/blob/master/kaolin/ops/conversions/tetmesh.py
+class DMTet:
+ def __init__(self, device='cuda'):
+ self.device = device
+ self.triangle_table = torch.tensor([
+ [-1, -1, -1, -1, -1, -1],
+ [ 1, 0, 2, -1, -1, -1],
+ [ 4, 0, 3, -1, -1, -1],
+ [ 1, 4, 2, 1, 3, 4],
+ [ 3, 1, 5, -1, -1, -1],
+ [ 2, 3, 0, 2, 5, 3],
+ [ 1, 4, 0, 1, 5, 4],
+ [ 4, 2, 5, -1, -1, -1],
+ [ 4, 5, 2, -1, -1, -1],
+ [ 4, 1, 0, 4, 5, 1],
+ [ 3, 2, 0, 3, 5, 2],
+ [ 1, 3, 5, -1, -1, -1],
+ [ 4, 1, 2, 4, 3, 1],
+ [ 3, 0, 4, -1, -1, -1],
+ [ 2, 0, 1, -1, -1, -1],
+ [-1, -1, -1, -1, -1, -1]
+ ], dtype=torch.long, device=self.device)
+
+ self.num_triangles_table = torch.tensor([0,1,1,2,1,2,2,1,1,2,2,1,2,1,1,0], dtype=torch.long, device=self.device)
+ self.base_tet_edges = torch.tensor([0,1,0,2,0,3,1,2,1,3,2,3], dtype=torch.long, device=self.device)
+
+ # Utility functions
+ def sort_edges(self, edges_ex2):
+ with torch.no_grad():
+ order = (edges_ex2[:,0] > edges_ex2[:,1]).long()
+ order = order.unsqueeze(dim=1)
+
+ a = torch.gather(input=edges_ex2, index=order, dim=1)
+ b = torch.gather(input=edges_ex2, index=1-order, dim=1)
+
+ return torch.stack([a, b],-1)
+
+ def map_uv(self, faces, face_gidx, max_idx):
+ N = int(np.ceil(np.sqrt((max_idx+1)//2)))
+ tex_y, tex_x = torch.meshgrid(
+ torch.linspace(0, 1 - (1 / N), N, dtype=torch.float32, device="cuda"),
+ torch.linspace(0, 1 - (1 / N), N, dtype=torch.float32, device="cuda"),
+ indexing='ij'
+ )
+
+ pad = 0.9 / N
+
+ uvs = torch.stack([
+ tex_x , tex_y,
+ tex_x + pad, tex_y,
+ tex_x + pad, tex_y + pad,
+ tex_x , tex_y + pad
+ ], dim=-1).view(-1, 2)
+
+ def _idx(tet_idx, N):
+ x = tet_idx % N
+ y = torch.div(tet_idx, N, rounding_mode='trunc')
+ return y * N + x
+
+ tet_idx = _idx(torch.div(face_gidx, 2, rounding_mode='trunc'), N)
+ tri_idx = face_gidx % 2
+
+ uv_idx = torch.stack((
+ tet_idx * 4, tet_idx * 4 + tri_idx + 1, tet_idx * 4 + tri_idx + 2
+ ), dim = -1). view(-1, 3)
+
+ return uvs, uv_idx
+
+ # Marching tets implementation
+ def __call__(self, vertices, tet, sdf, with_uv=False):
+
+ r"""Convert discrete signed distance fields encoded on tetrahedral grids to triangle
+ meshes using marching tetrahedra algorithm as described in `An efficient method of
+ triangulating equi-valued surfaces by using tetrahedral cells`_. The output surface is differentiable with respect to
+ input vertex positions and the SDF values. For more details and example usage in learning, see
+ `Deep Marching Tetrahedra\: a Hybrid Representation for High-Resolution 3D Shape Synthesis`_ NeurIPS 2021.
+
+
+ Args:
+ vertices (torch.tensor): batched vertices of tetrahedral meshes, of shape
+ : (num_vertices, 3).
+ tets (torch.tensor): unbatched tetrahedral mesh topology, of shape
+ : (num_tetrahedrons, 4).
+ sdf (torch.tensor): batched SDFs which specify the SDF value of each vertex, of shape
+ : (num_vertices).
+ return_tet_idx (optional, bool): if True, return index of tetrahedron
+ where each face is extracted. Default: False.
+
+ Returns:
+ (list[torch.Tensor], list[torch.LongTensor], (optional) list[torch.LongTensor]):
+
+ - the list of vertices for mesh converted from each tetrahedral grid.
+ - the list of faces for mesh converted from each tetrahedral grid.
+ - the list of indices that correspond to tetrahedra where faces are extracted.
+
+ Example:
+ >>> vertices = torch.tensor([[[0, 0, 0],
+ ... [1, 0, 0],
+ ... [0, 1, 0],
+ ... [0, 0, 1]]], dtype=torch.float)
+ >>> tets = torch.tensor([[0, 1, 2, 3]], dtype=torch.long)
+ >>> sdf = torch.tensor([[-1., -1., 0.5, 0.5]], dtype=torch.float)
+ >>> verts_list, faces_list, tet_idx_list = marching_tetrahedra(vertices, tets, sdf, True)
+ >>> verts_list[0]
+ tensor([[0.0000, 0.6667, 0.0000],
+ [0.0000, 0.0000, 0.6667],
+ [0.3333, 0.6667, 0.0000],
+ [0.3333, 0.0000, 0.6667]])
+ >>> faces_list[0]
+ tensor([[3, 0, 1],
+ [3, 2, 0]])
+ >>> tet_idx_list[0]
+ tensor([0, 0])
+
+ .. _An efficient method of triangulating equi-valued surfaces by using tetrahedral cells:
+ https://search.ieice.org/bin/summary.php?id=e74-d_1_214
+
+ .. _Deep Marching Tetrahedra\: a Hybrid Representation for High-Resolution 3D Shape Synthesis:
+ https://arxiv.org/abs/2111.04276
+ """
+
+ with torch.no_grad():
+ occ_n = sdf > 0
+ occ_fx4 = occ_n[tet.reshape(-1)].reshape(-1,4)
+ occ_sum = torch.sum(occ_fx4, -1)
+ valid_tets = (occ_sum>0) & (occ_sum<4)
+ occ_sum = occ_sum[valid_tets]
+
+ # find all vertices
+ all_edges = tet[valid_tets][:,self.base_tet_edges].reshape(-1,2)
+ all_edges = self.sort_edges(all_edges)
+ unique_edges, idx_map = torch.unique(all_edges,dim=0, return_inverse=True)
+
+ unique_edges = unique_edges.long()
+ mask_edges = occ_n[unique_edges.reshape(-1)].reshape(-1,2).sum(-1) == 1
+ mapping = torch.ones((unique_edges.shape[0]), dtype=torch.long, device="cuda") * -1
+ mapping[mask_edges] = torch.arange(mask_edges.sum(), dtype=torch.long,device="cuda")
+ idx_map = mapping[idx_map] # map edges to verts
+
+ interp_v = unique_edges[mask_edges]
+ edges_to_interp = vertices[interp_v.reshape(-1)].reshape(-1,2,3)
+ edges_to_interp_sdf = sdf[interp_v.reshape(-1)].reshape(-1,2,1)
+ edges_to_interp_sdf[:,-1] *= -1
+
+ denominator = edges_to_interp_sdf.sum(1,keepdim = True)
+
+ edges_to_interp_sdf = torch.flip(edges_to_interp_sdf, [1])/denominator
+ verts = (edges_to_interp * edges_to_interp_sdf).sum(1)
+
+ idx_map = idx_map.reshape(-1,6)
+
+ v_id = torch.pow(2, torch.arange(4, dtype=torch.long, device="cuda"))
+ tetindex = (occ_fx4[valid_tets] * v_id.unsqueeze(0)).sum(-1)
+ num_triangles = self.num_triangles_table[tetindex]
+
+ # Generate triangle indices
+ faces = torch.cat((
+ torch.gather(input=idx_map[num_triangles == 1], dim=1, index=self.triangle_table[tetindex[num_triangles == 1]][:, :3]).reshape(-1,3),
+ torch.gather(input=idx_map[num_triangles == 2], dim=1, index=self.triangle_table[tetindex[num_triangles == 2]][:, :6]).reshape(-1,3),
+ ), dim=0)
+
+ if with_uv:
+ # Get global face index (static, does not depend on topology)
+ num_tets = tet.shape[0]
+ tet_gidx = torch.arange(num_tets, dtype=torch.long, device="cuda")[valid_tets]
+ face_gidx = torch.cat((
+ tet_gidx[num_triangles == 1]*2,
+ torch.stack((tet_gidx[num_triangles == 2]*2, tet_gidx[num_triangles == 2]*2 + 1), dim=-1).view(-1)
+ ), dim=0)
+
+ uvs, uv_idx = self.map_uv(faces, face_gidx, num_tets*2)
+
+ return verts, faces, uvs, uv_idx
+ else:
+ return verts, faces
+
+# Geometry interface
+class DMTetMesh:
+ def __init__(self, iterations=5000, chamfer_distance_weight=1, laplacian_weight=0.1, chamfer_faces_sample_scale=1, mesh_scale=1.0, grid_res=128, geom_lr=0.0001, multires=2, mlp_internal_dims=128, mlp_hidden_layer_num=5, device='cuda'):
+
+ self.device = torch.device(device)
+ self.chamfer_distance_weight = chamfer_distance_weight
+ self.laplacian_weight = laplacian_weight
+ self.chamfer_faces_sample_scale = chamfer_faces_sample_scale
+ self.iterations = iterations
+ self.grid_res = grid_res
+
+ self.marching_tets = DMTet(device=self.device)
+
+ self.model = Decoder(multires=multires, internal_dims=mlp_internal_dims, hidden=mlp_hidden_layer_num).to(self.device)
+ self.model.pre_train_sphere()
+
+ self.geom_optimizer = torch.optim.Adam(self.model.parameters(), lr=geom_lr)
+ self.geom_scheduler = torch.optim.lr_scheduler.LambdaLR(self.geom_optimizer, lr_lambda=lambda x: self.lr_schedule(x))
+
+ # Load tetrahedral tile, for grid_res==128: verts: torch.Size([277410, 3]), indices: torch.Size([1524684, 4])
+ # Get pre-generated tetrahedral grid from https://github.com/NVlabs/nvdiffrec/tree/main/data/tets
+ tets_path = os.path.join(os.path.dirname(__file__), f'../data/tets/{self.grid_res}_tets.npz')
+ tets = np.load(tets_path)
+ self.verts = torch.tensor(tets['vertices'], dtype=torch.float32, device=self.device) * mesh_scale
+ self.indices = torch.tensor(tets['indices'], dtype=torch.long, device=self.device)
+
+ self.generate_edges()
+
+ def lr_schedule(self, iter):
+ return max(0.0, 10**(-iter*0.0002)) # Exponential falloff from [1.0, 0.1] over 5k epochs.
+
+ def generate_edges(self):
+ with torch.no_grad():
+ edges = torch.tensor([0,1,0,2,0,3,1,2,1,3,2,3], dtype = torch.long, device = "cuda")
+ all_edges = self.indices[:,edges].reshape(-1,2)
+ all_edges_sorted = torch.sort(all_edges, dim=1)[0]
+ self.all_edges = torch.unique(all_edges_sorted, dim=0)
+
+ def get_mesh(self):
+ verts, faces = self.pred_verts_faces()
+ mesh = Mesh(v=verts, f=faces)
+ mesh.auto_normal()
+ mesh.auto_uv()
+ return mesh
+
+ def pred_verts_faces(self):
+ pred = self.model(self.verts) # predict SDF and per-vertex deformation
+ sdf, deform = self.model.get_sdf_and_deform(pred)
+ v_deformed = self.verts + torch.tanh(deform) / self.grid_res # constraint deformation to avoid flipping tets
+ return self.marching_tets(v_deformed, self.indices, sdf)
+
+ def training(self, pcd, ref_imgs, ref_masks):
+
+ allow_ref_points_loss = pcd is not None
+ if allow_ref_points_loss:
+ ref_points_batched = torch.from_numpy(np.asarray(pcd.points)).float().to(self.device).unsqueeze(0)
+
+ allow_imgs_loss = ref_imgs is not None
+ allow_masks_loss = ref_masks is not None
+
+ for step in tqdm.trange(self.iterations):
+
+ loss = 0
+
+ verts, faces = self.pred_verts_faces()
+
+ # chamfer distance loss
+ if allow_ref_points_loss:
+ num_faces_samples = int(self.chamfer_faces_sample_scale * faces.shape[0])
+ sampled_points_per_faces = sample_points(verts.unsqueeze(0), faces, num_faces_samples)[0]
+ loss += self.chamfer_distance_weight * chamfer_distance(sampled_points_per_faces, ref_points_batched)[0].mean()
+
+ # laplacian smoothing regularization loss
+ mesh = Meshes([verts], [faces])
+ loss += self.laplacian_weight * mesh_laplacian_smoothing(mesh)
+
+ # TODO: add images based diffrast loss, i.e (RGB, Alpha, Normal; with L1, SSIM loss)
+
+ loss.backward()
+ self.geom_optimizer.step()
+ self.geom_scheduler.step()
+ self.geom_optimizer.zero_grad()
\ No newline at end of file
diff --git a/algorithms/dmtet_network.py b/algorithms/dmtet_network.py
new file mode 100644
index 0000000..715c950
--- /dev/null
+++ b/algorithms/dmtet_network.py
@@ -0,0 +1,93 @@
+# This script is modified based on: https://github.com/NVIDIAGameWorks/kaolin/blob/5406915c3a020596384b1a36679ff68afd04d455/examples/tutorial/dmtet_network.py
+
+import torch
+from tqdm import tqdm
+
+# MLP + Positional Encoding
+class Decoder(torch.nn.Module):
+ def __init__(self, input_dims = 3, internal_dims = 128, output_dims = 4, hidden = 5, multires = 2):
+ super().__init__()
+ self.embed_fn = None
+ if multires > 0:
+ embed_fn, input_ch = get_embedder(multires)
+ self.embed_fn = embed_fn
+ input_dims = input_ch
+
+ net = (torch.nn.Linear(input_dims, internal_dims, bias=False), torch.nn.ReLU())
+ for i in range(hidden-1):
+ net = net + (torch.nn.Linear(internal_dims, internal_dims, bias=False), torch.nn.ReLU())
+ net = net + (torch.nn.Linear(internal_dims, output_dims, bias=False),)
+ self.net = torch.nn.Sequential(*net)
+
+ def forward(self, p):
+ if self.embed_fn is not None:
+ p = self.embed_fn(p)
+ out = self.net(p)
+ return out
+
+ def get_sdf_and_deform(self, out):
+ return out[:,0], out[:,1:] # sdf, deform
+
+ def pre_train_sphere(self, iter=1000):
+ print ("Initialize SDF to sphere")
+ loss_fn = torch.nn.MSELoss()
+ optimizer = torch.optim.Adam(list(self.parameters()), lr=1e-4)
+
+ for i in tqdm(range(iter)):
+ p = torch.rand((1024,3), device='cuda') - 0.5
+ ref_value = torch.sqrt((p**2).sum(-1)) - 0.3
+ output = self(p)
+ loss = loss_fn(output[...,0], ref_value)
+ optimizer.zero_grad()
+ loss.backward()
+ optimizer.step()
+
+ print("Pre-trained MLP", loss.item())
+
+
+# Positional Encoding from https://github.com/yenchenlin/nerf-pytorch/blob/1f064835d2cca26e4df2d7d130daa39a8cee1795/run_nerf_helpers.py
+class Embedder:
+ def __init__(self, **kwargs):
+ self.kwargs = kwargs
+ self.create_embedding_fn()
+
+ def create_embedding_fn(self):
+ embed_fns = []
+ d = self.kwargs['input_dims']
+ out_dim = 0
+ if self.kwargs['include_input']:
+ embed_fns.append(lambda x : x)
+ out_dim += d
+
+ max_freq = self.kwargs['max_freq_log2']
+ N_freqs = self.kwargs['num_freqs']
+
+ if self.kwargs['log_sampling']:
+ freq_bands = 2.**torch.linspace(0., max_freq, steps=N_freqs)
+ else:
+ freq_bands = torch.linspace(2.**0., 2.**max_freq, steps=N_freqs)
+
+ for freq in freq_bands:
+ for p_fn in self.kwargs['periodic_fns']:
+ embed_fns.append(lambda x, p_fn=p_fn, freq=freq : p_fn(x * freq))
+ out_dim += d
+
+ self.embed_fns = embed_fns
+ self.out_dim = out_dim
+
+ def embed(self, inputs):
+ return torch.cat([fn(inputs) for fn in self.embed_fns], -1)
+
+def get_embedder(multires):
+ embed_kwargs = {
+ 'include_input' : True,
+ 'input_dims' : 3,
+ 'max_freq_log2' : multires-1,
+ 'num_freqs' : multires,
+ 'log_sampling' : True,
+ 'periodic_fns' : [torch.sin, torch.cos],
+ }
+
+ embedder_obj = Embedder(**embed_kwargs)
+ embed = lambda x, eo=embedder_obj : eo.embed(x)
+ return embed, embedder_obj.out_dim
diff --git a/gaussian_splatting/main_3DGS.py b/algorithms/main_3DGS.py
similarity index 97%
rename from gaussian_splatting/main_3DGS.py
rename to algorithms/main_3DGS.py
index f3ee6d0..4564c55 100644
--- a/gaussian_splatting/main_3DGS.py
+++ b/algorithms/main_3DGS.py
@@ -73,20 +73,8 @@ class GSParams:
class GaussianSplatting:
- def __init__(self, reference_images, reference_masks, reference_orbit_camera_poses, reference_orbit_camera_fovy, gs_params=None, init_input=None):
- self.device = torch.device("cuda")
-
- self.ref_imgs_num = len(reference_images)
-
- self.all_ref_cam_poses = reference_orbit_camera_poses
- self.ref_cam_fovy = reference_orbit_camera_fovy
-
- self.ref_size_H = reference_images[0].shape[0]
- self.ref_size_W = reference_images[0].shape[1]
-
- # default camera settings
- self.cam = OrbitCamera(self.ref_size_W, self.ref_size_H, fovy=reference_orbit_camera_fovy)
- self.projection_matrix = get_projection_matrix(self.cam.near, self.cam.far, self.cam.fovx, self.cam.fovy).transpose(0, 1).cuda()
+ def __init__(self, gs_params=None, init_input=None, device='cuda'):
+ self.device = torch.device(device)
# prepare renderer for optimization
if gs_params is None:
@@ -106,6 +94,24 @@ class GaussianSplatting:
self.gs_params = gs_params
+ def prepare_img(self, img):
+ img_new = img.permute(2, 0, 1).unsqueeze(0).to(self.device)
+ img_new = F.interpolate(img_new, (self.ref_size_H, self.ref_size_W), mode="bilinear", align_corners=False).contiguous()
+ return img_new
+
+ def prepare_training(self, reference_images, reference_masks, reference_orbit_camera_poses, reference_orbit_camera_fovy):
+ self.ref_imgs_num = len(reference_images)
+
+ self.all_ref_cam_poses = reference_orbit_camera_poses
+ self.ref_cam_fovy = reference_orbit_camera_fovy
+
+ self.ref_size_H = reference_images[0].shape[0]
+ self.ref_size_W = reference_images[0].shape[1]
+
+ # default camera settings
+ self.cam = OrbitCamera(self.ref_size_W, self.ref_size_H, fovy=reference_orbit_camera_fovy)
+ self.projection_matrix = get_projection_matrix(self.cam.near, self.cam.far, self.cam.fovx, self.cam.fovy).transpose(0, 1).cuda()
+
# prepare reference images and masks
ref_imgs_torch_list = []
ref_masks_torch_list = []
@@ -115,11 +121,6 @@ class GaussianSplatting:
self.ref_imgs_torch = torch.cat(ref_imgs_torch_list, dim=0)
self.ref_masks_torch = torch.cat(ref_masks_torch_list, dim=0)
-
- def prepare_img(self, img):
- img_new = img.permute(2, 0, 1).unsqueeze(0).to(self.device)
- img_new = F.interpolate(img_new, (self.ref_size_H, self.ref_size_W), mode="bilinear", align_corners=False).contiguous()
- return img_new
def training(self):
starter = torch.cuda.Event(enable_timing=True)
diff --git a/gaussian_splatting/main_3DGS_renderer.py b/algorithms/main_3DGS_renderer.py
similarity index 96%
rename from gaussian_splatting/main_3DGS_renderer.py
rename to algorithms/main_3DGS_renderer.py
index a637fad..65999c0 100644
--- a/gaussian_splatting/main_3DGS_renderer.py
+++ b/algorithms/main_3DGS_renderer.py
@@ -2,7 +2,7 @@ import os
import math
import random
import numpy as np
-from typing import NamedTuple, Optional
+from typing import Optional
from torchtyping import TensorType
from plyfile import PlyData, PlyElement
@@ -10,6 +10,8 @@ import torch
from torch import nn
import torch.nn.functional as F
+from ..mesh_processer.mesh import PointCloud
+
pytorch3d_capable = True
try:
import pytorch3d
@@ -255,11 +257,6 @@ def distance_to_gaussian_surface(points, svec, rotmat, query):
def qvec2rotmat_batched(qvec: TensorType["N", 4]):
return quaternion_to_rotation_matrix(qvec)
-class BasicPointCloud(NamedTuple):
- points: np.array
- colors: np.array
- normals: np.array
-
class GaussianModel:
def setup_functions(self):
@@ -440,34 +437,6 @@ class GaussianModel:
return occ
- def extract_mesh(self, path, density_thresh=1, resolution=128, decimate_target=1e5):
-
- os.makedirs(os.path.dirname(path), exist_ok=True)
-
- occ = self.extract_fields(resolution).detach().cpu().numpy()
-
- import mcubes
- vertices, triangles = mcubes.marching_cubes(occ, density_thresh)
- vertices = vertices / (resolution - 1.0) * 2 - 1
-
- # transform back to the original space
- vertices = vertices / self.scale + self.center.detach().cpu().numpy()
-
- vertices, triangles = clean_mesh(vertices, triangles, remesh=True, remesh_size=0.015)
- if decimate_target > 0 and triangles.shape[0] > decimate_target:
- vertices, triangles = decimate_mesh(vertices, triangles, decimate_target)
-
- v = torch.from_numpy(vertices.astype(np.float32)).contiguous().cuda()
- f = torch.from_numpy(triangles.astype(np.int32)).contiguous().cuda()
-
- print(
- f"[INFO] marching cubes result: {v.shape} ({v.min().item()}-{v.max().item()}), {f.shape}"
- )
-
- mesh = Mesh(v=v, f=f, device='cuda')
-
- return mesh
-
def get_covariance(self, scaling_modifier = 1, gaussain_idx = None):
if gaussain_idx is None:
return self.covariance_activation(self.get_scaling, scaling_modifier, self._rotation)
@@ -478,7 +447,7 @@ class GaussianModel:
if self.active_sh_degree < self.max_sh_degree:
self.active_sh_degree += 1
- def create_from_pcd(self, pcd : BasicPointCloud, spatial_lr_scale : float = 1):
+ def create_from_pcd(self, pcd : PointCloud, spatial_lr_scale : float = 1):
self.spatial_lr_scale = spatial_lr_scale
fused_point_cloud = torch.tensor(np.asarray(pcd.points)).float().cuda()
fused_color = RGB2SH(torch.tensor(np.asarray(pcd.colors)).float().cuda())
@@ -545,6 +514,16 @@ class GaussianModel:
for i in range(self._rotation.shape[1]):
l.append('rot_{}'.format(i))
return l
+
+ def get_points_cloud(self):
+ xyz = self._xyz.detach().cpu().numpy()
+ normals = np.zeros_like(xyz)
+ shs = self.get_features.detach().cpu().numpy()
+ pcd = PointCloud(points=xyz, colors=SH2RGB(shs), normals=normals)
+ return pcd
+
+ def get_mesh(self):
+ xyz = self._xyz.detach().cpu().numpy()
def save_ply(self, path):
os.makedirs(os.path.dirname(path), exist_ok=True)
@@ -633,7 +612,7 @@ class GaussianModel:
xyz = np.array(all_points)
shs = np.random.random((num_pts, 3)) / 255.0
- pcd = BasicPointCloud(
+ pcd = PointCloud(
points=xyz, colors=SH2RGB(shs), normals=np.zeros((num_pts, 3))
)
self.create_from_pcd(pcd, 10)
@@ -650,7 +629,7 @@ class GaussianModel:
num_pts = len(uv_coords_3d)
xyz = np.array(uv_coords_3d)
shs = np.random.random((num_pts, 3)) / 255.0
- pcd = BasicPointCloud(
+ pcd = PointCloud(
points=xyz, colors=SH2RGB(shs), normals=np.zeros((num_pts, 3))
)
self.create_from_pcd(pcd, 10)
@@ -930,11 +909,11 @@ class Renderer:
# xyz = np.random.random((num_pts, 3)) * 2.6 - 1.3
shs = np.random.random((num_pts, 3)) / 255.0
- pcd = BasicPointCloud(
+ pcd = PointCloud(
points=xyz, colors=SH2RGB(shs), normals=np.zeros((num_pts, 3))
)
self.gaussians.create_from_pcd(pcd, 10)
- elif isinstance(input, BasicPointCloud):
+ elif isinstance(input, PointCloud):
# load from a provided pcd
self.gaussians.create_from_pcd(input, 1)
else:
diff --git a/algorithms/metrics_utils.py b/algorithms/metrics_utils.py
new file mode 100644
index 0000000..57a5074
--- /dev/null
+++ b/algorithms/metrics_utils.py
@@ -0,0 +1,9 @@
+import torch
+
+def sdf_reg_loss(sdf, all_edges):
+ sdf_f1x6x2 = sdf[all_edges.reshape(-1)].reshape(-1,2)
+ mask = torch.sign(sdf_f1x6x2[...,0]) != torch.sign(sdf_f1x6x2[...,1])
+ sdf_f1x6x2 = sdf_f1x6x2[mask]
+ sdf_diff = torch.nn.functional.binary_cross_entropy_with_logits(sdf_f1x6x2[...,0], (sdf_f1x6x2[...,1] > 0).float()) + \
+ torch.nn.functional.binary_cross_entropy_with_logits(sdf_f1x6x2[...,1], (sdf_f1x6x2[...,0] > 0).float())
+ return sdf_diff
\ No newline at end of file
diff --git a/algorithms/tetmesh.py b/algorithms/tetmesh.py
new file mode 100644
index 0000000..5283306
--- /dev/null
+++ b/algorithms/tetmesh.py
@@ -0,0 +1,165 @@
+# Copyright (c) 2021,22 NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import torch
+
+__all__ = ['marching_tetrahedra']
+
+triangle_table = torch.tensor([
+ [-1, -1, -1, -1, -1, -1],
+ [1, 0, 2, -1, -1, -1],
+ [4, 0, 3, -1, -1, -1],
+ [1, 4, 2, 1, 3, 4],
+ [3, 1, 5, -1, -1, -1],
+ [2, 3, 0, 2, 5, 3],
+ [1, 4, 0, 1, 5, 4],
+ [4, 2, 5, -1, -1, -1],
+ [4, 5, 2, -1, -1, -1],
+ [4, 1, 0, 4, 5, 1],
+ [3, 2, 0, 3, 5, 2],
+ [1, 3, 5, -1, -1, -1],
+ [4, 1, 2, 4, 3, 1],
+ [3, 0, 4, -1, -1, -1],
+ [2, 0, 1, -1, -1, -1],
+ [-1, -1, -1, -1, -1, -1]
+], dtype=torch.long)
+
+num_triangles_table = torch.tensor([0, 1, 1, 2, 1, 2, 2, 1, 1, 2, 2, 1, 2, 1, 1, 0], dtype=torch.long)
+base_tet_edges = torch.tensor([0, 1, 0, 2, 0, 3, 1, 2, 1, 3, 2, 3], dtype=torch.long)
+v_id = torch.pow(2, torch.arange(4, dtype=torch.long))
+
+
+def _sort_edges(edges):
+ """sort last dimension of edges of shape (E, 2)"""
+ with torch.no_grad():
+ order = (edges[:, 0] > edges[:, 1]).long()
+ order = order.unsqueeze(dim=1)
+
+ a = torch.gather(input=edges, index=order, dim=1)
+ b = torch.gather(input=edges, index=1 - order, dim=1)
+
+ return torch.stack([a, b], -1)
+
+
+def _unbatched_marching_tetrahedra(vertices, tets, sdf, return_tet_idx):
+ """unbatched marching tetrahedra.
+
+ Refer to :func:`marching_tetrahedra`.
+ """
+ device = vertices.device
+ with torch.no_grad():
+ occ_n = sdf > 0
+ occ_fx4 = occ_n[tets.reshape(-1)].reshape(-1, 4)
+ occ_sum = torch.sum(occ_fx4, -1)
+ valid_tets = (occ_sum > 0) & (occ_sum < 4)
+ occ_sum = occ_sum[valid_tets]
+
+ # find all vertices
+ all_edges = tets[valid_tets][:, base_tet_edges.to(device)].reshape(-1, 2)
+ all_edges = _sort_edges(all_edges)
+ unique_edges, idx_map = torch.unique(all_edges, dim=0, return_inverse=True)
+
+ unique_edges = unique_edges.long()
+ mask_edges = occ_n[unique_edges.reshape(-1)].reshape(-1, 2).sum(-1) == 1
+ mapping = torch.ones((unique_edges.shape[0]), dtype=torch.long, device=device) * -1
+ mapping[mask_edges] = torch.arange(mask_edges.sum(), dtype=torch.long, device=device)
+ idx_map = mapping[idx_map]
+
+ interp_v = unique_edges[mask_edges]
+ edges_to_interp = vertices[interp_v.reshape(-1)].reshape(-1, 2, 3)
+ edges_to_interp_sdf = sdf[interp_v.reshape(-1)].reshape(-1, 2, 1)
+ edges_to_interp_sdf[:, -1] *= -1
+
+ denominator = edges_to_interp_sdf.sum(1, keepdim=True)
+
+ edges_to_interp_sdf = torch.flip(edges_to_interp_sdf, [1]) / denominator
+ verts = (edges_to_interp * edges_to_interp_sdf).sum(1)
+
+ idx_map = idx_map.reshape(-1, 6)
+
+ tetindex = (occ_fx4[valid_tets] * v_id.to(device).unsqueeze(0)).sum(-1)
+ num_triangles = num_triangles_table.to(device)[tetindex]
+ triangle_table_device = triangle_table.to(device)
+
+ # Generate triangle indices
+ faces = torch.cat((
+ torch.gather(input=idx_map[num_triangles == 1], dim=1,
+ index=triangle_table_device[tetindex[num_triangles == 1]][:, :3]).reshape(-1, 3),
+ torch.gather(input=idx_map[num_triangles == 2], dim=1,
+ index=triangle_table_device[tetindex[num_triangles == 2]][:, :6]).reshape(-1, 3),
+ ), dim=0)
+
+ if return_tet_idx:
+ tet_idx = torch.arange(tets.shape[0], device=device)[valid_tets]
+ tet_idx = torch.cat((tet_idx[num_triangles == 1], tet_idx[num_triangles ==
+ 2].unsqueeze(-1).expand(-1, 2).reshape(-1)), dim=0)
+ return verts, faces, tet_idx
+ return verts, faces
+
+
+def marching_tetrahedra(vertices, tets, sdf, return_tet_idx=False):
+ r"""Convert discrete signed distance fields encoded on tetrahedral grids to triangle
+ meshes using marching tetrahedra algorithm as described in `An efficient method of
+ triangulating equi-valued surfaces by using tetrahedral cells`_. The output surface is differentiable with respect to
+ input vertex positions and the SDF values. For more details and example usage in learning, see
+ `Deep Marching Tetrahedra\: a Hybrid Representation for High-Resolution 3D Shape Synthesis`_ NeurIPS 2021.
+
+
+ Args:
+ vertices (torch.tensor): batched vertices of tetrahedral meshes, of shape
+ :math:`(\text{batch_size}, \text{num_vertices}, 3)`.
+ tets (torch.tensor): unbatched tetrahedral mesh topology, of shape
+ :math:`(\text{num_tetrahedrons}, 4)`.
+ sdf (torch.tensor): batched SDFs which specify the SDF value of each vertex, of shape
+ :math:`(\text{batch_size}, \text{num_vertices})`.
+ return_tet_idx (optional, bool): if True, return index of tetrahedron
+ where each face is extracted. Default: False.
+
+ Returns:
+ (list[torch.Tensor], list[torch.LongTensor], (optional) list[torch.LongTensor]):
+
+ - the list of vertices for mesh converted from each tetrahedral grid.
+ - the list of faces for mesh converted from each tetrahedral grid.
+ - the list of indices that correspond to tetrahedra where faces are extracted.
+
+ Example:
+ >>> vertices = torch.tensor([[[0, 0, 0],
+ ... [1, 0, 0],
+ ... [0, 1, 0],
+ ... [0, 0, 1]]], dtype=torch.float)
+ >>> tets = torch.tensor([[0, 1, 2, 3]], dtype=torch.long)
+ >>> sdf = torch.tensor([[-1., -1., 0.5, 0.5]], dtype=torch.float)
+ >>> verts_list, faces_list, tet_idx_list = marching_tetrahedra(vertices, tets, sdf, True)
+ >>> verts_list[0]
+ tensor([[0.0000, 0.6667, 0.0000],
+ [0.0000, 0.0000, 0.6667],
+ [0.3333, 0.6667, 0.0000],
+ [0.3333, 0.0000, 0.6667]])
+ >>> faces_list[0]
+ tensor([[3, 0, 1],
+ [3, 2, 0]])
+ >>> tet_idx_list[0]
+ tensor([0, 0])
+
+ .. _An efficient method of triangulating equi-valued surfaces by using tetrahedral cells:
+ https://search.ieice.org/bin/summary.php?id=e74-d_1_214
+
+ .. _Deep Marching Tetrahedra\: a Hybrid Representation for High-Resolution 3D Shape Synthesis:
+ https://arxiv.org/abs/2111.04276
+ """
+
+ list_of_outputs = [_unbatched_marching_tetrahedra(vertices[b], tets, sdf[b], return_tet_idx) for b in range(vertices.shape[0])]
+ return list(zip(*list_of_outputs))
diff --git a/data/samples_tets/128_tets_0.npz b/data/samples_tets/128_tets_0.npz
new file mode 100644
index 0000000000000000000000000000000000000000..8684f02858bf3e6bcb4263fcfdca4e13568f9ea2
GIT binary patch
literal 2070272
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%0D=!p=
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