def __init__(self, fleet_config):
super().__init__('fleet_driver_mir')
self.fleet_config = fleet_config
self.robots = {}
self.api_clients = []
self.status_pub = self.create_publisher(FleetState, 'fleet_states', 1)
self.pub_timer = self.create_timer(self.STATUS_PUB_PERIOD,
self.pub_fleet)
self.ref_coordinates_rmf = [[26.95, -20.23], [29.26, -22.38],
[11.4, -16.48], [12.46, -16.99]]
self.ref_coordinates_mir = [[7.2, 16.6], [5.15, 18.35], [23, 12.35],
[22.05, 12.95]]
self.rmf2mir_transform = nudged.estimate(self.ref_coordinates_rmf,
self.ref_coordinates_mir)
self.mir2rmf_transform = nudged.estimate(self.ref_coordinates_mir,
self.ref_coordinates_rmf)
mse = nudged.estimate_error(self.rmf2mir_transform,
self.ref_coordinates_rmf,
self.ref_coordinates_mir)
self.get_logger().info(f'transformation estimate error: {mse}')
for api_client in self.create_all_api_clients(self.fleet_config):
self.get_logger().info(f'initializing robot from \
{api_client.configuration.host}')
robot = Robot(self)
robot.api = mir100_client.DefaultApi(api_client)
# temporary retry configuration to workaround startup race condition while launching
connection_pool_kw = robot.api.api_client.rest_client.pool_manager.connection_pool_kw
orig_retries = connection_pool_kw.get('retries')
retries = urllib3.Retry(10)
retries.backoff_factor = 1
retries.status_forcelist = (404, )
connection_pool_kw['retries'] = retries
mir_status = robot.api.status_get()
robot.name = mir_status.robot_name
self.load_missions(robot)
self.update_positions(robot)
# reset retries
if orig_retries is not None:
connection_pool_kw['retries'] = orig_retries
else:
del connection_pool_kw['retries']
self.robots[robot.name] = robot
self.get_logger().info(f'successfully initialized robot \
{robot.name}')
# Setup fleet driver ROS2 topic subscriptions
self.path_request_sub = self.create_subscription(
PathRequest, '/robot_path_requests', self.on_path_request, 1)
self.mode_sub = self.create_subscription(ModeRequest,
f'/robot_mode_requests',
self.on_robot_mode_request, 1)
def compute_transforms(rmf_coordinates, mir_coordinates, node=None):
"""Get transforms between RMF and MIR coordinates."""
transforms = {
'rmf_to_mir': nudged.estimate(rmf_coordinates, mir_coordinates),
'mir_to_rmf': nudged.estimate(mir_coordinates, rmf_coordinates)
}
if node:
mse = nudged.estimate_error(transforms['rmf_to_mir'], rmf_coordinates,
mir_coordinates)
node.get_logger().info(f"Transformation estimate error: {mse}")
return transforms
def test_error(self):
dom = [[0,0], [1,1], [2, 2]]
ran = [[0,-1], [1,2], [2,-1]]
t = nudged.estimate(dom, ran)
self.assertEqual(t.transform(dom), [[0,0], [1,0], [2,0]])
mse = nudged.estimate_error(t, dom, ran)
self.assertEqual(mse, 2.0)
def nudgeTransf(x_p, y_p, cr_m_data):
"""
This works but gives *very* poor results (July 2019)
"""
ra, dec = cr_m_data['field_ra'], cr_m_data['field_dec']
x, y = cr_m_data['field_x'], cr_m_data['field_y']
import nudged
dom = list(map(list, zip(x, y)))
ran = list(map(list, zip(-ra, dec)))
trans = nudged.estimate(dom, ran)
cc = list(map(list, list(np.array([x_p, y_p]).T)))
ra_p, dec_p = np.array(trans.transform(cc)).T
ra_p = -ra_p
print(trans.get_matrix())
print(trans.get_rotation())
print(trans.get_scale())
print(trans.get_translation())
# plt.subplot(221);plt.title("dom");plt.scatter(x, y)
# plt.subplot(222);plt.title("ran");plt.scatter(ra, dec)
# plt.subplot(223);plt.title("(x, y)");plt.scatter(x_p, y_p)
# plt.subplot(224);plt.title("(x_t, y_t)");plt.scatter(ra_p, dec_p)
# plt.show()
ra_p = MaskedColumn(ra_p, name='ra')
dec_p = MaskedColumn(dec_p, name='dec')
return ra_p, dec_p
def test_rotation_in_radians(self):
'''
should give rotation in radians
'''
t = nudged.estimate([(1, 1), (-1, -1)], [(-2, -2), (2, 2)])
# 's': -2, 'r': 0, 'tx': 0, 'ty': 0
self.assertEqual(t.get_rotation(), pi)
def test_scale(self):
'''
should give scale
'''
t = nudged.estimate([(1, 1), (-1, -1)], [(-2, -2), (2, 2)])
# 's': -2, 'r': 0, 'tx': 0, 'ty': 0
self.assertEqual(t.get_scale(), 2.0)
def test_error(self):
dom = [(0, 0), (1, 1), (2, 2)]
ran = [(0, -1), (1, 2), (2, -1)]
t = nudged.estimate(dom, ran)
self.assertEqual(t.transform(dom), [(0, 0), (1, 0), (2, 0)])
mse = nudged.estimate_error(t, dom, ran)
self.assertEqual(mse, 2.0)
def test_scale(self):
'''
should give scale
'''
t = nudged.estimate([[ 1, 1], [-1,-1]], [[-2,-2], [ 2, 2]]);
# 's': -2, 'r': 0, 'tx': 0, 'ty': 0
self.assertEqual(t.get_scale(), 2.0)
def test_rotation_in_radians(self):
'''
should give rotation in radians
'''
t = nudged.estimate([[ 1, 1], [-1,-1]], [[-2,-2], [ 2, 2]]);
# 's': -2, 'r': 0, 'tx': 0, 'ty': 0
self.assertEqual(t.get_rotation(), pi)
def test_error(self):
dom = [[0, 0], [1, 1], [2, 2]]
ran = [[0, -1], [1, 2], [2, -1]]
t = nudged.estimate(dom, ran)
self.assertEqual(t.transform(dom), [[0, 0], [1, 0], [2, 0]])
mse = nudged.estimate_error(t, dom, ran)
self.assertEqual(mse, 2.0)
def load_label_data(self, js_list):
self.js_list = js_list
eg_p_l = self.eg_p_l
for js_name in self.js_list:
# data = open( js_name)
# data = json.load(data)
data = js_name
p_l = data['annotations']
_, pic_name = data["images"].split('/')
self.pic_name_l.append(pic_name)
trans = nudged.estimate(eg_p_l, p_l)
trans_location = trans.get_translation()
trans_scale = trans.get_scale()
p_Transed_l = [[(i[0] - trans_location[0]) / trans_scale,
(i[1] - trans_location[1]) / trans_scale]
for i in p_l]
exec(self.cfg['preprocess_data'])
for k, v in zip(self.params_d.keys(), self.params_d.values()):
""" k:funcs v: params"""
v = eval(v)
v = str(v)
# cal_dim = eval(k+'('+'eval('+'str(v)'+')'+',p_Transed_l,eg_p_l,p_l'+')')
cal_dim = eval(k + '(' + v + ',p_Transed_l,eg_p_l,p_l' + ')')
dim_l, score_l = cal_dim.calculate_dim()
self.load_score(dim_l, score_l)
def test_list_len_zero(self):
'''
should allow lists of length zero
'''
t = nudged.estimate([], []);
# Identity transform
self.assertEqual(t.transform([0,0]), [0,0]);
self.assertEqual(t.transform([7,7]), [7,7]);
def test_list_len_zero(self):
'''
should allow lists of length zero
'''
t = nudged.estimate([], [])
# Identity transform
self.assertEqual(t.transform((0, 0)), (0, 0))
self.assertEqual(t.transform((7, 7)), (7, 7))
def swap_faces(img1, img2):
# get landmark points from the images
landmarks1 = landmarks_from_pil_image(img1)
landmarks2 = landmarks_from_pil_image(img2)
img1_index = random.randint(0, len(landmarks1) - 1)
img2_index = random.randint(0, len(landmarks2) - 1)
landmarks1 = landmarks1[img1_index]
landmarks2 = landmarks2[random.randint(0, len(landmarks2) - 1)]
bb = coords_from_pil_image(img1)[img1_index]
bb = coords_from_pil_image(img2)[img2_index]
# calculate transformation matrix to go from one set of points to the other
trans_matrix1 = nudged.estimate(landmarks2, landmarks1).get_matrix()
trans1 = transform.ProjectiveTransform(matrix=np.array(trans_matrix1))
# transform the images to be on top of each other
img1_transformed = transform.warp(
np.array(img1), trans1,
output_shape=np.array(img2).shape[:2]).dot(255).astype('uint8')
s = np.linspace(0, 2 * np.pi, 400)
height = (bb.bottom() - bb.top())
rad_y = height / 2 * 1.2
x = (bb.left() + bb.right()) / 2 + (bb.right() - bb.left()) / 2 * np.cos(s)
y = (bb.top() + bb.bottom()) / 2 + rad_y * np.sin(s) - height * 0.15
init = np.array([x, y]).T
#init = init.dot(trans_matrix1)
shape = active_contour(gaussian(rgb2gray(img1_transformed), 3),
init,
alpha=0.08,
beta=1,
gamma=0.001,
max_iterations=height * 0.1,
max_px_move=1)
#shape = init
output = Image.fromarray(img1_transformed)
mask = Image.new('L', output.size)
draw = ImageDraw.Draw(mask)
draw.polygon([tuple(coord)[:2] for coord in shape], fill="white")
#draw = ImageDraw.Draw(img2)
#draw.polygon([tuple(coord)[:2] for coord in shape], outline="red")
#return img2
# Match histograms on the selected areas
hist_mask = Image.fromarray(
morphology.dilation(np.array(mask),
morphology.disk(int(height * 0.1))))
img2_histogram = generate_histogram(img2, hist_mask)
img1_histogram = generate_histogram(Image.fromarray(img1_transformed),
hist_mask)
matched = Image.fromarray(
match_histograms(np.asarray(img1_histogram),
np.asarray(img2_histogram),
multichannel=True))
mask = gaussian(np.array(mask), height * 0.1)
mask = Image.fromarray(mask.dot(255).astype('uint8'))
output = Image.composite(matched, img2, mask)
return output
def test_estimation(self):
'''
should estimate correctly
'''
for sple in samples:
t = nudged.estimate(sple['a'], sple['b'])
for k in ['s', 'r', 'tx', 'ty']:
msg = sple['id'] + ': ' + k + '=' + str(getattr(t, k))
self.assertEqual(getattr(t, k), sple[k], msg)
def test_estimation(self):
'''
should estimate correctly
'''
for sple in samples:
t = nudged.estimate(sple['a'], sple['b'])
for k in ['s', 'r', 'tx', 'ty']:
msg = sple['id'] + ': ' + k + '=' + str(getattr(t, k))
self.assertEqual(getattr(t, k), sple[k], msg)
def _align_image(self, image, shape):
shape = np.array(shape)
assert (np.prod(shape.shape) == 10)
shape = shape.reshape((5, 2))
tform = nudged.estimate(shape, self.anchor_points)
tform = np.asarray(tform.get_matrix())
img_align = cv2.warpPerspective(image, tform, self.align_size)
img_resize = cv2.resize(img_align, self.input_size)
return img_resize
def test_lists(self):
'''
should allow arrays of different length
but ignore the points without a pair
'''
dom = [[1,-1], [ 3, -2], [1, 2]]
ran = [[3, 4], [10, 8]]
# 's': 2, 'r': 3, 'tx': -2, 'ty': 3
t = nudged.estimate(dom, ran)
self.assertEqual(t.transform([1,1]), [-3,8])
def test_lists(self):
'''
should allow arrays of different length
but ignore the points without a pair
'''
dom = [[1, -1], [3, -2], [1, 2]]
ran = [[3, 4], [10, 8]]
# 's': 2, 'r': 3, 'tx': -2, 'ty': 3
t = nudged.estimate(dom, ran)
self.assertEqual(t.transform([1, 1]), [-3, 8])
def tag(self, tag):
"""Called when tag needs to be inserted into data."""
if self.collect_data:
self.collect_file.write(json.dumps({'tag': tag}) + '\n')
# check if validity is to be calculated
if tag["secondary_id"] == "start":
# go to nudged calibration mode
if "nudged_point" in tag:
# Nudged point format: "1.0, 0.5"
[x, y] = tag["nudged_point"].split(",")
xf = float(x)
yf = float(y)
self.nudged_current_range = [xf, yf]
# check if previous occurrances of this point exist
while [xf, yf] in self.nudged_range:
# find the index of the element in range
ind = self.nudged_range.index([xf, yf])
# remove the index from range and domains
self.nudged_range.pop(ind)
self.nudged_domain_l.pop(ind)
self.nudged_domain_r.pop(ind)
elif tag["secondary_id"] == "end":
if "nudged_point" in tag:
self.nudged_current_range = None
# calculate nudged transform
print "Calculating nudged calibration for right eye with " + \
"vectors: dom[" + str(len(self.nudged_domain_r)) + \
"] and range[" + str(len(self.nudged_range))
self.nudged_transform_r = nudged.estimate(
self.nudged_domain_r, self.nudged_range)
print "Calculating new calibration..."
self.nudged_transform_l = nudged.estimate(
self.nudged_domain_l, self.nudged_range)
return False
def test_lists(self):
'''
should allow arrays of different length
but ignore the points without a pair
'''
dom = [(1, -1), (3, -2), (1, 2)]
ran = [(3, 4), (10, 8)]
# 's': 2, 'r': 3, 'tx': -2, 'ty': 3
t = nudged.estimate(dom, ran)
self.assertEqual(t.transform((1, 1)), (-3, 8))
def tag(self, tag):
"""Called when tag needs to be inserted into data."""
if self.collect_data:
self.collect_file.write(json.dumps({'tag': tag}) + '\n')
# check if validity is to be calculated
if tag["secondary_id"] == "start":
# go to nudged calibration mode
if "nudged_point" in tag:
# Nudged point format: "1.0, 0.5"
[x, y] = tag["nudged_point"].split(",")
xf = float(x)
yf = float(y)
self.nudged_current_range = [xf, yf]
# check if previous occurrances of this point exist
while [xf, yf] in self.nudged_range:
# find the index of the element in range
ind = self.nudged_range.index([xf, yf])
# remove the index from range and domains
self.nudged_range.pop(ind)
self.nudged_domain_l.pop(ind)
self.nudged_domain_r.pop(ind)
elif tag["secondary_id"] == "end":
if "nudged_point" in tag:
self.nudged_current_range = None
# calculate nudged transform
print "Calculating nudged calibration for right eye with " + \
"vectors: dom[" + str(len(self.nudged_domain_r)) + \
"] and range[" + str(len(self.nudged_range))
self.nudged_transform_r = nudged.estimate(self.nudged_domain_r,
self.nudged_range)
print "Calculating new calibration..."
self.nudged_transform_l = nudged.estimate(self.nudged_domain_l,
self.nudged_range)
return False
def calc_106_landmarks(self, image, shapes):
images = []
tform_reverses = []
results = []
# preprocess and alignment
for shape in shapes:
shape = shape.reshape(-1, 2)
tform = nudged.estimate(shape, self.RefPts)
tform = np.asarray(tform.get_matrix())
img_warp = cv2.warpPerspective(image.copy(), tform,
(self.crop_size, self.crop_size))
img_tmp = cv2.resize(img_warp, (self.input_size, self.input_size))
if (self.type_str == "caffe_106"):
img_tmp = img_tmp.transpose(2, 0, 1) - 128.0
else:
img_tmp = (img_tmp - 127.5) * (1. / 128.0)
tform_reverses.append(np.asarray(np.mat(tform).I))
images.append(img_tmp)
if (len(images) == 0):
return results
images = np.asarray(images)
if (self.type_str == "tensorflow_106"):
outputs = self.sess.run(
'align/fc2/fc2:0',
feed_dict={'align/alignment_input:0': images})
for index, (output, tform_reverse) in enumerate(
zip(outputs, tform_reverses)):
point_aligned = np.concatenate((output.reshape(-1, 2) * (self.crop_size*1.0 / self.input_size), \
np.ones((106,1),dtype=np.float32)),axis=1)
point_original = np.dot(tform_reverse,
point_aligned.T)[:2, :].T
point_original = point_original.reshape((-1, 1))
results.append(point_original)
else:
for index, (image, tform_reverse) in enumerate(
zip(images, tform_reverses)):
self.net.blobs['data'].data[...] = np.asarray([image])
self.net.forward()
output = (self.net.blobs['fc106pts'].data[...].reshape(-1, 2) +
self.input_size / 2) * (self.crop_size * 1.0 /
self.input_size)
point_aligned = np.concatenate(
(output.reshape(-1, 2), np.ones(
(106, 1), dtype=np.float32)),
axis=1)
point_original = np.dot(tform_reverse,
point_aligned.T)[:2, :].T
point_original = point_original.reshape((-1, 1))
results.append(point_original)
return np.around(np.array(results))
def dissimilar(V, projections, X, min_threshold, err_threshold=0.8):
VT = V.T
m = 2 - min(map(lambda p: norm(VT.dot(p)), projections))
if m < min_threshold:
return False
Y = X.T.dot(V).tolist()
for p in projections:
Y2 = X.T.dot(p)
affine = nudged.estimate(Y, Y2.tolist())
err = norm(Y2 - np.array(affine.transform(Y))) / norm(Y2)
if err < err_threshold:
return False
return True
def load_label_data(self, js_list):
self.js_list = js_list
eg_p_l = self.eg_p_l
for js_name, pic_name in tqdm(zip(self.js_list, self.pic_name_list)):
data = open(self.data_path + js_name)
data = json.load(data)
points_ = data['shapes']
p_l = []
for p in points_:
p_l.append([p['points'][0][0], p['points'][0][1]])
self.pic_name_l.append(pic_name)
trans = nudged.estimate(eg_p_l, p_l)
trans_location = trans.get_translation()
trans_scale = trans.get_scale()
p_Transed_l = [[(i[0] - trans_location[0]) / trans_scale,
(i[1] - trans_location[1]) / trans_scale]
for i in p_l]
exec(self.cfg['preprocess_data'])
for k, v in zip(self.params_d.keys(), self.params_d.values()):
""" k:funcs v: params"""
v = eval(v)
v = str(v)
# cal_dim = eval(k+'('+'eval('+'str(v)'+')'+',p_Transed_l,eg_p_l,p_l'+')')
cal_dim = eval(k + '(' + v + ',p_Transed_l,eg_p_l,p_l' + ')')
print(k)
# print(v)
dim_l, score_l = cal_dim.calculate_dim()
self.load_score(dim_l, score_l)
if self.vis_data:
is_save = True
display(self.data_path, pic_name, self.save_path, is_save, p_l,
eg_p_l)
clearHis()
def get_processed_image(img):
image = imread(img)
a = get_facial_points(image, 49)
b = reftracker
trans = nudged.estimate(a, b)
h = np.array(trans.get_matrix())[0:2]
# h, status = cv2.findHomography(a, b)
warpedxx = np.array(cv2.warpAffine(xxc, h, xxc.shape))
warpedyy = np.array(cv2.warpAffine(yyc, h, yyc.shape))
warpedmask = np.array(cv2.warpAffine(maskc, h, maskc.shape))
# warpedxx = np.array(cv2.warpPerspective(xxc, h, xxc.shape))
# warpedyy = np.array(cv2.warpPerspective(yyc, h, yyc.shape))
# warpedmask = np.array(cv2.warpPerspective(maskc, h, maskc.shape))
warpedxx = warpedxx[600:1400, 600:1200]
warpedyy = warpedyy[600:1400, 600:1200]
warpedmask = warpedmask[600:1400, 600:1200]
filtered_img = np.zeros((image.shape[0], image.shape[1], 6))
filtered_img[:, :, 0:3] = normalize_image(image)
filtered_img[:, :, 3] = warpedxx
filtered_img[:, :, 4] = warpedyy
filtered_img[:, :, 5] = warpedmask
return filtered_img
def setUp(self):
dom = [[1, -1], [ 3, -2]]
ran = [[3, 4], [10, 8]]
self.t = nudged.estimate(dom, ran)
def test_zero_error(self):
dom = [(0, 0), (1, 1)]
ran = [(1, 1), (2, 2)]
t = nudged.estimate(dom, ran)
mse = nudged.estimate_error(t, dom, ran)
self.assertEqual(mse, 0.0)
import numpy as np import matplotlib.pyplot as plt import nudged x = [[1, 0], [0, 1], [-1, 0], [0, -1]] y = np.add([[0, -2], [2, 0], [0, 2], [-2, 0]], 1) trans = nudged.estimate(x, y) y1 = trans.transform([1, 0]) print(trans.get_rotation()) print(trans.get_scale()) print(trans.get_translation()) print(y1)
def test_list_len_one(self):
'''
should allow lists of length one
'''
t = nudged.estimate([[1, 1]], [[5, 5]])
self.assertEqual(t.transform([4, 4]), [8, 8])
def test_zero_error(self):
dom = [[0, 0], [1, 1]]
ran = [[1, 1], [2, 2]]
t = nudged.estimate(dom, ran)
mse = nudged.estimate_error(t, dom, ran)
self.assertEqual(mse, 0.0)
def test_singleton_domain(self):
dom = [0,0]
ran = [[1,1], [2,2]]
f = lambda: nudged.estimate(dom, ran)
self.assertRaises(TypeError, f)
def test_identical_points(self):
'''
should allow a list of identical points
'''
t = nudged.estimate([[1,1], [1,1]], [[5,5], [7,7]])
self.assertEqual(t.transform([1,1]), [6,6])
def test_list_len_one(self):
'''
should allow lists of length one
'''
t = nudged.estimate([(1, 1)], [(5, 5)])
self.assertEqual(t.transform((4, 4)), (8, 8))
def findMultipleLP(X, d, k, sigma, maxIter, embMethod='lpp', labs=None):
N = X.shape[1]
W = np.zeros((N, N))
B = np.zeros((N, N))
if embMethod == 'pca':
for i in range(N - 1):
for j in range(i + 1, N):
W[i, j] = 1.0 / N
W = np.maximum(W, W.T)
B = np.eye(N)
L = B - W
M1 = X.dot(L).dot(X.T)
Mc = np.eye(M1.shape[0])
elif embMethod == 'lpp':
G = kneighbors_graph(X.T, k, mode='distance',
include_self=False).toarray()
W = 0.5 * (G + G.T)
W[W != 0] = np.exp(-W[W != 0] / (2 * sigma * sigma))
B = np.diag(np.sum(W, axis=0))
L = B - W
M1 = X.dot(L).dot(X.T)
Mc = X.dot(B).dot(X.T)
elif embMethod == 'lde':
Gw = np.zeros((N, N))
Gb = np.zeros((N, N))
dists = pairwise_distances(X.T)
for ii in range(N):
inds = np.where(labs == labs[ii])[0]
sinds = np.argsort(dists[ii, inds])
Gw[ii, inds[sinds[:k]]] = 1
inds = np.where(labs != labs[ii])[0]
sinds = np.argsort(dists[ii, inds])
Gb[ii, inds[sinds[:k]]] = 1
Gw = np.maximum(Gw, Gw.T)
Bw = np.diag(np.sum(Gw, axis=0))
Lw = Bw - Gw
M1 = X.dot(Lw).dot(X.T)
Gb = np.maximum(Gb, Gb.T)
Bb = np.diag(np.sum(Gb, axis=0))
Lb = Bb - Gb
Mc = X.dot(Lb).dot(X.T)
u, s = eig(M1)
u = np.real(u)
if np.min(u) < 0:
M1 = M1 - np.min(u) * np.eye(M1.shape[0])
u, s = eig(Mc)
u = np.real(u)
if np.min(u) < 0:
Mc = Mc - np.min(u) * np.eye(Mc.shape[0])
projList = []
projListFinal = []
if embMethod == 'lde':
# gamma = 1e3 # bio 1e3
gamma = 5e2
thresh = 0.5 * 2
else:
gamma = 1e4
thresh = 0.6 * 2
for iters in range(1, maxIter + 1):
if iters > 1:
#print np.linalg.norm(X.dot(L).dot(X.T)), np.linalg.norm(C)
if embMethod == 'pca':
M1 = X.dot(L).dot(X.T) - gamma * C
elif embMethod == 'lpp':
M1 = X.dot(L).dot(X.T) + gamma * C
elif embMethod == 'lde':
M1 = X.dot(Lw).dot(X.T) + gamma * C
M1 = 0.5 * (M1 + M1.T)
u, s = np.linalg.eig(M1)
if np.min(u) < 0:
M1 = M1 - np.min(u) * np.eye(M1.shape[0])
eigvals, eigvecs = eig(M1, Mc)
eigvals = np.real(eigvals)
eigvecs = np.real(eigvecs)
eigvecs = np.dot(np.real(sp.linalg.sqrtm(Mc)), eigvecs)
if embMethod == 'pca':
ind = np.argsort(-eigvals)
temp = eigvecs[:, ind[0:d]]
elif embMethod == 'lpp' or embMethod == 'lde':
ind = np.argsort(eigvals)
temp = eigvecs[:, ind[0:d]]
for dim in range(2):
temp[:, dim] /= np.linalg.norm(temp[:, dim])
if len(projList) == 0:
projList.append(temp)
C = matprod(temp, temp.T)
projListFinal.append(temp)
else:
projList.append(temp)
C = grassSum(projList)
#print np.linalg.norm(temp[:,0]), np.linalg.norm(temp[:,1])
mval = 1e10
for kk in projListFinal:
mval = np.minimum(mval,
2 - np.linalg.norm(matprod(temp.T, kk)))
if mval > thresh:
err = []
emb1 = (temp.T.dot(X)).T
emb1 = emb1.tolist()
for ps in projListFinal:
emb2 = (ps.T.dot(X)).T
emb2 = emb2.tolist()
trans = nudged.estimate(emb1, emb2)
tt = np.linalg.norm(
np.array(emb2) -
np.array(trans.transform(emb1))) / np.linalg.norm(emb2)
err.append(tt)
# print np.linalg.norm(emb1), err
#print mval, np.min(np.array(err))
if np.min(np.array(err)) > 0.8:
projListFinal.append(temp)
#print len(projList), len(projListFinal)
return projListFinal
def test_zero_error(self):
dom = [[0,0], [1,1]]
ran = [[1,1], [2,2]]
t = nudged.estimate(dom, ran)
mse = nudged.estimate_error(t, dom, ran)
self.assertEqual(mse, 0.0)
def test_identical_points(self):
'''
should allow a list of identical points
'''
t = nudged.estimate([(1, 1), (1, 1)], [(5, 5), (7, 7)])
self.assertEqual(t.transform((1, 1)), (6, 6))
def test_singleton_domain(self):
dom = (0, 0)
ran = [(1, 1), (2, 2)]
self.assertRaises(TypeError, lambda: nudged.estimate(dom, ran))
def setUp(self):
dom = [(1, -1), (3, -2)]
ran = [(3, 4), (10, 8)]
self.t = nudged.estimate(dom, ran)
def test_list_len_one(self):
'''
should allow lists of length one
'''
t = nudged.estimate([[1,1]], [[5,5]])
self.assertEqual(t.transform([4,4]), [8,8])
