def test_MergeOmeTiffWriter_mc(simple_transform_affine_nl, tmp_path):
reg_image1 = np.random.randint(0, 255, (3, 1024, 1024), dtype=np.uint8)
reg_image2 = np.random.randint(0, 255, (3, 1024, 1024), dtype=np.uint8)
reg_image3 = np.random.randint(0, 255, (3, 1024, 1024), dtype=np.uint8)
mreg_image = MergeRegImage(
[reg_image1, reg_image2, reg_image3],
[1, 1, 1],
channel_names=[["1", "2", "3"], ["1", "2", "3"], ["1", "2", "3"]],
)
rts = RegTransformSeq(simple_transform_affine_nl)
merge_ometiffwriter = MergeOmeTiffWriter(
mreg_image, reg_transform_seqs=[rts, rts, rts]
)
by_plane_fp = merge_ometiffwriter.merge_write_image_by_plane(
"merge_testimage_by_plane",
["1", "2", "3"],
output_dir=str(tmp_path),
)
im_plane = imread(by_plane_fp)
reg_image1_loaded = reg_image_loader(reg_image1, 1)
ometiffwriter = OmeTiffWriter(reg_image1_loaded, reg_transform_seq=rts)
by_plane_fp_s1 = ometiffwriter.write_image_by_plane(
"testimage_by_plane_s1",
output_dir=str(tmp_path),
)
im_plane_s1 = imread(by_plane_fp_s1)
reg_image2_loaded = reg_image_loader(reg_image2, 1)
ometiffwriter = OmeTiffWriter(reg_image2_loaded, reg_transform_seq=rts)
by_plane_fp_s2 = ometiffwriter.write_image_by_plane(
"testimage_by_plane_s2",
output_dir=str(tmp_path),
)
im_plane_s2 = imread(by_plane_fp_s2)
reg_image3_loaded = reg_image_loader(reg_image3, 1)
ometiffwriter = OmeTiffWriter(reg_image3_loaded, reg_transform_seq=rts)
by_plane_fp_s3 = ometiffwriter.write_image_by_plane(
"testimage_by_plane_s3",
output_dir=str(tmp_path),
)
im_plane_s3 = imread(by_plane_fp_s3)
assert im_plane.shape[0] == 9
assert np.array_equal(im_plane[0:3, :, :], im_plane_s1)
assert np.array_equal(im_plane[3:6, :, :], im_plane_s2)
assert np.array_equal(im_plane[6:9, :, :], im_plane_s3)
def test_OmeTiffWriter_by_tile(complex_transform, tmp_path):
reg_image = reg_image_loader(np.ones((4096, 4096), dtype=np.uint8), 0.5)
rts = RegTransformSeq(complex_transform)
ometiffwriter = OmeTiffTiledWriter(reg_image, reg_transform_seq=rts)
by_tile_fp = ometiffwriter.write_image_by_tile(
gen_project_name_str(),
output_dir=str(tmp_path),
zarr_temp_dir=tmp_path,
)
by_tile_image = reg_image_loader(by_tile_fp, 2)
assert by_tile_image.shape == (1, 1024, 1024)
def test_OmeTiffWriter_by_plane(complex_transform, tmp_path):
reg_image = reg_image_loader(np.ones((1024, 1024), dtype=np.uint8), 1)
# composite_transform, _, final_transform = prepare_wsireg_transform_data(
# complex_transform
# )
rts = RegTransformSeq(complex_transform)
ometiffwriter = OmeTiffWriter(reg_image, reg_transform_seq=rts)
by_plane_fp = ometiffwriter.write_image_by_plane(
gen_project_name_str(),
output_dir=str(tmp_path),
)
by_plane_image = reg_image_loader(by_plane_fp, 2)
assert by_plane_image.shape == (1, 1024, 1024)
def test_wsireg_run_reg_with_crop_merge(data_out_dir, disk_im_gry):
wsi_reg = WsiReg2D(gen_project_name_str(), str(data_out_dir))
img_fp1 = str(disk_im_gry)
wsi_reg.add_modality(
"mod1",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
)
wsi_reg.add_modality(
"mod2",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
)
wsi_reg.add_modality(
"mod3",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
preprocessing={
"mask_bbox": [512, 512, 512, 512],
"crop_to_mask_bbox": True,
},
)
wsi_reg.add_reg_path("mod1", "mod3", reg_params=["rigid_test"])
wsi_reg.add_reg_path("mod2", "mod3", reg_params=["rigid_test"])
wsi_reg.register_images()
wsi_reg.add_merge_modalities("merge", ["mod1", "mod2", "mod3"])
# not cropped
im_fps = wsi_reg.transform_images(transform_non_reg=True,
to_original_size=True)
registered_image_nocrop = reg_image_loader(im_fps[0], 1)
# crop image
im_fps = wsi_reg.transform_images(transform_non_reg=True,
to_original_size=False)
wsi_reg.save_transformations()
registered_image_crop = reg_image_loader(im_fps[0], 1)
assert registered_image_nocrop.shape[1:] == (2048, 2048)
assert registered_image_crop.shape[1:] == (512, 512)
def test_ometiff_read_rgb():
image_fp = os.path.join(PRIVATE_DIR, "czi_rgb.ome.tiff")
ri = reg_image_loader(image_fp, 1)
assert len(ri.im_dims) == 3
assert ri.im_dtype == np.uint8
assert ri.is_rgb is True
assert ri.is_rgb_interleaved is False
def __init__(
self,
image_fp: List[Union[Path, str]],
image_res: List[Union[int, float]],
channel_names: Optional[List[List[str]]] = None,
channel_colors: Optional[List[List[str]]] = None,
):
if isinstance(image_fp, list) is False:
raise ValueError(
"MergeRegImage requires a list of images to merge")
if isinstance(image_res, list) is False:
raise ValueError(
"MergeRegImage requires a list of image resolutions for each image to merge"
)
if channel_names is None:
channel_names = [None for _ in range(0, len(image_fp))]
if channel_colors is None:
channel_colors = [None for _ in range(0, len(image_fp))]
images = []
for im_idx, image_data in enumerate(
zip(image_fp, image_res, channel_names, channel_colors)):
image, image_res, channel_names, channel_colors = image_data
imdata = reg_image_loader(
image,
image_res,
channel_names=channel_names,
channel_colors=channel_colors,
)
if (imdata.channel_names is None
or len(imdata.channel_names) != imdata.n_ch):
imdata._channel_names = [
f"C{idx}" for idx in range(0, imdata.n_ch)
]
images.append(imdata)
if all([im.im_dtype == images[0].im_dtype for im in images]) is False:
warn(
"MergeRegImage created with mixed data types, writing will cast "
"to the largest data type")
if any([im.is_rgb for im in images]) is True:
warn(
"MergeRegImage does not support writing merged interleaved RGB "
"Data will be written as multi-channel")
self.images = images
self.image_fps = image_fp
self.im_dtype = self.images[0].im_dtype
self.is_rgb = False
self.n_ch = np.sum([i.n_ch for i in self.images])
self.channel_names = [i.channel_names for i in self.images]
self.original_size_transform = None
def test_wsireg_run_reg_changeres(data_out_dir, disk_im_gry):
wsi_reg = WsiReg2D(gen_project_name_str(), str(data_out_dir))
img_fp1 = str(disk_im_gry)
wsi_reg.add_modality(
"mod1",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
output_res=0.325,
)
wsi_reg.add_modality(
"mod2",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
)
wsi_reg.add_reg_path("mod1",
"mod2",
reg_params=["rigid_test", "affine_test"])
wsi_reg.register_images()
im_fps = wsi_reg.transform_images(transform_non_reg=False)
regim = reg_image_loader(im_fps[0], 0.325)
assert regim.shape[1:] == (4096, 4096)
def test_czi_read_mc_read_channels():
image_fp = os.path.join(PRIVATE_DIR, "czi_4ch_16bit.ome.tiff")
ri = reg_image_loader(image_fp, 1)
ch0 = ri.read_single_channel(0)
ch1 = ri.read_single_channel(1)
ch2 = ri.read_single_channel(2)
ch3 = ri.read_single_channel(3)
assert np.squeeze(ch0).shape == ri.shape[1:]
assert np.squeeze(ch1).shape == ri.shape[1:]
assert np.squeeze(ch2).shape == ri.shape[1:]
assert np.squeeze(ch3).shape == ri.shape[1:]
assert np.ndim(ch0) == 2
assert np.ndim(ch1) == 2
assert np.ndim(ch2) == 2
assert np.ndim(ch3) == 2
assert np.array_equal(ch0, ch1) is False
assert np.array_equal(ch0, ch2) is False
assert np.array_equal(ch0, ch3) is False
assert np.array_equal(ch1, ch2) is False
assert np.array_equal(ch1, ch3) is False
assert np.array_equal(ch2, ch3) is False
assert ch0.dtype == np.uint16
assert ch1.dtype == np.uint16
assert ch2.dtype == np.uint16
assert ch3.dtype == np.uint16
def test_huron_read_rgb():
image_fp = os.path.join(PRIVATE_DIR, "huron_rgb.tif")
ri = reg_image_loader(image_fp, 1)
assert len(ri.im_dims) == 3
assert ri.im_dims[2] == 3
assert ri.im_dtype == np.uint8
assert ri.is_rgb is True
def test_czi_read_mc_fl_preprocess():
image_fp = os.path.join(PRIVATE_DIR, "czi_4ch_16bit.czi")
preprocessing = {"image_type": "FL", "as_uint8": True}
ri = reg_image_loader(image_fp, 1, preprocessing=preprocessing)
ri.read_reg_image()
assert ri.reg_image.GetNumberOfComponentsPerPixel() == 1
assert ri.reg_image.GetPixelID() == 1
def test_reg_image_loader_zarr_mch(im_rgb_np_uneven):
reg_image = reg_image_loader(im_rgb_np_uneven, 0.65, mask=GEOJSON_FP)
reg_image.read_reg_image()
assert reg_image.reg_image.GetSpacing() == (0.65, 0.65)
assert reg_image.reg_image.GetNumberOfComponentsPerPixel() == 1
assert reg_image.mask.GetSize() == reg_image.reg_image.GetSize()
assert reg_image.mask.GetSpacing() == reg_image.reg_image.GetSpacing()
def test_wsireg_run_reg_downsampling_m1m2_changeores(data_out_dir,
disk_im_gry):
wsi_reg = WsiReg2D(gen_project_name_str(), str(data_out_dir))
img_fp1 = str(disk_im_gry)
wsi_reg.add_modality(
"mod1",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
preprocessing={"downsampling": 2},
output_res=(1.3, 1.3),
)
wsi_reg.add_modality(
"mod2",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
preprocessing={"downsampling": 2},
)
wsi_reg.add_reg_path("mod1", "mod2", reg_params=["rigid_test"])
wsi_reg.register_images()
im_fps = wsi_reg.transform_images(transform_non_reg=False)
regim = reg_image_loader(im_fps[0], 0.65)
assert regim.shape[1:] == (1024, 1024)
def test_OmeTiffWriter_compare_tile_plane_rgb_nl_large(tmp_path):
im_array = da.from_array(
np.random.randint(0, 255, (2**13, 2**13, 3), dtype=np.uint8),
chunks=(1024, 1024, 3),
)
reg_image = reg_image_loader(im_array, 0.5)
rts = RegTransformSeq(TFORM_FP)
ometiffwriter = OmeTiffWriter(reg_image, reg_transform_seq=rts)
ometiletiffwriter = OmeTiffTiledWriter(reg_image, reg_transform_seq=rts)
by_tile_fp = ometiletiffwriter.write_image_by_tile(
gen_project_name_str(),
output_dir=str(tmp_path),
)
by_plane_fp = ometiffwriter.write_image_by_plane(
gen_project_name_str(),
output_dir=str(tmp_path),
)
im_tile = imread(by_tile_fp)
im_plane = imread(by_plane_fp)
assert np.array_equal(im_tile, im_plane)
def test_czi_read_mc_selectch_preprocess_list():
image_fp = os.path.join(PRIVATE_DIR, "czi_4ch_16bit.czi")
preprocessing = {"ch_indices": [0]}
ri = reg_image_loader(image_fp, 1, preprocessing=preprocessing)
ri.read_reg_image()
assert ri.reg_image.GetNumberOfComponentsPerPixel() == 1
assert ri.reg_image.GetPixelID() == 1
def test_OmeTiffWriter_compare_tile_plane_rgb_nl(
simple_transform_affine_nl, tmp_path
):
reg_image = reg_image_loader(
np.random.randint(0, 255, (1024, 1024, 3), dtype=np.uint8), 1
)
rts = RegTransformSeq(simple_transform_affine_nl)
ometiffwriter = OmeTiffWriter(reg_image, reg_transform_seq=rts)
ometiletiffwriter = OmeTiffTiledWriter(reg_image, reg_transform_seq=rts)
by_tile_fp = ometiletiffwriter.write_image_by_tile(
gen_project_name_str(),
output_dir=str(tmp_path),
)
by_plane_fp = ometiffwriter.write_image_by_plane(
gen_project_name_str(),
output_dir=str(tmp_path),
)
im_tile = imread(by_tile_fp)
im_plane = imread(by_plane_fp)
assert np.array_equal(im_tile, im_plane)
def test_wsireg_run_reg_wmerge(data_out_dir, disk_im_gry):
wsi_reg = WsiReg2D(gen_project_name_str(), str(data_out_dir))
img_fp1 = str(disk_im_gry)
wsi_reg.add_modality(
"mod1",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
)
wsi_reg.add_modality(
"mod2",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
)
wsi_reg.add_reg_path("mod1",
"mod2",
reg_params=["rigid_test", "affine_test"])
wsi_reg.add_merge_modalities("test_merge", ["mod1", "mod2"])
wsi_reg.register_images()
wsi_reg.save_transformations()
im_fps = wsi_reg.transform_images(transform_non_reg=True)
merged_im = reg_image_loader(im_fps[0], 0.65)
assert Path(im_fps[0]).exists() is True
assert merged_im.shape == (2, 2048, 2048)
def test_wsireg_run_reg_downsampling_m1m2_merge_no_prepro(
data_out_dir, disk_im_gry):
wsi_reg = WsiReg2D(gen_project_name_str(), str(data_out_dir))
img_fp1 = str(disk_im_gry)
wsi_reg.add_modality(
"mod1",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
preprocessing={"downsampling": 2},
)
wsi_reg.add_modality(
"mod2",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
preprocessing={"downsampling": 2},
)
wsi_reg.add_reg_path("mod1", "mod2", reg_params=["rigid_test"])
wsi_reg.add_merge_modalities("mod12-merge", ["mod1", "mod2"])
wsi_reg.register_images()
im_fps = wsi_reg.transform_images(transform_non_reg=False,
remove_merged=True)
regim = reg_image_loader(im_fps[0], 0.65)
assert regim.shape == (2, 2048, 2048)
def test_czi_read_mc_std_preprocess():
image_fp = os.path.join(PRIVATE_DIR, "czi_4ch_16bit.czi")
preprocessing = ImagePreproParams()
ri = reg_image_loader(image_fp, 1, preprocessing=preprocessing)
ri.read_reg_image()
assert ri.reg_image.GetNumberOfComponentsPerPixel() == 1
assert ri.reg_image.GetPixelID() == 1
def test_czi_read_rgb():
image_fp = os.path.join(PRIVATE_DIR, "czi_rgb.czi")
ri = reg_image_loader(image_fp, 1)
assert len(ri.shape) == 3
assert ri.shape[2] == 3
assert ri.im_dtype == np.uint8
assert ri.is_rgb is True
def test_czi_read_mc():
image_fp = os.path.join(PRIVATE_DIR, "czi_4ch_16bit.czi")
ri = reg_image_loader(image_fp, 1)
assert len(ri.shape) == 3
assert ri.shape[0] == 4
assert ri.shape[2] > 3
assert ri.im_dtype == np.uint16
assert ri.is_rgb is False
def test_reg_image_loader_to_itk(im_gry_np, mask_np):
reg_image = reg_image_loader(im_gry_np, 0.65, mask=mask_np)
reg_image.read_reg_image()
reg_image.sitk_to_itk(cast_to_float32=True)
assert isinstance(reg_image.image, itk.Image) is True
assert reg_image.image.GetSpacing() == (0.65, 0.65)
assert isinstance(reg_image.mask, itk.Image) is True
assert reg_image.mask.GetSpacing() == (0.65, 0.65)
def test_reg_image_loader_image_np_rgb_std_prepro_fliph(im_rgb_np):
reg_image = reg_image_loader(im_rgb_np, 0.65, preprocessing={"flip": "h"})
reg_image.read_reg_image()
assert reg_image.image.GetSize() == (2048, 2048)
assert reg_image.image.GetNumberOfComponentsPerPixel() == 1
assert reg_image.pre_reg_transforms is not None
assert len(reg_image.pre_reg_transforms) == 1
assert reg_image.image.GetSpacing() == (0.65, 0.65)
def test_gj_reg_image_loader_mask_flip(im_gry_np, mask_geojson):
reg_image = reg_image_loader(
im_gry_np, 0.65, preprocessing={"flip": "v"}, mask=mask_geojson
)
reg_image.read_reg_image()
assert reg_image.mask is not None
assert isinstance(reg_image.mask, sitk.Image) is True
assert reg_image.mask.GetSpacing() == (0.65, 0.65)
def test_reg_image_loader_image_np_gry_std_prepro_rot(im_gry_np):
reg_image = reg_image_loader(im_gry_np, 0.65, preprocessing={"rot_cc": 90})
reg_image.read_reg_image()
assert reg_image.image.GetSize() == (2048, 2048)
assert reg_image.image.GetNumberOfComponentsPerPixel() == 1
assert reg_image.pre_reg_transforms is not None
assert len(reg_image.pre_reg_transforms) == 1
assert reg_image.image.GetSpacing() == (0.65, 0.65)
def test_reg_image_loader_mask_rot(im_gry_np, mask_np):
reg_image = reg_image_loader(
im_gry_np, 0.65, preprocessing={"rot_cc": 90}, mask=mask_np
)
reg_image.read_reg_image()
assert reg_image.mask is not None
assert isinstance(reg_image.mask, sitk.Image) is True
assert reg_image.mask.GetSpacing() == (0.65, 0.65)
def test_wsireg_config_full_merge_rgb_mc(config_fp, data_out_dir):
wsi_reg1 = config_to_WsiReg2D(config_fp, data_out_dir)
wsi_reg1.add_data_from_config(config_fp)
wsi_reg1.register_images()
im_fps = wsi_reg1.transform_images()
ri = reg_image_loader(im_fps[0], 1)
assert ri.im_dtype == np.uint16
assert ri.im_dims == (9, 3993, 3397)
def test_reg_image_loader_dask_rgb(dask_im_rgb_np):
reg_image = reg_image_loader(dask_im_rgb_np, 0.65)
reg_image.read_reg_image()
assert len(reg_image.shape) == 3
assert reg_image.shape[-1] == 3
assert reg_image.is_rgb
assert reg_image.n_ch == 3
assert reg_image.reg_image.GetSpacing() == (0.65, 0.65)
assert reg_image.reg_image.GetNumberOfComponentsPerPixel() == 1
def test_reg_image_loader_zarr_mch(zarr_im_mch_np):
reg_image = reg_image_loader(zarr_im_mch_np, 0.65)
reg_image.read_reg_image()
assert len(reg_image.shape) == 3
assert reg_image.shape[0] == 3
assert reg_image.is_rgb is False
assert reg_image.n_ch == 3
assert reg_image.reg_image.GetSpacing() == (0.65, 0.65)
assert reg_image.reg_image.GetNumberOfComponentsPerPixel() == 1
def test_wsireg_run_reg_wattachment_ds2(data_out_dir, disk_im_gry):
wsi_reg = WsiReg2D(gen_project_name_str(), str(data_out_dir))
im1 = np.random.randint(0, 255, (2048, 2048), dtype=np.uint16)
im2 = np.random.randint(0, 255, (2048, 2048), dtype=np.uint16)
wsi_reg.add_modality(
"mod1",
im1,
0.65,
channel_names=["test"],
channel_colors=["red"],
preprocessing={"downsampling": 2},
)
wsi_reg.add_modality(
"mod2",
im2,
0.65,
channel_names=["test"],
channel_colors=["red"],
preprocessing={"downsampling": 2},
)
wsi_reg.add_attachment_images("mod2", "attached", im2, image_res=0.65)
wsi_reg.add_attachment_images("mod1", "attached2", im1, image_res=0.65)
wsi_reg.add_reg_path("mod2",
"mod1",
reg_params=["rigid_test", "affine_test"])
wsi_reg.register_images()
im_fps = wsi_reg.transform_images(transform_non_reg=False)
wsi_reg.save_transformations()
regim = reg_image_loader(im_fps[0], 0.65)
attachim = reg_image_loader(im_fps[1], 0.65)
attachim2 = reg_image_loader(im_fps[2], 0.65)
assert np.array_equal(
np.squeeze(regim.dask_image.compute()),
np.squeeze(attachim.dask_image.compute()),
)
assert np.array_equal(np.squeeze(im1),
np.squeeze(attachim2.dask_image.compute()))
def test_wsireg_run_reg_with_flip_crop(data_out_dir, disk_im_gry):
wsi_reg = WsiReg2D("test_proj8", str(data_out_dir))
img_fp1 = str(disk_im_gry)
wsi_reg.add_modality(
"mod1",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
)
wsi_reg.add_modality(
"mod2",
img_fp1,
0.65,
channel_names=["test"],
channel_colors=["red"],
prepro_dict={"mask_bbox": [512, 512, 512, 512], "flip": "h"},
)
wsi_reg.add_reg_path(
"mod1", "mod2", reg_params=["rigid_test", "affine_test"]
)
wsi_reg.register_images()
# not cropped
im_fps = wsi_reg.transform_images(
transform_non_reg=True, to_original_size=True
)
registered_image_nocrop = reg_image_loader(im_fps[0], 1)
unregistered_image_nocrop = reg_image_loader(im_fps[1], 1)
# crop image
im_fps = wsi_reg.transform_images(
transform_non_reg=True, to_original_size=False
)
registered_image_crop = reg_image_loader(im_fps[0], 1)
unregistered_image_crop = reg_image_loader(im_fps[1], 1)
assert registered_image_nocrop.im_dims[1:] == (2048, 2048)
assert unregistered_image_nocrop.im_dims[1:] == (2048, 2048)
assert registered_image_crop.im_dims[1:] == (512, 512)
assert unregistered_image_crop.im_dims[1:] == (512, 512)