def test_get_positions(self): grid = RegularGrid([0.0, 0.0, 1.0, 1.0, 0.0, 0.0], values=np.zeros((3, 3))) (i, j) = grid.get_positions(1.5, 1.5) self.assertEqual((i, j), (1.0, 1.0)) (i, j) = grid.get_positions(2.0, 1.5) self.assertEqual((i, j), (1.0, 1.5))
def test_sample_nearest_skewed(self): grid = RegularGrid([0.0, 0.0, 1.0, 1.0, 0.5, 0.2], values=np.array([[0, 1], [1, 0.5]])) self.assertEqual(grid.sample_nearest(1, 0.75), 0.0) self.assertEqual(grid.sample_nearest(1.5, 1.05), 1.0) self.assertEqual(grid.sample_nearest(1.2, 1.4), 1.0) self.assertEqual(grid.sample_nearest(2.0, 1.7), 0.5)
def test_sample_2d_array(self): grid = RegularGrid([0.0, 0.0, 1.0, 1.0, 0.0, 0.0], values=np.array([[0, 1], [1, 0.5]])) xi = np.array([[0.7, 1.3], [0.7, 1.3]]) yi = np.array([[0.7, 0.7], [1.3, 1.3]]) z = grid.sample(xi, yi, method="nearest") self.assertTrue(np.all(z == np.array([[0, 1], [1, 0.5]])))
def test_vertex_coords(self): grid = RegularGrid((0.0, 0.0, 30.0, 30.0, 0.0, 0.0), values=np.zeros([49, 49])) ans = np.meshgrid(np.arange(15.0, 1486.0, 30.0), np.arange(15.0, 1486.0, 30.0)) self.assertTrue(np.sum(grid.vertex_coords()[0] - ans[0]) < 1e-10) self.assertTrue(np.sum(grid.vertex_coords()[1] - ans[1]) < 1e-10)
def test_sample_bilinear_array(self): grid = RegularGrid([0.0, 0.0, 1.0, 1.0, 0.0, 0.0], values=np.arange(64, dtype=np.float64).reshape([8, 8])) X, Y = np.meshgrid(np.arange(1, 7, 0.5), np.arange(2, 5, 0.25)) res = grid.sample_bilinear(X, Y) self.assertEqual(res.shape, (1, 12, 12))
def test_center_coords(self): grid = RegularGrid((0.0, 0.0, 30.0, 30.0, 0.0, 0.0), values=np.zeros([49, 49])) ans = np.meshgrid(np.arange(15.0, 1471.0, 30.0), np.arange(15.0, 1471.0, 30.0)) self.assertEqual(0.0, np.sum(grid.center_coords()[0] - ans[0])) self.assertEqual(0.0, np.sum(grid.center_coords()[1] - ans[1]))
def test_mask_poly_partial2(self): # this case has the first transect begin off-grid, which has caused # problems in the past g = RegularGrid([0, 0, 1, 1, 0, 0], values=np.ones((7, 7))) p = karta.Polygon([(-2, 3), (8, -5), (8, -1), (-2, 7)]) gc = g.mask_by_poly(p) self.assertEqual(gc.data_mask.sum(), 20)
def test_resize_larger(self): proto = RegularGrid((500, 500, 30, 30, 0, 0), values=peaks(50)) newgrid = proto.resize([380, 320, 380 + 30 * 60, 320 + 30 * 62]) self.assertEqual(newgrid.transform, (380.0, 320.0, 30.0, 30.0, 0.0, 0.0)) self.assertTrue(np.all(newgrid[6:56, 4:54] == proto[:, :])) self.assertTrue(np.isnan(newgrid[0, 0]))
def test_sample_nearest(self): grid = RegularGrid([0.0, 0.0, 1.0, 1.0, 0.0, 0.0], values=np.array([[0, 1], [1, 0.5]])) self.assertEqual(grid.sample_nearest(0.6, 0.7), 0.0) self.assertEqual(grid.sample_nearest(0.6, 1.3), 1.0) self.assertEqual(grid.sample_nearest(1.4, 0.3), 1.0) self.assertEqual(grid.sample_nearest(1.6, 1.3), 0.5)
def test_sample_nearest_out_of_bounds(self): g = RegularGrid([0, 0, 1, 1, 0, 0], values=np.ones((10, 10))) v = g.sample_nearest(np.array([7, 9, 12, 15]), np.array([3, 1, -1, 1])) self.assertEqual(v[0][0], 1.0) self.assertEqual(v[0][1], 1.0) self.assertTrue(np.isnan(v[0][2])) self.assertTrue(np.isnan(v[0][3]))
def test_align_origin(self): xx, yy = np.meshgrid(np.linspace(0, 1, 50), np.linspace(0, 1, 30)) zz = 2.0 * xx**2 - 3.0 * yy**2 grid = RegularGrid((27, 53, 5, 5, 0, 0), values=zz) new_grid = grid._align_origin(5, 5, method='linear') self.assertEqual(new_grid.origin, (25, 55)) self.assertTrue(np.isnan(new_grid.values[0, 0]))
def test_minmax_nodata(self): values = np.array([[4, 5, 3], [4, 2, -9], [3, 6, 1]]) self.rast = RegularGrid((0.0, 0.0, 30.0, 30.0, 0.0, 0.0), values=values, nodata_value=-9) minmax = self.rast.minmax() self.assertEqual(minmax, (1, 6))
def test_data_extent(self): grid = RegularGrid((0, 0, 1, 1, 0, 0), values=np.zeros((128, 128), dtype=np.float64)) grid[:, :4] = grid.nodata grid[:, -7:] = grid.nodata grid[:21, :] = grid.nodata grid[-17:, :] = grid.nodata self.assertEqual(grid.data_extent("edge"), (4, 121, 21, 111)) self.assertEqual(grid.data_extent("center"), (4.5, 120.5, 21.5, 110.5))
def test_sample_multipoint(self): grid = RegularGrid([0.0, 0.0, 1.0, 1.0, 0.0, 0.0], values=np.array([[0, 1], [1, 0.5]])) mp = karta.Multipoint([(0.6, 0.7), (0.6, 1.3), (1.4, 0.3), (1.6, 1.3)], crs=grid.crs) self.assertTrue( np.all( np.allclose(grid.sample(mp, method="nearest"), np.array([0.0, 1.0, 1.0, 0.5]))))
def test_merge_weighted(self): grid1 = RegularGrid([10, 20, 1, 1, 0, 0], values=np.ones([8, 8])) grid2 = RegularGrid([7, 22, 1, 1, 0, 0], values=2 * np.ones([4, 6])) grid3 = RegularGrid([12, 19, 1, 1, 0, 0], values=3 * np.ones([5, 5])) grid_combined = karta.raster.merge([grid1, grid2, grid3], weights=[1, 2, 3]) self.assertAlmostEqual(grid_combined[4, 4, 0], 1.66666666666) self.assertAlmostEqual(grid_combined[2, 8, 0], 2.5) self.assertAlmostEqual(grid_combined[4, 5, 0], 2.33333333333)
def test_merge_multiband(self): grid3a = RegularGrid([0, 0, 1, 1, 0, 0], values=np.array([1, 2, 3]) * np.ones((16, 16, 3))) grid3b = RegularGrid([4, 4, 1, 1, 0, 0], values=np.array([2, 3, 4]) * np.ones((16, 16, 3))) grid3_mosaic = karta.raster.merge([grid3a, grid3b]) self.assertEqual(np.nansum(grid3_mosaic[:, :, 0]), 552) self.assertEqual(np.nansum(grid3_mosaic[:, :, 1]), 920) self.assertEqual(np.nansum(grid3_mosaic[:, :, 2]), 1288)
def test_minmax_nodata2(self): values = -9 * np.ones([3, 3]) self.rast = RegularGrid((0.0, 0.0, 30.0, 30.0, 0.0, 0.0), values=values, nodata_value=-9) minmax = self.rast.minmax() self.assertTrue(np.isnan(minmax[0])) self.assertTrue(np.isnan(minmax[1]))
def test_sample_bilinear2(self): grid = RegularGrid([0.0, 0.0, 1.0, 1.0, 0.0, 0.0], values=np.array([[0, 1], [1, 0.5]])) xi, yi = np.meshgrid(np.linspace(0.5, 1.5), np.linspace(0.5, 1.5)) z = grid.sample_bilinear(xi, yi).ravel() self.assertEqual([z[400], z[1200], z[1550], z[2120]], [ 0.16326530612244894, 0.48979591836734693, 0.63265306122448983, 0.74052478134110788 ])
def test_merge(self): grid1 = RegularGrid([10, 20, 1, 1, 0, 0], values=np.ones([8, 8])) grid2 = RegularGrid([7, 22, 1, 1, 0, 0], values=2 * np.ones([4, 6])) grid3 = RegularGrid([12, 15, 1, 1, 0, 0], values=3 * np.ones([5, 5])) grid_combined = karta.raster.merge([grid1, grid2, grid3]) self.assertEqual(grid_combined.transform, (7.0, 15.0, 1.0, 1.0, 0.0, 0.0)) self.assertEqual(grid_combined.size, (13, 11)) self.assertEqual(np.sum(np.isnan(grid_combined[:, :])), 42)
def test_mask_poly_partial(self): t = -np.linspace(0, 2 * np.pi, 200) xp = ((2 + np.cos(7 * t)) * np.cos(t + 0.3) + 2) * 12 yp = ((2 + np.cos(7 * t)) * np.sin(t + 0.2) + 2) * 12 poly = karta.Polygon(zip(xp, yp), crs=karta.crs.Cartesian) grid = RegularGrid([0.0, 0.0, 0.1, 0.1, 0.0, 0.0], values=np.arange(1e6).reshape(1000, 1000), crs=karta.crs.Cartesian) masked_grid = grid.mask_by_poly(poly) self.assertEqual(masked_grid.data_mask.sum(), 181424)
def test_resample_multiband(self): grid = RegularGrid((0, 0, 1, 1, 0, 0), values=np.dstack([ np.ones((64, 64)), 2 * np.ones((64, 64)), 3 * np.ones((64, 64)) ])) grid2 = grid.resample(0.5, 0.5) self.assertEqual(grid2[0, 0, 0], 1.0) self.assertEqual(grid2[0, 0, 1], 2.0) self.assertEqual(grid2[0, 0, 2], 3.0)
def test_mask_poly_inplace(self): t = -np.linspace(0, 2 * np.pi, 200) xp = ((2 + np.cos(7 * t)) * np.cos(t + 0.3) + 4) * 12 yp = ((2 + np.cos(7 * t)) * np.sin(t + 0.2) + 4) * 12 poly = karta.Polygon(zip(xp, yp), crs=karta.crs.Cartesian) grid = RegularGrid([0.0, 0.0, 0.1, 0.1, 0.0, 0.0], values=np.arange(1e6).reshape(1000, 1000), crs=karta.crs.Cartesian) grid.mask_by_poly(poly, inplace=True) self.assertEqual(int(np.nansum(grid[:, :])), 97048730546)
def test_clip_to_extent(self): proto = RegularGrid((500, 500, 30, 30, 0, 0), np.zeros((15, 15))) clipped = self.rast.clip(*proto.get_extent("edge")) self.assertEqual(clipped.size, (15, 15)) self.assertEqual(clipped.transform, (510, 510, 30, 30, 0, 0)) X, Y = clipped.center_coords() self.assertEqual(X[0, 0], 525) self.assertEqual(X[0, -1], 945) self.assertEqual(Y[0, 0], 525) self.assertEqual(Y[-1, 0], 945)
def test_slope(self): x = np.arange(64) y = np.arange(64).reshape(-1, 1) grid = RegularGrid((0, 0, 10, 10, 0, 0), values=x * np.ones_like(y)) slope = misc.slope(grid) self.assertTrue(np.all(0.1 == slope[:, :])) grid = RegularGrid((0, 0, 10, 10, 0, 0), values=x + y) slope = misc.slope(grid) self.assertTrue(np.allclose(0.14142136, slope[:, :]))
def test_set_nodata(self): v = np.arange(64, dtype=np.float64).reshape([8, 8]) v[2:4, 5:7] = -1 grid = RegularGrid([0, 0, 1, 1, 0, 0], values=v, nodata_value=-1) self.assertEqual(grid.nodata, -1.0) ret = grid.set_nodata_value(np.nan) self.assertEqual(ret, grid) self.assertTrue(np.isnan(grid.nodata)) self.assertEqual(np.sum(np.isnan(grid[:, :])), 4) self.assertEqual(np.sum(grid[:, :] == -1.0), 0)
def test_center_coords_skewed(self): grid = RegularGrid((15.0, 15.0, 30.0, 30.0, 20.0, 10.0), values=np.zeros([5, 5])) X, Y = grid.center_coords() self.assertEqual(X[0, 0], 40.0) self.assertEqual(Y[0, 0], 35.0) self.assertEqual(X[-1, 0], 120.0) self.assertEqual(Y[-1, 0], 155.0) self.assertEqual(X[-1, -1], 240.0) self.assertEqual(Y[-1, -1], 195.0)
def test_divergence(self): x = np.linspace(-np.pi, np.pi, 256) y = np.linspace(-np.pi, np.pi, 256).reshape(-1, 1) g = RegularGrid((0, 0, 2*np.pi/255, 2*np.pi/255, 0, 0), values=np.sin(x)+np.sin(y)) u, v = misc.normed_potential_vectors(g) twoband = RegularGrid(g.transform, np.dstack([u[:,:], v[:,:]])) div = misc.divergence(twoband) self.assertTrue( np.nansum(np.abs((g[:,:]/g.max() + div[:,:]/div.max()))) < 1.32 )
def test_mask_poly_inverted(self): # grids where transform dy is negative (common for geotiffs) t = -np.linspace(0, 2 * np.pi, 200) xp = ((2 + np.cos(7 * t)) * np.cos(t + 0.3) + 4) * 12 yp = ((2 + np.cos(7 * t)) * np.sin(t + 0.2) + 4) * 12 poly = karta.Polygon(zip(xp, yp), crs=karta.crs.Cartesian) grid = RegularGrid([0.0, 100, 0.1, -0.1, 0.0, 0.0], values=np.arange(1e6).reshape(1000, 1000), crs=karta.crs.Cartesian) masked_grid = grid.mask_by_poly(poly) self.assertEqual(int(np.nansum(masked_grid[:, :])), 97048730546)
def test_apply(self): msk = np.zeros([8, 8], dtype=np.bool) msk[3, 2] = True msk[:2, 3:] = True val = np.arange(64, dtype=np.float64).reshape([8, 8]) val_ = val.copy() val[msk] = -1 grid = RegularGrid([0, 0, 1, 1, 0, 0], values=val, nodata_value=-1) newgrid = grid.apply(lambda x: x**2) npt.assert_equal(newgrid[msk], -1) npt.assert_equal(newgrid[:, :, 0][~msk], val_[~msk]**2)
def test_apply_inplace(self): msk = np.zeros([8, 8], dtype=np.bool) msk[3, 2] = True msk[:2, 3:] = True val = np.arange(64, dtype=np.float64).reshape([8, 8]) val_ = val.copy() val[msk] = -1 grid = RegularGrid([0, 0, 1, 1, 0, 0], values=val, nodata_value=-1) grid.apply(lambda x: x**2, inplace=True) self.assertTrue(np.all(grid[:, :, 0][msk] == -1)) self.assertTrue(np.all(grid[:, :, 0][~msk] == val_[~msk]**2))
def test_sample_nearest_array_order(self): grid = RegularGrid((0, 0, 1, 1, 0, 0), values=np.dstack([ np.ones((64, 64)), 2 * np.ones((64, 64)), 3 * np.ones((64, 64)) ])) X, Y = np.meshgrid(np.arange(2, 10), np.arange(5, 13)) val = grid.sample_nearest(X, Y) self.assertEqual(val[0, 0, 0], 1.0) self.assertEqual(val[1, 0, 0], 2.0) self.assertEqual(val[2, 0, 0], 3.0)