forked from SizheAn/PanoHead
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathgen_mesh.py
142 lines (117 loc) · 6.5 KB
/
gen_mesh.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
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 mrcfile
import legacy
from camera_utils import LookAtPoseSampler, FOV_to_intrinsics
from torch_utils import misc
from training.triplane import TriPlaneGenerator
def generate_images(
network_pkl: str,
w: torch.ndarray,
truncation_psi: float,
truncation_cutoff: int,
outdir: str,
shapes: bool,
shape_res: int,
fov_deg: float,
shape_format: str,
class_idx: Optional[int],
reload_modules: bool,
pose_cond: int,
):
"""Generate a mesh using pretrained network pickle and a provided w vector
Examples:
\b
# Generate an image using pre-trained model.
python gen_samples.py --outdir=out --trunc=0.7 --shapes=true --seeds=0-3 \
--network models/easy-khair-180-gpc0.8-trans10-025000.pkl
"""
print('Loading networks from "%s"...' % network_pkl)
device = torch.device('cuda:0')
with dnnlib.util.open_url(network_pkl) as f:
G = legacy.load_network_pkl(f)['G_ema'].to(device) # type: ignore
# Specify reload_modules=True if you want code modifications to take effect; otherwise uses pickled code
if reload_modules:
print("Reloading Modules!")
G_new = TriPlaneGenerator(*G.init_args, **G.init_kwargs).eval().requires_grad_(False).to(device)
misc.copy_params_and_buffers(G, G_new, require_all=True)
G_new.neural_rendering_resolution = G.neural_rendering_resolution
G_new.rendering_kwargs = G.rendering_kwargs
G = G_new
network_pkl = os.path.basename(network_pkl)
outdir = os.path.join(outdir, os.path.splitext(network_pkl)[0] + '_' + str(pose_cond))
os.makedirs(outdir, exist_ok=True)
pose_cond_rad = pose_cond/180*np.pi
intrinsics = FOV_to_intrinsics(fov_deg, device=device)
# Generate images.
for seed_idx, seed in enumerate(seeds):
print('Generating image for seed %d (%d/%d) ...' % (seed, seed_idx, len(seeds)))
# cond camera settings
cam_pivot = torch.tensor([0, 0, 0], device=device)
cam_radius = G.rendering_kwargs.get('avg_camera_radius', 2.7)
conditioning_cam2world_pose = LookAtPoseSampler.sample(pose_cond_rad, np.pi/2, cam_pivot, radius=cam_radius, device=device)
conditioning_params = torch.cat([conditioning_cam2world_pose.reshape(-1, 16), intrinsics.reshape(-1, 9)], 1)
# z and w
z = torch.from_numpy(np.random.RandomState(seed).randn(1, G.z_dim)).to(device)
# z1 = torch.from_numpy(np.random.RandomState(44).randn(1, G.z_dim)).to(device)
# ws_list = []
# ws_list.append(G.mapping(torch.from_numpy(np.random.RandomState(0).randn(1, G.z_dim)).to(device), conditioning_params, truncation_psi=truncation_psi, truncation_cutoff=truncation_cutoff))
# ws_list.append(G.mapping(torch.from_numpy(np.random.RandomState(0).randn(1, G.z_dim)).to(device), conditioning_params, truncation_psi=truncation_psi, truncation_cutoff=truncation_cutoff))
# ws_list.append(G.mapping(z1, conditioning_params, truncation_psi=truncation_psi, truncation_cutoff=truncation_cutoff))
imgs = []
angle_p = -0.2
# for angle_y, angle_p in [(2.1, angle_p), (1.05, angle_p), (0, angle_p), (-1.05, angle_p), (-2.1, angle_p)]:
for idx, angles in enumerate([(0, angle_p), (-45/180*np.pi, angle_p), (-90/180*np.pi, angle_p), (-135/180*np.pi, angle_p), (-np.pi, angle_p)]):
angle_y = angles[0]
angle_p = angles[1]
# rand camera setting
cam2world_pose = LookAtPoseSampler.sample(np.pi/2 + angle_y, np.pi/2 + angle_p, cam_pivot, radius=cam_radius, device=device)
camera_params = torch.cat([cam2world_pose.reshape(-1, 16), intrinsics.reshape(-1, 9)], 1)
ws = G.mapping(z, conditioning_params, truncation_psi=truncation_psi, truncation_cutoff=truncation_cutoff)
# img = G.synthesis(ws, camera_params, ws_bcg = ws_list[idx])['image']
img = G.synthesis(ws, camera_params)['image']
img = (img.permute(0, 2, 3, 1) * 127.5 + 128).clamp(0, 255).to(torch.uint8)
imgs.append(img)
img = torch.cat(imgs, dim=2)
PIL.Image.fromarray(img[0].cpu().numpy(), 'RGB').save(f'{outdir}/seed{seed:04d}.png')
if shapes:
# extract a shape.mrc with marching cubes. You can view the .mrc file using ChimeraX from UCSF.
max_batch=1000000
samples, voxel_origin, voxel_size = create_samples(N=shape_res, voxel_origin=[0, 0, 0], cube_length=G.rendering_kwargs['box_warp'] * 1)#.reshape(1, -1, 3)
samples = samples.to(z.device)
sigmas = torch.zeros((samples.shape[0], samples.shape[1], 1), device=z.device)
transformed_ray_directions_expanded = torch.zeros((samples.shape[0], max_batch, 3), device=z.device)
transformed_ray_directions_expanded[..., -1] = -1
head = 0
with tqdm(total = samples.shape[1]) as pbar:
with torch.no_grad():
while head < samples.shape[1]:
torch.manual_seed(0)
sigma = G.sample(samples[:, head:head+max_batch], transformed_ray_directions_expanded[:, :samples.shape[1]-head], z, conditioning_params, truncation_psi=truncation_psi, truncation_cutoff=truncation_cutoff, noise_mode='const')['sigma']
sigmas[:, head:head+max_batch] = sigma
head += max_batch
pbar.update(max_batch)
sigmas = sigmas.reshape((shape_res, shape_res, shape_res)).cpu().numpy()
sigmas = np.flip(sigmas, 0)
# Trim the border of the extracted cube
pad = int(30 * shape_res / 256)
pad_value = -1000
sigmas[:pad] = pad_value
sigmas[-pad:] = pad_value
sigmas[:, :pad] = pad_value
sigmas[:, -pad:] = pad_value
sigmas[:, :, :pad] = pad_value
sigmas[:, :, -pad:] = pad_value
if shape_format == '.ply':
from shape_utils import convert_sdf_samples_to_ply
convert_sdf_samples_to_ply(np.transpose(sigmas, (2, 1, 0)), [0, 0, 0], 1, os.path.join(outdir, f'seed{seed:04d}.ply'), level=10)
elif shape_format == '.mrc': # output mrc
with mrcfile.new_mmap(os.path.join(outdir, f'seed{seed:04d}.mrc'), overwrite=True, shape=sigmas.shape, mrc_mode=2) as mrc:
mrc.data[:] = sigmas