# Load models
device = torch.device("cuda")
models = [None] * len(MODELS)
for i, m in enumerate(MODELS):
p = m['path']
if p is not MODEL_INPUT and p is not MODEL_GROUND_TRUTH:
models[i] = inference.LoadedModel(os.path.join(MODEL_DIR, p), device,
UPSCALING)
# create output folder
os.makedirs(OUTPUT_FOLDER, exist_ok=True)
# Render each dataset
for i in range(len(DATASETS)):
# create renderer
camera = inference.Camera(RESOLUTION[0], RESOLUTION[0], CAMERA_ORIGIN)
camera.currentDistance = DATASETS[i]['distance']
camera.currentPitch = DATASETS[i]['pitch']
camera.orientation = DATASETS[i]['orientation']
material = inference.Material(DATASETS[i]['iso'])
renderer_path = RENDERER_CPU if DATASETS[i]['file'].endswith(
'vdb') else RENDERER_GPU
data_dir = DATA_DIR_CPU if DATASETS[i]['file'].endswith(
'vdb') else DATA_DIR_GPU
datasetfile = os.path.join(data_dir, DATASETS[i]['file'])
print('Open', datasetfile)
renderer = inference.Renderer(renderer_path, datasetfile, material, camera)
time.sleep(5)
renderer.send_command("aoradius=%5.3f\n" % float(AO_RADIUS))
# create shading
shading = ScreenSpaceShading(torch.device('cpu'))
p = m['path']
if p is not MODEL_INPUT and p is not MODEL_GROUND_TRUTH:
models[i] = inference.LoadedModel(os.path.join(MODEL_DIR, p), device,
UPSCALING)
# Render each dataset
for i in range(len(DATASETS)):
if i > 0:
#write empty frames
empty = np.zeros((RESOLUTION[1], RESOLUTION[0], 3), dtype=np.uint8)
for j in range(EMPTY_FRAMES):
writer.append_data(empty)
background = createBackgroundImage(DATASETS[i]['name'])
# create renderer
camera = inference.Camera(CanvasWidth, CanvasHeight, CAMERA_ORIGIN)
camera.currentDistance = DATASETS[i]['distance']
material = inference.Material(DATASETS[i]['iso'])
renderer_path = RENDERER_CPU if DATASETS[i]['file'].endswith(
'vdb') else RENDERER_GPU
data_dir = DATA_DIR_CPU if DATASETS[i]['file'].endswith(
'vdb') else DATA_DIR_GPU
datasetfile = os.path.join(data_dir, DATASETS[i]['file'])
print('Open', datasetfile)
renderer = inference.Renderer(renderer_path, datasetfile, material, camera)
renderer.send_command("aoradius=%5.3f\n" % float(AO_RADIUS))
# create shading
shading = ScreenSpaceShading(torch.device('cpu'))
shading.fov(30)
shading.light_direction(np.array([0.1, 0.1, 1.0]))
shading.ambient_light_color(np.array(DATASETS[i]['ambient']) / 255.0)
MODEL_DIR = "D:/VolumeSuperResolution"
UPSCALING = 4
OUTPUT_FOLDER = 'D:/VolumeSuperResolution/comparisonVideo3' + (
"_diff" if SHOW_DIFFERENCE else "")
FPS = 25
BACKGROUND = [1, 1, 1]
RESOLUTION = (1920, 1080)
RESOLUTION_LOW = (RESOLUTION[0] // UPSCALING, RESOLUTION[1] // UPSCALING)
########################################
# Material + Camera
########################################
camera = inference.Camera(RESOLUTION[0], RESOLUTION[0], [0, 0, -1])
camera.currentDistance = 2.3
camera.currentPitch = 0.38
camera.orientation = inference.Orientation.Yp
class Scene:
file = None
isovalue = 0.36
light = "camera"
temporalConsistency = False
depthMin = None
depthMax = None
aoSamples = 4 #256 #4
aoRadius = 0.05
def benchmark(scene):
DEBUG = False
IMAGE_EXPORT = [(512, 512)] #[(2**9, 1024)] # screen, volume resolution
#SETTINGS
SCREEN_RESOLUTIONS = [2**i for i in range(6, 12)]
print("Screen resolutions: ", SCREEN_RESOLUTIONS)
MIN_VOLUME_RESOLUTION = 32
NUM_SAMPLES = 50
NETWORK_DIR = "D:/VolumeSuperResolution/adaptive-dvr-modeldir/"
NETWORK = ("network", NETWORK_DIR + "adapDvr5-rgb-temp001-perc01-epoch500")
VOLUME_FOLDER = "../../isosurface-super-resolution-data/volumes/cvol-filtered/"
SAMPLING_FILE = "D:/VolumeSuperResolution-InputData/samplingPattern.hdf5"
SETTINGS_FOLDER = "../network/video/"
device_cpu = torch.device("cpu")
device_gpu = torch.device("cuda")
# load sampling pattern
print("load sampling patterns")
SAMPLING_PATTERNS = ['halton', 'plastic', 'random', 'regular']
with h5py.File(SAMPLING_FILE, 'r') as f:
SAMPLING_PATTERN = torch.from_numpy(
f['plastic'][...]).to(device_gpu).unsqueeze(0)
# load networks
print("Load networks")
importanceNetwork = ImportanceModel(NETWORK, device_gpu)
reconNetwork = ReconstructionModel(NETWORK, device_gpu)
# scenes
if scene == 1:
# EJECTA 512
VOLUME = "snapshot_272_512.cvol"
STEPSIZE = 0.125
POSITION_SAMPLER = lambda: (1.1**0.3) * randomPointOnSphere()
SETTINGS = "Dvr-Ejecta-settings.json"
UPSCALING = 8
POSTPROCESS = importance.PostProcess(0.001, 0.05, 1, 0, 'basic')
IMAGE_PATH = "exportDvrEjecta512_%d_%d_%d.png"
OUTPUT_FILE = "../result-stats/DvrBenchmarkEjecta512.tsv"
elif scene == 2:
# RM
VOLUME = "ppmt273_1024.cvol"
STEPSIZE = 0.25
def rmPositionSampler():
pos = (1.1**0.3) * randomPointOnSphere()
pos[2] = -abs(pos[2])
return pos
POSITION_SAMPLER = rmPositionSampler
SETTINGS = "Dvr-RM-settings.json"
UPSCALING = 8
POSTPROCESS = importance.PostProcess(0.001, 0.05, 1, 0, 'basic')
IMAGE_PATH = "exportDvrRM1024_%d_%d_%d.png"
OUTPUT_FILE = "../result-stats/DvrBenchmarkRM1024.tsv"
elif scene == 3:
# RM
VOLUME = "cleveland70.cvol"
STEPSIZE = 0.25
POSITION_SAMPLER = lambda: (1.1**2.4) * randomPointOnSphere()
SETTINGS = "Dvr-Thorax-settings.json"
UPSCALING = 8
POSTPROCESS = importance.PostProcess(0.001, 0.05, 1, 0, 'basic')
IMAGE_PATH = "exportDvrThorax512_%d_%d_%d.png"
OUTPUT_FILE = "../result-stats/DvrBenchmarkThorax512.tsv"
###################################################
######## RUN BECHMARK##############################
###################################################
# no gradients anywhere
torch.set_grad_enabled(False)
# load volume
err = torch.ops.renderer.load_volume_from_binary(VOLUME_FOLDER + VOLUME)
assert err == 1
resX, resY, resZ = torch.ops.renderer.get_volume_resolution()
print("volume resolution:", resX, resY, resZ)
minRes = max(resX, resY, resZ)
numMipmapLevels = 0
while minRes >= MIN_VOLUME_RESOLUTION:
numMipmapLevels += 1
minRes = minRes // 2
print("Num mipmap levels:", numMipmapLevels)
# load settings
settings = inference.RenderSettings()
camera = inference.Camera(512, 512, [0, 0, -1])
with open(SETTINGS_FOLDER + SETTINGS, "r") as f:
o = json.load(f)
settings.from_dict(o)
camera.from_dict(o['Camera'])
settings.update_camera(camera)
settings.RENDER_MODE = 2
# run scenes
start = torch.cuda.Event(enable_timing=True)
end = torch.cuda.Event(enable_timing=True)
with open(OUTPUT_FILE, "w") as stat_file:
stat_file.write(
"VolumeResolution\tScreenResolution\tRenderingLowMillis\tImportanceMillis\tRenderingSamplesMillis\tReconstructionMillis\tRenderingHighMillis\tSamplePercentage\n"
)
with std_out_err_redirect_tqdm() as orig_stdout:
for mipmapLevel in range(numMipmapLevels):
# load mipmap level
if mipmapLevel > 0:
torch.ops.renderer.create_mipmap_level(
mipmapLevel, "average")
settings.MIPMAP_LEVEL = mipmapLevel
volumeResolution = max(resX, resY, resZ) / (2**mipmapLevel)
for resolution in SCREEN_RESOLUTIONS:
settings.RESOLUTION = [resolution, resolution]
settings.VIEWPORT = [0, 0, resolution, resolution]
print("volume resolution: %d, screen resolution %d" %
(volumeResolution, resolution))
# loop over sample positions
renderingLowMillis = 0
importanceMillis = 0
renderingSamplesMillis = 0
reconstructionMillis = 0
renderingHighMillis = 0
samplePercentage = 0
for i in trange(NUM_SAMPLES,
desc='Samples',
file=orig_stdout,
dynamic_ncols=True,
leave=True):
pos = list(POSITION_SAMPLER())
settings.CAM_ORIGIN_START = pos
settings.CAM_ORIGIN_END = pos
settings.send()
render_settings = settings.clone()
render_settings.send()
# high
torch.cuda.synchronize()
start.record()
high_res = torch.ops.renderer.render()
end.record()
torch.cuda.synchronize()
renderingHighMillis += start.elapsed_time(end)
if (resolution, volumeResolution) in IMAGE_EXPORT:
filename = IMAGE_PATH % (resolution,
volumeResolution, i)
image = high_res[0:3, :, :]
image = image.detach().cpu().numpy().transpose(
(1, 2, 0))
imageio.imwrite(filename, image)
print("Image saved to %s" % filename)
# low
settingsTmp = settings.clone()
settingsTmp.downsampling = UPSCALING
settingsTmp.send()
torch.cuda.synchronize()
start.record()
low_res = torch.ops.renderer.render()
end.record()
torch.cuda.synchronize()
renderingLowMillis += start.elapsed_time(end)
# prepare for importance map
low_res = low_res.unsqueeze(0)
low_res_input = low_res[:, :-2, :, :]
previous_input = torch.zeros(
1,
1,
low_res_input.shape[2] *
importanceNetwork.networkUpscaling(),
low_res_input.shape[3] *
importanceNetwork.networkUpscaling(),
dtype=low_res_input.dtype,
device=low_res_input.device)
# compute importance map
torch.cuda.synchronize()
start.record()
importance_map = importanceNetwork.call(
low_res_input[:, 0:5, :, :], previous_input)
end.record()
torch.cuda.synchronize()
importanceMillis += start.elapsed_time(end)
if len(importance_map.shape) == 3:
importance_map = importance_map.unsqueeze(1)
if DEBUG:
print("importance map min=%f, max=%f" %
(torch.min(importance_map),
torch.max(importance_map)))
# prepare sampling
settings.send()
pattern = SAMPLING_PATTERN[:, :importance_map.
shape[-2], :importance_map.
shape[-1]]
normalized_importance_map = POSTPROCESS(
importance_map)[0]
if DEBUG:
print("normalized importance map min=%f, max=%f" %
(torch.min(normalized_importance_map),
torch.max(normalized_importance_map)))
print("pattern min=%f, max=%f" %
(torch.min(pattern), torch.max(pattern)))
sampling_mask = normalized_importance_map > pattern
sample_positions = torch.nonzero(sampling_mask[0].t_())
sample_positions = sample_positions.to(
torch.float32).transpose(0, 1).contiguous()
samplePercentage += sample_positions.size(1) / (
importance_map.shape[-2] *
importance_map.shape[-1])
if DEBUG:
print("sample count: %d" %
sample_positions.size(1))
# do the sampling
torch.cuda.synchronize()
start.record()
sample_data = torch.ops.renderer.render_samples(
sample_positions)
reconstruction_input = torch.ops.renderer.scatter_samples(
sample_positions, sample_data, resolution,
resolution, [0] * 10)
end.record()
torch.cuda.synchronize()
renderingSamplesMillis += start.elapsed_time(end)
# reconstruction
reconstruction_input = reconstruction_input[:
9, :, :].unsqueeze(
0)
previous_input = torch.zeros(
1,
8,
reconstruction_input.shape[2],
reconstruction_input.shape[3],
dtype=reconstruction_input.dtype,
device=reconstruction_input.device)
torch.cuda.synchronize()
start.record()
reconNetwork.call(reconstruction_input, sampling_mask,
previous_input)
end.record()
torch.cuda.synchronize()
reconstructionMillis += start.elapsed_time(end)
# write stats
renderingLowMillis /= NUM_SAMPLES
importanceMillis /= NUM_SAMPLES
renderingSamplesMillis /= NUM_SAMPLES
reconstructionMillis /= NUM_SAMPLES
renderingHighMillis /= NUM_SAMPLES
samplePercentage /= NUM_SAMPLES
stat_file.write(
"%d\t%d\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\n" %
(volumeResolution, resolution, renderingLowMillis,
importanceMillis, renderingSamplesMillis,
reconstructionMillis, renderingHighMillis,
samplePercentage))
stat_file.flush()
# Render each dataset
for i in range(len(DATASETS)):
#output
outputFolder = os.path.join(OUTPUT_FOLDER, DATASETS[i]['name'])
os.makedirs(outputFolder, exist_ok = True)
statistics = open(os.path.join(outputFolder, "AA_AllFrames.txt"), "w")
statistics.write("Origin\tRotation\t" +
"\t".join((m['name']+"-PSNR-normal\t"+m['name']+"-PSNR-color\t"+m['name']+"-SSIM-normal\t"+m['name']+"-SSIM-color") for m in MODELS) +
"\n")
# create renderer
material = inference.Material(DATASETS[i]['iso'])
renderer_path = RENDERER_CPU if DATASETS[i]['file'].endswith('vdb') else RENDERER_GPU
data_dir = DATA_DIR_CPU if DATASETS[i]['file'].endswith('vdb') else DATA_DIR_GPU
datasetfile = os.path.join(data_dir, DATASETS[i]['file'])
print('Open', datasetfile)
renderer = inference.Renderer(renderer_path, datasetfile, material, inference.Camera(RESOLUTION[0], RESOLUTION[1]))
time.sleep(5)
renderer.send_command("aoradius=%5.3f\n"%float(AO_RADIUS))
# create shading
shading = ScreenSpaceShading(torch.device('cpu'))
shading.fov(30)
shading.light_direction(np.array([0.1,0.1,1.0]))
shading.ambient_light_color(np.array(DATASETS[i]['ambient'])/255.0)
shading.diffuse_light_color(np.array(DATASETS[i]['diffuse'])/255.0)
shading.specular_light_color(np.array(DATASETS[i]['specular'])/255.0)
shading.specular_exponent(SPECULAR_EXPONENT)
shading.material_color(np.array(DATASETS[i]['material'])/255.0)
shading.ambient_occlusion(AO_STRENGTH)
shading.background(np.array(BACKGROUND))
# prepare running stats