how to generate the .pickle file?

[max2857]

Hi, i want to ask how to convert the HDR image generated by the original transient rendering project into the required .pickle file?

[guoqi1123]

Hello! Here is a function that I used to generate transient rendering and then save it into a .pickle file. Hope it helps!

`
def data_create(cam,cam_t,scene,scene_t,program):

# create transient renderer and ground truth
data_dir = './dataset/*/'
lpickle = len(glob.glob(data_dir))
t = time.time()
idx = int(np.random.rand(1)*1e6)
folder = './dataset/'+("%10d" % t)+("%06d" % idx)+'/'
savename = folder+'data.pickle'
filename = folder+'prop'
filename_true = folder+'true'


if not os.path.exists(folder):
	os.makedirs(folder)


## ground truth
cmd_t = gen_cmd(program,cam_t,scene_t,filename_true)
os.system(cmd_t) 


## visualize the ground truth
depth_true = imageio.imread(filename_true+'_depth.hdr')
XX_true,YY_true,ZZ_true = map2mesh(depth_true[:,:,0],cam_t)
# write the true depth map into an image
tmp = cv2.cvtColor(ZZ_true.astype(np.float32),cv2.COLOR_GRAY2BGR)
cv2.imwrite(filename_true+'_depth.png',ZZ_true/ZZ_true.max()*255)


# impulse response
cmd = gen_cmd(program,cam,scene,filename)
os.system(cmd)


fig = plt.figure()
ax = fig.add_subplot(1,2,1,projection='3d')
ax.plot_surface(XX_true,YY_true,ZZ_true,cmap='jet')
ax.view_init(-60,-90)


ax = fig.add_subplot(1,2,2)
ax.imshow(ZZ_true,cmap='jet',interpolation='nearest')
plt.draw()


## read the data and visualize the impulse response
prop = np.empty((cam['dimy'],cam['dimx'],cam['dimt']))
for i in range(cam['dimy']):
	tmp = imageio.imread(filename+("_%04d.hdr" % i))
	prop[cam['dimy']-i-1,:,:] = np.sum(tmp,2)

  # choose those non-zeros and compress them using sparse mat
prop_idx = np.where(prop!=0)
prop_idx = [prop_idx[i].astype(np.int32) for i in range(3)]
prop_s = prop[prop!=0]




for i in range(prop.shape[2]):
	# write the propagation into images
	cv2.imwrite(folder+("%04d.png" % i),prop[:,:,i]*1e4)



## save all data
with open(savename,'wb') as f:
	data = {
		'program'	:	program,
		'cam' 		:	cam,
		'cam_t'		:	cam_t,
		'scene'		:	scene,
		'scene_t'	:	scene_t,
		'XX_true'	:	XX_true,
		'YY_true'	:	YY_true,
		'ZZ_true'	:	ZZ_true,
		'depth_true':	depth_true[:,:,0],
		'cmd'		:	cmd,
		'cmd_t'		:	cmd_t,
		'prop'		:	prop,
                     'prop_idx'        :       prop_idx,
	}
	pickle.dump(data,f)
return`

[max2857]

Thank you for your reply. The .pickle file generated by this function should be missing 'prop_idx'?

[max2857]

In addition, how you set the rendering parameters when generating transient rendering, such as 'camera_samples', 'max_bounces' and so on.

[guoqi1123]

Thank you for your reply. The .pickle file generated by this function should be missing 'prop_idx'?

My bad. I just updated the function to include the prop_idx. It is just a binary sparse matrix showing where the light has hit in the scene at each time frame.

[guoqi1123]

In addition, how you set the rendering parameters when generating transient rendering, such as 'camera_samples', 'max_bounces' and so on.

Here is the function that includes all hyperparameters:

`def params_create(setup):
## film and rendering parameters
cam = {}

cam['mode']='' # the renderer mode
cam['vptsamp']=1024 # sample per ray in bidirectional path tracing
cam['dimx']=512 # x dimension of the camera film
cam['dimy']=424 # y dimension of the camera film
cam['ratio']=cam['dimy']/cam['dimx'] # height over width ratio
cam['size']=[cam['ratio'],1] # sensor size
cam['dimt']=1000 # t dimension of transient rendering
cam['toffset']=0 # time offset in picosecond
cam['exp']=50 # exposure time in pico second for each time frame
cam['tsamp']=[] # whether to do time sampling
cam['single_pixel']=[] # whether to do single pixel film
cam['bouncing']=[] # whether to do multi-bounce streak film

## camera parameters: currently assuming pin-hole
cam['lookat']=[0,0,0] # where the camera is looking at
cam['vp'] = 0.714074 # camera's view plane distance
cam['up'] = [0,1,0] # camera's up vector
cam['spp'] = 1 # camera sample per pixel

 ## ground truth camera
cam_t = deepcopy(cam)
cam_t['mode']='-steady-state' # the renderer mode
cam_t['vptsamp']=8
cam_t['dimx']*=4
cam_t['dimy']*=4

# camera positions: they should be random and far from each other
rs = np.array([2,4]) # radii
ang = np.random.rand(rs.shape[0],1000,2)*2*PI # angles

# compute positions
pos = np.array([\
	[[rs[i]*np.sin(ang[i,j,0])*np.cos(ang[i,j,1]),\
	rs[i]*np.sin(ang[i,j,0])*np.sin(ang[i,j,1]),\
	rs[i]*np.cos(ang[i,j,0])]
	for j in range(ang.shape[1])\
	]\
	for i in range(rs.shape[0])
])
pos = np.abs(pos) # only look from the first octant

# kmeans clustering
pos_c = []
for i in range(pos.shape[0]):
	kmeans = KMeans(n_clusters=3).fit(pos[i,:,:])
	pos_c.append(kmeans.cluster_centers_)
	# normalize
	for j in range(pos_c[-1].shape[0]):
		pos_c[-1][j,:] /= np.sqrt(np.sum(pos_c[-1][j,:]**2))
		pos_c[-1][j,:] *= rs[i]
pos_c = np.concatenate(pos_c).tolist()

# pos_c = np.tile([[1.15,1.15,1.15]],[100,1]).tolist()

# pos_c = np.array([
# 	[i/10.,0,0] for i in range(5,50,1)
# ]).tolist()

# # used for plane 
# for i in range(len(pos_c)):
# 	pos_c[i][1]=0
# 	pos_c[i][2]=0

# # visualization
# fig = plt.figure()
# ax = fig.add_subplot(1,1,1,projection='3d')
# ax.scatter(pos_c[:][0],pos_c[:][1],pos_c[:][2],cmap='jet')
# ax.set_aspect('equal','box')
# plt.show()

scene = {}
scene['setup'] = setup
scene['scatlevel'] = 'all' # choice: all, multiple, once, none

scene['media']=[0.,0.] # the property of medium in the scene: -homogeneous-medium
scene['hg']=0.0 # parameter for heyney greenstein phase function

## miscellaneous
program='trans_render.exe'

# a list of data
cams = []
cam_ts = []
scenes = []
scene_ts = []
programs = []

# create camera setup array
for i in range(len(pos_c)):
	cams.append(deepcopy(cam))
	cam_ts.append(deepcopy(cam_t))
	scenes.append(deepcopy(scene))
	programs.append(deepcopy(program))

	# camera location
	cams[i]['pos'] = pos_c[i][:]
	cam_ts[i]['pos'] = pos_c[i][:]
	
	## light source
	light_dir = np.cross(\
		cams[i]['up'], \
		np.array(cams[i]['pos'])-np.array(cams[i]['lookat'])\
	) # light is on the right
	light_dir /= np.sqrt(np.sum(light_dir**2))
	light_dist = [0.03,0.03+0.015,0.03+0.015*2]

	scenes[i]['light'] = []
	for j in range(len(light_dist)):
		scenes[i]['light'].append('-point-light-source')
		scenes[i]['light'].append(cams[i]['pos']+light_dir*light_dist[j]) # position
		scenes[i]['light'].append(.4) # brightness

	# define different light source for the true depth
	scene_ts.append(deepcopy(scenes[i]))
	scene_ts[i]['light']=[]
	scene_ts[i]['light'].append('-point-light-source')
	scene_ts[i]['light'].append(cams[i]['pos'])
	scene_ts[i]['light'].append(.4) # brightness

return cams,cam_ts,scenes,scene_ts,programs

`

[max2857]

Thank you for the information!