def test_double_line_consistency(self):
xg = LineGenerator("x", "mm", 0, 4, 5, True)
yg = LineGenerator("y", "mm", 0, 4, 3)
m = RandomOffsetMutator(1, ["x", "y"], [0.1, 0.25])
g = CompoundGenerator([yg, xg], [], [])
g.prepare()
points = list(g.iterator())
ly = [l.upper["y"] for l in points[0:4] + points[5:9] + points[10:14]]
ry = [r.lower["y"] for r in points[1:5] + points[6:10] + points[11:15]]
self.assertEqual(ly, ry)
def test_bounds_consistency_in_compound(self):
liss = LissajousGenerator(["x", "y"], ["mm", "mm"], [0., 0.], [2., 2.],
4, 100, True)
line = LineGenerator("z", "mm", 0, 1, 3)
m = RandomOffsetMutator(1, ["x", "y"], [0.1, 0.1])
g = CompoundGenerator([line, liss], [], [])
gm = CompoundGenerator([line, liss], [], [m])
g.prepare()
gm.prepare()
points = list(gm.iterator())
lx = [l.upper["x"] for l in points[:-1]]
rx = [r.lower["x"] for r in points[1:]]
self.assertListAlmostEqual(lx, rx)
ly = [l.upper["y"] for l in points[:-1]]
ry = [r.lower["y"] for r in points[1:]]
self.assertListAlmostEqual(ly, ry)
def prepare(self):
self.num = 1
self.dimensions = []
# we're going to mutate these structures
excluders = list(self.excluders)
generators = list(self.generators)
# special case if we have rectangular regions on line generators
# we should restrict the resulting grid rather than merge dimensions
# this changes the alternating case a little (without doing this, we
# may have started in reverse direction)
for rect in [r for r in excluders \
if isinstance(r.roi, RectangularROI) and r.roi.angle == 0]:
axis_1, axis_2 = rect.scannables[0], rect.scannables[1]
gen_1 = [g for g in generators if axis_1 in g.axes][0]
gen_2 = [g for g in generators if axis_2 in g.axes][0]
if gen_1 is gen_2:
continue
if isinstance(gen_1, LineGenerator) \
and isinstance(gen_2, LineGenerator):
gen_1.produce_points()
gen_2.produce_points()
valid = np.full(gen_1.num, True, dtype=np.int8)
valid &= gen_1.points[
axis_1] <= rect.roi.width + rect.roi.start[0]
valid &= gen_1.points[axis_1] >= rect.roi.start[0]
points_1 = gen_1.points[axis_1][valid.astype(np.bool)]
valid = np.full(gen_2.num, True, dtype=np.int8)
valid &= gen_2.points[
axis_2] <= rect.roi.height + rect.roi.start[1]
valid &= gen_2.points[axis_2] >= rect.roi.start[1]
points_2 = gen_2.points[axis_2][valid.astype(np.bool)]
new_gen1 = LineGenerator(gen_1.name, gen_1.units, points_1[0],
points_1[-1], len(points_1),
gen_1.alternate_direction)
new_gen2 = LineGenerator(gen_2.name, gen_2.units, points_2[0],
points_2[-1], len(points_2),
gen_2.alternate_direction)
generators[generators.index(gen_1)] = new_gen1
generators[generators.index(gen_2)] = new_gen2
excluders.remove(rect)
for generator in generators:
generator.produce_points()
self.axes_points.update(generator.points)
self.axes_points_lower.update(generator.points_lower)
self.axes_points_upper.update(generator.points_upper)
self.num *= generator.num
dim = {
"size": generator.num,
"axes": list(generator.axes),
"generators": [generator],
"masks": [],
"tile": 1,
"repeat": 1,
"alternate": generator.alternate_direction
}
self.dimensions.append(dim)
for excluder in excluders:
axis_1, axis_2 = excluder.scannables
# ensure axis_1 is "outer" axis (if separate generators)
gen_1 = [g for g in generators if axis_1 in g.axes][0]
gen_2 = [g for g in generators if axis_2 in g.axes][0]
gen_diff = generators.index(gen_1) \
- generators.index(gen_2)
if gen_diff < -1 or gen_diff > 1:
raise ValueError(
"Excluders must be defined on axes that are adjacent in " \
"generator order")
if gen_diff == 1:
gen_1, gen_2 = gen_2, gen_1
axis_1, axis_2 = axis_2, axis_1
gen_diff = -1
#####
# first check if region spans two dimensions - merge if so
#####
dim_1 = [i for i in self.dimensions if axis_1 in i["axes"]][0]
dim_2 = [i for i in self.dimensions if axis_2 in i["axes"]][0]
dim_diff = self.dimensions.index(dim_1) \
- self.dimensions.index(dim_2)
if dim_diff < -1 or dim_diff > 1:
raise ValueError(
"Excluders must be defined on axes that are adjacent in " \
"generator order")
if dim_diff == 1:
dim_1, dim_2 = dim_2, dim_1
dim_diff = -1
if dim_1["alternate"] != dim_2["alternate"] \
and dim_1 is not self.dimensions[0]:
raise ValueError(
"Generators tied by regions must have the same " \
"alternate_direction setting")
# merge "inner" into "outer"
if dim_diff == -1:
# dim_1 is "outer" - preserves axis ordering
# need to appropriately scale the existing masks
# masks are "tiled" by the size of generators "below" them
# and their elements are "repeated" by the size of generators
# above them, so:
# |mask| * duplicates * repeates == |generators in index|
scale = 1
for g in dim_2["generators"]:
scale *= g.num
for m in dim_1["masks"]:
m["repeat"] *= scale
scale = 1
for g in dim_1["generators"]:
scale *= g.num
for m in dim_2["masks"]:
m["tile"] *= scale
dim_1["masks"] += dim_2["masks"]
dim_1["axes"] += dim_2["axes"]
dim_1["generators"] += dim_2["generators"]
dim_1["size"] *= dim_2["size"]
dim_1["alternate"] |= dim_2["alternate"]
self.dimensions.remove(dim_2)
dim = dim_1
#####
# generate the mask for this region
#####
# if gen_1 and gen_2 are different then the outer axis will have to
# have its elements repeated and the inner axis will have to have
# itself repeated - gen_1 is always inner axis
points_1 = self.axes_points[axis_1]
points_2 = self.axes_points[axis_2]
doubled_mask = False # used for some cases of alternating generators
if gen_1 is gen_2 and dim["alternate"]:
# run *both* axes backwards
# but our mask will be a factor of 2 too big
doubled_mask = True
points_1 = np.append(points_1, points_1[::-1])
points_2 = np.append(points_2, points_2[::-1])
elif dim["alternate"]:
doubled_mask = True
points_1 = np.append(points_1, points_1[::-1])
points_2 = np.append(points_2, points_2[::-1])
points_2 = np.tile(points_2, gen_1.num)
points_1 = np.repeat(points_1, gen_2.num)
elif gen_1 is not gen_2:
points_1 = np.repeat(points_1, gen_2.num)
points_2 = np.tile(points_2, gen_1.num)
else:
# copy the points arrays anyway so the regions can
# safely perform any array operations in place
# this is advantageous in the cases above
points_1 = np.copy(points_1)
points_2 = np.copy(points_2)
if axis_1 == excluder.scannables[0]:
mask = excluder.create_mask(points_1, points_2)
else:
mask = excluder.create_mask(points_2, points_1)
#####
# Add new mask to index
#####
tile = 0.5 if doubled_mask else 1
repeat = 1
found_axis = False
# tile by product of generators "before"
# repeat by product of generators "after"
for g in dim["generators"]:
if axis_1 in g.axes or axis_2 in g.axes:
found_axis = True
else:
if found_axis:
repeat *= g.num
else:
tile *= g.num
m = {"repeat": repeat, "tile": tile, "mask": mask}
dim["masks"].append(m)
# end for excluder in excluders
#####
tile = 1
repeat = 1
#####
# Generate full index mask and "apply"
#####
for dim in self.dimensions:
mask = np.full(dim["size"], True, dtype=np.int8)
for m in dim["masks"]:
assert len(m["mask"]) * m["repeat"] * m["tile"] == len(mask), \
"Mask lengths are not consistent"
expanded = np.repeat(m["mask"], m["repeat"])
if m["tile"] % 1 != 0:
ex = np.tile(expanded, int(m["tile"]))
expanded = np.append(ex, expanded[:len(expanded) // 2])
else:
expanded = np.tile(expanded, int(m["tile"]))
mask &= expanded
dim["mask"] = mask
dim["indicies"] = np.nonzero(mask)[0]
if len(dim["indicies"]) == 0:
raise ValueError("Regions would exclude entire scan")
repeat *= len(dim["indicies"])
self.num = repeat
for dim in self.dimensions:
l = len(dim["indicies"])
repeat /= l
dim["tile"] = tile
dim["repeat"] = repeat
tile *= l
for dim in self.dimensions:
tile = 1
repeat = 1
for g in dim["generators"]:
repeat *= g.num
for g in dim["generators"]:
repeat /= g.num
d = {"tile": tile, "repeat": repeat}
tile *= g.num
self.generator_dim_scaling[g] = d
def prepare(self):
"""
Prepare data structures required for point generation and
initialize size, shape, and dimensions attributes.
Must be called before get_point or iterator are called.
"""
if self._prepared:
return
self.dimensions = []
self._dim_meta = {}
self._generator_dim_scaling = {}
# we're going to mutate these structures
excluders = list(self.excluders)
generators = list(self.generators)
# special case if we have rectangular regions on line generators
# we should restrict the resulting grid rather than merge dimensions
# this changes the alternating case a little (without doing this, we
# may have started in reverse direction)
for excluder_ in [e for e in excluders if isinstance(e, ROIExcluder)]:
if len(excluder_.rois) == 1 \
and isinstance(excluder_.rois[0], RectangularROI) \
and excluder_.rois[0].angle == 0:
rect = excluder_.rois[0]
axis_1, axis_2 = excluder_.axes[0], excluder_.axes[1]
gen_1 = [g for g in generators if axis_1 in g.axes][0]
gen_2 = [g for g in generators if axis_2 in g.axes][0]
if gen_1 is gen_2:
continue
if isinstance(gen_1, LineGenerator) \
and isinstance(gen_2, LineGenerator):
gen_1.prepare_positions()
gen_2.prepare_positions()
# Filter by axis 1
valid = np.full(gen_1.size, True, dtype=np.int8)
valid &= \
gen_1.positions[axis_1] <= rect.width + rect.start[0]
valid &= \
gen_1.positions[axis_1] >= rect.start[0]
points_1 = gen_1.positions[axis_1][valid.astype(np.bool)]
# Filter by axis 2
valid = np.full(gen_2.size, True, dtype=np.int8)
valid &= \
gen_2.positions[axis_2] <= rect.height + rect.start[1]
valid &= gen_2.positions[axis_2] >= rect.start[1]
points_2 = gen_2.positions[axis_2][valid.astype(np.bool)]
# Recreate generators to replace larger generators + ROI
new_gen1 = LineGenerator(gen_1.axes, gen_1.units,
points_1[0], points_1[-1],
len(points_1), gen_1.alternate)
new_gen2 = LineGenerator(gen_2.axes, gen_2.units,
points_2[0], points_2[-1],
len(points_2), gen_2.alternate)
generators[generators.index(gen_1)] = new_gen1
generators[generators.index(gen_2)] = new_gen2
# Remove Excluder as it is now empty
excluders.remove(excluder_)
for generator in generators:
generator.prepare_positions()
self.dimensions.append(Dimension(generator))
# only the inner-most generator needs to have bounds calculated
if self.continuous:
generators[-1].prepare_bounds()
for excluder in excluders:
matched_dims = [
d for d in self.dimensions
if len(set(d.axes) & set(excluder.axes)) != 0
]
if len(matched_dims) == 0:
raise ValueError(
"Excluder references axes that have not been provided by generators: %s"
% str(excluder.axes))
d_start = self.dimensions.index(matched_dims[0])
d_end = self.dimensions.index(matched_dims[-1])
if d_start != d_end:
# merge all excluders between d_start and d_end (inclusive)
alternate = self.dimensions[d_end].alternate
# verify consistent alternate settings (ignoring outermost dimesion where it doesn't matter)
for d in self.dimensions[max(1, d_start):d_end]:
# filter out dimensions consisting of a single NullPointGenerator, since alternation means nothing
if len(d.generators) == 1 and isinstance(
d.generators[0], NullPointGenerator):
continue
if alternate != d.alternate:
raise ValueError(
"Nested generators connected by regions must have the same alternate setting"
)
merged_dim = Dimension.merge_dimensions(
self.dimensions[d_start:d_end + 1])
self.dimensions = self.dimensions[:d_start] + [
merged_dim
] + self.dimensions[d_end + 1:]
dim = merged_dim
else:
dim = self.dimensions[d_start]
dim.apply_excluder(excluder)
self.size = 1
for dim in self.dimensions:
self._dim_meta[dim] = {}
dim.prepare()
if dim.size == 0:
raise ValueError("Regions would exclude entire scan")
self.size *= dim.size
self.shape = tuple(dim.size for dim in self.dimensions)
repeat = self.size
tile = 1
for dim in self.dimensions:
repeat /= dim.size
self._dim_meta[dim]["tile"] = tile
self._dim_meta[dim]["repeat"] = repeat
tile *= dim.size
for dim in self.dimensions:
tile = 1
repeat = dim._max_length
for g in dim.generators:
repeat /= g.size
d = {"tile": tile, "repeat": repeat}
tile *= g.size
self._generator_dim_scaling[g] = d
self._prepared = True
def prepare(self):
"""
Prepare data structures required for point generation and
initialize size, shape, and dimensions attributes.
Must be called before get_point or iterator are called.
"""
if self._prepared:
return
self.dimensions = []
self._dim_meta = {}
self._generator_dim_scaling = {}
# we're going to mutate these structures
excluders = list(self.excluders)
generators = list(self.generators)
# special case if we have rectangular regions on line generators
# we should restrict the resulting grid rather than merge dimensions
# this changes the alternating case a little (without doing this, we
# may have started in reverse direction)
for excluder_ in [e for e in excluders if isinstance(e, ROIExcluder)]:
if len(excluder_.rois) == 1 \
and isinstance(excluder_.rois[0], RectangularROI) \
and excluder_.rois[0].angle == 0:
rect = excluder_.rois[0]
axis_1, axis_2 = excluder_.axes[0], excluder_.axes[1]
gen_1 = [g for g in generators if axis_1 in g.axes][0]
gen_2 = [g for g in generators if axis_2 in g.axes][0]
if gen_1 is gen_2:
continue
if isinstance(gen_1, LineGenerator) \
and isinstance(gen_2, LineGenerator):
gen_1.prepare_positions()
gen_2.prepare_positions()
# Filter by axis 1
valid = np.full(gen_1.size, True, dtype=np.int8)
valid &= \
gen_1.positions[axis_1] <= rect.width + rect.start[0]
valid &= \
gen_1.positions[axis_1] >= rect.start[0]
points_1 = gen_1.positions[axis_1][valid.astype(np.bool)]
# Filter by axis 2
valid = np.full(gen_2.size, True, dtype=np.int8)
valid &= \
gen_2.positions[axis_2] <= rect.height + rect.start[1]
valid &= gen_2.positions[axis_2] >= rect.start[1]
points_2 = gen_2.positions[axis_2][valid.astype(np.bool)]
# Recreate generators to replace larger generators + ROI
new_gen1 = LineGenerator(gen_1.axes, gen_1.units,
points_1[0], points_1[-1],
len(points_1), gen_1.alternate)
new_gen2 = LineGenerator(gen_2.axes, gen_2.units,
points_2[0], points_2[-1],
len(points_2), gen_2.alternate)
generators[generators.index(gen_1)] = new_gen1
generators[generators.index(gen_2)] = new_gen2
# Remove Excluder as it is now empty
excluders.remove(excluder_)
for generator in generators:
generator.prepare_positions()
self.dimensions.append(Dimension(generator))
# only the inner-most generator needs to have bounds calculated
generators[-1].prepare_bounds()
for excluder in excluders:
axis_1, axis_2 = excluder.axes
gen_1 = [g for g in generators if axis_1 in g.axes][0]
gen_2 = [g for g in generators if axis_2 in g.axes][0]
gen_diff = generators.index(gen_1) \
- generators.index(gen_2)
if gen_diff < -1 or gen_diff > 1:
raise ValueError(
"Excluders must be defined on axes that are adjacent in " \
"generator order")
# merge dimensions if region spans two
dim_1 = [i for i in self.dimensions if axis_1 in i.axes][0]
dim_2 = [i for i in self.dimensions if axis_2 in i.axes][0]
dim_diff = self.dimensions.index(dim_1) \
- self.dimensions.index(dim_2)
if dim_diff == 1:
dim_1, dim_2 = dim_2, dim_1
dim_diff = -1
if dim_1.alternate != dim_2.alternate \
and dim_1 is not self.dimensions[0]:
raise ValueError(
"Generators tied by regions must have the same " \
"alternate setting")
# merge "inner" into "outer"
if dim_diff == -1:
# dim_1 is "outer" - preserves axis ordering
new_dim = Dimension.merge_dimensions(dim_1, dim_2)
self.dimensions[self.dimensions.index(dim_1)] = new_dim
self.dimensions.remove(dim_2)
dim = new_dim
else:
dim = dim_1
dim.apply_excluder(excluder)
self.size = 1
for dim in self.dimensions:
self._dim_meta[dim] = {}
dim.prepare()
if dim.size == 0:
raise ValueError("Regions would exclude entire scan")
self.size *= dim.size
self.shape = tuple(dim.size for dim in self.dimensions)
repeat = self.size
tile = 1
for dim in self.dimensions:
repeat /= dim.size
self._dim_meta[dim]["tile"] = tile
self._dim_meta[dim]["repeat"] = repeat
tile *= dim.size
for dim in self.dimensions:
tile = 1
repeat = dim._max_length
for g in dim.generators:
repeat /= g.size
d = {"tile": tile, "repeat": repeat}
tile *= g.size
self._generator_dim_scaling[g] = d
self._prepared = True