return distances, distance_matrix
if __name__ == "__main__":
import sys
import numpy as np
from mindboggle.utils.io_vtk import load_vtk, read_scalars, write_scalars
from mindboggle.utils.mesh import find_neighbors
from mindboggle.labels.labels import extract_borders
from mindboggle.labels.protocol import dkt_protocol
protocol = 'DKT25'
sulcus_names, sulcus_label_pair_lists, unique_sulcus_label_pairs, \
label_names, label_numbers, cortex_names, cortex_numbers, \
noncortex_names, noncortex_numbers = dkt_protocol(protocol)
fundi_file = sys.argv[1]
folds_file = sys.argv[2]
labels_file = sys.argv[3]
print('***')
print('Input fundi:' + fundi_file)
print('Input folds:' + folds_file)
print('Input labels:' + labels_file)
print('***')
# Load fundi, folds, labels
fundi, name = read_scalars(fundi_file, return_arrays=True)
folds, name = read_scalars(folds_file, return_arrays=True)
faces, lines, indices, points, npoints, labels, scalar_names = load_vtk(labels_file, return_arrays=True)
def concatenate_sulcus_scalars(scalar_files, fold_files, label_files):
"""
Prepare data for estimating scalar distributions along and outside fundi.
Extract (e.g., depth, curvature) scalar values in folds, along sulcus
label boundaries as well as outside the sulcus label boundaries.
Concatenate these scalar values across multiple files.
Parameters
----------
scalar_files : list of strings
names of surface mesh VTK files with scalar values to concatenate
fold_files : list of strings (corr. to each list in scalar_files)
VTK files with fold numbers as scalars (-1 for non-fold vertices)
label_files : list of strings (corr. to fold_files)
VTK files with label numbers (-1 for unlabeled vertices)
Returns
-------
border_scalars : list of floats
concatenated scalar values within folds along sulcus label boundaries
nonborder_scalars : list of floats
concatenated scalar values within folds outside sulcus label boundaries
Examples
--------
>>> # Concatenate (duplicate) depth scalars:
>>> import os
>>> from mindboggle.shapes.likelihood import concatenate_sulcus_scalars
>>> path = os.environ['MINDBOGGLE_DATA']
>>> depth_file = os.path.join(path, 'arno', 'shapes', 'depth_rescaled.vtk')
>>> folds_file = os.path.join(path, 'arno', 'features', 'folds.vtk')
>>> labels_file = os.path.join(path, 'arno', 'labels', 'lh.labels.DKT25.manual.vtk')
>>> scalar_files = [depth_file, depth_file]
>>> fold_files = [folds_file, folds_file]
>>> label_files = [labels_file, labels_file]
>>> #
>>> S = concatenate_sulcus_scalars(scalar_files, fold_files, label_files)
"""
import numpy as np
from mindboggle.utils.io_vtk import read_scalars
from mindboggle.utils.mesh import find_neighbors_from_file
from mindboggle.labels.labels import extract_borders
from mindboggle.labels.protocol import dkt_protocol
protocol = 'DKT25'
sulcus_names, sulcus_label_pair_lists, unique_sulcus_label_pairs, \
label_names, label_numbers, cortex_names, cortex_numbers, \
noncortex_names, noncortex_numbers = dkt_protocol(protocol)
# Prepare (non-unique) list of sulcus label pairs:
protocol_label_pairs = [x for lst in sulcus_label_pair_lists for x in lst]
border_scalars = []
nonborder_scalars = []
# Loop through files with the scalar values:
for ifile, scalar_file in enumerate(scalar_files):
print(scalar_file)
# Load scalars, folds, and labels:
folds_file = fold_files[ifile]
labels_file = label_files[ifile]
scalars, name = read_scalars(scalar_file, True, True)
if scalars.shape:
folds, name = read_scalars(folds_file)
labels, name = read_scalars(labels_file)
indices_folds = [i for i,x in enumerate(folds) if x != -1]
neighbor_lists = find_neighbors_from_file(labels_file)
# Find all label border pairs within the folds:
indices_label_pairs, label_pairs, unique_pairs = extract_borders(
indices_folds, labels, neighbor_lists, ignore_values=[-1],
return_label_pairs=True)
indices_label_pairs = np.array(indices_label_pairs)
# Find vertices with label pairs in the sulcus labeling protocol:
Ipairs_in_protocol = [i for i,x in enumerate(label_pairs)
if x in protocol_label_pairs]
indices_label_pairs = indices_label_pairs[Ipairs_in_protocol]
indices_outside_pairs = list(frozenset(indices_folds).difference(
indices_label_pairs))
# Store scalar values in folds along label border pairs:
border_scalars.extend(scalars[indices_label_pairs].tolist())
# Store scalar values in folds outside label border pairs:
nonborder_scalars.extend(scalars[indices_outside_pairs].tolist())
return border_scalars, nonborder_scalars