def _init_draw(self): if self.display: lines = [self.line_spike] for x in range(self.n_joints): lines.append(self.analog_lines[x]) for l in lines: l.set_data([], [])
def plot_quantity_vs_index( self, ax: plt.Axes, a: u.Quantity, t: typ.Optional[astropy.time.Time] = None, a_name: str = '', # drawstyle: str = 'steps-mid', ) -> typ.Tuple[plt.Axes, typ.List[plt.Line2D]]: ax = plot.datetime_prep(ax) if t is None: t = self.time t_left = t - self.exposure_half_length t_right = t + self.exposure_half_length with astropy.visualization.quantity_support(): lines = [] for c in range(self.num_channels): time = astropy.time.Time( np.stack([t_left[:, c], t_right[:, c]], axis=~0).reshape(-1)) q = np.stack([a[:, c], a[:, c]], axis=~0).reshape(-1) line, = ax.plot( time.to_datetime(), q, label=a_name + ', ' + self.channel_labels[c], # drawstyle=drawstyle, ) lines.append(line) return ax, lines
def plot_wavelength( self, ax: matplotlib.axes.Axes, num_emission_lines: int = 10, digits_after_decimal: int = 3, colors: typ.Optional[typ.Sequence[str]] = None, ) -> typ.List[matplotlib.lines.Line2D]: if colors is None: colors = num_emission_lines * ['black'] with astropy.visualization.quantity_support(): wavelength = self.wavelength[:num_emission_lines] fullname = self.fullname(digits_after_decimal=digits_after_decimal, use_latex=True)[:num_emission_lines] # ax.set_ylabel('{0:latex_inline}'.format(intensity.unit)) lines = [] for i in range(wavelength.shape[0]): lines.append( ax.axvline( x=wavelength[i], label=fullname[i], linestyle='dashed', color=colors[i], )) return lines
def make_lines(obstacle_vertices,connect=True): lines = [] for i,vertex in enumerate(obstacle_vertices): if i < len(obstacle_vertices)-1: lines.append([obstacle_vertices[i],obstacle_vertices[i+1]]) else: if connect: lines.append([obstacle_vertices[i],obstacle_vertices[0]]) return lines
def marker_graph_add(ax: np.ndarray, marker_data: np.ndarray, x_data: np.ndarray, **kwargs) \ -> List[matplotlib.lines.Line2D]: """Plot each column of marker_data ((n,3) numpy array) onto the axes provided in ax. **kwargs passed to matplotlib plot(). """ lines = [] for n in range(3): current_line, = ax[n].plot(x_data, marker_data[:, n], **kwargs) lines.append(current_line) return lines
def kine_graph_add(ax: matplotlib.axes.Axes, marker_data: np.ndarray, x_data: np.ndarray, plot_args=None) \ -> List[matplotlib.lines.Line2D]: """Plot each column of marker_data ((n,3) numpy array) onto the axes provided in ax. Additionally, visually format each Axes and include a y_label on 2nd Axes. **kwargs passed to matplotlib plot(). """ if plot_args is None: plot_args = [{}] * marker_data.shape[1] lines = [] for dim in range(marker_data.shape[1]): current_line, = ax.plot(x_data, marker_data[:, dim], **plot_args[dim]) lines.append(current_line) return lines
def create_lines(polygons): """ creates all existing lines in each polygon. Lines within polygon are also created to distinguish possible paths that lie on the edge of the polygon vs illegal paths through the polygon :param polygons: :return: """ lines = [] for polygon in polygons: curr_lines = [] for idx in range(0, len(polygon)): for idx_ in range(idx, len(polygon)): curr_line = Line(polygon[idx], polygon[idx_]) curr_lines.append(curr_line) lines.append(curr_lines) return lines
def cov_trend_graph_add(ax: np.ndarray, variance_data: Any, x_data: np.ndarray, process_func: Callable, **kwargs) \ -> List[List[matplotlib.lines.Line2D]]: """Plot each kinematic variable/dimension combination contained in variance_data (tuple of 3 kinematic variables, each comprised of a (n, 3) numpy array) onto the 3 rows (kinematic variable) and 3 columns (dimension) contained in ax. Apply process_func to each kinematic variable/dimension before plotting. **kwargs passed to matplotlib plot(). """ lines = [] # iterate over kinematic variable for i in range(3): # iterate over dimension dim_lines = [] for j in range(3): line, = ax[i, j].plot(x_data, process_func(variance_data[i][:, j]), **kwargs) dim_lines.append(line) lines.append(dim_lines) return lines
def lorentz(field): '''Calculate Lorentz Force from E and B field''' print("Calculating LORENTZ-condition...") q = 1 c = 299792458 # 0 1 2 3 7 8 9 10 11 lines = [[ "id", r"s / m", r"x / m", r"y / m", r"z / m", r"$x'$ / rad", r"$y'$ / rad", r"$z'$ / rad", r"$B_x$ / T", r"$B_y$ / T", r"$B_z$ / T", r"$E_x$ / V/m", r"$E_y$ / V/m", r"$E_z$ / V/m", r"$F_{Bx}$ / eV/m", r"$F_{By}$ / eV/m", r"$F_{Bz}$ / eV/m", r"$F_{Ex}$ / eV/m", r"$F_{Ey}$ / eV/m", r"$F_{Ez}$ / eV/m", r"$F_x$ / eV/m", r"$F_y$ / eV/m", r"$F_z$ / eV/m", r"|B| / T", r"|E| / V/m", r"$\sqrt{B_y^2+B_z^2}$ / T", r"$\sqrt{E_x^2+E_z^2}$ / V/m" ]] for f in tqdm(field): s = f[13] * c * math.sqrt(f[4]**2 + f[5]**2 + f[6]**2) xprime = f[4] / math.sqrt(f[4]**2 + f[5]**2 + f[6]**2) yprime = f[5] / math.sqrt(f[4]**2 + f[5]**2 + f[6]**2) zprime = f[6] / math.sqrt(f[4]**2 + f[5]**2 + f[6]**2) FBx = q * c * (f[5] * f[9] - f[6] * f[8]) FBy = q * c * (f[6] * f[7] - f[4] * f[9]) FBz = q * c * (f[4] * f[8] - f[5] * f[7]) FEx = q * f[10] FEy = q * f[11] FEz = q * f[12] Fx = FEx + FBx Fy = FEy + FBy Fz = FEz + FBz absB = math.sqrt(f[7]**2 + f[8]**2 + f[9]**2) absE = math.sqrt(f[10]**2 + f[11]**2 + f[12]**2) unwantedB = math.sqrt(f[8]**2 + f[9]**2) unwantedE = math.sqrt(f[10]**2 + f[12]**2) line = [f[0], s] + f[1:4] + [xprime, yprime, zprime] + f[7:13] + [ FBx, FBy, FBz, FEx, FEy, FEz, Fx, Fy, Fz, absB, absE, unwantedB, unwantedE ] lines.append(line) return lines
def marker_graph_init(ax: np.ndarray, marker_data: np.ndarray, y_label: str, x_data: np.ndarray, **kwargs) \ -> List[matplotlib.lines.Line2D]: """Plot each column of marker_data ((n,3) numpy array) onto the axes provided in ax. Additionally, visually format each Axes and include a y_label on 2nd Axes. **kwargs passed to matplotlib plot(). """ lines = [] for n in range(3): current_line, = ax[n].plot(x_data, marker_data[:, n], **kwargs) lines.append(current_line) plot_utils.update_spines(ax[n]) plot_utils.update_xticks(ax[n], font_size=8) plot_utils.update_yticks(ax[n], fontsize=8) ax[n].margins(x=0, y=0.05) ax[n].yaxis.set_major_locator(ticker.MaxNLocator(nbins=4, integer=True)) if n == 2: plot_utils.update_xlabel(ax[n], 'Frame Number', font_size=10) elif n == 1: plot_utils.update_ylabel(ax[n], y_label, font_size=10) return lines
def kine_graph_init(ax: matplotlib.axes.Axes, marker_data: np.ndarray, y_label: str, x_data: np.ndarray, plot_args=None) -> List[matplotlib.lines.Line2D]: """Plot each column of marker_data ((n,3) numpy array) onto the axes provided in ax. Additionally, visually format each Axes and include a y_label on 2nd Axes. **kwargs passed to matplotlib plot(). """ if plot_args is None: plot_args = [{}] * marker_data.shape[1] lines = [] for dim in range(marker_data.shape[1]): current_line, = ax.plot(x_data, marker_data[:, dim], **plot_args[dim]) lines.append(current_line) plot_utils.update_spines(ax) plot_utils.update_xticks(ax, font_size=8) plot_utils.update_yticks(ax, fontsize=8) ax.margins(x=0, y=0.05) ax.yaxis.set_major_locator(ticker.MaxNLocator(nbins=4, integer=True)) plot_utils.update_xlabel(ax, 'Frame Number', font_size=10) plot_utils.update_ylabel(ax, y_label, font_size=10) return lines
def cov_trend_graph_init(ax: np.ndarray, variance_data: Any, x_data: np.ndarray, y_labels: Sequence[str], process_func: Callable, **kwargs) -> List[List[matplotlib.lines.Line2D]]: """Plot each kinematic variable/dimension combination contained in variance_data (tuple of 3 kinematic variables, each comprised of a (n, 3) numpy array) onto the 3 rows (kinematic variable) and 3 columns (dimension) contained in ax. Apply process_func to each kinematic variable/dimension before plotting. Additionally, visually format each axes and include a y_label for the first column of each row. **kwargs passed to matplotlib plot(). """ lines = [] # iterate over kinematic variable for i in range(3): # iterate over dimension dim_lines = [] for j in range(3): line, = ax[i, j].plot(x_data, process_func(variance_data[i][:, j]), **kwargs) dim_lines.append(line) plot_utils.update_spines(ax[i, j]) plot_utils.update_xticks(ax[i, j], font_size=8) plot_utils.update_yticks(ax[i, j], fontsize=8) ax[i, j].margins(x=0, y=0.05) ax[i, j].yaxis.set_major_locator( ticker.MaxNLocator(nbins=4, integer=True)) if i == 2 and j == 1: plot_utils.update_xlabel(ax[i, j], 'Frame Number', font_size=10) if j == 0: plot_utils.update_ylabel(ax[i, j], y_labels[i], font_size=10) lines.append(dim_lines) return lines
def readlines(file): '''Read in lines as list of strings''' print("Reading from %s ..." % file) f = open(file, 'r') lines = [] caption = True #False for line in f: if not line.split(): # Catch empty lines continue if line.split()[0] == "ID": # Capture particle IDs id = int(float(line.split()[1])) continue if id in [10000]: # last particle sometimes simulated wrong continue try: floats = [float(f) for f in line.split()] lines.append([id] + floats) except ValueError: # Catch lines not containing floats (e.g. Captions) if caption != True: lines = [["id"] + line.split()] + lines caption = True continue f.close() return lines
def autoconfig_processfile(name, pool_used, f_index, args): try: with open( name ) as result_file: # No need to specify 'r': this is the default.as gates = args.config if (gates is not None): num_gates = len(gates) else: num_gates = 0 nameParts = name.split("/") if len(nameParts) > 1: originalName = nameParts[len(nameParts) - 2] else: if args.name is not None: originalName = args.name + str(f_index) else: originalName = "NoNameSample" + str(f_index) print("Processing ", (originalName)) colorlist = args.colorlist events = sum(1 for line in result_file) - 1 #quickly determine number of events result_file.seek(0) #rewind to the beginning of file header = result_file.readline() header = header.strip() headers = header.split( "\t") #parse the headers from the first line of input num_markers = len(headers) - 2 # create a numpy array for faster data access if args.debug: print("Assigning data to numpy matrix") fcm = loadNp(result_file, len(headers), events) # find the start of pop info on fcs_results_all if args.flocklegacy is False: pop_offset = 0 for i, header in enumerate(headers): if header == "pop1": pop_offset = i - 1 if args.debug: print("Pop offset: ", pop_offset) # parsing gates from configuration data if args.debug: print("Configuring gates from file") sub_results = [] if pool_used == 0: inner_pool = Pool(processes=cores) for gate, config in gates.items(): xmarker = str(headers[config[1] - 1]) ymarker = str(headers[config[2] - 1]) startx = int((float(config[3]) / 200) * 4096) starty = int((float(config[5]) / 200) * 4096) endx = int((float(config[4]) / 200) * 4096) endy = int((float(config[6]) / 200) * 4096) parent_gate = int(config[7]) lines = [] cluster_type = int(config[8]) if cluster_type == 2: print("slanted") else: lines.append([(startx, endx), (starty, starty), colorlist[1]]) lines.append([(startx, startx), (starty, endy), colorlist[1]]) lines.append([(startx, endx), (endy, endy), colorlist[1]]) lines.append([(endx, endx), (starty, endy), colorlist[1]]) key = xmarker + "_vs_" + ymarker dim1 = xmarker dim2 = ymarker print(dim1, dim2) dim1_idx = 0 dim2_idx = 0 for i, marker in enumerate(headers): if marker == dim1: dim1_idx = i print(("Feature 1: ", marker, i + 1)) if marker == dim2: dim2_idx = i print(("Feature 2: ", marker, i + 1)) header_names = key print(header_names) if args.flocklegacy is False: poploc = int(config[0]) + pop_offset parent_poploc = parent_gate + pop_offset print("gate location: ", poploc) print("parent gate location: ", parent_poploc) if args.debug: print( "iterate through events to find population members" ) fcm[:, -1] = 0 if args.showparent and (config[0] > 1): fcm[:, -1] = (1 - fcm[:, poploc]) + ( 1 - fcm[:, parent_poploc]) else: fcm[:, -1] = (2 - 2 * fcm[:, poploc]) if args.debug: print("sorting numpy array") if args.sort: sfcm = fcm[np.argsort( fcm[:, -1] )] #sort the data set based on population number else: sfcm = fcm if args.reversesort: sfcm = sfcm[::-1] #print sfcm[0, :] if args.debug: print("creating color array") cdata = [] for a in sfcm[:, -1]: cdata.append(colorlist[a]) xdata = sfcm[:, dim1_idx] ydata = sfcm[:, dim2_idx] sample_name = originalName poplist = [] if args.flocklegacy is False: pop_name = gate parent_pop_name = "pop" + str(parent_gate) if args.showparent: poplist.append(parent_pop_name) poplist.append(pop_name) else: pop_name = "FLOCK" png_file = sample_name + "_" + header_names + "_" + pop_name + ".png" if pool_used == 0: inner_pool.apply_async(plotfig, args=[ sample_name, xdata, ydata, cdata, xmarker, ymarker, poplist, lines, args ]) else: plotfig(sample_name, xdata, ydata, cdata, xmarker, ymarker, poplist, lines, args) if args.flocklegacy is False: sub_results.append([pop_name, [sample_name, png_file]]) else: sub_results.append( [pop_name + str(gate), [sample_name, png_file]]) if pool_used == 0: inner_pool.close() inner_pool.join() return sub_results except IOError as exc: if exc.errno != errno.EISDIR: # Do not fail if a directory is found, just ignore it. raise # Propagate other kinds of IOError.args except: #print >> sys.stderr, "Exception: %s" % str(e) raise Exception("".join(traceback.format_exception(*sys.exc_info())))
def recall(model, class_names): class_dict = {} label_dict = ['background'] if args.label: label_file = open(args.label) label_lines = label_file.readlines() label_id = 1 for label_line in label_lines: label_line = label_line.replace('\n', '') class_dict[label_line] = label_id label_dict.append(label_line) label_id = label_id + 1 # Validation dataset dataset_val = MyDataset() dataset_val.load_my(args.dataset, "val", class_dict) dataset_val.prepare() pre_correct_dict = {} pre_total_dict = {} pre_iou_dict = {} pre_scores_dict = {} gt_total_dict = {} for i in range(1, len(class_dict) + 1): pre_correct_dict[i] = 0 pre_total_dict[i] = 0 pre_iou_dict[i] = 0.0 pre_scores_dict[i] = 0.0 gt_total_dict[i] = 0 backbone_shapes = modellib.compute_backbone_shapes(config, [768, 1280, 3]) anchor_boxes = utils.generate_pyramid_anchors(config.RPN_ANCHOR_SCALES, config.RPN_ANCHOR_RATIOS, backbone_shapes, config.BACKBONE_STRIDES, config.RPN_ANCHOR_STRIDE) #utils.generate_anchors(300, config.RPN_ANCHOR_RATIOS, [40,40], 32, config.RPN_ANCHOR_STRIDE) #print(anchor_boxes) rois = [] obj_groups = [] # {image_file, [gt_class_id], [gt_box, (y1,x1,y2,x2)], [gt_bbox_area], [gt_wh_ratio], [gt_mask_area], [gt_mask_ratio], [gt_size], } for image_id in dataset_val.image_ids: image, image_meta, gt_class_id, gt_box, gt_mask = modellib.load_image_gt( dataset_val, config, image_id, use_mini_mask=False) #print(image.shape) gt_detects = {} gt_detects['image'] = dataset_val.image_reference(image_id) gt_detects['gt_class_id'] = gt_class_id gt_detects['gt_bbox'] = gt_box gt_detects['gt_bbox_area'] = [] gt_detects['gt_wh_ratio'] = [] gt_detects['gt_mask_area'] = [] gt_detects['gt_mask_ratio'] = [] gt_detects['gt_size'] = [] for i in range(0, len(gt_class_id)): gt_total_dict[gt_class_id[i]] = gt_total_dict[gt_class_id[i]] + 1 wh_ratio, box_size, box_area, square_box = toSquareBox(gt_box[i]) mask_area = np.sum(gt_mask[:, :, i] == True) mask_ratio = mask_area / box_area gt_detects['gt_bbox_area'].append(box_area) gt_detects['gt_wh_ratio'].append(wh_ratio) gt_detects['gt_mask_area'].append(mask_area) gt_detects['gt_mask_ratio'].append(mask_ratio) gt_detects['gt_size'].append(box_size) molded_image = modellib.mold_image(image, config) #print(molded_image.shape) # Anchors """ anchors = model.get_anchors(molded_image.shape) # Duplicate across the batch dimension because Keras requires it # TODO: can this be optimized to avoid duplicating the anchors? anchors = np.broadcast_to(anchors, (config.BATCH_SIZE,) + anchors.shape) print(anchors) # Run object detection detections, mrcnn_class, mrcnn_bbox, mrcnn_mask, rpn_rois, rpn_class, rpn_bbox =\ model.keras_model.predict([np.expand_dims(molded_image, 0), np.expand_dims(image_meta, 0), anchors], verbose=0) print(detections[0]) print(mrcnn_class[0]) print(rpn_class[0]) """ #skimage.io.imsave("test.jpg", image) start_time = time.time() results = model.detect_molded(np.expand_dims(molded_image, 0), np.expand_dims(image_meta, 0), verbose=0) end_time = time.time() #print("Time: %s" % str(end_time - start_time)) #print(results) r = results[0] pre_class_ids = r['class_ids'] for i in range(0, len(pre_class_ids)): pre_total_dict[ pre_class_ids[i]] = pre_total_dict[pre_class_ids[i]] + 1 pre_scores = r['scores'] #print(r['rois']) for roi in r['rois']: whr, bsize, _, _ = toSquareBox(roi) rois.append([bsize, whr]) #print(gt_detects['gt_size']) #overlaps = utils.compute_iou(roi, gt_detects['gt_bbox'], roi_area, gt_detects['gt_bbox_area']) #print(overlaps) gt_match, pred_match, overlap = display_differences( image, gt_box, gt_class_id, gt_mask, r['rois'], pre_class_ids, pre_scores, r['masks'], class_names, title="", ax=None, show_mask=True, show_box=True, iou_threshold=0.1, score_threshold=0.1) gt_detects['rois'] = r['rois'] gt_detects['gt_match'] = gt_match gt_detects['pred_match'] = pred_match #print(gt_match) """ visualize.display_differences(image, gt_box, gt_class_id, gt_mask, r['rois'], pre_class_ids, pre_scores, r['masks'], class_names, title="", ax=None, show_mask=True, show_box=True, iou_threshold=0.1, score_threshold=0.1) """ for i in range(0, len(pred_match)): if pred_match[i] > -1.0: #print(r['rois'][i]) pre_correct_dict[ pre_class_ids[i]] = pre_correct_dict[pre_class_ids[i]] + 1 pre_iou_dict[pre_class_ids[i]] = pre_iou_dict[ pre_class_ids[i]] + overlap[i, int(pred_match[i])] pre_scores_dict[pre_class_ids[i]] = pre_scores_dict[ pre_class_ids[i]] + pre_scores[i] obj_groups.append(gt_detects) #print(rois) print("图片,类别,标注框,标注宽高比,标注尺寸,检测框,检测宽高比,检测尺寸,最大IOU") for det in obj_groups: for i in range(0, len(det['gt_class_id'])): overlaped = utils.compute_overlaps( anchor_boxes, np.reshape(det['gt_bbox'][i], (1, 4))) omax = max(overlaped) #if det['gt_size'][i] > 150 and det['gt_size'][i] < 367: if omax[0] > 0.0: print(det['image'], end='') print(",", label_dict[det['gt_class_id'][i]], ",", det['gt_bbox'][i], ",", det['gt_wh_ratio'][i], ",", det['gt_size'][i], end="") if det['gt_match'][i] > -1.0: idx = int(det['gt_match'][i]) #print(idx, det['rois']) whr, bsize, _, _ = toSquareBox(det['rois'][idx]) print(",", det['rois'][idx], ",", whr, ",", bsize, ",", omax[0]) else: print(",", 0, ",", 0, ",", 0, ",", omax[0]) tol_pre_correct_dict = 0 tol_pre_total_dict = 0 tol_pre_iou_dict = 0 tol_pre_scores_dict = 0 tol_gt_total_dict = 0 lines = [] tile_line = 'Type,Number,Correct,Proposals,Total,Rps/img,Avg IOU,Avg score,Recall,Precision\n' lines.append(tile_line) for key in class_dict: tol_pre_correct_dict = tol_pre_correct_dict + pre_correct_dict[ class_dict[key]] tol_pre_total_dict = pre_total_dict[ class_dict[key]] + tol_pre_total_dict tol_pre_iou_dict = pre_iou_dict[class_dict[key]] + tol_pre_iou_dict tol_pre_scores_dict = pre_scores_dict[ class_dict[key]] + tol_pre_scores_dict tol_gt_total_dict = gt_total_dict[class_dict[key]] + tol_gt_total_dict type_rps_img = pre_total_dict[class_dict[key]] / len( dataset_val.image_ids) if pre_correct_dict[class_dict[key]] > 0: type_avg_iou = pre_iou_dict[class_dict[key]] / pre_correct_dict[ class_dict[key]] type_avg_score = pre_scores_dict[ class_dict[key]] / pre_correct_dict[class_dict[key]] else: type_avg_iou = 0 type_avg_score = 0 if gt_total_dict[class_dict[key]] > 0: type_recall = pre_total_dict[class_dict[key]] / gt_total_dict[ class_dict[key]] else: type_recall = 0 if pre_total_dict[class_dict[key]] > 0: type_precision = pre_correct_dict[ class_dict[key]] / pre_total_dict[class_dict[key]] else: type_precision = 0 line = '{:s},{:d},{:d},{:d},{:d},{:.2f},{:.2f}%,{:.2f},{:.2f}%,{:.2f}%\n'.format( key, len(dataset_val.image_ids), pre_correct_dict[class_dict[key]], pre_total_dict[class_dict[key]], gt_total_dict[class_dict[key]], type_rps_img, type_avg_iou * 100, type_avg_score, type_recall * 100, type_precision * 100) lines.append(line) print(line) tol_rps_img = tol_pre_total_dict / len(dataset_val.image_ids) if tol_pre_correct_dict > 0: tol_avg_iou = tol_pre_iou_dict / tol_pre_correct_dict tol_avg_score = tol_pre_scores_dict / tol_pre_correct_dict else: tol_avg_iou = 0 tol_avg_score = 0 if tol_gt_total_dict > 0: tol_recall = tol_pre_total_dict / tol_gt_total_dict else: tol_recall = 0 if tol_pre_total_dict > 0: tol_precision = tol_pre_correct_dict / tol_pre_total_dict else: tol_precision = 0 totle_line = '{:s},{:d},{:d},{:d},{:d},{:.2f},{:.2f}%,{:.2f},{:.2f}%,{:.2f}%\n'.format( 'Total', len(dataset_val.image_ids), tol_pre_correct_dict, tol_pre_total_dict, tol_gt_total_dict, type_rps_img, tol_avg_iou * 100, tol_avg_score, tol_recall * 100, tol_precision * 100) print(totle_line) lines.append(totle_line) result_file_name = "result_{:%Y%m%dT%H%M%S}.csv".format(datetime.now()) result_file = open(result_file_name, 'w+') result_file.writelines(lines) result_file.close()
bbox_transform=plt.gcf().transFigure) fig.suptitle('CTRNN trace comparison between evolved and target networks', fontsize=20) fig.tight_layout() plt.subplots_adjust(top=0.85, bottom=0.1) plt.show() # And here are the network's responses to a $sin(t/25)$ wave: # In[114]: fig, ax = plt.subplots(figsize=(9, 6)) lines = [] lines.append( ax.plot(fixedStd['0:200'][0]['neur1'], linewidth=4, label='target')[0]) for key in sortedKeys: lines.append( ax.plot(ctrnnStd[key][0]['neur1'], linewidth=3, linestyle='--', label=key)[0]) plt.ylabel('Output') plt.xlabel('Time') inputAx = ax.twinx() line5 = inputAx.plot(fixedStd['0:200'][0]['input0'], color='gray', linestyle=':',
def plot_angles(angs, hist, mapargs, color_map='cool', area_mult=1.0, alpha=0.9, hide_zero_marker=False, use_scale=False, label_view=[], **extra): ''' Plot the angular histogram using a map projection from basemap .. note:: Basemap uses longitude latitude conventions, but the given angles are in colatitude, longitude convention. :Parameters: angs : array Array of view angles cnt : array Histogram for each view angle mapargs : dict Arguments specific to a map projection in basemap color_map : str Name of color map area_mult : float Scaling factor for size display alpha : float Transparency factor hide_zero_marker : bool If true, hide the zero projection count marker use_scale : bool If true, then display scale for size and color label_view : list Label each view with text extra : dict Unused keyword arguments ''' cmap = getattr(cm, color_map) m = basemap.Basemap(**mapargs) # Y -> latitude # Z -> longitude #longitude, latitude = 90-colatitude x, y = m(angs[:, 1], 90.0 - angs[:, 0]) sel = hist < 1 hist = hist.astype(numpy.float) s = numpy.sqrt(hist) * area_mult nhist = hist.copy() nhist -= nhist.min() nhist /= nhist.max() m.drawparallels(numpy.arange(-90., 120., 30.)) m.drawmeridians(numpy.arange(0., 420., 60.)) im = m.scatter(x, y, s=s, marker="o", c=cmap(nhist), alpha=alpha, edgecolors='none') font_tiny = matplotlib.font_manager.FontProperties() font_tiny.set_size('xx-small') if len(label_view) > 0: for i in label_view: if i > len(angs): _logger.warn( "Cannot label view: %d when there are only %d views (skipping)" % (i, len(angs))) continue ytext = -15 if i % 2 == 0 else 15 pylab.annotate('%d: %.1f,%.1f' % (i + 1, angs[i, 0], angs[i, 1]), xy=(x[i], y[i]), xycoords='data', xytext=(-15, ytext), textcoords='offset points', arrowprops=dict(arrowstyle="->"), fontproperties=font_tiny) if numpy.sum(sel) > 0 and not hide_zero_marker: im = m.scatter(x[sel], y[sel], numpy.max(s), marker="x", c=cm.gray(0.5)) #@UndefinedVariable if not use_scale: im = matplotlib.cm.ScalarMappable(cmap=cmap, norm=matplotlib.colors.Normalize()) im.set_array(hist) m.colorbar(im, "right", size="3%", pad='1%') else: fontP = matplotlib.font_manager.FontProperties() fontP.set_size('small') inc = len(hist) / 10 lines = [] labels = [] idx = numpy.argsort(hist)[::-1] for j in xrange(0, len(hist), inc): i = idx[j] labels.append("%s" % hist[i]) lines.append( matplotlib.lines.Line2D(range(1), range(1), color=cmap(nhist[i]), marker='o', markersize=s[i] / 2, linestyle='none', markeredgecolor='white')) if numpy.sum(sel) > 0 and not hide_zero_marker: i = idx[len(idx) - 1] labels.append("%s" % hist[i]) lines.append( matplotlib.lines.Line2D(range(1), range(1), color=cm.gray(0.5), marker='x', markersize=numpy.max(s) / 5, linestyle='none')) #@UndefinedVariable pylab.legend(tuple(lines), tuple(labels), numpoints=1, frameon=False, loc='center left', bbox_to_anchor=(1, 0.5), prop=fontP)
def main(label): num_shells_range = { 6: [3.5, 14.5], 12: [4.5, 16.5], 20: [6.5, 16.5], 30: [9.5, 16.5], 42: [11.5, 20.5], 56: [14.5, 20.5], } num_particles_ticks = [6, 30, 56] LEGEND_FACET_IDX = 2 if label == "ground": freq_ticks = [0.28, 1.0] methods = ["mp2", "imsrg", "ccsd", "fci"] fn = "../Manuscript/fig-gs2.pdf" else: freq_ticks = [0.28, 1.0] # 0.28 needed to show DMC results fn = "../Manuscript/fig-{}2.pdf".format(label) methods = ["imsrg+qdpt3", "imsrg+eom", "ccsd+eom"] d = utils.load_all() d_dmc = utils.load_all_dmc() d = utils.filter_preferred_ml(d) del d["ml"] d = d[d["interaction"] == "normal"] del d["interaction"] d = d[d["label"] == label] d_dmc = d_dmc[d_dmc["label"] == label] del d["label"] del d_dmc["label"] del d["num_filled"] d_dmc = d_dmc.set_index(["num_particles", "freq"]) facet_x = { "col": "num_particles", "symbol": "N", "ticks": num_particles_ticks, } facet_y = { "col": "freq", "symbol": "\omega", "ticks": freq_ticks, } facet_to_num_particles_freq = lambda x, y: (x, y) has_dmc = False width = 6.5 height = 3 base_markersize = 5.0 fig = plt.figure(figsize=(width, height)) gs = matplotlib.gridspec.GridSpec(len(facet_y["ticks"]), len(facet_x["ticks"])) for (fct_x, fct_y), d in d.groupby([facet_x["col"], facet_y["col"]]): num_particles, freq = facet_to_num_particles_freq(fct_x, fct_y) try: gi = (facet_x["ticks"].index(fct_x) + facet_y["ticks"].index(fct_y) * len(facet_x["ticks"])) except ValueError: continue if gi == LEGEND_FACET_IDX: continue ax = fig.add_subplot(gs[gi]) try: sel_dmc = d_dmc.loc[(num_particles, freq)] except KeyError: pass else: has_dmc = True ax.axhline(sel_dmc["energy"], color=utils.METHOD_COLOR["dmc"], linestyle=utils.DMC_LINESTYLE) for method, d in d.groupby("method"): if method not in methods: continue d = d[(d["num_shells"] >= num_shells_range[num_particles][0]) & (d["num_shells"] <= num_shells_range[num_particles][1])] d = d.sort_values(["num_shells"]) marker = utils.METHOD_MARKER[method] ax.plot(d["num_shells"], d["energy"], marker=marker, markerfacecolor="none", markersize=(utils.MARKERSIZE_CORRECTION.get(marker, 1.0) * base_markersize), color=utils.METHOD_COLOR[method]) title = ("${} = {}$\n${} = {}$" .format(facet_x["symbol"], fct_x, facet_y["symbol"], fct_y)) ax.text(1.0 - 2.65 / width, 0.6, title, color="#505050", horizontalalignment="left", transform=ax.transAxes, fontsize=12) ax.set_xlim(num_shells_range[num_particles]) fig.text(0.5, 0.05 / height, "$K$ (number of shells)", horizontalalignment="center", verticalalignment="bottom", transform=ax.transAxes) fig.text(0.05 / width, 0.5, "${}$".format(utils.ENERGY_SYMBOL[label]), horizontalalignment="left", verticalalignment="center", transform=ax.transAxes, rotation="vertical") # phantom lines to configure the legend markersize = (utils.MARKERSIZE_CORRECTION.get(marker, 1.0) * base_markersize) lines = [matplotlib.lines.Line2D([], [], marker=utils.METHOD_MARKER[method], markersize=markersize, color=utils.METHOD_COLOR[method], label=utils.METHOD_LABEL[method]) for method in methods] if has_dmc: lines.append(matplotlib.lines.Line2D([], [], linestyle=utils.DMC_LINESTYLE, color=utils.METHOD_COLOR["dmc"], label=utils.METHOD_LABEL["dmc"])) ax = fig.add_subplot(gs[LEGEND_FACET_IDX]) ax.axis("off") ax.legend(handles=lines, loc="center", frameon=False, bbox_to_anchor=(0.5, 0.5 - 0.1 / height)) left_margin = 0.1 right_margin = 0.0 top_margin = 0.0 bottom_margin = 0.1 gs.tight_layout(fig, rect=[left_margin / width, bottom_margin / height, 1.0 - right_margin / width, 1.0 - top_margin / height]) utils.savefig(fig, fn=fn)
def overlayFan(myData,myMap,myFig,param,coords='geo',gsct=0,site=None,\ fov=None,gs_flg=[],fill=True,velscl=1000.,dist=1000., cmap=None,norm=None,alpha=1): """A function of overlay radar scan data on a map **Args**: * **myData (:class:`pydarn.sdio.radDataTypes.scanData` or :class:`pydarn.sdio.radDataTypes.beamData` or list of :class:`pydarn.sdio.radDataTypes.beamData` objects)**: a radar beam object, a radar scanData object, or simply a list of radar beams * **myMap**: the map we are plotting on * **[param]**: the parameter we are plotting * **[coords]**: the coordinates we are plotting in * **[param]**: the parameter to be plotted, valid inputs are 'velocity', 'power', 'width', 'elevation', 'phi0'. default = 'velocity * **[gsct]**: a flag indicating whether we are distinguishing ground scatter. default = 0 * **[intensities]**: a list of intensities (used for colorbar) * **[fov]**: a radar fov object * **[gs_flg]**: a list of gs flags, 1 per range gate * **[fill]**: a flag indicating whether to plot filled or point RB cells. default = True * **[velscl]**: the velocity to use as baseline for velocity vector length, only applicable if fill = 0. default = 1000 * **[lines]**: an array to have the endpoints of velocity vectors. only applicable if fill = 0. default = [] * **[dist]**: the length in map projection coords of a velscl length velocity vector. default = 1000. km **OUTPUTS**: NONE **EXAMPLE**: :: overlayFan(aBeam,myMap,param,coords,gsct=gsct,site=sites[i],fov=fovs[i],\ verts=verts,intensities=intensities,gs_flg=gs_flg) Written by AJ 20121004 """ if(site == None): site = pydarn.radar.site(radId=myData[0].stid, dt=myData[0].time) if(fov == None): fov = pydarn.radar.radFov.fov(site=site,rsep=myData[0].prm.rsep,\ ngates=myData[0].prm.nrang+1,nbeams= site.maxbeam,coords=coords) if(isinstance(myData,pydarn.sdio.beamData)): myData = [myData] gs_flg,lines = [],[] if fill: verts,intensities = [],[] else: verts,intensities = [[],[]],[[],[]] #loop through gates with scatter for myBeam in myData: for k in range(0,len(myBeam.fit.slist)): if myBeam.fit.slist[k] not in fov.gates: continue r = myBeam.fit.slist[k] if fill: x1,y1 = myMap(fov.lonFull[myBeam.bmnum,r],fov.latFull[myBeam.bmnum,r]) x2,y2 = myMap(fov.lonFull[myBeam.bmnum,r+1],fov.latFull[myBeam.bmnum,r+1]) x3,y3 = myMap(fov.lonFull[myBeam.bmnum+1,r+1],fov.latFull[myBeam.bmnum+1,r+1]) x4,y4 = myMap(fov.lonFull[myBeam.bmnum+1,r],fov.latFull[myBeam.bmnum+1,r]) #save the polygon vertices verts.append(((x1,y1),(x2,y2),(x3,y3),(x4,y4),(x1,y1))) #save the param to use as a color scale if(param == 'velocity'): intensities.append(myBeam.fit.v[k]) elif(param == 'power'): intensities.append(myBeam.fit.p_l[k]) elif(param == 'width'): intensities.append(myBeam.fit.w_l[k]) elif(param == 'elevation' and myBeam.prm.xcf): intensities.append(myBeam.fit.elv[k]) elif(param == 'phi0' and myBeam.prm.xcf): intensities.append(myBeam.fit.phi0[k]) else: x1,y1 = myMap(fov.lonCenter[myBeam.bmnum,r],fov.latCenter[myBeam.bmnum,r]) verts[0].append(x1) verts[1].append(y1) x2,y2 = myMap(fov.lonCenter[myBeam.bmnum,r+1],fov.latCenter[myBeam.bmnum,r+1]) theta = math.atan2(y2-y1,x2-x1) x2,y2 = x1+myBeam.fit.v[k]/velscl*(-1.0)*math.cos(theta)*dist,y1+myBeam.fit.v[k]/velscl*(-1.0)*math.sin(theta)*dist lines.append(((x1,y1),(x2,y2))) #save the param to use as a color scale if(param == 'velocity'): intensities[0].append(myBeam.fit.v[k]) elif(param == 'power'): intensities[0].append(myBeam.fit.p_l[k]) elif(param == 'width'): intensities[0].append(myBeam.fit.w_l[k]) elif(param == 'elevation' and myBeam.prm.xcf): intensities[0].append(myBeam.fit.elv[k]) elif(param == 'phi0' and myBeam.prm.xcf): intensities[0].append(myBeam.fit.phi0[k]) if(myBeam.fit.p_l[k] > 0): intensities[1].append(myBeam.fit.p_l[k]) else: intensities[1].append(0.) if(gsct): gs_flg.append(myBeam.fit.gflg[k]) #do the actual overlay if(fill): #if we have data if(verts != []): if(gsct == 0): inx = numpy.arange(len(verts)) else: inx = numpy.where(numpy.array(gs_flg)==0) x = PolyCollection(numpy.array(verts)[numpy.where(numpy.array(gs_flg)==1)], facecolors='.3',linewidths=0,zorder=5,alpha=alpha) myFig.gca().add_collection(x, autolim=True) pcoll = PolyCollection(numpy.array(verts)[inx], edgecolors='face',linewidths=0,closed=False,zorder=4, alpha=alpha,cmap=cmap,norm=norm) #set color array to intensities pcoll.set_array(numpy.array(intensities)[inx]) myFig.gca().add_collection(pcoll, autolim=True) return intensities,pcoll else: #if we have data if(verts != [[],[]]): if(gsct == 0): inx = numpy.arange(len(verts[0])) else: inx = numpy.where(numpy.array(gs_flg)==0) #plot the ground scatter as open circles x = myFig.scatter(numpy.array(verts[0])[numpy.where(numpy.array(gs_flg)==1)],\ numpy.array(verts[1])[numpy.where(numpy.array(gs_flg)==1)],\ s=.1*numpy.array(intensities[1])[numpy.where(numpy.array(gs_flg)==1)],\ zorder=5,marker='o',linewidths=.5,facecolors='w',edgecolors='k') myFig.gca().add_collection(x, autolim=True) #plot the i-s as filled circles ccoll = myFig.gca().scatter(numpy.array(verts[0])[inx],numpy.array(verts[1])[inx], \ s=.1*numpy.array(intensities[1])[inx],zorder=10,marker='o',linewidths=.5, \ edgecolors='face',cmap=cmap,norm=norm) #set color array to intensities ccoll.set_array(numpy.array(intensities[0])[inx]) myFig.gca().add_collection(ccoll) #plot the velocity vectors lcoll = LineCollection(numpy.array(lines)[inx],linewidths=.5,zorder=12,cmap=cmap,norm=norm) lcoll.set_array(numpy.array(intensities[0])[inx]) myFig.gca().add_collection(lcoll) return intensities,lcoll
for j in range(0,num_singlets): time[j] = frame_number * time_interval if not x.loc[(x['C1_T Value (frame)'] == (frame_number + 1)) & (x['C1_Image'] == singlets[j]), 'Corrected XY_Distance (um)'].size == 0: dist[j] = x.loc[(x['C1_T Value (frame)'] == (frame_number + 1)) & (x['C1_Image'] == singlets[j]), 'Corrected XY_Distance (um)'] else: dist[j] = np.nan; scat = ax.scatter([time], [dist], marker='o', c='#F4E85A'); x_line = np.full((num_singlets, num_frames), np.nan) y_line = np.full((num_singlets, num_frames), np.nan) lines = [] for j in range(0,num_singlets): lobj = ax.plot([], [], c='#F4EA9D', linewidth=0.75)[0]; lines.append(lobj); def update (frame_number): for j in range(0,num_singlets): time[j] = frame_number * time_interval if not x.loc[(x['C1_T Value (frame)'] == (frame_number + 1)) & (x['C1_Image'] == singlets[j]), 'Corrected XY_Distance (um)'].size == 0: dist[j] = x.loc[(x['C1_T Value (frame)'] == (frame_number + 1)) & (x['C1_Image'] == singlets[j]), 'Corrected XY_Distance (um)']; else: dist[j] = np.nan; if not dist.size == 0: data = np.stack(([time], [dist]), axis=-1) scat.set_offsets(data); x_line[:, frame_number] = time;
def overlayFan(myData, myMap, myFig, param, coords='geo', gsct=0, site=None, fov=None, gs_flg=[], fill=True, velscl=1000., dist=1000., cmap=None, norm=None, alpha=1): """A function of overlay radar scan data on a map Parameters ---------- myData : pydarn.sdio.radDataTypes.scanData or pydarn.sdio.radDataTypes.beamData or list of pydarn.sdio.radDataTypes.beamData objects A radar beam object, a radar scanData object, or simply a list of radar beams myMap : The map we are plotting on myFig : Figure object that we are plotting to coords : Optional[str] The coordinates we are plotting in. Default: geo param : Optional[str] The parameter to be plotted, valid inputs are 'velocity', 'power', 'width', 'elevation', 'phi0'. default = 'velocity gsct : Optional[boolean] A flag indicating whether we are distinguishing ground scatter. default = 0 intensities : Optional[ ] A list of intensities (used for colorbar) fov : Optional[pydarn.radar.radFov.fov] A radar fov object gs_flg : Optional[ ] A list of gs flags, 1 per range gate fill : Optional[boolean] A flag indicating whether to plot filled or point RB cells. default = True velscl : Optional[float] The velocity to use as baseline for velocity vector length, only applicable if fill = 0. default = 1000 lines : Optional[ ] An array to have the endpoints of velocity vectors. only applicable if fill = 0. default = [] dist : Optional [float] The length in map projection coords of a velscl length velocity vector. default = 1000. km Returns ------- intensities pcoll lcoll Example ------- overlayFan(aBeam,myMap,param,coords,gsct=gsct,site=sites[i],fov=fovs[i], verts=verts,intensities=intensities,gs_flg=gs_flg) """ from davitpy import pydarn if(isinstance(myData, pydarn.sdio.beamData)): myData = [myData] if(site is None): site = pydarn.radar.site(radId=myData[0].stid, dt=myData[0].time) if(fov is None): fov = pydarn.radar.radFov.fov(site=site, rsep=myData[0].prm.rsep, ngates=myData[0].prm.nrang + 1, nbeams=site.maxbeam, coords=coords, date_time=myData[0].time) gs_flg, lines = [], [] if fill: verts, intensities = [], [] else: verts, intensities = [[], []], [[], []] # loop through gates with scatter for myBeam in myData: for k in range(0, len(myBeam.fit.slist)): if myBeam.fit.slist[k] not in fov.gates: continue r = myBeam.fit.slist[k] if fill: x1, y1 = myMap(fov.lonFull[myBeam.bmnum, r], fov.latFull[myBeam.bmnum, r]) x2, y2 = myMap(fov.lonFull[myBeam.bmnum, r + 1], fov.latFull[myBeam.bmnum, r + 1]) x3, y3 = myMap(fov.lonFull[myBeam.bmnum + 1, r + 1], fov.latFull[myBeam.bmnum + 1, r + 1]) x4, y4 = myMap(fov.lonFull[myBeam.bmnum + 1, r], fov.latFull[myBeam.bmnum + 1, r]) # save the polygon vertices verts.append(((x1, y1), (x2, y2), (x3, y3), (x4, y4), (x1, y1))) # save the param to use as a color scale if(param == 'velocity'): intensities.append(myBeam.fit.v[k]) elif(param == 'power'): intensities.append(myBeam.fit.p_l[k]) elif(param == 'width'): intensities.append(myBeam.fit.w_l[k]) elif(param == 'elevation' and myBeam.prm.xcf): intensities.append(myBeam.fit.elv[k]) elif(param == 'phi0' and myBeam.prm.xcf): intensities.append(myBeam.fit.phi0[k]) else: x1, y1 = myMap(fov.lonCenter[myBeam.bmnum, r], fov.latCenter[myBeam.bmnum, r]) verts[0].append(x1) verts[1].append(y1) x2, y2 = myMap(fov.lonCenter[myBeam.bmnum, r + 1], fov.latCenter[myBeam.bmnum, r + 1]) theta = math.atan2(y2 - y1, x2 - x1) x2, y2 = x1 + myBeam.fit.v[k] / velscl * (-1.0) * \ math.cos(theta) * dist, y1 + myBeam.fit.v[k] / velscl * \ (-1.0) * math.sin(theta) * dist lines.append(((x1, y1), (x2, y2))) # save the param to use as a color scale if(param == 'velocity'): intensities[0].append(myBeam.fit.v[k]) elif(param == 'power'): intensities[0].append(myBeam.fit.p_l[k]) elif(param == 'width'): intensities[0].append(myBeam.fit.w_l[k]) elif(param == 'elevation' and myBeam.prm.xcf): intensities[0].append(myBeam.fit.elv[k]) elif(param == 'phi0' and myBeam.prm.xcf): intensities[0].append(myBeam.fit.phi0[k]) if(myBeam.fit.p_l[k] > 0): intensities[1].append(myBeam.fit.p_l[k]) else: intensities[1].append(0.) if(gsct): gs_flg.append(myBeam.fit.gflg[k]) # do the actual overlay if(fill): # if we have data if(verts != []): if(gsct == 0): inx = numpy.arange(len(verts)) else: inx = numpy.where(numpy.array(gs_flg) == 0) x = PolyCollection(numpy.array(verts)[numpy.where( numpy.array(gs_flg) == 1)], facecolors='.3', linewidths=0, zorder=5, alpha=alpha) myFig.gca().add_collection(x, autolim=True) pcoll = PolyCollection(numpy.array(verts)[inx], edgecolors='face', linewidths=0, closed=False, zorder=4, alpha=alpha, cmap=cmap, norm=norm) # set color array to intensities pcoll.set_array(numpy.array(intensities)[inx]) myFig.gca().add_collection(pcoll, autolim=True) return intensities, pcoll else: # if we have data if(verts != [[], []]): if(gsct == 0): inx = numpy.arange(len(verts[0])) else: inx = numpy.where(numpy.array(gs_flg) == 0) # plot the ground scatter as open circles x = myFig.scatter(numpy.array(verts[0])[numpy.where( numpy.array(gs_flg) == 1)], numpy.array(verts[1])[numpy.where( numpy.array(gs_flg) == 1)], s=.1 * numpy.array(intensities[1])[ numpy.where(numpy.array(gs_flg) == 1)], zorder=5, marker='o', linewidths=.5, facecolors='w', edgecolors='k') myFig.gca().add_collection(x, autolim=True) # plot the i-s as filled circles ccoll = myFig.gca().scatter(numpy.array(verts[0])[inx], numpy.array(verts[1])[inx], s=.1 * numpy.array( intensities[1])[inx], zorder=10, marker='o', linewidths=.5, edgecolors='face', cmap=cmap, norm=norm) # set color array to intensities ccoll.set_array(numpy.array(intensities[0])[inx]) myFig.gca().add_collection(ccoll) # plot the velocity vectors lcoll = LineCollection(numpy.array(lines)[inx], linewidths=.5, zorder=12, cmap=cmap, norm=norm) lcoll.set_array(numpy.array(intensities[0])[inx]) myFig.gca().add_collection(lcoll) return intensities, lcoll
def createLinesFor3D(self): lines = [] depth_half = self.depthSpin.value() / 2 x_base = self.dragLine.get_xdata() y_base = np.array([0, 0]) z_base = self.dragLine.get_ydata() lines.append([x_base, y_base, z_base]) lines.append([x_base, y_base - depth_half, z_base]) lines.append([x_base, y_base + depth_half, z_base]) lines.append([[x_base[0], x_base[0]], y_base + np.array([-depth_half, depth_half]), [z_base[0], z_base[0]]]) lines.append([[x_base[1], x_base[1]], y_base + np.array([-depth_half, depth_half]), [z_base[1], z_base[1]]]) lines.append([[x_base[1], x_base[1]], y_base + np.array([-depth_half, depth_half]), [z_base[1], z_base[1]]]) return lines
async def graph(self, ctx): """ Creates and sends line graph of data values @param ctx: Discord context @return: None note: note: matplotlib creates x axis if not enough/too little distance from start/end """ dates = [] # dates url = [] # emoji URL lines = [] # graph lines img = [] temp_db = {} legend_counter = 0 MAX_LEGEND_COUNT = 10 MAX_DATES = 5 # last 3 dates for date in self.model.db[ctx.guild.id]: dates.append(date) dates = dates[-MAX_DATES:] # temp_db holds list of date & instance count keyed by emoji ID for date in dates: print(date) for emoji_id in self.model.db[ctx.guild.id][date]: # if emoji not yet processed if emoji_id not in temp_db.keys(): temp_db[emoji_id] = {'date': [], 'count': []} print( emoji_id, ' - ', self.model.db[ctx.guild.id][date][emoji_id].instance_count) temp_db[emoji_id]['count'].append( self.model.db[ctx.guild.id][date][emoji_id].instance_count) temp_db[emoji_id]['date'].append(date) url.append( str(self.model.db[ctx.guild.id][date] [emoji_id].emoji_obj.url)) print() print(temp_db) for emoji, db_content in temp_db.items(): if legend_counter < MAX_LEGEND_COUNT: line, = plt.plot(db_content['date'], db_content['count'], marker='.', label=' - ' + ctx.bot.get_emoji(emoji).name) else: line, = plt.plot(db_content['date'], db_content['count'], marker='.') lines.append(line) legend_counter += 1 # adding images in the legend for i in range(len(url)): async with aiohttp.ClientSession() as session: url_link = url[i] async with session.get(url_link) as resp: if resp.status == 200: f = await aiofiles.open('resources/emoji.png', mode='wb') await f.write(await resp.read()) await f.close() img.append(HandlerLineImage('resources/emoji.png')) legend_obj = dict(zip(lines, img)) plt.legend(handler_map=legend_obj) # legend plt.grid(True) # grid lines plt.title("Time series of emote use in " + ctx.guild.name) # title plt.xticks(ticks=dates) # display only given dates fig = plt.gcf() fig.autofmt_xdate() # might delete plt.show() plt.draw() fig.savefig('resources/graph.png', bbox_inches='tight') await ctx.send(file=discord.File('resources/graph.png'))
def plot_angles(angs, hist, mapargs, color_map='cool', area_mult=1.0, alpha=0.9, hide_zero_marker=False, use_scale=False, label_view=[], **extra): ''' Plot the angular histogram using a map projection from basemap .. note:: Basemap uses longitude latitude conventions, but the given angles are in colatitude, longitude convention. :Parameters: angs : array Array of view angles cnt : array Histogram for each view angle mapargs : dict Arguments specific to a map projection in basemap color_map : str Name of color map area_mult : float Scaling factor for size display alpha : float Transparency factor hide_zero_marker : bool If true, hide the zero projection count marker use_scale : bool If true, then display scale for size and color label_view : list Label each view with text extra : dict Unused keyword arguments ''' cmap = getattr(cm, color_map) m = basemap.Basemap(**mapargs) # Y -> latitude # Z -> longitude #longitude, latitude = 90-colatitude x, y = m(angs[:, 1], 90.0-angs[:, 0]) sel = hist < 1 hist = hist.astype(numpy.float) s = numpy.sqrt(hist)*area_mult nhist = hist.copy() nhist-=nhist.min() nhist/=nhist.max() m.drawparallels(numpy.arange(-90.,120.,30.)) m.drawmeridians(numpy.arange(0.,420.,60.)) im = m.scatter(x, y, s=s, marker="o", c=cmap(nhist), alpha=alpha, edgecolors='none') font_tiny=matplotlib.font_manager.FontProperties() font_tiny.set_size('xx-small') if len(label_view) > 0: for i in label_view: if i > len(angs): _logger.warn("Cannot label view: %d when there are only %d views (skipping)"%(i, len(angs))) continue ytext = -15 if i%2==0 else 15 pylab.annotate('%d: %.1f,%.1f'%(i+1, angs[i, 0], angs[i, 1]), xy=(x[i],y[i]), xycoords='data', xytext=(-15, ytext), textcoords='offset points', arrowprops=dict(arrowstyle="->"), fontproperties =font_tiny ) if numpy.sum(sel) > 0 and not hide_zero_marker: im = m.scatter(x[sel], y[sel], numpy.max(s), marker="x", c=cm.gray(0.5))#@UndefinedVariable if not use_scale: im = matplotlib.cm.ScalarMappable(cmap=cmap, norm=matplotlib.colors.Normalize()) im.set_array(hist) m.colorbar(im, "right", size="3%", pad='1%') else: fontP=matplotlib.font_manager.FontProperties() fontP.set_size('small') inc = len(hist)/10 lines = [] labels = [] idx = numpy.argsort(hist)[::-1] for j in xrange(0, len(hist), inc): i=idx[j] labels.append("%s"%hist[i]) lines.append(matplotlib.lines.Line2D(range(1), range(1), color=cmap(nhist[i]), marker='o', markersize=s[i]/2, linestyle='none', markeredgecolor='white')) if numpy.sum(sel) > 0 and not hide_zero_marker: i=idx[len(idx)-1] labels.append("%s"%hist[i]) lines.append(matplotlib.lines.Line2D(range(1), range(1), color=cm.gray(0.5), marker='x', markersize=numpy.max(s)/5, linestyle='none')) #@UndefinedVariable pylab.legend(tuple(lines),tuple(labels), numpoints=1, frameon=False, loc='center left', bbox_to_anchor=(1, 0.5), prop = fontP)
def autoconfig_processfile2(name, pool_used, f_index, args): try: with open( name ) as result_file: # No need to specify 'r': this is the default.as gates = args.config num_gates = len(gates) nameParts = name.split("/") if len(nameParts) > 1: originalName = nameParts[len(nameParts) - 2] else: if args.name is not None: originalName = args.name + str(f_index) else: originalName = "NoNameSample" + str(f_index) print("Processing ", (originalName)) colorlist = args.colorlist events = sum(1 for line in result_file) - 1 #quickly determine number of events result_file.seek(0) #rewind to the beginning of file header = result_file.readline() header = header.strip() headers = header.split( "\t") #parse the headers from the first line of input headers = [_f for _f in headers if _f] num_markers = len(headers) - 2 # create a numpy array for faster data access if args.debug: print("Assigning data to numpy matrix") print("header length: ", len(headers)) print(headers) print("events count: ", events) fcm = loadNp(result_file, len(headers), events) # find the start of pop info on fcs_results_all if args.flocklegacy is False: pop_offset = 0 for i, header in enumerate(headers): if header == "pop1": pop_offset = i - 1 if args.debug: print("Pop offset: ", pop_offset) axis_popIndexDict = defaultdict(list) print("Configuring axises from gate configuration file") axises = [] composite_axis = 0 last_xmarker = "" last_ymarker = "" last_parent = 0 for pop, config in list(gates.items()): #pop="pop"+str(i+1) #config=gates.get(pop) xmarker = str(headers[config[1] - 1]) ymarker = str(headers[config[2] - 1]) startx = int((float(config[3]) / 200) * 4096) starty = int((float(config[5]) / 200) * 4096) endx = int((float(config[4]) / 200) * 4096) endy = int((float(config[6]) / 200) * 4096) parent = int(config[7]) key = "axis" + str(composite_axis) if (xmarker != last_xmarker) or (ymarker != last_ymarker) or ( parent != last_parent): composite_axis = composite_axis + 1 key = "axis" + str(composite_axis) axises.append([xmarker, ymarker, key]) axis_popIndexDict[key].append(pop) last_xmarker = xmarker last_ymarker = ymarker last_parent = parent num_axises = len(axises) #print "axis_popIndexDict: ", axis_popIndexDict #print axises cols = int(min(num_axises, 4)) rows = int(max(int(math.ceil(num_axises / float(cols))), 1)) print("Iterating through feature pairs") sub_results = [] composite_list = [] if pool_used == 0: inner_pool = Pool(processes=cores) for w, mpair in enumerate(axises): lines = [] dim1 = mpair[0] dim2 = mpair[1] #print dim1, dim2 dim1_idx = 0 dim2_idx = 0 for i, marker in enumerate(headers): if marker == dim1: dim1_idx = i print(("Feature 1: ", marker, i + 1)) if marker == dim2: dim2_idx = i print(("Feature 2: ", marker, i + 1)) header_names = dim1 + "_vs_" + dim2 axis_name = mpair[2] print(header_names, axis_name) if args.flocklegacy is False: fcm[:, -1] = 0 #reset color mapping in np matrix pops = axis_popIndexDict.get(axis_name) if args.debug: print( "iterate through events to find population members" ) poplist_colors = [] for i, pop in enumerate(pops): config = gates.get(pop) found_pop = config[0] xmarker = str(headers[config[1] - 1]) ymarker = str(headers[config[2] - 1]) startx = int((float(config[3]) / 200) * 4096) starty = int((float(config[5]) / 200) * 4096) endx = int((float(config[4]) / 200) * 4096) endy = int((float(config[6]) / 200) * 4096) if i == 0: parent_gate = int(config[7]) cluster_type = int(config[8]) pop_loc = found_pop + pop_offset parent_poploc = parent_gate + pop_offset if (xmarker == dim1) and (ymarker == dim2): if cluster_type == 2: print("slanted") else: lines.append([(startx, endx), (starty, starty), colorlist[i + 2]]) lines.append([(startx, startx), (starty, endy), colorlist[i + 2]]) lines.append([(startx, endx), (endy, endy), colorlist[i + 2]]) lines.append([(endx, endx), (starty, endy), colorlist[i + 2]]) elif (xmarker == dim2) and (ymarker == dim1): if cluster_type == 2: print("slanted") else: lines.append([(starty, endy), (startx, startx), colorlist[i + 2]]) lines.append([(starty, starty), (startx, endx), colorlist[i + 2]]) lines.append([(starty, endy), (endx, endx), colorlist[i + 2]]) lines.append([(endy, endy), (startx, endx), colorlist[i + 2]]) if args.showparent and (config[0] > 1) and i == 0: fcm[:, -1] = (1 - fcm[:, pop_loc]) + ( 1 - fcm[:, parent_poploc]) else: fcm[:, -1] = np.maximum( fcm[:, -1], (1 - fcm[:, pop_loc]) * (i + 2)) if args.debug: print("sorting numpy array") if args.sort: sfcm = fcm[np.argsort( fcm[:, -1] )] #sort the data set based on population number else: sfcm = fcm if args.reversesort: sfcm = sfcm[::-1] print("creating color array") cdata = [] for a in sfcm[:, -1]: try: cdata.append(colorlist[a]) except Exception as err: print("ERROR in index: ", a) sys.stderr.write('Error: %sn' % str(err)) return 1 xdata = sfcm[:, dim1_idx] ydata = sfcm[:, dim2_idx] sample_name = originalName poplist = [] if args.flocklegacy is False: parent_pop_name = "pop" + str(parent_gate) if args.showparent: poplist.append(parent_pop_name) else: poplist.append("") poplist = poplist + pops pop_name = "" if args.showparent: for i, pop in enumerate(poplist): if i > 0: pop_name = pop_name + pop else: for i, pop in enumerate(poplist): pop_name = pop_name + pop else: pop_name = "FLOCK" png_file = sample_name + "_" + header_names + "_" + pop_name + ".png" if pool_used == 0: inner_pool.apply_async(plotfig, args=[ sample_name, xdata, ydata, cdata, dim1, dim2, poplist, lines, args ]) else: png_file = plotfig(sample_name, xdata, ydata, cdata, dim1, dim2, poplist, lines, args) sub_results.append([axis_name, [sample_name, png_file]]) composite_list.append([axis_name, png_file]) if pool_used == 0: inner_pool.close() inner_pool.join() if args.gatescomposite: print( "Number of rows and columns for the composite plots (gates): ", rows, cols) compose_from_fig(composite_list, rows, cols, num_axises, sample_name, " ", " ", 0, args) return sub_results except IOError as exc: if exc.errno != errno.EISDIR: # Do not fail if a directory is found, just ignore it. raise # Propagate other kinds of IOError.args except Exception as e: print("Exception: %s" % str(e), file=sys.stderr) raise Exception("".join(traceback.format_exception(*sys.exc_info())))
def processfile(name, pool_used, f_index, args): try: with open( name ) as result_file: # No need to specify 'r': this is the default.as gates = args.config if (gates is not None): num_gates = len(gates) nameParts = name.split("/") if args.name is not None: originalName = args.name + str(f_index) elif (args.flocklegacy is True): originalName = nameParts[len(nameParts) - 1] else: if len(nameParts) > 1: originalName = nameParts[len(nameParts) - 2] else: originalName = "NoNameSample" + str(f_index) print("Processing ", (originalName)) # retrieve command line options from args colorlist = args.colorlist mpairs = args.markers events = sum(1 for line in result_file) - 1 #quickly determine number of events result_file.seek(0) #rewind file to beginning header = result_file.readline() header = header.strip() headers = header.split("\t") markers = headers num_markers = len(headers) - 2 if ((args.markers is None) and (args.flocklegacy is True)): mpairs = list(itertools.permutations(markers[:-2], 2)) num_pairs = len(mpairs) # # create a numpy array # fcm = loadNp(result_file, len(headers), events) # # Check legacy FLOCK or new DAFI results # pops = args.listofpop if args.flocklegacy is False: pop2DList = [[i, j] for i, j in enumerate(pops)] # locate position of the specified populations in the input file columns for i, marker in enumerate(markers): for j, k in enumerate(pops): if marker == k: pop2DList[j][0] = i # create a dictionary for quick population order lookup plist = [int(x[0]) for x in pop2DList] pop2DIndex = set(plist) pdict = {e: (plist.index(e) + 1) for e in plist} pdict.update({0: 0}) # find the start of pop info on fcs_results_all pop_offset = 0 for i, header in enumerate(headers): if header == "pop1": pop_offset = i - 1 if args.debug: print("Pop offset: ", pop_offset) if args.debug: print(("Events: ", events)) if args.debug: print(("Number of Markers: ", num_markers)) fcm[:, -1] = 0 for i, popIndex in enumerate(pop2DIndex): print(i, popIndex) fcm[:, -1] = np.maximum(fcm[:, -1], (1 - fcm[:, popIndex]) * (popIndex)) # Sort the matrix data based on the population column (last column) if args.sort: sfcm = fcm[np.argsort( fcm[:, -1])] #sort the data set based on population number else: sfcm = fcm if args.reversesort: sfcm = sfcm[::-1] #generate color array from sorted numpy matrix colors = [] for a in sfcm[:, -1]: if args.flocklegacy: colors.append(colorlist[a]) else: colors.append(colorlist[pdict[a]]) #calculate cols and rows for composite plot cols = int(min(num_pairs, 4)) rows = int(max(int(math.ceil(num_pairs / float(cols))), 1)) sub_results = [] composite_list = [] #iterate through all 2D dot plot pairs specified for w, mpair in enumerate(mpairs): dim1 = mpair[0] dim2 = mpair[1] if args.debug: print(dim1, dim2) dim1_idx = 0 dim2_idx = 0 lines = [] if ((gates is not None) and (pops is not None)): for i, pop in enumerate(pops): config = gates.get(pop) xmarker = str(headers[config[1] - 1]) ymarker = str(headers[config[2] - 1]) startx = int((float(config[3]) / 200) * 4096) starty = int((float(config[5]) / 200) * 4096) endx = int((float(config[4]) / 200) * 4096) endy = int((float(config[6]) / 200) * 4096) parent_gate = int(config[7]) cluster_type = int(config[8]) if (xmarker == dim1) and (ymarker == dim2): if cluster_type == 2: print("slanted") else: lines.append([ (startx, endx), (starty, starty), colorlist[pdict[config[0] + pop_offset]] ]) lines.append([ (startx, startx), (starty, endy), colorlist[pdict[config[0] + pop_offset]] ]) lines.append([ (startx, endx), (endy, endy), colorlist[pdict[config[0] + pop_offset]] ]) lines.append([ (endx, endx), (starty, endy), colorlist[pdict[config[0] + pop_offset]] ]) elif (xmarker == dim2) and (ymarker == dim1): if cluster_type == 2: print("slanted") else: lines.append([ (starty, endy), (startx, startx), colorlist[pdict[config[0] + pop_offset]] ]) lines.append([ (starty, starty), (startx, endx), colorlist[pdict[config[0] + pop_offset]] ]) lines.append([ (starty, endy), (endx, endx), colorlist[pdict[config[0] + pop_offset]] ]) lines.append([ (endy, endy), (startx, endx), colorlist[pdict[config[0] + pop_offset]] ]) for i, marker in enumerate(markers): if marker == dim1: dim1_idx = i print(("Feature 1: ", marker, i)) if marker == dim2: dim2_idx = i print(("Feature 2: ", marker, i)) xdata = sfcm[:, dim1_idx] ydata = sfcm[:, dim2_idx] cdata = colors header_names = dim1 + "_vs_" + dim2 sample_name = originalName if args.flocklegacy is False: pop_name = "" if args.showparent: for i, pop in enumerate(pops): if i > 0: pop_name = pop_name + pop else: for i, pop in enumerate(pops): pop_name = pop_name + pop png_file = plotfig(sample_name, xdata, ydata, cdata, dim1, dim2, pops, lines, args) print(png_file) sub_results.append([header_names, [sample_name, png_file]]) composite_list.append([header_names, png_file]) if args.pairscomposite: print( "Number of rows and columns for the composite plots (markers): ", rows, cols) print(composite_list) compose_from_fig(composite_list, rows, cols, num_pairs, sample_name, " ", " ", 0, args) return sub_results except IOError as exc: if exc.errno != errno.EISDIR: # Do not fail if a directory is found, just ignore it. raise # Propagate other kinds of IOError.args except: raise Exception("".join(traceback.format_exception(*sys.exc_info())))
def do_plot(plotfile1, plotfile2, plotfile3, component, outFile, log, minval, maxval, ncontours, eps, dpi, xmin, xmax, ymin, ymax, label1, label2, label3): #-------------------------------------------------------------------------- # construct the output file name #-------------------------------------------------------------------------- if (outFile == ""): outFile = "compare_" + component if (not eps): outFile += ".png" else: outFile += ".eps" else: # make sure the proper extension is used if (not eps): if (not string.rfind(outFile, ".png") > 0): outFile = outFile + ".png" else: if (not string.rfind(outFile, ".eps") > 0): outFile = outFile + ".eps" #-------------------------------------------------------------------------- # read in the data from plotfile1 #-------------------------------------------------------------------------- (nx, ny, nz) = fsnapshot.fplotfile_get_size(plotfile1) time = fsnapshot.fplotfile_get_time(plotfile1) (xmin1, xmax1, ymin1, ymax1, zmin1, zmax1) = \ fsnapshot.fplotfile_get_limits(plotfile1) x1 = xmin1 + numpy.arange( (nx), dtype=numpy.float64 )*(xmax1 - xmin1)/nx y1 = ymin1 + numpy.arange( (ny), dtype=numpy.float64 )*(ymax1 - ymin1)/ny if (not nz == -1): print "ERROR: 2-d support only" sys.exit(2) # read in the main component data1 = numpy.zeros( (nx, ny), dtype=numpy.float64) (data1, err) = fsnapshot.fplotfile_get_data_2d(plotfile1, component, data1) if (not err == 0): sys.exit(2) data1 = numpy.transpose(data1) if log: data1 = numpy.log10(data1) extent1 = [xmin1, xmax1, ymin1, ymax1] #-------------------------------------------------------------------------- # read in the data from plotfile2 #-------------------------------------------------------------------------- (nx, ny, nz) = fsnapshot.fplotfile_get_size(plotfile2) time = fsnapshot.fplotfile_get_time(plotfile2) (xmin2, xmax2, ymin2, ymax2, zmin2, zmax2) = \ fsnapshot.fplotfile_get_limits(plotfile2) x2 = xmin2 + numpy.arange( (nx), dtype=numpy.float64 )*(xmax2 - xmin2)/nx y2 = ymin2 + numpy.arange( (ny), dtype=numpy.float64 )*(ymax2 - ymin2)/ny if (not nz == -1): print "ERROR: 2-d support only" sys.exit(2) # read in the main component data2 = numpy.zeros( (nx, ny), dtype=numpy.float64) (data2, err) = fsnapshot.fplotfile_get_data_2d(plotfile2, component, data2) if (not err == 0): sys.exit(2) data2 = numpy.transpose(data2) if log: data2 = numpy.log10(data2) extent2 = [xmin2, xmax2, ymin2, ymax2] #-------------------------------------------------------------------------- # read in the data from plotfile3 -- if present #-------------------------------------------------------------------------- if (not plotfile3 == ""): (nx, ny, nz) = fsnapshot.fplotfile_get_size(plotfile3) time = fsnapshot.fplotfile_get_time(plotfile3) (xmin3, xmax3, ymin3, ymax3, zmin3, zmax3) = \ fsnapshot.fplotfile_get_limits(plotfile3) x3 = xmin3 + numpy.arange( (nx), dtype=numpy.float64 )*(xmax3 - xmin3)/nx y3 = ymin3 + numpy.arange( (ny), dtype=numpy.float64 )*(ymax3 - ymin3)/ny if (not nz == -1): print "ERROR: 2-d support only" sys.exit(2) # read in the main component data3 = numpy.zeros( (nx, ny), dtype=numpy.float64) (data3, err) = fsnapshot.fplotfile_get_data_2d(plotfile3, component, data3) if (not err == 0): sys.exit(2) data3 = numpy.transpose(data3) if log: data3 = numpy.log10(data3) extent3 = [xmin3, xmax3, ymin3, ymax3] #-------------------------------------------------------------------------- # find data limits, etc. #-------------------------------------------------------------------------- if (not extent1 == extent2): print "ERROR: extent of domains do not agree" sys.exit(2) if (not plotfile3 == ""): if (not extent1 == extent3): print "ERROR: extent of domains do not agree" sys.exit(2) extent = extent1 if (not xmin == None): extent[0] = xmin if (not xmax == None): extent[1] = xmax if (not ymin == None): extent[2] = ymin if (not ymax == None): extent[3] = ymax if (minval == None): minval = min(numpy.min(data1), numpy.min(data2)) if (not plotfile3 == ""): minval = min(minval, numpy.min(data3)) if (maxval == None): maxval = max(numpy.max(data1), numpy.max(data2)) if (not plotfile3 == ""): maxval = max(maxval, numpy.max(data3)) levels = numpy.linspace(minval, maxval, ncontours, endpoint=True) #-------------------------------------------------------------------------- # make the figure #-------------------------------------------------------------------------- cs1 = pylab.contour(x1, y1, data1, ncontours, colors='k', levels=levels) cs2 = pylab.contour(x2, y2, data2, ncontours, colors='r', levels=levels) if (not plotfile3 == ""): cs3 = pylab.contour(x3, y3, data3, ncontours, colors='g', levels=levels) # make the labels -- see http://www.scipy.org/Cookbook/Matplotlib/Legend # for this technique lines = [] labels = [] if (not label1 == None): line1 = matplotlib.lines.Line2D(range(10), range(10), linestyle='-', color='k') lines.append(line1) labels.append(label1) if (not label2 == None): line2 = matplotlib.lines.Line2D(range(10), range(10), linestyle='-', color='r') lines.append(line2) labels.append(label2) if (not label3 == None): line3 = matplotlib.lines.Line2D(range(10), range(10), linestyle='-', color='g') lines.append(line3) labels.append(label3) pylab.legend(lines, labels, fontsize="small", frameon=False) formatter = matplotlib.ticker.ScalarFormatter(useMathText=True) #pylab.clabel(cs, fontsize=9, inline=1)#, fmt=formatter) pylab.axis(extent) ax = pylab.gca() ax.set_aspect("equal") fig1 = ax.get_figure() ax.xaxis.set_major_formatter(pylab.ScalarFormatter(useMathText=True)) ax.yaxis.set_major_formatter(pylab.ScalarFormatter(useMathText=True)) pylab.xlabel("x") pylab.ylabel("y") if (not eps): pylab.savefig(outFile, bbox_inches='tight', dpi=dpi, pad_inches=0.5) else: pylab.savefig(outFile, bbox_inches='tight', pad_inches=0.5)
def plotWaterfall(self): while True: # from matplotlib gallery # Fixing random state for reproducibility np.random.seed(19680801) # Create new Figure with black background fig = plt.figure(figsize=(8, 8), facecolor='black') # Add a subplot with no frame ax = plt.subplot(111, frameon=False) # Generate random data data = np.random.uniform(0, 1, (5, 400)) X = np.linspace(-1, 1, data.shape[-1]) # Generate line plots lines = [] colors = ['w', 'g', 'r', 'b', 'm'] labels = [ 'chan 174', 'chan 172', 'chan 168', 'chan 246', 'chan 247' ] for i in range(len(data)): # Small reduction of the X extents to get a cheap perspective effect xscale = 1 - i / 400. # Same for linewidth (thicker strokes on bottom) lw = 1.5 - i / 100.0 line, = ax.plot(xscale * X, i + data[i], color=colors[i], label=labels[i], lw=lw) ax.legend() lines.append(line) # Set y limit (or first line is cropped because of thickness) ax.set_ylim(-1, 400) # No ticks ax.set_xticks([]) ax.set_yticks([]) # 2 part titles to get different font weights #ax.text(0.5, 1.0, "KIDPY ", transform=ax.transAxes, # ha="right", va="bottom", color="w", # family="sans-serif", fontweight="light", fontsize=16) #ax.text(0.5, 1.0, "JOYDIVISION MODE", transform=ax.transAxes, # ha="left", va="bottom", color="w", # family="sans-serif", fontweight="bold", fontsize=16) def new_data(self, data): data_row = np.random.uniform(0, 1, len(data)) self.fpga.write_int( self.regs[np.where( self.regs == 'fft_snap_ctrl_reg')[0][0]][1], 0) self.fpga.write_int( self.regs[np.where( self.regs == 'fft_snap_ctrl_reg')[0][0]][1], 1) fft_snap = (np.fromstring(self.fpga.read( self.regs[np.where( self.regs == 'fft_snap_bram_reg')[0][0]][1], (2**9) * 8), dtype='>i2')).astype('float') I0 = fft_snap[0::4] Q0 = fft_snap[1::4] I1 = fft_snap[2::4] Q1 = fft_snap[3::4] mag0 = np.sqrt(I0**2 + Q0**2) #mag0 = 20*np.log10(mag0) mag1 = np.sqrt(I1**2 + Q1**2) mags = np.hstack(zip(mag0, mag1)) #mag1 = 20*np.log10(mag1) fft_mags = np.hstack(zip(mag0, mag1)) channels = fft_mags[174] # definitely chan 174, 245-6 channels = np.append(channels, fft_mags[172]) channels = np.append(channels, fft_mags[168]) channels = np.append(channels, fft_mags[246]) channels = np.append(channels, fft_mags[247]) return channels def update(*args): # Shift all data to the right data[:, 1:] = data[:, :-1] # Fill-in new values #data[:, 0] = np.random.uniform(0, 1, len(data)) data[:, 0] = new_data(self, data) # Update data for i in range(len(data)): lines[i].set_ydata(i + data[i]) # Return modified artists return lines # Construct the animation, using the update function as the animation # director. anim = animation.FuncAnimation(fig, update, interval=10) plt.show() #n = n+1 return
def do_plot(plotfile, component1, component2, outFile, minval1, maxval1, minval2, maxval2, ncontours, eps, dpi, xmin, xmax, ymin, ymax, label1, label2): print minval1, maxval1, minval2, maxval2 #-------------------------------------------------------------------------- # construct the output file name #-------------------------------------------------------------------------- if (outFile == ""): outFile = "compare_" + component1 + "_" + component2 if (not eps): outFile += ".png" else: outFile += ".eps" else: # make sure the proper extension is used if (not eps): if (not string.rfind(outFile, ".png") > 0): outFile = outFile + ".png" else: if (not string.rfind(outFile, ".eps") > 0): outFile = outFile + ".eps" #-------------------------------------------------------------------------- # read in the data from the plotfile #-------------------------------------------------------------------------- (nx, ny, nz) = fsnapshot.fplotfile_get_size(plotfile) time = fsnapshot.fplotfile_get_time(plotfile) (xmin, xmax, ymin, ymax, zmin, zmax) = \ fsnapshot.fplotfile_get_limits(plotfile) x = xmin + numpy.arange((nx), dtype=numpy.float64) * (xmax - xmin) / nx y = ymin + numpy.arange((ny), dtype=numpy.float64) * (ymax - ymin) / ny if (not nz == -1): print "ERROR: 2-d support only" sys.exit(2) # read in the first components data1 = numpy.zeros((nx, ny), dtype=numpy.float64) (data1, err1) = fsnapshot.fplotfile_get_data_2d(plotfile, component1, data1) data2 = numpy.zeros((nx, ny), dtype=numpy.float64) (data2, err2) = fsnapshot.fplotfile_get_data_2d(plotfile, component2, data2) if not err1 == 0 and err2 == 0: sys.exit(2) data1 = numpy.transpose(data1) data2 = numpy.transpose(data2) extent = [xmin, xmax, ymin, ymax] #-------------------------------------------------------------------------- # find data limits, etc. #-------------------------------------------------------------------------- if (not xmin == None): extent[0] = xmin if (not xmax == None): extent[1] = xmax if (not ymin == None): extent[2] = ymin if (not ymax == None): extent[3] = ymax if (minval1 == None): minval1 = numpy.min(data1) if (maxval1 == None): maxval1 = numpy.max(data1) if (minval2 == None): minval2 = numpy.min(data2) if (maxval2 == None): maxval2 = numpy.max(data2) levels1 = numpy.linspace(minval1, maxval1, ncontours, endpoint=True) levels2 = numpy.linspace(minval2, maxval2, ncontours, endpoint=True) print levels1 #-------------------------------------------------------------------------- # make the figure #-------------------------------------------------------------------------- cs1 = pylab.contour(x, y, data1, ncontours, colors='b', levels=levels1) cs2 = pylab.contour(x, y, data2, ncontours, colors='r', levels=levels2) # make the labels -- see http://www.scipy.org/Cookbook/Matplotlib/Legend # for this technique lines = [] labels = [] if (not label1 == None): line1 = matplotlib.lines.Line2D(range(10), range(10), linestyle='-', color='b') lines.append(line1) labels.append(label1) if (not label2 == None): line2 = matplotlib.lines.Line2D(range(10), range(10), linestyle='-', color='r') lines.append(line2) labels.append(label2) pylab.legend(lines, labels) formatter = matplotlib.ticker.ScalarFormatter(useMathText=True) #pylab.clabel(cs, fontsize=9, inline=1)#, fmt=formatter) pylab.axis(extent) ax = pylab.gca() ax.set_aspect("equal") fig1 = ax.get_figure() ax.xaxis.set_major_formatter(pylab.ScalarFormatter(useMathText=True)) ax.yaxis.set_major_formatter(pylab.ScalarFormatter(useMathText=True)) pylab.xlabel("x") pylab.ylabel("y") if (not eps): pylab.savefig(outFile, bbox_inches='tight', dpi=dpi, pad_inches=0.5) else: pylab.savefig(outFile, bbox_inches='tight', pad_inches=0.5)
def do_plot(plotfile1, plotfile2, plotfile3, component, outFile, minval, maxval, color1, color2, color3, ncontours, eps, dpi, xmin, xmax, ymin, ymax, label1, label2, label3): #-------------------------------------------------------------------------- # construct the output file name #-------------------------------------------------------------------------- if (outFile == ""): outFile = "compare_" + component if (not eps): outFile += ".png" else: outFile += ".eps" else: # make sure the proper extension is used if (not eps): if (not string.rfind(outFile, ".png") > 0): outFile = outFile + ".png" else: if (not string.rfind(outFile, ".eps") > 0): outFile = outFile + ".eps" #-------------------------------------------------------------------------- # read in the data from the plotfiles #-------------------------------------------------------------------------- (nx1, ny1, nz1) = fsnapshot.fplotfile_get_size(plotfile1) time = fsnapshot.fplotfile_get_time(plotfile1) (xmin1, xmax1, ymin1, ymax1, zmin1, zmax1) = \ fsnapshot.fplotfile_get_limits(plotfile1) if (not nz1 == -1): print "ERROR: 2-d support only" sys.exit(2) (nx2, ny2, nz2) = fsnapshot.fplotfile_get_size(plotfile2) time = fsnapshot.fplotfile_get_time(plotfile2) (xmin2, xmax2, ymin2, ymax2, zmin2, zmax2) = \ fsnapshot.fplotfile_get_limits(plotfile2) if not (nx1 == nx2 and ny1 == ny2 and xmin1 == xmin2 and xmax1 == xmax2 and ymin1 == ymin2 and ymax1 == ymax2): sys.exit("ERROR: grids don't match") if not plotfile3 == None: (nx3, ny3, nz3) = fsnapshot.fplotfile_get_size(plotfile3) time = fsnapshot.fplotfile_get_time(plotfile3) (xmin3, xmax3, ymin3, ymax3, zmin3, zmax3) = \ fsnapshot.fplotfile_get_limits(plotfile3) if not (nx1 == nx3 and ny1 == ny3 and xmin1 == xmin3 and xmax1 == xmax3 and ymin1 == ymin3 and ymax1 == ymax3): sys.exit("ERROR: grids don't match") x = xmin1 + numpy.arange( (nx1), dtype=numpy.float64) * (xmax1 - xmin1) / nx1 y = ymin1 + numpy.arange( (ny1), dtype=numpy.float64) * (ymax1 - ymin1) / ny1 # read in the components data1 = numpy.zeros((nx1, ny1), dtype=numpy.float64) (data1, err1) = fsnapshot.fplotfile_get_data_2d(plotfile1, component, data1) data2 = numpy.zeros((nx2, ny2), dtype=numpy.float64) (data2, err2) = fsnapshot.fplotfile_get_data_2d(plotfile2, component, data2) if not err1 == 0 and err2 == 0: sys.exit("ERRORS while reading data") data1 = numpy.transpose(data1) data2 = numpy.transpose(data2) if not plotfile3 == None: data3 = numpy.zeros((nx3, ny3), dtype=numpy.float64) (data3, err3) = fsnapshot.fplotfile_get_data_2d(plotfile3, component, data3) if not err3 == 0: sys.exit("ERRORS while reading data") data3 = numpy.transpose(data3) extent = [xmin1, xmax1, ymin1, ymax1] #-------------------------------------------------------------------------- # find data limits, etc. #-------------------------------------------------------------------------- if (not xmin == None): extent[0] = xmin if (not xmax == None): extent[1] = xmax if (not ymin == None): extent[2] = ymin if (not ymax == None): extent[3] = ymax if (minval == None): minval = min(numpy.min(data1), numpy.min(data2)) if (maxval == None): maxval = max(numpy.max(data1), numpy.max(data2)) if not plotfile3 == None: if (minval == None): minval = min(minval, numpy.min(data3)) if (maxval == None): maxval = max(maxval, numpy.max(data3)) levels = numpy.linspace(minval, maxval, ncontours, endpoint=True) #-------------------------------------------------------------------------- # make the figure #-------------------------------------------------------------------------- # left half of data1 xx = numpy.array(x[0:nx1 / 2 + 1]) yy = numpy.array(y) dd = numpy.array(data1[:, 0:nx1 / 2 + 1]) cs1 = pylab.contour(xx, yy, dd, ncontours, colors=color1, levels=levels) xx = numpy.array(x[nx2 / 2:]) yy = numpy.array(y) dd = numpy.array(data2[:, nx2 / 2:]) cs2 = pylab.contour(xx, yy, dd, ncontours, colors=color2, levels=levels) if not plotfile3 == None: xx = numpy.array(x[0:nx1 / 2 + 1]) yy = numpy.array(y) dd = numpy.array(data3[:, 0:nx1 / 2 + 1]) cs3 = pylab.contour(xx, yy, dd, ncontours, colors=color3, levels=levels) # make the labels -- see http://www.scipy.org/Cookbook/Matplotlib/Legend # for this technique lines = [] labels = [] if (not label1 == None): line1 = matplotlib.lines.Line2D(range(10), range(10), linestyle='-', color=color1) lines.append(line1) labels.append(label1) if (not label2 == None): line2 = matplotlib.lines.Line2D(range(10), range(10), linestyle='-', color=color2) lines.append(line2) labels.append(label2) if not plotfile3 == None: if (not label3 == None): line3 = matplotlib.lines.Line2D(range(10), range(10), linestyle='-', color=color3) lines.append(line3) labels.append(label3) pylab.legend(lines, labels) formatter = matplotlib.ticker.ScalarFormatter(useMathText=True) #pylab.clabel(cs, fontsize=9, inline=1)#, fmt=formatter) pylab.axis(extent) ax = pylab.gca() ax.set_aspect("equal") fig1 = ax.get_figure() ax.xaxis.set_major_formatter(pylab.ScalarFormatter(useMathText=True)) ax.yaxis.set_major_formatter(pylab.ScalarFormatter(useMathText=True)) pylab.xlabel("x") pylab.ylabel("y") if (not eps): pylab.savefig(outFile, bbox_inches='tight', dpi=dpi, pad_inches=0.5) else: pylab.savefig(outFile, bbox_inches='tight', pad_inches=0.5)
bbox_transform = plt.gcf().transFigure) fig.suptitle('CTRNN trace comparison between evolved and target networks',fontsize=20) fig.tight_layout() plt.subplots_adjust(top=0.85,bottom=0.1) plt.show() # And here are the network's responses to a $sin(t/25)$ wave: # In[114]: fig,ax = plt.subplots(figsize=(9,6)) lines = [] lines.append(ax.plot(fixedStd['0:200'][0]['neur1'],linewidth=4, label='target')[0]) for key in sortedKeys: lines.append(ax.plot(ctrnnStd[key][0]['neur1'],linewidth=3,linestyle='--',label=key)[0]) plt.ylabel('Output') plt.xlabel('Time') inputAx = ax.twinx() line5=inputAx.plot(fixedStd['0:200'][0]['input0'],color='gray',linestyle=':',label='input',linewidth=3) labs= [line.get_label() for line in lines] legend = ax.legend(lines,labs,loc="lower right") legend.set_frame_on(True) legend.get_frame().set_facecolor('#EEEEEE') legend.get_frame().set_edgecolor('grey')