def get_data_occ(im1, im2, flow_f, flow_b, name, cbn, occt, vmap_f, vmap_b):
outsz = flow_f.get_shape()
outsz = tf.stack([outsz[1], outsz[2]])
vmap_f = tf.image.resize_images(
vmap_f, size=outsz, method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
vmap_b = tf.image.resize_images(
vmap_b, size=outsz, method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
im1_ = backwarp.backwarper(im2, flow_f, outsz, name=name + 'forward')
im2_ = backwarp.backwarper(im1, flow_b, outsz, name=name + 'backward')
occ_f, occ_b = occlusion(flow_f, flow_b)
# get the robust difference
loss_f = occ_weighted_diff(im1,
im1_,
occ_f,
vmap=vmap_f,
cbn=cbn,
occt=occt)
loss_b = occ_weighted_diff(im2,
im2_,
occ_b,
vmap=vmap_b,
cbn=cbn,
occt=occt)
loss = tf.add(loss_f, loss_b)
return loss
def random_rotate_scale_translate_no_edge(img1s,
img2s,
flows,
imsize,
name='Rand_R_S_T',
RMAX=17.0,
SMIN=0.9,
SMAX=2.0,
TMAX=0.2,
RMAX0=3.0,
SMIN0=0.9,
SMAX0=1.1,
TMAX0=0.03):
"""
flows : float, defined on img1, shape: [B, H, W, 2]
imsize : [H, W], default in form of numpy array
"""
with tf.variable_scope(name):
batchsize = tf.shape(img1s)[0]
W = imsize[1]
A, A_ = rand_affine(minR=-RMAX,
maxR=RMAX,
minS=SMIN,
maxS=SMAX,
minT=-TMAX * W,
maxT=TMAX * W)
A0, A0_ = rand_affine(minR=-RMAX0,
maxR=RMAX0,
minS=SMIN0,
maxS=SMAX0,
minT=-TMAX0 * W,
maxT=TMAX0 * W)
ff1 = aff_flow(A_, imsize, batchsize)
img1s_ = backwarp.backwarper(img1s, ff1, imsize, name='img1s_')
#edge1s_= backwarp.backwarper( edge1s,ff1, imsize, name='edge1s_')
valid_map = tf.ones(
shape=tf.stack([batchsize, imsize[0], imsize[1], 1]))
valid_map = backwarp.backwarper(valid_map,
ff1,
imsize,
name='valid_map')
gx = backwarp.backwarper(flows, ff1, imsize, name='warped_flow')
flows_ = flow_transform(A0, A, gx, imsize)
A_A0_ = tf.matmul(A_, A0_)
ff2 = aff_flow(A_A0_, imsize, batchsize)
img2s_ = backwarp.backwarper(img2s, ff2, imsize, name='img2s_')
#edge2s_= backwarp.backwarper( edge2s,ff2, imsize, name='edge2s_')
valid_map_b = tf.ones(
shape=tf.stack([batchsize, imsize[0], imsize[1], 1]))
valid_map_b = backwarp.backwarper(valid_map_b,
ff2,
imsize,
name='valid_map_b')
return img1s_, img2s_, flows_, valid_map, valid_map_b
def get_data_term(im1,
im2,
flow,
vmap,
name='data_term',
epsilon=0.001,
cbn=0.5):
epsilon = tf.convert_to_tensor(epsilon)
# get flow's size and resize im1, im2
outsz = flow.get_shape()
outsz = tf.stack([outsz[1], outsz[2]])
#im1 = tf.image.resize_images( im1, size=outsz )
#im2 = tf.image.resize_images( im2, size=outsz )
vmap = tf.image.resize_images(vmap, size=outsz)
im1_ = backwarp.backwarper(im2, flow, outsz, name=name)
# get the robust difference
diff = tf.subtract(im1, im1_) # [B, H, W, 3]
diff = tf.add(tf.square(diff), tf.square(epsilon))
diff = tf.pow(diff, tf.convert_to_tensor(cbn), name='chamboneir')
diff = tf.reduce_sum(diff, axis=3, keep_dims=True) # [B, H, W, 1]
# vmap is also [B, H, W, 1]
diff = tf.multiply(vmap, diff)
loss = tf.reduce_sum(diff)
return loss
def occlusion(flow_f, flow_b):
outsz = flow_f.get_shape()
outsz = tf.stack([outsz[1], outsz[2]])
flow_f_ = backwarp.backwarper(flow_b, flow_f, outsz, name='flow_b_to_f')
flow_b_ = backwarp.backwarper(flow_f, flow_b, outsz, name='flow_f_to_b')
mag_sq_f = length_sq(flow_f) + length_sq(flow_f_)
mag_sq_b = length_sq(flow_b) + length_sq(flow_b_)
flow_diff_f = flow_f + flow_f_
flow_diff_b = flow_b + flow_b_
occ_thresh_f = tf.add(tf.multiply(tf.constant(0.01 * 1), mag_sq_f),
tf.constant(0.5 * 10))
occ_thresh_b = tf.add(tf.multiply(tf.constant(0.01 * 1), mag_sq_b),
tf.constant(0.5 * 10))
occ_f = tf.cast(length_sq(flow_diff_f) > occ_thresh_f, tf.float32)
occ_b = tf.cast(length_sq(flow_diff_b) > occ_thresh_b, tf.float32)
return occ_f, occ_b # occ=1, covisible=0
def sup_backwarp_target_image(flow, imH, imW, img2, ratio, name):
with tf.variable_scope(name) as scope:
flow_ = tf.multiply(flow, tf.constant(20.0))
flow_ = tf.image.resize_images(flow_,
size=[imH, imW],
align_corners=True)
flow_ = tf.multiply(flow_, tf.convert_to_tensor(ratio))
img2_wp = backwarp.backwarper(img2,
flow_,
imsize=[imH, imW],
name=name)
return img2_wp
def backwarp_target_image(flow, imH, imW, img2, name):
with tf.variable_scope(name) as scope:
flow_ = tf.image.resize_images(flow,
size=[imH, imW],
align_corners=True)
ratio = tf.cast(imH / tf.shape(flow)[1], 'float32')
flow_ = tf.multiply(ratio, flow_)
img2_wp = backwarp.backwarper(img2,
flow_,
imsize=[imH, imW],
name=name)
return img2_wp