def create_mask(dataset, batch_mask, dict_dir): mask_exists = [ extract_ids(f) for f in os.listdir(dict_dir[dataset]['Mask_Path']) ] global coco coco = COCO(dict_dir[dataset]['Ann_Small']) image_ids = [ id_ for id_ in load_ann_ids(dataset, dict_dir) if id_ not in mask_exists ] for img_ in image_ids[0:batch_mask]: annotations = annotation_image(img_) mask = coco.annToMask(annotations[0]) for i in range(len(annotations)): mask += coco.annToMask(annotations[i]) mask = mask.reshape((300, 300)) file_name = str(img_).zfill(12) + str('.jpg') print('File created:', file_name) mask[mask != 0] = 1 plt.viridis() plt.axis('off') plt.imshow(mask) plt.savefig(dict_dir[dataset]['Mask_Path'] + file_name, bbox_inches='tight', pad_inches=0)
def generate(observation, processing_name, toa_name): import matplotlib.pyplot as plt plt.viridis() if not os.path.exists(join(observation, processing_name)): meta = pickle.load(open(join(observation,"meta.pickle"),"rb")) spec = processing_specs[processing_name] kwargs = spec["generic"].copy() k = meta["tel"], meta["band"] if k not in spec: raise NoSpecError( "No processing spec for %s in %s" % (k, processing_name)) kwargs.update(spec[k]) pipe.process_observation(observation, processing_name, **kwargs) if not os.path.exists(join(observation, processing_name, toa_name)): meta = pickle.load(open(join( observation,processing_name,"process.pickle"),"rb")) spec = toa_specs[toa_name] kwargs = spec["generic"].copy() k = meta["tel"], meta["band"] if k not in spec: raise NoSpecError( "No TOA spec for %s in %s" % (k, toa_name)) kwargs.update(spec[k]) pipe.make_toas(observation, processing_name, toa_name, **kwargs) plt.close('all')
def plot_cam(geom, geom2d, geom1d, image, image2d, image1d): plt.viridis() plt.figure(figsize=(12, 3)) ax = plt.subplot(1, 3, 1) CameraDisplay(geom, image=image) plt.subplot(1, 3, 2, sharex=ax, sharey=ax) CameraDisplay(geom2d, image=image2d) plt.subplot(1, 3, 3, sharex=ax, sharey=ax) CameraDisplay(geom1d, image=image1d)
def plot_zeropoint(pars): """ Plot 2d histogram. Pars will be a dictionary containing: data, figure_id, vmax, title_str, xp,yp, searchrad """ from matplotlib import pyplot as plt xp = pars['xp'] yp = pars['yp'] searchrad = int(pars['searchrad'] + 0.5) plt.figure(num=pars['figure_id']) plt.clf() if pars['interactive']: plt.ion() else: plt.ioff() plt.imshow(pars['data'], vmin=0, vmax=pars['vmax'], interpolation='nearest') plt.viridis() plt.colorbar() plt.title(pars['title_str']) plt.plot(xp + searchrad, yp + searchrad, color='red', marker='+', markersize=24) plt.plot(searchrad, searchrad, color='yellow', marker='+', markersize=120) plt.text(searchrad, searchrad, "Offset=0,0", verticalalignment='bottom', color='yellow') plt.xlabel("Offset in X (pixels)") plt.ylabel("Offset in Y (pixels)") if pars['interactive']: plt.show() if pars['plotname']: suffix = pars['plotname'][-4:] output = pars['plotname'] if '.' not in suffix: output += '.png' format = 'png' else: if suffix[1:] in ['png', 'pdf', 'ps', 'eps', 'svg']: format = suffix[1:] plt.savefig(output, format=format)
def plot_zeropoint(pars): """ Plot 2d histogram. Pars will be a dictionary containing: data, figure_id, vmax, title_str, xp,yp, searchrad """ from matplotlib import pyplot as plt xp = pars['xp'] yp = pars['yp'] searchrad = int(pars['searchrad'] + 0.5) plt.figure(num=pars['figure_id']) plt.clf() if pars['interactive']: plt.ion() else: plt.ioff() plt.imshow(pars['data'], vmin=0, vmax=pars['vmax'], interpolation='nearest') plt.viridis() plt.colorbar() plt.title(pars['title_str']) plt.plot(xp + searchrad, yp + searchrad, color='red', marker='+', markersize=24) plt.plot(searchrad, searchrad, color='yellow', marker='+', markersize=120) plt.text(searchrad, searchrad, "Offset=0,0", verticalalignment='bottom', color='yellow') plt.xlabel("Offset in X (pixels)") plt.ylabel("Offset in Y (pixels)") if pars['interactive']: plt.show() if pars['plotname']: suffix = pars['plotname'][-4:] output = pars['plotname'] if '.' not in suffix: output += '.png' format = 'png' else: if suffix[1:] in ['png', 'pdf', 'ps', 'eps', 'svg']: format = suffix[1:] plt.savefig(output, format=format)
def bubbles_prmtr_by_prmtr(self, title, second_prmtr): self.conf_table = self.conf_table.dropna( subset=[second_prmtr, self.name]) first_prmtr_column = self.confirmed_planets_table_with_prmtr[ second_prmtr] second_prmtr_column = self.confirmed_planets_table_with_prmtr[ self.name] plt.scatter(second_prmtr_column, first_prmtr_column, s=first_prmtr_column * 30, c=first_prmtr_column, alpha=0.5) sec_index = columns.index(second_prmtr) plt.xlabel('{}'.format(self.rus_name)) plt.xticks(rotation=75) plt.ylabel('{}'.format(rus_columns[sec_index])) plt.title('{}'.format(title)) plt.viridis() plt.show()
def run_stats(a, e, showplot=True): """produce simulation statistics and graphs for (n_trials)""" # list of the total steps taken for each tiral steps_per_trial = [len(rewards) for _, rewards in a.rewards_dict.iteritems()] df_rows = ['steps to dest.', 'deadline'] df = pd.DataFrame([steps_per_trial, a.deadlines], index=df_rows) df = df.T dest_reached_before_deadline = str(sum(df['steps to dest.'] < df['deadline'])) title_str = 'LearningAgent reached dest. before deadline: ' + dest_reached_before_deadline + \ ' out of ' + str(len(steps_per_trial)) + ' trials' # set matplotlib parameters rc('axes', linewidth=2) rc('font', weight='bold') if showplot: # fig 1: plot cumulated rewards plt.figure() for trial_no, rewards in a.rewards_dict.iteritems(): cum_rewards = np.cumsum(rewards) plt.plot(cum_rewards, label=('trial ' + trial_no), linewidth=2) plt.xlabel('Step', fontweight='bold') plt.title("Cumulated rewards for separate trials", fontweight='bold') plt.legend(loc='lower right') plt.viridis() # fig 2: steps to dest. vs deadline df.plot(kind='bar') plt.ylim(0, df.values.max() + 5) plt.title(title_str, fontweight='bold') plt.xlabel('Trial No.', fontweight='bold') plt.ylabel('Steps taken to destination', fontweight='bold') # pd.set_option('precision', 1) # print(df.describe()) # print('Hard time limit: %d' % e.hard_time_limit) print(title_str) return dest_reached_before_deadline
def _plot_nut(t, nut): if nut is None: return print('Plotting nut ... ', end='') sys.stdout.flush() x = nut[:, 0] y = nut[:, 1] nut = nut[:, 3] plt.figure() plt.viridis() plt.tricontourf(x, y, nut / 15.11e-6, 64) plt.gca().set_aspect('equal') plt.colorbar(orientation='horizontal') plt.xlabel('x, m') plt.ylabel('y, m') plt.title(r'$\nu_t/\nu,\ t = {}\ s$'.format(t)) print('Done.') sys.stdout.flush() plt.savefig('nut.png', bbox_inches='tight', bbox_padding=0.5, dpi=150)
def animate(i): data = pd.read_csv(filename) # print(data) grid_data = data.loc[data['topic']=='Inverter/GridWatts'] pv_data = data.loc[data['topic']=='Inverter/PvWattsTotal'] load_data = data.loc[data['topic']=='Inverter/LoadWatts'] battery_data = data.loc[data['topic']=='Inverter/BatteryWatts'] # print(grid_data[['epochTime', 'value']]) # x = data['x_value'] # y1 = data['total_1'] # y2 = data['total_2'] plt.viridis() plt.cla() ax = plt.gca() grid_data_x = grid_data['epochTime'] ax.plot(grid_data_x, grid_data['value'], 'k', label='GridWatts') ax.plot(pv_data['epochTime'], pv_data['value'], label='PVWatts') ax.plot(load_data['epochTime'], load_data['value'], label='LoadWatts') ax.plot(battery_data['epochTime'], battery_data['value'], label='BatteryWatts') ax.legend(loc='best') plt.tight_layout() plt.gcf().autofmt_xdate() # plt.gca().xaxis.set_major_locator(mtick.FixedLocator(grid_data_x)) plt.gca().xaxis.set_major_formatter( mtick.FuncFormatter(lambda pos,_: time.strftime("%H:%M:%S",time.localtime(pos))) ) ax.text(0.1, 0.1,'Records: %d' % len(pv_data), horizontalalignment='center', verticalalignment='center', transform = ax.transAxes) if saveplot == True: plt.gcf().set_size_inches(16,9) plt.savefig(filename + ".png", dpi=100)
def _plot_velocity(t, vel): if vel is None: return print('Plotting velocity ... ', end='') sys.stdout.flush() x = vel[:, 0] y = vel[:, 1] Ux = vel[:, 3] Uy = vel[:, 4] Umag = np.sqrt(Ux * Ux + Uy * Uy) plt.figure() plt.viridis() plt.tricontourf(x, y, Umag, 64) plt.gca().set_aspect('equal') plt.colorbar(orientation='horizontal') plt.xlabel('x, m') plt.ylabel('y, m') plt.title('Velocity magnitude, t = {} s'.format(t)) print('Done.') sys.stdout.flush() plt.savefig('velocity.png', bbox_inches='tight', bbox_padding=0.5, dpi=150)
def support(data): """ Plot the support densities for a parcel. :param data: support densities for a parcel, as a 3D array """ density = numpy.ma.masked_where(data < 1e-5, data) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') X, Y, Z = numpy.mgrid[:density.shape[0], :density.shape[1], :density. shape[2]] img = ax.scatter(X, Y, Z, c=density.ravel(), cmap=plt.viridis()) fig.colorbar(img) plt.show()
def excalibur(true, preds, title=None, suptitle=None): sns.set_style('darkgrid') fig = plt.figure(figsize=(10, 7), dpi=100, facecolor='w', edgecolor='k') # o = np.argsort(true.flatten()) # points = zip(true[o], preds[o]) # print(1) plt.xlim([min(true), max(true)]) plt.ylim([min(true), max(true)]) # print(2) # plot_true = np.array([true[i] for i in range(len(true)) if min(true) < preds[i] and max(true) > preds[i]]) # plot_preds = np.array([preds[i] for i in range(len(preds)) if min(true) < preds[i] and max(true) > preds[i]]) plot_mask = np.logical_and(min(true) < preds, max(true) > preds) plot_true = true[plot_mask] plot_preds = preds[plot_mask] # print(3) # print("ABOUT TO POLYFIT") z = np.polyfit(plot_true.flatten(), plot_preds.flatten(), 1) p = np.poly1d(z) plt.plot(plot_true, p(plot_true), "r--") # print(4) colors = MinMaxScaler().fit_transform( np.power(np.abs(true - preds).reshape((len(true), 1)), 0.4)).flatten() # print(5) plt.scatter(true, preds, s=0.25, c=colors) plt.xlabel('True Value') plt.ylabel('Predicted Value') if suptitle is not None: plt.suptitle(suptitle) if title is not None: plt.title(title) plt.viridis() plt.show()
def plot_classes(self, three_d=False): ''' input 3d plot or 2d plot''' x = self.labeld_data[:, 0] y = self.labeld_data[:, 1] z = self.labeld_data[:, 2] labels = self.labeld_data[:, -1] if three_d: fig = plt.figure(figsize=(10, 8)) ax = fig.add_subplot(111, projection='3d') img = ax.scatter(x, y, z, c=labels, cmap=plt.viridis()) fig.colorbar(img) plt.show() else: img = plt.figure(figsize=(9, 6)) plt.scatter(x, y, c=labels, cmap='rainbow') #plot data plt.show()
def visualize_data(sp500_df: pd.DataFrame) -> None: sp500_df_corr = sp500_df.corr() data: np.ndarray = sp500_df_corr.values fig: plt.Figure = plt.figure() ax: plt.Axes = fig.add_subplot(1, 1, 1) heatmap = ax.pcolor(data, cmap=plt.viridis()) fig.colorbar(heatmap) ax.set_xticks(np.arange(data.shape[1]) + 0.5, minor=False) ax.set_yticks(np.arange(data.shape[0]) + 0.5, minor=False) ax.invert_yaxis() ax.xaxis.tick_top() column_labels = sp500_df_corr.columns row_labels = sp500_df_corr.index ax.set_xticklabels(column_labels) ax.set_yticklabels(row_labels) plt.xticks(rotation=90) heatmap.set_clim(-1, 1) plt.tight_layout() plt.show()
reconstructed_xaxis = [] reconstructed_yaxis = [] reconstructed_change = [] for i in range(195): for j in range(121): reconstructed_yaxis.append(j) reconstructed_xaxis.append(i) distance = [] for k in range(len(data)): dist_xy = dist([i, j], [reference_xaxis[k], reference_yaxis[k]]) distance.append([dist_xy, k]) distance.sort(key=lambda x: x[0]) distance_list = distance[:int(userinput)] average = 0 for l in range(len(distance_list)): lowest_k = distance_list[l][1] average += reference_change[lowest_k] average /= int(userinput) reconstructed_change.append(average) #print(reconstructed_yaxis) #mplot.scatter(reference_xaxis, reference_yaxis, c = reference_change) mplot.scatter(reconstructed_xaxis, reconstructed_yaxis, c=reconstructed_change) mplot.viridis() #mplot.scatter(xaxis, yaxis, c = "Black") mplot.plot(xaxis, yaxis, c="Black") mplot.show()
zi2 = RegularGridInterpolator((x, y), z.T, method='nearest')((xi, yi)) assert np.allclose(zi1, zi2) f = lambda x, y: x * y mid = lambda x: (x[1:] + x[:-1]) / 2. x = np.linspace(0, 2, 10) y = np.linspace(0, 2, 15) x_, y_ = mid(x), mid(y) z = f(*np.meshgrid(x_, y_)) # Example 2 xi = np.linspace(0, 2, 40) yi = np.linspace(0, 2, 60) xi_, yi_ = mid(xi), mid(yi) zi1 = EqualGridInterpolator((x_, y_), z.T, order=3)(np.meshgrid(xi_, yi_)) zi2 = EqualGridInterpolator((x_, y_), z.T)(np.meshgrid(xi_, yi_)) zi3 = EqualGridInterpolator((x_, y_), z.T, padding='nearest')(np.meshgrid(xi_, yi_)) plt.figure(figsize=(9, 9)) plt.viridis() plt.subplot(221) plt.pcolormesh(x, y, z) plt.subplot(222) plt.pcolormesh(xi, yi, np.ma.array(zi1, mask=np.isnan(zi1))) plt.subplot(223) plt.pcolormesh(xi, yi, np.ma.array(zi2, mask=np.isnan(zi2))) plt.subplot(224) plt.pcolormesh(xi, yi, zi3) plt.show()
# Separando a label das features X = df.values[:, :-1] y = df.values[:, -1] # Estratificação de dados e divisão de teste e treino X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.9, stratify=y, random_state=42) # Projeção no grafico de 4 dimensões (cor é a 4º Dimensão apresentada) # -------Execute ao proximas 4 linhas juntas-------# fig = plt.figure() ax = fig.add_subplot(111, projection='3d') img = ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=X[:, 3], cmap=plt.viridis()) fig.colorbar(img) # -------------------------------------------------# # MODELO CLASSIFICADOR # A acuracia vai varias de qual o melhor dependendo da quantidade de vizinhos # analisada. #--modelo sem scale # --kernel serve para classificar com multiclass model = SVC(random_state=1, kernel='poly') model.fit(X_train, y_train) y_pred = model.predict(X_test) acc = accuracy_score(y_test, y_pred) print("Acerto sem scale: ", acc * 100, '%')
def bayes(): #se carga el dataset dataset = pd.read_csv("Dataset_Bayes.csv") #Se imprime la cantidad de usuarios que ganaron y perdieron print(dataset.groupby('Gano').size()) #Imprime grafica de barras Gano vs Variables dataset.drop(['Gano'], axis=1).hist() plt.show() #se elimina userId, completer son irrelevantes para aplicar el metodo dataset_limpio = dataset.drop(['userId', 'completer'], axis=1) dataset_limpio.describe() # se limpia el dataset de valores NaN, Inf dataset_limpio = limpiar_dataset_Para_Bayes(dataset_limpio) #se elimna y obtiene la variable Gano con el fin de poder buscar las 5 mejores variables que pueden determinar si Gano o perdio a = dataset_limpio.drop(['Gano'], axis=1) b = dataset_limpio['Gano'] best = SelectKBest(k=5) a_new = best.fit_transform(a, b) a_new.shape selected = best.get_support(indices=True) print("Mejores 5 variables") print(a.columns[selected]) #Imprime grafica de correlación de pearson con respecto a las 5 mejores variables used_features = a.columns[selected] colormap = plt.viridis() plt.figure(figsize=(12, 12)) plt.title('Coeficiente de correlación de Pearson', y=1.05, size=15) sns.heatmap(dataset_limpio[used_features].astype(float).corr(), linewidths=0.1, vmax=1.0, square=True, cmap=colormap, linecolor='white', annot=True) plt.show() #se dividen los datos de entrada en 'entrenamiento' y 'pruebas' a_entrenamiento, a_pruebas = train_test_split(dataset_limpio, test_size=0.2, random_state=6) b_entrenamiento = a_entrenamiento["Gano"] b_pruebas = a_pruebas["Gano"] gnb = GaussianNB() gnb.fit(a_entrenamiento[used_features].values, b_entrenamiento) y_pred = gnb.predict(a_pruebas[used_features]) print('Precisión en el set de Entrenamiento: {:.2f}'.format( gnb.score(a_entrenamiento[used_features], b_entrenamiento))) print('Precisión en el set de Pruebas: {:.2f}'.format( gnb.score(a_pruebas[used_features], b_pruebas))) #cinco mejores variables #'SRL', 'Atry to lecture', 'num_events', 'grade', 'cluster' #tomamos datos del dataset donde un usuario perdio y gano (0,1) con relacion a las 5 mejores variables print( gnb.predict([[1.666666667, 0, 2, 5.999999866, 0], [2.041666667, 150, 151, 62.00000048, 1]]))
max_iter=100, # Quantidade de interações maxima. random_state=1, # Semente randomica. n_jobs=2) # Quantidae de theads. k_means.fit(X) #------------------ Treinamento do modelo. y_pred = k_means.predict(X) #----- Predição. # accuracy acc = accuracy_score(y, y_pred) print('Acertos: ', acc * 100) # Visualização # 01 - Visualizando X e y em 3D fig = plt.figure() ax = fig.add_subplot(221, projection='3d') img = ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=y, cmap=plt.viridis()) fig.colorbar(img) # 02 - Visualizando X e y_pred em 3D fig = plt.figure() ax = fig.add_subplot(222, projection='3d') img = ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=y_pred, cmap=plt.viridis()) fig.colorbar(img) # 03 - Visualizando X e y plt.subplot(221), plt.scatter(X[:, 0], X[:, 1], c=y) plt.title('01 - X[:,0] e X[:,1] com y') plt.subplot(222), plt.scatter(X[:, 0], X[:, 1], c=y_pred) plt.title('01 - X[:,0] e X[:,1] com y_pred')
def HoughLine(self): A = cv2.imread(self.imgpath) w = A.shape[0] h = A.shape[1] plt.figure(figsize=(4, 3), dpi=120, facecolor='white') plt.imshow(cv2.cvtColor(A, cv2.COLOR_BGR2RGB)) plt.show() ## Crop image to snooker table boundaries hsv = cv2.cvtColor(A, cv2.COLOR_BGR2HSV) H = hsv[:, :, 0].astype(np.float) # isolate green H = np.zeros((w, h)) H[np.logical_and(hsv[:, :, 0] > 20, hsv[:, :, 0] < 90)] = 1 plt.imshow(H) plt.viridis() plt.colorbar() plt.show() kernel = np.ones((31, 31), np.uint8) erosion = cv2.erode(H, kernel, iterations=1) plt.imshow(erosion) plt.viridis() plt.colorbar() plt.show() dilation = cv2.dilate(erosion, kernel, iterations=1) plt.imshow(dilation) plt.viridis() plt.colorbar() plt.show() W = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]]) Gx = cv2.filter2D(dilation, -1, W, cv2.BORDER_REPLICATE) Gy = cv2.filter2D(dilation, -1, W.T, cv2.BORDER_REPLICATE) G = np.abs(Gx) + np.abs(Gy) G = G.astype('uint8') plt.imshow(G) plt.show() # Standard Hough Line Transform lines = cv2.HoughLines(G, 1, np.pi / 180, 300) new_lines = [list(lines[0][0])] for [[rho, theta]] in lines: insert = True for [new_rho, _] in new_lines: if abs(new_rho - rho) < 10: insert = False break if insert: new_lines.append([rho, theta]) def intersection_pts(l1, l2): [rho1, theta1] = l1 [rho2, theta2] = l2 A = np.array([[math.cos(theta1), math.sin(theta1)], [math.cos(theta2), math.sin(theta2)]]) b = np.array([rho1, rho2]).T X = np.linalg.solve(A, b) return X points = [] # Show results plt.imshow(A) for i in range(4): x = intersection_pts(new_lines[i], new_lines[(i + 1) % 4]) points.append(list(x)) plt.plot(x[0], x[1], color='red', marker='o', markersize=12) plt.show() points = np.array(points, dtype=np.int32) mask = np.zeros(A.shape[:2], dtype=np.uint8) cv2.fillPoly(mask, pts=[points], color=255) plt.imshow(mask) plt.show() cv2.imwrite('src/WSC_mask.png', mask) return np.hstack((points, np.ones((4, 1), dtype=np.int32)))
grid[i], set_MSE = evaluateScenes(sceneSet, weight[i], sceneSetLoss); return weight, grid; def saveBadScene(scene, weight): gt, formula = loadScene(scene); Dd = denoise_tv_chambolle(formula, weight, multichannel=False) vmin, vmax = np.min(gt), np.max(gt); plt.figure(figsize=(14,3)); plt.subplot(131); plt.imshow(formula, interpolation='nearest', vmin=vmin, vmax=vmax); plt.title("Baseline"); plt.colorbar(); plt.axis('off'); plt.subplot(132); plt.imshow(Dd, interpolation='nearest', vmin=vmin, vmax=vmax); plt.title("Total Variation"); plt.colorbar(); plt.axis('off'); plt.subplot(133); plt.imshow(gt, interpolation='nearest', vmin=vmin, vmax=vmax); plt.title("Ground Truth %s"%scene); plt.axis('off'); plt.colorbar(); plt.savefig('%s_TV_bad.png'%scene, bbox_inches='tight') plt.viridis(); allScenes = getAllScenes(); valScenes = getScenes("Validation") testScenes = getScenes("Test") #valLoss = storeLoss(valScenes) #testLoss = storeLoss(testScenes) #weights, grid = totVarApplication(0.1, 0.2, 0.05, valScenes, valLoss); saveScene("bathroom_29", 0.15) #saveBadScene("bathroom_29", 2.4) #plt.plot(weights, grid, label="Total Variation"); plt.xlabel("TV weight"); plt.ylabel("TV loss"); plt.show(); #losses = storeLoss(allScenes) # Previous result
filename = "laser_tracks.npy" tracks = np.load(filename) residuals = np.array([[0], [0], [0]]) for track in tracks: res = calc_residual(track) residuals = np.append(residuals, res, axis=1) residuals = np.delete(residuals, 0, 1) z = residuals[0] x = residuals[1] res = residuals[2] grid_z, grid_x = np.mgrid[0:1057:8, 0:257:8] grid_z2 = griddata((z, x), res, (grid_z, grid_x), method='nearest') #print grid_z2.T print np.max(grid_z2) v = np.linspace(0, 40, 9) CS = plt.contourf(grid_z, grid_x, grid_z2, v, cmap=plt.viridis()) plt.colorbar(CS, label="Distrortion [cm]") plt.scatter(z, x, alpha=.01, s=2) plt.xlim([0, 1036]) plt.ylim([0, 250]) plt.xlabel("z [cm]") plt.ylabel("x (drift) [cm]") plt.show()
from matplotlib.ticker import LinearLocator, FormatStrFormatter import scipy import scipy.stats as stats from glob import glob from pprint import pprint as pp from synaptogenesis.function_definitions import * from analysis_functions_definitions import * from argparser import * from mpl_toolkits.axes_grid1 import make_axes_locatable import matplotlib as mlib import warnings warnings.filterwarnings("ignore", category=UserWarning) # ensure we use viridis as the default cmap plt.viridis() # ensure we use the same rc parameters for all matplotlib outputs mlib.rcParams.update({'font.size': 24}) mlib.rcParams.update({'errorbar.capsize': 5}) mlib.rcParams.update({'figure.autolayout': True}) root_stats = args.root_stats root_syn = args.root_syn fig_folder = args.fig_folder # check if the figures folder exist if not os.path.isdir(fig_folder) and not os.path.exists(fig_folder): os.mkdir(fig_folder) paths = [] for file in args.path:
import matplotlib.pyplot as plt fig = plt.figure() ax2 = fig.add_subplot(111, projection='3d') x1 = df.ix[0:, 'x1'] x2 = df.ix[0:, 'x2'] x3 = df.ix[0:, 'x3'] y = df.ix[0:, 'y'] if sys.argv[1:] == ['winter']: p = ax2.scatter(x1, x2, x3, c=y, cmap=plt.winter()) elif sys.argv[1:] == ['cool']: p = ax2.scatter(x1, x2, x3, c=y, cmap=plt.cool()) elif sys.argv[1:] == ['viridis']: p = ax2.scatter(x1, x2, x3, c=y, cmap=plt.viridis()) elif sys.argv[1:] == ['plasma']: p = ax2.scatter(x1, x2, x3, c=y, cmap=plt.plasma()) elif sys.argv[1:] == ['inferno']: p = ax2.scatter(x1, x2, x3, c=y, cmap=plt.inferno()) elif sys.argv[1:] == ['jet']: p = ax2.scatter(x1, x2, x3, c=y, cmap=plt.jet()) elif sys.argv[1:] == ['gist_ncar']: p = ax2.scatter(x1, x2, x3, c=y, cmap=plt.gist_ncar()) elif sys.argv[1:] == ['rainbow']: p = ax2.scatter(x1, x2, x3, c=y, cmap=plt.nipy_spectral()) else: p = ax2.scatter(x1, x2, x3, c=y, cmap=plt.nipy_spectral()) fig.colorbar(p)