def plot_rocs(data, save_to=None):
import matplotlib.pyplot as plt
import palettable
colors = palettable.colorbrewer.qualitative.Set2_8.mpl_colors
fig, ax = plt.subplots(1)
i = 0
for filename, (xs, ys) in data:
auc_score = metrics.auc(xs, ys, reorder=False)
label = "%s (%.3f)" % (filename, auc_score)
ax.plot(xs, ys, '-', linewidth=1.2, color=colors[i], label=label)
i += 1
ax.plot([0.0, 1.0], [0.0, 1.0], '--', color='gray')
ax.set_ylabel("Portion Relevant")
ax.set_xlabel("Portion Irrelevant")
ax.set_title("ROC")
ax.set_xlim([0.0, 1.0])
ax.set_ylim([0.0, 1.0])
ax.legend(loc='lower right')
if save_to is None:
fig.show()
plt.waitforbuttonpress()
else:
fig.savefig(save_to)
fig.clf()
def display_Direction(centroid0,centroid1,k=None,cluster=None):
"""
display the histogramm of a vector
:arg centroid0: first centroid
:type centroid0: Observation
:arg centroid1: second centroid
:type centroid1: Observation
:param k: k of kmeans, for title
:type k: int
:param cluster: cluster whose direction is computed, for title
:type cluster: int
:rtype: void
"""
dx = float(abs(centroid0.values[0]-centroid1.values[0]))
dy = float(abs(centroid0.values[1]-centroid1.values[1]))
if (centroid0.values[0]-centroid1.values[0])*(centroid0.values[1]-centroid1.values[1]) < 0:
dy = -dy
x = [(float(centroid0.values[0]+centroid1.values[0]))/2-1.5*dx,(float(centroid0.values[0]+centroid1.values[0]))/2+1.5*dx]
y = [(float(centroid0.values[1]+centroid1.values[1]))/2-1.5*dy,(float(centroid0.values[1]+centroid1.values[1]))/2+1.5*dy]
#time to keep displayed
time = 4
plt.hold(True)
plt.plot(x,y,c='red',linewidth=3)
plt.waitforbuttonpress(timeout=time)
plt.savefig("output/fig.png")
def replay():
data = pickle.load(open(fpkl, 'rb'))
for d in data:
ts = d['newdata']['ts']
spds = d['newdata']['spds']
dists = d['newdata']['dists']
coef_spd = d['fit_coef']['spd']
coef_dist = d['fit_coef']['dist']
tsp = np.linspace(0, ts[-1], 100)
pfspd = np.poly1d(coef_spd)
fspds = pfspd(tsp)
pfdist = np.poly1d(coef_dist)
fdists = pfdist(tsp)
print 'a: %f, %f' % (coef_dist[0] * 2, coef_spd[0])
plt.subplot(121)
plt.plot(ts, spds, '.', ms=10, color='b')
plt.plot(tsp, fspds, '-', color='b')
plt.plot(ts, dists, '.', ms=10, color='g')
plt.plot(tsp, fdists, '-', color='g')
plt.subplot(122)
plt.plot(ts, spds, '.')
plt.draw()
plt.waitforbuttonpress(-1)
plt.clf()
def draw_pivot_interactive(self, xk, key_pressed=False, wait_time=1):
"""Draw a red circle at the current pivot position.
To be used interactively.
Keyword Arguments:
xk -- a pair representing the position of the new pivot
key_pressed -- True if a key or button must be pressed to continue else
wait for time seconds
wait_time -- the time in seconds to wait
"""
if self.started:
if self.pivot_patch is None:
self.pivot_patch = plt.Circle((0, 0), 0.1, fc='r')
else:
gui_line, = self.ax.plot([self.pivot_patch.center[0], xk[0]],
[self.pivot_patch.center[1], xk[1]])
gui_line.set_color('red')
gui_line.set_linestyle('-')
gui_line.set_linewidth(3)
plt.draw()
self.pivot_patch.center = (xk[0], xk[1])
self.ax.add_patch(self.pivot_patch)
else:
self.started = True
if key_pressed:
plt.waitforbuttonpress()
else:
plt.pause(wait_time)
def plot_maps(maps,coords,width,height): import matplotlib.pyplot as plt; maps=np.array(maps); shape=maps.shape; num_vert=1; num_hor=len(maps); if(len(shape)>2): num_vert=shape[0]; num_hor=shape[1]; fig, axs=plt.subplots(num_vert,num_hor); for j in range(num_vert): for i in range(num_hor): if(num_vert==1): fig.colorbar( axs[i].imshow( mapnodestoimg(maps[i],width, height,coords)),ax=axs[i]); else: fig.colorbar( axs[j][i].imshow( mapnodestoimg(maps[j][i],width, height,coords)),ax=axs[j][i]); fig.show(); plt.draw(); plt.waitforbuttonpress();
def show_example(out_path, counter, data_all):
"""
Show example - need to re-write every time we change the data
:param out_path: output writing path
:param counter: example number
:param data_all: dictionary with all data
"""
print "out_path: " + out_path
print "counter: " + str(counter)
fig, ax = plt.subplots(nrows=3, ncols=2)
fig.set_size_inches(18.5, 10.5, forward=True)
ax[0][0].set_title('Original Image')
imshow(data_all["image_gt"], ax=ax[0][0], fig=fig)
ax[0][1].set_title('SubSampled Image')
imshow(data_all["image"], ax=ax[0][1], fig=fig)
ax[1][0].set_title('Origianl real k-space')
imshow(data_all["k_space_real_gt"], ax=ax[1][0], fig=fig)
ax[1][1].set_title('SubSampled real k-space')
imshow(data_all["k_space_real"], ax=ax[1][1], fig=fig)
ax[2][0].set_title('Origianl imaginary k-space')
imshow(data_all["k_space_imag_gt"], ax=ax[2][0], fig=fig)
ax[2][1].set_title('SubSampled imaginary k-space')
imshow(data_all["k_space_imag"], ax=ax[2][1], fig=fig)
plt.waitforbuttonpress(timeout=-1)
plt.close()
def debug_call(particles_weighted, the_map):
debug = False
if not debug:
return
# Initialize figure
my_dpi = 96
plt.figure(1, figsize=(800/my_dpi, 800/my_dpi), dpi=my_dpi)
plt.cla()
plt.xlim ( the_map.info.origin.position.x, the_map.info.origin.position.x + the_map.info.width )
plt.ylim ( the_map.info.origin.position.y, the_map.info.origin.position.y + the_map.info.height )
plt.gca().set_aspect('equal', adjustable='box')
plt.xlabel('X world')
plt.xlabel('Y world')
ax = plt.axes()
# Draw map
draw_occupancy_grid(the_map, ax)
# Draw particles
draw_particles_scored(particles_weighted)
# Show plot
plt.draw()
pause = True
if pause:
k = plt.waitforbuttonpress(1)
while not k:
k = plt.waitforbuttonpress(1)
else:
plt.waitforbuttonpress(1e-6)
def waitForInput():
''' This time, proceed with a click or by hitting any key '''
plt.plot(t,c)
plt.title('Click in that window, or hit any key to continue')
plt.waitforbuttonpress()
plt.close()
def cut_bounds(self, data):
def tellme(s):
print s
plt.title(s,fontsize=16)
plt.draw()
plt.clf()
plt.plot(data)
plt.setp(plt.gca(),autoscale_on=False)
tellme('You will select start and end bounds. Click to continue')
plt.waitforbuttonpress()
happy = False
while not happy:
pts = []
while len(pts) < 2:
tellme('Select 2 bounding points with mouse')
pts = plt.ginput(2,timeout=-1)
if len(pts) < 2:
tellme('Too few points, starting over')
time.sleep(1) # Wait a second
plt.fill_between(x, y1, y2, alpha=0.5, facecolor='grey', interpolate=True)
tellme('Happy? Key click for yes, mouse click for no')
happy = plt.waitforbuttonpress()
bounds = sorted([int(i[0]) for i in pts])
plt.clf()
print bounds
return data[bounds[0] if bounds[0] > .02*len(data) else 0:bounds[1] if bounds[1] < len(data)-1 else len(data)-1],bounds
def show_results(data, labels):
"""
This is a utility function that can be used to visualize which
images end up in which class.
Parameters:
data - A set of images in the original data format
labels - one 0,1 label for each image.
"""
implot = None
for i in range(data.shape[0]):
if implot == None:
implot = plt.imshow(data_to_img(data[i,:]),
interpolation='none')
txt = plt.text(5, 5, str(labels[i]),size='20',
color=(0,1,0))
else:
implot.set_data(data_to_img(data[i,:]))
txt.set_text(str(labels[i]))
fig = plt.gcf()
fig.set_size_inches(2,2)
plt.xticks(())
plt.yticks(())
plt.draw()
plt.waitforbuttonpress()
def interactive_fit(redshifts, vals, nchi2, templ, sp, outfile, filename,
fig, spec2d=None, wa2d=None, spec2dpos=None, msky=None):
fig.clf()
objname = filename.split('/')[-1].replace('_xcorr.sav', '')
wrapper = FindZWrapper(redshifts, vals, nchi2, templ, sp, objname, fig=fig,
spec2d=spec2d, wa2d=wa2d, spec2dpos=spec2dpos,
msky=msky)
# wait until user decides on redshift
try:
while wrapper.wait:
pl.waitforbuttonpress()
except (tkinter.TclError, KeyboardInterrupt):
print "\nClosing\n"
sys.exit(1)
if wrapper.zconf == 'k':
# skip
return
print filename
plotname = filename.replace('_xcorr.sav','.png')
print 'saving to ', plotname
fig.savefig(plotname)
outfile.write('%20s %10s % 8.5e %1s\n' % (
filename.split('/')[-1].split('_xcorr')[0], templ[wrapper.i].label,
wrapper.zgood, wrapper.zconf))
outfile.flush()
def test_mnist():
"""Summary
Returns
-------
name : TYPE
Description
"""
# %%
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data
import matplotlib.pyplot as plt
# %%
# load MNIST as before
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
mean_img = np.mean(mnist.train.images, axis=0)
ae = VAE()
# %%
learning_rate = 0.002
optimizer = tf.train.AdagradOptimizer(learning_rate).minimize(ae['cost'])
# %%
# We create a session to use the graph
sess = tf.Session()
sess.run(tf.initialize_all_variables())
# %%
# Fit all training data
batch_size = 100
n_epochs = 50
for epoch_i in range(n_epochs):
for batch_i in range(mnist.train.num_examples // batch_size):
batch_xs, _ = mnist.train.next_batch(batch_size)
train = np.array([(img - mean_img) for img in batch_xs])
print(epoch_i,
sess.run([ae['cost'], optimizer],
feed_dict={ae['x']: train})[0])
# %%
# Plot example reconstructions
n_examples = 12
test_xs, _ = mnist.test.next_batch(n_examples)
test_xs_norm = np.array([img - mean_img for img in test_xs])
recon = sess.run(ae['y'], feed_dict={ae['x']: test_xs_norm})
print(recon.shape)
fig, axs = plt.subplots(2, n_examples, figsize=(10, 2))
for example_i in range(n_examples):
axs[0][example_i].imshow(
np.reshape(test_xs[example_i, :], (28, 28)),
cmap='gray')
axs[1][example_i].imshow(
np.reshape(
np.reshape(recon[example_i, ...], (784,)) + mean_img,
(28, 28)),
cmap='gray')
fig.show()
plt.draw()
plt.waitforbuttonpress()
def createHistogramOfOrientedGradientFeatures(sourceImage, numOrientations, pixelsPerCell):
# Returns an nxd matrix, n pixels and d the HOG vector length.
# H is a matrix NBLOCKS_Y x NBLOCKS_X x CPB_Y x CPB_X x ORIENTATIONS
# Here CPB == 1
H,Himg = myhog.hog( sourceImage, numOrientations, pixelsPerCell, cells_per_block=(1,1), flatten=False, visualise=True )
hog_image_rescaled = skimage.exposure.rescale_intensity( Himg )#, in_range=(0, 0.2))
plt.interactive(True)
plt.figure()
plt.subplot(1,2,1)
plt.imshow(sourceImage)
plt.subplot(1,2,2)
plt.imshow( hog_image_rescaled, cmap=plt.cm.gray )
plt.title('HOG')
plt.waitforbuttonpress()
# Reduce to non-singleton dimensions, BY x BX x ORIENT
H = H.squeeze()
assert H.ndim == 3
assert H.max() <= 1.0
# resize to image pixels rather than grid blocks
hogImg = np.zeros( ( sourceImage.shape[0], sourceImage.shape[1], numOrientations ), dtype=float )
for o in range(numOrientations):
hogPerOrient = H[:,:,o].astype(np.float32)
hpoAsPil = pil.fromarray( hogPerOrient, mode='F' )
hogImg[:,:,o] = np.array( hpoAsPil.resize( (sourceImage.shape[1], sourceImage.shape[0]), pil.NEAREST ) )
return hogImg.reshape( ( sourceImage.shape[0]*sourceImage.shape[1], numOrientations ) )
def manual_sync_pick(flow, gyro_ts, gyro_data):
# First pick good points in flow
plt.clf()
plt.plot(flow)
plt.title('Select two points')
selected_frames = [int(round(x[0])) for x in plt.ginput(2)]
# Now pick good points in gyro
plt.clf()
plt.subplot(211)
plt.plot(flow)
plt.plot(selected_frames, flow[selected_frames], 'ro')
plt.subplot(212)
plt.plot(gyro_ts, gyro_data.T)
plt.title('Select corresponding sequence in gyro data')
plt.draw()
selected = plt.ginput(2) #[int(round(x[0])) for x in plt.ginput(2)]
gyro_idxs = [(gyro_ts >= x[0]).nonzero()[0][0] for x in selected]
plt.plot(gyro_ts[gyro_idxs], gyro_data[:, gyro_idxs].T, 'ro')
plt.title('Ok, click to continue to next')
plt.draw()
plt.waitforbuttonpress(timeout=10.0)
plt.close()
return (tuple(selected_frames), gyro_idxs)
def photos(tt, tangl, tz0):
fig = plt.figure(num=0)
ax = fig.add_subplot(111)
for i in [0, 100, 200, 300, 400]:
ax.clear()
photo2(ax, tt[i], tangl[i], tz0[i])
plt.show()
plt.waitforbuttonpress(timeout=1)
def display_unbounded(self):
tableau_latex = self.attain_tableau_latex()
unbounded_latex = r"""\noindent Unbounded!"""
unbounded_latex += r" \\"
self.text.set_text(unbounded_latex + tableau_latex)
plt.waitforbuttonpress()
plt.draw()
plt.waitforbuttonpress()
def hanoi(n, A, B, C):
if n > 0:
hanoi(n - 1, A, C, B)
config[A].pop()
config[C].append(n)
plt.waitforbuttonpress()
plot_config(config)
hanoi(n - 1, B, A, C)
def draw_mars_data(data):
u = np.unique(data.flatten())
u.sort()
print(u[0], u[1])
#print np.min(data), np.max(data)
data = np.clip(data, u[1], np.max(data))
imgplot = plt.imshow(data, interpolation="nearest")
plt.waitforbuttonpress()
def roipoly(ax=None):
""" use polygonmask to get the pixel mask"""
if ax is None:
ax = plt.gca()
r = Roipoly(ax)
while not r.done:
plt.waitforbuttonpress()
return r.verts
def test_mnist():
"""Test the convolutional autoencder using MNIST."""
# %%
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data
import matplotlib.pyplot as plt
flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_string('data_dir', '../data/mnist/', 'Directory for storing data')
# %%
# load MNIST as before
mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)
mean_img = np.mean(mnist.train.images, axis=0)
ae = autoencoder()
# %%
learning_rate = 0.01
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(ae['cost'])
# %%
# We create a session to use the graph
sess = tf.Session()
sess.run(tf.initialize_all_variables())
# %%
# Fit all training data
batch_size = 100
n_epochs = 10
for epoch_i in range(n_epochs):
for batch_i in range(mnist.train.num_examples // batch_size):
batch_xs, _ = mnist.train.next_batch(batch_size)
train = np.array([img - mean_img for img in batch_xs])
sess.run(optimizer, feed_dict={ae['x']: train})
print(epoch_i, sess.run(ae['cost'], feed_dict={ae['x']: train}))
# %%
# Plot example reconstructions
n_examples = 10
test_xs, _ = mnist.test.next_batch(n_examples)
test_xs_norm = np.array([img - mean_img for img in test_xs])
recon = sess.run(ae['y'], feed_dict={ae['x']: test_xs_norm})
print(recon.shape)
fig, axs = plt.subplots(2, n_examples, figsize=(10, 2))
for example_i in range(n_examples):
axs[0][example_i].imshow(
np.reshape(test_xs[example_i, :], (28, 28)))
axs[1][example_i].imshow(
np.reshape(
np.reshape(recon[example_i, ...], (784,)) + mean_img,
(28, 28)))
fig.show()
plt.draw()
plt.waitforbuttonpress()
def get():
i = cv2.imread('rdy.pgm', cv2.IMREAD_ANYDEPTH)
maxv = i.max()
i *= 255 / maxv
i = numpy.uint8(i)
i = cv2.bilateralFilter(i, 9, 75, 75)
# i = cv2.adaptiveThreshold(i, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 5)
plt.imshow(i)
plt.waitforbuttonpress()
return i
def plotspec(args):
"""Plot spectrum files
Parameters
----------
filenames : list of str
Spectrum filenames
"""
from linetools.spectra.io import readspec
import warnings
import matplotlib.pyplot as plt
import matplotlib as mpl
warnings.simplefilter('ignore', mpl.mplDeprecation)
spec_cache = {}
fig = plt.figure(figsize=(10,5))
fig.subplots_adjust(left=0.07, right=0.95, bottom=0.11)
ax = fig.add_subplot(111)
i = 0
quit = False
print("#### Use left and right arrow keys to navigate, 'Q' to quit ####")
while quit is False:
filename = args.filenames[i]
if filename not in spec_cache:
spec_cache[filename] = readspec(filename)
sp = spec_cache[filename]
ax.cla()
sp.plot(show=False)
ax.set_xlabel(str(sp.wavelength.unit))
ax.set_title(filename)
if args.redshift is not None:
from linetools.lists.linelist import LineList
ll = LineList('Strong')
#import pdb ;pdb.set_trace()
wlines = ll._data['wrest'] * (1 + args.redshift)
y0, y1 = ax.get_ylim()
ax.vlines(wlines.to(sp.wavelength.unit).value, y0, y1,
linestyle='dotted')
while True:
plt.waitforbuttonpress()
if sp._plotter.last_keypress == 'right':
i += 1
i = min(i, len(args.filenames) - 1)
# Note this only breaks out of the inner while loop
break
elif sp._plotter.last_keypress == 'left':
i -= 1
i = max(i, 0)
break
elif sp._plotter.last_keypress == 'Q':
quit = True
break
def display_dataset():
logging.basicConfig(level=logging.DEBUG)
cfg = load_config()
dataset = dataset_create(cfg)
dataset.set_shuffle(False)
while True:
batch = dataset.next_batch()
for frame_id in range(1):
img = batch[Batch.inputs][frame_id,:,:,:]
img = np.squeeze(img).astype('uint8')
scmap = batch[Batch.part_score_targets][frame_id,:,:,:]
scmap = np.squeeze(scmap)
# scmask = batch[Batch.part_score_weights]
# if scmask.size > 1:
# scmask = np.squeeze(scmask).astype('uint8')
# else:
# scmask = np.zeros(img.shape)
subplot_height = 4
subplot_width = 5
num_plots = subplot_width * subplot_height
f, axarr = plt.subplots(subplot_height, subplot_width)
for j in range(num_plots):
plot_j = j // subplot_width
plot_i = j % subplot_width
curr_plot = axarr[plot_j, plot_i]
curr_plot.axis('off')
if j >= cfg.num_joints:
continue
scmap_part = scmap[:,:,j]
scmap_part = imresize(scmap_part, 8.0, interp='nearest')
scmap_part = np.lib.pad(scmap_part, ((4, 0), (4, 0)), 'minimum')
curr_plot.set_title("{}".format(j+1))
curr_plot.imshow(img)
curr_plot.hold(True)
curr_plot.imshow(scmap_part, alpha=.5)
# figure(0)
# plt.imshow(np.sum(scmap, axis=2))
# plt.figure(100)
# plt.imshow(img)
# plt.figure(2)
# plt.imshow(scmask)
plt.show()
plt.waitforbuttonpress()
def addgrain(self,ori=0):
'''
add a grain inside the microstructure
:param ori: orienation of the new grain [phi1 phi] (default random value)
:type ori: array, float
:return: new_micro, object with the new grain include
:rtype: aita
:Exemple:
>>> data.addgrain()
'''
# select the contour of the grains
h=self.grains.plot()
# click on the submit of the new grain
plt.waitforbuttonpress()
print('click on the submit of the new grain :')
x=np.array(pylab.ginput(3))/self.grains.res
plt.close('all')
# select a subarea contening the triangle
minx=np.int(np.fix(np.min(x[:,0])))
maxx=np.int(np.ceil(np.max(x[:,0])))
miny=np.int(np.fix(np.min(x[:,1])))
maxy=np.int(np.ceil(np.max(x[:,1])))
# write all point inside this area
gpoint=[]
for i in list(range(minx,maxx)):
for j in list(range(miny,maxy)):
gpoint.append([i,j])
# test if the point is inside the triangle
gIn=[]
for i in list(range(len(gpoint))):
gIn.append(isInsideTriangle(gpoint[i],x[0,:],x[1,:],x[2,:]))
gpointIn=np.array(gpoint)[np.array(gIn)]
#transform in xIn and yIn, the coordinate of the map
xIn=np.shape(self.grains.field)[0]-gpointIn[:,1]
yIn=gpointIn[:,0]
# add one grains
self.grains.field[xIn,yIn]=np.nanmax(self.grains.field)+1
# add the orientation of the grains
if ori==0:
self.phi1.field[xIn,yIn]=random.random()*2*math.pi
self.phi.field[xIn,yIn]=random.random()*math.pi/2
else:
self.phi1.field[xIn,yIn]=ori[0]
self.phi.field[xIn,yIn]=ori[1]
returnphi=self.phi1*mask
def visualize_data(x, y, viz_trainining=False):
# Plot data using matplotlib
plt.plot(x, y, 'bo')
plt.ylabel('Output Value')
plt.xlabel('Input Feature')
if viz_trainining:
plt.title('Normalized data\tClick on the figure to run Gradient Descent Algorithm')
plt.waitforbuttonpress()
else:
plt.title('Original data')
plt.show()
def generate_data():
# Generate a non-normally distributed datasample
data = stats.poisson.rvs(2, size=1000)
# Show the data
plt.plot(data, '.')
plt.title('Non-normally distributed dataset: Press any key to continue')
# plt.show()
plt.waitforbuttonpress()
plt.close()
return(data)
def test_mnist(dimensions):
# Import and read MNIST data
import tensorflow.examples.tutorials.mnist.input_data as input_data
import matplotlib.pyplot as plt
mnist = input_data.read_data_sets("MNIST_data", one_hot=True)
mean_img = np.mean(mnist.train.images, axis=0)
# Create an SDA with dimensions.length() - 1 layers
ae = SDAutoencoder(dimensions=dimensions)
# Create an Adam optimizer for gradient descent
learning_rate = 1e-4
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(ae.cost)
# Setup accuracy model
# is_correct = tf.equal()
# Initialize the default session graph
sess = tf.Session()
sess.run(tf.initialize_all_variables())
# Set batch and epoch size
batch_size = 50
n_epochs = 10
for epoch_i in range(n_epochs):
for batch_i in range(mnist.train.num_examples // batch_size):
batch_xs, _ = mnist.train.next_batch(batch_size)
train = np.array([img - mean_img for img in batch_xs])
feed = {ae.x: train, ae.corrupt_prob: [1.0]}
sess.run(optimizer, feed_dict=feed)
if batch_i % 100 == 0:
pass
print(epoch_i, sess.run(ae.cost, feed_dict=feed))
# Plotting
n_examples = 15
test_xs, _ = mnist.test.next_batch(n_examples)
test_xs_norm = np.array([img - mean_img for img in test_xs])
recon = sess.run(ae.y, feed_dict={
ae.x: test_xs_norm, ae.corrupt_prob: [0.0]})
fig, axs = plt.subplots(2, n_examples, figsize=(10, 2))
for example_i in range(n_examples):
axs[0][example_i].imshow(
np.reshape(test_xs[example_i, :], (28, 28)))
axs[1][example_i].imshow(
np.reshape([recon[example_i, :] + mean_img], (28, 28)))
fig.show()
plt.draw()
plt.waitforbuttonpress()
def viewClassifiedImages(path,dataset,suffix = ".png"):
t=plt.text(20,-20,'Hello WOrld')
for i in xrange(0,len(dataset.fileNames)):
#load image
name = dataset.fileNames[i].split('.')[0]
name = name+suffix
im = plt.imread(path+name)
plt.imshow(im)
text = 'Name: '+name + ', label: '+dataset.target[i]+ ', classified as: '+dataset.classifiedAs[i]
t.set_text(text)
plt.draw()
plt.waitforbuttonpress()
def display_optimal(self):
tableau_latex = self.attain_tableau_latex()
optimal_latex = r"""\noindent Optimal value: """ + dn(self.simplex.value) + r" \\ "
optimal_latex += r"""Solution: """
for i, s in enumerate(self.simplex.solution):
if i != 0:
optimal_latex += r", "
optimal_latex += r"$x_" + str(i + 1) + r" = \,$" + dn(s[0])
optimal_latex += r" \\"
self.text.set_text(optimal_latex + tableau_latex)
plt.waitforbuttonpress()
plt.draw()
plt.waitforbuttonpress()
def UserVsini(self, spectrum):
"""
This does a Fourier transform on the spectrum, and then lets
the user click on the first minimum, which indicates the vsini of the star.
"""
# Set up plotting
self.interactive_mode = "vsini"
fig = plt.figure(1)
cid = fig.canvas.mpl_connect('button_press_event', self.mouseclick)
# Make wavelength spacing uniform
xgrid = np.linspace(spectrum.x[0], spectrum.x[-1], spectrum.size())
spectrum = FittingUtilities.RebinData(spectrum, xgrid)
extend = np.array(40 * spectrum.size() * [1, ])
spectrum.y = np.r_[extend, spectrum.y, extend]
# Do the fourier transorm and keep the positive frequencies
fft = np.fft.fft(spectrum.y - 1.0)
freq = np.fft.fftfreq(spectrum.y.size, d=spectrum.x[1] - spectrum.x[0])
good = np.where(freq > 0)[0]
fft = fft[good].real ** 2 + fft[good].imag ** 2
freq = freq[good]
# Plot inside a do loop, to let user try a few times
done = False
trials = []
plt.loglog(freq, fft)
plt.xlim((1e-2, 10))
plt.draw()
for i in range(10):
plt.waitforbuttonpress()
sigma_1 = self.click.xdata
if self.click.button == 1:
c = constants.c.cgs.value * units.cm.to(units.km)
vsini = 0.66 * c / (spectrum.x.mean() * sigma_1)
print "vsini = ", vsini, " km/s"
trials.append(vsini)
plt.cla()
else:
done = True
break
fig.canvas.mpl_disconnect(cid)
if len(trials) == 1:
return trials[0]
print "\n"
for i, vsini in enumerate(trials):
print "\t[%i]: vsini = %.1f km/s" % (i + 1, vsini)
inp = raw_input("\nWhich vsini do you want to use (choose from the options above)? ")
return trials[int(inp) - 1]
def example2_KF():
"""
Jet landing alttitude
Simulated data for noise V_t
Set initialize state from 1000
Generated Data by U, V, X_init, A, B, C
"""
# time t = 0 - 100
T = 100
#### Data simulation #### (below)
## Parameters ##
# Sensor error
R = np.array([[100]])
# Prediction transition
A = np.array([[0.95]])
# Control transition
B = np.array([[0.15]])
# Measurement transition
C = np.array([[0.5]])
# Prediction Covariance init
P = np.array([[1]])
# True state at t = 0
X_true = np.array([[1000]])
X = np.zeros((1,T))
Z = np.zeros((1,T))
X[0,0] = X_true[0,0]
# Control Signal (assumption in tutorial)
U = np.zeros((1,T))
U[0,:] = np.arange(T)
# Noise added to measurement (assumption in tutorial)
V = np.random.randint(-200,200,(1,T))
Z[0,0] = C * X[0,0] + V[0,0]
# Observation
for t in range(1, T):
_AX = A * X[0,t-1]
_BU = B * U[0,t]
X[0,t] = _AX + _BU
_CX_V = C * X[0,t] + V[0,t]
Z[0,t] = _CX_V
##### Data simulation ####### (above)
print("[INFO] Generated Data!")
kf = KF()
t = 0
kf.setInit(X=Z[:1,t:t+1], Z=Z[:1,t:t+1], U=U[:1,t:t+1],
A=A, B=B, C=C, R=R, P=P)
plt.axis([0, T+10, -50, 1100])
plt.grid(True)
plt.plot(list(range(T)), X[0,:], color=(0,1,1))
plt.scatter(t+1, Z[0,t], c='g')
print("t:%d Z:%s X:%s"%(t, Z[0,t], kf.X))
for t in range(1,T):
plt.grid(True)
#plt.pause(0.05)
str_p = ["t:%d"%t]
str_p.append("[G: %s]"%(kf.G))
#print(t, 'G', ekf.G)
plt.scatter(t+1, int(Z[0,t]),c='g')
str_p.append("[Z: %s]"%(Z[0,t]))
#print(t, 0, int(Z[0,t]), t+1)
# initialize State
kf.predict(U=U[:1,t:t+1])
# update State
kf.update(Z[:1,t:t+1])
plt.scatter(t+1, int(kf.X[0,0]),c='r')
str_p.append("[X+: %s]"%(kf.X[0,0]))
#print(t, 1, int(ekf.X[0,0]), t+1)
print(" ".join(str_p))
keyboardClick = False
while (keyboardClick != True) and ((t%50==0) or (t==T-1)):
time.sleep(0.05)
keyboardClick=plt.waitforbuttonpress()
def show_and_save(savename):
plt.pause(0.1)
plt.savefig(savename, dpi=100)
print("savename:", savename)
plt.waitforbuttonpress()
plt.clf()
def train_gan():
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
tf.reset_default_graph()
tf.set_random_seed(1)
# Build Networks
# Network Inputs
gen_input = tf.placeholder(tf.float32,
shape=[None, noise_dim],
name='input_noise')
x = tf.placeholder(tf.float32, shape=[None, 28 * 28])
disc_input = tf.reshape(x, [-1, 28, 28, 1])
label_input = tf.placeholder(tf.float32,
shape=[None, NUM_LABEL],
name='label_input')
# Build Generator Network
generator = Generator()
gen_sample = generator.build(gen_input, label_input)
# Build 2 Discriminator Networks (one from noise input, one from generated samples)
discriminator = Discriminator()
disc_real = discriminator.build(disc_input)
disc_fake = discriminator.build(gen_sample)
# Build Loss
gen_loss = -tf.reduce_mean(tf.log(disc_fake))
disc_loss = -tf.reduce_mean(tf.log(disc_real) + tf.log(1. - disc_fake))
# Build Optimizers
optimizer_gen = tf.train.AdamOptimizer(learning_rate=learning_rate)
optimizer_disc = tf.train.AdamOptimizer(learning_rate=learning_rate)
# Training Variables for each optimizer
# By default in TensorFlow, all variables are updated by each optimizer, so we
# need to precise for each one of them the specific variables to update.
# Generator Network Variables
gen_vars = [
Generator.linear_w, Generator.linear_b, Generator.deconv_w1,
Generator.deconv_w2, Generator.deconv_w3, Generator.deconv_b1,
Generator.deconv_b2, Generator.deconv_b3
]
# Discriminator Network Variables
disc_vars = [
Discriminator.conv_w1, Discriminator.conv_w2, Discriminator.conv_w3,
Discriminator.conv_w4, Discriminator.conv_w5, Discriminator.conv_b1,
Discriminator.conv_b2, Discriminator.conv_b3, Discriminator.conv_b4,
Discriminator.conv_b5, Discriminator.linear_w, Discriminator.linear_b
]
# Create training operations
train_gen = optimizer_gen.minimize(gen_loss, var_list=gen_vars)
train_disc = optimizer_disc.minimize(disc_loss, var_list=disc_vars)
# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()
# Start training
with tf.Session() as sess:
# Run the initializer
sess.run(init)
for i in range(1, num_steps + 1):
# Prepare Data
# Get the next batch of MNIST data (only images are needed, not labels)
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Generate noise to feed to the generator
z = np.random.uniform(-1., 1., size=[batch_size, noise_dim])
# Train
feed_dict = {x: batch_x, label_input: batch_y, gen_input: z}
_, _, gl, dl = sess.run(
[train_gen, train_disc, gen_loss, disc_loss],
feed_dict=feed_dict)
if i % 1000 == 0 or i == 1:
print('Step %i: Generator Loss: %f, Discriminator Loss: %f' %
(i, gl, dl))
# Generate images from noise, using the generator network.
f, a = plt.subplots(4, 10, figsize=(10, 4))
for i in range(10):
# Noise input.
z = np.random.uniform(-1., 1., size=[4, noise_dim])
g = sess.run([gen_sample], feed_dict={gen_input: z})
g = np.reshape(g, newshape=(4, 28, 28, 1))
# Reverse colours for better display
g = -1 * (g - 1)
for j in range(4):
# Generate image from noise. Extend to 3 channels for matplot figure.
img = np.reshape(np.repeat(g[j][:, :, np.newaxis], 3, axis=2),
newshape=(28, 28, 3))
a[j][i].imshow(img)
f.show()
plt.draw()
plt.waitforbuttonpress()
for ax in axes.flatten():
ax.set_xticks([])
ax.set_yticks([])
while True:
rand_idx = np.random.choice(np.arange(len(metadata)),
size=N,
replace=False)
X, y = [], []
for idx in rand_idx:
filename = os.path.join(config("image_path"), metadata.loc[idx,
"filename"])
X.append(imread(filename))
y.append(metadata.loc[idx, "semantic_label"])
for i, (xi, yi) in enumerate(zip(X, y)):
axes[0, i].imshow(xi)
axes[0, i].set_title(yi)
X_ = resize(np.array(X))
X_ = standardizer.transform(X_)
for i, (xi, yi) in enumerate(zip(X_, y)):
axes[1, i].imshow(denormalize_image(xi), interpolation="bicubic")
plt.draw()
if plt.waitforbuttonpress(0) == None:
break
print("OK, bye!")
def average_all_results(all_s: List[SimStats], display_plots: bool):
"""Gather information regarding all runs and its metrics"""
# gather summary information
actors_wo_end = [
len([1 for a in stats.actors if not a.reached_dest()])
for stats in all_s
]
avg_actors_not_finishing = np.sum(actors_wo_end) / len(all_s)
actors_summary = [
compute_average_over_time(stats.actors_in_graph) for stats in all_s
]
edges_summary = [{
str(e): compute_average_over_time(stats.edges_flow_over_time[e])
for e in stats.edges_flow_over_time
} for stats in all_s]
# gather atis information
atis_no = np.hstack([[a.total_travel_time for a in stats.actors]
for stats in all_s])
results = {
'avg_actors_not_finishing':
avg_actors_not_finishing,
'avg_actors': [np.mean(actors_summary),
np.std(actors_summary)],
'avg_edges':
defaultdict(lambda: []),
'time_atis_no': [np.mean(atis_no), np.std(atis_no)]
if len(atis_no) > 0 else [np.nan, np.nan]
}
for d in edges_summary:
for d_k in d:
results['avg_edges'][d_k].append(d[d_k])
results['avg_edges'] = {
e: [np.mean(results['avg_edges'][e]),
np.std(results['avg_edges'][e])]
for e in results['avg_edges']
}
# gather new information with atis separation
actors_flow = defaultdict(lambda: [(0.0, 0)])
for s in all_s:
for key in s.actors_atis.keys():
s.actors_atis[key] = s.actors_atis[key][1:]
for tuple in s.actors_atis[key]:
actors_flow[key].append(tuple)
for key in actors_flow.keys():
actors_flow[key] = sorted(actors_flow[key], key=lambda t: t[0])
actors_flow_acc = defaultdict(lambda: [(0.0, 0)])
for key in actors_flow.keys():
for actor_tuple in actors_flow[key]:
actors_flow_acc[key].append(
[actor_tuple[0], actor_tuple[1] + actors_flow_acc[key][-1][1]])
# plot_accumulated_actor_graph(actors_flow_acc, len(all_s))
# plt.waitforbuttonpress(0)
results['actors_atis_natis'] = actors_flow_acc
# the above but for every edge
inner_default_dict = lambda: defaultdict(lambda: [])
results['edges_occupation'] = defaultdict(inner_default_dict)
for s in all_s:
edges = s.edges_flow_atis
for key in edges.keys():
for service in edges[key]:
results['edges_occupation'][str(key)][service].append(
edges[key][service])
for e_key in results['edges_occupation'].keys():
edge_flow = defaultdict(lambda: [(0.0, 0)])
# pretty(results['edges_occupation'][e_key])
for actor_key in results['edges_occupation'][e_key]:
for tuple_list in results['edges_occupation'][e_key][actor_key]:
tuple_list = tuple_list[1:]
for tuple in tuple_list:
edge_flow[actor_key].append(tuple)
for key in edge_flow.keys():
edge_flow[key] = sorted(edge_flow[key], key=lambda t: t[0])
edge_flow_acc = defaultdict(lambda: [(0.0, 0)])
for actor_key in edge_flow.keys():
for edge_tuple in edge_flow[actor_key]:
edge_flow_acc[actor_key].append([
edge_tuple[0],
edge_tuple[1] + edge_flow_acc[actor_key][-1][1]
])
for actor_key in edge_flow_acc.keys():
edge_flow_acc[actor_key] = edge_flow_acc[actor_key][1:]
# print("acc")
# print(edge_flow_acc)
results['edges_occupation'][e_key] = edge_flow_acc
emissions_dict = {"car": [], "bus": [], "sharedCar": [], "total": []}
number_users_dict = {"car": [], "bus": [], "sharedCar": []}
for run in all_s:
run_emissions_dict = {"car": 0, "bus": 0, "sharedCar": 0, "total": 0}
run_number_users_dict = {"car": 0, "bus": 0, "sharedCar": 0}
for actor in run.actors:
run_emissions_dict[actor.service] += actor.emissions
run_number_users_dict[actor.service] += 1
run_emissions_dict["total"] += actor.emissions
emissions_dict["car"].append(run_emissions_dict["car"])
emissions_dict["bus"].append(run_emissions_dict["bus"])
emissions_dict["sharedCar"].append(run_emissions_dict["sharedCar"])
emissions_dict["total"].append(run_emissions_dict["total"])
number_users_dict["car"].append(run_number_users_dict["car"])
number_users_dict["bus"].append(run_number_users_dict["bus"])
number_users_dict["sharedCar"].append(
run_number_users_dict["sharedCar"])
np.save("{}_emissions".format(run_name), np.array(emissions_dict))
np.save("{}_number".format(run_name), np.array(number_users_dict))
if display_plots:
plot_accumulated_actor_graph(actors_flow_acc, len(all_s))
plot_accumulated_edges_graphs(results['edges_occupation'], len(all_s))
plot_emissions_development(emissions_dict)
plot_number_users_development(number_users_dict)
plt.waitforbuttonpress(0)
return results
def imshow_wait_input(img): """키보드 입력, 마우스클릭 기다리는 imshow""" plt.imshow(img) plt.draw() plt.waitforbuttonpress(0)
with tf.Session() as sess:
sess.run(init)
for step in range(1, training_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Reshape data to get 28 seq of 28 elements
batch_x = batch_x.reshape((batch_size, timesteps, num_input))
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y})
if step % display_step == 0 or step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
plt.scatter(step, acc, c='b')
plt.pause(0.1)
print("Optimization Finished!")
# Calculate accuracy for 128 mnist test images
test_len = 128
test_data = mnist.test.images[:test_len].reshape((-1, timesteps, num_input))
test_label = mnist.test.labels[:test_len]
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: test_data, Y: test_label}))
plt.waitforbuttonpress()
def train_network(noise_input, batch_size, num_steps, learning_rate,
g_noise_input, d_image_input):
# 第一次调用Generator， reuse保持默认的False，创建Generator变量域下的变量
g_output = generator(g_noise_input)
# 第一次调用Discriminator， reuse保持默认的False，创建Discriminator变量域下的变量
d_real_output = discriminator(d_image_input)
# 以g_output作为输入，再次调用discriminator()函数时，与上面以d_image_input调用共享一套鉴别器权重参数，因此设置reuse=True
d_fake_output = discriminator(g_output, reuse=True)
# 计算损失函数
d_real_loss = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(logits=d_real_output,
labels=tf.ones(
[batch_size],
dtype=tf.int32)))
d_fake_loss = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(logits=d_fake_output,
labels=tf.zeros(
[batch_size],
dtype=tf.int32)))
d_loss = d_real_loss + d_fake_loss
g_loss = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(logits=d_fake_output,
labels=tf.ones(
[batch_size],
dtype=tf.int32)))
# 定义优化器
g_optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
d_optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
# 为G和D获取各自的训练参数
g_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='Generator')
d_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='Discriminator')
# 创建训练
g_train = g_optimizer.minimize(g_loss, var_list=g_vars)
d_train = d_optimizer.minimize(d_loss, var_list=d_vars)
# 初始化变量
init = tf.global_variables_initializer()
# 开始训练
sess = tf.Session()
sess.run(init)
for i in range(1, num_steps + 1):
# 准备数据
batch_x, _ = mnist.train.next_batch(batch_size)
batch_x = np.reshape(batch_x, newshape=[-1, 28, 28, 1])
# 训练鉴别器D和生成器G
z = np.random.uniform(-1, 1, size=[batch_size,
noise_input]) # 随机生成噪声输入
_, _, gl, dl = sess.run([g_train, d_train, g_loss, d_loss],
feed_dict={
g_noise_input: z,
d_image_input: batch_x,
is_training: True
})
if i % 100 == 0 or i == 1:
print("Step %i: Generator Loss: %f, Discriminator Loss: %f" %
(i, gl, dl))
# 利用生成器网络在噪声中产生图像
f, a = plt.subplots(4, 10, figsize=(10, 4))
for i in range(10):
# Noise input.
z = np.random.uniform(-1., 1., size=[4, noise_input])
g = sess.run(g_output, feed_dict={g_noise_input: z})
for j in range(4):
# Generate image from noise. Extend to 3 channels for matplot figure.
img = np.reshape(np.repeat(g[j][:, :, np.newaxis], 3, axis=2),
newshape=(28, 28, 3))
a[j][i].imshow(img)
f.show()
plt.draw()
plt.waitforbuttonpress()
def imshow(img):
plt.imshow(img[:, :, [2, 1, 0]])
plt.axis("off")
plt.waitforbuttonpress()
plt.imshow(img_origin)
plt.scatter(x=[max_col], y=[max_row], c='r', s=30)
plt.title('scale response is: ' +
str(['{:.3f}'.format(i) for i in max_list]))
plt.subplot(1, 2, 2)
im = plt.imshow(out_mean * 1.0 / 255)
from matplotlib import colors
norm = colors.Normalize(vmin=0, vmax=1)
im.set_norm(norm)
norm = colors.Normalize(vmin=0, vmax=1)
plt.colorbar(ticks=np.linspace(0, 1.0, 10, endpoint=True))
plt.title('resnet oringial size maximum response is %.2f' %
(out_list[0].max()))
plt.draw()
plt.waitforbuttonpress(0.1)
plt.savefig(
'./exp_dir/fish_localise/imgs/resnet50_fish_detect_train/' +
img_list[im_num],
bbox_inches='tight')
###############################################
test_directory = '/home/stevenwudi/Documents/Python_Project/Kaggle_The_Nature_Conversancy_Fisheries_Monitoring/test_stg1'
img_list = os.listdir(test_directory)
# maximize the figure
fig, axes = plt.subplots(nrows=2, ncols=3)
# figManager = plt.get_current_fig_manager()
# figManager.window.showMaximized()
figManager = plt.gcf()
figManager.set_size_inches(40, 15)
def fitqsocont(wa,
fl,
er,
redshift,
oldco=None,
knots=None,
nbin=1,
divmult=1,
forest_divmult=1,
atmos=True,
debug=False):
""" Find an estimate of a QSO continuum.
divmult=3 works well for R~40000, S/N~10, z=3 QSO spectrum.
nbin bins the data for plotting and continuum fitting (obsolete)
"""
# choose initial reference continuum points. Increase divmult for
# fewer initial continuum points (generally needed for poorer S/N
# spectra).
zp1 = 1 + redshift
#reflines = np.array([1025.72, 1215.6701, 1240.14, 1398.0,
# 1549.06, 1908, 2800 ])
# generate the edges of wavelength chunks to send to fitting routine
# these edges and divisions are generated by trial and error
# for S/N = 15ish and resolution = 2000ish
div = np.rec.fromrecords([
(500., 800., 25),
(800., 1190., 25),
(1190., 1213., 4),
(1213., 1230., 6),
(1230., 1263., 6),
(1263., 1290., 5),
(1290., 1340., 5),
(1340., 1370., 2),
(1370., 1410., 5),
(1410., 1515., 5),
(1515., 1600., 15),
(1600., 1800., 8),
(1800., 1900., 5),
(1900., 1940., 5),
(1940., 2240., 15),
(2240., 3000., 25),
(3000., 6000., 80),
(6000., 20000., 100),
],
names=str('left,right,num'))
div.num[2:] = np.ceil(div.num[2:] * divmult)
div.num[:2] = np.ceil(div.num[:2] * forest_divmult)
div.left *= zp1
div.right *= zp1
if debug: print(div.tolist())
temp = [np.linspace(left, right, n + 1)[:-1] for left, right, n in div]
edges = np.concatenate(temp)
if debug: stats(edges)
i0, i1, i2 = edges.searchsorted([wa[0], 1210 * zp1, wa[-1]])
if debug: print(i0, i1, i2)
contpoints = []
if knots is not None:
contpoints.extend(knots)
else:
co, cp = spline_continuum(wa, fl, er, edges[i0:i2], debug=debug)
contpoints.extend(cp)
fig = pl.figure(figsize=(11, 7))
fig.subplots_adjust(left=0.05, right=0.95, bottom=0.1, top=0.95)
wrapper = InteractiveCoFit(wa,
fl,
er,
contpoints,
co=oldco,
nbin=nbin,
redshift=redshift,
fig=fig,
atmos=atmos)
while True:
if wrapper.finished: break
pl.waitforbuttonpress()
return wrapper.continuum, wrapper.contpoints
st = (d-1)*eband_K
plt.plot(outputs[frame,st:st+eband_K],'g')
plt.plot(outputs_lin[frame,st:st+eband_K],'b')
plt.plot(outputs_linstep[frame,st:st+eband_K],'c')
if args.nn:
plt.plot(outputs_nnest[frame,st:st+eband_K],'r')
elif args.nnpf:
plt.plot(outputs_linpf_est[frame,st:st+eband_K],'r')
else:
plt.plot(outputs_linpf[frame,st:st+eband_K],'r')
plt.ylim((0,10))
var_lin = np.var(10*outputs[frame,:]-10*outputs_lin[frame,:])
var_linpf = np.var(10*outputs[frame,:]-10*outputs_linpf[frame,:])
var_linstep = np.var(10*outputs[frame,:]-10*outputs_linstep[frame,:])
print("frame: %d var_lin (b): %3.2f " % (frame,var_lin), end='')
if args.nn:
var_nnest = np.var(10*outputs[frame,:]-10*outputs_nnest[frame,:])
print("var_nnest(r): %3.2f" % (var_nnest), end='')
elif args.nnpf:
var_nnpfest = np.var(10*outputs[frame,:]-10*outputs_linpf_est[frame,:])
print("var_nnpfest(r): %3.2f" % (var_nnpfest), end='')
else:
print("var_linpf(r): %3.2f var_linstep(c): %3.2f" % (var_linpf, var_linstep), end='')
print(flush=True)
plt.show(block=False)
loop = plt.waitforbuttonpress(0)
frame += 1
plt.clf()
def plot_data(d):
for c in range(self.num_classes):
for n in range(self.num_nuisances):
plt.scatter(*d[c][n].T, c=colours[c])
plt.waitforbuttonpress()
def redraw():
plt.gcf().canvas.draw()
plt.waitforbuttonpress(timeout=0.001)
time.sleep(wait)
def fit(self, X, Y, verbose=False):
"""
Trains the model.
Parameters
----------
X: ndarray
features having shape (n_samples, dim).
Y: ndarray
class labels having shape (n_samples,).
verbose: bool
whether or not to visualize the learning process.
Default is False
"""
# some inits
n, d = X.shape
if d != 2:
verbose = False # only plot learning if 2 dimensional
self.possible_labels = np.unique(Y)
# only binary problems please
assert self.possible_labels.size == 2, 'Error: data is not binary'
# initialize the sample weights as equally probable
sample_weights = np.ones(shape=n) / n
# start training
for l in xrange(0, self.n_learners):
# choose the indexes of 'difficult' samples (np.random.choice)
cur_idx = np.random.choice(a=range(0, n),
size=n,
replace=True,
p=sample_weights)
# extract 'difficult' samples
cur_X = X[cur_idx]
cur_Y = Y[cur_idx]
# search for a weak classifier
error = 1
n_trials = 0
while error > 0.5:
# select random feature (np.random.choice)
cur_dim = np.random.choice(a=range(0, d))
# select random split (np.random.uniform)
M, m = np.max(cur_X[:, cur_dim]), np.min(cur_X[:, cur_dim])
cur_split = np.random.uniform(low=m, high=M)
# select random verse (np.random.choice)
label_above_split = np.random.choice(a=self.possible_labels)
label_below_split = -label_above_split
# compute assignment
cur_assignment = np.zeros(shape=n)
cur_assignment[cur_X[:,
cur_dim] >= cur_split] = label_above_split
cur_assignment[cur_X[:,
cur_dim] < cur_split] = label_below_split
# compute error
error = np.sum(
sample_weights[cur_idx[cur_Y != cur_assignment]])
n_trials += 1
if n_trials > 100:
# initialize the sample weights again
sample_weights = np.ones(shape=n) / n
# save weak learner parameter
alpha = np.log((1 - error) / error) / 2
self.alphas[l] = alpha
self.dims[l] = cur_dim
self.splits[l] = cur_split
self.label_above_split[l] = label_above_split
# update sample weights
sample_weights[cur_idx[cur_Y != cur_assignment]] *= np.exp(alpha)
sample_weights[cur_idx[cur_Y == cur_assignment]] *= np.exp(-alpha)
sample_weights /= np.sum(sample_weights)
if verbose:
# plot
plt.clf()
plt.scatter(cur_X[:, 0],
cur_X[:, 1],
c=cur_assignment,
s=sample_weights[cur_idx] * 50000,
cmap=cmap,
edgecolors='k')
M1, m1 = np.max(X[:, 1]), np.min(X[:, 1])
M0, m0 = np.max(X[:, 0]), np.min(X[:, 0])
if cur_dim == 0:
plt.plot([cur_split, cur_split], [m1, M1], 'k-', lw=5)
else:
plt.plot([m0, M0], [cur_split, cur_split], 'k-', lw=5)
plt.xlim([m0, M0])
plt.ylim([m1, M1])
plt.xticks([])
plt.yticks([])
plt.title('Iteration: {:04d}'.format(l))
plt.waitforbuttonpress(timeout=0.1)
def example1_EKF():
"""
Jet landing alttitude
X_true - true state alttitude in meters
Z - observation(measurement) alttitude in meters
"""
# time t = 0 - 9
# True state
X_true = np.array([[1000, 750, 563, 422, 316, 237, 178, 133, 100, 75]])
# Observation
Z = np.array([[1090, 882, 554, 233, 345, 340, 340, 79, 299, -26]])
## Parameters ##
# Sensor error
R = np.array([[200]])
# Prediction transition
A = np.array([[0.75]])
# Prediction Covariance init
P = np.array([[1]])
## Initialize State ##
ekf = EKF()
t = 0
def f(X, U): return np.dot(A, X.copy()) , A.copy()
def h(Z): return Z.copy(), np.eye(ekf._sensDim)
ekf.f = f
ekf.h = h
ekf.setInit(X=Z[:1,t:t+1], Z=Z[:1,t:t+1], R=R, P=P)
plt.axis([0, 11, -50, 1100])
plt.grid(True)
plt.scatter(t+1, Z[0,t], c='g')
print("t:%d Z:%s X:%s"%(t, Z[0,t], ekf.X))
#plt.show()
## loop overvg bf
for t in range(1, X_true.shape[1]):
plt.grid(True)
plt.pause(0.05)
str_p = ["t:%d"%t]
str_p.append("[G: %s]"%(ekf.G))
#print(t, 'G', ekf.G)
plt.scatter(t+1, int(Z[0,t]),c='g')
str_p.append("[Z: %s]"%(Z[0,t]))
#print(t, 0, int(Z[0,t]), t+1)
# initialize State
ekf.predict()
# update State
ekf.update(Z[:1,t:t+1])
plt.scatter(t+1, int(ekf.X[0,0]),c='r')
str_p.append("[X+: %s]"%(ekf.X[0,0]))
#print(t, 1, int(ekf.X[0,0]), t+1)
print(" ".join(str_p))
keyboardClick = False
while keyboardClick != True:
time.sleep(0.05)
keyboardClick=plt.waitforbuttonpress()
#displayLineModel(x0, y0, x0[idx[0]], y0[idx[0]], x0[idx[1]], y0[idx[1]], 'r')
#plt.waitforbuttonpress(0.001)
#if len(list_lines) - 2 > 2:
list_lines = list_lines[-3:]
lines = np.vstack([lines, [y_best_1, x_best_1, y_best_2, x_best_2]])
# Display the lines
plt.figure('Ransac 1')
plt.clf()
plt.imshow(imBGR[..., ::-1] // 2)
plt.scatter(x_original, y_original, color='r', s=1)
data = np.argwhere(m_estimator_sac_best != 0)
#plt.scatter(x_original[best_inliers_Mask], y_original[best_inliers_Mask], c='b')
index = 0
cmap = get_cmap(len(list_lines))
for i in range(len(list_lines)):
plt.scatter(list_lines[i][2][list_lines[i][3]],
list_lines[i][3][list_lines[i][3]],
c=cmap(index))
y1, x1, y2, x2 = list_lines[i][0]
plt.plot([x1, x2], [y1, y2], 'g', marker='o', linewidth=2)
index += 1
plt.xlim(0, imBGR.shape[1])
plt.ylim(imBGR.shape[0], 0)
# Use either of the following functions:
plt.waitforbuttonpress(
0.001) # Wait for a button (click, key) to be pressed
# frameIdx += 10
frameIdx += 10
# plt.waitforbuttonpress() # Pause for 0.02 second. Useful to get an animation
import matplotlib.pyplot as plt
from multiple_view_geometry.scene import Scene
from multiple_view_geometry.cube import Cube
from multiple_view_geometry.camera import Camera
from multiple_view_geometry.camera_image_renderer import CameraImageRenderer
from multiple_view_geometry.homogeneous_matrix import HomogeneousMatrix
from multiple_view_geometry.transform_utils import create_rotation_mat_from_rpy
if __name__ == "__main__":
camera0_extrinsic = HomogeneousMatrix.create([1.7, 0.0, 0.5],
create_rotation_mat_from_rpy(
-np.pi / 2, 0,
-np.pi / 4))
camera0 = Camera("0", camera0_extrinsic)
camera1_extrinsic = HomogeneousMatrix.create([2.3, 0.0, 0.5],
create_rotation_mat_from_rpy(
-np.pi / 2, 0.0, 0))
camera1 = Camera("1", camera1_extrinsic)
cube = Cube((2, 3, 0), (2, 2, 2), resolution=1)
renderer = CameraImageRenderer({
camera0: "red",
camera1: "blue"
},
show_image_frame=True,
show_epipolar_lines=True)
scene = Scene(cube, [camera0, camera1], renderer)
scene.project(True)
plt.waitforbuttonpress(-1)
def keep_plot_open():
plt.show()
plt.waitforbuttonpress(0)
ax.scatter(*zip(*samp1), c="blue", s=50, label="mean=(-1,0), sigma=0.5") ax.scatter(*zip(*samp2), c="green", s=50, label="mean=(1,0), sigma=1.0") ax.scatter(*mean1, c="blue", s=500, marker="+") ax.scatter(*mean2, c="green", s=500, marker="+") ax.scatter(*samp1_mu, c="blue", s=500, marker="o", alpha=0.4) ax.scatter(*samp2_mu, c="green", s=500, marker="o", alpha=0.4) ax.legend(bbox_to_anchor=(1.4, 1.05)) fig.subplots_adjust(right=0.7) xlim = [-2.0, 4.0] ylim = [-3.0, 3.0] ax.set(xlim=xlim) ax.set(ylim=ylim) plt.draw() if args.pdf: plt.savefig(pdf, format="pdf") else: plt.waitforbuttonpress() #pause(10) ### naive linear classifier m1x = samp1_mu[0] m1y = samp1_mu[1] m2x = samp2_mu[0] m2y = samp2_mu[1] P = (0.5 * (m1x + m2x), 0.5 * (m1y + m2y)) N = (m2x - m1x, m2y - m1y) ABC = _sl_gen(P, N=N) naive_lcr = LinClassifier(ABC, samp2_mu) r1, w1, u1 = naive_lcr.test(-1, 1000, NV1) r2, w2, u2 = naive_lcr.test(1, 1000, NV2) acc = (r1 + r2) / 20.0 print "Naive classifier testing:"
return array[index]
def random_number(size):
return random.randint(0, size - 1)
end_dir = os.path.dirname(__file__)
end_dir = end_dir + "/Uloha2"
image_array = np.ndarray(shape=(4, 100, 100, 3), dtype=np.float32)
for parent in os.listdir(end_dir):
if ("Test" in parent) or ("Training" in parent):
for x in range(0, 4):
image = get_image(end_dir + "/" + parent)
image_array[x, :, :] = image
img0 = cv2.cvtColor(image_array[0], cv2.COLOR_RGB2BGR)
img1 = cv2.cvtColor(image_array[1], cv2.COLOR_RGB2BGR)
img2 = cv2.cvtColor(image_array[2], cv2.COLOR_RGB2BGR)
img3 = cv2.cvtColor(image_array[3], cv2.COLOR_RGB2BGR)
plt.subplot(221), plt.imshow(img0), plt.title(parent)
plt.subplot(222), plt.imshow(img1), plt.title(parent)
plt.subplot(223), plt.imshow(img2), plt.title(parent)
plt.subplot(224), plt.imshow(img3), plt.title(parent)
plt.tight_layout()
plt.imshow(img0)
plt.waitforbuttonpress(15)
plt.close()
def tellme(s):
print(s)
plt.title(s, fontsize=16)
plt.draw()
##################################################
# Define a triangle by clicking three points
##################################################
plt.clf()
plt.axis([-1., 1., -1., 1.])
plt.setp(plt.gca(), autoscale_on=False)
tellme('You will define a triangle, click to begin')
plt.waitforbuttonpress()
happy = False
while not happy:
pts = []
while len(pts) < 3:
tellme('Select 3 corners with mouse')
pts = np.asarray(plt.ginput(3, timeout=-1))
if len(pts) < 3:
tellme('Too few points, starting over')
time.sleep(1) # Wait a second
ph = plt.fill(pts[:, 0], pts[:, 1], 'r', lw=2)
tellme('Happy? Key click for yes, mouse click for no')
# algorithm in the book, but there are other options as well
u_n = n / N + noise
while u_n > cumweights[i]:
i += 1
pxn[n] = px[i]
# indicesout = indicesout[np.randperm(np.size(indicesout))]
rng.shuffle(pxn, axis=0)
w.fill(1 / N)
# else:
# pxn = px[:]
N_eff = 1 / np.sum(w**2)
# trajecory sample prediction
for n in range(n):
vkn = PF_dynamic_distribution.rvs()
px[n] = pendulum_dynamics_discrete(pxn[n], vkn, Ts, a)
# plot
sch_particles.set_offsets(np.c_[l * np.sin(pxn[:, 0]),
-l * np.cos(pxn[:, 0])])
sch_true.set_offsets(np.c_[l * np.sin(x[k, 0]), -l * np.cos(x[k, 0])])
fig4.canvas.draw_idle()
plt.show(block=False)
plt.waitforbuttonpress(plotpause)
plt.waitforbuttonpress()
# %%
def get_reference_sl(metadata, settings):
"""
Allows the user to manually digitize a reference shoreline that is used seed
the shoreline detection algorithm. The reference shoreline helps to detect
the outliers, making the shoreline detection more robust.
KV WRL 2018
Arguments:
-----------
metadata: dict
contains all the information about the satellite images that were downloaded
settings: dict with the following keys
'inputs': dict
input parameters (sitename, filepath, polygon, dates, sat_list)
'cloud_thresh': float
value between 0 and 1 indicating the maximum cloud fraction in
the cropped image that is accepted
'cloud_mask_issue': boolean
True if there is an issue with the cloud mask and sand pixels
are erroneously being masked on the images
'output_epsg': int
output spatial reference system as EPSG code
Returns:
-----------
reference_shoreline: np.array
coordinates of the reference shoreline that was manually digitized.
This is also saved as a .pkl and .geojson file.
"""
sitename = settings['inputs']['sitename']
filepath_data = settings['inputs']['filepath']
pts_coords = []
# check if reference shoreline already exists in the corresponding folder
filepath = os.path.join(filepath_data, sitename)
filename = sitename + '_reference_shoreline.pkl'
# if it exist, load it and return it
if filename in os.listdir(filepath):
print('Reference shoreline already exists and was loaded')
with open(os.path.join(filepath, sitename + '_reference_shoreline.pkl'), 'rb') as f:
refsl = pickle.load(f)
return refsl
# otherwise get the user to manually digitise a shoreline on S2, L8 or L5 images (no L7 because of scan line error)
else:
# first try to use S2 images (10m res for manually digitizing the reference shoreline)
if 'S2' in metadata.keys():
satname = 'S2'
filepath = SDS_tools.get_filepath(settings['inputs'],satname)
filenames = metadata[satname]['filenames']
# if no S2 images, try L8 (15m res in the RGB with pansharpening)
elif not 'S2' in metadata.keys() and 'L8' in metadata.keys():
satname = 'L8'
filepath = SDS_tools.get_filepath(settings['inputs'],satname)
filenames = metadata[satname]['filenames']
# if no S2 images and no L8, use L5 images (L7 images have black diagonal bands making it
# hard to manually digitize a shoreline)
elif not 'S2' in metadata.keys() and not 'L8' in metadata.keys() and 'L5' in metadata.keys():
satname = 'L5'
filepath = SDS_tools.get_filepath(settings['inputs'],satname)
filenames = metadata[satname]['filenames']
else:
raise Exception('You cannot digitize the shoreline on L7 images (because of gaps in the images), add another L8, S2 or L5 to your dataset.')
# create figure
fig, ax = plt.subplots(1,1, figsize=[18,9], tight_layout=True)
mng = plt.get_current_fig_manager()
mng.window.showMaximized()
# loop trhough the images
for i in range(len(filenames)):
# read image
fn = SDS_tools.get_filenames(filenames[i],filepath, satname)
im_ms, georef, cloud_mask, im_extra, im_QA, im_nodata = preprocess_single(fn, satname, settings['cloud_mask_issue'])
# compute cloud_cover percentage (with no data pixels)
cloud_cover_combined = np.divide(sum(sum(cloud_mask.astype(int))),
(cloud_mask.shape[0]*cloud_mask.shape[1]))
if cloud_cover_combined > 0.99: # if 99% of cloudy pixels in image skip
continue
# remove no data pixels from the cloud mask (for example L7 bands of no data should not be accounted for)
cloud_mask_adv = np.logical_xor(cloud_mask, im_nodata)
# compute updated cloud cover percentage (without no data pixels)
cloud_cover = np.divide(sum(sum(cloud_mask_adv.astype(int))),
(sum(sum((~im_nodata).astype(int)))))
# skip image if cloud cover is above threshold
if cloud_cover > settings['cloud_thresh']:
continue
# rescale image intensity for display purposes
im_RGB = rescale_image_intensity(im_ms[:,:,[2,1,0]], cloud_mask, 99.9)
# plot the image RGB on a figure
ax.axis('off')
ax.imshow(im_RGB)
# decide if the image if good enough for digitizing the shoreline
ax.set_title('Press <right arrow> if image is clear enough to digitize the shoreline.\n' +
'If the image is cloudy press <left arrow> to get another image', fontsize=14)
# set a key event to accept/reject the detections (see https://stackoverflow.com/a/15033071)
# this variable needs to be immuatable so we can access it after the keypress event
skip_image = False
key_event = {}
def press(event):
# store what key was pressed in the dictionary
key_event['pressed'] = event.key
# let the user press a key, right arrow to keep the image, left arrow to skip it
# to break the loop the user can press 'escape'
while True:
btn_keep = plt.text(1.1, 0.9, 'keep ⇨', size=12, ha="right", va="top",
transform=ax.transAxes,
bbox=dict(boxstyle="square", ec='k',fc='w'))
btn_skip = plt.text(-0.1, 0.9, '⇦ skip', size=12, ha="left", va="top",
transform=ax.transAxes,
bbox=dict(boxstyle="square", ec='k',fc='w'))
btn_esc = plt.text(0.5, 0, '<esc> to quit', size=12, ha="center", va="top",
transform=ax.transAxes,
bbox=dict(boxstyle="square", ec='k',fc='w'))
plt.draw()
fig.canvas.mpl_connect('key_press_event', press)
plt.waitforbuttonpress()
# after button is pressed, remove the buttons
btn_skip.remove()
btn_keep.remove()
btn_esc.remove()
# keep/skip image according to the pressed key, 'escape' to break the loop
if key_event.get('pressed') == 'right':
skip_image = False
break
elif key_event.get('pressed') == 'left':
skip_image = True
break
elif key_event.get('pressed') == 'escape':
plt.close()
raise StopIteration('User cancelled checking shoreline detection')
else:
plt.waitforbuttonpress()
if skip_image:
ax.clear()
continue
else:
# create two new buttons
add_button = plt.text(0, 0.9, 'add', size=16, ha="left", va="top",
transform=plt.gca().transAxes,
bbox=dict(boxstyle="square", ec='k',fc='w'))
end_button = plt.text(1, 0.9, 'end', size=16, ha="right", va="top",
transform=plt.gca().transAxes,
bbox=dict(boxstyle="square", ec='k',fc='w'))
# add multiple reference shorelines (until user clicks on <end> button)
pts_sl = np.expand_dims(np.array([np.nan, np.nan]),axis=0)
geoms = []
while 1:
add_button.set_visible(False)
end_button.set_visible(False)
# update title (instructions)
ax.set_title('Click points along the shoreline (enough points to capture the beach curvature).\n' +
'Start at one end of the beach.\n' + 'When finished digitizing, click <ENTER>',
fontsize=14)
plt.draw()
# let user click on the shoreline
pts = ginput(n=50000, timeout=-1, show_clicks=True)
pts_pix = np.array(pts)
# convert pixel coordinates to world coordinates
pts_world = SDS_tools.convert_pix2world(pts_pix[:,[1,0]], georef)
# interpolate between points clicked by the user (1m resolution)
pts_world_interp = np.expand_dims(np.array([np.nan, np.nan]),axis=0)
for k in range(len(pts_world)-1):
pt_dist = np.linalg.norm(pts_world[k,:]-pts_world[k+1,:])
xvals = np.arange(0,pt_dist)
yvals = np.zeros(len(xvals))
pt_coords = np.zeros((len(xvals),2))
pt_coords[:,0] = xvals
pt_coords[:,1] = yvals
phi = 0
deltax = pts_world[k+1,0] - pts_world[k,0]
deltay = pts_world[k+1,1] - pts_world[k,1]
phi = np.pi/2 - np.math.atan2(deltax, deltay)
tf = transform.EuclideanTransform(rotation=phi, translation=pts_world[k,:])
pts_world_interp = np.append(pts_world_interp,tf(pt_coords), axis=0)
pts_world_interp = np.delete(pts_world_interp,0,axis=0)
# save as geometry (to create .geojson file later)
geoms.append(geometry.LineString(pts_world_interp))
# convert to pixel coordinates and plot
pts_pix_interp = SDS_tools.convert_world2pix(pts_world_interp, georef)
pts_sl = np.append(pts_sl, pts_world_interp, axis=0)
ax.plot(pts_pix_interp[:,0], pts_pix_interp[:,1], 'r--')
ax.plot(pts_pix_interp[0,0], pts_pix_interp[0,1],'ko')
ax.plot(pts_pix_interp[-1,0], pts_pix_interp[-1,1],'ko')
# update title and buttons
add_button.set_visible(True)
end_button.set_visible(True)
ax.set_title('click on <add> to digitize another shoreline or on <end> to finish and save the shoreline(s)',
fontsize=14)
plt.draw()
# let the user click again (<add> another shoreline or <end>)
pt_input = ginput(n=1, timeout=-1, show_clicks=False)
pt_input = np.array(pt_input)
# if user clicks on <end>, save the points and break the loop
if pt_input[0][0] > im_ms.shape[1]/2:
add_button.set_visible(False)
end_button.set_visible(False)
plt.title('Reference shoreline saved as ' + sitename + '_reference_shoreline.pkl and ' + sitename + '_reference_shoreline.geojson')
plt.draw()
ginput(n=1, timeout=3, show_clicks=False)
plt.close()
break
pts_sl = np.delete(pts_sl,0,axis=0)
# convert world image coordinates to user-defined coordinate system
image_epsg = metadata[satname]['epsg'][i]
pts_coords = SDS_tools.convert_epsg(pts_sl, image_epsg, settings['output_epsg'])
# save the reference shoreline as .pkl
filepath = os.path.join(filepath_data, sitename)
with open(os.path.join(filepath, sitename + '_reference_shoreline.pkl'), 'wb') as f:
pickle.dump(pts_coords, f)
# also store as .geojson in case user wants to drag-and-drop on GIS for verification
for k,line in enumerate(geoms):
gdf = gpd.GeoDataFrame(geometry=gpd.GeoSeries(line))
gdf.index = [k]
gdf.loc[k,'name'] = 'reference shoreline ' + str(k+1)
# store into geodataframe
if k == 0:
gdf_all = gdf
else:
gdf_all = gdf_all.append(gdf)
gdf_all.crs = {'init':'epsg:'+str(image_epsg)}
# convert from image_epsg to user-defined coordinate system
gdf_all = gdf_all.to_crs({'init': 'epsg:'+str(settings['output_epsg'])})
# save as geojson
gdf_all.to_file(os.path.join(filepath, sitename + '_reference_shoreline.geojson'),
driver='GeoJSON', encoding='utf-8')
print('Reference shoreline has been saved in ' + filepath)
break
# check if a shoreline was digitised
if len(pts_coords) == 0:
raise Exception('No cloud free images are available to digitise the reference shoreline,'+
'download more images and try again')
return pts_coords
def do_segmentation(self, test_image_name="cheetah.bmp",
ground_truth_image_name=None,sliding_window=True):
"""
Perform segmentation using Bayesian Decision Rule
:param test_image_name: Image to be tested for segmentation
:param ground_truth_image_name: Segmentation mask (ground truth), to compare algorithm results
:param sliding_window: Do sliding window based prediction (for better results)
"""
assert isinstance(test_image_name, str)
if ground_truth_image_name:
assert isinstance(ground_truth_image_name, str)
test_image = cv2.imread(test_image_name)
# convert to GScale cv2 reads images by default as BGR
test_image = cv2.cvtColor(test_image, cv2.COLOR_BGR2GRAY)
assert len(test_image.shape) == 2
# Stride of 1, Therefore for SAME padding, p1+p2 = f - 1, where p1=top, p2=bottom, f=filter
# cv2.BORDER_DEFAULT pads the border with reflection padding(but doesn't repeat the border pixels themselves)
# https://answers.opencv.org/question/50706/border_reflect-vs-border_reflect_101/
f = 8 # filter
p1, p2 = 3, 4 # padding on left/right or top/bottom
padded_test_image = cv2.copyMakeBorder(test_image, p1, p2, p1, p2, borderType=cv2.BORDER_DEFAULT)
segmentation_mask = np.zeros_like(test_image)
R, C = segmentation_mask.shape
if sliding_window:
for i in range(R):
for j in range(C):
segmentation_mask[i, j] = self.get_prediction_on_block(padded_test_image[i:i+f, j:j+f], f)
else:
i, j = 0, 0
while i in range(R):
while j in range(C):
segmentation_mask[i:i+f, j:j+f] = self.get_prediction_on_block(padded_test_image[i:i+f, j:j+f], f)
j += f
i += f
if ground_truth_image_name:
ground_truth_image = cv2.imread(ground_truth_image_name)
ground_truth_image = cv2.cvtColor(ground_truth_image, cv2.COLOR_BGR2GRAY)
false_positives_perc = np.sum(((ground_truth_image/255) == 0) & (segmentation_mask == 1)) / np.sum((ground_truth_image/255) == 1)
false_negatives_perc = np.sum(((ground_truth_image/255) == 1) & (segmentation_mask == 0)) / np.sum((ground_truth_image/255) == 0)
prob_of_error = false_positives_perc*self.prior_class_1 + false_negatives_perc*self.prior_class_0
fig, ax = plt.subplots(nrows=1, ncols=2)
_ = ax[0].imshow(ground_truth_image, cmap="gray")
_ = ax[1].imshow(segmentation_mask, cmap="gray")
_ = ax[0].set_title("Ground truth", fontsize="small")
_ = ax[1].set_title(f"Segmentation Result | Prob. of Error: {prob_of_error:.3f}", fontsize="small")
fig.suptitle(test_image_name + " | Binary Segmentation using Bayesian Decision Rule")
else:
plt.imshow(segmentation_mask, cmap='gray')
title = test_image_name + " | Binary Segmentation using Bayesian Decision Rule"
plt.title = title
plt.show()
plt.waitforbuttonpress()
plt.close("all")
def visualize(args):
data_path = args.datapath or './data/{}/val_data_joint.npy'.format(
args.dataset)
label_path = args.labelpath or './data/{}/val_label.pkl.npy'.format(
args.dataset)
transformded_data = np.load(args.transformed_datapath, allow_pickle=True)
data = np.load(data_path, allow_pickle=True)
with open(label_path, 'rb') as f:
labels = pickle.load(f, encoding='latin1')
bones = bone_pairs[args.dataset]
print(f'Dataset: {args.dataset}\n')
def animate_1(skeleton):
ax1.clear()
ax1.set_xlim([-1, 1])
ax1.set_ylim([-1, 1])
ax1.set_zlim([-1, 1])
for i, j in bones:
joint_locs = skeleton[:, [i, j]]
# plot them
ax1.plot(joint_locs[0], joint_locs[1], joint_locs[2], color='blue')
action_class = labels[1][index] + 1
action_name = actions[action_class]
plt.title(
'Skeleton {} Frame #{} of 300 from {}\n (Action {}: {})'.format(
index, skeleton_index[0], args.dataset, action_class,
action_name))
skeleton_index[0] += 1
return ax1
def animate_2(skeleton):
ax2.clear()
ax2.set_xlim([-1, 1])
ax2.set_ylim([-1, 1])
ax2.set_zlim([-1, 1])
for i, j in bones:
joint_locs = skeleton[:, [i, j]]
# plot them
ax2.plot(joint_locs[0], joint_locs[1], joint_locs[2], color='blue')
action_class = labels[1][index] + 1
action_name = actions[action_class]
plt.title(
'Skeleton {} Frame #{} of 300 from {}\n (Action {}: {})'.format(
index, skeleton_index[0], args.dataset, action_class,
action_name))
skeleton_index[0] += 1
return ax1
for index in args.indices:
# for index in range(0,60,10):
mpl.rcParams['legend.fontsize'] = 10
fig = plt.figure(figsize=(20, 40))
ax1 = fig.add_subplot(2, 1, 1, projection='3d')
ax2 = fig.add_subplot(2, 2, 1, projection='3d')
# get data
skeletons = data[index]
action_class = labels[1][index] + 1
action_name = actions[action_class]
print(f'Sample index: {index}\nAction: {action_class}-{action_name}\n'
) # (C,T,V,M)
# print(skeletons.shape)
# Pick the first body to visualize
skeleton1 = skeletons[..., 0] # out (C,T,V)
# print(skeleton1.shape)
skeleton_index = [0]
skeleton1 = skeleton1.transpose(1, 0, 2)
print(skeleton1.shape)
an1 = FuncAnimation(fig, animate_1, skeleton1)
# an2 = FuncAnimation(fig, animate_2, transformded_data[index])
plt.title('Skeleton {} from {} test data'.format(index, args.dataset))
plt.waitforbuttonpress(0) # this will wait for indefinite time
plt.close(fig)
plt.show()
def handObjectTrack(w, h, objParamInit, handParamInit, objMesh, camProp,
out_dir):
ds = tf.data.Dataset.from_generator(
lambda: dataGen(w, h),
(tf.string, tf.float32, tf.float32, tf.float32, tf.float32),
((None, ), (None, h, w, 3), (None, h, w, 3), (None, h, w, 3),
(None, h, w, 3)))
# assert len(objParamInitList)==len(handParamInitList)
numFrames = 1
# read real observations
frameCntInt, loadData, realObservs = LossObservs.getRealObservables(
ds, numFrames, w, h)
icp = Icp(realObservs, camProp)
# set up the scene
scene = Scene(optModeEnum.MULTIFRAME_RIGID_HO_POSE, frameCnt=numFrames)
objID = scene.addObject(objMesh, objParamInit, segColor=objSegColor)
handID = scene.addHand(handParamInit, handSegColor, baseItemID=objID)
scene.addCamera(f=camProp.f,
c=camProp.c,
near=camProp.near,
far=camProp.far,
frameSize=camProp.frameSize)
finalMesh = scene.getFinalMesh()
# render the scene
renderer = DirtRenderer(finalMesh, renderModeEnum.SEG_COLOR_DEPTH)
virtObservs = renderer.render()
# get loss over observables
observLoss = LossObservs(virtObservs, realObservs,
renderModeEnum.SEG_COLOR_DEPTH)
segLoss, depthLoss, colLoss = observLoss.getL2Loss(isClipDepthLoss=True,
pyrLevel=2)
# get parameters and constraints
handConstrs = Constraints()
paramListHand = scene.getVarsByItemID(
handID, [varTypeEnum.HAND_JOINT, varTypeEnum.HAND_ROT])
jointAngs = paramListHand[0]
handRot = paramListHand[1]
validTheta = tf.concat([handRot, jointAngs], axis=0)
theta = handConstrs.getFullThetafromValidTheta(validTheta)
thetaConstrs, _ = handConstrs.getHandThetaConstraints(validTheta,
isValidTheta=True)
paramListObj = scene.getParamsByItemID(
[parTypeEnum.OBJ_ROT, parTypeEnum.OBJ_TRANS, parTypeEnum.OBJ_POSE_MAT],
objID)
rotObj = paramListObj[0]
transObj = paramListObj[1]
poseMat = paramListObj[2]
paramListHand = scene.getParamsByItemID([
parTypeEnum.HAND_THETA, parTypeEnum.HAND_TRANS, parTypeEnum.HAND_BETA
], handID)
thetaMat = paramListHand[0]
transHand = paramListHand[1]
betaHand = paramListHand[2]
# get icp losses
icpLossHand = icp.getLoss(scene.itemPropsDict[handID].transformedMesh.v,
handSegColor)
icpLossObj = icp.getLoss(scene.itemPropsDict[objID].transformedMesh.v,
objSegColor)
# get rel hand obj pose loss
handTransVars = tf.stack(scene.getVarsByItemID(
handID, [varTypeEnum.HAND_TRANS_REL_DELTA]),
axis=0)
handRotVars = tf.stack(scene.getVarsByItemID(
handID, [varTypeEnum.HAND_ROT_REL_DELTA]),
axis=0)
relPoseLoss = handConstrs.getHandObjRelDeltaPoseConstraint(
handRotVars, handTransVars)
# get final loss
icpLoss = 1e3 * icpLossHand + 1e3 * icpLossObj
totalLoss1 = 1.0e1 * segLoss + 1e0 * depthLoss + 0.0 * colLoss + 1e2 * thetaConstrs + icpLoss + 1e6 * relPoseLoss
totalLoss2 = 1.15 * segLoss + 5.0 * depthLoss + 0.0 * colLoss + 1e2 * thetaConstrs
# get the variables for opt
optVarsHandList = scene.getVarsByItemID(
handID,
[ #varTypeEnum.HAND_TRANS, varTypeEnum.HAND_ROT,
# varTypeEnum.HAND_ROT_REL_DELTA, varTypeEnum.HAND_TRANS_REL_DELTA,
varTypeEnum.HAND_JOINT
],
[])
optVarsHandDelta = scene.getVarsByItemID(
handID,
[varTypeEnum.HAND_TRANS_REL_DELTA, varTypeEnum.HAND_ROT_REL_DELTA], [])
optVarsHandJoint = scene.getVarsByItemID(handID, [varTypeEnum.HAND_JOINT],
[])
optVarsObjList = scene.getVarsByItemID(
objID, [varTypeEnum.OBJ_TRANS, varTypeEnum.OBJ_ROT], [])
optVarsList = optVarsObjList #+ optVarsHandList
optVarsListNoJoints = optVarsObjList #+ optVarsHandList
# get the initial val of variables for BFGS optimizer
initVals = []
for fID in range(len(objParamInitList)):
initVals.append(handParamInitList[fID].trans)
initVals.append(handParamInitList[fID].theta[:3])
initVals.append(handParamInitList[0].theta[handConstrs.validThetaIDs][3:])
for fID in range(len(objParamInitList)):
initVals.append(objParamInitList[fID].trans)
initVals.append(objParamInitList[fID].rot)
initValsNp = np.concatenate(initVals, axis=0)
# setup optimizer
opti1 = Optimizer(totalLoss1,
optVarsList,
'Adam',
learning_rate=0.02 / 2.0,
initVals=initValsNp)
opti2 = Optimizer(totalLoss1,
optVarsListNoJoints,
'Adam',
learning_rate=0.01)
# get the optimization reset ops
resetOpt1 = tf.variables_initializer(opti1.optimizer.variables())
resetOpt2 = tf.variables_initializer(opti2.optimizer.variables())
# tf stuff
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.4
session = tf.Session(config=config)
session.__enter__()
tf.global_variables_initializer().run()
# setup the plot window
if showFig:
plt.ion()
fig = plt.figure()
ax = fig.subplots(4, max(numFrames, 1))
axesList = [[], [], [], []]
for i in range(numFrames):
axesList[0].append(ax[0].imshow(
np.zeros((240, 320, 3), dtype=np.float32)))
axesList[1].append(ax[1].imshow(
np.zeros((240, 320, 3), dtype=np.float32)))
axesList[2].append(ax[2].imshow(
np.random.uniform(0, 2, (240, 320, 3))))
axesList[3].append(ax[3].imshow(
np.random.uniform(0, 1, (240, 320, 3))))
plt.subplots_adjust(top=0.984,
bottom=0.016,
left=0.028,
right=0.99,
hspace=0.045,
wspace=0.124)
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
# python renderer for rendering object texture
pyRend = renderScene(h, w)
pyRend.addObjectFromMeshFile(modelPath, 'obj')
pyRend.addCamera()
pyRend.creatcamProjMat(camProp.f, camProp.c, camProp.near, camProp.far)
segLossList = []
depLossList = []
icpLossList = []
relPoseLossList = []
while (True):
session.run(resetOpt1)
session.run(resetOpt2)
# load new frame
opti1.runOptimization(session, 1, {loadData: True})
# print(icpLoss.eval(feed_dict={loadData: False}))
# print(segLoss.eval(feed_dict={loadData: False}))
# print(depthLoss.eval(feed_dict={loadData: False}))
# run the optimization for new frame
frameID = (realObservs.frameID.eval(
feed_dict={loadData: False}))[0].decode('UTF-8')
opti1.runOptimization(session, FLAGS.numIter, {loadData: False})
segLossList.append(1.0 * segLoss.eval(feed_dict={loadData: False}))
depLossList.append(1.0 * depthLoss.eval(feed_dict={loadData: False}))
icpLossList.append(icpLoss.eval(feed_dict={loadData: False}))
relPoseLossList.append(1e3 *
relPoseLoss.eval(feed_dict={loadData: False}))
# icpLossList.append(1e2*icpLossObj.eval(feed_dict={loadData: False}))
# show all the images for analysis
plt.title(frameID)
depRen = virtObservs.depth.eval(feed_dict={loadData: False})
depGT = realObservs.depth.eval(feed_dict={loadData: False})
segRen = virtObservs.seg.eval(feed_dict={loadData: False})
segGT = realObservs.seg.eval(feed_dict={loadData: False})
poseMatNp = poseMat.eval(feed_dict={loadData: False})
colRen = virtObservs.col.eval(feed_dict={loadData: False})
colGT = realObservs.col.eval(feed_dict={loadData: False})
for f in range(numFrames):
if doPyRendFinalImage:
# render the obj col image
pyRend.setObjectPose('obj', poseMatNp[f].T)
cRend, dRend = pyRend.render()
# blend with dirt rendered image to get full texture image
dirtCol = colRen[f][:, :, [2, 1, 0]]
objRendMask = (np.sum(np.abs(segRen[f] - objSegColor), 2) <
0.05).astype(np.float32)
objRendMask = np.stack([objRendMask, objRendMask, objRendMask],
axis=2)
finalCol = dirtCol * (1 - objRendMask) + (
cRend.astype(np.float32) / 255.) * objRendMask
if showFig:
axesList[0][f].set_data(colGT[f])
if doPyRendFinalImage:
axesList[1][f].set_data(finalCol)
axesList[2][f].set_data(np.abs(depRen - depGT)[f, :, :, 0])
axesList[3][f].set_data(np.abs(segRen - segGT)[f, :, :, :])
if f >= 0:
coordChangMat = np.array([[1., 0., 0.], [0., -1., 0.],
[0., 0., -1.]])
handJoints = scene.itemPropsDict[handID].transorfmedJs.eval(
feed_dict={loadData: False})[f]
camMat = camProp.getCamMat()
handJointProj = cv2.projectPoints(
handJoints.dot(coordChangMat), np.zeros((3, )),
np.zeros((3, )), camMat, np.zeros((4, )))[0][:, 0, :]
imgIn = (colGT[f][:, :, [2, 1, 0]] * 255).astype(
np.uint8).copy()
imgIn = cv2.resize(
imgIn, (imgIn.shape[1] * dscale, imgIn.shape[0] * dscale),
interpolation=cv2.INTER_LANCZOS4)
imgJoints = showHandJoints(
imgIn,
np.round(handJointProj).astype(
np.int32)[jointsMapManoToObman] * dscale,
estIn=None,
filename=None,
upscale=1,
lineThickness=2)
objCorners = getObjectCorners(mesh.v)
rotObjNp = rotObj.eval(feed_dict={loadData: False})[f]
transObjNp = transObj.eval(feed_dict={loadData: False})[f]
objCornersTrans = np.matmul(
objCorners,
cv2.Rodrigues(rotObjNp)[0].T) + transObjNp
objCornersProj = cv2.projectPoints(
objCornersTrans.dot(coordChangMat), np.zeros((3, )),
np.zeros((3, )), camMat, np.zeros((4, )))[0][:, 0, :]
imgJoints = showObjJoints(imgJoints,
objCornersProj * dscale,
lineThickness=2)
alpha = 0.35
rendMask = segRen[f]
# rendMask[:,:,[1,2]] = 0
rendMask = np.clip(255. * rendMask, 0, 255).astype('uint8')
msk = rendMask.sum(axis=2) > 0
msk = msk * alpha
msk = np.stack([msk, msk, msk], axis=2)
blended = msk * rendMask[:, :, [2, 1, 0]] + (1. - msk) * (
colGT[f][:, :, [2, 1, 0]] * 255).astype(np.uint8)
blended = blended.astype(np.uint8)
cv2.imwrite(out_dir + '/annoVis_' + frameID + '.jpg',
imgJoints)
cv2.imwrite(out_dir + '/annoBlend_' + frameID + '.jpg',
blended)
cv2.imwrite(out_dir + '/maskOnly_' + frameID + '.jpg',
(segRen[0] * 255).astype(np.uint8))
depthEnc = encodeDepthImg(depRen[0, :, :, 0])
cv2.imwrite(out_dir + '/renderDepth_' + frameID + '.jpg',
depthEnc)
if doPyRendFinalImage:
cv2.imwrite(out_dir + '/renderCol_' + frameID + '.jpg',
(finalCol[:, :, [2, 1, 0]] * 255).astype(
np.uint8))
if showFig:
plt.savefig(out_dir + '/' + frameID + '.png')
plt.waitforbuttonpress(0.01)
# save all the vars
optVarListNp = []
for optVar in optVarsHandDelta:
optVarListNp.append(optVar.eval())
thetaNp = thetaMat.eval(feed_dict={loadData: False})[0]
betaNp = betaHand.eval(feed_dict={loadData: False})[0]
transNp = transHand.eval(feed_dict={loadData: False})[0]
rotObjNp = rotObj.eval(feed_dict={loadData: False})[0]
transObjNp = transObj.eval(feed_dict={loadData: False})[0]
JTransformed = scene.itemPropsDict[handID].transorfmedJs.eval(
feed_dict={loadData: False})
handJproj = np.reshape(
cv2ProjectPoints(camProp, np.reshape(JTransformed, [-1, 3])),
[numFrames, JTransformed.shape[1], 2])
# vis = getBatch2DPtVisFromDep(depRen, segRen, projPts, JTransformed, handSegColor)
objCornersRest = np.load(
os.path.join(YCB_OBJECT_CORNERS_DIR,
obj.split('/')[0], 'corners.npy'))
objCornersTransormed = objCornersRest.dot(
cv2.Rodrigues(rotObjNp)[0].T) + transObjNp
objCornersproj = np.reshape(
cv2ProjectPoints(camProp, np.reshape(objCornersTransormed,
[-1, 3])),
[objCornersTransormed.shape[0], 2])
savePickleData(
out_dir + '/' + frameID + '.pkl', {
'beta': betaNp,
'fullpose': thetaNp,
'trans': transNp,
'rotObj': rotObjNp,
'transObj': transObjNp,
'JTransformed': JTransformed,
'objCornersRest': objCornersRest,
'objCornersTransormed': objCornersTransormed,
'objName': obj.split('/')[0],
'objLabel': objLabel
})
def example3_EKF():
#2.5 sine period
#### Simulated Data #####
# Time steps
T = 500
tseq = np.linspace(0, 2.5*(2*math.pi), T)
X = np.zeros((1,T))
XT = np.zeros((1,T))
Z = np.zeros((2,T))
_stateDim = 1
_sensDim = 2
# Sensor noise var
R = np.array([[0.64, 0],
[0, 0.64]])
# Constant transition matrix for State vector
A = np.eye(_stateDim)
# Constant transition matrix for Control vector
B = np.eye(_stateDim)
# Constant transition matrix for Measurement from State
C = np.ones((_sensDim,_stateDim))
# Init prediction err
P = np.eye(_stateDim)
# Constant processing noise for both sensor
Q = np.array([[0.5]])
# Bias for sensor
V = np.array([[-1],
[1]])
# Control
U = np.zeros((_stateDim,1))
for t in range(T):
XT[0,t] = math.sin(tseq[t]) + 20
X[0,t] = XT[0,t] + np.random.randn(1)*Q
Z[0,t] = V[0,0] + X[0,t] + np.random.randn(1)*R[0,0]
Z[1,t] = V[1,0] + X[0,t] + np.random.randn(1)*R[1,1]
#### Simulated Data above ########
print("[INFO] Generated Data!")
ekf = EKF()
def f(_X, _U):
return _X.copy(), np.eye(_stateDim)
def h(_Z):
return _Z.copy(), np.ones((_sensDim, _stateDim))
ekf.f = f
ekf.h = h
t = 0
mean = np.mean(Z[:2,t:t+1])
_X = np.array([[mean]])
ekf.setInit(X=_X, Z=Z[:2,t:t+1], R=R, P=P, Q=Q)
plt.axis([0, T+10, 15, 25])
plt.plot(np.arange(T),X[0,:],np.arange(T),Z[0,:],np.arange(T),Z[1,:])
plt.grid(True)
plt.show()
plt.scatter(t+1, mean, c='g')
print("t:%d Z:%s X:%s"%(t, Z[0,t], ekf.X))
print("t:%d Z:%s X:%s"%(t, Z[1,t], ekf.X))
update = []
ti = []
for t in range(1,T):
plt.grid(True)
#plt.pause(0.05)
str_p = ["t:%d"%t]
str_p.append("[G: %s]"%(ekf.G))
#print(t, 'G', ekf.G)
#plt.scatter(t+1, Z[0,t],c='g')
str_p.append("[Z: %s]"%(Z[0,t]))
#print(t, 0, int(Z[0,t]), t+1)
# initialize State
ekf.predict()
# update State
ekf.update(Z=Z[:2,t:t+1])
ti.append(t+1)
update.append(ekf.X[0,0])
#plt.scatter(t+1, int(ekf.X[0,0]),c='r')
#plt.plot(ti, Z[0,0:t], c='b')
#plt.plot(ti, Z[1,0:t], c='g')
#plt.plot(ti, update, c='r')
str_p.append("[X+: %s]"%(ekf.X[0,0]))
#print(t, 1, int(ekf.X[0,0]), t+1)
print(" ".join(str_p))
## 1. Sensor one measurement
#plt.plot(ti, Z[0,0:t], c='b')
## 2. Sensor two measurement
#plt.plot(ti, Z[1,0:t], c='y')
## 3. Mean measurement
plt.plot(ti, np.mean(Z[:,:t],axis=0), c='b')
## 4. Simulated Data
plt.plot(ti, X[0,0:t], c='g')
## 5. Ground True data
plt.plot(ti, XT[0,0:t], c='c')
## 6. Kalman filtered data
plt.plot(ti, update, c='r')
keyboardClick = False
plt.show()
while (keyboardClick != True) and ((t==T-1)):
time.sleep(0.05)
keyboardClick=plt.waitforbuttonpress()
def label_images(metadata, settings):
"""
Load satellite images and interactively label different classes (hard-coded)
KV WRL 2019
Arguments:
-----------
metadata: dict
contains all the information about the satellite images that were downloaded
settings: dict with the following keys
'cloud_thresh': float
value between 0 and 1 indicating the maximum cloud fraction in
the cropped image that is accepted
'cloud_mask_issue': boolean
True if there is an issue with the cloud mask and sand pixels
are erroneously being masked on the images
'labels': dict
list of label names (key) and label numbers (value) for each class
'flood_fill': boolean
True to use the flood_fill functionality when labelling sand pixels
'tolerance': float
tolerance value for flood fill when labelling the sand pixels
'filepath_train': str
directory in which to save the labelled data
'inputs': dict
input parameters (sitename, filepath, polygon, dates, sat_list)
Returns:
-----------
Stores the labelled data in the specified directory
"""
filepath_train = settings['filepath_train']
# initialize figure
fig, ax = plt.subplots(1,
1,
figsize=[17, 10],
tight_layout=True,
sharex=True,
sharey=True)
mng = plt.get_current_fig_manager()
mng.window.showMaximized()
# loop through satellites
for satname in metadata.keys():
filepath = SDS_tools.get_filepath(settings['inputs'], satname)
filenames = metadata[satname]['filenames']
# loop through images
for i in range(len(filenames)):
# image filename
fn = SDS_tools.get_filenames(filenames[i], filepath, satname)
# read and preprocess image
im_ms, georef, cloud_mask, im_extra, im_QA, im_nodata, im_proj = SDS_preprocess.preprocess_single(
fn, satname, settings['cloud_mask_issue'])
# calculate cloud cover
cloud_cover = np.divide(
sum(sum(cloud_mask.astype(int))),
(cloud_mask.shape[0] * cloud_mask.shape[1]))
# skip image if cloud cover is above threshold
if cloud_cover > settings['cloud_thresh'] or cloud_cover == 1:
continue
# get individual RGB image
im_RGB = SDS_preprocess.rescale_image_intensity(
im_ms[:, :, [2, 1, 0]], cloud_mask, 99.9)
im_NDVI = SDS_tools.nd_index(im_ms[:, :, 3], im_ms[:, :, 2],
cloud_mask)
im_NDWI = SDS_tools.nd_index(im_ms[:, :, 3], im_ms[:, :, 1],
cloud_mask)
# initialise labels
im_viz = im_RGB.copy()
im_labels = np.zeros([im_RGB.shape[0], im_RGB.shape[1]])
# show RGB image
ax.axis('off')
ax.imshow(im_RGB)
implot = ax.imshow(im_viz, alpha=0.6)
filename = filenames[i][:filenames[i].find('.')][:-4]
ax.set_title(filename)
##############################################################
# select image to label
##############################################################
# set a key event to accept/reject the detections (see https://stackoverflow.com/a/15033071)
# this variable needs to be immuatable so we can access it after the keypress event
key_event = {}
def press(event):
# store what key was pressed in the dictionary
key_event['pressed'] = event.key
# let the user press a key, right arrow to keep the image, left arrow to skip it
# to break the loop the user can press 'escape'
while True:
btn_keep = ax.text(1.1,
0.9,
'keep ⇨',
size=12,
ha="right",
va="top",
transform=ax.transAxes,
bbox=dict(boxstyle="square", ec='k',
fc='w'))
btn_skip = ax.text(-0.1,
0.9,
'⇦ skip',
size=12,
ha="left",
va="top",
transform=ax.transAxes,
bbox=dict(boxstyle="square", ec='k',
fc='w'))
btn_esc = ax.text(0.5,
0,
'<esc> to quit',
size=12,
ha="center",
va="top",
transform=ax.transAxes,
bbox=dict(boxstyle="square", ec='k', fc='w'))
fig.canvas.draw_idle()
fig.canvas.mpl_connect('key_press_event', press)
plt.waitforbuttonpress()
# after button is pressed, remove the buttons
btn_skip.remove()
btn_keep.remove()
btn_esc.remove()
# keep/skip image according to the pressed key, 'escape' to break the loop
if key_event.get('pressed') == 'right':
skip_image = False
break
elif key_event.get('pressed') == 'left':
skip_image = True
break
elif key_event.get('pressed') == 'escape':
plt.close()
raise StopIteration('User cancelled labelling images')
else:
plt.waitforbuttonpress()
# if user decided to skip show the next image
if skip_image:
ax.clear()
continue
# otherwise label this image
else:
##############################################################
# digitize sandy pixels
##############################################################
ax.set_title(
'Click on SAND pixels (flood fill activated, tolerance = %.2f)\nwhen finished press <Enter>'
% settings['tolerance'])
# create erase button, if you click there it delets the last selection
btn_erase = ax.text(im_ms.shape[1],
0,
'Erase',
size=20,
ha='right',
va='top',
bbox=dict(boxstyle="square",
ec='k',
fc='w'))
fig.canvas.draw_idle()
color_sand = settings['colors']['sand']
sand_pixels = []
while 1:
seed = ginput(n=1, timeout=0, show_clicks=True)
# if empty break the loop and go to next label
if len(seed) == 0:
break
else:
# round to pixel location
seed = np.round(seed[0]).astype(int)
# if user clicks on erase, delete the last selection
if seed[0] > 0.95 * im_ms.shape[1] and seed[
1] < 0.05 * im_ms.shape[0]:
if len(sand_pixels) > 0:
im_labels[sand_pixels[-1]] = 0
for k in range(im_viz.shape[2]):
im_viz[sand_pixels[-1],
k] = im_RGB[sand_pixels[-1], k]
implot.set_data(im_viz)
fig.canvas.draw_idle()
del sand_pixels[-1]
# otherwise label the selected sand pixels
else:
# flood fill the NDVI and the NDWI
fill_NDVI = flood(im_NDVI, (seed[1], seed[0]),
tolerance=settings['tolerance'])
fill_NDWI = flood(im_NDWI, (seed[1], seed[0]),
tolerance=settings['tolerance'])
# compute the intersection of the two masks
fill_sand = np.logical_and(fill_NDVI, fill_NDWI)
im_labels[fill_sand] = settings['labels']['sand']
sand_pixels.append(fill_sand)
# show the labelled pixels
for k in range(im_viz.shape[2]):
im_viz[im_labels == settings['labels']['sand'],
k] = color_sand[k]
implot.set_data(im_viz)
fig.canvas.draw_idle()
##############################################################
# digitize white-water pixels
##############################################################
color_ww = settings['colors']['white-water']
ax.set_title(
'Click on individual WHITE-WATER pixels (no flood fill)\nwhen finished press <Enter>'
)
fig.canvas.draw_idle()
ww_pixels = []
while 1:
seed = ginput(n=1, timeout=0, show_clicks=True)
# if empty break the loop and go to next label
if len(seed) == 0:
break
else:
# round to pixel location
seed = np.round(seed[0]).astype(int)
# if user clicks on erase, delete the last labelled pixels
if seed[0] > 0.95 * im_ms.shape[1] and seed[
1] < 0.05 * im_ms.shape[0]:
if len(ww_pixels) > 0:
im_labels[ww_pixels[-1][1], ww_pixels[-1][0]] = 0
for k in range(im_viz.shape[2]):
im_viz[ww_pixels[-1][1], ww_pixels[-1][0],
k] = im_RGB[ww_pixels[-1][1],
ww_pixels[-1][0], k]
implot.set_data(im_viz)
fig.canvas.draw_idle()
del ww_pixels[-1]
else:
im_labels[seed[1],
seed[0]] = settings['labels']['white-water']
for k in range(im_viz.shape[2]):
im_viz[seed[1], seed[0], k] = color_ww[k]
implot.set_data(im_viz)
fig.canvas.draw_idle()
ww_pixels.append(seed)
im_sand_ww = im_viz.copy()
btn_erase.set(text='<Esc> to Erase', fontsize=12)
##############################################################
# digitize water pixels (with lassos)
##############################################################
color_water = settings['colors']['water']
ax.set_title(
'Click and hold to draw lassos and select WATER pixels\nwhen finished press <Enter>'
)
fig.canvas.draw_idle()
selector_water = SelectFromImage(ax, implot, color_water)
key_event = {}
while True:
fig.canvas.draw_idle()
fig.canvas.mpl_connect('key_press_event', press)
plt.waitforbuttonpress()
if key_event.get('pressed') == 'enter':
selector_water.disconnect()
break
elif key_event.get('pressed') == 'escape':
selector_water.array = im_sand_ww
implot.set_data(selector_water.array)
fig.canvas.draw_idle()
selector_water.implot = implot
selector_water.im_bool = np.zeros(
(selector_water.array.shape[0],
selector_water.array.shape[1]))
selector_water.ind = []
# update im_viz and im_labels
im_viz = selector_water.array
selector_water.im_bool = selector_water.im_bool.astype(bool)
im_labels[selector_water.im_bool] = settings['labels']['water']
im_sand_ww_water = im_viz.copy()
##############################################################
# digitize land pixels (with lassos)
##############################################################
color_land = settings['colors']['other land features']
ax.set_title(
'Click and hold to draw lassos and select OTHER LAND pixels\nwhen finished press <Enter>'
)
fig.canvas.draw_idle()
selector_land = SelectFromImage(ax, implot, color_land)
key_event = {}
while True:
fig.canvas.draw_idle()
fig.canvas.mpl_connect('key_press_event', press)
plt.waitforbuttonpress()
if key_event.get('pressed') == 'enter':
selector_land.disconnect()
break
elif key_event.get('pressed') == 'escape':
selector_land.array = im_sand_ww_water
implot.set_data(selector_land.array)
fig.canvas.draw_idle()
selector_land.implot = implot
selector_land.im_bool = np.zeros(
(selector_land.array.shape[0],
selector_land.array.shape[1]))
selector_land.ind = []
# update im_viz and im_labels
im_viz = selector_land.array
selector_land.im_bool = selector_land.im_bool.astype(bool)
im_labels[selector_land.
im_bool] = settings['labels']['other land features']
# save labelled image
ax.set_title(filename)
fig.canvas.draw_idle()
fp = os.path.join(filepath_train,
settings['inputs']['sitename'])
if not os.path.exists(fp):
os.makedirs(fp)
fig.savefig(os.path.join(fp, filename + '.jpg'), dpi=150)
ax.clear()
# save labels and features
features = dict([])
for key in settings['labels'].keys():
im_bool = im_labels == settings['labels'][key]
features[key] = SDS_shoreline.calculate_features(
im_ms, cloud_mask, im_bool)
training_data = {
'labels': im_labels,
'features': features,
'label_ids': settings['labels']
}
with open(os.path.join(fp, filename + '.pkl'), 'wb') as f:
pickle.dump(training_data, f)
# close figure when finished
plt.close(fig)
def plot_mean(th):
for c in range(self.num_classes):
for n in range(self.num_nuisances):
plt.scatter(*th[c][n].mean.T, c=colours[c], marker="x")
plt.waitforbuttonpress()
