def test_apply_mask_job(default_k2is, lt_ctx):
mask = np.ones((1860, 2048))
tileshape = Shape(
(16, 930, 16),
sig_dims=2,
)
tiling_scheme = TilingScheme.make_for_shape(
tileshape=tileshape,
dataset_shape=default_k2is.shape,
)
job = ApplyMasksJob(
dataset=default_k2is,
mask_factories=[lambda: mask],
tiling_scheme=tiling_scheme,
)
out = job.get_result_buffer()
executor = InlineJobExecutor()
for tiles in executor.run_job(job):
for tile in tiles:
tile.reduce_into_result(out)
results = lt_ctx.run(job)
assert results[0].shape == (34 * 35, )
# there should be _something_ in each result pixel
for px in results[0].reshape((-1, )):
assert not np.isclose(px, 0)
def test_subframe_tiles():
data = np.random.choice(a=[0, 1], size=(16, 16, 16, 16))
mask = np.random.choice(a=[0, 1], size=(16, 16))
expected = _naive_mask_apply([mask], data)
mask_factories = [
lambda: mask,
]
dataset = MemoryDataSet(data=data, tileshape=(1, 1, 4, 4), partition_shape=(16, 16, 16, 16))
job = ApplyMasksJob(dataset=dataset, mask_factories=mask_factories)
part = next(dataset.get_partitions())
executor = InlineJobExecutor()
result = np.zeros((1, 16, 16))
for tiles in executor.run_job(job):
for tile in tiles:
tile.copy_to_result(result)
print(part.shape)
print(expected)
print(result)
assert np.allclose(
result,
expected
)
def do_com(fn, tileshape):
ds = H5DataSet(
path=fn,
ds_path="data",
tileshape=tileshape,
target_size=512*1024*1024,
)
masks = [
# summation of all pixels:
lambda: np.ones(shape=ds.shape[2:]),
# gradient from left to right
lambda: gradient_x(*ds.shape[2:]),
# gradient from top to bottom
lambda: gradient_y(*ds.shape[2:]),
]
job = ApplyMasksJob(dataset=ds, mask_factories=masks)
print(job.masks.computed_masks)
print("\n\n")
executor = InlineJobExecutor()
full_result = np.zeros(shape=(3,) + ds.shape[:2])
color = np.zeros(shape=(3,) + ds.shape[:2])
for result in executor.run_job(job):
for tile in result:
print(tile)
print(tile.data[0])
color[tile.tile_slice.get()[:2]] += 1
tile.copy_to_result(full_result)
x_centers = np.divide(full_result[1], full_result[0])
y_centers = np.divide(full_result[2], full_result[0])
print(color)
return full_result, x_centers, y_centers
def test_apply_mask_on_raw_job(default_blo, lt_ctx):
mask = np.ones((144, 144))
job = ApplyMasksJob(dataset=default_blo, mask_factories=[lambda: mask])
out = job.get_result_buffer()
executor = InlineJobExecutor()
for tiles in executor.run_job(job):
for tile in tiles:
tile.reduce_into_result(out)
results = lt_ctx.run(job)
assert results[0].shape == (90 * 121, )
def test_apply_mask_on_empad_job(default_empad, lt_ctx):
mask = np.ones((128, 128))
job = ApplyMasksJob(dataset=default_empad, mask_factories=[lambda: mask])
out = job.get_result_buffer()
executor = InlineJobExecutor()
for tiles in executor.run_job(job):
for tile in tiles:
tile.reduce_into_result(out)
results = lt_ctx.run(job)
assert results[0].shape == (4 * 4,)
assert np.count_nonzero(results[0]) > 0
def test_apply_mask_on_raw_job(default_raw, lt_ctx):
mask = np.ones((128, 128))
job = ApplyMasksJob(dataset=default_raw, mask_factories=[lambda: mask])
out = job.get_result_buffer()
executor = InlineJobExecutor()
for tiles in executor.run_job(job):
for tile in tiles:
tile.reduce_into_result(out)
results = lt_ctx.run(job)
# FIXME: should the result here be 1D or 2D?
# currently, for inherently 4D datasets it is 2D, and for 3D datasets
# it is 1D. make this consistent?
assert results[0].shape == (16, 16)
def test_get_multiple_frame_row():
data = _mk_random(size=(16, 16, 16, 16))
dataset = MemoryDataSet(data=data,
tileshape=(1, 1, 16, 16),
partition_shape=(16, 16, 16, 16),
sig_dims=2)
job = PickFrameJob(dataset=dataset,
slice_=Slice(origin=(5, 0, 0, 0),
shape=Shape((1, 16, 16, 16), sig_dims=2)))
executor = InlineJobExecutor()
result = np.zeros(job.get_result_shape())
for tiles in executor.run_job(job):
for tile in tiles:
tile.reduce_into_result(result)
assert result.shape == (1, 16, 16, 16)
assert not np.allclose(result[0, 0], result[0, 1])
assert np.allclose(result[0, 0:16], data[5, 0:16])
