def map_labeling(self,
image=None,
msc=None,
geomsc=None,
labeled_segmentation=None,
invert=True):
if msc is not None:
self.msc = msc
if geomsc is not None:
self.geomsc = geomsc
self.msc = geomsc
self.arc_accuracies = self.geomsc.arc_accuracies
if labeled_segmentation is not None:
self.labeled_segmentation = labeled_segmentation
# This ensures smaller arcs take precedence in the event of
# pixel overlap
sorted_arcs = sorted(self.msc.arcs, key=lambda arc: len(arc.line))
arc_points = []
self.arcs = []
for arc in sorted_arcs:
if (not self.ridge and is_ridge_arc(arc, self.msc)) or (
not self.valley and is_valley_arc(arc, self.msc)):
continue
index = tuple(arc.node_ids) + (len(arc.line), ) #make_arc_id(arc)
arc_points.extend(arc.line)
self.arc_map.extend([index] * len(arc.line))
self.arcs.append(arc)
for arc in self.msc.arcs:
arc.label_accuracy = self.msc_arc_accuracy(
arc=arc,
labeled_segmentation=self.labeled_segmentation,
invert=invert)
return self.labeled_msc
def __init__(self,
fname=None,
blur_sigma=2,
persistence=0,
valley=True,
ridge=True,
construct_msc=True):
self.primal = None
self.dual = None
self.use_valley_arcs = valley
self.use_ridge_arcs = ridge
self.images = {}
super(ArcNeuronTracer, self).__init__(fname, blur_sigma, persistence,
construct_msc)
if not construct_msc:
self.in_arcs = None
self.out_arcs = None
self.msc = None
self.arcs = None
self.arcs = []
self.positive_arcs = None
self.negative_arcs = None
if construct_msc:
for arc in self.msc.arcs:
if (not self.use_ridge_arcs and is_ridge_arc(
arc, self.msc)) or (not self.use_valley_arcs
and is_valley_arc(arc, self.msc)):
continue
self.arcs.append(arc)
def __init__(self,
image,
msc,
selection_radius=10,
valley=True,
ridge=True,
invert=False,
kdtree=False):
# Needed for kdTree on large point sets:
sys.setrecursionlimit(10000)
self.image = image
self.msc = msc
self.msc.arcs = msc.arcs
self.invert = invert
self.selection_radius = selection_radius
self.selection_shape = morphology.disk(self.selection_radius)
self.fat_mask = make_dilated_arc_image(self.image, self.msc,
self.selection_radius,
self.invert)
self.in_color = orange
self.out_color = purple
self.in_arcs = set()
self.out_arcs = set()
self.out_pixels = set()
self.arc_map = []
self.arc_drawings = {}
self.use_valley_arcs = valley
self.use_ridge_arcs = ridge
# This ensures smaller arcs take precedence in the event of
# pixel overlap
sorted_arcs = sorted(self.msc.arcs, key=lambda arc: len(arc.line))
arc_points = []
self.arcs = []
for arc in sorted_arcs:
if (not self.use_ridge_arcs and is_ridge_arc(arc, self.msc)) or (
not self.use_valley_arcs and is_valley_arc(arc, self.msc)):
continue
index = make_arc_id(arc)
arc_points.extend(arc.line)
self.arc_map.extend([index] * len(arc.line))
self.arcs.append(arc)
# only needed for selection ui to choose neighboring arcs
# can cause error with sparse MSC
self.kdtree = None
if kdtree:
self.kdtree = scipy.spatial.KDTree(arc_points, leafsize=1000)
def launch_ui(self, xlims=None, ylims=None):
plt.ion()
self.fig = plt.figure()
plt.imshow(self.image, cmap=plt.cm.Greys_r, zorder=1)
for arc in self.msc.arcs:
if (not self.use_ridge_arcs and is_ridge_arc(arc, self.msc)) or (
not self.use_valley_arcs and is_valley_arc(arc, self.msc)):
continue
arc_index = make_arc_id(arc)
points = np.array(arc.line)
self.arc_drawings[arc_index] = plt.scatter(
points[:, 0],
points[:, 1],
facecolor="none",
edgecolor="none",
s=2,
marker=",",
zorder=3,
)
if arc_index in self.in_arcs:
self.arc_drawings[arc_index].set_facecolor(self.in_color)
self.arc_drawings[arc_index].set_visible(True)
elif arc_index in self.out_arcs:
self.arc_drawings[arc_index].set_facecolor(self.out_color)
self.arc_drawings[arc_index].set_visible(True)
else:
self.arc_drawings[arc_index].set_visible(False)
if self.use_ridge_arcs:
arc_mask = make_mc_arc_mask(self.image, self.msc, False)
plt.imshow(
arc_mask,
cmap="Oranges",
vmin=0,
vmax=4,
interpolation="none",
alpha=0.8,
zorder=2,
)
if self.use_valley_arcs:
arc_mask = make_mc_arc_mask(self.image, self.msc, True)
plt.imshow(
arc_mask,
cmap="Blues",
vmin=0,
vmax=4,
interpolation="none",
alpha=0.8,
zorder=2,
)
extrema_points = [[], [], []]
for node in self.msc.nodes.values():
x, y = node.xy
extrema_points[node.index].append([x, y])
for i, color in enumerate([blue, green, red]):
xy = np.array(extrema_points[i])
plt.scatter(
xy[:, 0],
xy[:, 1],
facecolor=color,
edgecolor="none",
s=1,
marker=",",
zorder=4,
)
plt.gca().set_xlim(0, self.image.shape[1])
plt.gca().set_ylim(self.image.shape[0], 0)
if xlims is not None:
plt.gca().set_xlim(xlims[0], xlims[1])
if ylims is not None:
plt.gca().set_ylim(ylims[1], ylims[0])
self.fig.canvas.mpl_connect("button_press_event", self.on_click)
plt.show(block=True)
in_arcs = []
out_arcs = []
for arc in self.msc.arcs:
index = make_arc_id(arc)
if index in self.in_arcs:
in_arcs.append(arc)
elif index in self.out_arcs:
out_arcs.append(arc)
return (in_arcs, out_arcs, np.array(list(self.out_pixels)))
def draw_binary_segmentation(self,
filename,
msc=None,
invert=False,
reshape_out=True,
dpi=True):
if not msc:
self.msc = msc
black_box = np.zeros(
(self.image.shape[0],
self.image.shape[1])) if not invert else np.zeros(
(self.image.shape[1], self.image.shape[0]))
#print(self.image.shape+(,,3))
fig = plt.imshow(black_box,
cmap='gray',
alpha=None,
interpolation='nearest') #plt.figure() #in
plt.axis('off')
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
for arc in self.msc.arcs:
if (not self.use_ridge_arcs and is_ridge_arc(arc, self.msc)) or (
not self.use_valley_arcs and is_valley_arc(arc, self.msc)):
continue
arc_index = make_arc_id(arc)
if arc_index in self.in_arcs:
points = np.array(arc.line)
arc_drawings[arc_index] = plt.scatter(
points[:, 0],
points[:, 1],
facecolor='white', #self.in_color,
alpha=None,
edgecolor="none",
s=5,
marker=",",
zorder=3,
)
arc_drawings[arc_index].set_visible(True)
elif arc_index in self.out_arcs:
points = np.array(arc.line)
arc_drawings[arc_index] = plt.scatter(
points[:, 0],
points[:, 1],
facecolor='white', #self.out_color,
edgecolor="none",
alpha=None,
s=5,
marker=",",
zorder=3,
)
arc_drawings[arc_index].set_visible(True)
if self.use_ridge_arcs:
arc_mask = make_mc_arc_mask(self.image, self.msc, invert) #False)
plt.imshow(
arc_mask,
cmap="binary",
vmin=0,
vmax=0,
norm=plt.Normalize(vmin=0, vmax=1),
interpolation="nearest",
alpha=None,
zorder=2,
)
if self.use_valley_arcs:
arc_mask = make_mc_arc_mask(self.image, self.msc, invert) #True)
plt.imshow(
arc_mask,
cmap="binary",
vmin=0,
vmax=0,
interpolation="nearest",
alpha=None,
zorder=2,
)
"""
extrema_points = [[], [], []]
for node in self.msc.nodes.values():
x, y = node.xy
extrema_points[node.index].append([x, y])
for i, color in enumerate([blue, green, red]):
xy = np.array(extrema_points[i])
plt.scatter(
xy[:, 0],
xy[:, 1],
facecolor=color,
edgecolor="none",
s=1,
marker=",",
zorder=4,
)
"""
#plt.gca().set_axis_off()
#plt.gca().set_xlim(0, self.image.shape[0])
#plt.gca().set_ylim(self.image.shape[1], 0)
dpi_ = None
if dpi:
if self.image.shape[0] >= 600:
dpi_ = 600
else:
dpi_ = 156
if isinstance(dpi, int):
dpi_ = dpi
plt.savefig(filename,
bbox_inches='tight',
pad_inches=0.0,
dpi=dpi_,
transparent=False,
cmap=None)
img = imageio.imread(filename)
if reshape_out:
if self.image.shape[0] >= 600:
img = Image.fromarray(img).resize(
(img.shape[1] + 9, img.shape[1] - 91 + 5))
else:
img = Image.fromarray(img).resize(
(img.shape[1] + 1, img.shape[0] + 1))
else:
img = Image.fromarray(img).resize(
(img.shape[1] + 1, img.shape[0] + 1)
) #if not invert else Image.fromarray(img).resize((img.shape[0], img.shape[1]))
img = np.array(img)[:, :, 0]
Img = Image.fromarray(img)
Img.save(filename)
plt.close()
in_arcs = []
out_arcs = []
for arc in self.msc.arcs:
index = make_arc_id(arc)
if index in self.in_arcs:
in_arcs.append(arc)
elif index in self.out_arcs:
out_arcs.append(arc)
return (in_arcs, out_arcs, np.array(list(self.out_pixels)))
def write_image(self, filename):
self.fig = plt.figure()
plt.imshow(self.image, cmap=plt.cm.Greys_r, zorder=1)
for arc in self.msc.arcs:
if (not self.use_ridge_arcs and is_ridge_arc(arc, self.msc)) or (
not self.use_valley_arcs and is_valley_arc(arc, self.msc)):
continue
arc_index = make_arc_id(arc)
if arc_index in self.in_arcs:
points = np.array(arc.line)
self.arc_drawings[arc_index] = plt.scatter(
points[:, 0],
points[:, 1],
facecolor=self.in_color,
edgecolor="none",
s=2,
marker=",",
zorder=3,
)
self.arc_drawings[arc_index].set_visible(True)
elif arc_index in self.out_arcs:
points = np.array(arc.line)
self.arc_drawings[arc_index] = plt.scatter(
points[:, 0],
points[:, 1],
facecolor=self.out_color,
edgecolor="none",
s=2,
marker=",",
zorder=3,
)
self.arc_drawings[arc_index].set_visible(True)
if self.use_ridge_arcs:
arc_mask = make_mc_arc_mask(self.image, self.msc, False)
plt.imshow(
arc_mask,
cmap="Oranges",
vmin=0,
vmax=4,
interpolation="none",
alpha=0.8,
zorder=2,
)
if self.use_valley_arcs:
arc_mask = make_mc_arc_mask(self.image, self.msc, True)
plt.imshow(
arc_mask,
cmap="Blues",
vmin=0,
vmax=4,
interpolation="none",
alpha=0.8,
zorder=2,
)
extrema_points = [[], [], []]
for node in self.msc.nodes.values():
x, y = node.xy
extrema_points[node.index].append([x, y])
for i, color in enumerate([blue, green, red]):
xy = np.array(extrema_points[i])
plt.scatter(
xy[:, 0],
xy[:, 1],
facecolor=color,
edgecolor="none",
s=1,
marker=",",
zorder=4,
)
plt.gca().set_xlim(0, self.image.shape[1])
plt.gca().set_ylim(self.image.shape[0], 0)
plt.savefig(filename)
in_arcs = []
out_arcs = []
for arc in self.msc.arcs:
index = make_arc_id(arc)
if index in self.in_arcs:
in_arcs.append(arc)
elif index in self.out_arcs:
out_arcs.append(arc)
return (in_arcs, out_arcs, np.array(list(self.out_pixels)))