def process(self, batch, request):
src_points = batch.points[self.src_points]
voxel_size = self.spec[self.array].voxel_size
# get roi used for creating the new array (points_roi does not
# necessarily align with voxel size)
enlarged_vol_roi = src_points.spec.roi.snap_to_grid(voxel_size)
offset = enlarged_vol_roi.get_begin() / voxel_size
shape = enlarged_vol_roi.get_shape() / voxel_size
data_roi = Roi(offset, shape)
logger.debug("Src points in %s", src_points.spec.roi)
for i, point in src_points.data.items():
logger.debug("%d, %s", i, point.location)
logger.debug("Data roi in voxels: %s", data_roi)
logger.debug("Data roi in world units: %s", data_roi * voxel_size)
mask_array = None if self.mask is None else batch.arrays[
self.mask].crop(enlarged_vol_roi)
partner_vectors_data, pointmask = self.__draw_partner_vectors(
src_points, batch.points[self.trg_points], data_roi, voxel_size,
enlarged_vol_roi.get_begin(), self.radius, mask_array)
# create array and crop it to requested roi
spec = self.spec[self.array].copy()
spec.roi = data_roi * voxel_size
partner_vectors = Array(data=partner_vectors_data, spec=spec)
logger.debug("Cropping partner vectors to %s", request[self.array].roi)
batch.arrays[self.array] = partner_vectors.crop(
request[self.array].roi)
if self.pointmask is not None and self.pointmask in request:
spec = self.spec[self.array].copy()
spec.roi = data_roi * voxel_size
pointmask = Array(data=np.array(pointmask, dtype=spec.dtype),
spec=spec)
batch.arrays[self.pointmask] = pointmask.crop(
request[self.pointmask].roi)
# restore requested ROI of src and target points.
if self.src_points in request:
self.__restore_points_roi(request, self.src_points,
batch.points[self.src_points])
if self.trg_points in request:
self.__restore_points_roi(request, self.trg_points,
batch.points[self.trg_points])
# restore requested objectmask
if self.mask is not None:
batch.arrays[self.mask] = batch.arrays[self.mask].crop(
request[self.mask].roi)
def process(self, batch, request):
points = batch.points[self.points]
voxel_size = self.spec[self.array].voxel_size
# get roi used for creating the new array (points_roi does not
# necessarily align with voxel size)
enlarged_vol_roi = points.spec.roi.snap_to_grid(voxel_size)
offset = enlarged_vol_roi.get_begin() / voxel_size
shape = enlarged_vol_roi.get_shape() / voxel_size
data_roi = Roi(offset, shape)
# points ROI is at least +- 1 in t of requested array ROI, we can save
# some time by shaving the excess off
data_roi = data_roi.grow((-1, 0, 0, 0), (-1, 0, 0, 0))
logger.debug("Points in %s", points.spec.roi)
for i, point in points.data.items():
logger.debug("%d, %s", i, point.location)
logger.debug("Data roi in voxels: %s", data_roi)
logger.debug("Data roi in world units: %s", data_roi * voxel_size)
parent_vectors_data, mask_data = self.__draw_parent_vectors(
points, data_roi, voxel_size, enlarged_vol_roi.get_begin(),
self.radius)
# create array and crop it to requested roi
spec = self.spec[self.array].copy()
spec.roi = data_roi * voxel_size
parent_vectors = Array(data=parent_vectors_data, spec=spec)
logger.debug("Cropping parent vectors to %s", request[self.array].roi)
batch.arrays[self.array] = parent_vectors.crop(request[self.array].roi)
# create mask and crop it to requested roi
spec = self.spec[self.mask].copy()
spec.roi = data_roi * voxel_size
mask = Array(data=mask_data, spec=spec)
logger.debug("Cropping mask to %s", request[self.mask].roi)
batch.arrays[self.mask] = mask.crop(request[self.mask].roi)
# restore requested ROI of points
if self.points in request:
request_roi = request[self.points].roi
points.spec.roi = request_roi
for i, p in list(points.data.items()):
if not request_roi.contains(p.location):
del points.data[i]
if len(points.data) == 0:
logger.warning("Returning empty batch for key %s and roi %s" %
(self.points, request_roi))
def process(self, batch, request):
if self.target not in request:
return
input_roi = batch.arrays[self.source].spec.roi
request_roi = request[self.target].roi
assert input_roi.contains(request_roi)
# upsample
order = 3 if batch.arrays[self.source].spec.interpolatable else 0
data = ndimage.zoom(batch.arrays[self.source].data,
np.array(self.factor),
order=order)
# Create output array, crop accordingly.
spec = self.spec[self.target].copy()
spec.roi = input_roi
ar = Array(data, spec)
batch.arrays[self.target] = ar.crop(request_roi)
if self.source in request:
# restore requested rois
request_roi = request[self.source].roi
if input_roi != request_roi:
assert input_roi.contains(request_roi)
logger.debug("restoring original request roi %s of %s from %s",
request_roi, self.source, input_roi)
cropped = batch.arrays[self.source].crop(request_roi)
batch.arrays[self.source] = cropped
def process(self, batch, request):
points = batch.points[self.points]
mask = self.settings.mask
voxel_size = self.spec[self.array].voxel_size
# get roi used for creating the new array (points_roi does no
# necessarily align with voxel size)
enlarged_vol_roi = points.spec.roi.snap_to_grid(voxel_size)
offset = enlarged_vol_roi.get_begin() / voxel_size
shape = enlarged_vol_roi.get_shape() / voxel_size
data_roi = Roi(offset, shape)
logger.debug("Points in %s", points.spec.roi)
for i, point in points.data.items():
logger.debug("%d, %s", i, point.location)
logger.debug("Data roi in voxels: %s", data_roi)
logger.debug("Data roi in world units: %s", data_roi*voxel_size)
if len(points.data.items()) == 0:
# If there are no points at all, just create an empty matrix.
rasterized_points_data = np.zeros(data_roi.get_shape(),
dtype=self.spec[self.array].dtype)
elif mask is not None:
mask_array = batch.arrays[mask].crop(enlarged_vol_roi)
# get those component labels in the mask, that contain points
labels = []
for i, point in points.data.items():
v = Coordinate(point.location / voxel_size)
v -= data_roi.get_begin()
labels.append(mask_array.data[v])
# Make list unique
labels = list(set(labels))
# zero label should be ignored
if 0 in labels:
labels.remove(0)
if len(labels) == 0:
logger.debug("Points and provided object mask do not overlap. No points to rasterize.")
rasterized_points_data = np.zeros(data_roi.get_shape(),
dtype=self.spec[self.array].dtype)
else:
# create data for the whole points ROI, "or"ed together over
# individual object masks
rasterized_points_data = np.sum(
[
self.__rasterize(
points,
data_roi,
voxel_size,
self.spec[self.array].dtype,
self.settings,
Array(data=mask_array.data==label, spec=mask_array.spec))
for label in labels
],
axis=0)
else:
# create data for the whole points ROI without mask
rasterized_points_data = self.__rasterize(
points,
data_roi,
voxel_size,
self.spec[self.array].dtype,
self.settings)
# fix bg/fg labelling if requested
if (self.settings.bg_value != 0 or
self.settings.fg_value != 1):
replaced = replace(
rasterized_points_data,
[0, 1],
[self.settings.bg_value, self.settings.fg_value])
rasterized_points_data = replaced.astype(self.spec[self.array].dtype)
# create array and crop it to requested roi
spec = self.spec[self.array].copy()
spec.roi = data_roi*voxel_size
rasterized_points = Array(
data=rasterized_points_data,
spec=spec)
batch.arrays[self.array] = rasterized_points.crop(request[self.array].roi)
# restore requested ROI of points
if self.points in request:
request_roi = request[self.points].roi
points.spec.roi = request_roi
points.data = {i: p for i, p in points.data.items() if request_roi.contains(p.location)}
# restore requested mask
if mask is not None:
batch.arrays[mask] = batch.arrays[mask].crop(request[mask].roi)
def process(self, batch, request):
points = batch.points[self.points]
mask = self.settings.mask
voxel_size = self.spec[self.array].voxel_size
# get the output array shape
offset = points.spec.roi.get_begin() / voxel_size
shape = -(-points.spec.roi.get_shape() / voxel_size) # ceil division
data_roi = Roi(offset, shape)
logger.debug("Points in %s", points.spec.roi)
for i, point in points.data.items():
logger.debug("%d, %s", i, point.location)
logger.debug("Data roi in voxels: %s", data_roi)
logger.debug("Data roi in world units: %s", data_roi * voxel_size)
if mask is not None:
# get all component labels in the mask
labels = list(np.unique(batch.arrays[mask].data))
# zero label should be ignored
if 0 in labels:
labels.remove(0)
# create data for the whole points ROI, "or"ed together over
# individual object masks
rasterized_points_data = np.sum([
self.__rasterize(
points, data_roi, voxel_size, self.spec[self.array].dtype,
self.settings,
Array(data=mask.data == label, spec=mask.spec))
for label in labels
],
axis=0)
else:
# create data for the whole points ROI without mask
rasterized_points_data = self.__rasterize(
points, data_roi, voxel_size, self.spec[self.array].dtype,
self.settings)
# fix bg/fg labelling if requested
if (self.settings.bg_value != 0 or self.settings.fg_value != 1):
replaced = replace(
rasterized_points_data, [0, 1],
[self.settings.bg_value, self.settings.fg_value])
rasterized_points_data = replaced.astype(
self.spec[self.array].dtype)
# create array and crop it to requested roi
spec = self.spec[self.array].copy()
spec.roi = data_roi * voxel_size
rasterized_points = Array(data=rasterized_points_data, spec=spec)
batch.arrays[self.array] = rasterized_points.crop(
request[self.array].roi)
# restore requested ROI of points
if self.points in request:
request_roi = request[self.points].roi
points.spec.roi = request_roi
for i, p in points.data.items():
if not request_roi.contains(p.location):
del points.data[i]