def resize_flow(flow, shape):
"""Rescale the values of the vector field (u, v) to the desired shape.
The values of the output vector field are scaled to the new
resolution.
Parameters
----------
flow : ndarray
The motion field to be processed.
shape : iterable
Couple of integers representing the output shape.
Returns
-------
rflow : ndarray
The resized and rescaled motion field.
"""
scale = [n / o for n, o in zip(shape, flow.shape[1:])]
scale_factor = cp.asarray(scale, dtype=flow.dtype)
for _ in shape:
scale_factor = scale_factor[..., cp.newaxis]
rflow = scale_factor * ndi.zoom(flow, [1] + scale, order=0,
mode='nearest', prefilter=False)
return rflow
def preview_datastore(stream, method, size):
# lookup size
size = {
"4K": (2160, 3840),
"QHD": (1440, 2560),
"FHD": (1080, 1920),
"HD": (720, 1280),
}[size]
if method == "zstack":
for data in stream:
data = cp.asarray(data)
factor = shape_to_zoom_factor(data.shape, size)
data = zoom(data, factor, order=1, output=data.dtype)
data = data.astype(cp.uint16)
data = auto_contrast(data)
data = (data - data.min()) / (data.max() - data.min()) * 255
data = data.astype(cp.uint8)
# frame
yield data
elif method == "mip":
result = None
for data in stream:
data = cp.asarray(data)
try:
np.maximum(result, data, out=result)
except TypeError:
result = data.copy()
yield result
def mark_boundaries(image, label_img, color=(1, 1, 0),
outline_color=None, mode='outer', background_label=0,
*, order=3):
"""Return image with boundaries between labeled regions highlighted.
Parameters
----------
image : (M, N[, 3]) array
Grayscale or RGB image.
label_img : (M, N) array of int
Label array where regions are marked by different integer values.
color : length-3 sequence, optional
RGB color of boundaries in the output image.
outline_color : length-3 sequence, optional
RGB color surrounding boundaries in the output image. If None, no
outline is drawn.
mode : string in {'thick', 'inner', 'outer', 'subpixel'}, optional
The mode for finding boundaries.
background_label : int, optional
Which label to consider background (this is only useful for
modes ``inner`` and ``outer``).
Additional Parameters
---------------------
order : int
The spline interpolation order to use when ``mode="subpixel"``.
Unused by other modes.
Returns
-------
marked : (M, N, 3) array of float
An image in which the boundaries between labels are
superimposed on the original image.
See Also
--------
find_boundaries
"""
marked = img_as_float(image, force_copy=True)
if marked.ndim == 2:
marked = gray2rgb(marked)
if mode == 'subpixel':
# Here, we want to interpose an extra line of pixels between
# each original line - except for the last axis which holds
# the RGB information. ``ndi.zoom`` then performs the (cubic)
# interpolation, filling in the values of the interposed pixels
marked = ndi.zoom(marked, [2 - 1 / s for s in marked.shape[:-1]] + [1],
mode='mirror', order=order)
boundaries = find_boundaries(label_img, mode=mode,
background=background_label)
if outline_color is not None:
outlines = dilation(boundaries, square(3))
marked[outlines] = outline_color
marked[boundaries] = color
return marked
def Data_anchor_sample(image, face_boxes, face_keys=None):
# 增加小人脸的比例
maxSize = 12000
infDistance = 9999999
height, width, _ = image.shape
random_counter = 0
box_area = face_boxes[:, 2] * face_boxes[:, 3]
rand_idx = random.randint(0, len(box_area) - 1) # 随机选择一个人脸
rand_Side = box_area[rand_idx]**0.5 # 等效正方形边长
if rand_Side <= 0: # 有的人脸大小被标记为0，可以跳过这些数据
return image, face_boxes, face_keys
anchors = [16, 32, 48, 64, 96, 128, 256, 512]
distance = infDistance
anchor_idx = 5
for i, anchor in enumerate(anchors):
if abs(anchor - rand_Side) < distance:
distance = abs(anchor - rand_Side) # 选择最接近的anchors
anchor_idx = i
target_anchor = random.choice(anchors[0:min(anchor_idx +
1, 5)]) # 随机选择一个相对较小的anchor，向下
ratio = float(target_anchor) / rand_Side # 缩放的尺度
ratio = ratio * (2**random.uniform(-1, 1)) # [ratio/2, 2ratio]的均匀分布
if height * ratio * width * ratio > maxSize * maxSize:
ratio = (maxSize * maxSize / (height * width))**0.5
image = ndimage.zoom(image,
zoom=(ratio, ratio, 1.0),
order=1,
mode='opencv')
face_boxes = face_boxes * ratio
if face_keys is not None:
face_keys[:, :, 0:2] *= ratio
return image, face_boxes, face_keys
def resize(image,
output_shape,
order=None,
mode='reflect',
cval=0,
clip=True,
preserve_range=False,
anti_aliasing=None,
anti_aliasing_sigma=None):
"""Resize image to match a certain size.
Performs interpolation to up-size or down-size N-dimensional images. Note
that anti-aliasing should be enabled when down-sizing images to avoid
aliasing artifacts. For down-sampling with an integer factor also see
`skimage.transform.downscale_local_mean`.
Parameters
----------
image : ndarray
Input image.
output_shape : tuple or ndarray
Size of the generated output image `(rows, cols[, ...][, dim])`. If
`dim` is not provided, the number of channels is preserved. In case the
number of input channels does not equal the number of output channels a
n-dimensional interpolation is applied.
Returns
-------
resized : ndarray
Resized version of the input.
Other parameters
----------------
order : int, optional
The order of the spline interpolation, default is 0 if
image.dtype is bool and 1 otherwise. The order has to be in
the range 0-5. See `skimage.transform.warp` for detail.
mode : {'constant', 'edge', 'symmetric', 'reflect', 'wrap'}, optional
Points outside the boundaries of the input are filled according
to the given mode. Modes match the behaviour of `numpy.pad`.
cval : float, optional
Used in conjunction with mode 'constant', the value outside
the image boundaries.
clip : bool, optional
Whether to clip the output to the range of values of the input image.
This is enabled by default, since higher order interpolation may
produce values outside the given input range.
preserve_range : bool, optional
Whether to keep the original range of values. Otherwise, the input
image is converted according to the conventions of `img_as_float`.
Also see https://scikit-image.org/docs/dev/user_guide/data_types.html
anti_aliasing : bool, optional
Whether to apply a Gaussian filter to smooth the image prior
to down-scaling. It is crucial to filter when down-sampling
the image to avoid aliasing artifacts. If input image data
type is bool, no anti-aliasing is applied.
anti_aliasing_sigma : {float, tuple of floats}, optional
Standard deviation for Gaussian filtering to avoid aliasing artifacts.
By default, this value is chosen as (s - 1) / 2 where s is the
down-scaling factor, where s > 1. For the up-size case, s < 1, no
anti-aliasing is performed prior to rescaling.
Notes
-----
Modes 'reflect' and 'symmetric' are similar, but differ in whether the edge
pixels are duplicated during the reflection. As an example, if an array
has values [0, 1, 2] and was padded to the right by four values using
symmetric, the result would be [0, 1, 2, 2, 1, 0, 0], while for reflect it
would be [0, 1, 2, 1, 0, 1, 2].
Examples
--------
>>> from skimage import data
>>> from cucim.skimage.transform import resize
>>> image = cp.array(data.camera())
>>> resize(image, (100, 100)).shape
(100, 100)
"""
output_shape = tuple(output_shape)
output_ndim = len(output_shape)
input_shape = image.shape
if output_ndim > image.ndim:
# append dimensions to input_shape
input_shape = input_shape + (1, ) * (output_ndim - image.ndim)
image = cp.reshape(image, input_shape)
elif output_ndim == image.ndim - 1:
# multichannel case: append shape of last axis
output_shape = output_shape + (image.shape[-1], )
elif output_ndim < image.ndim - 1:
raise ValueError("len(output_shape) cannot be smaller than the image "
"dimensions")
if anti_aliasing is None:
anti_aliasing = not image.dtype == bool
if image.dtype == bool and anti_aliasing:
warn(
"Input image dtype is bool. Gaussian convolution is not defined "
"with bool data type. Please set anti_aliasing to False or "
"explicitely cast input image to another data type. Starting "
"from version 0.19 a ValueError will be raised instead of this "
"warning.",
FutureWarning,
stacklevel=2)
factors = tuple(si / so for si, so in zip(input_shape, output_shape))
if anti_aliasing and any(f > 1 for f in factors):
if anti_aliasing_sigma is None:
anti_aliasing_sigma = tuple([max(0, (f - 1) / 2) for f in factors])
else:
if np.isscalar(anti_aliasing_sigma):
anti_aliasing_sigma = (anti_aliasing_sigma, ) * len(factors)
elif len(anti_aliasing_sigma) != len(factors):
raise ValueError("invalid anti_aliasing_sigma length")
if any(sigma < 0 for sigma in anti_aliasing_sigma):
raise ValueError("Anti-aliasing standard deviation must be "
"greater than or equal to zero")
elif any(((sigma > 0) & (factor <= 1))
for factor, sigma in zip(factors, anti_aliasing_sigma)):
warn("Anti-aliasing standard deviation greater than zero but "
"not down-sampling along all axes")
# Translate modes used by np.pad to those used by ndi.gaussian_filter
np_pad_to_ndimage = {
'constant': 'constant',
'edge': 'nearest',
'symmetric': 'reflect',
'reflect': 'mirror',
'wrap': 'wrap'
}
try:
ndi_mode = np_pad_to_ndimage[mode]
except KeyError:
raise ValueError("Unknown mode, or cannot translate mode. The "
"mode should be one of 'constant', 'edge', "
"'symmetric', 'reflect', or 'wrap'. See the "
"documentation of numpy.pad for more info.")
image = ndi.gaussian_filter(image,
anti_aliasing_sigma,
cval=cval,
mode=ndi_mode)
order = _validate_interpolation_order(image.dtype, order)
ndi_mode = _to_ndimage_mode(mode)
# TODO: move the following conversion into _to_ndimage_mode
if ndi_mode == 'constant':
ndi_mode = 'grid-constant'
elif ndi_mode == 'wrap':
ndi_mode = 'grid-wrap'
zoom_factors = [1 / f for f in factors]
image = convert_to_float(image, preserve_range)
out = ndi.zoom(image,
zoom_factors,
order=order,
mode=ndi_mode,
cval=cval,
grid_mode=True)
_clip_warp_output(image, out, order, mode, cval, clip)
return out
def upsample(x):
return zoom(x, (float(UPSAMPLE_X), float(UPSAMPLE_Y), 1), order=1)
def dataAugmentation(sample):
rotation = random.randint(0, 23)
if rotation == 1:
sample = cp.rot90(sample, 1, (1, 2))
elif rotation == 2:
sample = cp.rot90(sample, 2, (1, 2))
elif rotation == 3:
sample = cp.rot90(sample, 1, (2, 1))
elif rotation == 4:
sample = cp.rot90(sample, 1, (0, 1))
elif rotation == 5:
sample = cp.rot90(sample, 1, (0, 1))
sample = cp.rot90(sample, 1, (1, 2))
elif rotation == 6:
sample = cp.rot90(sample, 1, (0, 1))
sample = cp.rot90(sample, 2, (1, 2))
elif rotation == 7:
sample = cp.rot90(sample, 1, (0, 1))
sample = cp.rot90(sample, 1, (2, 1))
elif rotation == 8:
sample = cp.rot90(sample, 1, (1, 0))
elif rotation == 9:
sample = cp.rot90(sample, 1, (1, 0))
sample = cp.rot90(sample, 1, (1, 2))
elif rotation == 10:
sample = cp.rot90(sample, 1, (1, 0))
sample = cp.rot90(sample, 2, (1, 2))
elif rotation == 11:
sample = cp.rot90(sample, 1, (1, 0))
sample = cp.rot90(sample, 1, (2, 1))
elif rotation == 12:
sample = cp.rot90(sample, 2, (1, 0))
elif rotation == 13:
sample = cp.rot90(sample, 2, (1, 0))
sample = cp.rot90(sample, 1, (1, 2))
elif rotation == 14:
sample = cp.rot90(sample, 2, (1, 0))
sample = cp.rot90(sample, 2, (1, 2))
elif rotation == 15:
sample = cp.rot90(sample, 2, (1, 0))
sample = cp.rot90(sample, 1, (2, 1))
elif rotation == 16:
sample = cp.rot90(sample, 1, (0, 2))
elif rotation == 17:
sample = cp.rot90(sample, 1, (0, 2))
sample = cp.rot90(sample, 1, (1, 2))
elif rotation == 18:
sample = cp.rot90(sample, 1, (0, 2))
sample = cp.rot90(sample, 2, (1, 2))
elif rotation == 19:
sample = cp.rot90(sample, 1, (0, 2))
sample = cp.rot90(sample, 1, (2, 1))
elif rotation == 20:
sample = cp.rot90(sample, 1, (2, 0))
elif rotation == 21:
sample = cp.rot90(sample, 1, (2, 0))
sample = cp.rot90(sample, 1, (1, 2))
elif rotation == 22:
sample = cp.rot90(sample, 1, (2, 0))
sample = cp.rot90(sample, 2, (1, 2))
elif rotation == 23:
sample = cp.rot90(sample, 1, (2, 0))
sample = cp.rot90(sample, 1, (2, 1))
resolution = int(sample.shape[0])
strategy = random.randint(0, 9)
if strategy == 0:
factor = random.uniform(1.0625, 1.25)
sample = ndimage.zoom(sample, factor, order=0)
startx = random.randint(0, sample.shape[0] - resolution)
starty = random.randint(0, sample.shape[1] - resolution)
startz = random.randint(0, sample.shape[2] - resolution)
sample = sample[startx:startx + resolution, starty:starty + resolution,
startz:startz + resolution]
elif strategy == 1:
factor = random.uniform(0.9375, 0.75)
sample = ndimage.zoom(sample, factor, order=0)
padxwl = random.randint(0, resolution - sample.shape[0])
padxwr = resolution - padxwl - sample.shape[0]
padywl = random.randint(0, resolution - sample.shape[1])
padywr = resolution - padywl - sample.shape[1]
padzwl = random.randint(0, resolution - sample.shape[2])
padzwr = resolution - padzwl - sample.shape[2]
sample = np.pad(sample,
((padxwl, padxwr), (padywl, padywr), (padzwl, padzwr)),
mode='edge')
elif strategy == 2:
padr = int(resolution / 8)
loc = 2 * padr
startx = random.randint(0, loc)
starty = padr
startz = padr
sample = np.pad(sample, ((padr, padr), (padr, padr), (padr, padr)),
mode='edge')
sample = sample[startx:startx + resolution, starty:starty + resolution,
startz:startz + resolution]
elif strategy == 3:
padr = int(resolution / 8)
loc = 2 * padr
startx = padr
starty = random.randint(0, loc)
startz = padr
sample = np.pad(sample, ((padr, padr), (padr, padr), (padr, padr)),
mode='edge')
sample = sample[startx:startx + resolution, starty:starty + resolution,
startz:startz + resolution]
elif strategy == 4:
padr = int(resolution / 8)
loc = 2 * padr
startx = padr
starty = padr
startz = random.randint(0, loc)
sample = np.pad(sample, ((padr, padr), (padr, padr), (padr, padr)),
mode='edge')
sample = sample[startx:startx + resolution, starty:starty + resolution,
startz:startz + resolution]
return sample