plt.plot(cout0[:, 0], cout0[:, 1], 'r') plt.subplot(1, 2, 2) plt.plot(k) #%% #generate shape from segmentable image reload(wg) import analysis.experiment as exp img = exp.load_img(wid=80, t=524273 - 1) plt.figure(1) plt.clf() m = wm.WormModel(npoints=31) m.from_image(img, verbose=True) l, r = m.shape() plt.subplot(2, 3, 5) plt.plot(l[:10, 0], l[:10, 1], 'w') #%% img2 = exp.load_img(wid=80, t=524273) plt.figure(2) plt.clf() cont = wg.contours_from_image(img2, verbose=True)
import analysis.experiment as exp import scipy.ndimage.filters as filters from interpolation.curve import Curve from interpolation.resampling import resample as resample_curve import worm.costs as wc reload(wc) ### Gradient descent t0 = 500000 img = exp.load_img(wid=80, t=t0) #imgs = filters.gaussian_filter(np.asarray(img, float), 1.0); w = wm.WormModel(npoints=10) w.from_image(img, verbose=False) w.move_forward(0.1) w.rotate(0.1) contours = wgeo.contours_from_image(img, sigma=1, absolute_threshold=None, threshold_factor=0.9, verbose=False, save=None) contour = Curve(resample_curve(contours[0], 100), nparameter=50) head_tail_xy = wgeo.head_tail_from_contour_discrete(contour, ncontour=all,
def test(): import numpy as np import tensorflow as tf import matplotlib.pyplot as plt; import worm.model as wm; import worm.machine_vision_d as wmv import worm.geometry as wgeo reload(wgeo) reload(wmv) ### Prepare optimization task # work shape w = wm.WormModel(length = 80); ig = wmv.ImageGenerator(); ig.t_counter = 500000 + 25620 - 5; ig.t_counter = 500000 + 2510; ig.wid_counter = 0; img, cntr, nrml = ig.get_batch(nimages = 1); w.from_image(img) w.move_forward(0.05); plt.figure(20); plt.clf(); #wgeo.skeleton_from_image_discrete(img, verbose = True, with_head_tail=True) w.plot(image = img); plt.scatter(cntr[:,0], cntr[:,1]) # target ig.t_counter = 500000 + 25620 - 1; ig.t_counter = 500000 + 2510; ig.wid_counter = 0; #imgs, skels, valids, hts, htvs = ig.get_batch(nimages = 1); imgt, cntrt, nrmlt = ig.get_batch(nimages = 1); plt.figure(21); plt.clf(); w.plot(image = imgt); plt.scatter(cntrt[:,0], cntrt[:,1]) w2 = w.copy(); npts = w.npoints; ### bending profiles bend_exponent = 4; n2 = npts//2; bp = np.zeros((2, npts)); bp[0,:n2] = np.exp(-bend_exponent * np.linspace(-0.2,1,n2)); bp[1,-n2:] = np.exp(-bend_exponent * np.linspace(-0.2,1,n2))[::-1]; #can add other bending profiles here plt.figure(22); plt.clf(); plt.plot(bp.T) ### Cost functions wb = 0.0; ws = 0.0; gamma = 1.0; kappa = 10.0 xy = wmv.create_variable([2], value = 0.0); persitaltic = wmv.create_variable([1], value = 0.0); bend = wmv.create_variable([bp.shape[0]], value = 0.0); #center = wmv.create_variable([npts, 2]); center = tf.constant(w.center, "float32"); wh = w.width; wh[wh < 1.0] = 1.0; width = tf.constant(wh / 2.0, "float32"); length = w.length + 20; bend_profiles = tf.constant(bp, "float32"); contour = tf.constant(cntrt, "float32"); contour_normals = tf.constant(nrmlt, "float32"); cost, cost_left, cost_right, cost_spacing, cost_bending, center_new, left, right, normals = wmv.create_cost( center, xy, width, persitaltic, bend, bend_profiles, contour, contour_normals, length, weight_bending = wb, weight_spacing = ws, gamma = gamma, kappa = kappa); costs = [ cost, cost_left, cost_right, cost_spacing, cost_bending]; costs_names = ['cost', 'cost_left', 'cost_right', 'cost_spacing', 'cost_bending']; grad = tf.gradients(cost, [persitaltic, bend, xy]); ### Tensoroflow - Session sess = None; sess = tf.InteractiveSession() init = tf.initialize_all_variables(); sess.run(init) assign_p = persitaltic.assign([0]); assign_b = bend.assign([0,0]); sess.run(assign_p); sess.run(assign_b); g = sess.run(grad); print g ### Compare costs for c,n in zip(costs, costs_names): print '%20s: %f' % (n, sess.run(c)); ### Manual Gradient descent c1 = w.center; p1 = np.array([0]); b1 = np.array([0,0]); xy1 = np.array([0,0]); w2 = w.copy(); sg = .15; nsteps = 100; for i in range(nsteps): sess.run(persitaltic.assign(p1)); sess.run(bend.assign(b1)); sess.run(xy.assign(xy1)); g = sess.run(grad); p1 = p1 - sg * g[0]/ np.sqrt(np.sum(g[0]*g[0])); b1 = b1 - sg * g[1] / np.sqrt(np.sum(g[1]*g[1])); xy1 = xy1 - sg * g[2] / np.sqrt(np.sum(g[2]*g[2])); w2.center = sess.run(center_new); plt.figure(10); plt.clf(); w2.plot(image = imgt); plt.scatter(cntrt[0,0], cntrt[0,1], c = 'k', s = 150) plt.scatter(cntrt[1,0], cntrt[1,1], c = 'r', s = 150) plt.scatter(w2.center[0,0], w2.center[0,1], c = 'r', s = 150) plt.scatter(cntrt[:,0], cntrt[:,1]) for cc,nn in zip(cntrt, nrmlt): cn = cc + nn; plt.plot([cc[0], cn[0]], [cc[1], cn[1]], c = 'k') l,r = left.eval(), right.eval(); nrmls = normals.eval(); for cc,nn in zip(l, nrmls): cn = cc + nn; plt.plot([cc[0], cn[0]], [cc[1], cn[1]], c = 'k') for cc,nn in zip(r, -nrmls): cn = cc + nn; plt.plot([cc[0], cn[0]], [cc[1], cn[1]], c = 'k') plt.title('cost %f' % sess.run(cost)); #plt.xlim(40,120); plt.ylim(40, 120) plt.draw(); plt.pause(0.05); # test routines t = wmv.create_tangent(center); tn = wmv.create_normalize_tangent(t); nl = wmv.create_normal(tn); l,r = wmv.create_left_right(center, width, nl); d = wmv.create_pair_wise_distances(l, contour); a = wmv.create_pair_wise_dots(nl, contour_normals); a = tf.scalar_mul(-0.5, tf.add(a, -1.0)); # [0,1] 0 = aligned da= wmv.create_aligned_distance(d,a,gamma = gamma, k = kappa); plt.figure(6); plt.clf(); plt.subplot(2,2,1); plt.imshow(d.eval(), interpolation = 'none'); plt.subplot(2,2,2); plt.imshow(a.eval(), interpolation = 'none'); plt.subplot(2,2,3); plt.imshow(d.eval() + a.eval() * np.max(d.eval()), interpolation = 'none'); plt.subplot(2,2,4); plt.plot(da.eval()); #Test center to left,right wh = w.width; wh[wh < 1.0] = 1.0; l1,r1 = w.shape(); length = w.length; width = tf.constant(wh /2.0, "float32"); center = tf.constant(w.center, "float32"); left,right = wmv.create_left_right(center, width) sess = None; sess = tf.InteractiveSession() init = tf.initialize_all_variables(); sess.run(init) l2= sess.run(left); r2= sess.run(right); plt.figure(1); plt.clf(); plt.scatter(l1[:,0], l1[:,1], c='g'); plt.scatter(r1[:,0], r1[:,1], c='r'); plt.scatter(l2[:,0], l2[:,1], c='k'); plt.scatter(r2[:,0], r2[:,1], c='m'); c = left; s = contour; c_shape = c.get_shape().as_list(); s_shape = s.get_shape().as_list(); #expand matrices cc = tf.reshape(c, [c_shape[0], c_shape[1], 1]); ss = tf.reshape(s, [s_shape[0], s_shape[1], 1]); ss = tf.transpose(ss, perm = [2,1,0]); cc = tf.tile(cc, [1, 1, s_shape[0]]); ss = tf.tile(ss, [c_shape[0], 1, 1]); #cc = tf.transpose(cc, perm = [2,1,0]); #cc = tf.tile(cc, [s_shape[0], 1, 1]); #ss = tf.tile(ss, [1, 1, c_shape[0]]); #pairwise distances dist2 = tf.sqrt(tf.reduce_sum(tf.squared_difference(cc,ss), reduction_indices = 1)); #softmin k = 100000.0 softmin = tf.mul(tf.nn.softmax(tf.scalar_mul(tf.constant(-k,"float32"), dist2)), dist2); softmin2 = tf.reduce_sum(tf.mul(tf.nn.softmax(tf.scalar_mul(tf.constant(-k,"float32"), dist2)), dist2),reduction_indices = 1); plt.figure(11); plt.clf(); plt.subplot(2,2,1); plt.imshow(dist2.eval(), interpolation = 'none'); plt.colorbar() plt.subplot(2,2,2); plt.imshow(softmin.eval(), interpolation = 'none'); plt.colorbar() plt.subplot(2,2,3); plt.plot(softmin2.eval()) ### Tensorflow optimization #trainer = tf.train.AdadeltaOptimizer().minimize(cost, var_list=[par]); trainer = tf.train.GradientDescentOptimizer(learning_rate=2.0).minimize(cost); init = tf.initialize_all_variables(); sess.run(init) sess.run(assign_op) nsteps = 1000; for i in range(nsteps): trainer.run(session = sess, feed_dict={}); p1 = par.eval(session = sess); if i%10 == 0: plt.figure(10); plt.clf(); w.center = p1[0]; w.plot(image= imgt); plt.scatter(skels[0,:,0], skels[0,:,1], c= 'm') plt.xlim(0,151); plt.ylim(0,151) plt.draw(); plt.pause(0.1);
t = t+1; print(t); img = exp.load_img(wid = 80, t= 524700+914+t); imgs = filters.gaussian_filter(np.asarray(img, float), 1.0); #imgs = img; th = 90; imgs[imgs > th] = th; #imgs =- th -imgs; plt.figure(1); plt.clf(); plt.imshow(imgs); # find worm model ws = aw.WormModel(); ws.from_image(imgs, verbose = False, sigma = None, threshold_factor = 0.95); plt.figure(1); plt.clf(); ws.plot(image = imgs) # represent worm by spline coefficients for angle of center line + fixed width profile
import numpy as np import matplotlib.pyplot as plt import scipy.ndimage.filters as filters from interpolation.curve import Curve from interpolation.resampling import resample as resample_curve import analysis.experiment as exp reload(wgeo) reload(wmod) ### Initialize Worm from Image npoints = 11 nobs = npoints * 2 - 2 #d differences from the sides / head tail only once worm = wmod.WormModel(npoints=npoints) nparameter = worm.nparameter #full number of parameter t0 = 500000 threshold_factor = 0.9 absolute_threshold = None img = exp.load_img(wid=80, t=t0) imgs = filters.gaussian_filter(np.asarray(img, float), 1.0) worm.from_image(img, absolute_threshold=absolute_threshold, threshold_factor=threshold_factor, verbose=True) worm0 = worm.copy()
#%% f_id = 80 import worm.geometry as wgeo reload(wgeo); plt.clf() res = wgeo.shape_from_image(blur[f_id], threshold_factor = 0.975, sigma = None, verbose = True, smooth = 15, smooth_center = 2.5, npoints = 45, ncontour = 80, center_offset = 3) #%% import worm.model as wmod wm = wmod.WormModel(npoints = 21) f_id = 5; plt.figure(1); plt.clf(); wm.from_image(blur[f_id], sigma = None, verbose = True, smooth = 10) plt.figure(19); plt.clf(); plt.subplot(1,2,1); wm.plot(blur[f_id]) plt.subplot(1,2,2); plt.plot(wm.width); plt.draw(); #%% import worm.geometry as wgeo
Detect worm shapes / postures """ __license__ = 'MIT License <http://www.opensource.org/licenses/mit-license.php>' __author__ = 'Christoph Kirst <*****@*****.**>' import os import numpy as np import matplotlib.pyplot as plt import analysis.experiment as exp import analysis.plot as aplt import worm.model as wmodel npts = 22 w = wmodel.WormModel(npoints=npts) fn = exp.filename(strain='n2', wid=80, dtype='img') imgdata = np.load(fn, mmap_mode='r') ntimes = imgdata.shape[0] theta, orientation, xy, length = w.theta() ntheta = theta.shape[0] data_path = '/home/ckirst/Desktop' data_names = ['theta', 'orientation', 'xy', 'length', 'center', 'width'] data_sizes = [(ntimes, ntheta), ntimes, (ntimes, 2), ntimes, (ntimes, npts, 2), (ntimes, npts)] data_files = [
reload(wgeo) reload(wm) import analysis.experiment as exp import scipy.ndimage.filters as filters from interpolation.curve import Curve from interpolation.resampling import resample as resample_curve # load image t0 = 500000 img = exp.load_img(wid=80, t=t0) imgs = filters.gaussian_filter(np.asarray(img, float), 1.0) w = wm.WormModel(npoints=20) w.from_image(img, verbose=True) w.move_forward(0.1) w.rotate(0.1) plt.figure(1) plt.clf() plt.subplot(1, 2, 1) w.plot(image=imgs) plt.subplot(1, 2, 2) cntrs = wgeo.contour_from_image(imgs, sigma=1, absolute_threshold=None, threshold_factor=0.9, verbose=True,
# create worms fig = plt.figure(9); writer.setup(fig, "turning_resul_2t.mp4", dpi = 300) plt.clf(); plt.subplot(1,1,1); ax = plt.gca(); ax.set_xlim(0, 151) ax.set_ylim(0, 151) for i,c in enumerate(centers_2): print i #if i == 54-fid: # continue; #if i == 65 - fid: # break; wm = wmod.WormModel(center = c, width = width_prev); plt.clf(); wm.plot(blur[i+fid], ax = plt.gca(), cmap = 'gray'); plt.xlim(0,151); plt.ylim(0,151); plt.draw(); plt.pause(0.05); writer.grab_frame(); writer.cleanup(); #%% reload(dst);
def test(): import numpy as np import tensorflow as tf import matplotlib.pyplot as plt import worm.model as wm import worm.machine_vision_b as wmv import worm.geometry as wgeo reload(wgeo) reload(wmv) ### Prepare optimization task # work shape w = wm.WormModel(length=80) ig = wmv.ImageGenerator() ig.t_counter = 500000 + 25620 - 5 ig.wid_counter = 0 imgs, cntrs = ig.get_batch(nimages=1) img = imgs[0, :, :, 0] cntr = cntrs[0] w.from_image(img) plt.figure(20) plt.clf() #wgeo.skeleton_from_image_discrete(img, verbose = True, with_head_tail=True) w.plot(image=img) plt.scatter(cntr[:, 0], cntr[:, 1]) # target ig.t_counter = 500000 + 25620 - 1 ig.wid_counter = 0 #imgs, skels, valids, hts, htvs = ig.get_batch(nimages = 1); imgs, cntrs = ig.get_batch(nimages=1) imgt = imgs[0, :, :, 0] cntrt = cntrs[0] plt.figure(21) plt.clf() w.plot(image=imgt) plt.scatter(cntrt[:, 0], cntrt[:, 1]) #Test center to left,right wh = w.width wh[wh < 1.0] = 1.0 l1, r1 = w.shape() length = w.length width = tf.constant(wh / 2.0, "float32") center = tf.constant(w.center, "float32") left, right = wmv.create_left_right(center, width) sess = None sess = tf.InteractiveSession() init = tf.initialize_all_variables() sess.run(init) l2 = sess.run(left) r2 = sess.run(right) plt.figure(1) plt.clf() plt.scatter(l1[:, 0], l1[:, 1], c='g') plt.scatter(r1[:, 0], r1[:, 1], c='r') plt.scatter(l2[:, 0], l2[:, 1], c='k') plt.scatter(r2[:, 0], r2[:, 1], c='m') ### Cost functions wb = 0 ws = 0.1 wd = 0.1 npts = w.npoints left = wmv.create_variable([npts, 2]) right = wmv.create_variable([npts, 2]) wh = w.width wh[wh < 1.0] = 1.0 width = tf.constant(wh, "float32") length = w.length contour = tf.constant(cntrt, "float32") cost = wmv.create_cost(left, right, contour, width, length, weight_bending=wb, weight_spacing=ws, weight_distance=wd) cost_left = wmv.create_cost_side(left, contour, length, weight_spacing=ws, weight_bending=wb) cost_right = wmv.create_cost_side(right, contour, length, weight_spacing=ws, weight_bending=wb) cost_left_bend = wmv.create_cost_bending(left) cost_right_bend = wmv.create_cost_bending(right) cost_left_spacing = wmv.create_cost_spacing(left, length) cost_right_spacing = wmv.create_cost_spacing(right, length) cost_dist = wmv.create_cost_distance(left, right, width) cost_left_contour = wmv.create_cost_soft_min_distance(left, contour) cost_right_contour = wmv.create_cost_soft_min_distance(right, contour) costs = [ cost, cost_left, cost_right, cost_left_bend, cost_right_bend, cost_left_spacing, cost_right_spacing, cost_dist, cost_left_contour, cost_right_contour ] costs_names = [ 'cost', 'cost_left', 'cost_right', 'cost_left_bend', 'cost_right_bend', 'cost_left_spacing', 'cost_right_spacing', 'cost_dist', 'cost_left_contour', 'cost_right_contour' ] costs_weights = [1, 1, 1, wb, wb, ws, ws, wd, 1, 1] grad = tf.gradients(cost, [left, right]) ### Tensoroflow - Session sess = None sess = tf.InteractiveSession() init = tf.initialize_all_variables() sess.run(init) l, r = w.shape() assign_left = left.assign(l) assign_right = right.assign(r) sess.run(assign_left) sess.run(assign_right) g = sess.run(grad) print g ### Compare costs for c, n, ww in zip(costs, costs_names, costs_weights): print '%20s: %f' % (n, ww * sess.run(c)) ### Manual Gradient descent l1, r1 = w.shape() sg = .75 nsteps = 100 for i in range(nsteps): sess.run(left.assign(l1)) sess.run(right.assign(r1)) g = sess.run(grad) l1 = l1 - sg * g[0] / np.sqrt(np.sum(g[0] * g[0])) r1 = r1 - sg * g[1] / np.sqrt(np.sum(g[1] * g[1])) plt.figure(10) plt.clf() plt.imshow(imgt, cmap='jet') plt.scatter(l1[:, 0], l1[:, 1], s=60, c='r') plt.scatter(r1[:, 0], r1[:, 1], s=60, c='g') plt.plot(l1[:, 0], l1[:, 1], c='r') plt.plot(r1[:, 0], r1[:, 1], c='g') plt.scatter(l1[0, 0], l1[0, 1], c='k', s=150) plt.scatter(cntrt[0, 0], cntrt[0, 1], c='k', s=150) plt.scatter(cntrt[:, 0], cntrt[:, 1]) plt.title('cost %f' % sess.run(cost)) plt.draw() plt.pause(0.05) c = left s = contour c_shape = c.get_shape().as_list() s_shape = s.get_shape().as_list() #expand matrices cc = tf.reshape(c, [c_shape[0], c_shape[1], 1]) ss = tf.reshape(s, [s_shape[0], s_shape[1], 1]) ss = tf.transpose(ss, perm=[2, 1, 0]) cc = tf.tile(cc, [1, 1, s_shape[0]]) ss = tf.tile(ss, [c_shape[0], 1, 1]) #cc = tf.transpose(cc, perm = [2,1,0]); #cc = tf.tile(cc, [s_shape[0], 1, 1]); #ss = tf.tile(ss, [1, 1, c_shape[0]]); #pairwise distances dist2 = tf.sqrt( tf.reduce_sum(tf.squared_difference(cc, ss), reduction_indices=1)) #softmin k = 100000.0 softmin = tf.mul( tf.nn.softmax(tf.scalar_mul(tf.constant(-k, "float32"), dist2)), dist2) softmin2 = tf.reduce_sum(tf.mul( tf.nn.softmax(tf.scalar_mul(tf.constant(-k, "float32"), dist2)), dist2), reduction_indices=1) plt.figure(11) plt.clf() plt.subplot(2, 2, 1) plt.imshow(dist2.eval(), interpolation='none') plt.colorbar() plt.subplot(2, 2, 2) plt.imshow(softmin.eval(), interpolation='none') plt.colorbar() plt.subplot(2, 2, 3) plt.plot(softmin2.eval()) ### Tensorflow optimization #trainer = tf.train.AdadeltaOptimizer().minimize(cost, var_list=[par]); trainer = tf.train.GradientDescentOptimizer( learning_rate=2.0).minimize(cost) init = tf.initialize_all_variables() sess.run(init) sess.run(assign_op) nsteps = 1000 for i in range(nsteps): trainer.run(session=sess, feed_dict={}) p1 = par.eval(session=sess) if i % 10 == 0: plt.figure(10) plt.clf() w.center = p1[0] w.plot(image=imgt) plt.scatter(skels[0, :, 0], skels[0, :, 1], c='m') plt.xlim(0, 151) plt.ylim(0, 151) plt.draw() plt.pause(0.1)
def test(): import numpy as np import tensorflow as tf import matplotlib.pyplot as plt import worm.model as wm import worm.machine_vision_c as wmv import worm.geometry as wgeo reload(wgeo) reload(wmv) ### Prepare optimization task # work shape w = wm.WormModel(length=80) ig = wmv.ImageGenerator() ig.t_counter = 500000 + 25620 - 5 ig.wid_counter = 0 img, cntr, nrml = ig.get_batch(nimages=1) w.from_image(img) plt.figure(20) plt.clf() #wgeo.skeleton_from_image_discrete(img, verbose = True, with_head_tail=True) w.plot(image=img) plt.scatter(cntr[:, 0], cntr[:, 1]) # target ig.t_counter = 500000 + 25620 - 1 ig.wid_counter = 0 #imgs, skels, valids, hts, htvs = ig.get_batch(nimages = 1); imgt, cntrt, nrmlt = ig.get_batch(nimages=1) plt.figure(21) plt.clf() w.plot(image=imgt) plt.scatter(cntrt[:, 0], cntrt[:, 1]) w2 = w.copy() ### Cost functions wb = 1.0 ws = 0.5 gamma = 1.0 kappa = 10.0 npts = w.npoints center = wmv.create_variable([npts, 2]) wh = w.width wh[wh < 1.0] = 1.0 width = tf.constant(wh / 2.0, "float32") length = w.length + 20 contour = tf.constant(cntrt, "float32") contour_normals = tf.constant(nrmlt, "float32") cost, cost_left, cost_right, cost_spacing, cost_bending, normals, left, right = wmv.create_cost( center, width, contour, contour_normals, length, weight_bending=wb, weight_spacing=ws, gamma=gamma, kappa=kappa) costs = [cost, cost_left, cost_right, cost_spacing, cost_bending] costs_names = [ 'cost', 'cost_left', 'cost_right', 'cost_spacing', 'cost_bending' ] grad = tf.gradients(cost, [center]) ### Tensoroflow - Session sess = None sess = tf.InteractiveSession() init = tf.initialize_all_variables() sess.run(init) assign = center.assign(w.center) sess.run(assign) g = sess.run(grad) print g ### Compare costs for c, n in zip(costs, costs_names): print '%20s: %f' % (n, sess.run(c)) ### Manual Gradient descent c1 = w.center w2 = w.copy() sg = .75 nsteps = 100 for i in range(nsteps): sess.run(center.assign(c1)) g = sess.run(grad) c1 = c1 - sg * g[0] / np.sqrt(np.sum(g[0] * g[0])) w2.center = c1 plt.figure(10) plt.clf() w2.plot(image=imgt) plt.scatter(cntrt[0, 0], cntrt[0, 1], c='k', s=150) plt.scatter(cntrt[1, 0], cntrt[1, 1], c='r', s=150) plt.scatter(w2.center[0, 0], w2.center[0, 1], c='r', s=150) plt.scatter(cntrt[:, 0], cntrt[:, 1]) for cc, nn in zip(cntrt, nrmlt): cn = cc + nn plt.plot([cc[0], cn[0]], [cc[1], cn[1]], c='k') l, r = left.eval(), right.eval() nrmls = normals.eval() for cc, nn in zip(l, nrmls): cn = cc + nn plt.plot([cc[0], cn[0]], [cc[1], cn[1]], c='k') for cc, nn in zip(r, -nrmls): cn = cc + nn plt.plot([cc[0], cn[0]], [cc[1], cn[1]], c='k') plt.title('cost %f' % sess.run(cost)) plt.xlim(40, 120) plt.ylim(40, 120) plt.draw() plt.pause(0.05) # test routines t = wmv.create_tangent(center) tn = wmv.create_normalize_tangent(t) nl = wmv.create_normal(tn) l, r = wmv.create_left_right(center, width, nl) d = wmv.create_pair_wise_distances(l, contour) a = wmv.create_pair_wise_dots(nl, contour_normals) a = tf.scalar_mul(-0.5, tf.add(a, -1.0)) # [0,1] 0 = aligned da = wmv.create_aligned_distance(d, a, gamma=gamma, k=kappa) plt.figure(6) plt.clf() plt.subplot(2, 2, 1) plt.imshow(d.eval(), interpolation='none') plt.subplot(2, 2, 2) plt.imshow(a.eval(), interpolation='none') plt.subplot(2, 2, 3) plt.imshow(d.eval() + a.eval() * np.max(d.eval()), interpolation='none') plt.subplot(2, 2, 4) plt.plot(da.eval()) #Test center to left,right wh = w.width wh[wh < 1.0] = 1.0 l1, r1 = w.shape() length = w.length width = tf.constant(wh / 2.0, "float32") center = tf.constant(w.center, "float32") left, right = wmv.create_left_right(center, width) sess = None sess = tf.InteractiveSession() init = tf.initialize_all_variables() sess.run(init) l2 = sess.run(left) r2 = sess.run(right) plt.figure(1) plt.clf() plt.scatter(l1[:, 0], l1[:, 1], c='g') plt.scatter(r1[:, 0], r1[:, 1], c='r') plt.scatter(l2[:, 0], l2[:, 1], c='k') plt.scatter(r2[:, 0], r2[:, 1], c='m') c = left s = contour c_shape = c.get_shape().as_list() s_shape = s.get_shape().as_list() #expand matrices cc = tf.reshape(c, [c_shape[0], c_shape[1], 1]) ss = tf.reshape(s, [s_shape[0], s_shape[1], 1]) ss = tf.transpose(ss, perm=[2, 1, 0]) cc = tf.tile(cc, [1, 1, s_shape[0]]) ss = tf.tile(ss, [c_shape[0], 1, 1]) #cc = tf.transpose(cc, perm = [2,1,0]); #cc = tf.tile(cc, [s_shape[0], 1, 1]); #ss = tf.tile(ss, [1, 1, c_shape[0]]); #pairwise distances dist2 = tf.sqrt( tf.reduce_sum(tf.squared_difference(cc, ss), reduction_indices=1)) #softmin k = 100000.0 softmin = tf.mul( tf.nn.softmax(tf.scalar_mul(tf.constant(-k, "float32"), dist2)), dist2) softmin2 = tf.reduce_sum(tf.mul( tf.nn.softmax(tf.scalar_mul(tf.constant(-k, "float32"), dist2)), dist2), reduction_indices=1) plt.figure(11) plt.clf() plt.subplot(2, 2, 1) plt.imshow(dist2.eval(), interpolation='none') plt.colorbar() plt.subplot(2, 2, 2) plt.imshow(softmin.eval(), interpolation='none') plt.colorbar() plt.subplot(2, 2, 3) plt.plot(softmin2.eval()) ### Tensorflow optimization #trainer = tf.train.AdadeltaOptimizer().minimize(cost, var_list=[par]); trainer = tf.train.GradientDescentOptimizer( learning_rate=2.0).minimize(cost) init = tf.initialize_all_variables() sess.run(init) sess.run(assign_op) nsteps = 1000 for i in range(nsteps): trainer.run(session=sess, feed_dict={}) p1 = par.eval(session=sess) if i % 10 == 0: plt.figure(10) plt.clf() w.center = p1[0] w.plot(image=imgt) plt.scatter(skels[0, :, 0], skels[0, :, 1], c='m') plt.xlim(0, 151) plt.ylim(0, 151) plt.draw() plt.pause(0.1)
def test(): import numpy as np import tensorflow as tf import matplotlib.pyplot as plt import worm.model as wm import worm.machine_vision_2 as wmv import worm.geometry as wgeo reload(wgeo) reload(wmv) ### Prepare optimization task # work shape w = wm.WormModel(length=80) ig = wmv.ImageGenerator() net = wmv.WormVision(model=w, images=ig) ig.t_counter = 500000 + 25620 - 5 ig.wid_counter = 0 imgs, cntrs = ig.get_batch(nimages=1) img = imgs[0, :, :, 0] w.from_image(img) plt.figure(20) plt.clf() wgeo.skeleton_from_image_discrete(img, verbose=True, with_head_tail=True) w.plot() # target ig.t_counter = 500000 + 25620 - 1 ig.wid_counter = 0 #imgs, skels, valids, hts, htvs = ig.get_batch(nimages = 1); imgs, skels, hts = ig.get_batch(nimages=1) imgt = imgs[0, :, :, 0] plt.figure(21) plt.clf() wgeo.skeleton_from_image_discrete(imgt, verbose=True, with_head_tail=True, absolute_threshold=75) w.plot() ### Cost functions wb = 2 ws = 1.0 par = net.create_variable(net.output.get_shape()) skel = tf.constant(skels, "float32") cost = net.create_cost(par, skel, weight_bending=wb, weight_spacing=ws) cost_bend = net.create_cost_bending(par) cost_spacing = net.create_cost_spacing(par) cost_dist = net.create_cost_soft_min_distance(par, skel) grad = tf.gradients(cost, [par]) ### Tensoroflow ### Session sess = None sess = tf.InteractiveSession() init = tf.initialize_all_variables() sess.run(init) assign_op = par.assign(w.center[None, :, :]) sess.run(assign_op) ### Compare costs cb = wb * sess.run(cost_bend) cs = ws * sess.run(cost_spacing) cd = sess.run(cost_dist) c = sess.run(cost) print 'Costs: full: %f; dist: %f; bend: %f; spacing :%f' % (c, cd, cb, cs) ### Manual Gradient descent p1 = w.center sg = .75 nsteps = 100 for i in range(nsteps): sess.run(par.assign(p1[None, :, :])) g = sess.run(grad)[0][0] p1 = p1 - sg * g / np.sqrt(np.sum(g * g)) plt.figure(10) plt.clf() #plt.subplot(1,2,1) #w.plot(image = img); w.center = p1 #plt.subplot(1,2,2); w.plot(image=imgt) plt.title('cost %f' % sess.run(cost)) plt.draw() plt.pause(0.05) ### Tensorflow optimization #trainer = tf.train.AdadeltaOptimizer().minimize(cost, var_list=[par]); trainer = tf.train.GradientDescentOptimizer( learning_rate=2.0).minimize(cost) init = tf.initialize_all_variables() sess.run(init) sess.run(assign_op) nsteps = 1000 for i in range(nsteps): trainer.run(session=sess, feed_dict={}) p1 = par.eval(session=sess) if i % 10 == 0: plt.figure(10) plt.clf() w.center = p1[0] w.plot(image=imgt) plt.scatter(skels[0, :, 0], skels[0, :, 1], c='m') plt.xlim(0, 151) plt.ylim(0, 151) plt.draw() plt.pause(0.1) import shapely.geometry as geom cntrs = wgeo.contours_from_image(imgt) poly = geom.Polygon(cntrs[0], [cntrs[i] for i in range(1, len(cntrs))]) poly2 = poly.buffer(-3) bdr = poly.boundary from descartes.patch import PolygonPatch patch = PolygonPatch(poly, facecolor='b', edgecolor='k', alpha=0.5, zorder=2) patch2 = PolygonPatch(poly2, facecolor='r', edgecolor='k', alpha=0.5, zorder=2) fig = plt.figure(28) ax = fig.add_subplot(111) ax.add_patch(patch) ax.add_patch(patch2) plt.xlim(0, 151) plt.ylim(1, 151) plt.show()
fig = plt.figure(8); plt.clf(); plt.imshow(img, cmap = 'gray'); plt.xlim(0,151); plt.ylim(0,151) plt.axis('off') fig.savefig('pipeline_fail.png', facecolor = 'white') t0 = 500000 + 25620 -5; img = exp.load_img(t=t0, sigma = 1.0) fig = plt.figure(8); plt.clf(); plt.imshow(img, cmap = 'gray'); plt.xlim(0,151); plt.ylim(0,151) plt.axis('off') w = wmod.WormModel(npoints = 22) w.from_image(img, verbose = True) fig = plt.figure(9); plt.clf(); w.plot(image = img, cmap = 'gray', ccolor='b'); plt.xlim(0,151); plt.ylim(0,151) plt.axis('off') fig.savefig('pipeline_fail_0.png', facecolor = 'white') plt.clf(); t1 = t0 + 5 img = exp.load_img(t=t1, sigma = 1.0) w1 = w.copy(); w1.bend(9)
""" import numpy as np import matplotlib.pyplot as plt import copy import time import worm.model as aw #%% ### Test simple shape properties reload(aw) #ws = aw.WormModel(theta = 0.1, width = 10 * (1 - np.exp(-0.1 * (21 - np.abs(2* (np.arange(20)+1) - 21))))); ws = aw.WormModel(width=None, length=80, orientation=2.1) #ws.widen(0.5); plt.figure(1) plt.clf() plt.subplot(1, 2, 1) ws.plot() plt.axis('equal') plt.xlim(0, 151) plt.ylim(0, 151) plt.subplot(1, 2, 2) ws.plot(npoints=2 * ws.npoints + 1) plt.xlim(0, 151) plt.ylim(0, 151) plt.axis('equal') plt.draw()
def test(): import numpy as np import tensorflow as tf import matplotlib.pyplot as plt; import worm.model as wm; import worm.machine_vision_3 as wmv import worm.geometry as wgeo reload(wgeo) reload(wmv) ### Prepare optimization task # work shape w = wm.WormModel(length = 80); ig = wmv.ImageGenerator(); net = wmv.WormVision(model = w, images = ig); ig.t_counter = 500000 + 25620 - 5; ig.wid_counter = 0; imgs, cntrs = ig.get_batch(nimages = 1); img = imgs[0,:,:,0]; cntr = cntrs[0]; w.from_image(img) plt.figure(20); plt.clf(); #wgeo.skeleton_from_image_discrete(img, verbose = True, with_head_tail=True) w.plot(image = img); plt.scatter(cntr[:,0], cntr[:,1]) # target ig.t_counter = 500000 + 25620 - 1; ig.wid_counter = 0; #imgs, skels, valids, hts, htvs = ig.get_batch(nimages = 1); imgs, cntrs = ig.get_batch(nimages = 1); imgt = imgs[0,:,:,0]; cntrt = cntrs[0]; plt.figure(21); plt.clf(); w.plot(image = imgt); plt.scatter(cntrt[:,0], cntrt[:,1]) ### Cost functions wb = 2; ws = 1.0; wd = 2.0 npts = w.npoints; left = net.create_variable([1, npts]); right = net.create_variable([1, npts]); width = tf.constant(w.width, "float32"); length = tf.constant(w.length, "float32"); contour = tf.constant(cntrs, "float32"); cost = net.create_cost(left, right, contour, width, weight_bending = wb, weight_spacing = ws); cost_bend = net.create_cost_bending(par); cost_spacing = net.create_cost_spacing(par); cost_dist = net.create_cost_soft_min_distance(par, skel); grad = tf.gradients(cost, [par]); ### Tensoroflow ### Session sess = None; sess = tf.InteractiveSession() init = tf.initialize_all_variables(); sess.run(init) assign_op = par.assign(w.center[None,:,:]); sess.run(assign_op) ### Compare costs cb = wb * sess.run(cost_bend); cs = ws * sess.run(cost_spacing); cd = sess.run(cost_dist); c = sess.run(cost); print 'Costs: full: %f; dist: %f; bend: %f; spacing :%f' % (c, cd, cb, cs); ### Manual Gradient descent p1 = w.center; sg = .75; nsteps = 100; for i in range(nsteps): sess.run(par.assign(p1[None,:,:])); g = sess.run(grad)[0][0]; p1 = p1 - sg * g / np.sqrt(np.sum(g*g)); plt.figure(10); plt.clf(); #plt.subplot(1,2,1) #w.plot(image = img); w.center = p1; #plt.subplot(1,2,2); w.plot(image= imgt); plt.title('cost %f' % sess.run(cost)); plt.draw(); plt.pause(0.05); ### Tensorflow optimization #trainer = tf.train.AdadeltaOptimizer().minimize(cost, var_list=[par]); trainer = tf.train.GradientDescentOptimizer(learning_rate=2.0).minimize(cost); init = tf.initialize_all_variables(); sess.run(init) sess.run(assign_op) nsteps = 1000; for i in range(nsteps): trainer.run(session = sess, feed_dict={}); p1 = par.eval(session = sess); if i%10 == 0: plt.figure(10); plt.clf(); w.center = p1[0]; w.plot(image= imgt); plt.scatter(skels[0,:,0], skels[0,:,1], c= 'm') plt.xlim(0,151); plt.ylim(0,151) plt.draw(); plt.pause(0.1); import shapely.geometry as geom cntrs = wgeo.contours_from_image(imgt) poly = geom.Polygon(cntrs[0], [cntrs[i] for i in range(1,len(cntrs))]); poly2 = poly.buffer(-3) bdr = poly.boundary; from descartes.patch import PolygonPatch patch = PolygonPatch(poly, facecolor = 'b', edgecolor='k', alpha=0.5, zorder=2) patch2= PolygonPatch(poly2, facecolor = 'r', edgecolor='k', alpha=0.5, zorder=2) fig = plt.figure(28); ax = fig.add_subplot(111) ax.add_patch(patch) ax.add_patch(patch2) plt.xlim(0,151); plt.ylim(1,151) plt.show() ### make boundary pts in tensorflow npoints = 21; width = tf.placeholder("float32", shape = [npoints,2]);