def set_Kk2_uniform_activity(self, clip=True, **kwargs):
"""
Fixed activity distributions for adapted individual odorant response,
where each activity is chosen from a single uniform distribution.
"""
matrix_shape = [self.Mm, self.Nn]
params_Kk1 = [self.mu_Kk1, self.sigma_Kk1]
self.Kk1 = random_matrix(matrix_shape, params_Kk1, seed=self.seed_Kk1)
params_Kk2 = [self.uniform_activity_lo, self.uniform_activity_hi]
self.Kk2 = Kk2_eval_uniform_activity(matrix_shape, params_Kk2,
self.mu_Ss0, self.mu_eps,
self.seed_Kk2)
if clip == True:
array_dict = clip_array(dict(Kk1=self.Kk1, Kk2=self.Kk2))
self.Kk1 = array_dict['Kk1']
self.Kk2 = array_dict['Kk2']
def set_mixture_Kk(self, clip=True):
"""
Set K1 and K2 matrices where each receptor response is chosen from
a Gaussian mixture with stats mu_Kk1_1, sigma_Kk2_1,
mu_Kk1_2, sigma_Kk2_2.
"""
assert 0 <= self.Kk1_p <= 1., "Kk1 Mixture ratio must be between 0 and 1"
assert 0 <= self.Kk2_p <= 1., "Kk2 Mixture ratio must be between 0 and 1"
self.Kk1 = sp.zeros((self.Mm, self.Nn))
self.Kk2 = sp.zeros((self.Mm, self.Nn))
num_comp1 = int(self.Kk1_p * self.Mm)
num_comp2 = self.Mm - num_comp1
params_Kk1_1 = [self.mu_Kk1_1, self.sigma_Kk1_1]
params_Kk1_2 = [self.mu_Kk1_2, self.sigma_Kk1_2]
self.Kk1[:num_comp1, :] = random_matrix([num_comp1, self.Nn],
params_Kk1_1,
seed=self.seed_Kk1)
self.Kk1[num_comp1:, :] = random_matrix([num_comp2, self.Nn],
params_Kk1_2,
seed=self.seed_Kk1)
num_comp1 = int(self.Kk2_p * self.Mm)
num_comp2 = self.Mm - num_comp1
params_Kk2_1 = [self.mu_Kk2_1, self.sigma_Kk2_1]
params_Kk2_2 = [self.mu_Kk2_2, self.sigma_Kk2_2]
self.Kk2[:num_comp1, :] = random_matrix([num_comp1, self.Nn],
params_Kk2_1,
seed=self.seed_Kk2)
self.Kk2[num_comp1:, :] = random_matrix([num_comp2, self.Nn],
params_Kk2_2,
seed=self.seed_Kk2)
if clip == True:
array_dict = clip_array(dict(Kk1=self.Kk1, Kk2=self.Kk2))
self.Kk1 = array_dict['Kk1']
self.Kk2 = array_dict['Kk2']
def set_Kk2_normal_activity(self, clip=True, **kwargs):
"""
Fixed activity distributions for adapted individual odorant response,
where each activity is chosen from a normal distribution depending on
the receptor. The means for each receptor are chosen normally and the
sigmas are chosen uniformly. Kk2 is then derived from these choices,
while Kk1 is chosen from a single Gaussian distribution. The function
allows for overriding of mu_eps and mu_Ss0 if system has adapted to
another background state.
"""
matrix_shape = [self.Mm, self.Nn]
params_Kk1 = [self.mu_Kk1, self.sigma_Kk1]
self.Kk1 = random_matrix(matrix_shape, params_Kk1, seed=self.seed_Kk1)
mu_Ss0 = self.mu_Ss0
mu_eps = self.mu_eps
for key in kwargs:
exec ('%s = kwargs[key]' % key)
mu_stats = [self.receptor_tuning_mu_hyper_mu,
self.receptor_tuning_mu_hyper_sigma]
sigma_stats = [self.receptor_tuning_sigma_hyper_lo,
self.receptor_tuning_sigma_hyper_hi]
activity_mus = random_matrix([self.Mm], params=mu_stats,
sample_type='normal',
seed=self.seed_receptor_activity)
activity_sigmas = random_matrix([self.Mm], params=sigma_stats,
sample_type='uniform',
seed=self.seed_receptor_activity)
self.Kk2 = Kk2_eval_normal_activity(matrix_shape, activity_mus,
activity_sigmas, mu_Ss0, mu_eps,
self.seed_Kk2)
if clip == True:
array_dict = clip_array(dict(Kk1 = self.Kk1, Kk2 = self.Kk2))
self.Kk1 = array_dict['Kk1']
self.Kk2 = array_dict['Kk2']
def set_uniform_Kk(self, clip=True):
"""
Set K1 and K2 where each receptor from a distinct uniform with
uniform prior on the uniform bounds (lo_Kk1_hyper_lo, lo_Kk1_hyper_hi,
hi_Kk1_hyper_lo, hi_Kk1_hyper_hi, etc.)
"""
Kk1_los = random_matrix(
[self.Mm],
params=[self.lo_Kk1_hyper_lo, self.lo_Kk1_hyper_hi],
sample_type='uniform',
seed=self.seed_Kk1)
Kk1_his = random_matrix(
[self.Mm],
params=[self.hi_Kk1_hyper_lo, self.hi_Kk1_hyper_hi],
sample_type='uniform',
seed=self.seed_Kk1)
Kk2_los = random_matrix(
[self.Mm],
params=[self.lo_Kk2_hyper_lo, self.lo_Kk2_hyper_hi],
sample_type='uniform',
seed=self.seed_Kk2)
Kk2_his = random_matrix(
[self.Mm],
params=[self.hi_Kk2_hyper_lo, self.hi_Kk2_hyper_hi],
sample_type='uniform',
seed=self.seed_Kk2)
self.Kk1 = random_matrix([self.Mm, self.Nn], [Kk1_los, Kk1_his],
sample_type='rank2_row_uniform',
seed=self.seed_Kk1)
self.Kk2 = random_matrix([self.Mm, self.Nn], [Kk2_los, Kk2_his],
sample_type='rank2_row_uniform',
seed=self.seed_Kk2)
if clip == True:
array_dict = clip_array(dict(Kk1=self.Kk1, Kk2=self.Kk2))
self.Kk1 = array_dict['Kk1']
self.Kk2 = array_dict['Kk2']
def set_normal_Kk(self, clip=True):
"""
Set K1 and K2 where each receptor from a distinct Gaussian with
uniform prior on means and sigmas (mu_Kk1_hyper_lo, mu_Kk1_hyper_hi,
sigma_Kk1_hyper_lo, sigma_Kk1_hyper_hi, etc.)
"""
Kk1_mus = random_matrix(
[self.Mm],
params=[self.mu_Kk1_hyper_lo, self.mu_Kk1_hyper_hi],
sample_type='uniform',
seed=self.seed_Kk1)
Kk1_sigmas = random_matrix(
[self.Mm],
params=[self.sigma_Kk1_hyper_lo, self.sigma_Kk1_hyper_hi],
sample_type='uniform',
seed=self.seed_Kk1)
Kk2_mus = random_matrix(
[self.Mm],
params=[self.mu_Kk2_hyper_lo, self.mu_Kk2_hyper_hi],
sample_type='uniform',
seed=self.seed_Kk2)
Kk2_sigmas = random_matrix(
[self.Mm],
params=[self.sigma_Kk2_hyper_lo, self.sigma_Kk2_hyper_hi],
sample_type='uniform',
seed=self.seed_Kk2)
self.Kk1 = random_matrix([self.Mm, self.Nn], [Kk1_mus, Kk1_sigmas],
sample_type='rank2_row_gaussian',
seed=self.seed_Kk1)
self.Kk2 = random_matrix([self.Mm, self.Nn], [Kk2_mus, Kk2_sigmas],
sample_type='rank2_row_gaussian',
seed=self.seed_Kk2)
if clip == True:
array_dict = clip_array(dict(Kk1=self.Kk1, Kk2=self.Kk2))
self.Kk1 = array_dict['Kk1']
self.Kk2 = array_dict['Kk2']
def set_uniform_ordered_Kk(self, clip=True): """ Set K1 and K2 where each receptor from same Gaussian, and the tuning curves are ordered such that row one is centered at N1, etc. """ self.Kk1 = random_matrix([self.Mm, self.Nn], [self.uniform_Kk1_lo, self.uniform_Kk1_hi], sample_type='uniform', seed = self.seed_Kk1) self.Kk2 = random_matrix([self.Mm, self.Nn], [self.uniform_Kk2_lo, self.uniform_Kk2_hi], sample_type='uniform', seed = self.seed_Kk2) if clip == True: array_dict = clip_array(dict(Kk1 = self.Kk1, Kk2 = self.Kk2)) self.Kk1 = array_dict['Kk1'] self.Kk2 = array_dict['Kk2'] for iM in range(self.Mm): self.Kk2[iM, :] = sp.sort(self.Kk2[iM, :]) tmp = sp.hstack((self.Kk2[iM, :], self.Kk2[iM, ::-1])) self.Kk2[iM, :] = tmp[::2] self.Kk2[iM, :] = sp.roll(self.Kk2[iM, :], iM*int(self.Nn/self.Mm))
def img_to_new_aperture(target, img, image_region=15):
"""
modifies new aperture into target information to calculate new light curves
:target: target instance
:img: new aperture
:image_region: distance from center pixel to capture for aperture
"""
target.img = img
ii, jj = target.center
ii, jj = int(ii), int(jj)
len_y = img.shape[0]
len_x = img.shape[1]
for i in range(len_y):
for j in range(len_x):
if img[i, j] == 0:
big_i, big_j = clip_array([i+ii-image_region, j+jj-image_region], \
[target.targets.shape[0]-1, target.targets.shape[1]-1], \
[True, True])
target.targets[big_i, big_j] = 0
logger.info("done")
return img
def set_Kk2_normal_activity_mixture(self, clip=True, **kwargs):
"""
Fixed activity distributions for adapted individual odorant response,
where each activity is chosen from a Gaussian mixture.
"""
matrix_shape = [self.Mm, self.Nn]
params_Kk1 = [self.mu_Kk1, self.sigma_Kk1]
self.Kk1 = random_matrix(matrix_shape, params_Kk1, seed=self.seed_Kk1)
mu_Ss0 = self.mu_Ss0
mu_eps = self.mu_eps
for key in kwargs:
exec('%s = kwargs[key]' % key)
assert 0 <= self.activity_p <= 1., "Mixture ratio must be between 0 and 1"
activity_mus = sp.zeros(self.Mm)
activity_sigmas = sp.zeros(self.Mm)
num_comp1 = int(self.activity_p * self.Mm)
num_comp2 = self.Mm - num_comp1
activity_mus[:num_comp1] = self.receptor_tuning_mixture_mu_1
activity_mus[num_comp1:] = self.receptor_tuning_mixture_mu_2
activity_sigmas[:num_comp1] = self.receptor_tuning_mixture_sigma_1
activity_sigmas[num_comp1:] = self.receptor_tuning_mixture_sigma_2
self.Kk2 = Kk2_eval_normal_activity(matrix_shape, activity_mus,
activity_sigmas, mu_Ss0, mu_eps,
self.seed_Kk2)
if clip == True:
array_dict = clip_array(dict(Kk1=self.Kk1, Kk2=self.Kk2))
self.Kk1 = array_dict['Kk1']
self.Kk2 = array_dict['Kk2']
def plot_background_modelling(targ, fout="./", image_region=15, model_pix=15, mask_factor=0.001, \
max_factor=0.2, min_img=-1000, max_img=1000, save_pdf=True):
"""
plots information about different light curves before/after (1) improved aperture,
(2) background modelling
:targ: kic to plot
:fout: output folder
:image_region: region to plot around center of star
:model_pix: background modelling region
:mask_factor: % top bright pixels to collect from PSF to create basic PSF mask for aperture
:max_factor: % top bright stars to create mask for background modelling
:min_img: vmin for all plots, None if no minimum
:max_img: vmax for all plots, None if no maximum
:save_pdf: saves all plots to pdf, will always save before/after light curves
:return: target after photometry
"""
target = run_photometry(targ, plot_flag=True)
if target == 1:
return target
# make temp variables
save_post = np.empty_like(target.postcard)
save_post[:] = target.postcard
save_int = np.empty_like(target.integrated_postcard)
save_int[:] = target.integrated_postcard
coords = clip_array([target.center[0]-model_pix, target.center[0]+model_pix, \
target.center[1]-model_pix, target.center[1]+model_pix], \
[0, target.postcard.shape[1]-1, 0, target.postcard.shape[2]-1], \
[False, True, False, True])
min_i, max_i, min_j, max_j = coords
# plot
fig1 = plt.figure(1, figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.imshow(save_int, interpolation='nearest', cmap='gray', \
vmin=min_img, vmax=max_img, origin='lower')
plot_box(min_j, max_j, min_i, max_i, 'r-', linewidth=1)
with PdfPages(fout + targ + "_out.pdf") as pdf:
# original plot
fig0 = plot_data(target)
plt.gcf().text(4/8.5, 1/11., str(np.nanmean(target.flux_uncert)), \
ha='center', fontsize = 11)
pdf.savefig()
plt.close(fig0)
# improved aperture plot
calculate_better_aperture(target,
mask_factor=mask_factor,
image_region=image_region)
fig0 = plot_data(target)
plt.gcf().text(4/8.5, 1/11., str(np.nanmean(target.flux_uncert)), \
ha='center', fontsize = 11)
pdf.savefig()
plt.close(fig0)
# background modelling
for i in range(target.postcard.shape[0]):
# make model
region = target.postcard[i]
img = region[min_i:max_i, min_j:max_j]
mask = make_background_mask(target, img, coords, max_factor,
model_pix)
z = np.ma.masked_array(img, mask=mask)
img -= np.ma.median(z)
# plots first background modelling
if i == 0:
n = 3
fig2 = plt.figure(2, figsize=(10, 4))
plt.subplot(1, n, 1)
plt.imshow(mask, cmap='gray', vmin=0, vmax=1, origin='lower')
plt.title("Mask")
plt.subplot(1, n, 2)
plt.imshow(z, interpolation='nearest', cmap='gray', \
vmin=-200, vmax=1000, origin='lower')
plt.title("Data")
plt.subplot(1, n, 3)
plt.imshow(img, interpolation='nearest', cmap='gray', \
vmin=-200, vmax=1000, origin='lower')
plt.title("Residual")
plt.colorbar()
if save_pdf:
pdf.savefig()
plt.close(fig2)
# finalise new postcard
target.integrated_postcard = np.sum(target.postcard, axis=0)
target.data_for_target(do_roll=True, ignore_bright=0)
# plot rest of stuff
plt.figure(1)
plt.subplot(1, 2, 2)
plt.imshow(target.integrated_postcard, interpolation='nearest', cmap='gray', \
vmin=min_img, vmax=max_img, origin='lower')
plot_box(min_j, max_j, min_i, max_i, 'r-', linewidth=1)
plt.colorbar()
if save_pdf:
pdf.savefig()
plt.close(fig1)
else:
plt.show()
plt.close("all")
fig0 = plot_data(target)
plt.gcf().text(4/8.5, 1/11., str(np.nanmean(target.flux_uncert)), \
ha='center', fontsize = 11)
pdf.savefig()
plt.close("all")
logger.info("done")
return target
def update(self, _):
#draw game
if self.was_game_changed == False:
return 0
glEnable(GL_BLEND)
field = self.game.field_map
self.window.clear()
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
#draw terrain
player_x = self.game.actor_ctr.player.x
player_y = self.game.actor_ctr.player.y
clipped_image_id = clip_array(field.image, player_x, player_y,
self.GUI_width // 32,
self.GUI_map_height // 32)
for y, _ in enumerate(clipped_image_id):
for x, image_id in enumerate(_):
if image_id != -1:
self.TERRAIN_IMAGES[image_id].blit(
x * 32, self.GUI_height - (y + 1) * 32)
#draw door
clipped_door = clip_array(field.door,
player_x,
player_y,
self.GUI_width // 32,
self.GUI_map_height // 32,
pad_value=None)
for y, _ in enumerate(clipped_door):
for x, door in enumerate(_):
if door != None:
#replace 18 to door image id
self.TERRAIN_IMAGES[18].blit(
x * 32, self.GUI_height - (y + 1) * 32)
#draw actor
actors = self.game.actor_ctr.actors.values()
def relative_x(x):
return (self.GUI_width // (32 * 2) - player_x + x) * 32
def relative_y(y):
return self.GUI_height - (self.GUI_map_height //
(32 * 2) - player_y + y + 1) * 32
for actor in actors:
self.CHAR_IMAGES[actor.image].blit(relative_x(actor.x),
relative_y(actor.y))
self.BACK_IMAGE.blit(0, 0)
pad_num = max(0, 6 - len(self.game.log_message))
drawing_msg = "\n" * pad_num + "\n".join(self.game.log_message[-6:])
document = pyglet.text.decode_text(drawing_msg)
document.set_style(0, 0, {
"color": (0, 0, 0, 255),
"line_spacing": 24,
"wrap": "char"
})
layout = pyglet.text.layout.TextLayout(document,
self.GUI_width,
self.GUI_height -
self.GUI_map_height,
multiline=True)
layout.draw()
