def get_cm(sim_arr):
shape = np.array(sim_arr.shape)
cent = (shape.astype("float") - [1, 1]) / 2
# center of mass
torque = np.array([0.0, 0.0])
mass = 0.0
inertia_sum = 0.0
area = np.zeros(sim_arr.shape)
area[sim_arr > np.max(sim_arr) * 0.9] = sim_arr[sim_arr > np.max(sim_arr) * 0.9]
for cn in coords_iterate(shape):
r = np.array(cn) - cent
torque += area[cn] * r
mass += area[cn]
# if no mass, return zero
if mass == 0:
return np.array([0, 0]), 0
cm = torque / mass
for cn in coords_iterate(shape):
r = np.array(cn) - cent
a = la.norm(r)
inertia_sum += a ** 2 * area[cn]
inertia = inertia_sum / mass
return cm, inertia
def get_cm(sim_arr):
shape = np.array(sim_arr.shape)
cent = (shape.astype('float') - [1, 1]) / 2
# center of mass
torque = np.array([0.0, 0.0])
mass = 0.0
inertia_sum = 0.0
area = np.zeros(sim_arr.shape)
area[sim_arr > np.max(sim_arr) * 0.9] = sim_arr[sim_arr > np.max(sim_arr) * 0.9]
for cn in coords_iterate(shape):
r = (np.array(cn) - cent)
torque += area[cn] * r
mass += area[cn]
# if no mass, return zero
if mass == 0:
return np.array([0, 0]), 0
cm = torque / mass
for cn in coords_iterate(shape):
r = (np.array(cn) - cent)
a = la.norm(r)
inertia_sum += a ** 2 * area[cn]
inertia = inertia_sum / mass
return cm, inertia
def __init__(self, size=[160, 120], neighborarea=[8, 8]):
self.size = size
shape = size
nsensels = shape[0] * shape[1]
# for each sensel, create an area
lengths = np.array(neighborarea)
neighbor_coords = [None] * nsensels
self.neighbor_indices_flat = [None] * nsensels
flattening = Flattening.by_rows(tuple(shape))
cmg = cmap(lengths)
self.cmg = cmg
for coord in coords_iterate(shape):
k = flattening.cell2index[coord]
cm = cmg.copy()
cm[:, :, 0] += coord[0]
cm[:, :, 1] += coord[1]
cm[:, :, 0] = cm[:, :, 0] % shape[0]
cm[:, :, 1] = cm[:, :, 1] % shape[1]
neighbor_coords[k] = cm
indices = np.zeros(lengths, 'int32')
for a, b in coords_iterate(indices.shape):
c = tuple(cm[a, b, :])
indices[a, b] = flattening.cell2index[c]
self.neighbor_indices_flat[k] = np.array(indices.flat)
def summarize_smooth(self, noise=0.1):
''' Find best estimate for diffeomorphism
looking at each singularly. '''
maximum_likelihood_index = np.zeros(self.shape, dtype='int32')
variance = np.zeros(self.shape, dtype='float32')
epsilon = None
for c in coords_iterate(self.shape):
k = self.flattening.cell2index[c]
sim = self.neighbor_similarity_flat[k]
if epsilon is None:
epsilon = np.random.randn(*sim.shape)
sim_min = sim.min()
sim_max = sim.max()
if sim_max == sim_min:
best_index = 0
variance[c] = 0
else:
std = noise * (sim_max - sim_min)
best = np.argmin(sim + epsilon * std)
best_index = self.neighbor_indices_flat[k][best]
variance[c] = sim[best]
maximum_likelihood_index[c] = best_index
d = self.flattening.flat2coords(maximum_likelihood_index)
variance = variance - variance.min()
vmax = variance.max()
if vmax > 0:
variance *= (1 / vmax)
return Diffeomorphism2D(d, variance)
def summarize_smooth(self, noise=0.1):
''' Find best estimate for diffeomorphism
looking at each singularly. '''
maximum_likelihood_index = np.zeros(self.shape, dtype='int32')
variance = np.zeros(self.shape, dtype='float32')
epsilon = None
for c in coords_iterate(self.shape):
k = self.flattening.cell2index[c]
sim = self.neighbor_similarity_flat[k]
if epsilon is None:
epsilon = np.random.randn(*sim.shape)
sim_min = sim.min()
sim_max = sim.max()
if sim_max == sim_min:
best_index = 0
variance[c] = 0
else:
std = noise * (sim_max - sim_min)
best = np.argmin(sim + epsilon * std)
best_index = self.neighbor_indices_flat[k][best]
variance[c] = sim[best]
maximum_likelihood_index[c] = best_index
d = self.flattening.flat2coords(maximum_likelihood_index)
variance = variance - variance.min()
vmax = variance.max()
if vmax > 0:
variance *= (1 / vmax)
return Diffeomorphism2D(d, variance)
def init_structures(self, shape):
self.shape = shape
self.nsensels = shape[0] * shape[1]
self.ydd = np.zeros(shape, dtype='float32')
# for each sensel, create an area
self.lengths = np.ceil(self.max_displ *
np.array(self.shape)).astype('int32')
# print(' Field Shape: %s' % str(self.shape))
# print(' Fraction: %s' % str(self.max_displ))
# print(' Search area: %s' % str(self.lengths))
self.neighbor_coords = [None] * self.nsensels
self.neighbor_indices = [None] * self.nsensels
self.neighbor_indices_flat = [None] * self.nsensels
self.neighbor_similarity_flat = [None] * self.nsensels
self.neighbor_similarity_best = np.zeros(self.nsensels,
dtype='float32')
self.neighbor_argsort_flat = [None] * self.nsensels
self.neighbor_num_bestmatch_flat = [None] * self.nsensels
self.flattening = Flattening.by_rows(shape)
logger.info('Creating structure shape %s lengths %s' %
(self.shape, self.lengths))
cmg = cmap(self.lengths)
for coord in coords_iterate(self.shape):
k = self.flattening.cell2index[coord]
cm = cmg.copy()
cm[:, :, 0] += coord[0]
cm[:, :, 1] += coord[1]
cm[:, :, 0] = cm[:, :, 0] % self.shape[0]
cm[:, :, 1] = cm[:, :, 1] % self.shape[1]
self.neighbor_coords[k] = cm
indices = np.zeros(self.lengths, 'int32')
for a, b in coords_iterate(indices.shape):
c = tuple(cm[a, b, :])
indices[a, b] = self.flattening.cell2index[c]
self.neighbor_indices[k] = indices
self.neighbor_indices_flat[k] = np.array(indices.flat)
self.neighbor_similarity_flat[k] = np.zeros(
indices.size, 'float32')
self.neighbor_argsort_flat[k] = np.zeros(indices.size, 'float32')
self.neighbor_num_bestmatch_flat[k] = np.zeros(
indices.size, 'uint')
def init_structures(self, shape):
self.shape = shape
self.nsensels = shape[0] * shape[1]
self.ydd = np.zeros(shape, dtype='float32')
# for each sensel, create an area
self.lengths = np.ceil(self.max_displ *
np.array(self.shape)).astype('int32')
# print(' Field Shape: %s' % str(self.shape))
# print(' Fraction: %s' % str(self.max_displ))
# print(' Search area: %s' % str(self.lengths))
self.neighbor_coords = [None] * self.nsensels
self.neighbor_indices = [None] * self.nsensels
self.neighbor_indices_flat = [None] * self.nsensels
self.neighbor_similarity_flat = [None] * self.nsensels
self.neighbor_similarity_best = np.zeros(self.nsensels, dtype='float32')
self.neighbor_argsort_flat = [None] * self.nsensels
self.neighbor_num_bestmatch_flat = [None] * self.nsensels
self.flattening = Flattening.by_rows(shape)
logger.info('Creating structure shape %s lengths %s' %
(self.shape, self.lengths))
cmg = cmap(self.lengths)
for coord in coords_iterate(self.shape):
k = self.flattening.cell2index[coord]
cm = cmg.copy()
cm[:, :, 0] += coord[0]
cm[:, :, 1] += coord[1]
cm[:, :, 0] = cm[:, :, 0] % self.shape[0]
cm[:, :, 1] = cm[:, :, 1] % self.shape[1]
self.neighbor_coords[k] = cm
indices = np.zeros(self.lengths, 'int32')
for a, b in coords_iterate(indices.shape):
c = tuple(cm[a, b, :])
indices[a, b] = self.flattening.cell2index[c]
self.neighbor_indices[k] = indices
self.neighbor_indices_flat[k] = np.array(indices.flat)
self.neighbor_similarity_flat[k] = np.zeros(indices.size, 'float32')
self.neighbor_argsort_flat[k] = np.zeros(indices.size, 'float32')
self.neighbor_num_bestmatch_flat[k] = np.zeros(indices.size, 'uint')
def summarize_continuous(self, quivername):
center = np.zeros(list(self.shape) + [2], dtype='float32')
spread = np.zeros(self.shape, dtype='float32')
maxerror = np.zeros(self.shape, dtype='float32')
minerror = np.zeros(self.shape, dtype='float32')
# from PIL import Image # @UnresolvedImport
# sim_image = Image.new('L', np.flipud(self.shape) * np.flipud(self.lengths))
# zer_image = Image.new('L', np.flipud(self.shape) * np.flipud(self.lengths))
for c in coords_iterate(self.shape):
# find index in flat array
k = self.flattening.cell2index[c]
# Look at the average similarities of the neihgbors
sim = self.neighbor_similarity_flat[k]
sim_square = sim.reshape(
self.lengths).astype('float32') / self.num_samples
from diffeo2d_learn.library.simple.display import sim_square_modify
sim_square, minerror[c], maxerror[c] = sim_square_modify(
sim_square,
np.min(self.neighbor_similarity_flat) / self.num_samples,
np.max(self.neighbor_similarity_flat) / self.num_samples)
# avg_square = (np.max(sim_square) + np.min(sim_square)) / 2
sim_zeroed = np.zeros(sim_square.shape)
sim_zeroed[sim_square > 0.85] = sim_square[sim_square > 0.85]
from diffeo2d_learn.library.simple.display import get_cm
center[c], spread[c] = get_cm(sim_square)
# p0 = tuple(np.flipud(np.array(c) * self.lengths))
# sim_image.paste(Image.fromarray((sim_square * 255).astype('uint8')), p0 + tuple(p0 + self.lengths))
# zer_image.paste(Image.fromarray((sim_zeroed * 255).astype('uint8')), p0 + tuple(p0 + self.lengths))
# sim_image.save(quivername + 'simimage.png')
# zer_image.save(quivername + 'simzeroed.png')
from diffeo2d_learn.library.simple.display import display_disp_quiver
display_disp_quiver(center, quivername)
from diffeo2d_learn.library.simple.display import display_continuous_stats
display_continuous_stats(center, spread, minerror, maxerror,
quivername)
dcont = displacement_to_coord(center)
diff = dcont.astype('int')
diff = get_valid_diffeomorphism(diff)
diffeo2d = Diffeomorphism2D(diff)
return diffeo2d
def summarize_continuous(self, quivername):
center = np.zeros(list(self.shape) + [2], dtype='float32')
spread = np.zeros(self.shape, dtype='float32')
maxerror = np.zeros(self.shape, dtype='float32')
minerror = np.zeros(self.shape, dtype='float32')
# from PIL import Image # @UnresolvedImport
# sim_image = Image.new('L', np.flipud(self.shape) * np.flipud(self.lengths))
# zer_image = Image.new('L', np.flipud(self.shape) * np.flipud(self.lengths))
for c in coords_iterate(self.shape):
# find index in flat array
k = self.flattening.cell2index[c]
# Look at the average similarities of the neihgbors
sim = self.neighbor_similarity_flat[k]
sim_square = sim.reshape(self.lengths).astype('float32') / self.num_samples
from diffeo2d_learn.library.simple.display import sim_square_modify
sim_square, minerror[c], maxerror[c] = sim_square_modify(sim_square, np.min(self.neighbor_similarity_flat) / self.num_samples, np.max(self.neighbor_similarity_flat) / self.num_samples)
# avg_square = (np.max(sim_square) + np.min(sim_square)) / 2
sim_zeroed = np.zeros(sim_square.shape)
sim_zeroed[sim_square > 0.85] = sim_square[sim_square > 0.85]
from diffeo2d_learn.library.simple.display import get_cm
center[c], spread[c] = get_cm(sim_square)
# p0 = tuple(np.flipud(np.array(c) * self.lengths))
# sim_image.paste(Image.fromarray((sim_square * 255).astype('uint8')), p0 + tuple(p0 + self.lengths))
# zer_image.paste(Image.fromarray((sim_zeroed * 255).astype('uint8')), p0 + tuple(p0 + self.lengths))
# sim_image.save(quivername + 'simimage.png')
# zer_image.save(quivername + 'simzeroed.png')
from diffeo2d_learn.library.simple.display import display_disp_quiver
display_disp_quiver(center, quivername)
from diffeo2d_learn.library.simple.display import display_continuous_stats
display_continuous_stats(center, spread, minerror, maxerror, quivername)
dcont = displacement_to_coord(center)
diff = dcont.astype('int')
diff = get_valid_diffeomorphism(diff)
diffeo2d = Diffeomorphism2D(diff)
return diffeo2d
def get_value(self):
'''
Find maximum likelihood estimate for diffeomorphism looking
at each pixel singularly.
Returns a Diffeomorphism2D.
'''
if not self.initialized():
msg = 'No data seen yet'
raise Diffeo2dEstimatorInterface.NotReady(msg)
maximum_likelihood_index = np.zeros(self.shape, dtype='int32')
variance = np.zeros(self.shape, dtype='float32')
E2 = np.zeros(self.shape, dtype='float32')
E3 = np.zeros(self.shape, dtype='float32')
E4 = np.zeros(self.shape, dtype='float32')
num_problems = 0
i = 0
# for each coordinate
for c in coords_iterate(self.shape):
# find index in flat array
k = self.flattening.cell2index[c]
# Look at the average similarities of the neihgbors
sim = self.neighbor_similarity_flat[k]
sim_min = sim.min()
sim_max = sim.max()
if sim_max == sim_min:
# if all the neighbors have the same similarity
best_index = 0
variance[c] = 0 # minimum information
maximum_likelihood_index[c] = best_index
else:
best = np.argmin(sim)
best_index = self.neighbor_indices_flat[k][best]
# uncertainty ~= similarity of the best pixel
variance[c] = sim[best]
maximum_likelihood_index[c] = best_index
E2[c] = self.neighbor_similarity_best[k] / self.num_samples
# Best match error
E3[c] = np.min(
self.neighbor_num_bestmatch_flat[k]) / self.num_samples
E4[c] = np.min(self.neighbor_argsort_flat[k]) / self.num_samples
i += 1
d = self.flattening.flat2coords(maximum_likelihood_index)
if num_problems > 0:
logger.info('Warning, %d were not informative.' % num_problems)
pass
# normalization for this variance measure
vmin = variance.min()
variance = variance - vmin
vmax = variance.max()
if vmax > 0:
variance *= (1 / vmax)
# return maximum likelihood plus uncertainty measure
return Diffeomorphism2D(d, variance) # , E2, E3, E4)
def get_value(self):
'''
Find maximum likelihood estimate for diffeomorphism looking
at each pixel singularly.
Returns a Diffeomorphism2D.
'''
if not self.initialized():
msg = 'No data seen yet'
raise Diffeo2dEstimatorInterface.NotReady(msg)
maximum_likelihood_index = np.zeros(self.shape, dtype='int32')
variance = np.zeros(self.shape, dtype='float32')
E2 = np.zeros(self.shape, dtype='float32')
E3 = np.zeros(self.shape, dtype='float32')
E4 = np.zeros(self.shape, dtype='float32')
num_problems = 0
i = 0
# for each coordinate
for c in coords_iterate(self.shape):
# find index in flat array
k = self.flattening.cell2index[c]
# Look at the average similarities of the neihgbors
sim = self.neighbor_similarity_flat[k]
sim_min = sim.min()
sim_max = sim.max()
if sim_max == sim_min:
# if all the neighbors have the same similarity
best_index = 0
variance[c] = 0 # minimum information
maximum_likelihood_index[c] = best_index
else:
best = np.argmin(sim)
best_index = self.neighbor_indices_flat[k][best]
# uncertainty ~= similarity of the best pixel
variance[c] = sim[best]
maximum_likelihood_index[c] = best_index
E2[c] = self.neighbor_similarity_best[k] / self.num_samples
# Best match error
E3[c] = np.min(self.neighbor_num_bestmatch_flat[k]) / self.num_samples
E4[c] = np.min(self.neighbor_argsort_flat[k]) / self.num_samples
i += 1
d = self.flattening.flat2coords(maximum_likelihood_index)
if num_problems > 0:
logger.info('Warning, %d were not informative.' % num_problems)
pass
# normalization for this variance measure
vmin = variance.min()
variance = variance - vmin
vmax = variance.max()
if vmax > 0:
variance *= (1 / vmax)
# return maximum likelihood plus uncertainty measure
return Diffeomorphism2D(d, variance) # , E2, E3, E4)
