Homec4science
Diffusion lineseg (morphology) Browse

R964/fullpipe.py
fb694d0eab72morphology

Last Change
Raw File

fullpipe.py
View Options

import argparse
import os
import tomasikanade as tkf
import numpy as np
from scipy.misc import imread
from u_net import get_unet
from test import segment_image, flow_image
from data import expand
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from scipy.misc import imsave
def points_from_mask(image):
return np.array(np.nonzero(image)).T
def delineate(images, weights_path, full=False, width=128):
shape = images[0].shape
wide_width = int(np.ceil(np.max(shape) / float(width)) * width)
padding = ((0, wide_width - shape[0]), (0, wide_width - shape[1]))
padded = [np.pad(line, padding, mode="symmetric") for line in images]
# padded = [expand(pad) for pad in padded]
if full:
model, inputs, x, center = get_unet(wide_width, wide_width, k=64, conv_per_level=4, classification=True)
model.load_weights(weights_path)
result = []
for padded_image in padded:
segmentation = np.squeeze(model.predict(np.expand_dims(np.expand_dims(padded_image, 0), 0)))
result.append(segmentation)
else:
model, inputs, x, center = get_unet(width, width, k=64, conv_per_level=4, classification=True)
model.load_weights(weights_path)
result = []
for padded_image in padded:
result.append(np.squeeze(segment_image(model, width, padded_image)))
for i, image in enumerate(result):
result[i] = image[:shape[0], :shape[1]]
return result
def find_flow(lines, weights_path, full=False, width=128):
assert len(lines) == 2
shape = lines[0].shape
wide_width = int(np.ceil(np.max(shape) / float(width)) * width)
padding = ((0, wide_width - shape[0]), (0, wide_width - shape[1]))
padded = [np.pad(line, padding, mode="symmetric") for line in lines]
if full:
model, inputs, x, center = get_unet(wide_width, wide_width, k=64, conv_per_level=4, classification=False)
model.load_weights(weights_path)
padded = [expand(pad) for pad in padded]
segmented = np.squeeze(model.predict(expand(np.concatenate((padded[0], padded[1]), axis=0))))
segmented_x, segmented_y = segmented[0], segmented[1]
else:
model, inputs, x, center = get_unet(width, width, k=64, conv_per_level=4, classification=False)
model.load_weights(weights_path)
segmented = flow_image(model, width, padded[0], padded[1])
segmented_x, segmented_y = np.squeeze(segmented[0]), np.squeeze(segmented[1])
segmented_x = segmented_x[:shape[0], :shape[1]]
segmented_y = segmented_y[:shape[0], :shape[1]]
return segmented_x, segmented_y
def reconstruct(images, d_x, d_y):
candidates = [points_from_mask(image) for image in images]
left = []
right = []
for i, point in enumerate(candidates[0]):
right.append(point - [d_y[point[0], point[1]], d_x[point[0], point[1]]])
left.append(point)
left = np.array(left)
right = np.array(right)
tk = tkf.TomasiKanadeFactorization([left, right])
M, S, T, reprojection = tk.findMotionAndShape()
return S
def warp(image, d_x, d_y):
warped = np.zeros(image.shape)
for x in range(image.shape[0]):
for y in range(image.shape[1]):
try:
if np.abs(d_x[x, y]) >= 0.5 and np.abs(d_y[x, y]) >= 0.5:
warped[x - d_y[x, y], y - d_x[x, y]] = 1
except:
print("{}, {}".format(x, y))
pass
return warped
def parse_arguments():
parser = argparse.ArgumentParser(description='Run full pipeline.')
parser.add_argument('i', metavar='i', type=str, nargs=2, help='Two images')
args = parser.parse_args()
paths = args.i
for path in paths:
assert os.path.isfile(path)
return paths
def main():
seg_path = "/Users/sandro/Google Drive/applications/domain_adaption/08_unet_k64_cpl4_100e/2016_11_29_891444weights.h5"
disp_path = "/Users/sandro/Google Drive/applications/domain_adaption/10_disparity/2016_12_5_111229weights.h5"
assert os.path.isfile(seg_path)
assert os.path.isfile(disp_path)
paths = parse_arguments()
print("Computing on image pair: {}, {}".format(paths[0], paths[1]))
print("Loading images")
images = [imread(path, flatten=True).astype(float) for path in paths]
shape = images[0].shape
full = shape[0] * shape[1] < 500 * 500
print("Delineating")
delineations = delineate(images, weights_path=seg_path, width=256, full=False)
[np.savetxt('./delineations{}.txt'.format(i), delineation) for i, delineation in enumerate(delineations)]
delineations = [255 * (delineation - delineation.min()) / (delineation.max() - delineation.min()) for delineation in
delineations]
[imsave("./delineation{}.png".format(i), delineation) for i, delineation in enumerate(delineations)]
# print("Finding flow")
# disparities = find_flow(delineations, weights_path=disp_path, width=256, full=full)
# [np.savetxt('./disparities{}.txt'.format(i), disparity) for i, disparity in enumerate(disparities)]
# disparities = find_flow([delineations[1], delineations[0]], weights_path=disp_path, full=True)
# [np.savetxt('./disparities_opo{}.txt'.format(i), disparity) for i, disparity in enumerate(disparities)]
# print("Reconstructing")
# reconstruction = reconstruct(delineations, *disparities)
# np.savetxt('./reconstruction.txt', reconstruction)
# cmap = 'gray'
# figure, axes = plt.subplots(3, 2, sharex=True, sharey=True)
# axes[0, 0].imshow(images[0], cmap=cmap)
# axes[0, 1].imshow(images[1], cmap=cmap)
# axes[1, 0].imshow(delineations[0], cmap=cmap)
# axes[1, 1].imshow(delineations[1], cmap=cmap)
# axes[2, 0].imshow(disparities[0], cmap=cmap)
# axes[2, 1].imshow(disparities[1], cmap=cmap)
# fig = plt.figure()
# ax = Axes3D(fig)
# ax.scatter(reconstruction[0, :], reconstruction[1, :], reconstruction[2, :])
# plt.show()
#
#
# delineations = np.loadtxt('./delineations0.txt'), np.loadtxt('./delineations1.txt')
# disparities = np.loadtxt('./disparities0.txt'), np.loadtxt('./disparities1.txt')
# disparities_opo = np.loadtxt('./disparities_opo0.txt'), np.loadtxt('./disparities_opo1.txt')
#
# cmap = 'gray'
# figure, axes = plt.subplots(3, 2, sharex=True, sharey=True)
# axes[0, 0].imshow(delineations[0], cmap=cmap, interpolation='nearest')
# axes[0, 1].imshow(delineations[1], cmap=cmap, interpolation='nearest')
# axes[1, 0].imshow(disparities[0], cmap=cmap, interpolation='nearest')
# axes[1, 1].imshow(disparities[1], cmap=cmap, interpolation='nearest')
# axes[2, 0].imshow(warp(delineations[0], disparities[0], disparities[1]) - 0.5 * delineations[1],
# cmap=cmap, interpolation='nearest')
# axes[2, 1].imshow(warp(delineations[1], disparities_opo[0], disparities_opo[1]) - 0.5 * delineations[0],
# cmap=cmap, interpolation='nearest')
#
# dist = np.sqrt(disparities[0] ** 2 + disparities[1] ** 2)
# dist[dist < 1] = 0
#
# distopo = np.sqrt(sum([d ** 2 for d in disparities_opo]))
# distopo[distopo < 1] = 0
#
# candidates = points_from_mask(dist)
# candidates_opo = points_from_mask(distopo)
#
# # axes[2, 1].scatter()
#
# fig = plt.figure()
# ax = Axes3D(fig)
# ax.scatter(candidates[:, 1], candidates[:, 0], dist[np.nonzero(dist)], color='blue')
# ax.scatter(candidates_opo[:, 1], candidates_opo[:, 0], distopo[np.nonzero(distopo)], color='red')
# plt.show()
# main()
c4science · Help