def test_rgb_regrid_packed(self):
coords = {'x': [1, 2], 'y': [1, 2], 'band': [0, 1, 2]}
arr = np.array([
[[255, 10],
[ 0, 30]],
[[ 1, 0],
[ 0, 0]],
[[127, 0],
[ 0, 68]],
]).T
da = xr.DataArray(data=arr, dims=('x', 'y', 'band'), coords=coords)
im = RGB(da, ['x', 'y'])
agg = rasterize(im, width=3, height=3, dynamic=False, upsample=True)
xs = [0.8333333, 1.5, 2.166666]
ys = [0.8333333, 1.5, 2.166666]
arr = np.array([
[[255, 255, 10],
[255, 255, 10],
[ 0, 0, 30]],
[[ 1, 1, 0],
[ 1, 1, 0],
[ 0, 0, 0]],
[[127, 127, 0],
[127, 127, 0],
[ 0, 0, 68]],
]).transpose((1, 2, 0))
expected = RGB((xs, ys, arr))
self.assertEqual(agg, expected)
def test_regrid_rgb_mean(self):
arr = (np.arange(10) * np.arange(5)[np.newaxis].T).astype('f')
rgb = RGB((range(10), range(5), arr, arr*2, arr*2))
regridded = regrid(rgb, width=2, height=2, dynamic=False)
new_arr = np.array([[1.6, 5.6], [6.4, 22.4]])
expected = RGB(([2., 7.], [0.75, 3.25], new_arr, new_arr*2, new_arr*2), datatype=['xarray'])
self.assertEqual(regridded, expected)
def setUp(self):
self.rgb1_arr = np.array([[[0, 1], [1, 0]],
[[1, 0], [0, 1]],
[[0, 0], [0, 0]]], dtype=np.uint8).T*255
self.rgb2_arr = np.array([[[0, 0], [0, 0]],
[[0, 0], [0, 0]],
[[1, 0], [0, 1]]], dtype=np.uint8).T*255
self.rgb1 = RGB(self.rgb1_arr)
self.rgb2 = RGB(self.rgb2_arr)
def test_spread_rgb_1px(self):
arr = np.array([[[0, 0, 0], [0, 1, 1], [0, 1, 1]],
[[0, 0, 0], [0, 0, 0], [0, 0, 0]],
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]], dtype=np.uint8).T*255
spreaded = spread(RGB(arr))
arr = np.array([[[0, 0, 1], [0, 0, 1], [0, 0, 1]],
[[0, 0, 0], [0, 0, 0], [0, 0, 0]],
[[0, 0, 0], [0, 0, 0], [0, 0, 0]],
[[1, 1, 1], [1, 1, 1], [1, 1, 1]]], dtype=np.uint8).T*255
self.assertEqual(spreaded, RGB(arr))
def test_rgb_string_signature(self):
img = RGB(np.zeros((2, 2, 3)), ['a', 'b'], ['R', 'G', 'B'])
self.assertEqual(img.kdims, [Dimension('a'), Dimension('b')])
self.assertEqual(
img.vdims,
[Dimension('R'), Dimension('G'),
Dimension('B')])
def test_stack_add_compositor(self):
combined = stack(self.rgb1 * self.rgb2, compositor='add')
arr = np.array(
[[[0, 255, 255], [255, 0, 0]], [[255, 0, 0], [0, 255, 255]]],
dtype=np.uint8)
expected = RGB(arr)
self.assertEqual(combined, expected)
def test_shade_categorical_images_grid(self):
xs, ys = [0.25, 0.75], [0.25, 0.75]
data = NdOverlay(
{
'A':
Image((xs, ys, [[1, 0], [0, 0]]),
datatype=['grid'],
vdims='z Count'),
'B':
Image((xs, ys, [[0, 0], [1, 0]]),
datatype=['grid'],
vdims='z Count'),
'C':
Image((xs, ys, [[0, 0], [1, 0]]),
datatype=['grid'],
vdims='z Count')
},
kdims=['z'])
shaded = shade(data)
r = [[228, 255], [66, 255]]
g = [[26, 255], [150, 255]]
b = [[28, 255], [129, 255]]
a = [[40, 0], [255, 0]]
expected = RGB((xs, ys, r, g, b, a),
datatype=['grid'],
vdims=RGB.vdims + [Dimension('A', range=(0, 1))])
self.assertEqual(shaded, expected)
def test_shade_dt_xaxis_constant_yaxis(self):
df = pd.DataFrame({'y': np.ones(100)}, index=pd.date_range('1980-01-01', periods=100, freq='1T'))
rgb = shade(rasterize(Curve(df), dynamic=False, width=3))
xs = np.array(['1980-01-01T00:16:30.000000', '1980-01-01T00:49:30.000000',
'1980-01-01T01:22:30.000000'], dtype='datetime64[us]')
ys = np.array([])
bounds = (np.datetime64('1980-01-01T00:00:00.000000'), 1.0,
np.datetime64('1980-01-01T01:39:00.000000'), 1.0)
expected = RGB((xs, ys, np.empty((0, 3, 4))), ['index', 'y'],
xdensity=1, ydensity=1, bounds=bounds)
self.assertEqual(rgb, expected)
def init_data(self):
self.xs = np.linspace(-9, 9, 10)
self.ys = np.linspace(0.5, 9.5, 10)
self.rgb_array = np.random.rand(10, 10, 3)
self.rgb = RGB((self.xs, self.ys, self.rgb_array[:, :, 0],
self.rgb_array[:, :, 1], self.rgb_array[:, :, 2]))
def init_data(self):
self.rgb_array = np.random.rand(10, 10, 3)
self.rgb = RGB(self.rgb_array[::-1], bounds=(-10, 0, 10, 10))
class RGBInterfaceTest(ComparisonTestCase):
datatype = 'image'
def setUp(self):
self.eltype = RGB
self.restore_datatype = self.eltype.datatype
self.eltype.datatype = [self.datatype]
self.init_data()
def tearDown(self):
self.eltype.datatype = self.restore_datatype
def init_data(self):
self.rgb_array = np.random.rand(10, 10, 3)
self.rgb = RGB(self.rgb_array[::-1], bounds=(-10, 0, 10, 10))
def test_init_bounds(self):
self.assertEqual(self.rgb.bounds.lbrt(), (-10, 0, 10, 10))
def test_init_densities(self):
self.assertEqual(self.rgb.xdensity, 0.5)
self.assertEqual(self.rgb.ydensity, 1)
def test_dimension_values_xs(self):
self.assertEqual(self.rgb.dimension_values(0, expanded=False),
np.linspace(-9, 9, 10))
def test_dimension_values_ys(self):
self.assertEqual(self.rgb.dimension_values(1, expanded=False),
np.linspace(0.5, 9.5, 10))
def test_dimension_values_vdims(self):
self.assertEqual(self.rgb.dimension_values(2, flat=False),
self.rgb_array[:, :, 0])
self.assertEqual(self.rgb.dimension_values(3, flat=False),
self.rgb_array[:, :, 1])
self.assertEqual(self.rgb.dimension_values(4, flat=False),
self.rgb_array[:, :, 2])
def test_slice_xaxis(self):
sliced = self.rgb[0.3:5.2]
self.assertEqual(sliced.bounds.lbrt(), (0, 0, 6, 10))
self.assertEqual(sliced.xdensity, 0.5)
self.assertEqual(sliced.ydensity, 1)
self.assertEqual(sliced.dimension_values(2, flat=False),
self.rgb_array[:, 5:8, 0])
def test_slice_yaxis(self):
sliced = self.rgb[:, 1.2:5.2]
self.assertEqual(sliced.bounds.lbrt(), (-10, 1., 10, 5))
self.assertEqual(sliced.xdensity, 0.5)
self.assertEqual(sliced.ydensity, 1)
self.assertEqual(sliced.dimension_values(2, flat=False),
self.rgb_array[1:5, :, 0])
def test_slice_both_axes(self):
sliced = self.rgb[0.3:5.2, 1.2:5.2]
self.assertEqual(sliced.bounds.lbrt(), (0, 1., 6, 5))
self.assertEqual(sliced.xdensity, 0.5)
self.assertEqual(sliced.ydensity, 1)
self.assertEqual(sliced.dimension_values(2, flat=False),
self.rgb_array[1:5, 5:8, 0])
def test_slice_x_index_y(self):
sliced = self.rgb[0.3:5.2, 5.2]
self.assertEqual(sliced.bounds.lbrt(), (0, 5.0, 6.0, 6.0))
self.assertEqual(sliced.xdensity, 0.5)
self.assertEqual(sliced.ydensity, 1)
self.assertEqual(sliced.dimension_values(2, flat=False),
self.rgb_array[5:6, 5:8, 0])
def test_index_x_slice_y(self):
sliced = self.rgb[3.2, 1.2:5.2]
self.assertEqual(sliced.bounds.lbrt(), (2.0, 1.0, 4.0, 5.0))
self.assertEqual(sliced.xdensity, 0.5)
self.assertEqual(sliced.ydensity, 1)
self.assertEqual(sliced.dimension_values(2, flat=False),
self.rgb_array[1:5, 6:7, 0])
def test_select_value_dimension_rgb(self):
self.assertEqual(
self.rgb[..., 'R'],
Image(np.flipud(self.rgb_array[:, :, 0]),
bounds=self.rgb.bounds,
vdims=[Dimension('R', range=(0, 1))]))
def test_select_single_coordinate(self):
with DatatypeContext([self.datatype, 'dictionary', 'dataframe'],
self.rgb):
self.assertEqual(
self.rgb[5.2, 3.1],
self.rgb.clone([tuple(self.rgb_array[3, 7])],
kdims=[],
new_type=Dataset))
def test_reduce_to_single_values(self):
with DatatypeContext([self.datatype, 'dictionary', 'dataframe'],
self.rgb):
self.assertEqual(
self.rgb.reduce(['x', 'y'], function=np.mean),
self.rgb.clone([tuple(np.mean(self.rgb_array, axis=(0, 1)))],
kdims=[],
new_type=Dataset))
def test_sample_xcoord(self):
ys = np.linspace(0.5, 9.5, 10)
data = (ys, ) + tuple(self.rgb_array[:, 7, i] for i in range(3))
with DatatypeContext([self.datatype, 'dictionary', 'dataframe'],
self.rgb):
self.assertEqual(self.rgb.sample(x=5),
self.rgb.clone(data, kdims=['y'], new_type=Curve))
def test_sample_ycoord(self):
xs = np.linspace(-9, 9, 10)
data = (xs, ) + tuple(self.rgb_array[4, :, i] for i in range(3))
with DatatypeContext([self.datatype, 'dictionary', 'dataframe'],
self.rgb):
self.assertEqual(self.rgb.sample(y=5),
self.rgb.clone(data, kdims=['x'], new_type=Curve))
def test_dataset_reindex_constant(self):
ds = Dataset(self.rgb.select(x=0))
reindexed = ds.reindex(['y'], ['R'])
data = Dataset(ds.columns(['y', 'R']),
kdims=['y'],
vdims=[ds.vdims[0]])
self.assertEqual(reindexed, data)
def test_dataset_reindex_non_constant(self):
ds = Dataset(self.rgb)
reindexed = ds.reindex(['y'], ['R'])
data = Dataset(ds.columns(['y', 'R']),
kdims=['y'],
vdims=[ds.vdims[0]])
self.assertEqual(reindexed, data)
def test_rgb_casting(self):
rgb = RGB([], bounds=2)
self.assertEqual(rgb, RGB(rgb))
def init_data(self):
self.rgb = RGB(self.rgb_array[::-1], bounds=(-10, 0, 10, 10))
def init_data(self):
self.rgb = RGB(self.rgb_array[::-1], bounds=(-10, 0, 10, 10))
class RGB_ImageInterfaceTests(InterfaceTests):
datatype = 'image'
element = RGB
def init_grid_data(self):
self.xs = np.linspace(-9, 9, 10)
self.ys = np.linspace(0.5, 9.5, 10)
self.rgb_array = np.random.rand(10, 10, 3)
def init_data(self):
self.rgb = RGB(self.rgb_array[::-1], bounds=(-10, 0, 10, 10))
def test_init_bounds(self):
self.assertEqual(self.rgb.bounds.lbrt(), (-10, 0, 10, 10))
def test_init_densities(self):
self.assertEqual(self.rgb.xdensity, 0.5)
self.assertEqual(self.rgb.ydensity, 1)
def test_dimension_values_xs(self):
self.assertEqual(self.rgb.dimension_values(0, expanded=False),
np.linspace(-9, 9, 10))
def test_dimension_values_ys(self):
self.assertEqual(self.rgb.dimension_values(1, expanded=False),
np.linspace(0.5, 9.5, 10))
def test_dimension_values_vdims(self):
self.assertEqual(self.rgb.dimension_values(2, flat=False),
self.rgb_array[:, :, 0])
self.assertEqual(self.rgb.dimension_values(3, flat=False),
self.rgb_array[:, :, 1])
self.assertEqual(self.rgb.dimension_values(4, flat=False),
self.rgb_array[:, :, 2])
def test_slice_xaxis(self):
sliced = self.rgb[0.3:5.2]
self.assertEqual(sliced.bounds.lbrt(), (0, 0, 6, 10))
self.assertEqual(sliced.xdensity, 0.5)
self.assertEqual(sliced.ydensity, 1)
self.assertEqual(sliced.dimension_values(2, flat=False),
self.rgb_array[:, 5:8, 0])
def test_slice_yaxis(self):
sliced = self.rgb[:, 1.2:5.2]
self.assertEqual(sliced.bounds.lbrt(), (-10, 1., 10, 5))
self.assertEqual(sliced.xdensity, 0.5)
self.assertEqual(sliced.ydensity, 1)
self.assertEqual(sliced.dimension_values(2, flat=False),
self.rgb_array[1:5, :, 0])
def test_slice_both_axes(self):
sliced = self.rgb[0.3:5.2, 1.2:5.2]
self.assertEqual(sliced.bounds.lbrt(), (0, 1., 6, 5))
self.assertEqual(sliced.xdensity, 0.5)
self.assertEqual(sliced.ydensity, 1)
self.assertEqual(sliced.dimension_values(2, flat=False),
self.rgb_array[1:5, 5:8, 0])
def test_slice_x_index_y(self):
sliced = self.rgb[0.3:5.2, 5.2]
self.assertEqual(sliced.bounds.lbrt(), (0, 5.0, 6.0, 6.0))
self.assertEqual(sliced.xdensity, 0.5)
self.assertEqual(sliced.ydensity, 1)
self.assertEqual(sliced.dimension_values(2, flat=False),
self.rgb_array[5:6, 5:8, 0])
def test_index_x_slice_y(self):
sliced = self.rgb[3.2, 1.2:5.2]
self.assertEqual(sliced.bounds.lbrt(), (2.0, 1.0, 4.0, 5.0))
self.assertEqual(sliced.xdensity, 0.5)
self.assertEqual(sliced.ydensity, 1)
self.assertEqual(sliced.dimension_values(2, flat=False),
self.rgb_array[1:5, 6:7, 0])
def test_select_value_dimension_rgb(self):
self.assertEqual(self.rgb[..., 'R'],
Image(np.flipud(self.rgb_array[:, :, 0]), bounds=self.rgb.bounds,
vdims=[Dimension('R', range=(0, 1))], datatype=['image']))
def test_select_single_coordinate(self):
with DatatypeContext([self.datatype, 'dictionary' , 'dataframe'], self.rgb):
self.assertEqual(self.rgb[5.2, 3.1],
self.rgb.clone([tuple(self.rgb_array[3, 7])],
kdims=[], new_type=Dataset))
def test_reduce_to_single_values(self):
with DatatypeContext([self.datatype, 'dictionary' , 'dataframe'], self.rgb):
self.assertEqual(self.rgb.reduce(['x', 'y'], function=np.mean),
self.rgb.clone([tuple(np.mean(self.rgb_array, axis=(0, 1)))],
kdims=[], new_type=Dataset))
def test_sample_xcoord(self):
ys = np.linspace(0.5, 9.5, 10)
data = (ys,) + tuple(self.rgb_array[:, 7, i] for i in range(3))
with DatatypeContext([self.datatype, 'dictionary' , 'dataframe'], self.rgb):
self.assertEqual(self.rgb.sample(x=5),
self.rgb.clone(data, kdims=['y'],
new_type=Curve))
def test_sample_ycoord(self):
xs = np.linspace(-9, 9, 10)
data = (xs,) + tuple(self.rgb_array[4, :, i] for i in range(3))
with DatatypeContext([self.datatype, 'dictionary' , 'dataframe'], self.rgb):
self.assertEqual(self.rgb.sample(y=5),
self.rgb.clone(data, kdims=['x'],
new_type=Curve))
def test_dataset_reindex_constant(self):
with DatatypeContext([self.datatype, 'dictionary', 'dataframe', 'grid'], self.rgb):
ds = Dataset(self.rgb.select(x=0))
reindexed = ds.reindex(['y'], ['R'])
data = Dataset(ds.columns(['y', 'R']),
kdims=['y'], vdims=[ds.vdims[0]])
self.assertEqual(reindexed, data)
def test_dataset_reindex_non_constant(self):
with DatatypeContext([self.datatype, 'dictionary' , 'dataframe', 'grid'], self.rgb):
ds = Dataset(self.rgb)
reindexed = ds.reindex(['y'], ['R'])
data = Dataset(ds.columns(['y', 'R']),
kdims=['y'], vdims=[ds.vdims[0]])
self.assertEqual(reindexed, data)
