def test_openmp_locks():
static = []
moving = []
pts = 20
for i in range(1000):
s = np.random.rand(pts, 3)
static.append(s)
moving.append(s + 2)
moving = moving[2:]
points, offsets = unlist_streamlines(static)
points2, offsets2 = unlist_streamlines(moving)
D = np.zeros((len(offsets), len(offsets2)), dtype='f8')
_bundle_minimum_distance_matrix(points, points2, len(offsets),
len(offsets2), pts, D)
dist1 = 0.25 * (np.sum(np.min(D, axis=0)) / float(D.shape[1]) +
np.sum(np.min(D, axis=1)) / float(D.shape[0]))**2
dist2 = _bundle_minimum_distance(points, points2, len(offsets),
len(offsets2), pts)
assert_almost_equal(dist1, dist2, 6)
def test_openmp_locks():
static = []
moving = []
pts = 20
for i in range(1000):
s = np.random.rand(pts, 3)
static.append(s)
moving.append(s + 2)
moving = moving[2:]
points, offsets = unlist_streamlines(static)
points2, offsets2 = unlist_streamlines(moving)
D = np.zeros((len(offsets), len(offsets2)), dtype='f8')
_bundle_minimum_distance_matrix(points, points2,
len(offsets), len(offsets2),
pts, D)
dist1 = 0.25 * (np.sum(np.min(D, axis=0)) / float(D.shape[1]) +
np.sum(np.min(D, axis=1)) / float(D.shape[0])) ** 2
dist2 = _bundle_minimum_distance(points, points2,
len(offsets), len(offsets2),
pts)
assert_almost_equal(dist1, dist2, 6)
def bundle_min_distance_fast(t, static, moving, block_size, num_threads):
""" MDF-based pairwise distance optimization function (MIN)
We minimize the distance between moving streamlines as they align
with the static streamlines.
Parameters
-----------
t : array
1D array. t is a vector of affine transformation parameters with
size at least 6.
If the size is 6, t is interpreted as translation + rotation.
If the size is 7, t is interpreted as translation + rotation +
isotropic scaling.
If size is 12, t is interpreted as translation + rotation +
scaling + shearing.
static : array
N*M x 3 array. All the points of the static streamlines. With order of
streamlines intact. Where N is the number of streamlines and M
is the number of points per streamline.
moving : array
K*M x 3 array. All the points of the moving streamlines. With order of
streamlines intact. Where K is the number of streamlines and M
is the number of points per streamline.
block_size : int
Number of points per streamline. All streamlines in static and moving
should have the same number of points M.
num_threads : int
Number of threads. If None (default) then all available threads
will be used.
Returns
-------
cost: float
Notes
-----
This is a faster implementation of ``bundle_min_distance``, which requires
that all the points of each streamline are allocated into an ndarray
(of shape N*M by 3, with N the number of points per streamline and M the
number of streamlines). This can be done by calling
`dipy.tracking.streamlines.unlist_streamlines`.
"""
aff = compose_matrix44(t)
moving = np.dot(aff[:3, :3], moving.T).T + aff[:3, 3]
moving = np.ascontiguousarray(moving, dtype=np.float64)
rows = static.shape[0] // block_size
cols = moving.shape[0] // block_size
return _bundle_minimum_distance(static, moving, rows, cols, block_size,
num_threads)
def bundle_min_distance_fast(t, static, moving, block_size):
""" MDF-based pairwise distance optimization function (MIN)
We minimize the distance between moving streamlines as they align
with the static streamlines.
Parameters
-----------
t : array
1D array. t is a vector of of affine transformation parameters with
size at least 6.
If size is 6, t is interpreted as translation + rotation.
If size is 7, t is interpreted as translation + rotation +
isotropic scaling.
If size is 12, t is interpreted as translation + rotation +
scaling + shearing.
static : array
N*M x 3 array. All the points of the static streamlines. With order of
streamlines intact. Where N is the number of streamlines and M
is the number of points per streamline.
moving : array
K*M x 3 array. All the points of the moving streamlines. With order of
streamlines intact. Where K is the number of streamlines and M
is the number of points per streamline.
block_size : int
Number of points per streamline. All streamlines in static and moving
should have the same number of points M.
Returns
-------
cost: float
Notes
-----
This is a faster implementation of ``bundle_min_distance``, which requires
that all the points of each streamline are allocated into an ndarray
(of shape N*M by 3, with N the number of points per streamline and M the
number of streamlines). This can be done by calling
`dipy.tracking.streamlines.unlist_streamlines`.
"""
aff = compose_matrix44(t)
moving = np.dot(aff[:3, :3], moving.T).T + aff[:3, 3]
moving = np.ascontiguousarray(moving, dtype=np.float64)
rows = static.shape[0] / block_size
cols = moving.shape[0] / block_size
return _bundle_minimum_distance(static, moving,
rows,
cols,
block_size)
def test_efficient_bmd():
a = np.array([[1, 1, 1],
[2, 2, 2],
[3, 3, 3]])
streamlines = [a, a + 2, a + 4]
points, offsets = unlist_streamlines(streamlines)
points = points.astype(np.double)
points2 = points.copy()
D = np.zeros((len(offsets), len(offsets)), dtype='f8')
_bundle_minimum_distance_matrix(points, points2,
len(offsets), len(offsets),
a.shape[0], D)
assert_equal(np.sum(np.diag(D)), 0)
points2 += 2
_bundle_minimum_distance_matrix(points, points2,
len(offsets), len(offsets),
a.shape[0], D)
streamlines2 = relist_streamlines(points2, offsets)
D2 = distance_matrix_mdf(streamlines, streamlines2)
assert_array_almost_equal(D, D2)
cols = D2.shape[1]
rows = D2.shape[0]
dist = 0.25 * (np.sum(np.min(D2, axis=0)) / float(cols) +
np.sum(np.min(D2, axis=1)) / float(rows)) ** 2
dist2 = _bundle_minimum_distance(points, points2,
len(offsets), len(offsets),
a.shape[0])
assert_almost_equal(dist, dist2)