UniqAI/gaussian-splatting
1
0
Fork 0
mirror of https://github.com/graphdeco-inria/gaussian-splatting synced 2025-04-02 20:30:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

add comments

Browse Source
This commit is contained in:
liuzhi 2024-06-24 18:48:54 +08:00
parent da44a55c40
commit 268f92fafc
8 changed files with 68 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
run_code.txt
View File

@ -4,70 +4,68 @@ python train.py --source_path <path to COLMAP or NeRF Synthetic dataset> --model
python train.py --source_path ../../Dataset/3DGS_Dataset/linggongtang --model_path output/linggongtang --data_device 'cpu' --eval --resolution 1
python train.py --source_path ../../Dataset/3DGS_Dataset/xiangjiadang --model_path output/xiangjiadang --data_device 'cpu' --eval --resolution 1
--source_path / -s：COLMAP 或合成 Synthetic NeRF data set的源目录的路径。COLMAP类型包含 images/, sparse/0
--model_path / -m：训练模型的存储路径，默认为 output/<random>
--images / -i：COLMAP 图像的替代子目录，默认为 images
--eval：训练时默认使用全部图片，--eval可以在训练时按照MipNeRF360-style划分 training/test，用于 evaluation
--source_path / -s：数据集输入路径，包含图片文件夹：images, SfM输出文件夹：sparse/0
--model_path / -m：指定的训练模型存储路径，默认为 output/<random>
--images / -i：输入路径下存储图片的替代文件夹名，默认为 images
--eval：训练时默认使用全部图片，添加此标志将在训练时按照MipNeRF360-style划分训练集/测试集（每8张选1张作为测试集），以用于 evaluation
--resolution / -r：指定训练前加载图像的分辨率。如果是 1, 2, 4 or 8 则使用原始分辨率的 1/2, 1/4 or 1/8。
对于所有其他值，会将图像宽度调整到给定数字，同时保持图像宽高比；
如果未设置并且输入图像宽度超过 1.6K 像素，则输入将宽度自动缩放到 1.6k
如果未设置且输入图像宽度超过 1.6k 个像素，则输入将宽度自动缩放到 1.6k
--data_device：指定源图像数据在训练时的放置位置，默认使用cuda，如果在大型/高分辨率数据集上进行训练，建议使用cpu，减少显存占用，但训练速度会变慢
--data_device：指定源图像数据在训练时的放置位置，默认使用cuda，如果在大型/高分辨率数据集上进行训练，建议使用cpu，减少显存占用
--white_background / -w：添加此标志以使用白色背景而不是黑色（默认），用于评估 NeRF Synthetic dataset
--sh_degree：球谐函数的阶数（不大于 3），默认为 3
--convert_SHs_python：添加此标志以使用 PyTorch 而不是论文提出的pipeline计算 SH系数 的forward and backward
--convert_cov3D_python：添加此标志以使用 PyTorch 而不是论文提出的pipeline计算 3D协方差 的forward and backward
--convert_SHs_python：添加此标志以使用PyTorch而不是论文提出的pipeline计算 SH系数的forward和backward，默认为False
--convert_cov3D_python：添加此标志以使用PyTorch而不是论文提出的pipeline计算 3D协方差的forward和backward，默认为False
--debug：如果遇到错误，请启用调试模式。如果光栅化器失败，dump则会创建一个文件，您可以在问题中将其转发给我们，以便我们查看。
--debug：如果遇到错误，请启用调试模式。如果光栅化器失败，dump则会创建一个文件，默认为False
--debug_from：调试速度慢。可以指定从哪一迭代（>= 0）开始
--iterations：训练的总迭代次数，默认为 30_000
--ip：启动 GUI 服务器的 IP，默认为 127.0.0.1
--port：GUI 服务器的端口，默认为 6009
--test_iterations：训练脚本在测试集上计算 L1 和 PSNR 的分隔迭代次数，默认为 7000, 30000
--save_iterations：训练脚本保存高斯模型的分隔迭代次数，默认为 7000, 30000
--checkpoint_iterations：存储checkpoint的分隔迭代次数，以后续继续新联，保存在model directory中
--start_checkpoint：保存的checkpoint的路径，以继续训练
--iterations：训练的总迭代次数，默认为 30_000
--test_iterations：训练脚本在测试集上计算 L1 和 PSNR 的迭代次数，默认为 7000, 30000
--save_iterations：训练脚本保存高斯模型的迭代次数，默认为 7000, 30000
--checkpoint_iterations：存储checkpoint的迭代次数，以后续继续训练，保存在model_path中
--start_checkpoint：继续训练时要加载的checkpoint的路径
--quiet：此标志用于不写入任何文本到标准输出管道
--feature_lr：球谐函数的学习率，默认为 0.0025
--opacity_lr：不透明度的学习率，默认为 0.05
--scaling_lr：尺度的学习率，默认为 0.005
--rotation_lr：旋转四元数的学习率，默认为 0.001
--position_lr_max_steps：位置学习率从初始值到最终值的步数（从 0 开始），默认为 30_000
--position_lr_init：位置学习率的初始值，默认为 0.00016
--position_lr_final：位置学习率的最终值，默认为 0.0000016
--position_lr_delay_mult：位置学习率的乘数，默认为 0.01
--position_lr_max_steps：位置学习率从初始值到最终值的步数（从 0 开始），默认为 30_000
--densify_from_iter：densification开始的迭代次数，默认为 500
--densify_until_iter：densification结束的迭代次数，默认为 15_000
--feature_lr：球谐函数的学习率，默认为 0.0025
--opacity_lr：不透明度的学习率，默认为 0.05
--scaling_lr：缩放尺度的学习率，默认为 0.005
--rotation_lr：旋转四元数的学习率，默认为 0.001
--densify_from_iter：densification增稠开始的迭代次数，默认为 500
--densify_until_iter：densification增稠结束的迭代次数，默认为 15_000
--densify_grad_threshold：决定是否应基于 2D 位置梯度对点进行densification的限制，默认为0.0002
--densification_interval：densify的频率，默认为 100（每迭代100次进行1次）
--densification_interval：增稠的频率，默认为 100（每迭代100次进行1次）
--opacity_reset_interval：重置不透明度的频率，默认为 3_000
--lambda_dssim：SSIM 对总损失的影响，从 0 到 1，默认为0.2
--percent_dense：点必须超过场景范围的百分比才能强制致密， (0--1)，默认为0.01
--lambda_dssim：SSIM在总损失的权重，从 0 到 1，默认为0.2
--percent_dense：点必须超过场景范围的百分比才能强制增稠， (0--1)，默认为0.01
#--------------------------------------------------------------------------
Evluation:
# Generate renderings
python render.py -m <path to trained model>
--model_path / -m：为其创建renderings的以训练模型的路径
--skip_train：跳过渲染training set
--skip_test：跳过渲染test set
--model_path / -m：训练模型输出路径, 在其子文件夹下生成训练或测试视角的渲染图，同train中
--skip_train：跳过渲染训练视角
--skip_test：跳过渲染测试视角
--quiet：不写入任何文本到标准输出管道
以下参数会从用于训练的model path中自动读取。但可覆写它们
--source_path / -s：COLMAP 或合成 Synthetic NeRF data set的源目录的路径。
--images / -i：COLMAP 图像的替代子目录，默认为 images
以下参数会从用于训练输出的model_path中自动读取，但可覆写它们
--source_path / -s
--images / -i
--eval
--resolution / -r
--white_background / -w
@ -78,5 +76,5 @@ python render.py -m <path to trained model>
# Compute error metrics on renderings
python metrics.py -m <path to trained model>
--model_paths / -m：应计算metrics的model paths的分隔列表
--model_paths / -m：保存所有输出结果的文件夹路径，同train中

14
scene/cameras.py
View File

@ -23,8 +23,8 @@ class Camera(nn.Module):
self.uid = uid
self.colmap_id = colmap_id
self.R = R
self.T = T
self.R = R # 相机到世界的 C2W
self.T = T # 世界到相机的 W2C
self.FoVx = FoVx
self.FoVy = FoVy
self.image_name = image_name
@ -36,7 +36,7 @@ class Camera(nn.Module):
print(f"[Warning] Custom device {data_device} failed, fallback to default cuda device" )
self.data_device = torch.device("cuda")
self.original_image = image.clamp(0.0, 1.0).to(self.data_device)
self.original_image = image.clamp(0.0, 1.0).to(self.data_device) # tensor, 归一化的 C H W
self.image_width = self.original_image.shape[2]
self.image_height = self.original_image.shape[1]
@ -51,10 +51,10 @@ class Camera(nn.Module):
self.trans = trans
self.scale = scale
self.world_view_transform = torch.tensor(getWorld2View2(R, T, trans, scale)).transpose(0, 1).cuda()
self.projection_matrix = getProjectionMatrix(znear=self.znear, zfar=self.zfar, fovX=self.FoVx, fovY=self.FoVy).transpose(0,1).cuda()
self.full_proj_transform = (self.world_view_transform.unsqueeze(0).bmm(self.projection_matrix.unsqueeze(0))).squeeze(0)
self.camera_center = self.world_view_transform.inverse()[3, :3]
self.world_view_transform = torch.tensor(getWorld2View2(R, T, trans, scale)).transpose(0, 1).cuda() # C2W 相机到世界的变换矩阵
self.projection_matrix = getProjectionMatrix(znear=self.znear, zfar=self.zfar, fovX=self.FoVx, fovY=self.FoVy).transpose(0,1).cuda() # 生成了一个投影矩阵，用于将视图坐标投影到图像平面
self.full_proj_transform = (self.world_view_transform.unsqueeze(0).bmm(self.projection_matrix.unsqueeze(0))).squeeze(0) # 使用 bmm（批量矩阵乘法）将世界到视图变换矩阵和投影矩阵相乘，生成完整的投影变换矩阵
self.camera_center = self.world_view_transform.inverse()[3, :3] # 通过求逆变换矩阵获取相机在世界坐标系中的位置（相机中心）
class MiniCam:
def __init__(self, width, height, fovy, fovx, znear, zfar, world_view_transform, full_proj_transform):

17
scene/dataset_readers.py
View File

@ -67,7 +67,6 @@ def getNerfppNorm(cam_info):
def readColmapCameras(cam_extrinsics, cam_intrinsics, images_folder):
'''
cam_extrinsics: 存储每张图片相机的外参类Imgae 的字典
cam_intrinsics: 存储每张图片相机的内参类Camera 的字典
images_folder: 保存原图的文件夹路径
@ -90,11 +89,11 @@ def readColmapCameras(cam_extrinsics, cam_intrinsics, images_folder):
uid = intr.id # 相机的唯一标识符
R = np.transpose(qvec2rotmat(extr.qvec)) # 将旋转四元数 转为 旋转矩阵 R，并转置
T = np.array(extr.tvec) # 平移向量
R = np.transpose(qvec2rotmat(extr.qvec)) # W2C的四元数转为 R，transpose后 ==> C2W的R
T = np.array(extr.tvec) # W2C的T
# 根据相机内参模型计算 视场角（FoV）
if intr.model=="SIMPLE_PINHOLE":
if intr.model=="SIMPLE_PINHOLE" or intr.model=="SIMPLE_RADIAL":
# 如果是简单针孔模型，只有一个焦距参数
focal_length_x = intr.params[0]
FovY = focal2fov(focal_length_x, height) # 计算垂直方向的视场角
@ -105,11 +104,6 @@ def readColmapCameras(cam_extrinsics, cam_intrinsics, images_folder):
focal_length_y = intr.params[1]
FovY = focal2fov(focal_length_y, height) # 使用fy计算垂直视场角
FovX = focal2fov(focal_length_x, width) # 使用fx计算水平视场角
elif intr.model=="SIMPLE_RADIAL":
# 如果是针孔模型，有两个焦距参数
focal_length_x = intr.params[0]
FovY = focal2fov(focal_length_x, height) # 使用fy计算垂直视场角
FovX = focal2fov(focal_length_x, width) # 使用fx计算水平视场角
else:
# 如果不是以上两种模型，抛出错误
assert False, "Colmap camera model not handled: only undistorted datasets (PINHOLE or SIMPLE_PINHOLE cameras) supported!"
@ -119,7 +113,7 @@ def readColmapCameras(cam_extrinsics, cam_intrinsics, images_folder):
if not os.path.exists(image_path):
continue
image = Image.open(image_path)
image = Image.open(image_path) # PIL.Image读取的为RGB格式，OpenCV读取的为BGR格式
# 创建相机信息类CameraInfo对象 (包含旋转矩阵、平移向量、视场角、图像数据、图片路径、图片名、宽度、高度)，并添加到列表cam_infos中
cam_info = CameraInfo(uid=uid, R=R, T=T, FovY=FovY, FovX=FovX, image=image,
@ -160,8 +154,7 @@ def storePly(path, xyz, rgb):
def readColmapSceneInfo(path, images, eval, llffhold=8):
'''
加载COLMAP的结果中的二进制相机外参文件imags.bin 和 内参文件cameras.bin
加载COLMAP的结果中的二进制相机外参文件imags.bin 和 内参文件cameras.bin
path: GaussianModel中的源文件路径
images: 'images'
eval: 是否为eval模式

8
scene/gaussian_model.py
View File

@ -139,7 +139,7 @@ class GaussianModel:
def create_from_pcd(self, pcd : BasicPointCloud, spatial_lr_scale : float):
"""
从稀疏点云数据 初始化模型参数
从稀疏点云数据pcd 初始化模型参数
pcd: 稀疏点云，包含点的位置和颜色
spatial_lr_scale: 空间学习率缩放因子，影响 位置坐标参数的学习率
"""
@ -465,6 +465,12 @@ class GaussianModel:
self.densification_postfix(new_xyz, new_features_dc, new_features_rest, new_opacities, new_scaling, new_rotation)
def densify_and_prune(self, max_grad, min_opacity, extent, max_screen_size):
"""
max_grad 决定是否应基于 2D 位置梯度对点进行densification的限制，默认为0.0002
min_opacity 0.005
extent
max_screen_size 初始为None，3000代后，即后续重置不透明度，则为20
"""
grads = self.xyz_gradient_accum / self.denom # 计算平均梯度
grads[grads.isnan()] = 0.0

11
train.py
View File

@ -141,16 +141,17 @@ def training(dataset, opt, pipe, testing_iterations, saving_iterations, checkpoi
print("\n[ITER {}] Saving Gaussians".format(iteration))
scene.save(iteration)
# Densification，在指定迭代区间内，对3D高斯模型进行增密和修剪
# < 15000代，则对3D高斯模型进行增密和修剪，Densification
if iteration < opt.densify_until_iter:
# Keep track of max radii in image-space for pruning
gaussians.max_radii2D[visibility_filter] = torch.max(gaussians.max_radii2D[visibility_filter], radii[visibility_filter])
gaussians.add_densification_stats(viewspace_point_tensor, visibility_filter)
# > 500 且 每100代增稠，则进行 增稠和剪枝
if iteration > opt.densify_from_iter and iteration % opt.densification_interval == 0:
size_threshold = 20 if iteration > opt.opacity_reset_interval else None
size_threshold = 20 if iteration > opt.opacity_reset_interval else None # 初始为None，3000代后，即后续重置不透明度，则为20
gaussians.densify_and_prune(opt.densify_grad_threshold, 0.005, scene.cameras_extent, size_threshold)
# 每3000代 或 (白背景 且 为第500代)，则重置不透明度
if iteration % opt.opacity_reset_interval == 0 or (dataset.white_background and iteration == opt.densify_from_iter):
gaussians.reset_opacity()
@ -159,7 +160,7 @@ def training(dataset, opt, pipe, testing_iterations, saving_iterations, checkpoi
gaussians.optimizer.step()
gaussians.optimizer.zero_grad(set_to_none = True)
# 定期保存checkpoint
# 第checkpoint_iterations 代时，保存相应代数的网络模型checkpoint
if (iteration in checkpoint_iterations):
print("\n[ITER {}] Saving Checkpoint".format(iteration))
torch.save((gaussians.capture(), iteration), scene.model_path + "/chkpnt" + str(iteration) + ".pth")

2
utils/camera_utils.py
View File

@ -38,7 +38,7 @@ def loadCam(args, id, cam_info, resolution_scale):
scale = float(global_down) * float(resolution_scale)
resolution = (int(orig_w / scale), int(orig_h / scale))
resized_image_rgb = PILtoTorch(cam_info.image, resolution)
resized_image_rgb = PILtoTorch(cam_info.image, resolution) # 调整图片比例，归一化，并转换通道为torch上的 (C, H, W)
gt_image = resized_image_rgb[:3, ...]
loaded_mask = None

5
utils/general_utils.py
View File

@ -20,10 +20,11 @@ def inverse_sigmoid(x):
def PILtoTorch(pil_image, resolution):
resized_image_PIL = pil_image.resize(resolution)
resized_image = torch.from_numpy(np.array(resized_image_PIL)) / 255.0
resized_image = torch.from_numpy(np.array(resized_image_PIL)) / 255.0 # 归一化
if len(resized_image.shape) == 3:
return resized_image.permute(2, 0, 1)
return resized_image.permute(2, 0, 1) # 转换为 3 H W
else:
# 若为H W，则添加一个通道维度为 H W 1，再转换为 1 H W
return resized_image.unsqueeze(dim=-1).permute(2, 0, 1)
def get_expon_lr_func(

13
utils/graphics_utils.py
View File

@ -37,15 +37,16 @@ def getWorld2View(R, t):
def getWorld2View2(R, t, translate=np.array([.0, .0, .0]), scale=1.0):
Rt = np.zeros((4, 4))
Rt[:3, :3] = R.transpose()
Rt[:3, 3] = t
Rt[:3, :3] = R.transpose() # W2C的 R
Rt[:3, 3] = t # W2C的 t
Rt[3, 3] = 1.0
# C2W的变换矩阵
C2W = np.linalg.inv(Rt)
cam_center = C2W[:3, 3]
cam_center = C2W[:3, 3] # C2W的 t，即相机在世界坐标系中的坐标位置
cam_center = (cam_center + translate) * scale
C2W[:3, 3] = cam_center
Rt = np.linalg.inv(C2W)
C2W[:3, 3] = cam_center # 加上平移后的 C2W的变换矩阵
Rt = np.linalg.inv(C2W) # W2C的变换矩阵
return np.float32(Rt)
def getProjectionMatrix(znear, zfar, fovX, fovY):