"""

# window in 'flat', 'hanning', 'hamming', 'bartlett', 'blackman'

S = np.r_[Z[length-1:0:-1], Z, Z[-2:-length-1:-1]]

if window == 'flat':

W = np.ones(length,'d')

else:

W = eval('np.' + window + '(length)')

Z = np.convolve(W/W.sum(), S, mode='valid')

"""

values = np.array(values)

if len(values.shape) == 1:

values = values.reshape(len(values), 1)

n_values = values.shape[1]

gates = np.array(gates)

if len(gates.shape) == 1:

gates = gates.reshape(len(gates), 1)

n_gates = gates.shape[1]

size = len(values)

data = np.zeros(size, dtype = [ ("input", float, (n_values + n_gates,)),

("output", float, ( n_gates,))])

# Input signals

data["input"][:, 0:n_values ] = values

data["input"][:, n_values: ] = gates

wm = np.zeros(n_gates)

# If no last activity set gate=1 at time t=0

if last is None:

wm[:] = data["input"][0, 0]

data["input"][0, 1:] = 1

else:

wm[:] = last

# Output value(s) according to gates

for i in range(size):

for j in range(n_gates):

# Output at time of gate is not changed

# data["output"][i,j] = wm[j]

if data["input"][i,n_values+j] > 0:

wm[j] = data["input"][i,0]

# Output at time of gate is changed

data["output"][i,j] = wm[j]

"""

# Load fonts

fonts = ["./Inconsolata-Regular.ttf"]

faces = [ft.Face(filename) for filename in fonts]

for face in faces:

face.set_char_size(size*64)

slots = [face.glyph for face in faces]

# Find baseline and height (maximum)

baseline, height = 0, 0

for face in faces:

ascender = face.size.ascender >> 6

descender = face.size.descender >> 6

height = max(height, ascender-descender)

baseline = max(baseline, -descender)

# Set individual character font and zoom level

font_index = np.random.randint(0, len(faces), len(text))

zoom_level = np.random.uniform(zmin, zmax, len(text))

# First pass to compute bounding box

width = 0

previous = 0

for i,c in enumerate(text):

index = font_index[i]

zoom = zoom_level[i]

face, slot = faces[index], slots[index]

face.load_char(c, ft.FT_LOAD_RENDER | ft.FT_LOAD_FORCE_AUTOHINT)

bitmap = slot.bitmap

kerning = face.get_kerning(previous, c).x >> 6

kerning = int(round(zoom*kerning))

advance = slot.advance.x >> 6

advance = int(round(zoom*advance))

if i == len(text)-1:

width += max(advance, int(round(zoom*bitmap.width)))

else:

width += advance + kerning

previous = c

# Allocate arrays for storing data

Z = np.zeros((height,width), dtype=np.ubyte)

I = np.zeros(width, dtype=np.int) + ord(' ')

# Second pass for actual rendering

x, y = 0, 0

previous = 0

for i,c in enumerate(text):

index = font_index[i]

zoom = zoom_level[i]

face, slot = faces[index], slots[index]

face.load_char(c, ft.FT_LOAD_RENDER | ft.FT_LOAD_FORCE_AUTOHINT)

bitmap = slot.bitmap

top, left = slot.bitmap_top, slot.bitmap_left

w,h = bitmap.width, bitmap.rows

y = height - baseline - top

kerning = 0

if(add_kerning):

kerning = face.get_kerning(previous, c).x >> 6

kerning = int(round(zoom*kerning))

advance = slot.advance.x >> 6

advance = int(round(zoom*advance))

glyph = np.array(bitmap.buffer, dtype='ubyte').reshape(h,w)

glyph = scipy.ndimage.zoom(glyph, (1, zoom), order=3)

w = glyph.shape[1]

x += kerning

left = 0

Z[y:y+h,x+left:x+left+w] += glyph

I[x:x+w] = ord(c)

x += advance

previous = c

values = (data_["input"][:, 0]).astype(int)

text = [chr(ord("0")+i) for i in values]

Z, I = str_to_bmp(text, size = size)

Z = Z [3:-3]

n_gate = data_["output"].shape[1]

# Z *= np.random.uniform(0.9,1.1,Z.shape)

# Z = np.maximum(np.minimum(Z,1),0)

data = np.zeros(Z.shape[1], dtype = [ ("input", float, (1 + Z.shape[0],)),

("output", float, ( n_gate,))])

data["input"][:, :-1] = Z.T + noise*np.random.uniform(-1,1, size = Z.T.shape)

n = Z.shape[1]//len(text)

data["input"][:,-1] = np.repeat(data_["input"][:, 1], n)

data["output"][:, 0] = np.repeat(data_["output"], n) / 10