def __call__(self, data):
self.randomize()
d = dict(data)
if not self._do_transform:
return d
zoomer = Zoom(self._zoom, self.order, self.mode, self.cval, self.prefilter, self.use_gpu, self.keep_size)
for key in self.keys:
d[key] = zoomer(d[key])
return d
def __call__(self, data):
# match the spatial dim of first item
self.randomize()
d = dict(data)
if not self._do_transform:
return d
zoomer = Zoom(self._zoom, keep_size=self.keep_size)
for idx, key in enumerate(self.keys):
d[key] = zoomer(d[key], mode=self.mode[idx], align_corners=self.align_corners[idx])
return d
def __call__(self, data):
self.randomize()
d = dict(data)
if not self._do_transform:
return d
zoomer = Zoom(self._zoom,
align_corners=self.align_corners,
keep_size=self.keep_size)
for idx, key in enumerate(self.keys):
d[key] = zoomer(d[key], interp_order=self.interp_order[idx])
return d
def __init__(
self,
keys: KeysCollection,
zoom: Union[Sequence[float], float],
mode: InterpolateModeSequence = InterpolateMode.AREA,
align_corners=None,
keep_size: bool = True,
):
super().__init__(keys)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.align_corners = ensure_tuple_rep(align_corners, len(self.keys))
self.zoomer = Zoom(zoom=zoom, keep_size=keep_size)
def __init__(
self,
keys: KeysCollection,
zoom,
interp_order: str = "area",
align_corners: Optional[bool] = None,
keep_size: bool = True,
):
super().__init__(keys)
self.zoomer = Zoom(zoom=zoom,
align_corners=align_corners,
keep_size=keep_size)
self.interp_order = ensure_tuple_rep(interp_order, len(self.keys))
def __init__(
self,
keys: KeysCollection,
zoom: Union[Sequence[float], float],
mode: InterpolateModeSequence = InterpolateMode.AREA,
padding_mode: NumpyPadModeSequence = NumpyPadMode.EDGE,
align_corners: Union[Sequence[Optional[bool]], Optional[bool]] = None,
keep_size: bool = True,
) -> None:
super().__init__(keys)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.padding_mode = ensure_tuple_rep(padding_mode, len(self.keys))
self.align_corners = ensure_tuple_rep(align_corners, len(self.keys))
self.zoomer = Zoom(zoom=zoom, keep_size=keep_size)
def __call__(self, data: Mapping[Hashable, np.ndarray]) -> Dict[Hashable, np.ndarray]:
# match the spatial dim of first item
self.randomize()
d = dict(data)
if not self._do_transform:
return d
zoomer = Zoom(self._zoom, keep_size=self.keep_size)
for idx, key in enumerate(self.keys):
d[key] = zoomer(
d[key],
mode=self.mode[idx],
padding_mode=self.padding_mode[idx],
align_corners=self.align_corners[idx],
)
return d
def __call__(self, data):
self.randomize()
d = dict(data)
if not self._do_transform:
return d
zoomer = Zoom(self._zoom, use_gpu=self.use_gpu, keep_size=self.keep_size)
for idx, key in enumerate(self.keys):
d[key] = zoomer(
d[key],
order=self.interp_order[idx],
mode=self.mode[idx],
cval=self.cval[idx],
prefilter=self.prefilter[idx],
)
return d
def __init__(self,
keys,
zoom,
order=3,
mode="constant",
cval=0,
prefilter=True,
use_gpu=False,
keep_size=False):
super().__init__(keys)
self.zoomer = Zoom(zoom=zoom, use_gpu=use_gpu, keep_size=keep_size)
self.order = ensure_tuple_rep(order, len(self.keys))
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.cval = ensure_tuple_rep(cval, len(self.keys))
self.prefilter = ensure_tuple_rep(prefilter, len(self.keys))
def __init__(self,
keys,
zoom,
order=3,
mode='constant',
cval=0,
prefilter=True,
use_gpu=False,
keep_size=False):
super().__init__(keys)
self.zoomer = Zoom(zoom=zoom,
order=order,
mode=mode,
cval=cval,
prefilter=prefilter,
use_gpu=use_gpu,
keep_size=keep_size)
def __init__(
self,
keys,
zoom,
interp_order=InterpolationCode.SPLINE3,
mode="constant",
cval=0,
prefilter=True,
use_gpu=False,
keep_size=False,
):
super().__init__(keys)
self.zoomer = Zoom(zoom=zoom, use_gpu=use_gpu, keep_size=keep_size)
self.interp_order = ensure_tuple_rep(interp_order, len(self.keys))
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.cval = ensure_tuple_rep(cval, len(self.keys))
self.prefilter = ensure_tuple_rep(prefilter, len(self.keys))
def __call__(self, data: Mapping[Hashable, np.ndarray]) -> Dict[Hashable, np.ndarray]:
# match the spatial dim of first item
self.randomize()
d = dict(data)
if not self._do_transform:
return d
img_dims = data[self.keys[0]].ndim
if len(self._zoom) == 1:
# to keep the spatial shape ratio, use same random zoom factor for all dims
self._zoom = ensure_tuple_rep(self._zoom[0], img_dims - 1)
elif len(self._zoom) == 2 and img_dims > 3:
# if 2 zoom factors provided for 3D data, use the first factor for H and W dims, second factor for D dim
self._zoom = ensure_tuple_rep(self._zoom[0], img_dims - 2) + ensure_tuple(self._zoom[-1])
zoomer = Zoom(self._zoom, keep_size=self.keep_size)
for idx, key in enumerate(self.keys):
d[key] = zoomer(
d[key],
mode=self.mode[idx],
padding_mode=self.padding_mode[idx],
align_corners=self.align_corners[idx],
)
return d
