def get_colors(self, qty): qty = np.power(qty / qty.max(), 1.0 / CONTRAST) if COLORMAP == 0: rgba = cm.gray(qty, alpha=ALPHA) elif COLORMAP == 1: rgba = cm.afmhot(qty, alpha=ALPHA) elif COLORMAP == 2: rgba = cm.hot(qty, alpha=ALPHA) elif COLORMAP == 3: rgba = cm.gist_heat(qty, alpha=ALPHA) elif COLORMAP == 4: rgba = cm.copper(qty, alpha=ALPHA) elif COLORMAP == 5: rgba = cm.gnuplot2(qty, alpha=ALPHA) elif COLORMAP == 6: rgba = cm.gnuplot(qty, alpha=ALPHA) elif COLORMAP == 7: rgba = cm.gist_stern(qty, alpha=ALPHA) elif COLORMAP == 8: rgba = cm.gist_earth(qty, alpha=ALPHA) elif COLORMAP == 9: rgba = cm.spectral(qty, alpha=ALPHA) return rgba
def comp_sweep_kin(self, rng): '''compare kinetics from different sweeps within rng of WL rng = [wl1 min, wl1 max, wl2 min, wl2 max, ... wlx min, wlx max] author DP, last change 28/04/20''' idx = sup.get_idx(*rng, axis=self.wl) _, ax1 = plt.subplots() for j in range(self.n_sweeps): cmap = cm.gist_heat((j) / self.n_sweeps, 1) for i in range(int(len(rng) / 2)): kin = np.mean(self.sweeps[j][:, idx[2 * i]:idx[2 * i + 1]], axis=1) if self.inc_sweeps[j]: ax1.plot(self._t, kin, label=j, color=cmap) else: ax1.plot(self._t, kin, '--', linewidth=1, label=f'{j} not in av', color=cmap) # TODO works only for single rng. kin_av = np.mean(self.data[:, idx[2 * i]:idx[2 * i + 1]], axis=1) plt.plot(self._t, kin_av, linewidth=3, label='av kin') plt.xscale('Log') plt.legend() plt.show()
def animate_watershed(event, screen, state, settings): if event.type == pygame.MOUSEBUTTONDOWN: source = (pygame.mouse.get_pos(), ) elif event.type == pygame.KEYDOWN and event.key == pygame.K_RETURN: source = None else: return screen.fill((0, 0, 0)) state.node_flows, _ = calculate_watershed(state, source=source) state.node_flow_items = list(state.node_flows.items()) numpy_image = numpy.zeros( (settings.screen_size[1], settings.screen_size[0], 3), dtype=numpy.uint8) print(f"Num pixels to process {len(state.node_flow_items)}") for i in tqdm(range(len(state.node_flow_items)), desc="processing pixels"): node, flow = state.node_flow_items[i] colour = [int(i * 255) for i in cm.gist_heat(flow)[:3]] # print(node) # print(flow) # print(colour) for point in node: numpy_image[point[1], point[0]] = colour if i % 20 == 0: # print("Updating screen") write_colour_to_screen(screen, numpy_image) yield write_colour_to_screen(screen, numpy_image) yield
def plot_distribution (self): ccc = cm.gist_heat(np.linspace(0., 0.8, self.N_max)) for i in np.arange(self.N_max): if (self.data[i,0] > 0): plt.plot (self.beta*1e6, self.data[i, 1:], label = str(self.data[i,0]), color = ccc[i]) plt.legend() plt.show()
def plot_distribution(self): ccc = cm.gist_heat(np.linspace(0., 0.8, self.N_max)) for i in np.arange(self.N_max): if (self.data[i, 0] > 0): plt.plot(self.beta * 1e6, self.data[i, 1:], label=str(self.data[i, 0]), color=ccc[i]) plt.legend() plt.show()
def plot_feature_importance(Feature_importance, n): ''' plot top n features ''' plt.rcParams['figure.figsize'] = (12, 5) Feature_importance = pd.DataFrame(rf.feature_importances_, X_train.columns) Feature_importance.columns = ['features'] Feature_importance = Feature_importance.sort_values(by='features', axis=0, ascending=False) colors = cm.gist_heat(np.linspace(0, 1, len(tagged_df.columns))) Feature_importance.head(n).plot(title="Counts of Tags", color=colors, kind='bar') plt.show()
def barplot(labels,data,username): pos=arange(len(data)) c=[]; for i in data: c.append(cm.gist_heat(i/100,20)); pyplot.ylim(0,100); pyplot.xticks(pos+0.4,labels,color="black") pyplot.bar(pos,data,color=c); pyplot.xlabel("Class",fontsize="14",color="black"); pyplot.ylabel("Percentage",fontsize="14",color="black"); pyplot.title("Performance",fontsize="16",color="black"); imn="../student/graphs/"+username+".png"; pyplot.savefig(imn) pyplot.close()
def animate_flow(event, screen, state: VisState, settings: VisSettings) -> Generator: if event.type == pygame.MOUSEBUTTONDOWN: source = find_clicked_node(pygame.mouse.get_pos(), state) elif event.type == pygame.KEYDOWN and event.key == pygame.K_RETURN: source = None else: return circle_radius = int(max(*state.float_pixel_size) * 0.35) screen.blit(state.pygame_img, (0, 0)) yield for flows in calculate_flow(state, 200, source=source): # Draw edges between nodes edges_surface = pygame.Surface(settings.screen_size, pygame.SRCALPHA, 32).convert_alpha() for node in flows: new_location = get_node_centerpoint(node) for neighbour in state.graph[node]: if neighbour > node and neighbour in flows: neighbour_location = get_node_centerpoint(neighbour) _draw_line(edges_surface, new_location, neighbour_location, state) circles_surface = pygame.Surface(settings.screen_size, pygame.SRCALPHA, 32).convert_alpha() circle_drawn = False for node, flow in flows.items(): if flow != 0: new_location = get_node_centerpoint(node) circle_center = [ int(new_location[i] * state.float_pixel_size[i] + state.center_offset[i]) for i in (0, 1) ] colour = [i * 255 for i in cm.gist_heat(flow)[:3]] pygame.draw.circle(circles_surface, colour, circle_center, circle_radius) circle_drawn = True screen.blit(state.pygame_img, (0, 0)) screen.blit(edges_surface, (0, 0)) screen.blit(circles_surface, (0, 0)) yield if not circle_drawn: break
def old_real_space_analysis(self, log_plot=False, corrected=False, n_points=10000): self.reps = 30 if (self.N_values == None): self.N_values = np.arange(self.N - 1) + 2 ccc = cm.gist_heat(np.linspace(0., 0.8, len(self.N_values))) ind = 0 for N in self.N_values: print 'Evaluating N = ', N, ' msmnts' p0 = ProbabilityDistribution(B_max=B_max, n_points=n_points) for j in np.arange(self.reps): r = AdaptiveRamsey(N_msmnts=N, B_max=B_max) r.msmnt_results = self.data[j, :N] r.msmnt_phases = np.zeros(N) r.msmnt_times = self.ramsey_times[:N] p = r.analysis() p0.add(prob=p.data()) p0.normalize() self.mean.append(p0.mean()) self.variance.append((p0.variance() / B_max)) plt.plot(p0.beta * 1e-6, p0.data() / max(p0.data()), linewidth=1, label=str(N), color=ccc[ind]) ind = ind + 1 plt.xlabel('Magnetic field [MHz]') #plt.xlim([-3, 5]) plt.legend() plt.show() total_time = 1e-9 * (2**(self.N_values + 1) - 1) plt.plot(self.N_values, self.mean, 'ob') plt.show() plt.loglog(total_time * 1e6, self.variance * total_time, 'ob') plt.xlabel('Total msmnt time [us]') plt.show()
def animate_watershed(event, screen, state: VisState, settings: VisSettings) -> Generator: if event.type == pygame.MOUSEBUTTONDOWN: source = find_clicked_node(pygame.mouse.get_pos(), state) elif event.type == pygame.KEYDOWN and event.key == pygame.K_RETURN: source = None else: return circle_radius = int(max(*state.float_pixel_size) * 0.35) screen.blit(state.pygame_img, (0, 0)) state.node_flows, state.edge_flows = calculate_watershed(state, source=source) state.node_flow_items = list(state.node_flows.items()) node_flow_indexes = { state.node_flow_items[i][0]: i for i in range(len(state.node_flow_items)) } j = 0 for i in range(len(state.node_flow_items)): node, flow = state.node_flow_items[i] if flow > 0.0001: new_location = get_node_centerpoint(node) for neighbour in state.graph[node]: if neighbour in node_flow_indexes and node_flow_indexes[ neighbour] > i: neighbour_location = get_node_centerpoint(neighbour) _draw_line(screen, new_location, neighbour_location, state) j += 1 circle_center = [ int(new_location[i] * state.float_pixel_size[i] + state.center_offset[i]) for i in (0, 1) ] colour = [i * 255 for i in cm.gist_heat(flow)[:3]] pygame.draw.circle(screen, colour, circle_center, circle_radius) if j % 20 == 0: yield yield
def old_real_space_analysis (self, log_plot=False, corrected = False, n_points=10000): self.reps = 30 if (self.N_values == None): self.N_values = np.arange(self.N-1)+2 ccc = cm.gist_heat(np.linspace(0., 0.8, len(self.N_values))) ind = 0 for N in self.N_values: print 'Evaluating N = ', N, ' msmnts' p0 = ProbabilityDistribution (B_max=B_max, n_points=n_points) for j in np.arange(self.reps): r = AdaptiveRamsey(N_msmnts=N, B_max=B_max) r.msmnt_results = self.data [j,:N] r.msmnt_phases = np.zeros(N) r.msmnt_times = self.ramsey_times [:N] p = r.analysis() p0.add(prob=p.data()) p0.normalize() self.mean.append(p0.mean()) self.variance.append((p0.variance()/B_max)) plt.plot (p0.beta*1e-6, p0.data()/max(p0.data()), linewidth = 1, label = str(N), color = ccc[ind]) ind = ind+1 plt.xlabel ('magnetic field [MHz]') #plt.xlim([-3, 5]) plt.legend() plt.show() total_time = 1e-9*(2**(self.N_values+1)-1) plt.plot (self.N_values, self.mean, 'ob') plt.show() plt.loglog (total_time*1e6, self.variance*total_time, 'ob') plt.xlabel ('total msmnt time [us]') plt.show()
def main(): # Input asp-style ascii profile will be first argument. # (command-line options to come later) prog_name = argv[0].strip('.py') # Scale factor for plotting difference plots scale = 2.0 # arg = get_opt(prog_name) # prof_file = argv[1] # ref_file = argv[1] ref_file = argv[len(argv)-1] input_files = [] for file in argv[1:]: # For some reason this works and ".append()" doesn't: input_files[len(input_files):] = glob.glob(file) # input_files.append(glob.glob(file)) input_files.reverse() # Remove reference file from list if it is in the plotting list if(input_files.count(ref_file) > 0): input_files.remove(ref_file) duty = get_duty('0737-3039A') # Read in reference profile ref_header = read_asc_header(ref_file) ref_data = read_asc_prof(ref_file) # ref_data['i'] = norm(ref_data['i'], duty) # Make first prof in list for plot to be the ref profile prof_data = [ref_data] ref_date = mjd.mjdtodate(ref_header['imjd'], \ dateformat='%Y %b %d') date_text = [(0.5, 0.20, ref_date)] nobs = [] # Now calculate difference profiles and append to plotting list for i_prof in np.arange(len(input_files)): prof_header = read_asc_header(input_files[i_prof]) nobs.append(prof_header['obscode']) print 'NOBS = ', nobs prof_data_temp = read_asc_prof(input_files[i_prof]) # prof_data_temp['i'] = norm(prof_data_temp['i'], duty) diff_prof = remove_base((prof_data_temp['i'] - ref_data['i']), duty) prof_data_temp['i'] = scale*(diff_prof) + i_prof + 1.2 print "Index = ", i_prof prof_data.append(prof_data_temp) # Set up labelling for each profile: prof_date = mjd.mjdtodate(prof_header['imjd'], \ dateformat='%Y %b %d') date_text.append((0.5, i_prof+1.4+scale*0.02, prof_date)) print "Date = ", date_text nobs_unique = list(set(nobs)) clr=[] for i_nobs in range(len(nobs)): if(nobs_unique <= 1): clr.append('black') else: clr.append(cm.gist_heat(float(nobs_unique.index(nobs[i_nobs]))/float(len(nobs_unique)))) # Do this just to make the ordering such that the first alphanumerically # is at the top... # prof_data.reverse() # date_text.reverse() plot_prof(prof_data, yticks=False, canvassize=(8,10), vgrid=False, \ ylim=(np.min(prof_data[0]['i'])-0.1, len(input_files)+1 +0.1), \ figtext=date_text, linecolour=clr) # meaningThe following means that the 2nd argument is the # desired output plot file name # plot_file = 'diff_profile.png' plot_file = 'diff_profile.pdf' plt.savefig(plot_file)
def sw(image, image_array, x=1.6, y=2.4, save_files=True, threshold=0.97): #CONVERTING NUMPY ARRAY TO TENSOR AND PUTTING IT IN MODEL image_tensor = torch.from_numpy(image_array) output_tensor = working_model(image_tensor) print("out", output_tensor.shape) output_squeeze = torch.squeeze( output_tensor, 0).detach().numpy() # all dimensions of size 1 removed print(output_squeeze.shape) heatmap = output_squeeze[0] # the channel or the 2nd one is eliminated print(heatmap, "HEATMAP", heatmap.shape) heatmap_thr = heatmap.copy() # applying threshold or a simpler version of non-max suppression heatmap_thr[heatmap[:, :] > threshold] = 100 heatmap_thr[heatmap[:, :] <= threshold] = 0 boxes = [] #converting PIL image to DrawImage image_copy = image.copy() draw = ImageDraw.Draw(image) draw_copy = ImageDraw.Draw(image_copy) heatmap_img = Image.fromarray(np.uint8(cm.gist_heat(heatmap) * 255)) heatmap_img.show() print("with threshold") heatmap_img_thresh = Image.fromarray( np.uint8(cm.gist_heat(heatmap_thr) * 255)) heatmap_img_thresh.show() # print(heatmap.shape[0]) print("---------") # print(np.arange(heatmap.shape[0])) print("----------") # yy-rows have the same elements, xx- columns have the same elements xx, yy = np.meshgrid(np.arange(heatmap.shape[1]), np.arange(heatmap.shape[0])) # x_det and y_det contain all those indices of heatmap whose value is greater than threshold. x_det = (xx[heatmap[:, :] > threshold]) y_det = (yy[heatmap[:, :] > threshold]) print(y_det) # Scaling of the model shrink_ratio = (image.width / heatmap_img.width, image.height / heatmap_img.height) # Appending the dimensions of the bounding boxes for i, j in zip(x_det, y_det): if not save_files: if i > heatmap_img.width // 1.95 and j > int( heatmap_img.height / 1.95): boxes.append([int(i * 13), int(j * 13), int(48), int(96)]) else: boxes.append([int(i * 13), int(j * 13), int(48), int(96)]) #group interecting rectanlgles bound_boxes = cv2.groupRectangles(boxes, 2, 1) bound_boxes = bound_boxes[:1] print("Number of Objects: ", len(bound_boxes[0])) print(bound_boxes) # draw the box on the image and its copy for box in bound_boxes: for b in box: print(b, "BOX") draw_copy.rectangle( (b[0], b[1], b[2] + b[0], b[1] + b[3]), outline='blue') #draw.draw_rectangle(xy, ink, 0, width) for box in bound_boxes[0]: draw.rectangle( (box[0] - (x - 1) * box[2] // 2, box[1] - (y - 1) * box[2] // 2, box[2] * x + box[0] - (x - 1) * box[2] // 2, box[3] * y + box[1] - (y - 1) * box[2] // 2), outline='green') #saving the images if (save_files): image.save("Actual output.png") image_copy.save("Copy_Output.png") heatmap_img.save("Heatmap.png") heatmap_img_thresh.save("Heatmap_thresh.png") image.show()
def main(): # Input asp-style ascii profile will be first argument. # (command-line options to come later) prog_name = argv[0].strip(".py") # Scale factor for plotting difference plots scale = 2.0 # ref_file = argv[len(argv)-1] ref_file = argv[1] # arg = get_opt(prog_name) print "n_args = ", len(argv) - 1 # prof_file = argv[1] input_files = [] for file in argv[1:]: # For some reason this works and ".appen()" doesn't: input_files[len(input_files) :] = glob.glob(file) # input_files.append(glob.glob(file)) input_files.reverse() if input_files.count(ref_file) > 0: input_files.remove(ref_file) # First, read in profile data file, and assign each column to a separate # numpy array # prof_file = input_files[0] # prof_header = read_asc_header(prof_file) # prof_data[0] = read_asc_prof(prof_file) ref_header = read_asc_header(ref_file) ref_data = read_asc_prof(ref_file) # ref_data['i'] = norm(ref_data['i'], duty) # if(len(input_files) > 1): # for prof_file in input_files: prof_data = [] date_text = [] nobs = [] for i_prof in np.arange(len(input_files)): prof_header = read_asc_header(input_files[i_prof]) duty = get_duty(prof_header["psrname"]) nobs.append(prof_header["obscode"]) print "NOBS = ", nobs prof_data_temp = read_asc_prof(input_files[i_prof]) # prof_data_temp['i'] = norm(prof_data_temp['i'], duty) # prof_data_temp['i'] = prof_data_temp['i'] + i_prof diff_prof = remove_base((prof_data_temp["i"] - ref_data["i"]), duty) prof_data_temp["i"] = scale * (diff_prof) + i_prof + 1.2 print "Index = ", i_prof, ", Min = ", np.min(prof_data_temp["i"]), ", Max = ", np.max(prof_data_temp["i"]) prof_data.append(prof_data_temp) # Set up labelling for each profile: prof_date = mjd.mjdtodate(prof_header["imjd"], dateformat="%Y %b %d") date_text.append((0.8, i_prof + 0.25, prof_date)) print "Date = ", date_text # Make first prof in list for plot to be the ref profile prof_data.append(ref_data) ref_date = mjd.mjdtodate(ref_header["imjd"], dateformat="%Y %b %d") date_text.append((0.5, 0.20, ref_date)) nobs.append(ref_header["obscode"]) nobs_unique = list(set(nobs)) clr = [] for i_nobs in range(len(nobs)): if nobs_unique <= 1: clr.append("black") else: clr.append(cm.gist_heat(float(nobs_unique.index(nobs[i_nobs])) / float(len(nobs_unique)))) # Do this just to make the ordering such that the first alphanumerically # is at the top... # prof_data.reverse() # date_text.reverse() print "LENGTH of PROF DATA = ", len(prof_data) print "LENGTH of colour = ", len(clr) plot_prof( prof_data, yticks=False, canvassize=(8, 10), hgrid=False, vgrid=False, ylim=(np.min(prof_data[0]["i"]) - 0.1, len(input_files) + 0.1 + 1.0), figtext=date_text, linecolour=clr, ) # meaningThe following means that the 2nd argument is the # desired output plot file name # plot_file = 'multi_profile.png' plot_file = "diff_profile.pdf" # plt.show() plt.savefig(plot_file)
def prepare_spec_image(spectrogram): spectrogram = (spectrogram - np.min(spectrogram)) / ((np.max(spectrogram)) - np.min(spectrogram)) spectrogram = np.flip(spectrogram, axis=0) return np.uint8(cm.gist_heat(spectrogram) * 255)
plt.xlabel("Being Types (sorted based on profitable traits)") plt.ylabel("Number of Beings") #plt.savefig("plot_final.png") plt.show() # %% fig = pylab.figure() ax = Axes3D(fig) x = list() y = list() for day in range(10): for species in range(types_of_beings): y.append(day) x.append(species) z = [0 for i in range(10 * types_of_beings)] dx = 1 dy = 1 dz = np.array(barHeights) x = np.array(x) y = np.array(y) ax.set_xlabel("Species Index") ax.set_ylabel("Time") ax.set_zlabel("Population") values = (dz - dz.min()) / np.float_(dz.max() - dz.min()) colors = cm.gist_heat(values) #colors = cm.gnuplot2(values) #colors = cm.rainbow(values) ax.bar3d(x, y, z, dx, dy, dz, shade=True, color=colors) plt.show() # %%
def field_list_to_json(fields, filename=None): """ Given a list of fields, create a FeatureCollection JSON file to use with the interactive survey coverage viewer. The final structure should look like this, where "name" is the field id, and coordinates are a list of the coordinates of the 4 corners of the field. {"type" : "FeatureCollection", "features": [ {"type" : "Feature", "properties" : { "name" : "2471"}, "geometry": { "type" : "Polygon", "coordinates" : [[ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0] ]] }, "id":"2471"}, etc. ] } Parameters ---------- fields : list, iterable Must be a list of PTF Field objects. See: ptf.photometricdatabase.Field filename : str (optional) If filename is specified, will save the JSON to the file. Otherwise, return the JSON """ final_dict = dict(type="FeatureCollection", features=[]) # Minimum and maximum number of observations for all fields min_obs = 1 # There is one crazy outlier: the Orion field 101001, so I remove that for calculating the max... num_exposures = np.array([field.number_of_exposures for field in fields if field.id != 101001]) max_obs = num_exposures.max() # Create a matplotlib lognorm scaler between these values scaler = matplotlib.colors.LogNorm(vmin=min_obs, vmax=max_obs) for field in fields: if field.number_of_exposures < 1: logger.debug("Skipping field {}".format(field)) continue try: field.ra field.dec except AttributeError: this_field = all_fields[all_fields["id"] == field.id] if len(this_field) != 1: logger.warning("Field {} is weird".format(field)) continue field.ra = g.RA.fromDegrees(this_field["ra"][0]) field.dec = g.Dec.fromDegrees(this_field["dec"][0]) if field.dec.degrees < -40: logger.warning("Field {} is weird, dec < -40".format(field)) continue feature = field_to_feature(field) # Determine color of field #rgb = cm.autumn(scaler(field.number_of_exposures)) rgb = cm.gist_heat(scaler(field.number_of_exposures)) feature["properties"]["color"] = mc.rgb2hex(rgb) feature["properties"]["alpha"] = scaler(field.number_of_exposures)*0.75 + 0.05 feature["properties"]["number_of_observations"] = str(field.number_of_exposures) feature["properties"]["ra"] = "{:.5f}".format(field.ra.degrees) feature["properties"]["dec"] = "{:.5f}".format(field.dec.degrees) final_dict["features"].append(feature) blob = json.dumps(final_dict) if filename != None: f = open(filename, "wb") f.write(blob) f.close() return else: return blob
def main(): # Input asp-style ascii profile will be first argument. # (command-line options to come later) prog_name = argv[0].strip('.py') # arg = get_opt(prog_name) print 'n_args = ', len(argv) - 1 # prof_file = argv[1] input_files = [] for file in argv[1:]: # For some reason this works and ".appen()" doesn't: input_files[len(input_files):] = glob.glob(file) # input_files.append(glob.glob(file)) input_files.reverse() prof_data = [] # prof_date = [] date_text = [] # First, read in profile data file, and assign each column to a separate # numpy array # prof_file = input_files[0] # prof_header = read_asc_header(prof_file) # prof_data[0] = read_asc_prof(prof_file) # if(len(input_files) > 1): # for prof_file in input_files: nobs = [] for i_prof in np.arange(len(input_files)): prof_header = read_asc_header(input_files[i_prof]) duty = get_duty(prof_header['psrname']) nobs.append(prof_header['obscode']) print 'NOBS = ', nobs prof_data_temp = read_asc_prof(input_files[i_prof], ionly=True) prof_data_temp['i'] = norm(prof_data_temp['i'], duty) prof_data_temp['i'] = prof_data_temp['i'] + i_prof print "Index = ", i_prof, \ ", Min = ", np.min(prof_data_temp['i']), \ ", Max = ", np.max(prof_data_temp['i']) prof_data.append(prof_data_temp) # Set up labelling for each profile: prof_date = mjd.mjdtodate(prof_header['imjd'], \ dateformat='%Y %b %d') date_text.append((0.8, i_prof+0.25, prof_date)) print "Date = ", date_text nobs_unique = list(set(nobs)) clr=[] for i_nobs in range(len(nobs)): if(nobs_unique <= 1): clr.append('black') else: clr.append(cm.gist_heat(float(nobs_unique.index(nobs[i_nobs]))/float(len(nobs_unique)))) # Do this just to make the ordering such that the first alphanumerically # is at the top... # prof_data.reverse() # date_text.reverse() plot_prof(prof_data, yticks=False, canvassize=(8,10), \ hgrid=False, vgrid=False, \ ylim=(np.min(prof_data[0]['i'])-0.1, len(input_files)+0.1), figtext=date_text, linecolour=clr) # meaningThe following means that the 2nd argument is the # desired output plot file name # plot_file = 'multi_profile.png' plot_file = 'multi_profile.png' # plt.show() plt.savefig(plot_file)
def field_list_to_json(stats_filename, filename=None): """ Given a list of fields, create a FeatureCollection JSON file to use with the interactive survey coverage viewer. The final structure should look like this, where "name" is the field id, and coordinates are a list of the coordinates of the 4 corners of the field. {"type" : "FeatureCollection", "features": [ {"type" : "Feature", "properties" : { "name" : "2471"}, "geometry": { "type" : "Polygon", "coordinates" : [[ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0] ]] }, "id":"2471"}, etc. ] } Parameters ---------- fields : list, iterable Must be a list of PTF Field objects. See: ptf.photometricdatabase.Field filename : str (optional) If filename is specified, will save the JSON to the file. Otherwise, return the JSON """ data = np.genfromtxt(stats_filename, dtype=None, names=['field_id', 'mjd', 'ra', 'dec']) # final feature dictionary final_dict = dict(type="FeatureCollection", features=[]) # Minimum and maximum number of observations for all fields min_obs = 1 max_obs = 2576 # Create a matplotlib lognorm scaler between these values scaler = matplotlib.colors.LogNorm(vmin=min_obs, vmax=max_obs) for field_id in np.unique(data['field_id']): field_data = data[data['field_id'] == field_id] nexposures = len(field_data) ra = field_data['ra'].mean() dec = field_data['dec'].mean() mjds = field_data['mjd'] feature = field_to_feature(field_id, ra, dec) # Determine color of field #rgb = cm.autumn(scaler(field.number_of_exposures)) rgb = cm.gist_heat(scaler(nexposures)) feature["properties"]["color"] = mc.rgb2hex(rgb) feature["properties"]["alpha"] = scaler(nexposures) * 0.75 + 0.05 feature["properties"]["nexposures"] = str(nexposures) feature["properties"]["ra"] = "{:.5f}".format(ra) feature["properties"]["dec"] = "{:.5f}".format(dec) feature["properties"]["mjds"] = list(mjds) final_dict["features"].append(feature) blob = json.dumps(final_dict) if filename != None: f = open(filename, "wb") f.write(blob) f.close() return else: return blob
def plot_widths(width_data, canvassize=None, msize=None, \ xval='year', yunits='phase', \ xticks=True, yticks=True, xlabel=True, ylabel=True, \ sym='o', colour=None, mf_colour=None, me_colour=None, \ csize=3, xlim=None, ylim=None, \ figtext=None, gridlines=None, ticklabelsize=18, axislabelsize=18): possible_xval = ['mjd', 'mjd0', 'year', 'serial'] if(possible_xval.count(xval) == 0): print "There is not value "+xval+ \ " in the data that we can plot on x axis. Exiting." exit() possible_yunits = ['phase', 'deg', 'rad', 'cos_phi'] if(possible_yunits.count(yunits) == 0): print yunits+ " is not an option for y axis units. Exiting." exit() # If we have just the one set of residuals, cast it as a one-element # list to make things nice and general if(type(width_data) is dict): width_data = [width_data] # mjd0 will subtract the nearest 100 of the smallest mjd value from the # mjd arrays if(xval=='mjd0'): min_mjd = np.array([]) for width in width_data: min_mjd = np.append(min_mjd, np.amin(width['mjd'])) mjdint = np.floor(np.amin(min_mjd)) for width in width_data: width['mjd0'] = width['mjd'] - mjdint if(xval=='year'): for width in width_data: # date_out = [mjd.mjdtodate(m) for m in width['mjd']] width['year'] = [mjd.mjdtoyear(m) for m in width['mjd']] # width['year'] = [d.year + d.day/365. + \ # d.hour/(365.*24.) + \ # d.minute/(365.*24.*60.) + \ # d.second/(365.*24.*60.*60.) \ # for d in date_out] # Set up plot limits now xmin = np.amin(width_data[0][xval])-0.003 xmax = np.amax(width_data[0][xval])+0.003 ymin = np.amin(width_data[0]['width'] - width_data[0]['werr']) ymax = np.amax(width_data[len(width_data)-1]['width'] + \ width_data[len(width_data)-1]['werr']) xspan = abs(xmax - xmin) yspan = abs(ymax - ymin) # Set up the plot: fig = plt.figure(figsize=canvassize) ax = fig.add_axes([0.12, 0.14, 0.86, 0.83]) ax.xaxis.set_tick_params(labelsize=ticklabelsize, pad=8) ax.yaxis.set_tick_params(labelsize=ticklabelsize, pad=8) if(xlim==None): ax.set_xlim(xmin - 0.01*xspan, xmax + 0.01*xspan) else: ax.set_xlim(xlim) if(ylim==None): ax.set_ylim(ymin - 0.01*yspan, ymax + 0.02*yspan) else: ax.set_ylim(ylim) if (xlabel): if(xval=='serial'): ax.set_xlabel('Serial number', fontsize=axislabelsize, labelpad=12) elif(xval=='mjd'): ax.set_xlabel('MJD', fontsize=axislabelsize, labelpad=12) elif(xval=='mjd0'): ax.set_xlabel('MJD - {:d}'.format(int(mjdint)), fontsize=axislabelsize, labelpad=12) elif(xval=='year'): # Set formatting for years so that they have %d formatting: xmajorFormatter = FormatStrFormatter('%d') ax.set_xlabel('Year', fontsize=axislabelsize, labelpad=12) ax.xaxis.set_major_formatter(xmajorFormatter) if (ylabel): ax.set_ylabel('Pulse width (degrees)', fontsize=axislabelsize)#, labelpad=8) if(not xticks): for tick in ax.xaxis.get_major_ticks(): tick.label1On = False tick.label2On = False if(not yticks): for tick in ax.yaxis.get_major_ticks(): tick.label1On = False tick.label2On = False for i_width in range(len(width_data)): width = width_data[i_width] # Get colours if(colour!=None): if (type(colour) is list): clr = colour[i_width] else: clr = colour else: # Set up automated colours if (len(width_data)==1): clr = 'black' else: clr = cm.gist_heat(float(i_width)/float(len(width_data))) if (type(mf_colour) is list): mf_clr = mf_colour[i_width] else: mf_clr = clr if (type(me_colour) is list): me_clr = me_colour[i_width] else: me_clr = clr #ax.plot(res[xval], res['res'], 'o', markersize=msize, color=col) if(gridlines!=None): for ycoord in gridlines: ax.axhline(ycoord, linestyle='--', color='black', \ linewidth=0.4) # Change to appropriate units: if (yunits=='deg'): # Set formatting for degrees so that they have correct formatting: ymajorFormatter = FormatStrFormatter('%5.1f') ax.yaxis.set_major_formatter(ymajorFormatter) y_plot = width['width']*360. yerr_plot = width['werr']*360. elif (yunits=='rad'): y_plot = width['width']*2.*np.pi yerr_plot = width['werr']*2.*np.pi elif (yunits=='cos_phi'): y_plot = cos(width['width']/2.) yerr_plot = cos(width['werr']/2.) else: # Just in units of phase as given in data file y_plot = width['width'] yerr_plot = width['werr'] if(i_width==0): xmin = np.amin(width[xval]) xmax = np.amax(width[xval]) ymin = np.amin(y_plot-yerr_plot) ymax = np.amax(y_plot+yerr_plot) else: xmin = np.amin(np.append(width[xval], xmin)) xmax = np.amax(np.append(width[xval], xmax)) ymin = np.amin(np.append(y_plot-yerr_plot, ymin)) ymax = np.amax(np.append(y_plot+yerr_plot, ymax)) xspan = abs(xmax - xmin) yspan = abs(ymax - ymin) # Overplot error bars. Use fmt=None to tell it not to plot points: ax.plot(width[xval], y_plot, sym, color=clr, mfc=mf_clr, mec=me_clr) ax.errorbar(width[xval], y_plot, yerr=yerr_plot, \ capsize=csize, fmt=None, ecolor=clr, \ markersize=msize) if(xlim==None): ax.set_xlim(xmin - 0.025*xspan, xmax + 0.025*xspan) else: ax.set_xlim(xlim) if(ylim==None): ax.set_ylim(ymin - 0.1*yspan, ymax + 0.1*yspan) else: ax.set_ylim(ylim) # Figure text must be a list of tuples: [(x, y, text), (x, y, text), ...] if(figtext!=None): for txt in figtext: ax.text(txt[0], txt[1], txt[2], fontsize=10, \ horizontalalignment='center', \ verticalalignment='center') # plt.savefig('test_widths.png') return ax
def field_list_to_json(stats_filename, filename=None): """ Given a list of fields, create a FeatureCollection JSON file to use with the interactive survey coverage viewer. The final structure should look like this, where "name" is the field id, and coordinates are a list of the coordinates of the 4 corners of the field. {"type" : "FeatureCollection", "features": [ {"type" : "Feature", "properties" : { "name" : "2471"}, "geometry": { "type" : "Polygon", "coordinates" : [[ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0] ]] }, "id":"2471"}, etc. ] } Parameters ---------- fields : list, iterable Must be a list of PTF Field objects. See: ptf.photometricdatabase.Field filename : str (optional) If filename is specified, will save the JSON to the file. Otherwise, return the JSON """ data = np.genfromtxt(stats_filename, dtype=None, names=['field_id','mjd','ra','dec']) # final feature dictionary final_dict = dict(type="FeatureCollection", features=[]) # Minimum and maximum number of observations for all fields min_obs = 1 max_obs = 2576 # Create a matplotlib lognorm scaler between these values scaler = matplotlib.colors.LogNorm(vmin=min_obs, vmax=max_obs) for field_id in np.unique(data['field_id']): field_data = data[data['field_id'] == field_id] nexposures = len(field_data) ra = field_data['ra'].mean() dec = field_data['dec'].mean() mjds = field_data['mjd'] feature = field_to_feature(field_id, ra, dec) # Determine color of field #rgb = cm.autumn(scaler(field.number_of_exposures)) rgb = cm.gist_heat(scaler(nexposures)) feature["properties"]["color"] = mc.rgb2hex(rgb) feature["properties"]["alpha"] = scaler(nexposures)*0.75 + 0.05 feature["properties"]["nexposures"] = str(nexposures) feature["properties"]["ra"] = "{:.5f}".format(ra) feature["properties"]["dec"] = "{:.5f}".format(dec) feature["properties"]["mjds"] = list(mjds) final_dict["features"].append(feature) blob = json.dumps(final_dict) if filename != None: f = open(filename, "wb") f.write(blob) f.close() return else: return blob
pos1[:, 0:2] = -1+2*np.random.rand(5000, 2) pos2[:, 0:2] = -1+2*np.random.rand(10000, 2) r2 = np.sqrt(pos2[:, 0]**2+pos2[:, 1]**2) k2, = np.where(r2 < 0.5) pos2 = pos2[k2, :] qv1 = QuickView(pos1.T, np.ones(len(pos1)), r='infinity', logscale=False, plot=False, extent=[-1, 1, -1, 1], x=0, y=0, z=0) qv2 = QuickView(pos2.T, np.ones(len(pos2)), r='infinity', logscale=False, plot=False, extent=[-1, 1, -1, 1], x=0, y=0, z=0) image1 = cm.gist_heat(get_normalized_image(qv1.get_image())) image2 = cm.gist_stern(get_normalized_image(qv2.get_image())) fig = plt.figure(1, figsize=(10, 5)) ax1 = fig.add_subplot(121) ax2 = fig.add_subplot(122) blend = Blend(image1, 1.0*image2) screen = blend.Screen() overlay = blend.Overlay() ax1.imshow(screen, origin='lower', extent=qv1.get_extent()) ax1.set_title('Screen') ax2.imshow(overlay, origin='lower', extent=qv1.get_extent()) ax2.set_title('Overlay') plt.show()
pos2[:,0:2] = -1+2*np.random.rand(10000,2) r2 = np.sqrt(pos2[:,0]**2+pos2[:,1]**2) k2, = np.where(r2 < 0.5) pos2 = pos2[k2,:] qv1 = QuickView(pos1.T, np.ones(len(pos1)), r='infinity', logscale=False, plot=False, extent=[-1,1,-1,1], x=0, y=0, z=0) qv2 = QuickView(pos2.T, np.ones(len(pos2)), r='infinity', logscale=False, plot=False, extent=[-1,1,-1,1], x=0, y=0, z=0) image1 = cm.gist_heat(get_normalized_image(qv1.get_image())) image2 = cm.gist_stern(get_normalized_image(qv2.get_image())) fig = plt.figure(1, figsize=(10,5)) ax1 = fig.add_subplot(121) ax2 = fig.add_subplot(122) blend = Blend(image1, 1.0*image2) screen = blend.Screen() overlay = blend.Overlay() ax1.imshow(screen, origin='lower', extent=qv1.get_extent()) ax1.set_title('Screen') ax2.imshow(overlay, origin='lower', extent=qv1.get_extent()) ax2.set_title('Overlay')