PyTorch3D 渲染技術：光線取樣與體積重建實戰

– 13 分鐘閱讀

在 3D 圖形領域，PyTorch3D 提供了強大的工具和函式庫，讓開發者能更輕鬆地進行 3D 模型的渲染和重建。本文將深入探討 PyTorch3D 的核心技術，包含環境設定、相機引數設定、燈光配置、光線取樣與體積重建等關鍵步驟。

要使用 PyTorch3D 進行 3D 模型渲染，首先需確認 GPU 環境設定。利用 torch.cuda.is_available() 檢查 GPU 是否可用，並據此設定運算裝置。

import torch

if torch.cuda.is_available():
    device = torch.device("cuda:0")
else:
    device = torch.device("cpu")

# 設定相機引數，包含視角數量、仰角與方位角。
num_views = 10
elev = torch.linspace(0, 0, num_views)  # 仰角
azim = torch.linspace(-180, 180, num_views) + 180.0  # 方位角

內容解密

這段程式碼首先檢查系統中是否有可用的 GPU，如果有的話，就使用 GPU 進行運算；否則，使用 CPU。接著，設定了相機引數，包括相機的數量 num_views，以及每個相機的仰角 elev 和方位角 azim。torch.linspace() 函式用於生成均勻分佈的數值序列。

圖表翻譯

  graph LR
    A[檢查 GPU 是否可用] --> B{可用?};
    B -- Yes --> C[設定 device 為 cuda:0];
    B -- No --> D[設定 device 為 cpu];
    C --> E[設定相機引數];
    D --> E;

此圖展示了程式碼的執行流程，首先檢查 GPU 是否可用，然後根據結果設定運算裝置，最後設定相機引數。

接著，設定燈光與相機位置及相關引數。

from pytorch3d.structures import PointLights
from pytorch3d.renderer import look_at_view_transform, FoVPerspectiveCameras

# 定義點光源位置
lights = PointLights(device=device, location=[[0.0, 0.0, -3.0]])

# 計算相機的旋轉矩陣 R 和平移向量 T
R, T = look_at_view_transform(dist=2.7, elev=elev, azim=azim)

# 定義透視相機
cameras = FoVPerspectiveCameras(device=device, R=R, T=T)

內容解密

這段程式碼定義了場景中的燈光和相機。PointLights 建立了一個點光源，並設定其位置。look_at_view_transform 函式根據距離、仰角和方位角計算相機的旋轉和平移變換。FoVPerspectiveCameras 建立了一個透視相機，並使用計算出的旋轉和平移變換設定相機的位置和方向。

圖表翻譯

  graph LR
    A[定義點光源] --> B[計算相機變換];
    B --> C[定義透視相機];

此圖簡述了程式碼的執行流程：定義點光源、計算相機變換，最後定義透視相機。

設定光線取樣器，決定渲染的精細程度。

from pytorch3d.renderer import NDCGridRaysampler

image_size = 64 # 圖片大小
volume_extent_world = 3.0 # 體積範圍

# 建立光線取樣器
raysampler = NDCGridRaysampler(
    image_width=image_size,
    image_height=image_size,
    n_pts_per_ray=50,  # 每條光線上的取樣點數
    min_depth=0.1,
    max_depth=volume_extent_world,
)

ray_bundle = raysampler(cameras) # 產生光線包

print('光線包的原點形狀 = ', ray_bundle.origins.shape)
print('光線包的方向形狀 = ', ray_bundle.directions.shape)
print('光線包的長度形狀 = ', ray_bundle.lengths.shape)
print('光線包的 xy 位置形狀 = ', ray_bundle.xys.shape)

torch.save({'ray_bundle': ray_bundle}, 'ray_sampling.pt') # 儲存光線包

內容解密

這段程式碼建立了一個 NDCGridRaysampler 物件，用於生成光線。image_size 設定了渲染圖片的大小，volume_extent_world 設定了體積的範圍。n_pts_per_ray 設定了每條光線上的取樣點數。min_depth 和 max_depth 設定了光線的最小和最大深度。接著，使用 raysampler(cameras) 生成光線包 ray_bundle，並印出光線包中各個張量的形狀。最後，將光線包儲存到檔案中，以便後續使用。

圖表翻譯

  graph LR
    A[建立光線取樣器] --> B[生成光線包];
    B --> C[印出光線包資訊];
    C --> D[儲存光線包];

此圖展示了程式碼的執行流程：建立光線取樣器、生成光線包、印出光線包資訊，最後儲存光線包。

最後，進行體積取樣，從體積中獲取點的密度和顏色值。

import torch
from pytorch3d.structures import Volumes
from pytorch3d.renderer.implicit.renderer import VolumeSampler

# ... (其他程式碼)

# 載入先前儲存的光線包
loaded_data = torch.load('ray_sampling.pt')
ray_bundle = loaded_data['ray_bundle']


# 建立一個範例體積 (實際應用中，這裡應該根據你的資料建立體積)
features = torch.randn(1, 1, image_size, image_size, image_size, device=device)
densities = torch.sigmoid(features)
volumes = Volumes(densities=densities, features=features)

sampler = VolumeSampler(volumes=volumes)
samples = sampler(ray_bundle=ray_bundle)

內容解密

這段程式碼示範如何使用 VolumeSampler 從體積中取樣密度和特徵。首先，載入先前儲存的光線包。接著，建立一個範例體積 volumes，其中包含密度和特徵資訊。densities 使用 torch.sigmoid 確保其值介於 0 和 1 之間。最後，使用 VolumeSampler 對體積進行取樣，得到 samples，其中包含沿著光線取樣點的密度和特徵。

圖表翻譯

  graph LR
    A[載入光線包] --> B[建立範例體積];
    B --> C[建立 VolumeSampler];
    C --> D[取樣體積];

此圖展示了體積取樣的流程：載入光線包、建立範例體積、建立 VolumeSampler，最後取樣體積。

透過以上步驟，我們完成了使用 PyTorch3D 進行 3D 重建的流程，包含環境設定、相機引數、燈光配置、光線取樣以及體積重建等關鍵步驟。 PyTorch3D 提供了靈活且高效的工具，讓開發者能更深入地探索 3D 圖形領域的各種應用。

簡介

在這個章節中，我們將探討如何使用PyTorch進行3D模型渲染和最佳化。這涉及到使用PyTorch的渲染器和最佳化器來計算3D模型的渲染結果和最佳化模型的引數。

渲染3D模型

首先，我們需要定義一個3D模型的渲染函式。這個函式將會計算3D模型的渲染結果，包括輪廓和紋理。以下是這個函式的實作：

def look_at_rotation(camera_position, target_position):
    # ...

def render_silhouette(meshes, R, T):
    # ...

def render_textured(meshes, R, T):
    # ...

class Model(torch.nn.Module):
    def __init__(self, meshes, renderer_silhouette, renderer_textured, image_ref, weight_silhouette, weight_texture):
        super(Model, self).__init__()
        self.meshes = meshes
        self.renderer_silhouette = renderer_silhouette
        self.renderer_textured = renderer_textured
        self.image_ref = image_ref
        self.weight_silhouette = weight_silhouette
        self.weight_texture = weight_texture

    def forward(self):
        R = look_at_rotation(self.camera_position[None, :], self.target_position[None, :])
        T = -torch.bmm(R.transpose(1, 2), self.camera_position[None, :, None])[:, :, 0]
        image_silhouette = self.renderer_silhouette(meshes_world=self.meshes.clone(), R=R, T=T)
        image_textured = self.renderer_textured(meshes_world=self.meshes.clone(), R=R, T=T)
        loss_silhouette = torch.sum((image_silhouette[..., 3] - self.image_ref_silhouette) ** 2)
        loss_texture = torch.sum((image_textured[..., :3] - self.image_ref_textured) ** 2)
        loss = self.weight_silhouette * loss_silhouette + self.weight_texture * loss_texture
        return loss, image_silhouette, image_textured

最佳化模型引數

接下來，我們需要定義一個最佳化器來最佳化模型的引數。這個最佳化器將會使用PyTorch的Adam最佳化器來最佳化模型的引數。以下是這個最佳化器的實作：

model = Model(meshes=cow_mesh, renderer_silhouette=renderer_silhouette, renderer_textured=renderer_textured, image_ref=image_ref, weight_silhouette=1.0, weight_texture=0.1).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.05)

執行最佳化

最後，我們需要執行最佳化器來最佳化模型的引數。這個過程將會涉及到多次迭代，每次迭代都會計算模型的損失和梯度，並使用最佳化器來更新模型的引數。以下是這個過程的實作：

for epoch in range(100):
    optimizer.zero_grad()
    loss, image_silhouette, image_textured = model()
    loss.backward()
    optimizer.step()
    print(f'Epoch {epoch+1}, Loss: {loss.item()}')

圖表翻譯

  flowchart TD
    A[初始化模型] --> B[定義渲染函式]
    B --> C[定義最佳化器]
    C --> D[執行最佳化]
    D --> E[計算損失和梯度]
    E --> F[更新模型引數]
    F --> D

這個圖表展示了最佳化模型引數的過程，包括初始化模型、定義渲染函式、定義最佳化器、執行最佳化、計算損失和梯度、更新模型引數等步驟。

執行最佳化迴圈

最終目標是執行 200 次的最佳化迴圈，以達到最佳的結果。在每次迴圈中，我們會儲存當前的圖片。

最佳化迴圈

for i in range(0, 200):
    # 每 10 次迴圈印出目前的進度
    if i % 10 == 0:
        print('i = ', i)
    
    # 清除最佳化器的梯度
    optimizer.zero_grad()
    
    # 執行模型，取得損失值和圖片
    loss, image_silhouette, image_textured = model()
    
    # 反向傳播，計算梯度
    loss.backward()
    
    # 更新模型引數
    optimizer.step()
    
    # 繪製圖片
    plt.figure()
    plt.imshow(
        image_silhouette[..., 3].detach().squeeze().cpu().numpy())
    plt.title("iter: %d, loss: %0.2f" % (i, loss.data))
    plt.axis("off")
    plt.savefig(os.path.join(output_dir, 'soft_silhouette_' + str(i) + '.png'))
    plt.close()
    
    # 繪製另一個圖片
    plt.figure()
    plt.imshow(
        image_textured[..., 3].detach().squeeze().cpu().numpy())
    plt.title("iter: %d, loss: %0.2f" % (i, loss.data))
    plt.axis("off")
    plt.savefig(os.path.join(output_dir, 'textured_silhouette_' + str(i) + '.png'))
    plt.close()

圖表翻譯

此圖表示了執行最佳化迴圈的過程。每 10 次迴圈，程式會印出目前的進度，然後清除最佳化器的梯度，執行模型，計算損失值和圖片，反向傳播，更新模型引數，繪製圖片，最後儲存圖片。

內容解密

在這個程式中，我們使用了 PyTorch 的最佳化器和模型來執行最佳化迴圈。每次迴圈，我們會清除最佳化器的梯度，執行模型，計算損失值和圖片，反向傳播，更新模型引數。然後，我們會繪製圖片，最後儲存圖片。這個過程會重複 200 次，以達到最佳的結果。

圖表

  flowchart TD
    A[開始] --> B[清除最佳化器的梯度]
    B --> C[執行模型]
    C --> D[計算損失值和圖片]
    D --> E[反向傳播]
    E --> F[更新模型引數]
    F --> G[繪製圖片]
    G --> H[儲存圖片]
    H --> I[重複 200 次]

使用Python和PyTorch進行3D渲染和視覺化

在這個例子中，我們將使用Python和PyTorch進行3D渲染和視覺化。首先，我們需要匯入必要的庫，包括torch、matplotlib和numpy。

import torch
import matplotlib.pyplot as plt
import numpy as np

定義渲染器和相機引數

接下來，我們需要定義渲染器和相機引數。這包括定義相機位置、旋轉和視野。

# 定義相機位置和旋轉
camera_position = torch.tensor([1.0, 1.0, 1.0])
rotation = torch.tensor([0.5, 0.5, 0.5])

# 定義視野
fov = 30.0

進行渲染和視覺化

現在，我們可以進行渲染和視覺化。這包括使用Phong渲染器渲染3D模型，並使用Matplotlib進行視覺化。

# 定義Phong渲染器
def phong_renderer(meshes_world, R, T):
    # 渲染3D模型
    image = torch.zeros((1, 3, 256, 256))
    # ... (渲染邏輯)
    return image

# 定義視覺化函式
def visualize(image, title):
    plt.figure()
    plt.imshow(image)
    plt.title(title)
    plt.axis("off")
    plt.show()

# 進行渲染和視覺化
image = phong_renderer(meshes_world, R, T)
visualize(image, "渲染結果")

儲存渲染結果

最後，我們可以儲存渲染結果為圖片檔案。

# 儲存渲染結果
plt.savefig("渲染結果.png")

內容解密

在這個例子中，我們使用PyTorch和Matplotlib進行3D渲染和視覺化。首先，我們定義渲染器和相機引數，然後進行渲染和視覺化，最後儲存渲染結果為圖片檔案。

圖表翻譯

  graph LR
    A[定義渲染器和相機引數] --> B[進行渲染和視覺化]
    B --> C[儲存渲染結果]
    C --> D[顯示渲染結果]

在這個圖表中，我們可以看到渲染和視覺化的流程。首先，我們定義渲染器和相機引數，然後進行渲染和視覺化，最後儲存渲染結果為圖片檔案。

使用 PyTorch3D 進行 3D 重建

環境設定

首先，需要設定 PyTorch 的 GPU 環境。使用 torch.cuda.is_available() 檢查是否有可用的 GPU，如果有，則設定 GPU 裝置。

import torch

if torch.cuda.is_available():
    device = torch.device("cuda:0")
else:
    device = torch.device("cpu")

定義相機引數

接下來，定義相機引數，包括相機的數量、仰角、方位角等。

num_views = 10
azimuth_range = 180
elev = torch.linspace(0, 0, num_views)
azim = torch.linspace(-azimuth_range, azimuth_range, num_views) + 180.0

定義燈光和相機

定義燈光和相機的位置和引數。

from pytorch3d.structures import PointLights

lights = PointLights(device=device, location=[[0.0, 0.0, -3.0]])

from pytorch3d.renderer import look_at_view_transform

R, T = look_at_view_transform(dist=2.7, elev=elev, azim=azim)

from pytorch3d.renderer import FoVPerspectiveCameras

cameras = FoVPerspectiveCameras(device=device, R=R, T=T)

定義光線取樣器

定義光線取樣器，包括圖片大小、體積範圍和光線上的點數。

image_size = 64
volume_extent_world = 3.0

from pytorch3d.renderer import NDCGridRaysampler

raysampler = NDCGridRaysampler(
    image_width=image_size,
    image_height=image_size,
    n_pts_per_ray=50,
    min_depth=0.1,
    max_depth=volume_extent_world,
)

結合所有元件

現在，可以結合所有元件，包括相機、燈光、光線取樣器等，進行 3D 重建。

# ...

# 進行 3D 重建
# ...

內容解密

以上程式碼定義了 PyTorch3D 的 3D 重建流程，包括環境設定、相機引數定義、燈光和相機定義、光線取樣器定義等。這些元件是 3D 重建的基礎，需要根據具體需求進行調整和最佳化。

圖表翻譯

以下是 PyTorch3D 的 3D 重建流程圖：

  flowchart TD
    A[環境設定] --> B[相機引數定義]
    B --> C[燈光和相機定義]
    C --> D[光線取樣器定義]
    D --> E[3D 重建]

這個流程圖展示了 PyTorch3D 的 3D 重建流程，包括環境設定、相機引數定義、燈光和相機定義、光線取樣器定義和 3D 重建等步驟。

5.1 瞬時光線取樣

在前面的步驟中，我們已經確定了最佳的光線取樣器。為了讓光線取樣器沿著光線進行取樣，我們需要告訴它相機的位置和方向。這可以透過將相機的位置和方向傳遞給光線取樣器來實作。

ray_bundle = raysampler(cameras)

5.2 光線包的結構

光線包是一個包含多個 PyTorch 張量的集合，這些張量定義了取樣的光線和點。這些變數可以被打印出來，以檢查其形狀和內容。

print('光線包的原點形狀 = ', ray_bundle.origins.shape)
print('光線包的方向形狀 = ', ray_bundle.directions.shape)
print('光線包的長度形狀 = ', ray_bundle.lengths.shape)
print('光線包的 xy 位置形狀 = ', ray_bundle.xys.shape)

5.3 輸出結果

輸出結果應該如下所示：

  • ray_bundle.origins 是一個張量，代表光線的原點，大小為 10 x 64 x 64 x 3。
  • ray_bundle.directions 是一個張量，代表光線的方向，大小為 10 x 64 x 64 x 3。
  • ray_bundle.lengths 是一個張量，代表光線的長度，大小為 10 x 64 x 64 x 50。
  • ray_bundle.xys 是一個張量，代表光線的 xy 位置，大小為 10 x 64 x 64 x 2。

5.4 儲存光線包

最後，我們將光線包儲存到一個名為 ray_sampling.pt 的檔案中，以便在後面的範例中使用。

torch.save({'ray_bundle': ray_bundle}, 'ray_sampling.pt')

到目前為止，您應該已經瞭解了光線取樣器的工作原理。光線取樣器提供了一個光線包和離散的點，然而，我們還沒有定義這些點和光線的密度和顏色值。在下一節中，您將學習如何從體積中獲得這些密度和顏色值。

5.5 體積取樣

體積取樣是指從體積中獲得點的密度和顏色值的過程。由於我們使用的是離散的體積表示，因此體積取樣器中定義的點可能不會正確地落在體積的節點上。因此，需要使用插值方案來從體積的密度和顏色值中插值出點的密度和顏色值。

這可以透過 PyTorch3D 中的 VolumeSampler 來實作。以下是相關的程式碼：

import torch
from pytorch3d.structures import Volumes
from pytorch3d.renderer.implicit.renderer import VolumeSampler

# 設定裝置
if torch.cuda.is_available():
    torch.cuda.set_device(device)
else:
    # 如果沒有 CUDA 裝置，則使用 CPU
    pass

# 載入前面計算的光線包
ray_bundle = torch.load('ray_sampling.pt')['ray_bundle']

在這個例子中，我們載入了前面計算的光線包，並使用 VolumeSampler 來從體積中取樣密度和顏色值。這個過程可以用來生成高質量的影像和影片。

獨立體積渲染技術

在計算機圖學中，體積渲染是一種用於顯示3D體積資料的技術。與傳統的表面渲染不同，體積渲染可以顯示物體內部的結構和特徵。最近，人們開始關注可微分的體積渲染技術，這種技術可以將體積渲染的過程與神經網路相結合，實作端到端的學習和最佳化。

PyTorch3D 深度探索：3D 模型渲染與重建技術解析

本文深入探討如何利用 PyTorch3D 進行 3D 模型的渲染和重建，並解析其核心技術與實務應用。從環境設定到模型最佳化，我們將逐步剖析每個環節，並分享實務經驗與常見陷阱。

PyTorch3D 渲染流程解析與效能最佳化

首先，我們需要設定 PyTorch 的 GPU 環境，確保運算效率。

import torch

# 檢查 GPU 是否可用，並設定對應裝置
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

內容解密

這段程式碼檢查系統是否具備可用的 GPU，如果有的話，就使用 GPU 進行運算；否則，則使用 CPU。這樣的設計可以根據系統資源自動調整，提高程式碼的相容性。

圖表翻譯

  graph LR
    A[檢查 GPU 可用性] --> B{GPU 可用?};
    B -- Yes --> C[使用 GPU];
    B -- No --> D[使用 CPU];

此圖展示了程式碼的執行邏輯，根據 GPU 的可用性選擇運算裝置。

接著，定義相機引數，包含相機數量、視角等關鍵設定。

# 設定相機引數
num_views = 10
azimuth_range = 180
elev = torch.linspace(0, 0, num_views, device=device)
azim = torch.linspace(-azimuth_range, azimuth_range, num_views, device=device) + 180.0

內容解密

此段程式碼設定了相機引數，num_views 控制相機數量，azimuth_range 設定方位角範圍，elev 和 azim 則分別定義了仰角和方位角。值得注意的是，這裡直接將張量建立在指定的裝置上，避免了後續資料傳輸的開銷。

圖表翻譯

  graph LR
    A[設定相機數量] --> B[設定方位角範圍];
    B --> C[定義仰角];
    C --> D[定義方位角];

此圖展示了設定相機引數的流程，確保每個引數都得到正確設定。

定義燈光和相機的位置與引數。

from pytorch3d.structures import PointLights
from pytorch3d.renderer import look_at_view_transform, FoVPerspectiveCameras

# 定義燈光位置
lights = PointLights(device=device, location=[[0.0, 0.0, -3.0]])

# 計算相機的旋轉與平移矩陣
R, T = look_at_view_transform(dist=2.7, elev=elev, azim=azim)

# 定義相機
cameras = FoVPerspectiveCameras(device=device, R=R, T=T)

內容解密

這段程式碼定義了場景中的燈光和相機。PointLights 設定了點光源的位置，look_at_view_transform 函式計算了相機的旋轉和平移矩陣，FoVPerspectiveCameras 則建立了透視相機。這些設定直接影響渲染結果的真實感和準確性。

圖表翻譯

  graph LR
    A[定義燈光] --> B[計算相機變換];
    B --> C[建立相機];

此圖簡潔地展示了燈光和相機設定的流程。

光線取樣與體積渲染技術探討

定義光線取樣器，設定圖片大小、體積範圍等。

from pytorch3d.renderer import NDCGridRaysampler

image_size = 64
volume_extent_world = 3.0

# 建立光線取樣器
raysampler = NDCGridRaysampler(
    image_width=image_size,
    image_height=image_size,
    n_pts_per_ray=50,
    min_depth=0.1,
    max_depth=volume_extent_world,
)

內容解密

這段程式碼建立了一個 NDCGridRaysampler 物件，用於在正規化裝置座標系中生成光線樣本。image_size 設定了渲染圖片的解析度，volume_extent_world 定義了場景的體積範圍，n_pts_per_ray 設定了每條光線上的取樣點數。

圖表翻譯

  graph LR
    A[設定圖片大小] --> B[設定體積範圍];
    B --> C[設定取樣點數];
    C --> D[建立光線取樣器];

此圖展示了光線取樣器的設定流程，清晰明瞭。

ray_bundle = raysampler(cameras)

print('光線包的原點形狀 = ', ray_bundle.origins.shape)
print('光線包的方向形狀 = ', ray_bundle.directions.shape)
print('光線包的長度形狀 = ', ray_bundle.lengths.shape)
print('光線包的 xy 位置形狀 = ', ray_bundle.xys.shape)

torch.save({'ray_bundle': ray_bundle}, 'ray_sampling.pt')


import torch
from pytorch3d.structures import Volumes
from pytorch3d.renderer.implicit.renderer import VolumeSampler

# 設定裝置
if torch.cuda.is_available():
    torch.cuda.set_device(device)
else:
    # 如果沒有 CUDA 裝置，則使用 CPU
    pass

# 載入前面計算的光線包
ray_bundle = torch.load('ray_sampling.pt')['ray_bundle']

內容解密

這段程式碼首先使用 raysampler(cameras) 生成光線包 ray_bundle，並印出其各個屬性的形狀，包含光線原點、方向、長度和 xy 位置。接著，將 ray_bundle 儲存至檔案 ray_sampling.pt。最後，載入儲存的光線包，以便後續使用。

圖表翻譯

  graph LR
    A[生成光線包] --> B[印出光線包資訊];
    B --> C[儲存光線包];
    C --> D[載入光線包];

此圖展示了光線包的生成、儲存和載入流程。

綜觀 3D 模型渲染與重建技術的發展，PyTorch3D 提供了強大的工具和框架，簡化了開發流程。從底層的張量運算到高階的渲染器和最佳化器，PyTorch3D 都展現了高度的整合性和靈活性。然而，在實務應用中，仍需注意效能調校和資源管理，例如 GPU 記憶體的使用和運算效率的最佳化。對於追求高效能和高品質的 3D 應用開發者而言，深入理解 PyTorch3D 的核心機制至關重要。玄貓認為，PyTorch3D 代表了 3D 圖形技術發展的重要方向，值得投入更多資源進行研究和應用。隨著硬體效能的提升和軟體生態的完善，我們預見 PyTorch3D 將在更多領域發揮關鍵作用，例如虛擬實境、擴增實境和數位孿生等。未來，PyTorch3D 與其他深度學習框架的整合也將成為重要的發展趨勢，進一步拓展其應用範圍。對於臺灣的開發者來說，掌握 PyTorch3D 將有助於提升技術競爭力，並在全球 3D 技術浪潮中佔據一席之地。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。