def setup(dials_data):
from dials.algorithms.profile_model.gaussian_rs import BBoxCalculator3D
from dials.model.serialize import load
sequence = load.sequence(
dials_data("centroid_test_data").join("sweep.json").strpath)
fixture = {}
# Get the models
fixture["beam"] = sequence.get_beam()
fixture["detector"] = sequence.get_detector()
fixture["gonio"] = sequence.get_goniometer()
fixture["scan"] = sequence.get_scan()
# Set the delta_divergence/mosaicity
n_sigma = 5
sigma_divergence = 0.060 * math.pi / 180
mosaicity = 0.154 * math.pi / 180
fixture["delta_divergence"] = n_sigma * sigma_divergence
fixture["delta_mosaicity"] = n_sigma * mosaicity
# Create the bounding box calculator
fixture["calculate_bbox"] = BBoxCalculator3D(
fixture["beam"],
fixture["detector"],
fixture["gonio"],
fixture["scan"],
fixture["delta_divergence"],
fixture["delta_mosaicity"],
)
return fixture
def setup(dials_data):
sequence = load.imageset(
dials_data("centroid_test_data").join("sweep.json").strpath
)
fixture = {}
# Get the models
fixture["beam"] = sequence.get_beam()
fixture["detector"] = sequence.get_detector()
fixture["gonio"] = sequence.get_goniometer()
fixture["scan"] = sequence.get_scan()
# Set the delta_divergence/mosaicity
n_sigma = 5
sigma_divergence = 0.060 * math.pi / 180
mosaicity = 0.154 * math.pi / 180
fixture["delta_divergence"] = n_sigma * sigma_divergence
fixture["delta_mosaicity"] = n_sigma * mosaicity
# Create the bounding box calculator
fixture["calculate_bbox"] = BBoxCalculator3D(
fixture["beam"],
fixture["detector"],
fixture["gonio"],
fixture["scan"],
fixture["delta_divergence"],
fixture["delta_mosaicity"],
)
return fixture
def __init__(self, filename):
from math import pi
from dials.model.serialize import load
from dials.algorithms.profile_model.gaussian_rs.transform import MapFramesReverse
from dials.algorithms.profile_model.gaussian_rs.transform import MapFramesForward
from dials.algorithms.profile_model.gaussian_rs import BBoxCalculator3D
# Load the sweep
self.sweep = load.sweep(filename)
# Get the models
self.beam = self.sweep.get_beam()
self.detector = self.sweep.get_detector()
self.gonio = self.sweep.get_goniometer()
self.scan = self.sweep.get_scan()
# Set the delta_divergence/mosaicity
self.n_sigma = 3
self.sigma_divergence = 0.060 * pi / 180
self.mosaicity = 0.154 * pi / 180
self.delta_divergence = self.n_sigma * self.sigma_divergence
self.delta_mosaicity = self.n_sigma * self.mosaicity
# Set the grid size
self.grid_size = (4, 4, 4)
# Create the E3 fraction object
self.transform_forward = MapFramesForward(
self.scan.get_array_range()[0],
self.scan.get_oscillation(deg=False)[0],
self.scan.get_oscillation(deg=False)[1],
self.mosaicity,
self.n_sigma,
self.grid_size[2])
# Create the E3 fraction object
self.transform_reverse = MapFramesReverse(
self.scan.get_array_range()[0],
self.scan.get_oscillation(deg=False)[0],
self.scan.get_oscillation(deg=False)[1],
self.mosaicity,
self.n_sigma,
self.grid_size[2])
# Create the bounding box calculator
self.calculate_bbox = BBoxCalculator3D(
self.beam, self.detector, self.gonio, self.scan,
self.delta_divergence,
self.delta_mosaicity)
def __init__(self, filename):
from dials.model.serialize import load
from dials.algorithms.profile_model.gaussian_rs import transform
from dials.algorithms.profile_model.gaussian_rs import BBoxCalculator3D
from math import pi
# Load the sweep
self.sweep = load.sweep(filename)
# Get the models
self.beam = self.sweep.get_beam()
self.detector = self.sweep.get_detector()
self.gonio = self.sweep.get_goniometer()
self.scan = self.sweep.get_scan()
self.scan.set_image_range((0, 1000))
# self.beam.set_direction((0.0, 0.0, 1.0))
# self.gonio.set_rotation_axis((1.0, 0.0, 0.0))
# self.detector.set_frame((1.0, 0.0, 0.0),
# (0.0, 1.0, 0.0),
# (-150, -150, -200))
# Set some parameters
self.sigma_divergence = self.beam.get_sigma_divergence(deg=False)
self.mosaicity = 0.157 * pi / 180
self.n_sigma = 3
self.grid_size = 20
self.delta_divergence = self.n_sigma * self.sigma_divergence
step_size = self.delta_divergence / self.grid_size
self.delta_divergence2 = self.delta_divergence + step_size * 0.5
self.delta_mosaicity = self.n_sigma * self.mosaicity
# Create the bounding box calculator
self.calculate_bbox = BBoxCalculator3D(self.beam, self.detector,
self.gonio, self.scan,
self.delta_divergence2,
self.delta_mosaicity)
# Initialise the transform
self.spec = transform.TransformSpec(self.beam, self.detector,
self.gonio, self.scan,
self.sigma_divergence,
self.mosaicity, self.n_sigma + 1,
self.grid_size)
class Test(object):
def __init__(self):
from dials.algorithms.profile_model.gaussian_rs import BBoxCalculator3D
from dials.model.serialize import load
from math import pi
import libtbx.load_env
try:
dials_regression = libtbx.env.dist_path('dials_regression')
except KeyError, e:
print 'FAIL: dials_regression not configured'
exit(0)
import os
filename = os.path.join(dials_regression, 'centroid_test_data',
'sweep.json')
sweep = load.sweep(filename)
# Get the models
self.beam = sweep.get_beam()
self.detector = sweep.get_detector()
self.gonio = sweep.get_goniometer()
self.scan = sweep.get_scan()
# Set the delta_divergence/mosaicity
self.n_sigma = 5
self.sigma_divergence = 0.060 * pi / 180
self.mosaicity = 0.154 * pi / 180
self.delta_divergence = self.n_sigma * self.sigma_divergence
self.delta_mosaicity = self.n_sigma * self.mosaicity
# Create the bounding box calculator
self.calculate_bbox = BBoxCalculator3D(self.beam, self.detector,
self.gonio, self.scan,
self.delta_divergence,
self.delta_mosaicity)
def test_forward(dials_data):
sequence = load.imageset(
dials_data("centroid_test_data").join("sweep.json").strpath)
# Get the models
beam = sequence.get_beam()
detector = sequence.get_detector()
gonio = sequence.get_goniometer()
scan = sequence.get_scan()
# Set some parameters
sigma_divergence = beam.get_sigma_divergence(deg=False)
mosaicity = 0.157 * math.pi / 180
n_sigma = 3
grid_size = 7
delta_divergence = n_sigma * sigma_divergence
step_size = delta_divergence / grid_size
delta_divergence2 = delta_divergence + step_size * 0.5
delta_mosaicity = n_sigma * mosaicity
# Create the bounding box calculator
calculate_bbox = BBoxCalculator3D(beam, detector, gonio, scan,
delta_divergence2, delta_mosaicity)
# Initialise the transform
spec = transform.TransformSpec(beam, detector, gonio, scan,
sigma_divergence, mosaicity, n_sigma + 1,
grid_size)
# tst_conservation_of_counts(self):
assert len(detector) == 1
s0 = beam.get_s0()
m2 = gonio.get_rotation_axis()
s0_length = matrix.col(beam.get_s0()).length()
# Create an s1 map
s1_map = transform.beam_vector_map(detector[0], beam, True)
for i in range(100):
# Get random x, y, z
x = random.uniform(300, 1800)
y = random.uniform(300, 1800)
z = random.uniform(0, 9)
# Get random s1, phi, panel
s1 = matrix.col(detector[0].get_pixel_lab_coord(
(x, y))).normalize() * s0_length
phi = scan.get_angle_from_array_index(z, deg=False)
panel = 0
# Calculate the bounding box
bbox = calculate_bbox(s1, z, panel)
x0, x1, y0, y1, z0, z1 = bbox
# Create the coordinate system
cs = CoordinateSystem(m2, s0, s1, phi)
# The grid index generator
step_size = delta_divergence / grid_size
grid_index = transform.GridIndexGenerator(cs, x0, y0,
(step_size, step_size),
grid_size, s1_map)
# Create the image
# image = flex.double(flex.grid(z1 - z0, y1 - y0, x1 - x0), 1)
image = gaussian((z1 - z0, y1 - y0, x1 - x0), 10.0,
(z - z0, y - y0, x - x0), (2.0, 2.0, 2.0))
mask = flex.bool(flex.grid(image.all()), False)
for j in range(y1 - y0):
for i in range(x1 - x0):
inside = False
gx00, gy00 = grid_index(j, i)
gx01, gy01 = grid_index(j, i + 1)
gx10, gy10 = grid_index(j + 1, i)
gx11, gy11 = grid_index(j + 1, i + 1)
mingx = min([gx00, gx01, gx10, gx11])
maxgx = max([gx00, gx01, gx10, gx11])
mingy = min([gy00, gy01, gy10, gy11])
maxgy = max([gy00, gy01, gy10, gy11])
if (mingx >= 0 and maxgx < 2 * grid_size + 1 and mingy >= 0
and maxgy < 2 * grid_size + 1):
inside = True
for k in range(1, z1 - z0 - 1):
mask[k, j, i] = inside
# Transform the image to the grid
transformed = transform.TransformForward(spec, cs, bbox, 0,
image.as_double(), mask)
grid = transformed.profile()
# Get the sums and ensure they're the same
eps = 1e-7
sum_grid = flex.sum(grid)
sum_image = flex.sum(flex.double(flex.select(image, flags=mask)))
assert abs(sum_grid - sum_image) <= eps
# Test passed
# tst_transform_with_background(self):
assert len(detector) == 1
s0 = beam.get_s0()
m2 = gonio.get_rotation_axis()
s0_length = matrix.col(beam.get_s0()).length()
# Create an s1 map
s1_map = transform.beam_vector_map(detector[0], beam, True)
for i in range(100):
# Get random x, y, z
x = random.uniform(300, 1800)
y = random.uniform(300, 1800)
z = random.uniform(0, 9)
# Get random s1, phi, panel
s1 = matrix.col(detector[0].get_pixel_lab_coord(
(x, y))).normalize() * s0_length
phi = scan.get_angle_from_array_index(z, deg=False)
panel = 0
# Calculate the bounding box
bbox = calculate_bbox(s1, z, panel)
x0, x1, y0, y1, z0, z1 = bbox
# Create the coordinate system
cs = CoordinateSystem(m2, s0, s1, phi)
# The grid index generator
step_size = delta_divergence / grid_size
grid_index = transform.GridIndexGenerator(cs, x0, y0,
(step_size, step_size),
grid_size, s1_map)
# Create the image
# image = flex.double(flex.grid(z1 - z0, y1 - y0, x1 - x0), 1)
image = gaussian((z1 - z0, y1 - y0, x1 - x0), 10.0,
(z - z0, y - y0, x - x0), (2.0, 2.0, 2.0))
background = flex.random_double(len(image))
background.resize(image.accessor())
mask = flex.bool(flex.grid(image.all()), False)
for j in range(y1 - y0):
for i in range(x1 - x0):
inside = False
gx00, gy00 = grid_index(j, i)
gx01, gy01 = grid_index(j, i + 1)
gx10, gy10 = grid_index(j + 1, i)
gx11, gy11 = grid_index(j + 1, i + 1)
mingx = min([gx00, gx01, gx10, gx11])
maxgx = max([gx00, gx01, gx10, gx11])
mingy = min([gy00, gy01, gy10, gy11])
maxgy = max([gy00, gy01, gy10, gy11])
if (mingx >= 0 and maxgx <= 2 * grid_size + 1 and mingy >= 0
and maxgy <= 2 * grid_size + 1):
inside = True
for k in range(1, z1 - z0 - 1):
mask[k, j, i] = inside
# Transform the image to the grid
transformed = transform.TransformForward(spec, cs, bbox, 0,
image.as_double(),
background.as_double(), mask)
igrid = transformed.profile()
bgrid = transformed.background()
# Get the sums and ensure they're the same
eps = 1e-7
sum_igrid = flex.sum(igrid)
sum_bgrid = flex.sum(bgrid)
sum_image = flex.sum(flex.double(flex.select(image, flags=mask)))
sum_bkgrd = flex.sum(flex.double(flex.select(background, flags=mask)))
try:
assert abs(sum_igrid - sum_image) <= eps
assert abs(sum_bgrid - sum_bkgrd) <= eps
except Exception:
print("Failed for: ", (x, y, z))
raise
def test_forward_no_model(dials_data):
sequence = load.imageset(
dials_data("centroid_test_data").join("sweep.json").strpath)
# Get the models
beam = sequence.get_beam()
detector = sequence.get_detector()
gonio = sequence.get_goniometer()
scan = sequence.get_scan()
scan.set_image_range((0, 1000))
# Set some parameters
sigma_divergence = beam.get_sigma_divergence(deg=False)
mosaicity = 0.157 * math.pi / 180
n_sigma = 3
grid_size = 20
delta_divergence = n_sigma * sigma_divergence
step_size = delta_divergence / grid_size
delta_divergence2 = delta_divergence + step_size * 0.5
delta_mosaicity = n_sigma * mosaicity
# Create the bounding box calculator
calculate_bbox = BBoxCalculator3D(beam, detector, gonio, scan,
delta_divergence2, delta_mosaicity)
# Initialise the transform
spec = transform.TransformSpec(beam, detector, gonio, scan,
sigma_divergence, mosaicity, n_sigma + 1,
grid_size)
# tst_conservation_of_counts(self):
random.seed(0)
assert len(detector) == 1
s0 = beam.get_s0()
m2 = gonio.get_rotation_axis()
s0_length = matrix.col(beam.get_s0()).length()
# Create an s1 map
s1_map = transform.beam_vector_map(detector[0], beam, True)
for i in range(100):
# Get random x, y, z
x = random.uniform(300, 1800)
y = random.uniform(300, 1800)
z = random.uniform(500, 600)
# Get random s1, phi, panel
s1 = matrix.col(detector[0].get_pixel_lab_coord(
(x, y))).normalize() * s0_length
phi = scan.get_angle_from_array_index(z, deg=False)
panel = 0
# Calculate the bounding box
bbox = calculate_bbox(s1, z, panel)
x0, x1, y0, y1, z0, z1 = bbox
# Create the coordinate system
cs = CoordinateSystem(m2, s0, s1, phi)
if abs(cs.zeta()) < 0.1:
continue
# The grid index generator
step_size = delta_divergence / grid_size
grid_index = transform.GridIndexGenerator(cs, x0, y0,
(step_size, step_size),
grid_size, s1_map)
# Create the image
# image = flex.double(flex.grid(z1 - z0, y1 - y0, x1 - x0), 1)
image = gaussian((z1 - z0, y1 - y0, x1 - x0), 10.0,
(z - z0, y - y0, x - x0), (2.0, 2.0, 2.0))
mask = flex.bool(flex.grid(image.all()), False)
for j in range(y1 - y0):
for i in range(x1 - x0):
inside = False
gx00, gy00 = grid_index(j, i)
gx01, gy01 = grid_index(j, i + 1)
gx10, gy10 = grid_index(j + 1, i)
gx11, gy11 = grid_index(j + 1, i + 1)
mingx = min([gx00, gx01, gx10, gx11])
maxgx = max([gx00, gx01, gx10, gx11])
mingy = min([gy00, gy01, gy10, gy11])
maxgy = max([gy00, gy01, gy10, gy11])
if (mingx >= 0 and maxgx < 2 * grid_size + 1 and mingy >= 0
and maxgy < 2 * grid_size + 1):
inside = True
for k in range(1, z1 - z0 - 1):
mask[k, j, i] = inside
# Transform the image to the grid
transformed = transform.TransformForwardNoModel(
spec, cs, bbox, 0, image.as_double(), mask)
grid = transformed.profile()
# Get the sums and ensure they're the same
eps = 1e-7
sum_grid = flex.sum(grid)
sum_image = flex.sum(flex.double(flex.select(image, flags=mask)))
assert abs(sum_grid - sum_image) <= eps
mask = flex.bool(flex.grid(image.all()), True)
transformed = transform.TransformForwardNoModel(
spec, cs, bbox, 0, image.as_double(), mask)
grid = transformed.profile()
# Boost the bbox to make sure all intensity is included
x0, x1, y0, y1, z0, z1 = bbox
bbox2 = (x0 - 10, x1 + 10, y0 - 10, y1 + 10, z0 - 10, z1 + 10)
# Do the reverse transform
transformed = transform.TransformReverseNoModel(
spec, cs, bbox2, 0, grid)
image2 = transformed.profile()
# Check the sum of pixels are the same
sum_grid = flex.sum(grid)
sum_image = flex.sum(image2)
assert abs(sum_grid - sum_image) <= eps
# Do the reverse transform
transformed = transform.TransformReverseNoModel(
spec, cs, bbox, 0, grid)
image2 = transformed.profile()
from dials.algorithms.statistics import pearson_correlation_coefficient
cc = pearson_correlation_coefficient(image.as_1d().as_double(),
image2.as_1d())
assert cc >= 0.99
def test_map_forward_reverse(dials_data):
sequence = load.imageset(
dials_data("centroid_test_data").join("sweep.json").strpath)
# Get the models
beam = sequence.get_beam()
detector = sequence.get_detector()
gonio = sequence.get_goniometer()
scan = sequence.get_scan()
# Set the delta_divergence/mosaicity
n_sigma = 3
sigma_divergence = 0.060 * math.pi / 180
mosaicity = 0.154 * math.pi / 180
delta_divergence = n_sigma * sigma_divergence
delta_mosaicity = n_sigma * mosaicity
# Set the grid size
grid_size = (4, 4, 4)
# Create the E3 fraction object
transform_forward = MapFramesForward(
scan.get_array_range()[0],
scan.get_oscillation(deg=False)[0],
scan.get_oscillation(deg=False)[1],
mosaicity,
n_sigma,
grid_size[2],
)
# Create the E3 fraction object
transform_reverse = MapFramesReverse(
scan.get_array_range()[0],
scan.get_oscillation(deg=False)[0],
scan.get_oscillation(deg=False)[1],
mosaicity,
n_sigma,
grid_size[2],
)
# Create the bounding box calculator
calculate_bbox = BBoxCalculator3D(beam, detector, gonio, scan,
delta_divergence, delta_mosaicity)
s0 = beam.get_s0()
m2 = gonio.get_rotation_axis()
s0_length = matrix.col(beam.get_s0()).length()
for i in range(100):
# Get random x, y, z
x = random.uniform(0, 2000)
y = random.uniform(0, 2000)
z = random.uniform(0, 9)
# Get random s1, phi, panel
s1 = matrix.col(detector[0].get_pixel_lab_coord(
(x, y))).normalize() * s0_length
phi = scan.get_angle_from_array_index(z, deg=False)
panel = 0
# Calculate the bounding box
bbox = calculate_bbox(s1, phi, panel)
# Create the XDS coordinate system
xcs = CoordinateSystem(m2, s0, s1, phi)
# Calculate the transform fraction
forward_fraction = transform_forward(bbox[4:], phi, xcs.zeta())
# Calculate the transform fraction
reverse_fraction = transform_reverse(bbox[4:], phi, xcs.zeta())
# Check the same points are non-zero
eps = 1e-7
for j in range(forward_fraction.all()[0]):
for i in range(forward_fraction.all()[1]):
if forward_fraction[j, i] > 0.0:
assert reverse_fraction[i, j] > 0.0
else:
assert reverse_fraction[i, j] < eps
def test_map_frames_forward(dials_data):
sequence = load.imageset(
dials_data("centroid_test_data").join("sweep.json").strpath)
# Get the models
beam = sequence.get_beam()
detector = sequence.get_detector()
gonio = sequence.get_goniometer()
scan = sequence.get_scan()
# Set the delta_divergence/mosaicity
n_sigma = 3
sigma_divergence = 0.060 * math.pi / 180
mosaicity = 0.154 * math.pi / 180
delta_divergence = n_sigma * sigma_divergence
delta_mosaicity = n_sigma * mosaicity
# Set the grid size
grid_size = (4, 4, 4)
# Create the E3 fraction object
transform = MapFramesForward(
scan.get_array_range()[0],
scan.get_oscillation(deg=False)[0],
scan.get_oscillation(deg=False)[1],
mosaicity,
n_sigma,
grid_size[2],
)
# Create the bounding box calculator
calculate_bbox = BBoxCalculator3D(beam, detector, gonio, scan,
delta_divergence, delta_mosaicity)
assert len(detector) == 1
s0 = beam.get_s0()
m2 = gonio.get_rotation_axis()
s0_length = matrix.col(beam.get_s0()).length()
for i in range(100):
# Get random x, y, z
x = random.uniform(0, 2000)
y = random.uniform(0, 2000)
z = random.uniform(0, 9)
# Get random s1, phi, panel
s1 = matrix.col(detector[0].get_pixel_lab_coord(
(x, y))).normalize() * s0_length
phi = scan.get_angle_from_array_index(z, deg=False)
panel = 0
# Calculate the bounding box
bbox = calculate_bbox(s1, z, panel)
# Create the XDS coordinate system
xcs = CoordinateSystem(m2, s0, s1, phi)
# Calculate the transform fraction
fraction = transform(bbox[4:], phi, xcs.zeta())
# Ensure the minimum and maximum are 0 < 1
fmax = flex.max(fraction)
fmin = flex.min(fraction)
assert fmax <= (
1.0 + 5e-15) and fmax > 0.0, f"{fmax:.16f} not between 0 and 1"
assert fmin >= 0.0 and fmin <= 1.0
# Ensure the fraction for each image frame adds up to 1.0 for
# all those frames completely within the grid
for j in range(1, fraction.all()[0] - 1):
tot = flex.sum(fraction[j:j + 1, :])
assert abs(tot - 1.0) < 1e-7
# Ensure the frames follow a progression through the grid. I.e,
# check that values increase then decrease and don't jump around
for j in range(fraction.all()[0]):
f = fraction[j:j + 1, :]
last = f[0]
rev = False
for i in range(1, len(f)):
curr = f[1]
if rev is False:
if curr < last:
rev = True
else:
assert curr <= last
last = curr
def test_forward_panel_edge(dials_data):
expt = ExperimentList.from_file(
dials_data("centroid_test_data").join(
"imported_experiments.json").strpath)[0]
# Get the models
beam = expt.beam
detector = expt.detector
gonio = expt.goniometer
scan = expt.scan
# Set some parameters
sigma_divergence = 0.00101229
mosaicity = 0.157 * math.pi / 180
n_sigma = 3
grid_size = 7
delta_divergence = n_sigma * sigma_divergence
step_size = delta_divergence / grid_size
delta_divergence2 = delta_divergence + step_size * 0.5
delta_mosaicity = n_sigma * mosaicity
# Create the bounding box calculator
calculate_bbox = BBoxCalculator3D(beam, detector, gonio, scan,
delta_divergence2, delta_mosaicity)
# Initialise the transform
spec = transform.TransformSpec(beam, detector, gonio, scan,
sigma_divergence, mosaicity, n_sigma + 1,
grid_size)
assert len(detector) == 1
s0 = beam.get_s0()
m2 = gonio.get_rotation_axis()
s0_length = matrix.col(beam.get_s0()).length()
image_size = detector[0].get_image_size()
refl_xy = [
(0, 0),
(2, 3),
(4, 1000),
(1000, 5),
(image_size[0] - 1, image_size[1] - 1),
(image_size[0] - 2, 1),
(1, image_size[1] - 5),
(1000, image_size[1] - 4),
(image_size[0] - 3, 1000),
]
for x, y in refl_xy:
z = random.uniform(0, 9)
# Get random s1, phi, panel
s1 = matrix.col(detector[0].get_pixel_lab_coord(
(x, y))).normalize() * s0_length
phi = scan.get_angle_from_array_index(z, deg=False)
panel = 0
# Calculate the bounding box
bbox = calculate_bbox(s1, z, panel)
x0, x1, y0, y1, z0, z1 = bbox
# Create the coordinate system
cs = CoordinateSystem(m2, s0, s1, phi)
# Create the image
image = gaussian((z1 - z0, y1 - y0, x1 - x0), 10.0,
(z - z0, y - y0, x - x0), (2.0, 2.0, 2.0))
# Mask for the foreground pixels
refl_mask = image > 1e-3
bg = flex.double(image.accessor())
# Shoebox mask, i.e. mask out pixels that are outside the panel bounds
shoebox_mask = flex.bool(image.accessor(), False)
for j in range(y1 - y0):
for i in range(x1 - x0):
if (j + y0 >= 0 and j + y0 < image_size[1] and i + x0 >= 0
and i + x0 < image_size[0]):
for k in range(z1 - z0):
shoebox_mask[k, j, i] = True
mask = refl_mask & shoebox_mask
# from matplotlib import pyplot as plt
# fig, axes = plt.subplots(ncols=refl_mask.focus()[0], nrows=4)
# for i in range(refl_mask.focus()[0]):
# axes[0, i].imshow(image.as_numpy_array()[i])
# axes[1, i].imshow(refl_mask.as_numpy_array()[i])
# axes[2, i].imshow(shoebox_mask.as_numpy_array()[i])
# axes[3, i].imshow(mask.as_numpy_array()[i])
# plt.show()
# Transform the image to the grid
transformed = transform.TransformForward(spec, cs, bbox, 0,
image.as_double(), bg,
refl_mask)
grid = transformed.profile()
mask = refl_mask & shoebox_mask
# assert only pixels within the panel were transformed
assert flex.sum(grid) == pytest.approx(flex.sum(
image.select(mask.as_1d())),
rel=0.01)
# The total transformed counts should be less than the (unmasked) image counts
assert flex.sum(grid) < flex.sum(image)
# Transform the image to the grid, this time without a background
transformed = transform.TransformForward(spec, cs, bbox, 0,
image.as_double(), refl_mask)
grid = transformed.profile()
mask = refl_mask & shoebox_mask
# assert only pixels within the panel were transformed
assert flex.sum(grid) == pytest.approx(flex.sum(
image.select(mask.as_1d())),
rel=0.01)
# The total transformed counts should be less than the (unmasked) image counts
assert flex.sum(grid) < flex.sum(image)
def test_forward(dials_data):
from dials.model.serialize import load
from dials.algorithms.profile_model.gaussian_rs import transform
from dials.algorithms.profile_model.gaussian_rs import BBoxCalculator3D
sweep = load.sweep(
dials_data("centroid_test_data").join("sweep.json").strpath)
# Get the models
beam = sweep.get_beam()
detector = sweep.get_detector()
gonio = sweep.get_goniometer()
scan = sweep.get_scan()
# beam.set_direction((0.0, 0.0, 1.0))
# gonio.set_rotation_axis((1.0, 0.0, 0.0))
# detector.set_frame((1.0, 0.0, 0.0),
# (0.0, 1.0, 0.0),
# (-150, -150, -200))
# Set some parameters
sigma_divergence = beam.get_sigma_divergence(deg=False)
mosaicity = 0.157 * math.pi / 180
n_sigma = 3
grid_size = 7
delta_divergence = n_sigma * sigma_divergence
step_size = delta_divergence / grid_size
delta_divergence2 = delta_divergence + step_size * 0.5
delta_mosaicity = n_sigma * mosaicity
# Create the bounding box calculator
calculate_bbox = BBoxCalculator3D(beam, detector, gonio, scan,
delta_divergence2, delta_mosaicity)
# Initialise the transform
spec = transform.TransformSpec(beam, detector, gonio, scan,
sigma_divergence, mosaicity, n_sigma + 1,
grid_size)
# tst_conservation_of_counts(self):
from scitbx import matrix
from dials.algorithms.profile_model.gaussian_rs import CoordinateSystem
from dials.algorithms.profile_model.gaussian_rs import transform
from scitbx.array_family import flex
assert len(detector) == 1
s0 = beam.get_s0()
m2 = gonio.get_rotation_axis()
s0_length = matrix.col(beam.get_s0()).length()
# Create an s1 map
s1_map = transform.beam_vector_map(detector[0], beam, True)
for i in range(100):
# Get random x, y, z
x = random.uniform(300, 1800)
y = random.uniform(300, 1800)
z = random.uniform(0, 9)
# Get random s1, phi, panel
s1 = matrix.col(detector[0].get_pixel_lab_coord(
(x, y))).normalize() * s0_length
phi = scan.get_angle_from_array_index(z, deg=False)
panel = 0
# Calculate the bounding box
bbox = calculate_bbox(s1, z, panel)
x0, x1, y0, y1, z0, z1 = bbox
# Create the coordinate system
cs = CoordinateSystem(m2, s0, s1, phi)
# The grid index generator
step_size = delta_divergence / grid_size
grid_index = transform.GridIndexGenerator(cs, x0, y0,
(step_size, step_size),
grid_size, s1_map)
# Create the image
# image = flex.double(flex.grid(z1 - z0, y1 - y0, x1 - x0), 1)
image = gaussian((z1 - z0, y1 - y0, x1 - x0), 10.0,
(z - z0, y - y0, x - x0), (2.0, 2.0, 2.0))
mask = flex.bool(flex.grid(image.all()), False)
for j in range(y1 - y0):
for i in range(x1 - x0):
inside = False
gx00, gy00 = grid_index(j, i)
gx01, gy01 = grid_index(j, i + 1)
gx10, gy10 = grid_index(j + 1, i)
gx11, gy11 = grid_index(j + 1, i + 1)
mingx = min([gx00, gx01, gx10, gx11])
maxgx = max([gx00, gx01, gx10, gx11])
mingy = min([gy00, gy01, gy10, gy11])
maxgy = max([gy00, gy01, gy10, gy11])
if (mingx >= 0 and maxgx < 2 * grid_size + 1 and mingy >= 0
and maxgy < 2 * grid_size + 1):
inside = True
for k in range(1, z1 - z0 - 1):
mask[k, j, i] = inside
# Transform the image to the grid
transformed = transform.TransformForward(spec, cs, bbox, 0,
image.as_double(), mask)
grid = transformed.profile()
# Get the sums and ensure they're the same
eps = 1e-7
sum_grid = flex.sum(grid)
sum_image = flex.sum(flex.double(flex.select(image, flags=mask)))
assert abs(sum_grid - sum_image) <= eps
# Test passed
# def tst_transformed_centroid(self):
# from scitbx import matrix
# from random import uniform
# from dials.algorithms.profile_model.gaussian_rs import CoordinateSystem
# from dials.algorithms.profile_model.gaussian_rs import transform
# from scitbx.array_family import flex
# from time import time
# s0 = beam.get_s0()
# m2 = gonio.get_rotation_axis()
# s0_length = matrix.col(beam.get_s0()).length()
# # Create an s1 map
# s1_map = transform.beam_vector_map(detector, beam, True)
# # Get random x, y, z
# x = random.uniform(300, 1800)
# y = random.uniform(300, 1800)
# z = random.uniform(-10, 0)
# # Get random s1, phi, panel
# s1 = matrix.col(detector.get_pixel_lab_coord(
# (x, y))).normalize() * s0_length
# phi = scan.get_angle_from_array_index(z, deg=False)
# panel = 0
# # Calculate the bounding box
# bbox = calculate_bbox(s1, z, panel)
# x0, x1, y0, y1, z0, z1 = bbox
# # Create the coordinate system
# cs = CoordinateSystem(m2, s0, s1, phi)
# # The grid index generator
# step_size = delta_divergence / grid_size
# grid_index = transform.GridIndexGenerator(cs, x0, y0,
# (step_size, step_size), grid_size, s1_map)
# # Create the image
# image = gaussian((z1 - z0, y1 - y0, x1 - x0), 10.0,
# (z - z0, y - y0, x - x0), (2.0, 2.0, 2.0))
# print x, y, z, bbox
# print (z1 - z0, y1 - y0, x1 - x0), (z - z0, y - y0, x - x0)
# mask = flex.bool(flex.grid(image.all()), False)
# for j in range(y1 - y0):
# for i in range(x1 - x0):
# inside = False
# gx00, gy00 = grid_index(j, i)
# gx01, gy01 = grid_index(j, i+1)
# gx10, gy10 = grid_index(j+1, i)
# gx11, gy11 = grid_index(j+1, i+1)
# mingx = min([gx00, gx01, gx10, gx11])
# maxgx = max([gx00, gx01, gx10, gx11])
# mingy = min([gy00, gy01, gy10, gy11])
# maxgy = max([gy00, gy01, gy10, gy11])
# if (mingx >= 0 and maxgx <= 2 * grid_size + 1 and
# mingy >= 0 and maxgy <= 2 * grid_size + 1):
# inside = True
# for k in range(1, z1 - z0 - 1):
# mask[k,j,i] = inside
# #image[k,j,i] *= inside
# from matplotlib import pylab
# pylab.imshow(image.as_numpy_array()[(z1 - z0) / 2,:,:], interpolation='none')
# pylab.show()
# # Transform the image to the grid
# grid = transform(cs, bbox, image, mask)
# from matplotlib import pylab
# pylab.imshow(grid.as_numpy_array()[7,:,:], interpolation='none')
# pylab.show()
# # Get the sums and ensure they're the same
# eps = 1e-7
# sum_grid = flex.sum(grid)
# sum_image = flex.sum(flex.double(flex.select(image, flags=mask)))
# assert(abs(sum_grid - sum_image) <= eps)
# # Check the centroid
# sz = grid_size * 2 + 1
# grid_x = flex.double(flex.grid(sz, sz, sz))
# grid_y = flex.double(flex.grid(sz, sz, sz))
# grid_z = flex.double(flex.grid(sz, sz, sz))
# for k in range(sz):
# for j in range(sz):
# for i in range(sz):
# grid_x[k,j,i] = i + 0.5
# grid_y[k,j,i] = j + 0.5
# grid_z[k,j,i] = k + 0.5
#
# sum_grid_x = flex.sum(grid * grid_x)
# sum_grid_y = flex.sum(grid * grid_y)
# sum_grid_z = flex.sum(grid * grid_z)
# xc = sum_grid_x / sum_grid
# yc = sum_grid_y / sum_grid
# zc = sum_grid_z / sum_grid
# print xc, yc, zc
# assert(abs(xc - grid_size + 0.5) <= 0.5)
# assert(abs(yc - grid_size + 0.5) <= 0.5)
# assert(abs(zc - grid_size + 0.5) <= 0.5)
# # Test passed
# print 'OK'
# tst_transform_with_background(self):
from scitbx import matrix
from dials.algorithms.profile_model.gaussian_rs import CoordinateSystem
from dials.algorithms.profile_model.gaussian_rs import transform
from scitbx.array_family import flex
assert len(detector) == 1
s0 = beam.get_s0()
m2 = gonio.get_rotation_axis()
s0_length = matrix.col(beam.get_s0()).length()
# Create an s1 map
s1_map = transform.beam_vector_map(detector[0], beam, True)
for i in range(100):
# Get random x, y, z
x = random.uniform(300, 1800)
y = random.uniform(300, 1800)
z = random.uniform(0, 9)
# Get random s1, phi, panel
s1 = matrix.col(detector[0].get_pixel_lab_coord(
(x, y))).normalize() * s0_length
phi = scan.get_angle_from_array_index(z, deg=False)
panel = 0
# Calculate the bounding box
bbox = calculate_bbox(s1, z, panel)
x0, x1, y0, y1, z0, z1 = bbox
# Create the coordinate system
cs = CoordinateSystem(m2, s0, s1, phi)
# The grid index generator
step_size = delta_divergence / grid_size
grid_index = transform.GridIndexGenerator(cs, x0, y0,
(step_size, step_size),
grid_size, s1_map)
# Create the image
# image = flex.double(flex.grid(z1 - z0, y1 - y0, x1 - x0), 1)
image = gaussian((z1 - z0, y1 - y0, x1 - x0), 10.0,
(z - z0, y - y0, x - x0), (2.0, 2.0, 2.0))
background = flex.random_double(len(image))
background.resize(image.accessor())
mask = flex.bool(flex.grid(image.all()), False)
for j in range(y1 - y0):
for i in range(x1 - x0):
inside = False
gx00, gy00 = grid_index(j, i)
gx01, gy01 = grid_index(j, i + 1)
gx10, gy10 = grid_index(j + 1, i)
gx11, gy11 = grid_index(j + 1, i + 1)
mingx = min([gx00, gx01, gx10, gx11])
maxgx = max([gx00, gx01, gx10, gx11])
mingy = min([gy00, gy01, gy10, gy11])
maxgy = max([gy00, gy01, gy10, gy11])
if (mingx >= 0 and maxgx <= 2 * grid_size + 1 and mingy >= 0
and maxgy <= 2 * grid_size + 1):
inside = True
for k in range(1, z1 - z0 - 1):
mask[k, j, i] = inside
# Transform the image to the grid
transformed = transform.TransformForward(spec, cs, bbox, 0,
image.as_double(),
background.as_double(), mask)
igrid = transformed.profile()
bgrid = transformed.background()
# Get the sums and ensure they're the same
eps = 1e-7
sum_igrid = flex.sum(igrid)
sum_bgrid = flex.sum(bgrid)
sum_image = flex.sum(flex.double(flex.select(image, flags=mask)))
sum_bkgrd = flex.sum(flex.double(flex.select(background, flags=mask)))
try:
assert abs(sum_igrid - sum_image) <= eps
assert abs(sum_bgrid - sum_bkgrd) <= eps
except Exception:
print("Failed for: ", (x, y, z))
raise
def test_map_frames_reverse(dials_data):
from dials.model.serialize import load
from dials.algorithms.profile_model.gaussian_rs.transform import MapFramesReverse
from dials.algorithms.profile_model.gaussian_rs import BBoxCalculator3D
sequence = load.sequence(
dials_data("centroid_test_data").join("sweep.json").strpath)
# Get the models
beam = sequence.get_beam()
detector = sequence.get_detector()
gonio = sequence.get_goniometer()
scan = sequence.get_scan()
# Set the delta_divergence/mosaicity
n_sigma = 3
sigma_divergence = 0.060 * math.pi / 180
mosaicity = 0.154 * math.pi / 180
delta_divergence = n_sigma * sigma_divergence
delta_mosaicity = n_sigma * mosaicity
# Set the grid size
grid_size = (4, 4, 4)
# Create the E3 fraction object
transform = MapFramesReverse(
scan.get_array_range()[0],
scan.get_oscillation(deg=False)[0],
scan.get_oscillation(deg=False)[1],
mosaicity,
n_sigma,
grid_size[2],
)
# Create the bounding box calculator
calculate_bbox = BBoxCalculator3D(beam, detector, gonio, scan,
delta_divergence, delta_mosaicity)
from dials.algorithms.profile_model.gaussian_rs import CoordinateSystem
from scitbx.array_family import flex
s0 = beam.get_s0()
m2 = gonio.get_rotation_axis()
s0_length = matrix.col(beam.get_s0()).length()
for i in range(100):
# Get random x, y, z
x = random.uniform(0, 2000)
y = random.uniform(0, 2000)
z = random.uniform(0, 9)
# Get random s1, phi, panel
s1 = matrix.col(detector[0].get_pixel_lab_coord(
(x, y))).normalize() * s0_length
phi = scan.get_angle_from_array_index(z, deg=False)
panel = 0
# Calculate the bounding box
bbox = calculate_bbox(s1, phi, panel)
x1, x2 = bbox[0], bbox[1]
y1, y2 = bbox[2], bbox[3]
z1, z2 = bbox[4], bbox[5]
if x1 == 0 or y1 == 0 or z1 == 0:
continue
if x2 == 2000 or y2 == 2000 or z2 == 9:
continue
# Create the XDS coordinate system
xcs = CoordinateSystem(m2, s0, s1, phi)
# Calculate the transform fraction
fraction = transform(bbox[4:], phi, xcs.zeta())
# Ensure the minimum and maximum are 0 < 1
fmax = flex.max(fraction)
fmin = flex.min(fraction)
assert fmax <= 1.0 and fmax > 0.0
assert fmin >= 0.0 and fmin <= 1.0
# Ensure the fraction for image adds up to 1.0 for
# all those images completely within the image
for v3 in range(fraction.all()[0]):
tot = flex.sum(fraction[v3:v3 + 1, :])
assert abs(tot - 1.0) < 1e-7
# Ensure the frames follow a progression through the grid. I.e,
# check that values increase then decrease and don't jump around
for v3 in range(fraction.all()[0]):
f = fraction[v3:v3 + 1, :]
last = f[0]
rev = False
for i in range(1, len(f)):
curr = f[1]
if rev is False:
if curr < last:
rev = True
else:
assert curr <= last
last = curr
