def get_transforms(self):
transforms = Compose(RandomFlip3D(), RandomRotate())
# Elastic transforms can be skipped by setting elastic_transform to false in the
# yaml config file.
if self.master_config.get('elastic_transform'):
elastic_transform_config = self.master_config.get(
'elastic_transform')
transforms.add(
ElasticTransform(
alpha=elastic_transform_config.get('alpha', 2000.),
sigma=elastic_transform_config.get('sigma', 50.),
order=elastic_transform_config.get('order', 0)))
for_validation = self.master_config.get('for_validation', False)
# if we compute the affinities on the gpu, or use the feeder for validation only,
# we don't need to add the affinity transform here
if not for_validation:
assert self.affinity_config is not None
# we apply the affinity target calculation only to the segmentation (1)
transforms.add(
affinity_config_to_transform(apply_to=[1],
**self.affinity_config))
transforms.add(InvertAffinities(apply_to=[1]))
return transforms
def get_transforms(self):
transforms = Compose()
if self.master_config.get('random_flip', False):
transforms.add(RandomFlip3D())
transforms.add(RandomRotate())
# Elastic transforms can be skipped by
# setting elastic_transform to false in the
# yaml config file.
if self.master_config.get('elastic_transform'):
elastic_transform_config = self.master_config.get(
'elastic_transform')
if elastic_transform_config.get('apply', False):
transforms.add(
ElasticTransform(
alpha=elastic_transform_config.get('alpha', 2000.),
sigma=elastic_transform_config.get('sigma', 50.),
order=elastic_transform_config.get('order', 0)))
# random slide augmentation
if self.master_config.get('random_slides', False):
# TODO slide probability
ouput_shape = self.master_config.get('shape_after_slide', None)
max_misalign = self.master_config.get('max_misalign', None)
transforms.add(
RandomSlide(output_image_size=ouput_shape,
max_misalign=max_misalign))
# affinity transforms for affinity targets
# we apply the affinity target calculation only to the segmentation (1)
assert self.affinity_config is not None
# transforms.add(Segmentation2AffinitiesDynamicOffsets(apply_to=[1], **self.affinity_config))
transforms.add(
affinity_config_to_transform(apply_to=[1], **self.affinity_config))
# TODO: add clipping transformation
# crop invalid affinity labels and elastic augment reflection padding assymetrically
crop_config = self.master_config.get('crop_after_target', {})
if crop_config:
# One might need to crop after elastic transform to avoid edge artefacts of affinity
# computation being warped into the FOV.
transforms.add(VolumeAsymmetricCrop(**crop_config))
# transforms.add(InvertTarget(self.affinity_config.get("retain_segmentation", False)))
# transforms.add(HackyHacky())
#transforms.add(ComputeVAETarget()), HackyHacky
return transforms
def get_transforms(self):
transforms = Compose()
if self.master_config.get('random_flip', False):
transforms.add(RandomFlip3D())
transforms.add(RandomRotate())
# # Elastic transforms can be skipped by
# # setting elastic_transform to false in the
# # yaml config file.
# if self.master_config.get('elastic_transform'):
# elastic_transform_config = self.master_config.get('elastic_transform')
# if elastic_transform_config.get('apply', False):
# transforms.add(ElasticTransform(alpha=elastic_transform_config.get('alpha', 2000.),
# sigma=elastic_transform_config.get('sigma', 50.),
# order=elastic_transform_config.get('order', 0)))
# random slide augmentation
if self.master_config.get('random_slides', False):
# TODO slide probability
ouput_shape = self.master_config.get('shape_after_slide', None)
max_misalign = self.master_config.get('max_misalign', None)
transforms.add(
RandomSlide(output_image_size=ouput_shape,
max_misalign=max_misalign))
# affinity transforms for affinity targets
# we apply the affinity target calculation only to the segmentation (1)
assert self.affinity_config is not None
transforms.add(
affinity_config_to_transform(apply_to=[1], **self.affinity_config))
# crop invalid affinity labels and elastic augment reflection padding assymetrically
crop_config = self.master_config.get('crop_after_target', {})
if crop_config:
# One might need to crop after elastic transform to avoid edge artefacts of affinity
# computation being warped into the FOV.
transforms.add(VolumeAsymmetricCrop(**crop_config))
from vaeAffs.transforms import PassGTBoundaries_HackyHackyReloaded
transforms.add(PassGTBoundaries_HackyHackyReloaded())
return transforms
def get_transforms(self):
transforms = Compose(RandomFlip3D(), RandomRotate())
# Elastic transforms can be skipped by setting elastic_transform to false in the
# yaml config file.
if self.master_config.get('elastic_transform'):
elastic_transform_config = self.master_config.get(
'elastic_transform')
transforms.add(
ElasticTransform(
alpha=elastic_transform_config.get('alpha', 2000.),
sigma=elastic_transform_config.get('sigma', 50.),
order=elastic_transform_config.get('order', 0)))
# TODO doesn't look like we have misalignment, so should be fine
# if we do not use random slides
# random slide augmentation
if self.master_config.get('random_slides', False):
assert False, "No random slides for now"
ouput_shape = self.master_config.get('shape_after_slide', None)
max_misalign = self.master_config.get('max_misalign', None)
transforms.add(
RandomSlide(output_image_size=ouput_shape,
max_misalign=max_misalign))
# if we compute the affinities on the gpu, or use the feeder for validation only,
# we don't need to add the affinity transform here
if self.affinity_config is not None:
# we apply the affinity target calculation only to the segmentation (1)
transforms.add(
affinity_config_to_transform(apply_to=[1],
**self.affinity_config))
# Next: crop invalid affinity labels and elastic augment reflection padding assymetrically
crop_config = self.master_config.get('crop_after_target', {})
if crop_config:
# One might need to crop after elastic transform to avoid edge artefacts of affinity
# computation being warped into the FOV.
transforms.add(VolumeAsymmetricCrop(**crop_config))
return transforms
def make_transforms(self):
transforms = Compose(PadTo(self.window_size), RandomFlip3D(), RandomRotate())
if self.master_config.get('elastic_transform'):
elastic_transform_config = self.master_config.get('elastic_transform')
transforms.add(ElasticTransform(alpha=elastic_transform_config.get('alpha', 2000.),
sigma=elastic_transform_config.get('sigma', 50.),
order=elastic_transform_config.get('order', 0)))
# affinity transforms for affinity targets
# we apply the affinity target calculation only to the segmentation (1)
affinity_config = self.master_config.get('affinity_config', None)
# Do we also train with semantic labels ?
train_semantic = self.master_config.get('train_semantic', False)
if affinity_config is None:
if train_semantic:
transforms.add(Semantics(apply_to=[1]))
self.label_transforms = None
else:
self.label_transforms = Cast('float32')
elif affinity_config == 'distances':
# TODO read the bandwidths from the config
self.label_transforms = Compose(Cast('int64'), ConnectedComponents3D())
from ..transforms.distance_transform import SignedDistanceTransform
transforms.add(SignedDistanceTransform(fg_bandwidth=8,
bg_bandwidth=32,
apply_to=[1]))
else:
if train_semantic:
# we can't apply connected components yet if we train semantics and affinities
self.label_transforms = Cast('int64')
transforms.add(SemanticsAndAffinities(affinity_config, apply_to=[1]))
else:
self.label_transforms = Compose(Cast('int64'), ConnectedComponents3D())
transforms.add(affinity_config_to_transform(apply_to=[1], **affinity_config))
self.transforms = transforms
sigma = 0.025
self.raw_transforms = Compose(Cast('float32'), Normalize(), AdditiveNoise(sigma=sigma))
def __init__(self, affinity_config, **super_kwargs):
self.aff_trafo = affinity_config_to_transform(**affinity_config)
self.semantic_trafo = Semantics()
self.cc_trafo = ConnectedComponents3D()
super().__init__(**super_kwargs)