def __init__(self, device, picname, people):
analyser = Analyse(device, UNNAMED, picname)
self.data = analyser.get_data()
labels = []
data = np.empty([0, 128])
for key, value in people.iteritems():
for i in xrange(len(value)):
labels.append(key)
data = np.vstack((data, np.asarray(value)))
data = np.vstack((data, self.data))
k_neibor = 8
if len(labels) < 8:
k_neibor = len(labels)
sc = SC(n_clusters=len(people), k_neibor=k_neibor)
output = sc.fit_predict(data, labels)
self.name = labels[output]
self.confidence = 90
def make_network(eye, target, dt):
# inh_weight = -0.001
def plant_model(t, x):
x = np.matrix(x).T
eye.step(x, dt)
if eye.state[2] > 250: eye.state[2] = 250
return np.array(eye.state).squeeze()
with nengo.Network() as model:
model.config[nengo.Ensemble].encoders = nengo.dists.Uniform(1, 1)
model.config[nengo.Ensemble].intercepts = nengo.dists.Uniform(0, 0.9)
model.target = nengo.Node(output=target.step)
model.SC_net = SC(n_neurons=1000)
model.plant = nengo.Node(size_in=2, output=plant_model, label='l_eye')
model.cbm = cbm()
model.OPN = nengo.Ensemble(dimensions=1, n_neurons=200)
model.internal = Internal_Model(eye, neurons=1000)
model.SBG = SBG()
nengo.Connection(model.target, model.cbm.MF, transform=1. / 45)
nengo.Connection(model.SC_net.output[0],
model.cbm.IO,
transform=1. / 30)
nengo.Connection(model.target,
model.SC_net.stim_transform[0],
synapse=None)
nengo.Connection(model.SC_net.output[0], model.SBG.LLBN, synapse=None)
# nengo.Connection(model.SBG.LLBN, model.OPN,
# function=lambda x: 0 if x >= 5 else 1)
# nengo.Connection(model.SBG.LLBN, model.cbm, synapse=0.005)
# nengo.Connection(model.OPN, model.SBG.EBN.neurons,
# transform=inh_weight * np.ones((n_neurons, 1)))
# nengo.Connection(model.OPN, model.SBG.IBN.neurons,
# transform=inh_weight * np.ones((n_neurons, 1)))
# nengo.Connection(model.OPN, model.SBG.LLBN.neurons,
# transform=inh_weight * np.ones((n_neurons, 1)))
nengo.Connection(model.SBG.AMN, model.plant[0])
# nengo.Connection(model.SBG.OMN, model.plant[1])
nengo.Connection(model.SBG.AMN, model.internal.control)
# nengo.Connection(model.SBG.OMN, model.internal.control)
# nengo.Connection(model.internal.pos, model.SBG.LLBN, transform=-1)
nengo.Connection(model.internal.pos, model.SC_net.stim_transform[1])
nengo.Connection(model.cbm.DCN, model.SBG.EBN, transform=200)
model.epos = nengo.Node(size_in=1, label='eye_pos')
model.vel = nengo.Node(size_in=1, label='eye_vel')
model.force = nengo.Node(size_in=1, label='eye_force')
nengo.Connection(model.plant[0], model.epos, synapse=None)
nengo.Connection(model.plant[1], model.vel, synapse=None)
nengo.Connection(model.plant[2], model.force, synapse=None)
synapse = 0.005
model.pulse_p = nengo.Probe(model.SBG.EBN_AMN, synapse=synapse)
model.pos_p = nengo.Probe(model.epos, synapse=None)
model.vel_p = nengo.Probe(model.vel, synapse=None)
model.force_p = nengo.Probe(model.force, synapse=None)
model.integ_p = nengo.Probe(model.SBG.TN_AMN, synapse=synapse)
model.control_p = nengo.Probe(model.SBG.AMN, synapse=synapse)
model.ipos_p = nengo.Probe(model.internal.pos, synapse=synapse)
model.ivel_p = nengo.Probe(model.internal.vel, synapse=synapse)
model.iforce_p = nengo.Probe(model.internal.force, synapse=synapse)
model.OPN_p = nengo.Probe(model.OPN, synapse=synapse)
model.IBN_p = nengo.Probe(model.SBG.IBN_OMN, synapse=synapse)
model.LLBN_p = nengo.Probe(model.SBG.LLBN, synapse=synapse)
model.SC_p = nengo.Probe(model.SC_net.output[0], synapse=synapse)
model.DCN_p = nengo.Probe(model.cbm.DCN, synapse=synapse)
model.IO_p = nengo.Probe(model.cbm.IO, synapse=synapse)
model.PC_p = nengo.Probe(model.cbm.PCs, synapse=synapse)
model.MF_p = nengo.Probe(model.cbm.MF, synapse=synapse)
model.hpass_p = nengo.Probe(model.cbm.hpass_node, synapse=synapse)
return model
def make_graph(P1, P2, COST, LINES=[]):
from matplotlib import pylab
ax = pylab.subplot(111)
pylab.grid(True)
pylab.plot(P1[0], P1[1], 'go', P2[0], P2[1], 'ro')
ax.set_title('Total cost: %s' % COST)
for l in LINES:
pylab.plot((l[0][0], l[1][0]), (l[0][1], l[1][1]), 'k-')
pylab.show()
a = SC()
sampls = 100
points1, t1 = get_points_from_img('B.png', simpleto=sampls)
points2, t2 = get_points_from_img('D.png', simpleto=sampls)
P = a.compute(points1)
x1 = [p[0] for p in points1]
y1 = [400 - p[1] for p in points1]
Q = a.compute(points2)
x2 = [p[0] for p in points2]
y2 = [400 - p[1] for p in points2]
"""
# get rendom r shape contexts from query shape
Qs,points_ids = a.get_contextes(Q,5)
points2s = [points2[i] for i in points_ids]
x.append(al[i][0])
y.append(al[i][1])
ax = pylab.subplot(111)
pylab.grid(True)
pylab.plot(P1[0], P1[1], "go", P2[0], P2[1], "ro")
ax.set_title("Total cost: %s" % COST)
for l in LINES:
pylab.plot((l[0][0], l[1][0]), (l[0][1], l[1][1]), "k-")
pylab.show()
a = SC(r_outer=2)
sampls = 30
imgs = get_elements("test.png")
points1, t1 = get_points_from_img("9M.png", simpleto=sampls)
P = a.compute(points1)
x1 = [p[0] for p in points1]
y1 = [400 - p[1] for p in points1]
for i, img in enumerate(imgs):
cv.ShowImage("Preview - %s" % i, img)
cv.WaitKey()
sys.exit()
for img in imgs:
from sklearn.neighbors import NearestNeighbors
from sklearn.neighbors import LSHForest
from SC import SC
import numpy as np
from plot import plot # For plotting accuracies
import cv2
import time
Points_train = []
CANNY = 1
a = SC() # Shape context object
sampls = 100 # No. of points to select
# def timing(f):
# def wrap(*args):
# time1 = time.time()
# ret = f(*args)
# time2 = time.time()
# print '%s function took %0.3f ms' % (f.func_name, (time2-time1)*1000.0)
# return ret
# return wrap
def get_points_from_img(src, treshold=50, simpleto=100, t=CANNY):
''' Returns #simpleto points representing the image boundary '''
# Check for valid src #
if isinstance(src, str):
src = cv2.imread(src, cv2.IMREAD_GRAYSCALE)
#Load as grayscale image
# Canny edge detection #
if t == CANNY:
#debug
test_contours_img = np.zeros(src_test.shape)
src_contours_img = np.zeros(src.shape)
cv2.drawContours(src_contours_img, contour_samples, -1, (255, 255, 255))
cv2.drawContours(test_contours_img, test_contour_samples, -1, (255, 255, 255))
cv2.imshow("contours_test", test_contours_img)
cv2.imshow("contours", src_contours_img)
cv2.waitKey(0)
#end debug
'''
sc = SC()
test_contour_SC = sc.compute(test_contour_samples[0][:, 0, :])
input_contours_SC = []
min_cost = sys.maxint
min_cost_contour = input_samples[0]
for input_contour_samples in input_samples:
contour_SC = sc.compute(input_contour_samples[:, 0, :])
contour_cost, indices = sc.diff(test_contour_SC, contour_SC)
input_contours_SC.append((contour_SC, contour_cost))
print "Cost = ", contour_cost
if (contour_cost < min_cost):
min_cost = contour_cost
min_cost_contour = input_contour_samples
#debug
test_contours_img = np.zeros(src_test.shape)
src_contours_img = np.zeros(src.shape)
cv2.drawContours(src_contours_img, contour_samples, -1, (255, 255, 255))
cv2.drawContours(test_contours_img, test_contour_samples, -1, (255, 255, 255))
cv2.imshow("contours_test", test_contours_img)
cv2.imshow("contours", src_contours_img)
cv2.waitKey(0)
#end debug
'''
sc = SC()
test_contour_SC = sc.compute(test_contour_samples[0][:, 0, :])
input_contours_SC = []
min_cost = sys.maxint
min_cost_contour = input_samples[0]
for input_contour_samples in input_samples:
contour_SC = sc.compute(input_contour_samples[:, 0, :])
contour_cost, indices = sc.diff(test_contour_SC, contour_SC)
input_contours_SC.append((contour_SC, contour_cost))
print "Cost = ", contour_cost
if (contour_cost < min_cost):
min_cost = contour_cost
min_cost_contour = input_contour_samples