def make_plot(prefix='wp', show_plot=True, polygon_sides=3, rotation_rho=10, spirality_sigma=20, N=10, glue_tab=False, cut_tip=True, cut_bottom_func=None, angle_offsets=None): fig, ax = plt.subplots() name = '{}_poly{}_rho{}_sig{}_N{}'.format(prefix, polygon_sides, int(rotation_rho), int(spirality_sigma), N) exterior_base = 90.0 + rotation_rho / 2.0 poly = wp_angles() poly.beta = 360.0 / polygon_sides poly.alpha = (180.0 - poly.beta) / 2.0 poly.gamma = 2.0 * poly.alpha basic = wp_angles() basic.beta = exterior_base - poly.alpha basic.alpha = spirality_sigma basic.gamma = 180.0 - basic.alpha - basic.beta print(basic.alpha, basic.beta, basic.gamma) #FIXME: Check validity # standard whirlpool if angle_offsets is None: original_angle_offsets = [ rotation_rho * x for x in list(range(polygon_sides)) ] angle_offsets = [rotation_rho * x for x in list(range(polygon_sides))] ac_len = 10.0 row_origin = [0.0, 0.0] rows = [] triangles = [] for layer in range(N): # create a basic triangle of ac_len with angles given path = make_basic_triangle_path(row_origin, ac_len, basic) print(path.vertices) color = ["red", "green", "blue", "orange", "yellow", "cyan"] start = row_origin row = [] for n in range(polygon_sides): r = mpl.transforms.Affine2D().rotate_deg_around( path.vertices[0][0], path.vertices[0][1], -angle_offsets[n]) path = path.transformed(r) # put triangle in position at the angle_offset and position row.append(path) print(color[n]) print(path) path = make_basic_triangle_path(origin=path.vertices[2], ac_len=ac_len, basic=basic) # end poly for rows.append(row) # big matrix of paths so we can make a cut path # Calculate angle offsets then move row_origin ac_len = distance(row[0].vertices[1], row[1].vertices[1]) angoff = atan_deg(row[0].vertices[1], row[1].vertices[1]) - original_angle_offsets[1] for n in range(polygon_sides): angle_offsets[n] = original_angle_offsets[n] + angoff b = point(row[0].vertices[1][0], row[0].vertices[1][1]) a = b.pointFrom(-ac_len, angoff) row_origin = [a.x, a.y] print(row_origin, ac_len) print(angle_offsets) # end for each layer of triangles # make an outline for cutting, use cut_tip and cut_bottom to control it cut_vertices = [] for r in rows: # start at 0,0 and go clockwise, adding each A point in the column cut_vertices.append(r[0].vertices[0]) if cut_tip: path = rows[-1][0] pta = path.vertices[0] ptb = path.vertices[1] ab_mid = (pta + ptb) / 2.0 rot = mpl.transforms.Affine2D().rotate_deg_around( ab_mid[0], ab_mid[1], 180.0) v = path.transformed(rot).vertices[2] cut_vertices.append(v) for n in range( polygon_sides): # add B points of the top (smallest) row cut_vertices.append(rows[-1][n].vertices[1]) # else calculate the meeting point and use that # Fixme: add that # calculate the tip point, rho angle and then isoceles triangle # will need the vertical scores to tip point, ok to aappend a row to rows # add tip point to cut_vertices # add B point of the last triangle rows[-1][-1] for i in range(N): # back down the column using the C points on this side cut_vertices.append(rows[-(i + 1)][-1].vertices[2]) if cut_bottom_func is None: for n in range( polygon_sides): # along the wide bottom until back to start cut_vertices.append(rows[0][-(n + 1)].vertices[0]) cut_path = Path(cut_vertices) patch = patches.PathPatch(cut_path, facecolor='k', alpha=0.05, edgecolor='k') ax.add_patch(patch) # add all the trangles to the plot for r in rows: for n in range(polygon_sides): patch = patches.PathPatch(r[n], facecolor=color[n], alpha=0.75, edgecolor='k') ax.add_patch(patch) plt.axis('off') plt.box(False) ax.set_aspect(1), ax.autoscale() plt.savefig(name + ".svg") if show_plot: plt.title(name), plt.show()
fig = plt.figure() ax = fig.add_subplot(111) pathdata = [ (Path.MOVETO, (1.58, -2.57)), (Path.CURVE4, (0.35, -1.1)), (Path.CURVE4, (-1.75, 2.0)), (Path.CURVE4, (0.375, 2.0)), (Path.CURVE4, (2.2, 3.2)), (Path.CURVE4, (3, 0.05)), (Path.CURVE4, (2.0, -0.5)), ] codes, verts = list(zip(*pathdata)) path = mpath.Path(verts, codes) patch = mpatches.PathPatch(path, facecolor='green', edgecolor='red', alpha=0.5, fill=False) ax.add_patch(patch) class PathInteractor: """ An path editor. Key-bindings 't' toggle vertex markers on and off. When vertex markers are on, you can move them, delete them """
def render(self, mode='human', close=False): #fig, ax = plt.subplots(1, 1, figsize=(10, 10)) #x_axis = [x[0] for x in self.ue_path] #y_axis = [x[1] for x in self.ue_path] #z_axis = self.ue_path_rates #plt.plot(x_axis, y_axis) #plt.show() from matplotlib.path import Path import matplotlib.patches as patches verts = [(int(x[0]), int(x[1])) for x in self.ue_path] #print(self.ue_path) #print(verts) codes = [Path.LINETO for x in range(len(verts))] codes[0] = Path.MOVETO codes[-1] = Path.STOP path = Path(verts, codes) fig = plt.figure(figsize=(10, 10)) ax = fig.add_subplot(111) patch = patches.PathPatch(path, facecolor='none', lw=2) ax.add_patch(patch) xs, ys = zip(*verts) ax.plot(xs, ys, 'x--', lw=2, color='black') #xdisplay, ydisplay = ax.transData.transform_point((self.ue_xsrc, self.ue_ysrc)) bbox = dict(boxstyle="round", fc="0.8") arrowprops = dict(arrowstyle="->", connectionstyle="angle,angleA=0,angleB=90,rad=10") offset = 40 ax.annotate('Src = (%d, %d)' % (self.ue_xsrc, self.ue_ysrc), (self.ue_xsrc, self.ue_ysrc), xytext=(-2 * offset, offset), textcoords='offset points', bbox=bbox, arrowprops=arrowprops) ax.annotate('Dest = (%d, %d)' % (self.ue_xdest[0], self.ue_ydest[0]), (self.ue_xdest[0], self.ue_ydest[0]), xytext=(0.5 * offset, -offset), textcoords='offset points', bbox=bbox, arrowprops=arrowprops) offset = 10 bbox = dict(boxstyle="round", facecolor='yellow', edgecolor='none') for i in range(0, len(self.ue_path_rates)): ax.annotate('%.2f' % np.around(self.ue_path_rates[i], decimals=2), (verts[i][0], verts[i][1]), xytext=(-2 * offset, offset), textcoords='offset points', bbox=bbox, arrowprops=arrowprops) ax.grid() ax.set_xticks(self.ue_xloc) ax.set_yticks(self.ue_yloc) ax.set_title("UAV graph w.r.t gNB [0,0,0]") ax.set_xlabel("X direction") ax.set_ylabel("Y direction") plt.show() return
def mps_cc(subject, pathdict, plot=True, verbose=True): # Find location of peaks within a single-component radio source via contour counting contours = get_contours(subject, pathdict) lobe = contours['contours'][0] xmax, ymax, xmin, ymin = lobe[0]['bbox'] parr = [] valarr = [] for cl in lobe: parr.extend([(p['x'], p['y']) for p in cl['arr']]) valarr.extend(np.ones(len(cl['arr'])) + cl['level']) points = np.array([(px, py) for px, py in parr]) values = np.array(valarr) # Find levels with multiple contours # For each of those levels, check if next level up has geometric center within that contour # If no, then that level's geometric center is a local maximum # If yes, then move up one level and repeat k = [l['k'] for l in lobe] ck = Counter(k) mlarr = [] for x, y in ck.iteritems(): if y > 1: mlarr.append(x) if max(k) not in mlarr: mlarr.append(max(k)) mlarr.sort() local_maxima = [] for m in mlarr: levels = [l for l in lobe if l['k'] == m] # Is there a higher level? if m < max(k): upper_levels = [l for l in lobe if l['k'] == m + 1] for level in levels: within = False for ul in upper_levels: gc = centroid(ul['arr']) polygon = make_polygon(level['arr']) result = point_in_poly(gc[0], gc[1], polygon) within += result if not within: gc = centroid(level['arr']) local_maxima.append((m, gc)) if verbose: print 'Point in poly, m=%i, center=(%.1f,%.1f)' % ( m, gc[0], gc[1]) # If no higher level, centroids = local max else: for level in levels: gc = centroid(level['arr']) local_maxima.append((m, gc)) if verbose: print 'No higher levels, m=%i, center=(%.1f,%.1f)' % ( m, gc[0], gc[1]) # Plot locations of peaks npeaks = len(local_maxima) if plot: xc = [x[1][0] for x in local_maxima] yc = [x[1][1] for x in local_maxima] fig = plt.figure() ax = fig.add_subplot(111) verts_all = [] codes_all = [] components = contours['contours'] for comp in components: # Order of bounding box components is (xmax,ymax,xmin,ymin) comp_xmax, comp_ymax, comp_xmin, comp_ymin = comp[0]['bbox'] # Only plot radio components identified by the users as the consensus; # check on the xmax value to make sure for idx, level in enumerate(comp): verts = [(p['x'], p['y']) for p in level['arr']] codes = np.ones(len(verts), int) * Path.LINETO codes[0] = Path.MOVETO verts_all.extend(verts) codes_all.extend(codes) try: path = Path(verts_all, codes_all) patch_black = patches.PathPatch(path, facecolor='none', edgecolor='black', lw=1) except AssertionError: print 'Users found no components for consensus match of %s' % zooniverse_id # Plot contours identified as the consensus ax.add_patch(patch_black) ax.plot(xc, yc, 'r*', ms=10) ax.set_xlim(0, FIRST_FITS_WIDTH) ax.set_ylim(FIRST_FITS_HEIGHT, 0) ax.set_aspect('equal') #ax.title(subject['zooniverse_id']) plt.show() return local_maxima
def plot_one_triple(zooniverse_id, pathdict, figno=1, savefig=False, anglepath=''): # Make a four-panel plot of the consensus identification with marked bending angle and position angle for a triple source cons = consensus.checksum(zooniverse_id) subject = subjects.find_one({'zooniverse_id': zooniverse_id}) contours = get_contours(subject, pathdict) radio_components = contours['contours'] # Plot image answer = cons['answer'] # Download contour data sf_x = 500. / contours['width'] sf_y = 500. / contours['height'] verts_all = [] codes_all = [] components = contours['contours'] for comp in components: # Order of bounding box components is (xmax,ymax,xmin,ymin) comp_xmax, comp_ymax, comp_xmin, comp_ymin = comp[0]['bbox'] # Only plot radio components identified by the users as the consensus; # check on the xmax value to make sure for v in answer.itervalues(): if comp_xmax in v['xmax']: for idx, level in enumerate(comp): verts = [((p['x']) * sf_x, (p['y'] - 1) * sf_y) for p in level['arr']] codes = np.ones(len(verts), int) * Path.LINETO codes[0] = Path.MOVETO verts_all.extend(verts) codes_all.extend(codes) try: path = Path(verts_all, codes_all) patch_black = patches.PathPatch(path, facecolor='none', edgecolor='black', lw=1) except AssertionError: print 'Users found no components for consensus match of %s' % zooniverse_id # Plot the infrared results fig = plt.figure(figno, (15, 4)) fig.clf() ax3 = fig.add_subplot(143) ax4 = fig.add_subplot(144) colormaparr = [ cm.hot_r, cm.Blues, cm.RdPu, cm.Greens, cm.PuBu, cm.YlGn, cm.Greys ][::-1] colorarr = ['r', 'b', 'm', 'g', 'c', 'y', 'k'][::-1] if len(answer) > 0: # At least one galaxy was identified for idx, ans in enumerate(answer.itervalues()): if ans.has_key('peak_data'): # Plot the KDE map colormap = colormaparr.pop() ax3.imshow(np.rot90(ans['peak_data']['Z']), cmap=colormap, extent=[xmin, xmax, ymin, ymax]) # Plot individual sources color = colorarr.pop() x_plot, y_plot = ans['ir_x'], ans['ir_y'] ax3.scatter(x_plot, y_plot, c=color, marker='o', s=10, alpha=1. / len(x_plot)) ax4.plot([ans['ir_peak'][0]], [ans['ir_peak'][1]], color=color, marker='*', markersize=12) elif ans.has_key('ir'): color = colorarr.pop() x_plot, y_plot = ans['ir'] ax3.plot([x_plot], [y_plot], color=color, marker='o', markersize=2) ax4.plot([x_plot], [y_plot], color=color, marker='*', markersize=12) else: ax4.text(550, idx * 25, '#%i - no IR host' % idx, fontsize=11) ax3.set_xlim([0, 500]) ax3.set_ylim([500, 0]) ax3.set_title(zooniverse_id) ax3.set_aspect('equal') ax4.set_xlim([0, 500]) ax4.set_ylim([500, 0]) ax4.set_title('Consensus (%i/%i users)' % (cons['n_users'], cons['n_total'])) ax4.set_aspect('equal') # Display IR and radio images url_standard = subject['location']['standard'] im_standard = Image.open( cStringIO.StringIO(urllib.urlopen(url_standard).read())) ax1 = fig.add_subplot(141) ax1.imshow(im_standard, origin='upper') ax1.set_title('WISE') url_radio = subject['location']['radio'] im_radio = Image.open(cStringIO.StringIO(urllib.urlopen(url_radio).read())) ax2 = fig.add_subplot(142) ax2.imshow(im_radio, origin='upper') ax2.set_title(subject['metadata']['source']) ax2.get_yaxis().set_ticklabels([]) ax3.get_yaxis().set_ticklabels([]) # Plot contours identified as the consensus if len(answer) > 0: ax4.add_patch(patch_black) # Add centers of bounding boxes for comp in components: bbox_radio = comp[0]['bbox'] bbox_ir = bbox_radio_to_ir(bbox_radio) xrad = np.median((bbox_ir[0], bbox_ir[2])) yrad = np.median((bbox_ir[1], bbox_ir[3])) ax4.scatter(xrad, yrad, c='g', marker='s', s=15, alpha=1) dbx = [bbox_ir[i] for i in (2, 2, 0, 0, 2)] dby = [bbox_ir[i] for i in (3, 1, 1, 3, 3)] ax4.plot(dbx, dby, color='g') radiobeamsize = 5. # arcsec imagesize = 3. # arcmin imagescale = IMG_HEIGHT_NEW / imagesize / 60. # pixel / arcsec radio_tol = radiobeamsize * imagescale for ans in answer: if answer[ans].has_key('ir_peak'): # Optical counterpart position xc, yc = answer[ans]['ir_peak'] # Measure all positions in radio pixel coordinates radio_centroids = pix_radio(components) maxdist = 0 for centroid in radio_centroids: d = pix_dist(xc, yc, centroid[0], centroid[1]) maxdist = d if d > maxdist else maxdist if d <= radio_tol: middle_radio = centroid radio_centroids.remove(middle_radio) x1 = radio_centroids[0][0] y1 = radio_centroids[0][1] x2 = radio_centroids[1][0] y2 = radio_centroids[1][1] if len(radio_centroids) == 2: m1 = (y1 - yc) / (x1 - xc) b1 = yc - m1 * xc m2 = (y2 - yc) / (x2 - xc) b2 = yc - m2 * xc xedge1 = 0 if x1 < xc else 500 yedge1 = y1 - (x1 - xedge1) * (yc - y1) / (xc - x1) xedge2 = 0 if x2 < xc else 500 yedge2 = y2 - (x2 - xedge2) * (yc - y2) / (xc - x2) # Draw and annotate the the bending angle ax4.plot([xedge1, xc], [yedge1, yc], color='orange', linestyle='--') ax4.plot([xedge2, xc], [yedge2, yc], color='orange', linestyle='--') alpha_deg = bending_angle(xc, yc, x1, y1, x2, y2) * 180 / np.pi ax4.text(550, 0, r'$\alpha$ = %.1f deg' % alpha_deg, fontsize=11) else: print "\tDidn't find match to optical ID for triple radio source %s" % zooniverse_id else: print "\tNo IR peak for %s" % zooniverse_id ax4.yaxis.tick_right() ax1.get_xaxis().set_ticks([0, 100, 200, 300, 400]) ax2.get_xaxis().set_ticks([0, 100, 200, 300, 400]) ax3.get_xaxis().set_ticks([0, 100, 200, 300, 400]) ax4.get_xaxis().set_ticks([0, 100, 200, 300, 400, 500]) plt.subplots_adjust(wspace=0.02) # Save hard copy of the figure if savefig: fig.savefig( '{0:}/bending_angles/plots/individual/triples/{1:}ba_{2:}.pdf'. format(rgz_dir, anglepath, zooniverse_id)) plt.close() else: plt.show() # Close figure after it's done; otherwise mpl complains about having thousands of stuff open return None
codes = [ Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY, ] verts2_1 = [ (1., 0.5), # left, bottom (1., 3.5), # left, top (2., 3.5), # right, top (2., 0.5), # right, bottom (0., 0.), # ignored ] path2_1 = Path(verts2_1, codes) patch2_1 = patches.PathPatch(path2_1, facecolor='mistyrose', lw=0) verts2_2 = [ (3., 1.), # left, bottom (3., 3.), # left, top (4., 3.), # right, top (4., 1.), # right, bottom (0., 0.), # ignored ] path2_2 = Path(verts2_2, codes) patch2_2 = patches.PathPatch(path2_2, facecolor='honeydew', lw=0) plt.clf() fig = plt.figure() ax = fig.add_subplot(111) ax.set_xlabel('x') ax.set_ylabel('y') fig.tight_layout()
def plt_catalog(Model_list, File_bg, catalog_file, Run_name, xmin, xmax, ymin, ymax, llcrnrlon, llcrnrlat, urcrnrlon, urcrnrlat, completness_file, nb_inter, bining_in_mag, end_year_of_catalog, sub_area_file): if not os.path.exists(str(Run_name) + '/analysis/figures/catalogue'): os.makedirs(str(Run_name) + '/analysis/figures/catalogue') catalog_cum_rate = [] index_model = 0 for model in Model_list: # extract the geometry of the zone ( geometry of the background) Lon_bg, Lat_bg = Geom_bg(model, File_bg) ColX = Lon_bg ColY = Lat_bg Poly = [] for x1, y1 in zip(ColX, ColY): # creation du polygon de la zone Poly.append((x1, y1)) bbPath = mplPath.Path(Poly) bbPath_sub_areas = [] if os.path.exists(sub_area_file): read_sub_area_file = open(sub_area_file, 'rU') lines_sub_area = read_sub_area_file.readlines() sub_area_names = [] sub_area_coord = [] sub_area_lon = [] sub_area_lat = [] for line in lines_sub_area: model_sub_area = line.split('\t')[0] if model == model_sub_area: sub_area_names.append(line.split('\t')[1]) sub_area_coord.append(line.split('\t')[2:]) sub_area_lon_i = [] sub_area_lat_i = [] for sub_area_coord_i in line.split('\t')[2:]: if not '\n' in sub_area_coord_i.split(','): if not '' in sub_area_coord_i.split(','): sub_area_lon_i.append( float(sub_area_coord_i.split(',')[1])) sub_area_lat_i.append( float(sub_area_coord_i.split(',')[0])) sub_area_lon.append(sub_area_lon_i) sub_area_lat.append(sub_area_lat_i) if not os.path.exists( str(Run_name) + '/analysis/figures/catalogue/sub_area'): os.makedirs( str(Run_name) + '/analysis/figures/catalogue/sub_area') Poly_sub = [] for x1, y1 in zip( sub_area_lon_i, sub_area_lat_i): # creation du polygon de la zone Poly_sub.append((x1, y1)) bbPath_sub_areas.append(mplPath.Path(Poly_sub)) cat_data = np.genfromtxt(catalog_file, dtype=[('S100'), ('S100'), ('S100'), ('S100'), ('S100'), ('S100'), ('S100'), ('S100'), ('S100')], skip_header=1) cat_lon = list( map(lambda i: float(cat_data[i][5]), range(len(cat_data)))) cat_lat = list( map(lambda i: float(cat_data[i][4]), range(len(cat_data)))) cat_depth = list( map(lambda i: float(cat_data[i][6]), range(len(cat_data)))) cat_Mw = list( map(lambda i: float(cat_data[i][7]), range(len(cat_data)))) cat_sig_Mw = list( map(lambda i: float(cat_data[i][8]), range(len(cat_data)))) cat_Yr = list( map(lambda i: float(cat_data[i][0]), range(len(cat_data)))) #selects only the earthquakes that are in the subarea indexes_in = [] for index_cat in range(len(cat_lon)): if bbPath.contains_point( (cat_lon[index_cat], cat_lat[index_cat] )) == 1: #test pour savoir si la zone contient le point indexes_in.append(index_cat) cat_lon = np.take(cat_lon, indexes_in) cat_lat = np.take(cat_lat, indexes_in) cat_depth = np.take(cat_depth, indexes_in) cat_Mw = np.take(cat_Mw, indexes_in) cat_sig_Mw = np.take(cat_sig_Mw, indexes_in) cat_Yr = np.take(cat_Yr, indexes_in) #extracting the completeness time of the catalogue completness = [] weights_completness = [] read_comp_file = open(completness_file, 'rU') lines_of_the_file = read_comp_file.readlines() #lines_of_the_file.remove('\n') line_number = 0 for i in range(int(len(lines_of_the_file) / 2)): if len(lines_of_the_file[line_number].split('\t')) != 0: binning_comp_i = lines_of_the_file[line_number].split('\t') if '\r\n' in binning_comp_i: binning_comp_i.remove('\r\n') if '\n' in binning_comp_i: binning_comp_i.remove('\n') binning_comp = [] for magnitudes in binning_comp_i[1:]: mag = magnitudes.split(',') binning_comp.append(float(mag[0])) binning_comp.append(float(mag[1])) #binning_comp = [float(x) for x in binning_comp] binning_comp.append(bining_in_mag[-1]) comp_value_i = lines_of_the_file[line_number + 1].split('\t') if '\r\n' in comp_value_i: comp_value_i.remove('\r\n') if '\n' in comp_value_i: comp_value_i.remove('\n') comp_value = [] for value in comp_value_i[1:]: comp_value.append(float(value)) comp_value.append(float(value)) #comp_value = [float(x) for x in comp_value] comp_value.append(comp_value[-1]) completeness_interpolate = interp1d(binning_comp, comp_value) completness_i = [] for mag in bining_in_mag: try: completness_i.append(completeness_interpolate(mag)) except ValueError: print( '!!!!!!!!!!!!\n\n\nERROR in completeness file\n your minimum magnitude might not be low enough\n\n\n!!!!!!!!!!!!' ) line_number += 2 completness.append(completness_i) weights_completness.append(float(comp_value_i[0])) seismological_moment_rate = [] number_of_earthquakes_for_rate = [ ] #nuMber of earthquake greater than this magnitude number_of_earthquakes_for_rate_sub_area = [ ] #nuMber of earthquake greater than this magnitude in the sub areas for poly_sub_area_i in bbPath_sub_areas: number_of_earthquakes_for_rate_sub_area.append([]) #variables for the plot on the map file_catalog_for_map = open( str(Run_name) + '/analysis/figures/catalogue/catalog_for_map_' + str(model) + '.txt', 'w') earthquake_for_map = [] nb_time_picked = [ ] #number of time this earthquake has been kept in the complete catalog #self.rate_SHARE_WCR_cum_kdeplot = [] rate_SHARE_WCR_cum_density = [] #for the sub_areas rate_in_sub_area_cum = [] for poly_sub_area_i in bbPath_sub_areas: rate_in_sub_area_cum.append([]) #loop on the interations to explore the uncertainties for i in range(nb_inter): #cat_SHARE_WCR_i = [] cat_model_bin = np.zeros(len(bining_in_mag)) rate_SHARE_WCR = np.zeros(len(bining_in_mag)) seismological_moment_rate_i = 0. #moment rate calculated using the catalog test_if_eq_here = [ ] #will be checked if the earthquake is not count twice #random picking of the completness used index_completness = np.random.choice(len(weights_completness), 1, p=weights_completness)[0] completness_used = completness[index_completness] #for the sub areas cat_sub_area_bin = [] rate_sub_area = [] for poly_sub_area_i in bbPath_sub_areas: cat_sub_area_bin.append(np.zeros(len(bining_in_mag))) rate_sub_area.append(np.zeros(len(bining_in_mag))) #random pick of the earthquakes magnitudes envents_magnitude = [] index_cat = 0 for Yr in cat_Yr: #loop on all the earthquakes in the catalogue to pick the magnitude if cat_sig_Mw[index_cat] == 0: event_magnitude = cat_Mw[index_cat] elif cat_sig_Mw[index_cat] <= 3.: event_magnitude = np.random.triangular( cat_Mw[index_cat] - cat_sig_Mw[index_cat] / 2., cat_Mw[index_cat], cat_Mw[index_cat] + cat_sig_Mw[index_cat] / 2.) # else : # event_magnitude = np.random.triangular(cat_sig_Mw[index_cat],cat_Mw[index_cat],cat_sig_Mw_plus[index_cat]) envents_magnitude.append(event_magnitude) index_cat += 1 index_mag = 0 #for mag_i,completness_i,sigma_completness_i in zip(bining_in_mag,completeness,sigma_completness) : for mag_i, completness_i in zip(bining_in_mag, completness_used): #loop on the magnitudes index_cat = 0 #picked_completness = completness_i + random_factor * sigma_completness_i picked_completness = completness_i index_cat = 0 for Yr in cat_Yr: #loop on all the earthquakes in the catalogue if cat_depth[index_cat] < 30. or math.isnan( cat_depth[index_cat] ): #check if the event is not on the subduction interface for Corinth if Yr >= picked_completness and Yr <= end_year_of_catalog: event_magnitude = envents_magnitude[index_cat] if event_magnitude >= mag_i and event_magnitude < mag_i + 0.099: if bbPath.contains_point( (cat_lon[index_cat], cat_lat[index_cat]) ) == 1: #test pour savoir si la zone contient le point if not (str(Yr) + str(cat_lon[index_cat]) + str(cat_lat[index_cat]) + str(cat_sig_Mw[index_cat]) ) in test_if_eq_here: #cat_SHARE_WCR_i.append(event_magnitude) test_if_eq_here.append( str(Yr) + str(cat_lon[index_cat]) + str(cat_lat[index_cat])) cat_model_bin[index_mag] += 1 #for the map string_for_map = str(Yr) + '\t' + str( cat_Mw[index_cat]) + '\t' + str( cat_lon[index_cat] ) + '\t' + str(cat_lat[index_cat]) if not string_for_map in earthquake_for_map: #the earthquake has not been pîcked in an earlier iteration earthquake_for_map.append( string_for_map) nb_time_picked.append(1) else: index_in_cat_for_map = np.where( np.array(earthquake_for_map) == string_for_map)[0][0] nb_time_picked[ index_in_cat_for_map] += 1 #if earthquake arealy there, we count it one more time #for the sub areas index_sub_area = 0 for poly_sub_area_i in bbPath_sub_areas: if poly_sub_area_i.contains_point( (cat_lon[index_cat], cat_lat[index_cat]) ) == 1: #test pour savoir si la zone contient le point cat_sub_area_bin[ index_sub_area][ index_mag] += 1 index_sub_area += 1 index_cat += 1 rate_SHARE_WCR[index_mag] = cat_model_bin[index_mag] / ( end_year_of_catalog - picked_completness) M0 = 10.**(1.5 * mag_i + 9.1) #calculation of the moment rate_M0 = M0 * rate_SHARE_WCR[index_mag] seismological_moment_rate_i += rate_M0 #for the sub areas index_sub_area = 0 for poly_sub_area_i in bbPath_sub_areas: rate_sub_area[index_sub_area][ index_mag] = cat_sub_area_bin[index_sub_area][ index_mag] / (end_year_of_catalog - picked_completness) index_sub_area += 1 index_mag += 1 seismological_moment_rate.append(seismological_moment_rate_i) number_of_earthquakes_for_rate_i = [] for i in range(len(cat_model_bin) ): #calculate the cumulative number of earthquake number_of_earthquakes_for_rate_i.append( int( np.sum( np.array(cat_model_bin)[-(len(cat_model_bin) - i):]))) number_of_earthquakes_for_rate.append( number_of_earthquakes_for_rate_i) #for the sub areas index_sub_area = 0 for poly_sub_area_i in bbPath_sub_areas: number_of_earthquakes_for_rate_i = [] for i in range( len(cat_model_bin )): #calculate the cumulative number of earthquake number_of_earthquakes_for_rate_i.append( int( np.sum( np.array(cat_sub_area_bin[index_sub_area]) [-(len(cat_sub_area_bin[index_sub_area]) - i):]))) number_of_earthquakes_for_rate_sub_area[index_sub_area].append( number_of_earthquakes_for_rate_i) index_sub_area += 1 rate_SHARE_WCR_cum = [] for i in range( len(rate_SHARE_WCR)): #calculate the cumulative rate rate_SHARE_WCR_cum.append( np.sum( np.array(rate_SHARE_WCR)[-(len(rate_SHARE_WCR) - i):])) rate_SHARE_WCR_cum_density.append(rate_SHARE_WCR_cum) #for the sub areas index_sub_area = 0 for poly_sub_area_i in bbPath_sub_areas: rate_sub_area_i_cum = [] for i in range(len(rate_sub_area[index_sub_area]) ): #calculate the cumulative rate rate_sub_area_i_cum.append( np.sum( np.array(rate_sub_area[index_sub_area]) [-(len(rate_sub_area[index_sub_area]) - i):])) rate_in_sub_area_cum[index_sub_area].append( rate_sub_area_i_cum) index_sub_area += 1 plt.scatter(bining_in_mag, rate_SHARE_WCR_cum, c='brown', marker='_', s=50, alpha=0.2) #, linewidth = 0 axes = plt.gca() axes.set_xlim([xmin, xmax]) axes.set_ylim([ymin, ymax]) mean_nb_eq_in_cat = np.mean(number_of_earthquakes_for_rate, axis=0) for index_mag in range(len(bining_in_mag)): #does a simulation of the catalog in order to check the statistical validity nb_eq = mean_nb_eq_in_cat[index_mag] if completness[0][index_mag] == min( completness[0] ): #if it's the last completness period, do the statistical représentativity time_obs = int( round(end_year_of_catalog - completness[0][index_mag])) rate = float(nb_eq) / float(time_obs) time_simu = 1000000 nb_sample = 50 cat = [] #build the catalog for i in range(time_simu): test = np.random.uniform(0., 1.) if test <= rate: cat.append(1) else: cat.append(0) rates_simu = [] for i in range(nb_sample): yrs_start = random.choice(range(time_simu - time_obs)) cat_sampled = cat[yrs_start:yrs_start + time_obs] #print sum(cat_sampled), sum(cat_sampled)/float(time_obs) rates_simu.append(sum(cat_sampled) / float(time_obs)) # rate_plus = np.percentile(rate_SHARE_WCR_cum_density,84,axis=0)[index_mag] # rate_minus = np.percentile(rate_SHARE_WCR_cum_density,16,axis=0)[index_mag] unc_rate = (np.std(rate_SHARE_WCR_cum_density, axis=0)[index_mag]) / (np.square( mean_nb_eq_in_cat[index_mag])) unc_rate = np.std(rates_simu) #print(bining_in_mag[index_mag],nb_eq,time_obs,round(np.array(rate_SHARE_WCR_cum_density).mean(axis=0)[index_mag],6),round(unc_rate,6)) rate_plus = np.array(rate_SHARE_WCR_cum_density).mean( axis=0)[index_mag] + unc_rate rate_minus = np.array(rate_SHARE_WCR_cum_density).mean( axis=0)[index_mag] - unc_rate if rate_minus < 0.: # in order not to have negative values rate_minus = np.array(rate_SHARE_WCR_cum_density).mean( axis=0)[index_mag] / 10. else: #if it's another period, use the percentiles of the distribution rate_plus = np.percentile(rate_SHARE_WCR_cum_density, 84, axis=0)[index_mag] rate_minus = np.percentile(rate_SHARE_WCR_cum_density, 16, axis=0)[index_mag] mag = bining_in_mag[index_mag] mag_plus = mag + 0.05 mag_minus = mag - 0.05 verts = [(mag_minus, rate_minus), (mag_minus, rate_plus), (mag_plus, rate_plus), (mag_plus, rate_minus), (mag_minus, rate_minus)] codes = [ Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY ] path_poly = Path(verts, codes) patch = patches.PathPatch(path_poly, facecolor='k', lw=0., alpha=0.15) axes.add_patch(patch) # plt.scatter(bining_in_mag,np.percentile(rate_SHARE_WCR_cum_density,50,axis=0), # c='k', s=5, edgecolor='',marker = 'o',alpha = 0.8) # plt.scatter(bining_in_mag,np.percentile(rate_SHARE_WCR_cum_density,16,axis=0), # c='k', s=5, edgecolor='',marker = '+',alpha = 0.8) # plt.scatter(bining_in_mag,np.percentile(rate_SHARE_WCR_cum_density,84,axis=0), # c='k', s=5, edgecolor='',marker = '+',alpha = 0.8) # plt.scatter(bining_in_mag,np.percentile(rate_SHARE_WCR_cum_density,5,axis=0), # c='k', s=4, edgecolor='',marker = 'o',alpha = 0.8) # plt.scatter(bining_in_mag,np.percentile(rate_SHARE_WCR_cum_density,95,axis=0), # c='k', s=4, edgecolor='',marker = 'o',alpha = 0.8) plt.scatter(bining_in_mag, np.array(rate_SHARE_WCR_cum_density).mean(axis=0), c='k', s=20, edgecolor='', marker='s', alpha=0.95) plt.yscale('log') plt.title('earthquake catalog') plt.grid(alpha=0.3) plt.savefig(str(Run_name) + '/analysis/figures/catalogue/catalogue_' + str(model) + '.png', dpi=180, transparent=True) #plt.show() plt.close() #for the sub areas index_sub_area = 0 for poly_sub_area_i in bbPath_sub_areas: axes = plt.gca() axes.set_xlim([xmin, xmax]) axes.set_ylim([ymin, ymax]) mean_nb_eq_in_cat = np.mean( number_of_earthquakes_for_rate_sub_area[index_sub_area], axis=0) for index_mag in range(len(bining_in_mag)): #does a simulation of the catalog in order to check the statistical validity nb_eq = mean_nb_eq_in_cat[index_mag] time_obs = int( round(end_year_of_catalog - completness[0][index_mag])) rate = float(nb_eq) / float(time_obs) time_simu = 1000000 nb_sample = 50 cat = [] #build the catalog for i in range(time_simu): test = np.random.uniform(0., 1.) if test <= rate: cat.append(1) else: cat.append(0) rates_simu = [] for i in range(nb_sample): yrs_start = random.choice(range(time_simu - time_obs)) cat_sampled = cat[yrs_start:yrs_start + time_obs] #print sum(cat_sampled), sum(cat_sampled)/float(time_obs) rates_simu.append(sum(cat_sampled) / float(time_obs)) unc_rate = np.std(rates_simu) rate_plus = np.array( rate_in_sub_area_cum[index_sub_area]).mean( axis=0)[index_mag] + unc_rate rate_minus = np.array( rate_in_sub_area_cum[index_sub_area]).mean( axis=0)[index_mag] - unc_rate if rate_minus < 0.: # in order not to have negative values rate_minus = np.array( rate_in_sub_area_cum[index_sub_area]).mean( axis=0)[index_mag] / 10. mag = bining_in_mag[index_mag] mag_plus = mag + 0.05 mag_minus = mag - 0.05 verts = [(mag_minus, rate_minus), (mag_minus, rate_plus), (mag_plus, rate_plus), (mag_plus, rate_minus), (mag_minus, rate_minus)] codes = [ Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY ] path_poly = Path(verts, codes) patch = patches.PathPatch(path_poly, facecolor='k', lw=0., alpha=0.15) axes.add_patch(patch) for i in range(nb_inter): plt.scatter(bining_in_mag, rate_in_sub_area_cum[index_sub_area][i], c='brown', marker='_', s=50, alpha=0.2) #, linewidth = 0 # plt.scatter(bining_in_mag,np.percentile(rate_in_sub_area_cum[index_sub_area],50,axis=0), # c='k', s=15, edgecolor='',marker = 'o',alpha = 0.8) # plt.scatter(bining_in_mag,np.percentile(rate_in_sub_area_cum[index_sub_area],16,axis=0), # c='k', s=15, edgecolor='',marker = '+',alpha = 0.8) # plt.scatter(bining_in_mag,np.percentile(rate_in_sub_area_cum[index_sub_area],84,axis=0), # c='k', s=15, edgecolor='',marker = '+',alpha = 0.8) # plt.scatter(bining_in_mag,np.percentile(rate_in_sub_area_cum[index_sub_area],5,axis=0), # c='k', s=5, edgecolor='',marker = 'o',alpha = 0.8) # plt.scatter(bining_in_mag,np.percentile(rate_in_sub_area_cum[index_sub_area],95,axis=0), # c='k', s=5, edgecolor='',marker = 'o',alpha = 0.8) plt.scatter(bining_in_mag, np.array( rate_in_sub_area_cum[index_sub_area]).mean(axis=0), c='k', s=15, edgecolor='', marker='s', alpha=0.95) axes = plt.gca() axes.set_xlim([xmin, xmax]) axes.set_ylim([ymin, ymax]) plt.grid() plt.yscale('log') plt.title('catalogue sub area ' + sub_area_names[index_sub_area]) plt.savefig( str(Run_name) + '/analysis/figures/catalogue/sub_area/catalogue_sub_area_' + sub_area_names[index_sub_area] + ' Model ' + str(model) + '.png', dpi=180, transparent=True) #plt.show() plt.close() index_sub_area += 1 #export the rates of the catalogue for future comparisons #line_cat_for model = [model, rate_SHARE_WCR_cum_density] catalog_cum_rate.append(rate_SHARE_WCR_cum_density) #print 'Number of earthquake for the rate in catalogue' file_nb_eq_in_cat = open( str(Run_name) + '/analysis/figures/catalogue/nb_eq_in_cat_' + str(model) + '.txt', 'w') file_nb_eq_in_cat.write( 'Number of earthquake for the rate in catalogue' + '\n') mean_nb_eq_in_cat = np.mean(number_of_earthquakes_for_rate, axis=0) for i in range(len(bining_in_mag)): #print bining_in_mag[i],int(round(mean_nb_eq_in_cat[i],0)) file_nb_eq_in_cat.write( str(bining_in_mag[i]) + '\t' + str(round(mean_nb_eq_in_cat[i], 0)) + '\n') file_nb_eq_in_cat.close() plt.scatter(bining_in_mag, mean_nb_eq_in_cat) plt.axhline(y=1) plt.axhline(y=2) plt.axhline(y=5) plt.axhline(y=10) plt.title('nb of earthquakes (m>M) in the catalogue') plt.savefig(str(Run_name) + '/analysis/figures/catalogue/' + 'nb_of_EQ_in_catalogue.png', dpi=180, transparent=True) plt.grid() plt.close() for string, nb in zip(earthquake_for_map, nb_time_picked): #print string,nb #if nb >= nb_inter/2 : #we write in the catalog only if selected more than half the time file_catalog_for_map.write(string + '\t' + str(nb) + '\n') file_catalog_for_map.close() #for the sub areas index_sub_area = 0 for poly_sub_area_i in bbPath_sub_areas: plt.scatter( bining_in_mag, np.mean( number_of_earthquakes_for_rate_sub_area[index_sub_area], axis=0)) plt.axhline(y=1) plt.axhline(y=2) plt.axhline(y=5) plt.axhline(y=10) plt.title('nb of earthquakes (m>M) in the catalogue ' + sub_area_names[index_sub_area]) plt.savefig( str(Run_name) + '/analysis/figures/catalogue/sub_area/' + 'nb_of_EQ_in_ ' + sub_area_names[index_sub_area] + '.png', dpi=180, transparent=True) plt.grid() plt.close() index_sub_area += 1 ###### map plot of the catalog ##### if mean_nb_eq_in_cat[0] > 3: catalog_for_map = np.genfromtxt( str(Run_name) + '/analysis/figures/catalogue/catalog_for_map_' + str(model) + '.txt', dtype=[('f8'), ('f8'), ('f8'), ('f8'), ('f8')]) yr_cat_for_map = list( map(lambda i: round(float(catalog_for_map[i][0])), range(len(catalog_for_map)))) M_cat_for_map = list( map(lambda i: float(catalog_for_map[i][1]), range(len(catalog_for_map)))) lon_cat_for_map = list( map(lambda i: float(catalog_for_map[i][2]), range(len(catalog_for_map)))) lat_cat_for_map = list( map(lambda i: float(catalog_for_map[i][3]), range(len(catalog_for_map)))) nb_time_picked = list( map(lambda i: float(catalog_for_map[i][4]), range(len(catalog_for_map)))) m = Basemap(projection='mill', llcrnrlon=llcrnrlon, llcrnrlat=llcrnrlat, urcrnrlon=urcrnrlon, urcrnrlat=urcrnrlat, resolution='i') for (Yr, M, lon, lat, nb) in zip(yr_cat_for_map, M_cat_for_map, lon_cat_for_map, lat_cat_for_map, nb_time_picked): x, y = m(lon, lat) # color scale if M < 5.5: s = 6 c = 'grey' elif M < 6.0: s = 8 c = 'yellow' elif M < 6.5: s = 10 c = 'orange' else: s = 12 c = 'red' if nb >= 2 * nb_inter / 3: alpha = 1. if nb <= 2 * nb_inter / 3: alpha = 0.8 if nb <= 1 * nb_inter / 2: alpha = 0.3 if nb < 1 * nb_inter / 3: alpha = 0.1 c = plt.cm.jet((M - min(M_cat_for_map)) / (max(M_cat_for_map) - min(M_cat_for_map))) m.plot(x, y, 'o', markersize=s, linewidth=0.2, color=c, alpha=alpha) x_text, y_text = m(lon + 0.005, lat + 0.005) plt.text(x_text, y_text, str(int(Yr)) + ',' + str(int(nb)), fontsize=4) m.drawcoastlines(linewidth=0.1) #m.fillcontinents(color='grey',lake_color='w',alpha = 0.2) plt.gca().set_title('Earthquake catalog - Complete period') plt.savefig(str(Run_name) + '/analysis/figures/catalogue/' + 'earthquake_map_' + str(model) + '.png', dpi=180, transparent=True) #plt.show() plt.close() ###### map plot of the catalog ##### catalog_for_map = np.genfromtxt( str(Run_name) + '/analysis/figures/catalogue/catalog_for_map_' + str(model) + '.txt', dtype=[('f8'), ('f8'), ('f8'), ('f8'), ('f8')]) yr_cat_for_map = list( map(lambda i: round(float(catalog_for_map[i][0])), range(len(catalog_for_map)))) M_cat_for_map = list( map(lambda i: float(catalog_for_map[i][1]), range(len(catalog_for_map)))) lon_cat_for_map = list( map(lambda i: float(catalog_for_map[i][2]), range(len(catalog_for_map)))) lat_cat_for_map = list( map(lambda i: float(catalog_for_map[i][3]), range(len(catalog_for_map)))) nb_time_picked = list( map(lambda i: float(catalog_for_map[i][4]), range(len(catalog_for_map)))) m = Basemap(projection='mill', llcrnrlon=llcrnrlon, llcrnrlat=llcrnrlat, urcrnrlon=urcrnrlon, urcrnrlat=urcrnrlat, resolution='l') for (Yr, M, lon, lat) in zip(yr_cat_for_map, M_cat_for_map, lon_cat_for_map, lat_cat_for_map): x, y = m(lon, lat) # color scale if M < 5.5: s = 6 c = 'grey' elif M < 6.0: s = 8 c = 'yellow' elif M < 6.5: s = 10 c = 'orange' else: s = 12 c = 'red' if nb >= 2 * nb_inter / 3: alpha = 1. if nb <= 2 * nb_inter / 3: alpha = 0.8 if nb <= 1 * nb_inter / 2: alpha = 0.3 if nb < 1 * nb_inter / 3: alpha = 0.001 c = plt.cm.jet((M - min(M_cat_for_map)) / (max(M_cat_for_map) - min(M_cat_for_map))) m.plot(x, y, 'o', markersize=s, linewidth=0.2, color=c, alpha=0.5) plt.savefig(str(Run_name) + '/analysis/figures/catalogue/' + 'earthquake_map_just_EQ_' + str(model) + '.png', dpi=180, transparent=True) #plt.show() plt.close() index_model += 1 return seismological_moment_rate, catalog_cum_rate #,yr_cat_for_map,M_cat_for_map,lon_cat_for_map,lat_cat_for_map
def as_mpl_artists(shape_list, properties_func=None, text_offset=5.0, origin=1): """ Converts a region list to a list of patches and a list of artists. Optional Keywords: [ text_offset ] - If there is text associated with the regions, add some vertical offset (in pixels) to the text so that it doesn't overlap with the regions. Often, the regions files implicitly assume the lower-left corner of the image as a coordinate (1,1). However, the python convetion is that the array index starts from 0. By default (origin = 1), coordinates of the returned mpl artists have coordinate shifted by (1, 1). If you do not want this shift, set origin=0. """ patch_list = [] artist_list = [] if properties_func is None: properties_func = properties_func_default # properties for continued(? multiline?) regions saved_attrs = None for shape in shape_list: patches = [] if saved_attrs is None: _attrs = [], {} else: _attrs = copy.copy(saved_attrs[0]), copy.copy(saved_attrs[1]) kwargs = properties_func(shape, _attrs) if shape.name == "composite": saved_attrs = shape.attr continue if saved_attrs is None and shape.continued: saved_attrs = shape.attr # elif (shape.name in shape.attr[1]): # if (shape.attr[1][shape.name] != "ignore"): # saved_attrs = shape.attr if not shape.continued: saved_attrs = None # text associated with the shape txt = shape.attr[1].get("text") if shape.name == "polygon": xy = np.array(shape.coord_list) xy.shape = -1, 2 # -1 for change origin to 0,0 patches = [mpatches.Polygon(xy - origin, closed=True, **kwargs)] elif shape.name == "rotbox" or shape.name == "box": xc, yc, w, h, rot = shape.coord_list # -1 for change origin to 0,0 xc, yc = xc - origin, yc - origin _box = np.array([[-w / 2., -h / 2.], [-w / 2., h / 2.], [w / 2., h / 2.], [w / 2., -h / 2.]]) box = _box + [xc, yc] rotbox = rotated_polygon(box, xc, yc, rot) patches = [mpatches.Polygon(rotbox, closed=True, **kwargs)] elif shape.name == "ellipse": xc, yc = shape.coord_list[:2] # -1 for change origin to 0,0 xc, yc = xc - origin, yc - origin angle = shape.coord_list[-1] maj_list, min_list = shape.coord_list[2:-1:2], shape.coord_list[ 3:-1:2] patches = [mpatches.Ellipse((xc, yc), 2*maj, 2*min, angle=angle, **kwargs) \ for maj, min in zip(maj_list, min_list)] elif shape.name == "annulus": xc, yc = shape.coord_list[:2] # -1 for change origin to 0,0 xc, yc = xc - origin, yc - origin r_list = shape.coord_list[2:] patches = [mpatches.Ellipse((xc, yc), 2*r, 2*r, **kwargs) \ for r in r_list] elif shape.name == "circle": xc, yc, major = shape.coord_list # -1 for change origin to 0,0 xc, yc = xc - origin, yc - origin patches = [ mpatches.Ellipse((xc, yc), 2 * major, 2 * major, angle=0, **kwargs) ] elif shape.name == "panda": xc, yc, a1, a2, an, r1, r2, rn = shape.coord_list # -1 for change origin to 0,0 xc, yc = xc - origin, yc - origin patches = [mpatches.Arc((xc, yc), rr*2, rr*2, angle=0, theta1=a1, theta2=a2, **kwargs) \ for rr in np.linspace(r1, r2, rn+1)] for aa in np.linspace(a1, a2, an + 1): xx = np.array([r1, r2]) * np.cos(aa / 180. * np.pi) + xc yy = np.array([r1, r2]) * np.sin(aa / 180. * np.pi) + yc p = Path(np.transpose([xx, yy])) patches.append(mpatches.PathPatch(p, **kwargs)) elif shape.name == "pie": xc, yc, r1, r2, a1, a2 = shape.coord_list # -1 for change origin to 0,0 xc, yc = xc - origin, yc - origin patches = [mpatches.Arc((xc, yc), rr*2, rr*2, angle=0, theta1=a1, theta2=a2, **kwargs) \ for rr in [r1, r2]] for aa in [a1, a2]: xx = np.array([r1, r2]) * np.cos(aa / 180. * np.pi) + xc yy = np.array([r1, r2]) * np.sin(aa / 180. * np.pi) + yc p = Path(np.transpose([xx, yy])) patches.append(mpatches.PathPatch(p, **kwargs)) elif shape.name == "epanda": xc, yc, a1, a2, an, r11, r12, r21, r22, rn, angle = shape.coord_list # -1 for change origin to 0,0 xc, yc = xc - origin, yc - origin # mpl takes angle a1, a2 as angle as in circle before # transformation to ellipse. x1, y1 = cos(a1 / 180. * pi), sin(a1 / 180. * pi) * r11 / r12 x2, y2 = cos(a2 / 180. * pi), sin(a2 / 180. * pi) * r11 / r12 a1, a2 = atan2(y1, x1) / pi * 180., atan2(y2, x2) / pi * 180. patches = [mpatches.Arc((xc, yc), rr1*2, rr2*2, angle=angle, theta1=a1, theta2=a2, **kwargs) \ for rr1, rr2 in zip(np.linspace(r11, r21, rn+1), np.linspace(r12, r22, rn+1))] for aa in np.linspace(a1, a2, an + 1): xx = np.array([r11, r21]) * np.cos(aa / 180. * np.pi) yy = np.array([r11, r21]) * np.sin(aa / 180. * np.pi) p = Path(np.transpose([xx, yy])) tr = Affine2D().scale(1, r12 / r11).rotate_deg(angle).translate( xc, yc) p2 = tr.transform_path(p) patches.append(mpatches.PathPatch(p2, **kwargs)) elif shape.name == "text": xc, yc = shape.coord_list[:2] # -1 for change origin to 0,0 xc, yc = xc - origin, yc - origin if txt: _t = _get_text(txt, xc, yc, 0, 0, **kwargs) artist_list.append(_t) elif shape.name == "point": xc, yc = shape.coord_list[:2] # -1 for change origin to 0,0 xc, yc = xc - origin, yc - origin artist_list.append(Line2D([xc], [yc], **kwargs)) if txt: textshape = copy.copy(shape) textshape.name = "text" textkwargs = properties_func(textshape, _attrs) _t = _get_text(txt, xc, yc, 0, text_offset, va="bottom", **textkwargs) artist_list.append(_t) elif shape.name in ["line", "vector"]: if shape.name == "line": x1, y1, x2, y2 = shape.coord_list[:4] # -1 for change origin to 0,0 x1, y1, x2, y2 = x1 - origin, y1 - origin, x2 - origin, y2 - origin a1, a2 = shape.attr[1].get("line", "0 0").strip().split()[:2] arrowstyle = "-" if int(a1): arrowstyle = "<" + arrowstyle if int(a2): arrowstyle = arrowstyle + ">" else: # shape.name == "vector" x1, y1, l, a = shape.coord_list[:4] # -1 for change origin to 0,0 x1, y1 = x1 - origin, y1 - origin x2, y2 = x1 + l * np.cos(a / 180. * np.pi), y1 + l * np.sin( a / 180. * np.pi) v1 = int(shape.attr[1].get("vector", "0").strip()) if v1: arrowstyle = "->" else: arrowstyle = "-" patches = [ mpatches.FancyArrowPatch(posA=(x1, y1), posB=(x2, y2), arrowstyle=arrowstyle, arrow_transmuter=None, connectionstyle="arc3", patchA=None, patchB=None, shrinkA=0, shrinkB=0, connector=None, **kwargs) ] else: warnings.warn( "'as_mpl_artists' does not know how to convert '%s' to mpl artist" % (shape.name, )) patch_list.extend(patches) if txt and patches: # the text associated with a shape uses different # matplotlib keywords than the shape itself for, e.g., # color textshape = copy.copy(shape) textshape.name = "text" textkwargs = properties_func(textshape, _attrs) # calculate the text position _bb = [p.get_window_extent() for p in patches] # this is to work around backward-incompatible change made # in matplotlib 1.2. This change is later reverted so only # some versions are affected. With affected version of # matplotlib, get_window_extent method calls get_transform # method which sets the _transformSet to True, which is # not desired. for p in patches: p._transformSet = False _bbox = Bbox.union(_bb) x0, y0, x1, y1 = _bbox.extents xc = .5 * (x0 + x1) _t = _get_text(txt, xc, y1, 0, text_offset, va="bottom", **textkwargs) artist_list.append(_t) return patch_list, artist_list
def trans2d(x,y,tx,ty,phi): xx = x*np.cos(phi) - y*np.sin(phi) + tx yy = x*np.sin(phi) + y*np.cos(phi) + ty return(xx,yy) t = np.linspace(0,2*pi,6).reshape(6,1) limb_len = 1 x,y = pol2cart(t,1) num_square = 50 theta = pi/num_square phi = pi/5 fig, ax = plt.subplots() cmap = matplotlib.cm.get_cmap('hsv') Path = mpath.Path codes = [Path.MOVETO] + [Path.LINETO]*4 + [Path.CLOSEPOLY] for n in range(0, num_square): verts = np.hstack((x, y)) path = mpath.Path(limb_len*verts, codes) pathpatch = mpatches.PathPatch(path, facecolor=cmap((1.0*n)/num_square), edgecolor='white', linewidth=0.5) ax.add_patch(pathpatch) limb_len = limb_len*np.cos(phi)/np.cos(phi-theta) x,y = trans2d(x,y,0,0,theta) ax.axis('equal') plt.show()
nverts = nrects*(1+3+1) verts = np.zeros((nverts, 2)) codes = np.ones(nverts, int) * path.Path.LINETO codes[0::5] = path.Path.MOVETO codes[4::5] = path.Path.CLOSEPOLY verts[0::5,0] = left verts[0::5,1] = bottom verts[1::5,0] = left verts[1::5,1] = top verts[2::5,0] = right verts[2::5,1] = top verts[3::5,0] = right verts[3::5,1] = bottom barpath = path.Path(verts, codes) patch = patches.PathPatch(barpath, facecolor='blue', edgecolor='cyan', alpha=0.75) ax.add_patch(patch) ax.set_xlim(left[0], right[-1]) ax.set_ylim(bottom.min(), top.max()) def animate(i): # simulate new data coming in x = data[1:i] n, bins = np.histogram(x, np.append(left,right[-1])) top = bottom + n verts[1::5,1] = top verts[2::5,1] = top ani = animation.FuncAnimation(fig, animate, frames=iters, interval=5, repeat=False) plt.show()
def bell2(ax, x, y, px, py, w1, w2, h, phi, **kwargs): x = px w1 *= 2 r_ = np.r_ c_ = np.c_ d1 = 1 d2 = 1 d3 = .2 d4 = .5 d4L = .6 d5 = .1 d6 = .3 d7 = .5 + d4 + d4L w2 = w1 * 1.1 # Breite oben p1 = r_[x, y] p2 = r_[x - d1, y - d2] p3_0 = r_[x + w1, y] dp3 = r_[d1, -d2] p3 = p3_0 + dp3 p4 = r_[x + w1, y] # Ende ex-Kreis p5 = p3_0 - .1 * dp3 p6 = r_[x + w1, y + d4 - d3] p7 = r_[x + w1, y + d4] p7b = r_[x + w1, y + d4 + d4L] # Endpunkt Linie p8 = r_[x + w1, p7b[1] + d5] # Kontrollpunkt p9 = r_[x + w2, y + d7 - d6] p10 = r_[x + w2, y + d7] # obere rechte Ecke w3 = -(w2 - w1) p11 = r_[x + w3, y + d7] # obere linke Ecke p12 = r_[x + w3, p9[1]] # Kontrollpunkt p13 = r_[x, p8[1]] # Kontrollpunkt p14 = r_[x, p7b[1]] # S-Kurve Endpunkt p14b = r_[x, p7[1]] # Linie-Endpunkt p15 = r_[x, p6[1]] # senkrechter Konrollpunkt p16 = r_[x, y] + .1 * dp3 * r_[1, -1] # schräger Konrollpunkt p17 = r_[x, y] # schräger Konrollpunkt if 0: plot(p5, 'rx', ms=5) plot(p6, 'rx', ms=5) plot(p7, 'ro', ms=5) plot(p7b, 'go', ms=5) plot(p8, 'bo', ms=5) plot(p9, 'mo', ms=5) plot(p10, 'yo', ms=5) pathdata = [(Path.MOVETO, p1), (Path.CURVE4, p2), (Path.CURVE4, p3), (Path.CURVE4, p4), (Path.CURVE4, p5), (Path.CURVE4, p6), (Path.CURVE4, p7), (Path.LINETO, p7b), (Path.CURVE4, p8), (Path.CURVE4, p9), (Path.CURVE4, p10), (Path.LINETO, p11), (Path.CURVE4, p12), (Path.CURVE4, p13), (Path.CURVE4, p14), (Path.LINETO, p14b), (Path.CURVE4, p15), (Path.CURVE4, p16), (Path.CURVE4, p17), (Path.CLOSEPOLY, (x, y))] codes, verts = list(zip(*pathdata)) verts = np.array(verts).T verts[0, :] -= w1 / 2.0 # correct x pivot = np.array([[px, py]]).T # plot(pivot, 'ro', ms = 8) # plot([x,y], 'go', ms = 8) verts = np.dot(rotZ(phi), verts - pivot) + pivot verts = verts.T path = mpath.Path(verts, codes) patch = mpatches.PathPatch(path, **dark) ax.add_patch(patch)
for geom in feat.GetGeometryRef(): x = [geom.GetX(j) for j in range(geom.GetPointCount())] y = [geom.GetY(j) for j in range(geom.GetPointCount())] print(y) codes += [mpath.Path.MOVETO] + \ (len(x)-1)*[mpath.Path.LINETO] all_x += x all_y += y path = mpath.Path(np.column_stack((all_x,all_y)), codes) paths.append(path) # Add paths as patches to axes for path in paths: if idx==0: ax.add_patch(mpatches.PathPatch(path,color='C0')) else: ax.add_patch(mpatches.PathPatch(path,color='C1')) xBounds.append([np.min(all_x),np.max(all_x)]) yBounds.append([np.min(all_y),np.max(all_y)]) ax.set_xlim(np.min(np.array(xBounds)[:,0]),np.max(np.array(xBounds)[:,1])) ax.set_ylim(np.min(np.array(yBounds)[:,0]),np.max(np.array(yBounds)[:,1])) legend = [mpatches.Patch(color='C0', label='Train'),mpatches.Patch(color='C1', label='Valid')] plt.legend(handles=legend) plt.show()
def plot_skymap_tract(skyMap, tract=0, title=None, ax=None, nvisits_tab=None): """ Plot a tract from a skyMap. Parameters ---------- skyMap: lsst.skyMap.SkyMap The SkyMap object containing the tract and patch information. tract: int [0] The tract id of the desired tract to plot. title: str [None] Title of the tract plot. If None, the use `tract <id>`. ax: matplotlib.axes._subplots.AxesSubplot [None] The subplot object to contain the tract plot. If None, then make a new one. Returns ------- matplotlib.axes._subplots.AxesSubplot: The subplot containing the tract plot. """ if title is None: title = 'tract {}'.format(tract) tractInfo = skyMap[tract] tractBox = afwgeom.Box2D(tractInfo.getBBox()) tractPosList = tractBox.getCorners() wcs = tractInfo.getWcs() xNum, yNum = tractInfo.getNumPatches() if ax is None: fig = plt.figure(figsize=(12,8)) ax = fig.add_subplot(111) tract_center = wcs.pixelToSky(tractBox.getCenter())\ .getPosition(afw_geom.degrees) ax.text(tract_center[0], tract_center[1], '%d' % tract, size=16, ha="center", va="center", color='blue') for x in range(xNum): for y in range(yNum): patchInfo = tractInfo.getPatchInfo([x, y]) patchBox = afwgeom.Box2D(patchInfo.getOuterBBox()) pixelPatchList = patchBox.getCorners() path = make_patch(pixelPatchList, wcs) patch = patches.PathPatch(path, alpha=0.1, lw=1) ax.add_patch(patch) center = wcs.pixelToSky(patchBox.getCenter())\ .getPosition(afw_geom.degrees) if nvisits_tab is not None: nvisits = nvisits_tab[(nvisits_tab.tract==tract)&(nvisits_tab.patch_x==x)&(nvisits_tab.patch_y==y)].nvisits ax.text(center[0], center[1], '%d'%nvisits, size=6, ha="center", va="center") else: ax.text(center[0], center[1], '%d,%d'%(x,y), size=6, ha="center", va="center") skyPosList = [wcs.pixelToSky(pos).getPosition(afw_geom.degrees) for pos in tractPosList] ax.set_xlim(max(coord[0] for coord in skyPosList) + 1, min(coord[0] for coord in skyPosList) - 1) ax.set_ylim(min(coord[1] for coord in skyPosList) - 1, max(coord[1] for coord in skyPosList) + 1) ax.grid(ls=':',color='gray') ax.set_xlabel("RA (deg.)") ax.set_ylabel("Dec (deg.)") ax.set_title(title) return ax
def plot_focal_plane_fast(butler, visit, ax, color='red', opsimdb=None): """ Plot the CCDs in the LSST focal plane using CCD coordinates derived from the pointing info using the lsst.sims code. Notes ----- This function assumes that the obs_lsstSims package was used to define the camera geometry for the analysis of the simulated image data. Parameters ---------- butler: lsst.daf.persistence.Butler The data butler serving up data from the desired repo. visit: int The visit or obsHistID number. ax: matplotlib.axes._subplots.AxesSubplot The matplotlib subplot object onto which to plot the focal plane. color: str ['red'] Color to use for plotting the individual CCDs. opsimDb: str [None] Filename of the OpSim sqlite database. If None, then the dithered opsim db for Run1.1p is used. Returns ------- matplotlib.axes._subplots.AxesSubplot: The subplot object used for plotting. """ if opsimdb is None: opsimdb = '/global/projecta/projectdirs/lsst/groups/SSim/DC2/minion_1016_desc_dithered_v4.db' conn = sqlite3.connect(opsimdb) obs_gen = ObservationMetaDataGenerator(database=opsimdb, driver='sqlite') # The dithered pointing info was added to the baseline minion_1016 db. We query for the values # used for the desired visit. curs = conn.execute('''select descDitheredRA, descDitheredDec, descDitheredRotTelPos from summary where obshistid={}'''.format(visit)) ra, dec, rottelpos = [np.degrees(x) for x in curs][0] # An ObservationMetaData object used to pass the pointing info to the function in # lsst.sims.coordUtils that provides the CCD coordinates. obs_md = obs_gen.getObservationMetaData(obsHistID=visit, boundType='circle', boundLength=0.1)[0] obs_md.pointingRA = ra obs_md.pointingDec = dec obs_md.OpsimMetaData['rotTelPos'] = rottelpos # Convert the rotation angle of the sky relative to the telescope to the sky angle relative to # the camera. obs_md.rotSkyPos = getRotSkyPos(ra, dec, obs_md, rottelpos) # Use the butler to get the camera appropriate for this observation. If the data were from a # different camera, e.g., DECam or HSC, the corresponding camera objects with the associated # CCD geometries would be returned. camera = butler.get('camera') # Grab one of the calexps via its dataref so that we can ask for its filename and thereby infer # the location on disk of all of the calexps for this visit. dataref = list(butler.subset('calexp', visit=visit))[0] calexp_path = os.path.dirname(os.path.dirname(dataref.get('calexp_filename')[0])) # The following code is specific to the obs_lsstSim package and how it names CCDs # (e.g., "R:2,2 S:1,1") and formulates the path components for writing to disk. This # code would not work for a different obs_ package/camera implementation. # Re-order the CCD vertex list returned by the lsst_sims code so that a rectangle is plotted. corner_index = (np.array([0, 1, 3, 2]),) for det in camera: # Skip the WAVEFRONT and GUIDER CCDs if det.getType() != cameraGeom.SCIENCE: continue detname = det.getName() raft, sensor = re.match(r'R:?(\d,?\d)[_ ]S:?(\d,?\d)', detname).groups() raft = 'R' + raft.replace(',', '') sensor = 'S{}.fits'.format(sensor.replace(',', '')) if os.path.isfile(os.path.join(calexp_path, raft, sensor)): corners = np.array(lsst.sims.coordUtils.getCornerRaDec(detname, camera, obs_md)) path = make_patch(corners[corner_index]) ccd = patches.PathPatch(path, alpha=0.2, lw=1, color=color) ax.add_patch(ccd) return ax
#col = 'tab:red' col = 'azure' #circ = Circle((B3_pix[0][ind], B3_pix[1][ind]), radius=10, fill=False, color=col) #ax.add_patch(circ) #ax.plot(B3_pix[0][ind], B3_pix[1][ind], marker = 'x', linestyle='') cent_x = B3_pix[0][ind] cent_y = B3_pix[1][ind] Path = mpath.Path path_data = [(Path.MOVETO, [cent_x-5, cent_y+5]), (Path.LINETO, [cent_x+5, cent_y-5]), (Path.MOVETO, [cent_x-5, cent_y-5]), (Path.LINETO, [cent_x+5, cent_y+5])] codes, verts = zip(*path_data) path = mpath.Path(verts, codes) patch = mpatches.PathPatch(path, fill=False, color=col) patch.set_path_effects([PathEffects.Stroke(linewidth=2, foreground="black"), PathEffects.Normal()]) ax.add_patch(patch) if did not in IRid and did not in coupid and did not in Fbid and did not in new_srcs: #col = 'tab:blue' col = 'lavenderblush' circ = Circle((B3_pix[0][ind], B3_pix[1][ind]), radius=8, fill=False, color=col) circ.set_path_effects([PathEffects.Stroke(linewidth=2, foreground="black"), PathEffects.Normal()]) ax.add_patch(circ) #circ = Circle((B3_pix[0][ind], B3_pix[1][ind]), radius=10, fill=False, color=col) #ax.add_patch(circ)
def crop(ax): try: from IPython.html import widgets from IPython.display import display, Javascript from IPython.utils.traitlets import Unicode, Integer except ImportError: raise ImportError("You need IPython 2.0+ to use this feature.") try: import mpld3 from mpld3._display import NumpyEncoder from mpld3.urls import MPLD3_URL, D3_URL from mpld3.utils import get_id from mpld3.mplexporter import Exporter from mpld3.mpld3renderer import MPLD3Renderer except ImportError: raise ImportError("You need mpld3 v0.3 to use this feature.") fig = None if isinstance(ax, mpl.figure.Figure): fig = ax ax = fig.axes[0] xmin, xmax = ax.get_xlim() ymin, ymax = ax.get_ylim() Path = mpath.Path path_data = [ (Path.MOVETO, (xmin + 0.25 * (xmax - xmin), ymin + 0.25 * (ymax - ymin))), (Path.LINETO, (xmin + 0.25 * (xmax - xmin), ymin + 0.75 * (ymax - ymin))), (Path.LINETO, (xmin + 0.75 * (xmax - xmin), ymin + 0.75 * (ymax - ymin))), (Path.LINETO, (xmin + 0.75 * (xmax - xmin), ymin + 0.25 * (ymax - ymin))), (Path.CLOSEPOLY, (xmin + 0.75 * (xmax - xmin), ymin + 0.25 * (ymax - ymin))), ] codes, verts = zip(*path_data) path = mpath.Path(verts, codes) patch = mpatches.PathPatch(path, facecolor='r', alpha=0.5) ax.add_patch(patch) fig = ax.figure # plot control points and connecting lines x, y = zip(*path.vertices[:-1]) points = ax.plot(x, y, 'go', ms=10) line = ax.plot(x, y, '-k') ax.set_title("Drag Points to Change Path", fontsize=18) mpld3.plugins.connect(ax.figure, LinkedDragPlugin(points[0], line[0], patch)) renderer = MPLD3Renderer() Exporter(renderer, close_mpl=False).run(fig) fig, figure_json, extra_css, extra_js = renderer.finished_figures[0] my_widget = FigureWidget() my_widget.figure_json = json.dumps(figure_json, cls=NumpyEncoder) my_widget.extra_js = extra_js my_widget.extra_css = extra_css my_widget.figid = 'fig_' + get_id(fig) + str(int(random.random() * 1E10)) my_widget.idpts = mpld3.utils.get_id(points[0], 'pts') my_widget.x1 = xmin + 0.25 * (xmax - xmin) my_widget.x2 = xmin + 0.25 * (xmax - xmin) my_widget.x3 = xmin + 0.75 * (xmax - xmin) my_widget.x4 = xmin + 0.75 * (xmax - xmin) my_widget.y1 = ymin + 0.25 * (ymax - ymin) my_widget.y2 = ymin + 0.75 * (ymax - ymin) my_widget.y3 = ymin + 0.75 * (ymax - ymin) my_widget.y4 = ymin + 0.75 * (ymax - ymin) # Copy over preservation of axis information if looking at a FlowML # generated figure. if hasattr(fig, '_flowml_axis'): my_widget._flowml_axis = fig._flowml_axis display(Javascript(JAVASCRIPT)) fig.clf() return my_widget
def draw(g, layout=None, labels=False, figsize=(8,2), h_edge_draw='blue', rows=None): if not isinstance(g, BaseGraph): g = g.to_graph(zh=True) fig1 = plt.figure(figsize=figsize) ax = fig1.add_axes([0, 0, 1, 1], frameon=False) ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) vs_on_row = dict() # count the vertices on each row for v in g.vertices(): vs_on_row[g.row(v)] = vs_on_row.get(g.row(v), 0) + 1 if not layout: layout = circuit_layout(g) if rows: minrow,maxrow = rows vertices = [v for v in g.vertices() if (minrow<=g.row(v) and g.row(v) <=maxrow)] edges = [e for e in g.edges() if g.edge_s(e) in vertices and g.edge_t(e) in vertices] else: vertices = g.vertices() edges = g.edges() for e in edges: sp = layout[g.edge_s(e)] tp = layout[g.edge_t(e)] et = g.edge_type(e) n_row = vs_on_row.get(g.row(g.edge_s(e)), 0) dx = tp[0] - sp[0] dy = tp[1] - sp[1] bend_wire = (dx == 0) and h_edge_draw == 'blue' and n_row > 2 ecol = '#0099ff' if h_edge_draw == 'blue' and et == 2 else 'black' if bend_wire: bend = 0.25 mid = (sp[0] + 0.5 * dx + bend * dy, sp[1] + 0.5 * dy - bend * dx) pth = path.Path([sp,mid,tp], [path.Path.MOVETO, path.Path.CURVE3, path.Path.LINETO]) patch = patches.PathPatch(pth, edgecolor=ecol, linewidth=0.8, fill=False) ax.add_patch(patch) else: pos = 0.5 if dx == 0 or dy == 0 else 0.4 mid = (sp[0] + pos*dx, sp[1] + pos*dy) ax.add_line(lines.Line2D([sp[0],tp[0]],[sp[1],tp[1]], color=ecol, linewidth=0.8, zorder=0)) if h_edge_draw == 'box' and et == 2: #hadamard edge w = 0.2 h = 0.15 diag = math.sqrt(w*w+h*h) angle = math.atan2(dy,dx) angle2 = math.atan2(h,w) centre = (mid[0] - diag/2*math.cos(angle+angle2), mid[1] - diag/2*math.sin(angle+angle2)) ax.add_patch(patches.Rectangle(centre,w,h,angle=angle/math.pi*180,facecolor='yellow',edgecolor='black')) #plt.plot([sp[0],tp[0]],[sp[1],tp[1]], 'k', zorder=0, linewidth=0.8) for v in vertices: p = layout[v] t = g.type(v) a = g.phase(v) a_offset = 0.5 if t == VertexType.Z: ax.add_patch(patches.Circle(p, 0.2, facecolor='green', edgecolor='black', zorder=1)) elif t == VertexType.X: ax.add_patch(patches.Circle(p, 0.2, facecolor='red', edgecolor='black', zorder=1)) elif t == VertexType.H_BOX: ax.add_patch(patches.Rectangle((p[0]-0.1, p[1]-0.1), 0.2, 0.2, facecolor='yellow', edgecolor='black')) a_offset = 0.25 else: ax.add_patch(patches.Circle(p, 0.1, facecolor='black', edgecolor='black', zorder=1)) if labels: plt.text(p[0]+0.25, p[1]+0.25, str(v), ha='center', color='gray', fontsize=5) if a: plt.text(p[0], p[1]-a_offset, phase_to_s(a, t), ha='center', color='blue', fontsize=8) ax.axis('equal') plt.close() return fig1
def artist_reference(): import matplotlib.path as mpath import matplotlib.lines as mlines import matplotlib.patches as mpatches from matplotlib.collections import PatchCollection def label(xy, text): y = xy[ 1] - 0.15 # shift y-value for label so that it's below the artist plt.text(xy[0], y, text, ha="center", family='sans-serif', size=14) # ha = horizontalalignment fig, ax = plt.subplots() grid = np.mgrid[0.2:0.8:0.3, 0.2:0.8:0.3].reshape(2, -1).T patches = [] # add a circle circle = mpatches.Circle(grid[0], 0.1, ec="none") patches.append(circle) label(grid[0], "Circle") # add a rectangle rect = mpatches.Rectangle(grid[1] - [0.025, 0.05], 0.05, 0.1, ec="none") patches.append(rect) label(grid[1], "Rectangle") # add a wedge wedge = mpatches.Wedge(grid[2], 0.1, 30, 270, ec="none") patches.append(wedge) label(grid[2], "Wedge") # add a Polygon polygon = mpatches.RegularPolygon(grid[3], 5, 0.1) patches.append(polygon) label(grid[3], "Polygon") # add an ellipse ellipse = mpatches.Ellipse(grid[4], 0.2, 0.1) patches.append(ellipse) label(grid[4], "Ellipse") # add an arrow arrow = mpatches.Arrow(grid[5, 0] - 0.05, grid[5, 1] - 0.05, 0.1, 0.1, width=0.1) patches.append(arrow) label(grid[5], "Arrow") # add a path patch Path = mpath.Path path_data = [(Path.MOVETO, [0.018, -0.11]), (Path.CURVE4, [-0.031, -0.051]), (Path.CURVE4, [-0.115, 0.073]), (Path.CURVE4, [-0.03, 0.073]), (Path.LINETO, [-0.011, 0.039]), (Path.CURVE4, [0.043, 0.121]), (Path.CURVE4, [0.075, -0.005]), (Path.CURVE4, [0.035, -0.027]), (Path.CLOSEPOLY, [0.018, -0.11])] codes, verts = zip(*path_data) path = mpath.Path(verts + grid[6], codes) patch = mpatches.PathPatch(path) patches.append(patch) label(grid[6], "PathPatch") # add a fancy box fancybox = mpatches.FancyBboxPatch(grid[7] - [0.025, 0.05], 0.05, 0.1, boxstyle=mpatches.BoxStyle("Round", pad=0.02)) patches.append(fancybox) label(grid[7], "FancyBboxPatch") # add a line x, y = np.array([[-0.06, 0.0, 0.1], [0.05, -0.05, 0.05]]) line = mlines.Line2D(x + grid[8, 0], y + grid[8, 1], lw=5., alpha=0.3) label(grid[8], "Line2D") colors = np.linspace(0, 1, len(patches)) collection = PatchCollection(patches, cmap=plt.cm.hsv, alpha=0.3) collection.set_array(np.array(colors)) ax.add_collection(collection) ax.add_line(line) plt.subplots_adjust(left=0, right=1, bottom=0, top=1) plt.axis('equal') plt.axis('off') plt.show() pass
def map(h2: Histogram2D, ax: Axes, *, show_zero: bool = True, show_values: bool = False, show_colorbar: bool = True, x=None, y=None, **kwargs): """Coloured-rectangle plot of 2D histogram. Parameters ---------- show_zero : Whether to show coloured box for bins with 0 frequency (otherwise background). show_values : Whether to show labels with frequencies/densities in the middle of the bin text_color : Optional Colour of text descriptions text_alpha : Optional[float] Alpha for the text labels only x : Optional[Callable] Transformation of x bin coordinates y : Optional[Callable] Transformation of y bin coordinates zorder : float z-order in the axis (higher number above lower) See Also -------- image, polar_map, surface_map Notes ----- If you transform axes using x or y parameters, the deduction of axis limits does not work well automatically. Please, make sure to attend to it yourself. The densities in transformed maps are calculated from original bins. """ # Detect transformation transformed = False if x is not None or y is not None: if not x: x = lambda x, y: x if not y: y = lambda x, y: y transformed = True value_format = kwargs.pop("value_format", lambda x: str(x)) # TODO: Implement correctly the text_kwargs if isinstance(value_format, str): format_str = "{0:" + value_format + "}" value_format = lambda x: format_str.format(x) rect_args = {} if "zorder" in kwargs: rect_args["zorder"] = kwargs.pop("zorder") data = get_data(h2, cumulative=False, flatten=True, density=kwargs.pop("density", False)) cmap = _get_cmap(kwargs) norm, cmap_data = _get_cmap_data(data, kwargs) colors = cmap(cmap_data) xpos, ypos = (arr.flatten() for arr in h2.get_bin_left_edges()) dx, dy = (arr.flatten() for arr in h2.get_bin_widths()) text_x, text_y = (arr.flatten() for arr in h2.get_bin_centers()) _apply_xy_lims(ax, h2, data=data, kwargs=kwargs) _add_labels(ax, h2, kwargs) ax.autoscale_view() alphas = _get_alpha_data(cmap_data, kwargs) if np.isscalar(alphas): alphas = np.ones_like(data) * alphas for i in range(len(xpos)): bin_color = colors[i] alpha = alphas[i] if data[i] != 0 or show_zero: if not transformed: rect = plt.Rectangle([xpos[i], ypos[i]], dx[i], dy[i], facecolor=bin_color, edgecolor=kwargs.get( "grid_color", cmap(0.5)), lw=kwargs.get("lw", 0.5), alpha=alpha, **rect_args) tx, ty = text_x[i], text_y[i] else: # See http://matplotlib.org/users/path_tutorial.html points = ((xpos[i], ypos[i]), (xpos[i] + dx[i], ypos[i]), (xpos[i] + dx[i], ypos[i] + dy[i]), (xpos[i], ypos[i] + dy[i]), (xpos[i], ypos[i])) verts = [(x(*p), y(*p)) for p in points] codes = [ path.Path.MOVETO, path.Path.LINETO, path.Path.LINETO, path.Path.LINETO, path.Path.CLOSEPOLY, ] rect_path = path.Path(verts, codes) rect = patches.PathPatch(rect_path, facecolor=bin_color, edgecolor=kwargs.get( "grid_color", cmap(0.5)), lw=kwargs.get("lw", 0.5), alpha=alpha, **rect_args) tx = x(text_x[i], text_y[i]) ty = y(text_x[i], text_y[i]) ax.add_patch(rect) if show_values: text = value_format(data[i]) yiq_y = np.dot(bin_color[:3], [0.299, 0.587, 0.114]) text_color = kwargs.get("text_color", None) if not text_color: if yiq_y > 0.5: text_color = (0.0, 0.0, 0.0, kwargs.get("text_alpha", alpha)) else: text_color = (1.0, 1.0, 1.0, kwargs.get("text_alpha", alpha)) ax.text(tx, ty, text, horizontalalignment='center', verticalalignment='center', color=text_color, clip_on=True, **rect_args) if show_colorbar: _add_colorbar(ax, cmap, cmap_data, norm)
def _add_solids(self, X, Y, C): """ Draw the colors using :class:`~matplotlib.patches.Patch`; optionally add separators. """ # Save, set, and restore hold state to keep pcolor from # clearing the axes. Ordinarily this will not be needed, # since the axes object should already have hold set. _hold = self.ax.ishold() self.ax.hold(True) kw = { 'alpha': self.alpha, } n_segments = len(C) # ensure there are sufficent hatches hatches = self.mappable.hatches * n_segments patches = [] for i in xrange(len(X) - 1): val = C[i][0] hatch = hatches[i] xy = np.array([[X[i][0], Y[i][0]], [X[i][1], Y[i][0]], [X[i + 1][1], Y[i + 1][0]], [X[i + 1][0], Y[i + 1][1]]]) if self.orientation == 'horizontal': # if horizontal swap the xs and ys xy = xy[..., ::-1] patch = mpatches.PathPatch(mpath.Path(xy), facecolor=self.cmap(self.norm(val)), hatch=hatch, edgecolor='none', linewidth=0, antialiased=False, **kw) self.ax.add_patch(patch) patches.append(patch) if self.solids_patches: for solid in self.solids_patches: solid.remove() self.solids_patches = patches if self.dividers is not None: self.dividers.remove() self.dividers = None if self.drawedges: self.dividers = collections.LineCollection( self._edges(X, Y), colors=(mpl.rcParams['axes.edgecolor'], ), linewidths=(0.5 * mpl.rcParams['axes.linewidth'], )) self.ax.add_collection(self.dividers) self.ax.hold(_hold)
def locfdr(zz, bre = 120, df = 7, pct = 0., pct0 = 1./4, nulltype = 1, type = 0, plot = 1, mult = None, mlests = None, main = ' ', sw = 0, verbose = True, showplot = True, saveplot = False, saveroot = 'locfdr', saveext = 'pdf', savestamp = False): """Computes local false discovery rates. This is Abhinav Nellore's Python implementation of the R function locfdr() v1.1.7, originally written by Bradley Efron, Brit B. Turnbull, and Balasubramanian Narasimhan; and later enhanced by Alyssa Frazee, Leonardo Collado-Torres, and Jeffrey Leek (see https://github.com/alyssafrazee/derfinder/blob/master/R/locfdrFit.R ). It is licensed under the GNU GPL v2. See COPYING for more information. The port is relatively faithful. Variable names are almost precisely the same; if the original variable name contained a period, that period is replaced by an underscore here. (So 'Cov2.out' in the R is 'Cov2_out' in the Python.) To access returned values: (in R) --- results = locfdr(...) results$fdr results$z.2 (in Python) --- results = locfdr(...) results['fdr'] results['z_2'] Some returned values are pandas Series and DataFrames. An introduction to pandas data structures is available at http://pandas.pydata.org/pandas-docs/dev/dsintro.html . A nearly complete description of arguments and returned values may be found at http://cran.r-project.org/web/packages/locfdr/vignettes/locfdr-example.pdf . Additional arguments in this version: verbose: (True or False) --- If True, outputs warnings. showplot: (True or False) --- If True, displays plot. Ignored if plot = 0. saveplot: (True or False) --- If True, saves plot according to constraints specified by saveroot, saveext, and savestamp. Ignored if plot = 0. saveroot: (Any string that constitutes a valid filename.) --- Specifies prefix of file to save. Ignored if saveplot = False. saveext: (Most valid image file extensions work here. Try 'png', 'pdf', 'ps', 'eps', or 'svg'.) --- Selects file format and extension. Ignored if saveplot = False. savestamp: (True or False) --- If True, date/timestamp is appended to filename prefix; this helps prevent overwriting old saves. Ignored if saveplot = False. Additional returned values in this version: yt: Heights of pink histogram bars that appear on the plots (i.e., heights of alt. density's histogram). x: Locations of pinkfl histogram bars that appear on the plots (locations of alt. density's histogram). mlest_lo AND mlest_hi: If the function outputs a warning message that reads "please rerun with mlest parameters = ...", these parameters are contained in mlest_lo and mlest_hi . needsfix: 1 if a rerun warning is output; otherwise 0. nulldens: y-values of estimated null distribution density. nulldens: y-values of estimated full (mixture) density.""" call = it.stack() zz = np.array(zz) mlest_lo = None mlest_hi = None yt = None x = None needsfix = 0 try: brelength = len(bre) lo = min(bre) up = max(bre) bre = brelength except TypeError: try: len(pct) lo = pct[0] up = pct[1] # the following line is present to mimic how R handles [if (pct > 0)] (see code below) when pct is an array pct = pct[0] except TypeError: if pct == 0: lo = min(zz) up = max(zz) elif pct < 0: med = np.median(zz) lo = med + (1 - pct) * (min(zz) - med) up = med + (1 - pct) * (max(zz) - med) elif pct > 0: lo = np.percentile(zz, pct * 100) up = np.percentile(zz, (1 - pct) * 100) zzz = np.array([max(min(el, up), lo) for el in zz]) breaks = np.linspace(lo, up, bre) x = (breaks[1:] + breaks[0:-1]) / 2. y = np.histogram(zzz, bins = len(breaks) - 1)[0] yall = y K = len(y) N = len(zz) if pct > 0: y[0] = min(y[0], 1.) y[K-1] = min(y[K-1], 1) if not type: basismatrix = rf.ns(x, df) X = np.ones((basismatrix.shape[0], basismatrix.shape[1]+1), dtype=np.float64) X[:, 1:] = basismatrix f = glm("y ~ basismatrix", data = dict(y=np.matrix(y).transpose(), basismatrix=basismatrix), family=families.Poisson()).fit().fittedvalues else: basismatrix = rf.poly(x, df) X = np.ones((basismatrix.shape[0], basismatrix.shape[1]+1), dtype=np.float64) X[:, 1:] = basismatrix f = glm("y ~ basismatrix", data = dict(y=np.matrix(y).transpose(), basismatrix=basismatrix), family=families.Poisson()).fit().fittedvalues fulldens = f l = np.log(f) Fl = f.cumsum() Fr = f[::-1].cumsum() D = ((y - f) / np.sqrt((f + 1))) D = sum(np.power(D[1:(K-1)], 2)) / (K - 2 - df) if D > 1.5: wa.warn("f(z) misfit = " + str(round(D,1)) + ". Rerun with larger df.") if nulltype == 3: fp0 = pd.DataFrame(np.zeros((6,4)).fill(np.nan), index=['thest', 'theSD', 'mlest', 'mleSD', 'cmest', 'cmeSD'], columns=['delta', 'sigleft', 'p0', 'sigright']) else: fp0 = pd.DataFrame(np.zeros((6,3)).fill(np.nan), index=['thest', 'theSD', 'mlest', 'mleSD', 'cmest', 'cmeSD'], columns=['delta', 'sigma', 'p0']) fp0.loc['thest'][0:2] = np.array([0,1]) fp0.loc['theSD'][0:2] = 0 imax = np.where(max(l)==l)[0][0] xmax = x[imax] try: len(pct) pctlo = pct0[0] pctup = pct0[1] except TypeError: pctup = 1 - pct0 pctlo = pct0 lo0 = np.percentile(zz, pctlo*100) hi0 = np.percentile(zz, pctup*100) nx = len(x) i0 = np.array([i for i, el in enumerate(x) if el > lo0 and el < hi0]) x0 = np.array([el for el in x if el > lo0 and el < hi0]) y0 = np.array([el for i,el in enumerate(l) if x[i] > lo0 and x[i] < hi0]) xsubtract = x0 - xmax X00 = np.zeros((2, len(xsubtract))) if nulltype == 3: X00[0, :] = np.power(xsubtract, 2) X00[1, :] = [max(el, 0)*max(el, 0) for el in xsubtract] else: X00[0, :] = xsubtract X00[1, :] = np.power(xsubtract, 2) X00 = X00.transpose() co = glm("y0 ~ X00", data = dict(y0=y0, X00=X00)).fit().params # these errors may not be necessary if nulltype == 3 and ((pd.isnull(co[1]) or pd.isnull(co[2])) or (co[1] >= 0 or co[1] + co[2] >= 0)): raise EstimationError('CM estimation failed. Rerun with nulltype = 1 or 2.') elif pd.isnull(co[2]) or co[2] >= 0: if nulltype == 2: raise EstimationError('CM estimation failed. Rerun with nulltype = 1.') elif nulltype != 3: xsubtract2 = x - xmax X0 = np.ones((3, len(xsubtract2))) X0[1, :] = xsubtract2 X0[2, :] = np.power(xsubtract2, 2) X0 = X0.transpose() wa.warn('CM estimation failed; middle of histogram nonnormal') else: xsubtract2 = x - xmax X0 = np.ones((3, len(xsubtract2))) if nulltype == 3: X0[1, :] = np.power(xsubtract2, 2) X0[2, :] = [max(el, 0)*max(el, 0) for el in xsubtract2] sigs = np.array([1/np.sqrt(-2*co[1]), 1/np.sqrt(-2*(co[1]+co[2]))]) fp0.loc['cmest'][0] = xmax fp0.loc['cmest'][1] = sigs[0] fp0.loc['cmest'][3] = sigs[1] else: X0[1, :] = xsubtract2 X0[2, :] = np.power(xsubtract2, 2) xmaxx = -co[1] / (2 * co[2]) + xmax sighat = 1 / np.sqrt(-2 * co[2]) fp0.loc['cmest'][[0,1]] = [xmaxx, sighat] X0 = X0.transpose() l0 = np.array((X0 * np.matrix(co).transpose()).transpose())[0] f0 = np.exp(l0) p0 = sum(f0) / float(sum(f)) f0 = f0 / p0 fp0.loc['cmest'][2] = p0 b = 4.3 * np.exp(-0.26 * np.log10(N)) if mlests == None: med = np.median(zz) sc = (np.percentile(zz, 75) - np.percentile(zz, 25)) / (2 * stats.norm.ppf(.75)) mlests = lf.locmle(zz, xlim = np.array([med, b * sc])) if N > 5e05: if verbose: wa.warn('length(zz) > 500,000: an interval wider than the optimal one was used for maximum likelihood estimation. To use the optimal interval, rerun with mlests = [' + str(mlests[0]) + ', ' + str(b * mlests[1]) + '].') mlest_lo = mlests[0] mlest_hi = b * mlests[1] needsfix = 1 mlests = lf.locmle(zz, xlim = [med, sc]) if not pd.isnull(mlests[0]): if N > 5e05: b = 1 if nulltype == 1: Cov_in = {'x' : x, 'X' : X, 'f' : f, 'sw' : sw} ml_out = lf.locmle(zz, xlim = [mlests[0], b * mlests[1]], d = mlests[0], s = mlests[1], Cov_in = Cov_in) mlests = ml_out['mle'] else: mlests = lf.locmle(zz, xlim = [mlests[0], b * mlests[1]], d = mlests[0], s = mlests[1]) fp0.loc['mlest'][0:3] = mlests[0:3] fp0.loc['mleSD'][0:3] = mlests[3:6] if (not (pd.isnull(fp0.loc['mlest'][0]) or pd.isnull(fp0.loc['mlest'][1]) or pd.isnull(fp0.loc['cmest'][0]) or pd.isnull(fp0.loc['cmest'][1]))) and nulltype > 1: if abs(fp0.loc['cmest'][0] - mlests[0]) > 0.05 or abs(np.log(fp0.loc['cmest'][1] / mlests[1])) > 0.05: wa.warn('Discrepancy between central matching and maximum likelihood estimates. Consider rerunning with nulltype = 1.') if pd.isnull(mlests[0]): if nulltype == 1: if pd.isnull(fp0.loc['cmest'][1]): raise EstimationError('CM and ML estimation failed; middle of histogram is nonnormal.') else: raise EstimationError('ML estimation failed. Rerun with nulltype = 2.') else: wa.warn('ML estimation failed.') if nulltype < 2: xmaxx = mlests[0] xmax = mlests[0] delhat = mlests[0] sighat = mlests[1] p0 = mlests[2] f0 = np.array([stats.norm.pdf(el, delhat, sighat) for el in x]) f0 = (sum(f) * f0) / sum(f0) fdr = np.array([min(el, 1) for el in (p0 * (f0 / f))]) f00 = np.exp(-np.power(x, 2) / 2) f00 = (f00 * sum(f)) / sum(f00) p0theo = sum(f[i0]) / sum(f00[i0]) fp0.loc['thest'][2] = p0theo fdr0 = np.array([min(el, 1) for el in ((p0theo * f00) / f)]) f0p = p0 * f0 if nulltype == 0: f0p = p0theo * f00 F0l = f0p.cumsum() F0r = f0p[::-1].cumsum() Fdrl = F0l / Fl Fdrr = (F0r / Fr)[::-1] Int = (1 - fdr) * f * (fdr < 0.9) if np.any([x[i] <= xmax and fdr[i] == 1 for i in xrange(len(fdr))]): xxlo = min([el for i,el in enumerate(x) if el <= xmax and fdr[i] == 1]) else: xxlo = xmax if np.any([x[i] >= xmax and fdr[i] == 1 for i in xrange(len(fdr))]): xxhi = max([el for i,el in enumerate(x) if el >= xmax and fdr[i] == 1]) else: xxhi = xmax indextest = [i for i,el in enumerate(x) if el >= xxlo and el <= xxhi] if len(indextest) > 0: fdr[indextest] = 1 indextest = [i for i,el in enumerate(x) if el <= xmax and fdr0[i] == 1] if len(indextest) > 0: xxlo = min(x[indextest]) else: xxlo = xmax indextest = [i for i,el in enumerate(x) if el >= xmax and fdr0[i] == 1] if len(indextest) > 0: xxhi = max(x[indextest]) else: xxhi = xmax indextest = [i for i,el in enumerate(x) if el >= xxlo and el <= xxhi] if len(indextest) > 0: fdr0[indextest] = 1 if nulltype == 1: indextest = [i for i,el in enumerate(x) if el >= mlests[0] - mlests[1] and el <= mlests[0] + mlests[1]] fdr[indextest] = 1 fdr0[indextest] = 1 p1 = sum((1 - fdr) * f) / N p1theo = sum((1 - fdr0) * f) / N fall = f + (yall - y) Efdr = sum((1 - fdr) * fdr * fall) / sum((1 - fdr) * fall) Efdrtheo = sum((1 - fdr0) * fdr0 * fall) / sum((1 - fdr0) * fall) iup = [i for i,el in enumerate(x) if el >= xmax] ido = [i for i,el in enumerate(x) if el <= xmax] Eleft = sum((1 - fdr[ido]) * fdr[ido] * fall[ido]) / sum((1 - fdr[ido]) * fall[ido]) Eleft0 = sum((1 - fdr0[ido]) * fdr0[ido] * fall[ido])/sum((1 - fdr0[ido]) * fall[ido]) Eright = sum((1 - fdr[iup]) * fdr[iup] * fall[iup])/sum((1 - fdr[iup]) * fall[iup]) Eright0 = sum((1 - fdr0[iup]) * fdr0[iup] * fall[iup])/sum((1 - fdr0[iup]) * fall[iup]) Efdr = np.array([Efdr, Eleft, Eright, Efdrtheo, Eleft0, Eright0]) for i,el in enumerate(Efdr): if pd.isnull(el): Efdr[i] = 1 Efdr = pd.Series(Efdr, index=['Efdr', 'Eleft', 'Eright', 'Efdrtheo', 'Eleft0', 'Eright0']) if nulltype == 0: f1 = (1 - fdr0) * fall else: f1 = (1 - fdr) * fall if mult != None: try: mul = np.ones(len(mult) + 1) mul[1:] = mult except TypeError: mul = np.array([1, mult]) EE = np.zeros(len(mul)) for m in xrange(len(EE)): xe = np.sqrt(mul[m]) * x f1e = rf.approx(xe, f1, x, rule = 2, ties = 'mean') f1e = (f1e * sum(f1)) / sum(f1e) f0e = f0 p0e = p0 if nulltype == 0: f0e = f00 p0e = p0theo fdre = (p0e * f0e) / (p0e * f0e + f1e) EE[m] = sum(f1e * fdre) / sum(f1e) EE = EE / EE[0] EE = pd.Series(EE, index=mult) Cov2_out = lf.loccov2(X, X0, i0, f, fp0.loc['cmest'], N) Cov0_out = lf.loccov2(X, np.ones((len(x), 1)), i0, f, fp0.loc['thest'], N) if sw == 3: if nulltype == 0: Ilfdr = Cov0_out['Ilfdr'] elif nulltype == 1: Ilfdr = ml_out['Ilfdr'] elif nulltype == 2: Ilfdr = Cov2_out['Ilfdr'] else: raise InputError('When sw = 3, nulltype must be 0, 1, or 2.') return Ilfdr if nulltype == 0: Cov = Cov0_out['Cov'] elif nulltype == 1: Cov = ml_out['Cov_lfdr'] else: Cov = Cov2_out['Cov'] lfdrse = np.sqrt(np.diag(Cov)) fp0.loc['cmeSD'][0:3] = Cov2_out.loc['stdev'][[1,2,0]] if nulltype == 3: fp0.loc['cmeSD'][3] = fp0['cmeSD'][1] fp0.loc['theSD'][2] = Cov0_out['stdev'][0] if sw == 2: if nulltype == 0: pds = fp0.loc['thest'][[2, 0, 1]] stdev = fp0.loc['theSD'][[2, 0, 1]] pds_ = Cov0_out['pds_'].transpose() elif nulltype == 1: pds = fp0.loc['mlest'][[2, 0, 1]] stdev = fp0.loc['mleSD'][[2, 0, 1]] pds_ = ml_out['pds_'].transpose() elif nulltype == 2: pds = fp0.loc['cmest'][[2, 0, 1]] stdev = fp0.loc['cmeSD'][[2, 0, 1]] pds_ = Cov2_out['pds_'].transpose() else: raise InputError('When sw = 2, nulltype must equal 0, 1, or 2.') pds_ = pd.DataFrame(pds_, columns=['p0', 'delhat', 'sighat']) pds = pd.Series(pds, index=['p0', 'delhat', 'sighat']) stdev = pd.Series(stdev, index=['sdp0', 'sddelhat', 'sdsighat']) return pd.Series({'pds': pds, 'x': x, 'f': f, 'pds_' : pds_, 'stdev' : stdev}) p1 = np.arange(0.01, 1, 0.01) cdf1 = np.zeros((2,99)) cdf1[0, :] = p1 if nulltype == 0: fd = fdr0 else: fd = fdr for i in xrange(99): cdf1[1, i] = sum([el for j,el in enumerate(f1) if fd[j] <= p1[i]]) cdf1[1, :] = cdf1[1, :] / cdf1[1, -1] cdf1 = cdf1.transpose() if nulltype != 0: mat = pd.DataFrame(np.vstack((x, fdr, Fdrl, Fdrr, f, f0, f00, fdr0, yall, lfdrse, f1)), index=['x', 'fdr', 'Fdrleft', 'Fdrright', 'f', 'f0', 'f0theo', 'fdrtheo', 'counts', 'lfdrse', 'p1f1']) else: mat = pd.DataFrame(np.vstack((x, fdr, Fdrl, Fdrr, f, f0, f00, fdr0, yall, lfdrse, f1)), index=['x', 'fdr', 'Fdrltheo', 'Fdrrtheo', 'f', 'f0', 'f0theo', 'fdrtheo', 'counts', 'lfdrsetheo', 'p1f1']) z_2 = np.array([np.nan, np.nan]) m = sorted([(i, el) for i, el in enumerate(fd)], key=lambda nn: nn[1])[-1][0] if fd[-1] < 0.2: z_2[1] = rf.approx(fd[m:], x[m:], 0.2, ties = 'mean') if fd[0] < 0.2: z_2[0] = rf.approx(fd[0:m], x[0:m], 0.2, ties = 'mean') if nulltype == 0: nulldens = p0theo * f00 else: nulldens = p0 * f0 yt = np.array([max(el, 0) for el in (yall * (1 - fd))]) # construct plots if plot > 0: try: import matplotlib.pyplot as plt import matplotlib.patches as patches import matplotlib.path as path except ImportError: print 'matplotlib is required for plotting, but it was not found. Rerun with plot = 0 to turn off plots.' print 'locfdr-python was tested on matplotlib 1.3.0.' raise fig = plt.figure(figsize=(14, 8)) if plot == 4: histplot = fig.add_subplot(131) fdrFdrplot = fig.add_subplot(132) f1cdfplot = fig.add_subplot(133) elif plot == 2 or plot == 3: histplot = fig.add_subplot(121) if plot == 2: fdrFdrplot = fig.add_subplot(122) else: f1cdfplot = fig.add_subplot(122) elif plot == 1: histplot = fig.add_subplot(111) # construct histogram leftplt = breaks[:-1] rightplt = breaks[1:] bottomplt = np.zeros(len(leftplt)) topplt = bottomplt + y XYplt = np.array([[leftplt,leftplt,rightplt,rightplt], [bottomplt,topplt,topplt,bottomplt]]).transpose() barpath = path.Path.make_compound_path_from_polys(XYplt) patch = patches.PathPatch(barpath, facecolor='white', edgecolor='#302f2f') histplot.add_patch(patch) histplot.set_xlim(leftplt[0], rightplt[-1]) histplot.set_ylim(-1.5, (topplt.max()+1.5) * 0.1 + topplt.max()) histplot.set_title(main) for k in xrange(K): histplot.plot([x[k], x[k]], [0, yt[k]], color='#e31d76', linewidth = 2) if nulltype == 3: histplot.set_xlabel('delta = ' + str(round(xmax, 3)) + ', sigleft = ' + str(round(sigs[0], 3)) + ', sigright = ' + str(round(sigs[1], 3)) + ', p0 = ' + str(round(fp0.loc['cmest'][2], 3))) if nulltype == 1 or nulltype == 2: histplot.set_xlabel('MLE: delta = ' + str(round(mlests[0], 3)) + ', sigma = ' + str(round(mlests[1], 3)) + ', p0 = ' + str(round(mlests[2], 3)) + '\nCME: delta = ' + str(round(fp0.loc['cmest'][0], 3)) + ', sigma = ' + str(round(fp0.loc['cmest'][1], 3)) + ', p0 = ' + str(round(fp0.loc['cmest'][2], 3))) histplot.set_ylabel('Frequency') histplot.plot(x, f, color='#3bbf53', linewidth = 3) if nulltype == 0: histplot.plot(x, p0theo * f00, linewidth = 3, linestyle = 'dashed', color = 'blue') else: histplot.plot(x, p0 * f0, linewidth = 3, linestyle = 'dashed', color = 'blue') if not pd.isnull(z_2[1]): histplot.plot([z_2[1]], [-0.5], marker = '^', markersize = 16, markeredgecolor = 'red', markeredgewidth = 1.3, color = 'yellow') if not pd.isnull(z_2[0]): histplot.plot([z_2[0]], [-0.5], marker = '^', markersize = 16, markeredgecolor = 'red', markeredgewidth = 1.3, color = 'yellow') if nulltype == 1 or nulltype == 2: Ef = Efdr[0] elif nulltype == 0: Ef = Efdr[3] # construct fdr + Fdr plot if plot == 2 or plot == 4: if nulltype == 0: fdd = fdr0 else: fdd = fdr fdrFdrplot.plot(x, fdd, linewidth = 3, color = 'black') fdrFdrplot.plot(x, Fdrl, linewidth = 3, color = 'red', linestyle = 'dashed') fdrFdrplot.plot(x, Fdrr, linewidth = 3, color = 'green', linestyle = 'dashed') fdrFdrplot.set_ylim(-0.05, 1.1) fdrFdrplot.set_title('fdr (solid); Fdr\'s (dashed)') fdrFdrplot.set_xlabel('Efdr = ' + str(round(Ef, 3))) fdrFdrplot.set_ylabel('fdd (black), Fdrl (red), and Fdrr (green)') fdrFdrplot.plot([0, 0], [0, 1], linestyle = 'dotted', color = 'red') fdrFdrplot.axhline(linestyle = 'dotted', color = 'red') # construct plot of f1 cdf of estimated fdr curve if plot == 3 or plot == 4: if sum([1 for el in cdf1[:, 1] if pd.isnull(el)]) == cdf1.shape[0]: wa.warning('cdf1 is not available.') else: f1cdfplot.plot(cdf1[:, 0], cdf1[:, 1], linewidth = 3, color = 'black') f1cdfplot.set_xlabel('fdr level\nEfdr = ' + str(round(Ef, 3))) f1cdfplot.set_ylabel('f1 proportion < fdr level') f1cdfplot.set_title('f1 cdf of estimated fdr') f1cdfplot.set_ylim(0, 1) f1cdfplot.plot([0.2, 0.2], [0, cdf1[19, 1]], color = 'blue', linestyle = 'dashed') f1cdfplot.plot([0, 0.2], [cdf1[19, 1], cdf1[19, 1]], color = 'blue', linestyle = 'dashed') f1cdfplot.text(0.05, cdf1[19, 1], str(round(cdf1[19, 1], 2))) if saveplot: if savestamp: import time, datetime plt.savefig(saveroot + '_' + '-'.join(str(el) for el in list(tuple(datetime.datetime.now().timetuple())[:6])) + '.' + saveext) else: plt.savefig(saveroot + '.' + saveext) if showplot: plt.show() if nulltype == 0: ffdr = rf.approx(x, fdr0, zz, rule = 2, ties = 'ordered') else: ffdr = rf.approx(x, fdr, zz, rule = 2, ties = 'ordered') if mult != None: return {'fdr' : ffdr, 'fp0' : fp0, 'Efdr' : Efdr, 'cdf1' : cdf1, 'mat' : mat, 'z_2' : z_2, 'yt' : yt, 'call' : call, 'x' : x, 'mlest_lo' : mlest_lo, 'mlest_hi' : mlest_hi, 'needsfix' : needsfix, 'nulldens' : nulldens, 'fulldens' : fulldens, 'mult' : EE} return {'fdr' : ffdr, 'fp0' : fp0, 'Efdr' : Efdr, 'cdf1' : cdf1, 'mat' : mat, 'z_2' : z_2, 'yt' : yt, 'call' : call, 'x' : x, 'mlest_lo' : mlest_lo, 'mlest_hi' : mlest_hi, 'needsfix' : needsfix, 'nulldens' : nulldens, 'fulldens' : fulldens}
import rectangle codes = [ Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY, ] path = Path(rectangle.verts, codes) fig = plt.figure() ax = fig.add_subplot() ax.set_title('BFP/kg') patch = patches.PathPatch(path, facecolor='orange', lw=2) ax.add_patch(patch) fit = pd.read_csv("fit.csv", float_precision='high') fit['weight'] = ( fit['weight'].str.split()).apply(lambda x: float(x[0].replace(',', '.'))) fit['weight'] = fit['weight'].astype(float) fit['bfp'] = ( fit['bfp'].str.split()).apply(lambda x: float(x[0].replace(',', '.'))) fit['bfp'] = fit['bfp'].astype(float) # plt.scatter(fit['weight'][0], fit['bfp'][0], color='orange', marker='*') for i in range(len(fit.index) - 1):
def plot_one_double(zooniverse_id, pathdict, figno=1, savefig=False, anglepath='', dbltype='radio'): # Make a four-panel plot of the consensus identification with marked bending angle and position angle for a double source cons = consensus.checksum(zooniverse_id) subject = subjects.find_one({'zooniverse_id': zooniverse_id}) contours = get_contours(subject, pathdict) radio_components = contours['contours'] # Plot image answer = cons['answer'] # Download contour data sf_x = 500. / contours['width'] sf_y = 500. / contours['height'] verts_all = [] codes_all = [] components = contours['contours'] for comp in components: # Order of bounding box components is (xmax,ymax,xmin,ymin) comp_xmax, comp_ymax, comp_xmin, comp_ymin = comp[0]['bbox'] # Only plot radio components identified by the users as the consensus; # check on the xmax value to make sure for v in answer.itervalues(): if comp_xmax in v['xmax']: for idx, level in enumerate(comp): verts = [((p['x']) * sf_x, (p['y'] - 1) * sf_y) for p in level['arr']] codes = np.ones(len(verts), int) * Path.LINETO codes[0] = Path.MOVETO verts_all.extend(verts) codes_all.extend(codes) try: path = Path(verts_all, codes_all) patch_black = patches.PathPatch(path, facecolor='none', edgecolor='black', lw=1) except AssertionError: print 'Users found no components for consensus match of %s' % zooniverse_id # Plot the infrared results fig = plt.figure(figno, (15, 4)) fig.clf() ax3 = fig.add_subplot(143) ax4 = fig.add_subplot(144) colormaparr = [ cm.hot_r, cm.Blues, cm.RdPu, cm.Greens, cm.PuBu, cm.YlGn, cm.Greys ][::-1] colorarr = ['r', 'b', 'm', 'g', 'c', 'y', 'k'][::-1] if len(answer) > 0: # At least one galaxy was identified for idx, ans in enumerate(answer.itervalues()): if ans.has_key('peak_data'): # Plot the KDE map colormap = colormaparr.pop() ax3.imshow(np.rot90(ans['peak_data']['Z']), cmap=colormap, extent=[xmin, xmax, ymin, ymax]) # Plot individual sources color = colorarr.pop() ''' x_plot = [xt * 500./424 for xt in ans['ir_x'] if xt != -99.0] y_plot = [yt * 500./424 for yt in ans['ir_y'] if yt != -99.0] ''' x_plot, y_plot = ans['ir_x'], ans['ir_y'] ax3.scatter(x_plot, y_plot, c=color, marker='o', s=10, alpha=1. / len(x_plot)) ax4.plot([ans['ir_peak'][0]], [ans['ir_peak'][1]], color=color, marker='*', markersize=12) elif ans.has_key('ir'): color = colorarr.pop() x_plot, y_plot = ans['ir'] ax3.plot([x_plot], [y_plot], color=color, marker='o', markersize=2) ax4.plot([x_plot], [y_plot], color=color, marker='*', markersize=12) else: ax4.text(550, idx * 25, '#%i - no IR host' % idx, fontsize=11) ax3.set_xlim([0, 500]) ax3.set_ylim([500, 0]) ax3.set_title(zooniverse_id) ax3.set_aspect('equal') ax4.set_xlim([0, 500]) ax4.set_ylim([500, 0]) ax4.set_title('Consensus (%i/%i users)' % (cons['n_users'], cons['n_total'])) ax4.set_aspect('equal') # Display IR and radio images url_standard = subject['location']['standard'] im_standard = Image.open( cStringIO.StringIO(urllib.urlopen(url_standard).read())) ax1 = fig.add_subplot(141) ax1.imshow(im_standard, origin='upper') ax1.set_title('WISE') url_radio = subject['location']['radio'] im_radio = Image.open(cStringIO.StringIO(urllib.urlopen(url_radio).read())) ax2 = fig.add_subplot(142) ax2.imshow(im_radio, origin='upper') ax2.set_title(subject['metadata']['source']) ax2.get_yaxis().set_ticklabels([]) ax3.get_yaxis().set_ticklabels([]) # Plot contours identified as the consensus if len(answer) > 0: ax4.add_patch(patch_black) radio_centers = [] for component in components: bbox = component[0]['bbox'] # Draw centers of bounding boxes xradiocen = np.median((bbox[0], bbox[2])) / first_ir_scale_x yradiocen = np.median((bbox[1], bbox[3])) / first_ir_scale_y radio_centers.append((xradiocen, yradiocen)) ax4.scatter(xradiocen, yradiocen, c='g', marker='s', s=15, alpha=1) # Draw edge of bounding box xradiomin = bbox[2] / first_ir_scale_x xradiomax = bbox[0] / first_ir_scale_x yradiomin = bbox[3] / first_ir_scale_y yradiomax = bbox[1] / first_ir_scale_y ax4.plot([xradiomin, xradiomin, xradiomax, xradiomax, xradiomin], [yradiomin, yradiomax, yradiomax, yradiomin, yradiomin], color='g') for ans in answer: if answer[ans].has_key('ir_peak'): # Optical counterpart position xc, yc = answer[ans]['ir_peak'] # Position of radio sources for multi-peaked, single-component subjects if dbltype == "mps": local_maxima = mps_cc(subject, pathdict, plot=False, verbose=False) suffix = '' if len(local_maxima) == 1 else 's' assert len(local_maxima) >= 2, \ "%i peak%s in first radio component of %s; must have exactly 2 peaks to plot bending angle using mps method." % (len(local_maxima),suffix,zooniverse_id) x1 = local_maxima[0][1][0] / first_ir_scale_x y1 = local_maxima[0][1][1] / first_ir_scale_y x2 = local_maxima[1][1][0] / first_ir_scale_x y2 = local_maxima[1][1][1] / first_ir_scale_y ax4.scatter(x1, y1, color='darkorange', marker='s', s=15, alpha=1) ax4.scatter(x2, y2, color='darkorange', marker='s', s=15, alpha=1) # Position of radio sources for double-lobed, two-component subjects elif len(radio_centers) == 2: x1, y1 = radio_centers[0] x2, y2 = radio_centers[1] else: raise ValueError("Centers of radio boxes not defined.") m1 = (y1 - yc) / (x1 - xc) b1 = yc - m1 * xc m2 = (y2 - yc) / (x2 - xc) b2 = yc - m2 * xc xedge1 = 0 if x1 < xc else 500 yedge1 = y1 - (x1 - xedge1) * (yc - y1) / (xc - x1) xedge2 = 0 if x2 < xc else 500 yedge2 = y2 - (x2 - xedge2) * (yc - y2) / (xc - x2) # Draw and annotate the the bending angle ax4.plot([xedge1, xc], [yedge1, yc], color='orange', linestyle='--') ax4.plot([xedge2, xc], [yedge2, yc], color='orange', linestyle='--') alpha_deg = bending_angle(xc, yc, x1, y1, x2, y2) * 180 / np.pi ax4.text(550, 0, r'$\alpha$ = %.1f deg' % alpha_deg, fontsize=11) # Draw vector pointing north # Draw the bisector vector ''' yd = y_bisect(xc,yc,xedge1,yedge1,xedge2,yedge2) ax4.arrow(xc,yc,-xc,yd-yc,head_width=20, head_length=40, fc='blue', ec='blue') ''' # Compute the position angle with respect to north phi_deg = position_angle(xc, 500 - yc, x1, 500 - y1, x2, 500 - y2) * 180 / np.pi ax4.text(550, 50, r'$\phi$ = %.1f deg' % phi_deg, fontsize=11) ax4.arrow(xc, yc, 0, -yc, head_width=20, head_length=40, fc='grey', ec='grey', ls='dotted') else: print "No peak for %s" % zooniverse_id ax4.yaxis.tick_right() ax1.get_xaxis().set_ticks([0, 100, 200, 300, 400]) ax2.get_xaxis().set_ticks([0, 100, 200, 300, 400]) ax3.get_xaxis().set_ticks([0, 100, 200, 300, 400]) ax4.get_xaxis().set_ticks([0, 100, 200, 300, 400, 500]) plt.subplots_adjust(wspace=0.02) # Save hard copy of the figure if savefig: fig.savefig('%s/bending_angles/plots/individual/%sba_%s.pdf' % (rgz_dir, anglepath, zooniverse_id)) plt.close() else: plt.show() # Close figure after it's done; otherwise mpl complains about having thousands of stuff open return None
import matplotlib.pyplot as plt fig, ax = plt.subplots() Path = mpath.Path path_data = [ (Path.MOVETO, (1.58, -2.57)), (Path.LINETO, (0.35, -1.1)), (Path.LINETO, (-1.75, 2.0)), (Path.LINETO, (0.375, 2.0)), (Path.LINETO, (0.85, 1.15)), (Path.LINETO, (2.2, 3.2)), (Path.LINETO, (3, 0.05)), (Path.LINETO, (2.0, -0.5)), (Path.CLOSEPOLY, (1.58, -2.57)), ] codes, verts = zip(*path_data) path = mpath.Path(verts, codes) patch = mpatches.PathPatch(path, facecolor='orange', alpha=0.152343) ax.add_patch(patch) # plot control points and connecting lines x, y = zip(*path.vertices) line, = ax.plot(x, y, 'b-') ax.grid() ax.axis('equal') plt.show()
def sankey(ax, outputs=[100.], outlabels=None, inputs=[100.], inlabels='', dx=40, dy=10, outangle=45, w=3, inangle=30, offset=2, **kwargs): """Draw a Sankey diagram. outputs: array of outputs, should sum up to 100% outlabels: output labels (same length as outputs), or None (use default labels) or '' (no labels) inputs and inlabels: similar for inputs dx: horizontal elongation dy: vertical elongation outangle: output arrow angle [deg] w: output arrow shoulder inangle: input dip angle offset: text offset **kwargs: propagated to Patch (e.g., fill=False) Return (patch,[intexts,outtexts]). """ import matplotlib.patches as mpatches from matplotlib.path import Path outs = np.absolute(outputs) outsigns = np.sign(outputs) outsigns[-1] = 0 # Last output ins = np.absolute(inputs) insigns = np.sign(inputs) insigns[0] = 0 # First input assert sum(outs) == 100, "Outputs don't sum up to 100%" assert sum(ins) == 100, "Inputs don't sum up to 100%" def add_output(path, loss, sign=1): # Arrow tip height h = (loss / 2 + w) * np.tan(outangle / 180. * np.pi) move, (x, y) = path[-1] # Use last point as reference if sign == 0: # Final loss (horizontal) path.extend([ (Path.LINETO, [x + dx, y]), (Path.LINETO, [x + dx, y + w]), (Path.LINETO, [x + dx + h, y - loss / 2]), # Tip (Path.LINETO, [x + dx, y - loss - w]), (Path.LINETO, [x + dx, y - loss]) ]) outtips.append((sign, path[-3][1])) else: # Intermediate loss (vertical) path.extend([ (Path.CURVE4, [x + dx / 2, y]), (Path.CURVE4, [x + dx, y]), (Path.CURVE4, [x + dx, y + sign * dy]), (Path.LINETO, [x + dx - w, y + sign * dy]), # Tip (Path.LINETO, [x + dx + loss / 2, y + sign * (dy + h)]), (Path.LINETO, [x + dx + loss + w, y + sign * dy]), (Path.LINETO, [x + dx + loss, y + sign * dy]), (Path.CURVE3, [x + dx + loss, y - sign * loss]), (Path.CURVE3, [x + dx / 2 + loss, y - sign * loss]) ]) outtips.append((sign, path[-5][1])) def add_input(path, gain, sign=1): h = (gain / 2) * np.tan(inangle / 180. * np.pi) # Dip depth move, (x, y) = path[-1] # Use last point as reference if sign == 0: # First gain (horizontal) path.extend([ (Path.LINETO, [x - dx, y]), (Path.LINETO, [x - dx + h, y + gain / 2]), # Dip (Path.LINETO, [x - dx, y + gain]) ]) xd, yd = path[-2][1] # Dip position indips.append((sign, [xd - h, yd])) else: # Intermediate gain (vertical) path.extend([ (Path.CURVE4, [x - dx / 2, y]), (Path.CURVE4, [x - dx, y]), (Path.CURVE4, [x - dx, y + sign * dy]), # Dip (Path.LINETO, [x - dx - gain / 2, y + sign * (dy - h)]), (Path.LINETO, [x - dx - gain, y + sign * dy]), (Path.CURVE3, [x - dx - gain, y - sign * gain]), (Path.CURVE3, [x - dx / 2 - gain, y - sign * gain]) ]) xd, yd = path[-4][1] # Dip position indips.append((sign, [xd, yd + sign * h])) outtips = [] # Output arrow tip dir. and positions urpath = [(Path.MOVETO, [0, 100])] # 1st point of upper right path lrpath = [(Path.LINETO, [0, 0])] # 1st point of lower right path for loss, sign in zip(outs, outsigns): add_output(sign >= 0 and urpath or lrpath, loss, sign=sign) indips = [] # Input arrow tip dir. and positions llpath = [(Path.LINETO, [0, 0])] # 1st point of lower left path ulpath = [(Path.MOVETO, [0, 100])] # 1st point of upper left path for gain, sign in reversed(list(zip(ins, insigns))): add_input(sign <= 0 and llpath or ulpath, gain, sign=sign) def revert(path): """A path is not just revertable by path[::-1] because of Bezier curves.""" rpath = [] nextmove = Path.LINETO for move, pos in path[::-1]: rpath.append((nextmove, pos)) nextmove = move return rpath # Concatenate subpathes in correct order path = urpath + revert(lrpath) + llpath + revert(ulpath) codes, verts = zip(*path) verts = np.array(verts) # Path patch path = Path(verts, codes) patch = mpatches.PathPatch(path, **kwargs) ax.add_patch(patch) if False: # DEBUG print("urpath", urpath) print("lrpath", revert(lrpath)) print("llpath", llpath) print("ulpath", revert(ulpath)) xs, ys = zip(*verts) ax.plot(xs, ys, 'go-') # Labels def set_labels(labels, values): """Set or check labels according to values.""" if labels == '': # No labels return labels elif labels is None: # Default labels return ['%2d%%' % val for val in values] else: assert len(labels) == len(values) return labels def put_labels(labels, positions, output=True): """Put labels to positions.""" texts = [] lbls = output and labels or labels[::-1] for i, label in enumerate(lbls): s, (x, y) = positions[i] # Label direction and position if s == 0: t = ax.text(x + offset, y, label, ha=output and 'left' or 'right', va='center') elif s > 0: t = ax.text(x, y + offset, label, ha='center', va='bottom') else: t = ax.text(x, y - offset, label, ha='center', va='top') texts.append(t) return texts outlabels = set_labels(outlabels, outs) outtexts = put_labels(outlabels, outtips, output=True) inlabels = set_labels(inlabels, ins) intexts = put_labels(inlabels, indips, output=False) # Axes management ax.set_xlim(verts[:, 0].min() - dx, verts[:, 0].max() + dx) ax.set_ylim(verts[:, 1].min() - dy, verts[:, 1].max() + dy) ax.set_aspect('equal', adjustable='datalim') return patch, [intexts, outtexts]
def get_random_shape(): out = [] black_type = random.randint(0, 9) if black_type == 0: src_tmp = np.array(np.zeros((128, 128)), dtype='uint8') point_num = 10 point_list = [] left_x = random.randint(0, 127) left_y = random.randint(0, 127) for i in range(point_num): center_x = random.randint(0, 5) center_y = random.randint(0, 5) point_list.append((left_x + center_x, left_y + center_y)) point_list = np.array(point_list) hull = cv.convexHull(point_list) # print(hull) src_tmp = cv.drawContours(src_tmp, [hull], 0, 255, -1) src_tmp = rotato(src_tmp, random.randint(0, 360), 1, hull[0][0]) out = src_tmp > 125 return np.where(out, 1.0, 0) elif black_type == 1: src_tmp = np.array(np.zeros((128, 128)), dtype='uint8') point_num = 15 point_list = [] left_x = random.randint(0, 127) left_y = random.randint(0, 127) for i in range(point_num): center_x = random.randint(0, 8) center_y = random.randint(0, 8) point_list.append((left_x + center_x, left_y + center_y)) point_list = np.array(point_list) hull = cv.convexHull(point_list) # print(hull) src_tmp = cv.drawContours(src_tmp, [hull], 0, 255, -1) src_tmp = rotato(src_tmp, random.randint(0, 360), 1, hull[0][0]) out = src_tmp > 125 return np.where(out, 1.0, 0) elif black_type == 2 or black_type == 8: src_tmp = np.array(np.zeros((128, 128)), dtype='uint8') point_num = 15 point_list = [] left_x = random.randint(0, 127) left_y = random.randint(0, 127) for i in range(point_num): center_x = random.randint(0, 10) center_y = random.randint(0, 30) point_list.append((left_x + center_x, left_y + center_y)) point_list = np.array(point_list) hull = cv.convexHull(point_list) src_tmp = cv.drawContours(src_tmp, [hull], 0, 255, -1) src_tmp = rotato(src_tmp, random.randint(0, 360), 1, hull[0][0]) out = src_tmp > 125 return np.where(out, 1.0, 0) elif black_type == 9: src_tmp = np.array(np.zeros((128, 128)), dtype='uint8') point_num = 15 point_list = [] left_x = random.randint(0, 127) left_y = random.randint(0, 127) for i in range(point_num): center_x = random.randint(0, 30) center_y = random.randint(0, 30) point_list.append((left_x + center_x, left_y + center_y)) point_list = np.array(point_list) hull = cv.convexHull(point_list) src_tmp = cv.drawContours(src_tmp, [hull], 0, 255, -1) src_tmp = rotato(src_tmp, random.randint(0, 360), 1, hull[0][0]) out = src_tmp > 125 return np.where(out, 1.0, 0) elif black_type == 3 or black_type == 6: src_tmp = np.array(np.zeros((128, 128)), dtype='uint8') point_num = 10 point_list = [] left_x = random.randint(0, 127) left_y = random.randint(0, 127) for i in range(point_num): center_x = random.randint(0, 30) center_y = random.randint(0, 1) point_list.append((left_x + center_x, left_y + center_y)) point_list = np.array(point_list) hull = cv.convexHull(point_list) # print(hull) src_tmp = cv.drawContours(src_tmp, [hull], 0, 255, -1) src_tmp = rotato(src_tmp, random.randint(0, 360), 1, hull[0][0]) out = src_tmp > 125 return np.where(out, 1.0, 0) elif black_type == 4: src_tmp = np.array(np.zeros((128, 128)), dtype='uint8') left_x = random.randint(0, 50) left_y = random.randint(0, 50) right_x = random.randint(80, 127) right_y = random.randint(80, 127) src_tmp = cv.line(src_tmp, (left_x, left_y), (right_x, right_y), 255, random.randint(1, 2), lineType=cv.LINE_AA) src_tmp = rotato(src_tmp, random.randint(0, 360), 1, (64, 64)) out = src_tmp > 125 return np.where(out, 1.0, 0) elif black_type == 5 or black_type == 7: n = random.randint(3, 5) r = 0.7 N = n * 3 + 1 # number of points in the Path # There is the initial point and 3 points per cubic bezier curve. Thus, the curve will only pass though n points, which will be the sharp edges, the other 2 modify the shape of the bezier curve angles = np.linspace(0, 2 * np.pi, N) codes = np.full(N, Path.CURVE4) codes[0] = Path.MOVETO verts = np.stack((np.cos(angles), np.sin(angles))).T * ( 2 * r * np.random.random(N) + 1 - r)[:, None] verts[-1, :] = verts[ 0, :] # Using this instad of Path.CLOSEPOLY avoids an innecessary straight line path = Path(verts, codes) fig = plt.figure() ax = fig.add_subplot(111) patch = patches.PathPatch(path, facecolor='none', lw=2) ax.add_patch(patch) ax.set_xlim(np.min(verts) * 1.1, np.max(verts) * 1.1) ax.set_ylim(np.min(verts) * 1.1, np.max(verts) * 1.1) ax.axis('off') # removes the axis to leave only the shape plt.savefig('./1.png') plt.close() img = cv.imread('1.png', 0) try: _, c, h = cv.findContours(img, cv.RETR_TREE, cv.CHAIN_APPROX_NONE) except: c, h = cv.findContours(img, cv.RETR_TREE, cv.CHAIN_APPROX_NONE) temp = np.zeros(img.shape, np.uint8) * 255 cv.drawContours(temp, c, 1, 255, -1) temp = cv.resize(temp, (128, 128)) temp = np.where(temp > 128, get_weight((64, 64)), 0.) src_tmp = rotato(temp, random.randint(0, 360), random.randint(4, 8) / 10, center=(random.randint(30, 100), random.randint(30, 100))) return src_tmp
def print_diff(self, pca_modes, anm_modes): print("here I am in DIFF") import matplotlib.pyplot as plt from matplotlib.path import Path import matplotlib.patches as patches residues = self.ref_chain.getResnums() print_offset = residues[0] #Paper01:PCA-X-Ray: print_offset = 738 plt.rcParams.update({'font.size': 24}) plt.rcParams['xtick.major.pad'] = 10 plt.rcParams['ytick.major.pad'] = 10 a3d_pca = ((pca_modes[0].getArrayNx3())**2).sum(axis=1)**0.5 a3d_anm = ((anm_modes[0].getArrayNx3())**2).sum(axis=1)**0.5 a3d_all = a3d_pca - a3d_anm for count in range(1,6): #array with lenghts of vectors a3d_pca = ((pca_modes[count].getArrayNx3())**2).sum(axis=1)**0.5 a3d_anm = ((anm_modes[count].getArrayNx3())**2).sum(axis=1)**0.5 a3d_all = a3d_all + a3d_pca - a3d_anm show = plt.plot(a3d_all[:], label=("Difference"), lw=1.5) plt.xlabel('Residue index') plt.ylabel('|PCA| - |ANM|') locs,labels = plt.xticks() new_labels = ['%d' % (a+print_offset) for a in locs] plt.xticks(locs,new_labels) lgd = plt.legend(loc='center right', bbox_to_anchor=(1.65,0.5)) ##add boxes codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY, ] ### light green verts = [ (95, -2.0), # left, bottom (95, 2.0), # left, top (115, 2.0), # right, top (115, -2.0), # right, bottom (0., 0.), # ignored ] path = Path(verts, codes) #add box around area of interest ax = plt.subplot() patch = patches.PathPatch(path, facecolor='#CCFFCC', lw=1) #patch = patches.PathPatch(path, facecolor='lightgreen', lw=1) ax.add_patch(patch) plt.axhline(y=0.0,xmin=0,xmax=3,c="black",linewidth=1.0,zorder=0) plt.savefig(str(pca_modes)+"_all_DIFF.pdf", bbox_extra_artists=(lgd, ), bbox_inches='tight') plt.clf() for count in range(6): #array with lenghtes of vectors a3d = ((pca_modes[count].getArrayNx3())**2).sum(axis=1)**0.5 - ((anm_modes[count].getArrayNx3())**2).sum(axis=1)**0.5 show = plt.plot(a3d[:], label=("Mode "+str(count+1)), lw=1.5) plt.xlabel('Residue index') plt.ylabel('|PCA| - |ANM|') locs,labels = plt.xticks() new_labels = ['%d' % (a+print_offset) for a in locs] plt.xticks(locs,new_labels) lgd = plt.legend(loc='center right', bbox_to_anchor=(1.65,0.5)) ##add boxes codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY, ] ### light green verts = [ (95, -0.7), # left, bottom (95, 0.7), # left, top (115, 0.7), # right, top (115, -0.7), # right, bottom (0., 0.), # ignored ] path = Path(verts, codes) #add box around area of interest ax = plt.subplot() patch = patches.PathPatch(path, facecolor='#CCFFCC', lw=1) ax.add_patch(patch) plt.axhline(y=0.0,xmin=0,xmax=3,c="black",linewidth=1.0,zorder=0) plt.savefig(str(pca_modes)+"_ANM_PCA_DIFF.pdf", bbox_extra_artists=(lgd, ), bbox_inches='tight')
verts = list(polygon.exterior.coords) codes = [Path.LINETO] * len(verts) codes[0] = Path.MOVETO codes[-1] = Path.CLOSEPOLY path = Path(verts, codes) return path p_min = sess.run(concepts[label].p_min) p_max = sess.run(concepts[label].p_max) cuboids = zip(p_min, p_max) if not isnan(p_min[0][0]): core_path = _path_for_core(cuboids, 0, 1) core_patch = patches.PathPatch(core_path, facecolor='grey', lw=2, alpha=0.4) ax.add_patch(core_patch) elif ltn.default_type == "prototype": # plot the prototype prototypes = sess.run(concepts[label].prototypes) for p in prototypes: ax.scatter(p[0], p[1], marker='x') ax.set_title(label) yg = ax.scatter(xs, ys, c=colors, marker='o') cb = fig.colorbar(colmap) counter += 1 plt.show() elif args.plot and config["num_dimensions"] == 3:
def render_and_save(Verts, Codes, line_width=5, imsize=8, canvas_size=600, session_id='SESSION_ID', age='AGE', trial_num='TRIAL_NUM', category='CATEGORY', save=False): ''' input: line_width: how wide of strokes do we want? (int) imsize: how big of a picture do we want? (setting the size of the figure) canvas_size: original canvas size on tablet? out_path: where do you want to save your images? currently hardcoded below. output: rendered sketches into nested directories ''' ## where do you want to save your cumulative drawings? out_path = os.path.join('./cumulative_drawings', '{}_{}'.format(session_id, age), '{}_{}'.format(trial_num, category)) if not os.path.exists('./cumulative_drawings'): os.makedirs('./cumulative_drawings') if not os.path.exists( os.path.join('cumulative_drawings', '{}_{}'.format( session_id, age))): os.makedirs( os.path.join('cumulative_drawings', '{}_{}'.format(session_id, age))) verts = Verts[0] codes = Codes[0] for i, verts in enumerate(Verts): codes = Codes[i] fig = plt.figure(figsize=(imsize, imsize)) ax = plt.subplot(111) ax.axis('off') ax.set_xlim(0, canvas_size) ax.set_ylim(0, canvas_size) ### render sketch so far if len(verts) > 0: path = Path(verts, codes) patch = patches.PathPatch(path, facecolor='none', lw=line_width) ax.add_patch(patch) plt.gca().invert_yaxis( ) # y values increase as you go down in image plt.show() ## save out as png ## maybe to make it not render every single thing, use plt.ioff if save == True: if not os.path.exists(out_path): os.makedirs(out_path) fname = '{}_{}_{}_{}.png'.format(session_id, trial_num, category, i) filepath = os.path.join(out_path, fname) print filepath fig.savefig(filepath, bbox_inches='tight') plt.close(fig)
def plot_connectivity_circle(con, node_names, indices=None, n_lines=None, node_angles=None, node_width=None, node_colors=None, facecolor='black', textcolor='white', node_edgecolor='black', linewidth=1.5, colormap='hot', vmin=None, vmax=None, colorbar=True, title=None, colorbar_size=0.2, colorbar_pos=(-0.3, 0.1), fontsize_title=12, fontsize_names=8, fontsize_colorbar=8, padding=6., fig=None, subplot=111, interactive=True, node_linewidth=2., show=True): """Visualize connectivity as a circular graph. Parameters ---------- con : array Connectivity scores. Can be a square matrix, or a 1D array. If a 1D array is provided, "indices" has to be used to define the connection indices. node_names : list of str Node names. The order corresponds to the order in con. indices : tuple of arrays | None Two arrays with indices of connections for which the connections strenghts are defined in con. Only needed if con is a 1D array. n_lines : int | None If not None, only the n_lines strongest connections (strength=abs(con)) are drawn. node_angles : array, shape=(len(node_names,)) | None Array with node positions in degrees. If None, the nodes are equally spaced on the circle. See mne.viz.circular_layout. node_width : float | None Width of each node in degrees. If None, the minimum angle between any two nodes is used as the width. node_colors : list of tuples | list of str List with the color to use for each node. If fewer colors than nodes are provided, the colors will be repeated. Any color supported by matplotlib can be used, e.g., RGBA tuples, named colors. facecolor : str Color to use for background. See matplotlib.colors. textcolor : str Color to use for text. See matplotlib.colors. node_edgecolor : str Color to use for lines around nodes. See matplotlib.colors. linewidth : float Line width to use for connections. colormap : str Colormap to use for coloring the connections. vmin : float | None Minimum value for colormap. If None, it is determined automatically. vmax : float | None Maximum value for colormap. If None, it is determined automatically. colorbar : bool Display a colorbar or not. title : str The figure title. colorbar_size : float Size of the colorbar. colorbar_pos : 2-tuple Position of the colorbar. fontsize_title : int Font size to use for title. fontsize_names : int Font size to use for node names. fontsize_colorbar : int Font size to use for colorbar. padding : float Space to add around figure to accommodate long labels. fig : None | instance of matplotlib.pyplot.Figure The figure to use. If None, a new figure with the specified background color will be created. subplot : int | 3-tuple Location of the subplot when creating figures with multiple plots. E.g. 121 or (1, 2, 1) for 1 row, 2 columns, plot 1. See matplotlib.pyplot.subplot. interactive : bool When enabled, left-click on a node to show only connections to that node. Right-click shows all connections. node_linewidth : float Line with for nodes. show : bool Show figure if True. Returns ------- fig : instance of matplotlib.pyplot.Figure The figure handle. axes : instance of matplotlib.axes.PolarAxesSubplot The subplot handle. Notes ----- This code is based on the circle graph example by Nicolas P. Rougier http://www.labri.fr/perso/nrougier/coding/. By default, :func:`matplotlib.pyplot.savefig` does not take ``facecolor`` into account when saving, even if set when a figure is generated. This can be addressed via, e.g.:: >>> fig.savefig(fname_fig, facecolor='black') # doctest:+SKIP If ``facecolor`` is not set via :func:`matplotlib.pyplot.savefig`, the figure labels, title, and legend may be cut off in the output figure. """ import matplotlib.pyplot as plt import matplotlib.path as m_path import matplotlib.patches as m_patches n_nodes = len(node_names) if node_angles is not None: if len(node_angles) != n_nodes: raise ValueError('node_angles has to be the same length ' 'as node_names') # convert it to radians node_angles = node_angles * np.pi / 180 else: # uniform layout on unit circle node_angles = np.linspace(0, 2 * np.pi, n_nodes, endpoint=False) if node_width is None: # widths correspond to the minimum angle between two nodes dist_mat = node_angles[None, :] - node_angles[:, None] dist_mat[np.diag_indices(n_nodes)] = 1e9 node_width = np.min(np.abs(dist_mat)) else: node_width = node_width * np.pi / 180 if node_colors is not None: if len(node_colors) < n_nodes: node_colors = cycle(node_colors) else: # assign colors using colormap try: spectral = plt.cm.spectral except AttributeError: spectral = plt.cm.Spectral node_colors = [spectral(i / float(n_nodes)) for i in range(n_nodes)] # handle 1D and 2D connectivity information if con.ndim == 1: if indices is None: raise ValueError('indices has to be provided if con.ndim == 1') elif con.ndim == 2: if con.shape[0] != n_nodes or con.shape[1] != n_nodes: raise ValueError('con has to be 1D or a square matrix') # we use the lower-triangular part indices = np.tril_indices(n_nodes, -1) con = con[indices] else: raise ValueError('con has to be 1D or a square matrix') # get the colormap if isinstance(colormap, string_types): colormap = plt.get_cmap(colormap) # Make figure background the same colors as axes if fig is None: fig = plt.figure(figsize=(8, 8), facecolor=facecolor) # Use a polar axes if not isinstance(subplot, tuple): subplot = (subplot,) axes = plt.subplot(*subplot, polar=True) _set_ax_facecolor(axes, facecolor) # No ticks, we'll put our own plt.xticks([]) plt.yticks([]) # Set y axes limit, add additional space if requested plt.ylim(0, 10 + padding) # Remove the black axes border which may obscure the labels axes.spines['polar'].set_visible(False) # Draw lines between connected nodes, only draw the strongest connections if n_lines is not None and len(con) > n_lines: con_thresh = np.sort(np.abs(con).ravel())[-n_lines] else: con_thresh = 0. # get the connections which we are drawing and sort by connection strength # this will allow us to draw the strongest connections first con_abs = np.abs(con) con_draw_idx = np.where(con_abs >= con_thresh)[0] con = con[con_draw_idx] con_abs = con_abs[con_draw_idx] indices = [ind[con_draw_idx] for ind in indices] # now sort them sort_idx = np.argsort(con_abs) con_abs = con_abs[sort_idx] con = con[sort_idx] indices = [ind[sort_idx] for ind in indices] # Get vmin vmax for color scaling if vmin is None: vmin = np.min(con[np.abs(con) >= con_thresh]) if vmax is None: vmax = np.max(con) vrange = vmax - vmin # We want to add some "noise" to the start and end position of the # edges: We modulate the noise with the number of connections of the # node and the connection strength, such that the strongest connections # are closer to the node center nodes_n_con = np.zeros((n_nodes), dtype=np.int) for i, j in zip(indices[0], indices[1]): nodes_n_con[i] += 1 nodes_n_con[j] += 1 # initialize random number generator so plot is reproducible rng = np.random.mtrand.RandomState(seed=0) n_con = len(indices[0]) noise_max = 0.25 * node_width start_noise = rng.uniform(-noise_max, noise_max, n_con) end_noise = rng.uniform(-noise_max, noise_max, n_con) nodes_n_con_seen = np.zeros_like(nodes_n_con) for i, (start, end) in enumerate(zip(indices[0], indices[1])): nodes_n_con_seen[start] += 1 nodes_n_con_seen[end] += 1 start_noise[i] *= ((nodes_n_con[start] - nodes_n_con_seen[start]) / float(nodes_n_con[start])) end_noise[i] *= ((nodes_n_con[end] - nodes_n_con_seen[end]) / float(nodes_n_con[end])) # scale connectivity for colormap (vmin<=>0, vmax<=>1) con_val_scaled = (con - vmin) / vrange # Finally, we draw the connections for pos, (i, j) in enumerate(zip(indices[0], indices[1])): # Start point t0, r0 = node_angles[i], 10 # End point t1, r1 = node_angles[j], 10 # Some noise in start and end point t0 += start_noise[pos] t1 += end_noise[pos] verts = [(t0, r0), (t0, 5), (t1, 5), (t1, r1)] codes = [m_path.Path.MOVETO, m_path.Path.CURVE4, m_path.Path.CURVE4, m_path.Path.LINETO] path = m_path.Path(verts, codes) color = colormap(con_val_scaled[pos]) # Actual line patch = m_patches.PathPatch(path, fill=False, edgecolor=color, linewidth=linewidth, alpha=1.) axes.add_patch(patch) # Draw ring with colored nodes height = np.ones(n_nodes) * 1.0 bars = axes.bar(node_angles, height, width=node_width, bottom=9, edgecolor=node_edgecolor, lw=node_linewidth, facecolor='.9', align='center') for bar, color in zip(bars, node_colors): bar.set_facecolor(color) # Draw node labels angles_deg = 180 * node_angles / np.pi for name, angle_rad, angle_deg in zip(node_names, node_angles, angles_deg): if angle_deg >= 270: ha = 'left' else: # Flip the label, so text is always upright angle_deg += 180 ha = 'right' axes.text(angle_rad, 10.4, name, size=fontsize_names, rotation=angle_deg, rotation_mode='anchor', horizontalalignment=ha, verticalalignment='center', color=textcolor) if title is not None: plt.title(title, color=textcolor, fontsize=fontsize_title, axes=axes) if colorbar: sm = plt.cm.ScalarMappable(cmap=colormap, norm=plt.Normalize(vmin, vmax)) sm.set_array(np.linspace(vmin, vmax)) cb = plt.colorbar(sm, ax=axes, use_gridspec=False, shrink=colorbar_size, anchor=colorbar_pos) cb_yticks = plt.getp(cb.ax.axes, 'yticklabels') cb.ax.tick_params(labelsize=fontsize_colorbar) plt.setp(cb_yticks, color=textcolor) # Add callback for interaction if interactive: callback = partial(_plot_connectivity_circle_onpick, fig=fig, axes=axes, indices=indices, n_nodes=n_nodes, node_angles=node_angles) fig.canvas.mpl_connect('button_press_event', callback) plt_show(show) return fig, axes