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()