def test_multi_geom_dataset_line_string_scalar_values(self):
geoms = [{
'geometry': sgeom.LineString([(0, 0), (3, 3), (6, 0)]),
'z': 1
}]
mds = Dataset(geoms, kdims=['x', 'y', 'z'], datatype=[self.datatype])
self.assertEqual(mds.dimension_values('z'), np.array([1, 1, 1]))
self.assertEqual(mds.dimension_values('z', expanded=False),
np.array([1]))
def test_construct_from_xarray(self):
try:
import xarray as xr
except:
raise SkipError("Test requires xarray")
da = xr.DataArray(self.zs, dims=['y', 'x'],
coords = {'lat': (('y', 'x'), self.ys),
'lon': (('y', 'x'), self.xs)}, name='z')
dataset = Dataset(da, ['lon', 'lat'], 'z')
self.assertEqual(dataset.dimension_values('lon'), self.xs.T.flatten())
self.assertEqual(dataset.dimension_values('lat'), self.ys.T.flatten())
self.assertEqual(dataset.dimension_values('z'), self.zs.T.flatten())
def test_geometry_column_not_named_geometry(self):
# The geodataframe has its geometry column not named 'geometry'
gdf = geopandas.GeoDataFrame(
{
'v': [1, 2],
'not geometry': [sgeom.Point(0, 1), sgeom.Point(1, 2)],
},
geometry='not geometry',
)
ds = Dataset(gdf, kdims=['Longitude', 'Latitude'], datatype=[self.datatype])
self.assertEqual(ds.dimension_values('Longitude'), np.array([0, 1]))
self.assertEqual(ds.dimension_values('Latitude'), np.array([1, 2]))
def test_geometry_column_not_named_geometry_and_additional_geometry_column(self):
gdf = geopandas.GeoDataFrame(
{
'v': [1, 2],
'not geometry': [sgeom.Point(0, 1), sgeom.Point(1, 2)],
},
geometry='not geometry',
)
# The geodataframe contains a column called 'geometry' that doesn't contain geometry data.
gdf = gdf.rename(columns={'v': 'geometry'})
ds = Dataset(gdf, kdims=['Longitude', 'Latitude'], datatype=[self.datatype])
self.assertEqual(ds.dimension_values('Longitude'), np.array([0, 1]))
self.assertEqual(ds.dimension_values('Latitude'), np.array([1, 2]))
def test_construct_3d_from_xarray(self):
try:
import xarray as xr
except:
raise SkipError("Test requires xarray")
zs = np.arange(40).reshape(2, 4, 5)
da = xr.DataArray(zs, dims=['z', 'y', 'x'],
coords = {'lat': (('y', 'x'), self.ys),
'lon': (('y', 'x'), self.xs),
'z': [0, 1]}, name='A')
dataset = Dataset(da, ['lon', 'lat', 'z'], 'A')
self.assertEqual(dataset.dimension_values('lon'), self.xs.T.flatten())
self.assertEqual(dataset.dimension_values('lat'), self.ys.T.flatten())
self.assertEqual(dataset.dimension_values('z', expanded=False), np.array([0, 1]))
self.assertEqual(dataset.dimension_values('A'), zs.T.flatten())
def test_construct_3d_from_xarray(self):
try:
import xarray as xr
except:
raise SkipTest("Test requires xarray")
zs = np.arange(48).reshape(2, 4, 6)
da = xr.DataArray(zs, dims=['z', 'y', 'x'],
coords = {'lat': (('y', 'x'), self.ys),
'lon': (('y', 'x'), self.xs),
'z': [0, 1]}, name='A')
dataset = Dataset(da, ['lon', 'lat', 'z'], 'A')
self.assertEqual(dataset.dimension_values('lon'), self.xs.T.flatten())
self.assertEqual(dataset.dimension_values('lat'), self.ys.T.flatten())
self.assertEqual(dataset.dimension_values('z', expanded=False), np.array([0, 1]))
self.assertEqual(dataset.dimension_values('A'), zs.T.flatten())
def test_dimension_values_vdim(self):
cube = Dataset(self.cube, kdims=['longitude', 'latitude'])
self.assertEqual(cube.dimension_values('unknown', flat=False),
np.flipud(np.array([[ 0, 4, 8],
[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11]], dtype=np.int32).T))
def test_dimension_values_vdim(self):
cube = Dataset(self.cube, kdims=['longitude', 'latitude'])
self.assertEqual(cube.dimension_values('unknown', flat=False),
np.array([[ 0, 4, 8],
[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11]], dtype=np.int32).T)
def test_irregular_grid_data_values_inverted_y(self):
nx, ny = 20, 5
xs, ys = np.meshgrid(np.arange(nx)+0.5, np.arange(ny)*-1+0.5)
zs = np.arange(100).reshape(5, 20)
ds = Dataset((xs, ys, zs), ['x', 'y'], 'z')
self.assertEqual(ds.dimension_values(2, flat=False), zs)
self.assertEqual(ds.interface.coords(ds, 'x'), xs)
self.assertEqual(ds.interface.coords(ds, 'y'), ys)
def test_irregular_grid_data_values_inverted_y(self):
nx, ny = 20, 5
xs, ys = np.meshgrid(np.arange(nx)+0.5, np.arange(ny)*-1+0.5)
zs = np.arange(100).reshape(5, 20)
ds = Dataset((xs, ys, zs), ['x', 'y'], 'z')
self.assertEqual(ds.dimension_values(2, flat=False), zs)
self.assertEqual(ds.interface.coords(ds, 'x'), xs)
self.assertEqual(ds.interface.coords(ds, 'y'), ys)
def test_construct_from_xarray(self):
try:
import xarray as xr
except:
raise SkipTest("Test requires xarray")
coords = OrderedDict([('lat', (('y', 'x'), self.ys)),
('lon', (('y', 'x'), self.xs))])
da = xr.DataArray(self.zs, dims=['y', 'x'], coords=coords, name='z')
dataset = Dataset(da)
# Ensure that dimensions are inferred correctly
self.assertEqual(dataset.kdims, [Dimension('lat'), Dimension('lon')])
self.assertEqual(dataset.vdims, [Dimension('z')])
# Ensure that canonicalization works on multi-dimensional coordinates
self.assertEqual(dataset.dimension_values('lon', flat=False), self.xs)
self.assertEqual(dataset.dimension_values('lat', flat=False), self.ys)
self.assertEqual(dataset.dimension_values('z'), self.zs.T.flatten())
def test_multi_geom_point_coord_values(self):
geoms = [{
'geometry': sgeom.Point([(0, 1)])
}, {
'geometry': sgeom.Point([(3, 5)])
}]
mds = Dataset(geoms, kdims=['x', 'y'], datatype=[self.datatype])
self.assertEqual(mds.dimension_values('x'), np.array([0, 3]))
self.assertEqual(mds.dimension_values('y'), np.array([1, 5]))
def test_irregular_and_regular_coordinate_inference_inverted(self):
data = self.get_irregular_dataarray(False)
ds = Dataset(data, vdims='Value')
self.assertEqual(
ds.kdims,
[Dimension('band'),
Dimension('x'), Dimension('y')])
self.assertEqual(ds.dimension_values(3, flat=False),
data.values.transpose([1, 2, 0]))
def test_construct_from_xarray(self):
try:
import xarray as xr
except:
raise SkipTest("Test requires xarray")
coords = OrderedDict([('lat', (('y', 'x'), self.ys)),
('lon', (('y', 'x'), self.xs))])
da = xr.DataArray(self.zs, dims=['y', 'x'],
coords=coords, name='z')
dataset = Dataset(da)
# Ensure that dimensions are inferred correctly
self.assertEqual(dataset.kdims, [Dimension('lat'), Dimension('lon')])
self.assertEqual(dataset.vdims, [Dimension('z')])
# Ensure that canonicalization works on multi-dimensional coordinates
self.assertEqual(dataset.dimension_values('lon', flat=False), self.xs)
self.assertEqual(dataset.dimension_values('lat', flat=False), self.ys)
self.assertEqual(dataset.dimension_values('z'), self.zs.T.flatten())
def test_xarray_dataset_with_scalar_dim_canonicalize(self):
xs = [0, 1]
ys = [0.1, 0.2, 0.3]
zs = np.array([[[0, 1], [2, 3], [4, 5]]])
xrarr = xr.DataArray(zs, coords={'x': xs, 'y': ys, 't': [1]}, dims=['t', 'y', 'x'])
xrds = xr.Dataset({'v': xrarr})
ds = Dataset(xrds, kdims=['x', 'y'], vdims=['v'], datatype=['xarray'])
canonical = ds.dimension_values(2, flat=False)
self.assertEqual(canonical.ndim, 2)
expected = np.array([[0, 1], [2, 3], [4, 5]])
self.assertEqual(canonical, expected)
def test_xarray_dataset_with_scalar_dim_canonicalize(self):
xs = [0, 1]
ys = [0.1, 0.2, 0.3]
zs = np.array([[[0, 1], [2, 3], [4, 5]]])
xrarr = xr.DataArray(zs, coords={'x': xs, 'y': ys, 't': [1]}, dims=['t', 'y', 'x'])
xrds = xr.Dataset({'v': xrarr})
ds = Dataset(xrds, kdims=['x', 'y'], vdims=['v'], datatype=['xarray'])
canonical = ds.dimension_values(2, flat=False)
self.assertEqual(canonical.ndim, 2)
expected = np.array([[0, 1], [2, 3], [4, 5]])
self.assertEqual(canonical, expected)
def test_3d_xarray_with_constant_dim_canonicalized_to_2d(self):
try:
import xarray as xr
except:
raise SkipTest("Test requires xarray")
zs = np.arange(24).reshape(1, 4, 6)
# Construct DataArray with additional constant dimension
da = xr.DataArray(zs, dims=['z', 'y', 'x'],
coords = {'lat': (('y', 'x'), self.ys),
'lon': (('y', 'x'), self.xs),
'z': [0]}, name='A')
# Declare Dataset without declaring constant dimension
dataset = Dataset(da, ['lon', 'lat'], 'A')
# Ensure that canonicalization drops the constant dimension
self.assertEqual(dataset.dimension_values('A', flat=False), zs[0])
def test_3d_xarray_with_constant_dim_canonicalized_to_2d(self):
try:
import xarray as xr
except:
raise SkipTest("Test requires xarray")
zs = np.arange(24).reshape(1, 4, 6)
# Construct DataArray with additional constant dimension
da = xr.DataArray(zs, dims=['z', 'y', 'x'],
coords = {'lat': (('y', 'x'), self.ys),
'lon': (('y', 'x'), self.xs),
'z': [0]}, name='A')
# Declare Dataset without declaring constant dimension
dataset = Dataset(da, ['lon', 'lat'], 'A')
# Ensure that canonicalization drops the constant dimension
self.assertEqual(dataset.dimension_values('A', flat=False), zs[0])
def test_irregular_and_regular_coordinate_explicit_irregular_coords_inverted(
self):
data = self.get_irregular_dataarray(False)
ds = Dataset(data, ['xc', 'yc'], vdims='Value')
self.assertEqual(ds.kdims, [Dimension('xc'), Dimension('yc')])
self.assertEqual(ds.dimension_values(2, flat=False), data.values[0])
def test_irregular_and_regular_coordinate_inference_inverted(self):
data = self.get_irregular_dataarray(False)
ds = Dataset(data, vdims='Value')
self.assertEqual(ds.kdims, [Dimension('band'), Dimension('x'), Dimension('y')])
self.assertEqual(ds.dimension_values(3, flat=False), data.values.transpose([1, 2, 0]))
def test_dataset_allow_none_values(self):
ds = Dataset({'x': None, 'y': [0, 1]}, kdims=['x', 'y'])
self.assertEqual(ds.dimension_values(0), np.array([None, None]))
def test_graph_node_info_no_index(self):
node_info = Dataset(np.arange(8), vdims=['Label'])
graph = Graph(((self.source, self.target), node_info))
self.assertEqual(graph.nodes.dimension_values(3),
node_info.dimension_values(0))
def test_dimension_values_kdim(self):
cube = Dataset(self.cube, kdims=['longitude', 'latitude'])
self.assertEqual(cube.dimension_values('longitude', expanded=False),
np.array([-1, 0, 1, 2], dtype=np.int32))
def test_irregular_and_regular_coordinate_explicit_irregular_coords_inverted(self):
data = self.get_irregular_dataarray(False)
ds = Dataset(data, ['xc', 'yc'], vdims='Value')
self.assertEqual(ds.kdims, [Dimension('xc'), Dimension('yc')])
self.assertEqual(ds.dimension_values(2, flat=False), data.values[0])
def test_multi_geom_dataset_poly_coord_values(self):
geoms = [sgeom.Polygon([(0, 0), (6, 6), (3, 3)])]
mds = Dataset(geoms, kdims=['x', 'y'], datatype=[self.datatype])
self.assertEqual(mds.dimension_values('x'), np.array([0, 6, 3, 0]))
self.assertEqual(mds.dimension_values('y'), np.array([0, 6, 3, 0]))
def test_graph_node_info_merge_on_index(self):
node_info = Dataset((np.arange(8), np.arange(1,9)), 'index', 'label')
graph = Graph(((self.source, self.target), node_info))
self.assertEqual(graph.nodes.dimension_values(3),
node_info.dimension_values(1))
def test_construct_from_dict(self):
dataset = Dataset((self.xs, self.ys, self.zs), ['x', 'y'], 'z')
self.assertEqual(dataset.dimension_values('x'), self.xs.T.flatten())
self.assertEqual(dataset.dimension_values('y'), self.ys.T.flatten())
self.assertEqual(dataset.dimension_values('z'), self.zs.T.flatten())
def test_construct_from_dict(self):
dataset = Dataset((self.xs, self.ys, self.zs), ['x', 'y'], 'z')
self.assertEqual(dataset.dimension_values('x'), self.xs.T.flatten())
self.assertEqual(dataset.dimension_values('y'), self.ys.T.flatten())
self.assertEqual(dataset.dimension_values('z'), self.zs.T.flatten())
def test_dimension_values_kdim(self):
cube = Dataset(self.cube, kdims=['longitude', 'latitude'])
self.assertEqual(cube.dimension_values('longitude', expanded=False),
np.array([-1, 0, 1, 2], dtype=np.int32))
def test_xarray_irregular_dataset_values(self):
ds = Dataset(self.get_multi_dim_irregular_dataset())
values = ds.dimension_values('z', expanded=False)
self.assertEqual(values, np.array([0, 1, 2, 3]))
def test_graph_node_info_no_index(self):
node_info = Dataset(np.arange(8), vdims=['Label'])
graph = Graph(((self.source, self.target), node_info))
self.assertEqual(graph.nodes.dimension_values(3),
node_info.dimension_values(0))
def test_dataset_empty_list_init_dtypes(self):
dataset = Dataset([], kdims=['x'], vdims=['y'])
for d in 'xy':
self.assertEqual(dataset.dimension_values(d).dtype, np.float64)
def test_multi_geom_dataset_line_string_coord_values(self):
geoms = [sgeom.LineString([(0, 0), (3, 3), (6, 0)])]
mds = Dataset(geoms, kdims=['x', 'y'], datatype=[self.datatype])
self.assertEqual(mds.dimension_values('x'), np.array([0, 3, 6]))
self.assertEqual(mds.dimension_values('y'), np.array([0, 3, 0]))
def test_dataset_empty_list_init_dtypes(self):
dataset = Dataset([], kdims=['x'], vdims=['y'])
for d in 'xy':
self.assertEqual(dataset.dimension_values(d).dtype, np.float64)
def test_dataset_multi_vdim_empty_constructor(self):
ds = Dataset([], ['x', 'y'], ['z1', 'z2', 'z3'])
assert all(
ds.dimension_values(vd, flat=False).shape == (0, 0)
for vd in ds.vdims)
def test_graph_node_info_merge_on_index(self):
node_info = Dataset((np.arange(8), np.arange(1, 9)), 'index', 'label')
graph = Graph(((self.source, self.target), node_info))
self.assertEqual(graph.nodes.dimension_values(3),
node_info.dimension_values(1))
def test_dataset_allow_none_values(self):
ds = Dataset({'x': None, 'y': [0, 1]}, kdims=['x', 'y'])
self.assertEqual(ds.dimension_values(0), np.array([None, None]))
