def test_mag_constructor() -> None:
mag = Mag(16)
assert mag.to_list() == [16, 16, 16]
mag = Mag("256")
assert mag.to_list() == [256, 256, 256]
mag = Mag("16-2-4")
assert mag.to_list() == [16, 2, 4]
mag1 = Mag("16-2-4")
mag2 = Mag("8-2-4")
assert mag1 > mag2
assert mag1.to_layer_name() == "16-2-4"
assert np.all(mag1.to_np() == np.array([16, 2, 4]))
assert mag1 == Mag(mag1)
assert mag1 == Mag(mag1.to_np())
def calculate_mags_to_downsample(
from_mag: Mag,
coarsest_mag: Mag,
dataset_to_align_with: Optional["Dataset"],
voxel_size: Optional[Tuple[float, float, float]],
) -> List[Mag]:
assert np.all(from_mag.to_np() <= coarsest_mag.to_np())
mags = []
current_mag = from_mag
if dataset_to_align_with is None:
mags_to_align_with = set()
else:
mags_to_align_with = set(
mag
for layer in dataset_to_align_with.layers.values()
for mag in layer.mags.keys()
)
mags_to_align_with_by_max_dim = {mag.max_dim: mag for mag in mags_to_align_with}
assert len(mags_to_align_with) == len(
mags_to_align_with_by_max_dim
), "Some layers contain different values for the same mag, this is not allowed."
while current_mag < coarsest_mag:
if current_mag.max_dim * 2 in mags_to_align_with_by_max_dim:
current_mag = mags_to_align_with_by_max_dim[current_mag.max_dim * 2]
if current_mag > coarsest_mag:
warnings.warn(
"The mag taken from another layer is larger in some dimensions than coarsest_mag."
)
elif voxel_size is None:
# In case the sampling mode is CONSTANT_Z or ISOTROPIC:
current_mag = Mag(np.minimum(current_mag.to_np() * 2, coarsest_mag.to_np()))
else:
# In case the sampling mode is ANISOTROPIC:
current_size = current_mag.to_np() * np.array(voxel_size)
min_value = np.min(current_size)
min_value_bitmask = np.array(current_size == min_value)
factor = min_value_bitmask + 1
# Calculate the two potential magnifications.
# Either, double all components or only double the smallest component.
all_voxel_sized = current_size * 2
min_voxel_sized = (
current_size * factor
) # only multiply the smallest dimension
all_voxel_sized_ratio = np.max(all_voxel_sized) / np.min(all_voxel_sized)
min_voxel_sized_ratio = np.max(min_voxel_sized) / np.min(min_voxel_sized)
# The smaller the ratio between the smallest dimension and the largest dimension, the better.
if all_voxel_sized_ratio < min_voxel_sized_ratio:
# Multiply all dimensions with "2"
new_mag = Mag(np.minimum(current_mag.to_np() * 2, coarsest_mag.to_np()))
else:
# Multiply only the minimal dimension by "2".
new_mag = Mag(
np.minimum(current_mag.to_np() * factor, coarsest_mag.to_np())
)
# In case of isotropic resolution but anisotropic mag we need to ensure unique max dims.
# current mag: 4-4-2, voxel_size: 1,1,1 -> new_mag: 4-4-4, therefore we skip this entry.
if new_mag.max_dim == current_mag.max_dim:
current_mag = new_mag
continue
if new_mag == current_mag:
raise RuntimeError(
f"The coarsest mag {coarsest_mag} can not be reached from {current_mag} with voxel_size {voxel_size}!"
)
current_mag = new_mag
mags += [current_mag]
return mags