def test_dxdy_batch(self, device, dtype): # prepare input data inp = torch.tensor([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]], device=device, dtype=dtype).repeat(2, 1, 1, 1) expected = torch.tensor( [[[[0.0, 1.0], [0.0, 3.0], [0.0, 5.0], [0.0, 7.0]]], [[[0.0, 0.0], [0.0, 1.0], [0.0, 3.0], [0.0, 5.0]]]], device=device, dtype=dtype, ) # prepare transformation translation = torch.tensor([[1.0, 0.0], [1.0, 1.0]], device=device, dtype=dtype) transform = kornia.geometry.transform.Translate(translation, align_corners=True) assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_scale_factor_05_batch2_broadcast(self, device, dtype): # prepare input data inp = torch.tensor( [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], device=device, dtype=dtype, ).repeat(2, 1, 1, 1) expected = torch.tensor( [[[0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]]], device=device, dtype=dtype, ).repeat(2, 1, 1, 1) # prepare transformation scale_factor = torch.tensor([[0.5, 0.5]], device=device, dtype=dtype) transform = kornia.geometry.transform.Scale(scale_factor) assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_shear_batch2_broadcast(self, device, dtype): # prepare input data inp = torch.tensor( [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], device=device, dtype=dtype, ).repeat(2, 1, 1, 1) expected = torch.tensor( [[[[0.75, 1.0, 1.0, 1.0], [0.25, 1.0, 1.0, 1.0], [0.0, 0.75, 1.0, 1.0], [0.0, 0.25, 1.0, 1.0]]]], device=device, dtype=dtype, ).repeat(2, 1, 1, 1) # prepare transformation shear = torch.tensor([[0.5, 0.0]], device=device, dtype=dtype) transform = kornia.Shear(shear, align_corners=False) assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_warp_grid_translation(self, shape, offset, device, dtype): # create input data height, width = shape dst_homo_src = utils.create_eye_batch(batch_size=1, eye_size=3, device=device, dtype=dtype) dst_homo_src[..., 0, 2] = offset # apply offset in x grid = kornia.utils.create_meshgrid(height, width, normalized_coordinates=False) flow = kornia.geometry.transform.warp_grid(grid, dst_homo_src) # the grid the src plus the offset should be equal to the flow # on the x-axis, y-axis remains the same. assert_close(grid[..., 0].to(device=device, dtype=dtype) + offset, flow[..., 0]) assert_close(grid[..., 1].to(device=device, dtype=dtype), flow[..., 1])
def test_clean_points(self, batch_size, device, dtype): # generate input data points_src = torch.rand(batch_size, 10, 2, device=device, dtype=dtype) H = kornia.eye_like(3, points_src) H = H * 0.3 * torch.rand_like(H) H = H / H[:, 2:3, 2:3] points_dst = kornia.transform_points(H, points_src) weights = torch.ones(batch_size, 10, device=device, dtype=dtype) # compute transform from source to target dst_homo_src = find_homography_dlt_iterated(points_src, points_dst, weights, 10) assert_close(kornia.transform_points(dst_homo_src, points_src), points_dst, rtol=1e-3, atol=1e-4)
def test_random_mixup_p0(self, device, dtype): torch.manual_seed(0) f = RandomMixUp(p=0.0) input = torch.stack([ torch.ones(1, 3, 4, device=device, dtype=dtype), torch.zeros(1, 3, 4, device=device, dtype=dtype) ]) label = torch.tensor([1, 0], device=device) # TODO(jian): where is it used ? # lam = torch.tensor([0.0, 0.0], device=device, dtype=dtype) expected = input.clone() out_image, out_label = f(input, label) assert_close(out_image, expected, rtol=1e-4, atol=1e-4) assert (out_label == label).all()
def test_kernel(self, device, dtype): tensor = torch.tensor( [[0.5, 1.0, 0.3], [0.7, 0.3, 0.8], [0.4, 0.9, 0.2]], device=device, dtype=dtype)[None, None, :, :] kernel = torch.tensor( [[0.0, 1.0, 0.0], [1.0, 1.0, 1.0], [0.0, 1.0, 0.0]], device=device, dtype=dtype) expected = torch.tensor( [[0.5, 0.3, 0.3], [0.3, 0.3, 0.2], [0.4, 0.2, 0.2]], device=device, dtype=dtype)[None, None, :, :] assert_close(erosion(tensor, kernel), expected, atol=1e-4, rtol=1e-4) assert_close(erosion(tensor, kernel, engine='convolution'), expected, atol=1e-3, rtol=1e-3)
def test_four_classes_one_missing(self, device, dtype): num_classes = 4 actual = torch.tensor( [[3, 3, 1, 1, 2, 1, 1, 3, 2, 2, 1, 1, 2, 3, 2, 1]], device=device, dtype=torch.long) predicted = torch.tensor( [[3, 2, 1, 1, 1, 1, 1, 2, 1, 3, 3, 2, 1, 1, 3, 3]], device=device, dtype=torch.long) conf_mat = kornia.metrics.confusion_matrix(predicted, actual, num_classes) conf_mat_real = torch.tensor( [[[0, 0, 0, 0], [0, 4, 1, 2], [0, 3, 0, 2], [0, 1, 2, 1]]], device=device, dtype=torch.float32) assert_close(conf_mat, conf_mat_real)
def test_project(self, num_points, device, dtype): intrinsics, _, world_points, img_points = self._get_test_data( num_points, device, dtype) pred_world_to_cam = kornia.geometry.solve_pnp_dlt( world_points, img_points, intrinsics) pred_world_to_cam_4x4 = kornia.eye_like(4, pred_world_to_cam) pred_world_to_cam_4x4[:, :3, :] = pred_world_to_cam repeated_intrinsics = intrinsics.unsqueeze(1).repeat( 1, num_points, 1, 1) pred_img_points = self._project_to_image(world_points, pred_world_to_cam_4x4, repeated_intrinsics) assert_close(pred_img_points, img_points, atol=1e-3, rtol=1e-3)
def test_opencv(self, device, dtype): data = torch.tensor( [[ [0.4684734, 0.8954562, 0.6064363, 0.5236061, 0.6106016], [0.1709944, 0.5133104, 0.7915002, 0.5745703, 0.1680204], [0.5279005, 0.6092287, 0.3034387, 0.5333768, 0.6064113], [0.3503858, 0.5720159, 0.7052018, 0.4558409, 0.3261529], [0.6988886, 0.5897652, 0.6532392, 0.7234108, 0.7218805], ]], device=device, dtype=dtype, ) # Output data generated with OpenCV 4.5.2: cv2.cvtColor(img_np, cv2.COLOR_GRAY2RGB) expected = torch.tensor( [ [ [0.4684734, 0.8954562, 0.6064363, 0.5236061, 0.6106016], [0.1709944, 0.5133104, 0.7915002, 0.5745703, 0.1680204], [0.5279005, 0.6092287, 0.3034387, 0.5333768, 0.6064113], [0.3503858, 0.5720159, 0.7052018, 0.4558409, 0.3261529], [0.6988886, 0.5897652, 0.6532392, 0.7234108, 0.7218805], ], [ [0.4684734, 0.8954562, 0.6064363, 0.5236061, 0.6106016], [0.1709944, 0.5133104, 0.7915002, 0.5745703, 0.1680204], [0.5279005, 0.6092287, 0.3034387, 0.5333768, 0.6064113], [0.3503858, 0.5720159, 0.7052018, 0.4558409, 0.3261529], [0.6988886, 0.5897652, 0.6532392, 0.7234108, 0.7218805], ], [ [0.4684734, 0.8954562, 0.6064363, 0.5236061, 0.6106016], [0.1709944, 0.5133104, 0.7915002, 0.5745703, 0.1680204], [0.5279005, 0.6092287, 0.3034387, 0.5333768, 0.6064113], [0.3503858, 0.5720159, 0.7052018, 0.4558409, 0.3261529], [0.6988886, 0.5897652, 0.6532392, 0.7234108, 0.7218805], ], ], device=device, dtype=dtype, ) img_rgb = kornia.grayscale_to_rgb(data) assert_close(img_rgb, expected)
def test_opencv(self, device, dtype): data = torch.tensor( [ [ [0.3944633, 0.8597369, 0.1670904, 0.2825457, 0.0953912], [0.1251704, 0.8020709, 0.8933256, 0.9170977, 0.1497008], [0.2711633, 0.1111478, 0.0783281, 0.2771807, 0.5487481], [0.0086008, 0.8288748, 0.9647092, 0.8922020, 0.7614344], [0.2898048, 0.1282895, 0.7621747, 0.5657831, 0.9918593], ], [ [0.5414237, 0.9962701, 0.8947155, 0.5900949, 0.9483274], [0.0468036, 0.3933847, 0.8046577, 0.3640994, 0.0632100], [0.6171775, 0.8624780, 0.4126036, 0.7600935, 0.7279997], [0.4237089, 0.5365476, 0.5591233, 0.1523191, 0.1382165], [0.8932794, 0.8517839, 0.7152701, 0.8983801, 0.5905426], ], [ [0.2869580, 0.4700376, 0.2743714, 0.8135023, 0.2229074], [0.9306560, 0.3734594, 0.4566821, 0.7599275, 0.7557513], [0.7415742, 0.6115875, 0.3317572, 0.0379378, 0.1315770], [0.8692724, 0.0809556, 0.7767404, 0.8742208, 0.1522012], [0.7708948, 0.4509611, 0.0481175, 0.2358997, 0.6900532], ], ], device=device, dtype=dtype, ) # Output data generated with OpenCV 4.1.1: cv2.cvtColor(img_np, cv2.COLOR_BGR2GRAY) expected = torch.tensor( [[ [0.4485849, 0.8233618, 0.6262833, 0.6218331, 0.6341921], [0.3200093, 0.4340172, 0.7107211, 0.5454938, 0.2801398], [0.6149265, 0.7018101, 0.3503231, 0.4891168, 0.5292346], [0.5096100, 0.4336508, 0.6704276, 0.4525143, 0.2134447], [0.7878902, 0.6494595, 0.5211386, 0.6623823, 0.6660464], ]], device=device, dtype=dtype, ) img_gray = kornia.bgr_to_grayscale(data) assert_close(img_gray, expected)
def test_opencv(self, device, dtype): data = torch.tensor( [ [ [0.3944633, 0.8597369, 0.1670904, 0.2825457, 0.0953912], [0.1251704, 0.8020709, 0.8933256, 0.9170977, 0.1497008], [0.2711633, 0.1111478, 0.0783281, 0.2771807, 0.5487481], [0.0086008, 0.8288748, 0.9647092, 0.8922020, 0.7614344], [0.2898048, 0.1282895, 0.7621747, 0.5657831, 0.9918593], ], [ [0.5414237, 0.9962701, 0.8947155, 0.5900949, 0.9483274], [0.0468036, 0.3933847, 0.8046577, 0.3640994, 0.0632100], [0.6171775, 0.8624780, 0.4126036, 0.7600935, 0.7279997], [0.4237089, 0.5365476, 0.5591233, 0.1523191, 0.1382165], [0.8932794, 0.8517839, 0.7152701, 0.8983801, 0.5905426], ], [ [0.2869580, 0.4700376, 0.2743714, 0.8135023, 0.2229074], [0.9306560, 0.3734594, 0.4566821, 0.7599275, 0.7557513], [0.7415742, 0.6115875, 0.3317572, 0.0379378, 0.1315770], [0.8692724, 0.0809556, 0.7767404, 0.8742208, 0.1522012], [0.7708948, 0.4509611, 0.0481175, 0.2358997, 0.6900532], ], ], device=device, dtype=dtype, ) # Output data generated with OpenCV 4.1.1: cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY) expected = torch.tensor( [[ [0.4684734, 0.8954562, 0.6064363, 0.5236061, 0.6106016], [0.1709944, 0.5133104, 0.7915002, 0.5745703, 0.1680204], [0.5279005, 0.6092287, 0.3034387, 0.5333768, 0.6064113], [0.3503858, 0.5720159, 0.7052018, 0.4558409, 0.3261529], [0.6988886, 0.5897652, 0.6532392, 0.7234108, 0.7218805], ]], device=device, dtype=dtype, ) img_gray = kornia.rgb_to_grayscale(data) assert_close(img_gray, expected)
def test_magnitude_threshold(self, device, dtype): inp = torch.tensor( [[[ [0.5, 0.4, 0.5, 0.45, 0.1], [0.3, 0.2, 0.3, 0.0, 0.3], [0.5, 1.0, 1.0, 0.6, 0.75], [0.2, 0.4, 0.6, 0.0, 0.5], [0.1, 0.35, 0.35, 0.26, 0.1], ]]], device=device, dtype=dtype, ) expected_magnitude = torch.tensor( [[[ [0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [0.4858, 0.5594, 0.6878, 0.6977, 0.5602], [0.1129, 0.0000, 0.0000, 0.4531, 0.0000], [0.6115, 0.5859, 0.6110, 0.6766, 0.5160], [0.0000, 0.0000, 0.0000, 0.0000, 0.0000], ]]], device=device, dtype=dtype, ) expected_edges = torch.tensor( [[[ [0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [0.0000, 0.0000, 0.0000, 0.0000, 0.0000], ]]], device=device, dtype=dtype, ) magnitude, edges = kornia.filters.canny(inp, low_threshold=0.3, high_threshold=0.9) tol_val: float = utils._get_precision(device, dtype) assert_close(magnitude, expected_magnitude, rtol=tol_val, atol=tol_val) assert_close(edges, expected_edges, rtol=tol_val, atol=tol_val)
def test_normalized_mean_filter(self, padding, device, dtype): kernel = torch.ones(1, 3, 3).to(device) input = torch.tensor( [[[ [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 5.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], ]]], device=device, dtype=dtype, ).expand(2, 2, -1, -1) nv: float = 5.0 / 9 # normalization value expected_same = torch.tensor( [[[ [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, nv, nv, nv, 0.0], [0.0, nv, nv, nv, 0.0], [0.0, nv, nv, nv, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], ]]], device=device, dtype=dtype, ).expand(2, 2, -1, -1) expected_valid = torch.tensor( [[[[nv, nv, nv], [nv, nv, nv], [nv, nv, nv]]]], device=device, dtype=dtype).expand(2, 2, -1, -1) actual = kornia.filters.filter2d(input, kernel, normalized=True, padding=padding) tol_val: float = utils._get_precision_by_name(device, 'xla', 1e-1, 1e-4) if padding == 'same': assert_close(actual, expected_same, rtol=tol_val, atol=tol_val) else: assert_close(actual, expected_valid, rtol=tol_val, atol=tol_val)
def test_batch_variable_size(self, device, dtype): im = torch.rand(2, 3, 12, 16, dtype=dtype, device=device) pts = [ torch.tensor([[4, 4], [12, 4], [12, 8], [4, 8]], dtype=dtype, device=device), torch.tensor([[0, 0], [2, 0], [4, 0], [4, 4], [0, 4]], dtype=dtype, device=device), ] color = torch.tensor([[0.5, 0.5, 0.5], [0.5, 0.5, 0.75]], dtype=dtype, device=device) poly_im = draw_convex_polygon(im.clone(), pts, color) rect = torch.tensor([[[4, 4, 12, 8]], [[0, 0, 4, 4]]], dtype=dtype, device=device) rect_im = draw_rectangle(im.clone(), rect, color[:, None], fill=True) assert_close(rect_im, poly_im)
def test_factor_tensor(self, device, dtype): # prepare input data data = torch.tensor( [ [[1.0, 1.0], [1.0, 1.0]], [[0.5, 0.5], [0.5, 0.5]], [[0.25, 0.25], [0.25, 0.25]], [[0.5, 0.5], [0.5, 0.5]], ], device=device, dtype=dtype, ) # 4x2x2 factor = torch.tensor([0, 0.5, 0.75, 2], device=device, dtype=dtype) expected = torch.ones_like(data) f = kornia.enhance.AdjustBrightness(factor) assert_close(f(data), expected)
def test_random_mixup_lam0(self, device, dtype): torch.manual_seed(0) f = RandomMixUp(lambda_val=(0.0, 0.0), p=1.0) input = torch.stack([ torch.ones(1, 3, 4, device=device, dtype=dtype), torch.zeros(1, 3, 4, device=device, dtype=dtype) ]) label = torch.tensor([1, 0], device=device) lam = torch.tensor([0.0, 0.0], device=device, dtype=dtype) expected = input.clone() out_image, out_label = f(input, label) assert_close(out_image, expected, rtol=1e-4, atol=1e-4) assert (out_label[:, 0] == label).all() assert (out_label[:, 1] == torch.tensor([0, 1], device=device)).all() assert_close(out_label[:, 2], lam, rtol=1e-4, atol=1e-4)
def test_shear_y(self, device, dtype): # prepare input data inp = torch.tensor( [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], device=device, dtype=dtype, ) expected = torch.tensor( [[[0.75, 0.25, 0.0, 0.0], [1.0, 1.0, 0.75, 0.25], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], device=device, dtype=dtype, ) # prepare transformation shear = torch.tensor([[0.0, 0.5]], device=device, dtype=dtype) transform = kornia.geometry.transform.Shear(shear, align_corners=False) assert_close(transform(inp), expected, atol=1e-4, rtol=1e-4)
def test_real_keynet(self, device, dtype, data): torch.random.manual_seed(0) # This is not unit test, but that is quite good integration test matcher = LocalFeatureMatcher(KeyNetHardNet(500), DescriptorMatcher('snn', 0.9)).to( device, dtype) ransac = RANSAC('homography', 1.0, 2048, 10).to(device, dtype) data_dev = utils.dict_to(data, device, dtype) pts_src = data_dev['pts0'] pts_dst = data_dev['pts1'] with torch.no_grad(): out = matcher(data_dev) homography, inliers = ransac(out['keypoints0'], out['keypoints1']) assert inliers.sum().item() > 50 # we have enough inliers # Reprojection error of 5px is OK assert_close(transform_points(homography[None], pts_src[None]), pts_dst[None], rtol=5e-2, atol=5)
def test_crop_by_boxes_resizing(self, device, dtype): inp = torch.arange(0.0, 343.0, device=device, dtype=dtype).view(1, 1, 7, 7, 7) src_box = torch.tensor( [ [ [1.0, 1.0, 1.0], [3.0, 1.0, 1.0], [3.0, 3.0, 1.0], [1.0, 3.0, 1.0], [1.0, 1.0, 2.0], [3.0, 1.0, 2.0], [3.0, 3.0, 2.0], [1.0, 3.0, 2.0], ] ], device=device, dtype=dtype, ) # 1x8x3 dst_box = torch.tensor( [ [ [0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 1.0], [1.0, 1.0, 1.0], [0.0, 1.0, 1.0], ] ], device=device, dtype=dtype, ) # 1x8x3 expected = torch.tensor( [[[[[57.0000, 59.0000], [71.0000, 73.0000]], [[106.0000, 108.0000], [120.0000, 122.0000]]]]], device=device, dtype=dtype, ) patches = kornia.geometry.transform.crop_by_boxes3d(inp, src_box, dst_box, align_corners=True) assert_close(patches, expected, rtol=1e-4, atol=1e-4)
def test_against_functional(self, input_shape): input = torch.randn(*input_shape) f = RandomMotionBlur(kernel_size=(3, 5), angle=(10, 30), direction=0.5, p=1.0) output = f(input) expected = motion_blur( input, f._params['ksize_factor'].unique().item(), f._params['angle_factor'], f._params['direction_factor'], f.flags['border_type'].name.lower(), ) assert_close(output, expected, rtol=1e-4, atol=1e-4)
def test_downscale_values(self, device, dtype): inp_x = torch.arange(20, device=device, dtype=dtype) / 20.0 inp = inp_x[None].T @ inp_x[None] inp = inp[None, None] out = kornia.geometry.transform.rescale(inp, (0.25, 0.25), antialias=False, align_corners=False) expected = torch.tensor( [[[ [0.0056, 0.0206, 0.0356, 0.0506, 0.0656], [0.0206, 0.0756, 0.1306, 0.1856, 0.2406], [0.0356, 0.1306, 0.2256, 0.3206, 0.4156], [0.0506, 0.1856, 0.3206, 0.4556, 0.5906], [0.0656, 0.2406, 0.4156, 0.5906, 0.7656], ]]], device=device, dtype=dtype, ) assert_close(out, expected, atol=1e-3, rtol=1e-3)
def test_unit(self, device, dtype, aval): data = torch.tensor( [[[[1.0, 1.0], [1.0, 1.0]], [[2.0, 2.0], [2.0, 2.0]], [[3.0, 3.0], [3.0, 3.0]]]], device=device, dtype=dtype) # Bx3x2x2 expected = torch.tensor( [[ [[1.0, 1.0], [1.0, 1.0]], [[2.0, 2.0], [2.0, 2.0]], [[3.0, 3.0], [3.0, 3.0]], [[aval, aval], [aval, aval]], ]], device=device, dtype=dtype, ) # Bx4x2x2 assert_close(kornia.rgb_to_rgba(data, aval), expected)
def test_triplet_qma(self, axis, device, dtype, atol, rtol): array = [[0.0, 0.0, 0.0, 0.0]] array[0][1 + axis] = 1.0 # `1 + axis` this should fail when XYZW quaternion = torch.tensor(array, device=device, dtype=dtype) assert quaternion.shape[-1] == 4 mm = kornia.quaternion_to_rotation_matrix(quaternion, order=QuaternionCoeffOrder.WXYZ) assert mm.shape[-1] == 3 assert mm.shape[-2] == 3 angle_axis = kornia.rotation_matrix_to_angle_axis(mm) assert angle_axis.shape[-1] == 3 angle_axis_expected = [[0.0, 0.0, 0.0]] angle_axis_expected[0][axis] = kornia.pi angle_axis_expected = torch.tensor(angle_axis_expected, device=device, dtype=dtype) assert_close(angle_axis, angle_axis_expected, atol=atol, rtol=rtol) quaternion_hat = kornia.angle_axis_to_quaternion(angle_axis, order=QuaternionCoeffOrder.WXYZ) assert_close(quaternion_hat, quaternion, atol=atol, rtol=rtol)
def test_values(self, device, dtype): image = torch.tensor( [[[[0.0018, 0.7521, 0.7550], [0.2053, 0.4249, 0.1369], [0.1027, 0.3992, 0.8773]]]], device=device, dtype=dtype, ) noise = torch.ones(1, 2, 3, 3, device=device, dtype=dtype) expected = torch.tensor( [[[[0.0005, 0.3795, 0.1905], [0.1034, 0.4235, 0.0702], [0.0259, 0.2007, 0.2193]]]], device=device, dtype=dtype, ) actual = elastic_transform2d(image, noise) assert_close(actual, expected, atol=1e-3, rtol=1e-3)
def test_b2_ch1_h3w3_ws2_stride1_padding1(self, device): batch_size = 2 img = torch.arange(9.0).view(1, 1, 3, 3).to(device) img = img.expand(batch_size, -1, -1, -1) m = kornia.contrib.ExtractTensorPatches(2, stride=1, padding=1) patches = m(img) assert patches.shape == (batch_size, 16, 1, 2, 2) for i in range(batch_size): assert_close(img[i, :, 0:2, 0:2], patches[i, 5]) assert_close(img[i, :, 0:2, 1:3], patches[i, 6]) assert_close(img[i, :, 1:3, 0:2], patches[i, 9]) assert_close(img[i, :, 1:3, 1:3], patches[i, 10])
def test_translation_normalized(self, device, dtype): # this is for normalize_points=True image_src = torch.tensor([[[[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0]]]], device=device, dtype=dtype) depth_dst = torch.tensor([[[[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]]], device=device, dtype=dtype) src_trans_dst = torch.tensor( [[[1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]], device=device, dtype=dtype, ) h, w = image_src.shape[-2:] camera_matrix = torch.tensor( [[[1.0, 0.0, w / 2], [0.0, 1.0, h / 2], [0.0, 0.0, 1.0]]], device=device, dtype=dtype) image_dst_expected = torch.tensor( [[[ [0.9223, 0.0000, 0.0000], [2.8153, 1.5000, 0.0000], [2.8028, 2.6459, 0.0000], [2.8153, 1.5000, 0.0000], ]]], device=device, dtype=dtype, ) image_dst = kornia.geometry.depth.warp_frame_depth( image_src, depth_dst, src_trans_dst, camera_matrix, normalize_points=True) assert_close(image_dst, image_dst_expected, rtol=1e-3, atol=1e-3)
def test_smoke(self, device, dtype): H, W = 5, 5 translation = torch.tensor([[0.0, 0.0]], device=device, dtype=dtype) # NOTE: ideally the center should be [W * 0.5, H * 0.5] center = torch.tensor([[W // 2, H // 2]], device=device, dtype=dtype) zoom1 = torch.ones([1, 1], device=device, dtype=dtype) * 0.5 zoom2 = torch.ones([1, 1], device=device, dtype=dtype) * 1.0 zoom = torch.cat([zoom1, zoom2], -1) angle = torch.zeros([1], device=device, dtype=dtype) affine_mat = kornia.geometry.get_affine_matrix2d( translation, center, zoom, angle) img = torch.ones(1, 1, H, W, device=device, dtype=dtype) expected = torch.zeros_like(img) expected[..., 1:4] = 1.0 out = kornia.geometry.transform.warp_affine(img, affine_mat[:, :2], (H, W)) assert_close(out, expected)
def test_unit_linear(self, device, dtype): data = torch.tensor( [ [[1.00000000, 0.00000000], [0.21404116, 0.01002283]], [[1.00000000, 0.00000000], [0.21404116, 0.03310477]], [[1.00000000, 0.00000000], [0.21404116, 0.07323898]], ], device=device, dtype=dtype, ) # 3x2x2 expected = torch.tensor( [[[1.0, 0.0], [0.5, 0.1]], [[1.0, 0.0], [0.5, 0.2]], [[1.0, 0.0], [0.5, 0.3]]], device=device, dtype=dtype) # 3x2x2 f = kornia.color.linear_rgb_to_rgb assert_close(f(data), expected)
def test_factor_zero_with_mean_subtraction(self, device, dtype): # prepare input data data = torch.tensor( [[[1.0, 1.0], [1.0, 1.0]], [[0.5, 0.5], [0.5, 0.5]], [[0.25, 0.25], [0.25, 0.25]]], device=device, dtype=dtype, ) # 3x2x2 expected = torch.tensor( [[[0.6210, 0.6210], [0.6210, 0.6210]], [[0.6210, 0.6210], [0.6210, 0.6210]], [[0.6210, 0.6210], [0.6210, 0.6210]]], device=device, dtype=dtype, ) # 3x2x2 f = kornia.enhance.AdjustContrastWithMeanSubtraction(0.0) assert_close(f(data), expected)