def test_read_as_bands(self):
# write several files and then read as a single multiband grid
v = peaks(500)[:100, :]
utm7 = karta.crs.ProjectedCRS("+proj=utm +zone=7 +north +datum=WGS84",
"UTM 7N (WGS 84)")
g1 = karta.RegularGrid([15.0, 15.0, 30.0, 30.0, 0.0, 0.0], v, crs=utm7)
g2 = karta.RegularGrid([15.0, 15.0, 30.0, 30.0, 0.0, 0.0],
v**2,
crs=utm7)
g3 = karta.RegularGrid([15.0, 15.0, 30.0, 30.0, 0.0, 0.0],
v + 2,
crs=utm7)
g4 = karta.RegularGrid([15.0, 15.0, 30.0, 30.0, 0.0, 0.0],
v * 2,
crs=utm7)
paths = []
for i, g in enumerate((g1, g2, g3, g4)):
fpath = os.path.join(TMPDATA, "test{0}.tif".format(i))
g.to_geotiff(fpath, compress=None)
paths.append(fpath)
gnew = karta.from_geotiffs(*paths)
self.assertTrue("+proj=utm" in gnew.crs.get_proj4())
self.assertTrue("+zone=7" in gnew.crs.get_proj4())
self.assertEqual(g.transform, gnew.transform)
self.assertEqual(g.values.dtype, gnew.values.dtype)
self.assertEqual(gnew.size, (100, 500))
self.assertEqual(gnew.nbands, 4)
return
def test_merge(self):
grid1 = karta.RegularGrid([10, 20, 1, 1, 0, 0], values=np.ones([8, 8]))
grid2 = karta.RegularGrid([7, 22, 1, 1, 0, 0],
values=2 * np.ones([4, 6]))
grid3 = karta.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)
return
def test_merge_weighted(self):
grid1 = karta.RegularGrid([10, 20, 1, 1, 0, 0], values=np.ones([8, 8]))
grid2 = karta.RegularGrid([7, 22, 1, 1, 0, 0],
values=2 * np.ones([4, 6]))
grid3 = karta.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], 1.66666666666)
self.assertAlmostEqual(grid_combined[2, 8], 2.5)
self.assertAlmostEqual(grid_combined[4, 5], 2.33333333333)
return
def test_read_aai_corner(self):
pe = peaks(n=49)
control = karta.RegularGrid((0.0, 0.0, 30.0, 30.0, 0.0, 0.0),
values=pe)
grid = karta.read_aai(os.path.join(TESTDATA, "peaks49_corner.asc"))
self.assertTrue(np.all(grid[::-1] == control[:, :]))
return
def test_resize_lower_left(self):
proto = karta.RegularGrid((500, 500, 30, 30, 0, 0), values=peaks(50))
newgrid = proto.resize([380, 320, 380 + 30 * 30, 320 + 30 * 32])
self.assertEqual(newgrid.transform,
(380.0, 320.0, 30.0, 30.0, 0.0, 0.0))
self.assertTrue(np.all(newgrid[6:, 4:] == proto[:26, :26]))
return
def test_resize_larger(self):
proto = karta.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[:, :]))
return
def test_resize_upper_right(self):
proto = karta.RegularGrid((500, 500, 30, 30, 0, 0), values=peaks(50))
newgrid = proto.resize([1940, 1910, 1940 + 30 * 10, 1910 + 30 * 7])
self.assertEqual(newgrid.transform,
(1940.0, 1910.0, 30.0, 30.0, 0.0, 0.0))
self.assertTrue(np.all(newgrid[:3, :2] == proto[-3:, -2:]))
return
def test_resize_smaller(self):
proto = karta.RegularGrid((500, 500, 30, 30, 0, 0), values=peaks(50))
newgrid = proto.resize([620, 650, 1370, 1310])
self.assertEqual(newgrid.transform,
(620.0, 650.0, 30.0, 30.0, 0.0, 0.0))
self.assertTrue(np.all(newgrid[:, :] == proto[5:27, 4:29]))
return
def test_data_mask_nonnan(self):
T = [0.0, 0.0, 1.0, 1.0, 0.0, 0.0]
v = np.arange(64, dtype=np.int8).reshape([8, 8])
v[0, 2:7] = -1
g = karta.RegularGrid(T, values=v, nodata_value=-1)
self.assertEqual(np.sum(g.data_mask), 59)
return
def test_vertex_coords_skewed(self):
grid = karta.RegularGrid((0.0, 0.0, 30.0, 30.0, 20.0, 10.0),
values=np.zeros([5, 5]))
ans = np.meshgrid(np.arange(15.0, 1486.0, 30.0),
np.arange(15.0, 1486.0, 30.0))
self.assertTrue(np.sum(self.rast.vertex_coords()[0] - ans[0]) < 1e-10)
self.assertTrue(np.sum(self.rast.vertex_coords()[1] - ans[1]) < 1e-10)
return
def test_sample_nearest_skewed(self):
grid = karta.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)
return
def test_sample_nearest(self):
grid = karta.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)
return
def test_mask_poly_partial2(self):
# this case has the first transect begin off-grid, which has caused
# problems in the past
g = karta.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)
return
def test_center_coords(self):
grid = karta.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]))
return
def test_get_positions(self):
grid = karta.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))
return
def setUp(self):
v = peaks(500)[:100, :]
utm7 = karta.crs.ProjectedCRS("+proj=utm +zone=7 +north +datum=WGS84",
"UTM 7N (WGS 84)")
g = karta.RegularGrid([15.0, 15.0, 30.0, 30.0, 0.0, 0.0], v, crs=utm7)
fpath = os.path.join(TMPDATA, "test.tif")
g.to_geotiff(fpath, compress=None)
self.grid = karta.read_geotiff(fpath, in_memory=False)
def test_minmax_nodata(self):
values = np.array([[4, 5, 3], [4, 2, -9], [3, 6, 1]])
self.rast = karta.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))
return
def test_sample_bilinear2(self):
grid = karta.RegularGrid([0.5, 0.5, 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.ravel(), yi.ravel())
self.assertEqual([z[400], z[1200], z[1550], z[2120]],
[0.16326530612244894, 0.48979591836734693,
0.63265306122448983, 0.74052478134110788])
return
def test_set_nodata(self):
v = np.arange(64, dtype=np.float64).reshape([8, 8])
v[2:4, 5:7] = -1
grid = karta.RegularGrid([0, 0, 1, 1, 0, 0], values=v, nodata_value=-1)
self.assertEqual(grid.nodata, -1.0)
grid.set_nodata_value(np.nan)
self.assertTrue(np.isnan(grid.nodata))
self.assertEqual(np.sum(np.isnan(grid[:, :])), 4)
self.assertEqual(np.sum(grid[:, :] == -1.0), 0)
return
def test_minmax_nodata2(self):
values = -9 * np.ones([3, 3])
self.rast = karta.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]))
return
def test_clip_to_extents(self):
proto = karta.RegularGrid((495, 495, 30, 30, 0, 0), np.zeros((15,15)))
clipped = self.rast.clip(*proto.get_extents())
self.assertEqual(clipped.size, (15, 15))
self.assertEqual(clipped.transform, (495, 495, 30, 30, 0, 0))
X, Y = clipped.center_coords()
self.assertEqual(X[0,0], 495)
self.assertEqual(X[0,-1], 915)
self.assertEqual(Y[0,0], 495)
self.assertEqual(Y[-1,0], 915)
def test_write_compress(self):
v = peaks(500)[:100, :]
utm7 = karta.crs.ProjectedCRS("+proj=utm +zone=7 +north +datum=WGS84",
"UTM 7N (WGS 84)")
g = karta.RegularGrid([15.0, 15.0, 30.0, 30.0, 0.0, 0.0], v, crs=utm7)
fpath = os.path.join(TMPDATA, "test.tif")
g.to_gtiff(fpath, compress="LZW")
g.to_gtiff(fpath, compress="PACKBITS")
return
def test_sample_multipoint(self):
grid = karta.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]))))
return
def test_center_coords_skewed(self):
grid = karta.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)
return
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 = karta.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)
return
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 = karta.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)
return
def test_clip_to_extent(self):
proto = karta.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)
return
def test_mask_poly_partial(self):
# test case where polygon is partly outside the grid extents
# simply ensures that it doesn't crash for now
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 = karta.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)
return
def test_get_extent_crs(self):
pe = peaks(n=49)
crs = karta.crs.ProjectedCRS(
"+proj=utm +zone=12 +ellps=WGS84 +north=True", "UTM 12N (WGS 84)")
rast_utm12N = karta.RegularGrid((0.0, 0.0, 10000.0, 10000.0, 0.0, 0.0),
values=pe,
crs=crs)
a, b, c, d = rast_utm12N.get_extent(reference='center',
crs=karta.crs.LonLatWGS84)
self.assertAlmostEqual(a, -115.45687156)
self.assertAlmostEqual(b, -111.13480112)
self.assertAlmostEqual(c, 0.0450996517)
self.assertAlmostEqual(d, 4.3878488543)
return
def test_mask_poly_multipl(self):
t = -np.linspace(0, 2 * np.pi, 200)
xp = ((2 + np.cos(7 * t)) * np.cos(t + 0.3) + 4) * 4 + 15
yp = ((2 + np.cos(7 * t)) * np.sin(t + 0.2) + 4) * 4 + 72
poly = karta.Polygon(zip(xp, yp), crs=karta.crs.Cartesian)
xp2 = ((2 + np.cos(7 * t)) * np.cos(t + 0.3) + 4) * 6 + 40
yp2 = ((2 + np.cos(7 * t)) * np.sin(t + 0.2) + 4) * 6 + 30
poly2 = karta.Polygon(zip(xp2, yp2), crs=karta.crs.Cartesian)
grid = karta.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, poly2])
self.assertEqual(int(np.nansum(masked_grid[:, :])), 47081206720)
return
