function test_suite = test_external_surfing()
% regression tests for external "surfing" toolbox
%
% # For CoSMoMVPA's copyright information and license terms, #
% # see the COPYING file distributed with CoSMoMVPA. #
try % assignment of 'localfunctions' is necessary in Matlab >= 2016
test_functions = localfunctions();
catch % no problem; early Matlab versions can use initTestSuite fine
end
initTestSuite;
function test_surfing_subsample_surface()
if cosmo_skip_test_if_no_external('surfing')
return
end
opt = struct();
opt.progress = false;
vertices = [0 -1 -2 -1 1 2 1 3 4 3
0 -2 0 2 2 0 -2 2 0 -2
0 0 0 0 0 0 0 0 0 0]';
faces = [1 1 1 1 1 1 5 8 6 6
2 3 4 5 6 7 8 9 9 10
3 4 5 6 7 2 6 6 10 7]';
[v_sub, f_sub] = surfing_subsample_surface(vertices, faces, 1, .2, false);
assertEqual(v_sub', [-1 -2 -1 1 2 1 3 4 3
-2 0 2 2 0 -2 2 0 -2
0 0 0 0 0 0 0 0 0]);
assertEqual(f_sub', [1 1 1 1 4 5 7 5
2 3 4 5 7 9 8 8
3 4 5 6 5 6 5 9]);
[v_sub2, f_sub2] = surfing_subsample_surface(v_sub, f_sub, 1, .2, false);
assertEqual(v_sub2', [-1 -2 -1 1 1 3 4 3
-2 0 2 2 -2 2 0 -2
0 0 0 0 0 0 0 0]);
assertEqual(f_sub2', [1 1 1 4 6 4
2 3 4 8 7 7
3 4 5 5 4 8]);
[v_sub2_alt, f_sub2_alt] = surfing_subsample_surface(vertices, faces, ...
2, .2, false);
assertEqual(v_sub2_alt, v_sub2);
assertEqual(f_sub2_alt, f_sub2);
function test_surfing_generate_planar_surface()
if cosmo_skip_test_if_no_external('surfing')
return
end
if isempty(which('surfing_generate_planar_surface'))
% older versions of surfing
cosmo_notify_test_skipped(['surfing_generate_planar_surface '...
'is not available']);
return
end
nx = round(rand() * 5) + 5;
ny = round(rand() * 5) + 5;
origin = rand(3, 1) * 10;
x1 = rand(3, 1) * 10;
y1 = rand(3, 1) * 10;
[v1, f1] = generate_planar_surface(nx, ny, origin, x1, y1);
[v2, f2] = surfing_generate_planar_surface(nx, ny, origin, x1, y1);
assertElementsAlmostEqual(v1, v2);
assertElementsAlmostEqual(f1, f2);
% test default options
[v1, f1] = generate_planar_surface(nx, ny, [0, 0, 0], [1, 0, 0], [0, 1, 0]);
[v2, f2] = surfing_generate_planar_surface(nx, ny);
assertElementsAlmostEqual(v1, v2);
assertElementsAlmostEqual(f1, f2);
function test_surfing_voxel_selection_dijkstra()
helper_test_surfing_voxel_selection('dijkstra');
function test_surfing_voxel_selection_euclidean()
helper_test_surfing_voxel_selection('euclidean');
function helper_test_surfing_voxel_selection(metric)
if cosmo_skip_test_if_no_external('surfing')
return
end
warning_state = warning();
warning_resetter = onCleanup(@()warning(warning_state));
warning('off', 'all');
nx = round(rand() * 5) + 5;
ny = round(rand() * 5) + 5;
% surface with some nodes outside the volume
[v, f] = generate_planar_surface(nx, ny, [-4, -4, 0], [1, 0, 0], [0, 1, 0]);
thickness = rand() * 2 + 2;
pial = bsxfun(@plus, v, [0, 0, -thickness])';
white = bsxfun(@plus, v, [0, 0, thickness])';
ds = cosmo_synthetic_dataset('size', 'big');
ds_xyz = cosmo_vol_coordinates(ds);
voldef = ds.a.vol;
half_vox_size = voldef.mat(1);
thickness_margin = thickness + half_vox_size;
radius = rand() * 4 + 2;
args = {pial, white, f', radius, voldef, [], [], metric, 0};
n2v = surfing_voxelselection(args{:});
switch metric
case 'dijkstra'
extra_distance = 0;
case 'euclidean'
extra_distance = 0;
otherwise
error('illegal distance ''%s''', metric);
end
nv = size(v, 1);
rp = randperm(nv);
for k = 1:nv / 2
node_id = rp(k);
node_xyz = v(node_id, :);
is_inside = ~isequal(cosmo_vol_coordinates(ds, node_xyz'), 0);
voxel_ids = n2v{node_id};
has_voxels = ~isempty(voxel_ids);
assertEqual(is_inside, has_voxels);
if is_inside
voxels_xyz = ds_xyz(:, n2v{node_id})';
voxels_z = voxels_xyz(:, 3);
% check z coordinates
assert(all(-thickness_margin <= voxels_z & ...
voxels_z <= thickness_margin));
distances = euclidean_distance(ds_xyz', node_xyz, 1:3);
node_distances = distances(n2v{node_id});
assert(all(node_distances <= radius + thickness_margin));
% check voxels not selected
nfeatures = size(ds_xyz, 2);
candidates = true(nfeatures, 1);
candidates(ds_xyz(1, :) <= min(v(:, 1))) = false;
candidates(ds_xyz(2, :) <= min(v(:, 2))) = false;
candidates(ds_xyz(3, :) <= -(thickness + half_vox_size)) = false;
candidates(ds_xyz(1, :) >= max(v(:, 1))) = false;
candidates(ds_xyz(2, :) >= max(v(:, 2))) = false;
candidates(ds_xyz(3, :) >= thickness + half_vox_size) = false;
candidates(n2v{node_id}) = false;
if any(candidates)
min_outside = min(distances(candidates));
assert(min_outside > radius - half_vox_size);
end
end
% check individual call for this node id
args_single_node = args;
args_single_node{6} = node_id;
n2v_single_node = surfing_voxelselection(args_single_node{:});
assertEqual(n2v_single_node, n2v(node_id));
end
function d = euclidean_distance(p, q, dim)
d = sqrt(sum(bsxfun(@minus, p(:, dim), q(:, dim)).^2, 2));
function [vertices, faces] = generate_planar_surface(nx, ny, origin, x1, y1)
vertices = zeros(nx * ny, 3);
faces = zeros(2 * (nx - 1) * (ny - 1), 3);
for i = 1:nx
for j = 1:ny
vpos = (i - 1) * ny + j;
vertices(vpos, :) = origin + (i - 1) * x1 + (j - 1) * y1;
if i < nx && j < ny
p = vpos;
q = vpos + 1;
r = vpos + ny;
s = vpos + ny + 1;
fpos = ((i - 1) * (ny - 1) + j) * 2 - 1;
faces(fpos, :) = [p, q, r];
faces(fpos + 1, :) = [s, r, q];
end
end
end
