def find_neighbors_from_file(input_vtk):
"""
Generate the list of unique, sorted indices of neighboring vertices
for all vertices in the faces of a triangular mesh in a VTK file.
Parameters
----------
input_vtk : string
name of input VTK file containing surface mesh
Returns
-------
neighbor_lists : list of lists of integers
each list contains indices to neighboring vertices for each vertex
Examples
--------
>>> import os
>>> import numpy as np
>>> from mindboggle.utils.mesh import find_neighbors_from_file
>>> from mindboggle.utils.io_vtk import rewrite_scalars
>>> from mindboggle.utils.plots import plot_surfaces
>>> path = os.environ['MINDBOGGLE_DATA']
>>> vtk_file = os.path.join(path, 'arno', 'freesurfer', 'lh.pial.vtk')
>>> #
>>> neighbor_lists = find_neighbors_from_file(vtk_file)
>>> #
>>> # Write results to vtk file and view:
>>> index = 0
>>> IDs = -1 * np.ones(npoints)
>>> IDs[index] = 1
>>> IDs[neighbor_lists[index]] = 2
>>> rewrite_scalars(vtk_file, 'find_neighbors_from_file.vtk', IDs, 'neighbors', IDs)
>>> plot_surfaces('find_neighbors_from_file.vtk')
"""
from mindboggle.utils.io_vtk import read_faces_points
from mindboggle.utils.mesh import find_neighbors
faces, points, npoints = read_faces_points(input_vtk)
neighbor_lists = find_neighbors(faces, npoints)
return neighbor_lists
def find_neighbors_from_file(input_vtk):
"""
Generate the list of unique, sorted indices of neighboring vertices
for all vertices in the faces of a triangular mesh in a VTK file.
Parameters
----------
input_vtk : string
name of input VTK file containing surface mesh
Returns
-------
neighbor_lists : list of lists of integers
each list contains indices to neighboring vertices for each vertex
Examples
--------
>>> import os
>>> import numpy as np
>>> from mindboggle.utils.mesh import find_neighbors_from_file
>>> from mindboggle.utils.io_vtk import rewrite_scalars
>>> from mindboggle.utils.plots import plot_vtk
>>> path = os.environ['MINDBOGGLE_DATA']
>>> vtk_file = os.path.join(path, 'arno', 'freesurfer', 'lh.pial.vtk')
>>> #
>>> neighbor_lists = find_neighbors_from_file(vtk_file)
>>> #
>>> # Write results to vtk file and view:
>>> index = 0
>>> IDs = -1 * np.ones(npoints)
>>> IDs[index] = 1
>>> IDs[neighbor_lists[index]] = 2
>>> rewrite_scalars(vtk_file, 'find_neighbors_from_file.vtk', IDs, 'neighbors', IDs)
>>> plot_vtk('find_neighbors_from_file.vtk')
"""
from mindboggle.utils.io_vtk import read_faces_points
from mindboggle.utils.mesh import find_neighbors
faces, points, npoints = read_faces_points(input_vtk)
neighbor_lists = find_neighbors(faces, npoints)
return neighbor_lists
def propagate_fundus_lines(points, faces, fundus_line_indices, thickness):
"""Propagate fundus lines to tile the surface.
Parameters
----------
surf_file: file containing the surface geometry in vtk format
fundus_lines_file: file containing scalars representing fundus lines
thickness_file: file containing cortical thickness scalar data
(for masking out the medial wall only)
Returns
-------
scalars indicating whether each vertex is part of the closed
fundus lines or not
"""
from mindboggle.utils.mesh import find_neighbors
import numpy as np
num_points = len(points)
neighbor_lists = find_neighbors(faces, num_points)
# Find the boundary of the cc and call that a fundus line
cc_inds = [x for x in xrange(num_points) if thickness[x] < 0.001]
cc_boundary = [x for x in cc_inds if len([y for y in neighbor_lists[x]
if y not in cc_inds])]
fundus_line_indices += cc_boundary
endpoints = _find_fundus_line_endpoints(
fundus_line_indices, neighbor_lists)
closed_fundus_lines = _close_fundus_lines(points, fundus_line_indices,
neighbor_lists, endpoints)
closed_fundus_line_indices = np.where(
np.array(closed_fundus_lines) > 0)[0].tolist()
new_endpoints = _find_fundus_line_endpoints(closed_fundus_line_indices,
neighbor_lists)
new_closed_fundus_lines = _close_fundus_lines(
points, closed_fundus_line_indices, neighbor_lists, new_endpoints)
return new_closed_fundus_lines, points, faces
# Example use of the minimum spanning tree algorithm
if __name__ == "__main__" :
import os
import networkx as nx
from mindboggle.utils.io_vtk import read_vtk, rewrite_scalars
from mindboggle.utils.mesh import find_neighbors, remove_faces
from mindboggle.utils.mesh import min_span_tree
from mindboggle.utils.plots import plot_vtk
data_path = os.environ['MINDBOGGLE_DATA']
sulci_file = os.path.join(data_path, 'arno', 'features', 'sulci.vtk')
faces, lines, indices, points, npoints, sulci, name, input_vtk = read_vtk(sulci_file)
sulcus_ID = 1
sulcus_indices = [i for i,x in enumerate(sulci) if x == sulcus_ID]
sulcus_faces = remove_faces(faces, sulcus_indices)
sulcus_neighbor_lists = find_neighbors(sulcus_faces, len(points))
G=nx.Graph()
G.add_nodes_from(sulcus_indices)
for i, sulcus_neighbor_list in enumerate(sulcus_neighbor_lists):
G.add_edges_from([[i,x] for x in sulcus_neighbor_list])
adjacency_matrix = nx.adjacency_matrix(G, nodelist=None, weight='weight')
indices_to_connect = [0, len(sulcus_indices)-1]
adjacency_matrix2, W, Path, Degree, TreeNbr = min_span_tree(adjacency_matrix,
indices_to_connect)
# Write results to vtk file and view:
MST = np.zeros(len(points))
MST[W] = 1
rewrite_scalars(sulci_file, 'test_min_span_tree.vtk', MST, 'MST', MST)
Terminal, Branching = [], []
def extract_sulci(labels_file, folds_or_file, hemi, sulcus_label_pair_lists,
unique_sulcus_label_pairs, min_boundary=1, sulcus_names=[]):
"""
Identify sulci from folds in a brain surface according to a labeling
protocol that includes a list of label pairs defining each sulcus.
A fold is a group of connected, deep vertices.
Steps for each fold ::
1. Remove fold if it has fewer than two labels.
2. Remove fold if its labels do not contain a sulcus label pair.
3. Find vertices with labels that are in only one of the fold's
label boundary pairs. Assign the vertices the sulcus with the
label pair if they are connected to the label boundary for that pair.
4. If there are remaining vertices, segment into sets of vertices
connected to label boundaries, and assign a unique ID to each segment.
Parameters
----------
labels_file : string
file name for surface mesh VTK containing labels for all vertices
folds_or_file : list or string
fold number for each vertex or name of VTK file containing folds scalars
hemi : string
hemisphere ('lh' or 'rh')
sulcus_label_pair_lists : list of two lists of multiple lists of integer pairs
list containing left and right lists, each with multiple lists of
integer pairs corresponding to label boundaries / sulcus / fundus
unique_sulcus_label_pairs : list of unique pairs of integers
unique label pairs
min_boundary : integer
minimum number of vertices for a sulcus label boundary segment
sulcus_names : list of strings
names of sulci
Returns
-------
sulci : list of integers
sulcus numbers for all vertices (-1 for non-sulcus vertices)
n_sulci : integers
number of sulci
sulci_file : string
name of output VTK file with sulcus numbers (-1 for non-sulcus vertices)
Examples
--------
>>> import os
>>> from mindboggle.utils.io_vtk import read_scalars, rewrite_scalars
>>> from mindboggle.labels.protocol import dkt_protocol
>>> from mindboggle.features.sulci import extract_sulci
>>> from mindboggle.utils.plots import plot_vtk
>>> path = os.environ['MINDBOGGLE_DATA']
>>> # Load labels, folds, neighbor lists, and sulcus names and label pairs
>>> labels_file = os.path.join(path, 'arno', 'labels', 'relabeled_lh.DKTatlas40.gcs.vtk')
>>> folds_file = os.path.join(path, 'arno', 'features', 'folds.vtk')
>>> folds_or_file, name = read_scalars(folds_file)
>>> protocol = 'DKT31'
>>> hemi = 'lh'
>>> 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)
>>> min_boundary = 10
>>> #
>>> sulci, n_sulci, sulci_file = extract_sulci(labels_file, folds_or_file,
>>> hemi, sulcus_label_pair_lists, unique_sulcus_label_pairs,
>>> min_boundary, sulcus_names)
>>> # View:
>>> plot_vtk('sulci.vtk')
"""
import os
from time import time
import numpy as np
from mindboggle.utils.io_vtk import read_scalars, read_vtk, rewrite_scalars
from mindboggle.utils.mesh import find_neighbors
from mindboggle.labels.labels import extract_borders
from mindboggle.utils.segment import propagate, segment
# Load fold numbers if folds_or_file is a string
if isinstance(folds_or_file, str):
folds, name = read_scalars(folds_or_file)
elif isinstance(folds_or_file, list):
folds = folds_or_file
if hemi == 'lh':
sulcus_label_pair_lists = sulcus_label_pair_lists[0]
elif hemi == 'rh':
sulcus_label_pair_lists = sulcus_label_pair_lists[1]
else:
print("Warning: hemisphere not properly specified ('lh' or 'rh').")
# Load points, faces, and neighbors
faces, foo1, foo2, points, npoints, labels, foo3, foo4 = read_vtk(labels_file)
neighbor_lists = find_neighbors(faces, npoints)
# Array of sulcus IDs for fold vertices, initialized as -1.
# Since we do not touch gyral vertices and vertices whose labels
# are not in the label list, or vertices having only one label,
# their sulcus IDs will remain -1.
sulci = -1 * np.ones(npoints)
#-------------------------------------------------------------------------
# Loop through folds
#-------------------------------------------------------------------------
fold_numbers = [int(x) for x in np.unique(folds) if x > -1]
n_folds = len(fold_numbers)
print("Extract sulci from {0} folds...".format(n_folds))
t0 = time()
for n_fold in fold_numbers:
fold = [i for i,x in enumerate(folds) if x == n_fold]
len_fold = len(fold)
# List the labels in this fold (greater than zero)
fold_labels = [labels[x] for x in fold]
unique_fold_labels = [int(x) for x in np.unique(fold_labels) if x > 0]
#---------------------------------------------------------------------
# NO MATCH -- fold has fewer than two labels
#---------------------------------------------------------------------
if len(unique_fold_labels) < 2:
# Ignore: sulci already initialized with -1 values
if not unique_fold_labels:
print(" Fold {0} ({1} vertices): NO MATCH -- fold has no labels".
format(n_fold, len_fold))
else:
print(" Fold {0} ({1} vertices): "
"NO MATCH -- fold has only one label ({2})".
format(n_fold, len_fold, unique_fold_labels[0]))
# Ignore: sulci already initialized with -1 values
else:
# Find all label boundary pairs within the fold
indices_fold_pairs, fold_pairs, unique_fold_pairs = extract_borders(
fold, labels, neighbor_lists, ignore_values=[],
return_label_pairs=True)
# Find fold label pairs in the protocol (pairs are already sorted)
fold_pairs_in_protocol = [x for x in unique_fold_pairs
if x in unique_sulcus_label_pairs]
if unique_fold_labels:
print(" Fold {0} labels: {1} ({2} vertices)".format(n_fold,
', '.join([str(x) for x in unique_fold_labels]), len_fold))
#-----------------------------------------------------------------
# NO MATCH -- fold has no sulcus label pair
#-----------------------------------------------------------------
if not fold_pairs_in_protocol:
print(" Fold {0}: NO MATCH -- fold has no sulcus label pair".
format(n_fold, len_fold))
#-----------------------------------------------------------------
# Possible matches
#-----------------------------------------------------------------
else:
print(" Fold {0} label pairs in protocol: {1}".format(n_fold,
', '.join([str(x) for x in fold_pairs_in_protocol])))
# Labels in the protocol (includes repeats across label pairs)
labels_in_pairs = [x for lst in fold_pairs_in_protocol for x in lst]
# Labels that appear in one or more than one sulcus label boundary
unique_labels = []
nonunique_labels = []
for label in np.unique(labels_in_pairs):
if len([x for x in labels_in_pairs if x == label]) == 1:
unique_labels.append(label)
else:
nonunique_labels.append(label)
#-------------------------------------------------------------
# Vertices whose labels are in only one sulcus label pair
#-------------------------------------------------------------
# Find vertices with a label that is in only one of the fold's
# label pairs (the other label in the pair can exist
# in other pairs). Assign the vertices the sulcus with the label
# pair if they are connected to the label boundary for that pair.
#-------------------------------------------------------------
if len(unique_labels):
for pair in fold_pairs_in_protocol:
# If one or both labels in label pair is/are unique
unique_labels_in_pair = [x for x in pair if x in unique_labels]
n_unique = len(unique_labels_in_pair)
if n_unique:
ID = [i for i,x in enumerate(sulcus_label_pair_lists)
if pair in x][0]
# Construct seeds from label boundary vertices
# (fold_pairs and pair already sorted)
indices_pair = [x for i,x in enumerate(indices_fold_pairs)
if fold_pairs[i] == pair]
# Identify vertices with unique label(s) in pair
indices_unique_labels = [fold[i]
for i,x in enumerate(fold_labels)
if x in unique_sulcus_label_pairs]
# Propagate from seeds to labels in label pair
sulci2 = segment(indices_unique_labels, neighbor_lists,
min_region_size=1,
seed_lists=[indices_pair],
keep_seeding=False,
spread_within_labels=True,
labels=labels)
sulci[sulci2 > -1] = ID
# Print statement
if n_unique == 1:
ps1 = '1 label'
else:
ps1 = 'Both labels'
if len(sulcus_names):
ps2 = sulcus_names[ID]
else:
ps2 = ''
print(" {0} unique to one fold pair: {1} {2}".
format(ps1, ps2, unique_labels_in_pair))
#-------------------------------------------------------------
# Vertex labels shared by multiple label pairs
#-------------------------------------------------------------
# Propagate labels from label borders to vertices with labels
# that are shared by multiple label pairs in the fold.
#-------------------------------------------------------------
if len(nonunique_labels):
# For each label shared by different label pairs
for label in nonunique_labels:
# Print statement
print(" Propagate sulcus label borders with label {0}".
format(int(label)))
# Construct seeds from label boundary vertices
seeds = -1 * np.ones(len(points))
for ID, label_pair_list in enumerate(sulcus_label_pair_lists):
label_pairs = [x for x in label_pair_list if label in x]
for label_pair in label_pairs:
indices_pair = [x for i,x in enumerate(indices_fold_pairs)
if np.sort(fold_pairs[i]).tolist() == label_pair]
if indices_pair:
# Do not include short boundary segments
if min_boundary > 1:
indices_pair2 = []
seeds2 = segment(indices_pair, neighbor_lists)
for seed2 in range(int(max(seeds2))+1):
iseed2 = [i for i,x in enumerate(seeds2)
if x == seed2]
if len(iseed2) >= min_boundary:
indices_pair2.extend(iseed2)
else:
if len(iseed2) == 1:
print(" Remove assignment "
"of ID {0} from 1 vertex".
format(seed2))
else:
print(" Remove assignment "
"of ID {0} from {1} vertices".
format(seed2, len(iseed2)))
indices_pair = indices_pair2
# Assign sulcus IDs to seeds
seeds[indices_pair] = ID
# Identify vertices with the label
label_array = -1 * np.ones(len(points))
indices_label = [fold[i] for i,x in enumerate(fold_labels)
if x == label]
if len(indices_label):
label_array[indices_label] = 1
# Propagate from seeds to vertices with label
#indices_seeds = []
#for seed in range(int(max(seeds))+1):
# indices_seeds.append([i for i,x in enumerate(seeds)
# if x == seed])
#sulci2 = segment(indices_label, neighbor_lists,
# 50, indices_seeds, False, True, labels)
sulci2 = propagate(points, faces,
label_array, seeds, sulci,
max_iters=10000,
tol=0.001, sigma=5)
sulci[sulci2 > -1] = sulci2[sulci2 > -1]
#-------------------------------------------------------------------------
# Print out assigned sulci
#-------------------------------------------------------------------------
sulcus_numbers = [int(x) for x in np.unique(sulci) if x > -1]
n_sulci = len(sulcus_numbers)
print("Extracted {0} sulci from {1} folds ({2:.1f}s):".
format(n_sulci, n_folds, time()-t0))
if len(sulcus_names):
for sulcus_number in sulcus_numbers:
print(" {0}: {1}".format(sulcus_number, sulcus_names[sulcus_number]))
else:
print(" " + ", ".join([str(x) for x in sulcus_numbers]))
#-------------------------------------------------------------------------
# Print out unresolved sulci
#-------------------------------------------------------------------------
unresolved = [i for i in range(len(sulcus_label_pair_lists))
if i not in sulcus_numbers]
if len(unresolved) == 1:
print("The following sulcus is unaccounted for:")
else:
print("The following {0} sulci are unaccounted for:".format(len(unresolved)))
if len(sulcus_names):
for sulcus_number in unresolved:
print(" {0}: {1}".format(sulcus_number, sulcus_names[sulcus_number]))
else:
print(" " + ", ".join([str(x) for x in unresolved]))
#-------------------------------------------------------------------------
# Return sulci, number of sulci, and file name
#-------------------------------------------------------------------------
sulci_file = os.path.join(os.getcwd(), 'sulci.vtk')
rewrite_scalars(labels_file, sulci_file, sulci, 'sulci', sulci)
sulci.tolist()
return sulci, n_sulci, sulci_file
def select_largest(points, faces, exclude_labels=[-1], areas=None,
reindex=True):
"""
Select the largest segment (connected set of indices) in a mesh.
In case a surface patch is fragmented, we select the largest fragment,
remove extraneous triangular faces, and reindex indices.
Parameters
----------
points : list of lists of 3 floats
x,y,z coordinates for each vertex of the structure
faces : list of lists of 3 integers
3 indices to vertices that form a triangle on the mesh
exclude_labels : list of integers
background values to exclude
areas : numpy array or list of floats (or None)
surface area scalar values for all vertices
reindex : Boolean
reindex indices in faces?
Returns
-------
points : list of lists of 3 floats
x,y,z coordinates for each vertex of the structure
faces : list of lists of 3 integers
3 indices to vertices that form a triangle on the mesh
Examples
--------
>>> # Spectrum for one label (artificial composite), two fragments:
>>> import os
>>> import numpy as np
>>> from mindboggle.utils.io_vtk import read_scalars, read_vtk, write_vtk
>>> from mindboggle.utils.mesh import remove_faces
>>> from mindboggle.utils.segment import select_largest
>>> path = os.environ['MINDBOGGLE_DATA']
>>> label_file = os.path.join(path, 'arno', 'labels', 'lh.labels.DKT31.manual.vtk')
>>> area_file = os.path.join(path, 'arno', 'shapes', 'lh.pial.area.vtk')
>>> exclude_labels = [-1]
>>> faces, lines, indices, points, u1, labels, u2,u3 = read_vtk(label_file,
>>> return_first=True, return_array=True)
>>> I19 = [i for i,x in enumerate(labels) if x==19] # pars orbitalis
>>> I22 = [i for i,x in enumerate(labels) if x==22] # postcentral
>>> I19.extend(I22)
>>> faces = remove_faces(faces, I19)
>>> areas, u1 = read_scalars(area_file, True, True)
>>> reindex = True
>>> #
>>> points, faces = select_largest(points, faces, exclude_labels, areas,
>>> reindex)
>>> # View:
>>> from mindboggle.utils.plots import plot_vtk
>>> scalars = np.zeros(np.shape(labels))
>>> scalars[I19] = 1
>>> vtk_file = 'test_two_labels.vtk'
>>> write_vtk(vtk_file, points, indices, lines, faces,
>>> scalars, scalar_names='scalars')
>>> plot_vtk(vtk_file)
"""
import numpy as np
from mindboggle.utils.mesh import find_neighbors, remove_faces, \
reindex_faces_points
from mindboggle.utils.segment import segment
# Areas:
use_area = False
if isinstance(areas, np.ndarray) and np.shape(areas):
use_area = True
elif isinstance(areas, list) and len(areas):
areas = np.array(areas)
use_area = True
# Check to see if there are enough points:
min_npoints = 4
npoints = len(points)
if npoints < min_npoints or len(faces) < min_npoints:
print("The input size {0} ({1} faces) should be much larger "
"than {2}". format(npoints, len(faces), min_npoints))
return None
else:
#---------------------------------------------------------------------
# Segment the indices into connected sets of indices:
#---------------------------------------------------------------------
# Construct neighbor lists:
neighbor_lists = find_neighbors(faces, npoints)
# Determine the indices:
indices = [x for sublst in faces for x in sublst]
# Segment:
segments = segment(indices, neighbor_lists, min_region_size=1,
seed_lists=[], keep_seeding=False, spread_within_labels=False,
labels=[], label_lists=[], values=[], max_steps='', verbose=False)
#---------------------------------------------------------------------
# Select the largest segment (connected set of indices):
#---------------------------------------------------------------------
unique_segments = [x for x in np.unique(segments)
if x not in exclude_labels]
if len(unique_segments) > 1:
select_indices = []
max_segment_area = 0
for segment_number in unique_segments:
segment_indices = [i for i,x in enumerate(segments)
if x == segment_number]
if use_area:
segment_area = np.sum(areas[segment_indices])
else:
segment_area = len(segment_indices)
if segment_area > max_segment_area:
select_indices = segment_indices
max_segment_area = len(select_indices)
print('Maximum size of {0} segments: {1} vertices'.
format(len(unique_segments), len(select_indices)))
#-----------------------------------------------------------------
# Extract points and renumber faces for the selected indices:
#-----------------------------------------------------------------
faces = remove_faces(faces, select_indices)
else:
select_indices = indices
# Alert if the number of indices is small:
if len(select_indices) < min_npoints:
print("The input size {0} is too small.".format(len(select_indices)))
return None
elif faces:
#-----------------------------------------------------------------
# Reindex indices in faces:
#-----------------------------------------------------------------
if reindex:
faces, points = reindex_faces_points(faces, points)
return points, faces
else:
points = np.array(points)
points = points[select_indices].tolist()
return points, faces
else:
return None
def extract_sulci(labels_file,
folds_or_file,
hemi,
min_boundary=1,
sulcus_names=[]):
"""
Identify sulci from folds in a brain surface according to a labeling
protocol that includes a list of label pairs defining each sulcus.
A fold is a group of connected, deep vertices.
Steps for each fold ::
1. Remove fold if it has fewer than two labels.
2. Remove fold if its labels do not contain a sulcus label pair.
3. Find vertices with labels that are in only one of the fold's
label boundary pairs. Assign the vertices the sulcus with the label
pair if they are connected to the label boundary for that pair.
4. If there are remaining vertices, segment into sets of vertices
connected to label boundaries, and assign a unique ID to each set.
Parameters
----------
labels_file : string
file name for surface mesh VTK containing labels for all vertices
folds_or_file : list or string
fold number for each vertex / name of VTK file containing fold scalars
hemi : string
hemisphere abbreviation in {'lh', 'rh'} for sulcus labels
min_boundary : integer
minimum number of vertices for a sulcus label boundary segment
sulcus_names : list of strings
names of sulci
Returns
-------
sulci : list of integers
sulcus numbers for all vertices (-1 for non-sulcus vertices)
n_sulci : integers
number of sulci
sulci_file : string
output VTK file with sulcus numbers (-1 for non-sulcus vertices)
Examples
--------
>>> import os
>>> from mindboggle.utils.io_vtk import read_scalars, rewrite_scalars
>>> from mindboggle.features.sulci import extract_sulci
>>> from mindboggle.utils.plots import plot_surfaces
>>> path = os.environ['MINDBOGGLE_DATA']
>>> # Load labels, folds, neighbor lists, and sulcus names and label pairs
>>> labels_file = os.path.join(path, 'arno', 'labels', 'relabeled_lh.DKTatlas40.gcs.vtk')
>>> folds_file = os.path.join(path, 'arno', 'features', 'folds.vtk')
>>> folds_or_file, name = read_scalars(folds_file)
>>> hemi = 'lh'
>>> min_boundary = 10
>>> sulcus_names = []
>>> #
>>> sulci, n_sulci, sulci_file = extract_sulci(labels_file, folds_or_file, hemi, min_boundary, sulcus_names)
>>> # View:
>>> plot_surfaces('sulci.vtk')
"""
import os
from time import time
import numpy as np
from mindboggle.utils.io_vtk import read_scalars, read_vtk, rewrite_scalars
from mindboggle.utils.mesh import find_neighbors
from mindboggle.utils.segment import extract_borders, propagate, segment
from mindboggle.LABELS import DKTprotocol
# Load fold numbers if folds_or_file is a string:
if isinstance(folds_or_file, str):
folds, name = read_scalars(folds_or_file)
elif isinstance(folds_or_file, list):
folds = folds_or_file
dkt = DKTprotocol()
if hemi == 'lh':
pair_lists = dkt.left_sulcus_label_pair_lists
elif hemi == 'rh':
pair_lists = dkt.right_sulcus_label_pair_lists
else:
print("Warning: hemisphere not properly specified ('lh' or 'rh').")
# Load points, faces, and neighbors:
faces, o1, o2, points, npoints, labels, o3, o4 = read_vtk(labels_file)
neighbor_lists = find_neighbors(faces, npoints)
# Array of sulcus IDs for fold vertices, initialized as -1.
# Since we do not touch gyral vertices and vertices whose labels
# are not in the label list, or vertices having only one label,
# their sulcus IDs will remain -1:
sulci = -1 * np.ones(npoints)
#-------------------------------------------------------------------------
# Loop through folds
#-------------------------------------------------------------------------
fold_numbers = [int(x) for x in np.unique(folds) if x != -1]
n_folds = len(fold_numbers)
print("Extract sulci from {0} folds...".format(n_folds))
t0 = time()
for n_fold in fold_numbers:
fold = [i for i, x in enumerate(folds) if x == n_fold]
len_fold = len(fold)
# List the labels in this fold:
fold_labels = [labels[x] for x in fold]
unique_fold_labels = [
int(x) for x in np.unique(fold_labels) if x != -1
]
#---------------------------------------------------------------------
# NO MATCH -- fold has fewer than two labels
#---------------------------------------------------------------------
if len(unique_fold_labels) < 2:
# Ignore: sulci already initialized with -1 values:
if not unique_fold_labels:
print(" Fold {0} ({1} vertices): "
"NO MATCH -- fold has no labels".format(
n_fold, len_fold))
else:
print(" Fold {0} ({1} vertices): "
"NO MATCH -- fold has only one label ({2})".format(
n_fold, len_fold, unique_fold_labels[0]))
# Ignore: sulci already initialized with -1 values
else:
# Find all label boundary pairs within the fold:
indices_fold_pairs, fold_pairs, unique_fold_pairs = \
extract_borders(fold, labels, neighbor_lists,
ignore_values=[], return_label_pairs=True)
# Find fold label pairs in the protocol (pairs are already sorted):
fold_pairs_in_protocol = [
x for x in unique_fold_pairs
if x in dkt.unique_sulcus_label_pairs
]
if unique_fold_labels:
print(" Fold {0} labels: {1} ({2} vertices)".format(
n_fold, ', '.join([str(x) for x in unique_fold_labels]),
len_fold))
#-----------------------------------------------------------------
# NO MATCH -- fold has no sulcus label pair
#-----------------------------------------------------------------
if not fold_pairs_in_protocol:
print(" Fold {0}: NO MATCH -- fold has no sulcus label pair".
format(n_fold, len_fold))
#-----------------------------------------------------------------
# Possible matches
#-----------------------------------------------------------------
else:
print(" Fold {0} label pairs in protocol: {1}".format(
n_fold,
', '.join([str(x) for x in fold_pairs_in_protocol])))
# Labels in the protocol (includes repeats across label pairs):
labels_in_pairs = [
x for lst in fold_pairs_in_protocol for x in lst
]
# Labels that appear in one or more sulcus label boundary:
unique_labels = []
nonunique_labels = []
for label in np.unique(labels_in_pairs):
if len([x for x in labels_in_pairs if x == label]) == 1:
unique_labels.append(label)
else:
nonunique_labels.append(label)
#-------------------------------------------------------------
# Vertices whose labels are in only one sulcus label pair
#-------------------------------------------------------------
# Find vertices with a label that is in only one of the fold's
# label pairs (the other label in the pair can exist in other
# pairs). Assign the vertices the sulcus with the label pair
# if they are connected to the label boundary for that pair.
#-------------------------------------------------------------
if unique_labels:
for pair in fold_pairs_in_protocol:
# If one or both labels in label pair is/are unique:
unique_labels_in_pair = [
x for x in pair if x in unique_labels
]
n_unique = len(unique_labels_in_pair)
if n_unique:
ID = None
for i, pair_list in enumerate(pair_lists):
if not isinstance(pair_list, list):
pair_list = [pair_list]
if pair in pair_list:
ID = i
break
if ID:
# Seeds from label boundary vertices
# (fold_pairs and pair already sorted):
indices_pair = [
x for i, x in enumerate(indices_fold_pairs)
if fold_pairs[i] == pair
]
# Vertices with unique label(s) in pair:
indices_unique_labels = [
fold[i] for i, x in enumerate(fold_labels)
if x in dkt.unique_sulcus_label_pairs
]
# Propagate from seeds to labels in label pair:
sulci2 = segment(indices_unique_labels,
neighbor_lists,
min_region_size=1,
seed_lists=[indices_pair],
keep_seeding=False,
spread_within_labels=True,
labels=labels)
sulci[sulci2 != -1] = ID
# Print statement:
if n_unique == 1:
ps1 = '1 label'
else:
ps1 = 'Both labels'
if len(sulcus_names):
ps2 = sulcus_names[ID]
else:
ps2 = ''
print(" {0} unique to one fold pair: "
"{1} {2}".format(ps1, ps2,
unique_labels_in_pair))
#-------------------------------------------------------------
# Vertex labels shared by multiple label pairs
#-------------------------------------------------------------
# Propagate labels from label borders to vertices with labels
# that are shared by multiple label pairs in the fold.
#-------------------------------------------------------------
if len(nonunique_labels):
# For each label shared by different label pairs:
for label in nonunique_labels:
# Print statement:
print(" Propagate sulcus borders with label {0}".
format(int(label)))
# Construct seeds from label boundary vertices:
seeds = -1 * np.ones(len(points))
for ID, pair_list in enumerate(pair_lists):
if not isinstance(pair_list, list):
pair_list = [pair_list]
label_pairs = [x for x in pair_list if label in x]
for label_pair in label_pairs:
indices_pair = [
x for i, x in enumerate(indices_fold_pairs)
if np.sort(fold_pairs[i]).tolist() ==
label_pair
]
if indices_pair:
# Do not include short boundary segments:
if min_boundary > 1:
indices_pair2 = []
seeds2 = segment(
indices_pair, neighbor_lists)
useeds2 = [
x for x in np.unique(seeds2)
if x != -1
]
for seed2 in useeds2:
iseed2 = [
i for i, x in enumerate(seeds2)
if x == seed2
]
if len(iseed2) >= min_boundary:
indices_pair2.extend(iseed2)
else:
if len(iseed2) == 1:
print(" Remove "
"assignment "
"of ID {0} from "
"1 vertex".format(
seed2))
else:
print(
" Remove "
"assignment "
"of ID {0} from "
"{1} vertices".format(
seed2,
len(iseed2)))
indices_pair = indices_pair2
# Assign sulcus IDs to seeds:
seeds[indices_pair] = ID
# Identify vertices with the label:
label_array = -1 * np.ones(len(points))
indices_label = [
fold[i] for i, x in enumerate(fold_labels)
if x == label
]
if len(indices_label):
label_array[indices_label] = 1
# Propagate from seeds to vertices with label:
#indices_seeds = []
#for seed in range(int(max(seeds))+1):
# indices_seeds.append([i for i,x
# in enumerate(seeds)
# if x == seed])
#sulci2 = segment(indices_label, neighbor_lists,
# 50, indices_seeds, False, True,
# labels)
sulci2 = propagate(points,
faces,
label_array,
seeds,
sulci,
max_iters=10000,
tol=0.001,
sigma=5)
sulci[sulci2 != -1] = sulci2[sulci2 != -1]
#-------------------------------------------------------------------------
# Print out assigned sulci
#-------------------------------------------------------------------------
sulcus_numbers = [int(x) for x in np.unique(sulci) if x != -1]
# if not np.isnan(x)]
n_sulci = len(sulcus_numbers)
print("Extracted {0} sulci from {1} folds ({2:.1f}s):".format(
n_sulci, n_folds,
time() - t0))
if sulcus_names:
for sulcus_number in sulcus_numbers:
print(" {0}: {1}".format(sulcus_number,
sulcus_names[sulcus_number]))
elif sulcus_numbers:
print(" " + ", ".join([str(x) for x in sulcus_numbers]))
#-------------------------------------------------------------------------
# Print out unresolved sulci
#-------------------------------------------------------------------------
unresolved = [i for i in range(len(pair_lists)) if i not in sulcus_numbers]
if len(unresolved) == 1:
print("The following sulcus is unaccounted for:")
else:
print("The following {0} sulci are unaccounted for:".format(
len(unresolved)))
if sulcus_names:
for sulcus_number in unresolved:
print(" {0}: {1}".format(sulcus_number,
sulcus_names[sulcus_number]))
else:
print(" " + ", ".join([str(x) for x in unresolved]))
#-------------------------------------------------------------------------
# Return sulci, number of sulci, and file name
#-------------------------------------------------------------------------
sulci = [int(x) for x in sulci]
sulci_file = os.path.join(os.getcwd(), 'sulci.vtk')
rewrite_scalars(labels_file, sulci_file, sulci, 'sulci', sulci)
if not os.path.exists(sulci_file):
raise (IOError(sulci_file + " not found"))
return sulci, n_sulci, sulci_file
def close_surface_pair(faces, points1, points2, scalars, background_value=-1):
"""
Close a surface patch by connecting its border vertices with
corresponding vertices in a second surface file.
Assumes no lines or indices when reading VTK files in.
Note ::
Scalar values different than background define the surface patch.
The two sets of points have a 1-to-1 mapping; they are from
two surfaces whose corresponding vertices are shifted in position.
For pial vs. gray-white matter, the two surfaces are not parallel,
so connecting the vertices leads to intersecting faces.
Parameters
----------
faces : list of lists of integers
each sublist contains 3 indices of vertices that form a face
on a surface mesh
points1 : list of lists of floats
each sublist contains 3-D coordinates of a vertex on a surface mesh
points2 : list of lists of floats
points from second surface with 1-to-1 correspondence with points1
scalars : numpy array of integers
labels used to find foreground vertices
background_value : integer
scalar value for background vertices
Returns
-------
closed_faces : list of lists of integers
indices of vertices that form a face on the closed surface mesh
closed_points : list of lists of floats
3-D coordinates from points1 and points2
closed_scalars : list of integers
scalar values for points1 and points2
Examples
--------
>>> # Example 1: build a cube by closing two parallel planes:
>>> import os
>>> from mindboggle.utils.morph import close_surface_pair
>>> from mindboggle.utils.plots import plot_surfaces
>>> from mindboggle.utils.io_vtk import write_vtk
>>> # Build plane:
>>> background_value = -1
>>> n = 10 # plane edge length
>>> points1 = []
>>> for x in range(n):
>>> for y in range(n):
>>> points1.append([x,y,0])
>>> points2 = [[x[0],x[1],1] for x in points1]
>>> scalars = [background_value for x in range(len(points1))]
>>> p = n*(n-1)/2 - 1
>>> for i in [p, p+1, p+n, p+n+1]:
>>> scalars[i] = 1
>>> faces = []
>>> for x in range(n-1):
>>> for y in range(n-1):
>>> faces.append([x+y*n,x+n+y*n,x+n+1+y*n])
>>> faces.append([x+y*n,x+1+y*n,x+n+1+y*n])
>>> #write_vtk('plane.vtk', points1, [], [], faces, scalars)
>>> #plot_surfaces('plane.vtk') # doctest: +SKIP
>>> closed_faces, closed_points, closed_scalars = close_surface_pair(faces, points1, points2, scalars, background_value)
>>> # View:
>>> write_vtk('cube.vtk', closed_points, [], [], closed_faces, closed_scalars, 'int')
>>> plot_surfaces('cube.vtk') # doctest: +SKIP
>>> #
>>> # Example 2: Gray and white cortical brain surfaces:
>>> import os
>>> from mindboggle.utils.morph import close_surface_pair
>>> from mindboggle.utils.plots import plot_surfaces
>>> from mindboggle.utils.io_vtk import read_scalars, read_vtk, read_points, write_vtk
>>> path = os.environ['MINDBOGGLE_DATA']
>>> patch_surface1 = 'fold.pial.vtk'
>>> whole_surface2 = 'fold.white.vtk'
>>> # Select a single fold:
>>> folds_file = os.path.join(path, 'arno', 'features', 'folds.vtk')
>>> points1 = read_points(folds_file)
>>> scalars, name = read_scalars(folds_file, True, True)
>>> fold_number = 11
>>> scalars[scalars != fold_number] = -1
>>> white_surface = os.path.join(path, 'arno', 'freesurfer', 'lh.white.vtk')
>>> faces, u1, u2, points2, N, u3, u4, u5 = read_vtk(white_surface)
>>> background_value = -1
>>> closed_faces, closed_points, closed_scalars = close_surface_pair(faces, points1, points2, scalars, background_value)
>>> # View:
>>> write_vtk('closed.vtk', closed_points, [], [], closed_faces, closed_scalars, name, 'int')
>>> plot_surfaces('closed.vtk') # doctest: +SKIP
"""
import sys
import numpy as np
from mindboggle.utils.mesh import find_neighbors, remove_faces
from mindboggle.utils.segment import extract_borders
if isinstance(scalars, list):
scalars = np.array(scalars)
N = len(points1)
closed_points = points1 + points2
# Find all vertex neighbors and surface patch border vertices:
neighbor_lists = find_neighbors(faces, N)
I = np.where(scalars != background_value)[0]
scalars[scalars == background_value] = background_value + 1
scalars[I] = background_value + 2
scalars = scalars.tolist()
borders, u1, u2 = extract_borders(range(N), scalars, neighbor_lists)
if not len(borders):
sys.exit('There are no border vertices!')
borders = [x for x in borders if x in I]
# Reindex copy of faces and combine with original (both zero-index):
indices = range(N)
indices2 = range(N, 2 * N)
reindex = dict([(index, indices2[i]) for i, index in enumerate(indices)])
faces = remove_faces(faces, I)
faces2 = [[reindex[i] for i in face] for face in faces]
closed_faces = faces + faces2
# Connect border vertices between surface patches and add new faces:
add_faces = []
taken_already = []
for index in borders:
if index not in taken_already:
neighbors = list(set(neighbor_lists[index]).intersection(borders))
taken_already.append(index)
#taken_already.extend([index] + neighbors)
for neighbor in neighbors:
add_faces.append([index, index + N, neighbor])
add_faces.append([index + N, neighbor, neighbor + N])
closed_faces = closed_faces + add_faces
closed_scalars = scalars * 2
return closed_faces, closed_points, closed_scalars
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)
# List of indices to fold vertices
fold_indices = [i for i,x in enumerate(folds) if x > 0]
# Calculate neighbor lists for all points
print('Find neighbors to all vertices...')
neighbor_lists = find_neighbors(faces, npoints)
# Prepare list of all unique sorted label pairs in the labeling protocol
print('Prepare a list of unique, sorted label pairs in the protocol...')
n_fundi = len(sulcus_label_pair_lists)
# Find label boundary points in any of the folds
print('Find label boundary points in any of the folds...')
border_indices, border_label_tuples, unique_border_label_tuples = \
extract_borders(fold_indices, labels, neighbor_lists)
if not len(border_indices):
sys.exit('There are no label boundary points!')
# Initialize an array of label boundaries fundus IDs
# (label boundary vertices that define sulci in the labeling protocol)
print('Build an array of label boundary fundus IDs...')
def extract_subfolds(depth_file,
folds,
min_size=10,
depth_factor=0.25,
depth_ratio=0.1,
tolerance=0.01,
save_file=False):
"""
Use depth to segment folds into subfolds in a triangular surface mesh.
Note ::
The function extract_sulci() performs about the same whether folds
or subfolds are used as input. The latter leads to some loss of
small subfolds and possibly holes for small subfolds in the middle
of other subfolds.
Note about the watershed() function:
The watershed() function performs individual seed growing from deep seeds,
repeats segmentation from the resulting seeds until each seed's segment
touches a boundary. The function segment() fills in the rest. Finally
segments are joined if their seeds are too close to each other.
Despite these precautions, the order of seed selection in segment() could
possibly influence the resulting borders between adjoining segments.
[The propagate() function is slower and insensitive to depth,
but is not biased by seed order.]
Parameters
----------
depth_file : string
surface mesh file in VTK format with faces and depth scalar values
folds : list of integers
fold numbers for all vertices (-1 for non-fold vertices)
min_size : integer
minimum number of vertices for a subfold
depth_factor : float
watershed() depth_factor:
factor to determine whether to merge two neighboring watershed catchment
basins -- they are merged if the Euclidean distance between their basin
seeds is less than this fraction of the maximum Euclidean distance
between points having minimum and maximum depths
depth_ratio : float
watershed() depth_ratio:
the minimum fraction of depth for a neighboring shallower
watershed catchment basin (otherwise merged with the deeper basin)
tolerance : float
watershed() tolerance:
tolerance for detecting differences in depth between vertices
save_file : Boolean
save output VTK file?
Returns
-------
subfolds : list of integers
fold numbers for all vertices (-1 for non-fold vertices)
n_subfolds : int
number of subfolds
subfolds_file : string (if save_file)
name of output VTK file with fold IDs (-1 for non-fold vertices)
Examples
--------
>>> import os
>>> from mindboggle.utils.io_vtk import read_scalars, rewrite_scalars
>>> from mindboggle.utils.mesh import find_neighbors_from_file
>>> from mindboggle.features.folds import extract_subfolds
>>> from mindboggle.utils.plots import plot_surfaces
>>> path = os.environ['MINDBOGGLE_DATA']
>>> depth_file = os.path.join(path, 'arno', 'shapes', 'lh.pial.travel_depth.vtk')
>>> folds_file = os.path.join(path, 'arno', 'features', 'folds.vtk')
>>> folds, name = read_scalars(folds_file)
>>> min_size = 10
>>> depth_factor = 0.5
>>> depth_ratio = 0.1
>>> tolerance = 0.01
>>> #
>>> subfolds, n_subfolds, subfolds_file = extract_subfolds(depth_file,
>>> folds, min_size, depth_factor, depth_ratio, tolerance, True)
>>> #
>>> # View:
>>> rewrite_scalars(depth_file, 'subfolds.vtk', subfolds, 'subfolds', subfolds)
>>> plot_surfaces('subfolds.vtk')
"""
import os
import numpy as np
from time import time
from mindboggle.utils.io_vtk import rewrite_scalars, read_vtk
from mindboggle.utils.mesh import find_neighbors
from mindboggle.utils.segment import segment, propagate, watershed
print("Segment folds into subfolds")
t0 = time()
#-------------------------------------------------------------------------
# Load depth values for all vertices
#-------------------------------------------------------------------------
faces, lines, indices, points, npoints, depths, \
name, input_vtk = read_vtk(depth_file, return_first=True, return_array=True)
#-------------------------------------------------------------------------
# Find neighbors for each vertex
#-------------------------------------------------------------------------
neighbor_lists = find_neighbors(faces, npoints)
#-------------------------------------------------------------------------
# Segment folds into "watershed basins"
#-------------------------------------------------------------------------
indices_folds = [i for i, x in enumerate(folds) if x != -1]
subfolds, seed_indices = watershed(depths,
points,
indices_folds,
neighbor_lists,
min_size,
depth_factor=0.25,
depth_ratio=0.1,
tolerance=0.01,
regrow=True)
# Print statement
n_subfolds = len([x for x in np.unique(subfolds) if x != -1])
print(' ...Extracted {0} subfolds ({1:.2f} seconds)'.format(
n_subfolds,
time() - t0))
#-------------------------------------------------------------------------
# Return subfolds, number of subfolds, file name
#-------------------------------------------------------------------------
if save_file:
subfolds_file = os.path.join(os.getcwd(), 'subfolds.vtk')
rewrite_scalars(depth_file, subfolds_file, subfolds, 'subfolds',
subfolds)
if not os.path.exists(subfolds_file):
raise (IOError(subfolds_file + " not found"))
else:
subfolds_file = None
return subfolds, n_subfolds, subfolds_file
def realign_boundaries_to_fundus_lines(surf_file,
init_label_file,
fundus_lines_file,
thickness_file,
out_label_file=None):
"""
Fix label boundaries to fundus lines.
Parameters
----------
surf_file : file containing the surface geometry in vtk format
init_label_file : file containing scalars that represent the
initial guess at labels
fundus_lines_file : file containing scalars representing fundus lines.
thickness_file: file containing cortical thickness scalar data
(for masking out the medial wall only)
out_label_file : if specified, the realigned labels will be writen to
this file
Returns
-------
numpy array representing the realigned label for each surface vertex.
"""
import numpy as np
from mindboggle.utils.segment import extract_borders
import mindboggle.utils.graph as go
from mindboggle.utils.io_vtk import read_vtk, read_scalars, write_vtk
from mindboggle.utils.mesh import find_neighbors
import propagate_fundus_lines
## read files
faces, _, indices, points, num_points, _, _, _ = read_vtk(
surf_file, return_first=True, return_array=True)
indices = range(num_points)
init_labels, _ = read_scalars(init_label_file,
return_first=True,
return_array=True)
fundus_lines, _ = read_scalars(fundus_lines_file,
return_first=True,
return_array=True)
thickness, _ = read_scalars(thickness_file,
return_first=True,
return_array=True)
# remove labels from vertices with zero thickness (get around
# DKT40 annotations having the label '3' for all the Corpus
# Callosum vertices).
cc_inds = [x for x in indices if thickness[x] < 0.001]
init_labels[cc_inds] = 0
## setup seeds from initial label boundaries
neighbor_lists = find_neighbors(faces, num_points)
# extract all vertices that are on a boundary between labels
boundary_indices, label_pairs, _ = extract_borders(indices,
init_labels,
neighbor_lists,
return_label_pairs=True)
# split boundary vertices into segments with common boundary pairs.
boundary_segments = {}
for boundary_index, label_pair in zip(boundary_indices, label_pairs):
key = ((label_pair[0],
label_pair[1]) if label_pair[0] < label_pair[1] else
(label_pair[1], label_pair[0]))
if key not in boundary_segments:
boundary_segments[key] = []
boundary_segments[key].append(boundary_index)
boundary_matrix, boundary_matrix_keys = _build_boundary_matrix(
boundary_segments, num_points)
# build the affinity matrix
affinity_matrix = go.weight_graph(np.array(points),
indices,
np.array(faces),
sigma=10,
add_to_graph=False)
## propagate boundaries to fundus line vertices
learned_matrix = _propagate_labels(affinity_matrix, boundary_matrix,
boundary_indices, 100, 1)
# assign labels to fundus line vertices based on highest probability
new_boundaries = -1 * np.ones(init_labels.shape)
fundus_line_indices = [i for i, x in enumerate(fundus_lines) if x > 0.5]
# tile the surface into connected components delimited by fundus lines
closed_fundus_lines, _, _ = propagate_fundus_lines.propagate_fundus_lines(
points, faces, fundus_line_indices, thickness)
closed_fundus_line_indices = np.where(closed_fundus_lines > 0)[0]
# split surface into connected components
connected_component_faces = _remove_boundary_faces(
points, faces, closed_fundus_line_indices)
# label components based on most probable label assignment
new_labels = _label_components(connected_component_faces, num_points,
boundary_indices, learned_matrix,
boundary_matrix_keys)
# propagate new labels to fill holes
label_matrix, label_map = _build_label_matrix(new_labels)
new_learned_matrix = _propagate_labels(
affinity_matrix, label_matrix,
[i for i in range(num_points) if new_labels[i] >= 0], 100, 1)
# assign most probable labels
for idx in [i for i in range(num_points) if new_labels[i] == -1]:
max_idx = np.argmax(new_learned_matrix[idx])
new_labels[idx] = label_map[max_idx]
# save
if out_label_file is not None:
write_vtk(out_label_file,
points,
faces=faces,
scalars=[int(x) for x in new_labels],
scalar_type='int')
return new_labels
def extract_folds(depth_file, min_fold_size=50, tiny_depth=0.001, save_file=False):
"""
Use depth to extract folds from a triangular surface mesh.
Steps ::
1. Compute histogram of depth measures.
2. Define a depth threshold and find the deepest vertices.
3. Segment deep vertices as an initial set of folds.
4. Remove small folds.
5. Find and fill holes in the folds.
6. Renumber folds.
Step 2 ::
To extract an initial set of deep vertices from the surface mesh,
we anticipate that there will be a rapidly decreasing distribution
of low depth values (on the outer surface) with a long tail
of higher depth values (in the folds), so we smooth the histogram's
bin values, convolve to compute slopes, and find the depth value
for the first bin with slope = 0. This is our threshold.
Step 5 ::
The folds could have holes in areas shallower than the depth threshold.
Calling fill_holes() could accidentally include very shallow areas
(in an annulus-shaped fold, for example), so we call fill_holes() with
the argument exclude_range set close to zero to retain these areas.
Parameters
----------
depth_file : string
surface mesh file in VTK format with faces and depth scalar values
min_fold_size : integer
minimum fold size (number of vertices)
tiny_depth : float
largest non-zero depth value that will stop a hole from being filled
save_file : Boolean
save output VTK file?
Returns
-------
folds : list of integers
fold numbers for all vertices (-1 for non-fold vertices)
n_folds : int
number of folds
depth_threshold : float
threshold defining the minimum depth for vertices to be in a fold
bins : list of integers
histogram bins: each is the number of vertices within a range of depth values
bin_edges : list of floats
histogram bin edge values defining the bin ranges of depth values
folds_file : string (if save_file)
name of output VTK file with fold IDs (-1 for non-fold vertices)
Examples
--------
>>> import os
>>> import numpy as np
>>> import pylab
>>> from scipy.ndimage.filters import gaussian_filter1d
>>> from mindboggle.utils.io_vtk import read_scalars
>>> from mindboggle.utils.mesh import find_neighbors_from_file
>>> from mindboggle.utils.plots import plot_vtk
>>> from mindboggle.features.folds import extract_folds
>>> path = os.environ['MINDBOGGLE_DATA']
>>> depth_file = os.path.join(path, 'arno', 'shapes', 'lh.pial.travel_depth.vtk')
>>> neighbor_lists = find_neighbors_from_file(depth_file)
>>> min_fold_size = 50
>>> tiny_depth = 0.001
>>> save_file = True
>>> #
>>> folds, n_folds, thr, bins, bin_edges, folds_file = extract_folds(depth_file,
>>> min_fold_size, tiny_depth, save_file)
>>> #
>>> # View folds:
>>> plot_vtk('folds.vtk')
>>> # Plot histogram and depth threshold:
>>> depths, name = read_scalars(depth_file)
>>> nbins = np.round(len(depths) / 100.0)
>>> a,b,c = pylab.hist(depths, bins=nbins)
>>> pylab.plot(thr*np.ones((100,1)), np.linspace(0, max(bins), 100), 'r.')
>>> pylab.show()
>>> # Plot smoothed histogram:
>>> bins_smooth = gaussian_filter1d(bins.tolist(), 5)
>>> pylab.plot(range(len(bins)), bins, '.', range(len(bins)), bins_smooth,'-')
>>> pylab.show()
"""
import os
import sys
import numpy as np
from time import time
from scipy.ndimage.filters import gaussian_filter1d
from mindboggle.utils.io_vtk import rewrite_scalars, read_vtk
from mindboggle.utils.mesh import find_neighbors
from mindboggle.utils.morph import fill_holes
from mindboggle.utils.segment import segment
do_fill_holes = True
print("Extract folds in surface mesh")
t0 = time()
#-------------------------------------------------------------------------
# Load depth values for all vertices
#-------------------------------------------------------------------------
faces, lines, indices, points, npoints, depths, name, input_vtk = read_vtk(depth_file,
return_first=True, return_array=True)
#-------------------------------------------------------------------------
# Find neighbors for each vertex
#-------------------------------------------------------------------------
neighbor_lists = find_neighbors(faces, npoints)
#-------------------------------------------------------------------------
# Compute histogram of depth measures
#-------------------------------------------------------------------------
min_vertices = 10000
if npoints > min_vertices:
nbins = np.round(npoints / 100.0)
else:
sys.err(" Expecting at least {0} vertices to create depth histogram".
format(min_vertices))
bins, bin_edges = np.histogram(depths, bins=nbins)
#-------------------------------------------------------------------------
# Anticipating that there will be a rapidly decreasing distribution
# of low depth values (on the outer surface) with a long tail of higher
# depth values (in the folds), smooth the bin values (Gaussian), convolve
# to compute slopes, and find the depth for the first bin with slope = 0.
#-------------------------------------------------------------------------
bins_smooth = gaussian_filter1d(bins.tolist(), 5)
window = [-1, 0, 1]
bin_slopes = np.convolve(bins_smooth, window, mode='same') / (len(window) - 1)
ibins0 = np.where(bin_slopes == 0)[0]
if ibins0.shape:
depth_threshold = bin_edges[ibins0[0]]
else:
depth_threshold = np.median(depths)
#-------------------------------------------------------------------------
# Find the deepest vertices
#-------------------------------------------------------------------------
indices_deep = [i for i,x in enumerate(depths) if x >= depth_threshold]
if indices_deep:
#---------------------------------------------------------------------
# Segment deep vertices as an initial set of folds
#---------------------------------------------------------------------
print(" Segment vertices deeper than {0:.2f} as folds".format(depth_threshold))
t1 = time()
folds = segment(indices_deep, neighbor_lists)
# Slightly slower alternative -- fill boundaries:
#regions = -1 * np.ones(len(points))
#regions[indices_deep] = 1
#folds = segment_by_filling_borders(regions, neighbor_lists)
print(' ...Segmented folds ({0:.2f} seconds)'.format(time() - t1))
#---------------------------------------------------------------------
# Remove small folds
#---------------------------------------------------------------------
if min_fold_size > 1:
print(' Remove folds smaller than {0}'.format(min_fold_size))
unique_folds = [x for x in np.unique(folds) if x > -1]
for nfold in unique_folds:
indices_fold = [i for i,x in enumerate(folds) if x == nfold]
if len(indices_fold) < min_fold_size:
folds[indices_fold] = -1
#---------------------------------------------------------------------
# Find and fill holes in the folds
# Note: Surfaces surrounded by folds can be mistaken for holes,
# so exclude_range includes outer surface values close to zero.
#---------------------------------------------------------------------
if do_fill_holes:
print(" Find and fill holes in the folds")
folds = fill_holes(folds, neighbor_lists, values=depths,
exclude_range=[0, tiny_depth])
#---------------------------------------------------------------------
# Renumber folds so they are sequential
#---------------------------------------------------------------------
renumber_folds = -1 * np.ones(len(folds))
fold_numbers = [int(x) for x in np.unique(folds) if x > -1]
for i_fold, n_fold in enumerate(fold_numbers):
fold = [i for i,x in enumerate(folds) if x == n_fold]
renumber_folds[fold] = i_fold
folds = renumber_folds
n_folds = i_fold + 1
# Print statement
print(' ...Extracted {0} folds ({1:.2f} seconds)'.
format(n_folds, time() - t0))
else:
print(' No deep vertices')
#-------------------------------------------------------------------------
# Return folds, number of folds, file name
#-------------------------------------------------------------------------
if save_file:
folds_file = os.path.join(os.getcwd(), 'folds.vtk')
rewrite_scalars(depth_file, folds_file, folds, 'folds', folds)
if not os.path.exists(folds_file):
raise(IOError(folds_file + " not found"))
else:
folds_file = None
return folds.tolist(), n_folds, depth_threshold, bins, bin_edges, folds_file
def extract_borders_2nd_surface(labels_file, mask_file="", values_file=""):
"""
Extract borders (between labels) on a surface.
Options: Mask out values; extract border values on a second surface.
Parameters
----------
labels_file : string
file name for surface mesh with labels
mask_file : string
file name for surface mesh with mask (>-1) values
values_file : string
file name for surface mesh with values to extract along borders
Returns
-------
border_file : string
file name for surface mesh with label borders (-1 background values)
border_values : numpy array
values for all vertices (-1 for vertices not along label borders)
Examples
--------
>>> # Extract depth values along label borders in sulci (mask):
>>> import os
>>> from mindboggle.labels.labels import extract_borders_2nd_surface
>>> from mindboggle.utils.plots import plot_vtk
>>> path = os.environ['MINDBOGGLE_DATA']
>>> labels_file = os.path.join(path, 'arno', 'labels', 'lh.labels.DKT25.manual.vtk')
>>> mask_file = os.path.join(path, 'arno', 'features', 'sulci.vtk')
>>> values_file = os.path.join(path, 'arno', 'shapes', 'lh.pial.travel_depth.vtk')
>>> #
>>> border_file, border_values = extract_borders_2nd_surface(labels_file, mask_file, values_file)
>>> #
>>> plot_vtk(border_file)
"""
import os
import numpy as np
from mindboggle.utils.io_vtk import read_scalars, read_vtk, rewrite_scalars
from mindboggle.utils.mesh import find_neighbors
from mindboggle.labels.labels import extract_borders
# Load labeled surface file
faces, foo1, foo2, foo3, npoints, labels, foo4, foo5 = read_vtk(labels_file, return_first=True, return_array=True)
# Detect borders
neighbor_lists = find_neighbors(faces, npoints)
indices_borders, foo1, foo2 = extract_borders(range(npoints), labels, neighbor_lists)
# Filter values with label borders
border_values = -1 * np.ones(npoints)
if values_file:
values, name = read_scalars(values_file, return_first=True, return_array=True)
border_values[indices_borders] = values[indices_borders]
else:
border_values[indices_borders] = 1
# Mask values (for mask >-1)
if mask_file:
mask_values, name = read_scalars(mask_file)
else:
mask_values = []
# Write out label boundary vtk file
border_file = os.path.join(os.getcwd(), "borders_" + os.path.basename(labels_file))
rewrite_scalars(labels_file, border_file, border_values, "label_borders_in_mask", mask_values)
if not os.path.exists(border_file):
raise (IOError(border_file + " not found"))
return border_file, border_values
def realign_boundaries_to_fundus_lines(
surf_file, init_label_file, fundus_lines_file, out_label_file=None):
"""
Fix label boundaries to fundus lines.
Parameters
----------
surf_file : file containing the surface geometry in vtk format
init_label_file : file containing scalars that represent the
initial guess at labels
fundus_lines_file : file containing scalars representing fundus lines.
out_label_file : if specified, the realigned labels will be writen to
this file
Returns
-------
numpy array representing the realigned label for each surface vertex.
"""
# import os
import numpy as np
from mindboggle.labels.labels import extract_borders
import mindboggle.utils.graph as go
from mindboggle.utils.io_vtk import read_vtk, read_scalars, write_vtk
# import mindboggle.utils.kernels as kernels
from mindboggle.utils.mesh import find_neighbors
# 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)
## read files
faces, _, indices, points, num_points, _, _, _ = read_vtk(
surf_file, return_first=True, return_array=True)
indices = range(num_points)
init_labels, _ = read_scalars(init_label_file,
return_first=True, return_array=True)
fundus_lines, _ = read_scalars(fundus_lines_file,
return_first=True, return_array=True)
## setup seeds from initial label boundaries
neighbor_lists = find_neighbors(faces, num_points)
# extract all vertices that are on a boundary between labels
boundary_indices, label_pairs, _ = extract_borders(
indices, init_labels, neighbor_lists,
return_label_pairs=True)
# split boundary vertices into segments with common boundary pairs.
boundary_segments = {}
for boundary_index, label_pair in zip(boundary_indices, label_pairs):
key = ((label_pair[0], label_pair[1]) if label_pair[0] < label_pair[1]
else (label_pair[1], label_pair[0]))
if key not in boundary_segments:
boundary_segments[key] = []
boundary_segments[key].append(boundary_index)
boundary_matrix, boundary_matrix_keys = _build_boundary_matrix(
boundary_segments, num_points)
# build the affinity matrix
affinity_matrix = go.weight_graph(
np.array(points), indices, np.array(faces), sigma=10, add_to_graph=False)
## propagate boundaries to fundus line vertices
learned_matrix = _propagate_labels(
affinity_matrix, boundary_matrix, boundary_indices, 1000, 1)
# assign labels to fundus line vertices based on highest probability
new_boundaries = -1 * np.ones(init_labels.shape)
fundus_line_indices = [i for i, x in enumerate(fundus_lines) if x > 0.5]
# TODO: this currently only works for fundus lines that tile the
# surface into connected components (which is fine when you want
# to test this method on fundus lines generated from manual
# labeling). However, to work on real data, fundus lines will
# need to be connected together using shortest paths.
# split surface into connected components
connected_component_faces = _remove_boundary_faces(
points, faces, fundus_line_indices)
# label components based on most probable label assignment
new_labels = _label_components(
connected_component_faces, num_points, boundary_indices, learned_matrix,
boundary_matrix_keys)
# propagate new labels to fill holes
label_matrix, label_map = _build_label_matrix(new_labels)
new_learned_matrix = _propagate_labels(
affinity_matrix, label_matrix,
[i for i in range(num_points) if new_labels[i] >= 0], 100, 1)
# assign most probable labels
for idx in [i for i in range(num_points) if new_labels[i] == -1]:
max_idx = np.argmax(new_learned_matrix[idx])
new_labels[idx] = label_map[max_idx]
# save
if out_label_file is not None:
write_vtk(out_label_file, points, faces=faces,
scalars=new_labels.tolist())
return new_labels
def spectrum_of_largest(points, faces, n_eigenvalues=6, exclude_labels=[-1],
normalization=None, areas=None):
"""
Compute Laplace-Beltrami spectrum on largest connected segment.
In case a surface patch is fragmented, we select the largest fragment,
remove extraneous triangular faces, and reindex indices.
Parameters
----------
points : list of lists of 3 floats
x,y,z coordinates for each vertex of the structure
faces : list of lists of 3 integers
3 indices to vertices that form a triangle on the mesh
n_eigenvalues : integer
number of eigenvalues to be computed (the length of the spectrum)
exclude_labels : list of integers
background values to exclude
normalization : string
the method used to normalize eigenvalues ('area' or None)
if "area", use area of the 2D structure as in Reuter et al. 2006
areas : numpy array or list of floats (or None)
surface area scalar values for all vertices
Returns
-------
spectrum : list
first n_eigenvalues eigenvalues for Laplace-Beltrami spectrum
Examples
--------
>>> # Spectrum for one label (artificial composite), two fragments:
>>> import os
>>> import numpy as np
>>> from mindboggle.utils.io_vtk import read_scalars, read_vtk, write_vtk
>>> from mindboggle.utils.mesh import remove_faces
>>> from mindboggle.shapes.laplace_beltrami import spectrum_of_largest
>>> path = os.environ['MINDBOGGLE_DATA']
>>> label_file = os.path.join(path, 'arno', 'labels', 'lh.labels.DKT25.manual.vtk')
>>> area_file = os.path.join(path, 'arno', 'shapes', 'lh.pial.area.vtk')
>>> n_eigenvalues = 6
>>> exclude_labels = [0] #[-1]
>>> normalization = None
>>> faces, lines, indices, points, foo1, labels, foo2, foo3 = read_vtk(label_file,
>>> return_first=True, return_array=True)
>>> I2 = [i for i,x in enumerate(labels) if x==2] # cingulate
>>> I22 = [i for i,x in enumerate(labels) if x==22] # postcentral
>>> I2.extend(I22)
>>> faces = remove_faces(faces, I2)
>>> areas, u1 = read_scalars(area_file, True, True)
>>> #
>>> spectrum_of_largest(points, faces, n_eigenvalues, exclude_labels,
>>> normalization, areas)
>>> #
>>> # View:
>>> from mindboggle.utils.plots import plot_vtk
>>> scalars = np.zeros(np.shape(labels))
>>> scalars[I2] = 1
>>> vtk_file = 'test_two_labels.vtk'
>>> write_vtk(vtk_file, points, indices, lines, faces,
>>> scalars, scalar_names='scalars')
>>> plot_vtk(vtk_file)
Load "Labels" scalars from lh.labels.DKT25.manual.vtk
Reduced 290134 to 29728 triangular faces
Load "scalars" scalars from lh.pial.area.vtk
2 segments
Reduced 29728 to 14498 triangular faces
Compute linear FEM Laplace-Beltrami spectrum
[-8.764053090852845e-18,
0.00028121452203987146,
0.0010941205613292243,
0.0017301461686759188,
0.0034244633555606295,
0.004280982704174599]
"""
from scipy.sparse.linalg import eigsh, lobpcg
import numpy as np
from mindboggle.utils.mesh import find_neighbors, remove_faces, \
reindex_faces_points
from mindboggle.utils.segment import segment
from mindboggle.shapes.laplace_beltrami import fem_laplacian
# Areas:
use_area = False
if isinstance(areas, np.ndarray) and np.shape(areas):
use_area = True
elif isinstance(areas, list) and len(areas):
areas = np.array(areas)
use_area = True
# Check to see if there are enough points:
min_npoints = n_eigenvalues
npoints = len(points)
if npoints < min_npoints or len(faces) < min_npoints:
print("The input size {0} ({1} faces) should be much larger "
"than n_eigenvalues {2}".
format(npoints, len(faces), n_eigenvalues))
return None
else:
#---------------------------------------------------------------------
# Segment the indices into connected sets of indices:
#---------------------------------------------------------------------
# Construct neighbor lists:
neighbor_lists = find_neighbors(faces, npoints)
# Determine the indices:
indices = [x for sublst in faces for x in sublst]
# Segment:
segments = segment(indices, neighbor_lists, min_region_size=1,
seed_lists=[], keep_seeding=False, spread_within_labels=False,
labels=[], label_lists=[], values=[], max_steps='', verbose=False)
#---------------------------------------------------------------------
# Select the largest segment (connected set of indices):
#---------------------------------------------------------------------
unique_segments = [x for x in np.unique(segments)
if x not in exclude_labels]
if len(unique_segments) > 1:
select_indices = []
max_segment_area = 0
for segment_number in unique_segments:
segment_indices = [i for i,x in enumerate(segments)
if x == segment_number]
if use_area:
segment_area = np.sum(areas[segment_indices])
else:
segment_area = len(segment_indices)
if segment_area > max_segment_area:
select_indices = segment_indices
max_segment_area = len(select_indices)
print('Maximum size of {0} segments: {1} vertices'.
format(len(unique_segments), len(select_indices)))
#-----------------------------------------------------------------
# Extract points and renumber faces for the selected indices:
#-----------------------------------------------------------------
faces = remove_faces(faces, select_indices)
else:
select_indices = indices
# Alert if the number of indices is small:
if len(select_indices) < min_npoints:
print("The input size {0} is too small.".format(len(select_indices)))
return None
elif faces:
#-----------------------------------------------------------------
# Reindex indices in faces:
#-----------------------------------------------------------------
faces, points = reindex_faces_points(faces, points)
#-----------------------------------------------------------------
# Compute spectrum:
#-----------------------------------------------------------------
spectrum = fem_laplacian(points, faces, n_eigenvalues,
normalization)
return spectrum
else:
return None
def evaluate_deep_features(features_file,
labels_file,
sulci_file='',
hemi='',
excludeIDs=[-1],
output_vtk_name='',
verbose=True):
"""
Evaluate deep surface features by computing the minimum distance from each
label border vertex to all of the feature vertices in the same sulcus,
and from each feature vertex to all of the label border vertices in the
same sulcus. The label borders run along the deepest parts of sulci
and correspond to fundi in the DKT cortical labeling protocol.
Parameters
----------
features_file : string
VTK surface file with feature numbers for vertex scalars
labels_file : string
VTK surface file with label numbers for vertex scalars
sulci_file : string
VTK surface file with sulcus numbers for vertex scalars
excludeIDs : list of integers
feature/sulcus/label IDs to exclude (background set to -1)
output_vtk_name : Boolean
if not empty, output a VTK file beginning with output_vtk_name that
contains a surface with mean distances as scalars
verbose : Boolean
print mean distances to standard output?
Returns
-------
feature_to_border_mean_distances : numpy array [number of features x 1]
mean distance from each feature to sulcus label border
feature_to_border_sd_distances : numpy array [number of features x 1]
standard deviations of feature-to-border distances
feature_to_border_distances_vtk : string
VTK surface file containing feature-to-border distances
border_to_feature_mean_distances : numpy array [number of features x 1]
mean distances from each sulcus label border to feature
border_to_feature_sd_distances : numpy array [number of features x 1]
standard deviations of border-to-feature distances
border_to_feature_distances_vtk : string
VTK surface file containing border-to-feature distances
"""
import os
import sys
import numpy as np
from mindboggle.utils.io_vtk import read_vtk, read_scalars, write_vtk
from mindboggle.utils.mesh import find_neighbors, remove_faces
from mindboggle.utils.segment import extract_borders
from mindboggle.utils.compute import source_to_target_distances
from mindboggle.LABELS import DKTprotocol
dkt = DKTprotocol()
#-------------------------------------------------------------------------
# Load labels, features, and sulci:
#-------------------------------------------------------------------------
faces, lines, indices, points, npoints, labels, scalar_names, \
input_vtk = read_vtk(labels_file, True, True)
features, name = read_scalars(features_file, True, True)
if sulci_file:
sulci, name = read_scalars(sulci_file, True, True)
# List of indices to sulcus vertices:
sulcus_indices = [i for i, x in enumerate(sulci) if x != -1]
segmentIDs = sulci
sulcus_faces = remove_faces(faces, sulcus_indices)
else:
sulcus_indices = range(len(labels))
segmentIDs = []
sulcus_faces = faces
#-------------------------------------------------------------------------
# Prepare neighbors, label pairs, border IDs, and outputs:
#-------------------------------------------------------------------------
# Calculate neighbor lists for all points:
print('Find neighbors for all vertices...')
neighbor_lists = find_neighbors(faces, npoints)
# Find label border points in any of the sulci:
print('Find label border points in any of the sulci...')
border_indices, border_label_tuples, unique_border_label_tuples = \
extract_borders(sulcus_indices, labels, neighbor_lists,
ignore_values=[], return_label_pairs=True)
if not len(border_indices):
sys.exit('There are no label border points!')
# Initialize an array of label border IDs
# (label border vertices that define sulci in the labeling protocol):
print('Build an array of label border IDs...')
label_borders = -1 * np.ones(npoints)
if hemi == 'lh':
nsulcus_lists = len(dkt.left_sulcus_label_pair_lists)
else:
nsulcus_lists = len(dkt.right_sulcus_label_pair_lists)
feature_to_border_mean_distances = -1 * np.ones(nsulcus_lists)
feature_to_border_sd_distances = -1 * np.ones(nsulcus_lists)
border_to_feature_mean_distances = -1 * np.ones(nsulcus_lists)
border_to_feature_sd_distances = -1 * np.ones(nsulcus_lists)
feature_to_border_distances_vtk = ''
border_to_feature_distances_vtk = ''
#-------------------------------------------------------------------------
# Loop through sulci:
#-------------------------------------------------------------------------
# For each list of sorted label pairs (corresponding to a sulcus):
for isulcus, label_pairs in enumerate(dkt.sulcus_label_pair_lists):
# Keep the border points with label pair labels:
label_pair_border_indices = [
x for i, x in enumerate(border_indices)
if np.unique(border_label_tuples[i]).tolist() in label_pairs
]
# Store the points as sulcus IDs in the border IDs array:
if label_pair_border_indices:
label_borders[label_pair_border_indices] = isulcus
if len(np.unique(label_borders)) > 1:
#---------------------------------------------------------------------
# Construct a feature-to-border distance matrix and VTK file:
#---------------------------------------------------------------------
# Construct a distance matrix:
print('Construct a feature-to-border distance matrix...')
sourceIDs = features
targetIDs = label_borders
distances, distance_matrix = source_to_target_distances(
sourceIDs, targetIDs, points, segmentIDs, excludeIDs)
# Compute mean distances for each feature:
nfeatures = min(np.shape(distance_matrix)[1], nsulcus_lists)
for ifeature in range(nfeatures):
feature_distances = [
x for x in distance_matrix[:, ifeature] if x != -1
]
feature_to_border_mean_distances[ifeature] = \
np.mean(feature_distances)
feature_to_border_sd_distances[ifeature] = \
np.std(feature_distances)
if verbose:
print('Feature-to-border mean distances:')
print(feature_to_border_mean_distances)
print('Feature-to-border standard deviations of distances:')
print(feature_to_border_sd_distances)
# Write resulting feature-label border distances to VTK file:
if output_vtk_name:
feature_to_border_distances_vtk = os.path.join(
os.getcwd(),
output_vtk_name + '_feature_to_border_mean_distances.vtk')
print('Write feature-to-border distances to {0}...'.format(
feature_to_border_distances_vtk))
write_vtk(feature_to_border_distances_vtk, points, [], [],
sulcus_faces, [distances],
['feature-to-border_distances'], 'float')
#---------------------------------------------------------------------
# Construct a border-to-feature distance matrix and VTK file:
#---------------------------------------------------------------------
# Construct a distance matrix:
print('Construct a border-to-feature distance matrix...')
sourceIDs = label_borders
targetIDs = features
distances, distance_matrix = source_to_target_distances(
sourceIDs, targetIDs, points, segmentIDs, excludeIDs)
# Compute mean distances for each feature:
nfeatures = min(np.shape(distance_matrix)[1], nsulcus_lists)
for ifeature in range(nfeatures):
border_distances = [
x for x in distance_matrix[:, ifeature] if x != -1
]
border_to_feature_mean_distances[ifeature] = \
np.mean(border_distances)
border_to_feature_sd_distances[ifeature] = \
np.std(border_distances)
if verbose:
print('border-to-feature mean distances:')
print(border_to_feature_mean_distances)
print('border-to-feature standard deviations of distances:')
print(border_to_feature_sd_distances)
# Write resulting feature-label border distances to VTK file:
if output_vtk_name:
border_to_feature_distances_vtk = os.path.join(
os.getcwd(),
output_vtk_name + '_border_to_feature_mean_distances.vtk')
print('Write border-to-feature distances to {0}...'.format(
border_to_feature_distances_vtk))
write_vtk(border_to_feature_distances_vtk, points, [], [],
sulcus_faces, [distances],
['border-to-feature_distances'], 'float')
#-------------------------------------------------------------------------
# Return outputs:
#-------------------------------------------------------------------------
return feature_to_border_mean_distances, feature_to_border_sd_distances,\
feature_to_border_distances_vtk,\
border_to_feature_mean_distances, border_to_feature_sd_distances,\
border_to_feature_distances_vtk
def evaluate_deep_features(features_file, labels_file, sulci_file='', hemi='',
excludeIDs=[-1], output_vtk_name='', verbose=True):
"""
Evaluate deep surface features by computing the minimum distance from each
label boundary vertex to all of the feature vertices in the same sulcus,
and from each feature vertex to all of the label boundary vertices in the
same sulcus. The label boundaries run along the deepest parts of sulci
and correspond to fundi in the DKT cortical labeling protocol.
Parameters
----------
features_file : string
VTK surface file with feature numbers for vertex scalars
labels_file : string
VTK surface file with label numbers for vertex scalars
sulci_file : string
VTK surface file with sulcus numbers for vertex scalars
excludeIDs : list of integers
feature/sulcus/label IDs to exclude (background set to -1)
output_vtk_name : Boolean
if not empty, output a VTK file beginning with output_vtk_name that
contains a surface with mean distances as scalars
verbose : Boolean
print mean distances to standard output?
Returns
-------
feature_to_fundus_mean_distances : numpy array [number of features x 1]
mean distance from each feature to sulcus label boundary ("fundus")
feature_to_fundus_sd_distances : numpy array [number of features x 1]
standard deviations of feature-to-fundus distances
feature_to_fundus_mean_distances_vtk : string
VTK surface file containing feature_to_fundus_mean_distances
fundus_to_feature_mean_distances : numpy array [number of features x 1]
mean distances from each sulcus label boundary ("fundus") to feature
fundus_to_feature_sd_distances : numpy array [number of features x 1]
standard deviations of fundus-to-feature distances
fundus_to_feature_mean_distances_vtk : string
VTK surface file containing fundus_to_feature_mean_distances
"""
import os
import sys
import numpy as np
from mindboggle.utils.io_vtk import read_vtk, read_scalars, write_vtk
from mindboggle.utils.mesh import find_neighbors, remove_faces
from mindboggle.utils.segment import extract_borders
from mindboggle.utils.compute import source_to_target_distances
from mindboggle.LABELS import DKTprotocol
dkt = DKTprotocol()
#-------------------------------------------------------------------------
# Load labels, features, and sulci:
#-------------------------------------------------------------------------
faces, lines, indices, points, npoints, labels, scalar_names, \
input_vtk = read_vtk(labels_file, True, True)
features, name = read_scalars(features_file, True, True)
if sulci_file:
sulci, name = read_scalars(sulci_file, True, True)
# List of indices to sulcus vertices:
sulcus_indices = [i for i,x in enumerate(sulci) if x != -1]
segmentIDs = sulci
sulcus_faces = remove_faces(faces, sulcus_indices)
else:
sulcus_indices = range(len(labels))
segmentIDs = []
sulcus_faces = faces
#-------------------------------------------------------------------------
# Prepare neighbors, label pairs, fundus IDs, and outputs:
#-------------------------------------------------------------------------
# Calculate neighbor lists for all points:
print('Find neighbors to all vertices...')
neighbor_lists = find_neighbors(faces, npoints)
# Find label boundary points in any of the sulci:
print('Find label boundary points in any of the sulci...')
border_indices, border_label_tuples, unique_border_label_tuples = \
extract_borders(sulcus_indices, labels, neighbor_lists,
ignore_values=[], return_label_pairs=True)
if not len(border_indices):
sys.exit('There are no label boundary points!')
# Initialize an array of label boundaries fundus IDs
# (label boundary vertices that define sulci in the labeling protocol):
print('Build an array of label boundary fundus IDs...')
label_boundary_fundi = -1 * np.ones(npoints)
if hemi == 'lh':
nsulcus_lists = len(dkt.left_sulcus_label_pair_lists)
else:
nsulcus_lists = len(dkt.right_sulcus_label_pair_lists)
feature_to_fundus_mean_distances = -1 * np.ones(nsulcus_lists)
feature_to_fundus_sd_distances = -1 * np.ones(nsulcus_lists)
fundus_to_feature_mean_distances = -1 * np.ones(nsulcus_lists)
fundus_to_feature_sd_distances = -1 * np.ones(nsulcus_lists)
feature_to_fundus_mean_distances_vtk = ''
fundus_to_feature_mean_distances_vtk = ''
#-------------------------------------------------------------------------
# Loop through sulci:
#-------------------------------------------------------------------------
# For each list of sorted label pairs (corresponding to a sulcus):
for isulcus, label_pairs in enumerate(dkt.sulcus_label_pair_lists):
# Keep the boundary points with label pair labels:
fundus_indices = [x for i,x in enumerate(border_indices)
if np.unique(border_label_tuples[i]).tolist()
in label_pairs]
# Store the points as sulcus IDs in the fundus IDs array:
if fundus_indices:
label_boundary_fundi[fundus_indices] = isulcus
if len(np.unique(label_boundary_fundi)) > 1:
#---------------------------------------------------------------------
# Construct a feature-to-fundus distance matrix and VTK file:
#---------------------------------------------------------------------
# Construct a distance matrix:
print('Construct a feature-to-fundus distance matrix...')
sourceIDs = features
targetIDs = label_boundary_fundi
distances, distance_matrix = source_to_target_distances(
sourceIDs, targetIDs, points, segmentIDs, excludeIDs)
# Compute mean distances for each feature:
nfeatures = min(np.shape(distance_matrix)[1], nsulcus_lists)
for ifeature in range(nfeatures):
feature_distances = [x for x in distance_matrix[:, ifeature]
if x != -1]
feature_to_fundus_mean_distances[ifeature] = \
np.mean(feature_distances)
feature_to_fundus_sd_distances[ifeature] = \
np.std(feature_distances)
if verbose:
print('Feature-to-fundus mean distances:')
print(feature_to_fundus_mean_distances)
print('Feature-to-fundus standard deviations of distances:')
print(feature_to_fundus_sd_distances)
# Write resulting feature-label boundary distances to VTK file:
if output_vtk_name:
feature_to_fundus_mean_distances_vtk = os.path.join(os.getcwd(),
output_vtk_name + '_feature_to_fundus_mean_distances.vtk')
print('Write feature-to-fundus distances to {0}...'.
format(feature_to_fundus_mean_distances_vtk))
write_vtk(feature_to_fundus_mean_distances_vtk, points,
[], [], sulcus_faces, [distances],
['feature-to-fundus_distances'], 'float')
#---------------------------------------------------------------------
# Construct a fundus-to-feature distance matrix and VTK file:
#---------------------------------------------------------------------
# Construct a distance matrix:
print('Construct a fundus-to-feature distance matrix...')
sourceIDs = label_boundary_fundi
targetIDs = features
distances, distance_matrix = source_to_target_distances(
sourceIDs, targetIDs, points, segmentIDs, excludeIDs)
# Compute mean distances for each feature:
nfeatures = min(np.shape(distance_matrix)[1], nsulcus_lists)
for ifeature in range(nfeatures):
fundus_distances = [x for x in distance_matrix[:, ifeature]
if x != -1]
fundus_to_feature_mean_distances[ifeature] = \
np.mean(fundus_distances)
fundus_to_feature_sd_distances[ifeature] = \
np.std(fundus_distances)
if verbose:
print('Fundus-to-feature mean distances:')
print(fundus_to_feature_mean_distances)
print('Fundus-to-feature standard deviations of distances:')
print(fundus_to_feature_sd_distances)
# Write resulting feature-label boundary distances to VTK file:
if output_vtk_name:
fundus_to_feature_mean_distances_vtk = os.path.join(os.getcwd(),
output_vtk_name + '_fundus_to_feature_mean_distances.vtk')
print('Write fundus-to-feature distances to {0}...'.
format(fundus_to_feature_mean_distances_vtk))
write_vtk(fundus_to_feature_mean_distances_vtk, points,
[], [], sulcus_faces, [distances],
['fundus-to-feature_distances'], 'float')
#-------------------------------------------------------------------------
# Return outputs:
#-------------------------------------------------------------------------
return feature_to_fundus_mean_distances, feature_to_fundus_sd_distances,\
feature_to_fundus_mean_distances_vtk,\
fundus_to_feature_mean_distances, fundus_to_feature_sd_distances,\
fundus_to_feature_mean_distances_vtk
def _label_components(component_faces, num_points, boundary_indices,
boundary_probability_matrix, boundary_matrix_keys):
"""Label the connected components of a surface with the most
probable label based on the boundary_probability_matrix.
"""
import numpy as np
from mindboggle.utils.mesh import find_neighbors
neighbor_lists = find_neighbors(component_faces, num_points)
result_labels = -1 * np.ones((num_points))
# find all the connected components
point_visited = num_points * [False]
components = {}
component_boundaries = {}
print "Finding connected components"
while True:
first_vertex = None
try:
first_vertex = next(i for i, v in enumerate(point_visited)
if not v)
except:
break
open_vertices = [first_vertex]
point_visited[first_vertex] = True
component_vertices = []
component_boundary_vertices = []
while len(open_vertices) > 0:
this_vertex = open_vertices.pop()
component_vertices.append(this_vertex)
if this_vertex in boundary_indices:
component_boundary_vertices.append(this_vertex)
for neighbor in neighbor_lists[this_vertex]:
if not point_visited[neighbor]:
open_vertices.append(neighbor)
point_visited[neighbor] = True
components[len(component_vertices)] = component_vertices
component_boundaries[len(component_vertices)] = \
component_boundary_vertices
# compute the most probable label for each connected
# component. Only boundary indices are considered when computing
# label probability.
# Note: Here we assume that components and component_boundaries
# have the same keys.
used_labels = []
print "Computing most probable labels"
for component in sorted(components.keys(), None, None, True):
label_likelihoods = {}
for vertex in component_boundaries[component]:
for index, boundary_prob in \
enumerate(boundary_probability_matrix[vertex]):
labels = boundary_matrix_keys[index]
for label in labels:
# if label in used_labels:
# continue
if label not in label_likelihoods:
label_likelihoods[label] = 0
label_likelihoods[label] += boundary_prob
# assign the most likely label
max_label = None
max_label_likelihood = None
for key, val in label_likelihoods.iteritems():
if max_label is None or val > max_label_likelihood:
max_label = key
max_label_likelihood = val
if max_label is not None:
result_labels[components[component]] = max_label
used_labels.append(max_label)
return result_labels
def realign_boundaries_to_fundus_lines(
surf_file, init_label_file, fundus_lines_file, thickness_file,
out_label_file=None):
"""
Fix label boundaries to fundus lines.
Parameters
----------
surf_file : file containing the surface geometry in vtk format
init_label_file : file containing scalars that represent the
initial guess at labels
fundus_lines_file : file containing scalars representing fundus lines.
thickness_file: file containing cortical thickness scalar data
(for masking out the medial wall only)
out_label_file : if specified, the realigned labels will be writen to
this file
Returns
-------
numpy array representing the realigned label for each surface vertex.
"""
import numpy as np
from mindboggle.utils.segment import extract_borders
import mindboggle.utils.graph as go
from mindboggle.utils.io_vtk import read_vtk, read_scalars, write_vtk
from mindboggle.utils.mesh import find_neighbors
import propagate_fundus_lines
## read files
faces, _, indices, points, num_points, _, _, _ = read_vtk(
surf_file, return_first=True, return_array=True)
indices = range(num_points)
init_labels, _ = read_scalars(init_label_file,
return_first=True, return_array=True)
fundus_lines, _ = read_scalars(fundus_lines_file,
return_first=True, return_array=True)
thickness, _ = read_scalars(thickness_file,
return_first=True, return_array=True)
# remove labels from vertices with zero thickness (get around
# DKT40 annotations having the label '3' for all the Corpus
# Callosum vertices).
cc_inds = [x for x in indices if thickness[x] < 0.001]
init_labels[cc_inds] = 0
## setup seeds from initial label boundaries
neighbor_lists = find_neighbors(faces, num_points)
# extract all vertices that are on a boundary between labels
boundary_indices, label_pairs, _ = extract_borders(
indices, init_labels, neighbor_lists,
return_label_pairs=True)
# split boundary vertices into segments with common boundary pairs.
boundary_segments = {}
for boundary_index, label_pair in zip(boundary_indices, label_pairs):
key = ((label_pair[0], label_pair[1]) if label_pair[0] < label_pair[1]
else (label_pair[1], label_pair[0]))
if key not in boundary_segments:
boundary_segments[key] = []
boundary_segments[key].append(boundary_index)
boundary_matrix, boundary_matrix_keys = _build_boundary_matrix(
boundary_segments, num_points)
# build the affinity matrix
affinity_matrix = go.weight_graph(
np.array(points), indices, np.array(faces), sigma=10, add_to_graph=False)
## propagate boundaries to fundus line vertices
learned_matrix = _propagate_labels(
affinity_matrix, boundary_matrix, boundary_indices, 100, 1)
# assign labels to fundus line vertices based on highest probability
new_boundaries = -1 * np.ones(init_labels.shape)
fundus_line_indices = [i for i, x in enumerate(fundus_lines) if x > 0.5]
# tile the surface into connected components delimited by fundus lines
closed_fundus_lines, _, _ = propagate_fundus_lines.propagate_fundus_lines(
points, faces, fundus_line_indices, thickness)
closed_fundus_line_indices = np.where(closed_fundus_lines > 0)[0]
# split surface into connected components
connected_component_faces = _remove_boundary_faces(
points, faces, closed_fundus_line_indices)
# label components based on most probable label assignment
new_labels = _label_components(
connected_component_faces, num_points, boundary_indices, learned_matrix,
boundary_matrix_keys)
# propagate new labels to fill holes
label_matrix, label_map = _build_label_matrix(new_labels)
new_learned_matrix = _propagate_labels(
affinity_matrix, label_matrix,
[i for i in range(num_points) if new_labels[i] >= 0], 100, 1)
# assign most probable labels
for idx in [i for i in range(num_points) if new_labels[i] == -1]:
max_idx = np.argmax(new_learned_matrix[idx])
new_labels[idx] = label_map[max_idx]
# save
if out_label_file is not None:
write_vtk(out_label_file, points, faces=faces,
scalars=[int(x) for x in new_labels], scalar_type='int')
return new_labels
def extract_subfolds(depth_file, folds, min_size=10, depth_factor=0.25,
depth_ratio=0.1, tolerance=0.01, save_file=False):
"""
Use depth to segment folds into subfolds in a triangular surface mesh.
Note ::
The function extract_sulci() performs about the same whether folds
or subfolds are used as input. The latter leads to some loss of
small subfolds and possibly holes for small subfolds in the middle
of other subfolds.
Note about the watershed() function:
The watershed() function performs individual seed growing from deep seeds,
repeats segmentation from the resulting seeds until each seed's segment
touches a boundary. The function segment() fills in the rest. Finally
segments are joined if their seeds are too close to each other.
Despite these precautions, the order of seed selection in segment() could
possibly influence the resulting borders between adjoining segments.
[The propagate() function is slower and insensitive to depth,
but is not biased by seed order.]
Parameters
----------
depth_file : string
surface mesh file in VTK format with faces and depth scalar values
folds : list of integers
fold numbers for all vertices (-1 for non-fold vertices)
min_size : integer
minimum number of vertices for a subfold
depth_factor : float
watershed() depth_factor:
factor to determine whether to merge two neighboring watershed catchment
basins -- they are merged if the Euclidean distance between their basin
seeds is less than this fraction of the maximum Euclidean distance
between points having minimum and maximum depths
depth_ratio : float
watershed() depth_ratio:
the minimum fraction of depth for a neighboring shallower
watershed catchment basin (otherwise merged with the deeper basin)
tolerance : float
watershed() tolerance:
tolerance for detecting differences in depth between vertices
save_file : Boolean
save output VTK file?
Returns
-------
subfolds : list of integers
fold numbers for all vertices (-1 for non-fold vertices)
n_subfolds : int
number of subfolds
subfolds_file : string (if save_file)
name of output VTK file with fold IDs (-1 for non-fold vertices)
Examples
--------
>>> import os
>>> from mindboggle.utils.io_vtk import read_scalars, rewrite_scalars
>>> from mindboggle.utils.mesh import find_neighbors_from_file
>>> from mindboggle.features.folds import extract_subfolds
>>> from mindboggle.utils.plots import plot_vtk
>>> path = os.environ['MINDBOGGLE_DATA']
>>> depth_file = os.path.join(path, 'arno', 'shapes', 'lh.pial.travel_depth.vtk')
>>> folds_file = os.path.join(path, 'arno', 'features', 'folds.vtk')
>>> folds, name = read_scalars(folds_file)
>>> min_size = 10
>>> depth_factor = 0.5
>>> depth_ratio = 0.1
>>> tolerance = 0.01
>>> #
>>> subfolds, n_subfolds, subfolds_file = extract_subfolds(depth_file,
>>> folds, min_size, depth_factor, depth_ratio, tolerance, True)
>>> #
>>> # View:
>>> rewrite_scalars(depth_file, 'subfolds.vtk', subfolds, 'subfolds', subfolds)
>>> plot_vtk('subfolds.vtk')
"""
import os
import numpy as np
from time import time
from mindboggle.utils.io_vtk import rewrite_scalars, read_vtk
from mindboggle.utils.mesh import find_neighbors
from mindboggle.utils.segment import segment, propagate, watershed
print("Segment folds into subfolds")
t0 = time()
#-------------------------------------------------------------------------
# Load depth values for all vertices
#-------------------------------------------------------------------------
faces, lines, indices, points, npoints, depths, \
name, input_vtk = read_vtk(depth_file, return_first=True, return_array=True)
#-------------------------------------------------------------------------
# Find neighbors for each vertex
#-------------------------------------------------------------------------
neighbor_lists = find_neighbors(faces, npoints)
#-------------------------------------------------------------------------
# Segment folds into "watershed basins"
#-------------------------------------------------------------------------
indices_folds = [i for i,x in enumerate(folds) if x > -1]
subfolds, seed_indices = watershed(depths, points, indices_folds,
neighbor_lists, min_size, depth_factor=0.25,
depth_ratio=0.1, tolerance=0.01, regrow=True)
# Print statement
n_subfolds = len([x for x in np.unique(subfolds) if x != -1])
print(' ...Extracted {0} subfolds ({1:.2f} seconds)'.
format(n_subfolds, time() - t0))
#-------------------------------------------------------------------------
# Return subfolds, number of subfolds, file name
#-------------------------------------------------------------------------
if save_file:
subfolds_file = os.path.join(os.getcwd(), 'subfolds.vtk')
rewrite_scalars(depth_file, subfolds_file, subfolds, 'subfolds', subfolds)
if not os.path.exists(subfolds_file):
raise(IOError(subfolds_file + " not found"))
else:
subfolds_file = None
return subfolds, n_subfolds, subfolds_file
def _label_components(component_faces, num_points, boundary_indices,
boundary_probability_matrix, boundary_matrix_keys):
"""Label the connected components of a surface with the most
probable label based on the boundary_probability_matrix.
"""
import numpy as np
from mindboggle.utils.mesh import find_neighbors
neighbor_lists = find_neighbors(component_faces, num_points)
result_labels = -1 * np.ones((num_points))
# find all the connected components
point_visited = num_points * [False]
components = {}
component_boundaries = {}
print "Finding connected components"
while True:
first_vertex = None
try:
first_vertex = next(i for i, v in enumerate(point_visited) if not v)
except:
break
open_vertices = [first_vertex]
point_visited[first_vertex] = True
component_vertices = []
component_boundary_vertices = []
while len(open_vertices) > 0:
this_vertex = open_vertices.pop()
component_vertices.append(this_vertex)
if this_vertex in boundary_indices:
component_boundary_vertices.append(this_vertex)
for neighbor in neighbor_lists[this_vertex]:
if not point_visited[neighbor]:
open_vertices.append(neighbor)
point_visited[neighbor] = True
components[len(component_vertices)] = component_vertices
component_boundaries[len(component_vertices)] = \
component_boundary_vertices
# compute the most probable label for each connected
# component. Only boundary indices are considered when computing
# label probability.
# Note: Here we assume that components and component_boundaries
# have the same keys.
used_labels = []
print "Computing most probable labels"
for component in sorted(components.keys(), None, None, True):
label_likelihoods = {}
for vertex in component_boundaries[component]:
for index, boundary_prob in \
enumerate(boundary_probability_matrix[vertex]):
labels = boundary_matrix_keys[index]
for label in labels:
# if label in used_labels:
# continue
if label not in label_likelihoods:
label_likelihoods[label] = 0
label_likelihoods[label] += boundary_prob
# assign the most likely label
max_label = None
max_label_likelihood = None
for key, val in label_likelihoods.iteritems():
if max_label is None or val > max_label_likelihood:
max_label = key
max_label_likelihood = val
if max_label is not None:
result_labels[components[component]] = max_label
used_labels.append(max_label)
return result_labels
def close_surface_pair(faces, points1, points2, scalars, background_value=-1):
"""
Close a surface patch by connecting its border vertices with
corresponding vertices in a second surface file.
Assumes no lines or indices when reading VTK files in.
Note ::
Scalar values different than background define the surface patch.
The two sets of points have a 1-to-1 mapping; they are from
two surfaces whose corresponding vertices are shifted in position.
For pial vs. gray-white matter, the two surfaces are not parallel,
so connecting the vertices leads to intersecting faces.
Parameters
----------
faces : list of lists of integers
each sublist contains 3 indices of vertices that form a face
on a surface mesh
points1 : list of lists of floats
each sublist contains 3-D coordinates of a vertex on a surface mesh
points2 : list of lists of floats
points from second surface with 1-to-1 correspondence with points1
scalars : numpy array of integers
labels used to find foreground vertices
background_value : integer
scalar value for background vertices
Returns
-------
closed_faces : list of lists of integers
indices of vertices that form a face on the closed surface mesh
closed_points : list of lists of floats
3-D coordinates from points1 and points2
closed_scalars : list of integers
scalar values for points1 and points2
Examples
--------
>>> # Example 1: build a cube by closing two parallel planes:
>>> import os
>>> from mindboggle.utils.morph import close_surface_pair
>>> from mindboggle.utils.plots import plot_surfaces
>>> from mindboggle.utils.io_vtk import write_vtk
>>> # Build plane:
>>> background_value = -1
>>> n = 10 # plane edge length
>>> points1 = []
>>> for x in range(n):
>>> for y in range(n):
>>> points1.append([x,y,0])
>>> points2 = [[x[0],x[1],1] for x in points1]
>>> scalars = [background_value for x in range(len(points1))]
>>> p = n*(n-1)/2 - 1
>>> for i in [p, p+1, p+n, p+n+1]:
>>> scalars[i] = 1
>>> faces = []
>>> for x in range(n-1):
>>> for y in range(n-1):
>>> faces.append([x+y*n,x+n+y*n,x+n+1+y*n])
>>> faces.append([x+y*n,x+1+y*n,x+n+1+y*n])
>>> #write_vtk('plane.vtk', points1, [], [], faces, scalars)
>>> #plot_surfaces('plane.vtk') # doctest: +SKIP
>>> closed_faces, closed_points, closed_scalars = close_surface_pair(faces, points1, points2, scalars, background_value)
>>> # View:
>>> write_vtk('cube.vtk', closed_points, [], [], closed_faces, closed_scalars, 'int')
>>> plot_surfaces('cube.vtk') # doctest: +SKIP
>>> #
>>> # Example 2: Gray and white cortical brain surfaces:
>>> import os
>>> from mindboggle.utils.morph import close_surface_pair
>>> from mindboggle.utils.plots import plot_surfaces
>>> from mindboggle.utils.io_vtk import read_scalars, read_vtk, read_points, write_vtk
>>> path = os.environ['MINDBOGGLE_DATA']
>>> patch_surface1 = 'fold.pial.vtk'
>>> whole_surface2 = 'fold.white.vtk'
>>> # Select a single fold:
>>> folds_file = os.path.join(path, 'arno', 'features', 'folds.vtk')
>>> points1 = read_points(folds_file)
>>> scalars, name = read_scalars(folds_file, True, True)
>>> fold_number = 11
>>> scalars[scalars != fold_number] = -1
>>> white_surface = os.path.join(path, 'arno', 'freesurfer', 'lh.white.vtk')
>>> faces, u1, u2, points2, N, u3, u4, u5 = read_vtk(white_surface)
>>> background_value = -1
>>> closed_faces, closed_points, closed_scalars = close_surface_pair(faces, points1, points2, scalars, background_value)
>>> # View:
>>> write_vtk('closed.vtk', closed_points, [], [], closed_faces, closed_scalars, name, 'int')
>>> plot_surfaces('closed.vtk') # doctest: +SKIP
"""
import sys
import numpy as np
from mindboggle.utils.mesh import find_neighbors, remove_faces
from mindboggle.utils.segment import extract_borders
if isinstance(scalars, list):
scalars = np.array(scalars)
N = len(points1)
closed_points = points1 + points2
# Find all vertex neighbors and surface patch border vertices:
neighbor_lists = find_neighbors(faces, N)
I = np.where(scalars != background_value)[0]
scalars[scalars == background_value] = background_value + 1
scalars[I] = background_value + 2
scalars = scalars.tolist()
borders, u1, u2 = extract_borders(range(N), scalars, neighbor_lists)
if not len(borders):
sys.exit('There are no border vertices!')
borders = [x for x in borders if x in I]
# Reindex copy of faces and combine with original (both zero-index):
indices = range(N)
indices2 = range(N, 2 * N)
reindex = dict([(index, indices2[i]) for i, index in enumerate(indices)])
faces = remove_faces(faces, I)
faces2 = [[reindex[i] for i in face] for face in faces]
closed_faces = faces + faces2
# Connect border vertices between surface patches and add new faces:
add_faces = []
taken_already = []
for index in borders:
if index not in taken_already:
neighbors = list(set(neighbor_lists[index]).intersection(borders))
taken_already.append(index)
#taken_already.extend([index] + neighbors)
for neighbor in neighbors:
add_faces.append([index, index + N, neighbor])
add_faces.append([index + N, neighbor, neighbor + N])
closed_faces = closed_faces + add_faces
closed_scalars = scalars * 2
return closed_faces, closed_points, closed_scalars
def extract_folds(depth_file,
min_fold_size=50,
tiny_depth=0.001,
save_file=False):
"""
Use depth to extract folds from a triangular surface mesh.
Steps ::
1. Compute histogram of depth measures.
2. Define a depth threshold and find the deepest vertices.
3. Segment deep vertices as an initial set of folds.
4. Remove small folds.
5. Find and fill holes in the folds.
6. Renumber folds.
Step 2 ::
To extract an initial set of deep vertices from the surface mesh,
we anticipate that there will be a rapidly decreasing distribution
of low depth values (on the outer surface) with a long tail
of higher depth values (in the folds), so we smooth the histogram's
bin values, convolve to compute slopes, and find the depth value
for the first bin with slope = 0. This is our threshold.
Step 5 ::
The folds could have holes in areas shallower than the depth threshold.
Calling fill_holes() could accidentally include very shallow areas
(in an annulus-shaped fold, for example), so we call fill_holes() with
the argument exclude_range set close to zero to retain these areas.
Parameters
----------
depth_file : string
surface mesh file in VTK format with faces and depth scalar values
min_fold_size : integer
minimum fold size (number of vertices)
tiny_depth : float
largest non-zero depth value that will stop a hole from being filled
save_file : Boolean
save output VTK file?
Returns
-------
folds : list of integers
fold numbers for all vertices (-1 for non-fold vertices)
n_folds : int
number of folds
depth_threshold : float
threshold defining the minimum depth for vertices to be in a fold
bins : list of integers
histogram bins: each is the number of vertices within a range of depth values
bin_edges : list of floats
histogram bin edge values defining the bin ranges of depth values
folds_file : string (if save_file)
name of output VTK file with fold IDs (-1 for non-fold vertices)
Examples
--------
>>> import os
>>> import numpy as np
>>> import pylab
>>> from scipy.ndimage.filters import gaussian_filter1d
>>> from mindboggle.utils.io_vtk import read_scalars
>>> from mindboggle.utils.mesh import find_neighbors_from_file
>>> from mindboggle.utils.plots import plot_surfaces
>>> from mindboggle.features.folds import extract_folds
>>> path = os.environ['MINDBOGGLE_DATA']
>>> depth_file = os.path.join(path, 'arno', 'shapes', 'lh.pial.travel_depth.vtk')
>>> neighbor_lists = find_neighbors_from_file(depth_file)
>>> min_fold_size = 50
>>> tiny_depth = 0.001
>>> save_file = True
>>> #
>>> folds, n_folds, thr, bins, bin_edges, folds_file = extract_folds(depth_file,
>>> min_fold_size, tiny_depth, save_file)
>>> #
>>> # View folds:
>>> plot_surfaces('folds.vtk')
>>> # Plot histogram and depth threshold:
>>> depths, name = read_scalars(depth_file)
>>> nbins = np.round(len(depths) / 100.0)
>>> a,b,c = pylab.hist(depths, bins=nbins)
>>> pylab.plot(thr*np.ones((100,1)), np.linspace(0, max(bins), 100), 'r.')
>>> pylab.show()
>>> # Plot smoothed histogram:
>>> bins_smooth = gaussian_filter1d(bins.tolist(), 5)
>>> pylab.plot(range(len(bins)), bins, '.', range(len(bins)), bins_smooth,'-')
>>> pylab.show()
"""
import os
import sys
import numpy as np
from time import time
from scipy.ndimage.filters import gaussian_filter1d
from mindboggle.utils.io_vtk import rewrite_scalars, read_vtk
from mindboggle.utils.mesh import find_neighbors
from mindboggle.utils.morph import fill_holes
from mindboggle.utils.segment import segment
do_fill_holes = True
print("Extract folds in surface mesh")
t0 = time()
#-------------------------------------------------------------------------
# Load depth values for all vertices
#-------------------------------------------------------------------------
faces, lines, indices, points, npoints, depths, name, input_vtk = read_vtk(
depth_file, return_first=True, return_array=True)
#-------------------------------------------------------------------------
# Find neighbors for each vertex
#-------------------------------------------------------------------------
neighbor_lists = find_neighbors(faces, npoints)
#-------------------------------------------------------------------------
# Compute histogram of depth measures
#-------------------------------------------------------------------------
min_vertices = 10000
if npoints > min_vertices:
nbins = np.round(npoints / 100.0)
else:
sys.err(" Expecting at least {0} vertices to create depth histogram".
format(min_vertices))
bins, bin_edges = np.histogram(depths, bins=nbins)
#-------------------------------------------------------------------------
# Anticipating that there will be a rapidly decreasing distribution
# of low depth values (on the outer surface) with a long tail of higher
# depth values (in the folds), smooth the bin values (Gaussian), convolve
# to compute slopes, and find the depth for the first bin with slope = 0.
#-------------------------------------------------------------------------
bins_smooth = gaussian_filter1d(bins.tolist(), 5)
window = [-1, 0, 1]
bin_slopes = np.convolve(bins_smooth, window,
mode='same') / (len(window) - 1)
ibins0 = np.where(bin_slopes == 0)[0]
if ibins0.shape:
depth_threshold = bin_edges[ibins0[0]]
else:
depth_threshold = np.median(depths)
#-------------------------------------------------------------------------
# Find the deepest vertices
#-------------------------------------------------------------------------
indices_deep = [i for i, x in enumerate(depths) if x >= depth_threshold]
if indices_deep:
#---------------------------------------------------------------------
# Segment deep vertices as an initial set of folds
#---------------------------------------------------------------------
print(" Segment vertices deeper than {0:.2f} as folds".format(
depth_threshold))
t1 = time()
folds = segment(indices_deep, neighbor_lists)
# Slightly slower alternative -- fill boundaries:
#regions = -1 * np.ones(len(points))
#regions[indices_deep] = 1
#folds = segment_by_filling_borders(regions, neighbor_lists)
print(' ...Segmented folds ({0:.2f} seconds)'.format(time() - t1))
#---------------------------------------------------------------------
# Remove small folds
#---------------------------------------------------------------------
if min_fold_size > 1:
print(' Remove folds smaller than {0}'.format(min_fold_size))
unique_folds = [x for x in np.unique(folds) if x != -1]
for nfold in unique_folds:
indices_fold = [i for i, x in enumerate(folds) if x == nfold]
if len(indices_fold) < min_fold_size:
folds[indices_fold] = -1
#---------------------------------------------------------------------
# Find and fill holes in the folds
# Note: Surfaces surrounded by folds can be mistaken for holes,
# so exclude_range includes outer surface values close to zero.
#---------------------------------------------------------------------
if do_fill_holes:
print(" Find and fill holes in the folds")
folds = fill_holes(folds,
neighbor_lists,
values=depths,
exclude_range=[0, tiny_depth])
#---------------------------------------------------------------------
# Renumber folds so they are sequential
#---------------------------------------------------------------------
renumber_folds = -1 * np.ones(len(folds))
fold_numbers = [int(x) for x in np.unique(folds) if x != -1]
for i_fold, n_fold in enumerate(fold_numbers):
fold = [i for i, x in enumerate(folds) if x == n_fold]
renumber_folds[fold] = i_fold
folds = renumber_folds
n_folds = i_fold + 1
# Print statement
print(' ...Extracted {0} folds ({1:.2f} seconds)'.format(
n_folds,
time() - t0))
else:
print(' No deep vertices')
folds = [int(x) for x in folds]
#-------------------------------------------------------------------------
# Return folds, number of folds, file name
#-------------------------------------------------------------------------
if save_file:
folds_file = os.path.join(os.getcwd(), 'folds.vtk')
rewrite_scalars(depth_file, folds_file, folds, 'folds', folds)
if not os.path.exists(folds_file):
raise (IOError(folds_file + " not found"))
else:
folds_file = None
return folds, n_folds, depth_threshold, bins, bin_edges, folds_file