def step_1(x, t, dt): # from numpy array to uni file vel_fn = os.path.join(sim_dir, 'vel_%04d.uni') density_fn = os.path.join(sim_dir, 'density_%04d.uni') xr = x.reshape(1, 64, 64, 3) np_density = xr[:, :, :, [0]] np_vel = zeros((1, 64, 64, 3)) # manta takes 3d velocities np_vel[:, :, :, :2] = xr[:, :, :, 1:] uniio.writeUni(density_fn % (t / dt), generate_header(np_density), np_density) uniio.writeUni(vel_fn % (t / dt), generate_header(np_vel), np_vel) # loading written data to state density.load(density_fn % (t / dt)) vel.load(vel_fn % (t / dt)) # applying model euler_step() # writing to uni density.save(density_fn % ((t + dt) / dt)) vel.save(vel_fn % ((t + dt) / dt)) # loading back as numpy array _, np_density = uniio.readUni(density_fn % ((t + dt) / dt)) _, np_vel = uniio.readUni(vel_fn % ((t + dt) / dt)) xn = zeros((xr.shape[0], 64, 64, 3)) xn[:, :, :, [0]] = np_density xn[:, :, :, 1:] = np_vel[:, :, :, :2] # manta takes 3d velocities xn = xn.reshape(1, 3 * 64 * 64) return xn
def get_data_next_batch(data_x_addrs,
data_y_addrs,
ibatch,
batch_size,
export=False):
data_x = []
data_y = []
for i in range(ibatch * batch_size, ibatch * batch_size + batch_size):
if os.path.isfile(data_x_addrs[i]) and os.path.isfile(data_y_addrs[i]):
# grid_x = read_streamline_txt(data_x_addrs[i])
grid_x = read_streamline_bin(data_x_addrs[i])
uni_header, grid_y = uniio.readUni(data_y_addrs[i])
# binarify levelset grid: should not include zero(ex. crop levelset grid is 0 everywhere)
grid_y = np.array(grid_y < 0.0, dtype='float32')
data_x.append(grid_x)
data_y.append(grid_y)
# export sketch and levelset file to check if the two grid data are aligned correctly
# the visulization routine is in cpp file!
if (export):
uniio.writeUni('../VisFluid/data/sketch_{:04}.uni'.format(i),
uni_header, grid_x)
uniio.writeUni('../VisFluid/data/levelset_{:04}.uni'.format(i),
uni_header, grid_y)
else:
print('{:} or {:} does not exists!'.format(data_x_addrs[i],
data_y_addrs[i]))
data_x = np.asarray(data_x, dtype='float32')
data_y = np.asarray(data_y, dtype='float32')
return data_x, data_y
def arrayToUni(input, savePath, motherUniPath, imageHeight, imageWidth, is_vel=False): head, _ = uniio.readUni(motherUniPath) head['dimX'] = imageWidth head['dimY'] = imageHeight if not is_vel: fixedArray = np.zeros((imageHeight, imageWidth), dtype='f') for x in range(0, imageHeight): for y in range(0, imageWidth): fixedArray[x][y] = input[(imageHeight - 1) - x][y] else: fixedArray = np.zeros((imageHeight, imageWidth, 3), dtype='f') for x in range(0, imageHeight): for y in range(0, imageWidth): fixedArray[x][y] = input[(imageHeight - 1) - x][y] uniio.writeUni(savePath, head, fixedArray)
def get_data_next_batch(data_addrs, ibatch, batch_size, export=False):
data_streamline_occ = []
data_streamline_vel = []
data_grid_lvst = []
data_grid_vel = []
for i in range(ibatch * batch_size, ibatch * batch_size + batch_size):
(data_sketch_addr, data_lvst_addr, data_vel_addr) = data_addrs[i]
if os.path.isfile(data_sketch_addr) and os.path.isfile(
data_lvst_addr) and os.path.isfile(data_vel_addr):
grid_sketch_occ = read_streamline_bin(data_sketch_addr)
header_lvst, grid_lvst = uniio.readUni(data_lvst_addr)
header_vel, grid_vel = uniio.readUni(data_vel_addr)
# clean the velocity field, using levelset as mask(must be same as the streamline program!)
fluid_mask = (grid_lvst <= 1.0)
grid_vel = grid_vel * fluid_mask
# extract streamline velocity
grid_sketch_vel = grid_sketch_occ * grid_vel
# binarify levelset grid: should not include zero(ex. crop levelset grid is 0 everywhere)
grid_lvst = np.array(grid_lvst < 0.0, dtype='float32')
data_streamline_occ.append(grid_sketch_occ)
data_streamline_vel.append(grid_sketch_vel)
data_grid_lvst.append(grid_lvst)
data_grid_vel.append(grid_vel)
# export sketch and levelset file to check if the two grid data are aligned correctly
# the visulization routine is in cpp file!
if (export):
uniio.writeUni(
'../VisFluid/data/sketch_occ_{:04}.uni'.format(i),
header_lvst, grid_sketch_occ)
uniio.writeUni(
'../VisFluid/data/sketch_vel_{:04}.uni'.format(i),
header_vel, grid_sketch_vel)
uniio.writeUni('../VisFluid/data/levelset_{:04}.uni'.format(i),
header_lvst, grid_lvst)
uniio.writeUni('../VisFluid/data/vel_{:04}.uni'.format(i),
header_vel, grid_vel)
else:
print('{:} or {:} does not exists!'.format(data_sketch_addr,
data_lvst_addr))
data_streamline_occ = np.asarray(data_streamline_occ, dtype='float32')
data_streamline_vel = np.asarray(data_streamline_vel, dtype='float32')
data_grid_lvst = np.asarray(data_grid_lvst, dtype='float32')
data_grid_vel = np.asarray(data_grid_vel, dtype='float32')
# concatenate occupancy field and velocity field
data_streamline = np.concatenate(
(data_streamline_occ, data_streamline_vel), axis=-1)
data_grid = np.concatenate((data_grid_lvst, data_grid_vel), axis=-1)
return data_streamline, data_grid
def surface_reconstruction_from_levelset_update(threshold_value, result_dir,
mat_dir, manta_dir,
sketch_addr, lvst_addr,
vel_addr):
addr_lvst = lvst_addr
filename_lvst = addr_lvst[int(addr_lvst.rfind(os.sep) +
1):int(addr_lvst.rfind('.'))]
frame_num = filename_lvst[int(filename_lvst.rfind('_')) + 1:]
addr_lvst_pre = addr_lvst[0:int(addr_lvst.rfind(os.sep))]
addr_lvst_pre_pre = addr_lvst_pre[0:int(addr_lvst_pre.rfind(os.sep))]
simname = addr_lvst_pre[int(addr_lvst_pre.rfind(os.sep) + 1):]
addr_sketch = sketch_addr
addr_sketch_pre = addr_sketch[0:int(addr_sketch.rfind(os.sep))]
addr_sketch_pre_pre = addr_sketch_pre[0:int(addr_sketch_pre.rfind(os.sep))]
seed_num = addr_sketch_pre_pre[int(addr_sketch_pre_pre.rfind(os.sep) + 1):]
# load the original predict levelset and velocity
outpath_pred_lvst = os.path.join(
result_dir, seed_num + '#' + simname + '#' + filename_lvst + '_pred')
predict_vec = np.load(outpath_pred_lvst + '.npy')
predict_occ = predict_vec[:, :, :, 0]
predict_vel = predict_vec[:, :, :, 1:4]
predict_lvst_copy = np.copy(predict_occ)
predict_lvst_copy[predict_occ <= threshold_value] = 0.5 # outside
predict_lvst_copy[predict_occ > threshold_value] = -0.5 # inside
predict_lvst_copy = np.ascontiguousarray(predict_lvst_copy,
dtype=np.float32)
uniio.writeUni(outpath_pred_lvst + '.uni', header_example,
predict_lvst_copy)
phi.load(outpath_pred_lvst + '.uni')
phi.createMesh(mesh)
# for iters in range(3):
# smoothMesh(mesh=mesh, strength=1e-3, steps=10)
# subdivideMesh(mesh=mesh, minAngle=0.01, minLength=0.5, maxLength=3*0.5, cutTubes=True)
mesh.save(outpath_pred_lvst + '.obj')
os.remove(outpath_pred_lvst + '.uni')
def manta_animate_from_reconstruction(result_dir, mat_dir, manta_dir,
sketch_addr, lvst_addr, vel_addr,
cur_frame, doOpen):
outdir = './demo/' + '%04d/' % cur_frame
if not os.path.exists(outdir):
os.makedirs(outdir)
addr_lvst = lvst_addr
filename_lvst = addr_lvst[int(addr_lvst.rfind(os.sep) +
1):int(addr_lvst.rfind('.'))]
frame_num = filename_lvst[int(filename_lvst.rfind('_')) + 1:]
addr_lvst_pre = addr_lvst[0:int(addr_lvst.rfind(os.sep))]
addr_lvst_pre_pre = addr_lvst_pre[0:int(addr_lvst_pre.rfind(os.sep))]
simname = addr_lvst_pre[int(addr_lvst_pre.rfind(os.sep) + 1):]
addr_sketch = sketch_addr
addr_sketch_pre = addr_sketch[0:int(addr_sketch.rfind(os.sep))]
addr_sketch_pre_pre = addr_sketch_pre[0:int(addr_sketch_pre.rfind(os.sep))]
seed_num = addr_sketch_pre_pre[int(addr_sketch_pre_pre.rfind(os.sep) + 1):]
# copy the streamline and original mesh
src_line = os.path.join(mat_dir, seed_num, simname,
'flipStreamline_' + frame_num + '_resampled.txt')
dst_line = os.path.join(
outdir, seed_num + '#' + simname + '#' + 'flipStreamline_' +
frame_num + '_resampled.txt')
copyfile(src_line, dst_line)
src_mesh = os.path.join(manta_dir, simname, 'flip_' + frame_num + '.gz')
dst_mesh = os.path.join(outdir,
simname + '#' + 'flip_' + frame_num + '.gz')
copyfile(src_mesh, dst_mesh)
# load the predict levelset and velocity
outpath_pred_lvst = os.path.join(
result_dir, seed_num + '#' + simname + '#' + filename_lvst + '_pred')
predict_vec = np.load(outpath_pred_lvst + '.npy')
predict_occ = predict_vec[:, :, :, 0]
predict_vel = predict_vec[:, :, :, 1:4]
# mantaflow fluid simulation here
global flags, phi, mesh_fluid, phiFluidIn, vel
bWidth = 1
flags.initDomain(boundaryWidth=bWidth, phiWalls=phiObs)
if doOpen:
setOpenBound(flags, bWidth, 'xXyYzZ', FlagOutflow | FlagEmpty)
phi.initFromFlags(flags)
# load fluid volume (obj file from reconstruction)
mesh_fluid.load(outpath_pred_lvst + '.obj')
print('mesh {} loaded successfully'.format(outpath_pred_lvst + '.obj'))
mesh_fluid.scale(vec3(args.res, args.res, args.res))
mesh_fluid.offset(vec3(args.res, args.res, args.res) * 0.5)
mesh_fluid.computeLevelset(phiFluidIn, 2.)
phi.join(phiFluidIn)
# load the fluid velocity
predict_vel_copy = np.copy(predict_vel)
predict_vel_copy = np.ascontiguousarray(predict_vel_copy, dtype=np.float32)
uniio.writeUni(outdir + 'vel.uni', header_vel_example, predict_vel_copy)
vel_fluid.load(outdir + 'vel.uni')
vel.copyFrom(vel_fluid)
global pp, pvel, s, steps
# update flag and sample particles
flags.updateFromLevelset(phi)
sampleLevelsetWithParticles(phi=phi,
flags=flags,
parts=pp,
discretization=2,
randomness=0.05)
mapGridToPartsVec3(source=vel, parts=pp, target=pVel)
if GUI:
gui = Gui()
gui.show()
gui.setCamPos(0., 0., -2)
gui.setCamRot(0, 0, 0)
# gui.pause()
for t in range(steps):
maxVel = vel.getMax()
s.adaptTimestep(maxVel)
mantaMsg('\nFrame %i, timestep %f, timeTotal %f' %
(s.frame, s.timestep, s.timeTotal))
flip(t)
s.step()
phi.createMesh(mesh)
if saveData:
# vel.save(outdir + 'flipVel_%04d.uni' % t)
# pp.save( outdir + 'flipParts_%04d.uni' % t )
# phi.save(outdir + 'flipLevelSet_%04d.uni' % t)
mesh.save(outdir + 'flip_%04d.gz' % t)
gui.screenshot(outdir + 'flip_%04d.png' % t)
def surface_reconstruction_from_levelset(threshold_value, result_dir, mat_dir,
manta_dir, batch, batch_size, iepoch,
filetype, sketch_addrs, lvst_addrs,
vel_addrs):
sketch_file = os.path.join(result_dir,
'{}_input_{}.npy'.format(filetype, batch))
gt_file = os.path.join(result_dir,
'{}_output_{}.npy'.format(filetype, batch))
predict_file = os.path.join(
result_dir, '{}_predict_{}_{}.npy'.format(filetype, batch, iepoch))
input_data = np.load(sketch_file)
gt_data = np.load(gt_file)
predict_data = np.load(predict_file)
# each .npy contains batch_size frames
for i in range(batch_size):
gt_vec = gt_data[i]
predict_vec = predict_data[i]
gt_occ = gt_vec[:, :, :, 0]
gtt_vel = gt_vec[:, :, :, 1:4]
predict_occ = predict_vec[:, :, :, 0]
predict_vel = predict_vec[:, :, :, 1:4]
# the corresponding filename and sim folder
addr_lvst = lvst_addrs[i]
filename_lvst = addr_lvst[int(addr_lvst.rfind(os.sep) +
1):int(addr_lvst.rfind('.'))]
frame_num = filename_lvst[int(filename_lvst.rfind('_')) + 1:]
addr_lvst_pre = addr_lvst[0:int(addr_lvst.rfind(os.sep))]
addr_lvst_pre_pre = addr_lvst_pre[0:int(addr_lvst_pre.rfind(os.sep))]
simname = addr_lvst_pre[int(addr_lvst_pre.rfind(os.sep) + 1):]
addr_sketch = sketch_addrs[i]
addr_sketch_pre = addr_sketch[0:int(addr_sketch.rfind(os.sep))]
addr_sketch_pre_pre = addr_sketch_pre[
0:int(addr_sketch_pre.rfind(os.sep))]
seed_num = addr_sketch_pre_pre[
int(addr_sketch_pre_pre.rfind(os.sep) + 1):]
# print(seed_num, simname, filename_lvst, frame_num)
# groundtruth
gt_occ_copy = np.copy(gt_occ)
gt_occ_copy[gt_occ <= threshold_value] = 0.5 # outside
gt_occ_copy[gt_occ > threshold_value] = -0.5 # inside
gt_occ_copy = np.ascontiguousarray(gt_occ_copy, dtype=np.float32)
outpath_gt_lvst = os.path.join(
result_dir,
seed_num + '#' + simname + '#' + filename_lvst + '_recons')
uniio.writeUni(outpath_gt_lvst + '.uni', header_example, gt_occ_copy)
phi.load(outpath_gt_lvst + '.uni')
phi.createMesh(mesh)
# for iters in range(3):
# smoothMesh(mesh=mesh, strength=1e-3, steps=10)
# subdivideMesh(mesh=mesh, minAngle=0.01, minLength=0.5, maxLength=3*0.5, cutTubes=True)
mesh.save(outpath_gt_lvst + '.obj')
os.remove(outpath_gt_lvst + '.uni')
# prediction
predict_lvst_copy = np.copy(predict_occ)
predict_lvst_copy[predict_occ <= threshold_value] = 0.5 # outside
predict_lvst_copy[predict_occ > threshold_value] = -0.5 # inside
predict_lvst_copy = np.ascontiguousarray(predict_lvst_copy,
dtype=np.float32)
outpath_pred_lvst = os.path.join(
result_dir,
seed_num + '#' + simname + '#' + filename_lvst + '_pred')
# save current frame for update later
np.save(outpath_pred_lvst + '.npy', predict_vec)
uniio.writeUni(outpath_pred_lvst + '.uni', header_example,
predict_lvst_copy)
phi.load(outpath_pred_lvst + '.uni')
phi.createMesh(mesh)
# for iters in range(3):
# smoothMesh(mesh=mesh, strength=1e-3, steps=10)
# subdivideMesh(mesh=mesh, minAngle=0.01, minLength=0.5, maxLength=3*0.5, cutTubes=True)
mesh.save(outpath_pred_lvst + '.obj')
os.remove(outpath_pred_lvst + '.uni')
# the streamline and original mesh
src_line = os.path.join(
mat_dir, seed_num, simname,
'flipStreamline_' + frame_num + '_resampled.txt')
dst_line = os.path.join(
result_dir, seed_num + '#' + simname + '#' + 'flipStreamline_' +
frame_num + '_resampled.txt')
copyfile(src_line, dst_line)
src_mesh = os.path.join(manta_dir, simname,
'flip_' + frame_num + '.gz')
dst_mesh = os.path.join(result_dir,
simname + '#' + 'flip_' + frame_num + '.gz')
copyfile(src_mesh, dst_mesh)
print('job: batch {:d} done'.format(batch))
header['gridType'] = 12
header['elementType'] = 2
header['bytesPerElement'] = 12
header[
'info'] = b'mantaflow 0.12 64bit fp1 omp commit 15eaf4aa72da62e174df6c01f85ccd66fde20acc from Aug 14 2018, 15:47:38\x00\x90\xb2PI0\x7f\x00\x00\xf8\x8e\x0eP0\x7f\x00\x00\n\x00\x00\x00\x00\x00\x00\x00f\x8b:]0\x7f\x00\x00@\xb6PI0\x7f\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\xb0\xb1PI0\x7f\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00 \x00\x00\x000\x00\x00\x00\x90\xb2PI0\x7f\x00\x00\xd0\xb1PI0\x7f\x00\x00\x10\xb6PI0\x7f\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x068*0\x7f\x00\x00\x10\xb6PI0\x7f\x00\x00\xf0\xb5PI0\x7f\x00\x00\xf0\xb5PI0\x7f\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00 \xb6PI'
else:
raise NotImplementedError('Does not correspond to density or velocity')
header['dimT'] = 0
header['timestamp'] = int(time.time())
return header
# sanity check
uniio.writeUni('test.uni', generate_header(content1), content1)
_, content1_new = uniio.readUni('test.uni')
print((content1 != content1_new).sum())
uniio.writeUni('test.uni', generate_header(content2), content2)
_, content2_new = uniio.readUni('test.uni')
print((content2 != content2_new).sum())
# print(dir(uniio))
exit()
res = 64
dim = 2
offset = 20
interval = 1
scaleFactor = 4
def generate3DUniForNewNetwork(imageindex=0,
outPath='../',
inputPer=3.0,
head=None):
start = time.time()
dim_output = []
intermed_res1 = []
batch_xs_tile = x_3d[imageindex]
if not load_model_test_1 == -1:
# z y x -> 2d conv on y - x (or different combination of axis, depending on transposeAxis)
# and switch velocity channels depending on orientation
if transposeAxis == 1:
batch_xs_in = np.reshape(
scipy.ndimage.zoom(batch_xs_tile, [1, upRes, 1, 1],
order=1,
mode='constant',
cval=0.0),
[-1, simSizeHigh, simSizeLow, n_inputChannels])
batch_xs_in = np.reshape(batch_xs_in.transpose(
1, 0, 2, 3), (-1, simSizeLow, simSizeLow, n_inputChannels))
temp_vel = np.copy(batch_xs_in[:, :, :, 3:4])
batch_xs_in[:, :, :, 3:4] = np.copy(batch_xs_in[:, :, :, 2:3])
batch_xs_in[:, :, :, 2:3] = np.copy(temp_vel)
elif transposeAxis == 2:
batch_xs_in = np.reshape(
scipy.ndimage.zoom(batch_xs_tile, [1, 1, upRes, 1],
order=1,
mode='constant',
cval=0.0),
[-1, simSizeLow, simSizeHigh, n_inputChannels])
batch_xs_in = np.reshape(batch_xs_in.transpose(
2, 1, 0, 3), (-1, simSizeLow, simSizeLow, n_inputChannels))
temp_vel = np.copy(batch_xs_in[:, :, :, 3:4])
batch_xs_in[:, :, :, 3:4] = np.copy(batch_xs_in[:, :, :, 1:2])
batch_xs_in[:, :, :, 1:2] = np.copy(temp_vel)
elif transposeAxis == 3:
batch_xs_in = np.reshape(
scipy.ndimage.zoom(batch_xs_tile, [1, 1, upRes, 1],
order=1,
mode='constant',
cval=0.0),
[-1, simSizeLow, simSizeHigh, n_inputChannels])
batch_xs_in = np.reshape(batch_xs_in.transpose(
2, 0, 1, 3), (-1, simSizeLow, simSizeLow, n_inputChannels))
temp_vel = np.copy(batch_xs_in[:, :, :, 3:4])
temp_vel2 = np.copy(batch_xs_in[:, :, :, 2:3])
batch_xs_in[:, :, :, 3:4] = np.copy(batch_xs_in[:, :, :, 1:2])
batch_xs_in[:, :, :, 2:3] = np.copy(temp_vel)
batch_xs_in[:, :, :, 1:2] = np.copy(temp_vel2)
else:
batch_xs_in = np.reshape(
scipy.ndimage.zoom(batch_xs_tile, [upRes, 1, 1, 1],
order=1,
mode='constant',
cval=0.0),
[-1, simSizeLow, simSizeLow, n_inputChannels])
if add_adj_idcs1:
batch_xs_in = np.concatenate(
(batch_xs_in, np.zeros_like(batch_xs_in[:, :, :, 0:1])),
axis=3)
batch_xs_in = np.concatenate(
(batch_xs_in, np.zeros_like(batch_xs_in[:, :, :, 0:1])),
axis=3)
for i in range(batch_xs_in.shape[0]):
if i == 0:
batch_xs_in[i:i + 1, :, :,
n_inputChannels:n_inputChannels +
1] = np.zeros_like(batch_xs_in[i:i + 1, :, :,
0:1])
batch_xs_in[i:i + 1, :, :,
n_inputChannels + 1:n_inputChannels +
2] = batch_xs_in[i + 1:i + 2, :, :, 0:1]
elif i == batch_xs_in.shape[0] - 1:
batch_xs_in[i:i + 1, :, :,
n_inputChannels:n_inputChannels +
1] = batch_xs_in[i - 1:i, :, :, 0:1]
batch_xs_in[i:i + 1, :, :,
n_inputChannels + 1:n_inputChannels +
2] = np.zeros_like(batch_xs_in[i - 1:i, :, :,
0:1])
else:
batch_xs_in[i:i + 1, :, :,
n_inputChannels:n_inputChannels +
1] = batch_xs_in[i - 1:i, :, :, 0:1]
batch_xs_in[i:i + 1, :, :,
n_inputChannels + 1:n_inputChannels +
2] = batch_xs_in[i + 1:i + 2, :, :, 0:1]
# start generating output of first network
batch_sz_out = 8
run_metadata = tf.RunMetadata()
start = time.time()
for j in range(0, batch_xs_in.shape[0] // batch_sz_out):
# x in shape (z,y,x,c)
# -> 512 x 512 x 512
results = sess.run(sampler,
feed_dict={
x:
batch_xs_in[j * batch_sz_out:(j + 1) *
batch_sz_out].reshape(
-1, n_input),
percentage:
inputPer,
train:
False
})
intermed_res1.extend(results)
# exact timing of network performance...
if 0:
fetched_timeline = timeline.Timeline(run_metadata.step_stats)
chrome_trace = fetched_timeline.generate_chrome_trace_format()
with open('timeline_8x_%04d.json' % (j), 'w') as f:
f.write(chrome_trace)
end = time.time()
print("time for first network: {0:.6f}".format(end - start))
dim_output = np.copy(
np.array(intermed_res1).reshape(simSizeHigh, simSizeHigh,
simSizeHigh)).transpose(2, 1, 0)
save_img_3d(
outPath + 'source_1st_{:04d}.png'.format(imageindex + frame_min),
dim_output / 80)
if not load_model_test_2 == -1:
if transposeAxis == 3:
batch_xs_in = np.reshape(
scipy.ndimage.zoom(batch_xs_tile, [1, upRes, 1, 1],
order=1,
mode='constant',
cval=0.0),
[-1, simSizeHigh, simSizeLow, n_inputChannels])
batch_xs_in = np.reshape(batch_xs_in.transpose(
1, 0, 2, 3), (-1, simSizeLow, simSizeLow, n_inputChannels))
temp_vel = np.copy(batch_xs_in[:, :, :, 3:4])
batch_xs_in[:, :, :, 3:4] = np.copy(batch_xs_in[:, :, :, 2:3])
batch_xs_in[:, :, :, 2:3] = np.copy(temp_vel)
elif transposeAxis == 0:
batch_xs_in = np.reshape(
scipy.ndimage.zoom(batch_xs_tile, [1, 1, upRes, 1],
order=1,
mode='constant',
cval=0.0),
[-1, simSizeLow, simSizeHigh, n_inputChannels])
batch_xs_in = np.reshape(batch_xs_in.transpose(
2, 1, 0, 3), (-1, simSizeLow, simSizeLow, n_inputChannels))
temp_vel = np.copy(batch_xs_in[:, :, :, 3:4])
batch_xs_in[:, :, :, 3:4] = np.copy(batch_xs_in[:, :, :, 1:2])
batch_xs_in[:, :, :, 1:2] = np.copy(temp_vel)
elif transposeAxis == 1:
batch_xs_in = np.reshape(
scipy.ndimage.zoom(batch_xs_tile, [1, 1, upRes, 1],
order=1,
mode='constant',
cval=0.0),
[-1, simSizeLow, simSizeHigh, n_inputChannels])
batch_xs_in = np.reshape(batch_xs_in.transpose(
2, 0, 1, 3), (-1, simSizeLow, simSizeLow, n_inputChannels))
temp_vel = np.copy(batch_xs_in[:, :, :, 3:4])
temp_vel2 = np.copy(batch_xs_in[:, :, :, 2:3])
batch_xs_in[:, :, :, 3:4] = np.copy(batch_xs_in[:, :, :, 1:2])
batch_xs_in[:, :, :, 2:3] = np.copy(temp_vel)
batch_xs_in[:, :, :, 1:2] = np.copy(temp_vel2)
else:
batch_xs_in = np.reshape(
scipy.ndimage.zoom(batch_xs_tile, [upRes, 1, 1, 1],
order=1,
mode='constant',
cval=0.0),
[-1, simSizeLow, simSizeLow, n_inputChannels])
if add_adj_idcs2:
batch_xs_in = np.concatenate(
(batch_xs_in, np.zeros_like(batch_xs_in[:, :, :, 0:1])),
axis=3)
for i in range(batch_xs_in.shape[0]):
if i == 0:
batch_xs_in[i:i + 1, :, :,
n_inputChannels:n_inputChannels +
1] = np.zeros_like(batch_xs_in[i:i + 1, :, :,
0:1])
batch_xs_in[i:i + 1, :, :,
n_inputChannels + 1:n_inputChannels +
2] = batch_xs_in[i + 1:i + 2, :, :, 0:1]
elif i == batch_xs_in.shape[0] - 1:
batch_xs_in[i:i + 1, :, :,
n_inputChannels:n_inputChannels +
1] = batch_xs_in[i - 1:i, :, :, 0:1]
batch_xs_in[i:i + 1, :, :,
n_inputChannels + 1:n_inputChannels +
2] = np.zeros_like(batch_xs_in[i - 1:i, :, :,
0:1])
else:
batch_xs_in[i:i + 1, :, :,
n_inputChannels:n_inputChannels +
1] = batch_xs_in[i - 1:i, :, :, 0:1]
batch_xs_in[i:i + 1, :, :,
n_inputChannels + 1:n_inputChannels +
2] = batch_xs_in[i + 1:i + 2, :, :, 0:1]
intermed_res1 = []
batch_sz_out = 2
start = time.time()
for j in range(0, batch_xs_in.shape[0] // batch_sz_out):
# x in shape (z,y,x,c)
# -> 64 x 256 x 256
results = sess.run(
sampler_2,
feed_dict={
x:
batch_xs_in[j * batch_sz_out:(j + 1) *
batch_sz_out].reshape(-1, n_input),
y:
dim_output[j * batch_sz_out:(j + 1) *
batch_sz_out].reshape(-1, n_output),
percentage:
inputPer,
train:
False
})
intermed_res1.extend(results)
# exact timing of network performance...
if 0:
fetched_timeline = timeline.Timeline(run_metadata.step_stats)
chrome_trace = fetched_timeline.generate_chrome_trace_format()
with open('timeline_8x_%04d.json' % (j), 'w') as f:
f.write(chrome_trace)
end = time.time()
print("time for second network: {0:.6f}".format(end - start))
dim_output = np.array(intermed_res1).reshape(simSizeHigh, simSizeHigh,
simSizeHigh).transpose(
1, 2, 0)
save_img_3d(
outPath + 'source_2nd_{:04d}.png'.format(imageindex + frame_min),
dim_output / 80)
if not load_model_test_3 == -1:
if transposeAxis == 0:
batch_xs_in = np.reshape(
scipy.ndimage.zoom(batch_xs_tile, [1, upRes, 1, 1],
order=1,
mode='constant',
cval=0.0),
[-1, simSizeHigh, simSizeLow, n_inputChannels])
batch_xs_in = np.reshape(batch_xs_in.transpose(
1, 0, 2, 3), (-1, simSizeLow, simSizeLow, n_inputChannels))
temp_vel = np.copy(batch_xs_in[:, :, :, 3:4])
batch_xs_in[:, :, :, 3:4] = np.copy(batch_xs_in[:, :, :, 2:3])
batch_xs_in[:, :, :, 2:3] = np.copy(temp_vel)
elif transposeAxis == 3:
batch_xs_in = np.reshape(
scipy.ndimage.zoom(batch_xs_tile, [1, 1, upRes, 1],
order=1,
mode='constant',
cval=0.0),
[-1, simSizeLow, simSizeHigh, n_inputChannels])
batch_xs_in = np.reshape(batch_xs_in.transpose(
0, 2, 1, 3), (-1, simSizeLow, simSizeLow, n_inputChannels))
temp_vel = np.copy(batch_xs_in[:, :, :, 2:3])
batch_xs_in[:, :, :, 2:3] = np.copy(batch_xs_in[:, :, :, 1:2])
batch_xs_in[:, :, :, 1:2] = np.copy(temp_vel)
elif transposeAxis == 2:
batch_xs_in = np.reshape(
scipy.ndimage.zoom(batch_xs_tile, [1, 1, upRes, 1],
order=1,
mode='constant',
cval=0.0),
[-1, simSizeLow, simSizeHigh, n_inputChannels])
batch_xs_in = np.reshape(batch_xs_in.transpose(
1, 2, 0, 3), (-1, simSizeLow, simSizeLow, n_inputChannels))
temp_vel = np.copy(batch_xs_in[:, :, :, 3:4])
temp_vel2 = np.copy(batch_xs_in[:, :, :, 13])
batch_xs_in[:, :, :, 3:4] = np.copy(batch_xs_in[:, :, :, 2:3])
batch_xs_in[:, :, :, 2:3] = np.copy(batch_xs_in[:, :, :, 1:2])
batch_xs_in[:, :, :, 1:2] = np.copy(temp_vel)
else:
batch_xs_in = np.reshape(
scipy.ndimage.zoom(batch_xs_tile, [upRes, 1, 1, 1],
order=1,
mode='constant',
cval=0.0),
[-1, simSizeLow, simSizeLow, n_inputChannels])
if add_adj_idcs3:
batch_xs_in = np.concatenate(
(batch_xs_in, np.zeros_like(batch_xs_in[:, :, :, 0:1])),
axis=3)
for i in range(batch_xs_in.shape[0]):
if i == 0:
batch_xs_in[i:i + 1, :, :,
n_inputChannels:n_inputChannels +
1] = np.zeros_like(batch_xs_in[i:i + 1, :, :,
0:1])
batch_xs_in[i:i + 1, :, :,
n_inputChannels + 1:n_inputChannels +
2] = batch_xs_in[i + 1:i + 2, :, :, 0:1]
elif i == batch_xs_in.shape[0] - 1:
batch_xs_in[i:i + 1, :, :,
n_inputChannels:n_inputChannels +
1] = batch_xs_in[i - 1:i, :, :, 0:1]
batch_xs_in[i:i + 1, :, :,
n_inputChannels + 1:n_inputChannels +
2] = np.zeros_like(batch_xs_in[i - 1:i, :, :,
0:1])
else:
batch_xs_in[i:i + 1, :, :,
n_inputChannels:n_inputChannels +
1] = batch_xs_in[i - 1:i, :, :, 0:1]
batch_xs_in[i:i + 1, :, :,
n_inputChannels + 1:n_inputChannels +
2] = batch_xs_in[i + 1:i + 2, :, :, 0:1]
intermed_res1 = []
batch_sz_out = 2
start = time.time()
for j in range(0, batch_xs_in.shape[0] // batch_sz_out):
# x in shape (z,y,x,c)
# -> 64 x 256 x 256
results = sess.run(
sampler_3,
feed_dict={
x:
batch_xs_in[j * batch_sz_out:(j + 1) *
batch_sz_out].reshape(-1, n_input),
y:
dim_output[j * batch_sz_out:(j + 1) *
batch_sz_out].reshape(-1, n_output),
percentage:
inputPer,
train:
False
})
intermed_res1.extend(results)
# exact timing of network performance...
if 0:
fetched_timeline = timeline.Timeline(run_metadata.step_stats)
chrome_trace = fetched_timeline.generate_chrome_trace_format()
with open('timeline_8x_%04d.json' % (j), 'w') as f:
f.write(chrome_trace)
end = time.time()
print("time for third network: {0:.6f}".format(end - start))
dim_output = np.array(intermed_res1).reshape(simSizeHigh, simSizeHigh,
simSizeHigh)
save_img_3d(
outPath + 'source_3rd_{:04d}.png'.format(imageindex + frame_min),
dim_output / 80)
if not load_model_no_2 == -1:
dim_output = dim_output.transpose(2, 0, 1)
if not load_model_no_1 == -1:
dim_output = dim_output.transpose(2, 1, 0)
# output for images of slices (along every dimension)
if 1:
for i in range(simSizeHigh // 2 - 1, simSizeHigh // 2 + 1):
if np.average(dim_output[i]) > 0.0001:
save_img(outPath + 'slice_xy_{:04d}_{:04d}.png'.format(
i, (imageindex + frame_min)),
dim_output[i]) #.transpose(2,1,0)
save_img(
outPath + 'slice_yz_{:04d}_{:04d}.png'.format(
i, (imageindex + frame_min)),
dim_output.transpose(2, 1, 0)[i])
save_img(
outPath + 'slice_xz_{:04d}_{:04d}.png'.format(
i, (imageindex + frame_min)),
dim_output.transpose(1, 0, 2)[i])
if (imageindex + frame_min) == 110:
for i in range(0, tileSizeHigh):
if np.average(dim_output[i]) > 0.0001:
save_img(outPath + 'slice_xy_{:04d}_{:04d}.png'.format(
(imageindex + frame_min), i),
dim_output[i]) #.transpose(2,1,0)
save_img(
outPath + 'slice_yz_{:04d}_{:04d}.png'.format(
(imageindex + frame_min), i),
dim_output.transpose(2, 1, 0)[i])
save_img(
outPath + 'slice_xz_{:04d}_{:04d}.png'.format(
(imageindex + frame_min), i),
dim_output.transpose(1, 0, 2)[i])
if head is None:
head, _ = uniio.readUni(packedSimPath +
"sim_%04d/density_low_%04d.uni" % (fromSim, 0))
head['dimX'] = simSizeHigh
head['dimY'] = simSizeHigh
head['dimZ'] = simSizeHigh
if generateUni:
# set low density to zero to save storage space...
cond_out = dim_output < 0.0005
dim_output[cond_out] = 0
uniio.writeUni(
packedSimPath + '/sim_%04d/source_%04d.uni' %
(fromSim, imageindex + frame_min), head, dim_output)
print('stored .uni file')
return
def surface_reconstruction_from_levelset(threshold_value, result_dir, mat_dir, manta_dir, ibatch, batch_size, iepoch, filetype, sketch_addrs, lvst_addrs):
sketch_files = os.path.join(result_dir, '{}_input_{}.npy'.format(filetype, ibatch))
gt_files = os.path.join(result_dir, '{}_output_{}.npy'.format(filetype, ibatch))
predict_files = os.path.join(result_dir, '{}_predict_{}_{}.npy'.format(filetype, ibatch, iepoch))
sketch_grid_data = np.load(sketch_files)
gt_lvst_grid_data = np.load(gt_files)
predict_lvst_grid_data = np.load(predict_files)
# each .npy contains batch_size frames
for i in range(batch_size):
# the levelset grid is binarified during training
gt_lvst = gt_lvst_grid_data[i]
predict_lvst = predict_lvst_grid_data[i]
# the corresponding filename and sim folder
addr_lvst = lvst_addrs[i]
filename_lvst = addr_lvst[int(addr_lvst.rfind(os.sep)+1):int(addr_lvst.rfind('.'))]
frame_num = filename_lvst[int(filename_lvst.rfind('_'))+1:]
addr_lvst_pre = addr_lvst[0:int(addr_lvst.rfind(os.sep))]
addr_lvst_pre_pre = addr_lvst_pre[0:int(addr_lvst_pre.rfind(os.sep))]
simname = addr_lvst_pre[int(addr_lvst_pre.rfind(os.sep)+1):]
addr_sketch = sketch_addrs[i]
addr_sketch_pre = addr_sketch[0:int(addr_sketch.rfind(os.sep))]
addr_sketch_pre_pre = addr_sketch_pre[0:int(addr_sketch_pre.rfind(os.sep))]
seed_num = addr_sketch_pre_pre[int(addr_sketch_pre_pre.rfind(os.sep)+1):]
# print(seed_num, simname, filename_lvst, frame_num)
# groundtruth
# gt_lvst_copy = gt_lvst: Does not make a copy of gt_lvst, it merely creates a new reference to gt_lvst name!!!!
gt_lvst_copy = np.copy(gt_lvst)
gt_lvst_copy[gt_lvst<=threshold_value] = 0.5 # outside
gt_lvst_copy[gt_lvst>threshold_value] = -0.5 # inside
gt_lvst_copy = np.ascontiguousarray(gt_lvst_copy, dtype=np.float32)
outpath_gt_lvst = os.path.join(result_dir, seed_num+'#'+simname+'#'+filename_lvst+'_recons')
uniio.writeUni(outpath_gt_lvst +'.uni', header_example, gt_lvst_copy)
phi.load(outpath_gt_lvst +'.uni')
phi.createMesh(mesh)
# for iters in range(3):
# smoothMesh(mesh=mesh, strength=1e-3, steps=10)
# subdivideMesh(mesh=mesh, minAngle=0.01, minLength=0.5, maxLength=3*0.5, cutTubes=True)
mesh.save(outpath_gt_lvst +'.obj')
os.remove(outpath_gt_lvst +'.uni')
# prediction
predict_lvst_copy = np.copy(predict_lvst)
predict_lvst_copy[predict_lvst<=threshold_value] = 0.5 # outside
predict_lvst_copy[predict_lvst>threshold_value] = -0.5 # inside
predict_lvst_copy = np.ascontiguousarray(predict_lvst_copy, dtype=np.float32)
outpath_pred_lvst = os.path.join(result_dir, seed_num+'#'+simname+'#'+filename_lvst+'_pred')
uniio.writeUni(outpath_pred_lvst +'.uni', header_example, predict_lvst_copy)
phi.load(outpath_pred_lvst +'.uni')
phi.createMesh(mesh)
# for iters in range(3):
# smoothMesh(mesh=mesh, strength=1e-3, steps=10)
# subdivideMesh(mesh=mesh, minAngle=0.01, minLength=0.5, maxLength=3*0.5, cutTubes=True)
mesh.save(outpath_pred_lvst +'.obj')
os.remove(outpath_pred_lvst +'.uni')
# the streamline and original mesh
src_line = os.path.join(mat_dir, seed_num, simname, 'flipStreamline_'+frame_num+'_resampled.txt')
dst_line = os.path.join(result_dir, seed_num+'#'+simname+'#'+'flipStreamline_'+frame_num+'_resampled.txt')
copyfile(src_line, dst_line)
src_mesh = os.path.join(manta_dir, simname, 'flip_'+frame_num+'.gz')
dst_mesh = os.path.join(result_dir, simname+'#'+'flip_'+frame_num+'.gz')
copyfile(src_mesh, dst_mesh)
print('job: ibatch {:d} done'.format(ibatch))
