In [13]:

from display import parse_and_show, displacement_field
import matplotlib.pyplot as plt
import subprocess
import time
import numpy as np
import cPickle as pickle
import os
import sys
from config import frame_cols, frame_rows, get_px_ndx, get_image_pair

In [44]:

image_dir = '../../data/vort_sim'
im_pair = get_image_pair(image_dir)

In [3]:

X, Y, U, V = displacement_field(pickle.load(open(os.path.join(image_dir, 'stdout.pck'), 'rb')), image_dir)

In [6]:

from scipy import mgrid, signal

In [7]:

def gauss_kern(size, sizey=None):
    """ Returns a normalized 2D gauss kernel array for convolutions """
    size = int(size)
    if not sizey:
        sizey = size
    else:
        sizey = int(sizey)
    x, y = mgrid[-size:size+1, -sizey:sizey+1]
    g = exp(-(x**2/float(size)+y**2/float(sizey)))
    return g / g.sum()
def blur_image(im, n, ny=None) :
    """ blurs the image by convolving with a gaussian kernel of typical
        size n. The optional keyword argument ny allows for a different
        size in the y direction.
    """
    g = gauss_kern(n, sizey=ny)
    improc = signal.convolve(im,g, mode='valid')
    return(improc)

In [11]:

Z = np.power(U, 2) + np.power(V, 2)

In [143]:

plt.figure()
plt.contourf(Z)
plt.colorbar()
plt.gca().invert_yaxis()
plt.savefig('sample_density.pdf')

In [144]:

plt.figure()
plt.contourf(blur_image(Z, 5))
plt.gca().invert_yaxis()
plt.colorbar()

Out[144]:

<matplotlib.colorbar.Colorbar instance at 0x10c20d320>

In [55]:

P = blur_image(Z, 5)
cum_P = np.cumsum(np.reshape(P, None, 1))
total = cum_P[-1]

In [97]:

P = np.exp(Z)
P.size
P.shape

Out[97]:

(56, 76)

In [145]:

P = np.exp(Z / 6)

pixel_Z = np.kron(Z, np.ones((8, 8)))
pixel_Z = np.concatenate((pixel_Z, np.zeros((448, 32))), axis=1)
pixel_Z = np.concatenate((pixel_Z, np.zeros((32, 640))), axis=0)
print pixel_Z.shape
pixel_P = np.exp(pixel_Z/6)
cum_P = np.cumsum(np.reshape(pixel_P, None, 1))
total = cum_P[-1]
new = np.random.sample(1000)*total
ndx = np.searchsorted(cum_P, new)
y = ndx // im_pair.A.size[0]
x = ndx % im_pair.A.size[0]
ndx[x > 600] = ndx[x > 600] - 40
ndx[y > 440] = ndx[y > 440] - 40 * im_pair.A.size[0]
y = ndx // im_pair.A.size[0]
x = ndx % im_pair.A.size[0]
plt.figure()
plt.plot(x, y, 'r.')
plt.gca().invert_yaxis()
plt.savefig('sample_points.pdf')
pickle.dump(ndx, open('adaptive_coords.pck', 'wb'))
print max(ndx), 640*480

(480, 640)
282142 307200

In [136]:

print max(x), max(y)

600 440

In [132]:

a = np.array([1,2,3])
a[a > 1]

Out[132]:

array([2, 3])

In [59]:

np.searchsorted(cum_P, total)

Out[59]:

In [60]:

3035 // frame_cols(im_pair.A)

Out[60]:

In [61]:

frame_rows(im_pair.A)

Out[61]:

In [66]:

frame_cols(im_pair.A)

Out[66]:

In [62]:

X.size

Out[62]:

In [63]:

Z.size

Out[63]:

In [113]:

np.concatenate((np.array([[1],[2],[3]]), np.zeros((3,2))), axis=1)

Out[113]:

array([[ 1.,  0.,  0.],
       [ 2.,  0.,  0.],
       [ 3.,  0.,  0.]])

In [ ]: