def test_vectorized_integrate():
r0 = np.array([12, 0, 0, 10, 0, 10, 30])
c0 = np.array([10, 0, 10, 0, 0, 10, 31])
r1 = np.array([23, 19, 19, 19, 0, 10, 49])
c1 = np.array([19, 19, 19, 19, 0, 10, 49])
expected = np.array([
x[12:24, 10:20].sum(), x[:20, :20].sum(), x[:20, 10:20].sum(),
x[10:20, :20].sum(), x[0, 0], x[10, 10], x[30:, 31:].sum()
])
start_pts = [(r0[i], c0[i]) for i in range(len(r0))]
end_pts = [(r1[i], c1[i]) for i in range(len(r0))]
assert_equal(expected, integrate(s, r0, c0, r1, c1)) # test deprecated
assert_equal(expected, integrate(s, start_pts, end_pts))
def __is_min_masked(self, random_shift, request):
if not self.mask or self.min_masked == 0:
return True
# get randomly chosen mask ROI
request_mask_roi = request.array_specs[self.mask].roi
request_mask_roi = request_mask_roi.shift(random_shift)
# get coordinates inside mask array
mask_voxel_size = self.spec[self.mask].voxel_size
request_mask_roi_in_array = request_mask_roi/mask_voxel_size
request_mask_roi_in_array -= self.mask_spec.roi.get_offset()/mask_voxel_size
# get number of masked-in voxels
num_masked_in = integrate(
self.mask_integral,
[request_mask_roi_in_array.get_begin()],
[request_mask_roi_in_array.get_end()-(1,)*self.mask_integral.ndim]
)[0]
mask_ratio = float(num_masked_in)/request_mask_roi_in_array.size()
logger.debug("mask ratio is %f", mask_ratio)
return mask_ratio >= self.min_masked
def test_vectorized_integrate():
r0 = np.array([12, 0, 0, 10, 0, 10, 30])
c0 = np.array([10, 0, 10, 0, 0, 10, 31])
r1 = np.array([23, 19, 19, 19, 0, 10, 49])
c1 = np.array([19, 19, 19, 19, 0, 10, 49])
expected = np.array([
x[12:24, 10:20].sum(), x[:20, :20].sum(), x[:20, 10:20].sum(),
x[10:20, :20].sum(), x[0, 0], x[10, 10], x[30:, 31:].sum()
])
assert_equal(expected, integrate(s, r0, c0, r1, c1))
def test_vectorized_integrate():
r0 = np.array([12, 0, 0, 10, 0, 10, 30])
c0 = np.array([10, 0, 10, 0, 0, 10, 31])
r1 = np.array([23, 19, 19, 19, 0, 10, 49])
c1 = np.array([19, 19, 19, 19, 0, 10, 49])
expected = np.array(
[
x[12:24, 10:20].sum(),
x[:20, :20].sum(),
x[:20, 10:20].sum(),
x[10:20, :20].sum(),
x[0, 0],
x[10, 10],
x[30:, 31:].sum(),
]
)
start_pts = [(r0[i], c0[i]) for i in range(len(r0))]
end_pts = [(r1[i], c1[i]) for i in range(len(r0))]
assert_equal(expected, integrate(s, r0, c0, r1, c1)) # test deprecated
assert_equal(expected, integrate(s, start_pts, end_pts))
def test_vectorized_integrate():
r0 = np.array([12, 0, 0, 10, 0, 10, 30])
c0 = np.array([10, 0, 10, 0, 0, 10, 31])
r1 = np.array([23, 19, 19, 19, 0, 10, 49])
c1 = np.array([19, 19, 19, 19, 0, 10, 49])
expected = np.array([x[12:24, 10:20].sum(),
x[:20, :20].sum(),
x[:20, 10:20].sum(),
x[10:20, :20].sum(),
x[0,0],
x[10, 10],
x[30:, 31:].sum()])
assert_equal(expected, integrate(s, r0, c0, r1, c1))
def test_single():
assert_equal(x[0, 0], integrate(s, 0, 0, 0, 0))
assert_equal(x[10, 10], integrate(s, 10, 10, 10, 10))
def test_basic():
assert_equal(x[12:24, 10:20].sum(), integrate(s, 12, 10, 23, 19))
assert_equal(x[:20, :20].sum(), integrate(s, 0, 0, 19, 19))
assert_equal(x[:20, 10:20].sum(), integrate(s, 0, 10, 19, 19))
assert_equal(x[10:20, :20].sum(), integrate(s, 10, 0, 19, 19))
def test_integrate_single():
assert_equal(x[0, 0], integrate(s, (0, 0), (0, 0)))
assert_equal(x[10, 10], integrate(s, (10, 10), (10, 10)))
def test_integrate_basic():
assert_equal(x[12:24, 10:20].sum(), integrate(s, (12, 10), (23, 19)))
assert_equal(x[:20, :20].sum(), integrate(s, (0, 0), (19, 19)))
assert_equal(x[:20, 10:20].sum(), integrate(s, (0, 10), (19, 19)))
assert_equal(x[10:20, :20].sum(), integrate(s, (10, 0), (19, 19)))
def test_single():
assert_equal(x[0, 0], integrate(s, 0, 0, 0, 0))
assert_equal(x[10, 10], integrate(s, 10, 10, 10, 10))
def test_basic():
assert_equal(x[12:24, 10:20].sum(), integrate(s, 12, 10, 23, 19))
assert_equal(x[:20, :20].sum(), integrate(s, 0, 0, 19, 19))
assert_equal(x[:20, 10:20].sum(), integrate(s, 0, 10, 19, 19))
assert_equal(x[10:20, :20].sum(), integrate(s, 10, 0, 19, 19))
def prepare(self, request):
shift_roi = None
for volume_type, request_roi in request.volumes.items():
assert volume_type in self.get_spec().volumes, "Requested %s, but source does not provide it."%volume_type
provided_roi = self.get_spec().volumes[volume_type]
volume_shift_roi = provided_roi.shift(-request_roi.get_begin()).grow((0,0,0), -request_roi.get_shape())
if shift_roi is None:
shift_roi = volume_shift_roi
else:
shift_roi = shift_roi.intersect(volume_shift_roi)
logger.debug("valid shifts for request in " + str(shift_roi))
assert shift_roi.size() > 0, "Can not satisfy batch request, no location covers all requested ROIs."
good_location_found = False
while not good_location_found:
# select a random point inside ROI
random_shift = Coordinate(
randint(begin, end-1)
for begin, end in zip(shift_roi.get_begin(), shift_roi.get_end())
)
logger.debug("random shift: " + str(random_shift))
if self.min_masked > 0:
# get randomly chosen mask ROI
request_mask_roi = request.volumes[self.mask_volume_type]
request_mask_roi = request_mask_roi.shift(random_shift)
# get coordinates inside mask volume
request_mask_roi_in_volume = request_mask_roi.shift(-self.mask_roi.get_offset())
# get number of masked-in voxels
num_masked_in = integrate(
self.mask_integral,
[request_mask_roi_in_volume.get_begin()],
[request_mask_roi_in_volume.get_end()-(1,)*self.mask_integral.ndim]
)[0]
mask_ratio = float(num_masked_in)/request_mask_roi.size()
logger.debug("mask ratio is %f"%mask_ratio)
if mask_ratio >= self.min_masked:
logger.debug("good batch found")
good_location_found = True
else:
logger.debug("bad batch found")
else:
good_location_found = True
# shift request ROIs
for (volume_type, roi) in request.volumes.items():
roi = roi.shift(random_shift)
logger.debug("new %s ROI: %s"%(volume_type,roi))
request.volumes[volume_type] = roi
assert self.roi.contains(roi)
