Spaces:
Sleeping
Sleeping
| import torch | |
| import numpy as np | |
| from .sobel2 import SobelLayer, SeperateSobelLayer | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| def image_warp(image, flow): | |
| ''' | |
| image: 上一帧的图片,torch.Size([1, 3, 256, 256]) | |
| flow: 光流, torch.Size([1, 2, 256, 256]) | |
| final_grid: torch.Size([1, 2, 256, 256]) | |
| ''' | |
| b, c, h, w = image.size() | |
| device = image.device | |
| flow = torch.cat([flow[:, 0:1, :, :] / ((w - 1.0) / 2.0), flow[:, 1:2, :, :] / ((h - 1.0) / 2.0)], | |
| dim=1) # normalize to [-1~1](from upper left to lower right | |
| flow = flow.permute(0, 2, 3, | |
| 1) # if you wanna use grid_sample function, the channel(band) shape of show must be in the last dimension | |
| x = np.linspace(-1, 1, w) | |
| y = np.linspace(-1, 1, h) | |
| X, Y = np.meshgrid(x, y) | |
| grid = torch.cat((torch.from_numpy(X.astype('float32')).unsqueeze(0).unsqueeze(3), | |
| torch.from_numpy(Y.astype('float32')).unsqueeze(0).unsqueeze(3)), 3).to(device) | |
| output = torch.nn.functional.grid_sample(image, grid + flow, mode='bilinear', padding_mode='zeros') | |
| return output | |
| def length_sq(x): | |
| return torch.sum(torch.square(x), dim=1, keepdim=True) | |
| def fbConsistencyCheck(flow_fw, flow_bw, alpha1=0.01, alpha2=0.5): | |
| flow_bw_warped = image_warp(flow_bw, flow_fw) # wb(wf(x)) | |
| flow_fw_warped = image_warp(flow_fw, flow_bw) # wf(wb(x)) | |
| flow_diff_fw = flow_fw + flow_bw_warped # wf + wb(wf(x)) | |
| flow_diff_bw = flow_bw + flow_fw_warped # wb + wf(wb(x)) | |
| mag_sq_fw = length_sq(flow_fw) + length_sq(flow_bw_warped) # |wf| + |wb(wf(x))| | |
| mag_sq_bw = length_sq(flow_bw) + length_sq(flow_fw_warped) # |wb| + |wf(wb(x))| | |
| occ_thresh_fw = alpha1 * mag_sq_fw + alpha2 | |
| occ_thresh_bw = alpha1 * mag_sq_bw + alpha2 | |
| fb_occ_fw = (length_sq(flow_diff_fw) > occ_thresh_fw).float() | |
| fb_occ_bw = (length_sq(flow_diff_bw) > occ_thresh_bw).float() | |
| return fb_occ_fw, fb_occ_bw # fb_occ_fw -> frame2 area occluded by frame1, fb_occ_bw -> frame1 area occluded by frame2 | |
| def rgb2gray(image): | |
| gray_image = image[:, 0] * 0.299 + image[:, 1] * 0.587 + 0.110 * image[:, 2] | |
| gray_image = gray_image.unsqueeze(1) | |
| return gray_image | |
| def ternary_transform(image, max_distance=1): | |
| device = image.device | |
| patch_size = 2 * max_distance + 1 | |
| intensities = rgb2gray(image) * 255 | |
| out_channels = patch_size * patch_size | |
| w = np.eye(out_channels).reshape(out_channels, 1, patch_size, patch_size) | |
| weights = torch.from_numpy(w).float().to(device) | |
| patches = F.conv2d(intensities, weights, stride=1, padding=1) | |
| transf = patches - intensities | |
| transf_norm = transf / torch.sqrt(0.81 + torch.square(transf)) | |
| return transf_norm | |
| def hamming_distance(t1, t2): | |
| dist = torch.square(t1 - t2) | |
| dist_norm = dist / (0.1 + dist) | |
| dist_sum = torch.sum(dist_norm, dim=1, keepdim=True) | |
| return dist_sum | |
| def create_mask(mask, paddings): | |
| """ | |
| padding: [[top, bottom], [left, right]] | |
| """ | |
| shape = mask.shape | |
| inner_height = shape[2] - (paddings[0][0] + paddings[0][1]) | |
| inner_width = shape[3] - (paddings[1][0] + paddings[1][1]) | |
| inner = torch.ones([inner_height, inner_width]) | |
| mask2d = F.pad(inner, pad=[paddings[1][0], paddings[1][1], paddings[0][0], paddings[0][1]]) # mask最外边一圈都pad成0了 | |
| mask3d = mask2d.unsqueeze(0) | |
| mask4d = mask3d.unsqueeze(0).repeat(shape[0], 1, 1, 1) | |
| return mask4d.detach() | |
| def ternary_loss2(frame1, warp_frame21, confMask, masks, max_distance=1): | |
| """ | |
| Args: | |
| frame1: torch tensor, with shape [b * t, c, h, w] | |
| warp_frame21: torch tensor, with shape [b * t, c, h, w] | |
| confMask: confidence mask, with shape [b * t, c, h, w] | |
| masks: torch tensor, with shape [b * t, c, h, w] | |
| max_distance: maximum distance. | |
| Returns: ternary loss | |
| """ | |
| t1 = ternary_transform(frame1) | |
| t21 = ternary_transform(warp_frame21) | |
| dist = hamming_distance(t1, t21) # 近似求解，其实利用了mask区域和外界边缘交叉的那一部分像素 | |
| loss = torch.mean(dist * confMask * masks) / torch.mean(masks) | |
| return loss | |
| def gradient_loss(frame1, frame2, confMask): | |
| device = frame1.device | |
| frame1_edge = SobelLayer(device)(frame1) | |
| frame2_edge = SobelLayer(device)(frame2) | |
| loss = torch.sum(torch.abs(frame1_edge * confMask - frame2_edge * confMask)) / (torch.sum(confMask) + 1) # escape divide 0 | |
| return loss | |
| def seperate_gradient_loss(frame1, warp_frame21, confMask): | |
| device = frame1.device | |
| mask_x = create_mask(frame1, [[0, 0], [1, 1]]).to(device) | |
| mask_y = create_mask(frame1, [[1, 1], [0, 0]]).to(device) | |
| gradient_mask = torch.cat([mask_x, mask_y], dim=1).repeat(1, 3, 1, 1) | |
| frame1_edge = SeperateSobelLayer(device)(frame1) | |
| warp_frame21_edge = SeperateSobelLayer(device)(warp_frame21) | |
| loss = nn.L1Loss()(frame1_edge * confMask * gradient_mask, warp_frame21_edge * confMask * gradient_mask) | |
| return loss | |