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]